Skip to content

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

35.4 KB
Raw Blame
//! Transient Render view requests and explicit refusals for planned interactions.
use super::CommandSpec;
use crate::schema::render_lights::{MuteParams, SoloParams};
use crate::schema::{
    TypedContract, output_schema_for,
    render_ui::{BatchParams, BatchResult, CheckReport, CompareDivider, CompareParams, CompareSide, ResultIndex},
};
use crate::{Result, Session, params::bad};
use serde::Deserialize;
use serde_json::{Value, json};

const SOLO: crate::schema::TypedContract<SoloParams> = crate::schema::TypedContract::new();
const MUTE: crate::schema::TypedContract<MuteParams> = crate::schema::TypedContract::new();

fn solo(_: &mut crate::Session, params: &serde_json::Value) -> crate::Result<serde_json::Value> {
    let command = "render.lights.solo";
    if !params.is_object() {
        return Err(crate::params::bad(command, "expected an object"));
    }
    let input: SoloParams = serde_json::from_value(params.clone()).map_err(|e| crate::params::bad(command, e.to_string()))?;
    if input.solo && input.id.is_none() {
        return Err(crate::params::bad(command, "solo requires a light id"));
    }
    if let Some(id) = &input.id {
        crate::render_lights::parse_id(id).map_err(|e| crate::params::bad(command, e))?;
    }
    serde_json::to_value(input).map_err(|e| crate::params::bad(command, e.to_string()))
}

fn mute(_: &mut crate::Session, params: &serde_json::Value) -> crate::Result<serde_json::Value> {
    let command = "render.lights.mute";
    if !params.is_object() {
        return Err(crate::params::bad(command, "expected an object"));
    }
    let input: MuteParams = serde_json::from_value(params.clone()).map_err(|e| crate::params::bad(command, e.to_string()))?;
    crate::render_lights::parse_id(&input.id).map_err(|e| crate::params::bad(command, e))?;
    serde_json::to_value(input).map_err(|e| crate::params::bad(command, e.to_string()))
}
const RESULT_INDEX: TypedContract<ResultIndex> = TypedContract::new();
const COMPARE: TypedContract<CompareParams> = TypedContract::new();
const DIVIDER: TypedContract<CompareDivider> = TypedContract::new();
const BATCH: TypedContract<BatchParams> = TypedContract::new();

const CHECK_REPORT: TypedContract<CheckReport> = TypedContract::new();

