From 2683b8dfed9d3eb6bd00640aafedf74862115b26 Mon Sep 17 00:00:00 2001
From: lillith <35337584+0xlillith@users.noreply.github.com>
Date: Sun, 11 Oct 2026 00:58:49 +0200
Subject: [PATCH 1/7] fix: allow horizontal and vertical alignment of sketch
 points

---
 crates/ui-egui/src/tools.rs             | 29 +++++++-
 crates/ui-egui/tests/point_alignment.rs | 90 +++++++++++++++++++++++++
 docs/book/src/guide/sketching.md        |  4 ++
 3 files changed, 121 insertions(+), 2 deletions(-)
 create mode 100644 crates/ui-egui/tests/point_alignment.rs

diff --git a/crates/ui-egui/src/tools.rs b/crates/ui-egui/src/tools.rs
index adbefac1..a2a68433 100644
--- a/crates/ui-egui/src/tools.rs
+++ b/crates/ui-egui/src/tools.rs
@@ -14,6 +14,8 @@ pub enum Kind {
     Draw(usize),
     /// Pick sketch entities; `n` picks run the command.
     Pick(usize),
+    /// Pick one straight line, or two distinct points to align.
+    HorizontalVertical,
     Dimension,
     /// A tool from `sketch_tools` (it handles its own clicks).
     Ext,
@@ -56,7 +58,7 @@ impl Tool {
             "sketch.slot.overall" => ("sketch.slot.overall", Kind::Draw(3)),
             "sketch.point" => ("sketch.point", Kind::Draw(1)),
             "sketch.dimension" => ("sketch.dimension", Kind::Dimension),
-            "sketch.constraint.horizontal_vertical" => ("sketch.constraint.horizontal_vertical", Kind::Pick(1)),
+            "sketch.constraint.horizontal_vertical" => ("sketch.constraint.horizontal_vertical", Kind::HorizontalVertical),
             "sketch.constraint.fix" => ("sketch.constraint.fix", Kind::Pick(1)),
             "sketch.constraint.coincident" => ("sketch.constraint.coincident", Kind::Pick(2)),
             "sketch.constraint.tangent" => ("sketch.constraint.tangent", Kind::Pick(2)),
@@ -93,6 +95,7 @@ pub fn hint(id: &str) -> String {
         "sketch.arc.three_point" => "Arc: click start, end, then a point on the arc".into(),
         "sketch.arc.center_point" => "Arc: click centre and start, then click end or type a signed sweep".into(),
         "sketch.dimension" => "Dimension: pick one or two entities, then click to place the value".into(),
+        "sketch.constraint.horizontal_vertical" => "Horizontal/Vertical: pick a line or two points to align".into(),
         "sketch.slot.center_to_center" | "sketch.slot.overall" => "Slot: click both ends, then the width".into(),
         _ if id.starts_with("sketch.constraint.") => "Constraint: pick the sketch entities".into(),
         _ => crate::sketch_tools::hint(id).unwrap_or_else(|| "Click in the sketch".into()),
@@ -143,6 +146,29 @@ pub fn on_click(app: &mut SolveApp, proj: &Proj, pos: Pos2) {
                 return;
             }
         }
+        Kind::HorizontalVertical => {
+            let hits = pick(app, proj, pos);
+            let hit = hits.iter().find(|hit| match hit {
+                Hit::SketchPoint { sketch, .. } | Hit::SketchCurve { sketch, .. } => Some(*sketch) == app.session.active_sketch,
+                _ => false,
+            });
+            match hit {
+                Some(Hit::SketchPoint { id, .. }) => {
+                    if let Some(first) = tool.picks.first() {
+                        if first != id {
+                            let _ = app.run(tool.cmd, json!({"points": [first, id]}));
+                            tool.picks.clear();
+                        }
+                    } else {
+                        tool.picks.push(id.clone());
+                    }
+                }
+                Some(Hit::SketchCurve { id, straight: true, .. }) if tool.picks.is_empty() => {
+                    let _ = app.run(tool.cmd, json!({"line": id}));
+                }
+                _ => {}
+            }
+        }
         Kind::Pick(n) => {
             let hits = pick(app, proj, pos);
             if let Some(id) = hits.iter().find_map(|h| match h {
@@ -292,7 +318,6 @@ fn run_shape(app: &mut SolveApp, t: &Tool) -> Result<Vec<String>, String> {
 fn run_pick(app: &mut SolveApp, t: &Tool) {
     let k = &t.picks;
     let params = match t.cmd {
-        "sketch.constraint.horizontal_vertical" => json!({"line": k[0]}),
         "sketch.constraint.fix" => json!({"entity": k[0]}),
         "sketch.constraint.coincident" => json!({"a": k[0], "b": k[1]}),
         "sketch.constraint.midpoint" => json!({"point": k[0], "line": k[1]}),
diff --git a/crates/ui-egui/tests/point_alignment.rs b/crates/ui-egui/tests/point_alignment.rs
new file mode 100644
index 00000000..45c6e126
--- /dev/null
+++ b/crates/ui-egui/tests/point_alignment.rs
@@ -0,0 +1,90 @@
+//! Horizontal/Vertical accepts either one line or two distinct sketch points.
+
+use serde_json::json;
+use solvecraft_engine::sketch::ConstraintKind;
+use solvecraft_ui_egui::scenario::Harness;
+
+#[test]
+fn horizontal_vertical_aligns_origin_and_circle_center() {
+    for (center, horizontal) in [([20.0, 3.0], true), ([3.0, 20.0], false)] {
+        for origin_first in [true, false] {
+            let mut h = Harness::new();
+            h.run(&json!([
+                {"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}},
+                {"call":"engine.execute","params":{"command":"sketch.circle.center","params":{"center":center,"radius":5}}},
+                {"call":"ui.view","params":{"view":"top"}},
+                {"start":"sketch.constraint.horizontal_vertical"}
+            ]))
+            .unwrap();
+            let (first, second) = if origin_first { ([0.0, 0.0], center) } else { (center, [0.0, 0.0]) };
+            let undo = h.app.session.undo.len();
+            h.run(&json!([{"click":{"sketch":first}}, {"expect":{"errors":0}}])).unwrap();
+            assert_eq!(h.app.tool.as_ref().unwrap().picks.len(), 1);
+            assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error));
+            assert_eq!(h.app.session.undo.len(), undo);
+            // Repeating the first point must not complete a self-constraint.
+            h.run(&json!([{"click":{"sketch":first}}, {"click":{"sketch":second}}, {"expect":{"errors":0}}])).unwrap();
+            let aligned = |h: &Harness| {
+                let sk = &h.app.session.model.state().sketches[0].sketch;
+                let p = sk.point(sk.resolve_point("c1.center").unwrap()).unwrap();
+                if horizontal { p.y } else { p.x }
+            };
+            assert!(aligned(&h).abs() < 1e-6);
+            let sk = &h.app.session.model.state().sketches[0].sketch;
+            assert!(sk.constraints.iter().any(|c| if horizontal {
+                matches!(c.kind, ConstraintKind::HorizontalPoints { .. })
+            } else {
+                matches!(c.kind, ConstraintKind::VerticalPoints { .. })
+            }));
+            assert_eq!(h.app.session.undo.len(), undo + 1);
+            assert!(h.app.tool.as_ref().unwrap().picks.is_empty());
+            h.run(&json!([{"call":"engine.execute","params":{"command":"edit.undo","params":{}}}])).unwrap();
+            assert!((aligned(&h) - 3.0).abs() < 1e-6);
+            h.run(&json!([{"call":"engine.execute","params":{"command":"edit.redo","params":{}}}])).unwrap();
+            assert!(aligned(&h).abs() < 1e-6);
+        }
+    }
+}
+
+#[test]
+fn horizontal_vertical_still_accepts_one_line() {
+    let mut h = Harness::new();
+    h.run(&json!([
+        {"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}},
+        {"call":"engine.execute","params":{"command":"sketch.line","params":{"points":[[10,10],[40,13]],"infer":false}}},
+        {"call":"ui.view","params":{"view":"top"}},
+        {"start":"sketch.constraint.horizontal_vertical"},
+        {"click":{"sketch":[25,11.5]}},
+        {"expect":{"errors":0}}
+    ]))
+    .unwrap();
+    let sk = &h.app.session.model.state().sketches[0].sketch;
+    assert!(sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Horizontal { .. })));
+    let a = sk.point(sk.resolve_point("l1.start").unwrap()).unwrap();
+    let b = sk.point(sk.resolve_point("l1.end").unwrap()).unwrap();
+    assert!((a.y - b.y).abs() < 1e-6);
+}
+
+#[test]
+fn horizontal_vertical_ignores_curves_and_cancels_a_pending_point() {
+    let mut h = Harness::new();
+    h.run(&json!([
+        {"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}},
+        {"call":"engine.execute","params":{"command":"sketch.circle.center","params":{"center":[20,3],"radius":5}}},
+        {"call":"ui.view","params":{"view":"top"}},
+        {"start":"sketch.constraint.horizontal_vertical"},
+        {"click":{"sketch":[25,3]}}
+    ]))
+    .unwrap();
+    assert!(h.app.tool.as_ref().unwrap().picks.is_empty());
+    assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error));
+    let undo = h.app.session.undo.len();
+    h.run(&json!([{"click":{"sketch":[0,0]}}, {"click":{"sketch":[25,3]}}])).unwrap();
+    assert_eq!(h.app.tool.as_ref().unwrap().picks.len(), 1);
+    h.run(&json!([{"key":"Escape"}])).unwrap();
+    assert!(h.app.tool.is_none());
+    assert_eq!(h.app.session.undo.len(), undo);
+    let sk = &h.app.session.model.state().sketches[0].sketch;
+    let p = sk.point(sk.resolve_point("c1.center").unwrap()).unwrap();
+    assert!((p.y - 3.0).abs() < 1e-6);
+}
diff --git a/docs/book/src/guide/sketching.md b/docs/book/src/guide/sketching.md
index de24f0d4..38b908ab 100644
--- a/docs/book/src/guide/sketching.md
+++ b/docs/book/src/guide/sketching.md
@@ -54,6 +54,10 @@ fresh link once the source is available; their stored point values are preserved
 
 ## Constraints and dimensions
 
+**Horizontal/Vertical** accepts a click on a line or clicks on two distinct sketch points,
+including the origin, endpoints and circle centres. For two points, it chooses horizontal
+or vertical alignment from their current positions. Esc cancels a pending first point.
+
 The solver is SolveCraft's own (damped Gauss–Newton with degree-of-freedom analysis). Constraints:
 coincident, horizontal/vertical, parallel, perpendicular, tangent, equal, concentric, collinear,
 midpoint, symmetry, fix, curvature (G2) and polygon. **Sketch Dimension** (D) adds linear,

From 5cc65fe46bfbac10b1210e1416f4b8b5126b9c31 Mon Sep 17 00:00:00 2001
From: lillith <35337584+0xlillith@users.noreply.github.com>
Date: Sun, 11 Oct 2026 01:09:01 +0200
Subject: [PATCH 2/7] fix: apply curve-pair constraints to sketch preselection

---
 crates/ui-egui/src/lib.rs                     |  21 +++
 .../ui-egui/tests/constraint_preselection.rs  | 123 ++++++++++++++++++
 docs/book/src/guide/sketching.md              |   5 +
 3 files changed, 149 insertions(+)
 create mode 100644 crates/ui-egui/tests/constraint_preselection.rs

diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 11577212..ff1a316c 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -517,6 +517,27 @@ impl SolveApp {
             self.last_command = Some((spec.id.to_string(), spec.label.to_string()));
         }
         if let Some(mut t) = tools::Tool::for_command(id) {
+            // Curve-pair constraints can consume an exact preselection. Leave ambiguous
+            // selections to the ordinary pick tool; never silently constrain a subset.
+            if matches!(
+                id,
+                "sketch.constraint.parallel"
+                    | "sketch.constraint.perpendicular"
+                    | "sketch.constraint.equal"
+                    | "sketch.constraint.tangent"
+                    | "sketch.constraint.concentric"
+                    | "sketch.constraint.collinear"
+            ) && let [solvecraft_engine::Sel::SketchCurve { id: a }, solvecraft_engine::Sel::SketchCurve { id: b }] =
+                self.session.selection.as_slice()
+                && a != b
+            {
+                let params = json!({ "a": a, "b": b });
+                if self.run(id, params).is_ok() {
+                    let _ = self.session.execute("select.clear", &json!({}));
+                    self.set_status("Constraint applied", false);
+                }
+                return;
+            }
             if id == "sketch.dimension" {
                 t.picks = self
                     .session
diff --git a/crates/ui-egui/tests/constraint_preselection.rs b/crates/ui-egui/tests/constraint_preselection.rs
new file mode 100644
index 00000000..215d5fb5
--- /dev/null
+++ b/crates/ui-egui/tests/constraint_preselection.rs
@@ -0,0 +1,123 @@
+//! Constraint tools accept a selected curve pair as well as tool-first clicks.
+
+use serde_json::json;
+use solvecraft_engine::{Sel, sketch::ConstraintKind};
+use solvecraft_ui_egui::scenario::Harness;
+
+fn lines() -> Harness {
+    let mut h = Harness::new();
+    h.run(&json!([
+        {"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}},
+        {"call":"engine.execute","params":{"command":"sketch.line","params":{"points":[[10,10],[40,10]],"infer":false}}},
+        {"call":"engine.execute","params":{"command":"sketch.line","params":{"points":[[10,30],[40,35]],"infer":false}}},
+        {"call":"ui.view","params":{"view":"top"}}
+    ]))
+    .unwrap();
+    h
+}
+
+fn select_lines(h: &mut Harness) {
+    h.run(&json!([
+        {"click":{"sketch":[25,10]}},
+        {"click":{"sketch":[25,32.5]},"shift":true}
+    ]))
+    .unwrap();
+    assert_eq!(h.app.session.selection, vec![Sel::SketchCurve { id: "l1".into() }, Sel::SketchCurve { id: "l2".into() }]);
+}
+
+#[test]
+fn selected_lines_apply_constraints_with_one_undo_step() {
+    for command in ["parallel", "perpendicular", "equal", "collinear"] {
+        let mut h = lines();
+        select_lines(&mut h);
+        let before = h.app.session.doc.clone();
+        let undo = h.app.session.undo.len();
+        h.run(&json!([{"start":format!("sketch.constraint.{command}")}])).unwrap();
+        assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error), "{command}");
+        let sk = &h.app.session.model.state().sketches[0].sketch;
+        assert!(
+            sk.constraints.iter().any(|c| match command {
+                "parallel" => matches!(c.kind, ConstraintKind::Parallel { .. }),
+                "perpendicular" => matches!(c.kind, ConstraintKind::Perpendicular { .. }),
+                "equal" => matches!(c.kind, ConstraintKind::Equal { .. }),
+                _ => matches!(c.kind, ConstraintKind::Collinear { .. }),
+            }),
+            "{command}"
+        );
+        let after = h.app.session.doc.clone();
+        assert_eq!(h.app.session.undo.len(), undo + 1);
+        assert!(h.app.session.selection.is_empty());
+        assert!(h.app.tool.is_none());
+        h.app.session.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(serde_json::to_value(&h.app.session.doc).unwrap(), serde_json::to_value(before).unwrap());
+        h.app.session.execute("edit.redo", &json!({})).unwrap();
+        assert_eq!(serde_json::to_value(&h.app.session.doc).unwrap(), serde_json::to_value(after).unwrap());
+    }
+}
+
+#[test]
+fn selected_circles_apply_constraints() {
+    for command in ["tangent", "concentric", "equal"] {
+        let mut h = Harness::new();
+        h.run(&json!([
+            {"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}},
+            {"call":"engine.execute","params":{"command":"sketch.circle.center","params":{"center":[10,10],"radius":5}}},
+            {"call":"engine.execute","params":{"command":"sketch.circle.center","params":{"center":[25,12],"radius":7}}},
+            {"call":"ui.view","params":{"view":"top"}},
+            {"click":{"sketch":[10,15]}},
+            {"click":{"sketch":[25,19]},"shift":true}
+        ]))
+        .unwrap();
+        assert_eq!(h.app.session.selection.len(), 2);
+        let undo = h.app.session.undo.len();
+        h.run(&json!([{"start":format!("sketch.constraint.{command}")}])).unwrap();
+        assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error), "{command}");
+        assert_eq!(h.app.session.undo.len(), undo + 1, "{command}");
+        let sk = &h.app.session.model.state().sketches[0].sketch;
+        assert!(sk.constraints.iter().any(|c| match command {
+            "tangent" => matches!(c.kind, ConstraintKind::Tangent { .. }),
+            "concentric" => matches!(c.kind, ConstraintKind::Concentric { .. }),
+            _ => matches!(c.kind, ConstraintKind::Equal { .. }),
+        }));
+        assert!(h.app.session.selection.is_empty());
+    }
+}
+
+#[test]
+fn ambiguous_selection_preserves_tool_first_workflow() {
+    for selection in [
+        vec![],
+        vec![Sel::SketchCurve { id: "l1".into() }],
+        vec![Sel::SketchCurve { id: "l1".into() }, Sel::SketchCurve { id: "l2".into() }, Sel::SketchPoint { id: "origin".into() }],
+    ] {
+        let mut h = lines();
+        h.app.session.selection = selection;
+        let undo = h.app.session.undo.len();
+        h.run(&json!([{"start":"sketch.constraint.parallel"}])).unwrap();
+        assert_eq!(h.app.session.undo.len(), undo);
+        assert!(h.app.tool.as_ref().unwrap().picks.is_empty());
+        h.run(&json!([{"click":{"sketch":[25,10]}}, {"click":{"sketch":[25,32.5]}}])).unwrap();
+        assert_eq!(h.app.session.undo.len(), undo + 1);
+        assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error));
+    }
+}
+
+#[test]
+fn rejected_preselection_preserves_document_and_error() {
+    let mut h = lines();
+    h.app.session.execute("sketch.constraint.fix", &json!({"entities":["l1","l2"]})).unwrap();
+    select_lines(&mut h);
+    let before = serde_json::to_value(&h.app.session.doc).unwrap();
+    let undo = h.app.session.undo.len();
+    let selection = h.app.session.selection.clone();
+    h.run(&json!([{"start":"sketch.constraint.parallel"}])).unwrap();
+    assert!(h.app.status.as_ref().is_some_and(|(_, _, error)| *error));
+    assert_eq!(serde_json::to_value(&h.app.session.doc).unwrap(), before);
+    assert_eq!(h.app.session.undo.len(), undo);
+    assert_eq!(h.app.session.selection, selection);
+    // Correct the conflict and retry without reselecting; the old error must disappear.
+    h.app.session.execute("sketch.constraint.fix", &json!({"entities":["l1","l2"]})).unwrap();
+    h.run(&json!([{"start":"sketch.constraint.parallel"}])).unwrap();
+    assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error));
+    assert!(h.app.session.selection.is_empty());
+}
diff --git a/docs/book/src/guide/sketching.md b/docs/book/src/guide/sketching.md
index de24f0d4..7bb00f1b 100644
--- a/docs/book/src/guide/sketching.md
+++ b/docs/book/src/guide/sketching.md
@@ -60,6 +60,11 @@ midpoint, symmetry, fix, curvature (G2) and polygon. **Sketch Dimension** (D) ad
 aligned, horizontal, vertical, radius, diameter and angle dimensions. Each is a parameter
 (`d1`, `d2`, …), so it can hold an expression.
 
+For Parallel, Perpendicular, Equal, Tangent, Concentric and Collinear, select exactly two
+sketch curves (Shift-click to add the second) and choose the constraint to apply it immediately.
+You can also start the constraint first and then pick its curves. An incomplete or mixed
+selection starts that pick workflow; a rejected constraint keeps the selection for correction.
+
 Under-constrained geometry is blue and fully constrained geometry turns dark, and the status
 shows the remaining degrees of freedom. A constraint or dimension that would over-constrain the
 sketch is refused rather than applied. Drag a point to move it; the solver keeps every

From 7c667eda536e1bbaa0d42a374955c310d0748b4b Mon Sep 17 00:00:00 2001
From: lillith <35337584+0xlillith@users.noreply.github.com>
Date: Sun, 11 Oct 2026 01:24:42 +0200
Subject: [PATCH 3/7] test: verify constrained line geometry after preselection
 and redo

---
 .../ui-egui/tests/constraint_preselection.rs  | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/crates/ui-egui/tests/constraint_preselection.rs b/crates/ui-egui/tests/constraint_preselection.rs
index 215d5fb5..6787aee7 100644
--- a/crates/ui-egui/tests/constraint_preselection.rs
+++ b/crates/ui-egui/tests/constraint_preselection.rs
@@ -25,6 +25,29 @@ fn select_lines(h: &mut Harness) {
     assert_eq!(h.app.session.selection, vec![Sel::SketchCurve { id: "l1".into() }, Sel::SketchCurve { id: "l2".into() }]);
 }
 
+fn assert_line_geometry(h: &Harness, command: &str) {
+    let sk = &h.app.session.model.state().sketches[0].sketch;
+    let point = |name| sk.point(sk.resolve_point(name).unwrap()).unwrap();
+    let a = point("l1.start");
+    let b = point("l2.start");
+    let u = point("l1.end") - a;
+    let v = point("l2.end") - b;
+    // Normalization also rejects a collapsed line; zero-length vectors must not
+    // accidentally satisfy the parallel/perpendicular checks.
+    let du = u.normalized().unwrap();
+    let dv = v.normalized().unwrap();
+    match command {
+        "parallel" => assert!(du.cross(dv).abs() < 1e-6),
+        "perpendicular" => assert!(du.dot(dv).abs() < 1e-6),
+        "equal" => assert!((u.len() - v.len()).abs() < 1e-6),
+        "collinear" => {
+            assert!(du.cross(dv).abs() < 1e-6);
+            assert!((b - a).cross(du).abs() < 1e-6);
+        }
+        _ => panic!("unexpected line constraint: {command}"),
+    }
+}
+
 #[test]
 fn selected_lines_apply_constraints_with_one_undo_step() {
     for command in ["parallel", "perpendicular", "equal", "collinear"] {
@@ -44,6 +67,7 @@ fn selected_lines_apply_constraints_with_one_undo_step() {
             }),
             "{command}"
         );
+        assert_line_geometry(&h, command);
         let after = h.app.session.doc.clone();
         assert_eq!(h.app.session.undo.len(), undo + 1);
         assert!(h.app.session.selection.is_empty());
@@ -52,6 +76,7 @@ fn selected_lines_apply_constraints_with_one_undo_step() {
         assert_eq!(serde_json::to_value(&h.app.session.doc).unwrap(), serde_json::to_value(before).unwrap());
         h.app.session.execute("edit.redo", &json!({})).unwrap();
         assert_eq!(serde_json::to_value(&h.app.session.doc).unwrap(), serde_json::to_value(after).unwrap());
+        assert_line_geometry(&h, command);
     }
 }
 

