Skip to content

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

102 KB
Raw Blame
//! Edit Feature must replace the selections as well as the numerical definition.

use serde_json::{Value, json};

use crate::{Sel, Session};

fn run(s: &mut Session, id: &str, params: Value) -> Value {
    s.execute(id, &params).unwrap_or_else(|e| panic!("{id} {params}: {e}"))
}

#[test]
fn select_geometry_resolves_points_and_indices_without_changing_history() {
    use solidcore_record::Vec3;

    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"body_name":"Block", "corner":[20,30,40], "length":10, "width":10, "height":10}));
    let before = (s.doc.to_json(), s.undo.len());
    for (kind, point) in [("face", Vec3::new(25.0, 35.0, 50.0)), ("edge", Vec3::new(25.0, 30.0, 50.0))] {
        assert_eq!(run(&mut s, "select.set", json!({"items":[{"type":kind,"body":"Block","point":point}]}))["selected"], 1);
        let index = match &s.selection[0] {
            Sel::Face { index, point: actual, .. } | Sel::Edge { index, point: actual, .. } => {
                assert_eq!(*actual, point);
                *index
            }
            other => panic!("unexpected selection: {other:?}"),
        };
        let measured = s.measure_items(&s.selection);
        let (field, expected) = if kind == "face" { ("area_mm2", 100.0) } else { ("length_mm", 10.0) };
        assert!((measured["items"][0][field].as_f64().unwrap() - expected).abs() < 1e-9, "{measured}");
        run(&mut s, "select.set", json!({"items":[{"type":kind,"body":"Block","index":index}]}));
        let complete = serde_json::to_value(&s.selection[0]).unwrap();
        assert_eq!(complete["index"], index);
        let mut point_only = complete.clone();
        point_only.as_object_mut().unwrap().remove("index");
        run(&mut s, "select.set", json!({"items":[point_only]}));
        assert_eq!(serde_json::to_value(&s.selection[0]).unwrap(), complete);
    }
    assert_eq!((s.doc.to_json(), s.undo.len()), before);
}

#[test]
fn select_geometry_curved_picks_round_trip_and_add_without_duplicates() {
    let mut s = Session::default();
    run(&mut s, "solid.cylinder", json!({"body_name":"Round", "radius":5, "height":10}));
    for (kind, point) in [("face", [3, 4, 5]), ("edge", [3, 4, 10])] {
        run(&mut s, "select.set", json!({"items":[{"type":kind,"body":"Round","point":point}]}));
        let index = serde_json::to_value(&s.selection[0]).unwrap()["index"].clone();
        run(&mut s, "select.set", json!({"items":[{"type":kind,"body":"Round","index":index}]}));
        let complete = serde_json::to_value(&s.selection[0]).unwrap();
        let pick: solidcore_record::Vec3 = serde_json::from_value(complete["point"].clone()).unwrap();
        assert!((pick.x.hypot(pick.y) - 5.0).abs() < 1e-6, "the inferred point lies on the cylinder: {complete}");
        let mut partial = complete.clone();
        partial.as_object_mut().unwrap().remove("index");
        run(&mut s, "select.set", json!({"items":[partial, complete],"add":true}));
        assert_eq!(s.selection.len(), 1);
        assert_eq!(serde_json::to_value(&s.selection[0]).unwrap(), complete);
        let measured = s.measure_items(&s.selection);
        assert!((measured["items"][0]["diameter"].as_f64().unwrap() - 10.0).abs() < 1e-6, "{measured}");
    }
}

#[test]
fn select_geometry_uses_the_placed_body_in_world_coordinates() {
    let mut s = Session::default();
    let created = run(&mut s, "component.create", json!({"name":"Part"}));
    run(&mut s, "solid.box", json!({"body_name":"Block", "length":2, "width":3, "height":4}));
    let second = run(&mut s, "occurrence.copy", json!({"occurrence":created["occurrence"]}))["occurrence"].as_u64().unwrap();
    run(&mut s, "occurrence.move", json!({"occurrence":second,"translate":[10,20,0],"axis":[0,0,1],"angle":"90 deg","capture":false}));
    let name = s.occurrence_placement(&[second]).unwrap().bodies[0].world.clone();
    for (kind, point) in [("face", [8.5, 21.0, 4.0]), ("edge", [8.5, 20.0, 4.0])] {
        run(&mut s, "select.set", json!({"items":[{"type":kind,"body":name,"point":point}]}));
        let complete = serde_json::to_value(&s.selection[0]).unwrap();
        assert_eq!(complete["body"], name);
        run(&mut s, "select.set", json!({"items":[{"type":kind,"body":name,"index":complete["index"]}]}));
        let inferred = serde_json::to_value(&s.selection[0]).unwrap();
        let pick: solidcore_record::Vec3 = serde_json::from_value(inferred["point"].clone()).unwrap();
        assert!((pick.z - 4.0).abs() < 1e-9 && (7.0..=10.0).contains(&pick.x) && (20.0..=22.0).contains(&pick.y), "{inferred}");
        assert!(s.execute("select.set", &json!({"items":[{"type":kind,"body":name,"point":[1,1,4]}]})).is_err());
        assert_eq!(serde_json::to_value(&s.selection[0]).unwrap(), inferred);
    }
}

#[test]
fn select_geometry_invalid_partial_picks_leave_selection_and_revision_unchanged() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"body_name":"Block", "length":10, "width":10, "height":10}));
    run(&mut s, "select.set", json!({"items":[{"type":"body","name":"Block"}]}));
    let before = (s.selection.clone(), s.revision, s.undo.len());
    for kind in ["face", "edge"] {
        for fields in [
            json!({}),
            json!({"index":999999}),
            json!({"index":-1}),
            json!({"index":"0"}),
            json!({"point":[500,500,500]}),
            json!({"point":[1,2]}),
            json!({"point":[1e308,1e308,1e308]}),
        ] {
            let mut item = json!({"type":kind,"body":"Block"});
            item.as_object_mut().unwrap().extend(fields.as_object().unwrap().clone());
            for add in [false, true] {
                let result = s.execute("select.set", &json!({"items":[{"type":"face","body":"Block","point":[5,5,10]},item],"add":add}));
                assert!(result.is_err(), "accepted {item}");
                assert_eq!((s.selection.clone(), s.revision, s.undo.len()), before, "{item}");
            }
        }
    }
    assert!(s.execute("select.set", &json!({"items":[{"type":"face","body":"Missing","point":[5,5,10]}]})).is_err());
    assert_eq!((s.selection, s.revision, s.undo.len()), before);
}

#[test]
fn history_playback_is_a_typed_display_request_without_history_edits() {
    let mut s = Session::default();
    let revision = s.revision;
    let undo = s.undo.len();
    for action in ["toggle", "play", "stop"] {
        assert_eq!(run(&mut s, "timeline.play", json!({"action": action})), json!({"action": action}));
    }
    assert_eq!(run(&mut s, "timeline.play", json!({})), json!({"action": "toggle"}));
    for action in [json!("pause"), json!(true), json!(1), json!([])] {
        assert!(s.execute("timeline.play", &json!({"action": action})).is_err());
    }
    assert_eq!(s.revision, revision);
    assert_eq!(s.undo.len(), undo);
    assert!(s.doc.marker.is_none());
    let description = run(&mut s, "engine.describe", json!({"command": "timeline.play"}));
    assert!(description["input"].is_object());
    assert!(description["output"].is_object());
    run(&mut s, "sketch.create", json!({"plane": "XY"}));
    assert!(s.execute("timeline.play", &json!({})).is_err());
}

/// `timeline.roll_to` takes a number of features or "end"; any other value is refused instead of
/// silently moving the marker to the end.
#[test]
fn roll_to_takes_a_number_or_end_and_refuses_anything_else() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10}));
    run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 20, "operation": "join"}));
    for cmd in ["timeline.roll_to", "timeline.rollback"] {
        assert_eq!(run(&mut s, cmd, json!({"position": 1}))["marker"], 1);
        assert_eq!(run(&mut s, cmd, json!({"position": "end"}))["marker"], 2);
        assert_eq!(run(&mut s, cmd, json!({"position": "1"}))["marker"], 1, "a number in a string is still a number");
        assert_eq!(run(&mut s, cmd, json!({"position": "END"}))["marker"], 2);
        run(&mut s, cmd, json!({"position": 1}));
        for bad in [json!("start"), json!("first"), json!([1]), json!({"n": 1}), json!(true), json!("NaN")] {
            let e = s.execute(cmd, &json!({"position": bad})).unwrap_err().to_string();
            assert!(e.contains("`position` must be a number") && e.contains("\"end\""), "{bad}: {e}");
            assert_eq!(s.doc.marker, Some(1), "{bad}: the refused call left the marker where it was");
        }
        assert_eq!(run(&mut s, cmd, json!({}))["marker"], 2, "omitted: the end");
        // #4712: a negative position is refused (it rolled the whole timeline back), in the
        // name of the command asked for.
        run(&mut s, cmd, json!({"position": 1}));
        for neg in [json!(-1), json!("-1"), json!(-0.5)] {
            let e = s.execute(cmd, &json!({"position": neg})).unwrap_err().to_string();
            assert!(e.contains("negative") && e.contains(&format!("`{cmd}`")), "{neg}: {e}");
            assert_eq!(s.doc.marker, Some(1), "{neg}: the marker stays");
        }
        let e = s.execute(cmd, &json!({"position": "start"})).unwrap_err().to_string();
        assert!(e.contains(&format!("`{cmd}`")), "named as asked: {e}");
    }
}

/// #7077: Repeat Last Command is a command (its key can change, command search finds it), but
/// only the app has a tool to start, so a script's call is refused and changes nothing.
#[test]
fn repeat_is_refused_outside_the_app_and_changes_nothing() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10}));
    let (doc, undo) = (s.doc.to_json(), s.undo.len());
    let e = s.execute("edit.repeat", &json!({})).unwrap_err().to_string();
    assert!(e.contains("in the app"), "{e}");
    assert_eq!((s.doc.to_json(), s.undo.len()), (doc, undo));
    let spec = crate::find_command("edit.repeat").unwrap();
    assert_eq!((spec.shortcut, spec.tab, spec.undoable), (Some("Shift+R"), "", false));
}

#[test]
fn creating_after_deleting_future_features_keeps_the_new_feature_active() {
    let mut s = Session::default();
    for (name, corner, size) in [("Base", [0, 0, 0], 10), ("Later1", [20, 0, 0], 2), ("Later2", [40, 0, 0], 3)] {
        run(&mut s, "solid.box", json!({"name": name, "corner": corner, "length": size, "width": size, "height": size, "operation": "new"}));
    }

    run(&mut s, "timeline.roll_to", json!({"position": 1}));
    run(&mut s, "solid.box", json!({"name": "Inserted", "corner": [60, 0, 0], "length": 4, "width": 4, "height": 4, "operation": "new"}));
    assert_eq!(s.doc.features.iter().map(|feature| feature.name.as_str()).collect::<Vec<_>>(), ["Base", "Inserted", "Later1", "Later2"]);
    assert_eq!(s.doc.marker, Some(2), "with later features, the new feature is inserted at the cursor");

    run(&mut s, "timeline.delete", json!({"features": ["Later1", "Later2"]}));
    assert_eq!(s.doc.features.len(), 2);
    assert_eq!(s.doc.marker, Some(2), "the cursor is at the end after deleting all later features");

    run(&mut s, "solid.box", json!({"name": "Appended", "corner": [80, 0, 0], "length": 5, "width": 5, "height": 5, "operation": "new"}));

    assert_eq!(s.doc.features.iter().map(|feature| feature.name.as_str()).collect::<Vec<_>>(), ["Base", "Inserted", "Appended"]);
    assert_eq!(s.doc.marker, Some(3), "the new feature advances the cursor to the end");
    assert_eq!(s.model.state().bodies.len(), 3, "the appended feature is evaluated, not left in the future");
    let volume = run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap();
    assert!((volume - 1189.0).abs() < 1e-6, "{volume}");
}

#[test]
fn g2_fillet_survives_edit_undo_and_reopen() {
    use solidcraft_doc::{Document, FeatureKind, FilletStyle};
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 20, "width": 20, "height": 20, "name": "Base"}));
    run(&mut s, "solid.fillet", json!({"edges": [[20, 0, 10]], "radius": 2, "type": "g2", "name": "Smooth"}));
    assert!(matches!(&s.doc.find_feature("Smooth").unwrap().kind, FeatureKind::Fillet { style: FilletStyle::Curvature, .. }));
    let before = run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap();
    run(&mut s, "timeline.edit", json!({"feature": "Smooth", "set": {"radius": "3"}}));
    let after = run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap();
    assert!(after < before);
    run(&mut s, "edit.undo", json!({}));
    let undo = run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap();
    assert!((undo - before).abs() < 1e-6);
    run(&mut s, "edit.redo", json!({}));
    let mut reopened = Session::new(Document::from_json(&s.doc.to_json()).unwrap());
    assert!(matches!(&reopened.doc.find_feature("Smooth").unwrap().kind, FeatureKind::Fillet { style: FilletStyle::Curvature, .. }));
    let volume = run(&mut reopened, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap();
    assert!((volume - after).abs() < 1e-6);
    assert!(s.execute("solid.fillet", &json!({"edges": [[0, 0, 10]], "radius": 2, "type": "curvature", "fit": "reduce"})).is_err());
}

