fluidcad 0.0.29 → 0.0.31

package/lib/dist/common/build-error.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Error thrown by feature pre-build validation when an operand or input is
+ * unsuitable for the operation. Carries an optional hint so the user can be
+ * told both what went wrong and how to fix it.
+ *
+ * Extends Error so the renderer's existing try/catch in `buildObject` and
+ * `describeError` keep working unchanged.
+ */
+export declare class BuildError extends Error {
+    readonly diagnostic: string;
+    readonly hint?: string;
+    constructor(diagnostic: string, hint?: string);
+}

package/lib/dist/common/build-error.js

@@ -0,0 +1,18 @@
+/**
+ * Error thrown by feature pre-build validation when an operand or input is
+ * unsuitable for the operation. Carries an optional hint so the user can be
+ * told both what went wrong and how to fix it.
+ *
+ * Extends Error so the renderer's existing try/catch in `buildObject` and
+ * `describeError` keep working unchanged.
+ */
+export class BuildError extends Error {
+    diagnostic;
+    hint;
+    constructor(diagnostic, hint) {
+        super(hint ? `${diagnostic}\nHint: ${hint}` : diagnostic);
+        this.diagnostic = diagnostic;
+        this.hint = hint;
+        this.name = 'BuildError';
+    }
+}

package/lib/dist/common/describe-error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert any thrown value to a readable string. OCC throws come through
+ * Emscripten as raw numeric pointers; decode those via OCJS.getStandard_FailureData
+ * so the actual reason ("Offset wire is not closed.", etc.) reaches the user.
+ */
+export declare function describeError(error: unknown): string;

package/lib/dist/common/describe-error.js

@@ -0,0 +1,26 @@
+import { getOC } from "../oc/init.js";
+/**
+ * Convert any thrown value to a readable string. OCC throws come through
+ * Emscripten as raw numeric pointers; decode those via OCJS.getStandard_FailureData
+ * so the actual reason ("Offset wire is not closed.", etc.) reaches the user.
+ */
+export function describeError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'number' && Number.isFinite(error)) {
+        try {
+            const oc = getOC();
+            const failure = oc.OCJS.getStandard_FailureData(error);
+            const msg = failure.GetMessageString();
+            if (msg) {
+                return `OCC: ${msg}`;
+            }
+            return `OCC error (ptr=${error})`;
+        }
+        catch (e) {
+            console.log("[describeError] decode failed:", e);
+        }
+    }
+    return String(error);
+}

package/lib/dist/common/operand-check.d.ts

@@ -0,0 +1,19 @@
+import { SceneObject } from "./scene-object.js";
+import { Shape } from "./shape.js";
+interface RequireShapesOpts {
+    /** Require exactly this many shapes. */
+    count?: number;
+    /** Require every shape to be of this type. */
+    type?: string;
+}
+/**
+ * Validate that an operand SceneObject still owns shapes the consumer can use,
+ * and produce a uniform diagnostic when it doesn't.
+ *
+ * The most common failure mode is a SceneObject whose geometry was consumed by
+ * an earlier op (e.g. `translate(amount, target)` moves the shape from
+ * `target` onto the translate object). `getRemovedShapes()` records who took
+ * each shape, so we can name the consumer in the error.
+ */
+export declare function requireShapes(obj: SceneObject, operandLabel: string, consumerType: string, opts?: RequireShapesOpts): Shape[];
+export {};

package/lib/dist/common/operand-check.js

