fluidcad 0.0.37 → 0.0.39

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

@@ -1,5 +1,32 @@
 import { Solid } from "../common/solid.js";
 import { Wire } from "../common/wire.js";
+import { LoftEndCondition, LoftConditionKind } from "./loft/constrained-loft.js";
+export type { LoftEndCondition, LoftConditionKind };
+export interface LoftOptions {
+    /** Constrains how the surface leaves the first profile. */
+    startCondition?: LoftEndCondition;
+    /** Constrains how the surface arrives at the last profile. */
+    endCondition?: LoftEndCondition;
+    /** One or two side rails the loft surface must follow. */
+    guides?: Wire[];
+}
 export declare class LoftOps {
-    static makeLoft(wires: Wire[]): Solid[];
+    /**
+     * Lofts through the section wires. Plain lofts run OCC's ThruSections;
+     * guides dispatch to `GuidedLoft` (virtual sections carried onto the
+     * rails) and start/end conditions to `ConstrainedLoft` (derivative-pinned
+     * skinning) — both in-house skins, since OCC can neither constrain end
+     * tangency nor follow rails without distorting sections. Conditions
+     * compose with guides: the condition fades out around each guide contact
+     * (the rails own their sides of the surface).
+     */
+    static makeLoft(wires: Wire[], options?: LoftOptions): Solid[];
+    /**
+     * Thin-walled loft with start/end conditions: both walls are skinned with
+     * the same conditions and assembled directly with ring caps — see
+     * `ConstrainedLoft.buildThin`. (The condition-less thin loft stays on the
+     * legacy ThruSections + boolean path in the feature layer.)
+     */
+    static makeThinLoft(outerWires: Wire[], innerWires: Wire[], options: LoftOptions): Solid[];
+    private static makeThruSectionsLoft;
 }

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

@@ -1,8 +1,38 @@
 import { getOC } from "./init.js";
 import { Explorer } from "./explorer.js";
 import { Solid } from "../common/solid.js";