#[test]
fn redefining_a_fillet_as_g2_on_sloped_ends_survives_undo_and_reopen() {
    use solidcraft_doc::{Document, FeatureKind, FilletStyle};
    let mut s = Session::default();
    run(&mut s, "sketch.create", json!({"plane": "XY"}));
    run(&mut s, "sketch.line", json!({"points": [[0, 0], [40, 0], [30, 20], [10, 20]], "closed": true}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"distance": 20}));
    run(&mut s, "solid.fillet", json!({"edges": [[20, 0, 20]], "radius": 5, "name": "Fillet1"}));
    let original = s.doc.clone();
    let id = s.doc.find_feature("Fillet1").unwrap().id;
    // #2708: changing an existing constant fillet to Curvature (G2) in Edit Feature.
    run(
        &mut s,
        "timeline.redefine",
        json!({"feature": id, "command": "solid.fillet", "params": {"edges": [[20, 0, 20]], "radius": "5", "type": "curvature"}}),
    );
    let f = s.doc.find_feature("Fillet1").unwrap();
    assert_eq!(f.id, id);
    assert!(matches!(&f.kind, FeatureKind::Fillet { style: FilletStyle::Curvature, .. }));
    // Use a fixed fine chord tolerance for the analytic comparison; Measure's
    // adaptive display tolerance is coarser and need not satisfy this bound.
    let volume = |s: &Session| {
        let bodies = &s.model.state().bodies;
        assert_eq!(bodies.len(), 1);
        bodies.first().unwrap().body.mesh(&solidcraft_kernel::MeshTolerance::chord(0.0001)).unwrap().measure().volume
    };
    // The curvature section at its equal-area thumbweight removes (1 - pi/4) r² at the square
    // corner, first moment 0.0474559669443 r³ (Green's theorem on the section).
    let expected = |r: f64| 12000.0 - 40.0 * (1.0 - std::f64::consts::FRAC_PI_4) * r.powi(2) + 0.0474559669443 * r.powi(3);
    let actual = volume(&s);
    assert!((actual - expected(5.0)).abs() < 0.05, "{actual} vs {}", expected(5.0));
    let edited = s.doc.clone();
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(s.doc, original);
    run(&mut s, "edit.redo", json!({}));
    assert_eq!(s.doc, edited);
    let mut reopened = Session::new(Document::from_json(&s.doc.to_json()).unwrap());
    assert!((volume(&reopened) - expected(5.0)).abs() < 0.05);
    run(&mut reopened, "timeline.edit", json!({"feature": id, "set": {"radius": "3"}}));
    assert!((volume(&reopened) - expected(3.0)).abs() < 0.05);
    let before = reopened.doc.clone();
    assert!(
        reopened
            .execute(
                "timeline.redefine",
                &json!({"feature": id, "command": "solid.fillet", "params": {"edges": [[20, 0, 20]], "radius": 100, "type": "curvature"}})
            )
            .is_err()
    );
    assert_eq!(reopened.doc, before);
    assert!((volume(&reopened) - expected(3.0)).abs() < 0.05);
}

#[test]
fn redefining_a_blend_replaces_persistent_edge_selection_and_survives_resize() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20, "name": "Base"}));
    run(&mut s, "solid.fillet", json!({"edges": [[20, 0, 20]], "radius": 2, "name": "Round"}));
    let round_id = s.doc.find_feature("Round").unwrap().id;
    let body_name = s.model.state().bodies[0].name.clone();
    s.doc_mut().feature_mut(round_id).unwrap().participants = vec![body_name];
    s.refresh();
    let old = s.doc.find_feature("Round").unwrap().clone();
    let before = (*s.doc).clone();
    run(&mut s, "timeline.redefine", json!({"feature": "Round", "command": "solid.fillet", "params": {"edges": [[0, 15, 20]], "radius": 2}}));
    let edited = s.doc.find_feature("Round").unwrap().clone();
    assert_eq!(edited.id, old.id);
    assert_eq!(edited.param_names, old.param_names);
    assert_eq!(edited.participants, old.participants);
    assert_ne!(edited.edge_names, old.edge_names, "the new edge must be the reference used on recompute");
    assert_ne!(edited.edge_refs, old.edge_refs);
    assert_eq!(s.doc.next_id, before.next_id, "temporary definitions must not consume feature ids");
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(*s.doc, before);
    run(&mut s, "edit.redo", json!({}));
    assert_eq!(s.doc.find_feature("Round").unwrap().edge_names, edited.edge_names);
    run(&mut s, "timeline.edit", json!({"feature": "Base", "set": {"length": "60", "height": "25"}}));
    let volume = run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap();
    let expected = 60.0 * 30.0 * 25.0 - (4.0 - std::f64::consts::PI) * 30.0;
    assert!((volume - expected).abs() < expected * 1e-4, "{volume} != {expected}");
    assert!(s.model.result(old.id).unwrap().warning.is_none());
}

/// A redefine computes the features after the edited one once: its trial's results are kept
/// for the session's own evaluation, though the cache holds only the last state (a large
/// design's). The reply reports that one rebuild (#5694): a session that had to compute the
/// features again would count them twice.
#[test]
fn redefining_computes_the_later_features_once() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 20, "width": 10, "height": 5, "name": "Base"}));
    for x in [30, 40, 50] {
        run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [x, 0, 0]}));
    }
    *s.model.cache.lock().unwrap() = solidcraft_doc::EvalCache::with_budget(1);
    let reply =
        run(&mut s, "timeline.redefine", json!({"feature": "Base", "command": "solid.box", "params": {"length": 25, "width": 10, "height": 5}}));
    assert_eq!((reply["recomputed"].as_u64(), reply["restored"].as_u64()), (Some(4), Some(0)), "{reply}");
    let volume = run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap();
    assert!((volume - (25.0 * 10.0 * 5.0 + 3.0 * 125.0)).abs() < 1e-6, "{volume}");
}

/// #5694: the reply reports what the redefine rebuilt — the edited feature and the features
/// after it — not the session's reuse of the trial's own results, which read as "nothing was
/// rebuilt" and did not match what the same change reports through `timeline.edit`.
#[test]
fn redefining_reports_the_features_it_rebuilt() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 20, "center": [0, 0, 10], "name": "Block"}));
    run(&mut s, "solid.hole", json!({"position": [0, 0, 20], "diameter": 6, "depth": 12, "name": "H"}));
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 5, "center": [30, 0, 2.5], "operation": "new", "name": "Other"}));
    let reply = run(
        &mut s,
        "timeline.redefine",
        json!({"feature": "H", "command": "solid.hole",
               "params": {"position": [0, 0, 20], "type": "counterbore", "diameter": 6, "depth": 12, "cb_diameter": 10, "cb_depth": 4}}),
    );
    assert_eq!((reply["recomputed"].as_u64(), reply["restored"].as_u64()), (Some(2), Some(0)), "{reply}");
}

#[test]
fn redefining_preserves_body_names_participants_and_marker_without_temporary_features() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 20, "width": 10, "height": 5, "name": "Base", "body_name": "Housing"}));
    run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [30, 0, 0], "name": "Other"}));
    let id = s.doc.find_feature("Base").unwrap().id;
    run(&mut s, "timeline.rollback", json!({"position": 1}));
    let before = s.doc.feature(id).unwrap().clone();
    run(&mut s, "timeline.redefine", json!({"feature": id, "command": "solid.box", "params": {"length": 25, "width": 10, "height": 5}}));
    let after = s.doc.feature(id).unwrap();
    assert_eq!(s.doc.features.len(), 2);
    assert_eq!(s.doc.marker, Some(1));
    assert_eq!(after.body_names, before.body_names);
    assert_eq!(after.participants, before.participants);
    assert_eq!(after.param_names, before.param_names);
    assert_eq!(after.name, before.name);
    assert!(s.model.state().body("Housing").is_some());
}

#[test]
fn failed_or_non_feature_redefinitions_leave_session_and_history_intact() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 20, "width": 10, "height": 5, "name": "Base"}));
    run(&mut s, "sketch.create", json!({"plane": "XY"}));
    s.selection = vec![Sel::Feature { id: s.doc.find_feature("Base").unwrap().id }];
    let doc = s.doc.clone();
    let sketch = s.active_sketch;
    let selection = s.selection.clone();
    let undo = s.undo.len();
    for (command, params) in [
        ("solid.cylinder", json!({"radius": 5, "height": 10})),
        ("solid.box", json!({"length": "unknown_parameter", "width": 10, "height": 5})),
        ("file.export", json!({"path": "should-not-be-created.step"})),
        ("edit.undo", json!({})),
    ] {
        assert!(s.execute("timeline.redefine", &json!({"feature": "Base", "command": command, "params": params})).is_err());
        assert_eq!(*s.doc, *doc, "{command}");
        assert_eq!(s.active_sketch, sketch, "{command}");
        assert_eq!(s.selection, selection, "{command}");
        assert_eq!(s.undo.len(), undo, "{command}");
    }
}

#[test]
fn redefining_an_extrude_names_new_optional_inputs() {
    let mut s = Session::default();
    run(&mut s, "sketch.create", json!({"plane": "XY"}));
    run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [10, 10]}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"distance": 5, "name": "Pad"}));
    let distance = s.doc.find_feature("Pad").unwrap().param_names[0].clone();
    run(&mut s, "timeline.redefine", json!({"feature": "Pad", "command": "solid.extrude", "params": {"distance": 5, "start_offset": 2}}));
    let f = s.doc.find_feature("Pad").unwrap();
    assert_eq!(f.param_names.len(), f.kind.inputs().len());
    assert_eq!(f.param_names[0], distance);
    assert!(f.param_names.iter().all(|name| !name.is_empty()));
    assert_eq!(s.doc.features.len(), 2);
    let offset = s.doc.find_feature("Pad").unwrap().param_names.last().unwrap().clone();
    run(
        &mut s,
        "timeline.redefine",
        json!({"feature": "Pad", "command": "solid.extrude", "params": {"distance": 5, "distance2": 2, "start_offset": 2}}),
    );
    let f = s.doc.find_feature("Pad").unwrap();
    let inputs = f.kind.inputs();
    let offset_index = inputs.iter().position(|(label, _, _)| *label == "Start offset").unwrap();
    assert_eq!(f.param_names[offset_index], offset, "adding Distance 2 must not steal the offset dimension's parameter name");
    let distance2_index = inputs.iter().position(|(label, _, _)| *label == "Distance 2").unwrap();
    assert_ne!(f.param_names[distance2_index], offset);
}

#[test]
fn redefining_a_shell_replaces_persistent_face_selection() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20, "name": "Base"}));
    run(&mut s, "solid.shell", json!({"faces": [[20, 15, 20]], "thickness": 2, "name": "Hollow"}));
    let before = s.doc.find_feature("Hollow").unwrap().face_names.clone();
    assert!(!before.is_empty());
    run(&mut s, "timeline.redefine", json!({"feature": "Hollow", "command": "solid.shell", "params": {"faces": [[20, 15, 0]], "thickness": 2}}));
    let after = s.doc.find_feature("Hollow").unwrap().face_names.clone();
    assert!(!after.is_empty());
    assert_ne!(before, after);
    run(&mut s, "timeline.edit", json!({"feature": "Base", "set": {"height": "30"}}));
    let id = s.doc.find_feature("Hollow").unwrap().id;
    assert!(s.model.result(id).unwrap().error.is_none());
    assert!(s.model.result(id).unwrap().warning.is_none());
    assert_eq!(s.doc.find_feature("Hollow").unwrap().face_names, after);
}

#[test]
fn redefine_rejects_sheet_exports_before_they_touch_any_files() {
    let mut s = Session::default();
    run(&mut s, "sketch.create", json!({"plane": "XY"}));
    run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [30, 20]}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "sheet.flange", json!({"name": "Plate"}));
    let doc = s.doc.clone();
    let base = std::env::temp_dir().join(format!("solidcraft-redefine-export-{}", std::process::id()));
    std::fs::create_dir_all(&base).unwrap();
    for command in ["sheet.export_dxf", "sheet.export_bend_table"] {
        for existing in [false, true] {
            let path = base.join(format!("{}-{existing}.out", command.replace('.', "-")));
            if existing {
                std::fs::write(&path, b"original file").unwrap();
            } else if path.exists() {
                std::fs::remove_file(&path).unwrap();
            }
            let error = s.execute("timeline.redefine", &json!({"feature": "Plate", "command": command, "params": {"path": path}})).unwrap_err();
            assert!(error.to_string().contains("does not make a feature"), "{error}");
            assert_eq!(*s.doc, *doc);
            if existing {
                assert_eq!(std::fs::read(&path).unwrap(), b"original file");
                std::fs::remove_file(&path).unwrap();
            } else {
                assert!(!path.exists(), "{command} must not create a file before refusing the edit");
            }
        }
    }
    for command in ["sheet.manage_rules", "sheet.rules", "sheet.flat_pattern", "parameters.list", "plastic.manage_rules"] {
        let error = s.execute("timeline.redefine", &json!({"feature": "Plate", "command": command, "params": {"name": "unexpected"}})).unwrap_err();
        assert!(error.to_string().contains("does not make a feature"), "{error}");
        assert_eq!(*s.doc, *doc);
    }
    std::fs::remove_dir(&base).unwrap();
}

