Skip to content

AI media harness for planning, generating, and editing locally

TypeScript
99.8 KB
Raw Blame
use super::{
    config::*, events::stage_name, ffi::RequestHandle, h3::*, planning::*, platform::*,
    references::ReferenceVideos, *,
};
use crate::settings::{ProviderOption, ProviderSetting};
use std::collections::BTreeMap;

#[test]
fn music_plans_on_cuda_and_vulkan_without_video_controls() {
    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(super::DLL_FILE_NAME);
    let api = ffi::Api::load(&path).unwrap();
    for family in ["yue2", "minimax_music3"] {
        let mut configuration = Configuration::from_settings(&BTreeMap::new());
        configuration.model_type = family.into();
        let mut request = GenerationRequest { prompt: "Quiet piano".into(), steps: 2, seed: 42,
            music: Some(music::MusicSettings { duration: 2.0, ..Default::default() }), ..Default::default() };
        for backend in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
            let handle = RequestHandle::new(&api).unwrap();
            configure_request(&api, &handle, &request, &configuration, backend, RequestPurpose::Plan, &ReferenceVideos::default()).unwrap();
            let plan = api.resolve(&handle).unwrap();
            assert!(plan.duration_seconds >= 2.0);
            assert_eq!(plan.canvas_width, 0);
            assert_eq!(plan.canvas_height, 0);
        }
        request.reference_paths.push("reference.wav".into());
        assert!(configuration.validate_inputs(&request).unwrap_err().contains("references"));
        request.reference_paths.clear();
        request.music.as_mut().unwrap().duration = f64::NAN;
        assert!(configuration.validate_inputs(&request).is_err());
    }
}

#[test]
fn yue_fast_flow_sampler_reaches_native_planning_and_generation() {
    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(super::DLL_FILE_NAME);
    let api = ffi::Api::load(&path).unwrap();
    let mut config = Configuration::from_settings(&BTreeMap::new());
    config.model_type = "yue2".into();
    for backend in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            for (sampler, resolved, steps, evaluations) in [("default", "dpmpp_2m", 6, 6), ("dpmpp_2m", "dpmpp_2m", 6, 6), ("midpoint", "midpoint", 32, 64)] {
                let request = GenerationRequest { prompt: "Quiet piano".into(), steps, seed: 42,
                    music: Some(music::MusicSettings { duration: 2.0, flow_sampler: sampler.into(), ..Default::default() }), ..Default::default() };
                let handle = RequestHandle::new(&api).unwrap();
                configure_request(&api, &handle, &request, &config, backend, purpose, &ReferenceVideos::default()).unwrap();
                let description = api.describe(&handle).unwrap();
                assert!(description.contains(&format!("{steps} ({resolved})")), "{description}");
                assert_eq!(api.resolve(&handle).unwrap().num_model_evaluations, evaluations);
            }
        }
    }
    config.model_type = "minimax_music3".into();
    let request = GenerationRequest { prompt: "Quiet piano".into(), steps: 30, seed: 42,
        music: Some(music::MusicSettings { flow_sampler: "dpmpp_2m".into(), ..Default::default() }), ..Default::default() };
    assert!(config.validate_inputs(&request).unwrap_err().contains("MiniMax Music3"));
    assert!(serde_json::from_value::<music::MusicSettings>(serde_json::json!({"flow_sampler":"dpm_2"})).unwrap().validate().is_err());
}

#[test]
fn sampler_and_scheduler_options_reach_planning_and_generation_and_reset() {
    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(super::DLL_FILE_NAME);
    let api = ffi::Api::load(&path).unwrap();
    for family in ["minimax-h3", "moss", "fibo2", "krea2"] {
        let mut configuration = Configuration::from_settings(&BTreeMap::new());
        configuration.model_type = family.into();
        configuration.attention = "flash2";
        let request = GenerationRequest { prompt: "An apple".into(), still_image: family != "minimax-h3",
            frames: if family == "minimax-h3" { 22 } else { 1 }, steps: 8, seed: 42,
            canvas_width: 512, canvas_height: 512, video_sigma_shift: if family == "fibo2" { None } else { Some(4.0) }, ..Default::default() };
        for sampler in &crate::models::generator_features(family).samplers {
            for scheduler in [None, Some("beta")] {
                for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
                    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
                        if platform == ComputePlatform::Vulkan && crate::models::generator_features(family).cuda_only { continue; }
                        configuration.sampling = Ok(SamplingChoices { sampler: Some(sampler.clone()), scheduler: scheduler.map(str::to_owned) });
                        let handle = RequestHandle::new(&api).unwrap();
                        if platform == ComputePlatform::Vulkan && sampler == "ab2" {
                            assert!(configure_request(&api, &handle, &request, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap_err().contains("AB2 sampling requires CUDA"));
                            continue;
                        }
                        configure_request(&api, &handle, &request, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap();
                        let description = api.describe(&handle).unwrap();
                        assert!(description.contains(if sampler == "euler" && family != "minimax-h3" { "Euler" } else { sampler }), "{description}");
                        if family != "minimax-h3" { assert!(description.contains(if scheduler.is_some() { "schedule    beta" } else { "schedule    default" }), "{description}"); }
                        configuration.sampling = Ok(Default::default());
                        configure_request(&api, &handle, &request, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap();
                        let reset = api.describe(&handle).unwrap();
                        assert!(!reset.contains("er_sde"));
                        assert!(!reset.contains("schedule    beta"));
                        if family == "minimax-h3" && scheduler.is_some() {
                            assert_ne!(description.lines().find(|line| line.contains("sigma range")), reset.lines().find(|line| line.contains("sigma range")));
                        }
                    }
                }
            }
        }
    }
}

#[test]
fn unsupported_sampling_choices_are_rejected_before_generation() {
    for (family, sampler, scheduler) in [("moss", "ab2", "default"), ("fibo2", "renoise", "default"),
        ("krea2", "euler", "unknown"), ("yue2", "er_sde", "default"), ("minimax_music3", "default", "beta")] {
        let settings = BTreeMap::from([("slopfab".into(), ProviderSetting { enabled: true, model: None,
            options: BTreeMap::from([("modelType".into(), ProviderOption::String(family.into())),
                ("sampler".into(), ProviderOption::String(sampler.into())), ("scheduler".into(), ProviderOption::String(scheduler.into()))]) })]);
        let configuration = Configuration::from_settings(&settings);
        assert!(configuration.validate_inputs(&GenerationRequest::default()).unwrap_err().contains("does not support"));
    }
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.animate = true;
    configuration.sampling = Ok(SamplingChoices { sampler: Some("er_sde".into()), scheduler: None });
    assert!(configuration.validate_inputs(&GenerationRequest::default()).unwrap_err().contains("Animate requires Euler"));
    configuration.animate = false;
    configuration.sampling_preset = Ok(Some(SamplingPreset::Pika6Step));
    assert!(configuration.validate_inputs(&GenerationRequest::default()).unwrap_err().contains("LoRA recipe"));
}

#[test]
fn krea_plans_turbo_and_raw_on_cuda_and_vulkan() {
    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(super::DLL_FILE_NAME);
    let api = ffi::Api::load(&path).unwrap();
    for raw in [false, true] {
        let mut configuration = Configuration::from_settings(&BTreeMap::new());
        configuration.model_type = "krea2".into();
        configuration.krea_raw = raw;
        configuration.attention = "flash2";
        let mut request = GenerationRequest { still_image: true, frames: 1, steps: if raw { 52 } else { 8 },
            prompt: "A red apple".into(), negative_prompt: Some("watermark".into()),
            canvas_width: 1024, canvas_height: 1024, ..Default::default() };
        for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
            for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
                let handle = RequestHandle::new(&api).unwrap();
                configure_request(&api, &handle, &request, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap();
                let plan = api.resolve(&handle).unwrap();
                assert_eq!((plan.canvas_width, plan.canvas_height, plan.aligned_frames), (1024, 1024, 1));
                let description = api.describe(&handle).unwrap();
                assert!(description.contains("Krea 2"));
                assert!(description.contains(if raw { "52 Euler updates (shift 2.48)" } else { "8 Euler updates (shift 3.16)" }), "{description}");
                assert!(description.contains(if raw { "guidance    3.5" } else { "guidance    0" }), "{description}");
            }
        }
        request.video_sigma_shift = Some(4.0);
        request.guidance_scale = Some(2.5);
        let handle = RequestHandle::new(&api).unwrap();
        configure_request(&api, &handle, &request, &configuration, ComputePlatform::Vulkan, RequestPurpose::Plan, &ReferenceVideos::default()).unwrap();
        assert!(api.describe(&handle).unwrap().contains("shift 4"));
        request.guidance_scale = None;
        request.negative_prompt = None;
        request.still_image = false;
        assert!(configuration.validate_inputs(&request).unwrap_err().contains("video generation"));
        request.still_image = true;
        request.image_edit = Some(serde_json::from_value(serde_json::json!({"sourceRelativePath":"media/apple.png", "edits":[]})).unwrap());
        assert!(configuration.validate_inputs(&request).unwrap_err().contains("image editing"));
        request.image_edit = None;
        request.reference_paths.push("apple.png".into());
        assert!(configuration.validate_inputs(&request).unwrap_err().contains("image references"));
        request.reference_paths.clear();
        request.audio_steps = Some(4);
        assert!(configuration.validate_inputs(&request).unwrap_err().contains("without audio"));
    }
}

#[test]
fn moss_capabilities_reject_video_edits_and_references() {
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.model_type = "moss".into();
    let mut request = GenerationRequest { still_image: true, frames: 1, steps: 50, prompt: "A red apple".into(), canvas_width: 512, canvas_height: 512, ..Default::default() };
    configuration.validate_inputs(&request).unwrap();
    request.generation_effects = Some(serde_json::from_value(serde_json::json!({"sharpness":{"strength":1}})).unwrap());
    assert!(configuration.validate_inputs(&request).unwrap_err().contains("generation effects"));
    request.generation_effects.as_mut().unwrap().sharpness.as_mut().unwrap().enabled = Some(false);
    configuration.validate_inputs(&request).unwrap();
    request.generation_effects = None;
    request.still_image = false;
    assert!(configuration.validate_inputs(&request).unwrap_err().contains("video generation"));
    request.still_image = true;
    request.image_edit = Some(serde_json::from_value(serde_json::json!({"sourceRelativePath":"media/apple.png", "edits":[]})).unwrap());
    assert!(configuration.validate_inputs(&request).unwrap_err().contains("image editing"));
    request.image_edit = None;
    request.reference_paths.push("apple.png".into());
    assert!(configuration.validate_inputs(&request).unwrap_err().contains("image references"));
}

#[test]
fn moss_status_requires_tokenizer_but_no_audio_vae() {
    let folder = tempfile::tempdir().unwrap();
    let weights = folder.path().join("weights");
    std::fs::write(&weights, b"status only").unwrap();
    let dll = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(super::DLL_FILE_NAME);
    let mut settings = BTreeMap::from([("slopfab".into(), ProviderSetting {
        enabled: true, model: None, options: BTreeMap::from([
            ("modelType".into(), ProviderOption::String("moss".into())),
            ("dllPath".into(), ProviderOption::String(dll.to_string_lossy().into_owned())),
        ]),
    })]);
    for id in ["transformer", "textEncoder", "videoVae"] {
        settings.get_mut("slopfab").unwrap().options.insert(id.into(), ProviderOption::String(weights.to_string_lossy().into_owned()));
    }
    let missing = status(&settings);
    assert_eq!(missing.state, "modelsMissing");
    assert!(!missing.models.iter().any(|model| model.id == "audioVae"));
    settings.get_mut("slopfab").unwrap().options.insert("tokenizer".into(), ProviderOption::String(weights.to_string_lossy().into_owned()));
    assert_eq!(status(&settings).state, "ready");
}

