fluidcad 0.0.34 → 0.0.36

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

@@ -1,5 +1,6 @@
 import { Point2D } from "../../math/point.js";
 import { Geometry } from "../../oc/geometry.js";
+import { Vertex } from "../../common/vertex.js";
 import { rad } from "../../helpers/math-helpers.js";
 import { ExtrudableGeometryBase } from "./extrudable-base.js";
 export class Slot extends ExtrudableGeometryBase {
@@ -7,11 +8,19 @@ export class Slot extends ExtrudableGeometryBase {
     radius;
     _center = false;
     _angle = 0;
+    _startPoint = null;
+    _endPoint = null;
     constructor(distance, radius, targetPlane = null) {
         super(targetPlane);
         this.distance = distance;
         this.radius = radius;
     }
+    static fromTwoPoints(start, end, radius, targetPlane = null) {
+        const slot = new Slot(0, radius, targetPlane);
+        slot._startPoint = start;
+        slot._endPoint = end;
+        return slot;
+    }
     centered(value = true) {
         this._center = value;
         return this;
@@ -21,21 +30,28 @@ export class Slot extends ExtrudableGeometryBase {
         return this;
     }
     build() {
-        if (this.distance < 0) {
-            throw new Error("Slot distance must be positive");
+        if (this._startPoint && this._endPoint) {
+            const s = this._startPoint.asPoint2D();
+            const e = this._endPoint.asPoint2D();
+            const dx = e.x - s.x;
+            const dy = e.y - s.y;
+            this.distance = Math.sqrt(dx * dx + dy * dy);
+            this._angle = Math.atan2(dy, dx) * 180 / Math.PI;
         }
+        const absDistance = Math.abs(this.distance);
+        const flipAngle = this.distance < 0 ? 180 : 0;
         const plane = this.targetPlane?.getPlane() || this.getParent().getPlane();
         const localToWorld = plane.localToWorld.bind(plane);
         let leftCenter = this.targetPlane
             ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
             : this.getCurrentPosition();
         if (this._center) {
-            const angleRad = rad(this._angle);
+            const angleRad = rad(this._angle + flipAngle);
             const cos = Math.cos(angleRad);
             const sin = Math.sin(angleRad);
-            leftCenter = leftCenter.translate(-this.distance / 2 * cos, -this.distance / 2 * sin);
+            leftCenter = leftCenter.translate(-absDistance / 2 * cos, -absDistance / 2 * sin);
         }
-        const angleRad = rad(this._angle);
+        const angleRad = rad(this._angle + flipAngle);
         const cos = Math.cos(angleRad);
         const sin = Math.sin(angleRad);
         // Direction along the slot axis
@@ -44,7 +60,7 @@ export class Slot extends ExtrudableGeometryBase {
         // Perpendicular direction (90 degrees CCW)
         const perpX = -sin;
         const perpY = cos;
-        const rightCenter = new Point2D(leftCenter.x + this.distance * dirX, leftCenter.y + this.distance * dirY);
+        const rightCenter = new Point2D(leftCenter.x + absDistance * dirX, leftCenter.y + absDistance * dirY);
         // Four key points where lines meet arcs
         const topLeft = new Point2D(leftCenter.x + this.radius * perpX, leftCenter.y + this.radius * perpY);
         const topRight = new Point2D(rightCenter.x + this.radius * perpX, rightCenter.y + this.radius * perpY);
@@ -65,6 +81,12 @@ export class Slot extends ExtrudableGeometryBase {
             Geometry.makeEdgeFromCurve(leftArc),
         ];
         this.addShapes(edges);
+        const leftCenterVertex = Vertex.fromPoint2D(leftCenter);
+        leftCenterVertex.markAsMetaShape();
+        this.addShape(leftCenterVertex);
+        const rightCenterVertex = Vertex.fromPoint2D(rightCenter);
+        rightCenterVertex.markAsMetaShape();
+        this.addShape(rightCenterVertex);
         if (this.sketch) {
             if (this._center) {
                 this.setCurrentPosition(this.getCurrentPosition());
@@ -85,7 +107,13 @@ export class Slot extends ExtrudableGeometryBase {
     }
     createCopy(remap) {
         const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
-        const s = new Slot(this.distance, this.radius, targetPlane);
+        let s;
+        if (this._startPoint && this._endPoint) {
+            s = Slot.fromTwoPoints(this._startPoint, this._endPoint, this.radius, targetPlane);
+        }
+        else {
+            s = new Slot(this.distance, this.radius, targetPlane);
+        }
         s.centered(this._center);
         s.rotate(this._angle);
         return s;
@@ -103,6 +131,22 @@ export class Slot extends ExtrudableGeometryBase {
         if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
             return false;
         }
+        if ((this._startPoint === null) !== (other._startPoint === null)) {
+            return false;
+        }
+        if ((this._endPoint === null) !== (other._endPoint === null)) {
+            return false;
+        }
+        if (this._startPoint && other._startPoint && !this._startPoint.compareTo(other._startPoint)) {
+            return false;
+        }
+        if (this._endPoint && other._endPoint && !this._endPoint.compareTo(other._endPoint)) {
+            return false;
+        }
+        if (this._startPoint && this._endPoint) {
+            return this.radius === other.radius &&
+                this._center === other._center;
+        }
         return this.distance === other.distance &&
             this.radius === other.radius &&
             this._center === other._center &&
@@ -114,6 +158,7 @@ export class Slot extends ExtrudableGeometryBase {
             radius: this.radius,
             centered: this._center,
             angle: this._angle,
+            hasTwoPoints: this._startPoint !== null && this._endPoint !== null,
         };
     }
 }

package/lib/dist/features/2d/tarc-to-point-tangent.js

@@ -60,6 +60,9 @@ export class TangentArcToPointTangent extends GeometrySceneObject {
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(targetPoint));
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.setCurrentPosition(targetPoint);
     }
     createCopy(remap) {

package/lib/dist/features/2d/tarc-to-point.js

@@ -58,6 +58,9 @@ export class TangentArcToPoint extends GeometrySceneObject {
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(targetPoint));
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.setCurrentPosition(targetPoint);
     }
     createCopy(remap) {

package/lib/dist/features/2d/tarc-with-tangent.js

@@ -44,6 +44,9 @@ export class TangentArcWithTangent extends GeometrySceneObject {
         const ty = sign * Math.cos(endAngleRad);
         this.setTangent(new Point2D(tx, ty));
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.setCurrentPosition(endPoint);
     }
     createCopy(remap) {

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

@@ -46,6 +46,9 @@ export class TangentArc extends GeometrySceneObject {
         const ty = sign * Math.cos(endAngleRad);
         this.setTangent(new Point2D(tx, ty));
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.setCurrentPosition(endPoint);
     }
     createCopy(remap) {

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

@@ -6,8 +6,10 @@ export declare class VerticalLine extends GeometrySceneObject implements IVLine
     distanceOrTarget: number | SceneObject;
     private targetPlane;
     private _centered;
+    private _hasExplicitStart;
     constructor(distanceOrTarget: number | SceneObject, targetPlane?: PlaneObjectBase);
     centered(value?: boolean): this;
+    setHasExplicitStart(value?: boolean): this;
     build(): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
@@ -17,5 +19,6 @@ export declare class VerticalLine extends GeometrySceneObject implements IVLine
     serialize(): {
         distance: number;
         centered: boolean;
+        hasExplicitStart: boolean;
     };
 }

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 || [];