Add modifyingBodyAndParts to apply an operation to body and parts

Lets a single closure modify the main geometry and each matching
part in one call, avoiding having to repeat the operation across
both. Defaults to the .solid semantic filter, mirroring
modifyingParts.

Author: tomasf

Sources/Cadova/Abstract Layer/Geometry/Parts/PartModification.swift

@@ -72,6 +72,28 @@ public extension Geometry {
         PartModifier(body: self, predicate: { $0.semantic == type }, modifier: reader)
     }
 
+    /// Applies a transformation to the main geometry and to each part of the specified semantic.
+    ///
+    /// This method runs the `reader` closure on the receiver's body geometry and on each part in the
+    /// catalog whose semantic matches `type`. Use it to apply the same modification - such as a
+    /// boolean operation, recoloring, or wrapping - to both the body and matching parts in a single
+    /// pass, without writing the closure twice.
+    ///
+    /// - Parameters:
+    ///   - type: The semantic of parts to modify. Defaults to `.solid`.
+    ///   - reader: A closure that receives 3D geometry (either the body or a part's combined geometry)
+    ///     and returns new geometry to replace it.
+    /// - Returns: A geometry with the closure applied to the body and to each matching part.
+    ///
+    func modifyingBodyAndParts(
+        ofType type: PartSemantic = .solid,
+        @GeometryBuilder<D3> reader: @Sendable @escaping (_ geometry: any Geometry3D) -> any Geometry3D
+    ) -> D3.Geometry where D == D3 {
+        reader(self).modifyingParts(ofType: type) { partGeometry, _ in
+            reader(partGeometry)
+        }
+    }
+
     /// Removes the specified part from the part catalog.
     ///
     /// This does not alter the base geometry of the receiver; it only removes the matching entry

Tests/Tests/Parts.swift

@@ -247,6 +247,36 @@ struct PartTests {
         #expect(try await geometry.measurements.volume ≈ 1016)
     }
 
+    @Test func `modifyingBodyAndParts applies operation to body and matching parts`() async throws {
+        let boxPart = Part("box")
+        let visualPart = Part("visual", semantic: .visual)
+
+        let geometry = Box(10)
+            .adding {
+                Box(4)
+                    .translated(x: 12)
+                    .inPart(boxPart)
+                Box(4)
+                    .translated(x: 20)
+                    .inPart(visualPart)
+            }
+            .modifyingBodyAndParts {
+                $0.subtracting {
+                    Box(x: 100, y: 1, z: 1)
+                        .translated(x: -10, y: 1, z: 1)
+                }
+            }
+
+        // Slab carves 10 from Box(10) and 4 from the solid Box(4) at x=12. The .visual part is
+        // skipped because the default semantic filter is .solid, leaving it at its full volume of 64.
+        #expect(try await geometry.partNames.sorted() == ["box", "visual"])
+        #expect(try await geometry.mainModelMeasurements.volume ≈ 990) // 1000 - 10
+        // body (990) + solid part (64 - 4 = 60), all disjoint; visual excluded by .solidParts scope
+        #expect(try await geometry.measurements.volume ≈ 1050)
+        // body (990) + solid part (60) + untouched visual part (64) = 1114
+        #expect(try await geometry.measurements(for: .allParts).volume ≈ 1114)
+    }
+
     @Test func `removingParts removes all parts of semantic`() async throws {
         let box1Part = Part("box1")
         let box2Part = Part("box2")