+import { ConstrainedLoft } from "./loft/constrained-loft.js";
+import { GuidedLoft } from "./loft/guided-loft.js";
 export class LoftOps {
-    static makeLoft(wires) {
+    /**
+     * Lofts through the section wires. Plain lofts run OCC's ThruSections;
+     * guides dispatch to `GuidedLoft` (virtual sections carried onto the
+     * rails) and start/end conditions to `ConstrainedLoft` (derivative-pinned
+     * skinning) — both in-house skins, since OCC can neither constrain end
+     * tangency nor follow rails without distorting sections. Conditions
+     * compose with guides: the condition fades out around each guide contact
+     * (the rails own their sides of the surface).
+     */
+    static makeLoft(wires, options) {
+        const guides = options?.guides ?? [];
+        if (guides.length > 0) {
+            return GuidedLoft.build(wires, guides, options?.startCondition, options?.endCondition);
+        }
+        if (options?.startCondition || options?.endCondition) {
+            return ConstrainedLoft.build(wires, options.startCondition, options.endCondition);
+        }
+        return LoftOps.makeThruSectionsLoft(wires);
+    }
+    /**
+     * Thin-walled loft with start/end conditions: both walls are skinned with
+     * the same conditions and assembled directly with ring caps — see
+     * `ConstrainedLoft.buildThin`. (The condition-less thin loft stays on the
+     * legacy ThruSections + boolean path in the feature layer.)
+     */
+    static makeThinLoft(outerWires, innerWires, options) {
+        return ConstrainedLoft.buildThin(outerWires, innerWires, options.startCondition, options.endCondition);
+    }
+    static makeThruSectionsLoft(wires) {
         const oc = getOC();
         const thruSections = new oc.BRepOffsetAPI_ThruSections(true, false, 1e-6);
         for (const wire of wires) {

package/lib/dist/oc/ncollection.d.ts

@@ -0,0 +1,19 @@
+import type { NCollection_Array1_double, NCollection_Array1_int, NCollection_Array1_gp_Pnt, NCollection_Array1_gp_Pnt2d, NCollection_Array2_gp_Pnt, NCollection_Array2_double } from "ocjs-fluidcad";
+import type { Disposable } from "./convert.js";
+import { Point2D } from "../math/point.js";
+/**
+ * Builders for the 1-based NCollection arrays that OCC geometry constructors
+ * consume. Each returns the codebase's `Disposable` pair so call sites free
+ * the native array (and nothing else) once the consumer has copied it.
+ */
+export declare class NCollections {
+    static toArray1Double(values: ReadonlyArray<number>): Disposable<NCollection_Array1_double>;
+    static toArray1Int(values: ReadonlyArray<number>): Disposable<NCollection_Array1_int>;
+    /** Each point is an [x, y, z] triple. */
+    static toArray1Pnt(points: ReadonlyArray<ReadonlyArray<number>>): Disposable<NCollection_Array1_gp_Pnt>;
+    static toArray1Pnt2d(points: ReadonlyArray<Point2D>): Disposable<NCollection_Array1_gp_Pnt2d>;
+    /** Grid of [x, y, z] triples, indexed [row][column]. */
+    static toArray2Pnt(grid: ReadonlyArray<ReadonlyArray<ReadonlyArray<number>>>): Disposable<NCollection_Array2_gp_Pnt>;
+    /** Grid of numbers, indexed [row][column]. */
+    static toArray2Double(grid: ReadonlyArray<ReadonlyArray<number>>): Disposable<NCollection_Array2_double>;
+}

package/lib/dist/oc/ncollection.js

@@ -0,0 +1,69 @@
+import { getOC } from "./init.js";
+/**
+ * Builders for the 1-based NCollection arrays that OCC geometry constructors
+ * consume. Each returns the codebase's `Disposable` pair so call sites free
+ * the native array (and nothing else) once the consumer has copied it.
+ */
+export class NCollections {
+    static toArray1Double(values) {
+        const oc = getOC();
+        const array = new oc.NCollection_Array1_double(1, values.length);
+        for (let i = 0; i < values.length; i++) {
+            array.SetValue(i + 1, values[i]);
+        }
+        return [array, () => array.delete()];
+    }
+    static toArray1Int(values) {
+        const oc = getOC();
+        const array = new oc.NCollection_Array1_int(1, values.length);
+        for (let i = 0; i < values.length; i++) {
+            array.SetValue(i + 1, values[i]);
+        }
+        return [array, () => array.delete()];
+    }
+    /** Each point is an [x, y, z] triple. */
+    static toArray1Pnt(points) {
+        const oc = getOC();
+        const array = new oc.NCollection_Array1_gp_Pnt(1, points.length);
+        for (let i = 0; i < points.length; i++) {
+            const point = new oc.gp_Pnt(points[i][0], points[i][1], points[i][2]);
+            array.SetValue(i + 1, point);
+            point.delete();
+        }
+        return [array, () => array.delete()];
+    }
+    static toArray1Pnt2d(points) {
+        const oc = getOC();
+        const array = new oc.NCollection_Array1_gp_Pnt2d(1, points.length);
+        for (let i = 0; i < points.length; i++) {
+            const point = new oc.gp_Pnt2d(points[i].x, points[i].y);
+            array.SetValue(i + 1, point);
+            point.delete();
+        }
+        return [array, () => array.delete()];
+    }
+    /** Grid of [x, y, z] triples, indexed [row][column]. */
+    static toArray2Pnt(grid) {
+        const oc = getOC();
+        const array = new oc.NCollection_Array2_gp_Pnt(1, grid.length, 1, grid[0].length);
+        for (let row = 0; row < grid.length; row++) {
+            for (let col = 0; col < grid[row].length; col++) {
+                const point = new oc.gp_Pnt(grid[row][col][0], grid[row][col][1], grid[row][col][2]);
+                array.SetValue(row + 1, col + 1, point);
+                point.delete();
+            }
+        }
+        return [array, () => array.delete()];
+    }
+    /** Grid of numbers, indexed [row][column]. */
+    static toArray2Double(grid) {
+        const oc = getOC();
+        const array = new oc.NCollection_Array2_double(1, grid.length, 1, grid[0].length);
+        for (let row = 0; row < grid.length; row++) {
+            for (let col = 0; col < grid[row].length; col++) {
+                array.SetValue(row + 1, col + 1, grid[row][col]);
+            }
+        }
+        return [array, () => array.delete()];
+    }
+}

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

@@ -4,6 +4,7 @@ import { Point } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
 import { Matrix4 } from "../math/matrix4.js";
 import { WireOps } from "./wire-ops.js";
+import { WireExtendOps } from "./wire-extend-ops.js";
 import { FaceOps } from "./face-ops.js";
 import { EdgeOps } from "./edge-ops.js";
 import { ShapeOps } from "./shape-ops.js";
@@ -144,17 +145,9 @@ export class RibOps {
     // overlaps every cavity boundary regardless of curvature (drafted cones,
     // fillets, etc.) — so the cut produces a clean blend on every face it touches.
     static extendSpineWire(spineWire, scopeShapes, _plane) {
-        const edges = spineWire.getEdges();
-        if (edges.length === 0) {
+        if (spineWire.getEdges().length === 0) {
             return spineWire;
         }
-        const firstVertex = spineWire.getFirstVertex().toPoint();
-        const lastVertex = spineWire.getLastVertex().toPoint();
-        const lastEdge = edges[edges.length - 1];
-        const endTangent = EdgeOps.getEdgeTangentAtEnd(lastEdge).normalize();
-        const firstEdge = edges[0];
-        const firstEdgeEnd = EdgeOps.getLastVertex(firstEdge).toPoint();
-        const startTangent = firstVertex.vectorTo(firstEdgeEnd).normalize();
         let minX = Infinity, minY = Infinity, minZ = Infinity;
         let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
         for (const s of scopeShapes) {
@@ -184,14 +177,9 @@ export class RibOps {
             return spineWire;
         }
         const ext = 2 * diag;
-        const startExtPoint = firstVertex.add(startTangent.multiply(-ext));
-        const endExtPoint = lastVertex.add(endTangent.multiply(ext));
-        const newEdges = [
-            EdgeOps.makeLineEdge(startExtPoint, firstVertex),
-            ...edges,
-            EdgeOps.makeLineEdge(lastVertex, endExtPoint),
-        ];
-        return WireOps.makeWireFromEdges(newEdges);
+        let extended = WireExtendOps.extendWire(spineWire, "start", ext);
+        extended = WireExtendOps.extendWire(extended, "end", ext);
+        return extended;
     }
     static computeExtrudeDistanceAlongDirection(direction, origin, scopeShapes) {
         let maxDist = 0;

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

@@ -12,22 +12,13 @@ export declare class SweepOps {
     static makeSweep(spineWire: Wire, profileFaces: Face[]): SweepResult;
     /** Sweep a single wire along the spine with a fixed binormal. */
     private static sweepWire;
-    /** Unit tangent of the spine wire at its first parameter. */
-    private static getSpineTangent;
-    /** World-space centroid of a planar face (uses surface-area properties). */
-    private static getFaceCentroid;
     /**
-     * Build a world-to-world trsf that lays a planar face flat in world XY
-     * with its centroid at the world origin.
-     *
-     * `gp_Trsf::SetTransformation(A, B)` builds the transformation that maps
-     * frame A onto frame B (i.e., A's origin → B's origin, A's axes → B's
-     * axes). To move the profile *from* its current frame *to* the canonical
-     * frame, we pass the canonical frame as A and the profile's frame as B —
-     * counterintuitive but matches OCC's convention as verified empirically.
-     *
-     * The canonical frame is what OCC's MakePipeShell expects when
-     * WithContact/WithCorrection are both false: `Saxe = gp_Ax3(0, +Z, +X)`.
+     * The axis the spine's tangent rotates around, = normalize(Σ Tᵢ × Tᵢ₊₁) over
+     * tangents sampled along the spine. For a planar spine this is the plane
+     * normal; for a helix it is the coil axis. For a straight spine the tangent
+     * is constant, every cross product vanishes, and it returns null.
      */
-    private static profileToCanonicalFrameTrsf;
+    private static tangentRotationAxis;
+    /** Unit tangent of the spine wire at its first parameter. */
+    private static getSpineTangent;
 }

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

@@ -17,58 +17,40 @@ export class SweepOps {
         let firstShape = null;
         let lastShape = null;
         const profilePlane = profileFaces[0].getPlane();
-        // Fixed binormal: profile plane's "up" direction (perpendicular to xDir
-        // and to the face normal). Locking it via SetMode stops the swept profile
-        // from twisting along helical spines (clean spring instead of a wobbling
-        // ribbon). The binormal stays in WORLD coords — it's the user's intended
-        // "up" direction even when we pre-canonicalize the profile below.
-        const binormalVec = profilePlane.yDirection;
-        const [binormalDir, disposeBinormal] = Convert.toGpDir(binormalVec);
-        // Decide whether to pre-canonicalize the profile.
-        //
-        // OCC's `MakePipeShell.Add(_, false, true)` (no contact, with correction)
-        // works for most profile orientations: it rotates the profile to align
-        // its plane normal with the spine tangent, around an axis given by
-        // `profile.normal × spine.tangent`. That axis is well-defined unless
-        // the two are *anti-parallel* — in which case the cross product is
-        // zero, the rotation axis is undefined, and OCC produces a degenerate
-        // sweep.
+        // Fixed binormal for MakePipeShell's `SetMode`: it locks the section's
+        // "up", so the profile keeps a constant angle to it instead of twisting
+        // along the spine. The correct direction is the axis the spine's tangent
+        // rotates around — the plane normal for a planar spine, the coil axis for a
+        // helix. The tangent keeps a constant, non-zero angle to that axis, so the
+        // section never flips and the result is a clean coil.
         //
-        // For the well-behaved case we keep the user's drawn position (so the
-        // swept solid lands where the user expects). For the antiparallel case
-        // we manually canonicalize to (origin, XY plane), then call
-        // `Add(_, false, false)`. The canonicalization is necessary because
-        // `GeomFill_SectionPlacement::Transformation` builds its trsf as
-        // `Tf.SetTransformation(Saxe = gp_Ax3(0, +Z, +X), Paxe = trihedron)` —
-        // it implicitly assumes the section is at the world origin in XY and
-        // produces offset placements otherwise.
+        // The profile plane's own "up" (used previously) only works when it happens
+        // to equal that axis — true for a profile sketched on a world plane, but
+        // NOT for a plane built off a helix, whose in-plane axes are arbitrary.
+        // A wrong (e.g. roughly horizontal) binormal lets the helix tangent rotate
+        // into it, collapsing `Normal = BiNormal × Tangent` ~twice per turn and
+        // shredding the section into a self-intersecting ribbon. A straight spine
+        // has no rotation axis (the cross products vanish); there the profile's up
+        // is well-defined and never aligns with the constant tangent, so use it.
+        const spineAxis = SweepOps.tangentRotationAxis(spineWire.getShape());
+        const binormalVec = spineAxis ?? profilePlane.yDirection;
+        const [binormalDir, disposeBinormal] = Convert.toGpDir(binormalVec);
+        // `Add(_, false, true)` (no contact, with correction) rotates the profile
+        // to sit perpendicular to the spine tangent, about an axis given by
+        // `profile.normal × spine.tangent`. That axis is undefined when the two are
+        // anti-parallel — but then the profile plane is *already* perpendicular to
+        // the spine (its normal is ∥ -tangent), so no correction is needed: skip it
+        // and keep the profile's drawn position.
         const spineTangent = SweepOps.getSpineTangent(spineWire.getShape());
         const isAntiParallel = profilePlane.normal.dot(spineTangent) < -0.999;
-        let trsf = null;
-        let withCorrection = true;
-        if (isAntiParallel) {
-            const profileCentroid = SweepOps.getFaceCentroid(profileFaces[0].getShape());
-            trsf = SweepOps.profileToCanonicalFrameTrsf(profileCentroid, profilePlane.normal, profilePlane.xDirection);
-            withCorrection = false;
-        }
+        const withCorrection = !isAntiParallel;
         try {
             for (const face of profileFaces) {
-                let workingFace;
-                let transformer = null;
-                if (trsf) {
-                    transformer = new oc.BRepBuilderAPI_Transform(trsf);
-                    transformer.Perform(face.getShape(), true);
-                    workingFace = transformer.Shape();
-                }
-                else {
-                    workingFace = face.getShape();
-                }
-                const ocFace = oc.TopoDS.Face(workingFace);
+                const ocFace = oc.TopoDS.Face(face.getShape());
                 const outerWire = oc.BRepTools.OuterWire(ocFace);
-                const innerWires = trsf
-                    ? Explorer.findShapes(workingFace, Explorer.getOcShapeType("wire"))
-                        .filter(w => !w.IsSame(outerWire))
-                    : face.getWires().map(w => w.getShape()).filter(w => !w.IsSame(outerWire));
+                const innerWires = face.getWires()
+                    .map(w => w.getShape())
+                    .filter(w => !w.IsSame(outerWire));
                 const outer = SweepOps.sweepWire(spineWire.getShape(), outerWire, binormalDir, withCorrection);
                 let resultSolid = outer.solid;
                 let resultFirst = outer.firstFace;
@@ -115,11 +97,9 @@ export class SweepOps {
                 for (const s of solids) {
                     allSolids.push(Solid.fromTopoDSSolid(Explorer.toSolid(s)));
                 }
-                transformer?.delete();
             }
         }
         finally {
-            trsf?.delete();
             disposeBinormal();
         }
         if (allSolids.length === 0) {
@@ -135,10 +115,10 @@ export class SweepOps {
     static sweepWire(spine, profile, binormalDir, withCorrection) {
         const oc = getOC();
         const pipe = new oc.BRepOffsetAPI_MakePipeShell(spine);
-        // Fixed binormal (the profile plane's "up"): keeps the swept profile from
-        // twisting along the spine — a clean spring rather than a wobbling ribbon —
-        // and is well-defined on straight spines, where Frenet is not (zero
-        // curvature ⇒ undefined normal).
+        // Fixed binormal (the spine's tangent-rotation axis; see makeSweep): keeps
+        // the swept section from twisting — a clean coil rather than a wobbling
+        // ribbon — and is well-defined on straight spines, where Frenet is not
+        // (zero curvature ⇒ undefined normal).
         pipe.SetMode(binormalDir);
         // Give the swept-surface approximation enough spans for tapered/tight
         // helical spines (see MAX_PIPE_SEGMENTS) — at OCCT's default budget the
@@ -162,6 +142,41 @@ export class SweepOps {
         pipe.delete();
         return { solid, firstFace, lastFace };
     }
+    /**
+     * The axis the spine's tangent rotates around, = normalize(Σ Tᵢ × Tᵢ₊₁) over
+     * tangents sampled along the spine. For a planar spine this is the plane
+     * normal; for a helix it is the coil axis. For a straight spine the tangent
+     * is constant, every cross product vanishes, and it returns null.
+     */
+    static tangentRotationAxis(spine) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_CompCurve(spine, false);
+        const u0 = adaptor.FirstParameter();
+        const u1 = adaptor.LastParameter();
+        const SAMPLES = 64;
+        const tangents = [];
+        const pnt = new oc.gp_Pnt();
+        const vec = new oc.gp_Vec();
+        for (let i = 0; i <= SAMPLES; i++) {
+            const u = u0 + ((u1 - u0) * i) / SAMPLES;
+            adaptor.D1(u, pnt, vec);
+            const t = new Vector3d(vec.X(), vec.Y(), vec.Z());
+            if (t.length() > 1e-9) {
+                tangents.push(t.normalize());
+            }
+        }
+        pnt.delete();
+        vec.delete();
+        adaptor.delete();
+        let axis = new Vector3d(0, 0, 0);
+        for (let i = 0; i + 1 < tangents.length; i++) {
+            axis = axis.add(tangents[i].cross(tangents[i + 1]));
+        }
+        if (axis.length() < 1e-6) {
+            return null;
+        }
+        return axis.normalize();
+    }
     /** Unit tangent of the spine wire at its first parameter. */
     static getSpineTangent(spine) {
         const oc = getOC();
@@ -177,51 +192,4 @@ export class SweepOps {
         adaptor.delete();
         return tangent;
     }
-    /** World-space centroid of a planar face (uses surface-area properties). */
-    static getFaceCentroid(face) {
-        const oc = getOC();
-        const ocFace = oc.TopoDS.Face(face);
-        const props = new oc.GProp_GProps();
-        oc.BRepGProp.SurfaceProperties(ocFace, props, false, false);
-        const c = props.CentreOfMass();
-        const out = new Vector3d(c.X(), c.Y(), c.Z());
-        c.delete();
-        props.delete();
-        return out;
-    }
-    /**
-     * Build a world-to-world trsf that lays a planar face flat in world XY
-     * with its centroid at the world origin.
-     *
-     * `gp_Trsf::SetTransformation(A, B)` builds the transformation that maps
-     * frame A onto frame B (i.e., A's origin → B's origin, A's axes → B's
-     * axes). To move the profile *from* its current frame *to* the canonical
-     * frame, we pass the canonical frame as A and the profile's frame as B —
-     * counterintuitive but matches OCC's convention as verified empirically.
-     *
-     * The canonical frame is what OCC's MakePipeShell expects when
-     * WithContact/WithCorrection are both false: `Saxe = gp_Ax3(0, +Z, +X)`.
-     */
-    static profileToCanonicalFrameTrsf(centroid, normal, xDir) {
-        const oc = getOC();
-        const [originPnt, disposeOriginPnt] = Convert.toGpPnt(centroid);
-        const [normalDirGp, disposeNormalDir] = Convert.toGpDir(normal);
-        const [xDirGp, disposeXDirGp] = Convert.toGpDir(xDir);
-        const profileAx3 = new oc.gp_Ax3(originPnt, normalDirGp, xDirGp);
-        const zeroPnt = new oc.gp_Pnt(0, 0, 0);
-        const zDir = new oc.gp_Dir(0, 0, 1);
-        const xDirWorld = new oc.gp_Dir(1, 0, 0);
-        const canonicalAx3 = new oc.gp_Ax3(zeroPnt, zDir, xDirWorld);
-        const trsf = new oc.gp_Trsf();
-        trsf.SetTransformation(canonicalAx3, profileAx3);
-        profileAx3.delete();
-        canonicalAx3.delete();
-        zeroPnt.delete();
-        zDir.delete();
-        xDirWorld.delete();
-        disposeOriginPnt();
-        disposeNormalDir();
-        disposeXDirGp();
-        return trsf;
-    }
 }

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

@@ -11,19 +11,6 @@ export declare class ThinFaceMaker {
     static make(edges: (Wire | Edge)[], plane: Plane, offset1: number, offset2?: number): ThinFaceResult;
     private static makeSingleOffsetFace;
     private static makeDualOffsetFace;
-    /**
-     * 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.
-     */
-    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
@@ -33,12 +20,6 @@ export declare class ThinFaceMaker {
      * 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.
-     * Only handles positive distances — use doOffset for sign handling.
-     */
-    private static offsetWireOnPlane;
     /**
      * 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/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-extend-ops.d.ts

@@ -0,0 +1,12 @@
+import { Wire } from "../common/wire.js";
+export type WireEnd = "start" | "end";
+export declare class WireExtendOps {
+    /**
+     * Extends an open wire beyond one end by `length`, continuing straight along
+     * the wire's true tangent there. The new straight edge joins the existing
+     * first/last vertex, so the result is a single connected wire.
+     *
+     * No-op for closed wires, empty wires, or `length <= 0`.
+     */
+    static extendWire(wire: Wire, side: WireEnd, length: number): Wire;
+}

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

@@ -0,0 +1,42 @@
+import { EdgeOps } from "./edge-ops.js";
+import { WireOps } from "./wire-ops.js";
+import { PathSampler } from "./path-sampler.js";
+export class WireExtendOps {
+    /**
+     * Extends an open wire beyond one end by `length`, continuing straight along
+     * the wire's true tangent there. The new straight edge joins the existing
+     * first/last vertex, so the result is a single connected wire.
+     *
+     * No-op for closed wires, empty wires, or `length <= 0`.
+     */
+    static extendWire(wire, side, length) {
+        if (length <= 0) {
+            return wire;
+        }
+        const edges = wire.getEdges();
+        if (edges.length === 0) {
+            return wire;
+        }
+        const sampler = new PathSampler(wire);
+        try {
+            if (sampler.closed) {
+                return wire;
+            }
+            if (side === "start") {
+                // Tangent at the start points into the wire; extend the opposite way.
+                const startPt = wire.getFirstVertex().toPoint();
+                const inward = sampler.evalAt(0).tangent;
+                const extPt = startPt.add(inward.multiply(-length));
+                return WireOps.makeWireFromEdges([EdgeOps.makeLineEdge(extPt, startPt), ...edges]);
+            }
+            // Tangent at the end already points out of the wire.
+            const endPt = wire.getLastVertex().toPoint();
+            const outward = sampler.evalAt(sampler.length).tangent;
+            const extPt = endPt.add(outward.multiply(length));
+            return WireOps.makeWireFromEdges([...edges, EdgeOps.makeLineEdge(endPt, extPt)]);
+        }
+        finally {
+            sampler.dispose();
+        }
+    }
+}