#[test]
fn moss_planning_uses_image_family_and_shared_request_pipeline() {
    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(super::DLL_FILE_NAME);
    let api = ffi::Api::load(&path).unwrap();
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.model_type = "moss".into();
    configuration.attention = "flash2";
    let request = GenerationRequest { still_image: true, frames: 1, steps: 50, prompt: "A red apple".into(), canvas_width: 512, canvas_height: 512, ..Default::default() };
    let handle = RequestHandle::new(&api).unwrap();
    configure_request(&api, &handle, &request, &configuration, ComputePlatform::Cuda13, RequestPurpose::Plan, &ReferenceVideos::default()).unwrap();
    let plan = api.resolve(&handle).unwrap();
    assert_eq!((plan.canvas_width, plan.canvas_height, plan.aligned_frames), (512, 512, 1));
    assert!(api.describe(&handle).unwrap().contains("MOSS"));
    assert!(configure_request(&api, &handle, &request, &configuration, ComputePlatform::Vulkan, RequestPurpose::Plan, &ReferenceVideos::default()).unwrap_err().contains("requires CUDA"));
}

#[test]
fn audio_steps_override_and_reset_reach_planning_and_execution() {
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.motion_cache = true;
    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(super::DLL_FILE_NAME);
    let api = ffi::Api::load(&path).unwrap();
    for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
        let handle = RequestHandle::new(&api).unwrap();
        let mut request = GenerationRequest { prompt: "Ocean waves".into(), frames: 48, steps: 4,
            audio_steps: Some(7), seed: 1, canvas_width: 64, canvas_height: 32, ..Default::default() };
        configure_request(&api, &handle, &request, &configuration, ComputePlatform::Cuda13, purpose, &ReferenceVideos::default()).unwrap();
        assert!(api.resolve(&handle).unwrap().num_model_evaluations >= 6);
        request.audio_steps = None;
        configure_request(&api, &handle, &request, &configuration, ComputePlatform::Cuda13, purpose, &ReferenceVideos::default()).unwrap();
        assert_eq!(api.resolve(&handle).unwrap().num_model_evaluations, 3);
        for steps in [0, 1, 1_000_001] {
            request.audio_steps = Some(steps);
            assert!(validate_generation_controls(&request).is_err());
        }
    }
}

#[test]
fn dmad_recipe_reaches_preview_and_execution_on_both_backends() {
    let root = tempfile::tempdir().unwrap();
    let adapter = root.path().join("renamed-adapter.safetensors");
    metadata_checkpoint(&adapter, serde_json::json!({}));
    let settings = BTreeMap::from([("slopfab".into(), ProviderSetting {
        enabled: true, model: None,
        options: BTreeMap::from([
            ("samplingPreset".into(), ProviderOption::String("dmad-4step".into())),
            ("motionCache".into(), ProviderOption::Boolean(true)),
            ("stepOverride".into(), ProviderOption::Number(12.0)),
            ("loras".into(), ProviderOption::String(serde_json::json!([
                { "path": adapter, "strength": 1.0 }
            ]).to_string())),
        ]),
    })]);
    let configuration = Configuration::from_settings(&settings);
    assert_eq!(configuration.generation_steps(30).unwrap(), 4);
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let request = GenerationRequest {
        prompt: "A polar bear plays the violin in the snow.".into(),
        frames: 124, steps: 30, seed: 42, canvas_width: 1344, canvas_height: 768,
        video_sigma_shift: Some(7.0), audio_sigma_shift: Some(4.0),
        ..Default::default()
    };
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            let handle = RequestHandle::new(&api).unwrap();
            configure_request(&api, &handle, &request, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap();
            let plan = api.resolve(&handle).unwrap();
            assert_eq!(plan.num_model_evaluations, 4);
            let description = api.describe(&handle).unwrap();
            assert!(description.contains("renoise"), "{description}");
            assert!(description.contains("shift 12"), "{description}");
            assert!(description.contains("shift 2"), "{description}");
        }
    }
    let ordinary = Configuration::from_settings(&BTreeMap::new());
    assert_ne!(configuration.timing_profile("1.16.0", ComputePlatform::Vulkan), ordinary.timing_profile("1.16.0", ComputePlatform::Vulkan));
}

#[test]
fn pika_recipe_reaches_preview_and_execution_on_both_backends() {
    let root = tempfile::tempdir().unwrap();
    let adapter = root.path().join("renamed-adapter.safetensors");
    metadata_checkpoint(&adapter, serde_json::json!({}));
    let settings = BTreeMap::from([("slopfab".into(), ProviderSetting {
        enabled: true, model: None,
        options: BTreeMap::from([
            ("samplingPreset".into(), ProviderOption::String("pika-6step".into())),
            ("motionCache".into(), ProviderOption::Boolean(true)),
            ("stepOverride".into(), ProviderOption::Number(12.0)),
            ("loras".into(), ProviderOption::String(serde_json::json!([
                { "path": adapter, "strength": 1.0 }
            ]).to_string())),
        ]),
    })]);
    let configuration = Configuration::from_settings(&settings);
    assert_eq!(configuration.generation_steps(30).unwrap(), 6);
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let request = GenerationRequest {
        prompt: "A polar bear plays the violin in the snow.".into(),
        frames: 124, steps: 30, seed: 42, canvas_width: 1344, canvas_height: 768,
        video_sigma_shift: Some(7.0), audio_sigma_shift: Some(4.0),
        ..Default::default()
    };
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            let handle = RequestHandle::new(&api).unwrap();
            configure_request(&api, &handle, &request, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap();
            let plan = api.resolve(&handle).unwrap();
            assert_eq!(plan.num_model_evaluations, 6);
            let description = api.describe(&handle).unwrap();
            assert!(description.contains("renoise"), "{description}");
            assert!(description.contains("shift 12"), "{description}");
            assert!(description.contains("shift 3"), "{description}");
        }
    }
    let ordinary = Configuration::from_settings(&BTreeMap::new());
    assert_ne!(configuration.timing_profile("1.16.0", ComputePlatform::Vulkan), ordinary.timing_profile("1.16.0", ComputePlatform::Vulkan));
}

#[test]
fn image_edit_recipe_disables_motion_cache_and_keeps_source_geometry() {
    let references = ReferenceVideos::default();
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.motion_cache = true;
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let request = GenerationRequest {
        prompt: "A red vase".into(), still_image: true, frames: 1, steps: 4, seed: 1,
        canvas_width: 65, canvas_height: 41,
        image_edit_pixels: Some(std::sync::Arc::new(vec![100; 65 * 41 * 3])),
        image_edit: Some(types::ImageEditRequest { source_relative_path: "media/source.png".into(), region_size: None, edits: vec![
            types::ImageEditStep { mask_contours: None, mask_polygon: None, prompt: "A red vase".into(), x: 30, y: 10, width: 35, height: 31, feather: None, strength: None, invert_mask: false, outpaint_blend_overlap: None, outpaint_langevin_steps: None, reference_paths: None, refmods: None }
        ] }), ..Default::default()
    };
    validate_generation_controls(&request).unwrap();
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            let handle = RequestHandle::new(&api).unwrap();
            configure_request(&api, &handle, &request, &configuration, platform, purpose, &references).unwrap();
            // Resolving fails if MotionCache is still enabled for inpainting.
            let plan = api.resolve(&handle).unwrap();
            assert_eq!((plan.canvas_width, plan.canvas_height, plan.aligned_frames), (96, 64, 1));
            let description = api.describe(&handle).unwrap();
            assert!(description.contains("feather 16;"), "{description}");
        }
    }
    let mut invalid = request;
    for feather in [None, Some(0), Some(16)] {
        invalid.image_edit.as_mut().unwrap().edits[0].feather = feather;
        // Explicit zero must survive transfer to a LAN worker; old requests
        // without a feather value keep the ordinary editing default.
        let roundtrip: GenerationRequest = serde_json::from_value(serde_json::to_value(&invalid).unwrap()).unwrap();
        assert_eq!(roundtrip.image_edit.as_ref().unwrap().edits[0].feather, feather);
        validate_generation_controls(&roundtrip).unwrap();
    }
    for feather in [-1, 8193] {
        invalid.image_edit.as_mut().unwrap().edits[0].feather = Some(feather);
        assert!(validate_generation_controls(&invalid).is_err());
    }
    invalid.image_edit.as_mut().unwrap().edits[0].feather = None;
    invalid.image_edit.as_mut().unwrap().edits[0].width = 36;
    assert!(validate_generation_controls(&invalid).is_err());
}

#[test]
fn whole_image_edits_never_feather_at_the_native_boundary() {
    let configuration = Configuration::from_settings(&BTreeMap::new());
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let folder = tempfile::tempdir().unwrap();
    for (width, height) in [(96, 64), (65, 41)] {
        let source = folder.path().join("source.png");
        image::RgbImage::from_pixel(width as u32, height as u32, image::Rgb([100, 120, 140]))
            .save(&source).unwrap();
        for feather in [None, Some(0), Some(1), Some(16)] {
            let request: GenerationRequest = serde_json::from_value(serde_json::json!({
                "jobId":"whole-image", "prompt":"Change the entire image", "stillImage":true, "frames":1,
                "steps":4, "seed":1, "canvasWidth":width, "canvasHeight":height,
                "imageEdit":{"sourceRelativePath":"source.png", "edits":[{
                    "prompt":"Change the entire image", "x":0, "y":0,
                    "width":width, "height":height, "feather":feather
                }]}
            })).unwrap();
            // Exercise the serialized request used by LAN workers as well.
            let mut request: GenerationRequest = serde_json::from_value(serde_json::to_value(request).unwrap()).unwrap();
            request.image_edit_path = Some(source.clone());
            for from_pixels in [false, true] {
                request.image_edit_pixels = from_pixels.then(|| std::sync::Arc::new(vec![100; (width * height * 3) as usize]));
                for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
                    for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
                        let handle = RequestHandle::new(&api).unwrap();
                        configure_request(&api, &handle, &request, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap();
                        api.resolve(&handle).unwrap();
                        let description = api.describe(&handle).unwrap();
                        assert!(description.contains("feather 0;"), "{description}");
                    }
                }
            }
        }
    }
}

#[test]
fn crop_regeneration_strength_survives_worker_transfer_and_reaches_native_sampling() {
    let configuration = Configuration::from_settings(&BTreeMap::new());
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let request: GenerationRequest = serde_json::from_value(serde_json::json!({
        "jobId":"crop", "prompt":"Refine the crop", "stillImage":true, "frames":1,
        "steps":20, "seed":0, "canvasWidth":128, "canvasHeight":64,
        "imageEdit":{"sourceRelativePath":"canvas.png", "edits":[{
            "prompt":"Refine the crop", "x":0, "y":0, "width":128, "height":64,
            "feather":0, "strength":0.65
        }]}
    })).unwrap();
    let mut roundtrip: GenerationRequest = serde_json::from_value(serde_json::to_value(&request).unwrap()).unwrap();
    assert_eq!(roundtrip.image_edit.as_ref().unwrap().edits[0].strength, Some(0.65));
    roundtrip.image_edit_pixels = Some(std::sync::Arc::new(vec![127; 128 * 64 * 3]));
    validate_generation_controls(&roundtrip).unwrap();
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        let plan = |request: &GenerationRequest| {
            let handle = RequestHandle::new(&api).unwrap();
            configure_request(&api, &handle, request, &configuration, platform, RequestPurpose::Plan, &ReferenceVideos::default()).unwrap();
            api.resolve(&handle).unwrap()
        };
        let crop = plan(&roundtrip);
        assert_eq!((crop.canvas_width, crop.canvas_height, crop.aligned_frames), (128, 64, 1));
        let mut full = roundtrip.clone();
        full.image_edit.as_mut().unwrap().edits[0].strength = None;
        assert!(crop.num_model_evaluations > 0 && crop.num_model_evaluations < plan(&full).num_model_evaluations);
    }
    for strength in [0.0, -0.1, 1.1, f32::NAN, f32::INFINITY] {
        roundtrip.image_edit.as_mut().unwrap().edits[0].strength = Some(strength);
        assert!(validate_generation_controls(&roundtrip).is_err());
    }
}