#[test]
fn redefine_keeps_allocator_above_component_and_occurrence_ids() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 20, "width": 20, "height": 10, "body_name": "Base"}));
    run(&mut s, "solid.box", json!({"length": 20, "width": 20, "height": 10, "corner": [10, 0, 0], "body_name": "Tool"}));
    run(&mut s, "solid.combine", json!({"target": "Base", "tools": ["Tool"], "name": "Join"}));
    let original = s.doc.clone();
    let original_feature = s.doc.find_feature("Join").unwrap().id;
    run(
        &mut s,
        "timeline.redefine",
        json!({"feature": "Join", "command": "solid.combine", "params": {"target": "Base", "tools": ["Tool"], "new_component": true, "component_name": "Merged"}}),
    );
    let destination = s.doc.find_component("Merged").unwrap();
    assert_eq!(s.model.state().body("Base").unwrap().component, destination);
    assert_eq!(s.doc.find_feature("Join").unwrap().id, original_feature);
    let combine_index = s.doc.feature_index(original_feature).unwrap();
    assert!(
        matches!(&s.doc.features[combine_index + 1].kind, solidcraft_doc::FeatureKind::BodyTransfer { bodies, to, .. } if bodies == &["Base"] && *to == destination)
    );
    assert!((solidcraft_kernel::measure(&s.world_state().unwrap().body("Base").unwrap().body).unwrap().volume - 6000.0).abs() < 1e-6);
    assert_eq!(s.world_state().unwrap().bodies.len(), 1);
    run(&mut s, "timeline.rollback", json!({"position":combine_index + 1}));
    assert_eq!(s.world_state().unwrap().body("Base").unwrap().component, 0, "the result transfers only AFTER Combine");
    run(&mut s, "edit.undo", json!({}));
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(*s.doc, *original);
    run(&mut s, "edit.redo", json!({}));
    let reopened = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
    assert_eq!(reopened.world_state().unwrap().body("Base").unwrap().component, destination);
    assert!((solidcraft_kernel::measure(&reopened.world_state().unwrap().body("Base").unwrap().body).unwrap().volume - 6000.0).abs() < 1e-6);
    let max_id =
        s.doc.components.iter().map(|c| c.id).chain(s.doc.occurrences.iter().map(|o| o.id)).chain(s.doc.features.iter().map(|f| f.id)).max().unwrap();
    assert!(s.doc.next_id > max_id);
    run(&mut s, "component.create", json!({"name": "Next", "parent": 0}));
    run(&mut s, "solid.box", json!({"length": 2, "width": 2, "height": 2}));
    let ids: Vec<u64> =
        s.doc.components.iter().map(|c| c.id).chain(s.doc.occurrences.iter().map(|o| o.id)).chain(s.doc.features.iter().map(|f| f.id)).collect();
    let unique: std::collections::BTreeSet<u64> = ids.iter().copied().collect();
    assert_eq!(ids.len(), unique.len(), "feature, component and occurrence ids must remain unique: {ids:?}");
}

#[test]
fn redefine_cannot_publish_a_second_transfer_that_breaks_existing_ownership() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length":2,"width":2,"height":2,"body_name":"Base"}));
    run(&mut s, "solid.box", json!({"length":2,"width":2,"height":2,"corner":[1,0,0],"body_name":"Tool"}));
    run(&mut s, "solid.combine", json!({"target":"Base","tools":["Tool"],"name":"Join","new_component":true,"component_name":"Original"}));
    let full = s.doc.to_json();
    let join_index = s.doc.features.iter().position(|feature| feature.name == "Join").unwrap();
    for marker in [None, Some(join_index), Some(join_index + 1)] {
        let mut s = Session::new(solidcraft_doc::Document::from_json(&full).unwrap());
        s.doc_mut().marker = marker;
        s.refresh();
        let before = s.doc.to_json();
        let pending = s.pending_moves.clone();
        let error = s.execute("timeline.redefine", &json!({"feature":"Join","command":"solid.combine","params":{"target":"Base","tools":["Tool"],"new_component":true,"component_name":"Duplicate"}})).unwrap_err();
        assert!(error.to_string().contains("transfer source component"), "marker {marker:?}: {error}");
        assert_eq!(s.doc.to_json(), before);
        assert_eq!(s.pending_moves, pending);
    }
    let reopened = Session::new(solidcraft_doc::Document::from_json(&full).unwrap());
    assert_eq!(reopened.world_state().unwrap().body("Base").unwrap().component, reopened.doc.find_component("Original").unwrap());
    assert!(reopened.doc.features.iter().all(|feature| reopened.model.result(feature.id).is_some_and(|result| result.error.is_none())));
}

#[test]
fn redefine_maps_placement_inputs_in_the_feature_owner_frame() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 4, "width": 4, "height": 4, "name": "RootBox", "body_name": "RootBody"}));
    let owner = run(&mut s, "component.create", json!({"name": "Owner", "grounded": false}));
    run(&mut s, "solid.box", json!({"length": 4, "width": 4, "height": 4, "corner": [10, 0, 0], "name": "OwnedBox", "body_name": "OwnedBody"}));
    run(&mut s, "solid.fillet", json!({"edges": [[12, 0, 4]], "radius": 0.5, "body": "OwnedBody", "name": "OwnerRound"}));
    run(&mut s, "occurrence.move", json!({"occurrence": owner["occurrence"], "translate": [100, 0, 0]}));
    let other = run(&mut s, "component.create", json!({"name": "Other", "parent": 0}));
    run(&mut s, "occurrence.move", json!({"occurrence": other["occurrence"], "translate": [200, 0, 0]}));
    let active = s.active_component;
    run(
        &mut s,
        "timeline.redefine",
        json!({"feature": "RootBox", "command": "solid.box", "params": {"length": 4, "width": 4, "height": 4, "corner": [2, 0, 0]}}),
    );
    run(
        &mut s,
        "timeline.redefine",
        json!({"feature": "OwnedBox", "command": "solid.box", "params": {"length": 4, "width": 4, "height": 4, "corner": [110, 0, 0]}}),
    );
    run(
        &mut s,
        "timeline.redefine",
        json!({"feature": "OwnerRound", "command": "solid.fillet", "params": {"edges": [[112, 0, 4]], "radius": 0.75, "body": "OwnedBody"}}),
    );
    assert_eq!(s.active_component, active, "editing must not activate the owner in the real session");
    assert_eq!(s.doc.find_feature("OwnedBox").unwrap().component, owner["component"].as_u64().unwrap());
    let root = run(&mut s, "inspect.measure", json!({"bodies": ["RootBody"]}));
    let owned = run(&mut s, "inspect.measure", json!({"bodies": ["OwnedBody"]}));
    assert!((root["bodies"][0]["bbox"]["min"][0].as_f64().unwrap() - 2.0).abs() < 1e-8);
    assert!((owned["bodies"][0]["bbox"]["min"][0].as_f64().unwrap() - 110.0).abs() < 1e-8);
}

#[test]
fn redefining_fillet_style_keeps_primary_parameter_and_downstream_references() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 20, "height": 30}));
    run(&mut s, "solid.fillet", json!({"edges": [[10, 10, 30]], "radius": 2, "name": "Round"}));
    let parameter = s.doc.find_feature("Round").unwrap().param_names[0].clone();
    run(&mut s, "solid.box", json!({"length": parameter, "width": 2, "height": 2, "corner": [50, 0, 0], "name": "Dependent"}));
    run(
        &mut s,
        "timeline.redefine",
        json!({"feature": "Round", "command": "solid.fillet", "params": {"edges": [[10, 10, 30]], "radius": 3, "type": "chord"}}),
    );
    assert_eq!(s.doc.find_feature("Round").unwrap().param_names[0], parameter);
    let dependent = s.doc.find_feature("Dependent").unwrap().id;
    assert!(s.model.result(dependent).unwrap().error.is_none());
    let value = run(&mut s, "expr.evaluate", json!({"expression": parameter}));
    assert_eq!(value["value"], 3.0);
}

#[test]
fn inserting_variable_fillet_control_preserves_parameters_at_existing_positions() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 20, "height": 30}));
    run(
        &mut s,
        "solid.fillet",
        json!({"edges": [[10, 10, 30]], "radius": 2, "radius2": 2, "type": "variable", "start": [10, 0, 30], "mid": [[0.25, 3], [0.75, 4]], "name": "Round"}),
    );
    let parameters = s.doc.find_feature("Round").unwrap().param_names.clone();
    run(&mut s, "solid.box", json!({"length": parameters[2], "width": parameters[3], "height": 2, "corner": [50, 0, 0], "name": "Dependent"}));
    run(
        &mut s,
        "timeline.redefine",
        json!({"feature": "Round", "command": "solid.fillet", "params": {"edges": [[10, 10, 30]], "radius": 2, "radius2": 2, "type": "variable", "start": [10, 0, 30], "mid": [[0.1, 2.5], [0.25, 3], [0.75, 4]]}}),
    );
    let edited = s.doc.find_feature("Round").unwrap();
    assert_eq!(edited.param_names[0..2], parameters[0..2]);
    assert_eq!(edited.param_names[3..5], parameters[2..4]);
    assert!(!parameters.contains(&edited.param_names[2]), "the inserted control needs a new dimension");
    let dependent = s.doc.find_feature("Dependent").unwrap().id;
    assert!(s.model.result(dependent).unwrap().error.is_none());
    let length = run(&mut s, "expr.evaluate", json!({"expression": parameters[2]}));
    let width = run(&mut s, "expr.evaluate", json!({"expression": parameters[3]}));
    assert_eq!(length["value"], 3.0);
    assert_eq!(width["value"], 4.0);
}

#[test]
fn timeline_folders_are_command_backed_saved_undoable_and_follow_feature_ids() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "name": "Base"}));
    run(&mut s, "solid.fillet", json!({"edges": [[10, 5, 10]], "radius": 1, "name": "Round"}));
    let base = s.doc.find_feature("Base").unwrap().id;
    let round = s.doc.find_feature("Round").unwrap().id;

    let made = run(&mut s, "timeline.group", json!({"name": "Housing", "features": ["Base", round]}));
    let group = made["group"].as_u64().unwrap();
    assert_eq!(s.doc.timeline_groups[0].features, vec![base, round]);
    run(&mut s, "timeline.rename", json!({"feature": base, "name": "Foundation"}));
    assert_eq!(s.doc.timeline_groups[0].features, vec![base, round], "folders follow stable ids, not names");
    run(&mut s, "timeline.rename_group", json!({"group": group, "name": "Main housing"}));
    run(&mut s, "timeline.move_to_group", json!({"features": [round], "group": null}));
    assert_eq!(s.doc.timeline_groups[0].features, vec![base]);

    let reopened = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
    assert_eq!(reopened.timeline_groups, s.doc.timeline_groups);
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(s.doc.timeline_groups[0].features, vec![base, round]);
    run(&mut s, "timeline.delete", json!({"features": [base]}));
    assert_eq!(s.doc.timeline_groups[0].features, vec![round], "deleted features leave folders cleanly");
    run(&mut s, "timeline.ungroup", json!({"group": group}));
    assert!(s.doc.timeline_groups.is_empty());
}

/// #9373: editing a feature inside a timeline folder left the id of the edit's trial feature in
/// the folder and gave that id out again, so every edit there added it once more, and a feature
/// made later took it and was listed twice: the saved design then would not open. Edited, the
/// folder keeps its own features, once each, and the design opens again.
#[test]
fn editing_a_feature_inside_a_folder_leaves_the_folder_as_it_was() {
    let mut s = Session::default();
    for (name, height) in [("Base", 10), ("Post", 20), ("Pin", 30)] {
        run(&mut s, "solid.box", json!({"length": 4, "width": 4, "height": height, "operation": "new", "name": name}));
    }
    let ids: Vec<u64> = s.doc.features.iter().map(|f| f.id).collect();
    run(&mut s, "timeline.group", json!({"name": "Parts", "features": ids}));
    for width in [5, 6, 7] {
        run(&mut s, "timeline.redefine", json!({"feature": "Post", "command": "solid.box", "params": {"length": 4, "width": width, "height": 20}}));
    }
    assert_eq!(s.doc.timeline_groups[0].features, ids, "no trial feature is left in the folder");
    let made =
        run(&mut s, "solid.box", json!({"length": 2, "width": 2, "height": 2, "operation": "new", "name": "Later"}))["feature"].as_u64().unwrap();
    assert!(!s.doc.timeline_groups[0].features.contains(&made), "a feature made after the folder is not in it");
    let reopened = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
    assert_eq!(reopened.timeline_groups, s.doc.timeline_groups);
}