pub static COMMANDS: &[CommandSpec] = &[
    CommandSpec::new("render.preflight.copy", "Copy Render Check Report", crate::checked!("render.preflight.copy", copy_check))
        .icon("copy")
        .contract(&CHECK_REPORT)
        .output(output_schema_for::<CheckReport>)
        .noundo()
        .doc_only()
        .params("text: nonempty report, at most 65536 bytes. Validated clipboard request; headless echo only, never renders or edits a design."),
    CommandSpec::new("render.result.select", "Select Render Result", crate::checked!("render.result.select", select_result))
        .icon("render_image").noundo().doc_only()
        .enabled(results_ready)
        .contract(&RESULT_INDEX).output(output_schema_for::<ResultIndex>)
        .params("index: integer 0..7, oldest first; must be retained. Selects a completed result as transient per-document view state; echoes index."),
    CommandSpec::new("render.result.discard", "Discard Render Result", crate::checked!("render.result.discard", discard_result))
        .icon("delete").noundo().doc_only()
        .enabled(results_ready)
        .contract(&RESULT_INDEX).output(output_schema_for::<ResultIndex>)
        .params("index: integer 0..7, oldest first; must be retained. Drops only that transient result, selecting the newest remaining result if necessary; echoes index."),
    CommandSpec::new("render.output.size", "Set Render Output Size", output_size)
        .icon("settings")
        .noundo()
        .doc_only()
        .params("width, height: 1..16384; custom?: bool. Validated Render output draft request; headless echo only, no design edits or job."),
    CommandSpec::new("render.result.view", "View Render Image", result_view)
        .icon("render_image")
        .noundo()
        .doc_only()
        .params("view: model|image|fit|actual. Validated result canvas request; headless echo only, never starts a job."),
    CommandSpec::new("render.result.close", "Close Render Image", close_result)
        .icon("close")
        .key("Escape")
        .noundo()
        .doc_only()
        .params("No parameters. Return to Model Preview; headless echo only, never cancels a job."),
    CommandSpec::new("appearance.paint", "Paint Appearance", super::inspect::appearance_gestures::paint)
        .icon("appearance").key("B").noundo()
        .params("appearance or color/name/opacity/pbr: appearance.assign look parameters; validates and returns look for ui.start paint. done?: true ends the UI tool. Programmatic calls never open UI."),
    CommandSpec::new("appearance.pick_up", "Pick Up Appearance", super::inspect::appearance_gestures::pick_up)
        .icon("select").key("I").noundo()
        .params("target?: appearance.chain target; returns its resolved look, or requests the UI sampling tool when omitted. Programmatic calls never open UI."),

    CommandSpec::new("render.lights.solo","Solo Light",crate::checked!("render.lights.solo",solo))
        .noundo().doc_only().icon("render_scene").at("RENDER SCENE","LIGHTS")
        .contract(&SOLO).output(crate::schema::output_schema_for::<SoloParams>)
        .params("id?: kind:slot light address; solo:bool. Enabling requires an id; false clears solo. Validates and echoes per-document UI view state. Never saves settings, evaluates geometry, opens an editor or changes history."),
    CommandSpec::new("render.lights.mute","Mute Light",crate::checked!("render.lights.mute",mute))
        .noundo().doc_only().icon("render_scene").at("RENDER SCENE","LIGHTS")
        .contract(&MUTE).output(crate::schema::output_schema_for::<MuteParams>)
        .params("id: kind:slot light address; mute:bool. Validates and echoes per-document UI view state, applied to live preview and captured render copies only. Never changes saved settings or history."),
    CommandSpec::new("render.compare", "Compare Images", crate::checked!("render.compare", compare))
        .icon("compare").noundo().doc_only().at("RENDER", "RESULT")
        .enabled(results_ready)
        .contract(&COMPARE).output(output_schema_for::<CompareParams>)
        .params("left, right: live or retained result index 0..7 (oldest first), distinct and retained; OR off:true. Validated per-document comparison view request; headless echo, no rendering or design/history change."),
    CommandSpec::new("render.compare.divider", "Move Render Comparison Divider", crate::checked!("render.compare.divider", divider))
        .icon("compare").noundo().doc_only()
        .contract(&DIVIDER).output(output_schema_for::<CompareDivider>)
        .params("position: finite number, clamped to 0.05..0.95. Transient comparison divider request; headless echo only."),
    CommandSpec::new("render.batch", "Render All Shots", crate::checked!("render.batch", batch))
        .icon("render_image").noundo().doc_only().at("RENDER", "BATCH")
        .enabled(|s| s.render_batch_ready())
        .contract(&BATCH).output(output_schema_for::<BatchResult>)
        .params("request?: render.start parameters, shared across all saved shots except camera. Default: first saved setup in name order. Captures up to 32 shot cameras and queues sequentially through render.start; returns {queued:n}. Refuses active renders, no shots or stale geometry. render.status (also with {}) and the UI tick advance the queue; Cancel on the active job drops waiting shots. No design/history/revision change."),
];

fn copy_check(_: &mut Session, params: &Value) -> Result<Value> {
    let report: CheckReport = serde_json::from_value(params.clone()).map_err(|e| bad("render.preflight.copy", e.to_string()))?;
    if report.text.is_empty() || report.text.len() > 65536 {
        return Err(bad("render.preflight.copy", "report must contain 1..65536 bytes"));
    }
    Ok(json!({"text":report.text}))
}

fn compare(s: &mut Session, params: &Value) -> Result<Value> {
    let input: CompareParams = serde_json::from_value(params.clone()).map_err(|e| bad("render.compare", e.to_string()))?;
    match input {
        CompareParams::Off(off) if off.off => {
            s.render_jobs.set_comparison(None);
            Ok(json!({"off":true}))
        }
        CompareParams::Pair(pair) => {
            if pair.left == pair.right {
                return Err(bad("render.compare", "comparison sides must differ"));
            }
            let results = s.render_retained_results()?;
            for side in [pair.left, pair.right] {
                if let CompareSide::Result(index) = side
                    && (index > 7 || results.get(index as usize).is_none())
                {
                    return Err(bad("render.compare", "retained result index is out of bounds"));
                }
            }
            let resolve = |side| match side {
                CompareSide::Live(_) => None,
                CompareSide::Result(index) => results.get(index as usize).map(|result| result.frame.job),
            };
            s.render_jobs.set_comparison(Some([resolve(pair.left), resolve(pair.right)]));
            Ok(json!({"left":pair.left,"right":pair.right}))
        }
        _ => Err(bad("render.compare", "off must be true")),
    }
}