#[test]
fn outpainting_preserves_one_box_in_preview_execution_and_worker_requests() {
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.motion_cache = true;
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let request: GenerationRequest = serde_json::from_value(serde_json::json!({
        "jobId":"outpaint", "prompt":"Continue the scene", "stillImage":true, "frames":1,
        "steps":4, "seed":0, "canvasWidth":128, "canvasHeight":64,
        "imageEdit":{"sourceRelativePath":"canvas.png", "edits":[{
            "prompt":"Continue the scene", "x":38, "y":13, "width":51, "height":38,
            "feather":0, "invertMask":true, "outpaintBlendOverlap":9, "outpaintLangevinSteps":5
        }]}
    })).unwrap();
    // This is the same serialization boundary used by LAN workers.
    let mut roundtrip: GenerationRequest = serde_json::from_value(serde_json::to_value(&request).unwrap()).unwrap();
    let edit = &roundtrip.image_edit.as_ref().unwrap().edits[0];
    assert!(edit.invert_mask);
    assert_eq!(edit.outpaint_blend_overlap, Some(9));
    assert_eq!(edit.outpaint_langevin_steps, Some(5));
    validate_generation_controls(&roundtrip).unwrap();
    roundtrip.image_edit_pixels = Some(std::sync::Arc::new(vec![127; 128 * 64 * 3]));
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            let handle = RequestHandle::new(&api).unwrap();
            configure_request(&api, &handle, &roundtrip, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap();
            let plan = api.resolve(&handle).unwrap();
            assert_eq!((plan.canvas_width, plan.canvas_height, plan.aligned_frames), (128, 64, 1));
            assert_eq!(plan.num_model_evaluations, 3);
            let description = api.describe(&handle).unwrap();
            assert!(description.contains("outpaint (preserve box)"));
            assert!(description.contains("blend overlap 9; Langevin steps 5"));
            api.set_outpaint_blend_overlap(&handle, 1).unwrap();
            api.set_outpaint_langevin_steps(&handle, 0).unwrap();
            assert!(api.describe(&handle).unwrap().contains("blend overlap 1; Langevin steps 0"));
        }
    }
    for change in [
        serde_json::json!({"feather":16}), serde_json::json!({"feather":null}),
        serde_json::json!({"x":0,"y":0,"width":128,"height":64}),
        serde_json::json!({"width":1}), serde_json::json!({"height":1}),
        serde_json::json!({"outpaintBlendOverlap":0}), serde_json::json!({"outpaintBlendOverlap":8}),
        serde_json::json!({"outpaintBlendOverlap":53}), serde_json::json!({"outpaintLangevinSteps":-1}),
        serde_json::json!({"outpaintLangevinSteps":101}), serde_json::json!({"invertMask":false}),
    ] {
        let mut value = serde_json::to_value(&request).unwrap();
        value["imageEdit"]["edits"][0].as_object_mut().unwrap().extend(change.as_object().unwrap().clone());
        assert!(validate_generation_controls(&serde_json::from_value(value).unwrap()).is_err());
    }
    // The restored template supplies a source interior with complete 32px
    // patches. Both backend plans must include its positioned keyframe rows.
    let mut positioned = roundtrip.clone();
    positioned.canvas_width = 416;
    positioned.canvas_height = 416;
    positioned.image_edit_pixels = Some(std::sync::Arc::new(vec![127; 416 * 416 * 3]));
    let step = &mut positioned.image_edit.as_mut().unwrap().edits[0];
    step.x = 69; step.y = 69; step.width = 277; step.height = 277;
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        let handle = RequestHandle::new(&api).unwrap();
        configure_request(&api, &handle, &positioned, &configuration, platform, RequestPurpose::Plan, &ReferenceVideos::default()).unwrap();
        let plan = api.resolve(&handle).unwrap();
        assert_eq!(plan.sequence_rows_without_text, 13 * 13 + 7 * 7);
    }
    let mut invalid = request.clone();
    let edits = &mut invalid.image_edit.as_mut().unwrap().edits;
    edits.push(edits[0].clone());
    assert!(validate_generation_controls(&invalid).is_err());
}

#[test]
fn video_transitions_use_encoded_boundaries_with_the_bundled_runtime() {
    let references = ReferenceVideos::default();
    let settings = BTreeMap::new();
    let configuration = Configuration::from_settings(&settings);
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let start = references.create_reference_video(3.0, &settings).unwrap();
    let end = references.create_reference_video(2.0, &settings).unwrap();
    for id in [&start, &end] {
        references
            .append_reference_video(id, &vec![127; 64 * 32 * 4], 64, 32, 0.0)
            .unwrap();
    }
    for mode in ["extend", "bridge"] {
        let mut request = GenerationRequest {
            prompt: "The dancer turns and walks toward the door.".into(),
            video_transition: Some(mode.into()),
            frames: 39,
            steps: 4,
            seed: 1,
            canvas_width: 64,
            canvas_height: 32,
            reference_video_ids: if mode == "extend" {
                vec![start.clone()]
            } else {
                vec![start.clone(), end.clone()]
            },
            ..Default::default()
        };
        for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
            for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
                let handle = RequestHandle::new(&api).unwrap();
                configure_request(
                    &api,
                    &handle,
                    &request,
                    &configuration,
                    platform,
                    purpose,
                    &references,
                )
                .unwrap();
                let plan = api.resolve(&handle).unwrap();
                assert_eq!(
                    scene_frame_window(&request, plan.aligned_frames).unwrap(),
                    (0, 39)
                );
                assert!(api
                    .describe(&handle)
                    .unwrap()
                    .contains(&format!("video transition    {mode}")));
            }
        }
        request.reference_paths.push("stale-first-frame.png".into());
        assert!(configuration.validate_inputs(&request).is_err());
    }
    references.release_reference_videos(&[start, end]).unwrap();
}

// Minimal table-model header: planning reads descriptors but never executes
// these fixture tensors. Active LoRAs also need a valid SafeTensors header.
fn metadata_checkpoint(path: &std::path::Path, metadata: serde_json::Value) {
    let header = serde_json::json!({
        "__metadata__": metadata,
        "adaln_t_table": { "dtype": "F32", "shape": [1], "data_offsets": [0, 4] },
        "blocks.0.adaln_proj.linear.weight": { "dtype": "F32", "shape": [1], "data_offsets": [4, 8] }
    }).to_string();
    let mut bytes = (header.len() as u64).to_le_bytes().to_vec();
    bytes.extend_from_slice(header.as_bytes());
    bytes.extend_from_slice(&[0; 8]);
    std::fs::write(path, bytes).unwrap();
}

#[test]
fn keystone_lock_uses_checkpoint_video_updates_instead_of_requested_or_joint_steps() {
    let root = tempfile::tempdir().unwrap();
    let transformer = root.path().join("short-grid.safetensors");
    metadata_checkpoint(&transformer, serde_json::json!({
        "slopfab.sampling": r#"{"version":1,"base_sigmas":[1,0.5,0]}"#
    }));
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.models[0].2 = Some(transformer);
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let source = continuation::tests::archive(124).into_temp_path();
    let context = continuation::tests::archive(56).into_temp_path();
    let request = GenerationRequest { prompt: "A quiet harbour.".into(), frames: 48, steps: 20,
        audio_steps: Some(17), canvas_width: 64, canvas_height: 32,
        single_shot: Some(types::SingleShotRequest { ending_prompt: String::new(), ending_path: None }),
        continuation_path: Some(source.to_path_buf()), continuation_overlap_frames: Some(22),
        continuation_lock_overlap: true, keystone_path: Some(context.to_path_buf()), ..Default::default() };
    for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
        let handle = RequestHandle::new(&api).unwrap();
        configure_request(&api, &handle, &request, &configuration, ComputePlatform::Cuda13, purpose, &ReferenceVideos::default()).unwrap();
        assert!(api.resolve(&handle).unwrap().num_model_evaluations > 4);
        assert!(api.describe(&handle).unwrap().contains("capstone locks after 1 video updates"));
    }
}

#[test]
fn model_metadata_is_shared_by_preview_and_execution_requests() {
    let root = tempfile::tempdir().unwrap();
    let transformer = root.path().join("model.safetensors");
    metadata_checkpoint(
        &transformer,
        serde_json::json!({
            "slopfab.sampling": r#"{"version":1,"video_sigma_shift":6,"base_sigmas":[1,0.5,0]}"#
        }),
    );
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.models[0].2 = Some(transformer);
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let request = GenerationRequest {
        prompt: "A quiet harbour.".into(),
        frames: 48,
        steps: 20,
        canvas_width: 736,
        canvas_height: 416,
        ..Default::default()
    };
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            let handle = RequestHandle::new(&api).unwrap();
            configure_request(
                &api,
                &handle,
                &request,
                &configuration,
                platform,
                purpose,
                &ReferenceVideos::default(),
            )
            .unwrap();
            // The model's fixed grid overrides the UI's explicit 20 steps.
            assert_eq!(api.resolve(&handle).unwrap().num_model_evaluations, 2);
            assert!(api.describe(&handle).unwrap().contains("shift 6"));
            api.set_motion_cache(&handle, true).unwrap();
            assert!(
                api.resolve(&handle).is_err(),
                "fixed grids must reject MotionCache during preview too"
            );
        }
    }
}

#[test]
fn preview_enforces_model_conditioning_and_reports_invalid_metadata() {
    let root = tempfile::tempdir().unwrap();
    let transformer = root.path().join("model.safetensors");
    let settings = BTreeMap::from([(
        "slopfab".into(),
        ProviderSetting {
            enabled: true,
            model: None,
            options: BTreeMap::from([
                (
                    "transformer".into(),
                    ProviderOption::String(transformer.to_string_lossy().into_owned()),
                ),
                (
                    "inferenceBackend".into(),
                    ProviderOption::String("vulkan".into()),
                ),
            ]),
        },
    )]);
    let request = GenerationRequest {
        prompt: "A quiet harbour.".into(),
        frames: 48,
        steps: 20,
        canvas_width: 736,
        canvas_height: 416,
        ..Default::default()
    };
    let references = ReferenceVideos::default();
    // Undownloaded models still permit a generic geometry preview.
    assert!(resolve_plan(&request, &settings, &references).is_ok());
    metadata_checkpoint(
        &transformer,
        serde_json::json!({
            "slopfab.conditioning": r#"{"version":1,"max_frames":40}"#
        }),
    );
    assert!(resolve_plan(&request, &settings, &references)
        .err()
        .unwrap()
        .contains("max_frames"));
    metadata_checkpoint(
        &transformer,
        serde_json::json!({ "slopfab.sampling": "invalid JSON" }),
    );
    assert!(resolve_plan(&request, &settings, &references).is_err());
}