From 3afd6ae4472aaa0d267e292ec5c6c59f02546732 Mon Sep 17 00:00:00 2001
From: Mithril-3d <hinata19830813@gmail.com>
Date: Sun, 11 Oct 2026 12:41:41 +0900
Subject: [PATCH 4/7] feat: add multi-language (i18n) support with Japanese UI

---
 apps/solvecraft/src/main.rs          |   1 +
 crates/ui-egui/src/browser.rs        |   9 +-
 crates/ui-egui/src/context_menu.rs   |  13 +-
 crates/ui-egui/src/dialogs.rs        |  31 +-
 crates/ui-egui/src/documents.rs      |  32 +-
 crates/ui-egui/src/fonts.rs          |  46 +++
 crates/ui-egui/src/i18n.rs           | 424 +++++++++++++++++++++++++++
 crates/ui-egui/src/lib.rs            |   8 +
 crates/ui-egui/src/prefs.rs          |  73 +++--
 crates/ui-egui/src/sketch_palette.rs |  31 +-
 crates/ui-egui/src/toolbar.rs        |  59 ++--
 11 files changed, 647 insertions(+), 80 deletions(-)
 create mode 100644 crates/ui-egui/src/fonts.rs
 create mode 100644 crates/ui-egui/src/i18n.rs

diff --git a/apps/solvecraft/src/main.rs b/apps/solvecraft/src/main.rs
index f7e14d3f..0d9cd71b 100644
--- a/apps/solvecraft/src/main.rs
+++ b/apps/solvecraft/src/main.rs
@@ -169,6 +169,7 @@ fn main() -> eframe::Result {
         "SolveCraft",
         options,
         Box::new(move |cc| {
+            solvecraft_ui_egui::fonts::setup_fonts(&cc.egui_ctx);
             let mut app = SolveApp::new(Session::default(), services());
             app.custom_titlebar = CUSTOM_TITLEBAR;
             app.integrated_titlebar = cfg!(target_os = "macos");
diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rs
index 5fbc0c8f..cedabc0c 100644
--- a/crates/ui-egui/src/browser.rs
+++ b/crates/ui-egui/src/browser.rs
@@ -351,7 +351,8 @@ pub(crate) fn draw_row(ui: &mut egui::Ui, id: egui::Id, row: &Row) -> RowResp {
         x += 21.0;
     }
     let col = row.color.unwrap_or(if row.dim { t.text_dim } else { t.text });
-    let galley = ui.painter().layout_no_wrap(row.label.to_string(), FontId::proportional(12.5), col);
+    let label_display = crate::i18n::tr_dyn(row.label);
+    let galley = ui.painter().layout_no_wrap(label_display, FontId::proportional(12.5), col);
     let lw = galley.size().x;
     ui.painter().galley(pos2(x, cy - galley.size().y / 2.0), galley, col);
     let mut bx = (x + lw + 6.0).min(r.right() - 16.0);
@@ -362,9 +363,9 @@ pub(crate) fn draw_row(ui: &mut egui::Ui, id: egui::Id, row: &Row) -> RowResp {
     }
     crate::scenario::publish_handle(&format!("row:{}", row.label), r.center());
     let tip = match hover_on {
-        1 => Some(if row.fold == Some(true) { "Collapse" } else { "Expand" }),
-        2 => Some(if row.eye == Some(true) { "Hide" } else { "Show" }),
-        3 => Some(if row.radio == Some(true) { "Active component" } else { "Activate" }),
+        1 => Some(if row.fold == Some(true) { crate::i18n::tr("Collapse") } else { crate::i18n::tr("Expand") }),
+        2 => Some(if row.eye == Some(true) { crate::i18n::tr("Hide") } else { crate::i18n::tr("Show") }),
+        3 => Some(if row.radio == Some(true) { crate::i18n::tr("Active component") } else { crate::i18n::tr("Activate") }),
         _ => None,
     };
     let resp = match tip {
diff --git a/crates/ui-egui/src/context_menu.rs b/crates/ui-egui/src/context_menu.rs
index 3b9ba9ab..c5dbeaaa 100644
--- a/crates/ui-egui/src/context_menu.rs
+++ b/crates/ui-egui/src/context_menu.rs
@@ -1273,7 +1273,8 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
                 painter.circle_filled(c, 3.0, t.text_dim);
             }
             for (k, item) in radial.iter().enumerate() {
-                let galley = painter.layout_no_wrap(item.label.clone(), font.clone(), if item.enabled { t.text } else { t.text_dim });
+                let display_label = crate::i18n::tr(&item.label);
+                let galley = painter.layout_no_wrap(display_label.to_string(), font.clone(), if item.enabled { t.text } else { t.text_dim });
                 let size = vec2(galley.size().x + 40.0, 28.0);
                 let rr = slot_rect(c, k, size);
                 let resp = ui.interact(rr, ui.id().with(("radial", k)), Sense::click());
@@ -1295,7 +1296,7 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
                     picked = Some(item.clone());
                 }
                 if item.enabled {
-                    resp.on_hover_text(item.shortcut.clone());
+                    resp.on_hover_text(crate::i18n::tr(&item.shortcut).to_string());
                 }
             }
         });
@@ -1393,7 +1394,7 @@ pub fn list_row_lit(ui: &mut egui::Ui, item: &Item, lit: bool) -> Option<Item> {
         ui.painter().text(
             pos2(r.left() + 8.0, r.center().y + 2.0),
             Align2::LEFT_CENTER,
-            item.label.to_uppercase(),
+            crate::i18n::tr(&item.label).to_uppercase(),
             FontId::proportional(10.5),
             t.text_dim,
         );
@@ -1415,9 +1416,11 @@ pub fn list_row_lit(ui: &mut egui::Ui, item: &Item, lit: bool) -> Option<Item> {
         );
     }
     let text = if item.enabled { t.text } else { t.text_dim.gamma_multiply(0.75) };
