fix(kernel): a small overlap is not taken for bodies apart or inside (#484)

When sample points say two bodies are apart or one is inside the other, the facetings are now checked for surfaces passing through each other; if they do, the boolean is computed instead of shortcut. If it still can't be intersected, the sampled answer is kept as a flagged, unverified result, and Interference lists such pairs as "could not be checked" with the reason. Fixes #442 and #443.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/engine/src/cmd/features_more_tests.rs

@@ -602,3 +602,26 @@ fn cylinder_auto_inference_refuses_ambiguity_curves_and_seam_crossing_atomically
         assert_eq!(exact_cylinder_volume(&s), volume);
     }
 }
+
+/// A cone that takes only a 1 mm chamfer off a cylinder's top edge leaves nearly all of the
+/// cylinder inside it; the intersection is still the chamfered cylinder (#443).
+#[test]
+fn loft_intersect_that_trims_one_edge_changes_the_body() {
+    let mut s = Session::default();
+    run(&mut s, "sketch.create", json!({"plane": "XY"}));
+    run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 35}));
+    run(&mut s, "sketch.finish", json!({}));
+    run(&mut s, "solid.extrude", json!({"distance": 10, "body_name": "Body"}));
+    for (name, offset, radius) in [("A", -1, 45), ("B", 11, 33)] {
+        run(&mut s, "sketch.create", json!({"plane": "XY", "offset": offset, "name": name}));
+        run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": radius}));
+        run(&mut s, "sketch.finish", json!({}));
+    }
+    run(&mut s, "solid.loft", json!({"sections": [{"sketch": "A"}, {"sketch": "B"}], "operation": "intersect"}));
+    // r 35 up to z = 9, then a frustum to r 34 at z = 10.
+    let want = std::f64::consts::PI * (35.0 * 35.0 * 9.0 + (35.0 * 35.0 + 35.0 * 34.0 + 34.0 * 34.0) / 3.0);
+    let got = volume(&mut s);
+    assert!((got - want).abs() < want * 2e-4, "{got} vs {want}");
+    let m = measure(&mut s);
+    assert_eq!(m["bodies"][0]["face_types"]["cone"], 1, "{m}");
+}

crates/engine/src/cmd/joints.rs

@@ -37,7 +37,7 @@ pub static COMMANDS: &[CommandSpec] = &[
     CommandSpec::new("joint.list", "List Joints", list).noundo().params("→ joints (type, occurrences, values, limits), origins, links, degrees of freedom, conflicts"),
     CommandSpec::new("joint.solve", "Solve Joints", solve_cmd).params("re-place the occurrences from the joints → conflicts, errors, dof"),
     CommandSpec::new("inspect.interference", "Interference", interference).at("SOLID", "INSPECT").icon("interference").noundo().params(
-        "bodies?: [names] (default: all, in world placement) → pairs that overlap with the overlap volume, area, bounding box and centre",
+        "bodies?: [names] (default: all, in world placement) → interferences: pairs that overlap with the overlap volume, area, bounding box and centre; unchecked: pairs that could not be checked, with the reason",
     ),
 ];
 