fn divider(_: &mut Session, params: &Value) -> Result<Value> {
    let input: CompareDivider = serde_json::from_value(params.clone()).map_err(|e| bad("render.compare.divider", e.to_string()))?;
    if !input.position.is_finite() {
        return Err(bad("render.compare.divider", "position must be finite"));
    }
    Ok(json!({"position":input.position.clamp(0.05,0.95)}))
}

pub(crate) fn batch_request(s: &Session, params: &Value) -> Result<Value> {
    let input: BatchParams = serde_json::from_value(params.clone()).map_err(|e| bad("render.batch", e.to_string()))?;
    s.render_batch_ready().map_err(|reason| bad("render.batch", reason))?;
    if s.model.is_stale() {
        return Err(bad("render.batch", "finish the modelling gesture before rendering shots"));
    }
    for name in s.doc.render.setups.keys() {
        solidcraft_doc::render_settings::RenderSettings::validate_name(name).map_err(|error| bad("render.batch", error.to_string()))?;
    }
    let common = if let Some(request) = input.request {
        Value::Object(request.into_iter().collect())
    } else {
        let setup = s.doc.render.setups.values().next().ok_or_else(|| bad("render.batch", "no saved shots"))?;
        json!({"settings":setup})
    };
    let mut request = common.as_object().cloned().ok_or_else(|| bad("render.batch", "request must be an object"))?;
    let settings = if let Some(name) = request.get("setup") {
        let name = name.as_str().ok_or_else(|| bad("render.batch", "setup must be a saved name"))?;
        if request.contains_key("settings") {
            return Err(bad("render.batch", "choose either setup or settings"));
        }
        s.doc.render.setups.get(name).cloned().ok_or_else(|| bad("render.batch", "unknown saved setup"))?
    } else if let Some(settings) = request.get("settings") {
        serde_json::from_value(settings.clone()).map_err(|e| bad("render.batch", e.to_string()))?
    } else {
        s.doc.render.setups.values().next().cloned().ok_or_else(|| bad("render.batch", "no saved shots"))?
    };
    request.remove("setup");
    // A batch never replaces an active job; malformed replace values must still refuse.
    if request.get("replace").is_some_and(|value| value != &json!(false)) {
        return Err(bad("render.batch", "replace must be false or omitted"));
    }
    request.insert("settings".into(), json!(settings));
    Ok(Value::Object(request))
}

fn batch(s: &mut Session, params: &Value) -> Result<Value> {
    let request = std::sync::Arc::new(batch_request(s, params)?);
    let shots = s
        .doc
        .render
        .setups
        .iter()
        .map(|(name, shot)| crate::render_jobs::BatchShot { name: name.clone(), camera: shot.camera, request: request.clone() })
        .collect();
    let queued = s.start_render_batch(shots)?;
    Ok(json!({"queued":queued}))
}

fn results_ready(s: &Session) -> std::result::Result<(), String> {
    if s.render_jobs.has_results() { Ok(()) } else { Err("no completed render results are retained".into()) }
}

fn indexed_result(s: &mut Session, params: &Value, command: &str, discard: bool) -> Result<Value> {
    let input: ResultIndex = serde_json::from_value(params.clone()).map_err(|e| bad(command, e.to_string()))?;
    if input.index > 7 {
        return Err(bad(command, "index must be in 0..7"));
    }
    s.render_jobs.result_index(input.index as usize, discard).map_err(crate::render_jobs::job_error)?;
    Ok(json!({"index":input.index}))
}

fn select_result(s: &mut Session, params: &Value) -> Result<Value> {
    indexed_result(s, params, "render.result.select", false)
}

fn discard_result(s: &mut Session, params: &Value) -> Result<Value> {
    indexed_result(s, params, "render.result.discard", true)
}