#[test]
fn animate_requires_video_and_prompt_mode_requires_text() {
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    let mut request = GenerationRequest::default();
    assert!(configuration
        .validate_inputs(&request)
        .unwrap_err()
        .contains("prompt"));
    configuration.animate = true;
    assert!(configuration
        .validate_inputs(&request)
        .unwrap_err()
        .contains("reference video"));
    request.reference_paths.push("image.png".into());
    assert!(configuration.validate_inputs(&request).is_err());
    request.reference_video_ids.push("video".into());
    configuration.validate_inputs(&request).unwrap();
    request.still_image = true;
    assert!(configuration
        .validate_inputs(&request)
        .unwrap_err()
        .contains("video generation"));
}

#[test]
fn animate_recipe_and_audio_selection_reach_bundled_dll() {
    let references = ReferenceVideos::default();
    let root = tempfile::tempdir().unwrap();
    let embedding = root.path().join("conditioning.safetensors");
    crate::conditioning::fixture(&embedding);
    let settings = BTreeMap::from([(
        "slopfab".into(),
        ProviderSetting {
            enabled: true,
            model: None,
            options: BTreeMap::from([
                (
                    "generationMode".into(),
                    ProviderOption::String("animate".into()),
                ),
                (
                    "promptEmbedding".into(),
                    ProviderOption::String(embedding.to_string_lossy().into_owned()),
                ),
                ("stepOverride".into(), ProviderOption::Number(4.0)),
            ]),
        },
    )]);
    let configuration = Configuration::from_settings(&settings);
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let id = references.create_reference_video(2.0, &settings).unwrap();
    let result = (|| -> Result<(), String> {
        references.append_reference_video(&id, &vec![127; 64 * 64 * 4], 64, 64, 0.0)?;
        let request = GenerationRequest {
            job_id: "animate-test".into(),
            frames: 48,
            steps: 20,
            seed: 1,
            prompt: "This scene prompt must be ignored by Animate.".into(),
            canvas_width: 736,
            canvas_height: 416,
            reference_video_ids: vec![id.clone()],
            reference_paths: vec!["repainted.png".into()],
            ..Default::default()
        };
        for preserve_audio in [false, true] {
            if preserve_audio {
                references.set_reference_video_audio(&id, &vec![0; 32_000 * 2 * 4], 1, 32_000)?;
            }
            for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
                for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
                    let handle = RequestHandle::new(&api)?;
                    configure_request(
                        &api,
                        &handle,
                        &request,
                        &configuration,
                        platform,
                        purpose,
                        &references,
                    )?;
                    assert_eq!(api.resolve(&handle)?.num_model_evaluations, 3);
                    let description = api.describe(&handle)?;
                    assert!(description.contains("fixed 362-token embedding"));
                    // The resolved recipe reports target-canvas preprocessing,
                    // omitted reference audio and video-first packing here.
                    assert!(description.contains(&format!(
                        "conditioning-v1:1:362:2048:768:1032192:1:1:0:1:{}:360",
                        i32::from(preserve_audio)
                    )));
                    assert!(description.contains("video 1.000000 .. 0.600000 (shift 3)"));
                    assert_eq!(
                        description.contains("pinned driving soundtrack"),
                        preserve_audio
                    );
                    assert!(description.contains(&format!(
                        "prompt              {} characters",
                        ANIMATE_PROMPT.len()
                    )));
                }
            }
        }
        Ok(())
    })();
    references.release_reference_videos(&[id]).unwrap();
    result.unwrap();
}

#[test]
fn animate_duration_limit_resolves_with_bundled_dll() {
    let references = ReferenceVideos::default();
    let root = tempfile::tempdir().unwrap();
    let embedding = root.path().join("conditioning.safetensors");
    crate::conditioning::fixture(&embedding);
    let settings = BTreeMap::new();
    let mut configuration = Configuration::from_settings(&settings);
    configuration.animate = true;
    configuration.prompt_embedding = Some(embedding);
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let id = references.create_reference_video(15.0, &settings).unwrap();
    let result = (|| -> Result<(), String> {
        references.append_reference_video(&id, &vec![127; 64 * 64 * 4], 64, 64, 0.0)?;
        let mut request = GenerationRequest {
            prompt: "A dancer.".into(),
            steps: 4,
            seed: 1,
            canvas_width: 736,
            canvas_height: 416,
            reference_video_ids: vec![id.clone()],
            reference_paths: vec!["repainted.png".into()],
            ..Default::default()
        };
        for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
            for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
                for (frames, expected) in [
                    (48, 56),
                    (336, 345),
                    (345, 345),
                    (346, 345),
                    (348, 345),
                    (359, 345),
                    (360, 345),
                ] {
                    request.frames = frames;
                    let handle = RequestHandle::new(&api)?;
                    configure_request(
                        &api,
                        &handle,
                        &request,
                        &configuration,
                        platform,
                        purpose,
                        &references,
                    )?;
                    let plan = api.resolve(&handle)?;
                    assert_eq!(plan.aligned_frames, expected, "requested {frames} frames");
                    assert_eq!(plan.duration_seconds, f64::from(expected) / 24.0);
                    assert_eq!(
                        scene_frame_window(&request, plan.aligned_frames)?,
                        (0, expected)
                    );
                }
            }
        }
        request.frames = 361;
        let handle = RequestHandle::new(&api)?;
        configure_request(
            &api,
            &handle,
            &request,
            &configuration,
            ComputePlatform::Cuda13,
            RequestPurpose::Plan,
            &references,
        )?;
        assert!(api
            .resolve(&handle)
            .err()
            .unwrap()
            .contains("exceeds conditioning max_frames"));

        // Other generators keep their existing upward alignment at 15 s.
        configuration.animate = false;
        request.frames = 360;
        let handle = RequestHandle::new(&api)?;
        configure_request(
            &api,
            &handle,
            &request,
            &configuration,
            ComputePlatform::Cuda13,
            RequestPurpose::Plan,
            &references,
        )?;
        assert_eq!(api.resolve(&handle)?.aligned_frames, 362);
        Ok(())
    })();
    references.release_reference_videos(&[id]).unwrap();
    result.unwrap();
}

#[test]
fn animate_reports_missing_runtime_api() {
    let mut api = ffi::Api::load(&default_dll_path()).unwrap();
    api.disable_animate_for_test();
    let handle = RequestHandle::new(&api).unwrap();
    assert!(api.set_animate(&handle, true).unwrap_err().contains("1.10"));
}

#[test]
fn continuation_uses_22_overlap_frames_and_preserves_the_joined_output() {
    let references = ReferenceVideos::default();
    // An independent 39-frame, 64x32 archive exercises the real DLL without
    // loading model weights. Its sampling window should be 22 + 34 frames.
    let root = tempfile::tempdir().unwrap();
    let path = root.path().join("previous.safetensors");
    let video_bytes = 24 * 96 * 4;
    let audio_bytes = 130 * 32 * 4;
    let mut header = serde_json::json!({
        "__metadata__": { "slopfab_latents": "h3-av-v1", "width": "64", "height": "32", "frames": "39", "fps": "24", "sampled": "1" },
        "video_rows": { "dtype": "F32", "shape": [24, 96], "data_offsets": [0, video_bytes] },
        "audio_rows": { "dtype": "F32", "shape": [130, 32], "data_offsets": [video_bytes, video_bytes + audio_bytes] },
    }).to_string();
    while header.len() % 8 != 0 {
        header.push(' ');
    }
    let mut bytes = (header.len() as u64).to_le_bytes().to_vec();
    bytes.extend_from_slice(header.as_bytes());
    bytes.resize(bytes.len() + video_bytes + audio_bytes, 0);
    std::fs::write(&path, bytes).unwrap();
    let mut request = GenerationRequest {
        job_id: "continued".into(),
        prompt: "The camera keeps moving.".into(),
        frames: 18,
        steps: 4,
        seed: 1,
        canvas_width: 64,
        canvas_height: 32,
        continuation_path: Some(path.clone()),
        save_latents_path: Some(root.path().join("next.safetensors")),
        ..Default::default()
    };
    let settings = BTreeMap::new();
    let configuration = Configuration::from_settings(&settings);
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        let handle = RequestHandle::new(&api).unwrap();
        configure_request(
            &api,
            &handle,
            &request,
            &configuration,
            platform,
            RequestPurpose::Generate,
            &references,
        )
        .unwrap();
        let raw = api.resolve(&handle).unwrap();
        assert_eq!(raw.aligned_frames, 73);
        assert_eq!(raw.latent_frames, 17); // 56-frame window, including 22 overlap.
        assert_eq!(
            scene_frame_window(&request, raw.aligned_frames).unwrap(),
            (0, 73)
        );
    }
    let plan = resolve_plan(&request, &settings, &references).unwrap();
    assert_eq!(plan.aligned_frames, 73);
    assert!((plan.duration_seconds - 73.0 / 24.0).abs() < 1e-6);
    assert!(!request.save_latents_path.as_ref().unwrap().exists()); // Planning never writes.
    request.canvas_width = 128;
    assert!(resolve_plan(&request, &settings, &references).is_err());
    request.canvas_width = 64;
    std::fs::write(&path, b"invalid archive").unwrap();
    assert!(resolve_plan(&request, &settings, &references).is_err());
}

#[test]
fn continuation_frame_window_keeps_the_cumulative_source() {
    let mut request = GenerationRequest {
        frames: 119,
        continuation_path: Some("source".into()),
        ..Default::default()
    };
    assert_eq!(scene_frame_window(&request, 243).unwrap(), (0, 243));
    assert_eq!(scene_frame_window(&request, 362).unwrap(), (0, 362));
    assert!(scene_frame_window(&request, 120).is_err());
    request.continuation_path = None;
    assert_eq!(scene_frame_window(&request, 124).unwrap(), (0, 124));
}

#[test]
fn refmods_attach_for_plans_and_icons_or_report_an_older_dll() {
    let references = ReferenceVideos::default();
    let configuration = Configuration::from_settings(&BTreeMap::new());
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let root = tempfile::tempdir().unwrap();
    let file = root.path().join("person.safetensors");
    let header = serde_json::json!({
        "__metadata__": { "refmod_meta": serde_json::json!({ "kind": "image", "name": "Person", "_format_version": 4 }).to_string() },
        "latent": { "dtype": "F32", "shape": [1, 24, 1, 2, 2], "data_offsets": [0, 384] }
    }).to_string();
    let mut bytes = (header.len() as u64).to_le_bytes().to_vec();
    bytes.extend_from_slice(header.as_bytes());
    for _ in 0..96 {
        bytes.extend_from_slice(&0.25_f32.to_le_bytes());
    }
    std::fs::write(&file, bytes).unwrap();
    let mut request = GenerationRequest {
        job_id: "refmod-test".into(),
        prompt: "A portrait.".into(),
        still_image: true,
        frames: 1,
        steps: 20,
        seed: 1,
        canvas_width: 768,
        canvas_height: 768,
        reference_paths: Vec::new(),
        reference_video_ids: Vec::new(),
        refmods: vec![RefmodInput {
            path: file.to_string_lossy().into_owned(),
            strength: 0.7,
            copies: 2,
        }],
        ..Default::default()
    };
    let probe = RequestHandle::new(&api).unwrap();
    let added = api.add_refmod(&probe, &file, 0.7, 2);
    assert_eq!(request.refmod_count(), 1);
    if let Err(error) = &added {
        assert!(error.contains("does not support refmods"), "{error}");
        eprintln!(
            "Refmod export not yet available in the installed DLL; checked compatibility error."
        );
        assert!(configure_request(
            &api,
            &probe,
            &request,
            &configuration,
            ComputePlatform::Vulkan,
            RequestPurpose::Plan,
            &references
        )
        .unwrap_err()
        .contains("does not support refmods"));
    } else {
        for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
            for still_image in [false, true] {
                request.still_image = still_image;
                request.frames = if still_image { 1 } else { 120 };
                for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
                    let handle = RequestHandle::new(&api).unwrap();
                    configure_request(
                        &api,
                        &handle,
                        &request,
                        &configuration,
                        platform,
                        purpose,
                        &references,
                    )
                    .unwrap();
                    let plan = api.resolve(&handle).unwrap();
                    assert!(plan.aligned_frames >= request.frames);
                }
            }
        }
    }
    request.refmods[0].strength = 0.0;
    assert_eq!(request.refmod_count(), 0);
    std::fs::remove_file(&file).unwrap();
    let handle = RequestHandle::new(&api).unwrap();
    configure_request(
        &api,
        &handle,
        &request,
        &configuration,
        ComputePlatform::Vulkan,
        RequestPurpose::Generate,
        &references,
    )
    .unwrap();
    request.refmods[0].copies = 11;
    assert!(configure_request(
        &api,
        &handle,
        &request,
        &configuration,
        ComputePlatform::Vulkan,
        RequestPurpose::Plan,
        &references
    )
    .is_err());
}