#[test]
fn timeline_reorders_selected_features_as_one_block_and_removes_folders_in_one_step() {
    let mut s = Session::default();
    for (name, body, x) in [("First", "FirstBody", 0), ("Second", "SecondBody", 20), ("Third", "ThirdBody", 40)] {
        run(
            &mut s,
            "solid.box",
            json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0], "operation": "new_body", "name": name, "body_name": body}),
        );
    }
    let names = |session: &Session| session.doc.features.iter().map(|feature| feature.name.clone()).collect::<Vec<_>>();
    assert_eq!(names(&s), vec!["First", "Second", "Third"]);

    run(&mut s, "timeline.reorder_many", json!({"features": ["First", "Third"], "position": 3}));
    assert_eq!(names(&s), vec!["Second", "First", "Third"], "selected features keep their relative order");
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(names(&s), vec!["First", "Second", "Third"]);
    run(&mut s, "edit.redo", json!({}));
    assert_eq!(names(&s), vec!["Second", "First", "Third"]);
    run(&mut s, "edit.undo", json!({}));

    let first = run(&mut s, "timeline.group", json!({"name": "One", "features": ["First"]}))["group"].as_u64().unwrap();
    run(&mut s, "edit.undo", json!({}));
    assert!(s.doc.timeline_groups.is_empty(), "creating a folder is undoable");
    run(&mut s, "edit.redo", json!({}));
    assert_eq!(s.doc.timeline_groups.first().map(|group| group.id), Some(first));
    let second = run(&mut s, "timeline.group", json!({"name": "Two", "features": ["Second"]}))["group"].as_u64().unwrap();
    run(&mut s, "timeline.ungroup", json!({"groups": [first, second]}));
    assert!(s.doc.timeline_groups.is_empty());
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(s.doc.timeline_groups.len(), 2, "removing several folders is one undoable command");
    run(&mut s, "edit.redo", json!({}));
    assert!(s.doc.timeline_groups.is_empty(), "removing folders is redoable");
}

#[test]
fn timeline_folders_refuse_unknown_non_contiguous_and_split_contents() {
    let mut s = Session::default();
    for (name, body, x) in [("First", "FirstBody", 0), ("Second", "SecondBody", 20), ("Third", "ThirdBody", 40)] {
        run(
            &mut s,
            "solid.box",
            json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0], "operation": "new_body", "name": name, "body_name": body}),
        );
    }
    let before = s.doc.clone();
    let error = s.execute("timeline.group", &json!({"features": ["First", "Third"]})).unwrap_err().to_string();
    assert!(error.contains("contiguous"), "{error}");
    assert_eq!(s.doc, before);

    let group = run(&mut s, "timeline.group", json!({"name": "Pair", "features": ["First", "Second"]}))["group"].as_u64().unwrap();
    let before = s.doc.clone();
    let error = s.execute("timeline.reorder_many", &json!({"features": ["First"], "position": 3})).unwrap_err().to_string();
    assert!(error.contains("contiguous"), "{error}");
    assert_eq!(s.doc, before, "a refused reorder must not split the folder");

    for params in [json!({"features": [999_u64], "group": group}), json!({"groups": [999_u64], "group": group})] {
        let error = s.execute("timeline.move_to_group", &params).unwrap_err().to_string();
        assert!(error.contains("no feature") || error.contains("no timeline folder"), "{error}");
    }

    let mut damaged: Value = serde_json::from_str(&s.doc.to_json()).unwrap();
    let first = s.doc.find_feature("First").unwrap().id;
    let third = s.doc.find_feature("Third").unwrap().id;
    damaged["timeline_groups"] = json!([{"id": 1, "name": "Broken", "features": [first, third]}]);
    let error = solidcraft_doc::Document::from_json(&damaged.to_string()).unwrap_err().to_string();
    assert!(error.contains("not contiguous"), "{error}");
}

#[test]
fn deleted_timeline_group_ids_are_not_reused_after_reopening() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "name": "Block"}));
    let params = json!({"features": ["Block"]});
    let first = run(&mut s, "timeline.group", params.clone())["group"].as_u64().unwrap();
    run(&mut s, "timeline.ungroup", json!({"group": first}));
    let doc = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
    *s.doc_mut() = doc;
    let second = run(&mut s, "timeline.group", params)["group"].as_u64().unwrap();
    assert!(second > first, "deleted folder {first} was reused as {second}");
    assert!(s.execute("timeline.rename_group", &json!({"group": first, "name": "Stale reference"})).is_err());
}

#[test]
fn timeline_move_many_is_atomic_and_one_undo_step() {
    let mut s = Session::default();
    for (name, body, x) in [("First", "FirstBody", 0), ("Second", "SecondBody", 20), ("Third", "ThirdBody", 40)] {
        run(
            &mut s,
            "solid.box",
            json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0], "operation": "new_body", "name": name, "body_name": body}),
        );
    }
    let group = run(&mut s, "timeline.group", json!({"name": "Pair", "features": ["First"]}))["group"].as_u64().unwrap();
    let before = (*s.doc).clone();
    run(&mut s, "timeline.move_many", json!({"features": ["Third"], "group": group, "position": 1}));
    assert_eq!(s.doc.features.iter().map(|feature| feature.name.as_str()).collect::<Vec<_>>(), vec!["First", "Third", "Second"]);
    assert_eq!(s.doc.timeline_groups[0].features.len(), 2);
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(*s.doc, before, "one undo restores both order and folder membership");
    run(&mut s, "edit.redo", json!({}));
    assert_eq!(s.doc.timeline_groups[0].features.len(), 2);

    let child = run(&mut s, "timeline.group", json!({"name": "Child", "features": ["Second"]}))["group"].as_u64().unwrap();
    let before_parent = (*s.doc).clone();
    let parent = run(&mut s, "timeline.group", json!({"name": "Parent", "groups": [group, child]}))["group"].as_u64().unwrap();
    assert!(s.doc.timeline_groups.iter().filter(|folder| folder.parent == Some(parent)).count() == 2);
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(*s.doc, before_parent, "creating a parent for selected folders is one undo step");
}

/// `active` moves features across the history marker together with the reorder: one undo step
/// restores both the order and the marker. Before, moving a feature more than one step behind the
//  history marker would need two undo steps: one to retore the order and one to move the marker
#[test]
fn timeline_moves_across_the_marker_are_one_undo_step() {
    let mut s = Session::default();
    for (name, x) in [("A", 0), ("B", 20), ("C", 40), ("D", 60)] {
        run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0], "operation": "new_body", "name": name}));
    }
    run(&mut s, "timeline.roll_to", json!({"position": 2}));
    let names = |s: &Session| s.doc.features.iter().map(|feature| feature.name.clone()).collect::<Vec<_>>();
    let before = (*s.doc).clone();

    // A B | C D: B moves between C and D, rolled back; C stays rolled back.
    run(&mut s, "timeline.move_many", json!({"features": ["B"], "position": 3, "active": false}));
    assert_eq!((names(&s), s.doc.marker), (vec!["A".into(), "C".into(), "B".into(), "D".into()], Some(1)));
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(*s.doc, before, "one undo restores both order and marker");

    // B stays in place and only crosses the marker; and back again with `timeline.reorder`.
    run(&mut s, "timeline.move_many", json!({"features": ["B"], "position": 2, "active": false}));
    assert_eq!((names(&s), s.doc.marker), (vec!["A".into(), "B".into(), "C".into(), "D".into()], Some(1)));
    run(&mut s, "timeline.reorder", json!({"feature": "B", "position": 1, "active": true}));
    assert_eq!(s.doc.marker, Some(2));
    run(&mut s, "timeline.reorder", json!({"feature": "C", "position": 2, "active": true}));
    run(&mut s, "timeline.reorder", json!({"feature": "D", "position": 3, "active": true}));
    assert_eq!(s.doc.marker, None, "every feature active again");

    let undo = s.undo.len();
    let error = s.execute("timeline.reorder", &json!({"feature": "A", "position": 0, "active": false})).unwrap_err().to_string();
    assert!(error.contains("behind the history marker"), "{error}");
    assert_eq!(s.undo.len(), undo, "a refused move adds no undo step");
}

/// #5962: a reorder that breaks a feature is refused unless `allow_errors`; with it the move is
/// made, the reply lists what broke, and one undo puts the order back. For both reorder commands.
#[test]
fn reorder_with_allow_errors_is_made_and_lists_what_broke() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "name": "Base"}));
    run(&mut s, "solid.fillet", json!({"edges": [[10, 5, 10]], "radius": 1, "name": "Round"}));
    let order = |s: &Session| s.doc.features.iter().map(|f| f.name.clone()).collect::<Vec<_>>();
    let before = s.doc.clone();
    for (cmd, params) in
        [("timeline.reorder", json!({"feature": "Round", "position": 0})), ("timeline.reorder_many", json!({"features": ["Round"], "position": 0}))]
    {
        let error = s.execute(cmd, &params).unwrap_err().to_string();
        assert!(error.contains("breaks Round"), "{cmd}: {error}");
        assert_eq!(s.doc, before, "{cmd}: refused, nothing moved");
        let mut anyway = params.clone();
        anyway["allow_errors"] = json!(true);
        let r = run(&mut s, cmd, anyway);
        assert_eq!(order(&s), ["Round", "Base"], "{cmd}");
        let broken = r["broken"].as_array().unwrap();
        assert_eq!(broken.len(), 1, "{cmd}: {r}");
        assert_eq!(broken[0]["feature"], "Round", "{cmd}: {r}");
        assert!(broken[0]["error"].as_str().is_some_and(|e| !e.is_empty()), "{cmd}: {r}");
        run(&mut s, "edit.undo", json!({}));
        assert_eq!(s.doc, before, "{cmd}: one undo puts the order back");
    }
    // A move that breaks nothing says so, and refuses anything but a boolean.
    run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [20, 0, 0], "operation": "new", "name": "Other"}));
    let r = run(&mut s, "timeline.reorder_many", json!({"features": ["Other"], "position": 0, "allow_errors": true}));
    assert_eq!(r["broken"], json!([]));
    assert!(s.execute("timeline.reorder", &json!({"feature": "Other", "position": 2, "allow_errors": "yes"})).is_err());
    // `reorder_many` takes `active` too: the moved feature ends up behind the history marker.
    run(&mut s, "timeline.reorder_many", json!({"features": ["Other"], "position": 3, "active": false}));
    assert_eq!(order(&s).last().map(String::as_str), Some("Other"));
    assert_eq!(s.doc.marker, Some(2));
}

#[test]
fn failed_timeline_move_many_keeps_folder_membership_and_order() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "name": "Base"}));
    run(&mut s, "solid.fillet", json!({"edges": [[10, 5, 10]], "radius": 1, "name": "Round"}));
    let group = run(&mut s, "timeline.group", json!({"name": "Destination"}))["group"].as_u64().unwrap();
    let before = s.doc.clone();
    let undo = s.undo.len();
    let error = s.execute("timeline.move_many", &json!({"features": ["Base"], "group": group, "position": 2})).unwrap_err().to_string();
    assert!(error.contains("breaks"), "{error}");
    assert_eq!(s.doc, before);
    assert_eq!(s.undo.len(), undo, "a refused atomic move adds no undo step");
}

#[test]
fn timeline_folders_can_nest_and_reject_cycles() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "name": "Base"}));
    let root = run(&mut s, "timeline.group", json!({"name": "Root"}))["group"].as_u64().unwrap();
    let child = run(&mut s, "timeline.group", json!({"name": "Child", "parent": root}))["group"].as_u64().unwrap();
    assert_eq!(s.doc.timeline_groups.iter().find(|group| group.id == child).unwrap().parent, Some(root));
    run(&mut s, "timeline.move_to_group", json!({"groups": [child], "group": null}));
    assert_eq!(s.doc.timeline_groups.iter().find(|group| group.id == child).unwrap().parent, None);
    run(&mut s, "timeline.move_to_group", json!({"groups": [child], "group": root}));
    let error = s.execute("timeline.move_to_group", &json!({"groups": [root], "group": child})).unwrap_err().to_string();
    assert!(error.contains("itself") || error.contains("descendant"), "{error}");
    let before = s.doc.clone();
    let error = s.execute("timeline.move_many", &json!({"groups": [root], "group": child, "position": 0})).unwrap_err().to_string();
    assert!(error.contains("itself") || error.contains("descendant"), "{error}");
    assert_eq!(s.doc, before);
    let reopened = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
    assert_eq!(reopened.timeline_groups, s.doc.timeline_groups);
    run(&mut s, "timeline.ungroup", json!({"group": root}));
    assert_eq!(s.doc.timeline_groups.iter().find(|group| group.id == child).unwrap().parent, None, "deleting a folder promotes its children");
}

/// Four separate boxes, `First`…`Fourth`, for the timeline folder tests.
fn four_boxes() -> Session {
    let mut s = Session::default();
    for (i, name) in ["First", "Second", "Third", "Fourth"].into_iter().enumerate() {
        let corner = [20 * i, 0, 0];
        run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": corner, "operation": "new_body", "name": name}));
    }
    s
}

fn feature_names(s: &Session) -> Vec<String> {
    s.doc.features.iter().map(|feature| feature.name.clone()).collect()
}

