Engine: geometry.bodies lists each body's named edges

Each edge with its persistent name and length. A reference to an edge name
selects its numbered pieces (`~k`), as a face name selects its `#k` pieces.

Part of #230.

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

crates/engine/src/cmd/geometry.rs

@@ -25,7 +25,7 @@ pub const OPEN: CommandSpec = CommandSpec {
 pub const BODIES: CommandSpec = CommandSpec {
     id: "geometry.bodies",
     label: "Bodies",
-    params: "{} — the open design's bodies: measures and persistent face names (by face index)",
+    params: "{} — the open design's bodies: measures, persistent face names (by face index) and edges (persistent name `<face>|<face>`, `~k` when several separate the same faces, and length)",
     form: Some(&[]),
     kind: CommandKind::Model,
     requires: &[], // No design is an answer too: no bodies.
@@ -126,6 +126,7 @@ fn bodies(s: &mut Session, _: &Value) -> Result<Value> {
     let mut out = Vec::with_capacity(design.bodies.len());
     for b in &design.bodies {
         let m = b.measure()?;
+        let edges: Vec<Value> = b.edges()?.iter().map(|e| json!({"name": e.name, "length": e.length()})).collect();
         out.push(json!({
             "name": b.name,
             "volume": m.volume,
@@ -133,6 +134,7 @@ fn bodies(s: &mut Session, _: &Value) -> Result<Value> {
             "centroid": m.centroid,
             "bbox": [m.bbox_min, m.bbox_max],
             "faces": b.faces().iter().map(|f| json!({"name": f.name, "exact": f.exact})).collect::<Vec<_>>(),
+            "edges": edges,
         }));
     }
     Ok(Value::Array(out))

crates/engine/src/lib.rs

@@ -645,6 +645,10 @@ mod tests {
         assert!((volume - expect).abs() < 1e-3 * expect, "{volume}");
         let faces = bodies[0]["faces"].as_array().unwrap();
         assert_eq!(faces.len(), 8);
+        let edges = bodies[0]["edges"].as_array().unwrap();
+        assert_eq!(edges.len(), 18);
+        // Through the thickness: four box corners, the two hole seams.
+        assert_eq!(edges.iter().filter(|e| (e["length"].as_f64().unwrap() - 10.0).abs() < 1e-6).count(), 6);
 
         let t = s.execute("geometry.tessellate", &json!({"body": "Body1", "tolerance": 0.05})).unwrap();
         let per_face: Vec<u64> = t["faces"].as_array().unwrap().iter().map(|f| f["triangles"].as_u64().unwrap()).collect();
@@ -662,6 +666,8 @@ mod tests {
         let wider = s.execute("geometry.bodies", &json!({})).unwrap();
         assert!(wider[0]["volume"].as_f64().unwrap() > volume);
         assert_eq!(wider[0]["faces"], bodies[0]["faces"]);
+        let names = |b: &Value| b[0]["edges"].as_array().unwrap().iter().map(|e| e["name"].clone()).collect::<Vec<_>>();
+        assert_eq!(names(&wider), names(&bodies));
         assert_eq!(s.journal.len(), 2);
     }
 

crates/mcp/src/tools.rs

@@ -126,7 +126,8 @@ pub fn tool_definitions() -> Vec<Value> {
             "Inspect the model",
             "The model: node and element counts, the unit system and the definitions by kind (model.info); the step \
              table (which boundary conditions and loads each step has, model.activity); the open design's bodies with \
-             their measures and persistent face names (geometry.bodies), which sets name as {body, face}.",
+             their measures, persistent face names (geometry.bodies), which sets name as {body, face}, and persistent \
+             edge names `<face>|<face>` with lengths, which sets name as {body, edge}.",
             obj(json!({}), &[]),
             true,
             false,

crates/model/src/geometry.rs

@@ -140,17 +140,20 @@ impl GeometryRef {
     /// Whether this reference (from a set) selects the tagged entity `tag`: the same body and
     /// kind, and the same name or the name of one of its pieces. A B-rep face the kernel splits
     /// into pieces (a full cylinder is two half-cylinders) carries the face's name with `#0`,
-    /// `#1`, … appended; a reference to the plain name selects all of them.
+    /// `#1`, … appended; a reference to the plain name selects all of them. Edges separating the
+    /// same faces are numbered `~0`, `~1`, … the same way.
     pub fn selects(&self, tag: &GeometryRef) -> bool {
         if self.body != tag.body || self.entity.kind() != tag.entity.kind() {
             return false;
         }
         match (self.entity.name(), tag.entity.name()) {
             (Some(want), Some(have)) => {
+                // A face's pieces are numbered `#k`, an edge's `~k` (edges separating the same faces).
+                let mark = if matches!(self.entity, Entity::Edge(_)) { '~' } else { '#' };
                 have == want
                     || have
                         .strip_prefix(want)
-                        .and_then(|r| r.strip_prefix('#'))
+                        .and_then(|r| r.strip_prefix(mark))
                         .is_some_and(|k| !k.is_empty() && k.bytes().all(|b| b.is_ascii_digit()))
             }
             _ => true,
@@ -354,6 +357,10 @@ mod tests {
         assert!(!r.selects(&GeometryRef::face("Body2", "F2:side").unwrap()));
         assert!(!r.selects(&GeometryRef::new("Body1", Entity::Edge("F2:side".into())).unwrap()));
         assert!(GeometryRef::body("Body1").unwrap().selects(&GeometryRef::body("Body1").unwrap()));
+        let edge = |n: &str| GeometryRef::new("Body1", Entity::Edge(n.into())).unwrap();
+        assert!(edge("A|B").selects(&edge("A|B~1")));
+        assert!(!edge("A|B").selects(&edge("A|B#1")));
+        assert!(!edge("A|B~0").selects(&edge("A|B~1")));
 
         for bad in [
             serde_json::json!({"body": ""}),