fluidcad 0.0.38 → 0.0.39

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

@@ -1,4 +1,3 @@
-import { PlaneLike } from "../../math/plane.js";
 import { IALine, ISceneObject } from "../interfaces.js";
 import { type NumberParam } from "../param.js";
 interface ALineFunction {
@@ -17,13 +16,6 @@ interface ALineFunction {
      * @param target - The geometry to intersect with
      */
     (angle: NumberParam, target: ISceneObject): IALine;
-    /**
-     * Draws a line at the given angle on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param angle - The angle in degrees
-     * @param length - The line length
-     */
-    (targetPlane: PlaneLike | ISceneObject, angle: NumberParam, length: NumberParam): IALine;
 }
 declare const _default: ALineFunction;
 export default _default;

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

@@ -1,34 +1,15 @@
 import { AngledLine } from "../../features/2d/aline.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";
 import { resolveParam } from "../param.js";
 function build(context) {
     return function line() {
-        let planeObj = null;
-        let argOffset = 0;
-        const inSketch = context.getActiveSketch() !== null;
-        if (arguments.length > 0) {
-            const firstArg = arguments[0];
-            if (isPlaneLike(firstArg)) {
-                if (inSketch) {
-                    throw new Error("aLine(plane, ...) cannot be used inside a sketch. Use aLine(...) instead.");
-                }
-                planeObj = resolvePlane(firstArg, context);
-                argOffset = 1;
-            }
-            else if (!inSketch && firstArg instanceof SceneObject) {
-                planeObj = resolvePlane(firstArg, context);
-                argOffset = 1;
-            }
-        }
-        const angle = resolveParam(arguments[argOffset]);
-        const second = arguments[argOffset + 1];
+        const angle = resolveParam(arguments[0]);
+        const second = arguments[1];
         const lengthOrTarget = second instanceof SceneObject
             ? second
             : resolveParam(second);
-        const aline = new AngledLine(angle, lengthOrTarget, planeObj);
+        const aline = new AngledLine(angle, lengthOrTarget, null);
         context.addSceneObject(aline);
         return aline;
     };

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

@@ -1,6 +1,5 @@
 import { Point2DLike } from "../../math/point.js";
-import { PlaneLike } from "../../math/plane.js";
-import { IArcPoints, IArcAngles, ISceneObject } from "../interfaces.js";
+import { IArcPoints, IArcAngles } from "../interfaces.js";
 import { type NumberParam } from "../param.js";
 interface ArcFunction {
     /**
@@ -27,27 +26,6 @@ interface ArcFunction {
      * @param endAngle - The end angle in degrees, relative to the current tangent (defaults to 180)
      */
     (radius: NumberParam, startAngle?: NumberParam, endAngle?: NumberParam): IArcAngles;
-    /**
-     * Draws an arc to an end point on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param endPoint - The end point of the arc
-     */
-    (targetPlane: PlaneLike | ISceneObject, endPoint: Point2DLike): IArcPoints;
-    /**
-     * Draws an arc between two points on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param startPoint - The start point of the arc
-     * @param endPoint - The end point of the arc
-     */
-    (targetPlane: PlaneLike | ISceneObject, startPoint: Point2DLike, endPoint: Point2DLike): IArcPoints;
-    /**
-     * Draws an arc by radius and angle range on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param radius - The arc radius
-     * @param startAngle - The start angle in degrees
-     * @param endAngle - The end angle in degrees
-     */
-    (targetPlane: PlaneLike | ISceneObject, radius: NumberParam, startAngle: NumberParam, endAngle: NumberParam): IArcAngles;
 }
 declare const _default: ArcFunction;
 export default _default;

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

@@ -2,46 +2,29 @@ import { isPoint2DLike } from "../../math/point.js";
 import { Arc } from "../../features/2d/arc.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";
 import { resolveParam } from "../param.js";
 function build(context) {
     return function arc() {
-        let planeObj = null;
-        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("arc(plane, ...) cannot be used inside a sketch. Use arc(...) instead.");
-                }
-                planeObj = resolvePlane(firstArg, context);
-                argOffset = 1;
-            }
-        }
-        const argCount = arguments.length - argOffset;
         // (startPoint, endPoint) — two Point2DLike args, default center = current position
-        if (argCount >= 2 && isPoint2DLike(arguments[argOffset]) && isPoint2DLike(arguments[argOffset + 1])) {
-            const start = normalizePoint2D(arguments[argOffset]);
-            const end = normalizePoint2D(arguments[argOffset + 1]);
-            const arcObj = Arc.twoPoints(start, end, planeObj);
+        if (arguments.length >= 2 && isPoint2DLike(arguments[0]) && isPoint2DLike(arguments[1])) {
+            const start = normalizePoint2D(arguments[0]);
+            const end = normalizePoint2D(arguments[1]);
+            const arcObj = Arc.twoPoints(start, end);
             context.addSceneObject(arcObj);
             return arcObj;
         }
         // (endPoint) — single Point2DLike arg
-        if (isPoint2DLike(arguments[argOffset])) {
-            const end = normalizePoint2D(arguments[argOffset]);
-            const arcObj = Arc.toPoint(end, planeObj);
+        if (isPoint2DLike(arguments[0])) {
+            const end = normalizePoint2D(arguments[0]);
+            const arcObj = Arc.toPoint(end);
             context.addSceneObject(arcObj);
             return arcObj;
         }
         // (radius, startAngle?, endAngle?) — all numeric args
-        const radius = resolveParam(arguments[argOffset]) || 100;
-        const startAngle = resolveParam(arguments[argOffset + 1]) || 0;
-        const endAngle = argCount >= 3 ? resolveParam(arguments[argOffset + 2]) : 180;
-        const arcObj = Arc.fromAngles(radius, startAngle, endAngle, planeObj);
+        const radius = resolveParam(arguments[0]) || 100;
+        const startAngle = resolveParam(arguments[1]) || 0;
+        const endAngle = arguments.length >= 3 ? resolveParam(arguments[2]) : 180;
+        const arcObj = Arc.fromAngles(radius, startAngle, endAngle);
         context.addSceneObject(arcObj);
         return arcObj;
     };

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

@@ -1,6 +1,5 @@
 import { Point2DLike } from "../../math/point.js";
-import { PlaneLike } from "../../math/plane.js";
-import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
+import { IExtrudableGeometry } from "../interfaces.js";
 import { type NumberParam } from "../param.js";
 interface CircleFunction {
     /**
@@ -14,12 +13,6 @@ interface CircleFunction {
      * @param diameter - The circle diameter (defaults to 40)
      */
     (diameter?: NumberParam): IExtrudableGeometry;
-    /**
-     * Draws a circle with a given diameter on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param diameter - The circle diameter
-     */
-    (targetPlane: PlaneLike | ISceneObject, diameter: NumberParam): IExtrudableGeometry;
 }
 declare const _default: CircleFunction;
 export default _default;

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

@@ -1,45 +1,28 @@
-import { isPoint2DLike } from "../../math/point.js";
 import { Circle } from "../../features/2d/circle.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";
 import { resolveParam } from "../param.js";
 function build(context) {
     return function circle() {
         let diameter;
         let center;
         let circle;
-        let planeObj = null;
-        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;
+        const argCount = arguments.length;
         if (argCount === 0) {
             diameter = 40;
-            circle = new Circle(diameter, null, planeObj);
+            circle = new Circle(diameter, null, null);
             context.addSceneObject(circle);
         }
         else if (argCount === 1) {
-            diameter = resolveParam(arguments[argOffset]) || 40;
-            circle = new Circle(diameter, null, planeObj);
+            diameter = resolveParam(arguments[0]) || 40;
+            circle = new Circle(diameter, null, null);
             context.addSceneObject(circle);
         }
         else {
-            center = normalizePoint2D(arguments[argOffset]);
-            diameter = resolveParam(arguments[argOffset + 1]) || 40;
-            circle = new Circle(diameter, null, planeObj);
+            center = normalizePoint2D(arguments[0]);
+            diameter = resolveParam(arguments[1]) || 40;
+            circle = new Circle(diameter, null, null);
             const move = new Move(center);
             context.addSceneObjects([move, circle]);
         }

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

@@ -1,6 +1,5 @@
 import { Point2DLike } from "../../math/point.js";
-import { PlaneLike } from "../../math/plane.js";
-import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
+import { IExtrudableGeometry } from "../interfaces.js";
 import { type NumberParam } from "../param.js";
 interface EllipseFunction {
     /**
@@ -16,21 +15,6 @@ interface EllipseFunction {
      * @param ry - Semi-radius along the plane's Y axis
      */
     (center: Point2DLike, rx: NumberParam, ry: NumberParam): 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: NumberParam, ry: NumberParam): 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: NumberParam, ry: NumberParam): IExtrudableGeometry;
 }
 declare const _default: EllipseFunction;
 export default _default;

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

@@ -1,60 +1,22 @@
-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";
 import { resolveParam } from "../param.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;
+        const argCount = arguments.length;
         if (argCount === 2) {
-            const rx = resolveParam(arguments[argOffset]);
-            const ry = resolveParam(arguments[argOffset + 1]);
-            const e = new Ellipse(rx, ry, planeObj);
+            const rx = resolveParam(arguments[0]);
+            const ry = resolveParam(arguments[1]);
+            const e = new Ellipse(rx, ry, null);
             context.addSceneObject(e);
             return e;
         }
         if (argCount === 3) {
-            const centerArg = arguments[argOffset];
-            const rx = resolveParam(arguments[argOffset + 1]);
-            const ry = resolveParam(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 centerArg = arguments[0];
+            const rx = resolveParam(arguments[1]);
+            const ry = resolveParam(arguments[2]);
             const center = normalizePoint2D(centerArg);
             const e = new Ellipse(rx, ry, null);
             context.addSceneObjects([new Move(center), e]);

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

@@ -1,5 +1,4 @@
 import { Point2DLike } from "../../math/point.js";
-import { PlaneLike } from "../../math/plane.js";
 import { IHLine, ISceneObject } from "../interfaces.js";
 import { type NumberParam } from "../param.js";
 interface HLineFunction {
@@ -30,12 +29,6 @@ interface HLineFunction {
      * @param target - The geometry to intersect with
      */
     (start: Point2DLike, target: ISceneObject): IHLine;
-    /**
-     * Draws a horizontal line on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param distance - The line length
-     */
-    (targetPlane: PlaneLike | ISceneObject, distance: NumberParam): IHLine;
 }
 declare const _default: HLineFunction;
 export default _default;

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

@@ -3,53 +3,31 @@ import { Move } from "../../features/2d/move.js";
 import { HorizontalLine } from "../../features/2d/hline.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";
 import { isNumberParam, resolveParam } from "../param.js";
 function build(context) {
     return function line() {
-        let planeObj = null;
-        let argOffset = 0;
         const inSketch = context.getActiveSketch() !== null;
-        // Detect plane as first argument (only valid outside a sketch).
-        // Inside a sketch, a SceneObject in the first position is a target geometry,
-        // and a true PlaneLike is an error since drawing on another plane mid-sketch
-        // is not supported.
-        if (arguments.length > 0) {
-            const firstArg = arguments[0];
-            if (isPlaneLike(firstArg)) {
-                if (inSketch) {
-                    throw new Error("hLine(plane, ...) cannot be used inside a sketch. Use hLine(...) instead.");
-                }
-                planeObj = resolvePlane(firstArg, context);
-                argOffset = 1;
-            }
-            else if (!inSketch && firstArg instanceof SceneObject && !isPoint2DLike(firstArg)) {
-                planeObj = resolvePlane(firstArg, context);
-                argOffset = 1;
-            }
-        }
-        if (argOffset === 0 && inSketch && arguments[0] instanceof SceneObject && !isPoint2DLike(arguments[0])) {
+        if (inSketch && arguments[0] instanceof SceneObject && !isPoint2DLike(arguments[0])) {
             // hLine(target)
             const hline = new HorizontalLine(arguments[0], null);
             context.addSceneObject(hline);
             return hline;
         }
-        if (argOffset === 0 && !isNumberParam(arguments[0])) {
+        if (!isNumberParam(arguments[0])) {
             // hLine(start, distance) or hLine(start, target)
             const start = normalizePoint2D(arguments[0]);
             const second = arguments[1];
             const distanceOrTarget = second instanceof SceneObject
                 ? second
                 : resolveParam(second);
-            const hline = new HorizontalLine(distanceOrTarget, planeObj);
+            const hline = new HorizontalLine(distanceOrTarget, null);
             hline.setHasExplicitStart();
             context.addSceneObjects([new Move(start), hline]);
             return hline;
         }
-        const distance = resolveParam(arguments[argOffset]);
-        const hline = new HorizontalLine(distance, planeObj);
+        const distance = resolveParam(arguments[0]);
+        const hline = new HorizontalLine(distance, null);
         context.addSceneObject(hline);
         return hline;
     };

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

@@ -1,4 +1,3 @@
-import { PlaneLike } from "../../math/plane.js";
 import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
 interface IntersectFunction {
     /**
@@ -6,12 +5,6 @@ interface IntersectFunction {
      * @param sourceObjects - The 3D objects to intersect
      */
     (...sourceObjects: ISceneObject[]): IExtrudableGeometry;
-    /**
-     * Intersects 3D objects with a target plane, producing cross-section edges.
-     * @param targetPlane - The plane to intersect with
-     * @param sourceObjects - The 3D objects to intersect
-     */
-    (targetPlane: PlaneLike | ISceneObject, sourceObjects: ISceneObject[]): IExtrudableGeometry;
 }
 declare const _default: IntersectFunction;
 export default _default;

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

@@ -1,20 +1,7 @@
 import { Intersect } from "../../features/2d/intersect.js";
-import { resolvePlane } from "../../helpers/resolve.js";
 import { registerBuilder } from "../../index.js";
 function build(context) {
     return function intersect(...args) {
-        // 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 result = new Intersect(sourceObjects, planeObj);
-            context.addSceneObject(result);
-            return result;
-        }
         const result = new Intersect(args);
         context.addSceneObjects(args);
         context.addSceneObject(result);

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

@@ -1,6 +1,5 @@
 import { Point2DLike } from "../../math/point.js";
-import { PlaneLike } from "../../math/plane.js";
-import { IGeometry, ISceneObject } from "../interfaces.js";
+import { IGeometry } from "../interfaces.js";
 interface LineFunction {
     /**
      * Draws a line from the current position to the given point.
@@ -13,12 +12,6 @@ interface LineFunction {
      * @param end - The end point
      */
     (start: Point2DLike, end: Point2DLike): IGeometry;
-    /**
-     * Draws a line to the given point on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param end - The end point
-     */
-    (targetPlane: PlaneLike | ISceneObject, end: Point2DLike): IGeometry;
 }
 declare const _default: LineFunction;
 export default _default;

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

@@ -1,38 +1,20 @@
-import { isPoint2DLike } from "../../math/point.js";
 import { LineTo } from "../../features/2d/line.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 build(context) {
     return function line() {
         let line;
-        let planeObj = null;
-        let argOffset = 0;
-        // Detect plane as first argument (only valid outside a sketch)
-        // Point2DLike is not plane-like so no conflict
-        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;
+        const argCount = arguments.length;
         if (argCount === 1) {
-            const vertex = normalizePoint2D(arguments[argOffset]);
-            line = new LineTo(vertex, planeObj);
+            const vertex = normalizePoint2D(arguments[0]);
+            line = new LineTo(vertex, null);
             context.addSceneObject(line);
         }
         else if (argCount === 2) {
-            const start = normalizePoint2D(arguments[argOffset]);
-            const end = normalizePoint2D(arguments[argOffset + 1]);
-            line = new LineTo(end, planeObj);
+            const start = normalizePoint2D(arguments[0]);
+            const end = normalizePoint2D(arguments[1]);
+            line = new LineTo(end, null);
             line.setHasExplicitStart();
             context.addSceneObjects([new Move(start), line]);
         }

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

@@ -1,6 +1,4 @@
-import { PlaneLike } from "../../math/plane.js";
-import { IOffset, ISceneObject } from "../interfaces.js";
-import { Extrudable } from "../../helpers/types.js";
+import { IOffset } from "../interfaces.js";
 import { type NumberParam, type BooleanParam } from "../param.js";
 interface OffsetFunction {
     /**
@@ -9,14 +7,6 @@ interface OffsetFunction {
      * @param removeOriginal - Whether to remove the original geometry
      */
     (distance?: NumberParam, removeOriginal?: BooleanParam): 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 sourceGeometries - The geometries to offset
-     */
-    (targetPlane: PlaneLike | ISceneObject, distance: NumberParam, removeOriginal: BooleanParam, ...sourceGeometries: Extrudable[]): IOffset;
 }
 declare const _default: OffsetFunction;
 export default _default;

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

@@ -1,24 +1,8 @@
 import { Offset } from "../../features/2d/offset.js";
 import { registerBuilder } from "../../index.js";
-import { resolvePlane } from "../../helpers/resolve.js";
 import { isNumberParam, isBooleanParam, resolveParam } from "../param.js";
 function build(context) {
     return function offset(...args) {
-        // Plane-first mode: offset(plane, distance, removeOriginal, ...sourceGeometries)
-        // Detected when first arg is not a number/undefined.
-        if (args.length > 0 && args[0] !== undefined && !isNumberParam(args[0]) && !isBooleanParam(args[0])) {
-            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 = resolveParam(args[1]) ?? 1;
-            const removeOriginal = resolveParam(args[2]) ?? false;
-            const sourceObjects = args.slice(3);
-            const off = new Offset(distance, removeOriginal, sourceObjects, planeObj);
-            context.addSceneObject(off);
-            return off;
-        }
-        // In-sketch mode: offset(distance, removeOriginal)
         const distance = isNumberParam(args[0]) ? resolveParam(args[0]) : 1;
         const removeOriginal = isBooleanParam(args[1]) ? resolveParam(args[1]) : false;
         const off = new Offset(distance, removeOriginal);

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

@@ -1,7 +1,6 @@
 import { Point2DLike } from "../../math/point.js";
 import { PolygonMode } from "../../features/2d/polygon.js";
-import { PlaneLike } from "../../math/plane.js";
-import { IPolygon, ISceneObject } from "../interfaces.js";
+import { IPolygon } from "../interfaces.js";
 import { type NumberParam } from "../param.js";
 interface PolygonFunction {
     /**
@@ -19,21 +18,6 @@ interface PolygonFunction {
      * @param mode - `'inscribed'` or `'circumscribed'` (defaults to `'inscribed'`)
      */
     (center: Point2DLike, numberOfSides: NumberParam, diameter: NumberParam, 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
-     */
-    (targetPlane: PlaneLike | ISceneObject, numberOfSides: NumberParam, diameter: NumberParam): 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'`
-     */
-    (targetPlane: PlaneLike | ISceneObject, numberOfSides: NumberParam, diameter: NumberParam, mode: PolygonMode): IPolygon;
 }
 declare const _default: PolygonFunction;
 export default _default;