fluidcad 0.0.36 → 0.0.37

package/lib/dist/filters/edge/belongs-to-face.d.ts

@@ -1,6 +1,7 @@
 import { Matrix4 } from "../../math/matrix4.js";
 import { Edge, Face } from "../../common/shapes.js";
 import { Solid } from "../../common/solid.js";
+import { ShapeHasher } from "../../oc/shape-hash.js";
 import { FilterBase } from "../filter-base.js";
 import { FilterBuilderBase } from "../filter-builder-base.js";
 declare abstract class BelongsToFaceFilterBase extends FilterBase<Edge> {
@@ -8,8 +9,9 @@ declare abstract class BelongsToFaceFilterBase extends FilterBase<Edge> {
     protected scopeSolids: Solid[];
     protected scopeFaces: Face[];
     protected faceByHash: Map<number, Face[]>;
+    protected shapeHasher: ShapeHasher | null;
     constructor(faceFilterBuilders: FilterBuilderBase<Face>[]);
-    setScopeIndex(solids: Solid[], extraFaces: Face[], faceByHash: Map<number, Face[]>): void;
+    setScopeIndex(solids: Solid[], extraFaces: Face[], faceByHash: Map<number, Face[]>, hasher: ShapeHasher): void;
     protected findContainingFaces(edge: Edge): Face[];
 }
 export declare class BelongsToFaceFilter extends BelongsToFaceFilterBase {

package/lib/dist/filters/edge/belongs-to-face.js

@@ -7,14 +7,16 @@ class BelongsToFaceFilterBase extends FilterBase {
     scopeSolids = [];
     scopeFaces = [];
     faceByHash = new Map();
+    shapeHasher = null;
     constructor(faceFilterBuilders) {
         super();
         this.faceFilterBuilders = faceFilterBuilders;
     }
-    setScopeIndex(solids, extraFaces, faceByHash) {
+    setScopeIndex(solids, extraFaces, faceByHash, hasher) {
         this.scopeSolids = solids;
         this.scopeFaces = extraFaces;
         this.faceByHash = faceByHash;
+        this.shapeHasher = hasher;
     }
     findContainingFaces(edge) {
         const edgeShape = edge.getShape();
@@ -24,7 +26,7 @@ class BelongsToFaceFilterBase extends FilterBase {
             const index = solid.getEdgeToFacesIndex();
             const rawFaces = TopologyIndex.seekShapes(index, edgeShape);
             for (const raw of rawFaces) {
-                const wrapper = resolveFaceWrapper(raw, this.faceByHash);
+                const wrapper = resolveFaceWrapper(raw, this.faceByHash, this.shapeHasher);
                 if (wrapper && !seen.has(wrapper)) {
                     seen.add(wrapper);
                     result.push(wrapper);
@@ -93,9 +95,9 @@ export class NotBelongsToFaceFilter extends BelongsToFaceFilterBase {
         return new NotBelongsToFaceFilter(transformed);
     }
 }
-function resolveFaceWrapper(rawFace, faceByHash) {
-    const hash = rawFace.HashCode(2147483647);
-    const bucket = faceByHash.get(hash);
+function resolveFaceWrapper(rawFace, faceByHash, hasher) {
+    const hash = hasher ? hasher.key(rawFace) : null;
+    const bucket = hash !== null ? faceByHash.get(hash) : undefined;
     if (bucket) {
         for (const candidate of bucket) {
             if (candidate.getShape().IsSame(rawFace)) {
@@ -106,11 +108,13 @@ function resolveFaceWrapper(rawFace, faceByHash) {
     // Not in scope (e.g. neighbor face from another part / out-of-scope solid).
     // Wrap on the fly so the face filters can still evaluate it.
     const wrapped = Face.fromTopoDSFace(Explorer.toFace(rawFace));
-    if (!bucket) {
-        faceByHash.set(hash, [wrapped]);
-    }
-    else {
-        bucket.push(wrapped);
+    if (hash !== null) {
+        if (!bucket) {
+            faceByHash.set(hash, [wrapped]);
+        }
+        else {
+            bucket.push(wrapped);
+        }
     }
     return wrapped;
 }

package/lib/dist/filters/filter.d.ts

@@ -4,5 +4,5 @@ export declare class ShapeFilter {
     private shapes;
     private builders;
     constructor(shapes: Shape[], ...filterBuilders: FilterBuilderBase[]);
-    apply(): Shape<import("occjs-wrapper").TopoDS_Shape>[];
+    apply(): Shape<import("ocjs-fluidcad").TopoDS_Shape>[];
 }

package/lib/dist/filters/from-object.d.ts

@@ -1,4 +1,4 @@
-import type { TopTools_MapOfShape } from "occjs-wrapper";
+import type { TopTools_MapOfShape } from "ocjs-fluidcad";
 import { Matrix4 } from "../math/matrix4.js";
 import { Shape } from "../common/shapes.js";
 import { ShapeType } from "../common/shape-type.js";

package/lib/dist/filters/tangent-expander.d.ts

@@ -1,4 +1,4 @@
-import type { TopoDS_Edge } from "occjs-wrapper";
+import type { TopoDS_Edge } from "ocjs-fluidcad";
 import { Shape, Edge, Face } from "../common/shapes.js";
 export declare class TangentExpander {
     /**

package/lib/dist/filters/tangent-expander.js

@@ -1,4 +1,5 @@
 import { getOC } from "../oc/init.js";
+import { ShapeHasher } from "../oc/shape-hash.js";
 export class TangentExpander {
     /**
      * Expands a set of seed shapes to include all transitively tangent-connected
@@ -20,48 +21,64 @@ export class TangentExpander {
      * and their tangent vectors at that vertex are parallel.
      */
     static expandEdges(seeds, pool) {
-        // Build vertex → edge adjacency map for efficient lookup
-        const vertexToEdges = TangentExpander.buildVertexToEdgeMap(pool);
-        const included = new Set(seeds);
-        const queue = [...seeds];
-        while (queue.length > 0) {
-            const current = queue.shift();
-            const neighbors = TangentExpander.getAdjacentEdges(current, vertexToEdges);
-            for (const candidate of neighbors) {
-                if (included.has(candidate)) {
-                    continue;
-                }
-                if (TangentExpander.areEdgesTangent(current, candidate)) {
-                    included.add(candidate);
-                    queue.push(candidate);
+        // Interns shapes for IsSame-consistent Map keys (replaces TopoDS_Shape.HashCode,
+        // removed in OCCT 8.0); scoped to this expansion and freed below.
+        const hasher = new ShapeHasher();
+        try {
+            // Build vertex → edge adjacency map for efficient lookup
+            const vertexToEdges = TangentExpander.buildVertexToEdgeMap(pool, hasher);
+            const included = new Set(seeds);
+            const queue = [...seeds];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                const neighbors = TangentExpander.getAdjacentEdges(current, vertexToEdges, hasher);
+                for (const candidate of neighbors) {
+                    if (included.has(candidate)) {
+                        continue;
+                    }
+                    if (TangentExpander.areEdgesTangent(current, candidate)) {
+                        included.add(candidate);
+                        queue.push(candidate);
+                    }
                 }
             }
+            return [...included];
+        }
+        finally {
+            hasher.delete();
         }
-        return [...included];
     }
     /**
      * BFS expansion for faces. Two faces are tangent if they share an edge
      * and have G1 or higher continuity across that edge.
      */
     static expandFaces(seeds, pool) {
-        // Build edge → face adjacency map
-        const edgeToFaces = TangentExpander.buildEdgeToFaceMap(pool);
-        const included = new Set(seeds);
-        const queue = [...seeds];
-        while (queue.length > 0) {
-            const current = queue.shift();
-            const neighbors = TangentExpander.getAdjacentFaces(current, edgeToFaces);
-            for (const [candidate, sharedEdge] of neighbors) {
-                if (included.has(candidate)) {
-                    continue;
-                }
-                if (TangentExpander.areFacesTangent(current, candidate, sharedEdge)) {
-                    included.add(candidate);
-                    queue.push(candidate);
+        // Interns shapes for IsSame-consistent Map keys (replaces TopoDS_Shape.HashCode,
+        // removed in OCCT 8.0); scoped to this expansion and freed below.
+        const hasher = new ShapeHasher();
+        try {
+            // Build edge → face adjacency map
+            const edgeToFaces = TangentExpander.buildEdgeToFaceMap(pool, hasher);
+            const included = new Set(seeds);
+            const queue = [...seeds];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                const neighbors = TangentExpander.getAdjacentFaces(current, edgeToFaces, hasher);
+                for (const [candidate, sharedEdge] of neighbors) {
+                    if (included.has(candidate)) {
+                        continue;
+                    }
+                    if (TangentExpander.areFacesTangent(current, candidate, sharedEdge)) {
+                        included.add(candidate);
+                        queue.push(candidate);
+                    }
                 }
             }
+            return [...included];
+        }
+        finally {
+            hasher.delete();
         }
-        return [...included];
     }
     /**
      * Checks if two edges are tangent at a shared vertex by comparing
@@ -89,10 +106,10 @@ export class TangentExpander {
             }
             // Get raw curves and parameters at the shared vertex
             const curve1Handle = oc.BRep_Tool.Curve(e1Raw, 0, 1);
-            const curve1 = curve1Handle.get();
+            const curve1 = curve1Handle.returnValue;
             const param1 = oc.BRep_Tool.Parameter(v1, e1Raw);
             const curve2Handle = oc.BRep_Tool.Curve(e2Raw, 0, 1);
-            const curve2 = curve2Handle.get();
+            const curve2 = curve2Handle.returnValue;
             const param2 = oc.BRep_Tool.Parameter(v2, e2Raw);
             // Evaluate tangent vectors using D1
             const pnt1 = new oc.gp_Pnt();
@@ -144,7 +161,7 @@ export class TangentExpander {
     /**
      * Builds a map from vertex TShape hash to the list of edges that share that vertex.
      */
-    static buildVertexToEdgeMap(edges) {
+    static buildVertexToEdgeMap(edges, hasher) {
         const oc = getOC();
         const map = new Map();
         for (const edge of edges) {
@@ -152,7 +169,7 @@ export class TangentExpander {
             const first = oc.TopExp.FirstVertex(raw, true);
             const last = oc.TopExp.LastVertex(raw, true);
             for (const vertex of [first, last]) {
-                const hash = vertex.HashCode(2147483647);
+                const hash = hasher.key(vertex);
                 if (!map.has(hash)) {
                     map.set(hash, []);
                 }
@@ -164,12 +181,12 @@ export class TangentExpander {
     /**
      * Builds a map from edge TShape hash to the list of faces that share that edge.
      */
-    static buildEdgeToFaceMap(faces) {
+    static buildEdgeToFaceMap(faces, hasher) {
         const map = new Map();
         for (const face of faces) {
             const faceEdges = face.getEdges();
             for (const edge of faceEdges) {
-                const hash = edge.getShape().HashCode(2147483647);
+                const hash = hasher.key(edge.getShape());
                 if (!map.has(hash)) {
                     map.set(hash, []);
                 }
@@ -181,14 +198,14 @@ export class TangentExpander {
     /**
      * Returns edges from the adjacency map that share a vertex with the given edge.
      */
-    static getAdjacentEdges(edge, vertexToEdges) {
+    static getAdjacentEdges(edge, vertexToEdges, hasher) {
         const oc = getOC();
         const raw = edge.getShape();
         const first = oc.TopExp.FirstVertex(raw, true);
         const last = oc.TopExp.LastVertex(raw, true);
         const neighbors = new Set();
         for (const vertex of [first, last]) {
-            const hash = vertex.HashCode(2147483647);
+            const hash = hasher.key(vertex);
             const candidates = vertexToEdges.get(hash);
             if (candidates) {
                 for (const c of candidates) {
@@ -204,11 +221,11 @@ export class TangentExpander {
      * Returns faces from the adjacency map that share an edge with the given face,
      * along with the shared edge's raw TopoDS_Edge.
      */
-    static getAdjacentFaces(face, edgeToFaces) {
+    static getAdjacentFaces(face, edgeToFaces, hasher) {
         const result = [];
         const faceEdges = face.getEdges();
         for (const edge of faceEdges) {
-            const hash = edge.getShape().HashCode(2147483647);
+            const hash = hasher.key(edge.getShape());
             const candidates = edgeToFaces.get(hash);
             if (candidates) {
                 for (const c of candidates) {

package/lib/dist/helpers/scene-helpers.d.ts

@@ -7,6 +7,7 @@ export declare function fuseWithSceneObjects(sceneObjects: SceneObject[], extrus
     glue?: 'full' | 'shift';
     recordHistoryFor?: SceneObject;
     profiler?: Profiler;
+    skipSimplify?: boolean;
 }): {
     newShapes: Shape<any>[];
     modifiedShapes: any[];
@@ -21,6 +22,7 @@ export declare function fuseWithSceneObjects(sceneObjects: SceneObject[], extrus
 };
 export declare function cutWithSceneObjects(sceneObjects: SceneObject[], toolShapes: Shape[], plane: Plane, distance: number, caller: SceneObject, options?: {
     recordHistoryFor?: SceneObject;
+    skipSimplify?: boolean;
 }): {
     cleanedShapes: Shape[];
     stockShapes: Shape[];

package/lib/dist/helpers/scene-helpers.js

@@ -302,7 +302,7 @@ export function cutWithSceneObjects(sceneObjects, toolShapes, plane, distance, c
         const list = cutResult.modified(shape);
         if (list.length) {
             for (const newShape of list) {
-                const cleanup = ShapeOps.cleanShapeWithLineage(newShape);
+                const cleanup = ShapeOps.cleanShapeWithLineage(newShape, { skipSimplify: options?.skipSimplify });
                 caller.addShape(cleanup.shape);
                 cleanedShapes.push(cleanup.shape);
                 cleanups.push(cleanup);

package/lib/dist/index.d.ts

@@ -22,6 +22,7 @@ export type { ParamDefinition, MultiControlType, SelectOption, ParamVal, ParamSc
 export { setAssetProvider } from './io/file-import.js';
 export type { AssetProvider } from './io/file-import.js';
 export { getSceneManager } from './scene-manager.js';
+export { describeOcException } from './oc/errors.js';
 export interface FluidCADOptions {
     mesh?: {
         lineDeflection?: number;
@@ -42,6 +43,7 @@ export declare function init(options?: FluidCADOptions): Promise<{
     getShapeProperties(scene: Scene, shapeId: string): import("./oc/props.js").ShapeProperties | null;
     getFaceProperties(scene: Scene, shapeId: string, faceIndex: number): import("./oc/face-props.js").FaceProperties | null;
     getEdgeProperties(scene: Scene, shapeId: string, edgeIndex: number): import("./oc/edge-props.js").EdgeProperties | null;
+    measure(scene: Scene, refs: import("./oc/index.js").MeasureEntityRef[]): import("./oc/index.js").MeasureResult | null;
     exportShapes(scene: Scene, shapeIds: string[], options: import("./io/file-export.js").ExportOptions): {
         data: string | Uint8Array;
         fileName: string;

package/lib/dist/index.js

@@ -1,4 +1,5 @@
 import { loadOC } from "./load.js";
+import { FontRegistry } from "./io/font-registry.js";
 import { createManager, getCurrentScene, getSceneManager } from "./scene-manager.js";
 import { parse as parseStackTrace } from "stacktrace-parser";
 export function captureSourceLocation() {
@@ -91,8 +92,9 @@ export function registerBuilder(builder) {
 export { createParamRegistry, getParamRegistry } from './param-registry.js';
 export { setAssetProvider } from './io/file-import.js';
 export { getSceneManager } from './scene-manager.js';
+export { describeOcException } from './oc/errors.js';
 export async function init(options) {
-    await loadOC();
+    await Promise.all([loadOC(), FontRegistry.init()]);
     const existing = getSceneManager();
     if (existing) {
         return existing;

package/lib/dist/io/file-import.d.ts

@@ -7,6 +7,13 @@ import { Solid } from "../common/solid.js";
  */
 export type AssetProvider = (workspaceRelPath: string) => Uint8Array | null;
 export declare function setAssetProvider(provider: AssetProvider | null): void;
+/**
+ * Reads a workspace asset as raw bytes (e.g. a font file). Consults the
+ * AssetProvider first (hub mode), then the workspace filesystem. Paths are
+ * workspace-relative and confined to the workspace root (no `..` traversal).
+ * Returns null when the asset cannot be found.
+ */
+export declare function readWorkspaceAssetBytes(relPath: string): Uint8Array | null;
 export declare class FileImport {
     static deserializeShapes(fileName: string): Solid[];
     static serializeShape(shape: Shape, workspacePath: string, fileName: string): void;

package/lib/dist/io/file-import.js

@@ -1,5 +1,5 @@
 import * as fs from "fs";
-import { join } from "path";
+import { join, resolve, sep } from "path";
 import { OcIO } from "../oc/io.js";
 import { getSceneManager } from "../scene-manager.js";
 let assetProvider = null;
@@ -20,6 +20,33 @@ function readWorkspaceAsset(relPath) {
     }
     return { text: fs.readFileSync(filePath, 'utf8'), exists: true };
 }
+/**
+ * Reads a workspace asset as raw bytes (e.g. a font file). Consults the
+ * AssetProvider first (hub mode), then the workspace filesystem. Paths are
+ * workspace-relative and confined to the workspace root (no `..` traversal).
+ * Returns null when the asset cannot be found.
+ */
+export function readWorkspaceAssetBytes(relPath) {
+    if (assetProvider) {
+        const bytes = assetProvider(relPath);
+        if (bytes) {
+            return bytes;
+        }
+    }
+    const sceneManager = getSceneManager();
+    if (!sceneManager) {
+        return null;
+    }
+    const root = resolve(sceneManager.rootPath);
+    const filePath = resolve(root, relPath);
+    if (filePath !== root && !filePath.startsWith(root + sep)) {
+        return null;
+    }
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    return fs.readFileSync(filePath);
+}
 export class FileImport {
     static deserializeShapes(fileName) {
         if (!fileName.endsWith(('.brep'))) {

package/lib/dist/io/font-registry.d.ts

@@ -0,0 +1,45 @@
+import type { Font } from "fontkit";
+/**
+ * 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 declare class FontRegistry {
+    private static index;
+    private static allFiles;
+    private static fontCache;
+    static init(): Promise<void>;
+    /**
+     * 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: {
+        font?: string;
+        weight?: number;
+        italic?: boolean;
+    }): Font;
+    private static ensureInit;
+    /** Collects a family's variants plus its alias families' variants, unsorted. */
+    private static collectVariants;
+    /**
+     * Sorts variants by italic match then nearest weight, and opens the first that
+     * actually renders (skipping fonts that throw on outline access).
+     */
+    private static openFirstRenderable;
+    /** Opens and validates a variant; caches the result, including known-bad (null). */
+    private static openVariant;
+    /** All indexed system font family names (lowercased). Useful for tooling/tests. */
+    static availableFamilies(): string[];
+    private static tryOpenFile;
+    /**
+     * 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.
+     */
+    private static canRender;
+    private static loadLocalFile;
+}