fluidcad 0.0.27 → 0.0.29

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

@@ -12,28 +12,32 @@ function build(context) {
         let center;
         let circle;
         let planeObj = null;
-        let argCount = arguments.length;
-        // Detect plane as last argument
-        if (argCount > 0) {
-            const lastArg = arguments[argCount - 1];
-            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
-                planeObj = resolvePlane(lastArg, context);
-                argCount--;
+        let argOffset = 0;
+        // Detect plane as first argument (only valid outside a sketch)
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
+                if (context.getActiveSketch() !== null) {
+                    throw new Error("circle(plane, ...) cannot be used inside a sketch. Use circle(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
             }
         }
+        const argCount = arguments.length - argOffset;
         if (argCount === 0) {
             diameter = 40;
             circle = new Circle(diameter, null, planeObj);
             context.addSceneObject(circle);
         }
         else if (argCount === 1) {
-            diameter = arguments[0] || 40;
+            diameter = arguments[argOffset] || 40;
             circle = new Circle(diameter, null, planeObj);
             context.addSceneObject(circle);
         }
         else {
-            center = normalizePoint2D(arguments[0]);
-            diameter = arguments[1] || 40;
+            center = normalizePoint2D(arguments[argOffset]);
+            diameter = arguments[argOffset + 1] || 40;
             circle = new Circle(diameter, null, planeObj);
             const move = new Move(center);
             context.addSceneObjects([move, circle]);

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

@@ -0,0 +1,35 @@
+import { Point2DLike } from "../../math/point.js";
+import { PlaneLike } from "../../math/plane.js";
+import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
+interface EllipseFunction {
+    /**
+     * Draws an ellipse at the current position.
+     * @param rx - Semi-radius along the plane's X axis
+     * @param ry - Semi-radius along the plane's Y axis
+     */
+    (rx: number, ry: number): IExtrudableGeometry;
+    /**
+     * Draws an ellipse at a given center.
+     * @param center - The center point
+     * @param rx - Semi-radius along the plane's X axis
+     * @param ry - Semi-radius along the plane's Y axis
+     */
+    (center: Point2DLike, rx: number, ry: number): IExtrudableGeometry;
+    /**
+     * Draws an ellipse on a specific plane.
+     * @param targetPlane - The plane to draw on
+     * @param rx - Semi-radius along the plane's X axis
+     * @param ry - Semi-radius along the plane's Y axis
+     */
+    (targetPlane: PlaneLike | ISceneObject, rx: number, ry: number): IExtrudableGeometry;
+    /**
+     * Draws an ellipse at a given center on a specific plane.
+     * @param targetPlane - The plane to draw on
+     * @param center - The center point in plane-local coordinates
+     * @param rx - Semi-radius along the plane's X axis
+     * @param ry - Semi-radius along the plane's Y axis
+     */
+    (targetPlane: PlaneLike | ISceneObject, center: Point2DLike, rx: number, ry: number): IExtrudableGeometry;
+}
+declare const _default: EllipseFunction;
+export default _default;

package/lib/dist/core/2d/ellipse.js

@@ -0,0 +1,65 @@
+import { Point2D, isPoint2DLike } from "../../math/point.js";
+import { LazyVertex } from "../../features/lazy-vertex.js";
+import { Ellipse } from "../../features/2d/ellipse.js";
+import { Move } from "../../features/2d/move.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+import { isPlaneLike } from "../../math/plane.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+function toPoint2D(p) {
+    if (p instanceof Point2D) {
+        return p;
+    }
+    if (p instanceof LazyVertex) {
+        return p.asPoint2D();
+    }
+    if (Array.isArray(p)) {
+        return new Point2D(p[0], p[1]);
+    }
+    return new Point2D(p.x, p.y);
+}
+function build(context) {
+    return function ellipse() {
+        let planeObj = null;
+        let argOffset = 0;
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
+                if (context.getActiveSketch() !== null) {
+                    throw new Error("ellipse(plane, ...) cannot be used inside a sketch. Use ellipse(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
+            }
+        }
+        const argCount = arguments.length - argOffset;
+        if (argCount === 2) {
+            const rx = arguments[argOffset];
+            const ry = arguments[argOffset + 1];
+            const e = new Ellipse(rx, ry, planeObj);
+            context.addSceneObject(e);
+            return e;
+        }
+        if (argCount === 3) {
+            const centerArg = arguments[argOffset];
+            const rx = arguments[argOffset + 1];
+            const ry = arguments[argOffset + 2];
+            if (planeObj) {
+                // Standalone (plane, center, rx, ry): center is plane-local. Move
+                // can't run outside a sketch, so resolve the center eagerly into the
+                // Ellipse via centerOverride.
+                const center = toPoint2D(centerArg);
+                const e = new Ellipse(rx, ry, planeObj, center);
+                context.addSceneObject(e);
+                return e;
+            }
+            const center = normalizePoint2D(centerArg);
+            const e = new Ellipse(rx, ry, null);
+            context.addSceneObjects([new Move(center), e]);
+            return e;
+        }
+        throw new Error("Invalid arguments for ellipse()");
+    };
+}
+export default registerBuilder(build);

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

@@ -17,17 +17,17 @@ interface HLineFunction {
     (start: Point2DLike, distance: number, centered?: boolean): IGeometry;
     /**
      * Draws a horizontal line on a specific plane.
-     * @param distance - The line length
      * @param targetPlane - The plane to draw on
+     * @param distance - The line length
      */
-    (distance: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, distance: number): IGeometry;
     /**
      * Draws a horizontal line with centering on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @param distance - The line length
      * @param centered - Whether to center the line on the current position
-     * @param targetPlane - The plane to draw on
      */
-    (distance: number, centered: boolean, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, distance: number, centered: boolean): IGeometry;
 }
 declare const _default: HLineFunction;
 export default _default;

package/lib/dist/core/2d/hline.js

@@ -9,16 +9,20 @@ import { resolvePlane } from "../../helpers/resolve.js";
 function build(context) {
     return function line() {
         let planeObj = null;
-        let argCount = arguments.length;
-        // Detect plane as last argument
-        if (argCount > 0) {
-            const lastArg = arguments[argCount - 1];
-            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
-                planeObj = resolvePlane(lastArg, context);
-                argCount--;
+        let argOffset = 0;
+        // Detect plane as first argument (only valid outside a sketch)
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
+                if (context.getActiveSketch() !== null) {
+                    throw new Error("hLine(plane, ...) cannot be used inside a sketch. Use hLine(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
             }
         }
-        if (typeof arguments[0] !== 'number') {
+        const argCount = arguments.length - argOffset;
+        if (argOffset === 0 && typeof arguments[0] !== 'number') {
             // hline(start, distance) or hline(start, distance, centered)
             const start = normalizePoint2D(arguments[0]);
             const distance = arguments[1];
@@ -27,8 +31,8 @@ function build(context) {
             context.addSceneObjects([new Move(start), hline]);
             return hline;
         }
-        const distance = arguments[0];
-        const centered = argCount >= 2 ? arguments[1] : false;
+        const distance = arguments[argOffset];
+        const centered = argCount >= 2 ? arguments[argOffset + 1] : false;
         const hline = new HorizontalLine(distance, centered, planeObj);
         context.addSceneObject(hline);
         return hline;

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

@@ -1,5 +1,6 @@
 export { default as line } from './line.js';
 export { default as circle } from './circle.js';
+export { default as ellipse } from './ellipse.js';
 export { default as rect } from './rect.js';
 export { default as hMove } from './hmove.js';
 export { default as vMove } from './vmove.js';

package/lib/dist/core/2d/index.js

@@ -1,5 +1,6 @@
 export { default as line } from './line.js';
 export { default as circle } from './circle.js';
+export { default as ellipse } from './ellipse.js';
 export { default as rect } from './rect.js';
 export { default as hMove } from './hmove.js';
 export { default as vMove } from './vmove.js';

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

@@ -8,10 +8,10 @@ interface IntersectFunction {
     (...sourceObjects: ISceneObject[]): IExtrudableGeometry;
     /**
      * Intersects 3D objects with a target plane, producing cross-section edges.
-     * @param sourceObjects - The 3D objects to intersect
      * @param targetPlane - The plane to intersect with
+     * @param sourceObjects - The 3D objects to intersect
      */
-    (sourceObjects: ISceneObject[], targetPlane: PlaneLike | ISceneObject): IExtrudableGeometry;
+    (targetPlane: PlaneLike | ISceneObject, sourceObjects: ISceneObject[]): IExtrudableGeometry;
 }
 declare const _default: IntersectFunction;
 export default _default;

package/lib/dist/core/2d/intersect.js

@@ -3,10 +3,14 @@ import { resolvePlane } from "../../helpers/resolve.js";
 import { registerBuilder } from "../../index.js";
 function build(context) {
     return function intersect(...args) {
-        if (Array.isArray(args[0])) {
-            const sourceObjects = args[0];
+        // Plane-first mode: intersect(plane, sources[])
+        if (args.length === 2 && Array.isArray(args[1])) {
+            if (context.getActiveSketch() !== null) {
+                throw new Error("intersect(plane, sources[]) cannot be used inside a sketch. Use intersect(...sources) instead.");
+            }
+            const planeObj = resolvePlane(args[0], context);
+            const sourceObjects = args[1];
             context.addSceneObjects(sourceObjects);
-            const planeObj = resolvePlane(args[1], context);
             const result = new Intersect(sourceObjects, planeObj);
             context.addSceneObject(result);
             return result;

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

@@ -15,10 +15,10 @@ interface LineFunction {
     (start: Point2DLike, end: Point2DLike): IGeometry;
     /**
      * Draws a line to the given point on a specific plane.
-     * @param end - The end point
      * @param targetPlane - The plane to draw on
+     * @param end - The end point
      */
-    (end: Point2DLike, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, end: Point2DLike): IGeometry;
 }
 declare const _default: LineFunction;
 export default _default;

package/lib/dist/core/2d/line.js

@@ -10,24 +10,28 @@ function build(context) {
     return function line() {
         let line;
         let planeObj = null;
-        let argCount = arguments.length;
-        // Detect plane as last argument
+        let argOffset = 0;
+        // Detect plane as first argument (only valid outside a sketch)
         // Point2DLike is not plane-like so no conflict
-        if (argCount > 0) {
-            const lastArg = arguments[argCount - 1];
-            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
-                planeObj = resolvePlane(lastArg, context);
-                argCount--;
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
+                if (context.getActiveSketch() !== null) {
+                    throw new Error("line(plane, ...) cannot be used inside a sketch. Use line(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
             }
         }
+        const argCount = arguments.length - argOffset;
         if (argCount === 1) {
-            const vertex = normalizePoint2D(arguments[0]);
+            const vertex = normalizePoint2D(arguments[argOffset]);
             line = new LineTo(vertex, planeObj);
             context.addSceneObject(line);
         }
         else if (argCount === 2) {
-            const start = normalizePoint2D(arguments[0]);
-            const end = normalizePoint2D(arguments[1]);
+            const start = normalizePoint2D(arguments[argOffset]);
+            const end = normalizePoint2D(arguments[argOffset + 1]);
             line = new LineTo(end, planeObj);
             context.addSceneObjects([new Move(start), line]);
         }

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

@@ -1,5 +1,5 @@
 import { PlaneLike } from "../../math/plane.js";
-import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
+import { IOffset, ISceneObject } from "../interfaces.js";
 import { Extrudable } from "../../helpers/types.js";
 interface OffsetFunction {
     /**
@@ -7,15 +7,15 @@ interface OffsetFunction {
      * @param distance - The offset distance (defaults to 1)
      * @param removeOriginal - Whether to remove the original geometry
      */
-    (distance?: number, removeOriginal?: boolean): IExtrudableGeometry;
+    (distance?: number, removeOriginal?: boolean): IOffset;
     /**
      * Offsets source geometries onto a target plane.
+     * @param targetPlane - The plane to offset onto
      * @param distance - The offset distance
      * @param removeOriginal - Whether to remove the original geometry
-     * @param targetPlane - The plane to offset onto
      * @param sourceGeometries - The geometries to offset
      */
-    (distance: number, removeOriginal: boolean, targetPlane: PlaneLike | ISceneObject, ...sourceGeometries: Extrudable[]): IExtrudableGeometry;
+    (targetPlane: PlaneLike | ISceneObject, distance: number, removeOriginal: boolean, ...sourceGeometries: Extrudable[]): IOffset;
 }
 declare const _default: OffsetFunction;
 export default _default;

package/lib/dist/core/2d/offset.js

@@ -3,11 +3,15 @@ import { registerBuilder } from "../../index.js";
 import { resolvePlane } from "../../helpers/resolve.js";
 function build(context) {
     return function offset(...args) {
-        // Outside-sketch mode: offset(distance, removeOriginal, plane, ...sourceGeometries)
-        if (args.length >= 3 && !Array.isArray(args[0])) {
-            const distance = args[0] ?? 1;
-            const removeOriginal = args[1] ?? false;
-            const planeObj = resolvePlane(args[2], context);
+        // Plane-first mode: offset(plane, distance, removeOriginal, ...sourceGeometries)
+        // Detected when first arg is not a number/undefined.
+        if (args.length > 0 && args[0] !== undefined && typeof args[0] !== 'number' && typeof args[0] !== 'boolean') {
+            if (context.getActiveSketch() !== null) {
+                throw new Error("offset(plane, ...) cannot be used inside a sketch. Use offset(...) instead.");
+            }
+            const planeObj = resolvePlane(args[0], context);
+            const distance = args[1] ?? 1;
+            const removeOriginal = args[2] ?? false;
             const sourceObjects = args.slice(3);
             const off = new Offset(distance, removeOriginal, sourceObjects, planeObj);
             context.addSceneObject(off);

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

@@ -20,19 +20,19 @@ interface PolygonFunction {
     (center: Point2DLike, numberOfSides: number, diameter: number, mode?: PolygonMode): IPolygon;
     /**
      * Draws a regular polygon on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @param numberOfSides - The number of sides
      * @param diameter - The circumscribed or inscribed diameter
-     * @param targetPlane - The plane to draw on
      */
-    (numberOfSides: number, diameter: number, targetPlane: PlaneLike | ISceneObject): IPolygon;
+    (targetPlane: PlaneLike | ISceneObject, numberOfSides: number, diameter: number): IPolygon;
     /**
      * Draws a regular polygon with a given mode on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @param numberOfSides - The number of sides
      * @param diameter - The circumscribed or inscribed diameter
      * @param mode - `'inscribed'` or `'circumscribed'`
-     * @param targetPlane - The plane to draw on
      */
-    (numberOfSides: number, diameter: number, mode: PolygonMode, targetPlane: PlaneLike | ISceneObject): IPolygon;
+    (targetPlane: PlaneLike | ISceneObject, numberOfSides: number, diameter: number, mode: PolygonMode): IPolygon;
 }
 declare const _default: PolygonFunction;
 export default _default;

package/lib/dist/core/2d/polygon.js

@@ -14,46 +14,50 @@ function build(context) {
         let center;
         let poly;
         let planeObj = null;
-        let argCount = arguments.length;
-        // Detect plane as last argument
+        let argOffset = 0;
+        // Detect plane as first argument (only valid outside a sketch)
         // PolygonMode strings ('inscribed'/'circumscribed') don't overlap with StandardPlane strings
-        if (argCount > 0) {
-            const lastArg = arguments[argCount - 1];
-            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
-                planeObj = resolvePlane(lastArg, context);
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
+                if (context.getActiveSketch() !== null) {
+                    throw new Error("polygon(plane, ...) cannot be used inside a sketch. Use polygon(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
                 context.addSceneObject(planeObj);
-                argCount--;
+                argOffset = 1;
             }
         }
+        const argCount = arguments.length - argOffset;
         if (argCount === 2) {
-            numberOfSides = arguments[0];
-            diameter = arguments[1];
+            numberOfSides = arguments[argOffset];
+            diameter = arguments[argOffset + 1];
             mode = 'inscribed';
             poly = new Polygon(numberOfSides, diameter, mode, planeObj);
             context.addSceneObject(poly);
         }
         else if (argCount === 3) {
-            if (typeof arguments[0] === 'number') {
-                numberOfSides = arguments[0];
-                diameter = arguments[1];
-                mode = arguments[2];
+            if (typeof arguments[argOffset] === 'number') {
+                numberOfSides = arguments[argOffset];
+                diameter = arguments[argOffset + 1];
+                mode = arguments[argOffset + 2];
                 poly = new Polygon(numberOfSides, diameter, mode, planeObj);
                 context.addSceneObject(poly);
             }
             else {
-                center = normalizePoint2D(arguments[0]);
-                numberOfSides = arguments[1];
-                diameter = arguments[2];
+                center = normalizePoint2D(arguments[argOffset]);
+                numberOfSides = arguments[argOffset + 1];
+                diameter = arguments[argOffset + 2];
                 mode = 'inscribed';
                 poly = new Polygon(numberOfSides, diameter, mode, planeObj);
                 context.addSceneObjects([new Move(center), poly]);
             }
         }
         else if (argCount === 4) {
-            center = normalizePoint2D(arguments[0]);
-            numberOfSides = arguments[1];
-            diameter = arguments[2];
-            mode = arguments[3];
+            center = normalizePoint2D(arguments[argOffset]);
+            numberOfSides = arguments[argOffset + 1];
+            diameter = arguments[argOffset + 2];
+            mode = arguments[argOffset + 3];
             poly = new Polygon(numberOfSides, diameter, mode, planeObj);
             context.addSceneObjects([new Move(center), poly]);
         }

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

@@ -8,10 +8,10 @@ interface ProjectFunction {
     (...sourceObjects: ISceneObject[]): IExtrudableGeometry;
     /**
      * Projects 3D objects onto a target plane.
-     * @param sourceObjects - The 3D objects to project
      * @param targetPlane - The plane to project onto
+     * @param sourceObjects - The 3D objects to project
      */
-    (sourceObjects: ISceneObject[], targetPlane: PlaneLike | ISceneObject): IExtrudableGeometry;
+    (targetPlane: PlaneLike | ISceneObject, sourceObjects: ISceneObject[]): IExtrudableGeometry;
 }
 declare const _default: ProjectFunction;
 export default _default;

package/lib/dist/core/2d/project.js

@@ -3,10 +3,14 @@ import { resolvePlane } from "../../helpers/resolve.js";
 import { registerBuilder } from "../../index.js";
 function build(context) {
     return function project(...args) {
-        if (Array.isArray(args[0])) {
-            const sourceObjects = args[0];
+        // Plane-first mode: project(plane, sources[])
+        if (args.length === 2 && Array.isArray(args[1])) {
+            if (context.getActiveSketch() !== null) {
+                throw new Error("project(plane, sources[]) cannot be used inside a sketch. Use project(...sources) instead.");
+            }
+            const planeObj = resolvePlane(args[0], context);
+            const sourceObjects = args[1];
             context.addSceneObjects(sourceObjects);
-            const planeObj = resolvePlane(args[1], context);
             const projection = new Projection(sourceObjects, planeObj);
             context.addSceneObject(projection);
             return projection;

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

@@ -17,11 +17,11 @@ interface RectFunction {
     (start: Point2DLike, width: number, height?: number): IRect;
     /**
      * Draws a rectangle with given dimensions on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @param width - The rectangle width
      * @param height - The rectangle height
-     * @param targetPlane - The plane to draw on
      */
-    (width: number, height: number, targetPlane: PlaneLike | ISceneObject): IRect;
+    (targetPlane: PlaneLike | ISceneObject, width: number, height: number): IRect;
 }
 declare const _default: RectFunction;
 export default _default;

package/lib/dist/core/2d/rect.js

@@ -8,7 +8,22 @@ import { SceneObject } from "../../common/scene-object.js";
 import { resolvePlane } from "../../helpers/resolve.js";
 function build(context) {
     return function cRect() {
-        let argCount = arguments.length;
+        // Detect plane as first argument (only valid outside a sketch)
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
+                if (context.getActiveSketch() !== null) {
+                    throw new Error("rect(plane, ...) cannot be used inside a sketch. Use rect(...) instead.");
+                }
+                const planeObj = resolvePlane(firstArg, context);
+                const width = arguments[1];
+                const height = arguments[2];
+                const rect = new Rect(width, height, planeObj);
+                context.addSceneObject(rect);
+                return rect;
+            }
+        }
+        const argCount = arguments.length;
         if (argCount === 1) {
             const width = arguments[0];
             const rect = new Rect(width, width);
@@ -32,26 +47,12 @@ function build(context) {
             }
         }
         else if (argCount === 3) {
-            if (typeof arguments[0] === 'number') {
-                const width = arguments[0];
-                const height = arguments[1];
-                const lastArg = arguments[argCount - 1];
-                let planeObj;
-                if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
-                    planeObj = resolvePlane(lastArg, context);
-                }
-                const rect = new Rect(width, height, planeObj);
-                context.addSceneObject(rect);
-                return rect;
-            }
-            else {
-                const start = normalizePoint2D(arguments[0]);
-                const width = arguments[1];
-                const height = arguments[2];
-                const rect = new Rect(width, height);
-                context.addSceneObjects([new Move(start), rect]);
-                return rect;
-            }
+            const start = normalizePoint2D(arguments[0]);
+            const width = arguments[1];
+            const height = arguments[2];
+            const rect = new Rect(width, height);
+            context.addSceneObjects([new Move(start), rect]);
+            return rect;
         }
     };
 }

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

@@ -10,11 +10,11 @@ interface SlotFunction {
     (distance: number, radius: number): ISlot;
     /**
      * Draws a slot on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @param distance - The slot length
      * @param radius - The end cap radius
-     * @param targetPlane - The plane to draw on
      */
-    (distance: number, radius: number, targetPlane: PlaneLike | ISceneObject): ISlot;
+    (targetPlane: PlaneLike | ISceneObject, distance: number, radius: number): ISlot;
     /**
      * Draws a slot from a start point with the given length and end radius.
      * @param start - The start point
@@ -31,19 +31,19 @@ interface SlotFunction {
     (geometry: ISceneObject, radius: number, deleteSource?: boolean): ISlot;
     /**
      * Creates a slot from a geometry edge on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @param geometry - The source geometry edge
      * @param radius - The end cap radius
-     * @param targetPlane - The plane to draw on
      */
-    (geometry: ISceneObject, radius: number, targetPlane: PlaneLike | ISceneObject): ISlot;
+    (targetPlane: PlaneLike | ISceneObject, geometry: ISceneObject, radius: number): ISlot;
     /**
      * Creates a slot from a geometry edge, optionally keeping the source, on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @param geometry - The source geometry edge
      * @param radius - The end cap radius
      * @param deleteSource - Whether to delete the source geometry
-     * @param targetPlane - The plane to draw on
      */
-    (geometry: ISceneObject, radius: number, deleteSource: boolean, targetPlane: PlaneLike | ISceneObject): ISlot;
+    (targetPlane: PlaneLike | ISceneObject, geometry: ISceneObject, radius: number, deleteSource: boolean): ISlot;
 }
 declare const _default: SlotFunction;
 export default _default;