#[test]
fn refmod_export_needs_raw_media_and_vaes_or_reports_an_older_dll() {
    let references = ReferenceVideos::default();
    let settings = BTreeMap::new();
    let root = tempfile::tempdir().unwrap();
    let output = root.path().join("voice.safetensors");
    let mut request = GenerationRequest { job_id: "refmod-export-test".into(), ..Default::default() };
    let empty = export_refmod(&request, &settings, &references, &output, "Voice", "").unwrap_err();
    assert!(empty.contains("Add an image, video or sound"), "{empty}");
    let audio = references
        .create_reference_audio(&vec![0; 32_000 * 2 * 4], 1, 32_000)
        .unwrap();
    request.reference_audio_ids = vec![audio.clone()];
    // The runtime refuses a request without VAEs before any GPU work.
    let missing = export_refmod(&request, &settings, &references, &output, "Voice", "A voice").unwrap_err();
    assert!(missing.contains("VAE path is missing"), "{missing}");
    assert!(!output.exists());
    let configuration = Configuration::from_settings(&settings);
    let mut api = ffi::Api::load(&configuration.dll_path).unwrap();
    api.disable_refmod_export_for_test();
    let older = refmod_export::export_with(&api, &request, &configuration, &references, &output, "Voice", "").unwrap_err();
    assert!(older.contains("API 1.18"), "{older}");
    references.release_reference_audios(&[audio]).unwrap();
}

/// Encodes real media on the GPU. Needs SLOPUS_E2E_WEIGHTS: a folder holding
/// floating-point H3 video and audio VAEs.
#[test]
#[ignore]
fn refmod_export_encodes_an_image_a_clip_and_a_sound_into_a_loadable_bundle() {
    let weights = std::path::PathBuf::from(std::env::var("SLOPUS_E2E_WEIGHTS").expect("SLOPUS_E2E_WEIGHTS"));
    let find = |part: &str| std::fs::read_dir(&weights).unwrap().filter_map(Result::ok).map(|entry| entry.path())
        .find(|path| path.to_string_lossy().contains(part) && path.extension().is_some_and(|ext| ext == "safetensors"))
        .unwrap_or_else(|| panic!("no {part} weights")).to_string_lossy().into_owned();
    let options = BTreeMap::from([
        ("videoVae".to_string(), ProviderOption::String(find("video_vae_fp16"))),
        ("audioVae".to_string(), ProviderOption::String(find("audio_vae_fp32"))),
    ]);
    let settings = BTreeMap::from([("slopfab".to_string(), ProviderSetting { enabled: true, model: None, options })]);
    let root = tempfile::tempdir().unwrap();
    let picture = root.path().join("hero.png");
    image::RgbImage::from_fn(256, 384, |x, y| image::Rgb([x as u8, y as u8, 128])).save(&picture).unwrap();
    let references = ReferenceVideos::default();
    let video = references.create_reference_video(2.0, &settings).unwrap();
    for frame in 0..48_u8 {
        references.append_reference_video(&video, &vec![frame * 5; 320 * 192 * 4], 320, 192, f64::from(frame) / 24.0).unwrap();
    }
    let tone: Vec<u8> = (0..32_000 * 2).flat_map(|index| ((index as f32 * 0.05).sin() * 0.25).to_le_bytes()).collect();
    let audio = references.create_reference_audio(&tone, 1, 32_000).unwrap();
    let request = GenerationRequest {
        job_id: "refmod-export-e2e".into(),
        reference_paths: vec![picture.to_string_lossy().into_owned()],
        reference_video_ids: vec![video],
        reference_audio_ids: vec![audio],
        ..Default::default()
    };
    let output = root.path().join("hero.safetensors");
    export_refmod(&request, &settings, &references, &output, "Hero", "A traveler").unwrap();
    let bytes = std::fs::read(&output).unwrap();
    let length = u64::from_le_bytes(bytes[..8].try_into().unwrap()) as usize;
    let header: serde_json::Value = serde_json::from_slice(&bytes[8..8 + length]).unwrap();
    let meta: serde_json::Value = serde_json::from_str(header["__metadata__"]["refmod_meta"].as_str().unwrap()).unwrap();
    assert_eq!((meta["kind"].as_str(), meta["name"].as_str()), (Some("bundle"), Some("Hero")));
    let kinds: Vec<_> = meta["members"].as_array().unwrap().iter().map(|member| member["kind"].as_str().unwrap()).collect();
    assert_eq!(kinds, ["image", "video", "audio"]);
    assert_eq!(header["ref_0"]["shape"], serde_json::json!([1, 24, 1, 72, 48]));
    let api = ffi::Api::load(&Configuration::from_settings(&settings).dll_path).unwrap();
    api.add_refmod(&RequestHandle::new(&api).unwrap(), &output, 1.0, 1).unwrap();
}

#[test]
fn motion_cache_reaches_cuda_and_vulkan_requests_and_changes_timing_profile() {
    let mut configuration = Configuration::from_settings(&BTreeMap::from([(
        "slopfab".into(),
        ProviderSetting {
            enabled: true,
            model: None,
            options: BTreeMap::from([("motionCache".into(), ProviderOption::Boolean(true))]),
        },
    )]));
    assert!(configuration.motion_cache);
    assert!(!Configuration::from_settings(&BTreeMap::new()).motion_cache);
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let request = GenerationRequest {
        prompt: "A quiet harbour.".into(),
        frames: 120,
        steps: 20,
        seed: 1,
        canvas_width: 736,
        canvas_height: 416,
        ..Default::default()
    };
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        let enabled_profile = configuration.timing_profile("test", platform);
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            let handle = RequestHandle::new(&api).unwrap();
            configure_request(
                &api,
                &handle,
                &request,
                &configuration,
                platform,
                purpose,
                &ReferenceVideos::default(),
            )
            .unwrap();
            let description = api.describe(&handle).unwrap();
            assert!(description.contains("MotionCache"), "{description}");
            assert!(description.contains("threshold 0.150"), "{description}");
            api.set_motion_cache(&handle, false).unwrap();
            assert!(!api.describe(&handle).unwrap().contains("MotionCache"));
        }
        configuration.motion_cache = false;
        assert_ne!(
            enabled_profile,
            configuration.timing_profile("test", platform)
        );
        configuration.motion_cache = true;
    }
    configuration.animate = true;
    assert!(configuration
        .validate_inputs(&request)
        .unwrap_err()
        .contains("MotionCache is unavailable in Animate"));
}

#[test]
fn older_runtimes_work_with_motion_cache_off_and_explain_missing_support() {
    let mut api = ffi::Api::load(&default_dll_path()).unwrap();
    api.disable_motion_cache_for_test();
    let handle = RequestHandle::new(&api).unwrap();
    api.set_motion_cache(&handle, false).unwrap();
    assert!(api
        .set_motion_cache(&handle, true)
        .unwrap_err()
        .contains("does not support MotionCache"));
}

#[test]
fn ordered_loras_and_step_override_reach_cuda_and_vulkan_requests() {
    let references = ReferenceVideos::default();
    let root = tempfile::tempdir().unwrap();
    let paths = [
        root.path().join("style.safetensors"),
        root.path().join("TaoMate.safetensors"),
    ];
    for path in &paths {
        metadata_checkpoint(path, serde_json::json!({}));
    }
    let settings = BTreeMap::from([(
        "slopfab".into(),
        ProviderSetting {
            enabled: true,
            model: None,
            options: BTreeMap::from([
                (
                    "loras".into(),
                    ProviderOption::String(
                        serde_json::json!([
                            { "path": paths[0], "strength": -0.5 },
                            { "path": paths[1], "strength": 1.0 },
                        ])
                        .to_string(),
                    ),
                ),
                ("stepOverride".into(), ProviderOption::Number(8.0)),
            ]),
        },
    )]);
    let configuration = Configuration::from_settings(&settings);
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let request = GenerationRequest {
        job_id: "lora-test".into(),
        prompt: "A quiet harbour.".into(),
        frames: 120,
        still_image: false,
        steps: 20,
        seed: 1,
        canvas_width: 736,
        canvas_height: 416,
        reference_paths: Vec::new(),
        reference_video_ids: Vec::new(),
        refmods: Vec::new(),
        ..Default::default()
    };
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            let handle = RequestHandle::new(&api).unwrap();
            configure_request(
                &api,
                &handle,
                &request,
                &configuration,
                platform,
                purpose,
                &references,
            )
            .unwrap();
            assert_eq!(api.resolve(&handle).unwrap().num_model_evaluations, 7);
            let description = api.describe(&handle).unwrap();
            assert!(!description.contains("taomate-3step"));
            assert!(
                description.find("style.safetensors").unwrap()
                    < description.find("TaoMate.safetensors").unwrap()
            );
            assert!(description.contains("strength -0.5"));
        }
    }
    let invalid = BTreeMap::from([(
        "slopfab".into(),
        ProviderSetting {
            enabled: true,
            model: None,
            options: BTreeMap::from([(
                "loras".into(),
                ProviderOption::String("invalid JSON".into()),
            )]),
        },
    )]);
    assert!(Configuration::from_settings(&invalid).loras.is_err());
    std::fs::remove_file(&paths[0]).unwrap();
    let handle = RequestHandle::new(&api).unwrap();
    assert!(configure_request(
        &api,
        &handle,
        &request,
        &configuration,
        ComputePlatform::Vulkan,
        RequestPurpose::Generate,
        &references
    )
    .unwrap_err()
    .contains("LoRA file is missing"));
}

