fluidcad 0.0.34 → 0.0.35

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

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

@@ -1,5 +1,6 @@
 import { Point2D } from "../../math/point.js";
 import { Geometry } from "../../oc/geometry.js";
+import { Vertex } from "../../common/vertex.js";
 import { rad } from "../../helpers/math-helpers.js";
 import { ExtrudableGeometryBase } from "./extrudable-base.js";
 export class Slot extends ExtrudableGeometryBase {
@@ -7,11 +8,19 @@ export class Slot extends ExtrudableGeometryBase {
     radius;
     _center = false;
     _angle = 0;
+    _startPoint = null;
+    _endPoint = null;
     constructor(distance, radius, targetPlane = null) {
         super(targetPlane);
         this.distance = distance;
         this.radius = radius;
     }
+    static fromTwoPoints(start, end, radius, targetPlane = null) {
+        const slot = new Slot(0, radius, targetPlane);
+        slot._startPoint = start;
+        slot._endPoint = end;
+        return slot;
+    }
     centered(value = true) {
         this._center = value;
         return this;
@@ -21,21 +30,28 @@ export class Slot extends ExtrudableGeometryBase {
         return this;
     }
     build() {
-        if (this.distance < 0) {
-            throw new Error("Slot distance must be positive");
+        if (this._startPoint && this._endPoint) {
+            const s = this._startPoint.asPoint2D();
+            const e = this._endPoint.asPoint2D();
+            const dx = e.x - s.x;
+            const dy = e.y - s.y;
+            this.distance = Math.sqrt(dx * dx + dy * dy);
+            this._angle = Math.atan2(dy, dx) * 180 / Math.PI;
         }
+        const absDistance = Math.abs(this.distance);
+        const flipAngle = this.distance < 0 ? 180 : 0;
         const plane = this.targetPlane?.getPlane() || this.getParent().getPlane();
         const localToWorld = plane.localToWorld.bind(plane);
         let leftCenter = this.targetPlane
             ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
             : this.getCurrentPosition();
         if (this._center) {
-            const angleRad = rad(this._angle);
+            const angleRad = rad(this._angle + flipAngle);
             const cos = Math.cos(angleRad);
             const sin = Math.sin(angleRad);
-            leftCenter = leftCenter.translate(-this.distance / 2 * cos, -this.distance / 2 * sin);
+            leftCenter = leftCenter.translate(-absDistance / 2 * cos, -absDistance / 2 * sin);
         }
-        const angleRad = rad(this._angle);
+        const angleRad = rad(this._angle + flipAngle);
         const cos = Math.cos(angleRad);
         const sin = Math.sin(angleRad);
         // Direction along the slot axis
@@ -44,7 +60,7 @@ export class Slot extends ExtrudableGeometryBase {
         // Perpendicular direction (90 degrees CCW)
         const perpX = -sin;
         const perpY = cos;
-        const rightCenter = new Point2D(leftCenter.x + this.distance * dirX, leftCenter.y + this.distance * dirY);
+        const rightCenter = new Point2D(leftCenter.x + absDistance * dirX, leftCenter.y + absDistance * dirY);
         // Four key points where lines meet arcs
         const topLeft = new Point2D(leftCenter.x + this.radius * perpX, leftCenter.y + this.radius * perpY);
         const topRight = new Point2D(rightCenter.x + this.radius * perpX, rightCenter.y + this.radius * perpY);
@@ -65,6 +81,12 @@ export class Slot extends ExtrudableGeometryBase {
             Geometry.makeEdgeFromCurve(leftArc),
         ];
         this.addShapes(edges);
+        const leftCenterVertex = Vertex.fromPoint2D(leftCenter);
+        leftCenterVertex.markAsMetaShape();
+        this.addShape(leftCenterVertex);
+        const rightCenterVertex = Vertex.fromPoint2D(rightCenter);
+        rightCenterVertex.markAsMetaShape();
+        this.addShape(rightCenterVertex);
         if (this.sketch) {
             if (this._center) {
                 this.setCurrentPosition(this.getCurrentPosition());
@@ -85,7 +107,13 @@ export class Slot extends ExtrudableGeometryBase {
     }
     createCopy(remap) {
         const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
-        const s = new Slot(this.distance, this.radius, targetPlane);
+        let s;
+        if (this._startPoint && this._endPoint) {
+            s = Slot.fromTwoPoints(this._startPoint, this._endPoint, this.radius, targetPlane);
+        }
+        else {
+            s = new Slot(this.distance, this.radius, targetPlane);
+        }
         s.centered(this._center);
         s.rotate(this._angle);
         return s;
@@ -103,6 +131,22 @@ export class Slot extends ExtrudableGeometryBase {
         if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
             return false;
         }
+        if ((this._startPoint === null) !== (other._startPoint === null)) {
+            return false;
+        }
+        if ((this._endPoint === null) !== (other._endPoint === null)) {
+            return false;
+        }
+        if (this._startPoint && other._startPoint && !this._startPoint.compareTo(other._startPoint)) {
+            return false;
+        }
+        if (this._endPoint && other._endPoint && !this._endPoint.compareTo(other._endPoint)) {
+            return false;
+        }
+        if (this._startPoint && this._endPoint) {
+            return this.radius === other.radius &&
+                this._center === other._center;
+        }
         return this.distance === other.distance &&
             this.radius === other.radius &&
             this._center === other._center &&
@@ -114,6 +158,7 @@ export class Slot extends ExtrudableGeometryBase {
             radius: this.radius,
             centered: this._center,
             angle: this._angle,
+            hasTwoPoints: this._startPoint !== null && this._endPoint !== null,
         };
     }
 }

package/lib/dist/features/2d/tarc-to-point-tangent.js

@@ -60,6 +60,9 @@ export class TangentArcToPointTangent extends GeometrySceneObject {
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(targetPoint));
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.setCurrentPosition(targetPoint);
     }
     createCopy(remap) {

package/lib/dist/features/2d/tarc-to-point.js

@@ -58,6 +58,9 @@ export class TangentArcToPoint extends GeometrySceneObject {
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(targetPoint));
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.setCurrentPosition(targetPoint);
     }
     createCopy(remap) {

package/lib/dist/features/2d/tarc-with-tangent.js

@@ -44,6 +44,9 @@ export class TangentArcWithTangent extends GeometrySceneObject {
         const ty = sign * Math.cos(endAngleRad);
         this.setTangent(new Point2D(tx, ty));
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.setCurrentPosition(endPoint);
     }
     createCopy(remap) {

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

@@ -46,6 +46,9 @@ export class TangentArc extends GeometrySceneObject {
         const ty = sign * Math.cos(endAngleRad);
         this.setTangent(new Point2D(tx, ty));
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.setCurrentPosition(endPoint);
     }
     createCopy(remap) {

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

@@ -6,8 +6,10 @@ export declare class VerticalLine extends GeometrySceneObject implements IVLine
     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 VerticalLine extends GeometrySceneObject implements IVLine
     serialize(): {
         distance: number;
         centered: boolean;
+        hasExplicitStart: boolean;
     };
 }