#[cfg(test)]
#[test]
fn render_lights_remaining_planned_commands_refuse_without_mutation() {
    use serde_json::{Value, json};
    assert!(super::find_command("appearance.replace").is_some_and(|command| command.planned.is_none()));
    let mut session = crate::Session::default();
    session.execute("render.settings.set", &json!({"name":"Studio","set":{"width":800}})).unwrap();
    session.execute("render.settings.set", &json!({"name":"Studio","set":{"width":900}})).unwrap();
    session.execute("edit.undo", &json!({})).unwrap();
    let document = session.doc.clone();
    let before = (session.undo.len(), session.redo.len(), session.revision, session.evaluations, session.is_dirty());
    for command in COMMANDS {
        if command.planned.is_none() {
            continue;
        }
        assert!(!command.info(&session).enabled);
        for params in [json!({}), Value::Null, json!([]), json!({"target":1e300,"name":"hostile"})] {
            let error = session.execute(command.id, &params).unwrap_err().to_string();
            assert!(error.contains("not supported yet"), "{error}");
            assert!(std::sync::Arc::ptr_eq(&document, &session.doc));
            assert_eq!(before, (session.undo.len(), session.redo.len(), session.revision, session.evaluations, session.is_dirty()));
        }
    }
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct OutputSize {
    width: u32,
    height: u32,
    #[serde(default)]
    custom: bool,
}
fn output_size(_: &mut Session, params: &Value) -> Result<Value> {
    let input: OutputSize = serde_json::from_value(params.clone()).map_err(|e| bad("render.output.size", e.to_string()))?;
    if !(1..=16384).contains(&input.width) || !(1..=16384).contains(&input.height) {
        return Err(bad("render.output.size", "dimensions must be in 1..16384"));
    }
    let mut reply = json!({"width":input.width,"height":input.height});
    if input.custom {
        reply["custom"] = json!(true);
    }
    Ok(reply)
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ResultView {
    view: String,
}
fn result_view(s: &mut Session, params: &Value) -> Result<Value> {
    let input: ResultView = serde_json::from_value(params.clone()).map_err(|e| bad("render.result.view", e.to_string()))?;
    if !matches!(input.view.as_str(), "model" | "image" | "fit" | "actual") {
        return Err(bad("render.result.view", "view must be model, image, fit or actual"));
    }
    if input.view == "model" {
        s.render_jobs.set_comparison(None);
    }
    Ok(json!({"view":input.view}))
}
fn close_result(s: &mut Session, params: &Value) -> Result<Value> {
    if !params.as_object().is_some_and(|p| p.is_empty()) {
        return Err(bad("render.result.close", "expected no parameters"));
    }
    s.render_jobs.set_comparison(None);
    Ok(json!({"view":"model"}))
}

#[cfg(test)]
#[test]
fn output_viewer_requests_are_validated_headless_echoes() {
    let mut s = Session::default();
    let document = s.doc.clone();
    let before = (s.revision, s.undo.len(), s.evaluations);
    for size in [json!({"width":1280,"height":720}), json!({"width":1920,"height":1080})] {
        assert_eq!(s.execute("render.output.size", &size).unwrap(), size);
    }
    let custom = json!({"width":1920,"height":1080,"custom":true});
    assert_eq!(s.execute("render.output.size", &custom).unwrap(), custom);
    assert!(s.execute("render.output.size", &json!({"width":1920,"height":1080,"custom":"yes"})).is_err());
    for view in ["model", "image", "fit", "actual"] {
        let request = json!({"view":view});
        assert_eq!(s.execute("render.result.view", &request).unwrap(), request);
    }
    assert_eq!(s.execute("render.result.close", &json!({})).unwrap(), json!({"view":"model"}));
    for request in
        [json!(null), json!({}), json!({"width":0,"height":1}), json!({"width":u64::MAX,"height":1}), json!({"width":1,"height":1,"extra":true})]
    {
        assert!(s.execute("render.output.size", &request).is_err());
    }
    for request in [json!(null), json!({"view":"unknown"}), json!({"view":"image","extra":true})] {
        assert!(s.execute("render.result.view", &request).is_err());
        // Session normalizes null parameters to an empty object for no-argument commands.
        if request.is_object() {
            assert!(s.execute("render.result.close", &request).is_err());
        }
    }
    assert!(std::sync::Arc::ptr_eq(&document, &s.doc));
    assert_eq!(before, (s.revision, s.undo.len(), s.evaluations));
}

#[cfg(test)]
#[test]
fn output_sections_copy_report_validates_without_design_history_or_job_changes() {
    let mut s = Session::default();
    let doc = s.doc.clone();
    let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty());
    let report = json!({"text":"Check\n✓ Size is within the renderer limit"});
    assert_eq!(s.execute("render.preflight.copy", &report).unwrap(), report);
    for request in [json!({}), json!({"text":""}), json!({"text":true}), json!({"text":"check","job":1}), json!({"text":"x".repeat(65537)})] {
        assert!(s.execute("render.preflight.copy", &request).is_err());
    }
    assert!(std::sync::Arc::ptr_eq(&doc, &s.doc));
    assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty()));
}