#[test]
fn vulkan_video_references_prepare_and_attach_for_planning_and_generation() {
    let references = ReferenceVideos::default();
    let settings = BTreeMap::from([(
        "slopfab".into(),
        ProviderSetting {
            enabled: true,
            model: None,
            options: BTreeMap::from([(
                "inferenceBackend".into(),
                ProviderOption::String("vulkan".into()),
            )]),
        },
    )]);
    let id = references.create_reference_video(2.0, &settings).unwrap();
    let result = (|| -> Result<(), String> {
        references.append_reference_video(&id, &vec![127; 64 * 64 * 4], 64, 64, 0.0)?;
        references.set_reference_video_audio(&id, &vec![0; 32_000 * 2 * 4], 1, 32_000)?;
        let request = GenerationRequest {
            job_id: "vulkan-reference-test".into(),
            prompt: "A scene using <Video 1>.".into(),
            frames: 120,
            still_image: false,
            steps: 12,
            seed: 1,
            canvas_width: 736,
            canvas_height: 416,
            reference_paths: Vec::new(),
            reference_video_ids: vec![id.clone()],
            refmods: Vec::new(),
            ..Default::default()
        };
        let configuration = Configuration::from_settings(&settings);
        let api = ffi::Api::load(&configuration.dll_path)?;
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            let handle = RequestHandle::new(&api)?;
            configure_request(
                &api,
                &handle,
                &request,
                &configuration,
                ComputePlatform::Vulkan,
                purpose,
                &references,
            )?;
            assert!(api.resolve(&handle)?.aligned_frames > 0);
        }
        Ok(())
    })();
    references.release_reference_videos(&[id]).unwrap();
    result.unwrap();
}

#[test]
fn standalone_audio_references_attach_after_videos_and_need_visual_media() {
    let references = ReferenceVideos::default();
    let settings = BTreeMap::new();
    let video = references.create_reference_video(2.0, &settings).unwrap();
    let audio = references
        .create_reference_audio(&vec![0; 32_000 * 2 * 4], 1, 32_000)
        .unwrap();
    let result = (|| -> Result<(), String> {
        references.append_reference_video(&video, &vec![127; 64 * 64 * 4], 64, 64, 0.0)?;
        let mut request = GenerationRequest {
            job_id: "audio-reference-test".into(),
            prompt: "A scene using <Video 1> and <Audio 1>.".into(),
            frames: 120,
            steps: 12,
            seed: 1,
            canvas_width: 736,
            canvas_height: 416,
            reference_video_ids: vec![video.clone()],
            reference_audio_ids: vec![audio.clone()],
            ..Default::default()
        };
        let configuration = Configuration::from_settings(&settings);
        let api = ffi::Api::load(&configuration.dll_path)?;
        let plan = |request: &GenerationRequest| -> Result<String, String> {
            let handle = RequestHandle::new(&api)?;
            configure_request(&api, &handle, request, &configuration, ComputePlatform::Vulkan, RequestPurpose::Plan, &references)?;
            api.resolve(&handle)?;
            api.describe(&handle)
        };
        let description = plan(&request)?;
        assert!(description.contains("reference audios    1"));
        request.reference_video_ids.clear();
        assert!(plan(&request).unwrap_err().contains("image or video reference"));
        Ok(())
    })();
    references.release_reference_videos(&[video]).unwrap();
    references.release_reference_audios(&[audio.clone()]).unwrap();
    assert!(references.reference_audio(&audio).is_err());
    result.unwrap();
}

#[test]
fn reference_audio_registry_validates_pcm_layout() {
    let references = ReferenceVideos::default();
    assert!(references.create_reference_audio(&[0; 6], 1, 32_000).is_err());
    assert!(references.create_reference_audio(&[0; 12], 2, 32_000).is_err());
    assert!(references.create_reference_audio(&[0; 8], 3, 32_000).is_err());
    assert!(references.create_reference_audio(&[0; 8], 1, 0).is_err());
    let ids: Vec<String> = (0..3)
        .map(|_| references.create_reference_audio(&[0; 8], 2, 48_000).unwrap())
        .collect();
    assert!(references.create_reference_audio(&[0; 8], 2, 48_000).is_err());
    references.release_reference_audios(&ids).unwrap();
    assert!(references.create_reference_audio(&[0; 8], 2, 48_000).is_ok());
}

#[test]
fn video_reference_c_api_copies_inputs_and_retains_attached_snapshot() {
    let path = default_dll_path();
    let api = ffi::Api::load(&path).unwrap();
    let request = RequestHandle::new(&api).unwrap();
    api.set_prompt(&request, "A scene using <Video 1>.")
        .unwrap();
    api.set_frames(&request, 120).unwrap();
    api.set_resolution(&request, 736, 416).unwrap();
    let mut video =
        ffi::ReferenceVideoHandle::new(ffi::Api::load(&path).unwrap(), 2.0, path.clone()).unwrap();
    let pixels = vec![127_u8; 64 * 64 * 4];
    video.append(&pixels, 64, 64, 0.0).unwrap();
    assert!(video.append(&pixels, 64, 64, 0.0).is_err());
    assert!(video.append(&pixels[..10], 64, 64, 0.5).is_err());
    video.append(&pixels, 64, 64, 1.0).unwrap();
    video.set_audio(&vec![0.0; 32_000 * 2], 1, 32_000).unwrap();
    video.attach(&request, &path).unwrap();
    drop(video);
    drop(pixels);
    // Plan resolution reads the retained video/audio snapshot without a
    // neural model or a CUDA allocation, even after the host releases it.
    let plan = api.resolve(&request).unwrap();
    assert!(plan.aligned_frames > 0);
}

#[test]
fn absent_dll_is_an_explicit_disabled_state() {
    let mut settings = BTreeMap::new();
    settings.insert(
        "slopfab".into(),
        ProviderSetting {
            enabled: true,
            model: None,
            options: BTreeMap::from([(
                "dllPath".into(),
                ProviderOption::String("Z:/definitely-absent/slopfab.dll".into()),
            )]),
        },
    );
    let status = status(&settings);
    assert_eq!(status.state, "runtimeMissing");
}
#[test]
fn compatible_major_version_decodes_from_packed_value() {
    let packed = (1_u32 << 24) | (37 << 12) | 5;
    assert_eq!(packed >> 24, EXPECTED_CAPI_MAJOR);
}
#[test]
fn platform_selection_prefers_supported_cuda_majors_and_falls_back_to_vulkan() {
    assert_eq!(platform_from_cuda_probe(Ok(13)), ComputePlatform::Cuda13);
    assert_eq!(platform_from_cuda_probe(Ok(12)), ComputePlatform::Cuda12);
    assert_eq!(platform_from_cuda_probe(Ok(11)), ComputePlatform::Vulkan);
    assert_eq!(
        platform_from_cuda_probe(Err("no CUDA toolkit".into())),
        ComputePlatform::Vulkan
    );
    assert_eq!(ComputePlatform::Cuda13.backend(), 0);
    assert_eq!(ComputePlatform::Vulkan.backend(), 1);
}

#[test]
fn backend_preference_cannot_enable_cuda_without_cuda_hardware() {
    let mut config = Configuration::from_settings(&BTreeMap::new());
    assert_eq!(
        config.platform(ComputePlatform::Cuda13),
        ComputePlatform::Cuda13
    );
    assert_eq!(
        config.platform(ComputePlatform::Cuda12),
        ComputePlatform::Cuda12
    );
    assert_eq!(
        config.platform(ComputePlatform::Vulkan),
        ComputePlatform::Vulkan
    );
    config.vulkan = true;
    for detected in [
        ComputePlatform::Cuda13,
        ComputePlatform::Cuda12,
        ComputePlatform::Vulkan,
    ] {
        assert_eq!(config.platform(detected), ComputePlatform::Vulkan);
    }
}

#[test]
fn attention_defaults_to_sage_and_is_independent_of_backend() {
    assert_eq!(
        Configuration::from_settings(&BTreeMap::new()).attention,
        "sage2"
    );
    for backend in ["cuda", "vulkan"] {
        for attention in ["exact", "flash2", "sage2", "sol", "invalid"] {
            let settings = serde_json::from_value(serde_json::json!({
                "slopfab": { "enabled": true, "model": null,
                    "options": { "inferenceBackend": backend, "attention": attention } }
            }))
            .unwrap();
            let config = Configuration::from_settings(&settings);
            let expected = if attention == "invalid" {
                "sage2"
            } else {
                attention
            };
            assert_eq!(config.attention, expected);
            assert_eq!(config.vulkan, backend == "vulkan");
            assert!(config
                .timing_profile("1.4.0", ComputePlatform::Vulkan)
                .contains(&format!("attention={expected}|")));
        }
    }
}

#[test]
#[cfg(windows)]
fn bundled_dll_reports_a_compatible_api() {
    assert!(
        default_dll_path().is_file(),
        "The build must stage slopfab.dll beside the executable."
    );
    let runtime = status(&BTreeMap::new());
    assert_ne!(runtime.state, "runtimeMissing", "{}", runtime.detail);
    assert_ne!(runtime.state, "incompatible", "{}", runtime.detail);
    assert!(runtime
        .version
        .as_deref()
        .is_some_and(|value| value.starts_with("1.")));
    assert!(matches!(
        runtime.platform,
        Some("CUDA 13" | "CUDA 12" | "Vulkan")
    ));
}
#[test]
fn stage_ids_are_normalized_without_assuming_an_enum() {
    assert_eq!(stage_name(4), "denoising");
    assert_eq!(stage_name(99), "unknown");
}

#[test]
fn installed_dll_resolves_icons_as_one_still_frame_when_present() {
    let references = ReferenceVideos::default();
    if !default_dll_path().is_file() {
        return;
    }
    let request: GenerationRequest = serde_json::from_value(serde_json::json!({
        "jobId": "icon-plan", "prompt": "A red toy car", "frames": 1, "stillImage": true,
        "steps": 20, "seed": 1, "canvasWidth": 768, "canvasHeight": 768
    }))
    .unwrap();
    let plan = resolve_plan(&request, &BTreeMap::new(), &references).unwrap();
    assert_eq!(plan.aligned_frames, 1);
    assert_eq!(plan.latent_frames, 1);
    assert_eq!((plan.canvas_width, plan.canvas_height), (768, 768));
    for (width, height) in [(1376, 768), (768, 1376), (768, 960)] {
        let request = GenerationRequest {
            canvas_width: width,
            canvas_height: height,
            ..request.clone()
        };
        let plan = resolve_plan(&request, &BTreeMap::new(), &references).unwrap();
        assert_eq!(plan.aligned_frames, 1);
        assert_eq!(plan.latent_frames, 1);
        assert_eq!((plan.canvas_width, plan.canvas_height), (width, height));
    }
}

#[test]
fn bundled_dll_accepts_attention_modes_on_supported_backends() {
    let references = ReferenceVideos::default();
    if !default_dll_path().is_file() {
        return;
    }
    let api = ffi::Api::load(&default_dll_path()).unwrap();
    let request: GenerationRequest = serde_json::from_value(serde_json::json!({
        "jobId": "attention-plan", "prompt": "A red toy car", "frames": 1, "stillImage": true,
        "steps": 20, "seed": 1, "canvasWidth": 768, "canvasHeight": 768
    }))
    .unwrap();
    let mut config = Configuration::from_settings(&BTreeMap::new());
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        for attention in ["exact", "flash2", "sage2", "sol"] {
            config.attention = attention;
            let handle = RequestHandle::new(&api).unwrap();
            let configured = configure_request(
                &api,
                &handle,
                &request,
                &config,
                platform,
                RequestPurpose::Plan,
                &references,
            );
            if attention == "sol" && platform == ComputePlatform::Vulkan {
                assert!(configured.unwrap_err().contains("Sol attention requires CUDA"));
                continue;
            }
            configured.unwrap();
            assert_eq!(api.resolve(&handle).unwrap().aligned_frames, 1);
        }
    }
}
#[test]
fn generation_seed_accepts_random_and_non_negative_values() {
    assert!(generation_seed(-1).is_ok());
    assert_eq!(generation_seed(0).unwrap(), 0);
    assert_eq!(generation_seed(482_091).unwrap(), 482_091);
    assert!(generation_seed(-2).is_err());
}

