Document and test side-based footprint shape correction

Renames the per-side 2D mirror helper used by `cuttingEdgeProfile(using:)`
and `formingEdgeProfile(using:)` from `transformToPlaneLocal` to
`footprintShape`, with a doc comment that explains why three of the six
sides need the correction (minimum-angle plane rotation flips chirality).
Adds a regression test that cuts an asymmetric profile on all six sides.

Author: tomasf

Sources/Cadova/Values/Corners, Edges and Sides/DirectionalAxis.swift

@@ -92,6 +92,33 @@ public extension DirectionalAxis where D == D3 {
     static let top = maxZ
 }
 
+internal extension DirectionalAxis where D == D3 {
+    /// Returns a user-drawn 2D shape mirrored as needed so that it aligns with the
+    /// plane-local frame produced by `Plane(side: self, on:).transform` for this side.
+    ///
+    /// `Plane.transform` is built from `rotation(from: +Z, to: normal)` — the minimum-angle
+    /// rotation. For three of the six sides the resulting plane-local basis has its X or Y
+    /// axis flipped relative to the "looking at the face from outside the body" view that
+    /// users naturally draw in. This helper compensates with a 2D mirror so that the same
+    /// user-drawn shape lands in the same world-space position and orientation regardless
+    /// of which side it's applied to.
+    ///
+    /// Only relevant to side-based overloads that accept a user-provided 2D shape
+    /// (e.g. `cuttingEdgeProfile(_:on:offset:using:)`). Auto-sliced paths go through
+    /// `sliced(along:)`, which already runs through `plane.transform.inverse`, so no
+    /// correction is needed there.
+    func footprintShape(_ shape: any Geometry2D) -> any Geometry2D {
+        switch (axis, axisDirection) {
+        case (.z, .negative), (.x, .positive):
+            shape.scaled(x: -1)
+        case (.y, .positive):
+            shape.scaled(y: -1)
+        default:
+            shape
+        }
+    }
+}
+
 /// Convenience alias for referring to the sides of a 2D rectangle using directional axes.
 public extension Rectangle {
     /// A type representing one of the four orthogonal sides of a 2D rectangle.

Sources/Cadova/Values/Edge Profiles/EdgeProfile+Cutting.swift

@@ -60,7 +60,7 @@ public extension Geometry3D {
     ) -> any Geometry3D {
         measuringBounds { _, selfBounds in
             let plane = Plane(side: side, on: selfBounds, offset: offset * side.axisDirection.factor)
-            cuttingEdgeProfile(edgeProfile, with: shape(), at: plane)
+            cuttingEdgeProfile(edgeProfile, with: side.footprintShape(shape()), at: plane)
         }
     }
 }

Sources/Cadova/Values/Edge Profiles/EdgeProfile+Forming.swift

@@ -60,7 +60,7 @@ public extension Geometry3D {
     ) -> any Geometry3D {
         measuringBounds { _, selfBounds in
             let plane = Plane(side: side, on: selfBounds, offset: offset * side.axisDirection.factor)
-            formingEdgeProfile(edgeProfile, with: shape(), at: plane)
+            formingEdgeProfile(edgeProfile, with: side.footprintShape(shape()), at: plane)
         }
     }
 }

Tests/Tests/3D.swift

@@ -39,6 +39,32 @@ struct Geometry3DTests {
         .expectEquals(goldenFile: "3d/rounded-box")
     }
 
+    @Test func `cuttingEdgeProfile(using:) places asymmetric shape consistently across all six sides`() async throws {
+        // An asymmetric profile (not symmetric in either axis). If the per-side
+        // chirality correction is wrong on any side, the cut on that side would
+        // be mirrored relative to its neighbours, producing a visibly different
+        // combined result.
+        let profile: @Sendable () -> any Geometry2D = {
+            Rectangle([6, 3])
+                .aligned(at: .center)
+                .subtracting {
+                    Rectangle([2, 1.5])
+                        .translated(x: 1, y: 0)
+                }
+        }
+        let edge = EdgeProfile.chamfer(depth: 0.5)
+        let sides: [DirectionalAxis<D3>] = [.top, .bottom, .left, .right, .front, .back]
+
+        let geometry = sides.enumerated().mapUnion { index, side in
+            Box(10)
+                .aligned(at: .center)
+                .cuttingEdgeProfile(edge, on: side, using: profile)
+                .translated(x: Double(index) * 12)
+        }
+
+        try await geometry.expectEquals(goldenFile: "3d/edge-profile-side-orientation")
+    }
+
     @Test func `cylinders support various dimension specifications`() async throws {
         try await Stack(.y, spacing: 1) {
             Cylinder(bottomRadius: 3, topRadius: 6, height: 10)