@@ -531,7 +531,7 @@ fn interference(s: &mut Session, p: &Value) -> Result<Value> {
     if bodies.len() > 200 {
         return Err(bad(cmd, "too many bodies (200 at most)"));
     }
-    let mut hits = Vec::new();
+    let (mut hits, mut unchecked) = (Vec::new(), Vec::new());
     for (i, a) in bodies.iter().enumerate() {
         for b in bodies.iter().skip(i + 1) {
             let (ba, bb) = (a.mesh().bounds(), b.mesh().bounds());
@@ -544,14 +544,34 @@ fn interference(s: &mut Session, p: &Value) -> Result<Value> {
             if apart {
                 continue;
             }
-            let Ok(Some(o)) = solidcraft_kernel::boolean(&a.body, &b.body, solidcraft_kernel::BoolOp::Intersect) else { continue };
-            let Ok(m) = solidcraft_kernel::measure(&o) else { continue };
+            // A pair whose shared part can't be worked out is reported, not passed as clear.
+            let (shared, report) =
+                solidcraft_kernel::capture_boolean_diagnostics(|| solidcraft_kernel::boolean(&a.body, &b.body, solidcraft_kernel::BoolOp::Intersect));
+            let mut skip = |reason: String| unchecked.push(json!({"a": a.name, "b": b.name, "reason": reason}));
+            let shared = match shared {
+                Ok(o) => o,
+                Err(e) => {
+                    skip(e.to_string());
+                    continue;
+                }
+            };
+            if let Some(reason) = report.unverified() {
+                skip(reason);
+            }
+            let Some(o) = shared else { continue };
+            let m = match solidcraft_kernel::measure(&o) {
+                Ok(m) => m,
+                Err(e) => {
+                    skip(e.to_string());
+                    continue;
+                }
+            };
             if m.volume > 1e-9 * a.body.size().max(1.0).powi(3) {
                 hits.push(json!({"a": a.name, "b": b.name, "volume_mm3": m.volume, "area_mm2": m.area, "center": m.centroid, "bbox": {"min": m.bbox.min, "max": m.bbox.max}}));
             }
         }
     }
-    Ok(json!({"interferences": hits, "count": hits.len(), "checked": bodies.len()}))
+    Ok(json!({"interferences": hits, "count": hits.len(), "checked": bodies.len(), "unchecked": unchecked}))
 }
 
 #[cfg(test)]

crates/engine/src/cmd/joints_tests.rs

@@ -151,6 +151,57 @@ fn rigid_cycles_solve_and_conflicts_report() {
     assert!(s.execute("joint.create", &json!({"type": "hinge"})).is_err());
 }
 
+/// A 30 x 30 x 3 plate with a through slot whose x = 20 wall carries one rib (0.3 tall, 0.8
+/// wide), and a peg in the slot with 0.15 clearance all round.
+fn ribbed_slot_and_peg(s: &mut Session, peg_x1: f64) {
+    run(s, "sketch.create", json!({"plane": "XY"}));
+    run(s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [30, 30]}));
+    run(s, "sketch.finish", json!({}));
+    run(s, "solid.extrude", json!({"distance": 3, "body_name": "Plate"}));
+    run(s, "sketch.create", json!({"plane": "XY", "offset": -1}));
+    let slot = json!([[10, 5], [20, 5], [20, 14.6], [19.7, 14.6], [19.7, 15.4], [20, 15.4], [20, 25], [10, 25]]);
+    run(s, "sketch.line", json!({"points": slot, "closed": true}));
+    run(s, "sketch.finish", json!({}));
+    run(s, "solid.extrude", json!({"distance": 5, "operation": "cut", "targets": ["Plate"]}));
+    run(s, "sketch.create", json!({"plane": "XY"}));
+    run(s, "sketch.rectangle.two_point", json!({"p0": [10.15, 5.15], "p1": [peg_x1, 24.85]}));
+    run(s, "sketch.finish", json!({}));
+    run(s, "solid.extrude", json!({"distance": 3, "operation": "new", "body_name": "Peg"}));
+}
+
+/// The peg overlaps only the rib: 0.15 x 0.8 x 3 = 0.36 mm³ (#442).
+#[test]
+fn interference_finds_a_peg_overlapping_a_small_rib() {
+    let mut s = Session::default();
+    ribbed_slot_and_peg(&mut s, 19.85);
+    let i = run(&mut s, "inspect.interference", json!({}));
+    assert_eq!(i["count"], 1, "{i}");
+    assert!((i["interferences"][0]["volume_mm3"].as_f64().unwrap_or(0.0) - 0.36).abs() < 1e-6, "{i}");
+    let (lo, hi) = (&i["interferences"][0]["bbox"]["min"], &i["interferences"][0]["bbox"]["max"]);
+    assert!((lo[0].as_f64().unwrap_or(0.0) - 19.7).abs() < 1e-6 && (hi[0].as_f64().unwrap_or(0.0) - 19.85).abs() < 1e-6, "{i}");
+}
+
+/// An arc revolved up to a post ends on the post's wall, where the two bodies can't be
+/// intersected: the pair is listed as unchecked instead of passing as clear.
+#[test]
+fn interference_lists_a_pair_it_could_not_check() {
+    let mut s = Session::default();
+    run(&mut s, "solid.cylinder", json!({"base": [0, 14, -5], "radius": 4, "height": 15, "body_name": "Post"}));
+    run(&mut s, "sketch.create", json!({"name": "Profile", "plane": "XZ"}));
+    run(&mut s, "sketch.rectangle.two_point", json!({"p0": [10, 0], "p1": [15, 5]}));
+    run(&mut s, "sketch.finish", json!({}));
+    run(&mut s, "solid.revolve", json!({"sketch": "Profile", "axis": {"origin": [0, 0, 0], "dir": [0, 0, 1]}, "to": [4, 14, 2], "body_name": "Arc"}));
+    let i = run(&mut s, "inspect.interference", json!({}));
+    assert_eq!(i["count"], 0, "{i}");
+    let unchecked = i["unchecked"].as_array().cloned().unwrap_or_default();
+    assert_eq!(unchecked.len(), 1, "{i}");
+    assert!(unchecked[0]["reason"].as_str().is_some_and(|r| r.starts_with("not verified") && !r.contains("displacement")), "{i}");
+    // Bodies that are clear of each other, or overlap plainly, leave the list empty.
+    let mut s = two_cubes();
+    let i = run(&mut s, "inspect.interference", json!({}));
+    assert_eq!(i["unchecked"].as_array().map(Vec::len), Some(0), "{i}");
+}
+
 #[test]
 fn motion_links_and_interference() {
     let mut s = two_cubes();