fluidcad 0.0.33 → 0.0.35

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

@@ -16,6 +16,8 @@ export class Arc extends GeometrySceneObject {
     _bulgeRadius = 0;
     _centerPoint = null;
     _centered = false;
+    _clockwise = false;
+    _major = false;
     _targetPlane;
     constructor(targetPlane = null) {
         super();
@@ -39,6 +41,13 @@ export class Arc extends GeometrySceneObject {
         arc._endAngle = endAngle;
         return arc;
     }
+    static circumcenter(a, b, c) {
+        const D = 2 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
+        const aa = a.x * a.x + a.y * a.y;
+        const bb = b.x * b.x + b.y * b.y;
+        const cc = c.x * c.x + c.y * c.y;
+        return new Point2D((aa * (b.y - c.y) + bb * (c.y - a.y) + cc * (a.y - b.y)) / D, (aa * (c.x - b.x) + bb * (a.x - c.x) + cc * (b.x - a.x)) / D);
+    }
     // Chainable methods (IArc)
     radius(value) {
         this._bulgeRadius = value;
@@ -52,6 +61,14 @@ export class Arc extends GeometrySceneObject {
         this._centered = true;
         return this;
     }
+    cw() {
+        this._clockwise = true;
+        return this;
+    }
+    major() {
+        this._major = true;
+        return this;
+    }
     build() {
         if (this._startPoint && this._endPoint) {
             // Two explicit points: default center = current position
@@ -81,21 +98,26 @@ export class Arc extends GeometrySceneObject {
         const endPt = this._endPoint.asPoint2D();
         const centerPt = this._centerPoint
             ? this._centerPoint.asPoint2D()
-            : this.getCurrentPosition();
+            : new Point2D((startPt.x + endPt.x) / 2, (startPt.y + endPt.y) / 2);
         const dx = startPt.x - centerPt.x;
         const dy = startPt.y - centerPt.y;
         const radius = Math.sqrt(dx * dx + dy * dy);
         const endAngle = Math.atan2(endPt.y - centerPt.y, endPt.x - centerPt.x);
+        const normal = this._clockwise ? plane.normal.negate() : plane.normal;
         const center = plane.localToWorld(centerPt);
         const start = plane.localToWorld(startPt);
         const end = plane.localToWorld(endPt);
-        const arc = Geometry.makeArc(center, radius, plane.normal, start, end);
+        const arc = Geometry.makeArc(center, radius, normal, start, end);
         const edge = Geometry.makeEdgeFromCurve(arc);
-        const tx = -Math.sin(endAngle);
-        const ty = Math.cos(endAngle);
+        const sign = this._clockwise ? -1 : 1;
+        const tx = sign * (-Math.sin(endAngle));
+        const ty = sign * Math.cos(endAngle);
         this.setTangent(new Point2D(tx, ty));
         this.setState('start', Vertex.fromPoint2D(startPt));
         this.setState('end', Vertex.fromPoint2D(endPt));
+        const centerVertex = Vertex.fromPoint(center);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.addShape(edge);
         if (this.sketch) {
             this.setCurrentPosition(endPt);
@@ -129,14 +151,19 @@ export class Arc extends GeometrySceneObject {
         const center = plane.localToWorld(centerPoint);
         const start = plane.localToWorld(startPoint);
         const end = plane.localToWorld(targetPoint);
-        const arc = Geometry.makeArc(center, r, normal, start, end);
+        const arc = this._major
+            ? this.makeMajorArc(startPoint, targetPoint, centerPoint, cw, plane)
+            : Geometry.makeArc(center, r, normal, start, end);
         const edge = Geometry.makeEdgeFromCurve(arc);
-        const signT = cw ? -1 : 1;
+        const signT = (cw ? -1 : 1) * (this._major ? -1 : 1);
         const endTx = signT * (-Math.sin(endAngle));
         const endTy = signT * Math.cos(endAngle);
         this.setTangent(new Point2D(endTx, endTy));
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(targetPoint));
+        const centerVertex = Vertex.fromPoint(center);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.addShape(edge);
         if (this.sketch) {
             this.setCurrentPosition(targetPoint);
@@ -172,14 +199,19 @@ export class Arc extends GeometrySceneObject {
         const center = plane.localToWorld(centerPoint);
         const start = plane.localToWorld(startPoint);
         const end = plane.localToWorld(targetPoint);
-        const arc = Geometry.makeArc(center, r, normal, start, end);
+        const arc = this._major
+            ? this.makeMajorArc(startPoint, targetPoint, centerPoint, cw, plane)
+            : Geometry.makeArc(center, r, normal, start, end);
         const edge = Geometry.makeEdgeFromCurve(arc);
-        const signT = cw ? -1 : 1;
+        const signT = (cw ? -1 : 1) * (this._major ? -1 : 1);
         const endTx = signT * (-Math.sin(endAngle));
         const endTy = signT * Math.cos(endAngle);
         this.setTangent(new Point2D(endTx, endTy));
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(targetPoint));
+        const centerVertex = Vertex.fromPoint(center);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.addShape(edge);
         if (this.sketch) {
             this.setCurrentPosition(targetPoint);
@@ -188,6 +220,24 @@ export class Arc extends GeometrySceneObject {
             this._targetPlane.removeShapes(this);
         }
     }
+    makeMajorArc(startPoint2D, endPoint2D, centerPoint2D, cw, plane) {
+        const startAngleRad = Math.atan2(startPoint2D.y - centerPoint2D.y, startPoint2D.x - centerPoint2D.x);
+        const endAngleRad = Math.atan2(endPoint2D.y - centerPoint2D.y, endPoint2D.x - centerPoint2D.x);
+        let minorSweep = cw ? startAngleRad - endAngleRad : endAngleRad - startAngleRad;
+        if (minorSweep <= 0) {
+            minorSweep += 2 * Math.PI;
+        }
+        const midAngle = cw
+            ? startAngleRad + (2 * Math.PI - minorSweep) / 2
+            : startAngleRad - (2 * Math.PI - minorSweep) / 2;
+        const r = Math.sqrt((startPoint2D.x - centerPoint2D.x) ** 2 +
+            (startPoint2D.y - centerPoint2D.y) ** 2);
+        const midPoint2D = new Point2D(centerPoint2D.x + r * Math.cos(midAngle), centerPoint2D.y + r * Math.sin(midAngle));
+        const start = plane.localToWorld(startPoint2D);
+        const mid = plane.localToWorld(midPoint2D);
+        const end = plane.localToWorld(endPoint2D);
+        return Geometry.makeArcThreePoints(start, mid, end);
+    }
     buildWithCenter() {
         const plane = this._targetPlane?.getPlane() || this.sketch.getPlane();
         const startPt = this._targetPlane
@@ -195,20 +245,33 @@ export class Arc extends GeometrySceneObject {
             : this.getCurrentPosition();
         const endPt = this._endPoint.asPoint2D();
         const centerPt = this._centerPoint.asPoint2D();
-        const dx = startPt.x - centerPt.x;
-        const dy = startPt.y - centerPt.y;
-        const radius = Math.sqrt(dx * dx + dy * dy);
-        const endAngle = Math.atan2(endPt.y - centerPt.y, endPt.x - centerPt.x);
-        const center = plane.localToWorld(centerPt);
+        const aStart = Math.atan2(startPt.y - centerPt.y, startPt.x - centerPt.x);
+        const aEnd = Math.atan2(endPt.y - centerPt.y, endPt.x - centerPt.x);
+        let sweep = this._clockwise ? aStart - aEnd : aEnd - aStart;
+        if (sweep <= 0) {
+            sweep += 2 * Math.PI;
+        }
+        const midAngle = this._clockwise ? aStart - sweep / 2 : aStart + sweep / 2;
+        const rStart = Math.sqrt((startPt.x - centerPt.x) ** 2 + (startPt.y - centerPt.y) ** 2);
+        const rEnd = Math.sqrt((endPt.x - centerPt.x) ** 2 + (endPt.y - centerPt.y) ** 2);
+        const rMid = (rStart + rEnd) / 2;
+        const midPt = new Point2D(centerPt.x + rMid * Math.cos(midAngle), centerPt.y + rMid * Math.sin(midAngle));
+        const actualCenter = Arc.circumcenter(startPt, midPt, endPt);
+        const endAngle = Math.atan2(endPt.y - actualCenter.y, endPt.x - actualCenter.x);
         const start = plane.localToWorld(startPt);
         const end = plane.localToWorld(endPt);
-        const arc = Geometry.makeArc(center, radius, plane.normal, start, end);
+        const mid = plane.localToWorld(midPt);
+        const arc = Geometry.makeArcThreePoints(start, mid, end);
         const edge = Geometry.makeEdgeFromCurve(arc);
-        const tx = -Math.sin(endAngle);
-        const ty = Math.cos(endAngle);
+        const sign = this._clockwise ? -1 : 1;
+        const tx = sign * (-Math.sin(endAngle));
+        const ty = sign * Math.cos(endAngle);
         this.setTangent(new Point2D(tx, ty));
         this.setState('start', Vertex.fromPoint2D(startPt));
         this.setState('end', Vertex.fromPoint2D(endPt));
+        const centerVertex = Vertex.fromPoint(plane.localToWorld(actualCenter));
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.addShape(edge);
         if (this.sketch) {
             this.setCurrentPosition(endPt);
@@ -254,6 +317,9 @@ 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.fromPoint(center);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         const sign = cw ? -1 : 1;
         const tx = sign * (-Math.sin(endAngleRad));
         const ty = sign * Math.cos(endAngleRad);
@@ -286,6 +352,8 @@ export class Arc extends GeometrySceneObject {
         copy._bulgeRadius = this._bulgeRadius;
         copy._centerPoint = this._centerPoint;
         copy._centered = this._centered;
+        copy._clockwise = this._clockwise;
+        copy._major = this._major;
         return copy;
     }
     compareTo(other) {
@@ -301,6 +369,9 @@ export class Arc extends GeometrySceneObject {
         if (this._targetPlane && other._targetPlane && !this._targetPlane.compareTo(other._targetPlane)) {
             return false;
         }
+        if (this._clockwise !== other._clockwise) {
+            return false;
+        }
         if (this._endPoint && other._endPoint) {
             if (!this._endPoint.compareTo(other._endPoint)) {
                 return false;
@@ -316,7 +387,7 @@ export class Arc extends GeometrySceneObject {
             if (this._centerPoint && other._centerPoint) {
                 return this._centerPoint.compareTo(other._centerPoint);
             }
-            return this._bulgeRadius === other._bulgeRadius;
+            return this._bulgeRadius === other._bulgeRadius && this._major === other._major;
         }
         if (!this._endPoint && !other._endPoint) {
             return this._arcRadius === other._arcRadius &&
@@ -340,6 +411,12 @@ export class Arc extends GeometrySceneObject {
             if (this._bulgeRadius !== 0) {
                 base.radius = this._bulgeRadius;
             }
+            if (this._clockwise) {
+                base.clockwise = true;
+            }
+            if (this._major) {
+                base.major = true;
+            }
             return base;
         }
         return {

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

@@ -9,8 +9,9 @@ export class Back extends GeometrySceneObject {
         return 'back';
     }
     build() {
-        const target = this.sketch.getPreviousPosition(this, this.count);
-        this.setCurrentPosition(target);
+        const { position, tangent } = this.sketch.getPreviousState(this, this.count);
+        this.setCurrentPosition(position);
+        this.setTangent(tangent);
     }
     getDependencies() {
         return [];

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.d.ts

@@ -15,6 +15,10 @@ export declare class Sketch extends SceneObject implements Extrudable {
     getTangentAt(currentObj: GeometrySceneObject): Point2D;
     getPositionAt(currentObj: GeometrySceneObject): Point2D;
     getPreviousPosition(currentObj: GeometrySceneObject, count?: number): Point2D;
+    getPreviousState(currentObj: GeometrySceneObject, count?: number): {
+        position: Point2D;
+        tangent: Point2D;
+    };
     getLastPosition(scope?: Set<SceneObject>): Point2D;
     build(context?: BuildSceneObjectContext): void;
     getEdges(): Edge[];

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

@@ -78,6 +78,31 @@ export class Sketch extends SceneObject {
         }
         return this.getStartPoint();
     }
+    getPreviousState(currentObj, count = 1) {
+        const children = this.getChildren();
+        const previous = children.slice(0, children.indexOf(currentObj));
+        let remaining = count;
+        for (let i = previous.length - 1; i >= 0; i--) {
+            const pos = previous[i].getState('current-position');
+            if (pos) {
+                if (remaining === 0) {
+                    for (let j = i; j >= 0; j--) {
+                        const prev = previous[j];
+                        if (!(prev instanceof GeometrySceneObject)) {
+                            continue;
+                        }
+                        const t = prev.getTangent();
+                        if (t) {
+                            return { position: pos, tangent: t };
+                        }
+                    }
+                    return { position: pos, tangent: new Point2D(1, 0) };
+                }
+                remaining--;
+            }
+        }
+        return { position: this.getStartPoint(), tangent: new Point2D(1, 0) };
+    }
     getLastPosition(scope) {
         let children = this.getChildren().slice();
         if (scope) {

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