fluidcad 0.0.24 → 0.0.25

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

@@ -3,6 +3,9 @@ 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;
@@ -27,6 +30,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 +60,16 @@ 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;
+    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;
     compareTo(other: SceneObject): boolean;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;

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

@@ -1,10 +1,15 @@
 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 = [];
     _id;
     _order = 0;
     _transform = null;
+    _appliedTransform = null;
     _cloneSource = null;
     _parent = null;
     _alwaysVisible = false;
@@ -89,6 +94,59 @@ export class SceneObject {
     getSnapshot() {
         return this.getState('snapshot') || [];
     }
+    getAppliedTransform() {
+        return this._appliedTransform;
+    }
+    transform(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;
         if (!match) {
@@ -100,6 +158,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 +213,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();
@@ -395,3 +463,64 @@ 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/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/chamfer.d.ts

@@ -1,23 +1,23 @@
-import { ISceneObject } from "./interfaces.js";
+import { ISceneObject, ITransformable } from "./interfaces.js";
 interface ChamferFunction {
     /**
      * Chamfers selected edges with the given distance.
      * @param distance - The chamfer distance (defaults to 1)
      */
-    (distance?: number): ISceneObject;
+    (distance?: number): ITransformable;
     /**
      * 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[]): ISceneObject;
+    (distance: number, ...sceneObjects: ISceneObject[]): ITransformable;
     /**
      * 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): ISceneObject;
+    (distance: number, distance2: number, isAngle?: boolean): ITransformable;
     /**
      * 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[]): ISceneObject;
+    (distance: number, distance2: number, isAngle: boolean, ...sceneObjects: ISceneObject[]): ITransformable;
 }
 declare const _default: ChamferFunction;
 export default _default;

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

@@ -1,16 +1,16 @@
-import { ISceneObject } from "./interfaces.js";
+import { ISceneObject, ITransformable } from "./interfaces.js";
 interface ColorFunction {
     /**
      * Applies a color to the last selection.
      * @param color - The color value (CSS color string)
      */
-    (color: string): ISceneObject;
+    (color: string): ITransformable;
     /**
      * 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): ISceneObject;
+    (color: string, selection: ISceneObject): ITransformable;
 }
 declare const _default: ColorFunction;
 export default _default;

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/fillet.d.ts

@@ -1,33 +1,33 @@
-import { IGeometry, ISceneObject } from "./interfaces.js";
+import { IGeometry, ISceneObject, ITransformable } from "./interfaces.js";
 interface FilletFunction {
     /**
      * Fillets selected edges with the given radius.
      * @param radius - The fillet radius (defaults to 1)
      */
-    (radius?: number): ISceneObject;
+    (radius?: number): ITransformable;
     /**
      * 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[]): ISceneObject;
+    (radius: number, ...sceneObjects: ISceneObject[]): ITransformable;
     /**
      * [2D] Fillets corners between the given geometries.
      * @param objects - The geometries whose corners to fillet
      */
-    (objects: IGeometry[]): ISceneObject;
+    (objects: IGeometry[]): ITransformable;
     /**
      * [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): ISceneObject;
+    (objects: IGeometry[], radius: number): ITransformable;
     /**
      * [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[]): ISceneObject;
+    (radius: number, ...objects: IGeometry[]): ITransformable;
 }
 declare const _default: FilletFunction;
 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, IFuseable, 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,7 +24,7 @@ export interface ISceneObject {
      */
     reusable(): this;
 }
-export interface IFuseable extends ISceneObject {
+export interface IFuseable extends ITransformable {
     /**
      * Additive boolean operation — fuses the result with existing shapes.
      * When called with no arguments, fuses with all intersecting scene objects.
@@ -42,13 +45,66 @@ export interface IFuseable extends ISceneObject {
      */
     remove(...objects: ISceneObject[]): this;
 }
-export interface IPlane extends ISceneObject {
+/**
+ * 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 ITransformable {
 }
-export interface IAxis extends ISceneObject {
+export interface IAxis extends ITransformable {
 }
 export interface ISelect extends ISceneObject {
 }
-export interface IGeometry extends ISceneObject {
+export interface IGeometry extends ITransformable {
     /**
      * Returns a lazy-evaluated vertex at the start point of this geometry element.
      */
@@ -155,11 +211,6 @@ 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 {
     /**
@@ -197,7 +248,7 @@ export interface ITangentArcTwoObjects extends IGeometry {
      */
     end(index?: number): LazyVertex;
 }
-export interface ICommon extends ISceneObject {
+export interface ICommon extends ITransformable {
     /**
      * Controls whether the original objects involved in the boolean intersection
      * are retained or removed after the operation.
@@ -297,7 +348,7 @@ export interface IExtrude extends IFuseable {
      */
     thin(offset1: number, offset2: number): this;
 }
-export interface ICut extends ISceneObject {
+export interface ICut extends ITransformable {
     /**
      * Enables symmetric mode — cuts equally in both directions from the sketch plane.
      */
@@ -562,9 +613,9 @@ export interface ISweep extends IFuseable {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
-export interface IDraft extends ISceneObject {
+export interface IDraft extends ITransformable {
 }
-export interface IShell extends ISceneObject {
+export interface IShell extends ITransformable {
     /**
      * 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 { ISceneObject } from "./interfaces.js";
+import { ITransformable } 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): ISceneObject;
+    (fileName: string): ITransformable;
 }
 declare const _default: LoadFunction;
 export default _default;

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

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

package/lib/dist/core/mirror.js

@@ -68,9 +68,6 @@ function build(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;
             }

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

@@ -1,10 +1,10 @@
-import { ISceneObject } from "./interfaces.js";
+import { ISceneObject, ITransformable } from "./interfaces.js";
 interface RemoveFunction {
     /**
      * Removes the given objects from the scene.
      * @param objects - The objects to remove
      */
-    (...objects: ISceneObject[]): ISceneObject;
+    (...objects: ISceneObject[]): ITransformable;
 }
 declare const _default: RemoveFunction;
 export default _default;

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

@@ -1,26 +1,26 @@
 import { AxisLike } from "../math/axis.js";
-import { ISceneObject } from "./interfaces.js";
+import { ISceneObject, ITransformable } from "./interfaces.js";
 interface RotateFunction {
     /**
      * [2D] Rotates geometry by an angle inside a sketch.
      * @param angle - The rotation angle in degrees
      * @param targets - The geometries to rotate (defaults to last object)
      */
-    (angle: number, ...targets: ISceneObject[]): ISceneObject;
+    (angle: number, ...targets: ISceneObject[]): ITransformable;
     /**
      * [2D] Rotates geometry by an angle inside a sketch, optionally making a copy.
      * @param angle - The rotation angle in degrees
      * @param copy - Whether to copy instead of move
      * @param targets - The geometries to rotate (defaults to last object)
      */
-    (angle: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (angle: number, copy: boolean, ...targets: ISceneObject[]): ITransformable;
     /**
      * [3D] Rotates objects around an axis by an angle.
      * @param axis - The axis to rotate around
      * @param angle - The rotation angle in degrees
      * @param targets - The objects to rotate (defaults to last object)
      */
-    (axis: AxisLike, angle: number, ...targets: ISceneObject[]): ISceneObject;
+    (axis: AxisLike, angle: number, ...targets: ISceneObject[]): ITransformable;
     /**
      * [3D] Rotates objects around an axis by an angle, optionally making a copy.
      * @param axis - The axis to rotate around
@@ -28,7 +28,7 @@ interface RotateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to rotate (defaults to last object)
      */
-    (axis: AxisLike, angle: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (axis: AxisLike, angle: number, copy: boolean, ...targets: ISceneObject[]): ITransformable;
 }
 declare const _default: RotateFunction;
 export default _default;