fluidcad 0.0.25 → 0.0.26

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

@@ -3,9 +3,6 @@ import { Matrix4 } from "../math/matrix4.js";
 import { ISceneObject } from "../core/interfaces.js";
 import { FusionScope, OperationMode } from "../features/extrude-options.js";
 import { ShapeType } from "./shape-type.js";
-import type { AxisLike } from "../math/axis.js";
-import type { PlaneLike } from "../math/plane.js";
-import type { PointLike } from "../math/point.js";
 export type SourceLocation = {
     filePath: string;
     line: number;
@@ -61,15 +58,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     abstract getType(): string;
     abstract build(context?: BuildSceneObjectContext): void;
     getAppliedTransform(): Matrix4 | null;
-    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;
+    protected composeAppliedTransform(matrix: Matrix4): void;
     compareTo(other: SceneObject): boolean;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
@@ -118,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

@@ -1,8 +1,4 @@
 import { randomUUID } from "crypto";
-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 SceneObject {
     state;
     children = [];
@@ -97,55 +93,10 @@ export class SceneObject {
     getAppliedTransform() {
         return this._appliedTransform;
     }
-    transform(matrix) {
+    composeAppliedTransform(matrix) {
         this._appliedTransform = this._appliedTransform
             ? matrix.multiply(this._appliedTransform)
             : 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));
     }
     compareTo(other) {
         const match = this._guide === other._guide && this._reusable === other._reusable;
@@ -419,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() {
@@ -437,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;
@@ -463,64 +407,3 @@ export class SceneObject {
         return `${this.getOrder()}-${this.getUniqueType()}-${suffix}`;
     }
 }
-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/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/chamfer.d.ts

@@ -1,23 +1,23 @@
-import { ISceneObject, ITransformable } from "./interfaces.js";
+import { ISceneObject } from "./interfaces.js";
 interface ChamferFunction {
     /**
      * Chamfers selected edges with the given distance.
      * @param distance - The chamfer distance (defaults to 1)
      */
-    (distance?: number): ITransformable;
+    (distance?: number): ISceneObject;
     /**
      * Chamfers the given edge selections with the given distance.
      * @param distance - The chamfer distance
      * @param sceneObjects - The edge selections to chamfer
      */
-    (distance: number, ...sceneObjects: ISceneObject[]): ITransformable;
+    (distance: number, ...sceneObjects: ISceneObject[]): ISceneObject;
     /**
      * Chamfers selected edges with two distances or a distance and angle.
      * @param distance - The first chamfer distance
      * @param distance2 - The second distance, or angle if `isAngle` is true
      * @param isAngle - Whether `distance2` is an angle
      */
-    (distance: number, distance2: number, isAngle?: boolean): ITransformable;
+    (distance: number, distance2: number, isAngle?: boolean): ISceneObject;
     /**
      * Chamfers the given edge selections with two distances or a distance and angle.
      * @param distance - The first chamfer distance
@@ -25,7 +25,7 @@ interface ChamferFunction {
      * @param isAngle - Whether `distance2` is an angle
      * @param sceneObjects - The edge selections to chamfer
      */
-    (distance: number, distance2: number, isAngle: boolean, ...sceneObjects: ISceneObject[]): ITransformable;
+    (distance: number, distance2: number, isAngle: boolean, ...sceneObjects: ISceneObject[]): ISceneObject;
 }
 declare const _default: ChamferFunction;
 export default _default;

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

@@ -1,16 +1,16 @@
-import { ISceneObject, ITransformable } from "./interfaces.js";
+import { ISceneObject } from "./interfaces.js";
 interface ColorFunction {
     /**
      * Applies a color to the last selection.
      * @param color - The color value (CSS color string)
      */
-    (color: string): ITransformable;
+    (color: string): ISceneObject;
     /**
      * Applies a color to the given selection.
      * @param color - The color value (CSS color string)
      * @param selection - The face or edge selection to color
      */
-    (color: string, selection: ISceneObject): ITransformable;
+    (color: string, selection: ISceneObject): ISceneObject;
 }
 declare const _default: ColorFunction;
 export default _default;

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

@@ -1,33 +1,33 @@
-import { IGeometry, ISceneObject, ITransformable } from "./interfaces.js";
+import { IGeometry, ISceneObject } from "./interfaces.js";
 interface FilletFunction {
     /**
      * Fillets selected edges with the given radius.
      * @param radius - The fillet radius (defaults to 1)
      */
-    (radius?: number): ITransformable;
+    (radius?: number): ISceneObject;
     /**
      * Fillets the given edge selections with the given radius.
      * @param radius - The fillet radius
      * @param sceneObjects - The edge selections to fillet
      */
-    (radius: number, ...sceneObjects: ISceneObject[]): ITransformable;
+    (radius: number, ...sceneObjects: ISceneObject[]): ISceneObject;
     /**
      * [2D] Fillets corners between the given geometries.
      * @param objects - The geometries whose corners to fillet
      */
-    (objects: IGeometry[]): ITransformable;
+    (objects: IGeometry[]): ISceneObject;
     /**
      * [2D] Fillets corners between the given geometries with a radius.
      * @param objects - The geometries whose corners to fillet
      * @param radius - The fillet radius
      */
-    (objects: IGeometry[], radius: number): ITransformable;
+    (objects: IGeometry[], radius: number): ISceneObject;
     /**
      * [2D] Fillets corners at the given radius and geometries.
      * @param radius - The fillet radius
      * @param objects - The geometries whose corners to fillet
      */
-    (radius: number, ...objects: IGeometry[]): ITransformable;
+    (radius: number, ...objects: IGeometry[]): ISceneObject;
 }
 declare const _default: FilletFunction;
 export default _default;

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

@@ -1,4 +1,4 @@
-export type { ISceneObject, ITransformable, 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";

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

@@ -24,26 +24,28 @@ export interface ISceneObject {
      */
     reusable(): this;
 }
-export interface IFuseable extends ITransformable {
+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.
@@ -98,13 +100,13 @@ export interface ITransformable extends ISceneObject {
      */
     mirror(axis: AxisLike): this;
 }
-export interface IPlane extends ITransformable {
+export interface IPlane extends ISceneObject {
 }
-export interface IAxis extends ITransformable {
+export interface IAxis extends ISceneObject {
 }
 export interface ISelect extends ISceneObject {
 }
-export interface IGeometry extends ITransformable {
+export interface IGeometry extends ISceneObject {
     /**
      * Returns a lazy-evaluated vertex at the start point of this geometry element.
      */
@@ -211,6 +213,11 @@ export interface ISlot extends IExtrudableGeometry {
      * @param value - `true` to center, `false` (default) to start from the current position.
      */
     centered(value?: boolean): this;
+    /**
+     * Sets the rotation angle of the slot's primary axis.
+     * @param angle - Rotation in degrees.
+     */
+    rotate(angle: number): this;
 }
 export interface IPolygon extends IExtrudableGeometry {
     /**
@@ -248,7 +255,7 @@ export interface ITangentArcTwoObjects extends IGeometry {
      */
     end(index?: number): LazyVertex;
 }
-export interface ICommon extends ITransformable {
+export interface ICommon extends ISceneObject {
     /**
      * Controls whether the original objects involved in the boolean intersection
      * are retained or removed after the operation.
@@ -256,7 +263,7 @@ export interface ICommon extends ITransformable {
      */
     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.
      */
@@ -348,16 +355,17 @@ export interface IExtrude extends IFuseable {
      */
     thin(offset1: number, offset2: number): this;
 }
-export interface ICut extends ITransformable {
+export interface ICut extends ISceneObject {
     /**
      * Enables symmetric mode — cuts equally in both directions from the sketch plane.
      */
     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.
@@ -408,7 +416,7 @@ export interface ICut extends ITransformable {
      */
     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.
      */
@@ -456,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.
@@ -525,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.
@@ -613,9 +621,9 @@ export interface ISweep extends IFuseable {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
-export interface IDraft extends ITransformable {
+export interface IDraft extends ISceneObject {
 }
-export interface IShell extends ITransformable {
+export interface IShell extends ISceneObject {
     /**
      * Selects the inner wall faces created by the shell operation (from thickness removal).
      * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.

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

@@ -1,10 +1,10 @@
-import { ITransformable } from "./interfaces.js";
+import { ISceneObject } from "./interfaces.js";
 interface LoadFunction {
     /**
      * Loads a 3D model file (STEP, STL, etc.) by filename.
      * @param fileName - The path to the model file
      */
-    (fileName: string): ITransformable;
+    (fileName: string): ISceneObject;
 }
 declare const _default: LoadFunction;
 export default _default;

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

@@ -1,40 +1,40 @@
 import { PlaneLike } from "../math/plane.js";
 import { AxisLike } from "../math/axis.js";
-import { ISceneObject, ITransformable } from "./interfaces.js";
+import { ISceneObject } from "./interfaces.js";
 interface MirrorFunction {
     /**
     * [2D] Mirror all sketch geometries across a given line.
     * @param line The line to mirror across
     */
-    (line: ISceneObject): ITransformable;
+    (line: ISceneObject): ISceneObject;
     /**
     * [2D] Mirror all sketch geometries across a given axis.
     * @param axis The local axis to mirror across
     */
-    (axis: AxisLike): ITransformable;
+    (axis: AxisLike): ISceneObject;
     /**
     * [2D] Mirror given sketch geometries across a given line.
     * @param line The line to mirror across
     * @param geometries The geometries to mirror
     */
-    (line: ISceneObject, ...geometries: ISceneObject[]): ITransformable;
+    (line: ISceneObject, ...geometries: ISceneObject[]): ISceneObject;
     /**
     * [2D] Mirror given sketch geometries across a given axis.
     * @param axis The local axis to mirror across
     * @param geometries The geometries to mirror
     */
-    (axis: AxisLike, ...geometries: ISceneObject[]): ITransformable;
+    (axis: AxisLike, ...geometries: ISceneObject[]): ISceneObject;
     /**
     * [3D] Mirror all scene shapes across a given plane.
     * @param plane The plane to mirror across
     */
-    (plane: PlaneLike): ITransformable;
+    (plane: PlaneLike): ISceneObject;
     /**
     * [3D] Mirror given shapes across a given plane.
     * @param plane The plane to mirror across
     * @param objects The shapes to mirror
     */
-    (plane: PlaneLike, ...objects: ISceneObject[]): ITransformable;
+    (plane: PlaneLike, ...objects: ISceneObject[]): ISceneObject;
 }
 declare const _default: MirrorFunction;
 export default _default;