fluidcad 0.0.23 → 0.0.25

package/lib/dist/core/sphere.d.ts

@@ -1,16 +1,16 @@
-import { ISceneObject } from "./interfaces.js";
+import { ITransformable } from "./interfaces.js";
 interface SphereFunction {
     /**
      * Creates a full sphere with the given radius.
      * @param radius - The sphere radius
      */
-    (radius: number): ISceneObject;
+    (radius: number): ITransformable;
     /**
      * Creates a partial sphere with the given radius and sweep angle.
      * @param radius - The sphere radius
      * @param angle - The sweep angle in degrees
      */
-    (radius: number, angle: number): ISceneObject;
+    (radius: number, angle: number): ITransformable;
 }
 declare const _default: SphereFunction;
 export default _default;

package/lib/dist/core/subtract.d.ts

@@ -1,4 +1,4 @@
-import { ISceneObject } from "./interfaces.js";
+import { ISceneObject, ITransformable } from "./interfaces.js";
 interface SubtractFunction {
     /**
      * Subtracts the second shape from the first (boolean difference).
@@ -6,7 +6,7 @@ interface SubtractFunction {
      * @param object1 - The base shape
      * @param object2 - The shape to subtract
      */
-    (object1: ISceneObject, object2: ISceneObject): ISceneObject;
+    (object1: ISceneObject, object2: ISceneObject): ITransformable;
 }
 declare const _default: SubtractFunction;
 export default _default;

package/lib/dist/core/translate.d.ts

@@ -1,26 +1,26 @@
 import { PointLike } from "../math/point.js";
