Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

26.3 KB
Raw Blame
use super::*;
fn subject() -> Session {
    let mut s = Session::default();
    s.execute("solid.box", &json!({"length":20,"width":15,"height":10,"body_name":"Subject"})).unwrap();
    s.execute(
        "render.settings.set",
        &json!({"name":"Shot","set":{"width":96,"height":64,
        "job":{"method":"gpu_path","options":{"samples":37,"max_depth":7,"seed":91}}}}),
    )
    .unwrap();
    s
}
#[cfg(feature = "bundled-render-library")]
#[test]
fn native_studios_resolve_without_mutation_and_apply_one_complete_undo() {
    let entries = super::entries();
    let entries = entries.as_array().unwrap();
    assert!(!entries.is_empty());
    let mut ids = std::collections::BTreeSet::new();
    let hdrs: std::collections::BTreeSet<_> = entries.iter().map(|item| item["hdr"].as_str().unwrap()).collect();
    assert!(hdrs.len() >= 24, "every authored HDR has a complete curated composition");
    for entry in entries {
        let id = entry["id"].as_str().unwrap();
        assert!(!id.is_empty() && ids.insert(id));
        let mut s = subject();
        let before = s.doc.to_json();
        let undo = s.undo.len();
        let old = s.doc.render.setups["Shot"].clone();
        let revision = s.revision;
        let plan = s.execute("render.preset.resolve", &json!({"id":id,"name":"Shot","expected_revision":revision})).unwrap();
        assert_eq!(plan["document_changed"], false);
        assert_eq!(s.doc.to_json(), before);
        assert_eq!(s.undo.len(), undo);
        let request = json!({"id":id,"name":"Shot","expected_revision":revision,"replace_lighting_and_environment":true});
        let applied = s.execute("render.preset.apply", &request).unwrap();
        assert_eq!(applied["document_changed"], true);
        assert_eq!(s.undo.len(), undo + 1);
        let saved = &s.doc.render.setups["Shot"];
        assert_eq!((saved.width, saved.height, saved.camera), (old.width, old.height, old.camera));
        let Some(RenderJob::GpuPath { options, .. }) = &saved.job else { panic!("explicit GPU intent lost") };
        assert_eq!((options.samples, options.max_depth, options.seed), (37, 7, 91));
        assert!(options.hdr.is_some());
        assert!(!saved.stage.is_empty());
        assert_eq!(s.doc.features.len(), 1);
        assert!(s.doc.materials.is_empty());
        let reopened = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
        assert_eq!(reopened.render.setups["Shot"], *saved);
        s.execute("edit.undo", &json!({})).unwrap();
        assert_eq!(s.doc.to_json(), before);
    }
}
#[test]
fn native_studio_refusals_are_atomic_and_never_silently_replace_resources() {
    let mut s = subject();
    let revision = s.revision;
    let before = s.doc.to_json();
    for request in [
        json!({"id":"SCENE-001","name":"Shot","expected_revision":revision,"replace_lighting_and_environment":true}),
        json!({"id":"NATIVE-STUDIO-001","name":"Shot","expected_revision":revision}),
        json!({"id":"NATIVE-STUDIO-001","name":"Shot","replace_lighting_and_environment":true}),
        json!({"id":"NATIVE-STUDIO-001","name":"Shot","expected_revision":revision+1,"replace_lighting_and_environment":true}),
        json!({"id":"NATIVE-STUDIO-001","name":"Shot","expected_revision":revision,"replace_lighting_and_environment":true,"set":{"job":{"method":"raster"}}}),
    ] {
        assert!(s.execute("render.preset.apply", &request).is_err());
        assert_eq!(s.doc.to_json(), before);
    }
    s.execute("render.stage.ground", &json!({"name":"Shot"})).unwrap();
    let before = s.doc.to_json();
    let revision = s.revision;
    assert!(
        s.execute(
            "render.preset.apply",
            &json!({"id":"NATIVE-STUDIO-001","name":"Shot","expected_revision":revision,
        "set":{"stage":[]},"replace_lighting_and_environment":true})
        )
        .is_err()
    );
    assert_eq!(s.doc.to_json(), before);
    let mut empty = Session::default();
    assert!(
        empty
            .execute("render.preset.resolve", &json!({"id":"NATIVE-STUDIO-001","name":"E","set":{"job":{"method":"gpu_path","options":{}}}}))
            .is_err()
    );
}
#[test]
fn saved_shot_commands_preserve_exact_resources_reject_collisions_and_undo() {
    let mut s = subject();
    let before = s.doc.to_json();
    let revision = s.revision;
    s.execute("render.shot.duplicate", &json!({"name":"Shot","new_name":"Copy","expected_revision":revision})).unwrap();
    assert_eq!(s.doc.render.setups["Shot"], s.doc.render.setups["Copy"]);
    let duplicated = s.doc.to_json();
    for (command, p) in [
        ("render.shot.duplicate", json!({"name":"Shot","new_name":"Copy","expected_revision":s.revision})),
        ("render.shot.rename", json!({"name":"Shot","new_name":"Copy","expected_revision":s.revision})),
        ("render.shot.remove", json!({"name":"Shot","expected_revision":revision})),
        ("render.shot.remove", json!({"name":"Shot","new_name":"other","expected_revision":s.revision})),
        ("render.shot.duplicate", json!({"name":"Shot","new_name":"x".repeat(129),"expected_revision":s.revision})),
    ] {
        assert!(s.execute(command, &p).is_err());
        assert_eq!(s.doc.to_json(), duplicated);
    }
    s.execute("edit.undo", &json!({})).unwrap();
    assert_eq!(s.doc.to_json(), before);
    s.execute("render.shot.rename", &json!({"name":"Shot","new_name":"Renamed","expected_revision":s.revision})).unwrap();
    assert!(!s.doc.render.setups.contains_key("Shot"));
    assert!(s.doc.render.setups.contains_key("Renamed"));
    s.execute("render.shot.remove", &json!({"name":"Renamed","expected_revision":s.revision})).unwrap();
    assert!(s.doc.render.setups.is_empty());
    s.execute("edit.undo", &json!({})).unwrap();
    assert!(s.doc.render.setups.contains_key("Renamed"));
}
#[test]
fn quality_projection_never_claims_adaptive_or_unbounded_profiles() {
    let mut s = subject();
    let before = s.doc.to_json();
    for id in ["Q-001", "Q-002", "Q-003"] {
        let plan = s.execute("render.quality.prepare", &json!({"id":id,"variant":"fixed_samples_png","acknowledge_omissions":true})).unwrap();
        assert_eq!(plan["document_changed"], false);
        assert_eq!(plan["status"], "fixed_budget_projection_not_full_quality_profile");
        assert!(plan["omitted"].as_array().unwrap().iter().any(|v| v == "adaptive_stopping_and_error_target"));
        assert!(plan["gpu_options"]["samples"].as_u64().unwrap() <= 4096);
        assert_eq!(s.doc.to_json(), before);
    }
    for id in ["Q-004", "Q-005", "Q-006", "Q-007", "Q-008", "Q-009", "Q-010", "missing"] {
        assert!(s.execute("render.quality.prepare", &json!({"id":id,"variant":"fixed_samples_png","acknowledge_omissions":true})).is_err());
    }
    assert!(s.execute("render.quality.prepare", &json!({"id":"Q-002","variant":"full","acknowledge_omissions":true})).is_err());
    assert!(s.execute("render.quality.prepare", &json!({"id":"Q-002","variant":"fixed_samples_png","acknowledge_omissions":false})).is_err());
    assert_eq!(s.doc.to_json(), before);
}
#[cfg(feature = "bundled-render-library")]
#[test]
fn resource_availability_and_original_previews_are_bounded_and_nonmutating() {
    let mut s = subject();
    let before = s.doc.to_json();
    assert_eq!(s.execute("render.library.list", &json!({"kind":"native_scenes","availability":"usable"})).unwrap()["total"], 25);
    assert_eq!(s.execute("render.library.list", &json!({"kind":"materials","availability":"usable"})).unwrap()["total"], 0);
    assert_eq!(s.execute("render.library.list", &json!({"kind":"materials","availability":"specification"})).unwrap()["total"], 600);
    assert_eq!(s.execute("render.library.list", &json!({"kind":"selene_shots"})).unwrap()["total"], 12);
    assert!(s.execute("render.library.list", &json!({"availability":"invented"})).is_err());
    let preview = s.execute("render.library.preview", &json!({"id":"SURF-001"})).unwrap();
    let bytes: Vec<u8> = serde_json::from_value(preview["bytes"].clone()).unwrap();
    assert!(bytes.starts_with(b"\x89PNG\r\n\x1a\n"));
    assert_eq!(preview["sha256"], json!(solidcraft_doc::render_resources::HdrId::of(&bytes)));
    assert_eq!(preview["fidelity"], "authored_base_color_source_map_not_a_render");
    for id in ["../SURF-001", "HDR-001", "MAT-001", "SURF-999"] {
        assert!(s.execute("render.library.preview", &json!({"id":id})).is_err());
    }
    let targets = s.execute("render.library.targets", &json!({"query":"Subject"})).unwrap();
    assert_eq!(targets["items"][0]["name"], "Subject");
    assert_eq!(targets["items"][0]["opacity"], 1.0);
    assert_eq!(s.doc.to_json(), before);
}

