fluidcad 0.0.36 → 0.0.38

package/lib/dist/oc/shape-hash.js

@@ -0,0 +1,32 @@
+import { getOC } from "./init.js";
+/**
+ * Produces stable, `IsSame`-consistent integer keys for TopoDS shapes so they can
+ * be used as JS `Map`/`Set` keys.
+ *
+ * OCCT 8.0 removed `TopoDS_Shape::HashCode`. This interns shapes in a
+ * `TopTools_IndexedMapOfShape` — whose hasher compares keys with `IsSame` — and
+ * returns each shape's stable 1-based index. That gives the same bucketing the old
+ * `HashCode` + `IsSame` check provided, but collision-free (the same `IsSame`
+ * sub-shape always maps to the same key, distinct sub-shapes never collide).
+ *
+ * Wraps an OCCT map, so it owns native memory: scope one per operation and
+ * `delete()` it when done. Follows the same indexed-map convention as
+ * {@link TopologyIndex}.
+ */
+export class ShapeHasher {
+    map;
+    constructor() {
+        this.map = new (getOC().TopTools_IndexedMapOfShape)();
+    }
+    /**
+     * Stable, `IsSame`-consistent key for `shape`. Interns the shape on first use; an
+     * as-yet-unseen shape gets a fresh key, so a `Map` lookup against keys from other
+     * shapes correctly misses.
+     */
+    key(shape) {
+        return this.map.Add(shape);
+    }
+    delete() {
+        this.map.delete();
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { TopTools_ListOfShape, TopoDS_Shape } from "occjs-wrapper";
+import type { TopTools_ListOfShape, TopoDS_Shape } from "ocjs-fluidcad";
 import { Matrix4 } from "../math/matrix4.js";
 import { Shape } from "../common/shape.js";
 import { Face } from "../common/face.js";
@@ -26,14 +26,16 @@ export declare class ShapeOps {
     static getBoundingBox(shape: Shape | TopoDS_Shape): BoundingBox;
     static getBoundingBoxRaw(shape: TopoDS_Shape): BoundingBox;
     static makeCompound(shapes: Shape[]): Shape;
-    static makeCompoundRaw(shapes: TopoDS_Shape[]): import("occjs-wrapper").TopoDS_Compound;
+    static makeCompoundRaw(shapes: TopoDS_Shape[]): import("ocjs-fluidcad").TopoDS_Compound;
     static cleanShape(shape: Shape): Shape;
     /**
      * Variant of `cleanShape` that preserves UnifySameDomain lineage via
      * `BRepTools_History`. Caller must call `dispose()` exactly once to free
      * the OC wrappers.
      */
-    static cleanShapeWithLineage(shape: Shape): CleanShapeLineage;
+    static cleanShapeWithLineage(shape: Shape, opts?: {
+        skipSimplify?: boolean;
+    }): CleanShapeLineage;
     static cleanShapeRaw(shape: TopoDS_Shape): TopoDS_Shape;
     static shapeListToArray(list: TopTools_ListOfShape): TopoDS_Shape[];
 }

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

@@ -78,11 +78,13 @@ export class ShapeOps {
      * `BRepTools_History`. Caller must call `dispose()` exactly once to free
      * the OC wrappers.
      */
-    static cleanShapeWithLineage(shape) {
+    static cleanShapeWithLineage(shape, opts) {
         const oc = getOC();
         const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
         const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
-        const unify = new oc.ShapeUpgrade_UnifySameDomain(shape.getShape(), false, true, false);
+        // skipSimplify: pass unifyFaces=false to avoid the slow face-merging step
+        // that hangs on tangent contact along curves (e.g., helix sweep + cylinder).
+        const unify = new oc.ShapeUpgrade_UnifySameDomain(shape.getShape(), false, opts?.skipSimplify ? false : true, false);
         unify.Build();
         const cleanedRaw = unify.Shape();
         // Pre-compute which faces/edges this cleanup saw so the remap can
@@ -127,15 +129,14 @@ export class ShapeOps {
                 dispose,
             };
         }
-        const historyHandle = unify.History();
-        const history = historyHandle.get();
+        const history = unify.History();
         let disposed = false;
         const dispose = () => {
             if (disposed) {
                 return;
             }
             disposed = true;
-            historyHandle.delete();
+            history.delete();
             unify.delete();
             knownFaces.delete();
             knownEdges.delete();

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Shape } from "occjs-wrapper";
+import type { TopoDS_Shape } from "ocjs-fluidcad";
 import { Solid } from "../common/solid.js";
 import { Wire } from "../common/wire.js";
 import { Face } from "../common/face.js";
@@ -8,5 +8,17 @@ export interface SweepResult {
     lastShape: TopoDS_Shape;
 }
 export declare class SweepOps {
+    private static readonly MAX_PIPE_SEGMENTS;
     static makeSweep(spineWire: Wire, profileFaces: Face[]): SweepResult;
+    /** Sweep a single wire along the spine with a fixed binormal. */
+    private static sweepWire;
+    /**
+     * 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 tangentRotationAxis;
+    /** Unit tangent of the spine wire at its first parameter. */
+    private static getSpineTangent;
 }

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

@@ -1,32 +1,107 @@
 import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
 import { Explorer } from "./explorer.js";
+import { ShapeOps } from "./shape-ops.js";
 import { Solid } from "../common/solid.js";
+import { Vector3d } from "../math/vector3d.js";
 export class SweepOps {
+    // Ceiling for MakePipeShell's swept-surface approximation. OCCT's default
+    // (~30) is too small for tapered or tightly-coiled helical spines, whose
+    // swept surfaces need many spans to fit within tolerance — at the default the
+    // build silently fails (BRepBuilderAPI_PipeNotDone). This only caps the
+    // adaptive fit; simple spines converge far below it at no extra cost.
+    static MAX_PIPE_SEGMENTS = 1000;
     static makeSweep(spineWire, profileFaces) {
         const oc = getOC();
         const allSolids = [];
         let firstShape = null;
         let lastShape = null;
-        for (const face of profileFaces) {
-            const pipe = new oc.BRepOffsetAPI_MakePipe(spineWire.getShape(), face.getShape());
-            const progress = new oc.Message_ProgressRange();
-            pipe.Build(progress);
-            progress.delete();
-            if (!pipe.IsDone()) {
-                pipe.delete();
-                throw new Error("Sweep operation failed.");
-            }
-            if (!firstShape) {
-                firstShape = pipe.FirstShape();
-                lastShape = pipe.LastShape();
-            }
-            const result = pipe.Shape();
-            pipe.delete();
-            const solids = Explorer.findShapes(result, Explorer.getOcShapeType("solid"));
-            for (const s of solids) {
-                allSolids.push(Solid.fromTopoDSSolid(Explorer.toSolid(s)));
+        const profilePlane = profileFaces[0].getPlane();
+        // 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.
+        //
+        // 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;
+        const withCorrection = !isAntiParallel;
+        try {
+            for (const face of profileFaces) {
+                const ocFace = oc.TopoDS.Face(face.getShape());
+                const outerWire = oc.BRepTools.OuterWire(ocFace);
+                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;
+                let resultLast = outer.lastFace;
+                for (const innerWire of innerWires) {
+                    const inner = SweepOps.sweepWire(spineWire.getShape(), oc.TopoDS.Wire(innerWire), binormalDir, withCorrection);
+                    const stockList = new oc.TopTools_ListOfShape();
+                    stockList.Append(resultSolid);
+                    const toolList = new oc.TopTools_ListOfShape();
+                    toolList.Append(inner.solid);
+                    const cut = new oc.BRepAlgoAPI_Cut();
+                    cut.SetArguments(stockList);
+                    cut.SetTools(toolList);
+                    const progress = new oc.Message_ProgressRange();
+                    cut.Build(progress);
+                    progress.delete();
+                    if (!cut.IsDone()) {
+                        cut.delete();
+                        stockList.delete();
+                        toolList.delete();
+                        throw new Error("Sweep hole cut failed.");
+                    }
+                    const newSolid = cut.Shape();
+                    // Track first/last faces through the cut. The outer's start/end
+                    // face becomes a hole-bearing face after cutting through it.
+                    const modFirst = ShapeOps.shapeListToArray(cut.Modified(resultFirst));
+                    const modLast = ShapeOps.shapeListToArray(cut.Modified(resultLast));
+                    if (modFirst.length > 0) {
+                        resultFirst = modFirst[0];
+                    }
+                    if (modLast.length > 0) {
+                        resultLast = modLast[0];
+                    }
+                    cut.delete();
+                    stockList.delete();
+                    toolList.delete();
+                    resultSolid = newSolid;
+                }
+                if (!firstShape) {
+                    firstShape = resultFirst;
+                    lastShape = resultLast;
+                }
+                const solids = Explorer.findShapes(resultSolid, Explorer.getOcShapeType("solid"));
+                for (const s of solids) {
+                    allSolids.push(Solid.fromTopoDSSolid(Explorer.toSolid(s)));
+                }
             }
         }
+        finally {
+            disposeBinormal();
+        }
         if (allSolids.length === 0) {
             throw new Error("Sweep produced no solids.");
         }
@@ -36,4 +111,85 @@ export class SweepOps {
             lastShape: lastShape,
         };
     }
+    /** Sweep a single wire along the spine with a fixed binormal. */
+    static sweepWire(spine, profile, binormalDir, withCorrection) {
+        const oc = getOC();
+        const pipe = new oc.BRepOffsetAPI_MakePipeShell(spine);
+        // 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
+        // build fails on, e.g., a conical helix or a many-turn helix on a cone face.
+        pipe.SetMaxSegments(SweepOps.MAX_PIPE_SEGMENTS);
+        pipe.Add(profile, false, withCorrection);
+        const progress = new oc.Message_ProgressRange();
+        pipe.Build(progress);
+        progress.delete();
+        if (!pipe.IsDone()) {
+            pipe.delete();
+            throw new Error("Sweep operation failed.");
+        }
+        if (!pipe.MakeSolid()) {
+            pipe.delete();
+            throw new Error("Sweep failed to produce a solid.");
+        }
+        const firstFace = pipe.FirstShape();
+        const lastFace = pipe.LastShape();
+        const solid = pipe.Shape();
+        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();
+        const adaptor = new oc.BRepAdaptor_CompCurve(spine, false);
+        const u0 = adaptor.FirstParameter();
+        const pnt = new oc.gp_Pnt();
+        const tan = new oc.gp_Vec();
+        adaptor.D1(u0, pnt, tan);
+        tan.Normalize();
+        const tangent = new Vector3d(tan.X(), tan.Y(), tan.Z());
+        pnt.delete();
+        tan.delete();
+        adaptor.delete();
+        return tangent;
+    }
 }

package/lib/dist/oc/text-outline.d.ts

@@ -0,0 +1,62 @@
+import type { Font } from "fontkit";
+import { Edge } from "../common/edge.js";
+import { Plane } from "../math/plane.js";
+import { Point, Point2D } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+export type TextAlign = "left" | "center" | "right" | "start" | "end" | "space-between" | "space-around";
+export interface TextLayoutOptions {
+    /** Em size in model units (mm). */
+    size: number;
+    align: TextAlign;
+    /** Multiplier applied to the font's natural line height (default 1). */
+    lineSpacing: number;
+    /** Extra advance added between glyphs, in model units (default 0). */
+    letterSpacing: number;
+}
+export interface TextPathOptions {
+    /**
+     * Evaluates a point + unit tangent at an arc-length distance along the
+     * path (expected to wrap on closed paths and extrapolate on open ones).
+     */
+    evalAt(s: number): {
+        point: Point;
+        tangent: Vector3d;
+    };
+    /** Total path length in model units; used for alignment. */
+    length: number;
+    /** Unit normal of the path's plane. Glyph "up" is `normal × tangent`. */
+    normal: Vector3d;
+    /** Perpendicular baseline shift in model units (toward glyph "up"). */
+    offset: number;
+    /** Extra arc-length shift of the text start along the path. */
+    startAt: number;
+    /** Mirror the text to the other side of the path, reversing direction. */
+    flip: boolean;
+    /** Whether the path is a closed loop (affects `space-between` gap distribution). */
+    closed: boolean;
+}
+/**
+ * Turns a text string into outline edges laid out on `plane`, suitable for
+ * FaceMaker2 (which resolves letter counters like the holes in `o`/`A`/`e` as
+ * faces-with-holes). Glyph outlines come from fontkit as M/L/Q/C/Z commands in
+ * font units; quadratic/cubic curves map to OCCT Bézier edges, lines to
+ * segment edges.
+ */
+export declare class TextOutline {
+    static buildEdges(font: Font, text: string, opts: TextLayoutOptions, plane: Plane, origin: Point2D): Edge[];
+    /**
+     * Lays out `text` along a curve: each glyph is placed rigidly (not bent) at
+     * the arc-length position of its advance midpoint, rotated to the local
+     * tangent. Spacing is measured as arc length, so kerning/letterSpacing
+     * carry over from straight text. Multi-line strings stack below the
+     * baseline via perpendicular offsets.
+     */
+    static buildEdgesAlongPath(font: Font, text: string, opts: TextLayoutOptions, path: TextPathOptions): Edge[];
+    private static buildLineAlongPath;
+    /** Maps the path-friendly alignment synonyms onto the base values. */
+    private static resolveAlign;
+    /** Total advance of a laid-out line (for alignment), excluding trailing letter spacing. */
+    private static totalAdvance;
+    private static buildLine;
+    private static buildGlyph;
+}

package/lib/dist/oc/text-outline.js

@@ -0,0 +1,212 @@
+import { Geometry } from "./geometry.js";
+import { Point2D } from "../math/point.js";
+/**
+ * Minimum edge length (model units) below which a segment/curve is treated as
+ * degenerate and skipped. Safely above OCCT's Precision::Confusion (1e-7) and
+ * far below any real glyph feature at typical sizes.
+ */
+const EPS = 1e-6;
+/**
+ * Turns a text string into outline edges laid out on `plane`, suitable for
+ * FaceMaker2 (which resolves letter counters like the holes in `o`/`A`/`e` as
+ * faces-with-holes). Glyph outlines come from fontkit as M/L/Q/C/Z commands in
+ * font units; quadratic/cubic curves map to OCCT Bézier edges, lines to
+ * segment edges.
+ */
+export class TextOutline {
+    static buildEdges(font, text, opts, plane, origin) {
+        const scale = opts.size / font.unitsPerEm;
+        const lineHeight = (font.ascent - font.descent + font.lineGap) * scale * opts.lineSpacing;
+        const lines = text.split(/\r?\n/);
+        const edges = [];
+        for (let li = 0; li < lines.length; li++) {
+            const lineY = origin.y - li * lineHeight;
+            this.buildLine(font, lines[li], opts, scale, plane, new Point2D(origin.x, lineY), edges);
+        }
+        return edges;
+    }
+    /**
+     * Lays out `text` along a curve: each glyph is placed rigidly (not bent) at
+     * the arc-length position of its advance midpoint, rotated to the local
+     * tangent. Spacing is measured as arc length, so kerning/letterSpacing
+     * carry over from straight text. Multi-line strings stack below the
+     * baseline via perpendicular offsets.
+     */
+    static buildEdgesAlongPath(font, text, opts, path) {
+        const scale = opts.size / font.unitsPerEm;
+        const lineHeight = (font.ascent - font.descent + font.lineGap) * scale * opts.lineSpacing;
+        const lines = text.split(/\r?\n/);
+        const edges = [];
+        for (let li = 0; li < lines.length; li++) {
+            this.buildLineAlongPath(font, lines[li], opts, scale, path, -li * lineHeight, edges);
+        }
+        return edges;
+    }
+    static buildLineAlongPath(font, line, opts, scale, path, lineOffset, out) {
+        if (line.length === 0) {
+            return;
+        }
+        const run = font.layout(line);
+        const total = this.totalAdvance(run.positions, opts, scale);
+        const align = this.resolveAlign(opts.align);
+        let s0 = path.startAt;
+        let justifyGap = 0;
+        if (align === "center") {
+            s0 += (path.length - total) / 2;
+        }
+        else if (align === "right") {
+            s0 += path.length - total;
+        }
+        else if (align === "space-between" && run.glyphs.length > 1) {
+            // Justify across the whole path: distribute the leftover arc length
+            // evenly between glyphs. On a closed loop the wrap-around gap counts
+            // too, so the glyphs end up evenly spaced around the loop.
+            const gaps = path.closed ? run.glyphs.length : run.glyphs.length - 1;
+            justifyGap = (path.length - total) / gaps;
+        }
+        else if (align === "space-around" && run.glyphs.length > 0) {
+            // Every glyph gets an equal share of the leftover arc length, half on
+            // each side — so the run starts and ends half a gap from the path's
+            // ends (on a closed loop this just phase-shifts the even spacing).
+            justifyGap = (path.length - total) / run.glyphs.length;
+            s0 += justifyGap / 2;
+        }
+        let pen = 0;
+        for (let i = 0; i < run.glyphs.length; i++) {
+            const pos = run.positions[i];
+            const adv = pos.xAdvance * scale;
+            // Anchor each glyph at the midpoint of its advance so it straddles the
+            // curve symmetrically (less lift-off on tight curvature).
+            const sMid = s0 + pen + adv / 2;
+            const frame = path.evalAt(path.flip ? path.length - sMid : sMid);
+            const tangent = path.flip ? frame.tangent.multiply(-1) : frame.tangent;
+            const up = path.normal.cross(tangent).normalize();
+            const anchor = frame.point;
+            const toWorld = (p) => {
+                const dx = ((pos.xOffset || 0) + p.x) * scale - adv / 2;
+                const dy = ((pos.yOffset || 0) + p.y) * scale + path.offset + lineOffset;
+                return anchor.add(tangent.multiply(dx)).add(up.multiply(dy));
+            };
+            this.buildGlyph(run.glyphs[i], scale, toWorld, out);
+            pen += adv + opts.letterSpacing + justifyGap;
+        }
+    }
+    /** Maps the path-friendly alignment synonyms onto the base values. */
+    static resolveAlign(align) {
+        if (align === "start") {
+            return "left";
+        }
+        if (align === "end") {
+            return "right";
+        }
+        return align;
+    }
+    /** Total advance of a laid-out line (for alignment), excluding trailing letter spacing. */
+    static totalAdvance(positions, opts, scale) {
+        let total = 0;
+        for (const pos of positions) {
+            total += pos.xAdvance * scale + opts.letterSpacing;
+        }
+        if (positions.length > 0) {
+            total -= opts.letterSpacing;
+        }
+        return total;
+    }
+    static buildLine(font, line, opts, scale, plane, origin, out) {
+        if (line.length === 0) {
+            return;
+        }
+        const run = font.layout(line);
+        const total = this.totalAdvance(run.positions, opts, scale);
+        const align = this.resolveAlign(opts.align);
+        let penX = origin.x;
+        if (align === "center") {
+            penX -= total / 2;
+        }
+        else if (align === "right") {
+            penX -= total;
+        }
+        for (let i = 0; i < run.glyphs.length; i++) {
+            const pos = run.positions[i];
+            const gx = penX + (pos.xOffset || 0) * scale;
+            const gy = origin.y + (pos.yOffset || 0) * scale;
+            const toWorld = (p) => plane.localToWorld(new Point2D(gx + p.x * scale, gy + p.y * scale));
+            this.buildGlyph(run.glyphs[i], scale, toWorld, out);
+            penX += pos.xAdvance * scale + opts.letterSpacing;
+        }
+    }
+    static buildGlyph(glyph, scale, toWorld, out) {
+        const commands = glyph.path?.commands;
+        if (!commands || commands.length === 0) {
+            return;
+        }
+        const dist = (a, b) => Math.hypot((a.x - b.x) * scale, (a.y - b.y) * scale);
+        const addSegment = (a, b) => {
+            if (dist(a, b) < EPS) {
+                return;
+            }
+            try {
+                out.push(Geometry.makeEdge(Geometry.makeSegment(toWorld(a), toWorld(b))));
+            }
+            catch {
+                // Skip a segment OCCT rejects; one bad edge shouldn't drop the glyph.
+            }
+        };
+        const addBezier = (poles) => {
+            if (poles.every(p => dist(p, poles[0]) < EPS)) {
+                return;
+            }
+            try {
+                out.push(Geometry.makeEdgeFromBezier(Geometry.makeBezierCurve(poles.map(toWorld))));
+            }
+            catch {
+                // Fall back to a straight chord if the curve can't be built.
+                addSegment(poles[0], poles[poles.length - 1]);
+            }
+        };
+        let cur = null;
+        let startPt = null;
+        const closeContour = () => {
+            if (cur && startPt) {
+                addSegment(cur, startPt);
+            }
+            cur = null;
+            startPt = null;
+        };
+        for (const cmd of commands) {
+            const a = cmd.args;
+            switch (cmd.command) {
+                case "moveTo":
+                    closeContour();
+                    cur = { x: a[0], y: a[1] };
+                    startPt = cur;
+                    break;
+                case "lineTo":
+                    if (cur) {
+                        const next = { x: a[0], y: a[1] };
+                        addSegment(cur, next);
+                        cur = next;
+                    }
+                    break;
+                case "quadraticCurveTo":
+                    if (cur) {
+                        const next = { x: a[2], y: a[3] };
+                        addBezier([cur, { x: a[0], y: a[1] }, next]);
+                        cur = next;
+                    }
+                    break;
+                case "bezierCurveTo":
+                    if (cur) {
+                        const next = { x: a[4], y: a[5] };
+                        addBezier([cur, { x: a[0], y: a[1] }, { x: a[2], y: a[3] }, next]);
+                        cur = next;
+                    }
+                    break;
+                case "closePath":
+                    closeContour();
+                    break;
+            }
+        }
+        closeContour();
+    }
+}

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,