brep_render/engine_state/

committed_sketches.rs

use super::*;

/// The committed-sketch SHEET base color (dim cyan, matching the retired overlay
/// `COMMITTED_COLOR` 0x67c7d4) — a sketch sheet reads distinctly from a real solid.
const SKETCH_SHEET_COLOR: [f32; 3] = [
    0x67 as f32 / 255.0,
    0xc7 as f32 / 255.0,
    0xd4 as f32 / 255.0,
];

/// The feature types whose committed display is a synthesized SKETCH-LIKE
/// sheet (a dim-cyan `is_sketch` scene solid drawn from the paths the feature
/// published), and the prefix of the path names that are that feature's own
/// drawable segments:
///   * `S` — a sketch draws one segment per model geometry, `{id}:G{gid}`;
///   * `HX` — a helix draws its single fitted edge, `{id}:HelixEdge`.
/// Anything else (a spline, a solid feature) has no sheet here. Only `S` is
/// ever ENTERABLE — the sketch-mode guards check the type separately.
fn curve_feature_segment_prefix(feature_type: &str, id: &str) -> Option<String> {
    match feature_type {
        "S" => Some(format!("{id}:G")),
        "HX" => Some(format!("{id}:HelixEdge")),
        _ => None,
    }
}

/// The prefix of the published POINT names a sketch-like feature draws as
/// standalone vertices: a sketch publishes every solved point as `{id}:P{pid}`,
/// and the ones no segment covers (a points-only hole-placement sketch) are
/// otherwise invisible. A helix publishes only its two ends, which its edge
/// already draws, so it has no point prefix.
fn curve_feature_point_prefix(feature_type: &str, id: &str) -> Option<String> {
    match feature_type {
        "S" => Some(format!("{id}:P")),
        _ => None,
    }
}

impl EngineState {

    /// The committed sketches present at the CURRENT rollback: every sketch-like
    /// feature (see [`curve_feature_segment_prefix`]) at index `0..=rollback`,
    /// EXCEPT the one being edited (it displays via the live editing overlay) and
    /// EXCEPT any sketch a downstream feature within the current rollback CONSUMED
    /// (see [`consumed_feature_names`](Self::consumed_feature_names)). Hidden ids
    /// are still returned (the Scene tree lists them); visibility is filtered by
    /// the caller against [`hidden_sketches`].
    fn committed_sketch_ids(&self) -> Vec<String> {
        self.committed_curve_features()
            .into_iter()
            .map(|(id, _, _)| id)
            .collect()
    }

    /// [`committed_sketch_ids`](Self::committed_sketch_ids) with each id's
    /// segment-name prefix and (for a sketch) its point-name prefix — the
    /// `(id, segment prefix, point prefix)` triples the sheet refresh draws.
    fn committed_curve_features(&self) -> Vec<(String, String, Option<String>)> {
        let editing = self.sketch_edit.as_ref().map(|edit| edit.feature_id.as_str());
        let rollback = self.history.rollback();
        let mut ids = Vec::new();
        for index in 0..=rollback {
            let Some(feature_type) = self.history.feature_type(index) else {
                continue;
            };
            let Some(id) = self.history.feature_id(index) else {
                continue;
            };
            let Some(prefix) = curve_feature_segment_prefix(&feature_type, &id) else {
                continue;
            };
            if Some(id.as_str()) == editing {
                continue;
            }
            let point_prefix = curve_feature_point_prefix(&feature_type, &id);
            ids.push((id, prefix, point_prefix));
        }
        // Drop any sketch a downstream feature CONSUMED: extrude/revolve (gated by
        // `consumeProfileSketch`) and the sheet-metal consumers push the consumed
        // sketch id into their `result.removed`, so a consumed sketch must vanish
        // from the scene — no sheet, no tree row — exactly like a consumed solid.
        // Only replay when there is a candidate to test, so a sketch-less scene pays
        // nothing for the check.
        if !ids.is_empty() {
            let consumed = self.consumed_feature_names();
            ids.retain(|(id, _, _)| !consumed.contains(id));
        }
        ids
    }

