fluidcad 0.0.28 → 0.0.30

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

@@ -9,27 +9,45 @@ 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;
+        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])) {
+            // hLine(target)
+            const hline = new HorizontalLine(arguments[0], null);
+            context.addSceneObject(hline);
+            return hline;
         }
-        if (typeof arguments[0] !== 'number') {
-            // hline(start, distance) or hline(start, distance, centered)
+        if (argOffset === 0 && typeof arguments[0] !== 'number') {
+            // hLine(start, distance) or hLine(start, target)
             const start = normalizePoint2D(arguments[0]);
-            const distance = arguments[1];
-            const centered = argCount >= 3 ? arguments[2] : false;
-            const hline = new HorizontalLine(distance, centered, planeObj);
+            const second = arguments[1];
+            const distanceOrTarget = second instanceof SceneObject
+                ? second
+                : second;
+            const hline = new HorizontalLine(distanceOrTarget, planeObj);
             context.addSceneObjects([new Move(start), hline]);
             return hline;
         }
-        const distance = arguments[0];
-        const centered = argCount >= 2 ? arguments[1] : false;
-        const hline = new HorizontalLine(distance, centered, planeObj);
+        const distance = arguments[argOffset];
+        const hline = new HorizontalLine(distance, 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';
@@ -21,3 +22,4 @@ export { default as project } from './project.js';
 export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
 export { default as center } from './center.js';
+export { default as back } from './back.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';
@@ -21,3 +22,4 @@ export { default as project } from './project.js';
 export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
 export { default as center } from './center.js';
+export { default as back } from './back.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;

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

@@ -1,33 +1,40 @@
 import { Point2DLike } from "../../math/point.js";
 import { PlaneLike } from "../../math/plane.js";
-import { IGeometry, ISceneObject } from "../interfaces.js";
+import { IVLine, ISceneObject } from "../interfaces.js";
 interface VLineFunction {
     /**
      * Draws a vertical line of the given distance.
+     * Chain `.centered()` to center the line on the current position.
      * @param distance - The line length
-     * @param centered - Whether to center the line on the current position
      */
-    (distance: number, centered?: boolean): IGeometry;
+    (distance: number): IVLine;
+    /**
+     * Draws a vertical line that ends where it intersects the target geometry.
+     * The nearest intersection (in either direction along the Y axis) is used.
+     * @param target - The geometry to intersect with
+     */
+    (target: ISceneObject): IVLine;
     /**
      * Draws a vertical line from a start point.
+     * Chain `.centered()` to center the line on the start point.
      * @param start - The start point
      * @param distance - The line length
-     * @param centered - Whether to center the line on the start point
      */
-    (start: Point2DLike, distance: number, centered?: boolean): IGeometry;
+    (start: Point2DLike, distance: number): IVLine;
     /**
-     * Draws a vertical line on a specific plane.
-     * @param distance - The line length
-     * @param targetPlane - The plane to draw on
+     * Draws a vertical line from a start point that ends where it intersects
+     * the target geometry. The nearest intersection (in either direction along
+     * the Y axis) is used.
+     * @param start - The start point
+     * @param target - The geometry to intersect with
      */
-    (distance: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (start: Point2DLike, target: ISceneObject): IVLine;
     /**
-     * Draws a vertical line with centering on a specific plane.
-     * @param distance - The line length
-     * @param centered - Whether to center the line on the current position
+     * Draws a vertical line on a specific plane.
      * @param targetPlane - The plane to draw on
+     * @param distance - The line length
      */
-    (distance: number, centered: boolean, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, distance: number): IVLine;
 }
 declare const _default: VLineFunction;
 export default _default;