fluidcad 0.0.36 → 0.0.37

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,26 @@ 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;
+    /** 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)`.
+     */
+    private static profileToCanonicalFrameTrsf;
 }

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

@@ -1,32 +1,127 @@
 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: 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.
+        //
+        // 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.
+        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;
+        }
+        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 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 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)));
+                }
+                transformer?.delete();
             }
         }
+        finally {
+            trsf?.delete();
+            disposeBinormal();
+        }
         if (allSolids.length === 0) {
             throw new Error("Sweep produced no solids.");
         }
@@ -36,4 +131,97 @@ 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 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).
+        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 };
+    }
+    /** 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;
+    }
+    /** 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/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/topology-index.d.ts

@@ -1,4 +1,4 @@
-import type { TopoDS_Shape, TopTools_IndexedDataMapOfShapeListOfShape, TopTools_MapOfShape } from "occjs-wrapper";
+import type { TopoDS_Shape, TopTools_IndexedDataMapOfShapeListOfShape, TopTools_MapOfShape } from "ocjs-fluidcad";
 export declare class TopologyIndex {
     static buildEdgeToFaces(root: TopoDS_Shape): TopTools_IndexedDataMapOfShapeListOfShape;
     static buildShapeSet(shapes: TopoDS_Shape[]): TopTools_MapOfShape;

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Vertex } from "occjs-wrapper";
+import type { TopoDS_Vertex } from "ocjs-fluidcad";
 import { Point } from "../math/point.js";
 import { Vertex } from "../common/vertex.js";
 export declare class VertexOps {

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Edge, TopoDS_Wire, TopoDS_Face } from "occjs-wrapper";
+import type { TopoDS_Edge, TopoDS_Wire, TopoDS_Face } from "ocjs-fluidcad";
 import { Vector3d } from "../math/vector3d.js";
 import { Wire } from "../common/wire.js";
 import { Edge } from "../common/edge.js";