fluidcad 0.0.34 → 0.0.36

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

@@ -1,5 +1,6 @@
 import { AxisLike } from "../math/axis.js";
 import { IRevolve, ISceneObject } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
 interface RevolveFunction {
     /**
      * Revolves the last sketch 360 degrees around an axis.
@@ -13,7 +14,7 @@ interface RevolveFunction {
      * @param angle - The sweep angle in degrees
      * @param target - The sketch to revolve
      */
-    (axisLike: AxisLike, angle: number, target?: ISceneObject): IRevolve;
+    (axisLike: AxisLike, angle: NumberParam, target?: ISceneObject): IRevolve;
 }
 declare const _default: RevolveFunction;
 export default _default;

package/lib/dist/core/revolve.js

@@ -2,6 +2,7 @@ import { registerBuilder } from "../index.js";
 import { Revolve } from "../features/revolve.js";
 import { resolveAxis } from "../helpers/resolve.js";
 import { SceneObject } from "../common/scene-object.js";
+import { isNumberParam, resolveParam } from "./param.js";
 function isExtrudable(obj) {
     return obj instanceof SceneObject && obj.isExtrudable();
 }
@@ -16,8 +17,8 @@ function build(context) {
         // (axis, angle)
         if (params.length === 2) {
             const axis = resolveAxis(params[0], context);
-            if (typeof params[1] === 'number') {
-                return new Revolve(axis, params[1], extrudable);
+            if (isNumberParam(params[1])) {
+                return new Revolve(axis, resolveParam(params[1]), extrudable);
             }
         }
         throw new Error("Invalid parameters for revolve function.");

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

@@ -1,4 +1,5 @@
 import { IRib, ISceneObject } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
 interface RibFunction {
     /**
      * Creates a rib from the last sketch with the given thickness.
@@ -6,13 +7,13 @@ interface RibFunction {
      * surrounding solids. Positive thickness = forward, negative = reverse.
      * @param thickness - Wall thickness (sign controls direction)
      */
-    (thickness: number): IRib;
+    (thickness: NumberParam): IRib;
     /**
      * Creates a rib from an explicit sketch spine with the given thickness.
      * @param thickness - Wall thickness (sign controls direction)
      * @param spine - The sketch providing the rib spine wire and plane
      */
-    (thickness: number, spine: ISceneObject): IRib;
+    (thickness: NumberParam, spine: ISceneObject): IRib;
 }
 declare const _default: RibFunction;
 export default _default;

package/lib/dist/core/rib.js

@@ -1,6 +1,7 @@
 import { SceneObject } from "../common/scene-object.js";
 import { registerBuilder } from "../index.js";
 import { Rib } from "../features/rib.js";
+import { isNumberParam, resolveParam } from "./param.js";
 function isExtrudable(obj) {
     return obj instanceof SceneObject && obj.isExtrudable();
 }
@@ -11,8 +12,11 @@ function build(context) {
         if (args.length === 0) {
             throw new Error("rib() requires at least a thickness argument.");
         }
-        const thickness = args[0];
-        if (typeof thickness !== 'number' || thickness === 0) {
+        if (!isNumberParam(args[0])) {
+            throw new Error("rib() thickness must be a non-zero number.");
+        }
+        const thickness = resolveParam(args[0]);
+        if (thickness === 0) {
             throw new Error("rib() thickness must be a non-zero number.");
         }
         let spine;

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

@@ -1,26 +1,27 @@
 import { AxisLike } from "../math/axis.js";
 import { IRotate, ISceneObject } from "./interfaces.js";
+import { type NumberParam, type BooleanParam } from "./param.js";
 interface RotateFunction {
     /**
      * [2D] Rotates geometry by an angle inside a sketch.
      * @param angle - The rotation angle in degrees
      * @param targets - The geometries to rotate (defaults to last object)
      */
-    (angle: number, ...targets: ISceneObject[]): IRotate;
+    (angle: NumberParam, ...targets: ISceneObject[]): IRotate;
     /**
      * [2D] Rotates geometry by an angle inside a sketch, optionally making a copy.
      * @param angle - The rotation angle in degrees
      * @param copy - Whether to copy instead of move
      * @param targets - The geometries to rotate (defaults to last object)
      */
-    (angle: number, copy: boolean, ...targets: ISceneObject[]): IRotate;
+    (angle: NumberParam, copy: BooleanParam, ...targets: ISceneObject[]): IRotate;
     /**
      * [3D] Rotates objects around an axis by an angle.
      * @param axis - The axis to rotate around
      * @param angle - The rotation angle in degrees
      * @param targets - The objects to rotate (defaults to last object)
      */
-    (axis: AxisLike, angle: number, ...targets: ISceneObject[]): IRotate;
+    (axis: AxisLike, angle: NumberParam, ...targets: ISceneObject[]): IRotate;
     /**
      * [3D] Rotates objects around an axis by an angle, optionally making a copy.
      * @param axis - The axis to rotate around
@@ -28,7 +29,7 @@ interface RotateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to rotate (defaults to last object)
      */
-    (axis: AxisLike, angle: number, copy: boolean, ...targets: ISceneObject[]): IRotate;
+    (axis: AxisLike, angle: NumberParam, copy: BooleanParam, ...targets: ISceneObject[]): IRotate;
 }
 declare const _default: RotateFunction;
 export default _default;

package/lib/dist/core/rotate.js

@@ -5,6 +5,7 @@ import { SceneObject } from "../common/scene-object.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { AxisObject } from "../features/axis.js";
 import { Rotate2D } from "../features/rotate2d.js";
+import { isBooleanParam, resolveParam } from "./param.js";
 function build(context) {
     return function rotate() {
         const args = Array.from(arguments);
@@ -15,13 +16,13 @@ function build(context) {
             targets.unshift(args.pop());
         }
         // Extract copy flag from the end (if boolean)
-        const copy = typeof args[args.length - 1] === 'boolean' ? args.pop() : false;
+        const copy = isBooleanParam(args[args.length - 1]) ? resolveParam(args.pop()) : false;
         // 2D: rotate(angle, copy?, ...targets)
         if (args.length === 1) {
             if (!activeSketch) {
                 throw new Error("rotate(angle) is only valid inside a sketch. For 3D rotation, specify an axis: rotate(axis, angle).");
             }
-            const angle = args[0];
+            const angle = resolveParam(args[0]);
             const rotate = new Rotate2D(angle, copy, ...targets);
             context.addSceneObject(rotate);
             return rotate;
@@ -40,7 +41,7 @@ function build(context) {
                 axis = new AxisObject(a);
                 context.addSceneObject(axis);
             }
-            const angle = args[1];
+            const angle = resolveParam(args[1]);
             const rotate = new Rotate(axis, angle, copy, ...targets);
             context.addSceneObject(rotate);
             return rotate;

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

@@ -1,16 +1,17 @@
 import { ISceneObject, IShell } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
 interface ShellFunction {
     /**
      * Hollows out a solid with the given wall thickness.
      * @param thickness - The wall thickness (defaults to 2.5)
      */
-    (thickness?: number): IShell;
+    (thickness?: NumberParam): IShell;
     /**
      * Hollows out a solid, removing the selected faces.
      * @param thickness - The wall thickness
      * @param selections - The face selections to remove
      */
-    (thickness: number, ...selections: ISceneObject[]): IShell;
+    (thickness: NumberParam, ...selections: ISceneObject[]): IShell;
 }
 declare const _default: ShellFunction;
 export default _default;

package/lib/dist/core/shell.js

@@ -1,6 +1,7 @@
 import { Shell } from "../features/shell.js";
 import { SceneObject } from "../common/scene-object.js";
 import { registerBuilder } from "../index.js";
+import { isNumberParam, resolveParam } from "./param.js";
 function build(context) {
     return function shell() {
         const args = Array.from(arguments);
@@ -14,8 +15,8 @@ function build(context) {
                 selections.push(implicit);
             }
         }
-        const thickness = (args.length >= 1 && typeof args[0] === 'number')
-            ? args[0]
+        const thickness = (args.length >= 1 && isNumberParam(args[0]))
+            ? resolveParam(args[0])
             : 2.5;
         for (const sel of selections) {
             context.addSceneObject(sel);

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

@@ -1,16 +1,17 @@
 import { ITransformable } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
 interface SphereFunction {
     /**
      * Creates a full sphere with the given radius.
      * @param radius - The sphere radius
      */
-    (radius: number): ITransformable;
+    (radius: NumberParam): ITransformable;
     /**
      * Creates a partial sphere with the given radius and sweep angle.
      * @param radius - The sphere radius
      * @param angle - The sweep angle in degrees
      */
-    (radius: number, angle: number): ITransformable;
+    (radius: NumberParam, angle: NumberParam): ITransformable;
 }
 declare const _default: SphereFunction;
 export default _default;

package/lib/dist/core/sphere.js

@@ -1,9 +1,10 @@
 import { Sphere } from "../features/sphere.js";
 import { rad } from "../helpers/math-helpers.js";
 import { registerBuilder } from "../index.js";
+import { resolveParam } from "./param.js";
 function build(context) {
     return function sphere(radius, angle = 360) {
-        const sphere = new Sphere(radius, rad(angle));
+        const sphere = new Sphere(resolveParam(radius), rad(resolveParam(angle)));
         context.addSceneObject(sphere);
         return sphere;
     };

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

@@ -1,26 +1,27 @@
 import { PointLike } from "../math/point.js";
 import { ISceneObject, ITranslate } from "./interfaces.js";
+import { type NumberParam, type BooleanParam } from "./param.js";
 interface TranslateFunction {
     /**
      * Translates objects along the X axis.
      * @param x - The X distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, ...targets: ISceneObject[]): ITranslate;
+    (x: NumberParam, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along the X axis, optionally making a copy.
      * @param x - The X distance
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, copy: boolean, ...targets: ISceneObject[]): ITranslate;
+    (x: NumberParam, copy: BooleanParam, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along the X and Y axes.
      * @param x - The X distance
      * @param y - The Y distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, ...targets: ISceneObject[]): ITranslate;
+    (x: NumberParam, y: NumberParam, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along the X and Y axes, optionally making a copy.
      * @param x - The X distance
@@ -28,7 +29,7 @@ interface TranslateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, copy: boolean, ...targets: ISceneObject[]): ITranslate;
+    (x: NumberParam, y: NumberParam, copy: BooleanParam, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along all three axes.
      * @param x - The X distance
@@ -36,7 +37,7 @@ interface TranslateFunction {
      * @param z - The Z distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, z: number, ...targets: ISceneObject[]): ITranslate;
+    (x: NumberParam, y: NumberParam, z: NumberParam, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along all three axes, optionally making a copy.
      * @param x - The X distance
@@ -45,7 +46,7 @@ interface TranslateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, z: number, copy: boolean, ...targets: ISceneObject[]): ITranslate;
+    (x: NumberParam, y: NumberParam, z: NumberParam, copy: BooleanParam, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects by a point-like offset.
      * @param distance - The offset as a point

package/lib/dist/core/translate.js

@@ -5,6 +5,7 @@ import { Point } from "../math/point.js";
 import { SceneObject } from "../common/scene-object.js";
 import { Vertex } from "../common/vertex.js";
 import { LazyVertex } from "../features/lazy-vertex.js";
+import { isNumberParam, isBooleanParam, resolveParam } from "./param.js";
 function build(context) {
     return function translate() {
         const args = Array.from(arguments);
@@ -14,12 +15,12 @@ function build(context) {
             targets.unshift(args.pop());
         }
         // Extract copy flag from the end (if boolean)
-        const copy = typeof args[args.length - 1] === 'boolean' ? args.pop() : false;
+        const copy = isBooleanParam(args[args.length - 1]) ? resolveParam(args.pop()) : false;
         // translate(x, y?, z?)
-        if (typeof args[0] === 'number') {
-            const x = args[0];
-            const y = args[1] ?? 0;
-            const z = args[2] ?? 0;
+        if (isNumberParam(args[0])) {
+            const x = resolveParam(args[0]);
+            const y = isNumberParam(args[1]) ? resolveParam(args[1]) : 0;
+            const z = isNumberParam(args[2]) ? resolveParam(args[2]) : 0;
             const vertex = Vertex.fromPoint(new Point(x, y, z));
             const lazyVertex = LazyVertex.fromVertex(vertex);
             const translate = new Translate(lazyVertex, copy, ...targets);

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

@@ -115,7 +115,7 @@ export class Arc extends GeometrySceneObject {
         this.setTangent(new Point2D(tx, ty));
         this.setState('start', Vertex.fromPoint2D(startPt));
         this.setState('end', Vertex.fromPoint2D(endPt));
-        const centerVertex = Vertex.fromPoint2D(centerPt);
+        const centerVertex = Vertex.fromPoint(center);
         centerVertex.markAsMetaShape();
         this.addShape(centerVertex);
         this.addShape(edge);
@@ -161,7 +161,7 @@ export class Arc extends GeometrySceneObject {
         this.setTangent(new Point2D(endTx, endTy));
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(targetPoint));
-        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        const centerVertex = Vertex.fromPoint(center);
         centerVertex.markAsMetaShape();
         this.addShape(centerVertex);
         this.addShape(edge);
@@ -209,7 +209,7 @@ export class Arc extends GeometrySceneObject {
         this.setTangent(new Point2D(endTx, endTy));
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(targetPoint));
-        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        const centerVertex = Vertex.fromPoint(center);
         centerVertex.markAsMetaShape();
         this.addShape(centerVertex);
         this.addShape(edge);
@@ -269,7 +269,7 @@ export class Arc extends GeometrySceneObject {
         this.setTangent(new Point2D(tx, ty));
         this.setState('start', Vertex.fromPoint2D(startPt));
         this.setState('end', Vertex.fromPoint2D(endPt));
-        const centerVertex = Vertex.fromPoint2D(actualCenter);
+        const centerVertex = Vertex.fromPoint(plane.localToWorld(actualCenter));
         centerVertex.markAsMetaShape();
         this.addShape(centerVertex);
         this.addShape(edge);
@@ -317,7 +317,7 @@ export class Arc extends GeometrySceneObject {
         const edge = Geometry.makeEdgeFromCurve(arc);
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(endPoint));
-        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        const centerVertex = Vertex.fromPoint(center);
         centerVertex.markAsMetaShape();
         this.addShape(centerVertex);
         const sign = cw ? -1 : 1;

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

@@ -11,16 +11,20 @@ export class BezierCurve extends GeometrySceneObject {
         this.controlPoints = controlPoints;
     }
     build() {
-        if (this.controlPoints.length === 0) {
+        const points = this.controlPoints.map(cp => cp.asPoint2D());
+        if (points.length < 2) {
+            // 0 args: interactive placeholder. 1 arg: start placed, no curve yet.
+            if (points.length === 1) {
+                this.setState('start', Vertex.fromPoint2D(points[0]));
+                this.setCurrentPosition(points[0]);
+            }
             return;
         }
         const plane = this.sketch.getPlane();
-        const currentPos = this.getCurrentPosition();
-        const points = this.controlPoints.map(cp => cp.asPoint2D());
-        // Poles: [currentPos (start), ...controlPoints, endPoint]
-        // All args are in order: control points then endpoint (last arg)
-        const poles2D = [currentPos, ...points];
-        const polesWorld = poles2D.map(p => plane.localToWorld(p));
+        const startPoint = points[0];
+        const endPoint = points[points.length - 1];
+        // Poles: all args in order — first is start, last is endpoint, middle are controls.
+        const polesWorld = points.map(p => plane.localToWorld(p));
         const bezierCurve = Geometry.makeBezierCurve(polesWorld);
         // Compute tangent at endpoint before creating the edge
         const oc = getOC();
@@ -29,11 +33,9 @@ export class BezierCurve extends GeometrySceneObject {
         bezierCurve.D1(bezierCurve.LastParameter(), gpP, gpV);
         const tangentWorld = Convert.toVector3d(gpV, true);
         gpP.delete();
-        // Project tangent to 2D sketch coordinates
         const tangent2D = new Point2D(tangentWorld.dot(plane.xDirection), tangentWorld.dot(plane.yDirection)).normalize();
         const edge = Geometry.makeEdgeFromBezier(bezierCurve);
-        const endPoint = points[points.length - 1];
-        this.setState('start', Vertex.fromPoint2D(currentPos));
+        this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(endPoint));
         this.addShape(edge);
         this.setTangent(tangent2D);
@@ -63,14 +65,12 @@ export class BezierCurve extends GeometrySceneObject {
         return `bezier-${this.controlPoints.length}`;
     }
     serialize() {
-        const startPos = this.getCurrentPosition();
-        const resolved = this.controlPoints.map(cp => {
-            const p = cp.asPoint2D();
-            return [p.x, p.y];
-        });
+        const points = this.controlPoints.map(cp => cp.asPoint2D());
+        const start = points[0];
+        const resolved = points.slice(1).map(p => [p.x, p.y]);
         return {
             controlPoints: this.controlPoints,
-            startPoint: [startPos.x, startPos.y],
+            startPoint: start ? [start.x, start.y] : null,
             resolvedPoints: resolved,
         };
     }

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

@@ -1,4 +1,5 @@
 import { Geometry } from "../../oc/geometry.js";
+import { Vertex } from "../../common/vertex.js";
 import { ExtrudableGeometryBase } from "./extrudable-base.js";
 export class Circle extends ExtrudableGeometryBase {
     diameter;
@@ -21,6 +22,9 @@ export class Circle extends ExtrudableGeometryBase {
         const circle = Geometry.makeCircle(plane.localToWorld(center), radius, plane.normal);
         let edge = Geometry.makeEdgeFromCircle(circle);
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(center);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         if (this.sketch) {
             this.setCurrentPosition(center);
         }

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

@@ -1,4 +1,5 @@
 import { Geometry } from "../../oc/geometry.js";
+import { Vertex } from "../../common/vertex.js";
 import { ExtrudableGeometryBase } from "./extrudable-base.js";
 export class Ellipse extends ExtrudableGeometryBase {
     rx;
@@ -29,6 +30,9 @@ export class Ellipse extends ExtrudableGeometryBase {
         const majorAxisDir = rxIsMajor ? plane.xDirection : plane.yDirection;
         const edge = Geometry.makeEllipseEdge(plane.localToWorld(center), major, minor, plane.normal, majorAxisDir);
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(center);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         if (this.sketch) {
             this.setCurrentPosition(center);
         }

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

@@ -6,8 +6,10 @@ export declare class HorizontalLine extends GeometrySceneObject implements IHLin
     distanceOrTarget: number | SceneObject;
     private targetPlane;
     private _centered;
+    private _hasExplicitStart;
     constructor(distanceOrTarget: number | SceneObject, targetPlane?: PlaneObjectBase);
     centered(value?: boolean): this;
+    setHasExplicitStart(value?: boolean): this;
     build(): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
@@ -17,5 +19,6 @@ export declare class HorizontalLine extends GeometrySceneObject implements IHLin
     serialize(): {
         distance: number;
         centered: boolean;
+        hasExplicitStart: boolean;
     };
 }

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

@@ -8,6 +8,7 @@ export class HorizontalLine extends GeometrySceneObject {
     distanceOrTarget;
     targetPlane;
     _centered = false;
+    _hasExplicitStart = false;
     constructor(distanceOrTarget, targetPlane = null) {
         super();
         this.distanceOrTarget = distanceOrTarget;
@@ -17,6 +18,10 @@ export class HorizontalLine extends GeometrySceneObject {
         this._centered = value;
         return this;
     }
+    setHasExplicitStart(value = true) {
+        this._hasExplicitStart = value;
+        return this;
+    }
     build() {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         const currentPos = this.targetPlane
@@ -78,6 +83,7 @@ export class HorizontalLine extends GeometrySceneObject {
             : this.distanceOrTarget;
         const copy = new HorizontalLine(distanceOrTarget, targetPlane);
         copy.centered(this._centered);
+        copy._hasExplicitStart = this._hasExplicitStart;
         return copy;
     }
     compareTo(other) {
@@ -104,7 +110,7 @@ export class HorizontalLine extends GeometrySceneObject {
         else if (this.distanceOrTarget !== other.distanceOrTarget) {
             return false;
         }
-        return this._centered === other._centered;
+        return this._centered === other._centered && this._hasExplicitStart === other._hasExplicitStart;
     }
     getType() {
         return 'line';
@@ -115,7 +121,8 @@ export class HorizontalLine extends GeometrySceneObject {
     serialize() {
         return {
             distance: typeof this.distanceOrTarget === 'number' ? this.distanceOrTarget : null,
-            centered: this._centered
+            centered: this._centered,
+            hasExplicitStart: this._hasExplicitStart,
         };
     }
 }

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

@@ -5,7 +5,9 @@ import { GeometrySceneObject } from "./geometry.js";
 export declare class LineTo extends GeometrySceneObject {
     endPoint: LazyVertex;
     private targetPlane;
+    private _hasExplicitStart;
     constructor(endPoint: LazyVertex, targetPlane?: PlaneObjectBase);
+    setHasExplicitStart(value?: boolean): this;
     build(): void;
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: LineTo): boolean;
@@ -13,5 +15,6 @@ export declare class LineTo extends GeometrySceneObject {
     getUniqueType(): string;
     serialize(): {
         end: LazyVertex;
+        hasExplicitStart: boolean;
     };
 }

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

@@ -4,11 +4,16 @@ import { GeometrySceneObject } from "./geometry.js";
 export class LineTo extends GeometrySceneObject {
     endPoint;
     targetPlane;
+    _hasExplicitStart = false;
     constructor(endPoint, targetPlane = null) {
         super();
         this.endPoint = endPoint;
         this.targetPlane = targetPlane;
     }
+    setHasExplicitStart(value = true) {
+        this._hasExplicitStart = value;
+        return this;
+    }
     build() {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         const targetPoint = this.endPoint.asPoint2D();
@@ -32,7 +37,9 @@ export class LineTo extends GeometrySceneObject {
     }
     createCopy(remap) {
         const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
-        return new LineTo(this.endPoint, targetPlane);
+        const copy = new LineTo(this.endPoint, targetPlane);
+        copy._hasExplicitStart = this._hasExplicitStart;
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof LineTo)) {
@@ -47,7 +54,7 @@ export class LineTo extends GeometrySceneObject {
         if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
             return false;
         }
-        return this.endPoint.compareTo(other.endPoint);
+        return this.endPoint.compareTo(other.endPoint) && this._hasExplicitStart === other._hasExplicitStart;
     }
     getType() {
         return 'line';
@@ -57,7 +64,8 @@ export class LineTo extends GeometrySceneObject {
     }
     serialize() {
         return {
-            end: this.endPoint
+            end: this.endPoint,
+            hasExplicitStart: this._hasExplicitStart,
         };
     }
 }

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

@@ -87,7 +87,11 @@ export class Sketch extends SceneObject {
             if (pos) {
                 if (remaining === 0) {
                     for (let j = i; j >= 0; j--) {
-                        const t = previous[j].getTangent();
+                        const prev = previous[j];
+                        if (!(prev instanceof GeometrySceneObject)) {
+                            continue;
+                        }
+                        const t = prev.getTangent();
                         if (t) {
                             return { position: pos, tangent: t };
                         }

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

@@ -1,13 +1,17 @@
 import { SceneObject } from "../../common/scene-object.js";
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { ExtrudableGeometryBase } from "./extrudable-base.js";
+import { LazyVertex } from "../lazy-vertex.js";
 import { ISlot } from "../../core/interfaces.js";
 export declare class Slot extends ExtrudableGeometryBase implements ISlot {
     distance: number;
     radius: number;
     private _center;
     private _angle;
+    private _startPoint;
+    private _endPoint;
     constructor(distance: number, radius: number, targetPlane?: PlaneObjectBase);
+    static fromTwoPoints(start: LazyVertex, end: LazyVertex, radius: number, targetPlane?: PlaneObjectBase | null): Slot;
     centered(value?: boolean): this;
     rotate(angle: number): this;
     build(): void;
@@ -20,5 +24,6 @@ export declare class Slot extends ExtrudableGeometryBase implements ISlot {
         radius: number;
         centered: boolean;
         angle: number;
+        hasTwoPoints: boolean;
     };
 }