fluidcad 0.0.33 → 0.0.35

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 = {
@@ -32,6 +33,15 @@ export declare abstract class ExtrudeBase extends SceneObject implements IExtrud
     get faceSource(): SceneObject | null;
     isFaceSourced(): boolean;
     getSource(): SceneObject | null;
+    /**
+     * Dependency tail for cloning: if the source is a sketch-bound geometry
+     * primitive, return its containing `Sketch` so cloneWithTransform pulls
+     * the sketch in too. The sketch's clone-mode build path then carries
+     * correctly-transformed shapes onto cloned children, and the cloned
+     * primitive retains a `Sketch` parent for plane resolution. Otherwise
+     * return the source as-is.
+     */
+    protected getSourceDependencies(): SceneObject[];
     getSourcePlane(): Plane | null;
     getSourceFaces(): Face[];
     startFaces(...args: number[] | FaceFilterBuilder[]): SceneObject;
@@ -96,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

@@ -2,6 +2,7 @@ import { Face } from "../common/face.js";
 import { Edge } from "../common/edge.js";
 import { SceneObject } from "../common/scene-object.js";
 import { LazySelectionSceneObject } from "./lazy-scene-object.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
 import { normalizePoint2D } from "../helpers/normalize.js";
 import { FaceOps } from "../oc/face-ops.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
@@ -10,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";
@@ -81,6 +83,27 @@ export class ExtrudeBase extends SceneObject {
     getSource() {
         return this._extrudable ?? this._faceSource;
     }
+    /**
+     * Dependency tail for cloning: if the source is a sketch-bound geometry
+     * primitive, return its containing `Sketch` so cloneWithTransform pulls
+     * the sketch in too. The sketch's clone-mode build path then carries
+     * correctly-transformed shapes onto cloned children, and the cloned
+     * primitive retains a `Sketch` parent for plane resolution. Otherwise
+     * return the source as-is.
+     */
+    getSourceDependencies() {
+        const source = this.getSource();
+        if (!source) {
+            return [];
+        }
+        if (source instanceof GeometrySceneObject) {
+            const sketch = source.sketch;
+            if (sketch) {
+                return [sketch];
+            }
+        }
+        return [source];
+    }
     getSourcePlane() {
         if (this._extrudable) {
             return this._extrudable.getPlane();
@@ -376,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) {
@@ -388,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/extrude-to-face.js

@@ -282,11 +282,7 @@ export class ExtrudeToFace extends ExtrudeBase {
         return objects;
     }
     getDependencies() {
-        const deps = [];
-        const source = this.getSource();
-        if (source) {
-            deps.push(source);
-        }
+        const deps = [...this.getSourceDependencies()];
         if (this.face instanceof SceneObject) {
             deps.push(this.face);
         }

package/lib/dist/features/extrude-two-distances.js

@@ -158,8 +158,7 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         this.setFinalShapes(this.getShapes());
     }
     getDependencies() {
-        const source = this.getSource();
-        return source ? [source] : [];
+        return this.getSourceDependencies();
     }
     createCopy(remap) {
         const source = this.getSource();

package/lib/dist/features/extrude.js

@@ -286,8 +286,7 @@ export class Extrude extends ExtrudeBase {
         });
     }
     getDependencies() {
-        const source = this.getSource();
-        return source ? [source] : [];
+        return this.getSourceDependencies();
     }
     createCopy(remap) {
         const source = this.getSource();

package/lib/dist/features/mirror-feature.d.ts

@@ -1,10 +1,11 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 import { PlaneObjectBase } from "./plane-renderable-base.js";
 export declare class MirrorFeature extends SceneObject {
     private plane;
-    private _matrix?;
-    constructor(plane: PlaneObjectBase, _matrix?: Matrix4);
+    private _matrix;
+    constructor(plane: PlaneObjectBase, _matrix: LazyMatrix);
     getTransformMatrix(): Matrix4 | null;
     isContainer(): boolean;
     build(context: BuildSceneObjectContext): void;

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

@@ -9,7 +9,7 @@ export class MirrorFeature extends SceneObject {
         this.setAlwaysVisible();
     }
     getTransformMatrix() {
-        return this._matrix || null;
+        return this._matrix.resolve();
     }
     isContainer() {
         return true;

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,21 +1,22 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { Axis } from "../math/axis.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 {
-    axis: Axis;
+export declare class RepeatCircular extends RepeatBase {
+    axis: RepeatAxisSource;
     options: CircularRepeatOptions;
     targetObjects: SceneObject[] | null;
-    constructor(axis: Axis, options: CircularRepeatOptions, targetObjects?: SceneObject[] | null);
+    constructor(axis: RepeatAxisSource, options: CircularRepeatOptions, targetObjects?: SceneObject[] | null);
     isContainer(): boolean;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: RepeatCircular): boolean;

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

@@ -1,5 +1,6 @@
-import { SceneObject } from "../common/scene-object.js";
-export class RepeatCircular extends SceneObject {
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { RepeatBase } from "./repeat-base.js";
+export class RepeatCircular extends RepeatBase {
     axis;
     options;
     targetObjects;
@@ -14,6 +15,9 @@ export class RepeatCircular extends SceneObject {
         return true;
     }
     build(context) {
+        if (this.axis instanceof AxisObjectBase) {
+            this.axis.removeShapes(this);
+        }
         this.saveShapesSnapshot(context);
     }
     compareTo(other) {
@@ -23,7 +27,7 @@ export class RepeatCircular extends SceneObject {
         if (!super.compareTo(other)) {
             return false;
         }
-        if (!this.axis.equals(other.axis)) {
+        if (!RepeatCircular.axisSourceEquals(this.axis, other.axis)) {
             return false;
         }
         const thisTargetObjects = this.targetObjects || [];

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

@@ -1,21 +1,23 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { Axis } from "../math/axis.js";
+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 {
-    axes: Axis[];
+export declare class RepeatLinear extends RepeatBase {
+    axes: RepeatAxisSource[];
     options: LinearRepeatOptions;
     targetObjects: SceneObject[] | null;
-    constructor(axes: Axis[], options: LinearRepeatOptions, targetObjects?: SceneObject[] | null);
+    constructor(axes: RepeatAxisSource[], options: LinearRepeatOptions, targetObjects?: SceneObject[] | null);
     isContainer(): boolean;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: RepeatLinear): boolean;

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

@@ -1,5 +1,6 @@
-import { SceneObject } from "../common/scene-object.js";
-export class RepeatLinear extends SceneObject {
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { RepeatBase } from "./repeat-base.js";
+export class RepeatLinear extends RepeatBase {
     axes;
     options;
     targetObjects;
@@ -14,6 +15,11 @@ export class RepeatLinear extends SceneObject {
         return true;
     }
     build(context) {
+        for (const axis of this.axes) {
+            if (axis instanceof AxisObjectBase) {
+                axis.removeShapes(this);
+            }
+        }
         this.saveShapesSnapshot(context);
     }
     compareTo(other) {
@@ -27,7 +33,7 @@ export class RepeatLinear extends SceneObject {
             return false;
         }
         for (let i = 0; i < this.axes.length; i++) {
-            if (!this.axes[i].equals(other.axes[i])) {
+            if (!RepeatLinear.axisSourceEquals(this.axes[i], other.axes[i])) {
                 return false;
             }
         }

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

@@ -1,9 +1,11 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 export declare class RepeatMatrix extends SceneObject {
     private _matrix;
     targetObjects: SceneObject[];
-    constructor(_matrix: Matrix4, targetObjects: SceneObject[]);
+    private sources;
+    constructor(_matrix: LazyMatrix, targetObjects: SceneObject[], sources?: SceneObject[]);
     getTransformMatrix(): Matrix4 | null;
     isContainer(): boolean;
     build(context: BuildSceneObjectContext): void;

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

@@ -2,19 +2,24 @@ import { SceneObject } from "../common/scene-object.js";
 export class RepeatMatrix extends SceneObject {
     _matrix;
     targetObjects;
-    constructor(_matrix, targetObjects) {
+    sources;
+    constructor(_matrix, targetObjects, sources = []) {
         super();
         this._matrix = _matrix;
         this.targetObjects = targetObjects;
+        this.sources = sources;
         this.setAlwaysVisible();
     }
     getTransformMatrix() {
-        return this._matrix;
+        return this._matrix.resolve();
     }
     isContainer() {
         return true;
     }
     build(context) {
+        for (const source of this.sources) {
+            source.removeShapes(this);
+        }
         this.saveShapesSnapshot(context);
     }
     compareTo(other) {

package/lib/dist/features/shell.d.ts

@@ -2,12 +2,14 @@ import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js"
 import { SelectSceneObject } from "./select.js";
 import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
-import { IShell } from "../core/interfaces.js";
+import { IShell, ShellJoinType } from "../core/interfaces.js";
 export declare class Shell extends SceneObject implements IShell {
     private thickness;
     private _faceSelections;
+    private _joinType;
     constructor(thickness: number, faceSelections?: SelectSceneObject[]);
     get faceSelections(): SelectSceneObject[];
+    join(type: ShellJoinType): this;
     validate(): void;
     build(context: BuildSceneObjectContext): void;
     internalFaces(...args: (number | FaceFilterBuilder)[]): SceneObject;
@@ -21,5 +23,6 @@ export declare class Shell extends SceneObject implements IShell {
     getType(): string;
     serialize(): {
         thickness: number;
+        joinType: "intersection" | "tangent";
     };
 }

package/lib/dist/features/shell.js

@@ -11,6 +11,7 @@ import { requireShapes } from "../common/operand-check.js";
 export class Shell extends SceneObject {
     thickness;
     _faceSelections = [];
+    _joinType = 'arc';
     constructor(thickness, faceSelections) {
         super();
         this.thickness = thickness;
@@ -19,6 +20,10 @@ export class Shell extends SceneObject {
     get faceSelections() {
         return this._faceSelections;
     }
+    join(type) {
+        this._joinType = type;
+        return this;
+    }
     validate() {
         for (let i = 0; i < this._faceSelections.length; i++) {
             requireShapes(this._faceSelections[i], `face selection ${i + 1}`, "shell");
@@ -52,7 +57,7 @@ export class Shell extends SceneObject {
                 continue;
             }
             try {
-                const newShape = ShellOps.makeThickSolid(shape, targetFaces, this.thickness);
+                const newShape = ShellOps.makeThickSolid(shape, targetFaces, this.thickness, this._joinType);
                 newShapes.push(newShape);
                 const originalObj = shapeObjMap.get(shape);
                 originalObj.removeShape(shape, this);
@@ -192,6 +197,9 @@ export class Shell extends SceneObject {
         if (this.thickness !== other.thickness) {
             return false;
         }
+        if (this._joinType !== other._joinType) {
+            return false;
+        }
         if (this._faceSelections.length !== other._faceSelections.length) {
             return false;
         }
@@ -207,14 +215,17 @@ export class Shell extends SceneObject {
     }
     createCopy(remap) {
         const faceSelections = this._faceSelections.map(sel => (remap.get(sel) || sel));
-        return new Shell(this.thickness, faceSelections.length > 0 ? faceSelections : undefined);
+        const copy = new Shell(this.thickness, faceSelections.length > 0 ? faceSelections : undefined);
+        copy._joinType = this._joinType;
+        return copy;
     }
     getType() {
         return 'shell';
     }
     serialize() {
         return {
-            thickness: this.thickness
+            thickness: this.thickness,
+            joinType: this._joinType !== 'arc' ? this._joinType : undefined
         };
     }
 }

package/lib/dist/helpers/clone-transform.d.ts

@@ -1,3 +1,4 @@
 import { Matrix4 } from "../math/matrix4.js";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 import { SceneObject } from "../common/scene-object.js";
-export declare function cloneWithTransform(objects: SceneObject[], transform: Matrix4, container: SceneObject): SceneObject[];
+export declare function cloneWithTransform(objects: SceneObject[], transform: Matrix4 | LazyMatrix, container: SceneObject): SceneObject[];

package/lib/dist/index.d.ts

@@ -17,7 +17,18 @@ export type SceneParserContext = {
     getActiveSketch(): Sketch | null;
 };
 export declare function registerBuilder<T extends Function>(builder: (context: SceneParserContext) => T): T;
-export declare function init(rootPath?: string): Promise<{
+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;
+        angularDeflection?: number;
+    };
+}
+export declare function init(options?: FluidCADOptions): Promise<{
     currentScene: Scene;
     currentFile: string;
     renderer: import("./rendering/render.js").SceneRenderer;

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 async function init(rootPath) {
+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 resolvedPath = rootPath || process.env.FLUIDCAD_WORKSPACE_PATH || '';
-    return createManager(resolvedPath);
+    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

@@ -0,0 +1,36 @@
+import { Matrix4 } from "./matrix4.js";
+import { Axis } from "./axis.js";
+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
+ * value that depends on scene state (e.g. an AxisObjectBase or
+ * PlaneObjectBase) before that state exists. Resolution is deferred to the
+ * first call to `resolve()`, by which point the renderer has built the source
+ * object. Concrete `Axis` / `Plane` sources resolve eagerly with no extra
+ * indirection.
+ */
+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;
+    static rotation(axis: Axis | AxisLazySource, angle: number): LazyMatrix;
+    static translation(axis: Axis | AxisLazySource, distance: number): LazyMatrix;
+}