fluidcad 0.0.35 → 0.0.37

package/lib/dist/io/font-registry.js

@@ -0,0 +1,272 @@
+import getSystemFontsDefault from "get-system-fonts";
+import { openSync, create } from "fontkit";
+import { readWorkspaceAssetBytes } from "./file-import.js";
+// get-system-fonts ships a CJS default export; nodenext types the default import
+// as the module namespace, so cast it to its callable signature (the runtime
+// default import is the function).
+const listSystemFonts = getSystemFontsDefault;
+/**
+ * A `.font(...)` argument is treated as a local workspace file when it ends in a
+ * font extension; otherwise it is a system family name (e.g. "Arial").
+ */
+const FONT_FILE_RE = /\.(ttf|otf|ttc|woff2?|dfont)$/i;
+/**
+ * Fallback families for common names that may be absent on a given OS. The OS
+ * matcher (fontconfig/CoreText/DirectWrite) would normally substitute these;
+ * since `get-system-fonts` only lists files, we substitute ourselves.
+ */
+const FAMILY_ALIASES = {
+    "arial": ["helvetica", "helvetica neue", "liberation sans", "arimo", "dejavu sans", "noto sans"],
+    "helvetica": ["helvetica neue", "arial", "liberation sans", "arimo", "dejavu sans", "noto sans"],
+    "times new roman": ["times", "liberation serif", "tinos", "dejavu serif", "noto serif"],
+    "times": ["times new roman", "liberation serif", "tinos", "dejavu serif"],
+    "courier new": ["courier", "liberation mono", "cousine", "dejavu sans mono", "noto sans mono"],
+    "courier": ["courier new", "liberation mono", "dejavu sans mono"],
+    "comic sans ms": ["comic neue", "dejavu sans"],
+    "segoe ui": ["liberation sans", "dejavu sans", "noto sans", "arial"],
+    "calibri": ["carlito", "liberation sans", "dejavu sans"],
+    "cambria": ["caladea", "liberation serif", "dejavu serif"],
+    "verdana": ["dejavu sans", "liberation sans", "noto sans"],
+    "tahoma": ["dejavu sans", "liberation sans"],
+};
+/**
+ * Preferred default families (in order) when no font is specified.
+ */
+const DEFAULT_FAMILIES = [
+    "helvetica", "arial", "liberation sans", "dejavu sans", "noto sans",
+    "segoe ui", "san francisco", "roboto",
+];
+function normName(name) {
+    return name.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function faces(opened) {
+    return opened.fonts ?? [opened];
+}
+function isItalic(font) {
+    if (font.italicAngle && Math.abs(font.italicAngle) > 0.01) {
+        return true;
+    }
+    return /italic|oblique/i.test(font.subfamilyName || "");
+}
+function weightOf(font) {
+    const os2 = font["OS/2"];
+    if (os2 && typeof os2.usWeightClass === "number") {
+        return os2.usWeightClass;
+    }
+    return /bold/i.test(font.subfamilyName || "") ? 700 : 400;
+}
+/**
+ * Resolves font names/paths to ready-to-use fontkit `Font` instances.
+ *
+ * `init()` enumerates system fonts (via `get-system-fonts`) once per process and
+ * builds a family -> variants index (via `fontkit`). `resolve()` is synchronous
+ * so it can be called from `SceneObject.build()`; it requires `init()` to have
+ * completed first, mirroring `getOC()` / `loadOC()`.
+ */
+export class FontRegistry {
+    static index = null;
+    static allFiles = [];
+    static fontCache = new Map();
+    static async init() {
+        if (this.index) {
+            return;
+        }
+        const index = new Map();
+        let files = [];
+        try {
+            files = await listSystemFonts();
+        }
+        catch (e) {
+            console.warn("FontRegistry: failed to list system fonts:", e.message);
+        }
+        this.allFiles = files;
+        for (const file of files) {
+            try {
+                for (const face of faces(openSync(file))) {
+                    if (!face || !face.familyName) {
+                        continue;
+                    }
+                    const key = normName(face.familyName);
+                    const variant = {
+                        path: file,
+                        psName: face.postscriptName,
+                        weight: weightOf(face),
+                        italic: isItalic(face),
+                    };
+                    const list = index.get(key);
+                    if (list) {
+                        list.push(variant);
+                    }
+                    else {
+                        index.set(key, [variant]);
+                    }
+                }
+            }
+            catch {
+                // Skip unreadable / unsupported font files.
+            }
+        }
+        this.index = index;
+        console.debug(`FontRegistry: indexed ${index.size} families from ${files.length} files`);
+    }
+    /**
+     * Resolves a font request into a ready fontkit `Font`. Never returns null:
+     * falls back through aliases -> default families -> any available font, and
+     * only throws if the machine has no usable fonts at all.
+     */
+    static resolve(opts) {
+        const weight = opts.weight ?? 400;
+        const italic = opts.italic ?? false;
+        const name = opts.font?.trim();
+        // 1. Local workspace file, detected by extension.
+        if (name && FONT_FILE_RE.test(name)) {
+            return this.loadLocalFile(name);
+        }
+        const index = this.ensureInit();
+        // 2. Requested system family (+ aliases).
+        if (name) {
+            const font = this.openFirstRenderable(this.collectVariants(normName(name), true), weight, italic);
+            if (font) {
+                return font;
+            }
+            console.warn(`FontRegistry: font "${name}" not usable; falling back to a default font.`);
+        }
+        // 3. Default family priority list.
+        for (const fam of DEFAULT_FAMILIES) {
+            const font = this.openFirstRenderable(this.collectVariants(fam, false), weight, italic);
+            if (font) {
+                return font;
+            }
+        }
+        // 4. Any indexed family.
+        const anyFamily = this.openFirstRenderable([...index.values()].flat(), weight, italic);
+        if (anyFamily) {
+            return anyFamily;
+        }
+        // 5. Any font file at all (index may be empty if name parsing failed).
+        for (const file of this.allFiles) {
+            const font = this.tryOpenFile(file);
+            if (font) {
+                return font;
+            }
+        }
+        throw new Error('No fonts available on this system. Install a font package, or specify a ' +
+            'local font file, e.g. text(...).font("fonts/MyFont.ttf").');
+    }
+    static ensureInit() {
+        if (!this.index) {
+            throw new Error("Fonts not initialized. Call FontRegistry.init() first.");
+        }
+        return this.index;
+    }
+    /** Collects a family's variants plus its alias families' variants, unsorted. */
+    static collectVariants(key, useAliases) {
+        const index = this.ensureInit();
+        const out = [];
+        const direct = index.get(key);
+        if (direct) {
+            out.push(...direct);
+        }
+        if (useAliases) {
+            for (const alias of FAMILY_ALIASES[key] ?? []) {
+                const list = index.get(normName(alias));
+                if (list) {
+                    out.push(...list);
+                }
+            }
+        }
+        return out;
+    }
+    /**
+     * Sorts variants by italic match then nearest weight, and opens the first that
+     * actually renders (skipping fonts that throw on outline access).
+     */
+    static openFirstRenderable(list, weight, italic) {
+        const sorted = [...list].sort((a, b) => {
+            const ai = a.italic === italic ? 0 : 1;
+            const bi = b.italic === italic ? 0 : 1;
+            if (ai !== bi) {
+                return ai - bi;
+            }
+            return Math.abs(a.weight - weight) - Math.abs(b.weight - weight);
+        });
+        for (const variant of sorted) {
+            const font = this.openVariant(variant);
+            if (font) {
+                return font;
+            }
+        }
+        return null;
+    }
+    /** Opens and validates a variant; caches the result, including known-bad (null). */
+    static openVariant(variant) {
+        const cacheKey = `${variant.path}|${variant.psName}`;
+        const cached = this.fontCache.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+        let font = null;
+        try {
+            // Do NOT pass the postscriptName as openSync's 2nd argument: for a single
+            // (non-collection) font that arg is treated as a *variation instance*
+            // name and throws on non-variable fonts. Open the file, then pick the
+            // matching face out of a collection (.ttc) ourselves.
+            const list = faces(openSync(variant.path));
+            const picked = list.find(f => f.postscriptName === variant.psName) ?? list[0];
+            // Weight/italic come from face selection above; we never call fontkit
+            // getVariation() — some fonts declare an fvar wght axis without the
+            // variable outline tables and throw lazily at layout() time.
+            font = picked && this.canRender(picked) ? picked : null;
+        }
+        catch {
+            font = null;
+        }
+        this.fontCache.set(cacheKey, font);
+        return font;
+    }
+    /** All indexed system font family names (lowercased). Useful for tooling/tests. */
+    static availableFamilies() {
+        return [...this.ensureInit().keys()];
+    }
+    static tryOpenFile(file) {
+        try {
+            const face = faces(openSync(file))[0];
+            if (face?.familyName && this.canRender(face)) {
+                return face;
+            }
+        }
+        catch {
+            // skip unreadable / unusable font file
+        }
+        return null;
+    }
+    /**
+     * A font is usable only if its outlines compute without throwing. Fonts that
+     * declare an fvar variation axis but lack the variable outline tables
+     * (gvar/glyf or CFF2) throw lazily when glyph paths are accessed.
+     */
+    static canRender(font) {
+        try {
+            const glyph = font.glyphForCodePoint(65); // 'A'
+            void glyph.path.commands;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static loadLocalFile(relPath) {
+        const cacheKey = `file:${relPath}`;
+        const cached = this.fontCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const bytes = readWorkspaceAssetBytes(relPath);
+        if (!bytes) {
+            throw new Error(`Font file not found in workspace: ${relPath}`);
+        }
+        const font = faces(create(Buffer.from(bytes)))[0];
+        this.fontCache.set(cacheKey, font);
+        return font;
+    }
+}

package/lib/dist/math/bspline-interpolation.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Global B-spline interpolation of planar points (The NURBS Book, §9.2.1):
+ * chord-length parameters, knots by averaging, and a banded linear system
+ * solved densely. The resulting curve passes through every input point and
+ * is C2 (for the cubic case).
+ *
+ * Exists because fluidcad-ocjs currently miscompiles the `Geom2dAPI` fitting
+ * classes (both their constructors and `Init` produce corrupted curves);
+ * `Geom2d_BSplineCurve`'s array constructor is unaffected, so we compute the
+ * poles/knots ourselves and hand them over.
+ */
+export interface XY {
+    x: number;
+    y: number;
+}
+export interface BSpline2dData {
+    poles: XY[];
+    /** Distinct knot values (OCC convention). */
+    knots: number[];
+    /** Multiplicity per distinct knot. */
+    multiplicities: number[];
+    degree: number;
+}
+/**
+ * Interpolates the given planar points with a B-spline of degree up to 3
+ * (lower for 2 or 3 points). The curve passes exactly through every point,
+ * in order, parameterized by chord length.
+ */
+export declare function interpolateBSpline2d(rawPoints: ReadonlyArray<XY>): BSpline2dData;

package/lib/dist/math/bspline-interpolation.js

@@ -0,0 +1,194 @@
+/**
+ * Global B-spline interpolation of planar points (The NURBS Book, §9.2.1):
+ * chord-length parameters, knots by averaging, and a banded linear system
+ * solved densely. The resulting curve passes through every input point and
+ * is C2 (for the cubic case).
+ *
+ * Exists because fluidcad-ocjs currently miscompiles the `Geom2dAPI` fitting
+ * classes (both their constructors and `Init` produce corrupted curves);
+ * `Geom2d_BSplineCurve`'s array constructor is unaffected, so we compute the
+ * poles/knots ourselves and hand them over.
+ */
+/** Largest knot span index whose half-open interval contains t. */
+function findSpan(poleCount, degree, t, flatKnots) {
+    const n = poleCount - 1;
+    if (t >= flatKnots[n + 1]) {
+        return n;
+    }
+    let low = degree;
+    let high = n + 1;
+    let mid = (low + high) >> 1;
+    while (t < flatKnots[mid] || t >= flatKnots[mid + 1]) {
+        if (t < flatKnots[mid]) {
+            high = mid;
+        }
+        else {
+            low = mid;
+        }
+        mid = (low + high) >> 1;
+    }
+    return mid;
+}
+/** Nonzero basis function values N[span-degree .. span] at t (Cox–de Boor). */
+function basisFunctions(span, t, degree, flatKnots) {
+    const values = [1];
+    const left = [];
+    const right = [];
+    for (let j = 1; j <= degree; j++) {
+        left[j] = t - flatKnots[span + 1 - j];
+        right[j] = flatKnots[span + j] - t;
+        let saved = 0;
+        for (let r = 0; r < j; r++) {
+            const temp = values[r] / (right[r + 1] + left[j - r]);
+            values[r] = saved + right[r + 1] * temp;
+            saved = left[j - r] * temp;
+        }
+        values[j] = saved;
+    }
+    return values;
+}
+/** Gaussian elimination with partial pivoting; solves A·x = b for both RHS columns. */
+function solveDense(matrix, rhsX, rhsY) {
+    const n = matrix.length;
+    for (let col = 0; col < n; col++) {
+        let pivot = col;
+        for (let row = col + 1; row < n; row++) {
+            if (Math.abs(matrix[row][col]) > Math.abs(matrix[pivot][col])) {
+                pivot = row;
+            }
+        }
+        if (Math.abs(matrix[pivot][col]) < 1e-14) {
+            throw new Error("B-spline interpolation: singular system (degenerate or duplicate points)");
+        }
+        if (pivot !== col) {
+            [matrix[pivot], matrix[col]] = [matrix[col], matrix[pivot]];
+            [rhsX[pivot], rhsX[col]] = [rhsX[col], rhsX[pivot]];
+            [rhsY[pivot], rhsY[col]] = [rhsY[col], rhsY[pivot]];
+        }
+        for (let row = col + 1; row < n; row++) {
+            const factor = matrix[row][col] / matrix[col][col];
+            if (factor === 0) {
+                continue;
+            }
+            for (let k = col; k < n; k++) {
+                matrix[row][k] -= factor * matrix[col][k];
+            }
+            rhsX[row] -= factor * rhsX[col];
+            rhsY[row] -= factor * rhsY[col];
+        }
+    }
+    const x = new Array(n);
+    const y = new Array(n);
+    for (let row = n - 1; row >= 0; row--) {
+        let sumX = rhsX[row];
+        let sumY = rhsY[row];
+        for (let k = row + 1; k < n; k++) {
+            sumX -= matrix[row][k] * x[k];
+            sumY -= matrix[row][k] * y[k];
+        }
+        x[row] = sumX / matrix[row][row];
+        y[row] = sumY / matrix[row][row];
+    }
+    return { x, y };
+}
+/** Drops consecutive points closer than a millionth of the total chord. */
+function dedupe(points) {
+    let total = 0;
+    for (let i = 1; i < points.length; i++) {
+        total += Math.hypot(points[i].x - points[i - 1].x, points[i].y - points[i - 1].y);
+    }
+    const minChord = Math.max(1e-12, total * 1e-6);
+    const result = [points[0]];
+    for (let i = 1; i < points.length; i++) {
+        const prev = result[result.length - 1];
+        if (Math.hypot(points[i].x - prev.x, points[i].y - prev.y) >= minChord) {
+            result.push(points[i]);
+        }
+    }
+    // Never drop the true endpoint: replace the last kept point if needed.
+    const last = points[points.length - 1];
+    const kept = result[result.length - 1];
+    if (kept.x !== last.x || kept.y !== last.y) {
+        if (result.length > 1) {
+            result[result.length - 1] = last;
+        }
+        else {
+            result.push(last);
+        }
+    }
+    return result;
+}
+/**
+ * Interpolates the given planar points with a B-spline of degree up to 3
+ * (lower for 2 or 3 points). The curve passes exactly through every point,
+ * in order, parameterized by chord length.
+ */
+export function interpolateBSpline2d(rawPoints) {
+    const points = dedupe(rawPoints);
+    if (points.length < 2) {
+        throw new Error("B-spline interpolation needs at least two distinct points");
+    }
+    const n = points.length - 1;
+    const degree = Math.min(3, n);
+    // Chord-length parameters, normalized to [0, 1].
+    const params = new Array(points.length);
+    params[0] = 0;
+    for (let i = 1; i <= n; i++) {
+        params[i] = params[i - 1] + Math.hypot(points[i].x - points[i - 1].x, points[i].y - points[i - 1].y);
+    }
+    const total = params[n];
+    for (let i = 1; i <= n; i++) {
+        params[i] /= total;
+    }
+    params[n] = 1;
+    // Knots by averaging (NURBS book eq. 9.8): clamped ends, one internal knot
+    // per unconstrained pole.
+    const flatKnots = [];
+    for (let i = 0; i <= degree; i++) {
+        flatKnots.push(0);
+    }
+    for (let j = 1; j <= n - degree; j++) {
+        let sum = 0;
+        for (let i = j; i <= j + degree - 1; i++) {
+            sum += params[i];
+        }
+        flatKnots.push(sum / degree);
+    }
+    for (let i = 0; i <= degree; i++) {
+        flatKnots.push(1);
+    }
+    // Interpolation system: one basis row per parameter.
+    const matrix = [];
+    const rhsX = [];
+    const rhsY = [];
+    for (let k = 0; k <= n; k++) {
+        const row = new Array(n + 1).fill(0);
+        const span = findSpan(n + 1, degree, params[k], flatKnots);
+        const values = basisFunctions(span, params[k], degree, flatKnots);
+        for (let j = 0; j <= degree; j++) {
+            row[span - degree + j] = values[j];
+        }
+        matrix.push(row);
+        rhsX.push(points[k].x);
+        rhsY.push(points[k].y);
+    }
+    const solved = solveDense(matrix, rhsX, rhsY);
+    // Convert the flat knot vector to OCC's distinct-knots + multiplicities.
+    const knots = [];
+    const multiplicities = [];
+    for (const knot of flatKnots) {
+        if (knots.length > 0 && knot === knots[knots.length - 1]) {
+            multiplicities[multiplicities.length - 1]++;
+        }
+        else {
+            knots.push(knot);
+            multiplicities.push(1);
+        }
+    }
+    return {
+        poles: solved.x.map((x, i) => ({ x, y: solved.y[i] })),
+        knots,
+        multiplicities,
+        degree,
+    };
+}

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

@@ -1,10 +1,11 @@
-import type { BRepAlgoAPI_Cut, TopoDS_Shape } from "occjs-wrapper";
+import type { BRepAlgoAPI_Cut, TopoDS_Shape } from "ocjs-fluidcad";
 import { Shape } from "../common/shape.js";
 import { Solid } from "../common/solid.js";
 import { Edge } from "../common/edge.js";
 import { Face } from "../common/face.js";
 import { Plane } from "../math/plane.js";
 export declare class BooleanOps {
+    private static readonly FEATURE_BOOLEAN_FUZZY;
     static cutShapes(shape: Shape, tool: Shape): Shape;
     static cutShapesRaw(shape: TopoDS_Shape, tool: TopoDS_Shape): TopoDS_Shape;
     static cutMultiShape(stocks: Shape[], tools: Shape[], plane?: Plane, cutDistance?: number): {
@@ -33,6 +34,7 @@ export declare class BooleanOps {
      */
     static fuseStockAndTools(stock: Shape[], tools: Shape[], opts?: {
         glue?: 'full' | 'shift';
+        skipSimplify?: boolean;
     }): {
         result: Shape[];
         modifiedShapes: Shape[];

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

@@ -7,6 +7,16 @@ import { Edge } from "../common/edge.js";
 import { Face } from "../common/face.js";
 import { EdgeOps } from "./edge-ops.js";
 export class BooleanOps {
+    // Fuzzy tolerance (mm) for the feature cut/fuse builders. A swept tube whose
+    // path lies on a face it's cut from / fused to (e.g. a helical thread at the
+    // cylinder's own radius) touches that face tangentially along the contact
+    // curves; at zero fuzz OCCT's BOPAlgo silently no-ops (cut removes nothing,
+    // fuse returns an empty compound → "Unknown shape type"). A small fuzzy value
+    // resolves the near-coincident contact into clean intersections. 1e-4 is the
+    // smallest that works reliably here (1e-5 lands in a worse-than-zero regime);
+    // at 1e-4 mm it's far below any real feature size, so well-separated geometry
+    // is unaffected.
+    static FEATURE_BOOLEAN_FUZZY = 1e-4;
     static cutShapes(shape, tool) {
         const result = BooleanOps.cutShapesRaw(shape.getShape(), tool.getShape());
         return ShapeFactory.fromShape(result);
@@ -49,6 +59,7 @@ export class BooleanOps {
         cutMaker.SetTools(toolList);
         cutMaker.SetNonDestructive(true);
         cutMaker.SetRunParallel(true);
+        cutMaker.SetFuzzyValue(BooleanOps.FEATURE_BOOLEAN_FUZZY);
         cutMaker.Build(progress);
         const result = cutMaker.Shape();
         const resultSolids = Explorer.findShapes(result, Explorer.getOcShapeType("solid"));
@@ -162,6 +173,7 @@ export class BooleanOps {
         builder.SetNonDestructive(true);
         builder.SetCheckInverted(true);
         builder.SetRunParallel(true);
+        builder.SetFuzzyValue(BooleanOps.FEATURE_BOOLEAN_FUZZY);
         if (opts?.glue === 'full') {
             builder.SetGlue(oc.BOPAlgo_GlueEnum.BOPAlgo_GlueFull);
         }
@@ -185,7 +197,9 @@ export class BooleanOps {
         builder.SetTools(toolList);
         const progress = new oc.Message_ProgressRange();
         builder.Build(progress);
-        builder.SimplifyResult(false, true, oc.Precision.Angular());
+        if (!opts?.skipSimplify) {
+            builder.SimplifyResult(false, true, oc.Precision.Angular());
+        }
         const resultShape = builder.Shape();
         const rawShapes = Explorer.findAllShapes(resultShape);
         const result = rawShapes.map(s => ShapeFactory.fromShape(s));

package/lib/dist/oc/color-transfer.d.ts

@@ -1,4 +1,4 @@
-import type { BRepBuilderAPI_MakeShape } from "occjs-wrapper";
+import type { BRepBuilderAPI_MakeShape } from "ocjs-fluidcad";
 import { Shape } from "../common/shape.js";
 import type { CleanShapeLineage } from "./shape-ops.js";
 /**

package/lib/dist/oc/constraints/constraint-helpers.d.ts

@@ -1,14 +1,14 @@
-import type { GccEnt_Position, gp_Circ, gp_Circ2d, gp_Lin, gp_Lin2d, gp_Pln, gp_Pnt, gp_Pnt2d, Handle_Geom_Curve } from "occjs-wrapper";
+import type { GccEnt_Position, Geom_Curve, gp_Circ, gp_Circ2d, gp_Lin, gp_Lin2d, gp_Pln, gp_Pnt, gp_Pnt2d } from "ocjs-fluidcad";
 import { ConstraintQualifier } from "../../features/2d/constraints/qualified-geometry.js";
 import { Point2D } from "../../math/point.js";
 import { Edge } from "../../common/edge.js";
 import { Shape } from "../../common/shape.js";
 import { Plane } from "../../math/plane.js";
 export declare function get2dGeometry<T extends gp_Circ | gp_Lin | gp_Pnt>(plane: gp_Pln, geometry: T): gp_Lin2d | gp_Circ2d | gp_Pnt2d;
-export declare function get2dCurve(plane: gp_Pln, curve: Handle_Geom_Curve): import("occjs-wrapper").Handle_Geom2d_Curve;
+export declare function get2dCurve(plane: gp_Pln, curve: Geom_Curve): import("ocjs-fluidcad").Geom2d_Curve;
 export declare function getQualifier(qualifier: ConstraintQualifier): GccEnt_Position;
-export declare function getQualifiedCurve(plane: gp_Pln, curve: Handle_Geom_Curve, qualifier: ConstraintQualifier): import("occjs-wrapper").Geom2dGcc_QualifiedCurve;
-export declare function getQualifiedGeometry(plane: gp_Pln, geometry: gp_Circ | gp_Lin, qualifier: ConstraintQualifier): import("occjs-wrapper").GccEnt_QualifiedCirc | import("occjs-wrapper").GccEnt_QualifiedLin;
+export declare function getQualifiedCurve(plane: gp_Pln, curve: Geom_Curve, qualifier: ConstraintQualifier): import("ocjs-fluidcad").Geom2dGcc_QualifiedCurve;
+export declare function getQualifiedGeometry(plane: gp_Pln, geometry: gp_Circ | gp_Lin, qualifier: ConstraintQualifier): import("ocjs-fluidcad").GccEnt_QualifiedCirc | import("ocjs-fluidcad").GccEnt_QualifiedLin;
 export declare function calculateTangent(solutions: {
     center: gp_Pnt2d;
     radius: number;

package/lib/dist/oc/constraints/curve/tangent-circle-solver.js

@@ -67,15 +67,16 @@ export class CurveTangentCircleSolver {
         const tolerance = oc.Precision.Angular();
         const [pln, disposePln] = Convert.toGpPln(plane);
         const [pnt, disposePnt] = Convert.toGpPnt2d(vertex.toPoint2D());
+        // Handles are unwrapped in V8: pass the Geom2d_CartesianPoint straight to the
+        // solver (constructing the abstract oc.Geom2d_Point base throws at runtime).
         const geom2dPnt = new oc.Geom2d_CartesianPoint(pnt);
-        const handle = new oc.Handle_Geom2d_Point(geom2dPnt);
         disposePnt();
         const curve = this.getCurve(lineShape.shape);
         const qualifiedCurve = getQualifiedCurve(pln, curve, lineShape.qualifier);
-        const solver = new oc.Geom2dGcc_Circ2d2TanRad(qualifiedCurve, handle, radius, tolerance);
+        const solver = new oc.Geom2dGcc_Circ2d2TanRad(qualifiedCurve, geom2dPnt, radius, tolerance);
         const solutions = this.getSolutions(solver, plane);
         disposePln();
-        handle.delete();
+        geom2dPnt.delete();
         return solutions;
     }
     getSolutions(solver, plane) {
@@ -102,11 +103,11 @@ export class CurveTangentCircleSolver {
     }
     getCurve(shape) {
         const oc = getOC();
-        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
-        const curve = adaptor.Curve();
-        const handle = curve.Curve();
-        curve.delete();
-        adaptor.delete();
-        return handle;
+        // BRepAdaptor_Curve no longer exposes Curve() in OCCT 8.0. BRep_Tool.Curve
+        // returns the underlying Geom_Curve with the edge's location applied (world
+        // space) — the same geometry the adaptor chain used to yield — which is what
+        // GeomAPI.To2d / the Gcc qualifier expect.
+        const edge = oc.TopoDS.Edge(shape.getShape());
+        return oc.BRep_Tool.Curve(edge, 0, 1).returnValue;
     }
 }

package/lib/dist/oc/constraints/curve/tangent-line-solver.js

@@ -73,11 +73,10 @@ export class CurveTangentLineSolver {
     }
     getCurve(shape) {
         const oc = getOC();
-        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
-        const curve = adaptor.Curve();
-        const handle = curve.Curve();
-        curve.delete();
-        adaptor.delete();
-        return handle;
+        // BRepAdaptor_Curve no longer exposes Curve() in OCCT 8.0. BRep_Tool.Curve
+        // returns the underlying Geom_Curve with the edge's location applied (world
+        // space) — the same geometry the adaptor chain used to yield.
+        const edge = oc.TopoDS.Edge(shape.getShape());
+        return oc.BRep_Tool.Curve(edge, 0, 1).returnValue;
     }
 }

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

@@ -1,4 +1,4 @@
-import type { gp_Pnt, gp_Pnt2d, gp_Vec, gp_Dir, gp_Ax1, gp_Ax2, gp_Ax3, gp_Pln, gp_Trsf, gp_Quaternion } from "occjs-wrapper";
+import type { gp_Pnt, gp_Pnt2d, gp_Vec, gp_Dir, gp_Ax1, gp_Ax2, gp_Ax3, gp_Pln, gp_Trsf, gp_Quaternion } from "ocjs-fluidcad";
 import { Point, Point2D } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
 import { Axis } from "../math/axis.js";

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Shape } from "occjs-wrapper";
+import type { TopoDS_Shape } from "ocjs-fluidcad";
 import { Shape } from "../common/shape.js";
 export declare class DraftOps {
     static applyDraft(solid: Shape, faceRaws: TopoDS_Shape[], angle: number): Shape;

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Edge, TopoDS_Vertex } from "occjs-wrapper";
+import type { TopoDS_Edge, TopoDS_Vertex } from "ocjs-fluidcad";
 import { Axis } from "../math/axis.js";
 import { Point } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
@@ -20,7 +20,7 @@ export declare class EdgeOps {
     static getLastVertexRaw(edge: TopoDS_Edge): TopoDS_Vertex;
     static edgeToAxisRaw(edge: TopoDS_Edge): Axis;
     static axisToEdgeRaw(axis: Axis): TopoDS_Edge;
-    static edgeMiddlePoint(edge: TopoDS_Edge): import("occjs-wrapper").gp_Pnt;
+    static edgeMiddlePoint(edge: TopoDS_Edge): import("ocjs-fluidcad").gp_Pnt;
     static getVertexPointRaw(vertex: TopoDS_Vertex): Point;
     static getEdgeMidPointRaw(edge: TopoDS_Edge): Point;
     static reverseEdgeRaw(edge: TopoDS_Edge): TopoDS_Edge;