    /// The set of output names CONSUMED (removed) by some feature within the CURRENT
    /// rollback prefix — a solid absorbed by a boolean, or a sketch absorbed by a
    /// downstream extrude / revolve / sheet-metal consumer. Sourced from the SAME
    /// per-feature `removed` signal the scene build honors
    /// (`scene_query::resident_solid_handles`): replay the rolled-to prefix (a clean
    /// cache hit after a build — re-tessellates nothing) and union every feature's
    /// `removed`. Because [`prefix_request`](crate::history::History::prefix_request)
    /// stops at the rolled-to feature, a consumer ABOVE the rollback never runs, so
    /// its removed names are (correctly) absent — a sketch consumed above the
    /// rollback point still shows. A malformed request yields an empty set (same as
    /// `resident_solid_handles`).
    fn consumed_feature_names(&self) -> std::collections::HashSet<String> {
        let request: HistoryRequest = match serde_json::from_value(self.history.prefix_request()) {
            Ok(request) => request,
            Err(_) => return std::collections::HashSet::new(),
        };
        brep_kernel::execute_history(&request)
            .results
            .iter()
            .flat_map(|feature| feature.removed.iter().cloned())
            .collect()
    }

    /// (Re)build the persistent committed-sketch SHEET SOLIDS. For every committed
    /// sketch that should show — [`committed_sketch_ids`](Self::committed_sketch_ids)
    /// minus [`hidden_sketches`] — synthesize its display from the run's solved
    /// profile AND its own model segments, and insert it as a scene solid (keyed by
    /// the sketch id, dim-cyan, flagged `is_sketch`); remove any sheet inserted on
    /// the PREVIOUS refresh but not this one (rolled back, deleted, hidden, or
    /// became the active edit). A sketch that closes a region gets its planar sheet;
    /// one that closes NOTHING (an open chain — the single line of the 2026-09-02
    /// report) still draws its segments as named edges, so it is visible and
    /// pickable instead of vanishing; one holding ONLY points (a hole-placement
    /// sketch) draws them as vertices, so it too is visible, listed and pickable
    /// (a vertex hit carries its owning sketch, which the `SKETCH` pick lane
    /// admits). Only a sketch with no drawable geometry at all (empty /
    /// construction-only) is skipped. Marks dirty.
    pub fn refresh_committed_sketches(&mut self) {
        let visible: Vec<(String, String, Option<String>)> = self
            .committed_curve_features()
            .into_iter()
            .filter(|(id, _, _)| !self.hidden_sketches.contains(id))
            .collect();

        // Phase 1 (immutable borrow of the surfaced profiles + paths + points):
        // build a display payload per visible sketch — its closed profile's sheet
        // (when it has one), every model segment that sheet does not already
        // draw, and every model point no segment covers. A sketch with nothing to
        // draw (no face + no edges + no points) is skipped.
        let payloads: Vec<(String, brep_kernel::DisplaySolidPayload)> = visible
            .iter()
            .filter_map(|(id, prefix, point_prefix)| {
                let profile = self
                    .sketch_profiles
                    .iter()
                    .find(|(name, _)| name == id)
                    .map(|(_, profile)| profile);
                // The feature's own model segments, published under its segment
                // prefix (a sketch: one per geometry, `{id}:G{gid}`; a helix: its
                // one `{id}:HelixEdge`). The whole-chain `{id}` path duplicates
                // them and `{id}:REF:{source}` is projected reference geometry,
                // so neither is drawn here.
                let segments: Vec<(String, Vec<brep_kernel::NurbsCurve>)> = self
                    .sketch_paths
                    .iter()
                    .filter(|(name, _)| name.starts_with(prefix.as_str()))
                    .cloned()
                    .collect();
                // The sketch's own MODEL points, published under `{id}:P{pid}`.
                // Construction points constrain and never model, so — like
                // construction geometry — they do not draw.
                let points: Vec<brep_kernel::Vec3> = match point_prefix {
                    Some(point_prefix) => self
                        .sketch_points
                        .iter()
                        .filter(|(name, point)| {
                            name.starts_with(point_prefix.as_str()) && !point.construction
                        })
                        .map(|(_, point)| point.position)
                        .collect(),
                    None => Vec::new(),
                };
                let payload = brep_kernel::sketch_display_payload(profile, &segments, &points);
                if payload.mesh.indices.is_empty()
                    && payload.edges.is_empty()
                    && payload.vertices.is_empty()
                {
                    return None;
                }
                Some((id.clone(), payload))
            })
            .collect();

        // Phase 2 (mutable borrow of the scene): insert each sheet as a scene solid.
        let mut fed: Vec<String> = Vec::with_capacity(payloads.len());
        for (id, payload) in payloads {
            let mut solid = crate::scene::solid_display_from_payload(&id, payload);
            solid.is_sketch = true;
            solid.color_override = Some(SKETCH_SHEET_COLOR);
            self.scene.insert_solid(solid);
            fed.push(id);
        }

        // Remove any sketch sheet inserted last time but not now.
        let fed_set: std::collections::HashSet<&str> = fed.iter().map(String::as_str).collect();
        let stale: Vec<String> = self
            .shown_sketch_ids
            .iter()
            .filter(|id| !fed_set.contains(id.as_str()))
            .cloned()
            .collect();
        for id in stale {
            self.scene.remove_solid(&id);
        }

        self.shown_sketch_ids = fed;
        self.dirty = true;
    }