#[test]
fn timeline_keys_distinguish_numeric_names_from_ids() {
    let mut s = four_boxes();
    let id = s.doc.find_feature("Second").unwrap().id;
    let named = s.doc.find_feature("Third").unwrap().id;
    let key = id.to_string();
    run(&mut s, "timeline.rename", json!({"feature": named, "name": key}));

    assert_eq!(run(&mut s, "timeline.inspect", json!({"feature": key}))["id"], named);
    assert_eq!(run(&mut s, "timeline.inspect", json!({"feature": id}))["id"], id);
    assert_eq!(run(&mut s, "timeline.inspect", json!({"feature": named.to_string()}))["id"], named);
    assert_eq!(run(&mut s, "timeline.copy", json!({"features": [key, id]}))["copied"], json!(["Second", key]));

    // Resolve the whole request before deleting: a repeated name must not turn into an id
    // after the first deletion removes the feature with that name.
    assert_eq!(run(&mut s, "timeline.delete", json!({"features": [key, key]}))["deleted"], json!([named]));
    assert!(s.doc.feature(id).is_some());
    run(&mut s, "edit.undo", json!({}));
    run(&mut s, "selection.delete", json!({"items": [Sel::Feature { id }]}));
    assert!(s.doc.feature(id).is_none());
    assert!(s.doc.feature(named).is_some());
}

#[test]
fn timeline_keys_prefer_exact_case_and_refuse_an_ambiguous_fallback() {
    let mut s = four_boxes();
    let second = s.doc.find_feature("Second").unwrap().id;
    let third = s.doc.find_feature("Third").unwrap().id;
    run(&mut s, "timeline.rename", json!({"feature": third, "name": "second"}));

    let before = s.doc.clone();
    let error = s.execute("timeline.delete", &json!({"features": ["First", "SECOND"]})).unwrap_err().to_string();
    assert!(error.contains("ambiguous"), "{error}");
    assert_eq!(s.doc, before);
    assert_eq!(run(&mut s, "timeline.inspect", json!({"feature": "Second"}))["id"], second);
    assert_eq!(run(&mut s, "timeline.suppress", json!({"feature": "second"}))["feature"], third);
    assert_eq!(run(&mut s, "timeline.inspect", json!({"feature": "FIRST"}))["name"], "First");
}

/// `timeline.delete {groups}` deletes a folder with its features and nested folders in one undo
/// step; other folders and features stay, and `timeline.ungroup` still keeps the features (#7219).
#[test]
fn timeline_delete_takes_a_folder_with_its_features_and_nested_folders() {
    let mut s = four_boxes();
    let outer = run(&mut s, "timeline.group", json!({"name": "Outer", "features": ["Second"]}))["group"].as_u64().unwrap();
    let inner = run(&mut s, "timeline.group", json!({"name": "Inner", "features": ["Third"], "parent": outer}))["group"].as_u64().unwrap();
    let keep = run(&mut s, "timeline.group", json!({"name": "Keep", "features": ["Fourth"]}))["group"].as_u64().unwrap();
    let before = s.doc.clone();

    let out = run(&mut s, "timeline.delete", json!({"groups": [outer]}));
    assert_eq!(feature_names(&s), ["First", "Fourth"]);
    assert_eq!(out["groups"], json!([outer, inner]), "{out}");
    assert_eq!(s.doc.timeline_groups.iter().map(|group| group.id).collect::<Vec<_>>(), [keep], "the nested folder goes too");
    assert_eq!(s.model.state().bodies.len(), 2);
    let reopened = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
    assert_eq!(reopened.timeline_groups, s.doc.timeline_groups);

    run(&mut s, "edit.undo", json!({}));
    assert_eq!(s.doc.features, before.features, "one undo step brings the features back");
    assert_eq!(s.doc.timeline_groups, before.timeline_groups, "and the folders, nested as they were");
    run(&mut s, "edit.redo", json!({}));
    assert_eq!(feature_names(&s), ["First", "Fourth"]);
    run(&mut s, "edit.undo", json!({}));

    // A folder and a feature outside it in one delete; an empty folder goes on its own.
    run(&mut s, "timeline.delete", json!({"groups": [inner], "features": ["First"]}));
    assert_eq!(feature_names(&s), ["Second", "Fourth"]);
    assert_eq!(s.doc.timeline_groups.iter().map(|group| group.name.as_str()).collect::<Vec<_>>(), ["Outer", "Keep"]);
    let empty = run(&mut s, "timeline.group", json!({"name": "Empty"}))["group"].as_u64().unwrap();
    assert_eq!(run(&mut s, "timeline.delete", json!({"groups": [empty]}))["deleted"], json!([]));
    assert!(!s.doc.timeline_groups.iter().any(|group| group.id == empty));

    let before = s.doc.clone();
    for bad in [json!({"groups": [999_999]}), json!({"groups": ["Outer"]}), json!({"groups": 3}), json!({"groups": []})] {
        assert!(s.execute("timeline.delete", &bad).is_err(), "{bad}");
        assert_eq!(s.doc, before, "{bad}: a refused delete changes nothing");
    }
}

/// `timeline.suppress {groups}` suppresses every feature of a folder and its nested folders in
/// one undo step, toggles like several features do, and works with the marker inside the
/// folder (#7219).
#[test]
fn timeline_suppress_takes_a_folder_with_its_nested_folders() {
    let mut s = four_boxes();
    let outer = run(&mut s, "timeline.group", json!({"name": "Outer", "features": ["Second"]}))["group"].as_u64().unwrap();
    run(&mut s, "timeline.group", json!({"name": "Inner", "features": ["Third"], "parent": outer}));
    let suppressed = |s: &Session| s.doc.features.iter().filter(|feature| feature.suppressed).map(|feature| feature.name.clone()).collect::<Vec<_>>();

    let out = run(&mut s, "timeline.suppress", json!({"groups": [outer]}));
    assert_eq!(out["suppressed"], true);
    assert_eq!(out["groups"], json!([outer]));
    assert_eq!(suppressed(&s), ["Second", "Third"]);
    assert_eq!(s.model.state().bodies.len(), 2);
    let reopened = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
    assert_eq!(reopened.features, s.doc.features);
    run(&mut s, "edit.undo", json!({}));
    assert!(suppressed(&s).is_empty(), "one undo step");
    run(&mut s, "edit.redo", json!({}));
    assert_eq!(suppressed(&s), ["Second", "Third"]);

    // Toggle: all suppressed, so all come back; with one of them active, all are suppressed.
    run(&mut s, "timeline.suppress", json!({"groups": [outer]}));
    assert!(suppressed(&s).is_empty());
    run(&mut s, "timeline.suppress", json!({"feature": "Third"}));
    run(&mut s, "timeline.suppress", json!({"groups": [outer]}));
    assert_eq!(suppressed(&s), ["Second", "Third"]);
    run(&mut s, "timeline.suppress", json!({"groups": [outer], "suppressed": false, "features": ["Fourth"]}));
    assert!(suppressed(&s).is_empty(), "an explicit state, with a feature outside the folder as well");

    // The marker between the folder's features: the folder is suppressed all the same, and the
    // marker stays where it was.
    run(&mut s, "timeline.roll_to", json!({"feature": "Second"}));
    assert_eq!(s.doc.marker, Some(2));
    run(&mut s, "timeline.suppress", json!({"groups": [outer], "suppressed": true}));
    assert_eq!(suppressed(&s), ["Second", "Third"]);
    assert_eq!(s.doc.marker, Some(2));
    assert_eq!(s.model.state().bodies.len(), 1, "only First is before the marker and not suppressed");

    let empty = run(&mut s, "timeline.group", json!({"name": "Empty"}))["group"].as_u64().unwrap();
    let before = s.doc.clone();
    for bad in [json!({"groups": [empty]}), json!({"groups": [999_999]}), json!({"groups": [outer], "suppressed": "yes"})] {
        assert!(s.execute("timeline.suppress", &bad).is_err(), "{bad}");
        assert_eq!(s.doc, before, "{bad}: a refused suppress changes nothing");
    }
}

/// A field the feature's definition doesn't have is refused with the fields it does have,
/// instead of reporting success and changing nothing (#1491).
#[test]
fn edit_refuses_unknown_fields() {
    let mut s = Session::default();
    run(&mut s, "construct.plane.offset", json!({"base": "XZ", "offset": 50, "name": "P"}));
    let e = s.execute("timeline.edit", &json!({"feature": "P", "set": {"offset": "-50"}})).unwrap_err().to_string();
    assert!(e.contains("unknown field `offset`") && e.contains("`plane.distance`"), "{e}");
    let e = s.execute("timeline.edit", &json!({"feature": "P", "set": {"plane": {"dist": "-50"}}})).unwrap_err().to_string();
    assert!(e.contains("unknown field `plane.dist`") && e.contains("`plane.distance`"), "{e}");
    let def = run(&mut s, "timeline.inspect", json!({"feature": "P"}))["definition"].clone();
    assert_eq!(def["plane"]["distance"], json!("50"), "nothing changed: {def}");
    // The field it does have edits as before.
    run(&mut s, "timeline.edit", json!({"feature": "P", "set": {"plane": {"distance": "-50"}}}));
    let def = run(&mut s, "timeline.inspect", json!({"feature": "P"}))["definition"].clone();
    assert_eq!(def["plane"]["distance"], json!("-50"), "{def}");

    // Fields the definition leaves out at their default are still fields: `combine: false`
    // and `bodies: []` aren't shown on a feature mirror, and set them as they are.
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "name": "Base"}));
    run(&mut s, "solid.mirror", json!({"features": ["Base"], "plane": "YZ", "name": "Twin"}));
    run(&mut s, "timeline.edit", json!({"feature": "Twin", "set": {"combine": false, "bodies": []}}));
    run(&mut s, "timeline.edit", json!({"feature": "Twin", "set": {"combine": true}}));
    // An unknown field next to known ones refuses the whole edit.
    let e = s.execute("timeline.edit", &json!({"feature": "Twin", "set": {"combine": false, "flip": true}})).unwrap_err().to_string();
    assert!(e.contains("unknown field `flip`") && e.contains("`combine`") && e.contains("`plane.name`"), "{e}");
    let def = run(&mut s, "timeline.inspect", json!({"feature": "Twin"}))["definition"].clone();
    assert_eq!(def["combine"], json!(true), "{def}");
}

/// The check before a delete (`timeline.dependents`) evaluates on the session's model, so it
/// shares the evaluation cache (#2678): the delete that follows finds the features after the
/// deleted one already computed instead of computing them again. (What it reports is covered by
/// the timeline tests in `tests.rs`.)
#[test]
fn the_dependents_check_leaves_the_delete_its_results() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 60, "width": 20, "height": 10, "name": "Base"}));
    run(&mut s, "solid.box", json!({"corner": [5, 5, 10], "length": 10, "width": 10, "height": 5, "operation": "join", "name": "Boss"}));
    run(&mut s, "solid.cylinder", json!({"base": [40, 10, -1], "radius": 2, "height": 20, "operation": "cut", "name": "Hole"}));
    let report = run(&mut s, "timeline.dependents", json!({"feature": "Boss"}));
    assert_eq!(report, json!({"deleted_with_it": [], "would_fail": []}));
    let hits = |s: &Session| s.model.cache.lock().map(|c| c.hits).unwrap_or(0);
    let before = hits(&s);
    run(&mut s, "timeline.delete", json!({"features": ["Boss"]}));
    assert!(hits(&s) > before, "the delete takes the hole the check computed from the cache");
    let volume = run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap();
    assert!((volume - (12000.0 - std::f64::consts::PI * 4.0 * 10.0)).abs() < 1.0, "{volume}");
}

fn suppressed(s: &Session, name: &str) -> bool {
    s.doc.find_feature(name).unwrap().suppressed
}

