Rib and Web (to the next face or a depth, flip), Emboss/deboss on planar faces (EmbossCmd), Replace Face onto a parallel plane or face, Align (point to point, face to face), Remove (SoftDeleteCommand), timeline Copy/Paste of features (independent copies: own dimension parameters and input names, references remapped, optional translation)

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01AS5Tn3xieewUSg3uxrMVdL

crates/engine/src/cmd/clipboard.rs

@@ -0,0 +1,156 @@
+//! Copy and paste of timeline features. Pasted features are independent copies: sketches get
+//! their own dimension parameters, feature inputs their own names, and references inside the
+//! copied set point at the copies.
+
+use std::collections::BTreeMap;
+
+use serde_json::{Value, json};
+use solvecraft_doc::{FeatureKind, PlaneRef};
+
+use super::CommandSpec;
+use crate::params::{bad, string_list, vec3};
+use crate::{Result, Session};
+
+pub static COMMANDS: &[CommandSpec] = &[
+    CommandSpec::new("timeline.copy", "Copy Features", copy).noundo().params("features: [ids or names] (in timeline order on paste)"),
+    CommandSpec::new("timeline.paste", "Paste Features", paste)
+        .params("translate?: [x,y,z] (moves the copies' geometry); the copies go at the marker"),
+];
+
+fn copy(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "timeline.copy";
+    let mut keys = string_list(p, "features");
+    if let Some(Value::Array(a)) = p.get("features") {
+        keys.extend(a.iter().filter_map(Value::as_u64).map(|n| n.to_string()));
+    }
+    if keys.is_empty() || keys.len() > 1000 {
+        return Err(bad(cmd, "`features` must list 1…1000 features"));
+    }
+    let mut ids = Vec::new();
+    for k in &keys {
+        ids.push(s.doc.find_feature(k).map(|f| f.id).ok_or_else(|| bad(cmd, format!("no feature `{k}`")))?);
+    }
+    // Keep timeline order so sketches come before the features that use them.
+    let copied: Vec<solvecraft_doc::Feature> = s.doc.features.iter().filter(|f| ids.contains(&f.id)).cloned().collect();
+    let names: Vec<String> = copied.iter().map(|f| f.name.clone()).collect();
+    s.clipboard = copied;
+    Ok(json!({"copied": names}))
+}
+
+/// Origin planes become explicit planes so a translation can move them.
+fn explicit_planes(p: &mut PlaneRef) {
+    match p {
+        PlaneRef::Origin { name } => {
+            if let Some(plane) = solvecraft_geom::Plane::named(name) {
+                *p = PlaneRef::Custom { plane };
+            }
+        }
+        PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => explicit_planes(base),
+        _ => {}
+    }
+}
+
+fn paste(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "timeline.paste";
+    if s.clipboard.is_empty() {
+        return Err(bad(cmd, "nothing copied (timeline.copy first)"));
+    }
+    let translate = match p.get("translate") {
+        Some(v) => Some(vec3(v).ok_or_else(|| bad(cmd, "`translate` must be [x, y, z]"))?),
+        None => None,
+    };
+    let feats = s.clipboard.clone();
+    let comp = s.active_component;
+    let mut sketches: BTreeMap<u64, u64> = BTreeMap::new();
+    let mut names: BTreeMap<String, String> = BTreeMap::new();
+    let mut made = Vec::new();
+    for f in feats {
+        let mut kind = f.kind.clone();
+        kind.remap_refs(&sketches, &names);
+        let doc = s.doc_mut();
+        if let FeatureKind::Sketch { sketch, .. } = &mut kind {
+            // Each dimension of the copy gets its own parameter, with the same expression.
+            for c in &mut sketch.constraints {
+                if let Some(pn) = c.param.clone() {
+                    let (e, u) = doc.param(&pn).map(|x| (x.expr.clone(), x.unit.clone())).unwrap_or_else(|| (pn.clone(), "mm".into()));
+                    c.param = Some(doc.new_model_param(&e, &u));
+                }
+            }
+        }
+        if let Some(t) = translate {
+            if let FeatureKind::Sketch { plane, .. } | FeatureKind::ConstructionPlane { plane } = &mut kind {
+                explicit_planes(plane);
+            }
+            let mut m = solvecraft_doc::IDENTITY;
+            m[3][0] = t.x;
+            m[3][1] = t.y;
+            m[3][2] = t.z;
+            kind.transform_geometry(&m);
+        }
+        let id = doc.add_feature(kind, None)?;
+        if let Some(nf) = doc.feature_mut(id) {
+            nf.component = comp;
+            nf.body_names = f.body_names.iter().map(|b| format!("{b} (copy)")).collect();
+        }
+        let new_name = doc.feature(id).map(|x| x.name.clone()).unwrap_or_default();
+        if matches!(f.kind, FeatureKind::Sketch { .. }) {
+            sketches.insert(f.id, id);
+        }
+        names.insert(f.name.clone(), new_name.clone());
+        made.push(json!({"id": id, "name": new_name, "from": f.name}));
+    }
+    s.refresh();
+    let errors: Vec<Value> = made
+        .iter()
+        .filter_map(|m| m["id"].as_u64())
+        .filter_map(|id| s.model.result(id).and_then(|r| r.error.clone()).map(|e| json!({"feature": id, "error": e})))
+        .collect();
+    Ok(json!({"pasted": made, "errors": errors}))
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use crate::Session;
+
+    fn run(s: &mut Session, id: &str, p: serde_json::Value) -> serde_json::Value {
+        match s.execute(id, &p) {
+            Ok(v) => v,
+            Err(e) => panic!("{id} {p}: {e}"),
+        }
+    }
+
+    fn volume(s: &mut Session) -> f64 {
+        run(s, "MeasureCommand", json!({}))["total"]["volume_mm3"].as_f64().unwrap_or(f64::NAN)
+    }
+
+    #[test]
+    fn copy_paste_sketch_and_extrude() {
+        let mut s = Session::default();
+        run(&mut s, "ChangeParameterCommand", json!({"name": "w", "expression": "10 mm"}));
+        run(&mut s, "SketchCreate", json!({"plane": "XY", "name": "S"}));
+        run(&mut s, "ShapeRectangleTwoPoint", json!({"p0": [0, 0], "p1": [10, 10]}));
+        run(&mut s, "ConstraintCoincident", json!({"a": "p1", "b": "origin"}));
+        run(&mut s, "SketchDimension", json!({"entities": ["l1"], "value": "w"}));
+        run(&mut s, "SketchDimension", json!({"entities": ["l2"], "value": 10}));
+        run(&mut s, "SketchStop", json!({}));
+        run(&mut s, "Extrude", json!({"sketch": "S", "distance": 5}));
+        assert!((volume(&mut s) - 500.0).abs() < 1e-6);
+        run(&mut s, "timeline.copy", json!({"features": ["S", "Extrude1"]}));
+        let r = run(&mut s, "timeline.paste", json!({"translate": [30, 0, 0]}));
+        assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");
+        assert_eq!(run(&mut s, "MeasureCommand", json!({}))["body_count"], 2);
+        assert!((volume(&mut s) - 1000.0).abs() < 1e-6);
+        // The copy's dimensions are its own, still driven by the user parameter.
+        run(&mut s, "ChangeParameterCommand", json!({"name": "w", "expression": "20 mm"}));
+        assert!((volume(&mut s) - 2000.0).abs() < 1e-6);
+        let pasted_extrude = r["pasted"][1]["name"].as_str().unwrap_or_default().to_string();
+        let d = s.doc.find_feature(&pasted_extrude).and_then(|f| f.param_names.first().cloned()).unwrap_or_default();
+        run(&mut s, "ChangeParameterCommand", json!({"name": d, "expression": "10"}));
+        assert!((volume(&mut s) - 3000.0).abs() < 1e-6, "only the copy got thicker");
+        assert!(s.execute("timeline.paste", &json!({"translate": "x"})).is_err());
+        let mut t = Session::default();
+        assert!(t.execute("timeline.paste", &json!({})).is_err());
+    }
+}