    /// Whether the committed sketch `id`'s persistent overlay is shown (absent from
    /// [`hidden_sketches`] = visible).
    pub fn sketch_visible(&self, id: &str) -> bool {
        !self.hidden_sketches.contains(id)
    }

    /// Show/hide the committed sketch `id`'s persistent overlay (the Scene-tree
    /// checkbox). Toggles [`hidden_sketches`], rebuilds the committed overlays (so the
    /// group is fed or cleared immediately), and marks dirty.
    pub fn set_sketch_visible(&mut self, id: &str, visible: bool) {
        if visible {
            self.hidden_sketches.remove(id);
        } else {
            self.hidden_sketches.insert(id.to_string());
        }
        self.refresh_committed_sketches();
    }

    /// The committed sketches to list in the Scene tree: every `"S"` feature at the
    /// current rollback (minus the active edit), each with its live visibility — the
    /// ordered `(id, visible)` list the Scene panel snapshots.
    pub fn committed_sketches(&self) -> Vec<(String, bool)> {
        self.committed_sketch_ids()
            .into_iter()
            .map(|id| {
                let visible = !self.hidden_sketches.contains(&id);
                (id, visible)
            })
            .collect()
    }

    /// The committed sketches as JSON (`[{"name":<id>,"visible":<bool>}]`) — the
    /// sibling of [`scene_entities_json`](Self::scene_entities_json) the Scene panel
    /// publishes for the headed verifier (kept a SEPARATE method so the solids array's
    /// shape is unchanged).
    pub fn sketch_entities_json(&self) -> String {
        let list: Vec<serde_json::Value> = self
            .committed_sketches()
            .into_iter()
            .map(|(id, visible)| serde_json::json!({ "name": id, "visible": visible }))
            .collect();
        serde_json::Value::Array(list).to_string()
    }
}

// ===========================================================================
// Construction datums — DATUM + PLANE feature frames rendered as first-class,
// SELECTABLE scene citizens (the committed-sketch parallel). The frames the last
// history run resolved ride `construction_frames`; this block filters them to the
// D/P producing features (a frame name → its feature TYPE via the history), feeds
// the kept ones to the datum-plane widget channel (`set_datums`, which REPLACES
// its set wholesale each call — so re-feeding the full current set auto-drops
// departed/hidden/rolled-back planes), lists them in the Scene tree, and selects
// one BY NAME (`emphasis.selected_datums`, re-colored with the accent).
// `hidden_datums` drives per-plane visibility. Kept in ONE appended block so
// concurrent edits to the primary impl land clean.
// ===========================================================================


// Committed-sketch persistent-display + Scene-tree-listing tests — their OWN module
// (appended last) so they do not conflict with the modules above.
#[cfg(test)]
mod committed_sketch_tests {
    use super::*;

    /// A two-feature history: a cube (solid) followed by a committed closed-rectangle
    /// sketch on the XY plane (the sketch is the LAST feature).
    fn cube_and_sketch_history() -> String {
        serde_json::json!({
            "features": [
                {
                    "type": "P.CU",
                    "inputParams": {
                        "id": "Box",
                        "sizeX": 10.0, "sizeY": 10.0, "sizeZ": 10.0,
                        "transform": {
                            "position": [0.0, 0.0, 0.0],
                            "rotationEuler": [0.0, 0.0, 0.0],
                            "scale": [1.0, 1.0, 1.0]
                        },
                        "boolean": { "targets": [], "operation": "NONE" }
                    },
                    "persistentData": {}
                },
                {
                    "type": "S",
                    "inputParams": { "id": "Sk" },
                    "persistentData": {
                        "basis": { "origin": [0, 0, 0], "x": [1, 0, 0], "y": [0, 1, 0], "z": [0, 0, 1] },
                        "sketch": {
                            "points": [
                                { "id": 0, "x": 0.0,  "y": 0.0 },
                                { "id": 1, "x": 10.0, "y": 0.0 },
                                { "id": 2, "x": 10.0, "y": 6.0 },
                                { "id": 3, "x": 0.0,  "y": 6.0 }
                            ],
                            "geometries": [
                                { "id": 10, "type": "line", "points": [0, 1] },
                                { "id": 11, "type": "line", "points": [1, 2] },
                                { "id": 12, "type": "line", "points": [2, 3] },
                                { "id": 13, "type": "line", "points": [3, 0] }
                            ],
                            "constraints": []
                        }
                    }
                }
            ]
        })
        .to_string()
    }