@@ -0,0 +1,38 @@
+import { BuildError } from "./build-error.js";
+/**
+ * Validate that an operand SceneObject still owns shapes the consumer can use,
+ * and produce a uniform diagnostic when it doesn't.
+ *
+ * The most common failure mode is a SceneObject whose geometry was consumed by
+ * an earlier op (e.g. `translate(amount, target)` moves the shape from
+ * `target` onto the translate object). `getRemovedShapes()` records who took
+ * each shape, so we can name the consumer in the error.
+ */
+export function requireShapes(obj, operandLabel, consumerType, opts) {
+    // Lazy operands (LazySelectionSceneObject, LazyVertex) only populate their
+    // shapes during build. Their pre-build emptiness is expected, so skip —
+    // the build itself still validates them.
+    if (obj.isLazy()) {
+        return [];
+    }
+    const shapes = obj.getShapes();
+    if (shapes.length === 0) {
+        const removed = obj.getRemovedShapes();
+        const objLabel = `${operandLabel} (${obj.getType()})`;
+        if (removed.length > 0) {
+            const consumers = [...new Set(removed.map(r => r.removedBy.getType()))].join(", ");
+            throw new BuildError(`${consumerType}: ${objLabel} has no shapes — its geometry was consumed by ${consumers}.`, `Reference the result of ${consumers} as the operand instead of ${obj.getType()}.`);
+        }
+        throw new BuildError(`${consumerType}: ${objLabel} has no shapes.`, `Make sure the upstream operation produced geometry.`);
+    }
+    if (opts?.count !== undefined && shapes.length !== opts.count) {
+        throw new BuildError(`${consumerType}: ${operandLabel} has ${shapes.length} shapes, expected ${opts.count}.`);
+    }
+    if (opts?.type) {
+        const wrong = shapes.find(s => s.getType() !== opts.type);
+        if (wrong) {
+            throw new BuildError(`${consumerType}: ${operandLabel} has a shape of type '${wrong.getType()}', expected '${opts.type}'.`);
+        }
+    }
+    return shapes;
+}

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

@@ -69,11 +69,20 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     getPreviousSibling(obj: SceneObject): SceneObject | null;
     getPreviousSiblings(obj: SceneObject): SceneObject[];
     isContainer(): boolean;
+    isLazy(): boolean;
     saveShapesSnapshot(context: BuildSceneObjectContext): void;
     getSnapshot(): Map<SceneObject, Shape[]>;
     abstract serialize(scope?: Set<SceneObject>): any;
     abstract getType(): string;
     abstract build(context?: BuildSceneObjectContext): void;
+    /**
+     * Pre-build validation hook. The renderer calls this before `build()` so
+     * features can fail fast with a clear diagnostic (typically a `BuildError`)
+     * before any OC work runs. Default is a no-op; overrides should not mutate
+     * state. Existing per-feature checks inside `build()` are intentionally not
+     * removed — this hook is additive.
+     */
+    validate(): void;
     getAppliedTransform(): Matrix4 | null;
     protected composeAppliedTransform(matrix: Matrix4): void;
     compareTo(other: SceneObject): boolean;

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