/// timeline.suppress takes `features: [..]` as timeline.delete does, as one undo step; it used to
/// refuse it ("`feature` must be an id or name").
#[test]
fn suppress_takes_a_list_of_features_as_one_undo_step() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "name": "A"}));
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [20, 0, 0], "name": "B"}));
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [40, 0, 0], "name": "C"}));
    let id = |s: &Session, name: &str| s.doc.find_feature(name).unwrap().id;
    let undo = s.undo.len();
    let a = id(&s, "A");
    let r = run(&mut s, "timeline.suppress", json!({"features": [a, "B"], "suppressed": true}));
    assert_eq!(r, json!({"features": [id(&s, "A"), id(&s, "B")], "suppressed": true}));
    assert!(suppressed(&s, "A") && suppressed(&s, "B") && !suppressed(&s, "C"));
    assert_eq!(s.undo.len(), undo + 1, "one undo step");
    assert_eq!(s.model.state().bodies.len(), 1);
    run(&mut s, "edit.undo", json!({}));
    assert!(!suppressed(&s, "A") && !suppressed(&s, "B"));
    assert_eq!(s.model.state().bodies.len(), 3);

    // Toggling several: all suppressed unless all already are, then all unsuppressed.
    run(&mut s, "timeline.suppress", json!({"feature": "A"}));
    run(&mut s, "timeline.suppress", json!({"features": ["A", "B", "C"]}));
    assert!(suppressed(&s, "A") && suppressed(&s, "B") && suppressed(&s, "C"));
    run(&mut s, "timeline.suppress", json!({"features": ["A", "B", "C"]}));
    assert!(!suppressed(&s, "A") && !suppressed(&s, "B") && !suppressed(&s, "C"));
    // `feature` and `features` together; a repeat counts once.
    let r = run(&mut s, "timeline.suppress", json!({"feature": "C", "features": ["C", "B"], "suppressed": true}));
    assert_eq!(r["features"], json!([id(&s, "C"), id(&s, "B")]), "{r}");
    assert!(!suppressed(&s, "A") && suppressed(&s, "B") && suppressed(&s, "C"));
    // A single `feature` replies as before.
    let r = run(&mut s, "timeline.suppress", json!({"feature": "C", "suppressed": false}));
    assert_eq!(r, json!({"feature": id(&s, "C"), "suppressed": false}));

    // An unknown feature in the list refuses the whole command, as do no features at all.
    let before = (*s.doc).clone();
    let undo = s.undo.len();
    for bad in [
        json!({"features": ["A", "Nope"], "suppressed": true}),
        json!({"features": []}),
        json!({}),
        json!({"features": [{}]}),
        json!({"features": ["A"], "suppressed": "yes"}),
    ] {
        assert!(s.execute("timeline.suppress", &bad).is_err(), "{bad}");
    }
    assert_eq!(*s.doc, before);
    assert_eq!(s.undo.len(), undo);
    // timeline.delete takes either.
    run(&mut s, "timeline.delete", json!({"feature": "C"}));
    run(&mut s, "timeline.delete", json!({"features": ["B"]}));
    assert!(s.doc.find_feature("B").is_none() && s.doc.find_feature("C").is_none());
}

/// #4302: suppressing a feature that made a counted body (`Body1`) leaves the counted bodies of
/// later features as they were: `Body2` used to become `Body1`, and a Move of `Body2` failed.
#[test]
fn suppressing_a_feature_keeps_later_counted_body_names() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "name": "A"}));
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [20, 0, 0], "name": "B"}));
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [40, 0, 0], "name": "C"}));
    run(&mut s, "solid.move", json!({"bodies": ["Body2"], "translate": [0, 30, 0], "name": "Move"}));
    let bodies = |s: &Session| -> Vec<(String, String)> {
        let st = s.model.state();
        st.bodies.iter().map(|b| (b.name.clone(), s.doc.feature(b.feature).map(|f| f.name.clone()).unwrap_or_default())).collect()
    };
    let named = |pairs: &[(&str, &str)]| pairs.iter().map(|(b, f)| (b.to_string(), f.to_string())).collect::<Vec<_>>();
    let works = |s: &Session| s.doc.features.iter().all(|f| s.model.result(f.id).is_some_and(|r| r.error.is_none()));
    let moved = |s: &Session| crate::cmd::inspect::measure_json(s.model.state().body("Body2").unwrap())["bbox"]["min"].clone();
    assert_eq!(bodies(&s), named(&[("Body1", "A"), ("Body2", "B"), ("Body3", "C")]));
    let at = moved(&s);

    run(&mut s, "timeline.suppress", json!({"feature": "A", "suppressed": true}));
    assert_eq!(bodies(&s), named(&[("Body2", "B"), ("Body3", "C")]));
    assert!(works(&s), "the Move still finds Body2");
    assert_eq!(moved(&s), at, "and still moves B's body");

    // Back again: A takes its number back, the others keep theirs.
    run(&mut s, "timeline.suppress", json!({"feature": "A", "suppressed": false}));
    assert_eq!(bodies(&s), named(&[("Body1", "A"), ("Body2", "B"), ("Body3", "C")]));
    assert!(works(&s));

    // Several at once: the first one keeps the names of everything after it; undo restores all.
    run(&mut s, "timeline.suppress", json!({"features": ["B", "A"], "suppressed": true}));
    assert_eq!(bodies(&s), named(&[("Body3", "C")]));
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(bodies(&s), named(&[("Body1", "A"), ("Body2", "B"), ("Body3", "C")]));
    assert!(works(&s));

    // A body made while A is suppressed does not take A's `Body1`, so it keeps its name once A is
    // back (it used to be `Body1`, then `Body4`).
    run(&mut s, "timeline.suppress", json!({"feature": "A", "suppressed": true}));
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [60, 0, 0], "name": "D"}));
    assert_eq!(bodies(&s), named(&[("Body2", "B"), ("Body3", "C"), ("Body4", "D")]));
    // Also once the design is opened again with the model its file keeps, which does not keep
    // the names passed by: D computed again from a kept state is still `Body4`.
    let saved = s.model.saved(&s.doc).unwrap();
    let mut reopened = Session::opened(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap(), Some(&saved));
    run(&mut reopened, "timeline.edit", json!({"feature": "D", "set": {"length": "12"}}));
    assert_eq!(bodies(&reopened), named(&[("Body2", "B"), ("Body3", "C"), ("Body4", "D")]));
    run(&mut s, "timeline.suppress", json!({"feature": "A", "suppressed": false}));
    assert_eq!(bodies(&s), named(&[("Body1", "A"), ("Body2", "B"), ("Body3", "C"), ("Body4", "D")]));
    assert!(works(&s));
}

/// Counted body names are pinned when the body is made, as if the user had renamed it: deleting,
/// reordering or rolling back another feature leaves the other bodies' names alone, and a number
/// a deleted feature held is not handed to the next body.
#[test]
fn counted_body_names_stay_when_the_timeline_changes() {
    let mut s = Session::default();
    for (name, x) in [("A", 0), ("B", 20), ("C", 40)] {
        run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0], "name": name}));
    }
    run(&mut s, "solid.move", json!({"bodies": ["Body2"], "translate": [0, 30, 0], "name": "Move"}));
    let bodies = |s: &Session| -> Vec<(String, String)> {
        let st = s.model.state();
        st.bodies.iter().map(|b| (b.name.clone(), s.doc.feature(b.feature).map(|f| f.name.clone()).unwrap_or_default())).collect()
    };
    let named = |pairs: &[(&str, &str)]| pairs.iter().map(|(b, f)| (b.to_string(), f.to_string())).collect::<Vec<_>>();
    let works = |s: &Session| s.doc.features.iter().all(|f| s.model.result(f.id).is_some_and(|r| r.error.is_none()));
    // The names are stored on the features as soon as the bodies exist.
    assert_eq!(s.doc.find_feature("B").map(|f| f.body_names.clone()), Some(vec!["Body2".to_string()]));
    assert!(["Body1", "Body2", "Body3"].iter().all(|n| s.doc.reserved_body_names.contains(*n)));

    // Reordering A behind B: every body keeps its number, wherever it comes in the list.
    run(&mut s, "timeline.reorder", json!({"feature": "A", "position": 2, "active": true}));
    let mut reordered = bodies(&s);
    reordered.sort();
    assert_eq!(reordered, named(&[("Body1", "A"), ("Body2", "B"), ("Body3", "C")]));
    assert!(works(&s));
    run(&mut s, "edit.undo", json!({}));

    // Rolled back to before B and forward again.
    run(&mut s, "timeline.roll_to", json!({"position": 1}));
    run(&mut s, "timeline.roll_to", json!({"position": "end"}));
    assert_eq!(bodies(&s), named(&[("Body1", "A"), ("Body2", "B"), ("Body3", "C")]));

    // Deleting A: B and C keep their names, so the Move still finds Body2.
    run(&mut s, "timeline.delete", json!({"feature": "A"}));
    assert_eq!(bodies(&s), named(&[("Body2", "B"), ("Body3", "C")]));
    assert!(works(&s), "the Move still finds Body2");

    // The number A held is not handed out again.
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [60, 0, 0], "name": "D"}));
    assert_eq!(bodies(&s), named(&[("Body2", "B"), ("Body3", "C"), ("Body4", "D")]));
    // Undo takes the box away, and the number back with it.
    run(&mut s, "edit.undo", json!({}));
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [60, 0, 0], "name": "E"}));
    assert_eq!(bodies(&s), named(&[("Body2", "B"), ("Body3", "C"), ("Body4", "E")]));
}

/// Pinning reads each feature's bodies once and keeps them with the state it read them from;
/// the names it pins and reserves, and the fingerprints it leaves, are those of reading every
/// feature's bodies again: random boxes (named and counted), moves, suppressions, deletions,
/// reorders, undo and redo, against a session that forgets what it read before every command and
/// against fingerprinting the whole timeline again.
#[test]
fn pinning_with_the_bodies_it_read_before_pins_as_reading_them_again() {
    let (mut kept, mut fresh) = (Session::default(), Session::default());
    let mut seed = 0x9e37_79b9_7f4a_7c15u64;
    let mut next = |n: usize| {
        seed ^= seed << 13;
        seed ^= seed >> 7;
        seed ^= seed << 17;
        (seed % n as u64) as usize
    };
    for step in 0..60 {
        let features: Vec<String> = kept.doc.features.iter().map(|f| f.name.clone()).collect();
        let counted: Vec<String> = kept.model.state().bodies.iter().map(|b| b.name.clone()).collect();
        let pick = |names: &[String], k: usize| names.get(k % names.len().max(1)).cloned().unwrap_or_default();
        let x = 15 * step;
        let (id, params) = match next(9) {
            _ if features.len() < 3 => ("solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0]})),
            0 | 1 => ("solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0]})),
            2 => ("solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0], "body_name": format!("Named {step}")})),
            3 => ("solid.move", json!({"bodies": [pick(&counted, next(64))], "translate": [0, 5, 0]})),
            4 => ("timeline.suppress", json!({"feature": pick(&features, next(64)), "suppressed": next(2) == 0})),
            5 => ("timeline.delete", json!({"feature": pick(&features, next(64))})),
            6 => ("timeline.reorder", json!({"feature": pick(&features, next(64)), "position": next(features.len()), "active": true})),
            7 => ("edit.undo", json!({})),
            _ => ("edit.redo", json!({})),
        };
        fresh.made_bodies.clear();
        let (a, b) = (kept.execute(id, &params), fresh.execute(id, &params));
        assert_eq!(a.is_ok(), b.is_ok(), "step {step}: {id} {params}");
        assert_eq!(kept.doc.to_json(), fresh.doc.to_json(), "step {step}: {id} {params}");
        // The fingerprints match the design as fingerprinting the whole timeline again makes them
        // match it: evaluating it again reuses the same results (all, as a rule; the others are
        // computed or taken from the cache the copies share).
        let again = |model: &solidcraft_doc::Model| {
            let mut m = model.clone();
            m.evaluate(&kept.doc);
            m.last_recomputed + m.last_restored
        };
        let mut full = kept.model.clone();
        full.refingerprint(&kept.doc);
        assert_eq!(again(&kept.model), again(&full), "step {step}: {id} {params}");
        assert_eq!(again(&kept.model), again(&fresh.model), "step {step}: {id} {params}");
    }
    assert!(kept.doc.features.len() > 5 && !kept.doc.reserved_body_names.is_empty());
}

/// The value at a dotted path of a definition.
fn dotted<'a>(def: &'a Value, path: &str) -> &'a Value {
    path.split('.').fold(def, |v, k| &v[k])
}

/// The lowest Z of the design's first body.
fn low_z(s: &mut Session) -> f64 {
    let m = run(s, "inspect.measure", json!({}));
    let min = &m["bodies"][0]["bbox"]["min"];
    min[2].as_f64().or_else(|| min["z"].as_f64()).unwrap_or_else(|| panic!("{m}"))
}

/// timeline.edit takes the dotted keys its unknown-field message lists (`plane.distance`), and
/// numbers for expressions, as the feature commands do; both used to be refused.
#[test]
fn edit_takes_dotted_keys_and_numbers_for_expressions() {
    let mut s = Session::default();
    run(&mut s, "sketch.create", json!({"plane": "XY", "offset": 5, "name": "S"}));
    run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [10, 10]}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"distance": 5, "name": "Pad"}));
    let def = |s: &mut Session, f: &str| run(s, "timeline.inspect", json!({"feature": f}))["definition"].clone();

    run(&mut s, "timeline.edit", json!({"feature": "S", "set": {"plane.distance": "8 mm"}}));
    assert_eq!(def(&mut s, "S")["plane"]["distance"], json!("8 mm"));
    assert!((low_z(&mut s) - 8.0).abs() < 1e-9);
    // A bare number is mm, as in sketch.create's `offset`.
    run(&mut s, "timeline.edit", json!({"feature": "S", "set": {"plane.distance": 12}}));
    assert_eq!(def(&mut s, "S")["plane"]["distance"], json!("12"));
    assert!((low_z(&mut s) - 12.0).abs() < 1e-9);
    run(&mut s, "timeline.edit", json!({"feature": "S", "set": {"plane": {"distance": 3.5}}}));
    assert_eq!(def(&mut s, "S")["plane"]["distance"], json!("3.5"));
    // The nested form works as before.
    run(&mut s, "timeline.edit", json!({"feature": "S", "set": {"plane": {"distance": "4"}}}));
    assert!((low_z(&mut s) - 4.0).abs() < 1e-9);

    // Every field the unknown-field message lists is accepted as it is written there.
    let e = s.execute("timeline.edit", &json!({"feature": "S", "set": {"plane.dist": "1"}})).unwrap_err().to_string();
    assert!(e.contains("unknown field `plane.dist`") && e.contains("`plane.distance`"), "{e}");
    let e = s.execute("timeline.edit", &json!({"feature": "S", "set": {"nope": "1"}})).unwrap_err().to_string();
    let listed: Vec<&str> = e.split('`').skip(3).step_by(2).collect();
    assert!(listed.contains(&"plane.distance") && listed.contains(&"plane.type"), "{e}");
    // Not the sketch geometry, which timeline.inspect leaves out and the sketch commands edit.
    assert!(!listed.iter().any(|k| k.starts_with("sketch")), "{e}");
    let now = def(&mut s, "S");
    for key in listed {
        let value = dotted(&now, key).clone();
        run(&mut s, "timeline.edit", json!({"feature": "S", "set": {key: value}}));
    }
    assert_eq!(def(&mut s, "S"), now);

    // Numbers on an extrude, also for an expression the definition leaves out.
    run(&mut s, "timeline.edit", json!({"feature": "Pad", "set": {"extent.distance": 20, "extent": {"taper": 0}}}));
    let d = def(&mut s, "Pad");
    assert_eq!((&d["extent"]["distance"], &d["extent"]["taper"]), (&json!("20"), &json!("0")), "{d}");
    let volume = run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap();
    assert!((volume - 2000.0).abs() < 1e-6, "{volume}");

    // Still refused: a field given twice, unknown dotted fields, a number for a name.
    let before = (*s.doc).clone();
    for (set, says) in [
        (json!({"plane.distance": "1", "plane": {"distance": "2"}}), "given twice"),
        (json!({"plane.wobble": "1"}), "unknown field `plane.wobble`"),
        (json!({"plane.distance.x": "1"}), "invalid feature"),
        (json!({"plane.base.name": 5}), "invalid feature"),
    ] {
        let e = s.execute("timeline.edit", &json!({"feature": "S", "set": set})).unwrap_err().to_string();
        assert!(e.contains(says), "{set}: {e}");
    }
    assert_eq!(*s.doc, before);
}