    fn has_group(engine: &EngineState, name: &str) -> bool {
        engine.widgets.overlay_group_names().contains(&name)
    }

    /// The synthesized committed-sketch SHEET solid for `id`, if present.
    fn sketch_sheet<'a>(
        engine: &'a EngineState,
        id: &str,
    ) -> Option<&'a crate::scene::SolidDisplay> {
        engine.scene.solid(id).filter(|solid| solid.is_sketch)
    }

    fn has_sketch_sheet(engine: &EngineState, id: &str) -> bool {
        sketch_sheet(engine, id).is_some()
    }

    /// The same history, but the sketch holds ONE OPEN LINE — the shape of the
    /// 2026-09-02 report ("Sketch with single edge not visible in 3D").
    fn cube_and_open_sketch_history() -> String {
        let mut history: serde_json::Value =
            serde_json::from_str(&cube_and_sketch_history()).expect("history parses");
        history["features"][1]["persistentData"]["sketch"] = serde_json::json!({
            "points": [
                { "id": 0, "x": 1.0, "y": 2.0 },
                { "id": 1, "x": 7.0, "y": 4.0 }
            ],
            "geometries": [
                { "id": 10, "type": "line", "points": [0, 1] }
            ],
            "constraints": []
        });
        history.to_string()
    }

    /// An OPEN sketch closes no region, so it publishes no profile and the sheet
    /// builder used to be handed nothing — the sketch was invisible in 3D and
    /// unpickable there (the reported symptom). It now draws its own model
    /// segments: one named edge, both endpoints, and no face.
    #[test]
    fn open_sketch_renders_its_segments_without_a_sheet_face() {
        let mut engine = EngineState::new();
        engine.set_history_json(&cube_and_open_sketch_history()).unwrap();

        let sheet = sketch_sheet(&engine, "Sk").expect("open sketch still displays");
        assert!(sheet.is_sketch, "flagged as a sketch");
        assert!(sheet.faces.is_empty(), "nothing closes, so there is no sheet face");
        assert!(sheet.mesh.positions.is_empty(), "and no face mesh");
        assert_eq!(sheet.edges.len(), 1, "the single line draws as one edge");
        assert_eq!(sheet.edges[0].name, "Sk:G10", "named by its sketch geometry");
        assert_eq!(sheet.vertices.len(), 2, "both endpoints draw");
        // The drawn extent feeds zoom-to-fit and every bbox-gated traversal, so it
        // must cover the line rather than staying empty.
        assert!(!sheet.bbox.is_empty(), "the drawn segment gives the sketch an extent");

        // ...and it lists in the Scene tree like any other committed sketch.
        assert_eq!(engine.committed_sketches(), vec![("Sk".to_string(), true)]);
    }

    /// The same history, but the sketch holds ONLY POINTS — the shape of a
    /// hole-placement sketch as the app commits it (no seeded origin: the first
    /// point placed is `P0`), with one construction point among them.
    fn cube_and_points_only_sketch_history() -> String {
        let mut history: serde_json::Value =
            serde_json::from_str(&cube_and_sketch_history()).expect("history parses");
        history["features"][1]["persistentData"]["sketch"] = serde_json::json!({
            "points": [
                { "id": 0, "x": 2.0, "y": 2.0 },
                { "id": 1, "x": 8.0, "y": 2.0 },
                { "id": 2, "x": 5.0, "y": 5.0, "construction": true },
                { "id": 3, "x": 8.0, "y": 8.0 }
            ],
            "geometries": [],
            "constraints": []
        });
        history.to_string()
    }

    /// A POINTS-ONLY sketch closes no region and has no segment, so it published
    /// nothing the sheet builder could draw — the sketch was invisible in 3D, not
    /// listed as a scene solid, and unpickable, so a hole's `["SKETCH"]` placement
    /// field could not take it from the viewport (the 2026-09-06 report). It now
    /// draws each MODEL point as a vertex (the construction point, like
    /// construction geometry, does not draw), with no face and no edge.
    #[test]
    fn points_only_sketch_renders_its_model_points_as_vertices() {
        let mut engine = EngineState::new();
        engine.set_history_json(&cube_and_points_only_sketch_history()).unwrap();

        let sheet = sketch_sheet(&engine, "Sk").expect("points-only sketch still displays");
        assert!(sheet.is_sketch, "flagged as a sketch");
        assert!(sheet.faces.is_empty(), "nothing closes, so there is no sheet face");
        assert!(sheet.mesh.positions.is_empty(), "and no face mesh");
        assert!(sheet.edges.is_empty(), "no segment, so no edge");
        assert_eq!(sheet.vertices.len(), 3, "the three MODEL points draw; the ◐ point does not");
        let mut drawn: Vec<[i64; 2]> = sheet
            .vertices
            .iter()
            .map(|v| [v.position[0].round() as i64, v.position[1].round() as i64])
            .collect();
        drawn.sort_unstable();
        assert_eq!(drawn, vec![[2, 2], [8, 2], [8, 8]], "drawn at the solved positions");
        assert!(sheet.vertices.iter().all(|v| v.position[2].abs() < 1e-9), "on the XY plane");
        assert!(!sheet.bbox.is_empty(), "the drawn points give the sketch an extent");

        // ...and it lists in the Scene tree like any other committed sketch, and
        // its sheet counts its vertices in the entity JSON the verifier reads.
        assert_eq!(engine.committed_sketches(), vec![("Sk".to_string(), true)]);
        engine.set_sketch_visible("Sk", false);
        assert!(!has_sketch_sheet(&engine, "Sk"), "hidden sketch draws nothing");
        engine.set_sketch_visible("Sk", true);
        assert!(has_sketch_sheet(&engine, "Sk"), "and comes back");
    }

    /// A helix history: the cube plus a HELIX feature (default params: radius 5,
    /// height 15, three turns about +Z at the origin).
    fn cube_and_helix_history() -> String {
        let mut history: serde_json::Value =
            serde_json::from_str(&cube_and_sketch_history()).expect("history parses");
        history["features"][1] = serde_json::json!({
            "type": "HX",
            "inputParams": { "id": "HX1" },
            "persistentData": {}
        });
        history.to_string()
    }

    /// A HELIX is a sketch-like object in the model: it displays as a
    /// committed sheet with NO face and exactly ONE edge (its fitted curve,
    /// named `{id}:HelixEdge`), both ends as vertices, a real extent, a Scene
    /// tree row under the sketches — and it is NOT enterable as a sketch.
    #[test]
    fn helix_renders_as_a_single_edge_sketch_like_object() {
        let mut engine = EngineState::new();
        engine.set_history_json(&cube_and_helix_history()).unwrap();

        let sheet = sketch_sheet(&engine, "HX1").expect("the helix displays");
        assert!(sheet.is_sketch, "flagged sketch-like");
        assert!(sheet.faces.is_empty(), "a curve closes nothing, so no face");
        assert!(sheet.mesh.positions.is_empty(), "and no face mesh");
        assert_eq!(sheet.edges.len(), 1, "exactly one edge");
        assert_eq!(sheet.edges[0].name, "HX1:HelixEdge", "named as the published edge");
        // Three turns drawn from 24 points would be an octagon per turn: the
        // display samples a fitted curve by its knot spans instead.
        assert!(
            sheet.edges[0].polyline.len() >= 3 * 64,
            "a three-turn helix draws smoothly ({} points)",
            sheet.edges[0].polyline.len()
        );
        let [x, y, z] = sheet.edges[0].polyline[0];
        assert!((x - 5.0).abs() < 1e-3 && y.abs() < 1e-3 && z.abs() < 1e-3, "starts at (5,0,0)");
        let [x, y, z] = *sheet.edges[0].polyline.last().unwrap();
        assert!((x - 5.0).abs() < 1e-3 && y.abs() < 1e-3 && (z - 15.0).abs() < 1e-3, "ends at (5,0,15)");
        assert_eq!(sheet.vertices.len(), 2, "both ends draw");
        assert!(!sheet.bbox.is_empty(), "the drawn edge gives the helix an extent");

        assert_eq!(engine.committed_sketches(), vec![("HX1".to_string(), true)]);
        assert!(
            engine.enter_sketch_mode("HX1").is_err(),
            "a helix is sketch-LIKE, never an editable sketch"
        );

        // The Scene-tree visibility toggle applies like any committed sketch.
        engine.set_sketch_visible("HX1", false);
        assert!(!has_sketch_sheet(&engine, "HX1"), "hidden helix draws nothing");
        engine.set_sketch_visible("HX1", true);
        assert!(has_sketch_sheet(&engine, "HX1"), "and comes back");
    }

    /// A CLOSED sketch draws each boundary edge exactly ONCE: the sheet already
    /// carries them, and the per-segment paths that now also reach the display
    /// must not double them up.
    #[test]
    fn closed_sketch_draws_each_boundary_edge_once() {
        let mut engine = EngineState::new();
        engine.set_history_json(&cube_and_sketch_history()).unwrap();
        let sheet = sketch_sheet(&engine, "Sk").expect("committed sketch sheet solid");
        assert_eq!(sheet.edges.len(), 4, "four boundary edges, not eight");
        let mut names: Vec<&str> = sheet.edges.iter().map(|e| e.name.as_str()).collect();
        names.sort_unstable();
        names.dedup();
        assert_eq!(names.len(), 4, "each edge name appears once: {names:?}");
    }

    #[test]
    fn committed_sketch_renders_and_lists_after_rerun() {
        let mut engine = EngineState::new();
        engine.set_history_json(&cube_and_sketch_history()).unwrap();

        // The committed sketch is now a SHEET SOLID keyed by its id: a planar face,
        // its four named boundary edges, and four corner vertices — pickable via the
        // solid infrastructure.
        let sheet = sketch_sheet(&engine, "Sk").expect("committed sketch sheet solid");
        assert!(sheet.is_sketch, "flagged as a sketch");
        assert_eq!(sheet.faces.len(), 1, "one sheet face");
        assert_eq!(sheet.edges.len(), 4, "four boundary edges");
        assert_eq!(sheet.vertices.len(), 4, "four corner vertices");
        assert!(!sheet.mesh.positions.is_empty(), "filled face mesh");

        // The sketch sheet is NOT in the solids listing (it lists under "Sketches").
        let solids: serde_json::Value =
            serde_json::from_str(&engine.scene_entities_json()).unwrap();
        assert_eq!(solids.as_array().unwrap().len(), 1);
        assert_eq!(solids[0]["name"], "Box");

        // The committed sketch is listed by the sibling methods.
        assert_eq!(engine.committed_sketches(), vec![("Sk".to_string(), true)]);
        let sketches: serde_json::Value =
            serde_json::from_str(&engine.sketch_entities_json()).unwrap();
        assert_eq!(sketches[0]["name"], "Sk");
        assert_eq!(sketches[0]["visible"], true);
        assert!(engine.sketch_visible("Sk"));
    }

    #[test]
    fn rolling_back_before_sketch_clears_committed_sheet() {
        let mut engine = EngineState::new();
        engine.set_history_json(&cube_and_sketch_history()).unwrap();
        assert!(has_sketch_sheet(&engine, "Sk"));

        // Roll to the cube (index 0), before the sketch: its sheet is removed and it
        // drops out of the listing.
        engine.roll_to(0);
        assert!(!has_sketch_sheet(&engine, "Sk"), "rolled-back sketch sheet removed");
        assert!(engine.committed_sketches().is_empty());

        // Rolling forward again re-adds it.
        engine.roll_to(1);
        assert!(has_sketch_sheet(&engine, "Sk"), "rolled-forward sketch re-shown");
        assert_eq!(engine.committed_sketches(), vec![("Sk".to_string(), true)]);
    }

    #[test]
    fn set_sketch_visible_hides_and_restores() {
        let mut engine = EngineState::new();
        engine.set_history_json(&cube_and_sketch_history()).unwrap();
        assert!(has_sketch_sheet(&engine, "Sk"));

        // Hide: sheet removed from the scene, still LISTED but visible:false.
        engine.set_sketch_visible("Sk", false);
        assert!(!has_sketch_sheet(&engine, "Sk"), "hidden sketch sheet removed");
        assert!(!engine.sketch_visible("Sk"));
        assert_eq!(engine.committed_sketches(), vec![("Sk".to_string(), false)]);
        let sketches: serde_json::Value =
            serde_json::from_str(&engine.sketch_entities_json()).unwrap();
        assert_eq!(sketches[0]["visible"], false);

        // Show: sheet re-inserted.
        engine.set_sketch_visible("Sk", true);
        assert!(has_sketch_sheet(&engine, "Sk"), "re-shown sketch sheet inserted");
        assert!(engine.sketch_visible("Sk"));
    }

    #[test]
    fn entering_sketch_mode_removes_committed_sheet_then_commit_readds() {
        let mut engine = EngineState::new();
        engine.set_history_json(&cube_and_sketch_history()).unwrap();
        assert!(has_sketch_sheet(&engine, "Sk"));

        // Enter: the committed sheet is removed (no double display); the LIVE editing
        // overlay group is fed instead (unchanged active-edit path).
        engine.enter_sketch_mode("Sk").expect("enter");
        assert!(engine.sketch_mode());
        assert!(
            !has_sketch_sheet(&engine, "Sk"),
            "active sketch's committed sheet removed"
        );
        assert!(has_group(&engine, "sketch-geometry"), "live editing overlay fed");
        // While editing, the sketch is not in the committed listing.
        assert!(engine.committed_sketches().is_empty());

        // Commit exit: the just-committed sketch reappears as a sheet solid and the
        // live editing group is cleared.
        engine.exit_sketch_mode(true);
        assert!(!engine.sketch_mode());
        assert!(
            has_sketch_sheet(&engine, "Sk"),
            "committed sketch reappears as a sheet after commit"
        );
        assert!(!has_group(&engine, "sketch-geometry"), "live editing overlay cleared");
        assert_eq!(engine.committed_sketches(), vec![("Sk".to_string(), true)]);
    }

    /// A committed sketch sheet is MEASURABLE through the handle-less metadata path:
    /// its Info reports `kind:"sketch"` with the profile area (10x6 = 60 mm²) and
    /// total boundary length (perimeter 2*(10+6) = 32 mm), no volume, and its
    /// creating feature is the sketch.
    #[test]
    fn sketch_sheet_info_reports_area_and_edge_length() {
        let mut engine = EngineState::new();
        engine.set_history_json(&cube_and_sketch_history()).unwrap();
        let info: serde_json::Value =
            serde_json::from_str(&engine.object_info_json("Sk")).unwrap();
        assert_eq!(info["ok"], true, "sketch info must not error: {info}");
        assert_eq!(info["kind"], "sketch");
        assert!(info.get("volume").is_none(), "a sheet has no volume");
        assert!((info["area"].as_f64().unwrap() - 60.0).abs() < 1e-3, "area {}", info["area"]);
        assert!(
            (info["edgeLengthTotal"].as_f64().unwrap() - 32.0).abs() < 1e-3,
            "perimeter {}",
            info["edgeLengthTotal"]
        );
        assert_eq!(info["creatingFeature"]["id"], "Sk");
        assert_eq!(info["creatingFeature"]["type"], "S");
    }

    /// A boundary edge of the sheet is a normal selectable/measurable edge: its Info
    /// reports `kind:"edge"` and the segment length (a 10 or 6 mm rectangle side).
    #[test]
    fn sketch_sheet_edge_is_measurable() {
        let mut engine = EngineState::new();
        engine.set_history_json(&cube_and_sketch_history()).unwrap();
        let edge_name = sketch_sheet(&engine, "Sk").unwrap().edges[0].name.clone();
        assert!(!edge_name.is_empty(), "boundary edge is named");
        let info: serde_json::Value =
            serde_json::from_str(&engine.object_info_json(&edge_name)).unwrap();
        assert_eq!(info["ok"], true, "edge info: {info}");
        assert_eq!(info["kind"], "edge");
        assert_eq!(info["solid"], "Sk");
        let length = info["length"].as_f64().unwrap();
        assert!(
            (length - 10.0).abs() < 1e-3 || (length - 6.0).abs() < 1e-3,
            "rectangle side length {length}"
        );
    }

    /// The sheet is selectable BY NAME through the shared solid selection (the
    /// viewport pick and the Scene tree both route here), so a sketch highlights
    /// like any solid.
    #[test]
    fn sketch_sheet_is_selectable_by_name() {
        let mut engine = EngineState::new();
        engine.set_history_json(&cube_and_sketch_history()).unwrap();
        assert!(engine.select_by_name("solid", "Sk"));
        let sel: serde_json::Value = serde_json::from_str(&engine.selection_json()).unwrap();
        assert_eq!(sel["solids"][0], "Sk");
    }

    /// A two-feature history: a committed closed-rectangle sketch on the XY plane
    /// (feature 0), then an extrude of it (feature 1). `consume` sets the extrude's
    /// `consumeProfileSketch` — `true` consumes the sketch (removed from the scene),
    /// `false` keeps it.
    fn sketch_then_extrude_history(consume: bool) -> String {
        serde_json::json!({
            "features": [
                {
                    "type": "S",
                    "inputParams": { "id": "Sk" },
                    "persistentData": {
                        "basis": { "origin": [0, 0, 0], "x": [1, 0, 0], "y": [0, 1, 0], "z": [0, 0, 1] },
                        "sketch": {
                            "points": [
                                { "id": 0, "x": 0.0,  "y": 0.0 },
                                { "id": 1, "x": 10.0, "y": 0.0 },
                                { "id": 2, "x": 10.0, "y": 6.0 },
                                { "id": 3, "x": 0.0,  "y": 6.0 }
                            ],
                            "geometries": [
                                { "id": 10, "type": "line", "points": [0, 1] },
                                { "id": 11, "type": "line", "points": [1, 2] },
                                { "id": 12, "type": "line", "points": [2, 3] },
                                { "id": 13, "type": "line", "points": [3, 0] }
                            ],
                            "constraints": []
                        }
                    }
                },
                {
                    "type": "E",
                    "inputParams": {
                        "id": "Ext",
                        "profile": "Sk",
                        "distance": 4.0,
                        "consumeProfileSketch": consume
                    },
                    "persistentData": {}
                }
            ]
        })
        .to_string()
    }

    /// An extrude that CONSUMES its profile (`consumeProfileSketch` true) makes the
    /// consumed sketch vanish from the scene — no committed listing and no
    /// synthesized sheet solid — exactly like a consumed solid. The extrude result
    /// stands as a real solid.
    #[test]
    fn extrude_consumed_sketch_absent_from_scene() {
        let mut engine = EngineState::new();
        engine
            .set_history_json(&sketch_then_extrude_history(true))
            .unwrap();
        assert!(
            engine.committed_sketches().is_empty(),
            "a consumed sketch is not listed: {:?}",
            engine.committed_sketches()
        );
        assert!(
            !has_sketch_sheet(&engine, "Sk"),
            "a consumed sketch has no synthesized sheet"
        );
        assert!(engine.scene.solid("Ext").is_some(), "the extrude solid is present");
    }

    /// With `consumeProfileSketch=false` the extrude keeps its profile: the sketch is
    /// NOT consumed, so it remains a listed committed sketch WITH its sheet.
    #[test]
    fn extrude_kept_sketch_remains_in_scene() {
        let mut engine = EngineState::new();
        engine
            .set_history_json(&sketch_then_extrude_history(false))
            .unwrap();
        assert_eq!(engine.committed_sketches(), vec![("Sk".to_string(), true)]);
        assert!(has_sketch_sheet(&engine, "Sk"), "a kept sketch still has a sheet");
    }

    /// A sketch consumed by a feature ABOVE the rollback point is NOT YET consumed:
    /// rolling to the sketch (before its extrude) shows it; rolling forward to the
    /// extrude consumes it — the removed signal is read only over the rolled-to
    /// prefix.
    #[test]
    fn sketch_consumed_above_rollback_still_shows() {
        let mut engine = EngineState::new();
        engine
            .set_history_json(&sketch_then_extrude_history(true))
            .unwrap();
        // Loaded rolled to the extrude (index 1): consumed → absent.
        assert!(engine.committed_sketches().is_empty());
        assert!(!has_sketch_sheet(&engine, "Sk"));

        // Roll back to the sketch (index 0), BEFORE its consumer: it shows again.
        engine.roll_to(0);
        assert_eq!(engine.committed_sketches(), vec![("Sk".to_string(), true)]);
        assert!(
            has_sketch_sheet(&engine, "Sk"),
            "sketch shows while its consumer is above the rollback"
        );

        // Roll forward to the extrude: consumed again.
        engine.roll_to(1);
        assert!(engine.committed_sketches().is_empty());
        assert!(!has_sketch_sheet(&engine, "Sk"));
    }
}