#[cfg(test)]
fn complete_result(s: &mut Session, shot: &str) -> solidcraft_render::job::JobId {
    let reply = s.execute("render.start", &json!({"setup":shot})).unwrap();
    let job = serde_json::from_value(reply["job"].clone()).unwrap();
    let host = s.render_job_host().unwrap().clone();
    for _ in 0..1000 {
        host.pump(4096).unwrap();
        if s.execute("render.status", &json!({"job":job})).unwrap()["progress"]["phase"] == "completed" {
            return job;
        }
    }
    panic!("bounded result fixture did not complete");
}

#[cfg(test)]
#[test]
fn retained_results_cap_order_metadata_and_selection_never_edit_a_design() {
    let mut s = Session::default();
    s.set_render_job_host(Some(solidcraft_render::job::CpuHost::cooperative())).unwrap();
    s.execute("render.settings.set", &json!({"name":"Hero","set":{"width":16,"height":8}})).unwrap();
    s.execute("render.settings.set", &json!({"name":"Hero","set":{"width":32}})).unwrap();
    s.execute("edit.undo", &json!({})).unwrap();
    assert_eq!(s.redo.len(), 1, "view commands must preserve an available redo step");
    let document = s.doc.clone();
    let before = (s.undo.len(), s.redo.len(), s.revision, s.evaluations, s.is_dirty());
    let jobs: Vec<_> = (0..10).map(|_| complete_result(&mut s, "Hero")).collect();
    let results = s.render_retained_results().unwrap();
    assert_eq!(results.len(), 8);
    assert_eq!(results.iter().map(|result| result.frame.job).collect::<Vec<_>>(), jobs[2..]);
    for result in &results {
        assert_eq!(result.shot.as_deref(), Some("Hero"));
        assert_eq!((result.frame.width, result.frame.height), (16, 8));
        assert!(result.seconds.is_finite() && result.seconds >= 0.0);
        assert_eq!(result.frame.scene_generation, s.revision);
        assert!(!result.stale);
    }
    assert!(s.render_job_handle(jobs[0]).is_err());
    assert!(s.render_job_handle(jobs[1]).is_err());
    assert_eq!(s.render_selected_result(), Some(jobs[9]));
    assert_eq!(s.execute("render.result.select", &json!({"index":0})).unwrap(), json!({"index":0}));
    assert_eq!(s.render_selected_result(), Some(jobs[2]));
    assert_eq!(s.execute("render.result.copy", &json!({})).unwrap()["frame"]["job"], json!(jobs[2]));
    assert_eq!(s.execute("render.result.pin", &json!({})).unwrap()["frame"]["job"], json!(jobs[2]));
    s.execute("render.result.discard", &json!({"index":0})).unwrap();
    assert_eq!(s.render_selected_result(), Some(jobs[9]));
    assert!(s.render_job_handle(jobs[2]).is_err());
    s.execute("render.result.select", &json!({"index":2})).unwrap();
    s.execute("render.result.discard", &json!({"index":0})).unwrap();
    assert_eq!(s.render_selected_result(), Some(jobs[5]), "discarding an earlier row preserves the selected identity");
    while !s.render_retained_results().unwrap().is_empty() {
        s.execute("render.result.discard", &json!({"index":0})).unwrap();
    }
    assert!(s.render_selected_result().is_none());
    assert!(s.execute("render.result.copy", &json!({})).is_err());
    assert!(std::sync::Arc::ptr_eq(&document, &s.doc));
    assert_eq!(before, (s.undo.len(), s.redo.len(), s.revision, s.evaluations, s.is_dirty()));
}