/// #3044: renaming a feature labels it and builds nothing, so it, its undo and its redo evaluate
/// nothing, and leave the model evaluating the renamed design gives (the result's, the sketch's
/// and the construction plane's names). A rename other features follow is evaluated.
#[test]
fn renaming_a_feature_evaluates_nothing() {
    let mut s = Session::default();
    run(&mut s, "construct.plane.offset", json!({"base": "XY", "offset": 5, "name": "Shelf"}));
    run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Outline"}));
    run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [10, 6]}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"distance": 4, "name": "Plate"}));
    let labels = |s: &Session| {
        let st = s.model.state();
        let results: Vec<String> = s.model.results.iter().map(|r| r.name.clone()).collect();
        let sketches: Vec<String> = st.sketches.iter().map(|k| k.name.clone()).collect();
        let planes: Vec<String> = st.construct.iter().map(|c| c.name.clone()).collect();
        (results, sketches, planes)
    };
    for (feature, name) in [("Outline", "Profile"), ("Plate", "Base plate")] {
        s.evaluations = 0;
        run(&mut s, "timeline.rename", json!({"feature": feature, "name": name}));
        assert_eq!(s.evaluations, 0, "renaming {feature} evaluates nothing");
        let mut fresh = Session::new((*s.doc).clone());
        fresh.refresh();
        assert_eq!(labels(&s), labels(&fresh));
        s.refresh();
        assert_eq!(s.model.last_recomputed, 0, "the next evaluation reuses every result");
    }
    let renamed = labels(&s);
    s.evaluations = 0;
    run(&mut s, "edit.undo", json!({}));
    assert!(labels(&s).0.contains(&"Profile".to_string()) && labels(&s).0.contains(&"Plate".to_string()));
    run(&mut s, "edit.redo", json!({}));
    assert_eq!(labels(&s), renamed);
    assert_eq!(s.evaluations, 0, "undo and redo of a rename evaluate nothing");
    // A sketch on the plane names it by id (#1134): renaming the plane changes no reference,
    // so it now evaluates nothing — the name follows everywhere without a rebuild.
    run(&mut s, "sketch.create", json!({"plane": "Shelf", "name": "Top"}));
    run(&mut s, "sketch.finish", json!({}));
    s.evaluations = 0;
    run(&mut s, "timeline.rename", json!({"feature": "Shelf", "name": "Ledge"}));
    assert_eq!(s.evaluations, 0, "renaming a plane a sketch is built on evaluates nothing");
    assert!(labels(&s).2.contains(&"Ledge".to_string()));
    // A failed pattern's error quotes its source's name (the seed is keyed by id, #1134, and
    // the error is rendered from the source feature at evaluation): renaming the source is
    // evaluated, so the error names it as an evaluation does.
    run(&mut s, "solid.pattern.rectangular", json!({"features": ["Base plate"], "dir1": [0, 0, 1], "count1": 2, "spacing1": 10, "name": "Copies"}));
    let copies = s.doc.find_feature("Copies").unwrap().id;
    let top = s.doc.find_feature("Top").unwrap().id;
    if let Some(solidcraft_doc::FeatureKind::Pattern { features, .. }) = s.doc_mut().feature_mut(copies).map(|f| &mut f.kind) {
        *features = vec![top.into()];
    }
    s.refresh();
    let failed = |s: &Session| s.model.results.iter().filter_map(|r| r.error.clone()).collect::<Vec<_>>();
    assert!(failed(&s).iter().any(|e| e.contains("Top")), "{:?}", failed(&s));
    s.evaluations = 0;
    run(&mut s, "timeline.rename", json!({"feature": "Top", "name": "Lid sketch"}));
    assert!(s.evaluations > 0, "a later error quotes the old name");
    assert!(failed(&s).iter().any(|e| e.contains("Lid sketch")), "{:?}", failed(&s));
    let mut fresh = Session::new((*s.doc).clone());
    fresh.refresh();
    assert_eq!(failed(&s), failed(&fresh));
}

/// #4353: a construction plane is also named outside the features: by a sketch's projection of
/// it, a canvas placed on it and the hidden list. Renaming it renames it there too, and undo
/// takes the old name back.
#[test]
fn renaming_a_plane_keeps_its_projections_canvases_and_hidden_state() {
    let mut s = Session::default();
    run(&mut s, "construct.plane.offset", json!({"base": "XY", "offset": 20, "name": "Shelf"}));
    run(&mut s, "construct.plane.offset", json!({"base": "YZ", "offset": -30, "name": "Guide"}));
    run(&mut s, "browser.visibility", json!({"items": ["Guide"], "visible": false}));
    let mut png = b"\x89PNG\r\n\x1a\n\0\0\0\rIHDR".to_vec();
    png.extend([0, 0, 0, 4, 0, 0, 0, 2, 8, 6, 0, 0, 0, 0, 0, 0, 0]);
    run(&mut s, "canvas.insert", json!({"data": solidcraft_doc::canvas::base64_encode(&png), "plane": "Shelf", "width": 40}));
    run(&mut s, "sketch.create", json!({"plane": "XZ", "name": "Profile"}));
    run(&mut s, "sketch.project", json!({"refs": [{"plane": "Shelf"}]}));
    run(&mut s, "sketch.finish", json!({}));
    let plane_link = |s: &Session| match &s.doc.find_feature("Profile").unwrap().kind {
        solidcraft_doc::FeatureKind::Sketch { sketch, .. } => match &sketch.links[0].source {
            solidcraft_sketch::LinkSource::Plane { name } => name.clone(),
            other => panic!("{other:?}"),
        },
        other => panic!("{other:?}"),
    };
    let canvas_plane = |s: &Session| s.doc.canvases[0].plane.clone();
    let projected_z = |s: &mut Session| {
        let r = run(s, "sketch.inspect", json!({"sketch": "Profile"}));
        r["points"].as_array().unwrap().iter().find(|p| p["link"] == "j1").unwrap()["world"][2].as_f64().unwrap()
    };
    let warnings = |s: &Session| s.model.results.iter().filter_map(|r| r.warning.clone()).collect::<Vec<_>>();
    // The canvas keeps its plane by id (#1134): the rename leaves the reference alone.
    let shelf = s.doc.find_feature("Shelf").unwrap().id;
    run(&mut s, "select.set", json!({"items": [{"type": "plane", "name": "Shelf"}]}));
    run(&mut s, "timeline.rename", json!({"feature": "Shelf", "name": "Ledge"}));
    run(&mut s, "timeline.rename", json!({"feature": "Guide", "name": "Rail"}));
    assert_eq!(plane_link(&s), "Ledge");
    assert_eq!(canvas_plane(&s), solidcraft_doc::PlaneRef::Construction { feature: shelf.into() });
    assert_eq!(s.visibility.hidden_origin, ["Rail"]);
    assert_eq!(s.selection, [Sel::Plane { name: "Ledge".into() }]);
    assert!(warnings(&s).is_empty(), "{:?}", warnings(&s));
    // The projection follows the renamed plane.
    run(&mut s, "timeline.edit", json!({"feature": "Ledge", "set": {"plane.distance": "35"}}));
    assert!((projected_z(&mut s) - 35.0).abs() < 1e-9);
    assert!(warnings(&s).is_empty(), "{:?}", warnings(&s));
    // Undo takes the old name back everywhere in the design, and the sketch finds it again.
    for _ in 0..3 {
        run(&mut s, "edit.undo", json!({}));
    }
    assert_eq!(plane_link(&s), "Shelf");
    assert_eq!(canvas_plane(&s), solidcraft_doc::PlaneRef::Construction { feature: shelf.into() });
    assert_eq!(s.visibility.hidden_origin, ["Guide"], "the hidden plane stays hidden");
    assert!(warnings(&s).is_empty(), "{:?}", warnings(&s));
    assert!((projected_z(&mut s) - 20.0).abs() < 1e-9);
    run(&mut s, "edit.redo", json!({}));
    run(&mut s, "edit.redo", json!({}));
    assert_eq!(s.visibility.hidden_origin, ["Rail"]);
    assert_eq!(plane_link(&s), "Ledge");
}

/// #6186: a reorder evaluates the design once. The model the move was checked on is the one the
/// session keeps, so setting the reordered design finds every result ready: nothing is
/// recomputed or taken from the cache again. The same for `timeline.reorder_many`, whose check
/// starts from the session's results rather than an empty model.
#[test]
fn a_reorder_keeps_the_model_it_was_checked_on() {
    let mut s = Session::default();
    for i in 0..4 {
        run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5 + i, "corner": [i * 10, 0, 0], "operation": "new"}));
    }
    let bodies = |s: &Session| s.model.state().bodies.len();
    run(&mut s, "timeline.reorder", json!({"feature": "Box2", "position": 0}));
    assert_eq!((s.model.last_recomputed, s.model.last_restored), (0, 0), "the checked model was kept");
    assert_eq!(s.doc.features.first().map(|f| f.name.as_str()), Some("Box2"));
    assert_eq!(bodies(&s), 4);
    run(&mut s, "timeline.reorder_many", json!({"features": ["Box4"], "position": 2}));
    assert_eq!((s.model.last_recomputed, s.model.last_restored), (0, 0), "the checked model was kept");
    assert_eq!(s.doc.features.get(2).map(|f| f.name.as_str()), Some("Box4"));
    // The kept model is the design's: evaluating it from scratch gives the same bodies.
    let mut fresh = solidcraft_doc::Model::new();
    fresh.evaluate(&s.doc);
    assert_eq!(fresh.state().bodies.len(), bodies(&s));
}

#[test]
fn select_same_look_uses_resolved_looks_without_document_history_edits_and_refuses_hostile_input() {
    let mut s = Session::default();
    for (name, x) in [("A", 0), ("B", 20), ("C", 40)] {
        run(&mut s, "solid.box", json!({"corner":[x,0,0],"length":10,"width":10,"height":10,"body_name":name}));
    }
    run(&mut s, "appearance.assign", json!({"bodies":["A","B"],"appearance":"ABS - Red"}));
    run(&mut s, "appearance.assign", json!({"bodies":["C"],"appearance":"ABS - Blue"}));
    run(&mut s, "appearance.assign", json!({"body":"C","faces":[[40,5,5]],"appearance":"ABS - Red"}));
    let doc = s.doc.clone();
    let history = (s.undo.len(), s.redo.len(), s.evaluations);
    run(&mut s, "select.same_look", json!({"body":"A"}));
    assert_eq!(s.selection.len(), 3);
    let point = solidcore_record::Vec3::new(40.0, 5.0, 5.0);
    let face = solidcraft_doc::appearance::face_index_at(s.world_state().unwrap().body("C").unwrap(), point).unwrap();
    run(&mut s, "select.set", json!({"items":[Sel::Face {body:"C".into(),index:face,point}]}));
    run(&mut s, "select.same_look", json!({}));
    assert_eq!(s.selection.len(), 3);
    run(&mut s, "select.same_look", json!({"body":"C"}));
    assert_eq!(s.selection, [Sel::Body { name: "C".into() }]);
    let selected = s.selection.clone();
    // Session treats null parameters as the command's empty/default object.
    run(&mut s, "select.same_look", Value::Null);
    for params in [
        json!([]),
        json!({"body":"missing"}),
        json!({"body":"A","face":u64::MAX}),
        json!({"body":"A","face":-1}),
        json!({"body":1}),
        json!({"body":"A","extra":true}),
    ] {
        assert!(s.execute("select.same_look", &params).is_err(), "{params}");
        assert_eq!(s.selection, selected);
    }
    assert!(std::sync::Arc::ptr_eq(&doc, &s.doc));
    assert_eq!(history, (s.undo.len(), s.redo.len(), s.evaluations));
}

