Fix modelling regressions and reconcile WIP UI work

crates/doc/src/canvas.rs

@@ -34,6 +34,14 @@ pub struct Canvas {
     pub flip: bool,
     #[serde(default = "yes")]
     pub visible: bool,
+    /// The component it belongs to (its plane is in that component's frame, so it moves with
+    /// the component's occurrence); 0 = the root.
+    #[serde(default, skip_serializing_if = "is_root")]
+    pub component: u64,
+}
+
+fn is_root(c: &u64) -> bool {
+    *c == 0
 }
 
 fn half() -> f64 {
@@ -57,7 +65,7 @@ impl Canvas {
         let f = if self.flip { -1.0 } else { 1.0 };
         [rot(-hw * f, -hh), rot(hw * f, -hh), rot(hw * f, hh), rot(-hw * f, hh)]
     }
-    /// Corners in world coordinates.
+    /// Corners on `plane` (in whatever frame the plane is given).
     pub fn world_corners(&self, plane: &Plane) -> [Vec3; 4] {
         self.corners().map(|p| plane.to_world(p))
     }
@@ -66,6 +74,19 @@ impl Canvas {
     }
 }
 
+impl crate::Document {
+    /// A canvas's plane in the world: resolved in its component's frame, then placed where the
+    /// component's occurrence puts it.
+    pub fn canvas_plane(&self, vals: &std::collections::BTreeMap<String, crate::expr::Value>, c: &Canvas) -> crate::Result<Plane> {
+        let p = self.resolve_plane(vals, &c.plane, 0)?;
+        let m = self.component_transform(c.component);
+        if crate::is_identity(&m) {
+            return Ok(p);
+        }
+        Ok(Plane::new(crate::apply_point(&m, p.origin), crate::apply_vector(&m, p.x), crate::apply_vector(&m, p.y)).unwrap_or(p))
+    }
+}
+
 /// Image kind and pixel size from the file header (PNG or JPEG).
 pub fn image_info(b: &[u8]) -> Option<(&'static str, [u32; 2])> {
     if b.len() > 24 && b.starts_with(b"\x89PNG\r\n\x1a\n") {

crates/doc/src/document.rs

@@ -1115,6 +1115,7 @@ impl FeatureKind {
             FeatureKind::Extrude { extent, .. } => extent.to.iter_mut().chain(extent.from.iter_mut()).collect(),
             FeatureKind::Revolve { to: Some(p), .. } => vec![p],
             FeatureKind::Thread { face, .. } => vec![face],
+            FeatureKind::Boss { position, .. } | FeatureKind::SnapFit { position, .. } | FeatureKind::Rest { position, .. } => vec![position],
             _ => Vec::new(),
         }
     }

crates/doc/src/eval.rs

@@ -471,6 +471,22 @@ fn cache_key(f: &Feature, chain_fp: u64, local: u64, ctx: u64, state: &ModelStat
     h.finish()
 }
 
+/// Where components are placed, for a sketch that sees other components' geometry (on a face,
+/// or with projections): it is resolved in its own component's view of them.
+fn placement_digest(doc: &Document, f: &Feature) -> u64 {
+    let FeatureKind::Sketch { plane, sketch } = &f.kind else { return 0 };
+    if doc.occurrences.is_empty() || (!matches!(plane, PlaneRef::Face { .. }) && sketch.links.is_empty()) {
+        return 0;
+    }
+    let mut h = std::collections::hash_map::DefaultHasher::new();
+    for o in &doc.occurrences {
+        o.id.hash(&mut h);
+        o.transform.iter().flatten().for_each(|x| x.to_bits().hash(&mut h));
+    }
+    serde_json::to_string(&doc.body_offsets).unwrap_or_default().hash(&mut h);
+    h.finish()
+}
+
 fn now() -> web_time::Instant {
     web_time::Instant::now()
 }
@@ -514,7 +530,7 @@ impl Model {
         let ctx = context_digest(doc, &vals);
         for (i, f) in doc.features.iter().enumerate() {
             let rolled_back = i >= marker;
-            let mut fp = fingerprint(prev_fp, f, &vals, rolled_back);
+            let mut fp = fingerprint(prev_fp, f, &vals, rolled_back) ^ placement_digest(doc, f);
             // Sheet metal features also depend on the rules (and the parameters they use).
             if f.kind.is_sheet() {
                 let mut h = std::collections::hash_map::DefaultHasher::new();
@@ -570,7 +586,7 @@ impl Model {
                 continue;
             }
             // The same feature on the same inputs: its earlier result.
-            let key = cache_key(f, fp, fingerprint(0, f, &vals, false), ctx, &state);
+            let key = cache_key(f, fp, fingerprint(0, f, &vals, false) ^ placement_digest(doc, f), ctx, &state);
             if !self.no_cache
                 && let Some(c) = self.cache.lock().ok().and_then(|mut m| m.get(key))
             {
@@ -1405,6 +1421,20 @@ fn feature_tools(vals: &BTreeMap<String, Value>, f: &Feature, st: &ModelState) -
             }
             let mut tools = Vec::new();
             for r in &regions {
+                if *operation == Operation::Join {
+                    let exact = kernel::extrude(&ss.plane, std::slice::from_ref(r), lo + off, hi + off)?;
+                    if exact.iter().all(|tool| {
+                        st.bodies
+                            .iter()
+                            .filter(|b| targets.is_empty() || targets.contains(&b.name))
+                            .any(|b| kernel::can_join_touching_faces(&b.body, tool))
+                    }) {
+                        // Preserve a whole touching face: extending into a chamfer replaces
+                        // the sewable seam with a coincident curved intersection.
+                        tools.extend(exact);
+                        continue;
+                    }
+                }
                 let (l2, h2) = extend_for_coplanar(st, &ss.plane, r, lo + off, hi + off, *operation, targets);
                 let probe = |p: Vec2| (1..4).map(|k| ss.plane.to_world(p) + n * (lo + off + (hi - lo) * k as f64 / 4.0)).collect::<Vec<_>>();
                 let r = grow_profile_for_coplanar(st, r, *operation, targets, &probe);
@@ -2288,17 +2318,25 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
         | FeatureKind::Align { .. }
         | FeatureKind::Remove { .. } => more::eval(doc, vals, f, st),
         FeatureKind::Sketch { plane, sketch } => {
+            let fst = state_in_frame(doc, st, f.component);
             let (plane, face_warning) = match plane {
-                PlaneRef::Face { plane: picked, at, name } => face_plane(st, picked, *at, name.as_deref()),
-                other => (doc.resolve_plane_in(vals, other, 0, Some(st))?, None),
+                PlaneRef::Face { plane: picked, at, name } => face_plane(&fst, picked, *at, name.as_deref()),
+                other => (doc.resolve_plane_in(vals, other, 0, Some(&fst))?, None),
             };
             let mut sk = sketch.clone();
-            let mut warns = crate::project::refresh_links(doc, vals, st, &plane, &mut sk);
+            let mut warns = crate::project::refresh_links(doc, vals, &fst, &plane, &mut sk);
+            drop(fst);
+            sk.refresh_offsets()?;
             if let Some(w) = face_warning {
                 warns.insert(0, w);
             }
             doc.apply_dimension_values(vals, &mut sk)?;
-            let report = solve(&mut sk);
+            let mut report = solve(&mut sk);
+            if !sk.offsets.is_empty() {
+                // Source dimensions may have moved curves during the solve.
+                sk.refresh_offsets()?;
+                report = solve(&mut sk);
+            }
             if !report.ok() {
                 warns.insert(0, format!("the sketch constraints conflict ({})", report.failing.join(", ")));
             }
@@ -2818,6 +2856,52 @@ fn unique_body_name(st: &ModelState, base: &str) -> String {
     (2..).map(|i| format!("{base} ({i})")).find(|n| st.body(n).is_none()).unwrap_or_else(|| base.to_string())
 }
 
+/// The model as a component sees it: bodies and sketches of components placed differently from
+/// it are moved into its frame (through both placements), so a sketch on another component's
+/// face finds the face where it is shown and projects its edges there. The model itself when
+/// every placement agrees (the usual case).
+pub fn state_in_frame<'a>(doc: &Document, st: &'a ModelState, comp: u64) -> std::borrow::Cow<'a, ModelState> {
+    use std::borrow::Cow;
+    if doc.occurrences.is_empty() && doc.body_offsets.is_empty() {
+        return Cow::Borrowed(st);
+    }
+    let Some(inv) = crate::mat_inverse(&doc.component_transform(comp)) else { return Cow::Borrowed(st) };
+    let comp_of_feature = |id: u64| doc.feature(id).map(|f| f.component).unwrap_or(0);
+    let rel = |c: u64, body: Option<&str>| {
+        let m = crate::mat_mul(&inv, &doc.component_transform(c));
+        match body.and_then(|b| doc.body_offsets.get(b)) {
+            Some(o) => crate::mat_mul(&m, o),
+            None => m,
+        }
+    };
+    let body_m: Vec<Mat> = st.bodies.iter().map(|b| rel(doc.body_component(&b.name, b.feature), Some(&b.name))).collect();
+    let sketch_m: Vec<Mat> = st.sketches.iter().map(|s| rel(comp_of_feature(s.feature), None)).collect();
+    if body_m.iter().chain(&sketch_m).all(crate::is_identity) {
+        return Cow::Borrowed(st);
+    }
+    let mut out = st.clone();
+    for (b, m) in out.bodies.iter_mut().zip(&body_m) {
+        if !crate::is_identity(m)
+            && let Ok(t) = kernel::transform_matrix(&b.body, *m)
+        {
+            // Moving a body keeps its faces (and their order): it keeps their names.
+            let names = crate::naming::face_names(b);
+            let mut nb = ModelBody::new(b.name.clone(), t, b.feature);
+            nb.component = b.component;
+            nb.names = crate::naming::NameCell::known(names);
+            *b = nb;
+        }
+    }
+    for (s, m) in out.sketches.iter_mut().zip(&sketch_m) {
+        if !crate::is_identity(m)
+            && let Some(np) = Plane::new(crate::apply_point(m, s.plane.origin), crate::apply_vector(m, s.plane.x), crate::apply_vector(m, s.plane.y))
+        {
+            s.plane = np;
+        }
+    }
+    Cow::Owned(out)
+}
+
 /// The model placed in the world: each component's bodies, sketches and threads through every
 /// occurrence of it (bodies of the first placement keep their names; further instances get the
 /// occurrence path in brackets). Without components this is the model itself.

crates/doc/src/eval_more.rs

@@ -613,7 +613,12 @@ fn face_loops(mesh: &solvecraft_geom::Mesh, plane: &Plane, at: Vec3, n: Vec3, le
 /// The body a placed plastic feature joins: by name, else the one under the point.
 fn body_under(st: &ModelState, body: &Option<String>, p: Vec3) -> Result<String> {
     let i = body_at(st, body, &[p])?;
-    st.bodies.get(i).map(|b| b.name.clone()).ok_or_else(|| DocError::Invalid("there is no body".into()))
+    let b = st.bodies.get(i).ok_or_else(|| DocError::Invalid("there is no body".into()))?;
+    let tolerance = (b.body.size() * 1e-5).max(1e-4);
+    if crate::project::nearest_face(&b.mesh(), p).is_none_or(|(_, _, distance)| distance > tolerance) {
+        return Err(DocError::Invalid("the plastic feature's placement is no longer on its body face".into()));
+    }
+    Ok(b.name.clone())
 }
 
 /// Axes with z along `z` (and x along `x` when given).

crates/doc/src/format.rs

@@ -18,13 +18,15 @@
 //!   ["*"]` (every body), which is what they did, so those designs keep their shape.
 //! - 4: joint origins mate by default (B's z against A's, as Fusion does); `flip` now means
 //!   "don't mate". Older joints keep their placement: their `flip` is inverted.
+//! - 6: XZ origin planes use sketch y = -Z and normal +Y. Older XZ references become
+//!   explicit planes retaining their previous axes, including offset-plane expressions.
 
 use serde_json::Value;
 
 use crate::{DocError, Document, Result};
 
 /// The format this build writes.
-pub const FORMAT: u32 = 5;
+pub const FORMAT: u32 = 6;
 
 pub fn format_string(n: u32) -> String {
     format!("solvecraft/{n}")
@@ -37,7 +39,30 @@ pub fn version_of(s: &str) -> Option<u32> {
 
 /// JSON-level upgrades: entry `i` turns format `i + 1` into `i + 2`.
 type JsonStep = fn(&mut Value) -> Result<()>;
-const JSON_STEPS: [JsonStep; 4] = [|_| Ok(()), v2_to_v3, v3_to_v4, v4_to_v5];
+const JSON_STEPS: [JsonStep; 5] = [|_| Ok(()), v2_to_v3, v3_to_v4, v4_to_v5, v5_to_v6];
+
+/// Old XZ references retain their exact frame, including nested offset and angled planes.
+/// New origin references use +Y; freezing the old frame avoids changing sketch coordinates,
+/// dimensions, profiles, extrude directions or parameter expressions in saved designs.
+fn v5_to_v6(v: &mut Value) -> Result<()> {
+    fn preserve(v: &mut Value) {
+        match v {
+            Value::Object(o) => {
+                let old_xz = o.get("type").and_then(Value::as_str) == Some("origin")
+                    && o.get("name").and_then(Value::as_str).is_some_and(|n| n.eq_ignore_ascii_case("XZ") || n.eq_ignore_ascii_case("FRONT"));
+                if old_xz {
+                    *v = serde_json::json!({"type": "custom", "plane": {"origin": [0, 0, 0], "x_dir": [1, 0, 0], "y_dir": [0, 0, 1]}});
+                } else {
+                    o.values_mut().for_each(preserve);
+                }
+            }
+            Value::Array(a) => a.iter_mut().for_each(preserve),
+            _ => {}
+        }
+    }
+    preserve(v);
+    Ok(())
+}
 
 /// Features in designs with components keep reaching every body.
 fn v4_to_v5(v: &mut Value) -> Result<()> {
@@ -198,6 +223,32 @@ mod tests {
         assert_eq!(back, d);
     }
 
+    #[test]
+    fn old_xz_and_nested_offsets_keep_their_frame() {
+        let mut doc = Document::new("old XZ");
+        let id = doc
+            .add_feature(
+                crate::FeatureKind::ConstructionPlane {
+                    plane: crate::PlaneRef::Offset { base: Box::new(crate::PlaneRef::Origin { name: "XZ".into() }), distance: "7 mm".into() },
+                },
+                None,
+            )
+            .unwrap();
+        let mut json: Value = serde_json::from_str(&doc.to_json()).unwrap();
+        json["format"] = Value::from("solvecraft/5");
+        let migrated = read(&json.to_string()).unwrap();
+        let crate::FeatureKind::ConstructionPlane { plane } = &migrated.feature(id).unwrap().kind else { panic!("plane") };
+        let (values, errors) = migrated.param_values();
+        assert!(errors.is_empty());
+        let p = migrated.resolve_plane(&values, plane, 0).unwrap();
+        assert_eq!(p.y, solvecraft_geom::Vec3::Z);
+        assert_eq!(p.normal(), -solvecraft_geom::Vec3::Y);
+        assert_eq!(p.origin, solvecraft_geom::Vec3::new(0.0, -7.0, 0.0));
+        assert_eq!(read(&migrated.to_json()).unwrap(), migrated);
+        let fresh = doc.resolve_plane(&values, &crate::PlaneRef::Origin { name: "XZ".into() }, 0).unwrap();
+        assert_eq!(fresh.normal(), solvecraft_geom::Vec3::Y);
+    }
+
     #[test]
     fn older_upgraded_newer_refused_others_rejected() {
         let mut v: Value = serde_json::from_str(&Document::new("A").to_json()).unwrap();

crates/doc/src/lib.rs

@@ -29,7 +29,7 @@ pub use assembly::{IDENTITY, Mat, Occurrence, apply_point, apply_vector, is_iden
 pub use document::*;
 pub use eval::{
     EdgeRef, FeatureResult, Model, ModelBody, ModelState, SolvedSketch, ThreadInfo, edge_names_for, edge_refs, parse_metric_thread, pattern_matrices,
-    world_state,
+    state_in_frame, world_state,
 };
 pub use params::{ParamRow, ParamUser, cycles};
 pub use solvecraft_kernel as kernel;

crates/doc/src/naming.rs

@@ -34,6 +34,12 @@ impl NameCell {
     pub fn new(origin: Option<Arc<NamingOrigin>>) -> Self {
         NameCell { origin, names: Arc::new(OnceLock::new()) }
     }
+    /// Names already known (a moved copy of a body keeps its faces' names).
+    pub fn known(names: Arc<Vec<String>>) -> Self {
+        let cell = OnceLock::new();
+        let _ = cell.set(names);
+        NameCell { origin: None, names: Arc::new(cell) }
+    }
 }
 
 /// Deeper chains than this are named by position only (bounded work and stack).

crates/doc/src/project.rs

@@ -273,7 +273,20 @@ pub fn refresh_links(doc: &Document, vals: &BTreeMap<String, Value>, st: &ModelS
     let mut warn = Vec::new();
     let links = sk.links.clone();
     for l in &links {
-        match resolve(doc, vals, st, plane, l.kind, &l.source) {
+        let mut source = l.source.clone();
+        if let (Some(name), LinkSource::Face { at, .. }) = (&l.face_name, &mut source) {
+            if let Some((p, split)) = crate::naming::point_on_face(st, name, *at) {
+                *at = p;
+                if split {
+                    warn.push(format!("projected face `{name}` was split; using the nearest piece"));
+                }
+            } else {
+                sk.set_link_lost(&l.id, true);
+                warn.push(format!("projected face `{name}` no longer exists"));
+                continue;
+            }
+        }
+        match resolve(doc, vals, st, plane, l.kind, &source) {
             Ok(r) => {
                 sk.set_link_source(&l.id, r.source);
                 let _ = sk.set_link_wires(&l.id, &r.wires);