Surface bodies: Patch, Stitch, Trim and Thicken

Kernel (surfaces):
- Bodies with an open shell are surface bodies (Body::is_surface).
- patch_region: a planar patch of a sketch region. patch_edges: a planar
  patch filling a closed loop of a body's edges.
- copy_faces: faces copied out as a surface.
- stitch: sew surfaces along coinciding edges, turning faces to agree; the
  result is a solid when it closes.
- trim: cut a surface by a plane or face and keep one side.
- thicken: offset planar and circular-cylindrical faces along their
  normals (one side or symmetric) into a solid. Plane copies slide;
  cylinder copies scale about the axis, exact for NURBS circles. Free
  edges get ruled walls. Faces meeting at a sharp edge are refused.

Doc features Patch, Stitch, Thicken (with operations) and SurfaceTrim;
engine commands FusionSurfacePatchCommand, FusionSurfaceStitchCommand,
FusionSurfaceThickenCommand and FusionSurfaceTrimCommand.

Tests (volumes):
- A 10x10 patch thickened by 2 gives 200, also symmetric.
- Half a cylinder side thickened outward gives half a ring; both halves
  inward give the full ring.
- Six faces of a box stitched back give 6000; an open box with its top
  patched from the edges, stitched, gives 6000.
- Trim keeps 30 or 70 of 100.
- Engine: patch, trim, thicken gives 140.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AS5Tn3xieewUSg3uxrMVdL

crates/doc/src/document.rs

@@ -605,6 +605,44 @@ pub enum FeatureKind {
     Remove {
         bodies: Vec<String>,
     },
+    /// Surface bodies: planar patches filling sketch regions (`profiles` of `sketch`), or a
+    /// closed loop of a body's edges (`edges`: points on them, on `body`).
+    Patch {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        sketch: Option<u64>,
+        #[serde(default = "all_profiles")]
+        profiles: ProfileSel,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        body: Option<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        edges: Vec<Vec3>,
+    },
+    /// Surface bodies sewn along shared edges into the first one (a solid when they close).
+    Stitch {
+        bodies: Vec<String>,
+        #[serde(default = "zero_expr")]
+        tolerance: String,
+    },
+    /// Surface bodies thickened into solids along their normals (by half each way when
+    /// `symmetric`).
+    Thicken {
+        bodies: Vec<String>,
+        thickness: String,
+        #[serde(default)]
+        symmetric: bool,
+        operation: Operation,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        targets: Vec<String>,
+    },
+    /// A surface body trimmed by a plane, or by a face of a body (`tool`), keeping the side of
+    /// `keep`.
+    SurfaceTrim {
+        body: String,
+        plane: PlaneRef,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        tool: Option<FaceAt>,
+        keep: Vec3,
+    },
     Move {
         bodies: Vec<String>,
         translate: [String; 3],
@@ -845,6 +883,10 @@ impl FeatureKind {
             FeatureKind::ReplaceFace { .. } => "ReplaceFaceFeature",
             FeatureKind::Align { .. } => "AlignFeature",
             FeatureKind::Remove { .. } => "RemoveFeature",
+            FeatureKind::Patch { .. } => "PatchFeature",
+            FeatureKind::Stitch { .. } => "StitchFeature",
+            FeatureKind::Thicken { .. } => "ThickenFeature",
+            FeatureKind::SurfaceTrim { .. } => "TrimFeature",
             FeatureKind::Import { .. } => "BaseFeature",
             FeatureKind::MeshImport { .. } => "MeshFeature",
         }
@@ -899,6 +941,10 @@ impl FeatureKind {
             FeatureKind::ReplaceFace { .. } => "ReplaceFace",
             FeatureKind::Align { .. } => "Align",
             FeatureKind::Remove { .. } => "Remove",
+            FeatureKind::Patch { .. } => "Patch",
+            FeatureKind::Stitch { .. } => "Stitch",
+            FeatureKind::Thicken { .. } => "Thicken",
+            FeatureKind::SurfaceTrim { .. } => "Trim",
             FeatureKind::Import { .. } => "Import",
             FeatureKind::MeshImport { .. } => "Mesh",
         }
@@ -1037,6 +1083,10 @@ impl FeatureKind {
             }
             FeatureKind::ReplaceFace { target, .. } => plane_exprs(target, &mut v),
             FeatureKind::Align { .. } | FeatureKind::Remove { .. } => {}
+            FeatureKind::Stitch { tolerance, .. } => v.push(tolerance),
+            FeatureKind::Thicken { thickness, .. } => v.push(thickness),
+            FeatureKind::SurfaceTrim { plane, .. } => plane_exprs(plane, &mut v),
+            FeatureKind::Patch { .. } => {}
             FeatureKind::Import { .. } | FeatureKind::MeshImport { .. } => {}
         }
         v
@@ -1080,6 +1130,10 @@ fn inside_str() -> String {
     "inside".into()
 }
 
+fn all_profiles() -> ProfileSel {
+    ProfileSel::All
+}
+
 fn zero_expr() -> String {
     "0".into()
 }