#[test]
#[cfg(not(windows))]
fn linux_packages_find_the_runtime_in_the_resource_folder() {
    let temp = tempfile::tempdir().unwrap();
    let bin = temp.path().join("usr/bin");
    let resources = temp.path().join("usr/lib/Slopus");
    std::fs::create_dir_all(&bin).unwrap();
    std::fs::create_dir_all(&resources).unwrap();
    assert_eq!(super::runtime_beside(&bin), bin.join(super::DLL_FILE_NAME));
    std::fs::write(resources.join(super::DLL_FILE_NAME), b"\x7fELF").unwrap();
    assert_eq!(super::runtime_beside(&bin), bin.join("../lib/Slopus").join(super::DLL_FILE_NAME));
    std::fs::write(bin.join(super::DLL_FILE_NAME), b"\x7fELF").unwrap();
    assert_eq!(super::runtime_beside(&bin), bin.join(super::DLL_FILE_NAME));
}

#[test]
fn latent_upscale_uses_half_aligned_canvas_for_preview_and_execution() {
    let folder = tempfile::tempdir().unwrap();
    let weights = folder.path().join("latent-upscaler.safetensors");
    std::fs::write(&weights, b"planning does not load the weights").unwrap();
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.latent_upscaler = Some(weights);
    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(super::DLL_FILE_NAME);
    let api = ffi::Api::load(&path).unwrap();
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            for (width, height, half_width, half_height) in [(1344, 768, 672, 384), (736, 416, 384, 224), (416, 736, 224, 384)] {
                let handle = RequestHandle::new(&api).unwrap();
                let mut request = GenerationRequest { prompt: "Ocean waves".into(), frames: 48, steps: 4,
                    latent_upscale: true, seed: 1, canvas_width: width, canvas_height: height, ..Default::default() };
                validate_generation_controls(&request).unwrap();
                configure_request(&api, &handle, &request, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap();
                let plan = api.resolve(&handle).unwrap();
                assert_eq!((plan.canvas_width, plan.canvas_height), (half_width, half_height));
                request.latent_upscale = false;
                configure_request(&api, &handle, &request, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap();
                let normal = api.resolve(&handle).unwrap();
                assert_eq!((normal.canvas_width, normal.canvas_height), (width, height));
                assert_eq!(normal.aligned_frames, plan.aligned_frames);
            }
        }
    }
    let request = GenerationRequest { prompt: "Ocean waves".into(), frames: 48, steps: 4, latent_upscale: true,
        canvas_width: 736, canvas_height: 416, ..Default::default() };
    configuration.latent_upscaler = None;
    let handle = RequestHandle::new(&api).unwrap();
    assert!(configure_request(&api, &handle, &request, &configuration, ComputePlatform::Vulkan,
        RequestPurpose::Plan, &ReferenceVideos::default()).unwrap_err().contains("Other weights"));
    assert!(validate_generation_controls(&GenerationRequest { still_image: true, ..request.clone() }).is_err());
    assert!(validate_generation_controls(&GenerationRequest { canvas_width: 65, ..request }).is_err());
    assert_eq!(stage_name(9), "upscaling");
}

#[test]
fn sigma_shifts_reach_planning_execution_and_reset() {
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.sigma_shifts = Ok(SigmaShifts { video: Some(9.0), audio: Some(3.5), ..Default::default() });
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            let handle = RequestHandle::new(&api).unwrap();
            let mut request = GenerationRequest { prompt: "Ocean waves".into(), frames: 48, steps: 4,
                video_sigma_shift: Some(8.5), audio_sigma_shift: Some(2.5), seed: 1,
                canvas_width: 64, canvas_height: 32, ..Default::default() };
            for (video, audio) in [(8.5, 2.5), (6.0, 2.0), (9.0, 3.5), (12.0, 3.0)] {
                configure_request(&api, &handle, &request, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap();
                let description = api.describe(&handle).unwrap();
                assert!(description.contains(&format!("shift {video}")), "{description}");
                assert!(description.contains(&format!("shift {audio}")), "{description}");
                if video == 8.5 {
                    let shifts = configuration.sigma_shifts.as_mut().unwrap();
                    shifts.video_override = Some(6.0);
                    shifts.audio_override = Some(2.0);
                } else if video == 6.0 {
                    configuration.sigma_shifts = Ok(SigmaShifts { video: Some(9.0), audio: Some(3.5), ..Default::default() });
                    request.video_sigma_shift = None;
                    request.audio_sigma_shift = None;
                } else {
                    configuration.sigma_shifts = Ok(SigmaShifts::default());
                }
            }
            configuration.sigma_shifts = Ok(SigmaShifts { video: Some(9.0), audio: Some(3.5), ..Default::default() });
            for invalid in [0.0, -1.0, f32::INFINITY, f32::NAN] {
                request.video_sigma_shift = Some(invalid);
                assert!(validate_generation_controls(&request).is_err());
                request.video_sigma_shift = None;
                request.audio_sigma_shift = Some(invalid);
                assert!(validate_generation_controls(&request).is_err());
            }
        }
    }
}

#[test]
fn sigma_provider_settings_validate_float32_bounds() {
    for key in ["videoSigmaShift", "audioSigmaShift", "videoSigmaShiftOverride", "audioSigmaShiftOverride"] {
        for value in [0.0, -1.0, f64::INFINITY, 1e39, 1e-50] {
            let settings = BTreeMap::from([("slopfab".into(), ProviderSetting { enabled: true, model: None,
                options: BTreeMap::from([(key.into(), ProviderOption::Number(value))]) })]);
            assert!(Configuration::from_settings(&settings).sigma_shifts.is_err());
        }
    }
}

#[test]
fn moss_cfg_reaches_planning_and_generation_and_h3_rejects_it() {
    let api = ffi::Api::load(&std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(super::DLL_FILE_NAME)).unwrap();
    let mut config = Configuration::from_settings(&BTreeMap::new());
    config.model_type = "moss".into();
    config.attention = "flash2";
    let mut request = GenerationRequest { still_image: true, frames: 1, steps: 50, prompt: "Apple".into(), canvas_width: 512, canvas_height: 512, ..Default::default() };
    for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
        for (scale, expected) in [(None, "3"), (Some(0.0), "0"), (Some(1.0), "1"), (Some(4.5), "4.5")] {
            request.guidance_scale = scale;
            let handle = RequestHandle::new(&api).unwrap();
            configure_request(&api, &handle, &request, &config, ComputePlatform::Cuda13, purpose, &ReferenceVideos::default()).unwrap();
            assert!(api.describe(&handle).unwrap().contains(&format!("guidance    {expected}\n")));
        }
    }
    for scale in [-1.0, f32::NAN, f32::INFINITY] {
        request.guidance_scale = Some(scale);
        assert!(config.validate_inputs(&request).is_err());
    }
    config.model_type = "minimax-h3".into(); request.guidance_scale = Some(3.0);
    assert!(config.validate_inputs(&request).unwrap_err().contains("CFG"));
}

#[test]
fn lasso_masks_survive_worker_serialization_and_reach_native_requests() {
    for compound in [false, true] {
        let mut request: GenerationRequest = serde_json::from_value(serde_json::json!({
            "jobId":"lasso", "prompt":"A flower", "stillImage":true, "frames":1, "steps":4, "seed":1,
            "canvasWidth":64, "canvasHeight":32,
            "imageEdit":{"sourceRelativePath":"source.png", "edits":[{
                "prompt":"A flower", "x":0, "y":0, "width":32, "height":32, "feather":0,
                "maskPolygon":[{"x":0,"y":0},{"x":32,"y":0},{"x":0,"y":32}]
            }]}
        })).unwrap();
        if compound {
            let step = &mut request.image_edit.as_mut().unwrap().edits[0];
            step.mask_contours = Some(vec![step.mask_polygon.take().unwrap(), vec![
                crate::image_mask::MaskPoint { x: 2.0, y: 2.0 }, crate::image_mask::MaskPoint { x: 6.0, y: 2.0 }, crate::image_mask::MaskPoint { x: 2.0, y: 6.0 }
            ]]);
        }
        let serialized = serde_json::to_value(&request).unwrap();
        request = serde_json::from_value(serialized.clone()).unwrap();
        assert_eq!(serde_json::to_value(&request).unwrap(), serialized);
        validate_generation_controls(&request).unwrap();
        request.image_edit_pixels = Some(std::sync::Arc::new(vec![100; 64 * 32 * 3]));
        let configuration = Configuration::from_settings(&BTreeMap::new());
        let api = ffi::Api::load(&configuration.dll_path).unwrap();
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            let handle = RequestHandle::new(&api).unwrap();
            configure_request(&api, &handle, &request, &configuration, ComputePlatform::Vulkan, purpose, &ReferenceVideos::default()).unwrap();
            api.resolve(&handle).unwrap();
            let description = api.describe(&handle).unwrap();
            assert!(description.contains("mask"), "{description}");
        }
        request.image_edit.as_mut().unwrap().edits[0].invert_mask = true;
        assert!(validate_generation_controls(&request).is_err());
        request.image_edit.as_mut().unwrap().edits[0].invert_mask = false;
        let step = &mut request.image_edit.as_mut().unwrap().edits[0];
        if compound { step.mask_contours.as_mut().unwrap()[0][0].x = -1.0; }
        else { step.mask_polygon.as_mut().unwrap()[0].x = -1.0; }
        assert!(validate_generation_controls(&request).is_err());
    }
}

#[test]
fn fibo_planning_and_execution_requests_keep_the_image_family_and_masks() {
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.model_type = "fibo2".into();
    configuration.attention = "flash2";
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    for mask in 0..3 {
        let mut request: GenerationRequest = serde_json::from_value(serde_json::json!({
            "jobId":"fibo", "prompt":"Make the object blue", "stillImage":true, "frames":1, "steps":4, "seed":1,
            "canvasWidth":64, "canvasHeight":96,
            "imageEdit":{"sourceRelativePath":"source.png", "edits":[{
                "prompt":"Make the object blue", "x":0, "y":0, "width":64, "height":96, "feather":0
            }]}
        })).unwrap();
        if mask == 1 {
            request.image_edit.as_mut().unwrap().edits[0].mask_polygon = Some(vec![
                crate::image_mask::MaskPoint { x: 0.0, y: 0.0 },
                crate::image_mask::MaskPoint { x: 32.0, y: 0.0 },
                crate::image_mask::MaskPoint { x: 0.0, y: 32.0 },
            ]);
        }
        if mask == 2 {
            let contours = vec![(0.0, 0.0, 64.0, 96.0), (16.0, 24.0, 48.0, 72.0)].into_iter()
                .map(|(x, y, right, bottom)| vec![(x,y), (right,y), (right,bottom), (x,bottom)].into_iter()
                    .map(|(x,y)| crate::image_mask::MaskPoint { x, y }).collect()).collect::<Vec<_>>();
            let coverage = crate::image_mask::rasterize_contours(&contours, 64, 96).unwrap();
            for y in 0..96 { for x in 0..64 {
                assert_eq!(coverage[y * 64 + x], if (16..48).contains(&x) && (24..72).contains(&y) { 0 } else { 255 });
            }}
            request.image_edit.as_mut().unwrap().edits[0].mask_contours = Some(contours);
        }
        request.image_edit_pixels = Some(std::sync::Arc::new(vec![100; 64 * 96 * 3]));
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            let handle = RequestHandle::new(&api).unwrap();
            configure_request(&api, &handle, &request, &configuration, ComputePlatform::Cuda13, purpose, &ReferenceVideos::default()).unwrap();
            let plan = api.resolve(&handle).unwrap();
            assert_eq!((plan.canvas_width, plan.canvas_height, plan.aligned_frames, plan.num_model_evaluations), (64, 96, 1, 4));
            let description = api.describe(&handle).unwrap();
            assert!(description.contains("Fibo"), "{description}");
            assert!(configure_request(&api, &handle, &request, &configuration, ComputePlatform::Vulkan, purpose, &ReferenceVideos::default()).unwrap_err().contains("requires CUDA"));
        }
    }
}