@@ -85,6 +85,9 @@ export class SceneObject {
     isContainer() {
         return false;
     }
+    isLazy() {
+        return false;
+    }
     // called by containers to save the shapes state up to this object
     saveShapesSnapshot(context) {
         const upToHere = context.getSceneObjects();
@@ -97,6 +100,16 @@ export class SceneObject {
     getSnapshot() {
         return this.getState('snapshot') || [];
     }
+    /**
+     * Pre-build validation hook. The renderer calls this before `build()` so
+     * features can fail fast with a clear diagnostic (typically a `BuildError`)
+     * before any OC work runs. Default is a no-op; overrides should not mutate
+     * state. Existing per-feature checks inside `build()` are intentionally not
+     * removed — this hook is additive.
+     */
+    validate() {
+        // Override in subclasses to add operand checks via `requireShapes` etc.
+    }
     getAppliedTransform() {
         return this._appliedTransform;
     }

package/lib/dist/common/shape-factory.d.ts

@@ -4,5 +4,5 @@ import { Wire } from "./wire.js";
 import { Face } from "./face.js";
 import { Edge } from "./edge.js";
 export declare class ShapeFactory {
-    static fromShape(shape: TopoDS_Shape): Solid | Face | Edge | Wire;
+    static fromShape(shape: TopoDS_Shape): Edge | Wire | Solid | Face;
 }

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

@@ -1,28 +1,28 @@
 import { PlaneLike } from "../../math/plane.js";
-import { IGeometry, ISceneObject } from "../interfaces.js";
+import { IALine, ISceneObject } from "../interfaces.js";
 interface ALineFunction {
     /**
      * Draws a line at the given angle with the given length.
-     * @param length - The line length
+     * Chain `.centered()` to center the line on the current position.
      * @param angle - The angle in degrees
-     * @param centered - Whether to center the line on the current position
+     * @param length - The line length
      */
-    (length: number, angle: number, centered?: boolean): IGeometry;
+    (angle: number, length: number): IALine;
     /**
-     * Draws a line at the given angle on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param length - The line length
+     * Draws a line at the given angle that ends where it intersects the target
+     * geometry. The nearest intersection along the line's direction (in either
+     * sign) is used.
      * @param angle - The angle in degrees
+     * @param target - The geometry to intersect with
      */
-    (targetPlane: PlaneLike | ISceneObject, length: number, angle: number): IGeometry;
+    (angle: number, target: ISceneObject): IALine;
     /**
-     * Draws a centered line at the given angle on a specific plane.
+     * Draws a line at the given angle on a specific plane.
      * @param targetPlane - The plane to draw on
-     * @param length - The line length
      * @param angle - The angle in degrees
-     * @param centered - Whether to center the line on the current position
+     * @param length - The line length
      */
-    (targetPlane: PlaneLike | ISceneObject, length: number, angle: number, centered: boolean): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, angle: number, length: number): IALine;
 }
 declare const _default: ALineFunction;
 export default _default;

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

@@ -7,22 +7,27 @@ function build(context) {
     return function line() {
         let planeObj = null;
         let argOffset = 0;
-        // Detect plane as first argument (only valid outside a sketch)
+        const inSketch = context.getActiveSketch() !== null;
         if (arguments.length > 0) {
             const firstArg = arguments[0];
-            if (isPlaneLike(firstArg) || firstArg instanceof SceneObject) {
-                if (context.getActiveSketch() !== null) {
+            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 argCount = arguments.length - argOffset;
-        const length = arguments[argOffset];
-        const angle = arguments[argOffset + 1];
-        const centered = argCount >= 3 ? arguments[argOffset + 2] : false;
-        const aline = new AngledLine(length, angle, centered, planeObj);
+        const angle = arguments[argOffset];
+        const second = arguments[argOffset + 1];
+        const lengthOrTarget = second instanceof SceneObject
+            ? second
+            : second;
+        const aline = new AngledLine(angle, lengthOrTarget, planeObj);
         context.addSceneObject(aline);
         return aline;
     };

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

@@ -18,10 +18,12 @@ interface ArcFunction {
     (startPoint: Point2DLike, endPoint: Point2DLike): IArcPoints;
     /**
      * Draws an arc by radius and angle range at the current position.
+     * Angles are measured relative to the current tangent (the tangent of the previous
+     * geometry, or +X when there is none).
      * Chain `.centered()` to center the arc symmetrically around the start angle.
      * @param radius - The arc radius
-     * @param startAngle - The start angle in degrees (defaults to 0)
-     * @param endAngle - The end angle in degrees (defaults to 180)
+     * @param startAngle - The start angle in degrees, relative to the current tangent (defaults to 0)
+     * @param endAngle - The end angle in degrees, relative to the current tangent (defaults to 180)
      */
     (radius: number, startAngle?: number, endAngle?: number): IArcAngles;
     /**

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

@@ -0,0 +1,12 @@
+import { IGeometry } from "../interfaces.js";
+interface BackFunction {
+    /** Reverts the cursor to the previous position. */
+    (): IGeometry;
+    /**
+     * Reverts the cursor `count` position-changes back.
+     * @param count - How many prior cursor changes to undo (default 1).
+     */
+    (count: number): IGeometry;
+}
+declare const _default: BackFunction;
+export default _default;

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

@@ -0,0 +1,11 @@
+import { Back } from "../../features/2d/back.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function back() {
+        const count = arguments[0] ?? 1;
+        const obj = new Back(count);
+        context.addSceneObject(obj);
+        return obj;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/2d/hline.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 { IHLine, ISceneObject } from "../interfaces.js";
 interface HLineFunction {
     /**
      * Draws a horizontal 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): IHLine;
+    /**
+     * Draws a horizontal line that ends where it intersects the target geometry.
+     * The nearest intersection (in either direction along the X axis) is used.
+     * @param target - The geometry to intersect with
+     */
+    (target: ISceneObject): IHLine;
     /**
      * Draws a horizontal 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): IHLine;
     /**
-     * Draws a horizontal line on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param distance - The line length
+     * Draws a horizontal line from a start point that ends where it intersects
+     * the target geometry. The nearest intersection (in either direction along
+     * the X axis) is used.
+     * @param start - The start point
+     * @param target - The geometry to intersect with
      */
-    (targetPlane: PlaneLike | ISceneObject, distance: number): IGeometry;
+    (start: Point2DLike, target: ISceneObject): IHLine;
     /**
-     * Draws a horizontal line with centering on a specific plane.
+     * Draws a horizontal line 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
      */
-    (targetPlane: PlaneLike | ISceneObject, distance: number, centered: boolean): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, distance: number): IHLine;
 }
 declare const _default: HLineFunction;
 export default _default;

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

@@ -10,30 +10,44 @@ function build(context) {
     return function line() {
         let planeObj = null;
         let argOffset = 0;
-        // Detect plane as first argument (only valid outside a sketch)
+        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) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
-                if (context.getActiveSketch() !== null) {
+            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;
         }
-        const argCount = arguments.length - argOffset;
         if (argOffset === 0 && typeof arguments[0] !== 'number') {
-            // hline(start, distance) or hline(start, distance, centered)
+            // 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[argOffset];
-        const centered = argCount >= 2 ? arguments[argOffset + 1] : false;
-        const hline = new HorizontalLine(distance, centered, planeObj);
+        const hline = new HorizontalLine(distance, planeObj);
         context.addSceneObject(hline);
         return hline;
     };

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

@@ -1,9 +1,16 @@
+import { IGeometry, ISceneObject } from "../interfaces.js";
 interface HMoveFunction {
     /**
      * Moves the cursor horizontally by the given distance.
      * @param distance - The horizontal distance to move
      */
-    (distance: number): void;
+    (distance: number): IGeometry;
+    /**
+     * Moves the cursor horizontally to the nearest intersection with the target geometry.
+     * The nearest intersection (in either direction along the X axis) is used.
+     * @param target - The geometry to intersect with
+     */
+    (target: ISceneObject): IGeometry;
 }
 declare const _default: HMoveFunction;
 export default _default;

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

@@ -1,9 +1,13 @@
 import { HMove } from "../../features/2d/hmove.js";
+import { SceneObject } from "../../common/scene-object.js";
 import { registerBuilder } from "../../index.js";
 function build(context) {
     return function move() {
-        const distance = arguments[0];
-        const hmove = new HMove(distance);
+        const arg = arguments[0];
+        const distanceOrTarget = arg instanceof SceneObject
+            ? arg
+            : arg;
+        const hmove = new HMove(distanceOrTarget);
         context.addSceneObject(hmove);
         return hmove;
     };

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

@@ -22,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

@@ -22,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/pmove.d.ts

@@ -1,11 +1,21 @@
-import { IGeometry } from "../interfaces.js";
+import { IGeometry, ISceneObject } from "../interfaces.js";
 interface PolarMoveFunction {
     /**
-     * Moves the cursor by polar coordinates.
+     * Moves the cursor by polar coordinates, relative to the current tangent.
+     * The angle is measured from the tangent of the previous geometry (defaults to +X
+     * when there is none).
      * @param radius - The distance to move
-     * @param angle - The angle in degrees
+     * @param angle - The angle in degrees, relative to the current tangent
      */
     (radius: number, angle: number): IGeometry;
+    /**
+     * Moves the cursor along the given angle (relative to the current tangent) to the
+     * nearest intersection with the target geometry. The nearest intersection (in either
+     * direction along the ray) is used.
+     * @param target - The geometry to intersect with
+     * @param angle - The angle in degrees, relative to the current tangent
+     */
+    (target: ISceneObject, angle: number): IGeometry;
 }
 declare const _default: PolarMoveFunction;
 export default _default;

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

@@ -1,10 +1,14 @@
 import { PolarMove } from "../../features/2d/pmove.js";
+import { SceneObject } from "../../common/scene-object.js";
 import { registerBuilder } from "../../index.js";
 function build(context) {
     return function pmove() {
-        const radius = arguments[0];
+        const arg0 = arguments[0];
         const angle = arguments[1] * Math.PI / 180;
-        const pmove = new PolarMove(radius, angle);
+        const radiusOrTarget = arg0 instanceof SceneObject
+            ? arg0
+            : arg0;
+        const pmove = new PolarMove(radiusOrTarget, angle);
         context.addSceneObject(pmove);
         return pmove;
     };

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 targetPlane - The plane to draw on
-     * @param distance - The line length
+     * 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
      */
-    (targetPlane: PlaneLike | ISceneObject, distance: number): IGeometry;
+    (start: Point2DLike, target: ISceneObject): IVLine;
     /**
-     * Draws a vertical line with centering on a specific plane.
+     * Draws a vertical line 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
      */
-    (targetPlane: PlaneLike | ISceneObject, distance: number, centered: boolean): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, distance: number): IVLine;
 }
 declare const _default: VLineFunction;
 export default _default;

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

@@ -10,30 +10,40 @@ function build(context) {
     return function line() {
         let planeObj = null;
         let argOffset = 0;
-        // Detect plane as first argument (only valid outside a sketch)
+        const inSketch = context.getActiveSketch() !== null;
         if (arguments.length > 0) {
             const firstArg = arguments[0];
-            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
-                if (context.getActiveSketch() !== null) {
+            if (isPlaneLike(firstArg)) {
+                if (inSketch) {
                     throw new Error("vLine(plane, ...) cannot be used inside a sketch. Use vLine(...) 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])) {
+            // vLine(target)
+            const vline = new VerticalLine(arguments[0], null);
+            context.addSceneObject(vline);
+            return vline;
         }
-        const argCount = arguments.length - argOffset;
         if (argOffset === 0 && typeof arguments[0] !== 'number') {
-            // vline(start, distance) or vline(start, distance, centered)
+            // vLine(start, distance) or vLine(start, target)
             const start = normalizePoint2D(arguments[0]);
-            const distance = arguments[1];
-            const centered = argCount >= 3 ? arguments[2] : false;
-            const vline = new VerticalLine(distance, centered, planeObj);
+            const second = arguments[1];
+            const distanceOrTarget = second instanceof SceneObject
+                ? second
+                : second;
+            const vline = new VerticalLine(distanceOrTarget, planeObj);
             context.addSceneObjects([new Move(start), vline]);
             return vline;
         }
         const distance = arguments[argOffset];
-        const centered = argCount >= 2 ? arguments[argOffset + 1] : false;
-        const vline = new VerticalLine(distance, centered, planeObj);
+        const vline = new VerticalLine(distance, planeObj);
         context.addSceneObject(vline);
         return vline;
     };

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

@@ -1,9 +1,16 @@
+import { IGeometry, ISceneObject } from "../interfaces.js";
 interface VMoveFunction {
     /**
      * Moves the cursor vertically by the given distance.
      * @param distance - The vertical distance to move
      */
-    (distance: number): void;
+    (distance: number): IGeometry;
+    /**
+     * Moves the cursor vertically to the nearest intersection with the target geometry.
+     * The nearest intersection (in either direction along the Y axis) is used.
+     * @param target - The geometry to intersect with
+     */
+    (target: ISceneObject): IGeometry;
 }
 declare const _default: VMoveFunction;
 export default _default;