fluidcad 0.0.30 → 0.0.32

package/lib/dist/oc/face-query.js

@@ -178,28 +178,32 @@ export class FaceQuery {
         const ocFace = oc.TopoDS.Face(face);
         const faceAdaptor = new oc.BRepAdaptor_Surface(ocFace, true);
         const type = faceAdaptor.GetType();
-        faceAdaptor.delete();
         if (type !== oc.GeomAbs_SurfaceType.GeomAbs_Cylinder) {
+            faceAdaptor.delete();
+            return false;
+        }
+        const cylinder = faceAdaptor.Cylinder();
+        const radius = cylinder.Radius();
+        cylinder.delete();
+        faceAdaptor.delete();
+        if (diameter !== undefined && Math.abs(radius - diameter / 2) > oc.Precision.Confusion()) {
             return false;
         }
+        // A "cylinder curve" is a partial cylinder: it does not wrap fully around its axis.
+        // A full cylinder has at least one closed circular edge (the rim); a fillet/partial
+        // cylinder does not. Bounding edges may be lines, arcs, ellipses, or B-splines
+        // depending on adjacent geometry (e.g. drafted faces produce ellipse boundaries).
         const edges = Explorer.findShapes(ocFace, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
         for (const edge of edges) {
             const curveAdaptor = new oc.BRepAdaptor_Curve(oc.TopoDS.Edge(edge));
             const curveType = curveAdaptor.GetType();
-            if (curveType === oc.GeomAbs_CurveType.GeomAbs_Circle && !curveAdaptor.IsClosed()) {
-                if (diameter === undefined) {
-                    curveAdaptor.delete();
-                    return true;
-                }
-                const circle = curveAdaptor.Circle();
-                const r = circle.Radius();
-                circle.delete();
-                curveAdaptor.delete();
-                return Math.abs(r - diameter / 2) <= oc.Precision.Confusion();
-            }
+            const isClosedCircle = curveType === oc.GeomAbs_CurveType.GeomAbs_Circle && curveAdaptor.IsClosed();
             curveAdaptor.delete();
+            if (isClosedCircle) {
+                return false;
+            }
         }
-        return false;
+        return true;
     }
     static isTorusFaceRaw(face, majorRadius, minorRadius) {
         const oc = getOC();
@@ -342,8 +346,8 @@ export class FaceQuery {
         let bestFace = null;
         let bestDistance = mode === 'first' ? Infinity : -Infinity;
         for (const face of faces) {
-            const distance = plane.distanceToPoint(face.center());
-            if (distance < tolerance) {
+            const distance = plane.signedDistanceToPoint(face.center());
+            if (distance <= tolerance) {
                 continue;
             }
             if (mode === 'first' ? distance < bestDistance : distance > bestDistance) {

package/lib/dist/oc/ray-intersect.d.ts

@@ -11,6 +11,7 @@ import { SceneObject } from "../common/scene-object.js";
  * `start` (within tolerance) are skipped so a start point already on the
  * target is not picked.
  *
- * Throws if the target produces no usable edge hits.
+ * Returns null when no intersection is found. Callers should throw a
+ * context-appropriate error.
  */
-export declare function findNearestRayIntersection(plane: Plane, start: Point2D, direction: Point2D, target: SceneObject): Point2D;
+export declare function findNearestRayIntersection(plane: Plane, start: Point2D, direction: Point2D, target: SceneObject): Point2D | null;

package/lib/dist/oc/ray-intersect.js

@@ -14,7 +14,8 @@ const ON_TARGET_EPSILON = 1e-7;
  * `start` (within tolerance) are skipped so a start point already on the
  * target is not picked.
  *
- * Throws if the target produces no usable edge hits.
+ * Returns null when no intersection is found. Callers should throw a
+ * context-appropriate error.
  */
 export function findNearestRayIntersection(plane, start, direction, target) {
     const oc = getOC();
@@ -84,8 +85,5 @@ export function findNearestRayIntersection(plane, start, direction, target) {
     }
     probeAdaptor.delete();
     probeEdge.delete();
-    if (!bestHit) {
-        throw new Error("Line does not intersect target geometry");
-    }
     return bestHit;
 }

package/lib/dist/oc/shell-ops.js

@@ -1,6 +1,7 @@
 import { getOC } from "./init.js";
 import { ShapeOps } from "./shape-ops.js";
 import { ShapeFactory } from "../common/shape-factory.js";
+import { ColorTransfer } from "./color-transfer.js";
 export class ShellOps {
     static makeThickSolid(solid, faces, thickness) {
         const oc = getOC();
@@ -17,9 +18,21 @@ export class ShellOps {
             listOfFaces.delete();
             throw new Error("Failed to create thick solid.");
         }
-        const newShape = maker.Shape();
+        // Wrap the maker output so we can transfer colors before disposing it.
+        // The user-painted outer faces are mapped through `Modified()`; new
+        // internal walls have no source and stay uncolored — bleeding is
+        // intentionally skipped so painting the outside doesn't paint the
+        // inside.
+        const preClean = ShapeFactory.fromShape(maker.Shape());
+        ColorTransfer.applyThroughMaker([solid], [preClean], maker);
         maker.delete();
         listOfFaces.delete();
-        return ShapeFactory.fromShape(ShapeOps.cleanShapeRaw(newShape));
+        // Chain colors through the UnifySameDomain cleanup so any merged faces
+        // keep the colors that `applyThroughMaker` just placed.
+        const cleanup = ShapeOps.cleanShapeWithLineage(preClean);
+        ColorTransfer.applyThroughCleanup(preClean, cleanup);
+        const cleaned = cleanup.shape;
+        cleanup.dispose();
+        return cleaned;
     }
 }

package/lib/dist/oc/thin-face-maker.d.ts

@@ -16,8 +16,23 @@ export declare class ThinFaceMaker {
      * For closed wires, WireOps.offsetWire handles negative distances natively.
      * For open wires, negative distances are handled by reversing the wire,
      * offsetting with the absolute value, then reversing back.
+     *
+     * If the wire-only offset throws (e.g. "Offset wire is not closed." on
+     * wires whose corners are GeomAbs_OffsetCurve segments from `offset()` over
+     * a drafted body's filleted bottom), retries with a planar face as the
+     * offset spine — that path supplies an explicit normal which keeps the
+     * algorithm stable on the same input.
      */
     private static doOffset;
+    /**
+     * Merges adjacent edges that share the same underlying curve into a single
+     * edge (e.g. two conic-arc segments at a filleted corner produced by
+     * `offset()` over the section of a drafted body's fillets). Without this,
+     * BRepOffsetAPI_MakeOffset chokes on such split arcs with
+     * "Offset wire is not closed." Falls back to the original wire if the
+     * upgrader produces no usable result.
+     */
+    private static unifyWireEdges;
     /**
      * Offsets an open wire on a given plane, using a planar face as reference
      * so that BRepOffsetAPI_MakeOffset knows the offset direction.

package/lib/dist/oc/thin-face-maker.js

@@ -24,7 +24,13 @@ export class ThinFaceMaker {
         const inwardEdges = [];
         const outwardEdges = [];
         for (const group of groups) {
-            const wire = WireOps.makeWireFromEdges(group);
+            const rawWire = WireOps.makeWireFromEdges(group);
+            // ShapeUpgrade_UnifySameDomain merges adjacent edges that share the
+            // same underlying curve into single edges. Without this,
+            // BRepOffsetAPI_MakeOffset can choke on wires whose corners are split
+            // into multiple same-curve segments (e.g. wires returned by `offset()`
+            // over a drafted body's filleted bottom).
+            const wire = this.unifyWireEdges(rawWire);
             const isClosed = wire.isClosed();
             if (offset2 !== undefined) {
                 const result = this.makeDualOffsetFace(wire, isClosed, plane, offset1, offset2);
@@ -101,17 +107,52 @@ export class ThinFaceMaker {
      * For closed wires, WireOps.offsetWire handles negative distances natively.
      * For open wires, negative distances are handled by reversing the wire,
      * offsetting with the absolute value, then reversing back.
+     *
+     * If the wire-only offset throws (e.g. "Offset wire is not closed." on
+     * wires whose corners are GeomAbs_OffsetCurve segments from `offset()` over
+     * a drafted body's filleted bottom), retries with a planar face as the
+     * offset spine — that path supplies an explicit normal which keeps the
+     * algorithm stable on the same input.
      */
     static doOffset(wire, plane, distance, isClosed) {
-        if (isClosed) {
+        if (!isClosed) {
+            if (distance < 0) {
+                const reversed = WireOps.reverseWire(wire);
+                const offsetResult = this.offsetWireOnPlane(reversed, plane, -distance, true);
+                return WireOps.reverseWire(offsetResult);
+            }
+            return this.offsetWireOnPlane(wire, plane, distance, true);
+        }
+        try {
             return WireOps.offsetWire(wire, distance, false);
         }
-        if (distance < 0) {
-            const reversed = WireOps.reverseWire(wire);
-            const offsetResult = this.offsetWireOnPlane(reversed, plane, -distance, true);
-            return WireOps.reverseWire(offsetResult);
+        catch {
+            return this.offsetWireOnPlane(wire, plane, distance, false);
+        }
+    }
+    /**
+     * Merges adjacent edges that share the same underlying curve into a single
+     * edge (e.g. two conic-arc segments at a filleted corner produced by
+     * `offset()` over the section of a drafted body's fillets). Without this,
+     * BRepOffsetAPI_MakeOffset chokes on such split arcs with
+     * "Offset wire is not closed." Falls back to the original wire if the
+     * upgrader produces no usable result.
+     */
+    static unifyWireEdges(wire) {
+        const oc = getOC();
+        const upgrader = new oc.ShapeUpgrade_UnifySameDomain(wire.getShape(), true, false, true);
+        upgrader.AllowInternalEdges(true);
+        upgrader.Build();
+        const result = upgrader.Shape();
+        upgrader.delete();
+        if (Explorer.isWire(result)) {
+            return Wire.fromTopoDSWire(oc.TopoDS.Wire(result));
+        }
+        const wires = Explorer.findShapes(result, oc.TopAbs_ShapeEnum.TopAbs_WIRE);
+        if (wires.length === 0) {
+            return wire;
         }
-        return this.offsetWireOnPlane(wire, plane, distance, true);
+        return Wire.fromTopoDSWire(oc.TopoDS.Wire(wires[0]));
     }
     /**
      * Offsets an open wire on a given plane, using a planar face as reference

package/lib/dist/oc/wire-ops.d.ts

@@ -2,6 +2,7 @@ import type { TopoDS_Edge, TopoDS_Wire, TopoDS_Face } from "occjs-wrapper";
 import { Vector3d } from "../math/vector3d.js";
 import { Wire } from "../common/wire.js";
 import { Edge } from "../common/edge.js";
+import { Vertex } from "../common/vertex.js";
 import { Plane } from "../math/plane.js";
 export declare class WireOps {
     static isCW(wire: Wire, normal: Vector3d): boolean;
@@ -15,6 +16,19 @@ export declare class WireOps {
     static buildWireRaw(edges: TopoDS_Edge[]): TopoDS_Wire;
     static fixWire(wire: Wire, plane: Plane): Wire;
     static fixWireRaw(wire: TopoDS_Wire, face: TopoDS_Face): TopoDS_Wire;
+    /**
+     * Returns the two chain-end vertices of a connected edge set, or a single
+     * vertex (start === end) for a closed loop. Returns null if branching is
+     * detected (more than two unique endpoints).
+     *
+     * "Chain end" is a vertex that appears in exactly one edge; interior junction
+     * vertices appear in two or more. Vertex equivalence is tolerance-based so
+     * boundary representations with separately-built endpoints still match.
+     */
+    static findChainEndpoints(edges: Edge[]): {
+        start: Vertex;
+        end: Vertex;
+    } | null;
     static groupConnectedEdges(edges: Edge[]): Edge[][];
     private static verticesMatch;
     static offsetWireRaw(wire: TopoDS_Wire, distance: number, isOpen: boolean): TopoDS_Wire;

package/lib/dist/oc/wire-ops.js

@@ -109,6 +109,44 @@ export class WireOps {
         fixer.delete();
         return oc.TopoDS.Wire(fixed);
     }
+    /**
+     * Returns the two chain-end vertices of a connected edge set, or a single
+     * vertex (start === end) for a closed loop. Returns null if branching is
+     * detected (more than two unique endpoints).
+     *
+     * "Chain end" is a vertex that appears in exactly one edge; interior junction
+     * vertices appear in two or more. Vertex equivalence is tolerance-based so
+     * boundary representations with separately-built endpoints still match.
+     */
+    static findChainEndpoints(edges) {
+        if (edges.length === 0) {
+            return null;
+        }
+        const entries = [];
+        const findOrAdd = (vertex) => {
+            for (const entry of entries) {
+                if (WireOps.verticesMatch(entry.vertex, vertex)) {
+                    return entry;
+                }
+            }
+            const created = { vertex, count: 0 };
+            entries.push(created);
+            return created;
+        };
+        for (const edge of edges) {
+            findOrAdd(edge.getFirstVertex()).count++;
+            findOrAdd(edge.getLastVertex()).count++;
+        }
+        const ends = entries.filter(e => e.count === 1);
+        if (ends.length === 0) {
+            const v = edges[0].getFirstVertex();
+            return { start: v, end: v };
+        }
+        if (ends.length === 2) {
+            return { start: ends[0].vertex, end: ends[1].vertex };
+        }
+        return null;
+    }
     static groupConnectedEdges(edges) {
         if (edges.length === 0) {
             return [];

package/lib/dist/rendering/render.js

@@ -5,6 +5,7 @@ import { Sketch } from "../features/2d/sketch.js";
 import { transformMeshes } from "./mesh-transform.js";
 import { ShapeOps } from "../oc/shape-ops.js";
 import { Profiler } from "../common/profiler.js";
+import { describeError } from "../common/describe-error.js";
 export class SceneRenderer {
     meshBuilder = new MeshBuilder();
     render(scene) {
@@ -103,8 +104,8 @@ export class SceneRenderer {
             return { renderedSceneShapes, ownShapeCount: sceneShapes.length };
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error(`Error rendering object ${obj.getUniqueType()}:`, error);
+            const message = describeError(error);
+            console.error(`Error rendering object ${obj.getUniqueType()}:`, message);
             return { renderedSceneShapes, ownShapeCount: renderedSceneShapes.length, prepError: message };
         }
     }
@@ -135,6 +136,7 @@ export class SceneRenderer {
         const start = performance.now();
         const profiler = new Profiler();
         try {
+            object.validate();
             object.build({
                 getSceneObjects: () => scene.getPartScopedObjectsUpTo(object),
                 getActiveSceneObjects: () => scene.getPartScopedActiveObjectsUpTo(object),
@@ -161,8 +163,8 @@ export class SceneRenderer {
             }
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error(`Error building object ${object.getUniqueType()}:`, error);
+            const message = describeError(error);
+            console.error(`Error building object ${object.getUniqueType()}:`, message);
             object.setError(message);
         }
         const totalMs = performance.now() - start;

package/lib/dist/tests/common/describe-error.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/common/describe-error.test.js

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "vitest";
+import { setupOC } from "../setup.js";
+import { describeError } from "../../common/describe-error.js";
+import { getOC } from "../../oc/init.js";
+describe("describeError", () => {
+    setupOC();
+    it("returns Error.message for Error instances", () => {
+        expect(describeError(new Error("boom"))).toBe("boom");
+    });
+    it("falls back to String() for non-numeric, non-Error values", () => {
+        expect(describeError("plain string")).toBe("plain string");
+        expect(describeError(undefined)).toBe("undefined");
+        expect(describeError(null)).toBe("null");
+    });
+    it("decodes a numeric OCC exception pointer to its message string", () => {
+        const oc = getOC();
+        // Trigger a real OCC throw (BRepBuilderAPI_MakeOffset on an unsupported
+        // shape) and capture the numeric pointer.
+        let caught = null;
+        try {
+            const maker = new oc.BRepOffsetAPI_MakeOffset();
+            maker.Perform(1, 0); // no wire added — should throw
+        }
+        catch (e) {
+            caught = e;
+        }
+        // If OCC throws, it comes through as a number; otherwise the test setup
+        // didn't trigger it — skip in that case.
+        if (typeof caught !== 'number') {
+            return;
+        }
+        const decoded = describeError(caught);
+        expect(decoded.startsWith("OCC")).toBe(true);
+        expect(decoded).not.toBe(String(caught));
+    });
+});

package/lib/dist/tests/features/2d/intersect.test.js

@@ -2,7 +2,9 @@ import { describe, it, expect } from "vitest";
 import { setupOC, render } from "../../setup.js";
 import sketch from "../../../core/sketch.js";
 import extrude from "../../../core/extrude.js";
+import shell from "../../../core/shell.js";
 import { intersect, rect } from "../../../core/2d/index.js";
+import { Edge } from "../../../common/edge.js";
 describe("intersect", () => {
     setupOC();
     describe("intersect 3D shape with sketch plane", () => {
@@ -18,5 +20,46 @@ describe("intersect", () => {
             const shapes = s.getShapes();
             expect(shapes.length).toBeGreaterThan(0);
         });
+        it("start() should be at a chain endpoint, not at an interior junction", () => {
+            // Regression: when the section produces multiple edges (one per face),
+            // start/end were taken from an arbitrary "last edge". For a closed loop
+            // or branching chain that left start at an interior junction vertex
+            // instead of a real chain endpoint.
+            sketch("xy", () => {
+                rect(100, 50).centered().radius(8);
+            });
+            const e = extrude(20);
+            const s = shell(-2, e.endFaces());
+            let intersectFeature = null;
+            sketch("right", () => {
+                intersectFeature = intersect(s.internalFaces());
+            });
+            render();
+            // The plane-local start vertex must coincide with one of the section's
+            // edge endpoints. An interior junction would coincide with two edges,
+            // so we additionally assert the count of edges meeting at that point.
+            const start = intersectFeature.getState('start');
+            const end = intersectFeature.getState('end');
+            expect(start).toBeDefined();
+            expect(end).toBeDefined();
+            const edges = intersectFeature.getShapes().filter(s => s instanceof Edge);
+            expect(edges.length).toBeGreaterThan(0);
+            const plane = intersectFeature.getPlane();
+            const TOL_SQ = 1e-8;
+            let matchCount = 0;
+            const startPoint = start.toPoint2D();
+            for (const edge of edges) {
+                const v1 = plane.worldToLocal(edge.getFirstVertex().toPoint());
+                const v2 = plane.worldToLocal(edge.getLastVertex().toPoint());
+                const d1 = (v1.x - startPoint.x) ** 2 + (v1.y - startPoint.y) ** 2;
+                const d2 = (v2.x - startPoint.x) ** 2 + (v2.y - startPoint.y) ** 2;
+                if (d1 < TOL_SQ || d2 < TOL_SQ) {
+                    matchCount++;
+                }
+            }
+            // start must lie on at least one edge endpoint (so it's a real corner,
+            // not a constructed midpoint).
+            expect(matchCount).toBeGreaterThan(0);
+        });
     });
 });

package/lib/dist/tests/features/2d/move.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect } from "vitest";
 import { setupOC, render } from "../../setup.js";
 import sketch from "../../../core/sketch.js";
 import extrude from "../../../core/extrude.js";
-import { move, hMove, vMove, rect, circle } from "../../../core/2d/index.js";
+import { move, hMove, vMove, pMove, hLine, rect, circle } from "../../../core/2d/index.js";
 import { ShapeOps } from "../../../oc/shape-ops.js";
 describe("move functions", () => {
     setupOC();
@@ -57,6 +57,77 @@ describe("move functions", () => {
             expect(bbox.minY).toBeCloseTo(50, 0);
         });
     });
+    describe("hMove to target geometry", () => {
+        it("should move cursor to nearest intersection with a circle", () => {
+            sketch("xy", () => {
+                const c = circle([100, 0], 50).guide();
+                move([0, 0]);
+                hMove(c);
+                rect(10, 10);
+            });
+            const e = extrude(5);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(75, 1);
+            expect(bbox.minY).toBeCloseTo(0, 1);
+        });
+        it("should pick nearest intersection when target is behind start", () => {
+            sketch("xy", () => {
+                const c = circle([-100, 0], 50).guide();
+                move([0, 0]);
+                hMove(c);
+                rect(10, 10);
+            });
+            const e = extrude(5);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(-75, 1);
+            expect(bbox.minY).toBeCloseTo(0, 1);
+        });
+    });
+    describe("vMove to target geometry", () => {
+        it("should move cursor to nearest intersection with a circle above", () => {
+            sketch("xy", () => {
+                const c = circle([0, 100], 50).guide();
+                move([0, 0]);
+                vMove(c);
+                rect(10, 10);
+            });
+            const e = extrude(5);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(0, 1);
+            expect(bbox.minY).toBeCloseTo(75, 1);
+        });
+    });
+    describe("pMove to target geometry", () => {
+        it("should move cursor along angle to nearest intersection", () => {
+            sketch("xy", () => {
+                const h = hLine([-100, 50], 200).guide();
+                move([0, 0]);
+                pMove(h, 90);
+                rect(10, 10);
+            });
+            const e = extrude(5);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(0, 1);
+            expect(bbox.minY).toBeCloseTo(50, 1);
+        });
+        it("should support 45° intersection with a horizontal line", () => {
+            sketch("xy", () => {
+                const h = hLine([-100, 50], 200).guide();
+                move([0, 0]);
+                pMove(h, 45);
+                rect(10, 10);
+            });
+            const e = extrude(5);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(50, 1);
+            expect(bbox.minY).toBeCloseTo(50, 1);
+        });
+    });
     describe("combined moves", () => {
         it("should chain horizontal and vertical moves", () => {
             sketch("xy", () => {

package/lib/dist/tests/features/2d/project-regression.test.js

@@ -6,6 +6,19 @@ import cylinder from "../../../core/cylinder.js";
 import { project, rect, circle } from "../../../core/2d/index.js";
 import { Edge } from "../../../common/edge.js";
 import { EdgeOps } from "../../../oc/edge-ops.js";
+// Asserts no two projected edges share a midpoint within tolerance — a strong
+// signal that overlap-dedup ran and removed coincident projections.
+function assertNoDuplicateEdges(shapes, tol = 1e-5) {
+    const mids = shapes
+        .filter((s) => s instanceof Edge)
+        .map(e => EdgeOps.getEdgeMidPoint(e));
+    for (let i = 0; i < mids.length; i++) {
+        for (let j = i + 1; j < mids.length; j++) {
+            const d = mids[i].distanceTo(mids[j]);
+            expect(d, `edges ${i} and ${j} share a midpoint (distance ${d})`).toBeGreaterThan(tol);
+        }
+    }
+}
 describe("project — regression: all projected edges land on sketch plane", () => {
     setupOC();
     it("projects endFaces of a plain extrude onto z=0 (the sketch plane)", () => {
@@ -26,6 +39,11 @@ describe("project — regression: all projected edges land on sketch plane", ()
                 expect(mid.z).toBeCloseTo(0, 4);
             }
         }
+        // endFaces() returns top + bottom (both rectangles); they project to the
+        // same 4-edge rectangle. Dedup must collapse 8 edges down to 4.
+        const edges = shapes.filter(s => s instanceof Edge);
+        expect(edges.length).toBe(4);
+        assertNoDuplicateEdges(shapes);
     });
     it("projects endFaces of an extrude fused with a cylinder onto z=0", () => {
         // Mirrors the user's scenario: complex shape built by fusing an extrude
@@ -47,6 +65,7 @@ describe("project — regression: all projected edges land on sketch plane", ()
                 expect(mid.z).toBeCloseTo(0, 4);
             }
         }
+        assertNoDuplicateEdges(shapes);
     });
     it("projects sideFaces including a cylindrical one onto z=0", () => {
         sketch("xy", () => {
@@ -65,5 +84,21 @@ describe("project — regression: all projected edges land on sketch plane", ()
                 expect(mid.z).toBeCloseTo(0, 4);
             }
         }
+        assertNoDuplicateEdges(shapes);
+    });
+    it("dedupes when the same source is projected twice", () => {
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        const e = extrude(30);
+        const ef = e.endFaces();
+        const s = sketch("xy", () => {
+            project(ef, ef);
+        });
+        render();
+        // Two endFaces × projected twice = 16 raw edges → 4 unique after dedup.
+        const edges = s.getShapes().filter(x => x instanceof Edge);
+        expect(edges.length).toBe(4);
+        assertNoDuplicateEdges(s.getShapes());
     });
 });

package/lib/dist/tests/features/color-lineage.test.js

@@ -7,6 +7,7 @@ import select from "../../core/select.js";
 import fillet from "../../core/fillet.js";
 import chamfer from "../../core/chamfer.js";
 import fuse from "../../core/fuse.js";
+import shell from "../../core/shell.js";
 import { circle, rect } from "../../core/2d/index.js";
 import { face } from "../../filters/index.js";
 function hasRed(solid) {
@@ -210,4 +211,27 @@ describe("color preservation through operations (Phase 3 lineage)", () => {
         // another input was red.
         expect(result.colorMap).toEqual([]);
     });
+    it("shell preserves colored side faces and does not paint the new internal walls", () => {
+        sketch("xy", () => {
+            rect(100, 50).centered().radius(8);
+        });
+        const e = extrude(20);
+        color("orange", e.sideFaces());
+        const sh = shell(-2, e.endFaces());
+        render();
+        const result = sh.getShapes()[0];
+        expect(result).toBeDefined();
+        // The original side faces of the extrusion were orange. After shell, the
+        // outer side walls should still be orange (history-mapped through
+        // BRepOffsetAPI_MakeThickSolid). Internal walls are new geometry — the
+        // user only colored the outside, so they must NOT be painted.
+        const orangeFaces = result.colorMap.filter(e => e.color === '#ffa500');
+        expect(orangeFaces.length).toBeGreaterThan(0);
+        // None of the shell's internal faces should carry the orange color.
+        const internalFaces = sh.getState('internal-faces') || [];
+        expect(internalFaces.length).toBeGreaterThan(0);
+        for (const f of internalFaces) {
+            expect(result.getColor(f.getShape())).toBeUndefined();
+        }
+    });
 });

package/lib/dist/tests/features/cut.test.js

@@ -78,6 +78,46 @@ describe("cut", () => {
             // Circle edges at top and bottom of the hole
             expect(getEdgesByType(solid, "circle").length).toBeGreaterThanOrEqual(2);
         });
+        it("should apply draft to a through-all cut", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([50, 50]);
+                circle(40);
+            });
+            cut().draft(-5);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            // Drafted through-all cut: hole wall is a cone, not a cylinder
+            expect(getFacesByType(solid, "cone").length).toBeGreaterThanOrEqual(1);
+            expect(getFacesByType(solid, "cylinder")).toHaveLength(0);
+        });
+        it("should apply draft to a through-all cut on a small profile", () => {
+            // Mirrors the user's repro: small radius (1.5) and steep draft (-8°).
+            // With THROUGH_ALL_LENGTH=100000, lateral draft = 100000 * tan(8°) ≈ 14054
+            // would invert a 1.5-radius profile if applied over the full prism length.
+            sketch("xy", () => {
+                rect(7, 5).centered();
+            });
+            const e = extrude(1.5);
+            sketch(e.endFaces(), () => {
+                circle(1.5);
+            });
+            cut().draft(-8);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            // Drafted through-all cut: hole wall is a cone, not a cylinder
+            expect(getFacesByType(solid, "cone").length).toBeGreaterThanOrEqual(1);
+            expect(getFacesByType(solid, "cylinder")).toHaveLength(0);
+        });
     });
     describe("section edges", () => {
         it("should expose section edges", () => {

package/lib/dist/tests/features/cylinder-curve-filter.test.d.ts

@@ -0,0 +1 @@
+export {};