fluidcad 0.0.24 → 0.0.26

package/lib/dist/common/scene-object.d.ts

@@ -27,6 +27,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     private _id;
     private _order;
     private _transform;
+    private _appliedTransform;
     private _cloneSource;
     private _parent;
     private _alwaysVisible;
@@ -56,6 +57,8 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     abstract serialize(scope?: Set<SceneObject>): any;
     abstract getType(): string;
     abstract build(context?: BuildSceneObjectContext): void;
+    getAppliedTransform(): Matrix4 | null;
+    protected composeAppliedTransform(matrix: Matrix4): void;
     compareTo(other: SceneObject): boolean;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
@@ -104,9 +107,10 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     getOperationMode(): OperationMode;
     isSymmetric(): boolean;
     resolveFusionScope(sceneObjects: SceneObject[]): SceneObject[];
-    add(...objects: ISceneObject[]): this;
+    add(): this;
     new(): this;
-    remove(...objects: ISceneObject[]): this;
+    remove(): this;
+    scope(...objects: ISceneObject[]): this;
     symmetric(): this;
     /**
      * Called after all objects have been built. Override to perform

package/lib/dist/common/scene-object.js

@@ -5,6 +5,7 @@ export class SceneObject {
     _id;
     _order = 0;
     _transform = null;
+    _appliedTransform = null;
     _cloneSource = null;
     _parent = null;
     _alwaysVisible = false;
@@ -89,6 +90,14 @@ export class SceneObject {
     getSnapshot() {
         return this.getState('snapshot') || [];
     }
+    getAppliedTransform() {
+        return this._appliedTransform;
+    }
+    composeAppliedTransform(matrix) {
+        this._appliedTransform = this._appliedTransform
+            ? matrix.multiply(this._appliedTransform)
+            : matrix;
+    }
     compareTo(other) {
         const match = this._guide === other._guide && this._reusable === other._reusable;
         if (!match) {
@@ -100,6 +109,13 @@ export class SceneObject {
         if (this._symmetric !== other._symmetric) {
             return false;
         }
+        if (!this._appliedTransform !== !other._appliedTransform) {
+            return false;
+        }
+        if (this._appliedTransform && other._appliedTransform
+            && !this._appliedTransform.equals(other._appliedTransform)) {
+            return false;
+        }
         if (typeof (this._fusionScope) !== typeof (other._fusionScope)) {
             return false;
         }
@@ -148,6 +164,9 @@ export class SceneObject {
         const result = [];
         for (const obj of ordered) {
             const copy = obj.createCopy(remap);
+            if (obj._appliedTransform) {
+                copy._appliedTransform = obj._appliedTransform;
+            }
             remap.set(obj, copy);
             result.push(copy);
             const parent = obj.getParent();
@@ -351,17 +370,9 @@ export class SceneObject {
         }
         return sceneObjects;
     }
-    add(...objects) {
+    add() {
         this._operationMode = 'add';
-        if (objects.length === 0) {
-            this._fusionScope = 'all';
-        }
-        else if (objects.length === 1) {
-            this._fusionScope = objects[0];
-        }
-        else {
-            this._fusionScope = objects;
-        }
+        this._fusionScope = 'all';
         return this;
     }
     new() {
@@ -369,15 +380,16 @@ export class SceneObject {
         this._fusionScope = 'none';
         return this;
     }
-    remove(...objects) {
+    remove() {
         this._operationMode = 'remove';
-        if (objects.length === 0) {
-            this._fusionScope = 'all';
-        }
-        else if (objects.length === 1) {
+        this._fusionScope = 'all';
+        return this;
+    }
+    scope(...objects) {
+        if (objects.length === 1) {
             this._fusionScope = objects[0];
         }
-        else {
+        else if (objects.length > 1) {
             this._fusionScope = objects;
         }
         return this;

package/lib/dist/common/transformable-primitive.d.ts

@@ -0,0 +1,16 @@
+import { SceneObject } from "./scene-object.js";
+import { Matrix4 } from "../math/matrix4.js";
+import type { AxisLike } from "../math/axis.js";
+import type { PlaneLike } from "../math/plane.js";
+import type { PointLike } from "../math/point.js";
+export declare abstract class TransformablePrimitive extends SceneObject {
+    transform(matrix: Matrix4): this;
+    translate(x: number): this;
+    translate(x: number, y: number): this;
+    translate(x: number, y: number, z: number): this;
+    translate(p: PointLike): this;
+    rotate(angle: number): this;
+    rotate(axis: AxisLike, angle: number): this;
+    mirror(plane: PlaneLike): this;
+    mirror(axis: AxisLike): this;
+}

package/lib/dist/common/transformable-primitive.js

@@ -0,0 +1,116 @@
+import { SceneObject } from "./scene-object.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { Point } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+import { rad } from "../helpers/math-helpers.js";
+export class TransformablePrimitive extends SceneObject {
+    transform(matrix) {
+        this.composeAppliedTransform(matrix);
+        return this;
+    }
+    translate(a, b, c) {
+        let x, y, z;
+        if (typeof a === 'number') {
+            x = a;
+            y = b ?? 0;
+            z = c ?? 0;
+        }
+        else if (Array.isArray(a)) {
+            x = a[0] ?? 0;
+            y = a[1] ?? 0;
+            z = a[2] ?? 0;
+        }
+        else {
+            x = a.x;
+            y = a.y;
+            z = a.z;
+        }
+        return this.transform(Matrix4.fromTranslation(x, y, z));
+    }
+    rotate(a, b) {
+        let origin;
+        let direction;
+        let angleDeg;
+        if (typeof a === 'number') {
+            origin = new Point(0, 0, 0);
+            direction = Vector3d.unitZ();
+            angleDeg = a;
+        }
+        else {
+            const resolved = resolveAxisLike(a);
+            origin = resolved.origin;
+            direction = resolved.direction;
+            angleDeg = b;
+        }
+        return this.transform(Matrix4.fromRotationAroundAxis(origin, direction, rad(angleDeg)));
+    }
+    mirror(arg) {
+        if (isAxisLikeArg(arg)) {
+            const axis = resolveAxisLike(arg);
+            return this.transform(Matrix4.mirrorAxis(axis.origin, axis.direction));
+        }
+        const plane = resolvePlaneLike(arg);
+        return this.transform(Matrix4.mirrorPlane(plane.normal, plane.origin));
+    }
+}
+function isAxisLikeArg(arg) {
+    if (arg === 'x' || arg === 'y' || arg === 'z') {
+        return true;
+    }
+    if (arg && typeof arg === 'object') {
+        if (typeof arg.getAxis === 'function') {
+            return true;
+        }
+        if (arg.origin && arg.direction) {
+            return true;
+        }
+    }
+    return false;
+}
+function resolveAxisLike(arg) {
+    if (arg === 'x') {
+        return { origin: new Point(0, 0, 0), direction: Vector3d.unitX() };
+    }
+    if (arg === 'y') {
+        return { origin: new Point(0, 0, 0), direction: Vector3d.unitY() };
+    }
+    if (arg === 'z') {
+        return { origin: new Point(0, 0, 0), direction: Vector3d.unitZ() };
+    }
+    const a = arg;
+    if (typeof a.getAxis === 'function') {
+        const axis = a.getAxis();
+        return { origin: axis.origin, direction: axis.direction };
+    }
+    return { origin: a.origin, direction: a.direction };
+}
+function resolvePlaneLike(arg) {
+    if (typeof arg === 'string') {
+        switch (arg) {
+            case 'xy':
+            case 'top':
+                return { origin: new Point(0, 0, 0), normal: Vector3d.unitZ() };
+            case '-xy':
+            case 'bottom':
+                return { origin: new Point(0, 0, 0), normal: Vector3d.unitZ().multiply(-1) };
+            case 'xz':
+            case 'front':
+                return { origin: new Point(0, 0, 0), normal: Vector3d.unitY().multiply(-1) };
+            case '-xz':
+            case 'back':
+                return { origin: new Point(0, 0, 0), normal: Vector3d.unitY() };
+            case 'yz':
+            case 'right':
+                return { origin: new Point(0, 0, 0), normal: Vector3d.unitX() };
+            case '-yz':
+            case 'left':
+                return { origin: new Point(0, 0, 0), normal: Vector3d.unitX().multiply(-1) };
+        }
+    }
+    const p = arg;
+    if (typeof p.getPlane === 'function') {
+        const plane = p.getPlane();
+        return { origin: plane.origin, normal: plane.normal };
+    }
+    return { origin: p.origin, normal: p.normal };
+}

package/lib/dist/core/2d/tarc.d.ts

@@ -4,13 +4,13 @@ import { IGeometry, ISceneObject, ITangentArcTwoObjects } from "../interfaces.js
 interface TArcFunction {
     /**
      * Draws a tangent arc with a given radius and end angle.
-     * @param radius - The arc radius (defaults to 100)
+     * @param radius - The arc radius (defaults to 100). A negative value flips the sweep direction.
      * @param endAngle - The sweep angle in degrees (defaults to 90)
      */
     (radius?: number, endAngle?: number): IGeometry;
     /**
      * Draws a tangent arc with a given radius, angle, and start tangent direction.
-     * @param radius - The arc radius
+     * @param radius - The arc radius. A negative value flips the sweep direction.
      * @param angle - The sweep angle in degrees
      * @param tangent - The start tangent direction
      */