-    ui.painter().text(pos2(r.left() + 32.0, r.center().y), Align2::LEFT_CENTER, &item.label, FontId::proportional(13.0), text);
+    let display_label = crate::i18n::tr(&item.label);
+    ui.painter().text(pos2(r.left() + 32.0, r.center().y), Align2::LEFT_CENTER, display_label, FontId::proportional(13.0), text);
     if !item.shortcut.is_empty() {
-        ui.painter().text(pos2(r.right() - 10.0, r.center().y), Align2::RIGHT_CENTER, &item.shortcut, FontId::proportional(11.5), t.text_dim);
+        let display_shortcut = crate::i18n::tr(&item.shortcut);
+        ui.painter().text(pos2(r.right() - 10.0, r.center().y), Align2::RIGHT_CENTER, display_shortcut, FontId::proportional(11.5), t.text_dim);
     }
     (item.enabled && resp.clicked()).then(|| item.clone())
 }
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index 5038b79e..63e24a03 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -745,9 +745,10 @@ pub(crate) fn field(ui: &mut egui::Ui, s: &mut String) -> bool {
 
 pub(crate) fn combo(ui: &mut egui::Ui, id: &str, labels: &[&str], sel: &mut usize) {
     let row = ROW.with(|r| r.borrow().clone());
-    let r = egui::ComboBox::from_id_salt(id).selected_text(labels.get(*sel).copied().unwrap_or("")).width(FIELD_W).show_ui(ui, |ui| {
+    let selected = labels.get(*sel).copied().map(tr).unwrap_or("");
+    let r = egui::ComboBox::from_id_salt(id).selected_text(selected).width(FIELD_W).show_ui(ui, |ui| {
         for (i, l) in labels.iter().enumerate() {
-            let item = ui.selectable_value(sel, i, *l);
+            let item = ui.selectable_value(sel, i, tr(l));
             crate::scenario::publish_handle(&format!("dialog:{row}:{l}"), item.rect.center());
         }
     });
@@ -757,6 +758,11 @@ pub(crate) fn combo(ui: &mut egui::Ui, id: &str, labels: &[&str], sel: &mut usiz
 thread_local! {
     /// The label of the dialog row being laid out (its widgets publish `dialog:<label>` handles).
     static ROW: std::cell::RefCell<String> = const { std::cell::RefCell::new(String::new()) };
+    static LANG: std::cell::RefCell<String> = const { std::cell::RefCell::new(String::new()) };
+}
+
+fn tr(text: &str) -> &str {
+    crate::i18n::tr(text)
 }
 
 /// A dialog row's widget, for scenarios and demos: the handle `dialog:<row label>`.
@@ -848,11 +854,12 @@ const LABEL_MAX_W: f32 = 150.0;
 /// A row label in the dialog's label column (the grid sizes the column to its widest label).
 pub(crate) fn row_label(ui: &mut egui::Ui, text: &str) {
     ROW.with(|r| *r.borrow_mut() = text.to_string());
-    let full = egui::WidgetText::from(text).into_galley(ui, Some(egui::TextWrapMode::Extend), f32::INFINITY, egui::TextStyle::Body).size().x;
+    let display_text = tr(text);
+    let full = egui::WidgetText::from(display_text).into_galley(ui, Some(egui::TextWrapMode::Extend), f32::INFINITY, egui::TextStyle::Body).size().x;
     let w = full.clamp(LABEL_W, LABEL_MAX_W);
     ui.allocate_ui_with_layout(vec2(w, 22.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
         ui.set_width(w);
-        ui.add(egui::Label::new(text).wrap());
+        ui.add(egui::Label::new(display_text).wrap());
     });
 }
 
@@ -1026,9 +1033,9 @@ fn input_rows(d: &mut Dialog, ui: &mut egui::Ui) {
             // A chip: "↖ Select" (outlined) while empty, "N selected" (filled) once picked.
             let filled = !inp.items.is_empty();
             let text = if filled {
-                RichText::new(format!("↖ {} selected", inp.items.len())).color(Color32::WHITE)
+                RichText::new(format!("↖ {} {}", inp.items.len(), tr("selected"))).color(Color32::WHITE)
             } else {
-                RichText::new("↖ Select").color(t.text)
+                RichText::new(format!("↖ {}", tr("Select"))).color(t.text)
             };
             let stroke = if active { Stroke::new(1.5, t.accent) } else { Stroke::new(1.0, t.dialog_border.gamma_multiply(1.6)) };
             // Not in the Tab order: Tab moves between values.
@@ -1208,6 +1215,7 @@ fn auto_operation(app: &SolveApp, d: &mut Dialog) {
 /// the view cube, sized to its content.
 pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
     let Some(mut d) = app.dialog.take() else { return };
+    LANG.with(|l| *l.borrow_mut() = app.preferences.language.clone());
     auto_operation(app, &mut d);
     update_measure(app, &mut d);
     update_fill_cells(app, &mut d);
@@ -1220,7 +1228,8 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
     let mut cancel = false;
     let mut enter = false;
     let wide = d.is_wide();
-    let heading = if d.editing.is_some() { format!("EDIT {}", title(&d.kind)) } else { title(&d.kind).to_string() };
+    let raw_title = title(&d.kind);
+    let heading = if d.editing.is_some() { format!("{} {}", tr("EDIT"), tr(raw_title)) } else { tr(raw_title).to_string() };
     let frame = egui::Frame::window(&ctx.global_style())
         .fill(t.dialog_bg)
         .stroke(Stroke::new(1.0, t.dialog_border))
@@ -1807,17 +1816,19 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
             let buttons = if has_ok { 64.0 * 2.0 + ui.spacing().item_spacing.x } else { 64.0 };
             crate::frame::right_aligned(ui, total, buttons, |ui| {
                 if has_ok {
-                    let label = if matches!(d.kind, Kind::ConfirmDelete { .. }) { "Delete" } else { "OK" };
+                    let raw_label = if matches!(d.kind, Kind::ConfirmDelete { .. }) { "Delete" } else { "OK" };
+                    let label = tr(raw_label);
                     let b = egui::Button::new(RichText::new(label).color(if valid { Color32::WHITE } else { t.text_dim }))
                         .fill(if valid { t.accent } else { Color32::TRANSPARENT })
                         .min_size(vec2(64.0, 24.0));
                     let r = ui.add_enabled(valid, b);
-                    crate::scenario::publish_handle(&format!("dialog:{label}"), r.rect.center());
+                    crate::scenario::publish_handle(&format!("dialog:{raw_label}"), r.rect.center());
                     if r.clicked() {
                         ok = true;
                     }
                 }
-                let close = if matches!(d.kind, Kind::Params { .. } | Kind::Measure { .. }) { "Close" } else { "Cancel" };
+                let raw_close = if matches!(d.kind, Kind::Params { .. } | Kind::Measure { .. }) { "Close" } else { "Cancel" };
+                let close = tr(raw_close);
                 if ui.add(egui::Button::new(close).min_size(vec2(64.0, 24.0))).clicked() {
                     cancel = true;
                 }
diff --git a/crates/ui-egui/src/documents.rs b/crates/ui-egui/src/documents.rs
index 60a1ca1f..5ff6267e 100644
--- a/crates/ui-egui/src/documents.rs
+++ b/crates/ui-egui/src/documents.rs
@@ -307,7 +307,14 @@ pub fn tabs(app: &mut SolveApp, ui: &mut egui::Ui, r: Rect, x0: f32, x1: f32) {
             t.app_bar
         },
     );
-    ui.painter().text(home.center(), Align2::CENTER_CENTER, "Home", FontId::proportional(13.0), if app.home.open { t.text } else { t.app_bar_text });
+    let home_text = app.tr("Home");
+    ui.painter().text(
+        home.center(),
+        Align2::CENTER_CENTER,
+        home_text,
+        FontId::proportional(13.0),
+        if app.home.open { t.text } else { t.app_bar_text },
+    );
     crate::scenario::publish_handle("tab:home", home.center());
     if response.clicked() {
         app.home.show(app.session.revision);
@@ -342,7 +349,8 @@ pub fn tabs(app: &mut SolveApp, ui: &mut egui::Ui, r: Rect, x0: f32, x1: f32) {
         };
         ui.painter().rect_filled(tr, egui::CornerRadius { nw: 5, ne: 5, sw: 0, se: 0 }, fill);
         let ink = if active { t.text } else { t.app_bar_text };
-        let label = format!("{name}{}", if *dirty { " •" } else { "" });
+        let name_display = if name == "Untitled" { app.tr("Untitled") } else { name };
+        let label = format!("{name_display}{}", if *dirty { " •" } else { "" });
         let g = ui.painter().layout_no_wrap(label, FontId::proportional(13.0), ink);
         let text_w = (tr.width() - 30.0).max(10.0);
         let clip = Rect::from_min_size(tr.min, vec2(text_w + 10.0, tr.height()));
@@ -447,23 +455,33 @@ pub fn prompt(app: &mut SolveApp, ctx: &egui::Context) {
     quit_step(app);
     let Some(i) = app.docs.closing else { return };
     let name = tabs_info(app).get(i).map(|x| x.0.clone()).unwrap_or_default();
+    let name_display = if name == "Untitled" { crate::i18n::tr("Untitled") } else { &name };
     let mut answer: Option<Answer> = None;
-    crate::frame::window(ctx, format!("Save changes to {name}?"), crate::frame::Width::Normal)
+    let title = if crate::i18n::current_lang() == "ja" {
+        format!("{name_display} への変更を保存しますか？")
+    } else {
+        format!("Save changes to {name}?")
+    };
+    crate::frame::window(ctx, title, crate::frame::Width::Normal)
         .id(egui::Id::new("sc_close_prompt"))
         .collapsible(false)
         .resizable(false)
         .anchor(Align2::CENTER_CENTER, vec2(0.0, 0.0))
         .show(ctx, |ui| {
-            ui.label(format!("{name} has unsaved changes. If you don't save, they are lost."));
+            if crate::i18n::current_lang() == "ja" {
+                ui.label(format!("{name_display} には保存されていない変更があります。保存しない場合、変更内容は失われます。"));
+            } else {
+                ui.label(format!("{name} has unsaved changes. If you don't save, they are lost."));
+            }
             ui.add_space(8.0);
             ui.horizontal(|ui| {
-                if ui.button("Save").clicked() {
+                if ui.button(crate::i18n::tr("Save")).clicked() {
                     answer = Some(Answer::Save);
                 }
-                if ui.button("Don't Save").clicked() {
+                if ui.button(crate::i18n::tr("Don't Save")).clicked() {
                     answer = Some(Answer::DontSave);
                 }
-                if ui.button("Cancel").clicked() {
+                if ui.button(crate::i18n::tr("Cancel")).clicked() {
                     answer = Some(Answer::Cancel);
                 }
             });
diff --git a/crates/ui-egui/src/fonts.rs b/crates/ui-egui/src/fonts.rs
new file mode 100644
index 00000000..3b6e86f7
--- /dev/null
+++ b/crates/ui-egui/src/fonts.rs
@@ -0,0 +1,46 @@
+//! System font loading and fallback setup for multi-language (CJK/Japanese) support.
+
+use std::sync::Arc;
+
+/// Candidate font paths to look for on different operating systems.
+const FONT_CANDIDATES: &[&str] = &[
+    // Windows
+    "C:\\Windows\\Fonts\\meiryo.ttc",
+    "C:\\Windows\\Fonts\\YuGothM.ttc",
+    "C:\\Windows\\Fonts\\YuGothR.ttc",
+    "C:\\Windows\\Fonts\\msgothic.ttc",
+    "C:\\Windows\\Fonts\\BIZ-UDGothicR.ttc",
+    // macOS
+    "/System/Library/Fonts/Hiragino Sans GB.ttc",
+    "/System/Library/Fonts/PingFang.ttc",
+    "/Library/Fonts/Arial Unicode.ttf",
+    // Linux
+    "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
+    "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc",
+    "/usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc",
+    "/usr/share/fonts/truetype/droid/DroidSansFallbackFull.ttf",
+];
+
+/// Configure font definitions with system CJK fallback if available.
+pub fn setup_fonts(ctx: &egui::Context) {
+    let mut font_bytes: Option<Vec<u8>> = None;
+    for path in FONT_CANDIDATES {
+        if let Ok(bytes) = std::fs::read(path) {
+            font_bytes = Some(bytes);
+            break;
+        }
+    }
+
+    let Some(bytes) = font_bytes else {
+        return;
+    };
+
+    let mut fonts = egui::FontDefinitions::default();
+    fonts.font_data.insert("cjk_fallback".to_owned(), Arc::new(egui::FontData::from_owned(bytes)));
+
+    fonts.families.entry(egui::FontFamily::Proportional).or_default().push("cjk_fallback".to_owned());
+
+    fonts.families.entry(egui::FontFamily::Monospace).or_default().push("cjk_fallback".to_owned());
+
+    ctx.set_fonts(fonts);
+}
diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs
new file mode 100644
index 00000000..9a263134
--- /dev/null
+++ b/crates/ui-egui/src/i18n.rs
@@ -0,0 +1,424 @@
+//! Multi-language (i18n) static translation dictionary for SolveCraft.
+//!
+//! Provides zero-overhead, completely offline local string translations.
+
+/// Supported languages: (id, display_name).
+pub const LANGUAGES: [(&str, &str); 2] = [("en", "English"), ("ja", "日本語")];
+
+/// English to Japanese dictionary.
+const JA_TRANSLATIONS: &[(&str, &str)] = &[
+    // --- Common & Window controls ---
+    ("Preferences", "環境設定"),
+    ("General", "一般"),
+    ("Navigation", "ナビゲーション"),
+    ("Keyboard Shortcuts", "キーボードショートカット"),
+    ("Design", "デザイン"),
+    ("Graphics", "グラフィックス"),
+    ("Sketch", "スケッチ"),
+    ("Selection", "選択"),
+    ("Language", "言語"),
+    ("Theme", "テーマ"),
+    ("UI scale", "UIスケール"),
+    ("Units of new designs", "新規デザインの単位"),
+    ("Autosave every", "自動保存の間隔"),
+    ("Length decimals", "長さの小数点桁数"),
+    ("Angle decimals", "角度の小数点桁数"),
+    ("Agent cursor", "AIエージェントカーソル"),
+    ("Agent cursor speed", "AIエージェント速度"),
+    ("Restore Defaults", "初期値に戻す"),
+    ("Reset the settings on this page", "このページの設定をリセット"),
+    ("OK", "OK"),
+    ("Cancel", "キャンセル"),
+    ("Apply", "適用"),
+    ("Save", "保存"),
+    ("Don't Save", "保存しない"),
+    ("Untitled", "無題"),
+    ("Dark", "ダーク"),
+    ("Light", "ライト"),
+    ("System", "システム"),
+    ("Help", "ヘルプ"),
+    ("About", "SolveCraft について"),
+    ("Close", "閉じる"),
+    ("Delete", "削除"),
+    ("Expand", "展開"),
+    ("Collapse", "折りたたむ"),
+    // --- Preferences Navigation & Design ---
+    ("Pan, zoom, orbit", "パン、ズーム、オービット"),
+    ("Reverse zoom direction", "ズーム方向を反転"),
+    ("Zoom to the cursor", "カーソル位置へズーム"),
+    ("Orbit around", "回転の中心"),
+    ("View centre", "ビュー中心"),
+    ("Point under the cursor", "カーソル下の点"),
+    ("Animate view changes", "視点変更をアニメーション表示"),
+    ("Animation speed", "アニメーション速度"),
+    ("Default modelling orientation", "デフォルトのモデル方向"),
+    ("Offer to stand up Y-up files", "Y-upファイルを立ち上げるか確認"),
+    ("Visual style", "表示スタイル"),
+    // --- Application bar & Menus ---
+    ("File", "ファイル"),
+    ("Edit", "編集"),
+    ("Create", "作成"),
+    ("Modify", "修正"),
+    ("Assemble", "アセンブリ"),
+    ("Construct", "構築"),
+    ("Inspect", "検査"),
+    ("Insert", "挿入"),
+    ("Select", "選択"),
+    ("New Design", "新規デザイン"),
+    ("Open...", "開く..."),
+    ("Open", "開く"),
+    ("Save", "保存"),
+    ("Save As...", "名前を付けて保存..."),
+    ("Export...", "エクスポート..."),
+    ("Undo", "元に戻す"),
+    ("Redo", "やり直す"),
+    ("Cut", "切り取り"),
+    ("Copy", "コピー"),
+    ("Paste", "貼り付け"),
+    ("Clear Recent", "最近使った項目をクリア"),
+    ("Open Recent", "最近使った項目を開く"),
+    ("Quit", "終了"),
+    // --- Toolbar tabs ---
+    ("SOLID", "ソリッド"),
+    ("SURFACE", "サーフェス"),
+    ("MESH", "メッシュ"),
+    ("SHEET METAL", "板金"),
+    ("PLASTIC", "プラスチック"),
+    ("SKETCH", "スケッチ"),
+    ("CREATE", "作成"),
+    ("MODIFY", "修正"),
+    ("ASSEMBLE", "アセンブリ"),
+    ("CONSTRUCT", "構築"),
+    ("INSPECT", "検査"),
+    ("INSERT", "挿入"),
+    ("SELECT", "選択"),
+    ("FINISH SKETCH", "スケッチを終了"),
+    ("Finish Sketch", "スケッチを終了"),
+    // --- Sketch Palette ---
+    ("SKETCH PALETTE", "スケッチ パレット"),
+    ("Options", "オプション"),
+    ("Linetype", "線種"),
+    ("Normal", "標準"),
+    ("Construction", "構築"),
+    ("Centerline", "中心線"),
+    ("Look At", "視点を合わせる"),
+    ("Sketch Grid", "スケッチ グリッド"),
+    ("Snap", "スナップ"),
+    ("Slice", "スライス"),
+    ("Show Profile", "プロファイルを表示"),
+    ("Show Points", "点を表示"),
+    ("Show Dimensions", "寸法を表示"),
+    ("Show Constraints", "拘束を表示"),
+    ("Show Projected Geometries", "投影ジオメトリを表示"),
+    ("3D Sketch", "3D スケッチ"),
+    ("Fully constrained", "完全拘束"),
+    ("1 degree of freedom", "自由度 1"),
+    ("degrees of freedom", "自由度"),
+    ("Constraints conflict", "拘束が競合しています"),
+    // --- Dialog Titles (All Caps & Title Case) ---
+    ("CREATE SKETCH", "スケッチを作成"),
+    ("Create Sketch", "スケッチを作成"),
+    ("EDIT", "編集"),
+    ("EXTRUDE", "押し出し"),
+    ("Extrude", "押し出し"),
+    ("REVOLVE", "回転"),
+    ("Revolve", "回転"),
+    ("SWEEP", "スイープ"),
+    ("Sweep", "スイープ"),
+    ("LOFT", "ロフト"),
+    ("Loft", "ロフト"),
+    ("FILLET", "フィレット"),
+    ("Fillet", "フィレット"),
+    ("CHAMFER", "面取り"),
+    ("Chamfer", "面取り"),
+    ("SHELL", "シェル"),
+    ("Shell", "シェル"),
+    ("DRAFT", "勾配"),
+    ("Draft", "勾配"),
+    ("SCALE", "尺度"),
+    ("Scale", "尺度"),
+    ("COMBINE", "結合"),
+    ("Combine", "結合"),
+    ("SPLIT BODY", "ボディを分割"),
+    ("Split Body", "ボディを分割"),
+    ("MIRROR", "ミラー"),
+    ("Mirror", "ミラー"),
+    ("HOLE", "穴"),
+    ("Hole", "穴"),
+    ("THREAD", "ねじ"),
+    ("Thread", "ねじ"),
+    ("BOX", "直方体"),
+    ("Box", "直方体"),
+    ("CYLINDER", "円柱"),
+    ("Cylinder", "円柱"),
+    ("SPHERE", "球"),
+    ("Sphere", "球"),
+    ("TORUS", "トーラス"),
+    ("Torus", "トーラス"),
+    ("COIL", "コイル"),
+    ("Coil", "コイル"),
+    ("PIPE", "パイプ"),
+    ("Pipe", "パイプ"),
+    ("OFFSET PLANE", "オフセット平面"),
+    ("Offset Plane", "オフセット平面"),
+    ("PLANE AT ANGLE", "傾斜平面"),
+    ("Plane at Angle", "傾斜平面"),
+    ("MEASURE", "計測"),
+    ("Measure", "計測"),
+    ("SECTION ANALYSIS", "断面解析"),
+    ("Section Analysis", "断面解析"),
+    ("PARAMETERS", "パラメータ"),
+    ("Parameters", "パラメータ"),
+    ("MOVE", "移動"),
+    ("Move", "移動"),
+    ("RECTANGULAR PATTERN", "矩形パターン"),
+    ("Rectangular Pattern", "矩形パターン"),
+    ("CIRCULAR PATTERN", "円形パターン"),
+    ("Circular Pattern", "円形パターン"),
+    ("PATTERN ON PATH", "パス上のパターン"),
+    ("Pattern on Path", "パス上のパターン"),
+    // --- Dialog Row Labels and Inputs ---
+    ("Plane", "平面"),
+    ("Profile", "プロファイル"),
+    ("Profiles", "プロファイル"),
+    ("Axis", "軸"),
+    ("Axes", "軸"),
+    ("Path", "パス"),
+    ("Points", "点"),
+    ("Objects", "オブジェクト"),
+    ("Bodies", "ボディ"),
+    ("Features", "フィーチャー"),
+    ("Start", "開始"),
+    ("Offset", "オフセット"),
+    ("Profile Plane", "プロファイル平面"),
+    ("Direction", "方向"),
+    ("One Side", "片側"),
+    ("Two Sides", "両側"),
+    ("Symmetric", "対称"),
+    ("Extent Type", "範囲タイプ"),
+    ("Distance", "距離"),
+    ("Distance 1", "距離 1"),
+    ("Distance 2", "距離 2"),
+    ("To Object", "オブジェクトまで"),
+    ("All", "すべて"),
+    ("Taper Angle", "テーパ角度"),
+    ("Operation", "操作"),
+    ("New Body", "新規ボディ"),
+    ("Join", "結合"),
+    ("Cut", "切り取り"),
+    ("Intersect", "交差"),
+    ("Angle", "角度"),
+    ("Radius", "半径"),
+    ("Radius Type", "半径タイプ"),
+    ("Constant", "一定"),
+    ("Chord Length", "弦長"),
+    ("Variable", "可変"),
+    ("Start Radius", "開始半径"),
+    ("End Radius", "終了半径"),
+    ("Flip", "反転"),
+    ("Thickness", "厚さ"),
+    ("Placement", "配置"),
+    ("Single", "単一"),
+    ("Multiple", "複数"),
+    ("Hole Type", "穴タイプ"),
+    ("Simple", "単純"),
+    ("Counterbore", "座ぐり"),
+    ("Countersink", "皿もみ"),
+    ("Hole Tap Type", "タップタイプ"),
+    ("Tapped", "タップ立て"),
+    ("Drill Point", "先端"),
+    ("Flat", "フラット"),
+    ("Tip Angle", "先端角度"),
+    ("Diameter", "直径"),
+    ("Depth", "深さ"),
+    ("Object Type", "オブジェクトタイプ"),
+    ("Clear the selection", "選択をクリア"),
+    // --- Browser Tree ---
+    ("Document Settings", "ドキュメントの設定"),
+    ("Units", "単位"),
+    ("Named Views", "名前付きビュー"),
+    ("Origin", "原点"),
+    ("Top", "上面"),
+    ("Front", "正面"),
+    ("Right", "右側面"),
+    ("Home", "ホーム"),
+    // --- Sketch commands & tools ---
+    ("Line", "線分"),
+    ("Rectangle", "長方形"),
+    ("Circle", "円"),
+    ("Arc", "円弧"),
+    ("Polygon", "ポリゴン"),
+    ("Ellipse", "楕円"),
+    ("Slot", "スロット"),
+    ("Spline", "スプライン"),
+    ("Conic Curve", "円錐曲線"),
+    ("Point", "点"),
+    ("Text", "テキスト"),
+    ("Trim", "トリム"),
+    ("Extend", "延長"),
+    ("Break", "分割"),
+    ("Sketch Scale", "スケッチ尺度"),
+    ("Project", "投影"),
+    ("Dimension", "寸法"),
+    ("Sketch Dimension", "スケッチ寸法"),
+    ("Horizontal/Vertical", "水平/垂直"),
+    ("Coincident", "一致"),
+    ("Tangent", "正接"),
+    ("Equal", "等しい"),
+    ("Parallel", "平行"),
+    ("Perpendicular", "直交"),
+    ("Fix/Unfix", "固定/固定解除"),
+    ("Midpoint", "中点"),
+    ("Concentric", "同心円"),
+    ("Collinear", "同一直線"),
+    ("Symmetry", "対称"),
+    ("Curvature", "曲率"),
+    ("Smooth", "スムーズ"),
+    // --- Workspace selector & environments ---
+    ("DESIGN", "デザイン"),
+    ("workspace", "ワークスペース"),
+    ("Change workspace", "ワークスペースの変更"),
+    ("Generative Design", "ジェネレーティブ デザイン"),
+    ("Render", "レンダリング"),
+    ("Animation", "アニメーション"),
+    ("Simulation", "シミュレーション"),
+    ("Manufacture", "製造"),
+    ("Drawing", "図面"),
+    ("coming later", "準備中"),
+    ("current", "現在"),
+    // --- Browser Tree ---
+    ("Document Settings", "ドキュメントの設定"),
+    ("Units", "単位"),
+    ("Named Views", "名前付きビュー"),
+    ("Origin", "原点"),
+    ("Top", "上面"),
+    ("Front", "正面"),
+    ("Right", "右側面"),
+    ("Home", "ホーム"),
+    ("TOP", "上面"),
+    ("FRONT", "正面"),
+    ("RIGHT", "右側面"),
+    ("HOME", "ホーム"),
+    ("Bodies", "ボディ"),
+    ("Sketches", "スケッチ"),
+    ("Canvases", "キャンバス"),
+    ("Joints", "ジョイント"),
+    ("Construction", "構築"),
+    ("Collapse", "折りたたむ"),
+    ("Expand", "展開"),
+    ("Hide", "非表示"),
+    ("Show", "表示"),
+    ("Active component", "アクティブなコンポーネント"),
+    ("Activate", "アクティブ化"),
+];
+
+thread_local! {
+    static CURRENT_LANG: std::cell::RefCell<String> = const { std::cell::RefCell::new(String::new()) };
+}
+
+/// Sets the current UI language for the thread.
+pub fn set_current_lang(lang: &str) {
+    CURRENT_LANG.with(|l| {
+        *l.borrow_mut() = lang.to_string();
+    });
+}
+
+/// Gets the current UI language for the thread.
+pub fn current_lang() -> String {
+    CURRENT_LANG.with(|l| l.borrow().clone())
+}
+
+/// Translate text using the thread's current language.
+pub fn tr(text: &str) -> &str {
+    CURRENT_LANG.with(|l| {
+        let lang = l.borrow();
+        if lang.as_str() == "ja" { tr_for_lang("ja", text) } else { text }
+    })
+}
+
+/// Translate text using a specified language.
+pub fn tr_for_lang<'a>(lang: &str, text: &'a str) -> &'a str {
+    if lang == "ja" {
+        for &(en, ja) in JA_TRANSLATIONS {
+            if en == text {
+                return ja;
+            }
+        }
+    }
+    text
+}
+
+/// Dynamically translate labels including patterned names like "Sketch1", "Body2", "Units: mm", etc.
+pub fn tr_dyn(text: &str) -> String {
+    CURRENT_LANG.with(|l| {
+        let lang = l.borrow();
+        if lang.as_str() != "ja" {
+            return text.to_string();
+        }
+        for &(en, ja) in JA_TRANSLATIONS {
+            if en == text {
+                return ja.to_string();
+            }
+        }
+        if let Some(rest) = text.strip_prefix("Sketch")
+            && !rest.is_empty()
+            && rest.chars().all(|c| c.is_ascii_digit())
+        {
+            return format!("スケッチ{rest}");
+        }
+        if let Some(rest) = text.strip_prefix("Body")
+            && !rest.is_empty()
+            && rest.chars().all(|c| c.is_ascii_digit())
+        {
+            return format!("ボディ{rest}");
+        }
+        if let Some(rest) = text.strip_prefix("Component")
+            && !rest.is_empty()
+            && rest.chars().all(|c| c.is_ascii_digit())
+        {
+            return format!("コンポーネント{rest}");
+        }
+        if let Some(rest) = text.strip_prefix("Units: ") {
+            return format!("単位: {rest}");
+        }
+        if let Some(rest) = text.strip_prefix("Precision: ") {
+            return format!("精度: {rest}");
+        }
+        if let Some(rest) = text.strip_prefix("Parameters (") {
+            return format!("パラメータ ({rest}");
+        }
+        text.to_string()
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn translates_japanese() {
+        set_current_lang("ja");
+        assert_eq!(tr("Preferences"), "環境設定");
+        assert_eq!(tr("Extrude"), "押し出し");
+        assert_eq!(tr("CREATE SKETCH"), "スケッチを作成");
+        assert_eq!(tr("SKETCH PALETTE"), "スケッチ パレット");
+        assert_eq!(tr("Finish Sketch"), "スケッチを終了");
+        assert_eq!(tr("FINISH SKETCH"), "スケッチを終了");
+        assert_eq!(tr("Generative Design"), "ジェネレーティブ デザイン");
+        assert_eq!(tr("coming later"), "準備中");
+        assert_eq!(tr("Sketches"), "スケッチ");
+        assert_eq!(tr("NonExistentKey"), "NonExistentKey");
+
+        assert_eq!(tr_dyn("Sketch1"), "スケッチ1");
+        assert_eq!(tr_dyn("Body2"), "ボディ2");
+        assert_eq!(tr_dyn("Units: mm"), "単位: mm");
+    }
+
+    #[test]
+    fn keeps_english() {
+        set_current_lang("en");
+        assert_eq!(tr("Preferences"), "Preferences");
+        assert_eq!(tr("Extrude"), "Extrude");
+        assert_eq!(tr_dyn("Sketch1"), "Sketch1");
+    }
+}
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 34b7b49f..4e453f6c 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -27,11 +27,13 @@ pub mod dialogs_surface;
 pub mod dim_view;
 pub mod documents;
 pub mod drag_snap;
+pub mod fonts;
 pub mod frame;
 pub mod gizmo;
 pub mod gpu;
 pub mod help;
 pub mod home;
+pub mod i18n;
 pub mod icons;
 pub mod inference;
 pub mod keymap;
@@ -288,6 +290,11 @@ impl SolveApp {
         }
     }
 
+    /// Translate text using the active language preference.
+    pub fn tr<'a>(&self, text: &'a str) -> &'a str {
+        i18n::tr_for_lang(&self.preferences.language, text)
+    }
+
     /// Draw the viewport on the GPU (eframe's wgpu render state, with the app's depth and
     /// stencil buffer bits and MSAA sample count). Without it the viewport renders on the CPU.
     pub fn set_wgpu(&mut self, rs: &egui_wgpu::RenderState, depth_bits: u8, stencil_bits: u8, samples: u32) {
@@ -813,6 +820,7 @@ impl SolveApp {
     /// Lay out the whole window.
     pub fn ui(&mut self, ui: &mut egui::Ui) {
         let t0 = now_ms();
+        crate::i18n::set_current_lang(&self.preferences.language);
         scenario::clear_handles();
         toolbar::app_bar(self, ui);
         file_load::show(self, ui.ctx());
diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rs
index 4dcfe354..d256f48b 100644
--- a/crates/ui-egui/src/prefs.rs
+++ b/crates/ui-egui/src/prefs.rs
@@ -46,6 +46,8 @@ pub struct Prefs {
     pub angle_decimals: u8,
     /// `dark`, `light` or `system` (follow the operating system).
     pub theme: String,
+    /// Interface language (`en`, `ja`).
+    pub language: String,
     /// Interface scale (1 = 100 %).
     pub ui_scale: f32,
     /// The wheel zooms toward the point under the cursor (else toward the view's centre).
@@ -70,6 +72,7 @@ impl Default for Prefs {
             length_decimals: 2,
             angle_decimals: 1,
             theme: "dark".into(),
+            language: "en".into(),
             ui_scale: 1.0,
             zoom_to_cursor: true,
             look_at_anim: true,
@@ -157,6 +160,7 @@ fn defaults(app: &mut SolveApp, page: usize) {
     match page {
         0 => {
             p.theme = d.theme;
+            p.language = d.language;
             p.ui_scale = d.ui_scale;
             p.default_units = d.default_units;
             p.length_decimals = d.length_decimals;
@@ -376,7 +380,7 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
     let mut open = true;
     let mut button: Option<&str> = None;
     let before = app.preferences.clone();
-    crate::frame::window(ctx, "Preferences", crate::frame::Width::Wide)
+    crate::frame::window(ctx, app.tr("Preferences"), crate::frame::Width::Wide)
         .id(egui::Id::new("sc_prefs"))
         .open(&mut open)
         .collapsible(false)
@@ -389,7 +393,7 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
                 ui.vertical(|ui| {
                     ui.set_width(140.0);
                     for (i, s) in PAGES.iter().enumerate() {
-                        if ui.selectable_label(app.prefs_window.section == i, *s).clicked() {
+                        if ui.selectable_label(app.prefs_window.section == i, app.tr(s)).clicked() {
                             app.prefs_window.section = i;
                             app.keymap.read_only = false;
                         }
@@ -399,24 +403,24 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
                 ui.vertical(|ui| {
                     // A fixed width, so the window keeps its size from page to page.
                     ui.set_width(540.0);
-                    ui.label(RichText::new(PAGES.get(app.prefs_window.section).copied().unwrap_or_default()).strong().size(14.0));
+                    ui.label(RichText::new(app.tr(PAGES.get(app.prefs_window.section).copied().unwrap_or_default())).strong().size(14.0));
                     ui.add_space(6.0);
                     page(app, ui, &t);
                 });
             });
             ui.separator();
             ui.horizontal(|ui| {
-                if ui.button("Restore Defaults").on_hover_text("Reset the settings on this page").clicked() {
+                if ui.button(app.tr("Restore Defaults")).on_hover_text(app.tr("Reset the settings on this page")).clicked() {
                     button = Some("defaults");
                 }
                 crate::frame::right_aligned(ui, 700.0, 170.0, |ui| {
-                    if ui.button("OK").clicked() {
+                    if ui.button(app.tr("OK")).clicked() {
                         button = Some("ok");
                     }
-                    if ui.button("Cancel").clicked() {
+                    if ui.button(app.tr("Cancel")).clicked() {
                         button = Some("cancel");
                     }
-                    if ui.button("Apply").clicked() {
+                    if ui.button(app.tr("Apply")).clicked() {
                         button = Some("apply");
                     }
                 });
@@ -478,10 +482,19 @@ fn page(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) {
     }
     egui::Grid::new(("sc_prefs_grid", app.prefs_window.section)).num_columns(2).spacing([16.0, 8.0]).show(ui, |ui| match app.prefs_window.section {
         0 => {
-            ui.label("Theme");
+            ui.label(app.tr("Language"));
+            egui::ComboBox::from_id_salt("pref_language")
+                .selected_text(crate::i18n::LANGUAGES.iter().find(|(id, _)| *id == app.preferences.language).map_or("English", |x| x.1))
+                .show_ui(ui, |ui| {
+                    for (id, label) in crate::i18n::LANGUAGES {
+                        ui.selectable_value(&mut app.preferences.language, id.to_string(), label);
+                    }
+                });
+            ui.end_row();
+            ui.label(app.tr("Theme"));
             ui.horizontal(|ui| {
                 for (id, label) in THEMES {
-                    if ui.radio(app.preferences.theme == id, label).clicked() {
+                    if ui.radio(app.preferences.theme == id, app.tr(label)).clicked() {
                         app.preferences.theme = id.to_string();
                         if id != "system" {
                             app.ui.dark = id == "dark";
@@ -490,33 +503,34 @@ fn page(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) {
                 }
             });
             ui.end_row();
-            ui.label("UI scale");
+            ui.label(app.tr("UI scale"));
             ui.add(egui::Slider::new(&mut app.preferences.ui_scale, 0.75..=2.0).step_by(0.05).custom_formatter(|v, _| format!("{:.0} %", v * 100.0)));
             ui.end_row();
-            ui.label("Units of new designs");
+            ui.label(app.tr("Units of new designs"));
             egui::ComboBox::from_id_salt("pref_units").selected_text(app.preferences.default_units.clone()).show_ui(ui, |ui| {
                 for u in UNITS {
                     ui.selectable_value(&mut app.preferences.default_units, u.to_string(), u);
                 }
             });
             ui.end_row();
-            ui.label("Autosave every");
+            ui.label(app.tr("Autosave every"));
             if ui.add(egui::DragValue::new(&mut app.autosave_minutes).range(0.0..=120.0).speed(0.5).suffix(" min")).changed() {
                 set_autosave(app);
             }
             ui.end_row();
             note(ui, "0 turns it off");
-            ui.label("Length decimals");
+            ui.label(app.tr("Length decimals"));
             ui.add(egui::DragValue::new(&mut app.preferences.length_decimals).range(0..=6));
             ui.end_row();
-            ui.label("Angle decimals");
+            ui.label(app.tr("Angle decimals"));
             ui.add(egui::DragValue::new(&mut app.preferences.angle_decimals).range(0..=6));
             ui.end_row();
-            ui.label("Agent cursor");
+            ui.label(app.tr("Agent cursor"));
+            let speed_label = app.tr("Agent cursor speed");
             let s = &mut app.ui.agent_cursor;
             ui.checkbox(&mut s.show, "Show the pointer an AI agent moves (#35)");
             ui.end_row();
-            ui.label("Agent cursor speed");
+            ui.label(speed_label);
             ui.add_enabled_ui(s.show, |ui| {
                 crate::agent_cursor::speed_slider(ui, &mut s.speed);
             });
@@ -693,6 +707,9 @@ pub fn set(app: &mut SolveApp, p: &serde_json::Value) -> Result<serde_json::Valu
     if !THEMES.iter().any(|(id, _)| *id == new.theme) || !["z", "y"].contains(&new.up_axis.as_str()) {
         return Err("`theme` must be dark, light or system and `up_axis` z or y".into());
     }
+    if !crate::i18n::LANGUAGES.iter().any(|(id, _)| *id == new.language) {
+        return Err("`language` must be en or ja".into());
+    }
     if !(0.5..=2.5).contains(&new.ui_scale) || !(0.25..=4.0).contains(&new.look_at_speed) {
         return Err("`ui_scale` must be 0.5…2.5 and `look_at_speed` 0.25…4".into());
     }
@@ -778,11 +795,33 @@ mod tests {
         // File and Help › Keyboard Shortcuts open the same dialog at its page.
         app.keymap.open = true;
         let ctx = egui::Context::default();
-        let _ = ctx.run_ui(Default::default(), |ui| show(&mut app, ui.ctx()));
+        let mut out = ctx.run_ui(Default::default(), |ui| show(&mut app, ui.ctx()));
+        out.textures_delta.clear();
         assert!(app.prefs_window.open && app.prefs_window.section == PAGE_SHORTCUTS && !app.keymap.open);
         assert!(control(&mut app, &json!({"open": "Plugins"})).is_err());
         assert!(set(&mut app, &json!({"up_axis": "x"})).is_err());
         assert!(set(&mut app, &json!({"theme": "sepia"})).is_err());
+        assert!(set(&mut app, &json!({"language": "fr"})).is_err());
+    }
+
+    #[test]
+    fn language_preference_switches_and_persists() {
+        let mut app = SolveApp::new(solvecraft_engine::Session::default(), Default::default());
+        assert_eq!(app.preferences.language, "en");
+        assert_eq!(app.tr("Preferences"), "Preferences");
+        assert_eq!(app.tr("Extrude"), "Extrude");
+
+        // Switch language to Japanese
+        set(&mut app, &json!({"language": "ja"})).unwrap();
+        assert_eq!(app.preferences.language, "ja");
+        assert_eq!(app.tr("Preferences"), "環境設定");
+        assert_eq!(app.tr("Extrude"), "押し出し");
+
+        // Preferences round-trip
+        let mut other = SolveApp::new(solvecraft_engine::Session::default(), Default::default());
+        other.load_prefs(&app.prefs());
+        assert_eq!(other.preferences.language, "ja");
+        assert_eq!(other.tr("Preferences"), "環境設定");
     }
 
     /// A STEP file opened Z-up is offered to be stood up: a quarter turn about X, undoable.
diff --git a/crates/ui-egui/src/sketch_palette.rs b/crates/ui-egui/src/sketch_palette.rs
index aacf69fe..7cf75b32 100644
--- a/crates/ui-egui/src/sketch_palette.rs
+++ b/crates/ui-egui/src/sketch_palette.rs
@@ -201,7 +201,7 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
     let mut finish = false;
     let has_curves = !selected_curves(app).is_empty();
     crate::frame::docked(
-        "SKETCH PALETTE",
+        app.tr("SKETCH PALETTE"),
         egui::Id::new("sc_sketch_palette"),
         anchor,
         ctx.content_rect().bottom() - anchor.y - 8.0,
@@ -215,39 +215,47 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
             if ui.add(egui::Button::new(RichText::new(if folded { "+" } else { "−" }).size(14.0)).frame(false)).clicked() {
                 FOLDED.with(|f| f.set(!folded));
             }
-            ui.label(RichText::new("SKETCH PALETTE").strong().size(12.5));
+            ui.label(RichText::new(app.tr("SKETCH PALETTE")).strong().size(12.5));
         });
         if FOLDED.with(Cell::get) {
             return;
         }
         let ofold = OPTIONS_FOLDED.with(Cell::get);
-        if ui.add(egui::Button::new(RichText::new(format!("{} Options", if ofold { "+" } else { "−" })).size(12.0)).frame(false)).clicked() {
+        if ui
+            .add(egui::Button::new(RichText::new(format!("{} {}", if ofold { "+" } else { "−" }, app.tr("Options"))).size(12.0)).frame(false))
+            .clicked()
+        {
             OPTIONS_FOLDED.with(|f| f.set(!ofold));
         }
         if !ofold {
             egui::Grid::new("sc_palette_grid").num_columns(2).spacing(vec2(10.0, 6.0)).show(ui, |ui| {
-                ui.label("Linetype");
+                ui.label(app.tr("Linetype"));
                 ui.horizontal(|ui| {
                     // With a selection: convert it; without: the mode new curves are drawn in.
                     let current = mode(app);
                     for (i, (label, tip)) in [("—", "Normal"), ("- -", "Construction"), ("-·-", "Centerline")].iter().enumerate() {
                         let on = !has_curves && current == i as u8;
-                        let tip = if has_curves { format!("Make the selection {tip}") } else { format!("Draw {tip} curves") };
-                        if ui.add(egui::Button::new(*label).selected(on).min_size(vec2(30.0, 20.0))).on_hover_text(tip).clicked() {
+                        let tr_tip = app.tr(tip);
+                        let tip_str = if has_curves {
+                            format!("{} ({})", app.tr("Make the selection"), tr_tip)
+                        } else {
+                            format!("{} ({})", app.tr("Draw curves"), tr_tip)
+                        };
+                        if ui.add(egui::Button::new(*label).selected(on).min_size(vec2(30.0, 20.0))).on_hover_text(tip_str).clicked() {
                             linetype = Some(i as u8);
                         }
                     }
                 });
                 ui.end_row();
-                ui.label("Look At");
-                if ui.button("Look At").clicked() {
+                ui.label(app.tr("Look At"));
+                if ui.button(app.tr("Look At")).clicked() {
                     look = true;
                 }
                 ui.end_row();
                 for (k, label) in TOGGLES {
                     // The label is part of the checkbox: clicking it toggles too.
                     let mut on = shown(k);
-                    if ui.checkbox(&mut on, label).changed() {
+                    if ui.checkbox(&mut on, app.tr(label)).changed() {
                         set = Some((k.to_string(), on));
                     }
                     ui.end_row();
@@ -255,11 +263,12 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
             });
         }
         ui.add_space(4.0);
-        ui.label(RichText::new(dof_line.as_str()).color(if ok { t.sketch_accent } else { t.text_dim }));
+        let tr_dof = app.tr(&dof_line);
+        ui.label(RichText::new(tr_dof).color(if ok { t.sketch_accent } else { t.text_dim }));
         ui.add_space(4.0);
         ui.horizontal(|ui| {
             ui.add_space(WIDTH - 100.0);
-            if ui.add(egui::Button::new(RichText::new("Finish Sketch").color(Color32::WHITE)).fill(t.accent)).clicked() {
+            if ui.add(egui::Button::new(RichText::new(app.tr("Finish Sketch")).color(Color32::WHITE)).fill(t.accent)).clicked() {
                 finish = true;
             }
         });
diff --git a/crates/ui-egui/src/toolbar.rs b/crates/ui-egui/src/toolbar.rs
index 8e3571c6..bc4c7ed1 100644
--- a/crates/ui-egui/src/toolbar.rs
+++ b/crates/ui-egui/src/toolbar.rs
@@ -68,26 +68,26 @@ pub fn app_bar(app: &mut SolveApp, ui: &mut egui::Ui) {
             );
             resp.on_hover_text(tip).clicked()
         };
-        let file = click(ui, "folder", "File");
-        if click(ui, "save", "Save (Ctrl+S)") {
+        let file = click(ui, "folder", app.tr("File"));
+        if click(ui, "save", &format!("{} (Ctrl+S)", app.tr("Save"))) {
             save(app);
         }
-        if click(ui, "undo", "Undo (Ctrl+Z)") {
+        if click(ui, "undo", &format!("{} (Ctrl+Z)", app.tr("Undo"))) {
             let _ = app.run("edit.undo", json!({}));
         }
-        if click(ui, "redo", "Redo (Ctrl+Y)") {
+        if click(ui, "redo", &format!("{} (Ctrl+Y)", app.tr("Redo"))) {
             let _ = app.run("edit.redo", json!({}));
         }
-        if click(ui, "home", "Start page") {
+        if click(ui, "home", app.tr("Home")) {
             let rev = app.session.revision;
             app.home.show(rev);
         }
-        let theme_tip = if app.ui.dark { "Light theme" } else { "Dark theme" };
+        let theme_tip = if app.ui.dark { app.tr("Light") } else { app.tr("Dark") };
         if click(ui, if app.ui.dark { "sun" } else { "moon" }, theme_tip) {
             app.ui.dark = !app.ui.dark;
             app.preferences.theme = if app.ui.dark { "dark" } else { "light" }.into();
         }
-        if click(ui, "help", "Help") {
+        if click(ui, "help", app.tr("Help")) {
             app.help.menu = !app.help.menu;
             let at = ui.ctx().input(|i| i.pointer.latest_pos()).map_or(300.0, |p| p.x);
             ui.ctx().data_mut(|d| {
@@ -118,7 +118,9 @@ pub fn app_bar(app: &mut SolveApp, ui: &mut egui::Ui) {
         }
         icons::paint(ui.painter(), gear.shrink(4.0), "settings", t.app_bar_text, t.app_bar_text, t.app_bar);
         crate::scenario::publish_handle("titlebar:preferences", gear.center());
-        if gresp.on_hover_text(if cfg!(target_os = "macos") { "Preferences (Cmd+,)" } else { "Preferences (Ctrl+,)" }).clicked() {
+        let prefs_tip =
+            if cfg!(target_os = "macos") { format!("{} (Cmd+,)", app.tr("Preferences")) } else { format!("{} (Ctrl+,)", app.tr("Preferences")) };
+        if gresp.on_hover_text(prefs_tip).clicked() {
             crate::prefs::open_at(app, 0);
         }
         ui.painter().text(
@@ -155,17 +157,17 @@ fn file_menu(app: &mut SolveApp, ctx: &egui::Context) {
                 let item = |ui: &mut egui::Ui, label: &str, key: &str| {
                     ui.add(egui::Button::new(label).shortcut_text(key).min_size(vec2(180.0, 22.0))).clicked()
                 };
-                if item(ui, "New Design", "Ctrl+N") {
+                if item(ui, app.tr("New Design"), "Ctrl+N") {
                     crate::documents::new_design(app);
                     close = true;
                 }
-                if item(ui, "Open…", "Ctrl+O") {
+                if item(ui, &format!("{}…", app.tr("Open")), "Ctrl+O") {
                     if let Some(p) = app.services.pick_open.as_ref().and_then(|f| f()) {
                         app.open_path_async(&p);
                     }
                     close = true;
                 }
-                ui.menu_button("Open Recent", |ui| {
+                ui.menu_button(app.tr("Open Recent"), |ui| {
                     for path in app.home.recent.clone() {
                         let missing = !solvecraft_engine::io::vfs::exists(&path);
                         let label = format!("{path}{}", if missing { " (missing)" } else { "" });
@@ -176,7 +178,7 @@ fn file_menu(app: &mut SolveApp, ctx: &egui::Context) {
                         }
                     }
                     ui.separator();
-                    if ui.button("Clear Recent").clicked() {
+                    if ui.button(app.tr("Clear Recent")).clicked() {
                         app.home.recent.clear();
                         app.home.opened_at.clear();
                         close = true;
@@ -191,11 +193,11 @@ fn file_menu(app: &mut SolveApp, ctx: &egui::Context) {
                     app.start("file.insert_mesh");
                     close = true;
                 }
-                if item(ui, "Save", "Ctrl+S") {
+                if item(ui, app.tr("Save"), "Ctrl+S") {
                     save(app);
                     close = true;
                 }
-                if item(ui, "Save As…", "") {
+                if item(ui, &format!("{}…", app.tr("Save As")), "") {
                     save_as(app);
                     close = true;
                 }
@@ -217,16 +219,16 @@ fn file_menu(app: &mut SolveApp, ctx: &egui::Context) {
                     close = true;
                 }
                 ui.separator();
-                if item(ui, "Preferences…", "") {
+                if item(ui, &format!("{}…", app.tr("Preferences")), "") {
                     app.prefs_window.open = true;
                     close = true;
                 }
-                if item(ui, "Keyboard Shortcuts…", "") {
+                if item(ui, &format!("{}…", app.tr("Keyboard Shortcuts")), "") {
                     app.keymap.open = true;
                     app.keymap.read_only = false;
                     close = true;
                 }
-                if item(ui, "Quit", "") {
+                if item(ui, app.tr("Quit"), "") {
                     crate::documents::request_quit(app);
                     close = true;
                 }
@@ -282,13 +284,13 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {
         painter.text(
             pos2(ws.center().x - 5.0, ws.top() + 52.0),
             Align2::CENTER_CENTER,
-            crate::toolbar_custom::WORKSPACE,
+            app.tr(crate::toolbar_custom::WORKSPACE),
             FontId::proportional(12.0),
             t.text,
         );
         caret(&painter, pos2(ws.center().x + 27.0, ws.top() + 52.0), t.text);
-        painter.text(pos2(ws.center().x, ws.top() + 69.0), Align2::CENTER_CENTER, "workspace", FontId::proportional(10.0), t.text_dim);
-        if wresp.on_hover_text("Change workspace").clicked() {
+        painter.text(pos2(ws.center().x, ws.top() + 69.0), Align2::CENTER_CENTER, app.tr("workspace"), FontId::proportional(10.0), t.text_dim);
+        if wresp.on_hover_text(app.tr("Change workspace")).clicked() {
             crate::context_menu::open_for(app, ws.left_bottom(), crate::context_menu::Target::Workspace);
         }
         crate::scenario::publish_rect("toolbar", r);
@@ -300,7 +302,8 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {
         }
         tabs.extend(TABS.iter());
         for tab in tabs {
-            let w = 12.0 + tab.len() as f32 * 7.4;
+            let display_tab = app.tr(tab);
+            let w = 12.0 + (display_tab.len() as f32 * 7.4).max(28.0);
             let tr = Rect::from_min_size(pos2(x, tabs_y), vec2(w, 22.0));
             let active = app.ui.tab == tab;
             let resp = ui.interact(tr, ui.id().with(("tab", tab)), Sense::click());
@@ -317,7 +320,7 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {
             } else {
                 t.text_dim
             };
-            painter.text(tr.center(), Align2::CENTER_CENTER, tab, FontId::proportional(12.0), col);
+            painter.text(tr.center(), Align2::CENTER_CENTER, display_tab, FontId::proportional(12.0), col);
             if resp.clicked() {
                 app.ui.tab = tab.to_string();
             }
@@ -384,9 +387,10 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {
                 };
                 let icon = if c.id == "sketch.finish" { "finish" } else { c.icon };
                 icons::paint(&painter, br.shrink(6.0), icon, ink, fill, acc);
+                let tr_label = app.tr(c.label);
                 let tip = match &info.disabled_reason {
-                    Some(why) => format!("{}\n{why}", c.label),
-                    None => format!("{}{}", c.label, c.shortcut.map(|k| format!("  ({k})")).unwrap_or_default()),
+                    Some(why) => format!("{}\n{why}", tr_label),
+                    None => format!("{}{}", tr_label, c.shortcut.map(|k| format!("  ({k})")).unwrap_or_default()),
                 };
                 if resp.on_hover_text(tip).clicked() && info.enabled {
                     let id = c.id;
@@ -399,7 +403,7 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {
             }
             // Panel label with drop-down.
             let lr = Rect::from_min_size(pos2(px, top + 42.0), vec2(width, 18.0));
-            let label = panel.to_string();
+            let label = app.tr(panel).to_string();
             let lresp = ui.interact(lr, ui.id().with(("panel", panel)), Sense::click());
             crate::scenario::publish_handle(&format!("panel:{tab}:{panel}"), lr.center());
             if lresp.hovered() && enabled_panel {
@@ -437,7 +441,10 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {
                             ui.horizontal(|ui| {
                                 let (ir, _) = ui.allocate_exact_size(vec2(18.0, 18.0), Sense::hover());
                                 icons::paint(ui.painter(), ir, c.icon, t.icon, t.icon_fill, t.accent);
-                                let b = ui.add_enabled(info.enabled, egui::Button::new(c.label).frame(false).shortcut_text(c.shortcut.unwrap_or("")));
+                                let b = ui.add_enabled(
+                                    info.enabled,
+                                    egui::Button::new(app.tr(c.label)).frame(false).shortcut_text(c.shortcut.unwrap_or("")),
+                                );
                                 crate::scenario::publish_handle(&format!("toolbar:{}", c.id), b.rect.center());
                                 if b.secondary_clicked() {
                                     menu = Some((b.interact_pointer_pos().unwrap_or(b.rect.left_bottom()), c.id));

From cc22672041ac6d3f3a41530948120249fdaa6398 Mon Sep 17 00:00:00 2001
From: CypherNaugh_0x <9931495+CypherNaught-0x@users.noreply.github.com>
Date: Sun, 11 Oct 2026 05:25:40 +0200
Subject: [PATCH 5/7] Sketch commands return the ids of the points, curves,
 constraints and dimensions they create as created: {points, curves,
 constraints, dimensions}, worked out in Session::execute from the sketch
 before and after, so a script can dimension and constrain new geometry right
 away; ids stay stable and are not reused after a delete (undo rewinds the
 counters with the design). The MCP execute tool describes the field

---
 crates/engine/src/cmd/mod.rs              |   8 +
 crates/engine/src/cmd/sketch.rs           |  65 +++--
 crates/engine/src/cmd/sketch_3d.rs        |  13 +-
 crates/engine/src/cmd/sketch_create.rs    | 152 ++++++-----
 crates/engine/src/cmd/sketch_ids_tests.rs | 298 ++++++++++++++++++++++
 crates/engine/src/cmd/sketch_import.rs    |   4 +-
 crates/engine/src/cmd/sketch_modify.rs    |  22 +-
 crates/engine/src/cmd/sketch_project.rs   |  24 +-
 crates/engine/src/lib.rs                  |  23 ++
 crates/mcp/src/tools.rs                   |   5 +-
 docs/book/src/guide/sketching.md          |   5 +
 docs/control-protocol.md                  |  12 +
 12 files changed, 510 insertions(+), 121 deletions(-)
 create mode 100644 crates/engine/src/cmd/sketch_ids_tests.rs

diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index 3a8d77ff..71c06ec6 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -2,6 +2,13 @@
 //! `sketch.rectangle.two_point`); the toolbar placement (`tab`, `panel`) follows the familiar
 //! Design workspace layout. Ids used before the rename still resolve (`legacy_ids`).
 
+/// The params-doc note of every command that adds sketch geometry (see `sketch::created`).
+macro_rules! created_doc {
+    () => {
+        ". Returns created: {points, curves, constraints, dimensions}: the ids of what it added (stable and never reused: usable right away in sketch.dimension, sketch.constraint.*, sketch.delete…)"
+    };
+}
+
 mod browser;
 mod clipboard;
 mod component;
@@ -27,6 +34,7 @@ mod parameters;
 mod plastic;
 mod sheet;
 mod sketch;
+pub(crate) use sketch::created as sketch_created;
 mod sketch_3d;
 mod sketch_canvas;
 mod sketch_constraints;
diff --git a/crates/engine/src/cmd/sketch.rs b/crates/engine/src/cmd/sketch.rs
index 3a390268..3ba23f84 100644
--- a/crates/engine/src/cmd/sketch.rs
+++ b/crates/engine/src/cmd/sketch.rs
@@ -28,71 +28,71 @@ pub static COMMANDS: &[CommandSpec] = &[
         .icon("line")
         .key("L")
         .enabled(in_sketch)
-        .params(concat!("points: [[x,y] | \"l1.end\" | {at, ref}…], closed?: bool, construction?: bool, ids?: [..], infer?: bool (add horizontal/vertical)", connect_doc!())),
+        .params(concat!("points: [[x,y] | \"l1.end\" | {at, ref}…], closed?: bool, construction?: bool, ids?: [..], infer?: bool (add horizontal/vertical)", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.rectangle.two_point", "2-Point Rectangle", rect_two_point)
         .at("SKETCH", "CREATE")
         .icon("rect")
         .key("R")
         .enabled(in_sketch)
-        .params(concat!("p0, p1: opposite corners [x,y]; construction?. Returns sides {bottom, right, top, left} (line ids) and corners {bottom_left, bottom_right, top_right, top_left} (point ids)", connect_doc!())),
+        .params(concat!("p0, p1: opposite corners [x,y]; construction?. Returns sides {bottom, right, top, left} (line ids) and corners {bottom_left, bottom_right, top_right, top_left} (point ids)", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.rectangle.three_point", "3-Point Rectangle", rect_three_point)
         .at("SKETCH", "CREATE")
         .icon("rect3")
         .enabled(in_sketch)
-        .params(concat!("p0, p1: first edge; p2: point on the opposite edge", connect_doc!())),
+        .params(concat!("p0, p1: first edge; p2: point on the opposite edge", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.rectangle.center", "Center Rectangle", rect_center)
         .at("SKETCH", "CREATE")
         .icon("rect_center")
         .enabled(in_sketch)
-        .params(concat!("center, corner. Returns sides {bottom, right, top, left} (line ids) and corners {bottom_left, bottom_right, top_right, top_left} (point ids)", connect_doc!())),
+        .params(concat!("center, corner. Returns sides {bottom, right, top, left} (line ids) and corners {bottom_left, bottom_right, top_right, top_left} (point ids)", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.circle.center", "Center Diameter Circle", circle_center)
         .at("SKETCH", "CREATE")
         .icon("circle")
         .key("C")
         .enabled(in_sketch)
-        .params(concat!("center: [x,y] or point ref, radius | diameter: number", connect_doc!())),
+        .params(concat!("center: [x,y] or point ref, radius | diameter: number", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.circle.two_point", "2-Point Circle", circle_two)
         .at("SKETCH", "CREATE")
         .icon("circle2")
         .enabled(in_sketch)
-        .params(concat!("p0, p1: diameter ends", connect_doc!())),
+        .params(concat!("p0, p1: diameter ends", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.circle.three_point", "3-Point Circle", circle_three)
         .at("SKETCH", "CREATE")
         .icon("circle3")
         .enabled(in_sketch)
-        .params(concat!("p0, p1, p2", connect_doc!())),
-    CommandSpec::new("sketch.arc.three_point", "3-Point Arc", arc_three).at("SKETCH", "CREATE").icon("arc3").enabled(in_sketch).params(concat!("start, end, through", connect_doc!())),
+        .params(concat!("p0, p1, p2", connect_doc!(), created_doc!())),
+    CommandSpec::new("sketch.arc.three_point", "3-Point Arc", arc_three).at("SKETCH", "CREATE").icon("arc3").enabled(in_sketch).params(concat!("start, end, through", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.arc.center_point", "Center Point Arc", arc_center)
         .at("SKETCH", "CREATE")
         .icon("arc_center")
         .enabled(in_sketch)
-        .params(concat!("center, start, end (counter-clockwise from start) | center, start, sweep: signed degrees", connect_doc!())),
+        .params(concat!("center, start, end (counter-clockwise from start) | center, start, sweep: signed degrees", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.polygon.inscribed", "Inscribed Polygon", polygon_inscribed)
         .at("SKETCH", "CREATE")
         .icon("polygon")
         .enabled(in_sketch)
-        .params(concat!("center, radius (to vertices), sides, angle?: deg", connect_doc!())),
+        .params(concat!("center, radius (to vertices), sides, angle?: deg", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.polygon.circumscribed", "Circumscribed Polygon", polygon_circumscribed)
         .at("SKETCH", "CREATE")
         .icon("polygon")
         .enabled(in_sketch)
-        .params(concat!("center, radius (to edge midpoints), sides, angle?: deg", connect_doc!())),
+        .params(concat!("center, radius (to edge midpoints), sides, angle?: deg", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.polygon.edge", "Edge Polygon", polygon_edge)
         .at("SKETCH", "CREATE")
         .icon("polygon")
         .enabled(in_sketch)
-        .params(concat!("p0, p1: one edge, sides", connect_doc!())),
+        .params(concat!("p0, p1: one edge, sides", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.slot.center_to_center", "Center to Center Slot", slot_c2c)
         .at("SKETCH", "CREATE")
         .icon("slot")
         .enabled(in_sketch)
-        .params(concat!("p0, p1: arc centres, width", connect_doc!())),
+        .params(concat!("p0, p1: arc centres, width", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.slot.overall", "Overall Slot", slot_overall)
         .at("SKETCH", "CREATE")
         .icon("slot")
         .enabled(in_sketch)
-        .params(concat!("p0, p1: overall ends, width", connect_doc!())),
-    CommandSpec::new("sketch.point", "Point", draw_point).at("SKETCH", "CREATE").icon("point").enabled(in_sketch).params(concat!("point: [x,y], id?", connect_doc!())),
+        .params(concat!("p0, p1: overall ends, width", connect_doc!(), created_doc!())),
+    CommandSpec::new("sketch.point", "Point", draw_point).at("SKETCH", "CREATE").icon("point").enabled(in_sketch).params(concat!("point: [x,y], id?", connect_doc!(), created_doc!())),
     CommandSpec::new("sketch.dimension", "Sketch Dimension", dimension).at("SKETCH", "CREATE").icon("dimension").key("D").enabled(in_sketch).params(
         "entities: [refs], type?: auto|distance|horizontal|vertical|length|radius|diameter|angle, value?: number or expression (default: current); text_at?: [x, y]. Two lines: the angle between them (acute, or 180° − it when the value is nearer that) unless text_at picks a sector. Returns measured in unit (mm or deg)",
     ),
@@ -338,6 +338,37 @@ pub(super) fn mark_construction(sk: &mut Sketch, curves: &[usize], p: &Value) {
     }
 }
 
+/// What a command added to a sketch: the ids of the points, curves, constraints and dimensions
+/// in `after` that `before` does not have (`None`: a new sketch), in creation order, plus the
+/// 3D curves (`wires`) when there are any. Ids are stable and never reused in a sketch, so they
+/// can be used in later commands (`sketch.dimension`, `sketch.constraint.*`, `sketch.delete`…).
+pub(crate) fn created(before: Option<&Sketch>, after: &Sketch) -> Value {
+    use std::collections::HashSet;
+    let empty = Sketch::new();
+    let before = before.unwrap_or(&empty);
+    let old: HashSet<&str> = before
+        .points
+        .iter()
+        .map(|x| x.id.as_str())
+        .chain(before.curves.iter().map(|x| x.id.as_str()))
+        .chain(before.constraints.iter().map(|x| x.id.as_str()))
+        .chain(before.wires.iter().map(|x| x.id.as_str()))
+        .collect();
+    let new = |id: &&str| !old.contains(*id);
+    let points: Vec<&str> = after.points.iter().map(|x| x.id.as_str()).filter(new).collect();
+    let curves: Vec<&str> = after.curves.iter().map(|x| x.id.as_str()).filter(new).collect();
+    let (dims, cons): (Vec<_>, Vec<_>) = after.constraints.iter().filter(|c| new(&c.id.as_str())).partition(|c| c.kind.is_dimension());
+    let ids = |v: Vec<&solvecraft_sketch::Constraint>| v.into_iter().map(|c| c.id.clone()).collect::<Vec<_>>();
+    let mut out = json!({"points": points, "curves": curves, "constraints": ids(cons), "dimensions": ids(dims)});
+    let wires: Vec<&str> = after.wires.iter().map(|x| x.id.as_str()).filter(new).collect();
+    if !wires.is_empty()
+        && let Some(o) = out.as_object_mut()
+    {
+        o.insert("wires".into(), json!(wires));
+    }
+    out
+}
+
 pub(super) fn result(sk_out: (Vec<String>, Vec<String>), info: Value) -> Value {
     json!({"curves": sk_out.0, "constraints": sk_out.1, "sketch": info})
 }
@@ -1811,3 +1842,7 @@ mod rect_tests;
 #[cfg(test)]
 #[path = "sketch_ux_tests.rs"]
 mod ux_tests;
+
+#[cfg(test)]
+#[path = "sketch_ids_tests.rs"]
+mod ids_tests;
diff --git a/crates/engine/src/cmd/sketch_3d.rs b/crates/engine/src/cmd/sketch_3d.rs
index 061ff353..e6e27ebe 100644
--- a/crates/engine/src/cmd/sketch_3d.rs
+++ b/crates/engine/src/cmd/sketch_3d.rs
@@ -11,13 +11,16 @@ use crate::params::{bad, req_vec3, vec3};
 use crate::{Result, Session};
 
 pub static COMMANDS: &[CommandSpec] = &[
-    CommandSpec::new("sketch.line3d", "3D Line", line3d)
-        .enabled(in_sketch)
-        .params("points: [[x,y,z]…] world points (2 or more): one 3D line per segment, joined end to end (needs 3D Sketch on)"),
+    CommandSpec::new("sketch.line3d", "3D Line", line3d).enabled(in_sketch).params(concat!(
+        "points: [[x,y,z]…] world points (2 or more): one 3D line per segment, joined end to end (needs 3D Sketch on)",
+        created_doc!()
+    )),
     CommandSpec::new("sketch.spline3d", "3D Spline", spline3d)
         .enabled(in_sketch)
-        .params("points: [[x,y,z]…] world fit points (2 or more): a smooth 3D curve through them (needs 3D Sketch on)"),
-    CommandSpec::new("sketch.point3d", "3D Point", point3d).enabled(in_sketch).params("point: [x,y,z] world point (needs 3D Sketch on)"),
+        .params(concat!("points: [[x,y,z]…] world fit points (2 or more): a smooth 3D curve through them (needs 3D Sketch on)", created_doc!())),
+    CommandSpec::new("sketch.point3d", "3D Point", point3d)
+        .enabled(in_sketch)
+        .params(concat!("point: [x,y,z] world point (needs 3D Sketch on)", created_doc!())),
     CommandSpec::new("sketch.move3d", "Move 3D Point", move3d)
         .enabled(in_sketch)
         .params("wire: drawn 3D curve or point id, index?: fit point (default 0), to: [x,y,z] | by: [dx,dy,dz]; points joined to it move too"),
diff --git a/crates/engine/src/cmd/sketch_create.rs b/crates/engine/src/cmd/sketch_create.rs
index b5247c45..a8cd4272 100644
--- a/crates/engine/src/cmd/sketch_create.rs
+++ b/crates/engine/src/cmd/sketch_create.rs
@@ -10,83 +10,81 @@ use super::{CommandSpec, in_sketch};
 use crate::params::{bad, num, req_vec2, str_, string_list};
 use crate::{Result, Session};
 
-pub static COMMANDS: &[CommandSpec] =
-    &[
-        CommandSpec::new("sketch.line.midpoint", "Midpoint Line", midpoint_line)
-            .at("SKETCH", "CREATE")
-            .icon("line_mid")
-            .enabled(in_sketch)
-            .params("mid: [x,y] or point ref, end: [x,y]; construction?"),
-        CommandSpec::new("sketch.arc.tangent", "Tangent Arc", arc_tangent).at("SKETCH", "CREATE").icon("arc_tangent").enabled(in_sketch).params(
-            "start: end point of a line or arc (\"l1.end\"), end: [x,y]; curve?: the curve to be tangent to (default: the one ending at start)",
-        ),
-        CommandSpec::new("sketch.circle.two_tangent", "2-Tangent Circle", circle_tan_tan)
-            .at("SKETCH", "CREATE")
-            .icon("circle_tt")
-            .enabled(in_sketch)
-            .params("curves: [two lines/circles/arcs], radius | diameter: expr, near: [x,y] (which of the solutions)"),
-        CommandSpec::new("sketch.circle.three_tangent", "3-Tangent Circle", circle_three_tan)
-            .at("SKETCH", "CREATE")
-            .icon("circle_ttt")
-            .enabled(in_sketch)
-            .params("curves: [three lines/circles/arcs], near: [x,y] (which of the solutions)"),
-        CommandSpec::new("sketch.slot.center_point", "Center Point Slot", slot_center_point)
-            .at("SKETCH", "CREATE")
-            .icon("slot")
-            .enabled(in_sketch)
-            .params("center: slot centre, end: one arc centre, width"),
-        CommandSpec::new("sketch.slot.arc_three_point", "Three Point Arc Slot", arc_slot_three)
-            .at("SKETCH", "CREATE")
-            .icon("arc_slot")
-            .enabled(in_sketch)
-            .params("start, through, end: points on the centre arc, width"),
-        CommandSpec::new("sketch.slot.arc_center", "Center Point Arc Slot", arc_slot_center)
-            .at("SKETCH", "CREATE")
-            .icon("arc_slot")
-            .enabled(in_sketch)
-            .params("center, start: centre arc start, end: direction of the centre arc end (counter-clockwise), width"),
-        CommandSpec::new("sketch.ellipse", "Ellipse", ellipse)
-            .at("SKETCH", "CREATE")
-            .icon("ellipse")
-            .enabled(in_sketch)
-            .params("center, major: end of the major axis [x,y], minor: a point the ellipse passes through on the minor side [x,y] | minor_radius"),
-        CommandSpec::new("sketch.spline.fit_point", "Fit Point Spline", spline_fit)
-            .at("SKETCH", "CREATE")
-            .icon("spline")
-            .enabled(in_sketch)
-            .params("points: [[x,y] or point refs…] (2…500): the spline passes through them"),
-        CommandSpec::new("sketch.spline.control_point", "Control Point Spline", spline_cv3)
-            .at("SKETCH", "CREATE")
-            .icon("spline_cv")
-            .enabled(in_sketch)
-            .params("points: control points (2…500), cubic"),
-        CommandSpec::new("sketch.spline.control_point_5", "Control Point Spline (Degree 5)", spline_cv5)
-            .at("SKETCH", "CREATE")
-            .icon("spline_cv")
-            .enabled(in_sketch)
-            .params("points: control points (2…500), degree 5"),
-        CommandSpec::new("sketch.conic", "Conic Curve", conic)
-            .at("SKETCH", "CREATE")
-            .icon("conic")
-            .enabled(in_sketch)
-            .params("start, end, apex: [x,y] or point refs; rho?: 0…1 (default 0.5: parabola)"),
-        CommandSpec::new("sketch.blend_curve", "Blend Curve", blend)
-            .at("SKETCH", "MODIFY")
-            .icon("blend")
-            .enabled(in_sketch)
-            .params("a, b: end points of two curves (\"l1.end\", \"a2.start\"): a smooth (tangent) spline joining them"),
-        CommandSpec::new("sketch.centerline", "Centerline", centerline)
-            .enabled(in_sketch)
-            .params("curves: [line ids], value?: bool (default toggles): centerline line type (not in profiles; an axis)"),
-        CommandSpec::new("sketch.text", "Text", text)
-            .at("SKETCH", "CREATE")
-            .icon("text")
-            .enabled(in_sketch)
-            .params("text: string (\\n breaks lines), at: baseline start [x,y], height?: capital height mm (default 5), angle?: deg"),
-        CommandSpec::new("sketch.edit_text", "Edit Text", edit_text)
-            .enabled(in_sketch)
-            .params("link: the text's link id (or entity: one of its curves), text?, at?, height?, angle?: deg"),
-    ];
+pub static COMMANDS: &[CommandSpec] = &[
+    CommandSpec::new("sketch.line.midpoint", "Midpoint Line", midpoint_line)
+        .at("SKETCH", "CREATE")
+        .icon("line_mid")
+        .enabled(in_sketch)
+        .params(concat!("mid: [x,y] or point ref, end: [x,y]; construction?", created_doc!())),
+    CommandSpec::new("sketch.arc.tangent", "Tangent Arc", arc_tangent).at("SKETCH", "CREATE").icon("arc_tangent").enabled(in_sketch).params(concat!(
+        "start: end point of a line or arc (\"l1.end\"), end: [x,y]; curve?: the curve to be tangent to (default: the one ending at start)",
+        created_doc!()
+    )),
+    CommandSpec::new("sketch.circle.two_tangent", "2-Tangent Circle", circle_tan_tan)
+        .at("SKETCH", "CREATE")
+        .icon("circle_tt")
+        .enabled(in_sketch)
+        .params(concat!("curves: [two lines/circles/arcs], radius | diameter: expr, near: [x,y] (which of the solutions)", created_doc!())),
+    CommandSpec::new("sketch.circle.three_tangent", "3-Tangent Circle", circle_three_tan)
+        .at("SKETCH", "CREATE")
+        .icon("circle_ttt")
+        .enabled(in_sketch)
+        .params(concat!("curves: [three lines/circles/arcs], near: [x,y] (which of the solutions)", created_doc!())),
+    CommandSpec::new("sketch.slot.center_point", "Center Point Slot", slot_center_point)
+        .at("SKETCH", "CREATE")
+        .icon("slot")
+        .enabled(in_sketch)
+        .params(concat!("center: slot centre, end: one arc centre, width", created_doc!())),
+    CommandSpec::new("sketch.slot.arc_three_point", "Three Point Arc Slot", arc_slot_three)
+        .at("SKETCH", "CREATE")
+        .icon("arc_slot")
+        .enabled(in_sketch)
+        .params(concat!("start, through, end: points on the centre arc, width", created_doc!())),
+    CommandSpec::new("sketch.slot.arc_center", "Center Point Arc Slot", arc_slot_center)
+        .at("SKETCH", "CREATE")
+        .icon("arc_slot")
+        .enabled(in_sketch)
+        .params(concat!("center, start: centre arc start, end: direction of the centre arc end (counter-clockwise), width", created_doc!())),
+    CommandSpec::new("sketch.ellipse", "Ellipse", ellipse).at("SKETCH", "CREATE").icon("ellipse").enabled(in_sketch).params(concat!(
+        "center, major: end of the major axis [x,y], minor: a point the ellipse passes through on the minor side [x,y] | minor_radius",
+        created_doc!()
+    )),
+    CommandSpec::new("sketch.spline.fit_point", "Fit Point Spline", spline_fit)
+        .at("SKETCH", "CREATE")
+        .icon("spline")
+        .enabled(in_sketch)
+        .params(concat!("points: [[x,y] or point refs…] (2…500): the spline passes through them", created_doc!())),
+    CommandSpec::new("sketch.spline.control_point", "Control Point Spline", spline_cv3)
+        .at("SKETCH", "CREATE")
+        .icon("spline_cv")
+        .enabled(in_sketch)
+        .params(concat!("points: control points (2…500), cubic", created_doc!())),
+    CommandSpec::new("sketch.spline.control_point_5", "Control Point Spline (Degree 5)", spline_cv5)
+        .at("SKETCH", "CREATE")
+        .icon("spline_cv")
+        .enabled(in_sketch)
+        .params(concat!("points: control points (2…500), degree 5", created_doc!())),
+    CommandSpec::new("sketch.conic", "Conic Curve", conic)
+        .at("SKETCH", "CREATE")
+        .icon("conic")
+        .enabled(in_sketch)
+        .params(concat!("start, end, apex: [x,y] or point refs; rho?: 0…1 (default 0.5: parabola)", created_doc!())),
+    CommandSpec::new("sketch.blend_curve", "Blend Curve", blend)
+        .at("SKETCH", "MODIFY")
+        .icon("blend")
+        .enabled(in_sketch)
+        .params(concat!("a, b: end points of two curves (\"l1.end\", \"a2.start\"): a smooth (tangent) spline joining them", created_doc!())),
+    CommandSpec::new("sketch.centerline", "Centerline", centerline)
+        .enabled(in_sketch)
+        .params("curves: [line ids], value?: bool (default toggles): centerline line type (not in profiles; an axis)"),
+    CommandSpec::new("sketch.text", "Text", text).at("SKETCH", "CREATE").icon("text").enabled(in_sketch).params(concat!(
+        "text: string (\\n breaks lines), at: baseline start [x,y], height?: capital height mm (default 5), angle?: deg",
+        created_doc!()
+    )),
+    CommandSpec::new("sketch.edit_text", "Edit Text", edit_text)
+        .enabled(in_sketch)
+        .params(concat!("link: the text's link id (or entity: one of its curves), text?, at?, height?, angle?: deg", created_doc!())),
+];
 
 fn text_source(p: &Value, cmd: &str, old: Option<(String, Vec2, f64, f64)>) -> Result<LinkSource> {
     let (t0, at0, h0, a0) = old.unwrap_or((String::new(), Vec2::ZERO, 5.0, 0.0));
diff --git a/crates/engine/src/cmd/sketch_ids_tests.rs b/crates/engine/src/cmd/sketch_ids_tests.rs
new file mode 100644
index 00000000..1d288385
--- /dev/null
+++ b/crates/engine/src/cmd/sketch_ids_tests.rs
@@ -0,0 +1,298 @@
+//! Every command that adds sketch geometry returns `created: {points, curves, constraints,
+//! dimensions}` with the real ids of what it added, so a script can dimension and constrain the
+//! new geometry right away; ids are never reused after a delete.
+
+use serde_json::{Value, json};
+use solvecraft_sketch::{CurveKind, Sketch};
+
+use crate::Session;
+
+fn run(s: &mut Session, id: &str, p: Value) -> Value {
+    match s.execute(id, &p) {
+        Ok(v) => v,
+        Err(e) => panic!("{id} {p}: {e}"),
+    }
+}
+
+fn strs(v: &Value) -> Vec<String> {
+    v.as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default()
+}
+
+fn sketch(s: &Session) -> Sketch {
+    s.doc.sketch(s.active_sketch.unwrap()).unwrap().clone()
+}
+
+fn new_sketch() -> Session {
+    let mut s = Session::default();
+    run(&mut s, "sketch.create", json!({"plane": "XY"}));
+    s
+}
+
+/// The ids in `r.created` exist in the active sketch, and each curve and point takes a
+/// dimension (driven, so it never conflicts) and a fix right away. `before`: the sketch before
+/// the command. Returns `created`.
+fn check(s: &mut Session, cmd: &str, r: &Value, before: &Sketch) -> Value {
+    let c = r.get("created").cloned().unwrap_or_else(|| panic!("{cmd}: no `created` in {r}"));
+    for k in ["points", "curves", "constraints", "dimensions"] {
+        assert!(c[k].is_array(), "{cmd}: created.{k} in {c}");
+    }
+    let sk = sketch(s);
+    let curves = strs(&c["curves"]);
+    let points = strs(&c["points"]);
+    assert!(!curves.is_empty() || !points.is_empty() || c.get("wires").is_some(), "{cmd}: nothing created: {c}");
+    for id in &points {
+        assert!(sk.point_index(id).is_some(), "{cmd}: point {id} not in the sketch");
+        assert_ne!(id, "origin", "{cmd}");
+    }
+    for id in strs(&c["constraints"]).iter().chain(&strs(&c["dimensions"])) {
+        assert!(sk.constraints.iter().any(|k| &k.id == id), "{cmd}: constraint {id} not in the sketch");
+    }
+    for id in strs(&c["dimensions"]) {
+        assert!(sk.constraints.iter().any(|k| k.id == id && k.kind.is_dimension()), "{cmd}: {id} is not a dimension");
+    }
+    for id in strs(&c.get("wires").cloned().unwrap_or_default()) {
+        assert!(sk.wire_index(&id).is_some(), "{cmd}: wire {id} not in the sketch");
+    }
+    // The new curves in the command's own list (where it has one) are in `created`.
+    let wires = strs(&c.get("wires").cloned().unwrap_or_default());
+    for id in strs(&r["curves"]) {
+        let old = before.curve_index(&id).is_some() || before.wire_index(&id).is_some();
+        assert!(old || curves.contains(&id) || wires.contains(&id), "{cmd}: returned curve {id} missing from created {c}");
+    }
+    for id in curves.iter().chain(&points) {
+        assert!(before.curve_index(id).is_none() && before.point_index(id).is_none(), "{cmd}: {id} is not new");
+    }
+    for id in &curves {
+        let i = sk.curve_index(id).unwrap_or_else(|| panic!("{cmd}: curve {id} not in the sketch"));
+        let measurable = matches!(sk.curves[i].kind, CurveKind::Line { .. } | CurveKind::Circle { .. } | CurveKind::Arc { .. });
+        if measurable {
+            run(s, "sketch.dimension", json!({"entities": [id], "driven": true}));
+        }
+        run(s, "sketch.constraint.fix", json!({"entity": id, "fixed": true}));
+        run(s, "edit.undo", json!({}));
+        if measurable {
+            run(s, "edit.undo", json!({}));
+        }
+    }
+    for id in &points {
+        run(s, "sketch.dimension", json!({"entities": [id, "origin"], "driven": true}));
+        run(s, "edit.undo", json!({}));
+    }
+    c
+}
+
+/// Run `cmd` in `s` and check what it reports.
+fn made(s: &mut Session, cmd: &str, p: Value) -> Value {
+    let before = sketch(s);
+    let r = run(s, cmd, p);
+    check(s, cmd, &r, &before)
+}
+
+#[test]
+fn drawing_commands_return_the_ids_they_create() {
+    let cases: Vec<(&str, Value)> = vec![
+        ("sketch.line", json!({"points": [[0, 0], [10, 0], [10, 5]]})),
+        ("sketch.rectangle.two_point", json!({"p0": [1, 1], "p1": [21, 15]})),
+        ("sketch.rectangle.three_point", json!({"p0": [0, 0], "p1": [20, 5], "p2": [18, 15]})),
+        ("sketch.rectangle.center", json!({"center": [3, 2], "corner": [13, 9]})),
+        ("sketch.circle.center", json!({"center": [5, 5], "diameter": 8})),
+        ("sketch.circle.two_point", json!({"p0": [0, 0], "p1": [10, 0]})),
+        ("sketch.circle.three_point", json!({"p0": [0, 0], "p1": [10, 0], "p2": [5, 6]})),
+        ("sketch.arc.three_point", json!({"start": [0, 0], "end": [10, 0], "through": [5, 4]})),
+        ("sketch.arc.center_point", json!({"center": [0, 0], "start": [10, 0], "end": [0, 10]})),
+        ("sketch.polygon.inscribed", json!({"center": [0, 0], "radius": 10, "sides": 6})),
+        ("sketch.polygon.circumscribed", json!({"center": [0, 0], "radius": 10, "sides": 5})),
+        ("sketch.polygon.edge", json!({"p0": [0, 0], "p1": [10, 0], "sides": 4})),
+        ("sketch.slot.center_to_center", json!({"p0": [0, 0], "p1": [20, 0], "width": 6})),
+        ("sketch.slot.overall", json!({"p0": [0, 0], "p1": [20, 0], "width": 6})),
+        ("sketch.slot.center_point", json!({"center": [0, 0], "end": [10, 0], "width": 4})),
+        ("sketch.slot.arc_three_point", json!({"start": [0, 0], "through": [10, 5], "end": [20, 0], "width": 3})),
+        ("sketch.slot.arc_center", json!({"center": [0, 0], "start": [10, 0], "end": [0, 10], "width": 3})),
+        ("sketch.point", json!({"point": [3, 4]})),
+        ("sketch.line.midpoint", json!({"mid": [0, 0], "end": [10, 5]})),
+        ("sketch.ellipse", json!({"center": [0, 0], "major": [10, 0], "minor_radius": 4})),
+        ("sketch.spline.fit_point", json!({"points": [[0, 0], [5, 5], [10, 0]]})),
+        ("sketch.spline.control_point", json!({"points": [[0, 0], [5, 5], [10, 0], [15, 5]]})),
+        ("sketch.spline.control_point_5", json!({"points": [[0, 0], [3, 5], [6, 0], [9, 5], [12, 0], [15, 5]]})),
+        ("sketch.conic", json!({"start": [0, 0], "end": [10, 0], "apex": [5, 6]})),
+        ("sketch.text", json!({"text": "IT", "at": [0, 0], "height": 10})),
+    ];
+    for (cmd, p) in cases {
+        let mut s = new_sketch();
+        made(&mut s, cmd, p);
+    }
+}
+
+#[test]
+fn drawn_ids_take_driving_dimensions_and_constraints() {
+    let mut s = new_sketch();
+    let c = made(&mut s, "sketch.line", json!({"points": [[0, 0], [10, 0]], "connect": false}));
+    let l = strs(&c["curves"]);
+    let pts = strs(&c["points"]);
+    assert_eq!((l.len(), pts.len()), (1, 2), "{c}");
+    run(&mut s, "sketch.constraint.coincident", json!({"a": pts[0], "b": "origin"}));
+    run(&mut s, "sketch.constraint.horizontal_vertical", json!({"line": l[0]}));
+    let d = run(&mut s, "sketch.dimension", json!({"entities": [l[0]], "value": 30}));
+    assert_eq!(strs(&d["created"]["dimensions"]).len(), 1, "{d}");
+    let sk = sketch(&s);
+    let end = sk.point(sk.point_index(&pts[1]).unwrap()).unwrap();
+    assert!((end.x - 30.0).abs() < 1e-6 && end.y.abs() < 1e-6, "{end:?}");
+
+    let c = made(&mut s, "sketch.circle.center", json!({"center": [50, 0], "radius": 4}));
+    let circle = strs(&c["curves"]);
+    run(&mut s, "sketch.dimension", json!({"entities": [circle[0]], "type": "diameter", "value": 12}));
+    let sk = sketch(&s);
+    let i = sk.curve_index(&circle[0]).unwrap();
+    assert!(matches!(sk.curves[i].kind, CurveKind::Circle { r, .. } if (r - 6.0).abs() < 1e-6));
+}
+
+#[test]
+fn modify_commands_return_the_ids_they_create() {
+    // Corner tools: an open L of two lines.
+    for (cmd, extra) in [
+        ("sketch.fillet", json!({"radius": 2})),
+        ("sketch.chamfer.equal_distance", json!({"distance": 2})),
+        ("sketch.chamfer.distance_angle", json!({"distance": 2, "angle": 40})),
+        ("sketch.chamfer.two_distance", json!({"distance": 2, "distance2": 3})),
+    ] {
+        let mut s = new_sketch();
+        let c = made(&mut s, "sketch.line", json!({"points": [[0, 10], [0, 0], [10, 0]]}));
+        let l = strs(&c["curves"]);
+        let mut p = extra;
+        p["point"] = json!(format!("{}.end", l[0]));
+        let c = made(&mut s, cmd, p);
+        assert!(!strs(&c["curves"]).is_empty(), "{cmd}: {c}");
+    }
+
+    let mut s = new_sketch();
+    let rect = strs(&made(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [20, 10]}))["curves"]);
+    let c = made(&mut s, "sketch.offset", json!({"curves": [rect[0]], "distance": 2, "side": [10, 5]}));
+    assert_eq!(strs(&c["curves"]).len(), 4, "{c}");
+    made(&mut s, "sketch.move", json!({"entities": [rect[0]], "translate": [0, -20], "copy": true}));
+    made(&mut s, "sketch.pattern.rectangular", json!({"entities": [rect[2]], "count": 3, "spacing": 30}));
+    let circle = strs(&made(&mut s, "sketch.circle.center", json!({"center": [100, 0], "radius": 2}))["curves"]);
+    made(&mut s, "sketch.pattern.circular", json!({"entities": [circle[0]], "center": [90, 0], "count": 4}));
+    let axis = strs(&made(&mut s, "sketch.line", json!({"points": [[200, -10], [200, 10]]}))["curves"]);
+    let sm = strs(&made(&mut s, "sketch.circle.center", json!({"center": [190, 0], "radius": 2}))["curves"]);
+    made(&mut s, "sketch.mirror", json!({"entities": [sm[0]], "line": axis[0]}));
+
+    // Break and trim split a curve where another crosses it.
+    let mut s = new_sketch();
+    let h = strs(&made(&mut s, "sketch.line", json!({"points": [[0, 0], [20, 0]]}))["curves"]);
+    made(&mut s, "sketch.line", json!({"points": [[10, -5], [10, 5]]}));
+    made(&mut s, "sketch.break", json!({"curve": h[0], "at": [5, 0]}));
+    let mut s = new_sketch();
+    let h = strs(&made(&mut s, "sketch.line", json!({"points": [[0, 0], [30, 0]]}))["curves"]);
+    made(&mut s, "sketch.line", json!({"points": [[10, -5], [10, 5]]}));
+    made(&mut s, "sketch.line", json!({"points": [[20, -5], [20, 5]]}));
+    made(&mut s, "sketch.trim", json!({"curve": h[0], "at": [15, 0]}));
+
+    // Tangent tools and blends start from existing curves.
+    let mut s = new_sketch();
+    let l = strs(&made(&mut s, "sketch.line", json!({"points": [[0, 0], [10, 0]]}))["curves"]);
+    made(&mut s, "sketch.arc.tangent", json!({"start": format!("{}.end", l[0]), "end": [20, 10]}));
+    let a = strs(&made(&mut s, "sketch.line", json!({"points": [[0, 30], [10, 30]]}))["curves"]);
+    let b = strs(&made(&mut s, "sketch.line", json!({"points": [[20, 40], [30, 40]]}))["curves"]);
+    made(&mut s, "sketch.blend_curve", json!({"a": format!("{}.end", a[0]), "b": format!("{}.start", b[0])}));
+    let x = strs(&made(&mut s, "sketch.line", json!({"points": [[100, 0], [140, 0]], "connect": false}))["curves"]);
+    let y = strs(&made(&mut s, "sketch.line", json!({"points": [[100, 0], [100, 40]], "connect": false}))["curves"]);
+    made(&mut s, "sketch.circle.two_tangent", json!({"curves": [x[0], y[0]], "radius": 5, "near": [106, 4]}));
+    let z = strs(&made(&mut s, "sketch.line", json!({"points": [[100, 40], [140, 40]], "connect": false}))["curves"]);
+    made(&mut s, "sketch.circle.three_tangent", json!({"curves": [x[0], y[0], z[0]], "near": [120, 20]}));
+}
+
+#[test]
+fn text_edits_and_imports_return_the_ids_they_create() {
+    let mut s = new_sketch();
+    let r = run(&mut s, "sketch.text", json!({"text": "I", "at": [0, 0], "height": 10}));
+    check(&mut s, "sketch.text", &r, &Sketch::new());
+    let before = sketch(&s);
+    let link = r["link"].as_str().map(str::to_string).unwrap_or_else(|| panic!("{r}"));
+    let r = run(&mut s, "sketch.edit_text", json!({"link": link, "text": "II"}));
+    check(&mut s, "sketch.edit_text", &r, &before);
+
+    let svg = r#"<svg width="40mm" height="40mm" viewBox="0 0 40 40"><path d="M0 0 H40 V40 H0 Z"/></svg>"#;
+    let mut s = new_sketch();
+    let c = made(&mut s, "sketch.insert_svg", json!({"text": svg}));
+    assert_eq!(strs(&c["curves"]).len(), 4, "{c}");
+    let dxf = run(&mut s, "sketch.export_dxf", json!({}))["dxf"].as_str().unwrap_or_default().to_string();
+    let mut s = new_sketch();
+    let c = made(&mut s, "sketch.insert_dxf", json!({"text": dxf}));
+    assert_eq!(strs(&c["curves"]).len(), 4, "{c}");
+}
+
+#[test]
+fn projections_and_3d_curves_return_the_ids_they_create() {
+    let mut s = Session::default();
+    run(&mut s, "solid.box", json!({"corner": [0, 0, 0], "length": 20, "width": 20, "height": 10}));
+    let body = s.model.state().bodies.first().map(|b| b.name.clone()).unwrap_or_default();
+    run(&mut s, "sketch.create", json!({"plane": "XY", "offset": 5}));
+    made(&mut s, "sketch.project", json!({"refs": [{"edge": [10, 0, 10]}]}));
+    made(&mut s, "sketch.intersect", json!({"refs": [{"body": body}]}));
+    made(&mut s, "sketch.include_3d", json!({"refs": [{"edge": [20, 10, 10]}]}));
+    made(&mut s, "sketch.fit_curves_to_section", json!({"body": body}));
+    made(&mut s, "sketch.isoparametric_curve", json!({"face": [10, 10, 10]}));
+
+    let mut s = new_sketch();
+    run(&mut s, "sketch.options", json!({"sketch_3d": true}));
+    let c = made(&mut s, "sketch.line3d", json!({"points": [[0, 0, 0], [0, 0, 10], [10, 0, 10]]}));
+    assert_eq!(strs(&c["wires"]).len(), 2, "{c}");
+    made(&mut s, "sketch.spline3d", json!({"points": [[0, 0, 0], [5, 5, 5], [10, 0, 10]]}));
+    made(&mut s, "sketch.point3d", json!({"point": [5, 5, 5]}));
+}
+
+#[test]
+fn a_new_sketch_reports_its_projected_face_edges() {
+    let mut s = Session::default();
+    run(&mut s, "solid.box", json!({"corner": [0, 0, 0], "length": 20, "width": 20, "height": 10}));
+    let r = run(&mut s, "sketch.create", json!({"plane": {"face": [10, 10, 10]}}));
+    let c = check(&mut s, "sketch.create", &r, &Sketch::new());
+    assert_eq!(strs(&c["curves"]).len(), 4, "{c}");
+}
+
+#[test]
+fn ids_are_never_reused_after_a_delete() {
+    let mut s = new_sketch();
+    let first = made(&mut s, "sketch.line", json!({"points": [[0, 0], [10, 0]]}));
+    let circle = made(&mut s, "sketch.circle.center", json!({"center": [30, 0], "radius": 3}));
+    let dim = run(&mut s, "sketch.dimension", json!({"entities": [strs(&circle["curves"])[0]], "value": 8}));
+    let mut gone: Vec<String> = ["points", "curves"].iter().flat_map(|k| strs(&first[k]).into_iter().chain(strs(&circle[k]))).collect();
+    gone.extend(strs(&dim["created"]["dimensions"]));
+    // Deleting the curves takes their own end and centre points (and the dimension) with them.
+    run(&mut s, "sketch.delete", json!({"entities": strs(&first["curves"]).into_iter().chain(strs(&circle["curves"])).collect::<Vec<_>>()}));
+    let sk = sketch(&s);
+    assert!(sk.curves.is_empty() && sk.points.len() == 1 && sk.constraints.is_empty(), "{:?}", sk.curves);
+    // The same commands again: every id is new.
+    let again = made(&mut s, "sketch.line", json!({"points": [[0, 0], [10, 0]]}));
+    let circle2 = made(&mut s, "sketch.circle.center", json!({"center": [30, 0], "radius": 3}));
+    let dim2 = run(&mut s, "sketch.dimension", json!({"entities": [strs(&circle2["curves"])[0]], "value": 8}));
+    let mut fresh: Vec<String> = ["points", "curves"].iter().flat_map(|k| strs(&again[k]).into_iter().chain(strs(&circle2[k]))).collect();
+    fresh.extend(strs(&dim2["created"]["dimensions"]));
+    assert_eq!(fresh.len(), gone.len(), "{fresh:?} {gone:?}");
+    for id in &fresh {
+        assert!(!gone.contains(id), "id {id} reused: {gone:?} -> {fresh:?}");
+    }
+    // Undo of a delete brings the old ids back unchanged (they still name the same geometry).
+    let line = strs(&again["curves"])[0].clone();
+    run(&mut s, "sketch.delete", json!({"entities": [line]}));
+    run(&mut s, "edit.undo", json!({}));
+    assert!(sketch(&s).curve_index(&line).is_some());
+}
+
+/// The example in docs/control-protocol.md.
+#[test]
+fn documented_example_holds() {
+    let mut s = new_sketch();
+    let r = run(&mut s, "sketch.line", json!({"points": [[0, 0], [40, 0]]}));
+    assert_eq!(r["curves"], json!(["l1"]));
+    assert_eq!(r["created"], json!({"points": ["l1.start", "l1.end"], "curves": ["l1"], "constraints": ["k1"], "dimensions": []}));
+    run(&mut s, "sketch.dimension", json!({"entities": ["l1"], "value": 50}));
+}
+
+#[test]
+fn commands_that_add_nothing_report_empty_lists() {
+    let mut s = new_sketch();
+    let c = made(&mut s, "sketch.line", json!({"points": [[0, 0], [10, 5]]}));
+    let r = run(&mut s, "sketch.move_point", json!({"point": strs(&c["points"])[1], "to": [12, 6]}));
+    assert_eq!(r["created"], json!({"points": [], "curves": [], "constraints": [], "dimensions": []}), "{r}");
+}
diff --git a/crates/engine/src/cmd/sketch_import.rs b/crates/engine/src/cmd/sketch_import.rs
index 381391db..81403fa4 100644
--- a/crates/engine/src/cmd/sketch_import.rs
+++ b/crates/engine/src/cmd/sketch_import.rs
@@ -16,11 +16,11 @@ pub static COMMANDS: &[CommandSpec] = &[
     CommandSpec::new("sketch.insert_dxf", "Insert DXF", insert_dxf)
         .at("SKETCH", "INSERT")
         .icon("dxf")
-        .params("path | text: ASCII DXF (blocks expanded); at?: [x,y] offset, scale?, tolerance?: mm within which ends join (default 0.0001); plane?: (when no sketch is active, a new sketch on it; default XY)"),
+        .params(concat!("path | text: ASCII DXF (blocks expanded); at?: [x,y] offset, scale?, tolerance?: mm within which ends join (default 0.0001); plane?: (when no sketch is active, a new sketch on it; default XY)", created_doc!())),
     CommandSpec::new("sketch.insert_svg", "Insert SVG", insert_svg)
         .at("SKETCH", "INSERT")
         .icon("svg")
-        .params("path | text: SVG; at?: [x,y] offset, scale?, tolerance?: mm within which ends join (default 0.0001); plane?: (when no sketch is active, a new sketch on it; default XY)"),
+        .params(concat!("path | text: SVG; at?: [x,y] offset, scale?, tolerance?: mm within which ends join (default 0.0001); plane?: (when no sketch is active, a new sketch on it; default XY)", created_doc!())),
     CommandSpec::new("sketch.export_dxf", "Save As DXF", export_dxf)
         .noundo()
         .params("sketch?: id|name (default active); path?: file to write (else the DXF text is returned)"),
diff --git a/crates/engine/src/cmd/sketch_modify.rs b/crates/engine/src/cmd/sketch_modify.rs
index f79c3697..d7b98726 100644
--- a/crates/engine/src/cmd/sketch_modify.rs
+++ b/crates/engine/src/cmd/sketch_modify.rs
@@ -17,34 +17,34 @@ pub static COMMANDS: &[CommandSpec] = &[
         .at("SKETCH", "MODIFY")
         .icon("sketch_fillet")
         .enabled(in_sketch)
-        .params("point: corner shared by two curves (\"l1.end\") | points: [corners] (all rounded alike: one radius, the rest equal) | a, b: two lines or arcs meeting at a corner; radius: expr"),
+        .params(concat!("point: corner shared by two curves (\"l1.end\") | points: [corners] (all rounded alike: one radius, the rest equal) | a, b: two lines or arcs meeting at a corner; radius: expr", created_doc!())),
     CommandSpec::new("sketch.chamfer.equal_distance", "Equal Distance Chamfer", chamfer_equal)
         .at("SKETCH", "MODIFY")
         .icon("sketch_chamfer")
         .enabled(in_sketch)
-        .params("point | a, b: a corner of two lines; distance"),
+        .params(concat!("point | a, b: a corner of two lines; distance", created_doc!())),
     CommandSpec::new("sketch.chamfer.distance_angle", "Distance and Angle Chamfer", chamfer_dist_angle)
         .at("SKETCH", "MODIFY")
         .icon("sketch_chamfer")
         .enabled(in_sketch)
-        .params("point | a, b: a corner of two lines; distance: along a, angle: deg from a"),
+        .params(concat!("point | a, b: a corner of two lines; distance: along a, angle: deg from a", created_doc!())),
     CommandSpec::new("sketch.chamfer.two_distance", "Two Distance Chamfer", chamfer_two)
         .at("SKETCH", "MODIFY")
         .icon("sketch_chamfer")
         .enabled(in_sketch)
-        .params("point | a, b: a corner of two lines; distance: along a, distance2: along b"),
+        .params(concat!("point | a, b: a corner of two lines; distance: along a, distance2: along b", created_doc!())),
     CommandSpec::new("sketch.offset", "Offset", offset)
         .at("SKETCH", "MODIFY")
         .icon("offset")
         .key("O")
         .enabled(in_sketch)
-        .params("curves: [ids], distance: number (positive = left of the chain, or toward `side`), side?: [x,y], chain?: bool (default true: the connected chain)"),
+        .params(concat!("curves: [ids], distance: number (positive = left of the chain, or toward `side`), side?: [x,y], chain?: bool (default true: the connected chain)", created_doc!())),
     CommandSpec::new("sketch.trim", "Trim", trim)
         .at("SKETCH", "MODIFY")
         .icon("trim")
         .key("T")
         .enabled(in_sketch)
-        .params("curve: id, at: [x,y] (the piece to remove: between the nearest intersections around it)"),
+        .params(concat!("curve: id, at: [x,y] (the piece to remove: between the nearest intersections around it)", created_doc!())),
     CommandSpec::new("sketch.extend", "Extend", extend)
         .at("SKETCH", "MODIFY")
         .icon("extend")
@@ -54,7 +54,7 @@ pub static COMMANDS: &[CommandSpec] = &[
         .at("SKETCH", "MODIFY")
         .icon("break")
         .enabled(in_sketch)
-        .params("curve: id, at: [x,y] (split at the nearest intersections around it) | params: split at points: [[x,y]…]"),
+        .params(concat!("curve: id, at: [x,y] (split at the nearest intersections around it) | params: split at points: [[x,y]…]", created_doc!())),
     CommandSpec::new("sketch.scale", "Sketch Scale", scale)
         .at("SKETCH", "MODIFY")
         .icon("scale")
@@ -62,22 +62,22 @@ pub static COMMANDS: &[CommandSpec] = &[
         .params("entities: [curve/point ids], base: [x,y] or point ref, factor: number"),
     CommandSpec::new("sketch.move", "Move/Copy Sketch Entities", move_copy)
         .enabled(in_sketch)
-        .params("entities: [ids], translate?: [dx,dy], angle?: deg, center?: [x,y], copy?: bool"),
+        .params(concat!("entities: [ids], translate?: [dx,dy], angle?: deg, center?: [x,y], copy?: bool", created_doc!())),
     CommandSpec::new("sketch.mirror", "Mirror", mirror)
         .at("SKETCH", "CREATE")
         .icon("sketch_mirror")
         .enabled(in_sketch)
-        .params("entities: [curve/point ids], line: mirror line id (symmetry constraints are added)"),
+        .params(concat!("entities: [curve/point ids], line: mirror line id (symmetry constraints are added)", created_doc!())),
     CommandSpec::new("sketch.pattern.circular", "Circular Pattern", pattern_circular)
         .at("SKETCH", "CREATE")
         .icon("sketch_circ_pattern")
         .enabled(in_sketch)
-        .params("entities: [ids], center: [x,y] or point ref, count: 2…500, angle?: total deg (default 360)"),
+        .params(concat!("entities: [ids], center: [x,y] or point ref, count: 2…500, angle?: total deg (default 360)", created_doc!())),
     CommandSpec::new("sketch.pattern.rectangular", "Rectangular Pattern", pattern_rect)
         .at("SKETCH", "CREATE")
         .icon("sketch_rect_pattern")
         .enabled(in_sketch)
-        .params("entities: [ids], dir?: [x,y] (default x), count, spacing; count2?, spacing2? (perpendicular direction)"),
+        .params(concat!("entities: [ids], dir?: [x,y] (default x), count, spacing; count2?, spacing2? (perpendicular direction)", created_doc!())),
 ];
 
 const TOL: f64 = 1e-7;
diff --git a/crates/engine/src/cmd/sketch_project.rs b/crates/engine/src/cmd/sketch_project.rs
index b7ee7586..74a49ed9 100644
--- a/crates/engine/src/cmd/sketch_project.rs
+++ b/crates/engine/src/cmd/sketch_project.rs
@@ -13,41 +13,47 @@ use super::{CommandSpec, in_sketch};
 use crate::params::{bad, bool_, str_, vec3};
 use crate::{EngineError, Result, Session};
 
+macro_rules! refs_doc {
+    () => {
+        "refs: [{edge: [x,y,z], body?} | {face: [x,y,z], body?} (its edge loops) | {body: name} (silhouette) | {vertex: [x,y,z], body?} | {sketch, curve} | {sketch, point} | \"origin\" | {axis: X|Y|Z} | {plane: XY|XZ|YZ|name}]"
+    };
+}
+
 pub static COMMANDS: &[CommandSpec] = &[
-    CommandSpec::new("sketch.project", "Project", project_cmd).at("SKETCH", "CREATE").icon("project").key("P").enabled(in_sketch).params(REFS_DOC),
+    CommandSpec::new("sketch.project", "Project", project_cmd).at("SKETCH", "CREATE").icon("project").key("P").enabled(in_sketch).params(concat!(refs_doc!(), created_doc!())),
     CommandSpec::new("sketch.intersect", "Intersect", intersect_cmd).at("SKETCH", "CREATE").icon("intersect").enabled(in_sketch).params(
-        "refs: [{body}, {face: [x,y,z], body?}, {edge: [x,y,z], body?}, {sketch, curve}]: section curves (or points) with the sketch plane, linked",
+        concat!("refs: [{body}, {face: [x,y,z], body?}, {edge: [x,y,z], body?}, {sketch, curve}]: section curves (or points) with the sketch plane, linked", created_doc!()),
     ),
     CommandSpec::new("sketch.include_3d", "Include 3D Geometry", include_cmd)
         .at("SKETCH", "CREATE")
         .icon("include")
         .enabled(in_sketch)
-        .params("refs: like Project (edges, vertices, sketch curves and points); curves out of the sketch plane are flattened onto it"),
+        .params(concat!("refs: like Project (edges, vertices, sketch curves and points); curves out of the sketch plane are flattened onto it", created_doc!())),
     CommandSpec::new("sketch.project_to_surface", "Project To Surface", project_to_surface)
         .at("SKETCH", "CREATE")
         .icon("project_surface")
         .enabled(in_sketch)
-        .params("curves: [{sketch, curve}…] (curves of other sketches), face: [x,y,z] point on the target face, body?: projected along the active sketch's normal onto the face, as linked 3D curves"),
+        .params(concat!("curves: [{sketch, curve}…] (curves of other sketches), face: [x,y,z] point on the target face, body?: projected along the active sketch's normal onto the face, as linked 3D curves", created_doc!())),
     CommandSpec::new("sketch.intersection_curve", "Intersection Curve", intersection_curve)
         .at("SKETCH", "CREATE")
         .icon("intersection_curve")
         .enabled(in_sketch)
-        .params("a, b: {body} | {face: [x,y,z], body?}: where they meet, as linked 3D curves"),
+        .params(concat!("a, b: {body} | {face: [x,y,z], body?}: where they meet, as linked 3D curves", created_doc!())),
     CommandSpec::new("sketch.spun_profile", "Spun Profile", spun_profile)
         .at("SKETCH", "CREATE")
         .icon("spun")
         .enabled(in_sketch)
-        .params("body: name, axis: a line of the active sketch (curve id) | X|Y|Z: the body's outline revolved about the axis, in the sketch plane"),
+        .params(concat!("body: name, axis: a line of the active sketch (curve id) | X|Y|Z: the body's outline revolved about the axis, in the sketch plane", created_doc!())),
     CommandSpec::new("sketch.isoparametric_curve", "Isoparametric Curve", iso_curve)
         .at("SKETCH", "CREATE")
         .icon("iso_curve")
         .enabled(in_sketch)
-        .params("face: [x,y,z] point on the face (the curve passes through it), body?, direction?: u|v|[x,y,z] (default u): linked 3D curve"),
+        .params(concat!("face: [x,y,z] point on the face (the curve passes through it), body?, direction?: u|v|[x,y,z] (default u): linked 3D curve", created_doc!())),
     CommandSpec::new("sketch.fit_curves_to_section", "Fit Curves to Mesh Section", fit_section)
         .at("SKETCH", "CREATE")
         .icon("fit_section")
         .enabled(in_sketch)
-        .params("body: name (a mesh or solid body): its section with the sketch plane, fitted with lines and arcs, as normal (unlinked) geometry"),
+        .params(concat!("body: name (a mesh or solid body): its section with the sketch plane, fitted with lines and arcs, as normal (unlinked) geometry", created_doc!())),
     CommandSpec::new("sketch.break_link", "Break Link", break_link)
         .enabled(in_sketch)
         .params("link?: link id (j1) | entities?: [curve or point ids]: linked geometry becomes normal sketch geometry"),
@@ -56,8 +62,6 @@ pub static COMMANDS: &[CommandSpec] = &[
         .params("value?: bool (default toggles): project a face's edges when a sketch is created on it"),
 ];
 
-const REFS_DOC: &str = "refs: [{edge: [x,y,z], body?} | {face: [x,y,z], body?} (its edge loops) | {body: name} (silhouette) | {vertex: [x,y,z], body?} | {sketch, curve} | {sketch, point} | \"origin\" | {axis: X|Y|Z} | {plane: XY|XZ|YZ|name}]";
-
 /// Parse one reference.
 fn source(s: &Session, v: &Value, cmd: &str) -> Result<LinkSource> {
     if let Some(name) = v.as_str() {
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index a6907769..540f8ffb 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -351,6 +351,7 @@ impl Session {
         let changed = !Arc::ptr_eq(&self.doc, &before.doc);
         match r {
             Ok(v) => {
+                let v = if changed { self.with_created(spec.id, params, &before, v) } else { v };
                 if changed {
                     if spec.undoable {
                         self.undo.push(before);
@@ -374,6 +375,28 @@ impl Session {
         }
     }
 
+    /// A sketch command's result gets `created`: the ids of the points, curves, constraints and
+    /// dimensions it added to its sketch (the `sketch` param, else the active sketch), so every
+    /// drawing and modify command reports them the same way (see `cmd::sketch_created`).
+    fn with_created(&self, id: &str, params: &Value, before: &Snapshot, mut v: Value) -> Value {
+        if !id.starts_with("sketch.") {
+            return v;
+        }
+        let Some(out) = v.as_object_mut() else { return v };
+        if out.contains_key("created") {
+            return v;
+        }
+        let named = match params.get("sketch") {
+            Some(Value::Number(n)) => self.doc.find_feature(&n.to_string()).map(|f| f.id),
+            Some(Value::String(x)) => self.doc.find_feature(x).map(|f| f.id),
+            _ => None,
+        };
+        let Some(sk) = named.or(self.active_sketch).or(before.active_sketch) else { return v };
+        let Ok(after) = self.doc.sketch(sk) else { return v };
+        out.insert("created".into(), cmd::sketch_created(before.doc.sketch(sk).ok(), after));
+        v
+    }
+
     /// Remember the design, active sketch and undo history; returns the checkpoint's id.
     pub fn checkpoint(&mut self) -> u64 {
         let id = self.next_checkpoint;
diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs
index 938e0de7..f458ed38 100644
--- a/crates/mcp/src/tools.rs
+++ b/crates/mcp/src/tools.rs
@@ -58,7 +58,10 @@ pub fn tool_definitions() -> Vec<Value> {
              {center: [20,15], radius: 5}; sketch.dimension {entities: [curve id], value: \"width\"}; sketch.finish {}; solid.extrude \
              {distance: 20, operation: \"cut\"}; solid.fillet {edges: [[0,0,10]], radius: 3}; solid.box {length, \
              width, height}. Lengths are mm; expressions may use parameters and units (\"width / 2\", \"30 deg\"). Returns \
-             the command's result; failures leave the design unchanged.",
+             the command's result; failures leave the design unchanged. Sketch commands that add geometry return \
+             created: {points, curves, constraints, dimensions}: the ids of what they added, stable and not reused \
+             after a delete (undo rewinds the counters with the design), usable right away \
+             in sketch.dimension, sketch.constraint.* and sketch.delete.",
             obj(
                 json!({
                     "command": string("Command id (see list_commands)"),
diff --git a/docs/book/src/guide/sketching.md b/docs/book/src/guide/sketching.md
index d10bf732..85c7c25e 100644
--- a/docs/book/src/guide/sketching.md
+++ b/docs/book/src/guide/sketching.md
@@ -15,6 +15,11 @@ fillet, chamfer, offset (O), mirror, patterns, move/copy and scale.
 **Project** (P) and **Intersect** bring model edges into the sketch as linked geometry that
 follows later changes. Sketching on a face projects its edges automatically.
 
+Run from a script or the control channel, every command that adds sketch geometry returns the
+ids of what it added (`created: {points, curves, constraints, dimensions}`). Ids are stable and
+never reused within a sketch, even after a delete, so a script can dimension or constrain the new
+geometry right away.
+
 ## Constraints and dimensions
 
 The solver is SolveCraft's own (damped Gauss–Newton with degree-of-freedom analysis). Constraints:
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index 35a82c20..eb9d5044 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -17,6 +17,18 @@ events, one pointer event per frame.
 
 Commands never open dialogs when run this way. `solvecraft-cli commands` prints the same registry.
 
+Every `sketch.*` command that changes a sketch adds `created: {points, curves, constraints,
+dimensions}` to its result (and `wires` for 3D curves): the ids of what it added, in creation
+order, next to whatever else the command returns (`curves`, `sides`, `corners`…). Sketch ids are
+stable and never reused, even after a delete (`l1`, `l2`, then `l3` once `l2` is gone; only undo
+rolls the numbering back with the design), so they can go straight into later commands:
+
+```text
+{"id":7,"method":"engine.execute","params":{"command":"sketch.line","params":{"points":[[0,0],[40,0]]}}}
+→ {"curves":["l1"],"created":{"points":["l1.start","l1.end"],"curves":["l1"],"constraints":["k1"],"dimensions":[]},…}
+{"id":8,"method":"engine.execute","params":{"command":"sketch.dimension","params":{"entities":["l1"],"value":50}}}
+```
+
 ## UI
 
 | Method | Params | Notes |

From 21e0e99c866284e9a6bf60c8b90093a4d8b43f7f Mon Sep 17 00:00:00 2001
From: CypherNaugh_0x <9931495+CypherNaught-0x@users.noreply.github.com>
Date: Sun, 11 Oct 2026 10:16:49 +0200
Subject: [PATCH 6/7] Model renders (screenshot with source model, ui.render)
 show the section the window shows: the CPU renderer drew the cut face on the
 far walls at their own depth in a plain grey hatch, so the inside of the
 body, its edges and the grid showed through it and the cut barely read as a
 section, it had no outline, perspective views cut along a curve, and an open
 Section Analysis dialog's preview (or a sketch's Slice) was ignored. The cut
 face now writes the section plane's depth where it is the visible surface
 (the CPU counterpart of the viewport's stencil cap), takes the viewport's cap
 tint and hatch, the cut outline is drawn (section_segments moved from the UI
 to engine::view and shared), world positions and lines are clipped
 perspective-correctly, and ui.render in the app uses the viewport's section
 plane

---
 crates/engine/src/view.rs      |  74 ++++++++++++++++++++++-
 crates/mcp/src/tools.rs        |   3 +-
 crates/render/src/lib.rs       |   2 +-
 crates/render/src/raster.rs    | 105 ++++++++++++++++++++++++++++-----
 crates/ui-egui/src/control.rs  |  49 ++++++++++++++-
 crates/ui-egui/src/viewport.rs |  28 +--------
 docs/control-protocol.md       |   2 +-
 7 files changed, 217 insertions(+), 46 deletions(-)

diff --git a/crates/engine/src/view.rs b/crates/engine/src/view.rs
index 52b3a675..19fa34cb 100644
--- a/crates/engine/src/view.rs
+++ b/crates/engine/src/view.rs
@@ -35,6 +35,8 @@ pub mod colors {
     pub const AXIS_Z: Rgb = Rgb(60, 100, 230);
     pub const BG_TOP: Rgb = Rgb(240, 243, 247);
     pub const BG_BOTTOM: Rgb = Rgb(203, 210, 221);
+    /// What the section cap is tinted toward.
+    pub const SECTION_CAP: Rgb = solvecraft_render::SECTION_CAP;
 }
 
 /// Bounds of everything visible.
@@ -119,10 +121,23 @@ pub fn sketch_point_visible(sk: &Sketch, i: usize) -> bool {
     }
 }
 
-/// The scene for a headless render.
+/// The scene for a headless render, cut by the session's section.
 pub fn scene(s: &Session, cam: &Camera) -> Scene {
+    scene_with_section(s, cam, s.section)
+}
+
+/// The scene for a headless render, cut by `section` (origin, normal) instead of the session's:
+/// the app passes the cut its viewport shows (an open Section Analysis dialog's preview, a
+/// sketch's Slice), so model renders match the window.
+pub fn scene_with_section(s: &Session, cam: &Camera, section: Option<(Vec3, Vec3)>) -> Scene {
     let st = s.world_state();
-    let mut sc = Scene { background: Some((colors::BG_TOP, colors::BG_BOTTOM)), clip: s.section.map(|(o, n)| (n, n.dot(o))), ..Default::default() };
+    let section = section.filter(|(o, n)| o.is_finite() && n.is_finite() && n.len() > 1e-9);
+    let mut sc = Scene {
+        background: Some((colors::BG_TOP, colors::BG_BOTTOM)),
+        clip: section.map(|(o, n)| (n, n.dot(o))),
+        cap: Some(colors::SECTION_CAP),
+        ..Default::default()
+    };
     let b = bounds(s);
     sc.radius = (b.diagonal() * 0.5).max(cam.half_height()).max(10.0) + b.center().dist(cam.target);
     // Grid on the ground plane (XY with Z up, XZ with Y up).
@@ -172,6 +187,12 @@ pub fn scene(s: &Session, cam: &Camera) -> Scene {
             }
             sc.lines.push(SceneLine { points: e.clone(), color: colors::EDGE, width: 1.2, on_top: false });
         }
+        // The outline of the body where the section cuts it.
+        if let Some((o, n)) = section {
+            for (a, b) in section_segments(&mesh, o, n) {
+                sc.lines.push(SceneLine { points: vec![a, b], color: colors::EDGE, width: 1.6, on_top: false });
+            }
+        }
     }
     for ss in &st.sketches {
         let active = s.active_sketch == Some(ss.feature);
@@ -185,6 +206,28 @@ pub fn scene(s: &Session, cam: &Camera) -> Scene {
     sc
 }
 
+/// Where the plane through `o` with normal `n` cuts a mesh: one segment per crossed triangle,
+/// nudged a hair to the kept side (so the clip leaves them drawn).
+pub fn section_segments(m: &solvecraft_geom::Mesh, o: Vec3, n: Vec3) -> Vec<(Vec3, Vec3)> {
+    let eps = 1e-4 * (1.0 + m.bounds().diagonal());
+    let mut out = Vec::new();
+    for t in &m.triangles {
+        let Some(p) = m.tri(t) else { continue };
+        let d = p.map(|q| n.dot(q - o));
+        let mut pts = Vec::with_capacity(2);
+        for (i, j) in [(0, 1), (1, 2), (2, 0)] {
+            if (d[i] < 0.0) != (d[j] < 0.0) {
+                let s = d[i] / (d[i] - d[j]);
+                pts.push(p[i] + (p[j] - p[i]) * s - n * eps);
+            }
+        }
+        if let [a, b] = pts[..] {
+            out.push((a, b));
+        }
+    }
+    out
+}
+
 /// Is a sketch drawn? The active one is; others unless hidden. Finished sketches are hidden
 /// once a feature uses them, like Fusion's default, unless shown one by one.
 pub fn sketch_shown(s: &Session, id: u64) -> bool {
@@ -315,4 +358,31 @@ mod tests {
         let changed = whole.chunks(4).zip(cut.chunks(4)).filter(|(a, b)| a != b).count();
         assert!(changed > 500, "{changed} pixels changed");
     }
+
+    /// The section's cut face hides what lies inside the body behind it (it is drawn at the
+    /// plane's depth, not on the far wall like a pane of glass), shows in the cap colour, and
+    /// the cut's outline is drawn.
+    #[test]
+    fn snapshot_section_caps_hide_the_inside() {
+        let mut s = Session::default();
+        s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20})).unwrap();
+        // Cut away the front half (y < 15), so the iso camera looks into the cut.
+        s.execute("inspect.section", &json!({"plane": {"origin": [0, 15, 0], "normal": [0, -1, 0]}})).unwrap();
+        for fov in [0.0, 0.6] {
+            let mut cam = home_camera(&s);
+            cam.fov = fov;
+            let mut sc = scene(&s, &cam);
+            assert!(!section_segments(&s.world_state().bodies[0].mesh(), Vec3::new(0.0, 15.0, 0.0), -Vec3::Y).is_empty());
+            // A marker inside the body, behind the cut face.
+            let red = Rgb(255, 0, 0);
+            sc.lines.push(SceneLine { points: vec![Vec3::new(5.0, 25.0, 10.0), Vec3::new(35.0, 25.0, 10.0)], color: red, width: 3.0, on_top: false });
+            let img = solvecraft_render::render(&sc, &cam, 300, 220);
+            let px = || img.rgba.chunks(4);
+            let marker = px().filter(|p| p[0] > 200 && p[1] < 60 && p[2] < 60).count();
+            assert_eq!(marker, 0, "fov {fov}: the inside shows through the cut face");
+            // The cap: warm (red over blue), unlike the grey-blue body and background.
+            let cap = px().filter(|p| p[0] as i32 - p[2] as i32 > 20).count();
+            assert!(cap > 500, "fov {fov}: cap pixels {cap}");
+        }
+    }
 }
diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs
index 938e0de7..78f5762d 100644
--- a/crates/mcp/src/tools.rs
+++ b/crates/mcp/src/tools.rs
@@ -148,7 +148,8 @@ pub fn tool_definitions() -> Vec<Value> {
             "Look at the design",
             "Render the design and return it as a PNG image. Headless: a CPU render of the model, fitted to the view. \
              Connected to the app: a screenshot of the window (source \"window\", the default) or a render of the model \
-             with the app's camera (source \"model\"). `view` first turns the camera to a standard view.",
+             with the app's camera (source \"model\"). Both show an active section (inspect.section) with its cut face \
+             capped. `view` first turns the camera to a standard view.",
             obj(
                 json!({
                     "view": {"type": "string", "enum": VIEWS, "description": "Standard view (default: keep the current one; headless starts at iso)"},
diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs
index 38e7a0aa..56d940d0 100644
--- a/crates/render/src/lib.rs
+++ b/crates/render/src/lib.rs
@@ -8,4 +8,4 @@ mod camera;
 mod raster;
 
 pub use camera::{Camera, CameraAnim, Mat4, Quat, StandardView, UpAxis, ease_in_out};
-pub use raster::{Canvas, Rgb, Scene, SceneLine, SceneMesh, png, render, render_png, render_transparent};
+pub use raster::{Canvas, Rgb, SECTION_CAP, Scene, SceneLine, SceneMesh, png, render, render_png, render_transparent};
diff --git a/crates/render/src/raster.rs b/crates/render/src/raster.rs
index 69ac29aa..3b049533 100644
--- a/crates/render/src/raster.rs
+++ b/crates/render/src/raster.rs
@@ -43,8 +43,13 @@ pub struct Scene {
     /// A section cut: (normal, d); what lies where normal·p > d is cut away, and the inside
     /// shows as a hatched cap.
     pub clip: Option<(Vec3, f64)>,
+    /// The colour the section cap is tinted toward (default: [`SECTION_CAP`]).
+    pub cap: Option<Rgb>,
 }
 
+/// The section cap's default tint, as in the viewport.
+pub const SECTION_CAP: Rgb = Rgb(214, 128, 72);
+
 /// RGBA pixels plus depth.
 pub struct Canvas {
     pub w: usize,
@@ -105,16 +110,28 @@ pub fn render(scene: &Scene, cam: &Camera, w: usize, h: usize) -> Canvas {
         Some([(q[0] / q[3] + 1.0) * 0.5 * sw as f64, (1.0 - q[1] / q[3]) * 0.5 * sh as f64, q[2] / q[3]])
     };
     let view_dir = cam.back();
+    // Where the section cap is the visible surface: the depth of the section plane on that
+    // pixel's view ray. Written into the depth buffer once the solids are drawn, so the cut face
+    // hides edges inside the body (holes, far corners) instead of showing them like a pane of
+    // glass, while holes through the cut stay open (as the viewport does with its stencil).
+    let cap_z = scene.clip.and_then(|(n, d)| cap_plane(cam, n, d, scene.radius.max(1.0), &project));
+    let mut cap_depth = if cap_z.is_some() { vec![f32::INFINITY; sw * sh] } else { Vec::new() };
+    let cap_tint = scene.cap.unwrap_or(SECTION_CAP).f();
     for sm in &scene.meshes {
         let m = &sm.mesh;
         let body = sm.color.f();
         let pts: Vec<Option<[f64; 3]>> = m.positions.iter().map(|p| project(*p)).collect();
+        // 1 / clip w per vertex, for perspective-correct interpolation of world positions (so
+        // the section cuts along the plane, not a curve, in perspective views).
+        let inv_w: Vec<f64> = m.positions.iter().map(|p| 1.0 / vp.apply(*p)[3].max(1e-9)).collect();
         for (ti, t) in m.triangles.iter().enumerate() {
             let face = m.tri_face.get(ti).copied();
             let base = sm.face_colors.iter().find(|(f, _)| Some(*f) == face).map_or(body, |(_, c)| c.f());
             let wp = t.map(|k| m.positions.get(k as usize).copied().unwrap_or_default());
             // Seen from inside (only where a section cuts the body open).
-            let inside = (wp[1] - wp[0]).cross(wp[2] - wp[0]).dot(view_dir) < 0.0;
+            let to_eye = if cam.fov > 0.0 { cam.eye() - wp[0] } else { view_dir };
+            let inside = (wp[1] - wp[0]).cross(wp[2] - wp[0]).dot(to_eye) < 0.0;
+            let iw = t.map(|k| inv_w.get(k as usize).copied().unwrap_or(1.0));
             let (Some(Some(a)), Some(Some(b)), Some(Some(cc))) = (pts.get(t[0] as usize), pts.get(t[1] as usize), pts.get(t[2] as usize)) else {
                 continue;
             };
@@ -140,8 +157,11 @@ pub fn render(scene: &Scene, cam: &Camera, w: usize, h: usize) -> Canvas {
                     if w0 < -1e-9 || w1 < -1e-9 || w2 < -1e-9 {
                         continue;
                     }
+                    let (q0, q1, q2) = (w0 * iw[0], w1 * iw[1], w2 * iw[2]);
+                    let qs = q0 + q1 + q2;
+                    let (p0, p1, p2) = if qs > 1e-12 { (q0 / qs, q1 / qs, q2 / qs) } else { (w0, w1, w2) };
                     if let Some((cn, cd)) = scene.clip
-                        && cn.dot(wp[0] * w0 + wp[1] * w1 + wp[2] * w2) > cd
+                        && cn.dot(wp[0] * p0 + wp[1] * p1 + wp[2] * p2) > cd
                     {
                         continue;
                     }
@@ -151,11 +171,20 @@ pub fn render(scene: &Scene, cam: &Camera, w: usize, h: usize) -> Canvas {
                         if let Some(d) = c.depth.get_mut(i) {
                             *d = z;
                         }
-                        let n = (ns[0] * w0 + ns[1] * w1 + ns[2] * w2).normalized().unwrap_or(Vec3::Z);
-                        if scene.clip.is_some() && inside {
-                            // The cut: the body's colour, hatched at 45 degrees.
-                            let k = if ((x + y) / SS) % 9 < 2 { 0.5 } else { 0.8 };
-                            c.put(x, y, base.map(|v| v * k), 1.0);
+                        let n = (ns[0] * p0 + ns[1] * p1 + ns[2] * p2).normalized().unwrap_or(Vec3::Z);
+                        let cut = scene.clip.is_some() && inside;
+                        if let Some(d) = cap_depth.get_mut(i) {
+                            *d = match cap_z {
+                                Some([a, b, k]) if cut => ((a * px + b * py + k) as f32).min(z),
+                                _ => f32::INFINITY,
+                            };
+                        }
+                        if cut {
+                            // The cut: the body's colour tinted toward the cap colour, hatched
+                            // at 45 degrees (as the viewport draws it).
+                            let tinted: [f64; 3] = std::array::from_fn(|k| base[k] + (cap_tint[k] - base[k]) * 0.35);
+                            let k = if ((x + y) / SS) % 9 < 2 { 0.6 } else { 1.0 };
+                            c.put(x, y, tinted.map(|v| v * k), 1.0);
                             continue;
                         }
                         let mut col = shade(n, view_dir, base);
@@ -172,21 +201,24 @@ pub fn render(scene: &Scene, cam: &Camera, w: usize, h: usize) -> Canvas {
             }
         }
     }
+    for (d, cz) in c.depth.iter_mut().zip(&cap_depth) {
+        if cz.is_finite() {
+            *d = *cz;
+        }
+    }
     for l in &scene.lines {
         let col = l.color.f();
         let half = (l.width * SS as f64 * 0.5).max(0.5);
         for seg in l.points.windows(2) {
-            let (Some(p), Some(q)) = (seg.first(), seg.get(1)) else { continue };
-            let (Some(a), Some(b)) = (project(*p), project(*q)) else { continue };
+            let (Some(&p), Some(&q)) = (seg.first(), seg.get(1)) else { continue };
+            // The section cuts the segment in 3D (screen space is not linear in depth in
+            // perspective views).
+            let Some((p, q)) = clip_segment(p, q, scene.clip) else { continue };
+            let (Some(a), Some(b)) = (project(p), project(q)) else { continue };
             let len = ((b[0] - a[0]).powi(2) + (b[1] - a[1]).powi(2)).sqrt();
             let steps = (len.ceil() as usize).clamp(1, 20_000);
             for k in 0..=steps {
                 let t = k as f64 / steps as f64;
-                if let Some((cn, cd)) = scene.clip
-                    && cn.dot(*p + (*q - *p) * t) > cd + 1e-6
-                {
-                    continue;
-                }
                 let (x, y, z) = (a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t);
                 let r = half.ceil() as i64;
                 for dy in -r..=r {
@@ -234,6 +266,39 @@ pub fn render(scene: &Scene, cam: &Camera, w: usize, h: usize) -> Canvas {
     out
 }
 
+/// The part of segment `p`–`q` the section keeps (where normal·x <= d).
+fn clip_segment(p: Vec3, q: Vec3, clip: Option<(Vec3, f64)>) -> Option<(Vec3, Vec3)> {
+    let Some((n, d)) = clip else { return Some((p, q)) };
+    let (dp, dq) = (n.dot(p) - d - 1e-6, n.dot(q) - d - 1e-6);
+    match (dp > 0.0, dq > 0.0) {
+        (true, true) => None,
+        (false, false) => Some((p, q)),
+        (true, false) => Some((p + (q - p) * (dp / (dp - dq)), q)),
+        (false, true) => Some((p, p + (q - p) * (dp / (dp - dq)))),
+    }
+}
+
+/// Screen depth of the section plane `n·p = d` as `z = a·x + b·y + k` in canvas pixels (a plane
+/// stays a plane under projection), set a hair behind the plane so the cut's own outline stays
+/// drawn. None when the plane is seen edge-on or lies behind the eye.
+fn cap_plane(cam: &Camera, n: Vec3, d: f64, radius: f64, project: &dyn Fn(Vec3) -> Option<[f64; 3]>) -> Option<[f64; 3]> {
+    let margin = 1e-3 * (1.0 + radius);
+    let o = cam.target - n * (n.dot(cam.target) - d - margin);
+    let (u, v) = (n.any_perp(), n.cross(n.any_perp()));
+    let s = radius * 0.1;
+    let (p0, p1, p2) = (project(o)?, project(o + u * s)?, project(o + v * s)?);
+    let (ax, ay, az) = (p1[0] - p0[0], p1[1] - p0[1], p1[2] - p0[2]);
+    let (bx, by, bz) = (p2[0] - p0[0], p2[1] - p0[1], p2[2] - p0[2]);
+    let det = ax * by - ay * bx;
+    if det.abs() < 1e-9 {
+        return None;
+    }
+    let a = (az * by - ay * bz) / det;
+    let b = (ax * bz - az * bx) / det;
+    let k = p0[2] - a * p0[0] - b * p0[1];
+    [a, b, k].iter().all(|x| x.is_finite()).then_some([a, b, k])
+}
+
 /// Render to PNG bytes.
 pub fn render_png(scene: &Scene, cam: &Camera, w: usize, h: usize) -> Option<Vec<u8>> {
     let c = render(scene, cam, w, h);
@@ -274,6 +339,17 @@ mod tests {
     use super::*;
     use crate::StandardView;
 
+    /// Lines are cut by the section in 3D: the kept piece ends on the plane.
+    #[test]
+    fn section_clips_lines_at_the_plane() {
+        let clip = Some((Vec3::X, 2.0));
+        let (p, q) = clip_segment(Vec3::ZERO, Vec3::new(10.0, 4.0, 0.0), clip).unwrap();
+        assert_eq!(p, Vec3::ZERO);
+        assert!((q.x - 2.0).abs() < 1e-5 && (q.y - 0.8).abs() < 1e-5, "{q:?}");
+        assert!(clip_segment(Vec3::new(3.0, 0.0, 0.0), Vec3::new(5.0, 0.0, 0.0), clip).is_none());
+        assert!(clip_segment(Vec3::new(3.0, 0.0, 0.0), Vec3::new(5.0, 0.0, 0.0), None).is_some());
+    }
+
     #[test]
     fn renders_a_triangle() {
         let mesh = Mesh {
@@ -291,6 +367,7 @@ mod tests {
             background: None,
             radius: 20.0,
             clip: None,
+            cap: None,
         };
         let mut cam = Camera { distance: 50.0, ..Default::default() };
         cam.set_view(StandardView::Front);
diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index 7e8e2cb0..2d755af8 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -15,7 +15,8 @@
 //! - `ui.click {x, y, button?, shift?}`, `ui.move {x, y}`, `ui.scroll {x, y, delta}`: real
 //!   pointer input in screen points; `ui.key {key, cmd?, shift?}`, `ui.text {text}`
 //! - `ui.screenshot {path?}`: PNG of the window; `ui.render {path, width?, height?}`: headless
-//!   CPU render of the model with the current camera (no window needed)
+//!   CPU render of the model with the current camera and the section the viewport shows (no
+//!   window needed)
 //! - `ui.menu {x?, y?, target?, close?}`: open a context menu at a point (the viewport's marking
 //!   menu, or a browser menu with `target: {type: body|sketch|component, …}`); without a point,
 //!   the open menu and its items. `ui.menuPick {item}` runs an item by id or label;
@@ -512,7 +513,9 @@ pub fn handle(app: &mut SolveApp, ctx: &egui::Context, req: &ControlRequest) ->
         "ui.render" => {
             let w = f("width").unwrap_or(1280.0).clamp(16.0, 8192.0) as usize;
             let h = f("height").unwrap_or(800.0).clamp(16.0, 8192.0) as usize;
-            let scene = solvecraft_engine::view::scene(&app.session, &app.cam);
+            // Cut by the section the viewport shows (an open Section Analysis dialog's preview,
+            // a sketch's Slice), not only the committed one.
+            let scene = solvecraft_engine::view::scene_with_section(&app.session, &app.cam, crate::viewport::section_plane(app));
             let Some(png) = render_png(&scene, &app.cam, w, h) else { return err("render failed") };
             match s("path") {
                 Some(path) => match std::fs::write(path, &png) {
@@ -552,3 +555,45 @@ pub fn save_screenshot(image: &egui::ColorImage, path: Option<&str>) -> Value {
         Err(e) => json!({"ok": false, "error": e.to_string()}),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+    use solvecraft_engine::{Sel, Session};
+
+    use super::*;
+    use crate::Services;
+
+    fn render(app: &mut SolveApp, path: &std::path::Path) -> Vec<u8> {
+        let (req, _rx) = ControlRequest::new("ui.render", json!({"path": path.to_string_lossy(), "width": 200, "height": 140}));
+        match handle(app, &egui::Context::default(), &req) {
+            Outcome::Done(v) => assert_eq!(v["ok"], true, "{v}"),
+            Outcome::Screenshot { .. } => panic!("ui.render took a screenshot"),
+        }
+        std::fs::read(path).unwrap()
+    }
+
+    /// A model render shows the section the window shows: the open Section Analysis dialog's
+    /// preview too, not only a committed `inspect.section`.
+    #[test]
+    fn model_render_shows_the_section_dialog_preview() {
+        let mut s = Session::default();
+        s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20})).unwrap();
+        let mut app = SolveApp::new(s, Services::default());
+        let dir = std::env::temp_dir().join(format!("solvecraft-render-section-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let whole = render(&mut app, &dir.join("whole.png"));
+        app.session.selection = vec![Sel::Plane { name: "XZ".into() }];
+        app.start("inspect.section");
+        let Some(crate::dialogs::Kind::Section { offset, .. }) = app.dialog.as_mut().map(|d| &mut d.kind) else { panic!("no section dialog") };
+        *offset = "15 mm".into();
+        assert!(app.session.section.is_none() && crate::viewport::section_plane(&app).is_some());
+        let preview = render(&mut app, &dir.join("preview.png"));
+        assert!(whole != preview, "the model render ignores the section the window shows");
+        // Committed, it renders the same.
+        app.run("inspect.section", json!({"plane": "XZ", "offset": 15})).unwrap();
+        app.dialog = None;
+        assert!(render(&mut app, &dir.join("committed.png")) == preview, "the committed section renders differently");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}
diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs
index 300f3521..1dc3cc3a 100644
--- a/crates/ui-egui/src/viewport.rs
+++ b/crates/ui-egui/src/viewport.rs
@@ -330,7 +330,7 @@ fn build_scene(app: &SolveApp) -> GpuScene {
     if let Some((o, n)) = section_plane(app) {
         let col = c4(tk.text.gamma_multiply(0.9));
         for b in st.bodies.iter().filter(|b| !app.session.visibility.hidden_bodies.contains(&b.name)) {
-            for (a, c) in section_segments(&b.mesh(), o, n) {
+            for (a, c) in solvecraft_engine::view::section_segments(&b.mesh(), o, n) {
                 sc.line(a.to_f32(), c.to_f32(), col, 1.8, false);
             }
         }
@@ -419,28 +419,6 @@ fn ground_shadow(sc: &mut GpuScene, app: &SolveApp, st: &solvecraft_engine::doc:
     }
 }
 
-/// Where the plane through `o` with normal `n` cuts a mesh: one segment per crossed triangle,
-/// nudged a hair to the kept side (so the clip leaves them drawn).
-pub(crate) fn section_segments(m: &solvecraft_engine::geom::Mesh, o: Vec3, n: Vec3) -> Vec<(Vec3, Vec3)> {
-    let eps = 1e-4 * (1.0 + m.bounds().diagonal());
-    let mut out = Vec::new();
-    for t in &m.triangles {
-        let Some(p) = m.tri(t) else { continue };
-        let d = p.map(|q| n.dot(q - o));
-        let mut pts = Vec::with_capacity(2);
-        for (i, j) in [(0, 1), (1, 2), (2, 0)] {
-            if (d[i] < 0.0) != (d[j] < 0.0) {
-                let s = d[i] / (d[i] - d[j]);
-                pts.push(p[i] + (p[j] - p[i]) * s - n * eps);
-            }
-        }
-        if let [a, b] = pts[..] {
-            out.push((a, b));
-        }
-    }
-    out
-}
-
 /// The drawn pieces of a polyline in a dash pattern (on, off, on, off… lengths).
 pub(crate) fn dashes(pts: &[Vec3], pattern: &[f64]) -> Vec<(Vec3, Vec3)> {
     let mut out = Vec::new();
@@ -2969,7 +2947,7 @@ mod tests {
         let st = s.model.state();
         let m = st.bodies[0].mesh();
         let (o, n) = (Vec3::new(0.0, 15.0, 0.0), Vec3::new(0.0, -1.0, 0.0));
-        let segs = section_segments(&m, o, n);
+        let segs = solvecraft_engine::view::section_segments(&m, o, n);
         assert!(segs.len() >= 4, "{segs:?}");
         // On the plane (a hair to the kept side) and around the 40 x 20 cut.
         let mut len = 0.0;
@@ -2979,7 +2957,7 @@ mod tests {
         }
         assert!((len - 120.0).abs() < 0.5, "outline length {len}");
         // A plane that misses the body cuts nothing.
-        assert!(section_segments(&m, Vec3::new(0.0, 99.0, 0.0), n).is_empty());
+        assert!(solvecraft_engine::view::section_segments(&m, Vec3::new(0.0, 99.0, 0.0), n).is_empty());
     }
 
     #[test]
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index 35a82c20..ad35cbb5 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -43,7 +43,7 @@ Commands never open dialogs when run this way. `solvecraft-cli commands` prints
 | `ui.key` | `key` (egui key name, `Enter`, `Escape`…), `cmd?`, `shift?` | |
 | `ui.text` | `text` | typed text |
 | `ui.screenshot` | `path?` | PNG of the window (needs a presented frame) |
-| `ui.render` | `path`, `width?`, `height?` | CPU render of the model with the current camera (no window needed) |
+| `ui.render` | `path`, `width?`, `height?` | CPU render of the model with the current camera (no window needed); cut by the section the viewport shows (`inspect.section`, an open Section Analysis dialog's preview, a sketch's Slice), with the cut face capped |
 | `ui.confirm` | `accept?`: bool | answers the Delete confirmation (shown when a delete takes other features with it or makes some fail); without `accept`, what it lists |
 | `ui.documents` | `action?`: `new`, `switch`, `close`, `quit`; `index?`; `force?` (close without asking); `answer?`: `save`, `dont_save`, `cancel` (answers "save changes?") | the open designs (tabs): names, unsaved flags, the active one, a pending "save changes?" prompt, whether a quit is asking |
 | `ui.file` | `path`; `insert?`: bool | starts an interactive background Open or Insert; poll `ui.inspect.file_busy` for completion; the window stays responsive |

From 4667c3a6005a45ce0a6a6e1849b9c53c588beae8 Mon Sep 17 00:00:00 2001
From: CypherNaugh_0x <9931495+CypherNaught-0x@users.noreply.github.com>
Date: Sun, 11 Oct 2026 13:57:06 +0200
Subject: [PATCH 7/7] Fix sketch re-export ordering for rustfmt

---
 crates/engine/src/cmd/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index beddce9b..426389bb 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -36,8 +36,8 @@ mod parameters;
 mod plastic;
 mod sheet;
 mod sketch;
-pub(crate) use sketch::created as sketch_created;
 pub(crate) use sketch::author_path_for_rebind;
+pub(crate) use sketch::created as sketch_created;
 mod sketch_3d;
 mod sketch_canvas;
 mod sketch_constraints;