fluidcad 0.0.30 → 0.0.32

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

@@ -75,6 +75,14 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     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

@@ -100,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/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/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/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/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;

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

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

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

@@ -1,4 +1,5 @@
 import { IExtrude, ISceneObject } from "./interfaces.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 interface ExtrudeFunction {
     /**
      * Extrudes the last sketch with a default distance.
@@ -33,15 +34,27 @@ interface ExtrudeFunction {
     /**
      * Extrudes up to the first intersecting face.
      * @param face - The literal `'first-face'`
-     * @param target - The sketch or face-bearing scene object to extrude
+     * @param filters - Optional face filters to narrow the candidate set
+     */
+    (face: 'first-face', ...filters: FaceFilterBuilder[]): IExtrude;
+    /**
+     * Extrudes up to the first intersecting face.
+     * @param face - The literal `'first-face'`
+     * @param filtersAndTarget - Optional face filters followed by the target to extrude
      */
-    (face: 'first-face', target?: ISceneObject): IExtrude;
+    (face: 'first-face', ...filtersAndTarget: [...FaceFilterBuilder[], ISceneObject]): IExtrude;
     /**
      * Extrudes up to the last intersecting face.
      * @param face - The literal `'last-face'`
-     * @param target - The sketch or face-bearing scene object to extrude
+     * @param filters - Optional face filters to narrow the candidate set
+     */
+    (face: 'last-face', ...filters: FaceFilterBuilder[]): IExtrude;
+    /**
+     * Extrudes up to the last intersecting face.
+     * @param face - The literal `'last-face'`
+     * @param filtersAndTarget - Optional face filters followed by the target to extrude
      */
-    (face: 'last-face', target?: ISceneObject): IExtrude;
+    (face: 'last-face', ...filtersAndTarget: [...FaceFilterBuilder[], ISceneObject]): IExtrude;
 }
 declare const _default: ExtrudeFunction;
 export default _default;

package/lib/dist/core/extrude.js

@@ -4,6 +4,7 @@ import { Extrude } from "../features/extrude.js";
 import { ExtrudeTwoDistances } from "../features/extrude-two-distances.js";
 import { ExtrudeToFace } from "../features/extrude-to-face.js";
 import { SelectSceneObject } from "../features/select.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 function isExtrudable(obj) {
     return obj instanceof SceneObject && obj.isExtrudable();
 }
