fluidcad 0.0.37 → 0.0.38

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

@@ -4,7 +4,6 @@ import { WireOps } from "./wire-ops.js";
 import { FaceOps } from "./face-ops.js";
 import { EdgeOps } from "./edge-ops.js";
 import { Explorer } from "./explorer.js";
-import { Convert } from "./convert.js";
 import { getOC } from "./init.js";
 export class ThinFaceMaker {
     static make(edges, plane, offset1, offset2) {
@@ -48,7 +47,7 @@ export class ThinFaceMaker {
         return { faces, inwardEdges, outwardEdges };
     }
     static makeSingleOffsetFace(wire, isClosed, plane, offset) {
-        const offsetWire = this.doOffset(wire, plane, offset, isClosed);
+        const offsetWire = WireOps.offsetWireOnPlane(wire, offset, isClosed, plane);
         if (isClosed) {
             // Determine which wire is outer (larger) vs inner based on offset sign
             const [outer, inner] = offset >= 0
@@ -77,8 +76,8 @@ export class ThinFaceMaker {
         if (Math.sign(offset1) === Math.sign(offset2)) {
             offset2 = -offset2;
         }
-        const wire1 = this.doOffset(wire, plane, offset1, isClosed);
-        const wire2 = this.doOffset(wire, plane, offset2, isClosed);
+        const wire1 = WireOps.offsetWireOnPlane(wire, offset1, isClosed, plane);
+        const wire2 = WireOps.offsetWireOnPlane(wire, offset2, isClosed, plane);
         if (isClosed) {
             // The wire with the larger offset is the outer boundary
             const [outer, inner] = offset1 >= offset2
@@ -102,34 +101,6 @@ export class ThinFaceMaker {
         const outwardEdges = this.matchFaceEdgesByMidpoint(face, outwardWireEdges);
         return { face, inwardEdges, outwardEdges };
     }
-    /**
-     * Offsets a wire by the given distance, handling both closed and open wires.
-     * 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 (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);
-        }
-        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
@@ -154,42 +125,6 @@ export class ThinFaceMaker {
         }
         return Wire.fromTopoDSWire(oc.TopoDS.Wire(wires[0]));
     }
-    /**
-     * Offsets an open wire on a given plane, using a planar face as reference
-     * so that BRepOffsetAPI_MakeOffset knows the offset direction.
-     * Only handles positive distances — use doOffset for sign handling.
-     */
-    static offsetWireOnPlane(wire, plane, distance, isOpen) {
-        const oc = getOC();
-        const [pln, disposePlane] = Convert.toGpPln(plane);
-        const faceMaker = new oc.BRepBuilderAPI_MakeFace(pln);
-        if (!faceMaker.IsDone()) {
-            faceMaker.delete();
-            disposePlane();
-            throw new Error("Failed to create reference face for thin offset");
-        }
-        const face = faceMaker.Face();
-        faceMaker.delete();
-        disposePlane();
-        const maker = new oc.BRepOffsetAPI_MakeOffset();
-        maker.Init(face, oc.GeomAbs_JoinType.GeomAbs_Arc, isOpen);
-        maker.AddWire(wire.getShape());
-        maker.Perform(distance, 0);
-        if (!maker.IsDone()) {
-            maker.delete();
-            throw new Error("Failed to offset wire for thin extrude");
-        }
-        const result = maker.Shape();
-        maker.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) {
-            throw new Error("Thin offset produced no usable wire");
-        }
-        return Wire.fromTopoDSWire(oc.TopoDS.Wire(wires[0]));
-    }
     /**
      * Finds face edges that geometrically match the given wire edges by comparing midpoints.
      * This is needed because wire reversal (ShapeExtend_WireData.Reverse) creates new TShapes,

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

@@ -9,7 +9,22 @@ export declare class WireOps {
     static makeWireFromEdges(edges: Edge[]): Wire;
     static reverseWire(wire: Wire): Wire;
     static buildWire(edges: Edge[]): Wire;
-    static offsetWire(shape: Wire | Edge, distance: number, isOpen: boolean): Wire;
+    static offsetWire(shape: Wire | Edge, distance: number, isOpen: boolean, plane?: Plane): Wire;
+    /**
+     * Offsets a wire by `distance` on `plane`, handling open/closed wires and
+     * negative distances.
+     *
+     * The plane is passed as a reference face so BRepOffsetAPI_MakeOffset can
+     * resolve an offset direction even for wires with no curvature to imply a
+     * plane (e.g. a single straight segment, which otherwise fails outright).
+     *
+     * For open wires a negative distance offsets to the *opposite* side — the
+     * face-based offset does not flip sides on a sign change by itself, so the
+     * wire is reversed, offset by the magnitude, then reversed back. For closed
+     * wires the plane-less offset is tried first (the path circles rely on, where
+     * the sign selects inward/outward) and the face-based offset is the fallback.
+     */
+    static offsetWireOnPlane(wire: Wire, distance: number, isClosed: boolean, plane: Plane): Wire;
     static isCWRaw(wire: TopoDS_Wire, normal: Vector3d): boolean;
     static makeWireFromEdgesRaw(edges: TopoDS_Edge[]): TopoDS_Wire;
     static reverseWireRaw(wire: TopoDS_Wire): TopoDS_Wire;
@@ -31,5 +46,5 @@ export declare class WireOps {
     } | null;
     static groupConnectedEdges(edges: Edge[]): Edge[][];
     private static verticesMatch;
-    static offsetWireRaw(wire: TopoDS_Wire, distance: number, isOpen: boolean): TopoDS_Wire;
+    static offsetWireRaw(wire: TopoDS_Wire, distance: number, isOpen: boolean, plane?: Plane): TopoDS_Wire;
 }

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

@@ -15,9 +15,39 @@ export class WireOps {
     static buildWire(edges) {
         return Wire.fromTopoDSWire(WireOps.buildWireRaw(edges.map(e => e.getShape())));
     }
-    static offsetWire(shape, distance, isOpen) {
+    static offsetWire(shape, distance, isOpen, plane) {
         const wire = shape instanceof Wire ? shape : WireOps.makeWireFromEdges([shape]);
-        return Wire.fromTopoDSWire(WireOps.offsetWireRaw(wire.getShape(), distance, isOpen));
+        return Wire.fromTopoDSWire(WireOps.offsetWireRaw(wire.getShape(), distance, isOpen, plane));
+    }
+    /**
+     * Offsets a wire by `distance` on `plane`, handling open/closed wires and
+     * negative distances.
+     *
+     * The plane is passed as a reference face so BRepOffsetAPI_MakeOffset can
+     * resolve an offset direction even for wires with no curvature to imply a
+     * plane (e.g. a single straight segment, which otherwise fails outright).
+     *
+     * For open wires a negative distance offsets to the *opposite* side — the
+     * face-based offset does not flip sides on a sign change by itself, so the
+     * wire is reversed, offset by the magnitude, then reversed back. For closed
+     * wires the plane-less offset is tried first (the path circles rely on, where
+     * the sign selects inward/outward) and the face-based offset is the fallback.
+     */
+    static offsetWireOnPlane(wire, distance, isClosed, plane) {
+        if (!isClosed) {
+            if (distance < 0) {
+                const reversed = WireOps.reverseWire(wire);
+                const offsetResult = WireOps.offsetWire(reversed, -distance, true, plane);
+                return WireOps.reverseWire(offsetResult);
+            }
+            return WireOps.offsetWire(wire, distance, true, plane);
+        }
+        try {
+            return WireOps.offsetWire(wire, distance, false);
+        }
+        catch {
+            return WireOps.offsetWire(wire, distance, false, plane);
+        }
     }
     static isCWRaw(wire, normal) {
         const oc = getOC();
@@ -193,10 +223,31 @@ export class WireOps {
         const dz = p1.z - p2.z;
         return (dx * dx + dy * dy + dz * dz) < 1e-14;
     }
-    static offsetWireRaw(wire, distance, isOpen) {
+    static offsetWireRaw(wire, distance, isOpen, plane) {
         const oc = getOC();
         const maker = new oc.BRepOffsetAPI_MakeOffset();
-        maker.Init(oc.GeomAbs_JoinType.GeomAbs_Arc, isOpen);
+        // BRepOffsetAPI_MakeOffset can't infer an offset direction from a wire with
+        // no curvature (e.g. a single straight segment), so the face-less Init
+        // fails with "Failed to offset wire". Initializing it with a planar
+        // reference face supplies the normal it needs — pass `plane` whenever the
+        // offset happens on a known sketch/target plane.
+        if (plane) {
+            const [pln, disposePlane] = Convert.toGpPln(plane);
+            const faceMaker = new oc.BRepBuilderAPI_MakeFace(pln);
+            if (!faceMaker.IsDone()) {
+                faceMaker.delete();
+                disposePlane();
+                maker.delete();
+                throw new Error("Failed to create reference face for wire offset");
+            }
+            const face = faceMaker.Face();
+            faceMaker.delete();
+            disposePlane();
+            maker.Init(face, oc.GeomAbs_JoinType.GeomAbs_Arc, isOpen);
+        }
+        else {
+            maker.Init(oc.GeomAbs_JoinType.GeomAbs_Arc, isOpen);
+        }
         maker.AddWire(wire);
         maker.Perform(distance, 0);
         if (!maker.IsDone()) {

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

@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { setupOC, render } from "../../setup.js";
 import sketch from "../../../core/sketch.js";
-import { circle, hLine, vLine, offset } from "../../../core/2d/index.js";
+import { circle, hLine, vLine, aLine, line, offset } from "../../../core/2d/index.js";
 import { ShapeOps } from "../../../oc/shape-ops.js";
 describe("offset", () => {
     setupOC();
@@ -42,6 +42,79 @@ describe("offset", () => {
             expect(shapes.length).toBeGreaterThan(2);
         });
     });
+    // Regression: a single straight segment has no curvature to imply an offset
+    // plane, so BRepOffsetAPI_MakeOffset needs the sketch plane as a reference
+    // face. Without it, the offset failed with "Failed to offset wire" and no
+    // offset edge was produced.
+    describe("offset single open line", () => {
+        const endpoints = (edge) => [edge.getFirstVertex().toPoint(), edge.getLastVertex().toPoint()];
+        it("offsets a single hLine to a parallel line at the right distance", () => {
+            const s = sketch("xy", () => {
+                hLine(100);
+                offset(10);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBe(2);
+            const [a, b] = endpoints(shapes[1]);
+            expect(Math.abs(a.y)).toBeCloseTo(10, 6);
+            expect(Math.abs(b.y)).toBeCloseTo(10, 6);
+            expect(Math.hypot(b.x - a.x, b.y - a.y)).toBeCloseTo(100, 6);
+        });
+        it("offsets a single vLine to a parallel line at the right distance", () => {
+            const s = sketch("xy", () => {
+                vLine(100);
+                offset(10);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBe(2);
+            const [a, b] = endpoints(shapes[1]);
+            expect(Math.abs(a.x)).toBeCloseTo(10, 6);
+            expect(Math.abs(b.x)).toBeCloseTo(10, 6);
+            expect(Math.hypot(b.x - a.x, b.y - a.y)).toBeCloseTo(100, 6);
+        });
+        it("offsets a single aLine, preserving its length", () => {
+            const s = sketch("xy", () => {
+                aLine(30, 100);
+                offset(10);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBe(2);
+            const [a, b] = endpoints(shapes[1]);
+            expect(Math.hypot(b.x - a.x, b.y - a.y)).toBeCloseTo(100, 6);
+        });
+        it("offsets a single line, preserving its length", () => {
+            const s = sketch("xy", () => {
+                line([100, 50]);
+                offset(10);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBe(2);
+            const [a, b] = endpoints(shapes[1]);
+            expect(Math.hypot(b.x - a.x, b.y - a.y)).toBeCloseTo(Math.hypot(100, 50), 6);
+        });
+        it("offsets a single line to the opposite side with a negative distance", () => {
+            const sPos = sketch("xy", () => {
+                hLine(100);
+                offset(10);
+            });
+            render();
+            const posY = endpoints(sPos.getShapes()[1])[0].y;
+            const sNeg = sketch("xy", () => {
+                hLine(100);
+                offset(-10);
+            });
+            render();
+            const negShapes = sNeg.getShapes();
+            expect(negShapes.length).toBe(2);
+            const negY = endpoints(negShapes[1])[0].y;
+            expect(Math.abs(negY)).toBeCloseTo(10, 6);
+            expect(Math.sign(negY)).toBe(-Math.sign(posY));
+        });
+    });
     describe("offset direction", () => {
         it("positive and negative offsets should produce different results", () => {
             const s1 = sketch("xy", () => {

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

@@ -6,6 +6,7 @@ import plane from "../../core/plane.js";
 import select from "../../core/select.js";
 import { rect } from "../../core/2d/index.js";
 import { face } from "../../filters/index.js";
+import { Point } from "../../math/point.js";
 describe("plane", () => {
     setupOC();
     describe("standard plane creation", () => {
@@ -111,6 +112,100 @@ describe("plane", () => {
             expect(pl.origin.z).toBeCloseTo(50);
         });
     });
+    describe("plane from edge", () => {
+        const expectSamePoint = (a, b) => {
+            expect(a.x).toBeCloseTo(b.x);
+            expect(a.y).toBeCloseTo(b.y);
+            expect(a.z).toBeCloseTo(b.z);
+        };
+        it("should create a plane normal to an edge at its midpoint", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            const p = plane(e.startEdges(0), "middle");
+            render();
+            const pl = p.getPlane();
+            // A base-face edge lies in the z=0 plane, so its tangent — which becomes
+            // the plane normal — is horizontal.
+            expect(pl.origin.z).toBeCloseTo(0);
+            expect(pl.normal.z).toBeCloseTo(0);
+            // The normal is a unit vector.
+            expect(Math.hypot(pl.normal.x, pl.normal.y, pl.normal.z)).toBeCloseTo(1);
+        });
+        it("should default to the start when no position is given", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            const pStart = plane(e.startEdges(0), "start");
+            const pDefault = plane(e.startEdges(0));
+            render();
+            expectSamePoint(pDefault.getPlane().origin, pStart.getPlane().origin);
+        });
+        it("should place start/end at the endpoints with the midpoint between them", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            const pStart = plane(e.startEdges(0), "start");
+            const pEnd = plane(e.startEdges(0), "end");
+            const pMid = plane(e.startEdges(0), "middle");
+            render();
+            const s = pStart.getPlane().origin;
+            const en = pEnd.getPlane().origin;
+            const m = pMid.getPlane().origin;
+            // Distinct endpoints…
+            expect(s.distanceTo(en)).toBeGreaterThan(1);
+            // …with the midpoint halfway between them (the edge is straight).
+            expectSamePoint(m, new Point((s.x + en.x) / 2, (s.y + en.y) / 2, (s.z + en.z) / 2));
+        });
+        it("should treat the numeric position as a normalized 0–1 parameter", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            const p0 = plane(e.startEdges(0), 0);
+            const pHalf = plane(e.startEdges(0), 0.5);
+            const p1 = plane(e.startEdges(0), 1);
+            const pStart = plane(e.startEdges(0), "start");
+            const pMid = plane(e.startEdges(0), "middle");
+            const pEnd = plane(e.startEdges(0), "end");
+            render();
+            expectSamePoint(p0.getPlane().origin, pStart.getPlane().origin);
+            expectSamePoint(pHalf.getPlane().origin, pMid.getPlane().origin);
+            expectSamePoint(p1.getPlane().origin, pEnd.getPlane().origin);
+        });
+        it("should face outward at the start (cap convention)", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            const pStart = plane(e.startEdges(0), "start");
+            const pMid = plane(e.startEdges(0), "middle");
+            const pEnd = plane(e.startEdges(0), "end");
+            render();
+            const nStart = pStart.getPlane().normal;
+            const nMid = pMid.getPlane().normal;
+            const nEnd = pEnd.getPlane().normal;
+            // A straight edge has a constant forward tangent. The middle and end keep
+            // it; the start flips to face outward, so it's the negated tangent.
+            expectSamePoint(nMid, nEnd);
+            expectSamePoint(nStart, nEnd.negate());
+        });
+        it("should still treat a numeric argument on a face as a normal offset", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(40);
+            const p = plane(e.endFaces(), 10);
+            render();
+            const pl = p.getPlane();
+            // Face path: the bare number is an offset along the normal (40 + 10).
+            expect(pl.origin.z).toBeCloseTo(50);
+            expect(Math.abs(pl.normal.z)).toBeCloseTo(1);
+        });
+    });
     describe("plane middle", () => {
         it("should create a plane midway between two standard planes", () => {
             const p1 = plane("xy");

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

@@ -5,7 +5,8 @@ import sweep from "../../core/sweep.js";
 import extrude from "../../core/extrude.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 plane from "../../core/plane.js";
+import { circle, rect, vLine, hLine, arc, line, 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";
@@ -433,4 +434,48 @@ describe("sweep", () => {
             expect(vol).toBeLessThan(CYL_VOL - 100);
         });
     });
+    describe("helix thread sweep (asymmetric profile)", () => {
+        // An asymmetric profile swept along a helix is the case that exposes
+        // section twist — a rotationally symmetric circle (used by the tests above)
+        // looks identical no matter how the section spins, so it can't catch a
+        // wobbling trihedron. This sweeps a thread-like trapezoid drawn on a plane
+        // built off the helix (plane(h)), the orientation a user reaches for.
+        //
+        // The fixed binormal must track the helix axis. With the wrong binormal the
+        // section flips ~twice per turn, producing a self-intersecting ribbon whose
+        // mass piles up on one side (centroid leaves the axis) and whose volume
+        // collapses to a fraction of the real thread. For a whole number of turns a
+        // correct thread is axisymmetric: its centroid sits on the coil axis.
+        it("produces a clean axisymmetric coil, not a wobbling ribbon", () => {
+            const h = helix("z").height(80).radius(25).pitch(10); // 8 full turns
+            const p = plane(h);
+            const profile = sketch(p, () => {
+                line([3, 0], [-3, 0]);
+                line([-2, -6]);
+                line([2, -6]);
+                line([3, 0]);
+            });
+            const s = sweep(h, profile);
+            render();
+            expect(s.getError()).toBeNull();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            const props = ShapeProps.getProperties(shapes[0].getShape());
+            // Centroid on the coil (Z) axis — a wobbling ribbon piled it out at the
+            // ~25mm coil radius instead.
+            const radialOffset = Math.hypot(props.centroid.x, props.centroid.y);
+            expect(radialOffset).toBeLessThan(1);
+            expect(props.centroid.z).toBeCloseTo(40, 0);
+            // Real thread volume ≈ profile area (30mm²) × coil length (~1260mm).
+            // The wobble collapsed this to ~1500mm³; a section that collapses toward
+            // the axis (wrong trihedron the other way) drops it to a few thousand.
+            expect(props.volumeMm3).toBeGreaterThan(25000);
+            expect(props.volumeMm3).toBeLessThan(40000);
+            // The coil sits at the helix radius (~25mm), not collapsed onto the axis.
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            const radialExtent = Math.max(bbox.maxX - bbox.minX, bbox.maxY - bbox.minY) / 2;
+            expect(radialExtent).toBeGreaterThan(23);
+            expect(radialExtent).toBeLessThan(30);
+        });
+    });
 });