package/lib/dist/core/copy.js

@@ -4,6 +4,7 @@ import { CopyLinear } from "../features/copy-linear.js";
 import { CopyCircular } from "../features/copy-circular.js";
 import { CopyLinear2D } from "../features/copy-linear2d.js";
 import { CopyCircular2D } from "../features/copy-circular2d.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
 function build(context) {
     return function copy() {
         const args = Array.from(arguments);
@@ -19,14 +20,14 @@ function build(context) {
             : null;
         if (type === 'linear') {
             const axisArg = args[1];
-            const axes = Array.isArray(axisArg)
-                ? axisArg.map(a => normalizeAxis(a))
-                : [normalizeAxis(axisArg)];
+            const axisList = Array.isArray(axisArg) ? axisArg : [axisArg];
             if (activeSketch) {
-                const copy = new CopyLinear2D(axes, options, restObjects.length > 0 ? restObjects : null);
+                const sketchAxes = axisList.map(a => a instanceof AxisObjectBase ? a : normalizeAxis(a));
+                const copy = new CopyLinear2D(sketchAxes, options, restObjects.length > 0 ? restObjects : null);
                 context.addSceneObject(copy);
                 return copy;
             }
+            const axes = axisList.map(a => normalizeAxis(a));
             const copy = new CopyLinear(axes, options, objects);
             context.addSceneObject(copy);
             return copy;

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

@@ -1,11 +1,11 @@
-import { ISceneObject } from "./interfaces.js";
+import { ITransformable } from "./interfaces.js";
 interface CylinderFunction {
     /**
      * Creates a cylinder with the given radius and height.
      * @param radius - The cylinder radius
      * @param height - The cylinder height
      */
-    (radius: number, height: number): ISceneObject;
+    (radius: number, height: number): ITransformable;
 }
 declare const _default: CylinderFunction;
 export default _default;

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

@@ -1,5 +1,6 @@
-export type { ISceneObject, IFuseable, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft } from "./interfaces.js";
+export type { ISceneObject, ITransformable, IBooleanOperation, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft } from "./interfaces.js";
 export { default as axis } from "./axis.js";
+export { default as local } from "./local.js";
 export { default as plane } from "./plane.js";
 export { default as sketch } from "./sketch.js";
 export { default as fuse } from "./fuse.js";

package/lib/dist/core/index.js

@@ -1,4 +1,5 @@
 export { default as axis } from "./axis.js";
+export { default as local } from "./local.js";
 export { default as plane } from "./plane.js";
 export { default as sketch } from "./sketch.js";
 export { default as fuse } from "./fuse.js";

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

@@ -1,7 +1,10 @@
-import { LazyVertex } from "../features/lazy-vertex.js";
-import { Point2DLike } from "../math/point.js";
-import { FaceFilterBuilder } from "../filters/face/face-filter.js";
-import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+import type { LazyVertex } from "../features/lazy-vertex.js";
+import type { Point2DLike, PointLike } from "../math/point.js";
+import type { FaceFilterBuilder } from "../filters/face/face-filter.js";
+import type { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+import type { Matrix4 } from "../math/matrix4.js";
+import type { AxisLike } from "../math/axis.js";
+import type { PlaneLike } from "../math/plane.js";
 export interface ISceneObject {
     /**
      * Sets a custom display name for this object, overriding the default type-based name.
@@ -21,26 +24,81 @@ export interface ISceneObject {
      */
     reusable(): this;
 }
-export interface IFuseable extends ISceneObject {
+export interface IBooleanOperation extends ISceneObject {
     /**
-     * Additive boolean operation — fuses the result with existing shapes.
-     * When called with no arguments, fuses with all intersecting scene objects.
-     * When called with specific objects, fuses only with those objects.
-     * @param objects - Optional target objects to fuse with.
+     * Additive boolean operation — fuses the result with all intersecting scene objects.
+     * Use `.scope()` to target specific objects.
      */
-    add(...objects: ISceneObject[]): this;
+    add(): this;
     /**
      * No boolean operation — keeps the result as a standalone shape,
      * separate from all other scene objects.
      */
     'new'(): this;
     /**
-     * Subtractive boolean operation — cuts the result from existing shapes.
-     * When called with no arguments, cuts from all intersecting scene objects.
-     * When called with specific objects, cuts only from those objects.
-     * @param objects - Optional target objects to cut from.
+     * Subtractive boolean operation — cuts the result from all intersecting scene objects.
+     * Use `.scope()` to target specific objects.
      */
-    remove(...objects: ISceneObject[]): this;
+    remove(): this;
+    /**
+     * Narrows the boolean operation scope to specific target objects.
+     * Must be chained after `.add()` or `.remove()`.
+     * @param objects - The target objects to operate on.
+     */
+    scope(...objects: ISceneObject[]): this;
+}
+/**
+ * Scene objects that can be chained with world-space transformations.
+ * The chained form `obj.translate(...)` / `obj.rotate(...)` / `obj.mirror(...)`
+ * applies the transform to the object's built shapes; it does not create
+ * a separate history entry like the free-function `translate()` does.
+ *
+ * Container objects (sketches, parts, repeat/mirror features) deliberately
+ * do not expose this interface — apply transforms to their contents instead.
+ */
+export interface ITransformable extends ISceneObject {
+    /**
+     * Composes a 4x4 transformation matrix onto this object. Applied to the
+     * object's own shapes after build. Chained calls compose left-to-right:
+     * `.translate(T).rotate(R)` applies translation first, then rotation.
+     */
+    transform(matrix: Matrix4): this;
+    /**
+     * Translate along X.
+     * @param x - Distance along world X.
+     */
+    translate(x: number): this;
+    /**
+     * Translate along X and Y.
+     */
+    translate(x: number, y: number): this;
+    /**
+     * Translate along X, Y, and Z.
+     */
+    translate(x: number, y: number, z: number): this;
+    /**
+     * Translate by a point-like offset in world space.
+     */
+    translate(offset: PointLike): this;
+    /**
+     * Rotate by an angle around world Z through the origin.
+     * @param angle - Rotation in degrees.
+     */
+    rotate(angle: number): this;
+    /**
+     * Rotate around an axis by an angle.
+     * @param axis - The axis to rotate around. Use `local(...)` to reference a sketch-local axis.
+     * @param angle - Rotation in degrees.
+     */
+    rotate(axis: AxisLike, angle: number): this;
+    /**
+     * Mirror across a plane.
+     */
+    mirror(plane: PlaneLike): this;
+    /**
+     * Mirror across an axis (primarily useful for 2D geometry).
+     */
+    mirror(axis: AxisLike): this;
 }
 export interface IPlane extends ISceneObject {
 }
@@ -205,7 +263,7 @@ export interface ICommon extends ISceneObject {
      */
     keepOriginal(value?: boolean): this;
 }
-export interface IExtrude extends IFuseable {
+export interface IExtrude extends IBooleanOperation {
     /**
      * Enables symmetric mode — extrudes equally in both directions from the sketch plane.
      */
@@ -303,10 +361,11 @@ export interface ICut extends ISceneObject {
      */
     symmetric(): this;
     /**
-     * Narrows the cut scope to specific objects instead of all scene objects.
+     * Narrows the cut scope to specific target objects.
+     * Must be chained after `.remove()`.
      * @param objects - The target objects to cut from.
      */
-    remove(...objects: ISceneObject[]): this;
+    scope(...objects: ISceneObject[]): this;
     /**
      * Applies a draft (taper) angle to the cut walls.
      * @param value - A single angle for uniform draft, or a `[start, end]` tuple for asymmetric draft.
@@ -357,7 +416,7 @@ export interface ICut extends ISceneObject {
      */
     thin(offset1: number, offset2: number): this;
 }
-export interface IRevolve extends IFuseable {
+export interface IRevolve extends IBooleanOperation {
     /**
      * Enables symmetric mode — revolves equally in both directions from the sketch plane.
      */
@@ -405,7 +464,7 @@ export interface IRevolve extends IFuseable {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
-export interface ILoft extends IFuseable {
+export interface ILoft extends IBooleanOperation {
     /**
      * Selects faces on the first profile plane of the loft.
      * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
@@ -474,7 +533,7 @@ export interface ILoft extends IFuseable {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
-export interface ISweep extends IFuseable {
+export interface ISweep extends IBooleanOperation {
     /**
      * Selects faces at the start (profile plane) of the sweep.
      * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.

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

@@ -0,0 +1,12 @@
+import { StandardAxis } from "../math/axis.js";
+import { IAxis } from "./interfaces.js";
+interface LocalFunction {
+    /**
+     * Creates an axis in the active sketch's local coordinate system.
+     * @param axis - One of the standard axes ('x', 'y', 'z') to interpret
+     *   relative to the active sketch's plane.
+     */
+    (axis: StandardAxis): IAxis;
+}
+declare const _default: LocalFunction;
+export default _default;

package/lib/dist/core/local.js

@@ -0,0 +1,18 @@
+import { registerBuilder } from "../index.js";
+import { AxisFromSketch } from "../features/axis-from-sketch.js";
+import { isStandardAxis } from "../math/axis.js";
+function build(context) {
+    return function local(axis) {
+        if (!isStandardAxis(axis)) {
+            throw new Error("local() accepts only 'x', 'y', or 'z'");
+        }
+        const sketch = context.getActiveSketch();
+        if (!sketch) {
+            throw new Error("local() can only be used inside a sketch");
+        }
+        const ax = new AxisFromSketch(sketch, axis);
+        context.addSceneObject(ax);
+        return ax;
+    };
+}
+export default registerBuilder(build);

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

@@ -9,7 +9,7 @@ interface MirrorFunction {
     (line: ISceneObject): ISceneObject;
     /**
     * [2D] Mirror all sketch geometries across a given axis.
-    * @param axis The axis to mirror across
+    * @param axis The local axis to mirror across
     */
     (axis: AxisLike): ISceneObject;
     /**
@@ -20,7 +20,7 @@ interface MirrorFunction {
     (line: ISceneObject, ...geometries: ISceneObject[]): ISceneObject;
     /**
     * [2D] Mirror given sketch geometries across a given axis.
-    * @param axis The axis to mirror across
+    * @param axis The local axis to mirror across
     * @param geometries The geometries to mirror
     */
     (axis: AxisLike, ...geometries: ISceneObject[]): ISceneObject;

package/lib/dist/core/mirror.js

@@ -4,87 +4,69 @@ import { SceneObject } from "../common/scene-object.js";
 import { MirrorShape } from "../features/mirror-shape.js";
 import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { PlaneObject } from "../features/plane.js";
-import { isAxisLike } from "../math/axis.js";
+import { isAxisLike, isStandardAxis } from "../math/axis.js";
 import { MirrorShape2D } from "../features/mirror-shape2d.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { AxisObject } from "../features/axis.js";
 import { AxisFromEdge } from "../features/axis-from-edge.js";
+const axisToPlaneName = { x: "yz", y: "xz", z: "xy" };
+function resolveAxis(arg, context) {
+    if (arg instanceof AxisObjectBase) {
+        return arg;
+    }
+    if (arg instanceof SceneObject) {
+        const axis = new AxisFromEdge(arg);
+        context.addSceneObject(axis);
+        return axis;
+    }
+    const a = normalizeAxis(arg);
+    const axis = new AxisObject(a);
+    context.addSceneObject(axis);
+    return axis;
+}
+function resolvePlane(arg, context) {
+    if (arg instanceof PlaneObjectBase) {
+        return arg;
+    }
+    const normalizedPlane = normalizePlane(arg);
+    const planeObj = new PlaneObject(normalizedPlane);
+    context.addSceneObject(planeObj);
+    return planeObj;
+}
 function build(context) {
     return function mirror() {
+        const activeSketch = context.getActiveSketch();
         if (arguments.length === 1) {
-            if (isAxisLike(arguments[0] || arguments[0] instanceof SceneObject)) {
-                let axis = null;
-                if (arguments[0] instanceof AxisObjectBase) {
-                    axis = arguments[0];
-                }
-                else if (arguments[0] instanceof SceneObject) {
-                    const line = arguments[0];
-                    axis = new AxisFromEdge(line);
-                    context.addSceneObject(axis);
-                }
-                else {
-                    const a = normalizeAxis(arguments[0]);
-                    axis = new AxisObject(a);
-                    context.addSceneObject(axis);
-                }
+            if (activeSketch && (isAxisLike(arguments[0]) || arguments[0] instanceof SceneObject)) {
+                const axis = resolveAxis(arguments[0], context);
                 const mirror = new MirrorShape2D(axis);
                 context.addSceneObject(mirror);
                 return mirror;
             }
-            else {
-                const pln = arguments[0];
-                let planeObj;
-                if (!(pln instanceof PlaneObjectBase)) {
-                    const normalizedPlane = normalizePlane(arguments[0]);
-                    planeObj = new PlaneObject(normalizedPlane);
-                    context.addSceneObject(planeObj);
-                }
-                else {
-                    planeObj = pln;
-                    ;
-                }
-                const mirror = new MirrorShape(planeObj);
-                context.addSceneObject(mirror);
-                return mirror;
+            let planeArg = arguments[0];
+            if (isStandardAxis(planeArg)) {
+                planeArg = axisToPlaneName[planeArg];
             }
+            const planeObj = resolvePlane(planeArg, context);
+            const mirror = new MirrorShape(planeObj);
+            context.addSceneObject(mirror);
+            return mirror;
         }
         if (arguments.length >= 2) {
             const args = Array.from(arguments);
-            // 2D mirror with target objects: mirror(axis/line, geometries[])
-            if (isAxisLike(args[0]) || args[0] instanceof SceneObject) {
-                let axis = null;
-                if (args[0] instanceof AxisObjectBase) {
-                    axis = args[0];
-                }
-                else if (args[0] instanceof SceneObject) {
-                    const line = args[0];
-                    axis = new AxisFromEdge(line);
-                    context.addSceneObject(axis);
-                }
-                else {
-                    const a = normalizeAxis(args[0]);
-                    axis = new AxisObject(a);
-                    context.addSceneObject(axis);
-                }
+            if (activeSketch && (isAxisLike(args[0]) || args[0] instanceof SceneObject)) {
+                const axis = resolveAxis(args[0], context);
                 const targetObjects = args.slice(1);
                 const mirror = new MirrorShape2D(axis, targetObjects);
-                if (!(args[0] instanceof AxisObjectBase) && !(args[0] instanceof SceneObject)) {
-                    context.addSceneObject(axis);
-                }
                 context.addSceneObject(mirror);
                 return mirror;
             }
-            // 3D shape mirror: mirror(plane, ...objects)
-            const targetObjects = args.slice(1);
-            let planeObj;
-            if (!(args[0] instanceof PlaneObjectBase)) {
-                const normalizedPlane = normalizePlane(args[0]);
-                planeObj = new PlaneObject(normalizedPlane);
-                context.addSceneObject(planeObj);
-            }
-            else {
-                planeObj = args[0];
+            let planeArg = args[0];
+            if (isStandardAxis(planeArg)) {
+                planeArg = axisToPlaneName[planeArg];
             }
+            const planeObj = resolvePlane(planeArg, context);
+            const targetObjects = args.slice(1);
             const mirror = new MirrorShape(planeObj, targetObjects);
             context.addSceneObject(mirror);
             return mirror;