fluidcad 0.0.34 → 0.0.36

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;

package/lib/dist/math/lazy-matrix.js

@@ -16,9 +16,11 @@ function isPlaneLazySource(p) {
 export class LazyMatrix {
     _resolver;
     _cached;
-    constructor(resolver, cached = null) {
+    _identity;
+    constructor(resolver, identity, cached = null) {
         this._resolver = resolver;
         this._cached = cached;
+        this._identity = identity;
     }
     resolve() {
         if (this._cached === null) {
@@ -27,40 +29,106 @@ export class LazyMatrix {
         return this._cached;
     }
     equals(other, tolerance = 0) {
-        return this.resolve().equals(other.resolve(), tolerance);
+        const a = this._identity;
+        const b = other._identity;
+        if (a.kind !== b.kind) {
+            return false;
+        }
+        switch (a.kind) {
+            case "eager":
+                return a.matrix.equals(b.matrix, tolerance);
+            case "rotation": {
+                const bo = b;
+                return Math.abs(a.angle - bo.angle) <= tolerance
+                    && LazyMatrix.axisSourceEquals(a.axis, bo.axis, tolerance);
+            }
+            case "translation": {
+                const bo = b;
+                return Math.abs(a.distance - bo.distance) <= tolerance
+                    && LazyMatrix.axisSourceEquals(a.axis, bo.axis, tolerance);
+            }
+            case "mirror": {
+                const bo = b;
+                return LazyMatrix.planeSourceEquals(a.plane, bo.plane, tolerance);
+            }
+            case "opaque":
+                // No structural information — can't compare safely without resolving,
+                // and resolving may dereference unbuilt sources. Treat as unequal so
+                // the caller takes the rebuild path instead of crashing.
+                return false;
+        }
+    }
+    static axisSourceEquals(a, b, tolerance) {
+        if (isAxisLazySource(a)) {
+            if (!isAxisLazySource(b)) {
+                return false;
+            }
+            if (a === b) {
+                return true;
+            }
+            if (typeof a.compareTo === "function" && typeof b.compareTo === "function") {
+                return a.compareTo(b);
+            }
+            return false;
+        }
+        if (isAxisLazySource(b)) {
+            return false;
+        }
+        return a.equals(b, tolerance);
+    }
+    static planeSourceEquals(a, b, tolerance) {
+        if (isPlaneLazySource(a)) {
+            if (!isPlaneLazySource(b)) {
+                return false;
+            }
+            if (a === b) {
+                return true;
+            }
+            if (typeof a.compareTo === "function" && typeof b.compareTo === "function") {
+                return a.compareTo(b);
+            }
+            return false;
+        }
+        if (isPlaneLazySource(b)) {
+            return false;
+        }
+        return a.compareTo(b, tolerance);
     }
     static of(matrix) {
-        return new LazyMatrix(() => matrix, matrix);
+        return new LazyMatrix(() => matrix, { kind: "eager", matrix }, matrix);
     }
     static from(resolver) {
-        return new LazyMatrix(resolver);
+        return new LazyMatrix(resolver, { kind: "opaque" });
     }
     static mirror(plane) {
         if (isPlaneLazySource(plane)) {
             return new LazyMatrix(() => {
                 const p = plane.getPlane();
                 return Matrix4.mirrorPlane(p.normal, p.origin);
-            });
+            }, { kind: "mirror", plane });
         }
-        return LazyMatrix.of(Matrix4.mirrorPlane(plane.normal, plane.origin));
+        const matrix = Matrix4.mirrorPlane(plane.normal, plane.origin);
+        return new LazyMatrix(() => matrix, { kind: "mirror", plane }, matrix);
     }
     static rotation(axis, angle) {
         if (isAxisLazySource(axis)) {
             return new LazyMatrix(() => {
                 const a = axis.getAxis();
                 return Matrix4.fromRotationAroundAxis(a.origin, a.direction, angle);
-            });
+            }, { kind: "rotation", axis, angle });
         }
-        return LazyMatrix.of(Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, angle));
+        const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, angle);
+        return new LazyMatrix(() => matrix, { kind: "rotation", axis, angle }, matrix);
     }
     static translation(axis, distance) {
         if (isAxisLazySource(axis)) {
             return new LazyMatrix(() => {
                 const dir = axis.getAxis().direction;
                 return Matrix4.fromTranslation(dir.x * distance, dir.y * distance, dir.z * distance);
-            });
+            }, { kind: "translation", axis, distance });
         }
         const dir = axis.direction;