#[test]
fn fibo_validates_image_inputs_and_rejects_unsupported_h3_controls() {
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.model_type = "fibo2".into();
    configuration.attention = "flash2";
    let mut request = GenerationRequest { still_image: true, frames: 1, steps: 4, prompt: "Make it blue".into(), canvas_width: 512, canvas_height: 512, ..Default::default() };
    configuration.validate_inputs(&request).unwrap();
    request.reference_paths = vec!["image.png".into(); 4];
    configuration.validate_inputs(&request).unwrap();
    request.reference_paths.push("extra.png".into());
    assert!(configuration.validate_inputs(&request).unwrap_err().contains("at most 4"));
    request.reference_paths.truncate(1);
    for (name, value, message) in [
        ("guidanceScale", serde_json::json!(3), "CFG"),
        ("generationEffects", serde_json::json!({"sharpness":{"strength":1}}), "generation effects"),
        ("stillImage", serde_json::json!(false), "video generation"),
        ("videoSigmaShift", serde_json::json!(3), "sampling schedule"),
        ("latentUpscale", serde_json::json!(true), "latent features"),
    ] {
        let mut json = serde_json::to_value(&request).unwrap();
        json[name] = value;
        let invalid = serde_json::from_value(json).unwrap();
        assert!(configuration.validate_inputs(&invalid).unwrap_err().contains(message), "{name}");
    }
    request.image_edit = Some(serde_json::from_value(serde_json::json!({"sourceRelativePath":"source.png", "edits":[{
        "prompt":"Make it blue", "x":0, "y":0, "width":512, "height":512
    }]})).unwrap());
    assert!(configuration.validate_inputs(&request).unwrap_err().contains("without additional image references"));
    request.reference_paths.clear();
    configuration.validate_inputs(&request).unwrap();
    request.image_edit.as_mut().unwrap().edits[0].invert_mask = true;
    assert!(configuration.validate_inputs(&request).unwrap_err().contains("outpainting"));
}

#[test]
fn negative_prompts_reach_moss_and_are_rejected_for_other_models() {
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.model_type = "moss".into();
    configuration.attention = "flash2";
    let request = GenerationRequest { still_image: true, frames: 1, steps: 4, prompt: "A red apple".into(),
        negative_prompt: Some("watermark, blurry details".into()), canvas_width: 512, canvas_height: 512, ..Default::default() };
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
        let handle = RequestHandle::new(&api).unwrap();
        configure_request(&api, &handle, &request, &configuration, ComputePlatform::Cuda13, purpose, &ReferenceVideos::default()).unwrap();
        api.resolve(&handle).unwrap();
        assert!(api.set_image_guidance(&handle, 3.0, "invalid\0prompt").unwrap_err().contains("null characters"));
    }
    for model in ["fibo2", "minimax-h3"] {
        configuration.model_type = model.into();
        assert!(configuration.validate_inputs(&request).unwrap_err().contains("does not support negative prompts"));
    }
}

#[test]
fn fibo_text_only_requests_resolve_without_source_images() {
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.model_type = "fibo2".into();
    configuration.attention = "flash2";
    let api = ffi::Api::load(&configuration.dll_path).unwrap();
    let request = GenerationRequest { still_image: true, frames: 1, steps: 4, prompt: "A blue vase".into(),
        canvas_width: 256, canvas_height: 384, ..Default::default() };
    for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
        let handle = RequestHandle::new(&api).unwrap();
        configure_request(&api, &handle, &request, &configuration, ComputePlatform::Cuda13, purpose, &ReferenceVideos::default()).unwrap();
        let plan = api.resolve(&handle).unwrap();
        assert_eq!((plan.canvas_width, plan.canvas_height, plan.aligned_frames, plan.num_model_evaluations), (256, 384, 1, 4));
    }
}

#[test]
fn template_editing_flag_is_enforced_without_blocking_text_generation() {
    let mut settings: BTreeMap<String, ProviderSetting> = serde_json::from_value(serde_json::json!({
        "slopfab": {"enabled":true, "model":null, "options":{"modelType":"fibo2", "attention":"flash2", "editingModel":false}}
    })).unwrap();
    let configuration = Configuration::from_settings(&settings);
    let mut request = GenerationRequest { still_image: true, frames: 1, steps: 4, prompt: "A forest".into(), canvas_width: 64, canvas_height: 96, ..Default::default() };
    configuration.validate_inputs(&request).unwrap();
    request.image_edit = Some(serde_json::from_value(serde_json::json!({"sourceRelativePath":"source.png", "edits":[{
        "prompt":"Make it blue", "x":0, "y":0, "width":64, "height":96
    }]})).unwrap());
    assert!(configuration.validate_inputs(&request).unwrap_err().contains("does not support image editing"));
    settings.get_mut("slopfab").unwrap().options.insert("editingModel".into(), crate::settings::ProviderOption::Boolean(true));
    Configuration::from_settings(&settings).validate_inputs(&request).unwrap();
    settings.get_mut("slopfab").unwrap().options.remove("editingModel");
    Configuration::from_settings(&settings).validate_inputs(&request).unwrap();
}

#[test]
fn h3_image_plans_six_steps_on_cuda_and_vulkan_with_masked_edits_and_outpainting() {
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.model_type = "h3_image".into();
    configuration.attention = "flash2";
    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(super::DLL_FILE_NAME);
    let api = ffi::Api::load(&path).unwrap();
    let request = GenerationRequest { still_image: true, frames: 1, steps: 6, prompt: "A blue teapot".into(),
        canvas_width: 128, canvas_height: 128, ..Default::default() };
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        for purpose in [RequestPurpose::Plan, RequestPurpose::Generate] {
            for mode in ["generate", "references", "mask", "outpaint"] {
                let mut request = request.clone();
                if mode == "references" {
                    request.reference_paths = vec!["reference.png".into(); 16];
                } else if mode != "generate" {
                    request.image_edit = Some(serde_json::from_value(serde_json::json!({"sourceRelativePath":"source.png", "edits":[{
                        "prompt":"Edit <Picture 1>. Make it blue", "x":32, "y":32, "width":64, "height":64,
                        "invertMask": mode == "outpaint", "feather": 0
                    }]})).unwrap());
                    request.image_edit_pixels = Some(vec![128; 128 * 128 * 3].into());
                }
                let handle = RequestHandle::new(&api).unwrap();
                let blank = configure_request(&api, &handle, &request, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap();
                let plan = api.resolve(&handle).unwrap();
                assert_eq!((plan.canvas_width, plan.canvas_height, plan.aligned_frames, plan.num_model_evaluations), (128, 128, 1, 6));
                assert_eq!(blank.is_some(), mode == "generate");
                let description = api.describe(&handle).unwrap();
                let conditioning = match mode {
                    "generate" => "image editing (1 references)",
                    "references" => "image editing (16 references)",
                    _ => "pictures    1\n",
                };
                assert!(description.contains(conditioning), "{description}");
                if let Some(blank) = blank {
                    let path = blank.to_path_buf();
                    let bytes = std::fs::read(&path).unwrap();
                    assert!(bytes.starts_with(b"P6\n64 64\n255\n"));
                    assert_eq!(&bytes[b"P6\n64 64\n255\n".len()..], &[255; 64 * 64 * 3]);
                    // Automatic conditioning must match a manually supplied
                    // blank reference, including the unchanged text prompt.
                    let mut manual = request.clone();
                    manual.reference_paths.push(path.to_string_lossy().into_owned());
                    let manual_handle = RequestHandle::new(&api).unwrap();
                    assert!(configure_request(&api, &manual_handle, &manual, &configuration, platform, purpose, &ReferenceVideos::default()).unwrap().is_none());
                    assert_eq!(api.describe(&manual_handle).unwrap(), description);
                    drop(blank);
                    assert!(!path.exists());
                }
            }
        }
    }
}

#[test]
fn h3_image_rejects_incompatible_controls_and_counts_the_edit_source() {
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.model_type = "h3_image".into();
    configuration.attention = "flash2";
    let request = GenerationRequest { still_image: true, frames: 1, steps: 6, prompt: "A blue teapot".into(),
        canvas_width: 128, canvas_height: 128, reference_paths: vec!["picture.png".into(); 16], ..Default::default() };
    configuration.validate_inputs(&request).unwrap();
    for (name, value, message) in [
        ("steps", serde_json::json!(20), "six-step"),
        ("guidanceScale", serde_json::json!(3), "CFG"),
        ("negativePrompt", serde_json::json!("blurry"), "negative prompts"),
        ("stillImage", serde_json::json!(false), "video generation"),
        ("videoSigmaShift", serde_json::json!(3), "sampling schedule"),
        ("latentUpscale", serde_json::json!(true), "latent features"),
    ] {
        let mut json = serde_json::to_value(&request).unwrap();
        json[name] = value;
        assert!(configuration.validate_inputs(&serde_json::from_value(json).unwrap()).unwrap_err().contains(message), "{name}");
    }
    let mut request = request;
    request.image_edit = Some(serde_json::from_value(serde_json::json!({"sourceRelativePath":"source.png", "edits":[{
        "prompt":"Edit <Picture 1>", "x":0, "y":0, "width":128, "height":128
    }]})).unwrap());
    assert!(configuration.validate_inputs(&request).unwrap_err().contains("including the edit source"));
    request.reference_paths.pop();
    configuration.validate_inputs(&request).unwrap();
    request.image_edit.as_mut().unwrap().edits[0].strength = Some(0.65);
    assert!(configuration.validate_inputs(&request).unwrap_err().contains("strength 1"));
    request.image_edit.as_mut().unwrap().edits[0].strength = None;
    request.image_edit.as_mut().unwrap().edits[0].outpaint_langevin_steps = Some(5);
    assert!(configuration.validate_inputs(&request).unwrap_err().contains("zero Langevin"));
}

#[test]
fn h3_image_supports_twenty_mipixel_canvases() {
    let mut configuration = Configuration::from_settings(&BTreeMap::new());
    configuration.model_type = "h3_image".into();
    configuration.attention = "flash2";
    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(super::DLL_FILE_NAME);
    let api = ffi::Api::load(&path).unwrap();
    for platform in [ComputePlatform::Cuda13, ComputePlatform::Vulkan] {
        for (width, height, valid) in [(5120, 4096, true), (4096, 5120, true), (4480, 4480, true), (5120, 4128, false)] {
            let request = GenerationRequest { still_image: true, frames: 1, steps: 6, prompt: "A landscape".into(),
                canvas_width: width, canvas_height: height, ..Default::default() };
            let handle = RequestHandle::new(&api).unwrap();
            let _blank_reference = configure_request(&api, &handle, &request, &configuration, platform, RequestPurpose::Plan, &ReferenceVideos::default()).unwrap();
            if valid {
                let plan = api.resolve(&handle).unwrap();
                assert_eq!((plan.canvas_width, plan.canvas_height, plan.aligned_frames, plan.num_model_evaluations), (width, height, 1, 6));
            } else {
                assert!(api.resolve(&handle).err().unwrap().contains("20 Mi-pixels"));
            }
        }
    }
}