/// A body changed by a few hundred features in a row whose names nothing asks for, then
/// filleted: reordering or moving an earlier feature evaluates them all again, and the fillet
/// finds its edge by the names of the body before it, which are worked out from the body before
/// that, and so on back to the start. That walk recursed once per feature and overflowed the
/// window thread's stack (1 MB on Windows), ending the app (#7587, #7926). On a thread with that
/// stack, both moves are made.
#[test]
fn a_move_before_a_long_history_of_one_body_fits_a_window_threads_stack() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "Peg"}));
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [50, 0, 0], "body_name": "Other"}));
    for i in 0..300 {
        run(&mut s, "solid.move", json!({"bodies": ["Peg"], "translate": [0, 0, if i % 2 == 0 { 1 } else { -1 }]}));
    }
    run(&mut s, "solid.fillet", json!({"body": "Peg", "radius": 1, "edges": [[5, 0, 10]]}));
    let other = s.doc.features.get(1).map(|f| f.id).unwrap();
    let fillet = s.doc.features.last().map(|f| f.id).unwrap();
    let moved = std::thread::Builder::new()
        .stack_size(1024 * 1024)
        .spawn(move || {
            run(&mut s, "timeline.reorder", json!({"feature": other, "position": 0}));
            assert!(s.model.result(fillet).is_some_and(|r| r.error.is_none()), "the fillet is made after the reorder");
            run(&mut s, "timeline.move_many", json!({"features": [other], "position": 2}));
            assert_eq!(s.doc.features.get(1).map(|f| f.id), Some(other));
            assert!(s.model.result(fillet).is_some_and(|r| r.error.is_none()), "the fillet is made after the move");
        })
        .unwrap()
        .join();
    assert!(moved.is_ok());
}

#[test]
fn timeline_joint_folders_are_mixed_saved_and_undoable() {
    let mut s = Session::default();
    run(&mut s, "sketch.create", json!({"plane":"XY", "name":"Profile"}));
    run(&mut s, "component.create", json!({"name":"Part"}));
    let joint = run(&mut s, "joint.as_built", json!({"type":"revolute", "a":0, "b":"Part", "name":"Hinge"}))["joint"].as_u64().unwrap();
    let folder = run(&mut s, "timeline.group", json!({"name":"Mixed", "features":["Profile"], "joints":["Hinge", joint]}))["group"].as_u64().unwrap();
    assert_eq!(s.doc.timeline_groups[0].joints, [joint]);
    assert_eq!(s.doc.timeline_groups[0].features.len(), 1);
    assert_eq!(run(&mut s, "timeline.inspect", json!({"group":folder}))["joints"], json!([joint]));
    let saved = s.doc.to_json();
    let reopened = solidcraft_doc::Document::from_json(&saved).unwrap();
    assert_eq!(reopened.to_json(), saved);
    // A folder naming a joint the design doesn't have, or one twice, opens without that entry
    // (#9373).
    let mut damaged: Value = serde_json::from_str(&saved).unwrap();
    damaged["timeline_groups"][0]["joints"] = json!([u64::MAX]);
    assert!(solidcraft_doc::Document::from_json(&damaged.to_string()).unwrap().timeline_groups[0].joints.is_empty());
    damaged["timeline_groups"][0]["joints"] = json!([joint, joint]);
    assert_eq!(solidcraft_doc::Document::from_json(&damaged.to_string()).unwrap().timeline_groups[0].joints, [joint]);
    let destination = run(&mut s, "timeline.group", json!({"name":"Destination"}))["group"].as_u64().unwrap();
    run(&mut s, "timeline.move_to_group", json!({"joints":[joint], "group":destination}));
    assert!(s.doc.timeline_groups[0].joints.is_empty());
    assert_eq!(s.doc.timeline_groups[1].joints, [joint]);
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(s.doc.timeline_groups[0].joints, [joint]);
    // Both contents of a nested folder participate in the same toggle and undo.
    run(&mut s, "timeline.move_to_group", json!({"groups":[folder], "group":destination}));
    let before = s.doc.clone();
    run(&mut s, "timeline.suppress", json!({"groups":[destination]}));
    assert!(s.doc.features[0].suppressed && s.doc.assembly.joints[0].suppressed);
    run(&mut s, "timeline.suppress", json!({"groups":[destination]}));
    assert!(!s.doc.features[0].suppressed && !s.doc.assembly.joints[0].suppressed);
    run(&mut s, "edit.undo", json!({}));
    assert!(s.doc.features[0].suppressed && s.doc.assembly.joints[0].suppressed);
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(*s.doc, *before);
    run(&mut s, "timeline.delete", json!({"groups":[destination]}));
    assert!(s.doc.features.is_empty() && s.doc.assembly.joints.is_empty() && s.doc.timeline_groups.is_empty());
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(*s.doc, *before);
    run(&mut s, "timeline.ungroup", json!({"group":folder}));
    assert_eq!(s.doc.timeline_groups[0].joints, [joint], "contents promote to the surviving parent");
    run(&mut s, "timeline.ungroup", json!({"group":destination}));
    assert!(s.doc.timeline_groups.is_empty());
    assert_eq!(s.doc.assembly.joints[0].id, joint);
    let folder = run(&mut s, "timeline.group", json!({"joints":vec![joint; 10_000]}))["group"].as_u64().unwrap();
    assert_eq!(s.doc.timeline_groups[0].joints, [joint], "the 10000-entry cap is inclusive and deduplicated");
    run(&mut s, "timeline.move_to_group", json!({"joints":["Hinge"], "group":null}));
    assert!(s.doc.timeline_groups[0].joints.is_empty());
    run(&mut s, "timeline.move_to_group", json!({"joints":["Hinge"], "group":folder}));
    run(&mut s, "timeline.suppress", json!({"groups":[folder]}));
    assert!(s.doc.assembly.joints[0].suppressed, "joint-only folders suppress too");
    run(&mut s, "joint.delete", json!({"joint":joint}));
    assert!(s.doc.timeline_groups[0].joints.is_empty());
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(s.doc.timeline_groups[0].joints, [joint]);
    run(&mut s, "component.delete", json!({"component":"Part"}));
    assert!(s.doc.assembly.joints.is_empty());
    assert!(s.doc.timeline_groups[0].joints.is_empty());
    assert!(solidcraft_doc::Document::from_json(&s.doc.to_json()).is_ok());
}

#[test]
fn timeline_joint_folders_reject_hostile_joint_references_atomically() {
    let mut s = Session::default();
    run(&mut s, "component.create", json!({"name":"Part"}));
    let joint = run(&mut s, "joint.as_built", json!({"type":"rigid", "a":0, "b":"Part"}))["joint"].as_u64().unwrap();
    let folder = run(&mut s, "timeline.group", json!({}))["group"].as_u64().unwrap();
    for command in ["timeline.group", "timeline.move_to_group"] {
        for joints in
            [json!([u64::MAX]), json!([-1]), json!([1e100]), json!(["missing"]), json!([{}]), json!([null]), json!("bad"), json!(vec![joint; 10_001])]
        {
            let before = s.doc.to_json();
            let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| s.execute(command, &json!({"joints":joints, "group":folder}))));
            let error = result.unwrap().unwrap_err();
            assert!(
                matches!(&error, crate::EngineError::BadParams { .. }),
                "{command} must reject invalid joint references without an internal panic: {error}"
            );
            assert_eq!(s.doc.to_json(), before);
        }
    }
}

/// A reference image is shared, not copied, by every edit after it: each undo state holds the
/// design as it was, and a copied image of up to 16 MiB per state would hold gigabytes.
#[test]
fn edits_after_a_canvas_share_its_image_with_every_undo_state() {
    let mut s = Session::default();
    let mut png = b"\x89PNG\r\n\x1a\n\0\0\0\rIHDR".to_vec();
    png.extend([0, 0, 0, 4, 0, 0, 0, 2, 8, 6, 0, 0, 0, 0, 0, 0, 0]);
    png.resize(64 << 10, 0);
    run(&mut s, "canvas.insert", json!({"data": solidcraft_doc::canvas::base64_encode(&png), "plane": "XY", "width": 40}));
    for i in 0..20 {
        run(&mut s, "parameters.add", json!({"name": format!("p{i}"), "expression": "10 mm"}));
    }
    let image = s.doc.canvases[0].data.as_ptr();
    let copies = s.undo.iter().filter_map(|u| u.doc.canvases.first()).filter(|c| c.data.as_ptr() != image).count();
    assert_eq!(copies, 0, "undo states holding their own copy of the image");
    for _ in 0..20 {
        run(&mut s, "edit.undo", json!({}));
    }
    assert_eq!(s.doc.canvases[0].data.as_ptr(), image, "undo brings back the same image");
    assert_eq!(s.doc.canvases[0].bytes().as_deref(), Some(png.as_slice()));
}

#[test]
fn assistant_toggle_is_refused_headlessly_without_changing_the_document() {
    let mut s = Session::default();
    let before = (s.doc.to_json(), s.undo.len());
    let error = s.execute("ui.assistant", &json!({})).unwrap_err().to_string();
    assert!(error.contains("headless session"), "{error}");
    assert_eq!((s.doc.to_json(), s.undo.len()), before);
    let spec = crate::find_command("ui.assistant").unwrap();
    assert_eq!((spec.shortcut, spec.tab, spec.undoable), (Some("Ctrl+Shift+A"), "", false));
}

#[test]
fn reorder_reports_where_the_feature_is_or_why_it_did_not_move() {
    // #12140: a reorder never reports success while the feature stays put without saying so.
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [50, 0, 0], "operation": "new_body", "name": "Block"}));
    run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Profile"}));
    run(&mut s, "sketch.line", json!({"points": [[0, 0], [10, 0], [10, 10], [0, 10]], "closed": true}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"distance": 5, "operation": "new_body", "name": "Pad"}));
    let names = |s: &Session| s.doc.features.iter().map(|f| f.name.clone()).collect::<Vec<_>>();
    // A position past the end, where the feature already is: nothing moved, and the note says why.
    let out = run(&mut s, "timeline.reorder", json!({"feature": "Pad", "position": 9}));
    assert_eq!((out["position"].as_u64(), out["from"].as_u64(), out["moved"].as_bool()), (Some(2), Some(2), Some(false)));
    assert!(out["note"].as_str().is_some_and(|n| n.contains("nothing moved") && n.contains("past the end")), "{out}");
    // Ahead of its own sketch: refused, naming the cause.
    let e = s.execute("timeline.reorder", &json!({"feature": "Pad", "position": 0})).unwrap_err().to_string();
    assert!(e.contains("breaks Pad") && e.contains("move that feature earlier first"), "{e}");
    assert_eq!(names(&s), ["Block", "Profile", "Pad"], "a refused move leaves the order");
    // Moving the sketch first lets the extrude follow; the reply gives the real index.
    let out = run(&mut s, "timeline.reorder", json!({"feature": "Profile", "position": 0}));
    assert_eq!((out["position"].as_u64(), out["from"].as_u64(), out["moved"].as_bool()), (Some(0), Some(1), Some(true)));
    let out = run(&mut s, "timeline.reorder", json!({"feature": "Pad", "position": 1}));
    assert_eq!((out["position"].as_u64(), out["moved"].as_bool()), (Some(1), Some(true)));
    assert!(out.get("note").is_none(), "{out}");
    assert_eq!(names(&s), ["Profile", "Pad", "Block"]);
    // `active` on a feature left in place: the note says only the marker moved.
    run(&mut s, "timeline.reorder", json!({"feature": "Block", "position": 2, "active": false}));
    let out = run(&mut s, "timeline.reorder", json!({"feature": "Block", "position": 2, "active": true}));
    assert_eq!((out["moved"].as_bool(), s.doc.marker), (Some(false), None));
    assert!(out["note"].as_str().is_some_and(|n| n.contains("only the history marker moved")), "{out}");
}

#[test]
fn reorder_refusal_after_a_feature_that_removes_its_body_does_not_blame_the_order_of_its_inputs() {
    // A fillet moved behind a cut that removes its whole body fails though what it uses is earlier.
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "name": "Base"}));
    run(&mut s, "solid.fillet", json!({"edges": [[10, 5, 10]], "radius": 1, "name": "Round"}));
    run(&mut s, "solid.box", json!({"length": 30, "width": 30, "height": 30, "corner": [-10, -10, -10], "operation": "cut", "name": "Clear"}));
    let e = s.execute("timeline.reorder", &json!({"feature": "Round", "position": 2})).unwrap_err().to_string();
    assert!(e.contains("breaks Round") && e.contains("changes what it works on") && !e.contains("earlier first"), "{e}");
}