#[test]
fn physical_backgrounds_preserve_geometry_lights_camera_and_one_undo() {
    for kind in ["floor_wall", "cyclorama"] {
        let mut s = subject();
        let before = s.doc.to_json();
        let undo = s.undo.len();
        let setup = s.doc.render.setups["Shot"].clone();
        let p = json!({"name":"Shot","kind":kind,"expected_revision":s.revision,"reflectance_linear":[0.31,0.29,0.25]});
        let result = s.execute("render.stage.backdrop", &p).unwrap();
        assert_eq!(result["engineering_geometry_unchanged"], true);
        let after = &s.doc.render.setups["Shot"];
        assert_eq!(after.camera, setup.camera);
        assert_eq!(after.job, setup.job);
        assert_eq!(after.surfaces, setup.surfaces);
        assert_eq!(after.stage.iter().count(), if kind == "cyclorama" { 26 } else { 2 });
        assert_eq!(s.doc.features.len(), 1);
        assert_eq!(s.undo.len(), undo + 1);
        let mut scene = crate::product_scene::extract(&s).unwrap();
        let first = scene.meshes[0].mesh.clone();
        super::super::staging::apply(&mut scene, after, "test").unwrap();
        assert!(Arc::ptr_eq(&first, &scene.meshes[0].mesh));
        assert_eq!(scene.meshes.len(), 1 + after.stage.iter().count());
        let reopened = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
        assert_eq!(&reopened.render.setups["Shot"], after);
        let snapshot = s.doc.to_json();
        assert!(s.execute("render.stage.backdrop", &json!({"name":"Shot","kind":kind,"expected_revision":s.revision,"set":{"stage":[]}})).is_err());
        assert_eq!(s.doc.to_json(), snapshot);
        s.execute("edit.undo", &json!({})).unwrap();
        assert_eq!(s.doc.to_json(), before);
    }
}