#[cfg(test)]
#[test]
fn retained_result_requests_refuse_hostile_and_missing_indices_atomically() {
    let mut s = Session::default();
    s.set_render_job_host(Some(solidcraft_render::job::CpuHost::cooperative())).unwrap();
    s.execute("render.settings.set", &json!({"name":"Front","set":{"width":8,"height":8}})).unwrap();
    let job = complete_result(&mut s, "Front");
    let document = s.doc.clone();
    let before = (s.undo.len(), s.redo.len(), s.revision, s.evaluations, s.is_dirty());
    let retained = s.render_job_host().unwrap().admitted_bytes();
    for mode in [crate::schema::ParamCheck::Off, crate::schema::ParamCheck::Strict] {
        s.param_check = mode;
        for command in ["render.result.select", "render.result.discard"] {
            let spec = super::find_command(command).unwrap();
            assert!(spec.contract.is_some() && spec.output.is_some());
            for request in [
                json!(null),
                json!([]),
                json!({}),
                json!({"index":-1}),
                json!({"index":0.5}),
                json!({"index":1e300}),
                json!({"index":u64::MAX}),
                json!({"index":"0"}),
                json!({"index":null}),
                json!({"index":true}),
                json!({"index":1}),
                json!({"index":8}),
                json!({"index":0,"extra":true}),
            ] {
                assert!(s.execute(command, &request).is_err(), "{command}: {request}");
                assert_eq!(s.render_retained_results().unwrap().len(), 1);
                assert_eq!(s.render_selected_result(), Some(job));
                assert_eq!(s.render_job_host().unwrap().admitted_bytes(), retained);
                assert!(std::sync::Arc::ptr_eq(&document, &s.doc));
                assert_eq!(before, (s.undo.len(), s.redo.len(), s.revision, s.evaluations, s.is_dirty()));
            }
        }
    }
    s.execute("render.settings.set", &json!({"name":"Front","set":{"width":16}})).unwrap();
    assert!(s.render_retained_results().unwrap()[0].stale);
    s.execute("edit.undo", &json!({})).unwrap();
    assert!(s.render_retained_results().unwrap()[0].stale, "undo does not recapture pixels");
    assert_eq!(s.render_retained_results().unwrap()[0].frame.scene_generation, before.2);
    let mut other = Session::default();
    assert!(other.render_retained_results().unwrap().is_empty());
    assert!(other.execute("render.result.select", &json!({"index":0})).is_err());
    assert!(other.render_job_handle(job).is_err());
}

#[cfg(test)]
#[test]
fn render_results_compare_validates_both_sides_and_clamps_only_finite_dividers_without_mutation() {
    let mut s = Session::default();
    s.set_render_job_host(Some(solidcraft_render::job::CpuHost::cooperative())).unwrap();
    s.execute("render.settings.set", &json!({"name":"Hero","set":{"width":8,"height":8}})).unwrap();
    complete_result(&mut s, "Hero");
    complete_result(&mut s, "Hero");
    s.execute("render.settings.set", &json!({"name":"Hero","set":{"width":16}})).unwrap();
    s.execute("edit.undo", &json!({})).unwrap();
    let document = s.doc.clone();
    let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty());
    let selected = s.selection.clone();
    for mode in [crate::schema::ParamCheck::Off, crate::schema::ParamCheck::Strict] {
        s.param_check = mode;
        for request in [json!({"left":"live","right":0}), json!({"left":1,"right":0}), json!({"left":0,"right":"live"}), json!({"off":true})] {
            assert_eq!(s.execute("render.compare", &request).unwrap(), request);
        }
        for request in [
            json!({}),
            json!([]),
            json!({"off":false}),
            json!({"off":true,"left":0}),
            json!({"left":"live","right":"live"}),
            json!({"left":0,"right":0}),
            json!({"left":"unknown","right":0}),
            json!({"left":"live","right":2}),
            json!({"left":8,"right":0}),
            json!({"left":-1,"right":0}),
            json!({"left":0.5,"right":0}),
            json!({"left":1e300,"right":"live"}),
            json!({"left":null,"right":0}),
            json!({"left":"0","right":1}),
            json!({"left":true,"right":0}),
            json!({"left":"live","right":0,"extra":true}),
        ] {
            assert!(s.execute("render.compare", &request).is_err(), "{request}");
        }
        for (position, expected) in [(-1e300, 0.05), (0.0, 0.05), (0.25, 0.25), (1.0, 0.95), (1e300, 0.95)] {
            assert_eq!(s.execute("render.compare.divider", &json!({"position":position})).unwrap(), json!({"position":expected}));
        }
        for request in [json!({}), json!({"position":null}), json!({"position":"NaN"}), json!({"position":true}), json!({"position":0.5,"extra":1})] {
            assert!(s.execute("render.compare.divider", &request).is_err());
        }
        assert!(std::sync::Arc::ptr_eq(&document, &s.doc));
        assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty()));
        assert_eq!(s.selection, selected);
        assert_eq!(s.render_retained_results().unwrap().len(), 2);
    }
    let mut empty = Session::default();
    assert!(empty.execute("render.compare", &json!({"left":"live","right":0})).is_err());
    assert!(empty.execute("render.compare", &json!({"off":true})).is_err());
    for id in ["render.compare", "render.compare.divider", "render.batch"] {
        let command = super::find_command(id).unwrap();
        assert!(command.contract.is_some() && command.output.is_some() && command.planned.is_none());
        assert!(!command.undoable && !command.reads_model);
    }
}

