AI media harness for planning, generating, and editing locally
TypeScript
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"));
}
}
}
}