fluidcad 0.0.30 → 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

@@ -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/interfaces.d.ts

@@ -656,7 +656,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,

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
         };
     }
 }

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

@@ -1,5 +1,6 @@
 import { Vertex } from "../../common/vertex.js";
 import { SectionOps } from "../../oc/section-ops.js";
+import { WireOps } from "../../oc/wire-ops.js";
 import { ExtrudableGeometryBase } from "./extrudable-base.js";
 export class Intersect extends ExtrudableGeometryBase {
     sourceObjects;
@@ -11,19 +12,25 @@ export class Intersect extends ExtrudableGeometryBase {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         const shapes = this.sourceObjects.flatMap(obj => obj.getShapes());
         const transform = context?.getTransform() ?? null;
-        let lastEdge = null;
-        for (let shape of shapes) {
+        const allEdges = [];
+        for (const shape of shapes) {
             const edges = SectionOps.sectionShapeWithPlane(plane, shape);
-            for (const edge of edges) {
-                lastEdge = edge;
-            }
+            allEdges.push(...edges);
             this.addShapes(edges);
         }
-        if (lastEdge) {
-            const localStart = plane.worldToLocal(lastEdge.getFirstVertex().toPoint());
-            const localEnd = plane.worldToLocal(lastEdge.getLastVertex().toPoint());
-            this.setState('start', Vertex.fromPoint2D(localStart));
-            this.setState('end', Vertex.fromPoint2D(localEnd));
+        // Section across multiple source faces yields an unordered edge set that
+        // may form one connected chain, several disjoint chains, or closed loops.
+        // Take the first connected group and use its actual chain endpoints —
+        // not an arbitrary edge's vertices, which can land on interior junctions.
+        if (allEdges.length > 0) {
+            const groups = WireOps.groupConnectedEdges(allEdges);
+            const endpoints = WireOps.findChainEndpoints(groups[0]);
+            if (endpoints) {
+                const localStart = plane.worldToLocal(endpoints.start.toPoint());
+                const localEnd = plane.worldToLocal(endpoints.end.toPoint());
+                this.setState('start', Vertex.fromPoint2D(localStart));
+                this.setState('end', Vertex.fromPoint2D(localEnd));
+            }
         }
         for (const obj of this.sourceObjects) {
             obj.removeShapes(this);

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

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

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

@@ -1,11 +1,13 @@
 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 PolarMove extends GeometrySceneObject {
-    radius;
+    radiusOrTarget;
     angle;
-    constructor(radius, angle) {
+    constructor(radiusOrTarget, angle) {
         super();
-        this.radius = radius;
+        this.radiusOrTarget = radiusOrTarget;
         this.angle = angle;
     }
     getType() {
@@ -13,14 +15,43 @@ export class PolarMove extends GeometrySceneObject {
     }
     build() {
         const pos = this.getCurrentPosition();
-        const newPos = new Point2D(pos.x + this.radius * Math.cos(this.angle), pos.y + this.radius * Math.sin(this.angle));
+        const tangent = (this.sketch?.getTangentAt(this) ?? new Point2D(1, 0)).normalize();
+        const cos = Math.cos(this.angle);
+        const sin = Math.sin(this.angle);
+        const direction = new Point2D(cos * tangent.x - sin * tangent.y, sin * tangent.x + cos * tangent.y);
+        let newPos;
+        if (typeof this.radiusOrTarget === 'number') {
+            newPos = new Point2D(pos.x + this.radiusOrTarget * direction.x, pos.y + this.radiusOrTarget * direction.y);
+        }
+        else {
+            const plane = this.sketch.getPlane();
+            const hit = findNearestRayIntersection(plane, pos, direction, this.radiusOrTarget);
+            if (!hit) {
+                throw new Error("Cannot move at the specified angle up to the geometry");
+            }
+            newPos = hit;
+        }
         this.setCurrentPosition(newPos);
+        const moveVec = newPos.subtract(pos);
+        const moveLen = Math.hypot(moveVec.x, moveVec.y);
+        if (moveLen > 1e-12) {
+            this.setTangent(new Point2D(moveVec.x / moveLen, moveVec.y / moveLen));
+        }
+        else {
+            this.setTangent(direction);
+        }
     }
     getDependencies() {
+        if (this.radiusOrTarget instanceof SceneObject) {
+            return [this.radiusOrTarget];
+        }
         return [];
     }
     createCopy(remap) {
-        return new PolarMove(this.radius, this.angle);
+        const radiusOrTarget = this.radiusOrTarget instanceof SceneObject
+            ? (remap.get(this.radiusOrTarget) || this.radiusOrTarget)
+            : this.radiusOrTarget;
+        return new PolarMove(radiusOrTarget, this.angle);
     }
     compareTo(other) {
         if (!(other instanceof PolarMove)) {
@@ -29,11 +60,20 @@ export class PolarMove extends GeometrySceneObject {
         if (!super.compareTo(other)) {
             return false;
         }
-        return this.radius === other.radius && this.angle === other.angle;
+        if (this.angle !== other.angle) {
+            return false;
+        }
+        if (typeof this.radiusOrTarget !== typeof other.radiusOrTarget) {
+            return false;
+        }
+        if (this.radiusOrTarget instanceof SceneObject && other.radiusOrTarget instanceof SceneObject) {
+            return this.radiusOrTarget.compareTo(other.radiusOrTarget);
+        }
+        return this.radiusOrTarget === other.radiusOrTarget;
     }
     serialize() {
         return {
-            radius: this.radius,
+            radius: typeof this.radiusOrTarget === 'number' ? this.radiusOrTarget : null,
             angle: this.angle
         };
     }