#[test]
fn finishing_and_linear_master_saved_intent_survive_reopen_without_host_and_reject_conflicts() {
    let mut s = subject();
    let before = s.doc.to_json();
    let job = json!({"method":"gpu_path","options":{"samples":37,"linear_exr":true,
        "finishing":{"rgb_gain":[1.2,0.9,0.7],"saturation":0.75,"contrast":1.2,"vignette":0.2},
        "backdrop":{"mode":"radial","first_srgb":[230,220,200],"second_srgb":[25,35,45],"center":[0.4,0.3],"radius":0.8}}});
    s.execute("render.settings.set", &json!({"name":"Shot","set":{"job":job}})).unwrap();
    let after = s.doc.to_json();
    let reopened = solidcraft_doc::Document::from_json(&after).unwrap();
    assert_eq!(reopened.render, s.doc.render);
    for patch in [
        json!({"job":{"method":"gpu_path","transparent_background":true,"options":job["options"]}}),
        json!({"job":{"method":"gpu_path","options":{"finishing":{"saturation":-1}}}}),
        json!({"job":{"method":"gpu_path","options":{"backdrop":{"radius":0}}}}),
        json!({"job":{"method":"cpu_raytrace","options":{"linear_exr":true}}}),
        json!({"job":{"method":"gpu_path","options":{"adaptive_samples":true}}}),
    ] {
        assert!(s.execute("render.settings.set", &json!({"name":"Shot","set":patch})).is_err());
        assert_eq!(s.doc.to_json(), after);
    }
    s.execute("edit.undo", &json!({})).unwrap();
    assert_eq!(s.doc.to_json(), before);
}