-import { ISceneObject } from "./interfaces.js";
+import { ISceneObject, ITransformable } from "./interfaces.js";
 interface TranslateFunction {
     /**
      * Translates objects along the X axis.
      * @param x - The X distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, ...targets: ISceneObject[]): ITransformable;
     /**
      * Translates objects along the X axis, optionally making a copy.
      * @param x - The X distance
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, copy: boolean, ...targets: ISceneObject[]): ITransformable;
     /**
      * Translates objects along the X and Y axes.
      * @param x - The X distance
      * @param y - The Y distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, y: number, ...targets: ISceneObject[]): ITransformable;
     /**
      * Translates objects along the X and Y axes, optionally making a copy.
      * @param x - The X distance
@@ -28,7 +28,7 @@ interface TranslateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, y: number, copy: boolean, ...targets: ISceneObject[]): ITransformable;
     /**
      * Translates objects along all three axes.
      * @param x - The X distance
@@ -36,7 +36,7 @@ interface TranslateFunction {
      * @param z - The Z distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, z: number, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, y: number, z: number, ...targets: ISceneObject[]): ITransformable;
     /**
      * Translates objects along all three axes, optionally making a copy.
      * @param x - The X distance
@@ -45,20 +45,20 @@ interface TranslateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, z: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, y: number, z: number, copy: boolean, ...targets: ISceneObject[]): ITransformable;
     /**
      * Translates objects by a point-like offset.
      * @param distance - The offset as a point
      * @param targets - The objects to translate (defaults to last object)
      */
-    (distance: PointLike, ...targets: ISceneObject[]): ISceneObject;
+    (distance: PointLike, ...targets: ISceneObject[]): ITransformable;
     /**
      * Translates objects by a point-like offset, optionally making a copy.
      * @param distance - The offset as a point
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (distance: PointLike, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (distance: PointLike, copy: boolean, ...targets: ISceneObject[]): ITransformable;
 }
 declare const _default: TranslateFunction;
 export default _default;

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

@@ -21,8 +21,9 @@ export class Circle extends ExtrudableGeometryBase {
         const circle = Geometry.makeCircle(plane.localToWorld(center), radius, plane.normal);
         let edge = Geometry.makeEdgeFromCircle(circle);
         this.addShape(edge);
-        if (this.sketch)
+        if (this.sketch) {
             this.setCurrentPosition(center);
+        }
         if (this.targetPlane) {
             this.targetPlane.removeShapes(this);
         }

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

@@ -6,10 +6,8 @@ export declare class Slot extends ExtrudableGeometryBase implements ISlot {
     distance: number;
     radius: number;
     private _center;
-    private _angle;
     constructor(distance: number, radius: number, targetPlane?: PlaneObjectBase);
     centered(value?: boolean): this;
-    rotate(angle: number): this;
     build(): void;
     getType(): string;
     getDependencies(): SceneObject[];
@@ -19,6 +17,5 @@ export declare class Slot extends ExtrudableGeometryBase implements ISlot {
         distance: number;
         radius: number;
         centered: boolean;
-        angle: number;
     };
 }

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

@@ -1,12 +1,10 @@
 import { Point2D } from "../../math/point.js";
 import { Geometry } from "../../oc/geometry.js";
-import { rad } from "../../helpers/math-helpers.js";
 import { ExtrudableGeometryBase } from "./extrudable-base.js";
 export class Slot extends ExtrudableGeometryBase {
     distance;
     radius;
     _center = false;
-    _angle = 0;
     constructor(distance, radius, targetPlane = null) {
         super(targetPlane);
         this.distance = distance;
@@ -16,10 +14,6 @@ export class Slot extends ExtrudableGeometryBase {
         this._center = value;
         return this;
     }
-    rotate(angle) {
-        this._angle = angle;
-        return this;
-    }
     build() {
         if (this.distance < 0) {
             throw new Error("Slot distance must be positive");
@@ -30,26 +24,14 @@ export class Slot extends ExtrudableGeometryBase {
             ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
             : this.getCurrentPosition();
         if (this._center) {
-            const angleRad = rad(this._angle);
-            const cos = Math.cos(angleRad);
-            const sin = Math.sin(angleRad);
-            leftCenter = leftCenter.translate(-this.distance / 2 * cos, -this.distance / 2 * sin);
+            leftCenter = leftCenter.translate(-this.distance / 2, 0);
         }
-        const angleRad = rad(this._angle);
-        const cos = Math.cos(angleRad);
-        const sin = Math.sin(angleRad);
-        // Direction along the slot axis
-        const dirX = cos;
-        const dirY = sin;
-        // 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 + this.distance, leftCenter.y);
         // 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);
-        const bottomRight = new Point2D(rightCenter.x - this.radius * perpX, rightCenter.y - this.radius * perpY);
-        const bottomLeft = new Point2D(leftCenter.x - this.radius * perpX, leftCenter.y - this.radius * perpY);
+        const topLeft = new Point2D(leftCenter.x, leftCenter.y + this.radius);
+        const topRight = new Point2D(rightCenter.x, rightCenter.y + this.radius);
+        const bottomRight = new Point2D(rightCenter.x, rightCenter.y - this.radius);
+        const bottomLeft = new Point2D(leftCenter.x, leftCenter.y - this.radius);
         // Top line: topLeft -> topRight
         const topSegment = Geometry.makeSegment(localToWorld(topLeft), localToWorld(topRight));
         // Right arc: topRight -> bottomRight (CW semicircle around rightCenter)
@@ -87,7 +69,6 @@ export class Slot extends ExtrudableGeometryBase {
         const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
         const s = new Slot(this.distance, this.radius, targetPlane);
         s.centered(this._center);
-        s.rotate(this._angle);
         return s;
     }
     compareTo(other) {
@@ -105,15 +86,13 @@ export class Slot extends ExtrudableGeometryBase {
         }
         return this.distance === other.distance &&
             this.radius === other.radius &&
-            this._center === other._center &&
-            this._angle === other._angle;
+            this._center === other._center;
     }
     serialize() {
         return {
             distance: this.distance,
             radius: this.radius,
             centered: this._center,
-            angle: this._angle,
         };
     }
 }

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

@@ -15,13 +15,15 @@ export class TangentArcWithTangent extends GeometrySceneObject {
     }
     build() {
         const plane = this.sketch.getPlane();
-        const radius = this.radius;
+        // Negative radius flips the sweep direction.
+        const radius = Math.abs(this.radius);
+        const signedEndAngle = this.radius < 0 ? -this.endAngle : this.endAngle;
         const tangent = this.startTangent.asPoint2D();
         // Derive the base angle from the provided tangent.
         // Tangent at angle θ on a circle is (-sin θ, cos θ),
         // so θ = atan2(-tx, ty).
         const baseAngle = Math.atan2(-tangent.x, tangent.y);
-        const clampedEndAngle = Math.max(this.endAngle, -359.9999);
+        const clampedEndAngle = Math.max(signedEndAngle, -359.9999);
         const cw = clampedEndAngle < 0;
         const startAngleRad = cw ? baseAngle + Math.PI : baseAngle;
         const endAngleRad = startAngleRad + rad(clampedEndAngle);

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

@@ -17,7 +17,9 @@ export class TangentArc extends GeometrySceneObject {
             throw new Error('TangentArc requires a previous sibling with a tangent');
         }
         const plane = this.sketch.getPlane();
-        const radius = this.radius;
+        // Negative radius flips the sweep direction.
+        const radius = Math.abs(this.radius);
+        const signedEndAngle = this.radius < 0 ? -this.endAngle : this.endAngle;
         // Derive the base angle from the previous sibling's tangent.
         // Tangent at angle θ on a circle is (-sin θ, cos θ),
         // so θ = atan2(-tx, ty).
@@ -25,7 +27,7 @@ export class TangentArc extends GeometrySceneObject {
         // For CW (negative endAngle), flip the center to the opposite side
         // and negate the normal so makeArc sweeps in reverse
         // Clamp to avoid coincident start/end points at exactly ±360°
-        const clampedEndAngle = Math.max(this.endAngle, -359.9999);
+        const clampedEndAngle = Math.max(signedEndAngle, -359.9999);
         const cw = clampedEndAngle < 0;
         const startAngleRad = cw ? baseAngle + Math.PI : baseAngle;
         const endAngleRad = startAngleRad + rad(clampedEndAngle);

package/lib/dist/features/axis-from-edge.js

@@ -13,7 +13,7 @@ export class AxisFromEdge extends AxisObjectBase {
     build() {
         let axis;
         if (this.sourceObject instanceof SelectSceneObject) {
-            const shapes = this.sourceObject.getShapes();
+            const shapes = this.sourceObject.getShapes({ excludeGuide: false });
             console.log(`Axis: Retrieved ${shapes.length} shapes from selection`);
             if (shapes.length === 0) {
                 throw new Error("Axis: Selected object has no shapes to extract axis from");
@@ -34,7 +34,7 @@ export class AxisFromEdge extends AxisObjectBase {
             axis = this.sourceObject.getAxis();
         }
         else if (this.sourceObject instanceof SceneObject) {
-            const shapes = this.sourceObject.getShapes();
+            const shapes = this.sourceObject.getShapes({ excludeGuide: false });
             console.log(`Axis: Retrieved ${shapes.length} shapes from source object`);
             if (shapes.length === 0) {
                 throw new Error("Axis: Source object has no shapes to extract axis from");

package/lib/dist/features/axis-from-sketch.d.ts

@@ -0,0 +1,18 @@
+import { AxisTransformOptions, StandardAxis } from "../math/axis.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { SceneObject } from "../common/scene-object.js";
+import { Sketch } from "./2d/sketch.js";
+export declare class AxisFromSketch extends AxisObjectBase {
+    private sketch;
+    private direction;
+    private options?;
+    constructor(sketch: Sketch, direction: StandardAxis, options?: AxisTransformOptions);
+    build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: AxisFromSketch): boolean;
+    getUniqueType(): string;
+    serialize(): {
+        direction: StandardAxis;
+        options: AxisTransformOptions;
+    };
+}

package/lib/dist/features/axis-from-sketch.js

@@ -0,0 +1,58 @@
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { EdgeOps } from "../oc/edge-ops.js";
+export class AxisFromSketch extends AxisObjectBase {
+    sketch;
+    direction;
+    options;
+    constructor(sketch, direction, options) {
+        super();
+        this.sketch = sketch;
+        this.direction = direction;
+        this.options = options;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        let axis = plane.normalizeAxis(this.direction);
+        if (!axis) {
+            throw new Error(`AxisFromSketch: invalid direction '${this.direction}'`);
+        }
+        if (this.options) {
+            axis = axis.transform(this.options);
+        }
+        this.setState('axis', axis);
+        const edge = EdgeOps.axisToEdge(axis);
+        edge.markAsMetaShape();
+        this.addShape(edge);
+    }
+    createCopy(remap) {
+        const sketch = remap.get(this.sketch) || this.sketch;
+        return new AxisFromSketch(sketch, this.direction, this.options);
+    }
+    compareTo(other) {
+        if (!(other instanceof AxisFromSketch)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.sketch.compareTo(other.sketch)) {
+            return false;
+        }
+        if (this.direction !== other.direction) {
+            return false;
+        }
+        if (JSON.stringify(this.options) !== JSON.stringify(other.options)) {
+            return false;
+        }
+        return true;
+    }
+    getUniqueType() {
+        return 'axis-from-sketch';
+    }
+    serialize() {
+        return {
+            direction: this.direction,
+            options: this.options,
+        };
+    }
+}

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

@@ -2,11 +2,13 @@ import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js"
 import { Axis } from "../math/axis.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
 import { LinearCopyOptions } from "./copy-linear.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+export type CopyLinear2DAxis = Axis | AxisObjectBase;
 export declare class CopyLinear2D extends GeometrySceneObject {
-    axes: Axis[];
+    axes: CopyLinear2DAxis[];
     options: LinearCopyOptions;
     targetObjects: SceneObject[] | null;
-    constructor(axes: Axis[], options: LinearCopyOptions, targetObjects?: SceneObject[] | null);
+    constructor(axes: CopyLinear2DAxis[], options: LinearCopyOptions, targetObjects?: SceneObject[] | null);
     build(context: BuildSceneObjectContext): void;
     compareTo(other: CopyLinear2D): boolean;
     getType(): string;

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

@@ -1,6 +1,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";
 export class CopyLinear2D extends GeometrySceneObject {
     axes;
     options;
@@ -20,17 +21,18 @@ export class CopyLinear2D extends GeometrySceneObject {
         else {
             objects = allSiblings;
         }
+        const resolvedAxes = this.axes.map(a => a instanceof AxisObjectBase ? a.getAxis() : a);
         const { count, centered, skip } = this.options;
         const counts = Array.isArray(count)
             ? count
-            : this.axes.map(() => count);
+            : resolvedAxes.map(() => 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 : resolvedAxes.map(() => 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 : resolvedAxes.map(() => this.options.length))
             : null;
-        const axisOffsets = this.axes.map((_, a) => {
+        const axisOffsets = resolvedAxes.map((_, a) => {
             if (offsets) {
                 return offsets[a] ?? offsets[0];
             }
@@ -38,10 +40,10 @@ export class CopyLinear2D extends GeometrySceneObject {
             const axisCount = counts[a];
             return axisCount > 1 ? len / (axisCount - 1) : 0;
         });
-        const centerIndices = this.axes.map((_, a) => centered ? Math.floor(counts[a] / 2) : 0);
+        const centerIndices = resolvedAxes.map((_, a) => centered ? Math.floor(counts[a] / 2) : 0);
         // Build grid positions as cartesian product of per-axis indices (0..counts[a]-1)
         let positions = [[]];
-        for (let a = 0; a < this.axes.length; a++) {
+        for (let a = 0; a < resolvedAxes.length; a++) {
             const next = [];
             for (const pos of positions) {
                 for (let i = 0; i < counts[a]; i++) {
@@ -57,9 +59,9 @@ export class CopyLinear2D extends GeometrySceneObject {
                 continue;
             }
             let matrix = Matrix4.identity();
-            for (let a = 0; a < this.axes.length; a++) {
+            for (let a = 0; a < resolvedAxes.length; a++) {
                 const distance = (pos[a] - centerIndices[a]) * axisOffsets[a];
-                const translation = this.axes[a].direction.multiply(distance);
+                const translation = resolvedAxes[a].direction.multiply(distance);
                 matrix = matrix.multiply(Matrix4.fromTranslationVector(translation));
             }
             for (const obj of objects) {
@@ -82,7 +84,19 @@ export class CopyLinear2D extends GeometrySceneObject {
             return false;
         }
         for (let i = 0; i < this.axes.length; i++) {
-            if (!this.axes[i].equals(other.axes[i])) {
+            const a = this.axes[i];
+            const b = other.axes[i];
+            const aIsObj = a instanceof AxisObjectBase;
+            const bIsObj = b instanceof AxisObjectBase;
+            if (aIsObj !== bIsObj) {
+                return false;
+            }
+            if (aIsObj) {
+                if (!a.compareTo(b)) {
+                    return false;
+                }
+            }
+            else if (!a.equals(b)) {
                 return false;
             }
         }

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

@@ -70,6 +70,16 @@ export class MirrorShape extends SceneObject {
         if (!this.plane.compareTo(other.plane)) {
             return false;
         }
+        const thisTargetObjects = this.targetObjects || [];
+        const otherTargetObjects = other.targetObjects || [];
+        if (thisTargetObjects.length !== otherTargetObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < thisTargetObjects.length; i++) {
+            if (!thisTargetObjects[i].compareTo(otherTargetObjects[i])) {
+                return false;
+            }
+        }
         return true;
     }
     getType() {

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

@@ -14,7 +14,7 @@ export declare class SelectSceneObject extends SceneObject implements ISelect {
     private getAllShapes;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
-    transform(matrix: Matrix4): SelectSceneObject;
+    withTransformedFilters(matrix: Matrix4): SelectSceneObject;
     private injectScopeFaces;
     applyFilters(shapes: Shape[], filters: FilterBuilderBase<Shape>[]): Shape[];
     compareTo(other: SelectSceneObject): boolean;

package/lib/dist/features/select.js

@@ -63,9 +63,8 @@ export class SelectSceneObject extends SceneObject {
             : undefined;
         return new SelectSceneObject(this.filters, remappedConstraint);
     }
-    transform(matrix) {
+    withTransformedFilters(matrix) {
         const mirroredFilters = this.filters.map(f => f.transform(matrix));
-        console.log('SelectSceneObject: transform applied to selection filters.', mirroredFilters);
         return new SelectSceneObject(mirroredFilters, this.constraintObject);
     }
     injectScopeFaces(filters, sceneObjects) {

package/lib/dist/math/axis.d.ts

@@ -69,4 +69,5 @@ export declare class Axis {
 export type StandardAxis = "x" | "y" | "z";
 export type AxisLike = StandardAxis | Axis | IAxis | AxisObjectBase;
 export declare function isAxisLike(value: unknown): value is AxisLike;
+export declare function isStandardAxis(value: unknown): value is StandardAxis;
 export declare function toAxis(value: AxisLike): Axis;

package/lib/dist/math/axis.js

@@ -140,7 +140,10 @@ export class Axis {
     }
 }
 export function isAxisLike(value) {
-    return value instanceof AxisObjectBase || value instanceof Axis || value === "x" || value === "y" || value === "z";
+    return value instanceof AxisObjectBase || value instanceof Axis || isStandardAxis(value);
+}
+export function isStandardAxis(value) {
+    return value === "x" || value === "y" || value === "z";
 }
 export function toAxis(value) {
     if (value instanceof Axis) {

package/lib/dist/math/index.d.ts

@@ -2,7 +2,7 @@ export { Vector3d, Vector3dLike, normalizeVector as toVector3d } from "./vector3
 export { Point, Point2D, PointLike, Point2DLike, isPointLike, isPoint2DLike } from "./point.js";
 export { Quaternion } from "./quaternion.js";
 export { Matrix4 } from "./matrix4.js";
-export { Axis, AxisLike, StandardAxis, AxisTransformOptions, isAxisLike, toAxis } from "./axis.js";
+export { Axis, AxisLike, StandardAxis, AxisTransformOptions, isAxisLike, isStandardAxis, toAxis } from "./axis.js";
 export { Plane, PlaneLike, StandardPlane, PlaneTransformOptions, RotationSpace, isPlaneLike, toPlane } from "./plane.js";
 export { CoordinateSystem } from "./coordinate-system.js";
 export { Convert } from "./convert.js";

package/lib/dist/math/index.js

@@ -2,7 +2,7 @@ export { Vector3d, normalizeVector as toVector3d } from "./vector3d.js";
 export { Point, Point2D, isPointLike, isPoint2DLike } from "./point.js";
 export { Quaternion } from "./quaternion.js";
 export { Matrix4 } from "./matrix4.js";
-export { Axis, isAxisLike, toAxis } from "./axis.js";
+export { Axis, isAxisLike, isStandardAxis, toAxis } from "./axis.js";
 export { Plane, isPlaneLike, toPlane } from "./plane.js";
 export { CoordinateSystem } from "./coordinate-system.js";
 export { Convert } from "./convert.js";

package/lib/dist/rendering/render.js

@@ -3,6 +3,7 @@ import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { Sketch } from "../features/2d/sketch.js";
 import { transformMeshes } from "./mesh-transform.js";
+import { ShapeOps } from "../oc/shape-ops.js";
 const meshBuilder = new MeshBuilder();
 function renderSceneObject(obj, scene, buildDurationMs) {
     const hasError = !!obj.getError();
@@ -199,6 +200,13 @@ export function renderScene(scene) {
                         return null;
                     },
                 });
+                const appliedTransform = object.getAppliedTransform();
+                if (appliedTransform && !object.isContainer()) {
+                    const shapes = object.getAddedShapes();
+                    for (let i = 0; i < shapes.length; i++) {
+                        shapes[i] = ShapeOps.transform(shapes[i], appliedTransform);
+                    }
+                }
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);

package/lib/dist/tests/features/mirror2d.test.js

@@ -3,6 +3,7 @@ import { setupOC, render } from "../setup.js";
 import sketch from "../../core/sketch.js";
 import extrude from "../../core/extrude.js";
 import mirror from "../../core/mirror.js";
+import local from "../../core/local.js";
 import { move, rect, circle } from "../../core/2d/index.js";
 import { ShapeOps } from "../../oc/shape-ops.js";
 describe("mirror (2D)", () => {
@@ -72,4 +73,37 @@ describe("mirror (2D)", () => {
             expect(shapes.length).toBeGreaterThanOrEqual(2);
         });
     });
+    describe("local() axis wrapper", () => {
+        it("should fail when mirroring across a world axis parallel to the sketch plane normal", () => {
+            let mirrorRef;
+            sketch("front", () => {
+                move([30, 0]);
+                const c = circle(20);
+                mirrorRef = mirror("y", c);
+            });
+            render();
+            expect(mirrorRef.getError()).toBeTruthy();
+        });
+        it("should mirror across sketch-local Y on a non-XY plane via local()", () => {
+            sketch("front", () => {
+                move([30, 0]);
+                const c = circle(20);
+                mirror(local("y"), c);
+            });
+            const e = extrude(10);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+            // Mirroring across sketch-local Y on the "front" plane flips world X,
+            // so bbox should span both sides of X=0.
+            const allBBoxes = shapes.map(s => ShapeOps.getBoundingBox(s));
+            const minX = Math.min(...allBBoxes.map(b => b.minX));
+            const maxX = Math.max(...allBBoxes.map(b => b.maxX));
+            expect(minX).toBeLessThan(0);
+            expect(maxX).toBeGreaterThan(0);
+        });
+        it("should throw when local() is called outside a sketch", () => {
+            expect(() => local("y")).toThrow();
+        });
+    });
 });

package/lib/dist/tests/features/scene-object-chain.test.d.ts

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