@@ -25,16 +26,17 @@ function build(context) {
         if (params.length === 0) {
             return new Extrude(defaultDistance, extrudable);
         }
+        if (params[0] === 'first-face' || params[0] === 'last-face') {
+            const rest = params.slice(1);
+            if (!rest.every(a => a instanceof FaceFilterBuilder)) {
+                throw new Error("Invalid parameter for extrude function.");
+            }
+            return new ExtrudeToFace(params[0], extrudable, rest);
+        }
         if (params.length === 1) {
             if (typeof params[0] === 'number') {
                 return new Extrude(params[0], extrudable);
             }
-            else if (params[0] === 'first-face') {
-                return new ExtrudeToFace('first-face', extrudable);
-            }
-            else if (params[0] === 'last-face') {
-                return new ExtrudeToFace('last-face', extrudable);
-            }
             else if (params[0] instanceof SceneObject) {
                 context.addSceneObject(params[0]);
                 return new ExtrudeToFace(params[0], extrudable);

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

@@ -11,11 +11,6 @@ export interface ISceneObject {
      * @param value - The display name to assign.
      */
     name(value: string): this;
-    /**
-     * Marks this object as construction geometry. Guide objects are excluded from
-     * final geometry output unless explicitly included.
-     */
-    guide(): this;
     /**
      * Marks this object as reusable. Reusable objects retain their shapes when
      * consumed by features (e.g., extrude, revolve), allowing multiple features
@@ -107,6 +102,12 @@ export interface IAxis extends ISceneObject {
 export interface ISelect extends ISceneObject {
 }
 export interface IGeometry extends ISceneObject {
+    /**
+     * Marks this sketch geometry as construction geometry. Guide geometries are
+     * excluded from the final sketch output (e.g., extrude, revolve) unless
+     * explicitly included.
+     */
+    guide(): this;
     /**
      * Returns a lazy-evaluated vertex at the start point of this geometry element.
      */
@@ -656,7 +657,7 @@ export interface ISweep extends IBooleanOperation {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
-export interface IMirror extends ISceneObject {
+export interface IMirror extends IBooleanOperation {
     /**
      * Excludes the given objects from the mirror operation. Useful when
      * mirroring "everything" but a few specific objects should be skipped,
@@ -665,6 +666,15 @@ export interface IMirror extends ISceneObject {
      */
     exclude(...objects: ISceneObject[]): this;
 }
+export interface IMirror2D extends IGeometry {
+    /**
+     * Excludes the given sketch geometries from the mirror operation. Useful
+     * when mirroring "everything" but a few specific geometries should be
+     * skipped, or when narrowing an explicit target list.
+     * @param objects - The sketch geometries to exclude from mirroring.
+     */
+    exclude(...objects: ISceneObject[]): this;
+}
 export interface ITranslate extends ISceneObject {
     /**
      * Excludes the given objects from the translate operation. Useful when

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

@@ -1,29 +1,29 @@
 import { PlaneLike } from "../math/plane.js";
 import { AxisLike } from "../math/axis.js";
-import { IMirror, ISceneObject } from "./interfaces.js";
+import { IMirror, IMirror2D, ISceneObject } from "./interfaces.js";
 interface MirrorFunction {
     /**
     * [2D] Mirror all sketch geometries across a given line.
     * @param line The line to mirror across
     */
-    (line: ISceneObject): IMirror;
+    (line: ISceneObject): IMirror2D;
     /**
     * [2D] Mirror all sketch geometries across a given axis.
     * @param axis The local axis to mirror across
     */
-    (axis: AxisLike): IMirror;
+    (axis: AxisLike): IMirror2D;
     /**
     * [2D] Mirror given sketch geometries across a given line.
     * @param line The line to mirror across
     * @param geometries The geometries to mirror
     */
-    (line: ISceneObject, ...geometries: ISceneObject[]): IMirror;
+    (line: ISceneObject, ...geometries: ISceneObject[]): IMirror2D;
     /**
     * [2D] Mirror given sketch geometries across a given axis.
     * @param axis The local axis to mirror across
     * @param geometries The geometries to mirror
     */
-    (axis: AxisLike, ...geometries: ISceneObject[]): IMirror;
+    (axis: AxisLike, ...geometries: ISceneObject[]): IMirror2D;
     /**
     * [3D] Mirror all scene shapes across a given plane.
     * @param plane The plane to mirror across

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

@@ -22,7 +22,7 @@ export class AngledLine extends GeometrySceneObject {
     }
     build() {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
-        let tangent = this.sketch?.getTangentAt(this) || new Point2D(1, 0);
+        let tangent = this.sketch?.getTangentAt(this) ?? new Point2D(1, 0);
         tangent = tangent.normalize();
         const angleRad = rad(this.angle);
         // 2D rotation of tangent by angle
@@ -48,7 +48,11 @@ export class AngledLine extends GeometrySceneObject {
                 throw new Error('aLine: .centered() cannot be combined with a target geometry');
             }
             startPoint = currentPos;
-            endPoint = findNearestRayIntersection(plane, startPoint, direction, this.lengthOrTarget);
+            const hit = findNearestRayIntersection(plane, startPoint, direction, this.lengthOrTarget);
+            if (!hit) {
+                throw new Error("Line does not intersect target geometry");
+            }
+            endPoint = hit;
         }
         const start = plane.localToWorld(startPoint);
         const end = plane.localToWorld(endPoint);

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

@@ -3,6 +3,7 @@ import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
 import { LazyVertex } from "../lazy-vertex.js";
 import { IArcPoints, IArcAngles } from "../../core/interfaces.js";
+import { SceneObject } from "../../common/scene-object.js";
 export declare class Arc extends GeometrySceneObject implements IArcPoints, IArcAngles {
     private _startPoint;
     private _endPoint;
@@ -27,6 +28,8 @@ export declare class Arc extends GeometrySceneObject implements IArcPoints, IArc
     private buildWithCenter;
     private buildFromAngles;
     getType(): string;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Arc): boolean;
     serialize(): Record<string, unknown>;
 }

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

@@ -167,7 +167,6 @@ export class Arc extends GeometrySceneObject {
         const d = Math.sqrt(r * r - (chordLen / 2) * (chordLen / 2));
         const sign = cw ? -1 : 1;
         const centerPoint = new Point2D(mx + sign * d * px, my + sign * d * py);
-        const startAngle = Math.atan2(startPoint.y - centerPoint.y, startPoint.x - centerPoint.x);
         const endAngle = Math.atan2(targetPoint.y - centerPoint.y, targetPoint.x - centerPoint.x);
         const normal = cw ? plane.normal.negate() : plane.normal;
         const center = plane.localToWorld(centerPoint);
@@ -224,6 +223,10 @@ export class Arc extends GeometrySceneObject {
         const centerPoint = this._targetPlane
             ? plane.worldToLocal(this._targetPlane.getPlaneCenter())
             : this.getCurrentPosition();
+        // Angles are measured relative to the current tangent (defaults to +X).
+        const tangent = (this._targetPlane ? null : this.sketch?.getTangentAt(this))
+            ?? new Point2D(1, 0);
+        const tangentAngle = Math.atan2(tangent.y, tangent.x);
         const cw = this._endAngle < 0;
         const absStartAngle = Math.abs(this._startAngle);
         const absEndAngle = Math.abs(this._endAngle);
@@ -239,6 +242,8 @@ export class Arc extends GeometrySceneObject {
             startAngleRad = rad(absStartAngle);
             endAngleRad = rad(absEndAngle);
         }
+        startAngleRad += tangentAngle;
+        endAngleRad += tangentAngle;
         const normal = cw ? plane.normal.negate() : plane.normal;
         const startPoint = Geometry.getPointOnCircle(centerPoint, radius, startAngleRad);
         const endPoint = Geometry.getPointOnCircle(centerPoint, radius, endAngleRad);
@@ -261,6 +266,28 @@ export class Arc extends GeometrySceneObject {
     getType() {
         return 'arc';
     }
+    getDependencies() {
+        return this._targetPlane ? [this._targetPlane] : [];
+    }
+    createCopy(remap) {
+        const targetPlane = this._targetPlane
+            ? (remap.get(this._targetPlane) || this._targetPlane)
+            : null;
+        let copy;
+        if (this._startPoint && this._endPoint) {
+            copy = Arc.twoPoints(this._startPoint, this._endPoint, targetPlane);
+        }
+        else if (this._endPoint) {
+            copy = Arc.toPoint(this._endPoint, targetPlane);
+        }
+        else {
+            copy = Arc.fromAngles(this._arcRadius, this._startAngle, this._endAngle, targetPlane);
+        }
+        copy._bulgeRadius = this._bulgeRadius;
+        copy._centerPoint = this._centerPoint;
+        copy._centered = this._centered;
+        return copy;
+    }
     compareTo(other) {
         if (!(other instanceof Arc)) {
             return false;

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

@@ -38,7 +38,11 @@ export class HorizontalLine extends GeometrySceneObject {
                 throw new Error('hLine: .centered() cannot be combined with a target geometry');
             }
             startPoint = currentPos;
-            endPoint = findNearestRayIntersection(plane, startPoint, new Point2D(1, 0), this.distanceOrTarget);
+            const hit = findNearestRayIntersection(plane, startPoint, new Point2D(1, 0), this.distanceOrTarget);
+            if (!hit) {
+                throw new Error("Line does not intersect target geometry");
+            }
+            endPoint = hit;
             signedLength = endPoint.x - startPoint.x;
         }
         const start = plane.localToWorld(startPoint);

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

@@ -1,8 +1,8 @@
 import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
 export declare class HMove extends GeometrySceneObject {
-    distance: number;
-    constructor(distance: number);
+    distanceOrTarget: number | SceneObject;
+    constructor(distanceOrTarget: number | SceneObject);
     getType(): string;
     build(): void;
     getDependencies(): SceneObject[];

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

@@ -1,24 +1,43 @@
 import { Point2D } from "../../math/point.js";
+import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
+import { findNearestRayIntersection } from "../../oc/ray-intersect.js";
 export class HMove extends GeometrySceneObject {
-    distance;
-    constructor(distance) {
+    distanceOrTarget;
+    constructor(distanceOrTarget) {
         super();
-        this.distance = distance;
+        this.distanceOrTarget = distanceOrTarget;
     }
     getType() {
         return 'hmove';
     }
     build() {
         const pos = this.getCurrentPosition();
-        const newPos = new Point2D(pos.x + this.distance, pos.y);
+        let newPos;
+        if (typeof this.distanceOrTarget === 'number') {
+            newPos = new Point2D(pos.x + this.distanceOrTarget, pos.y);
+        }
+        else {
+            const plane = this.sketch.getPlane();
+            const hit = findNearestRayIntersection(plane, pos, new Point2D(1, 0), this.distanceOrTarget);
+            if (!hit) {
+                throw new Error("Cannot move horizontally up to the specified geometry");
+            }
+            newPos = hit;
+        }
         this.setCurrentPosition(newPos);
     }
     getDependencies() {
+        if (this.distanceOrTarget instanceof SceneObject) {
+            return [this.distanceOrTarget];
+        }
         return [];
     }
     createCopy(remap) {
-        return new HMove(this.distance);
+        const distanceOrTarget = this.distanceOrTarget instanceof SceneObject
+            ? (remap.get(this.distanceOrTarget) || this.distanceOrTarget)
+            : this.distanceOrTarget;
+        return new HMove(distanceOrTarget);
     }
     compareTo(other) {
         if (!(other instanceof HMove)) {
@@ -27,11 +46,17 @@ export class HMove extends GeometrySceneObject {
         if (!super.compareTo(other)) {
             return false;
         }
-        return this.distance === other.distance;
+        if (typeof this.distanceOrTarget !== typeof other.distanceOrTarget) {
+            return false;
+        }
+        if (this.distanceOrTarget instanceof SceneObject && other.distanceOrTarget instanceof SceneObject) {
+            return this.distanceOrTarget.compareTo(other.distanceOrTarget);
+        }
+        return this.distanceOrTarget === other.distanceOrTarget;
     }
     serialize() {
         return {
-            distance: this.distance
+            distance: typeof this.distanceOrTarget === 'number' ? this.distanceOrTarget : null
         };
     }
 }