#[cfg(test)]
fn batch_fixture(count: usize) -> Session {
    let mut s = Session::default();
    s.set_render_job_host(Some(solidcraft_render::job::CpuHost::cooperative())).unwrap();
    for index in 0..count {
        let camera = solidcraft_render::Camera { yaw: index as f64 * 0.2, roll: index as f64 * 0.01, ..Default::default() };
        s.execute("render.settings.set", &json!({"name":format!("Shot {index:02}"),"set":{"camera":camera,"width":8+index,"height":8}})).unwrap();
    }
    s
}

#[cfg(test)]
#[test]
fn render_results_batch_is_sequential_uses_snapshot_cameras_and_one_setup_without_design_or_history_changes() {
    let mut s = batch_fixture(3);
    s.execute("render.settings.set", &json!({"name":"Shot 00","set":{"width":64}})).unwrap();
    s.execute("edit.undo", &json!({})).unwrap();
    let document = s.doc.clone();
    let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty());
    let cameras: Vec<_> = s.doc.render.setups.values().map(|setup| setup.camera).collect();
    s.param_check = crate::schema::ParamCheck::Strict;
    assert_eq!(
        s.execute("render.batch", &json!({"request":{"settings":{"width":12,"height":10,"background":[7,8,9]}}})).unwrap(),
        json!({"queued":3})
    );
    assert_eq!((s.render_queue_state().running, s.render_queue_state().waiting), (1, 2));
    assert!(s.execute("render.batch", &json!({})).is_err());
    let host = s.render_job_host().unwrap().clone();
    let mut jobs = Vec::new();
    for (index, camera) in cameras.iter().enumerate() {
        let queue = s.render_queue_state();
        assert_eq!((queue.running, queue.waiting), (1, 2 - index));
        let job = queue.job.unwrap();
        let status = s.render_job_handle(job).unwrap().status().unwrap();
        assert_eq!(status.request.camera, *camera);
        assert_eq!((status.request.width, status.request.height, status.request.background), (12, 10, [7, 8, 9]));
        assert_eq!(queue.shot, Some(format!("Shot {index:02}")));
        jobs.push(job);
        for _ in 0..100 {
            if !host.pump(4096).unwrap() {
                break;
            }
        }
        let reply = s.execute("render.status", &json!({"job":job})).unwrap();
        assert_eq!(reply["progress"]["phase"], "completed");
    }
    assert_eq!((s.render_queue_state().running, s.render_queue_state().waiting), (0, 0));
    assert!(s.render_queue_state().job.is_none());
    let results = s.render_retained_results().unwrap();
    assert_eq!(results.iter().map(|result| result.frame.job).collect::<Vec<_>>(), jobs);
    assert_eq!(results.iter().map(|result| result.shot.clone().unwrap()).collect::<Vec<_>>(), ["Shot 00", "Shot 01", "Shot 02"]);
    assert!(std::sync::Arc::ptr_eq(&document, &s.doc));
    assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty()));
}

#[cfg(test)]
#[test]
fn render_results_batch_caps_at_32_and_cancel_discards_every_waiting_shot() {
    let mut s = batch_fixture(32);
    let document = s.doc.clone();
    let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty());
    assert_eq!(s.execute("render.batch", &json!({})).unwrap(), json!({"queued":32}));
    let queue = s.render_queue_state();
    assert_eq!((queue.running, queue.waiting), (1, 31));
    let job = queue.job.unwrap();
    assert!(s.execute("render.start", &json!({"settings":{"width":8,"height":8}})).is_err());
    s.execute("render.cancel", &json!({})).unwrap();
    assert_eq!(s.render_queue_state().waiting, 0);
    assert!(s.render_queue_state().job.is_none());
    s.render_job_host().unwrap().pump(4096).unwrap();
    assert!(s.render_job_handle(job).unwrap().frame().unwrap().is_none());
    for _ in 0..3 {
        assert_eq!(s.execute("render.status", &json!({})).unwrap()["queue"]["waiting"], 0);
    }
    assert!(s.render_retained_results().unwrap().is_empty());
    let next = s.execute("render.start", &json!({"settings":{"width":8,"height":8}})).unwrap();
    assert_eq!(next["job"]["serial"], 2, "Cancel must not start any waiting shot");
    s.execute("render.cancel", &json!({"job":next["job"]})).unwrap();
    assert!(std::sync::Arc::ptr_eq(&document, &s.doc));
    assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty()));
    std::sync::Arc::make_mut(&mut std::sync::Arc::make_mut(&mut s.doc).render).setups.insert("Over limit".into(), Default::default());
    assert!(s.execute("render.batch", &json!({})).unwrap_err().to_string().contains("32"));
    assert_eq!(s.render_queue_state().waiting, 0);
}