crates/engine/src/cmd/features.rs

@@ -154,7 +154,7 @@ pub fn auto_operation(s: &Session, p: &Value) -> Option<&'static str> {
     }
 }
 
-fn operation(p: &Value, cmd: &str) -> Result<Operation> {
+pub(super) fn operation(p: &Value, cmd: &str) -> Result<Operation> {
     match str_(p, "operation") {
         None => Ok(Operation::NewBody),
         Some(o) => Operation::parse(o).ok_or_else(|| bad(cmd, format!("unknown operation `{o}` (new, join, cut, intersect)"))),
@@ -162,7 +162,7 @@ fn operation(p: &Value, cmd: &str) -> Result<Operation> {
 }
 
 /// The sketch a feature uses: `sketch` param, the active sketch, or the last sketch.
-fn feature_sketch(s: &Session, p: &Value, cmd: &str) -> Result<u64> {
+pub(super) fn feature_sketch(s: &Session, p: &Value, cmd: &str) -> Result<u64> {
     if let Some(v) = p.get("sketch") {
         let key = match v {
             Value::Number(n) => n.to_string(),
@@ -189,7 +189,7 @@ fn feature_sketch(s: &Session, p: &Value, cmd: &str) -> Result<u64> {
         .ok_or_else(|| bad(cmd, "there is no sketch to use (create one first)"))
 }
 
-fn profiles(p: &Value, cmd: &str) -> Result<ProfileSel> {
+pub(super) fn profiles(p: &Value, cmd: &str) -> Result<ProfileSel> {
     let Some(v) = p.get("profiles") else { return Ok(ProfileSel::All) };
     match v {
         Value::String(s) if s.eq_ignore_ascii_case("all") => Ok(ProfileSel::All),
@@ -233,12 +233,12 @@ fn profiles(p: &Value, cmd: &str) -> Result<ProfileSel> {
     }
 }
 
-fn check_expr(s: &Session, e: &str, kind: Kind, cmd: &str, what: &str) -> Result<()> {
+pub(super) fn check_expr(s: &Session, e: &str, kind: Kind, cmd: &str, what: &str) -> Result<()> {
     s.doc.eval(e, kind).map(|_| ()).map_err(|err| bad(cmd, format!("{what}: {err}")))
 }
 
 /// Add a feature, evaluate, and report its result (an evaluation error fails the command).
-fn add_feature(s: &mut Session, p: &Value, kind: FeatureKind) -> Result<Value> {
+pub(super) fn add_feature(s: &mut Session, p: &Value, kind: FeatureKind) -> Result<Value> {
     let name = str_(p, "name");
     // Commands speak world coordinates; the feature is authored in the active component.
     let mut kind = kind;
@@ -779,7 +779,7 @@ fn draft(s: &mut Session, p: &Value) -> Result<Value> {
     add_feature(s, p, FeatureKind::Draft { faces, angle, neutral, pull, body: str_(p, "body").map(str::to_string) })
 }
 
-fn sketch_id(s: &Session, v: Option<&Value>, cmd: &str, what: &str) -> Result<u64> {
+pub(super) fn sketch_id(s: &Session, v: Option<&Value>, cmd: &str, what: &str) -> Result<u64> {
     let key = match v {
         Some(Value::Number(n)) => n.to_string(),
         Some(Value::String(x)) => x.clone(),

crates/engine/src/cmd/features_more.rs

@@ -0,0 +1,164 @@
+//! Rib, Web, Emboss, Replace Face, Align and Remove.
+
+use serde_json::Value;
+use solvecraft_doc::FeatureKind;
+use solvecraft_doc::expr::Kind;
+use solvecraft_geom::Vec3;
+
+use super::CommandSpec;
+use super::features::{add_feature, check_expr, feature_sketch, plane_param, profiles};
+use crate::params::{bad, bool_, expr, req_expr, str_, string_list, vec3};
+use crate::{Result, Session};
+
+pub static COMMANDS: &[CommandSpec] = &[
+    CommandSpec::new("FusionRibCommand", "Rib", rib)
+        .at("SOLID", "CREATE")
+        .icon("rib")
+        .params("sketch, curves: [open curve ids, in order]; thickness (across the sketch plane); depth? (default: to the next face); flip?: bool (fill to the other side)"),
+    CommandSpec::new("FusionWebCommand", "Web", web)
+        .at("SOLID", "CREATE")
+        .icon("rib")
+        .params("sketch, curves: [open curve ids] (one wall each); thickness; depth? (default: to the next face); flip?: bool"),
+    CommandSpec::new("EmbossCmd", "Emboss", emboss)
+        .at("SOLID", "CREATE")
+        .icon("emboss")
+        .params("sketch (on a planar face), profiles?; depth; mode?: emboss|deboss (default emboss); targets?"),
+    CommandSpec::new("FusionReplaceFaceCommand", "Replace Face", replace_face)
+        .at("SOLID", "MODIFY")
+        .icon("offset_face")
+        .params("faces: [[x,y,z] points on planar faces]; target: plane (XY|XZ|YZ|construction plane|{origin, normal}) | target_face: [x,y,z] on a parallel planar face; body?"),
+    CommandSpec::new("AlignCmd", "Align", align)
+        .at("SOLID", "MODIFY")
+        .icon("move")
+        .params("bodies: [names]; from: [x,y,z] | from_face: [x,y,z]; to: [x,y,z] | to_face: [x,y,z] (faces also turn to meet); flip?: bool"),
+    CommandSpec::new("SoftDeleteCommand", "Remove", remove).at("SOLID", "MODIFY").icon("delete").params("bodies: [names] (removed from here on in the timeline)"),
+];
+
+fn curves_param(p: &Value, cmd: &str) -> Result<Vec<String>> {
+    let c = string_list(p, "curves");
+    if c.is_empty() || c.len() > 1000 {
+        return Err(bad(cmd, "`curves` must list 1…1000 sketch curve ids"));
+    }
+    Ok(c)
+}
+
+fn rib_like(s: &mut Session, p: &Value, cmd: &str, web: bool) -> Result<Value> {
+    let sketch = feature_sketch(s, p, cmd)?;
+    let curves = curves_param(p, cmd)?;
+    {
+        let st = s.model.state();
+        let ss = st.sketch(sketch).ok_or_else(|| bad(cmd, "the sketch is not evaluated"))?;
+        if let Some(c) = curves.iter().find(|c| ss.sketch.curve_index(c).is_none()) {
+            return Err(bad(cmd, format!("no curve `{c}` in the sketch")));
+        }
+    }
+    let thickness = req_expr(cmd, p, "thickness")?;
+    check_expr(s, &thickness, Kind::Length, cmd, "thickness")?;
+    let depth = expr(p, "depth");
+    if let Some(d) = &depth {
+        check_expr(s, d, Kind::Length, cmd, "depth")?;
+    }
+    let flip = bool_(p, "flip").unwrap_or(false);
+    add_feature(s, p, FeatureKind::Rib { sketch, curves, thickness, depth, flip, web })
+}
+
+fn rib(s: &mut Session, p: &Value) -> Result<Value> {
+    rib_like(s, p, "FusionRibCommand", false)
+}
+
+fn web(s: &mut Session, p: &Value) -> Result<Value> {
+    rib_like(s, p, "FusionWebCommand", true)
+}
+
+fn emboss(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "EmbossCmd";
+    let sketch = feature_sketch(s, p, cmd)?;
+    let profiles = profiles(p, cmd)?;
+    let depth = req_expr(cmd, p, "depth")?;
+    check_expr(s, &depth, Kind::Length, cmd, "depth")?;
+    let deboss = match str_(p, "mode").map(str::to_ascii_lowercase).as_deref() {
+        None | Some("emboss") => false,
+        Some("deboss") => true,
+        Some(m) => return Err(bad(cmd, format!("unknown mode `{m}` (emboss or deboss)"))),
+    };
+    if let Some(fp) = p.get("face").and_then(vec3)
+        && super::face::face_normal(s, fp).is_none()
+    {
+        return Err(bad(cmd, "not supported yet: embossing onto a curved face"));
+    }
+    add_feature(s, p, FeatureKind::Emboss { sketch, profiles, depth, deboss, targets: string_list(p, "targets") })
+}
+
+fn face_points(p: &Value, k: &str, cmd: &str) -> Result<Vec<Vec3>> {
+    let a = p.get(k).and_then(Value::as_array).ok_or_else(|| bad(cmd, format!("`{k}` must list points [x, y, z]")))?;
+    if a.is_empty() || a.len() > 1000 {
+        return Err(bad(cmd, format!("`{k}` must list 1…1000 points")));
+    }
+    a.iter().map(|v| vec3(v).ok_or_else(|| bad(cmd, format!("`{k}` must contain [x, y, z] points")))).collect()
+}
+
+fn replace_face(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "FusionReplaceFaceCommand";
+    let faces = face_points(p, "faces", cmd)?;
+    for f in &faces {
+        if super::face::face_normal(s, *f).is_none() {
+            return Err(bad(cmd, "not supported yet: replacing a face that is not planar"));
+        }
+    }
+    let target = match p.get("target_face").and_then(vec3) {
+        Some(tp) => {
+            let n = super::face::face_normal(s, tp).ok_or_else(|| bad(cmd, "the target face must be planar"))?;
+            let plane = solvecraft_geom::Plane::from_normal(tp, n).ok_or_else(|| bad(cmd, "the target face's plane"))?;
+            solvecraft_doc::PlaneRef::Custom { plane }
+        }
+        None => plane_param(s, p.get("target"), cmd)?,
+    };
+    let body = str_(p, "body").map(str::to_string);
+    add_feature(s, p, FeatureKind::ReplaceFace { faces, target, body })
+}
+
+fn align(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "AlignCmd";
+    let bodies = string_list(p, "bodies");
+    if bodies.is_empty() {
+        return Err(bad(cmd, "`bodies` must list the bodies to move"));
+    }
+    {
+        let st = s.model.state();
+        if let Some(b) = bodies.iter().find(|b| st.body(b).is_none()) {
+            return Err(bad(cmd, format!("no body `{b}`")));
+        }
+    }
+    let pick = |s: &Session, pk: &str, fk: &str| -> Result<(Vec3, Option<Vec3>)> {
+        if let Some(fp) = p.get(fk).and_then(vec3) {
+            let n = super::face::face_normal(s, fp).ok_or_else(|| bad(cmd, format!("`{fk}` must be on a planar face")))?;
+            return Ok((fp, Some(n)));
+        }
+        p.get(pk).and_then(vec3).map(|v| (v, None)).ok_or_else(|| bad(cmd, format!("give `{pk}` or `{fk}` as [x, y, z]")))
+    };
+    let (from, from_normal) = pick(s, "from", "from_face")?;
+    let (to, to_normal) = pick(s, "to", "to_face")?;
+    let (from_normal, to_normal) = match (from_normal, to_normal) {
+        (Some(a), Some(b)) => (Some(a), Some(b)),
+        _ => (None, None),
+    };
+    let flip = bool_(p, "flip").unwrap_or(false);
+    add_feature(s, p, FeatureKind::Align { bodies, from, to, from_normal, to_normal, flip })
+}
+
+fn remove(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "SoftDeleteCommand";
+    let bodies = string_list(p, "bodies");
+    if bodies.is_empty() {
+        return Err(bad(cmd, "`bodies` must list bodies"));
+    }
+    let st = s.model.state();
+    if let Some(b) = bodies.iter().find(|b| st.body(b).is_none()) {
+        return Err(bad(cmd, format!("no body `{b}`")));
+    }
+    add_feature(s, p, FeatureKind::Remove { bodies })
+}
+
+#[cfg(test)]
+#[path = "features_more_tests.rs"]
+mod tests;

crates/engine/src/cmd/features_more_tests.rs

@@ -0,0 +1,110 @@
+use serde_json::{Value, json};
+
+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 measure(s: &mut Session) -> Value {
+    run(s, "MeasureCommand", json!({}))
+}
+
+fn volume(s: &mut Session) -> f64 {
+    measure(s)["total"]["volume_mm3"].as_f64().unwrap_or(f64::NAN)
+}
+
+fn rel(a: f64, b: f64) -> f64 {
+    (a - b).abs() / b.abs().max(1e-12)
+}
+
+/// An L bracket: a 40 x 20 x 5 base and a 5 x 20 x 40 wall at x = 0..5.
+fn bracket() -> Session {
+    let mut s = Session::default();
+    run(&mut s, "PrimitiveBox", json!({"length": 40, "width": 20, "height": 5, "corner": [0, 0, 0], "body_name": "L"}));
+    run(&mut s, "PrimitiveBox", json!({"length": 5, "width": 20, "height": 40, "corner": [0, 0, 0], "operation": "join"}));
+    assert!(rel(volume(&mut s), 4000.0 + 3500.0) < 1e-9);
+    // Mid-plane of the bracket (y = 10): sketch x = X, sketch y = Z.
+    run(&mut s, "SketchCreate", json!({"plane": {"origin": [0, 10, 0], "x_dir": [1, 0, 0], "y_dir": [0, 0, 1]}, "name": "RibSketch"}));
+    run(&mut s, "DrawPolyline", json!({"points": [[5, 25], [25, 5]], "ids": ["l1"]}));
+    run(&mut s, "SketchStop", json!({}));
+    s
+}
+
+#[test]
+fn rib_to_the_next_face_fills_the_corner() {
+    let mut s = bracket();
+    run(&mut s, "FusionRibCommand", json!({"sketch": "RibSketch", "curves": ["l1"], "thickness": 4}));
+    // The triangle (5,5)-(5,25)-(25,5) of area 200, 4 thick.
+    assert!(rel(volume(&mut s), 7500.0 + 800.0) < 1e-6, "{}", volume(&mut s));
+    assert_eq!(measure(&mut s)["body_count"], 1);
+    // The thickness is a parameter.
+    let t = s.doc.features.last().and_then(|f| f.param_names.first().cloned()).unwrap_or_default();
+    run(&mut s, "ChangeParameterCommand", json!({"name": t, "expression": "2"}));
+    assert!(rel(volume(&mut s), 7500.0 + 400.0) < 1e-6);
+}
+
+#[test]
+fn rib_with_a_depth_and_web() {
+    let mut s = bracket();
+    run(&mut s, "FusionRibCommand", json!({"sketch": "RibSketch", "curves": ["l1"], "thickness": 4, "depth": 2}));
+    let v = volume(&mut s);
+    assert!(v > 7500.0 + 100.0 && v < 7500.0 + 800.0, "{v}");
+    let mut s = bracket();
+    run(&mut s, "FusionWebCommand", json!({"sketch": "RibSketch", "curves": ["l1"], "thickness": 4}));
+    assert!(rel(volume(&mut s), 8300.0) < 1e-6);
+    // Curves that face no body.
+    let mut s = Session::default();
+    run(&mut s, "PrimitiveBox", json!({"length": 10, "width": 10, "height": 10}));
+    run(&mut s, "SketchCreate", json!({"plane": "XY", "name": "Far"}));
+    run(&mut s, "DrawPolyline", json!({"points": [[50, 50], [60, 60]], "ids": ["l1"]}));
+    run(&mut s, "SketchStop", json!({}));
+    let e = s.execute("FusionRibCommand", &json!({"sketch": "Far", "curves": ["l1"], "thickness": 1}));
+    assert!(e.is_err_and(|e| e.to_string().contains("do not face a body")));
+}
+
+#[test]
+fn emboss_and_deboss_on_a_face() {
+    let mut s = Session::default();
+    run(&mut s, "PrimitiveBox", json!({"length": 40, "width": 30, "height": 10}));
+    run(&mut s, "SketchCreate", json!({"plane": {"face": [20, 15, 10]}, "name": "Logo"}));
+    run(&mut s, "ShapeRectangleTwoPoint", json!({"p0": [5, 5], "p1": [15, 15]}));
+    run(&mut s, "SketchStop", json!({}));
+    run(&mut s, "EmbossCmd", json!({"sketch": "Logo", "depth": 2}));
+    assert!(rel(volume(&mut s), 12000.0 + 200.0) < 1e-6, "{}", volume(&mut s));
+    run(&mut s, "UndoCommand", json!({}));
+    run(&mut s, "EmbossCmd", json!({"sketch": "Logo", "depth": 3, "mode": "deboss"}));
+    assert!(rel(volume(&mut s), 12000.0 - 300.0) < 1e-6);
+    assert!(s.execute("EmbossCmd", &json!({"sketch": "Logo", "depth": 1, "mode": "sideways"})).is_err());
+}
+
+#[test]
+fn replace_face_align_remove() {
+    let mut s = Session::default();
+    run(&mut s, "PrimitiveBox", json!({"length": 10, "width": 10, "height": 10, "body_name": "A"}));
+    run(&mut s, "FusionReplaceFaceCommand", json!({"faces": [[5, 5, 10]], "target": {"origin": [0, 0, 15], "normal": [0, 0, 1]}}));
+    assert!(rel(volume(&mut s), 1500.0) < 1e-6);
+    let e = s.execute("FusionReplaceFaceCommand", &json!({"faces": [[5, 5, 15]], "target": {"origin": [0, 0, 15], "normal": [1, 0, 1]}}));
+    assert!(e.is_err() || s.model.results.last().is_some_and(|r| r.error.as_deref().unwrap_or("").contains("parallel")));
+    let mut s = Session::default();
+    run(&mut s, "PrimitiveBox", json!({"length": 10, "width": 10, "height": 10, "body_name": "A"}));
+    run(&mut s, "PrimitiveBox", json!({"length": 10, "width": 10, "height": 10, "corner": [50, 0, 0], "body_name": "B"}));
+    // B's top face onto A's top face: B turns over and sits on A.
+    run(&mut s, "AlignCmd", json!({"bodies": ["B"], "from_face": [55, 5, 10], "to_face": [5, 5, 10]}));
+    let m = measure(&mut s);
+    let b = m["bodies"].as_array().unwrap().iter().find(|b| b["name"] == "B").unwrap().clone();
+    let (lo, hi) = (b["bbox"]["min"].clone(), b["bbox"]["max"].clone());
+    for (got, want) in [(&lo[0], 0.0), (&lo[2], 10.0), (&hi[0], 10.0), (&hi[2], 20.0)] {
+        assert!((got.as_f64().unwrap_or(f64::NAN) - want).abs() < 1e-6, "{b}");
+    }
+    // Points only: a plain move.
+    run(&mut s, "AlignCmd", json!({"bodies": ["B"], "from": [0, 0, 10], "to": [0, 0, 30]}));
+    let m = measure(&mut s);
+    let b = m["bodies"].as_array().unwrap().iter().find(|b| b["name"] == "B").unwrap().clone();
+    assert!((b["bbox"]["min"][2].as_f64().unwrap_or(0.0) - 30.0).abs() < 1e-6, "{b}");
+    run(&mut s, "SoftDeleteCommand", json!({"bodies": ["B"]}));
+    assert_eq!(measure(&mut s)["body_count"], 1);
+}

crates/engine/src/cmd/mod.rs

@@ -2,10 +2,12 @@
 //! toolbar placement (`tab`, `panel`) follows Fusion's Design workspace so the registry doubles
 //! as the parity metric (`cargo xtask parity`).
 
+mod clipboard;
 mod component;
 mod edit;
 mod face;
 mod features;
+mod features_more;
 pub use features::auto_operation;
 mod file;
 mod inspect;
@@ -120,8 +122,10 @@ pub fn command_specs() -> Vec<&'static CommandSpec> {
     v.extend(sketch_modify::COMMANDS.iter());
     v.extend(sketch_project::COMMANDS.iter());
     v.extend(features::COMMANDS.iter());
+    v.extend(features_more::COMMANDS.iter());
     v.extend(component::COMMANDS.iter());
     v.extend(edit::COMMANDS.iter());
+    v.extend(clipboard::COMMANDS.iter());
     v.extend(parameters::COMMANDS.iter());
     v.extend(file::COMMANDS.iter());
     v.extend(inspect::COMMANDS.iter());

crates/engine/src/lib.rs

@@ -154,6 +154,8 @@ pub struct Session {
     /// Occurrence moves not captured yet (Capture Position keeps them, a recompute drops them).
     pub pending_moves: std::collections::BTreeMap<u64, solvecraft_doc::Mat>,
     world_cache: std::sync::Mutex<Option<(u64, Arc<solvecraft_doc::ModelState>)>>,
+    /// Features copied with `timeline.copy` (pasted by `timeline.paste`).
+    pub clipboard: Vec<solvecraft_doc::Feature>,
 }
 
 const MAX_UNDO: usize = 200;
@@ -185,6 +187,7 @@ impl Session {
             active_component: 0,
             pending_moves: Default::default(),
             world_cache: Default::default(),
+            clipboard: Vec::new(),
         }
     }
 
@@ -310,6 +313,7 @@ impl Session {
             active_component: self.active_component,
             pending_moves: self.pending_moves.clone(),
             world_cache: Default::default(),
+            clipboard: self.clipboard.clone(),
         }
     }