#[test]
fn cpu_quality_projects_exact_catalog_costs_with_existing_admissible_profiles_without_mutation() {
    use solidcraft_render::job::{CpuBudget, CpuProgressiveOptions};
    let mut s = subject();
    let before = s.doc.clone();
    let history = (s.revision, s.undo.len(), s.redo.len());
    for (id, width, height, samples, profile) in
        [("Q-001", 960, 540, 16, CpuBudget::Compact), ("Q-002", 1600, 900, 32, CpuBudget::Studio), ("Q-003", 2560, 1440, 64, CpuBudget::Studio)]
    {
        let plan = s.execute("render.quality.prepare", &json!({"id":id,"variant":"cpu_progressive_png","acknowledge_omissions":true})).unwrap();
        assert_eq!(plan["settings"], json!({"width":width,"height":height}));
        assert_eq!(plan["cpu_options"], json!({"budget":profile,"progressive":{"samples_per_pixel":samples,"seed":21026}}));
        assert_eq!(plan["changed_fields"], json!(["width", "height", "progressive.samples_per_pixel", "progressive.seed", "budget"]));
        assert!(plan.get("gpu_options").is_none());
        assert!(plan["cpu_options"].get("path").is_none());
        assert!(plan["cpu_options"].get("denoise").is_none());
        assert_eq!(plan["status"], "cpu_cost_budget_projection_not_full_quality_profile");
        assert_eq!(plan["document_changed"], false);
        let pixels = u64::from(width) * u64::from(height);
        assert!(pixels * u64::from(samples) <= profile.limits().max_camera_samples);
        profile.validate_image(width, height, Some(CpuProgressiveOptions { samples_per_pixel: samples, seed: 21026 })).unwrap();
        for larger in [CpuBudget::Studio, CpuBudget::Workstation] {
            let kept = s
                .execute(
                    "render.quality.prepare",
                    &json!({"id":id,"variant":"cpu_progressive_png","acknowledge_omissions":true,"cpu":{"minimum_budget":larger}}),
                )
                .unwrap();
            assert_eq!(kept["cpu_options"]["budget"], json!(larger), "an explicitly chosen larger profile must not be lowered");
        }
        assert!(Arc::ptr_eq(&before, &s.doc));
        assert_eq!(history, (s.revision, s.undo.len(), s.redo.len()));
    }
    let pilot = s
        .execute(
            "render.quality.prepare",
            &json!({"id":"Q-001","variant":"cpu_progressive_png","acknowledge_omissions":true,
        "cpu":{"adaptive":{"pilot_samples":256,"min_samples":16}}}),
        )
        .unwrap();
    assert_eq!(pilot["cpu_options"]["budget"], "studio", "Draft must budget272total passes, not hide pilots outside Compact64");
    let first_pixels = 960_u64 * 540;
    assert!(first_pixels * 272 < CpuBudget::Studio.limits().max_camera_samples);
    assert!(Arc::ptr_eq(&before, &s.doc));
    assert_eq!(history, (s.revision, s.undo.len(), s.redo.len()));
}

