fluidcad 0.0.34 → 0.0.35

package/lib/dist/features/2d/vline.js

@@ -8,6 +8,7 @@ export class VerticalLine extends GeometrySceneObject {
     distanceOrTarget;
     targetPlane;
     _centered = false;
+    _hasExplicitStart = false;
     constructor(distanceOrTarget, targetPlane = null) {
         super();
         this.distanceOrTarget = distanceOrTarget;
@@ -17,6 +18,10 @@ export class VerticalLine extends GeometrySceneObject {
         this._centered = value;
         return this;
     }
+    setHasExplicitStart(value = true) {
+        this._hasExplicitStart = value;
+        return this;
+    }
     build() {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         const currentPos = this.targetPlane
@@ -78,6 +83,7 @@ export class VerticalLine extends GeometrySceneObject {
             : this.distanceOrTarget;
         const copy = new VerticalLine(distanceOrTarget, targetPlane);
         copy.centered(this._centered);
+        copy._hasExplicitStart = this._hasExplicitStart;
         return copy;
     }
     compareTo(other) {
@@ -104,7 +110,7 @@ export class VerticalLine extends GeometrySceneObject {
         else if (this.distanceOrTarget !== other.distanceOrTarget) {
             return false;
         }
-        return this._centered === other._centered;
+        return this._centered === other._centered && this._hasExplicitStart === other._hasExplicitStart;
     }
     getType() {
         return 'line';
@@ -115,7 +121,8 @@ export class VerticalLine extends GeometrySceneObject {
     serialize() {
         return {
             distance: typeof this.distanceOrTarget === 'number' ? this.distanceOrTarget : null,
-            centered: this._centered
+            centered: this._centered,
+            hasExplicitStart: this._hasExplicitStart,
         };
     }
 }

package/lib/dist/features/copy-circular.d.ts

@@ -1,14 +1,15 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 import { Axis } from "../math/axis.js";
+import { type NumberParam } from "../core/param.js";
 export type CircularCopyOptions = {
-    count: number;
+    count: NumberParam;
     centered?: boolean;
     skip?: number[];
 } & ({
-    offset: number;
+    offset: NumberParam;
     angle?: never;
 } | {
-    angle: number;
+    angle: NumberParam;
     offset?: never;
 });
 export declare class CopyCircular extends SceneObject {

package/lib/dist/features/copy-circular.js

@@ -2,6 +2,7 @@ import { SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
 import { rad } from "../helpers/math-helpers.js";
 import { ShapeOps } from "../oc/shape-ops.js";
+import { resolveParam } from "../core/param.js";
 export class CopyCircular extends SceneObject {
     axis;
     options;
@@ -17,13 +18,21 @@ export class CopyCircular extends SceneObject {
         if (!this.targetObjects) {
             objects = context.getActiveSceneObjects();
         }
-        const { count, centered, skip } = this.options;
+        const originalShapes = objects.flatMap(obj => obj.getShapes());
+        for (const obj of objects) {
+            obj.removeShapes(this);
+        }
+        for (const shape of originalShapes) {
+            this.addShape(shape);
+        }
+        const count = resolveParam(this.options.count);
+        const { centered, skip } = this.options;
         let offset;
         if ('offset' in this.options && this.options.offset !== undefined) {
-            offset = this.options.offset;
+            offset = resolveParam(this.options.offset);
         }
         else {
-            offset = this.options.angle / count;
+            offset = resolveParam(this.options.angle) / count;
         }
         const startOffset = centered ? -(count * offset) / 2 : 0;
         for (let i = 1; i < count; i++) {
@@ -31,12 +40,10 @@ export class CopyCircular extends SceneObject {
                 continue;
             const angle = startOffset + offset * i;
             const matrix = Matrix4.fromRotationAroundAxis(this.axis.origin, this.axis.direction, rad(angle));
-            for (const obj of objects) {
-                for (const shape of obj.getShapes()) {
-                    const transformed = ShapeOps.transform(shape, matrix);
-                    transformed.setMeshSource(shape, matrix);
-                    this.addShape(transformed);
-                }
+            for (const shape of originalShapes) {
+                const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
+                this.addShape(transformed);
             }
         }
     }

package/lib/dist/features/copy-circular2d.js

@@ -2,6 +2,7 @@ import { Matrix4 } from "../math/matrix4.js";
 import { rad } from "../helpers/math-helpers.js";
 import { ShapeOps } from "../oc/shape-ops.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
+import { resolveParam } from "../core/param.js";
 export class CopyCircular2D extends GeometrySceneObject {
     center;
     options;
@@ -21,16 +22,24 @@ export class CopyCircular2D extends GeometrySceneObject {
         else {
             objects = allSiblings;
         }
+        const originalShapes = objects.flatMap(obj => obj.getShapes());
+        for (const obj of objects) {
+            obj.removeShapes(this);
+        }
+        for (const shape of originalShapes) {
+            this.addShape(shape);
+        }
         const plane = this.sketch.getPlane();
         const origin = plane.localToWorld(this.center.asPoint2D());
         const direction = plane.normal;
-        const { count, centered, skip } = this.options;
+        const count = resolveParam(this.options.count);
+        const { centered, skip } = this.options;
         let offset;
         if ('offset' in this.options && this.options.offset !== undefined) {
-            offset = this.options.offset;
+            offset = resolveParam(this.options.offset);
         }
         else {
-            offset = this.options.angle / count;
+            offset = resolveParam(this.options.angle) / count;
         }
         const startOffset = centered ? -(count * offset) / 2 : 0;
         for (let i = 1; i < count; i++) {
@@ -38,12 +47,10 @@ export class CopyCircular2D extends GeometrySceneObject {
                 continue;
             const angle = startOffset + offset * i;
             const matrix = Matrix4.fromRotationAroundAxis(origin, direction, rad(angle));
-            for (const obj of objects) {
-                for (const shape of obj.getShapes()) {
-                    const transformed = ShapeOps.transform(shape, matrix);
-                    transformed.setMeshSource(shape, matrix);
-                    this.addShape(transformed);
-                }
+            for (const shape of originalShapes) {
+                const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
+                this.addShape(transformed);
             }
         }
         this.setCurrentPosition(this.center.asPoint2D());

package/lib/dist/features/copy-linear.d.ts

@@ -1,14 +1,15 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 import { Axis } from "../math/axis.js";
+import { type NumberParam } from "../core/param.js";
 export type LinearCopyOptions = {
-    count: number | number[];
+    count: NumberParam | number[];
     centered?: boolean;
     skip?: number[][];
 } & ({
-    offset: number | number[];
+    offset: NumberParam | number[];
     length?: never;
 } | {
-    length: number | number[];
+    length: NumberParam | number[];
     offset?: never;
 });
 export declare class CopyLinear extends SceneObject {

package/lib/dist/features/copy-linear.js

@@ -1,6 +1,7 @@
 import { SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
 import { ShapeOps } from "../oc/shape-ops.js";
+import { resolveParam } from "../core/param.js";
 export class CopyLinear extends SceneObject {
     axes;
     options;
@@ -16,15 +17,22 @@ export class CopyLinear extends SceneObject {
         if (!this.targetObjects) {
             objects = context.getActiveSceneObjects();
         }
-        const { count, centered, skip } = this.options;
-        const counts = Array.isArray(count)
-            ? count
-            : this.axes.map(() => count);
+        const originalShapes = objects.flatMap(obj => obj.getShapes());
+        for (const obj of objects) {
+            obj.removeShapes(this);
+        }
+        for (const shape of originalShapes) {
+            this.addShape(shape);
+        }
+        const { centered, skip } = this.options;
+        const counts = Array.isArray(this.options.count)
+            ? this.options.count
+            : this.axes.map(() => resolveParam(this.options.count));
         const offsets = 'offset' in this.options && this.options.offset !== undefined
-            ? (Array.isArray(this.options.offset) ? this.options.offset : this.axes.map(() => this.options.offset))
+            ? (Array.isArray(this.options.offset) ? this.options.offset : this.axes.map(() => resolveParam(this.options.offset)))
             : null;
         const lengths = 'length' in this.options && this.options.length !== undefined
-            ? (Array.isArray(this.options.length) ? this.options.length : this.axes.map(() => this.options.length))
+            ? (Array.isArray(this.options.length) ? this.options.length : this.axes.map(() => resolveParam(this.options.length)))
             : null;
         const axisOffsets = this.axes.map((_, a) => {
             if (offsets) {
@@ -58,12 +66,10 @@ export class CopyLinear extends SceneObject {
                 const translation = this.axes[a].direction.multiply(distance);
                 matrix = matrix.multiply(Matrix4.fromTranslationVector(translation));
             }
-            for (const obj of objects) {
-                for (const shape of obj.getShapes()) {
-                    const transformed = ShapeOps.transform(shape, matrix);
-                    transformed.setMeshSource(shape, matrix);
-                    this.addShape(transformed);
-                }
+            for (const shape of originalShapes) {
+                const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
+                this.addShape(transformed);
             }
         }
     }

package/lib/dist/features/copy-linear2d.js

@@ -2,6 +2,7 @@ import { Matrix4 } from "../math/matrix4.js";
 import { ShapeOps } from "../oc/shape-ops.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
 import { AxisObjectBase } from "./axis-renderable-base.js";
+import { resolveParam } from "../core/param.js";
 export class CopyLinear2D extends GeometrySceneObject {
     axes;
     options;
@@ -21,16 +22,23 @@ export class CopyLinear2D extends GeometrySceneObject {
         else {
             objects = allSiblings;
         }
+        const originalShapes = objects.flatMap(obj => obj.getShapes());
+        for (const obj of objects) {
+            obj.removeShapes(this);
+        }
+        for (const shape of originalShapes) {
+            this.addShape(shape);
+        }
         const resolvedAxes = this.axes.map(a => a instanceof AxisObjectBase ? a.getAxis() : a);
-        const { count, centered, skip } = this.options;
-        const counts = Array.isArray(count)
-            ? count
-            : resolvedAxes.map(() => count);
+        const { centered, skip } = this.options;
+        const counts = Array.isArray(this.options.count)
+            ? this.options.count
+            : resolvedAxes.map(() => resolveParam(this.options.count));
         const offsets = 'offset' in this.options && this.options.offset !== undefined
-            ? (Array.isArray(this.options.offset) ? this.options.offset : resolvedAxes.map(() => this.options.offset))
+            ? (Array.isArray(this.options.offset) ? this.options.offset : resolvedAxes.map(() => resolveParam(this.options.offset)))
             : null;
         const lengths = 'length' in this.options && this.options.length !== undefined
-            ? (Array.isArray(this.options.length) ? this.options.length : resolvedAxes.map(() => this.options.length))
+            ? (Array.isArray(this.options.length) ? this.options.length : resolvedAxes.map(() => resolveParam(this.options.length)))
             : null;
         const axisOffsets = resolvedAxes.map((_, a) => {
             if (offsets) {
@@ -64,12 +72,10 @@ export class CopyLinear2D extends GeometrySceneObject {
                 const translation = resolvedAxes[a].direction.multiply(distance);
                 matrix = matrix.multiply(Matrix4.fromTranslationVector(translation));
             }
-            for (const obj of objects) {
-                for (const shape of obj.getShapes()) {
-                    const transformed = ShapeOps.transform(shape, matrix);
-                    transformed.setMeshSource(shape, matrix);
-                    this.addShape(transformed);
-                }
+            for (const shape of originalShapes) {
+                const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
+                this.addShape(transformed);
             }
         }
     }

package/lib/dist/features/extrude-base.d.ts

@@ -9,6 +9,7 @@ import { Point2DLike } from "../math/point.js";
 import { Plane } from "../math/plane.js";
 import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+import { type NumberParam } from "../core/param.js";
 import { ShapeHistory } from "../common/shape-history-tracker.js";
 /** A 3D op's classified face buckets. Each is empty if the op doesn't produce that category. */
 export type ClassifiedFaces = {
@@ -105,10 +106,10 @@ export declare abstract class ExtrudeBase extends SceneObject implements IExtrud
     private buildSuffix;
     private resolveFaces;
     private resolveEdges;
-    draft(value: number | [number, number]): this;
-    endOffset(value: number): this;
+    draft(value: NumberParam | [NumberParam, NumberParam]): this;
+    endOffset(value: NumberParam): this;
     drill(value?: boolean): this;
-    thin(offset1: number, offset2?: number): this;
+    thin(offset1: NumberParam, offset2?: NumberParam): this;
     isThin(): boolean;
     getThinOffsets(): [number] | [number, number] | undefined;
     protected serializePickFields(): {

package/lib/dist/features/extrude-base.js

@@ -11,6 +11,7 @@ import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
 import { ShapeFilter } from "../filters/filter.js";
 import { EdgeOps } from "../oc/edge-ops.js";
 import { Explorer } from "../oc/explorer.js";
+import { resolveParam } from "../core/param.js";
 import { getOC } from "../oc/init.js";
 import { ShapeHistoryTracker } from "../common/shape-history-tracker.js";
 import { fuseWithSceneObjects } from "../helpers/scene-helpers.js";
@@ -398,11 +399,16 @@ export class ExtrudeBase extends SceneObject {
         return new ShapeFilter(shapes, ...filters).apply();
     }
     draft(value) {
-        this._draft = value;
+        if (Array.isArray(value)) {
+            this._draft = [resolveParam(value[0]), resolveParam(value[1])];
+        }
+        else {
+            this._draft = resolveParam(value);
+        }
         return this;
     }
     endOffset(value) {
-        this._endOffset = value;
+        this._endOffset = resolveParam(value);
         return this;
     }
     drill(value = true) {
@@ -410,7 +416,8 @@ export class ExtrudeBase extends SceneObject {
         return this;
     }
     thin(offset1, offset2) {
-        this._thin = offset2 !== undefined ? [offset1, offset2] : [offset1];
+        const o1 = resolveParam(offset1);
+        this._thin = offset2 !== undefined ? [o1, resolveParam(offset2)] : [o1];
         return this;
     }
     isThin() {

package/lib/dist/features/mirror-shape2d.js

@@ -44,8 +44,8 @@ export class MirrorShape2D extends GeometrySceneObject {
                 transformedShapes.push(transformed);
             }
         }
-        const firstShape = transformedShapes[0];
-        const lastShape = transformedShapes[transformedShapes.length - 1];
+        const firstShape = transformedShapes.find(shape => !shape.isMetaShape() && !shape.isGuideShape());
+        const lastShape = transformedShapes.toReversed().find(shape => !shape.isMetaShape() && !shape.isGuideShape());
         if (firstShape) {
             const start = firstShape.getFirstVertex();
             if (start) {

package/lib/dist/features/repeat-base.d.ts

@@ -0,0 +1,13 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Axis } from "../math/axis.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+export type RepeatAxisSource = Axis | AxisObjectBase;
+/**
+ * Shared base for repeat features. Holds structural equality helpers used
+ * by `compareTo`, which runs during cache-compare — before any render —
+ * when an `AxisObjectBase` source may not yet have its resolved `Axis`
+ * state. Comparing via `getAxis()` at that point would NPE.
+ */
+export declare abstract class RepeatBase extends SceneObject {
+    protected static axisSourceEquals(a: RepeatAxisSource, b: RepeatAxisSource): boolean;
+}

package/lib/dist/features/repeat-base.js

@@ -0,0 +1,21 @@
+import { SceneObject } from "../common/scene-object.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+/**
+ * Shared base for repeat features. Holds structural equality helpers used
+ * by `compareTo`, which runs during cache-compare — before any render —
+ * when an `AxisObjectBase` source may not yet have its resolved `Axis`
+ * state. Comparing via `getAxis()` at that point would NPE.
+ */
+export class RepeatBase extends SceneObject {
+    static axisSourceEquals(a, b) {
+        const aObj = a instanceof AxisObjectBase;
+        const bObj = b instanceof AxisObjectBase;
+        if (aObj !== bObj) {
+            return false;
+        }
+        if (aObj) {
+            return a.compareTo(b);
+        }
+        return a.equals(b);
+    }
+}

package/lib/dist/features/repeat-circular.d.ts

@@ -1,17 +1,18 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { RepeatAxisSource } from "./repeat-linear.js";
+import { RepeatBase, RepeatAxisSource } from "./repeat-base.js";
+import { type NumberParam } from "../core/param.js";
 export type CircularRepeatOptions = {
-    count: number;
+    count: NumberParam;
     centered?: boolean;
     skip?: number[];
 } & ({
-    offset: number;
+    offset: NumberParam;
     angle?: never;
 } | {
-    angle: number;
+    angle: NumberParam;
     offset?: never;
 });
-export declare class RepeatCircular extends SceneObject {
+export declare class RepeatCircular extends RepeatBase {
     axis: RepeatAxisSource;
     options: CircularRepeatOptions;
     targetObjects: SceneObject[] | null;

package/lib/dist/features/repeat-circular.js

@@ -1,9 +1,6 @@
-import { SceneObject } from "../common/scene-object.js";
 import { AxisObjectBase } from "./axis-renderable-base.js";
-function axisOf(source) {
-    return source instanceof AxisObjectBase ? source.getAxis() : source;
-}
-export class RepeatCircular extends SceneObject {
+import { RepeatBase } from "./repeat-base.js";
+export class RepeatCircular extends RepeatBase {
     axis;
     options;
     targetObjects;
@@ -30,7 +27,7 @@ export class RepeatCircular extends SceneObject {
         if (!super.compareTo(other)) {
             return false;
         }
-        if (!axisOf(this.axis).equals(axisOf(other.axis))) {
+        if (!RepeatCircular.axisSourceEquals(this.axis, other.axis)) {
             return false;
         }
         const thisTargetObjects = this.targetObjects || [];

package/lib/dist/features/repeat-linear.d.ts

@@ -1,19 +1,19 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { Axis } from "../math/axis.js";
-import { AxisObjectBase } from "./axis-renderable-base.js";
-export type RepeatAxisSource = Axis | AxisObjectBase;
+import { RepeatBase, RepeatAxisSource } from "./repeat-base.js";
+export { RepeatAxisSource } from "./repeat-base.js";
+import { type NumberParam } from "../core/param.js";
 export type LinearRepeatOptions = {
-    count: number | number[];
+    count: NumberParam | number[];
     centered?: boolean;
     skip?: number[][];
 } & ({
-    offset: number | number[];
+    offset: NumberParam | number[];
     length?: never;
 } | {
-    length: number | number[];
+    length: NumberParam | number[];
     offset?: never;
 });
-export declare class RepeatLinear extends SceneObject {
+export declare class RepeatLinear extends RepeatBase {
     axes: RepeatAxisSource[];
     options: LinearRepeatOptions;
     targetObjects: SceneObject[] | null;

package/lib/dist/features/repeat-linear.js

@@ -1,9 +1,6 @@
-import { SceneObject } from "../common/scene-object.js";
 import { AxisObjectBase } from "./axis-renderable-base.js";
-function axisOf(source) {
-    return source instanceof AxisObjectBase ? source.getAxis() : source;
-}
-export class RepeatLinear extends SceneObject {
+import { RepeatBase } from "./repeat-base.js";
+export class RepeatLinear extends RepeatBase {
     axes;
     options;
     targetObjects;
@@ -36,7 +33,7 @@ export class RepeatLinear extends SceneObject {
             return false;
         }
         for (let i = 0; i < this.axes.length; i++) {
-            if (!axisOf(this.axes[i]).equals(axisOf(other.axes[i]))) {
+            if (!RepeatLinear.axisSourceEquals(this.axes[i], other.axes[i])) {
                 return false;
             }
         }

package/lib/dist/index.d.ts

@@ -17,6 +17,11 @@ export type SceneParserContext = {
     getActiveSketch(): Sketch | null;
 };
 export declare function registerBuilder<T extends Function>(builder: (context: SceneParserContext) => T): T;
+export { createParamRegistry, getParamRegistry } from './param-registry.js';
+export type { ParamDefinition, MultiControlType, SelectOption, ParamVal, ParamScalar } from './param-registry.js';
+export { setAssetProvider } from './io/file-import.js';
+export type { AssetProvider } from './io/file-import.js';
+export { getSceneManager } from './scene-manager.js';
 export interface FluidCADOptions {
     mesh?: {
         lineDeflection?: number;

package/lib/dist/index.js

@@ -1,5 +1,5 @@
 import { loadOC } from "./load.js";
-import { createManager, getCurrentScene } from "./scene-manager.js";
+import { createManager, getCurrentScene, getSceneManager } from "./scene-manager.js";
 import { parse as parseStackTrace } from "stacktrace-parser";
 export function captureSourceLocation() {
     const stack = new Error().stack;
@@ -88,8 +88,15 @@ export function registerBuilder(builder) {
     return fn;
     ;
 }
+export { createParamRegistry, getParamRegistry } from './param-registry.js';
+export { setAssetProvider } from './io/file-import.js';
+export { getSceneManager } from './scene-manager.js';
 export async function init(options) {
     await loadOC();
+    const existing = getSceneManager();
+    if (existing) {
+        return existing;
+    }
     const resolvedPath = process.env.FLUIDCAD_WORKSPACE_PATH || '';
     return createManager(resolvedPath, options);
 }

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

@@ -1,5 +1,12 @@
 import { Shape } from "../common/shape.js";
 import { Solid } from "../common/solid.js";
+/**
+ * Override hook for hub mode (and tests). When set, asset reads consult
+ * the provider instead of the filesystem — paths are workspace-relative
+ * (e.g. `imports/foo.brep`). Returning null falls back to disk.
+ */
+export type AssetProvider = (workspaceRelPath: string) => Uint8Array | null;
+export declare function setAssetProvider(provider: AssetProvider | null): void;
 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

@@ -2,17 +2,37 @@ import * as fs from "fs";
 import { join } from "path";
 import { OcIO } from "../oc/io.js";
 import { getSceneManager } from "../scene-manager.js";
+let assetProvider = null;
+export function setAssetProvider(provider) {
+    assetProvider = provider;
+}
+function readWorkspaceAsset(relPath) {
+    if (assetProvider) {
+        const bytes = assetProvider(relPath);
+        if (bytes) {
+            return { text: Buffer.from(bytes).toString('utf8'), exists: true };
+        }
+    }
+    const sceneManager = getSceneManager();
+    const filePath = join(sceneManager.rootPath, relPath);
+    if (!fs.existsSync(filePath)) {
+        return { exists: false };
+    }
+    return { text: fs.readFileSync(filePath, 'utf8'), exists: true };
+}
 export class FileImport {
     static deserializeShapes(fileName) {
         if (!fileName.endsWith(('.brep'))) {
             fileName += '.brep';
         }
-        const sceneManager = getSceneManager();
-        const filePath = join(sceneManager.rootPath, 'imports', fileName);
+        const relPath = join('imports', fileName);
         console.log(`Reading file ${fileName}`);
-        const file = fs.readFileSync(filePath, 'utf8');
-        console.log(`File ${filePath} read successfully, size: ${file.length} bytes`);
-        return OcIO.readBRepSolids(fileName, file);
+        const result = readWorkspaceAsset(relPath);
+        if (!result.exists) {
+            throw new Error(`Imported asset not found: ${relPath}`);
+        }
+        console.log(`File ${relPath} read successfully, size: ${result.text.length} bytes`);
+        return OcIO.readBRepSolids(fileName, result.text);
     }
     static serializeShape(shape, workspacePath, fileName) {
         const file = OcIO.writeBRep(shape, fileName);
@@ -56,11 +76,11 @@ export class FileImport {
         // Read color metadata from JSON sidecar (skipped when noColors is set)
         let colorData = [];
         if (!options?.noColors) {
-            const sceneManager = getSceneManager();
-            const jsonPath = join(sceneManager.rootPath, 'imports', brepFileName + '.colors.json');
-            if (fs.existsSync(jsonPath)) {
-                colorData = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
-                console.log(`Loaded color metadata from ${jsonPath}`);
+            const relPath = join('imports', brepFileName + '.colors.json');
+            const result = readWorkspaceAsset(relPath);
+            if (result.exists) {
+                colorData = JSON.parse(result.text);
+                console.log(`Loaded color metadata from ${relPath}`);
             }
         }
         const include = options?.include;

package/lib/dist/math/lazy-matrix.d.ts

@@ -4,10 +4,12 @@ import { Plane } from "./plane.js";
 /** Anything that can be resolved to an `Axis` once built — e.g. `AxisObjectBase`. */
 export interface AxisLazySource {
     getAxis(): Axis;
+    compareTo?(other: unknown): boolean;
 }
 /** Anything that can be resolved to a `Plane` once built — e.g. `PlaneObjectBase`. */
 export interface PlaneLazySource {
     getPlane(): Plane;
+    compareTo?(other: unknown): boolean;
 }
 /**
  * Memoized thunk over a Matrix4. Lets parse-time code thread a transform
@@ -20,9 +22,12 @@ export interface PlaneLazySource {
 export declare class LazyMatrix {
     private _resolver;
     private _cached;
+    private _identity;
     private constructor();
     resolve(): Matrix4;
     equals(other: LazyMatrix, tolerance?: number): boolean;
+    private static axisSourceEquals;
+    private static planeSourceEquals;
     static of(matrix: Matrix4): LazyMatrix;
     static from(resolver: () => Matrix4): LazyMatrix;
     static mirror(plane: Plane | PlaneLazySource): LazyMatrix;