-        return LazyMatrix.of(Matrix4.fromTranslation(dir.x * distance, dir.y * distance, dir.z * distance));
+        const matrix = Matrix4.fromTranslation(dir.x * distance, dir.y * distance, dir.z * distance);
+        return new LazyMatrix(() => matrix, { kind: "translation", axis, distance }, matrix);
     }
 }

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

@@ -8,8 +8,8 @@ export declare class BooleanOps {
     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): {
-        result: Edge | import("../common/wire.js").Wire | Solid | Face;
-        modified: (shape: Shape) => (Edge | import("../common/wire.js").Wire | Solid | Face)[];
+        result: import("../common/vertex.js").Vertex | Edge | import("../common/wire.js").Wire | Solid | Face;
+        modified: (shape: Shape) => (import("../common/vertex.js").Vertex | Edge | import("../common/wire.js").Wire | Solid | Face)[];
         sectionEdges: Edge[];
         startEdges: Edge[];
         endEdges: Edge[];

package/lib/dist/param-registry.d.ts

@@ -0,0 +1,34 @@
+export type ControlType = 'auto' | 'text' | 'number' | 'slider' | 'select' | 'checkbox' | 'color';
+export type MultiControlType = 'select' | 'checkboxes' | 'chips';
+export type SelectOption = {
+    label: string;
+    value: string | number;
+};
+export type ParamScalar = string | number | boolean;
+export type ParamVal = ParamScalar | (string | number)[];
+export type ParamDefinition = {
+    label: string;
+    defaultValue: ParamVal;
+    currentValue: ParamVal;
+    controlType: ControlType;
+    description?: string;
+    group?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: SelectOption[];
+    multi?: boolean;
+    multiControlType?: MultiControlType;
+};
+export declare class ParamRegistry {
+    private definitions;
+    private overrides;
+    register(def: ParamDefinition): void;
+    resolve(label: string, defaultValue: (string | number)[]): (string | number)[];
+    resolve<T extends string | number | boolean>(label: string, defaultValue: T): T;
+    setOverrides(overrides: Map<string, any>): void;
+    getDefinitions(): ParamDefinition[];
+    clear(): void;
+}
+export declare function createParamRegistry(): ParamRegistry;
+export declare function getParamRegistry(): ParamRegistry;

package/lib/dist/param-registry.js

@@ -0,0 +1,60 @@
+export class ParamRegistry {
+    definitions = new Map();
+    overrides = new Map();
+    register(def) {
+        this.definitions.set(def.label, def);
+    }
+    resolve(label, defaultValue) {
+        if (!this.overrides.has(label)) {
+            return defaultValue;
+        }
+        const override = this.overrides.get(label);
+        if (Array.isArray(defaultValue)) {
+            if (Array.isArray(override)) {
+                return override;
+            }
+            if (override != null) {
+                return [override];
+            }
+            return defaultValue;
+        }
+        if (typeof defaultValue === 'boolean') {
+            if (override === true || override === 'true' || override === 1) {
+                return true;
+            }
+            if (override === false || override === 'false' || override === 0) {
+                return false;
+            }
+            return defaultValue;
+        }
+        if (typeof defaultValue === 'number') {
+            const num = Number(override);
+            if (Number.isFinite(num)) {
+                return num;
+            }
+            return defaultValue;
+        }
+        return String(override);
+    }
+    setOverrides(overrides) {
+        this.overrides = overrides;
+    }
+    getDefinitions() {
+        return Array.from(this.definitions.values());
+    }
+    clear() {
+        this.definitions.clear();
+        this.overrides.clear();
+    }
+}
+let currentRegistry = null;
+export function createParamRegistry() {
+    currentRegistry = new ParamRegistry();
+    return currentRegistry;
+}
+export function getParamRegistry() {
+    if (!currentRegistry) {
+        currentRegistry = new ParamRegistry();
+    }
+    return currentRegistry;
+}

package/lib/dist/rendering/mesh-builder.js

@@ -33,7 +33,8 @@ export class MeshBuilder {
             console.warn("Shell shapes are not supported yet.");
         }
         else if (Explorer.isVertex(shape)) {
-            console.warn("Vertex shapes are not supported yet.");
+            const pt = shapeObj.toPoint();
+            result = { vertices: [pt.x, pt.y, pt.z], normals: [], indices: [] };
         }
         else {
             console.warn("Shape is not a valid TopoDS_Shape.");

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

@@ -28,7 +28,7 @@ describe("copy circular", () => {
         const c = copy("circular", "z", { count: 3, angle: 180 }, e);
         render();
         const shapes = c.getShapes();
-        expect(shapes).toHaveLength(2);
+        expect(shapes).toHaveLength(3);
     });
     it("should skip specified indices", () => {
         sketch("xy", () => {

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

@@ -25,11 +25,11 @@ describe("copy linear", () => {
         const e = extrude(10).new();
         const c = copy("linear", "x", { count: 3, offset: 50 }, e);
         render();
-        // 2 copies (index 1 and 2), each offset by 50 along X
+        // Original + 2 copies (index 1 and 2), each offset by 50 along X
         const shapes = c.getShapes();
-        expect(shapes).toHaveLength(2);
-        const bbox1 = ShapeOps.getBoundingBox(shapes[0]);
-        const bbox2 = ShapeOps.getBoundingBox(shapes[1]);
+        expect(shapes).toHaveLength(3);
+        const bbox1 = ShapeOps.getBoundingBox(shapes[1]);
+        const bbox2 = ShapeOps.getBoundingBox(shapes[2]);
         expect(bbox1.minX).toBeCloseTo(50, 0);
         expect(bbox2.minX).toBeCloseTo(100, 0);
     });
@@ -41,8 +41,8 @@ describe("copy linear", () => {
         const c = copy("linear", "y", { count: 2, offset: 60 }, e);
         render();
         const shapes = c.getShapes();
-        expect(shapes).toHaveLength(1);
-        const bbox = ShapeOps.getBoundingBox(shapes[0]);
+        expect(shapes).toHaveLength(2);
+        const bbox = ShapeOps.getBoundingBox(shapes[1]);
         expect(bbox.minY).toBeCloseTo(60, 0);
     });
     it("should copy along Z axis", () => {
@@ -53,8 +53,8 @@ describe("copy linear", () => {
         const c = copy("linear", "z", { count: 2, offset: 30 }, e);
         render();
         const shapes = c.getShapes();
-        expect(shapes).toHaveLength(1);
-        const bbox = ShapeOps.getBoundingBox(shapes[0]);
+        expect(shapes).toHaveLength(2);
+        const bbox = ShapeOps.getBoundingBox(shapes[1]);
         expect(bbox.minZ).toBeCloseTo(30, 0);
     });
     it("should distribute copies by total length", () => {
@@ -66,8 +66,8 @@ describe("copy linear", () => {
         const c = copy("linear", "x", { count: 4, length: 120 }, e);
         render();
         const shapes = c.getShapes();
-        expect(shapes).toHaveLength(3);
-        const bbox = ShapeOps.getBoundingBox(shapes[0]);
+        expect(shapes).toHaveLength(4);
+        const bbox = ShapeOps.getBoundingBox(shapes[1]);
         expect(bbox.minX).toBeCloseTo(40, 0);
     });
     it("should create a 2D grid with multiple axes", () => {

package/lib/dist/tests/features/repeat-user-repro-cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/repeat-user-repro-cache.test.js

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import { getSceneManager } from "../../scene-manager.js";
+import { SceneCompare } from "../../rendering/scene-compare.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import axis from "../../core/axis.js";
+import repeat from "../../core/repeat.js";
+import sweep from "../../core/sweep.js";
+import cut from "../../core/cut.js";
+import remove from "../../core/remove.js";
+import { rect, circle, vLine, tArc, tLine, slot, move, hMove } from "../../core/2d/index.js";
+import copy from "../../core/copy.js";
+// Regression: re-rendering a scene whose `repeat("circular", ...)` axis is an
+// AxisFromEdge derived from a sketch line used to crash inside
+// SceneCompare.compare with "Cannot read properties of undefined (reading
+// 'origin')". RepeatCircular.compareTo eagerly called getAxis() on the
+// new-scene axis source, which hadn't been built yet (compare runs pre-render).
+describe("repeat circular cache-compare on unbuilt axis source", () => {
+    setupOC();
+    function buildScene(includeRemove) {
+        const spine = sketch("front", () => {
+            vLine(1.5);
+            tArc(-4, 45);
+            const topSegment = tLine(1.5);
+            return { topSegment };
+        }).reusable();
+        const profile = sketch("top", () => {
+            const innerPipe = circle(1.5);
+            const outerPipe = circle(2);
+            return { innerPipe, outerPipe };
+        });
+        const pipe = sweep(spine, profile.regions.outerPipe);
+        sketch("top", () => {
+            rect(3.5).centered().radius(0.5);
+            move([-2.5 / 2, -2.5 / 2]);
+            const c = circle(0.5);
+            copy("circular", [0, 0], { count: 4, angle: 360 }, c);
+        });
+        extrude(0.375);
+        sketch(pipe.endFaces(), () => {
+            circle(4);
+        });
+        const upperFlange = extrude(-0.625);
+        sweep(spine, profile.regions.innerPipe).remove();
+        const slots = sketch(upperFlange.endFaces(), () => {
+            hMove(3.25 / 2);
+            const outerSlot = slot(1, 0.75 / 2);
+            const innerSlot = slot(1, 0.45 / 2);
+            return { outerSlot, innerSlot };
+        });
+        const s1 = cut(slots.regions.innerSlot);
+        const s2 = cut(0.25, slots.regions.outerSlot);
+        const a = axis(spine.regions.topSegment);
+        repeat("circular", a, { count: 4, angle: 360 }, s1, s2);
+        if (includeRemove) {
+            remove(spine);
+        }
+    }
+    function currentScene() {
+        const mgr = getSceneManager();
+        if (!mgr) {
+            throw new Error("Scene manager not initialized");
+        }
+        return mgr.currentScene;
+    }
+    function startNewScene() {
+        const mgr = getSceneManager();
+        if (!mgr) {
+            throw new Error("Scene manager not initialized");
+        }
+        return mgr.startScene();
+    }
+    it("re-parsing the same script with cache compare does not throw", () => {
+        buildScene(false);
+        render();
+        const previousScene = currentScene();
+        expect(previousScene.getAllSceneObjects().some(o => o.getError())).toBe(false);
+        const newScene = startNewScene();
+        buildScene(false);
+        SceneCompare.compare(previousScene, newScene);
+        const rendered = render();
+        const errored = rendered.getAllSceneObjects().filter(o => o.getError());
+        expect(errored.map(o => `${o.getUniqueType()}: ${o.getError()}`)).toEqual([]);
+    });
+    it("appending remove(spine) after a cached render does not throw", () => {
+        buildScene(false);
+        render();
+        const previousScene = currentScene();
+        const newScene = startNewScene();
+        buildScene(true);
+        SceneCompare.compare(previousScene, newScene);
+        const rendered = render();
+        const errored = rendered.getAllSceneObjects().filter(o => o.getError());
+        expect(errored.map(o => `${o.getUniqueType()}: ${o.getError()}`)).toEqual([]);
+    });
+});