#[test]
fn cpu_quality_rejects_unbound_ids_hostile_context_and_incompatible_adaptive_without_silent_substitution() {
    let mut s = subject();
    let doc = s.doc.clone();
    let before = (s.revision, s.undo.len(), s.redo.len());
    for value in [
        json!({"id":"Q-004","variant":"cpu_progressive_png","acknowledge_omissions":true}),
        json!({"id":"Q-999","variant":"cpu_progressive_png","acknowledge_omissions":true}),
        json!({"id":"Q-001","variant":"cpu_progressive_png","acknowledge_omissions":false}),
        json!({"id":"Q-001","variant":"cpu_progressive_png","acknowledge_omissions":true,"cpu":{"minimum_budget":"unlimited"}}),
        json!({"id":"Q-001","variant":"cpu_progressive_png","acknowledge_omissions":true,"cpu":{"enable_gi":true}}),
        json!({"id":"Q-001","variant":"fixed_samples_png","acknowledge_omissions":true,"cpu":{}}),
        json!({"id":"Q-001","variant":"cpu_progressive_png","acknowledge_omissions":true,"cpu":{"adaptive":{"pilot_samples":16,"min_samples":32}}}),
        json!({"id":"Q-003","variant":"cpu_progressive_png","acknowledge_omissions":true,"cpu":{"adaptive":{"pilot_samples":16,"min_samples":128}}}),
    ] {
        assert!(s.execute("render.quality.prepare", &value).is_err(), "{value}");
        assert!(Arc::ptr_eq(&doc, &s.doc));
        assert_eq!(before, (s.revision, s.undo.len(), s.redo.len()));
    }
}

#[cfg(feature = "bundled-render-library")]
#[test]
fn cpu_native_studios_preserve_full_job_and_exact_hdr_rig_authority_for_all_twenty_five() {
    use solidcraft_doc::render_settings::CpuJob;
    use solidcraft_render::job::{CpuBudget, CpuPathOptions, CpuProgressiveOptions, ThinLens, adaptive::AdaptiveSampling};
    for entry in entries().as_array().unwrap() {
        let id = entry["id"].as_str().unwrap();
        let mut s = Session::default();
        s.execute("solid.box", &json!({"length":20,"width":15,"height":10,"body_name":"Subject"})).unwrap();
        let camera = solidcraft_render::Camera { fov: 0.5, ..Default::default() };
        let options = CpuJob {
            budget: CpuBudget::Studio,
            progressive: Some(CpuProgressiveOptions { samples_per_pixel: 64, seed: 947 }),
            adaptive: Some(AdaptiveSampling::default()),
            path: Some(CpuPathOptions { max_depth: 5 }),
            denoise: true,
            lens: Some(ThinLens { aperture_radius_mm: 0.2, focus_distance_mm: 100.0 }),
            output: Some(Box::new(solidcraft_render::job::OutputOptions { linear_exr: true, ..Default::default() })),
            area_samples: Some(64),
            seed: Some(731),
            volume: Some(solidcraft_render::job::volume::HomogeneousVolume { extinction_per_mm: 0.0, ..Default::default() }),
            ..Default::default()
        };
        s.execute("render.settings.set", &json!({"name":"Shot","set":{"width":96,"height":64,"camera":camera,"job":{"method":"cpu_raytrace","transparent_background":true,"options":options}}})).unwrap();
        s.execute("render.library.environment.apply", &json!({"id":"HDR-001","name":"Shot","samples":64})).unwrap();
        let before = s.doc.clone();
        let undo = s.undo.len();
        let revision = s.revision;
        let old = s.doc.render.setups["Shot"].clone();
        let plan = s.execute("render.preset.resolve", &json!({"id":id,"name":"Shot","expected_revision":revision})).unwrap();
        assert!(Arc::ptr_eq(&s.doc, &before));
        assert_eq!(s.undo.len(), undo);
        assert_eq!(plan["executor"], "cpu-raytrace");
        let applied = s
            .execute("render.preset.apply", &json!({"id":id,"name":"Shot","expected_revision":revision,"replace_lighting_and_environment":true}))
            .unwrap();
        assert_eq!(s.undo.len(), undo + 1);
        assert_eq!(applied["setup"], plan["setup"]);
        let saved = &s.doc.render.setups["Shot"];
        assert_eq!((saved.camera, saved.width, saved.height), (old.camera, old.width, old.height));
        assert_eq!((&saved.optics, &saved.coats, &saved.surfaces), (&old.optics, &old.coats, &old.surfaces));
        let Some(RenderJob::CpuRaytrace { options, transparent_background }) = &saved.job else { panic!("CPU method lost") };
        assert!(*transparent_background);
        let Some(RenderJob::CpuRaytrace { options: old_options, .. }) = &old.job else {
            panic!("the captured original setup must retain its CPU method")
        };
        let mut expected = (**old_options).clone();
        expected.preset = None;
        expected.lights = Some(vec![]);
        expected.punctual_lights = Some(vec![]);
        expected.environment = None;
        expected.sky = None;
        expected.sun = None;
        expected.hdr = Some(CpuHdrEnvironment {
            resource: serde_json::from_value(plan["resource_sha256"].clone()).unwrap(),
            rotation_rad: 0.35 + std::f64::consts::PI,
            intensity: entry["intensity"].as_f64().unwrap(),
            samples: 64,
        });
        expected.area_lights = Some(vec![]);
        if entry["rig"] == "RIG-002" {
            let bounds = crate::product_scene::extract(&s).unwrap().bounds;
            let size = bounds.max - bounds.min;
            let c = bounds.center();
            let (lighting, _) = super::super::library::rig_lighting(
                &super::super::library::RigInput {
                    id: "RIG-002".into(),
                    variant: "complete".into(),
                    center_mm: [c.x, c.y, c.z],
                    subject_extent_mm: size.x.max(size.y).max(size.z),
                },
                "test",
            )
            .unwrap();
            expected.area_lights = Some(
                lighting
                    .area_lights
                    .iter()
                    .map(|light| solidcraft_render::job::RectangleLightOptions {
                        center_mm: light.center,
                        edge_u_mm: light.u.map(|x| x * 2.0),
                        edge_v_mm: light.v.map(|x| x * 2.0),
                        color: [1.0; 3],
                        intensity: light.radiance[0] / 16.0,
                    })
                    .collect(),
            );
            assert_eq!(expected.area_lights.as_ref().unwrap().iter().map(|a| a.intensity).fold(0.0, f64::max), 29.691586369625);
        }
        assert_eq!(**options, expected, "all unrelated CPU intent survives {id}");
        let hdr = options.hdr.unwrap();
        assert_eq!(
            s.doc.render.resources.required(&hdr.resource).unwrap().bytes(),
            super::super::library_data::asset(entry["hdr"].as_str().unwrap()).unwrap().0
        );
        assert_eq!(s.doc.features, before.features);
        assert_eq!(s.doc.materials, before.materials);
        let saved_json = s.doc.to_json();
        let reopened = solidcraft_doc::Document::from_json(&saved_json).unwrap();
        assert_eq!(reopened.render.setups["Shot"], *saved);
        s.execute("edit.undo", &json!({})).unwrap();
        assert_eq!(s.doc, before);
        s.execute("edit.redo", &json!({})).unwrap();
        assert_eq!(s.doc.to_json(), saved_json);
    }
}

