fluidcad 0.0.36 → 0.0.37

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

@@ -0,0 +1,295 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import helix from "../../core/helix.js";
+import sweep from "../../core/sweep.js";
+import cylinder from "../../core/cylinder.js";
+import select from "../../core/select.js";
+import { face } from "../../filters/index.js";
+import { circle, hLine } from "../../core/2d/index.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+import { Edge } from "../../common/edge.js";
+import { getOC } from "../../oc/init.js";
+// Bounding boxes are computed from the triangulated mesh of the helix edge,
+// so they're slightly larger than the analytic extents (~0.2 mm typical).
+const MESH_TOL = 0.5;
+describe("helix", () => {
+    setupOC();
+    describe("axis input", () => {
+        it("should create a helix wire with default radius and height", () => {
+            const h = helix("z").pitch(5).turns(4);
+            render();
+            const shapes = h.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0]).toBeInstanceOf(Edge);
+        });
+        it("should produce a helix whose axial extent equals pitch * turns", () => {
+            const h = helix("z").pitch(5).turns(4);
+            render();
+            const bbox = ShapeOps.getBoundingBox(h.getShapes()[0]);
+            expect(bbox.maxZ - bbox.minZ).toBeGreaterThanOrEqual(20 - MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeLessThanOrEqual(20 + MESH_TOL);
+        });
+        it("should use the provided .radius() for cylindrical helix", () => {
+            const h = helix("z").radius(15).pitch(5).turns(4);
+            render();
+            const bbox = ShapeOps.getBoundingBox(h.getShapes()[0]);
+            expect(bbox.maxX - bbox.minX).toBeGreaterThanOrEqual(30 - MESH_TOL);
+            expect(bbox.maxX - bbox.minX).toBeLessThanOrEqual(30 + MESH_TOL);
+            expect(bbox.maxY - bbox.minY).toBeGreaterThanOrEqual(30 - MESH_TOL);
+            expect(bbox.maxY - bbox.minY).toBeLessThanOrEqual(30 + MESH_TOL);
+        });
+        it("should default radius to 20 when not specified", () => {
+            const h = helix("z").pitch(5).turns(4);
+            render();
+            const bbox = ShapeOps.getBoundingBox(h.getShapes()[0]);
+            expect(bbox.maxX - bbox.minX).toBeGreaterThanOrEqual(40 - MESH_TOL);
+            expect(bbox.maxX - bbox.minX).toBeLessThanOrEqual(40 + MESH_TOL);
+        });
+        it("should default height to 50 when only turns is given", () => {
+            const h = helix("z").turns(4);
+            render();
+            const bbox = ShapeOps.getBoundingBox(h.getShapes()[0]);
+            expect(bbox.maxZ - bbox.minZ).toBeGreaterThanOrEqual(50 - MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeLessThanOrEqual(50 + MESH_TOL);
+        });
+        it("should respect explicit .height() over pitch * turns", () => {
+            const h = helix("z").pitch(5).turns(4).height(30);
+            render();
+            const bbox = ShapeOps.getBoundingBox(h.getShapes()[0]);
+            expect(bbox.maxZ - bbox.minZ).toBeGreaterThanOrEqual(30 - MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeLessThanOrEqual(30 + MESH_TOL);
+        });
+        it("should produce a conical helix when endRadius differs from radius", () => {
+            const h = helix("z").radius(20).endRadius(10).turns(4).height(30);
+            render();
+            const bbox = ShapeOps.getBoundingBox(h.getShapes()[0]);
+            // The helix curve is bounded by the cone's start radius (20) at the base;
+            // its diameter is at most 40 and strictly greater than the end diameter (20).
+            const diameterX = bbox.maxX - bbox.minX;
+            expect(diameterX).toBeGreaterThan(20);
+            expect(diameterX).toBeLessThanOrEqual(40 + MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeGreaterThanOrEqual(30 - MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeLessThanOrEqual(30 + MESH_TOL);
+        });
+    });
+    describe("tapered approximation (regression)", () => {
+        // A many-turn TAPERED helix must follow its cone profile along its WHOLE
+        // length, not just within its bounding box. The earlier implementation used
+        // HelixGeom_Tools.ApprHelix, whose hardcoded 150-segment budget saturates for
+        // ~10+ turn tapers: the single B-spline fit oscillated wildly over the final
+        // turns (radius collapsing toward the axis) while still reporting success — a
+        // bbox check can't see an inward excursion. Sample the curve and assert the
+        // radius tracks the ideal cone r(z) = startR + (endR - startR) * z / height.
+        it("should track the cone profile over the full length of a 10-turn taper", () => {
+            const startR = 15;
+            const endR = 25;
+            const height = 100;
+            const h = helix("z").radius(startR).endRadius(endR).height(height).pitch(10); // 10 turns
+            render();
+            expect(h.getError()).toBeFalsy();
+            const oc = getOC();
+            const edge = h.getShapes()[0];
+            const adaptor = new oc.BRepAdaptor_Curve(edge.getShape());
+            const first = adaptor.FirstParameter();
+            const last = adaptor.LastParameter();
+            let maxDev = 0;
+            let maxDevZ = 0;
+            const samples = 400;
+            for (let k = 0; k <= samples; k++) {
+                const t = first + (last - first) * (k / samples);
+                const p = adaptor.Value(t);
+                const radius = Math.hypot(p.X(), p.Y());
+                const ideal = startR + (endR - startR) * (p.Z() / height);
+                const dev = Math.abs(radius - ideal);
+                if (dev > maxDev) {
+                    maxDev = dev;
+                    maxDevZ = p.Z();
+                }
+                p.delete();
+            }
+            adaptor.delete();
+            // The fit holds to its 1e-4 mm tolerance; 0.1 mm is a generous bound that
+            // still fails hard on the old saturated fit (which deviated by ~24 mm).
+            expect(maxDev, `max radial deviation ${maxDev.toFixed(3)} mm at z=${maxDevZ.toFixed(1)}`).toBeLessThan(0.1);
+        });
+    });
+    describe("offsets", () => {
+        it("should extend the helix axially by .endOffset()", () => {
+            const base = helix("z").pitch(5).turns(4);
+            render();
+            const baseHeight = ShapeOps.getBoundingBox(base.getShapes()[0]).maxZ
+                - ShapeOps.getBoundingBox(base.getShapes()[0]).minZ;
+            const extended = helix("z").pitch(5).turns(4).endOffset(10);
+            render();
+            const extendedHeight = ShapeOps.getBoundingBox(extended.getShapes()[0]).maxZ
+                - ShapeOps.getBoundingBox(extended.getShapes()[0]).minZ;
+            expect(extendedHeight - baseHeight).toBeGreaterThanOrEqual(10 - MESH_TOL);
+            expect(extendedHeight - baseHeight).toBeLessThanOrEqual(10 + MESH_TOL);
+        });
+        it("should trim the helix start by positive .startOffset()", () => {
+            const base = helix("z").pitch(5).turns(4);
+            render();
+            const baseHeight = ShapeOps.getBoundingBox(base.getShapes()[0]).maxZ
+                - ShapeOps.getBoundingBox(base.getShapes()[0]).minZ;
+            const trimmed = helix("z").pitch(5).turns(4).startOffset(5);
+            render();
+            const trimmedHeight = ShapeOps.getBoundingBox(trimmed.getShapes()[0]).maxZ
+                - ShapeOps.getBoundingBox(trimmed.getShapes()[0]).minZ;
+            expect(baseHeight - trimmedHeight).toBeGreaterThanOrEqual(5 - MESH_TOL);
+            expect(baseHeight - trimmedHeight).toBeLessThanOrEqual(5 + MESH_TOL);
+        });
+        it("should extend the helix start by negative .startOffset()", () => {
+            const base = helix("z").pitch(5).turns(4);
+            render();
+            const baseHeight = ShapeOps.getBoundingBox(base.getShapes()[0]).maxZ
+                - ShapeOps.getBoundingBox(base.getShapes()[0]).minZ;
+            const extended = helix("z").pitch(5).turns(4).startOffset(-10);
+            render();
+            const extendedHeight = ShapeOps.getBoundingBox(extended.getShapes()[0]).maxZ
+                - ShapeOps.getBoundingBox(extended.getShapes()[0]).minZ;
+            expect(extendedHeight - baseHeight).toBeGreaterThanOrEqual(10 - MESH_TOL);
+            expect(extendedHeight - baseHeight).toBeLessThanOrEqual(10 + MESH_TOL);
+        });
+    });
+    describe("cylindrical face input", () => {
+        it("should derive axis, radius, and height from a cylinder face", () => {
+            cylinder(15, 60);
+            const sel = select(face().cylinder());
+            const h = helix(sel).turns(6);
+            render();
+            const shapes = h.getShapes();
+            expect(shapes).toHaveLength(1);
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxX - bbox.minX).toBeGreaterThanOrEqual(30 - MESH_TOL);
+            expect(bbox.maxX - bbox.minX).toBeLessThanOrEqual(30 + MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeGreaterThanOrEqual(60 - MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeLessThanOrEqual(60 + MESH_TOL);
+        });
+        it("should extend below/above the cylinder with offsets", () => {
+            cylinder(15, 60);
+            const sel = select(face().cylinder());
+            const h = helix(sel).turns(6).startOffset(-10).endOffset(10);
+            render();
+            const bbox = ShapeOps.getBoundingBox(h.getShapes()[0]);
+            // Cylinder is 0..60 in Z; offsets extend by 10 on each side.
+            expect(bbox.minZ).toBeGreaterThanOrEqual(-10 - MESH_TOL);
+            expect(bbox.minZ).toBeLessThanOrEqual(-10 + MESH_TOL);
+            expect(bbox.maxZ).toBeGreaterThanOrEqual(70 - MESH_TOL);
+            expect(bbox.maxZ).toBeLessThanOrEqual(70 + MESH_TOL);
+        });
+    });
+    describe("conical face input", () => {
+        it("should follow a cone surface with the face's natural taper", async () => {
+            const { default: extrude } = await import("../../core/extrude.js");
+            sketch("xy", () => {
+                circle(60); // radius 30
+            });
+            extrude(50).draft(10); // 10° draft → top radius widens
+            const sel = select(face().cone());
+            const h = helix(sel).turns(6);
+            render();
+            const shapes = h.getShapes();
+            expect(shapes).toHaveLength(1);
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            // Cone widens from r=30 at z=0 to r=~38.8 at z=50 (10° draft).
+            // Max helix diameter = ~77.6.
+            expect(bbox.maxX - bbox.minX).toBeGreaterThanOrEqual(60);
+            expect(bbox.maxX - bbox.minX).toBeLessThanOrEqual(78 + MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeGreaterThanOrEqual(50 - MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeLessThanOrEqual(50 + MESH_TOL);
+        });
+        it("should extend the helix following the cone's natural taper with offsets", async () => {
+            const { default: extrude } = await import("../../core/extrude.js");
+            sketch("xy", () => {
+                circle(60); // radius 30 at z=0
+            });
+            extrude(50).draft(10); // cone widens toward top (tanθ = tan(10°) ≈ 0.176)
+            const sel = select(face().cone());
+            const h = helix(sel).turns(6).startOffset(-10).endOffset(10);
+            render();
+            const bbox = ShapeOps.getBoundingBox(h.getShapes()[0]);
+            // Z extends 10 below (z=-10) and 10 above (z=60) the cone.
+            expect(bbox.maxZ - bbox.minZ).toBeGreaterThanOrEqual(70 - MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeLessThanOrEqual(70 + MESH_TOL);
+            // At z=60 (top extension), radius extrapolates: r = 30 + 60*tan(10°) ≈ 40.6
+            // Max diameter ≈ 81.2 — strictly larger than the un-offset top diameter (~77.6).
+            expect(bbox.maxX - bbox.minX).toBeGreaterThan(78);
+            expect(bbox.maxX - bbox.minX).toBeLessThanOrEqual(82 + MESH_TOL);
+        });
+    });
+    describe("line edge input", () => {
+        it("should treat a line edge as the helix axis and derive height from length", () => {
+            const s = sketch("xz", () => {
+                hLine(40);
+            });
+            const h = helix(s).turns(4);
+            render();
+            const shapes = h.getShapes();
+            expect(shapes).toHaveLength(1);
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            // Line is along world X (in the xz plane, hLine = X). Height ≈ 40 in X.
+            expect(bbox.maxX - bbox.minX).toBeGreaterThanOrEqual(40 - MESH_TOL);
+            expect(bbox.maxX - bbox.minX).toBeLessThanOrEqual(40 + MESH_TOL);
+        });
+    });
+    describe("circular edge input", () => {
+        it("should derive axis from circle normal and use circle radius", () => {
+            const s = sketch("xy", () => {
+                circle(30);
+            });
+            const h = helix(s).turns(4);
+            render();
+            const shapes = h.getShapes();
+            expect(shapes).toHaveLength(1);
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxX - bbox.minX).toBeGreaterThanOrEqual(30 - MESH_TOL);
+            expect(bbox.maxX - bbox.minX).toBeLessThanOrEqual(30 + MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeGreaterThanOrEqual(50 - MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeLessThanOrEqual(50 + MESH_TOL);
+        });
+        it("should respect .height() override on circular edge", () => {
+            const s = sketch("xy", () => {
+                circle(30);
+            });
+            const h = helix(s).turns(4).height(80);
+            render();
+            const bbox = ShapeOps.getBoundingBox(h.getShapes()[0]);
+            expect(bbox.maxZ - bbox.minZ).toBeGreaterThanOrEqual(80 - MESH_TOL);
+            expect(bbox.maxZ - bbox.minZ).toBeLessThanOrEqual(80 + MESH_TOL);
+        });
+    });
+    describe("validation", () => {
+        it("should record an error when pitch is zero", () => {
+            const h = helix("z").pitch(0).turns(4);
+            render();
+            expect(h.getError()).toMatch(/pitch/i);
+        });
+        it("should record an error when turns is zero", () => {
+            const h = helix("z").pitch(5).turns(0);
+            render();
+            expect(h.getError()).toMatch(/turns/i);
+        });
+        it("should record an error when source has no faces or edges", () => {
+            const s = sketch("xy", () => {
+                // empty sketch
+            });
+            const h = helix(s).turns(2);
+            render();
+            expect(h.getError()).toBeTruthy();
+        });
+    });
+    describe("sweep integration", () => {
+        it("should be sweepable by a small profile to build a spring", () => {
+            const profile = sketch("xz", () => {
+                circle(2);
+            });
+            const path = helix("z").radius(15).pitch(5).turns(4);
+            const spring = sweep(path, profile);
+            render();
+            const shapes = spring.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+    });
+});

package/lib/dist/tests/features/repeat-primitive.test.d.ts

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

package/lib/dist/tests/features/repeat-primitive.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import cylinder from "../../core/cylinder.js";
+import sphere from "../../core/sphere.js";
+import repeat from "../../core/repeat.js";
+import { ShapeProps } from "../../oc/props.js";
+function buildErrors(scene) {
+    return scene.getSceneObjects()
+        .map(o => ({ type: o.getType(), err: o.getError() }))
+        .filter(e => e.err);
+}
+function solidCentroids(scene) {
+    return scene.getSceneObjects()
+        .filter(o => !o.isContainer())
+        .flatMap(o => o.getShapes())
+        .filter(sh => sh.isSolid())
+        .map(sh => {
+        const c = ShapeProps.getProperties(sh.getShape()).centroid;
+        return { x: Math.round(c.x) + 0, y: Math.round(c.y) + 0, z: Math.round(c.z) + 0 };
+    });
+}
+describe("repeat of primitives", () => {
+    setupOC();
+    it("linear-repeats a cylinder", () => {
+        const c = cylinder(10, 30);
+        repeat("linear", "x", { count: 2, offset: 60 }, c);
+        const scene = render();
+        expect(buildErrors(scene)).toEqual([]);
+        const centroids = solidCentroids(scene).sort((a, b) => a.x - b.x);
+        expect(centroids).toEqual([
+            { x: 0, y: 0, z: 15 },
+            { x: 60, y: 0, z: 15 },
+        ]);
+    });
+    it("circular-repeats a translated cylinder, applying the rotation after the translate", () => {
+        const c = cylinder(5, 20).translate(30, 0, 0);
+        repeat("circular", "z", { count: 4, angle: 360 }, c);
+        const scene = render();
+        expect(buildErrors(scene)).toEqual([]);
+        const centroids = solidCentroids(scene)
+            .sort((a, b) => (a.x - b.x) || (a.y - b.y));
+        expect(centroids).toEqual([
+            { x: -30, y: 0, z: 10 },
+            { x: 0, y: -30, z: 10 },
+            { x: 0, y: 30, z: 10 },
+            { x: 30, y: 0, z: 10 },
+        ]);
+    });
+    it("mirror-repeats a sphere", () => {
+        const s = sphere(8).translate(20, 0, 0);
+        repeat("mirror", "yz", s);
+        const scene = render();
+        expect(buildErrors(scene)).toEqual([]);
+        const centroids = solidCentroids(scene).sort((a, b) => a.x - b.x);
+        expect(centroids).toEqual([
+            { x: -20, y: 0, z: 0 },
+            { x: 20, y: 0, z: 0 },
+        ]);
+    });
+});

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

@@ -227,8 +227,13 @@ describe("rib", () => {
         it("repeat circular on extended rib should produce valid copies", async () => {
             const repeatModule = await import("../../core/repeat.js");
             const repeat = repeatModule.default;
+            // The scope (box + boss) must be rotationally symmetric about Z so that a
+            // 90°/180°/270° clone really is congruent to the original — otherwise the
+            // rib legitimately conforms to a different wall distance per orientation
+            // and the volume-equality check below would measure scope asymmetry rather
+            // than flag propagation. A square box keeps the comparison about the flags.
             sketch("top", () => {
-                rect(100, 50).centered();
+                rect(100, 100).centered();
             });
             const box = extrude(30);
             const shelled = shell(-4, box.endFaces());

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

@@ -3,7 +3,9 @@ import { setupOC, render, addToScene } from "../setup.js";
 import sketch from "../../core/sketch.js";
 import sweep from "../../core/sweep.js";
 import extrude from "../../core/extrude.js";
-import { circle, rect, vLine, hLine, arc } from "../../core/2d/index.js";
+import helix from "../../core/helix.js";
+import cylinder from "../../core/cylinder.js";
+import { circle, rect, vLine, hLine, arc, move, hMove } from "../../core/2d/index.js";
 import { countShapes } from "../utils.js";
 import { ShapeOps } from "../../oc/shape-ops.js";
 import { ShapeProps } from "../../oc/props.js";
@@ -309,4 +311,126 @@ describe("sweep", () => {
             expect(countShapes(scene)).toBe(1);
         });
     });
+    describe("helix sweep with cone fuse/cut", () => {
+        it(".add() with helix on cone face fuses to a single solid", () => {
+            sketch("xy", () => { circle(30); });
+            const c = extrude(50).draft(10);
+            const path = helix(c.sideFaces()).turns(10);
+            const profile = sketch("xz", () => {
+                move([15, 0]);
+                circle(2);
+            });
+            const s = sweep(path, profile).add();
+            render();
+            const sShapes = s.getShapes();
+            const totalVol = sShapes.reduce((acc, sh) => acc + ShapeProps.getProperties(sh.getShape()).volumeMm3, 0);
+            expect(c.getShapes().length).toBe(0);
+            expect(sShapes.length).toBe(1);
+            expect(totalVol).toBeGreaterThan(60000);
+            expect(totalVol).toBeLessThan(64000);
+        });
+        it(".remove() with helix on cone face cuts a groove", () => {
+            sketch("xy", () => { circle(30); });
+            const c = extrude(50).draft(10);
+            const path = helix(c.sideFaces()).turns(10);
+            const profile = sketch("xz", () => {
+                move([15, 0]);
+                circle(2);
+            });
+            const s = sweep(path, profile).remove();
+            render();
+            const sShapes = s.getShapes();
+            const totalVol = sShapes.reduce((acc, sh) => acc + ShapeProps.getProperties(sh.getShape()).volumeMm3, 0);
+            expect(c.getShapes().length).toBe(0);
+            expect(sShapes.length).toBe(1);
+            expect(totalVol).toBeGreaterThan(56000);
+            expect(totalVol).toBeLessThan(62000);
+        });
+    });
+    describe("conical (tapered) helix sweep", () => {
+        // A tapered helical spine (endRadius ≠ radius) produces a swept surface
+        // that needs many approximation spans; at MakePipeShell's small default
+        // segment budget the build silently fails (PipeNotDone). SweepOps raises
+        // the budget (MAX_PIPE_SEGMENTS), so these build with the fixed binormal.
+        it("sweeps a circle along an outward-tapering helix", () => {
+            const path = helix("z").height(100).pitch(10).radius(15).endRadius(25);
+            const profile = sketch("left", () => {
+                hMove(15);
+                circle(2);
+            });
+            const s = sweep(path, profile);
+            render();
+            expect(s.getError()).toBeNull();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+            const props = ShapeProps.getProperties(shapes[0].getShape());
+            expect(props.volumeMm3).toBeGreaterThan(0);
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            // End radius 25 + tube radius 2 ⇒ ~54mm across; height 100 ⇒ ~100mm tall.
+            expect(bbox.maxX - bbox.minX).toBeGreaterThan(50);
+            expect(bbox.maxZ - bbox.minZ).toBeGreaterThan(95);
+        });
+        it("sweeps a circle along an inward-tapering helix", () => {
+            const path = helix("z").height(80).pitch(8).radius(25).endRadius(12);
+            const profile = sketch("left", () => {
+                hMove(25);
+                circle(1.5);
+            });
+            const s = sweep(path, profile);
+            render();
+            expect(s.getError()).toBeNull();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+            expect(ShapeProps.getProperties(shapes[0].getShape()).volumeMm3).toBeGreaterThan(0);
+        });
+    });
+    describe("helix sweep tangent to a cylinder (fuzzy boolean)", () => {
+        // A helix at the cylinder's own radius makes a swept thread that touches
+        // the cylinder tangentially along the contact curves. At zero boolean fuzz
+        // OCCT's BOPAlgo silently no-ops (cut removes nothing; fuse returns an empty
+        // compound). BooleanOps' small fuzzy value resolves the contact. Volume
+        // ≈ a radius-15 / height-50 cylinder = π·225·50 ≈ 35343 mm³.
+        const CYL_VOL = Math.PI * 225 * 50;
+        it("removes a helical groove from the cylinder surface", () => {
+            cylinder(15, 50);
+            const path = helix("z").height(50).radius(15).pitch(5).startOffset(-5).endOffset(5);
+            const profile = sketch("left", () => { move([15, 0]); circle(3); });
+            const s = sweep(path, profile).remove();
+            render();
+            expect(s.getError()).toBeNull();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            const vol = ShapeProps.getProperties(shapes[0].getShape()).volumeMm3;
+            // A real groove was carved: less than the full cylinder, but most remains.
+            expect(vol).toBeGreaterThan(CYL_VOL * 0.8);
+            expect(vol).toBeLessThan(CYL_VOL - 100);
+        });
+        it("fuses a helical thread onto the cylinder surface", () => {
+            cylinder(15, 50);
+            const path = helix("z").height(50).radius(15).pitch(5).startOffset(-5).endOffset(5);
+            const profile = sketch("left", () => { move([15, 0]); circle(3); });
+            const s = sweep(path, profile).add();
+            render();
+            expect(s.getError()).toBeNull();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            // A thread was added: more than the bare cylinder.
+            expect(ShapeProps.getProperties(shapes[0].getShape()).volumeMm3).toBeGreaterThan(CYL_VOL + 100);
+        });
+        it("removes a groove when the helix has no start/end offset", () => {
+            cylinder(15, 50);
+            const path = helix("z").height(50).radius(15).pitch(5);
+            const profile = sketch("left", () => { move([15, 0]); circle(3); });
+            const s = sweep(path, profile).remove();
+            render();
+            expect(s.getError()).toBeNull();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            const vol = ShapeProps.getProperties(shapes[0].getShape()).volumeMm3;
+            expect(vol).toBeGreaterThan(CYL_VOL * 0.8);
+            expect(vol).toBeLessThan(CYL_VOL - 100);
+        });
+    });
 });

package/lib/dist/tests/features/text.test.d.ts

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