fluidcad 0.0.28 → 0.0.29

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;

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

@@ -9,49 +9,46 @@ import { isPlaneLike } from "../../math/plane.js";
 import { resolvePlane } from "../../helpers/resolve.js";
 function build(context) {
     return function slot() {
-        // SlotFromEdge path: first arg is a SceneObject (geometry)
-        if (arguments[0] instanceof SceneObject) {
-            const geometry = arguments[0];
-            const radius = arguments[1];
-            let deleteSource = true;
-            let planeObj = null;
-            let argIdx = 2;
-            // Check if there's a deleteSource boolean before a potential plane
-            if (argIdx < arguments.length && typeof arguments[argIdx] === 'boolean') {
-                deleteSource = arguments[argIdx];
-                argIdx++;
-            }
-            // Check if there's a plane arg remaining
-            if (argIdx < arguments.length) {
-                const planeArg = arguments[argIdx];
-                if (isPlaneLike(planeArg) || planeArg instanceof SceneObject) {
-                    planeObj = resolvePlane(planeArg, context);
+        const inSketch = context.getActiveSketch() !== null;
+        // Detect plane as first argument (only valid outside a sketch).
+        // Inside a sketch, a SceneObject at position 0 means SlotFromEdge geometry, not plane.
+        let planeObj = null;
+        let argOffset = 0;
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            const looksLikePlane = isPlaneLike(firstArg) ||
+                (firstArg instanceof SceneObject && !isPoint2DLike(firstArg) && !inSketch);
+            if (looksLikePlane) {
+                if (inSketch) {
+                    throw new Error("slot(plane, ...) cannot be used inside a sketch. Use slot(...) instead.");
                 }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
+            }
+        }
+        // SlotFromEdge path: first non-plane arg is a SceneObject (geometry)
+        if (arguments[argOffset] instanceof SceneObject && !isPoint2DLike(arguments[argOffset])) {
+            const geometry = arguments[argOffset];
+            const radius = arguments[argOffset + 1];
+            let deleteSource = true;
+            if (arguments.length > argOffset + 2 && typeof arguments[argOffset + 2] === 'boolean') {
+                deleteSource = arguments[argOffset + 2];
             }
             const slotFromEdge = new SlotFromEdge(geometry, radius, deleteSource, planeObj);
             context.addSceneObject(slotFromEdge);
             return slotFromEdge;
         }
-        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--;
-            }
-        }
+        const argCount = arguments.length - argOffset;
         // slot(distance, radius)
-        if (argCount === 2 && typeof arguments[0] === 'number') {
-            const distance = arguments[0];
-            const radius = arguments[1];
+        if (argCount === 2 && typeof arguments[argOffset] === 'number') {
+            const distance = arguments[argOffset];
+            const radius = arguments[argOffset + 1];
             const s = new Slot(distance, radius, planeObj);
             context.addSceneObject(s);
             return s;
         }
-        // slot(start, distance, radius)
-        if (argCount === 3) {
+        // slot(start, distance, radius) — in-sketch only
+        if (argCount === 3 && argOffset === 0) {
             const start = normalizePoint2D(arguments[0]);
             const distance = arguments[1];
             const radius = arguments[2];

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

@@ -17,17 +17,17 @@ interface VLineFunction {
     (start: Point2DLike, distance: number, centered?: boolean): IGeometry;
     /**
      * Draws a vertical 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 vertical 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: VLineFunction;
 export default _default;

package/lib/dist/core/2d/vline.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("vLine(plane, ...) cannot be used inside a sketch. Use vLine(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
             }
         }
-        if (typeof arguments[0] !== 'number') {
+        const argCount = arguments.length - argOffset;
+        if (argOffset === 0 && typeof arguments[0] !== 'number') {
             // vline(start, distance) or vline(start, distance, centered)
             const start = normalizePoint2D(arguments[0]);
             const distance = arguments[1];
@@ -27,8 +31,8 @@ function build(context) {
             context.addSceneObjects([new Move(start), vline]);
             return vline;
         }
-        const distance = arguments[0];
-        const centered = argCount >= 2 ? arguments[1] : false;
+        const distance = arguments[argOffset];
+        const centered = argCount >= 2 ? arguments[argOffset + 1] : false;
         const vline = new VerticalLine(distance, centered, planeObj);
         context.addSceneObject(vline);
         return vline;

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

@@ -123,6 +123,14 @@ export interface IGeometry extends ISceneObject {
 }
 export interface IExtrudableGeometry extends IGeometry {
 }
+export interface IOffset extends IExtrudableGeometry {
+    /**
+     * Closes an open offset by joining it back to the source wire with
+     * straight cap edges at each endpoint. Has no effect when the offset
+     * is already closed. Cannot be combined with `removeOriginal=true`.
+     */
+    close(): this;
+}
 export interface IArcPoints extends IExtrudableGeometry {
     /**
      * Sets the bulge radius for point-to-point arcs.

package/lib/dist/core/mirror.js

@@ -5,11 +5,11 @@ import { MirrorShape } from "../features/mirror-shape.js";
 import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { PlaneObject } from "../features/plane.js";
 import { isAxisLike, isStandardAxis } from "../math/axis.js";
+import { isPlaneLike } from "../math/plane.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;
@@ -36,6 +36,20 @@ function resolvePlane(arg, context) {
 function build(context) {
     return function mirror() {
         const activeSketch = context.getActiveSketch();
+        const firstArg = arguments[0];
+        if (activeSketch) {
+            const isPlaneArg = firstArg instanceof PlaneObjectBase
+                || (!isAxisLike(firstArg) && !(firstArg instanceof SceneObject) && isPlaneLike(firstArg));
+            if (isPlaneArg) {
+                throw new Error("Cannot specify a plane for mirror inside a sketch. Use mirror(axis) or mirror(line) instead.");
+            }
+        }
+        else if (firstArg instanceof SceneObject && !(firstArg instanceof PlaneObjectBase)) {
+            throw new Error("mirror(line) is only valid inside a sketch. For 3D mirroring, specify a plane: mirror(plane).");
+        }
+        else if (isStandardAxis(firstArg)) {
+            throw new Error("Cannot specify an axis for mirror outside a sketch. For 3D mirroring, specify a plane: mirror(plane).");
+        }
         if (arguments.length === 1) {
             if (activeSketch && (isAxisLike(arguments[0]) || arguments[0] instanceof SceneObject)) {
                 const axis = resolveAxis(arguments[0], context);
@@ -43,11 +57,7 @@ function build(context) {
                 context.addSceneObject(mirror);
                 return mirror;
             }
-            let planeArg = arguments[0];
-            if (isStandardAxis(planeArg)) {
-                planeArg = axisToPlaneName[planeArg];
-            }
-            const planeObj = resolvePlane(planeArg, context);
+            const planeObj = resolvePlane(arguments[0], context);
             const mirror = new MirrorShape(planeObj);
             context.addSceneObject(mirror);
             return mirror;
@@ -61,11 +71,7 @@ function build(context) {
                 context.addSceneObject(mirror);
                 return mirror;
             }
-            let planeArg = args[0];
-            if (isStandardAxis(planeArg)) {
-                planeArg = axisToPlaneName[planeArg];
-            }
-            const planeObj = resolvePlane(planeArg, context);
+            const planeObj = resolvePlane(args[0], context);
             const targetObjects = args.slice(1);
             const mirror = new MirrorShape(planeObj, targetObjects);
             context.addSceneObject(mirror);

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

@@ -1,4 +1,6 @@
 import { ISceneObject } from "./interfaces.js";
-type Extend<T> = T extends object ? T : {};
+type Extend<T> = T extends object ? {
+    features: T;
+} : {};
 declare function part<T>(name: string, callback: () => T): ISceneObject & Extend<T>;
 export default part;

package/lib/dist/core/part.js

@@ -15,7 +15,7 @@ function part(name, callback) {
     const extensions = callback();
     scene.endProgressiveContainer();
     if (extensions && typeof extensions === 'object') {
-        Object.assign(partObj, extensions);
+        partObj.features = extensions;
     }
     return partObj;
 }

package/lib/dist/core/rotate.js

@@ -17,7 +17,10 @@ function build(context) {
         // Extract copy flag from the end (if boolean)
         const copy = typeof args[args.length - 1] === 'boolean' ? args.pop() : false;
         // 2D: rotate(angle, copy?, ...targets)
-        if (args.length === 1 && activeSketch) {
+        if (args.length === 1) {
+            if (!activeSketch) {
+                throw new Error("rotate(angle) is only valid inside a sketch. For 3D rotation, specify an axis: rotate(axis, angle).");
+            }
             const angle = args[0];
             const rotate = new Rotate2D(angle, copy, ...targets);
             context.addSceneObject(rotate);

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

@@ -1,6 +1,8 @@
 import { PlaneLike } from "../math/plane.js";
 import { IPlane, ISceneObject } from "./interfaces.js";
-type Extend<T> = T extends object ? T : {};
+type Extend<T> = T extends object ? {
+    regions: T;
+} : {};
 interface SketchFunction {
     /**
      * Draws 2D geometry on a standard plane.

package/lib/dist/core/sketch.js

@@ -29,7 +29,7 @@ function build(context) {
         const extensions = sketcher();
         context.endProgressiveContainer();
         if (extensions && typeof extensions === 'object') {
-            Object.assign(sketch, extensions);
+            sketch.regions = extensions;
         }
         return sketch;
     };

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

@@ -0,0 +1,23 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { Point2D } from "../../math/point.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export declare class Ellipse extends ExtrudableGeometryBase {
+    rx: number;
+    ry: number;
+    private centerOverride;
+    constructor(rx: number, ry: number, targetPlane?: PlaneObjectBase, centerOverride?: Point2D | null);
+    getType(): string;
+    build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: this): boolean;
+    serialize(): {
+        center?: {
+            x: number;
+            y: number;
+        };
+        rx: number;
+        ry: number;
+    };
+}