#[cfg(all(feature = "bundled-render-library", feature = "raytrace-cpu", not(target_arch = "wasm32")))]
#[test]
fn cpu_native_studio_cold_capture_matches_typed_source_every_prefix_and_raw_master() {
    use solidcraft_render::job::{CancelToken, CpuHost, ImageRequest, Integrator, JobId, Phase};
    use solidcraft_render::lighting::environment_input::EnvironmentInput;
    use solidcraft_render::raytrace::image::{ImagePoll, ImageTask};
    for id in ["NATIVE-STUDIO-001", "NATIVE-STUDIO-004", "RIG-020"] {
        let mut s = Session::default();
        s.execute("solid.box", &json!({"length":20,"width":15,"height":10,"body_name":"Subject"})).unwrap();
        let camera = solidcraft_render::Camera { target: solidcore_record::Vec3::new(10.0, 7.5, 5.0), distance: 35.0, ..Default::default() };
        s.execute("render.settings.set",&json!({"name":"Shot","set":{"width":8,"height":8,"camera":camera,"job":{"method":"cpu_raytrace","options":{"progressive":{"samples_per_pixel":3,"seed":47},"area_samples":1,"seed":731,"output":{"linear_exr":true}}}}})).unwrap();
        s.execute("render.library.environment.apply", &json!({"id":"HDR-001","name":"Shot","samples":1})).unwrap();
        if id == "RIG-020" {
            s.execute("render.library.studio.apply", &json!({"name":"Shot","rig":{"id":id,"variant":"complete","center_mm":[10,7.5,5],"subject_extent_mm":20},"expected_revision":s.revision,"replace_lighting_and_environment":true,"enable_indirect":true})).unwrap();
        } else {
            s.execute("render.preset.apply", &json!({"id":id,"name":"Shot","expected_revision":s.revision,"replace_lighting_and_environment":true}))
                .unwrap();
        }
        let bytes = solidcraft_io::write_design_container(&s.doc).unwrap();
        s = Session::new(solidcraft_io::read_design(&bytes).unwrap());
        s.execute("render.scene", &json!({})).unwrap();
        let setup = s.doc.render.setups["Shot"].clone();
        let Some(RenderJob::CpuRaytrace { options, transparent_background }) = &setup.job else { panic!() };
        let hdr = options.hdr;
        if id == "RIG-020" {
            assert!(hdr.is_none());
            assert!(options.sun.is_some());
        } else {
            assert_eq!(hdr.unwrap().samples, 1);
        }
        let runtime = options.to_runtime(setup.exposure_ev).unwrap();
        let mut scene = crate::product_scene::extract(&s).unwrap();
        super::super::staging::apply(&mut scene, &setup, "test").unwrap();
        let render = |quantum| {
            let request = ImageRequest {
                integrator: Integrator::Raytrace,
                raytrace: Some(runtime.clone()),
                camera: setup.camera,
                width: setup.width,
                height: setup.height,
                background: setup.background,
                transparent_background: *transparent_background,
                studio_weights: None,
                environment: None,
                textures: None,
            };
            let input = hdr.map(|hdr| {
                EnvironmentInput::new(s.doc.render.resources.required(&hdr.resource).unwrap().source(), hdr.rotation_rad, hdr.intensity, hdr.samples)
                    .unwrap()
            });
            let mut task = ImageTask::new_with_environment(scene.clone(), request, CancelToken::default(), runtime.clone(), input).unwrap();
            let mut prefixes = Vec::new();
            for _ in 0..2_000_000 {
                match task.step_with_previews(quantum).unwrap() {
                    ImagePoll::Pending(_) => {}
                    ImagePoll::Preview { png, samples_per_pixel } => prefixes.push((samples_per_pixel, png)),
                    ImagePoll::Complete(png) => return (prefixes, png, task.take_linear_exr().unwrap()),
                }
            }
            panic!("bounded native studio source failed to finish")
        };
        let expected = render(1);
        assert_eq!(expected.0.iter().map(|(sample, _)| *sample).collect::<Vec<_>>(), [1, 2]);
        assert!(expected.0.iter().all(|(_, png)| png.starts_with(b"\x89PNG\r\n\x1a\n")));
        assert_eq!(expected, render(4096), "every complete prefix, final PNG and raw master is independent of work quantum");
        let host = CpuHost::for_platform().unwrap();
        s.set_render_job_host(Some(host)).unwrap();
        let doc = s.doc.clone();
        let history = (s.revision, s.undo.len(), s.redo.len());
        s.execute("render.preflight", &json!({"settings":setup})).unwrap();
        let reply = s.execute("render.start", &json!({"settings":setup})).unwrap();
        let job: JobId = serde_json::from_value(reply["job"].clone()).unwrap();
        let handle = s.render_job_handle(job).unwrap();
        let status = handle.wait_timeout(std::time::Duration::from_secs(60)).unwrap();
        assert_eq!(status.progress.phase, Phase::Completed, "{:?}", status.error);
        let frame = handle.frame().unwrap().unwrap();
        assert_eq!(frame.png(), expected.1.as_slice());
        assert_eq!(frame.linear_exr().unwrap(), expected.2.as_slice());
        assert!(Arc::ptr_eq(&doc, &s.doc));
        assert_eq!((s.revision, s.undo.len(), s.redo.len()), history);
    }
}