#[cfg(test)]
#[test]
fn render_results_batch_refuses_missing_shots_busy_hostile_and_failed_requests_without_queuing() {
    let mut empty = batch_fixture(0);
    assert!(empty.execute("render.batch", &json!({})).is_err());
    let mut s = batch_fixture(2);
    let document = s.doc.clone();
    let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty());
    for request in [
        json!([]),
        json!({"request":1e300}),
        json!({"request":[]}),
        json!({"request":{"bogus":true}}),
        json!({"request":{"replace":true}}),
        json!({"request":{"settings":{"width":0}}}),
        json!({"extra":true}),
    ] {
        assert!(s.execute("render.batch", &request).is_err(), "{request}");
        assert_eq!((s.render_queue_state().running, s.render_queue_state().waiting), (0, 0));
        assert!(s.render_queue_state().job.is_none());
    }
    let job = s.execute("render.start", &json!({"settings":{"width":8,"height":8}})).unwrap()["job"].clone();
    assert!(s.execute("render.batch", &json!({})).is_err());
    assert_eq!((s.render_queue_state().running, s.render_queue_state().waiting), (1, 0));
    s.execute("render.cancel", &json!({"job":job})).unwrap();
    assert!(std::sync::Arc::ptr_eq(&document, &s.doc));
    assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty()));
    s.set_render_job_host(None).unwrap();
    assert!(s.execute("render.batch", &json!({})).is_err());
    assert_eq!((s.render_queue_state().running, s.render_queue_state().waiting), (0, 0));
    assert!(s.render_queue_state().error.is_some());
    assert!(std::sync::Arc::ptr_eq(&document, &s.doc));
    assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty()));
}

#[cfg(test)]
#[test]
fn render_results_batch_cameras_and_common_setup_are_captured_before_later_shot_edits() {
    let mut s = batch_fixture(2);
    let original = s.doc.render.setups.get("Shot 01").unwrap().camera;
    s.execute("render.batch", &json!({"request":{"setup":"Shot 00"}})).unwrap();
    let first = s.render_queue_state().job.unwrap();
    let changed = solidcraft_render::Camera { yaw: 2.0, ..Default::default() };
    s.execute("render.settings.set", &json!({"name":"Shot 01","set":{"camera":changed}})).unwrap();
    s.execute("render.settings.set", &json!({"name":"Shot 00","set":{"width":64}})).unwrap();
    let document = s.doc.clone();
    let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations);
    let host = s.render_job_host().unwrap().clone();
    for _ in 0..100 {
        if !host.pump(4096).unwrap() {
            break;
        }
    }
    let reply = s.execute("render.status", &json!({})).unwrap();
    let next: solidcraft_render::job::JobId = serde_json::from_value(reply["queue"]["job"].clone()).unwrap();
    assert_ne!(next, first);
    let request = s.render_job_handle(next).unwrap().status().unwrap().request;
    assert_eq!(request.camera, original);
    assert_eq!(request.width, 8);
    assert!(std::sync::Arc::ptr_eq(&document, &s.doc));
    assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations));
    s.execute("render.cancel", &json!({"job":next})).unwrap();
}

#[cfg(test)]
#[test]
fn render_results_compare_keeps_copy_on_the_visible_result_until_a_source_is_evicted() {
    let mut s = batch_fixture(1);
    let first = complete_result(&mut s, "Shot 00");
    complete_result(&mut s, "Shot 00");
    s.execute("render.compare", &json!({"left":"live","right":0})).unwrap();
    assert_eq!(s.render_comparison(), Some([None, Some(first)]));
    assert_eq!(s.render_selected_result(), Some(first));
    let document = s.doc.clone();
    let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations);
    let mut newest = first;
    for index in 0..7 {
        newest = complete_result(&mut s, "Shot 00");
        if index < 6 {
            assert_eq!(s.execute("render.result.copy", &json!({})).unwrap()["frame"]["job"], json!(first));
            assert_eq!(s.render_comparison(), Some([None, Some(first)]));
        }
    }
    assert!(s.render_comparison().is_none());
    assert_eq!(s.render_selected_result(), Some(newest));
    assert!(std::sync::Arc::ptr_eq(&document, &s.doc));
    assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations));
}