fluidcad 0.0.2

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

@@ -0,0 +1,119 @@
+import { Point2D } from "../../math/point.js";
+import { Geometry } from "../../oc/geometry.js";
+import { rad } from "../../helpers/math-helpers.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export class Slot extends ExtrudableGeometryBase {
+    distance;
+    radius;
+    _center = false;
+    _angle = 0;
+    constructor(distance, radius, targetPlane = null) {
+        super(targetPlane);
+        this.distance = distance;
+        this.radius = radius;
+    }
+    center(value = true) {
+        this._center = value;
+        return this;
+    }
+    rotate(angle) {
+        this._angle = angle;
+        return this;
+    }
+    build() {
+        if (this.distance < 0) {
+            throw new Error("Slot distance must be positive");
+        }
+        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 cos = Math.cos(angleRad);
+            const sin = Math.sin(angleRad);
+            leftCenter = leftCenter.translate(-this.distance / 2 * cos, -this.distance / 2 * sin);
+        }
+        const angleRad = rad(this._angle);
+        const cos = Math.cos(angleRad);
+        const sin = Math.sin(angleRad);
+        // Direction along the slot axis
+        const dirX = cos;
+        const dirY = sin;
+        // 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);
+        // 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);
+        const bottomRight = new Point2D(rightCenter.x - this.radius * perpX, rightCenter.y - this.radius * perpY);
+        const bottomLeft = new Point2D(leftCenter.x - this.radius * perpX, leftCenter.y - this.radius * perpY);
+        // Top line: topLeft -> topRight
+        const topSegment = Geometry.makeSegment(localToWorld(topLeft), localToWorld(topRight));
+        // Right arc: topRight -> bottomRight (CW semicircle around rightCenter)
+        const rightArc = Geometry.makeArc(localToWorld(rightCenter), this.radius, plane.normal.negate(), localToWorld(topRight), localToWorld(bottomRight));
+        // Bottom line: bottomRight -> bottomLeft
+        const bottomSegment = Geometry.makeSegment(localToWorld(bottomRight), localToWorld(bottomLeft));
+        // Left arc: bottomLeft -> topLeft (CW semicircle around leftCenter)
+        const leftArc = Geometry.makeArc(localToWorld(leftCenter), this.radius, plane.normal.negate(), localToWorld(bottomLeft), localToWorld(topLeft));
+        const edges = [
+            Geometry.makeEdge(topSegment),
+            Geometry.makeEdgeFromCurve(rightArc),
+            Geometry.makeEdge(bottomSegment),
+            Geometry.makeEdgeFromCurve(leftArc),
+        ];
+        this.addShapes(edges);
+        if (this.sketch) {
+            if (this._center) {
+                this.setCurrentPosition(this.getCurrentPosition());
+            }
+            else {
+                this.setCurrentPosition(leftCenter);
+            }
+        }
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+    }
+    getType() {
+        return 'slot';
+    }
+    getDependencies() {
+        return this.targetPlane ? [this.targetPlane] : [];
+    }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        const s = new Slot(this.distance, this.radius, targetPlane);
+        s.center(this._center);
+        s.rotate(this._angle);
+        return s;
+    }
+    compareTo(other) {
+        if (!(other instanceof Slot)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        return this.distance === other.distance &&
+            this.radius === other.radius &&
+            this._center === other._center &&
+            this._angle === other._angle;
+    }
+    serialize() {
+        return {
+            distance: this.distance,
+            radius: this.radius,
+            center: this._center,
+            angle: this._angle,
+        };
+    }
+}

package/lib/dist/features/2d/tarc-constrained.d.ts

@@ -0,0 +1,20 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { LazyVertex } from "../lazy-vertex.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+import { ITangentArcTwoObjects } from "../../core/interfaces.js";
+export declare class TangentArcTwoObjects extends GeometrySceneObject implements ITangentArcTwoObjects {
+    c1: QualifiedSceneObject;
+    c2: QualifiedSceneObject;
+    radius: number;
+    mustTouch: boolean;
+    constructor(c1: QualifiedSceneObject, c2: QualifiedSceneObject, radius: number, mustTouch: boolean);
+    build(): void;
+    start(index?: number): LazyVertex;
+    end(index?: number): LazyVertex;
+    compareTo(other: TangentArcTwoObjects): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        radius: number;
+    };
+}

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

@@ -0,0 +1,64 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { LazyVertex } from "../lazy-vertex.js";
+import { Vertex } from "../../common/vertex.js";
+import { createConstraintSolver } from "../../oc/constraints/create-solver.js";
+export class TangentArcTwoObjects extends GeometrySceneObject {
+    c1;
+    c2;
+    radius;
+    mustTouch;
+    constructor(c1, c2, radius, mustTouch) {
+        super();
+        this.c1 = c1;
+        this.c2 = c2;
+        this.radius = radius;
+        this.mustTouch = mustTouch;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        const solver = createConstraintSolver(this.mustTouch);
+        const results = solver.getTangentArcs(plane, this.c1.toQualifiedShape(), this.c2.toQualifiedShape(), this.radius);
+        for (let i = 0; i < results.edges.length; i++) {
+            this.setState(`edge-${i}`, results.edges[i]);
+        }
+        if (results.edges.length > 0) {
+            const lastEdge = results.edges[results.edges.length - 1];
+            const endTangent = results.endTangent;
+            const firstVertex = lastEdge.getFirstVertex();
+            const lastVertex = lastEdge.getLastVertex();
+            const localStart = plane.worldToLocal(firstVertex.toPoint());
+            const localEnd = plane.worldToLocal(lastVertex.toPoint());
+            this.setState('start', Vertex.fromPoint2D(localStart));
+            this.setState('end', Vertex.fromPoint2D(localEnd));
+            this.setTangent(endTangent);
+            this.setCurrentPosition(localEnd);
+        }
+        this.addShapes(results.edges);
+    }
+    start(index = 0) {
+        return new LazyVertex(this.generateUniqueName(`start-vertex-${index}`), () => [this.getState('start')]);
+    }
+    end(index = 0) {
+        return new LazyVertex(this.generateUniqueName(`end-vertex-${index}`), () => [this.getState('end')]);
+    }
+    compareTo(other) {
+        if (!(other instanceof TangentArcTwoObjects)) {
+            return false;
+        }
+        return this.c1.compareTo(other.c1) &&
+            this.c2.compareTo(other.c2) &&
+            this.radius === other.radius &&
+            this.mustTouch === other.mustTouch;
+    }
+    getType() {
+        return 'tarc';
+    }
+    getUniqueType() {
+        return 'two-objects-tarc';
+    }
+    serialize() {
+        return {
+            radius: this.radius
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { LazyVertex } from "../lazy-vertex.js";
+export declare class TangentArcToPointTangent extends GeometrySceneObject {
+    endPoint: LazyVertex;
+    startTangent: LazyVertex;
+    constructor(endPoint: LazyVertex, startTangent: LazyVertex);
+    build(): void;
+    compareTo(other: TangentArcToPointTangent): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        endPoint: {};
+        startTangent: {};
+    };
+}

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

@@ -0,0 +1,86 @@
+import { Vertex } from "../../common/vertex.js";
+import { Geometry } from "../../oc/geometry.js";
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class TangentArcToPointTangent extends GeometrySceneObject {
+    endPoint;
+    startTangent;
+    constructor(endPoint, startTangent) {
+        super();
+        this.endPoint = endPoint;
+        this.startTangent = startTangent;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        let startPoint = this.getCurrentPosition();
+        let targetPoint = this.endPoint.asPoint2D();
+        let tangent = this.startTangent.asPoint2D();
+        // Normal to start tangent (perpendicular, pointing left for CCW)
+        const norm = tangent.normalize();
+        const perpendicular = new Point2D(-norm.y, norm.x);
+        // Find circle center using perpendicular bisector constraint:
+        // Center lies on perpendicular to tangent through start, equidistant from both points
+        const d = startPoint.subtract(targetPoint);
+        const distSq = startPoint.distanceToSquared(targetPoint);
+        const dDotN = d.x * perpendicular.x + d.y * perpendicular.y;
+        if (Math.abs(dDotN) < 1e-10) {
+            throw new Error('TangentArcToPointTangent: endpoint is collinear with tangent direction');
+        }
+        // Signed parameter: positive = CCW, negative = CW
+        const t = -distSq / (2 * dDotN);
+        const radius = Math.abs(t);
+        const cw = t < 0;
+        const centerPoint = startPoint.add(perpendicular.multiplyScalar(t));
+        // Compute angles on the circle
+        const startAngle = Math.atan2(startPoint.y - centerPoint.y, startPoint.x - centerPoint.x);
+        const endAngle = Math.atan2(targetPoint.y - centerPoint.y, targetPoint.x - centerPoint.x);
+        let sweep = endAngle - startAngle;
+        if (cw) {
+            if (sweep > 0) {
+                sweep -= 2 * Math.PI;
+            }
+        }
+        else {
+            if (sweep < 0) {
+                sweep += 2 * Math.PI;
+            }
+        }
+        const normal = cw ? plane.normal.negate() : plane.normal;
+        const center = plane.localToWorld(centerPoint);
+        const start = plane.localToWorld(startPoint);
+        const end = plane.localToWorld(targetPoint);
+        const arc = Geometry.makeArc(center, radius, normal, start, end);
+        const edge = Geometry.makeEdgeFromCurve(arc);
+        // Tangent at end: perpendicular to radius direction at end point
+        // CCW: (-sin θ, cos θ), CW: (sin θ, -cos θ)
+        const sign = cw ? -1 : 1;
+        const endTx = sign * (-Math.sin(endAngle));
+        const endTy = sign * Math.cos(endAngle);
+        this.setTangent(new Point2D(endTx, endTy));
+        this.setState('start', Vertex.fromPoint2D(startPoint));
+        this.setState('end', Vertex.fromPoint2D(targetPoint));
+        this.addShape(edge);
+        this.setCurrentPosition(targetPoint);
+    }
+    compareTo(other) {
+        if (!(other instanceof TangentArcToPointTangent)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.endPoint.compareTo(other.endPoint) && this.startTangent.compareTo(other.startTangent);
+    }
+    getType() {
+        return 'tarc';
+    }
+    getUniqueType() {
+        return 'tarc-to-point-tangent';
+    }
+    serialize() {
+        return {
+            endPoint: this.endPoint.serialize(),
+            startTangent: this.startTangent.serialize()
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { LazyVertex } from "../lazy-vertex.js";
+export declare class TangentArcToPoint extends GeometrySceneObject {
+    endPoint: LazyVertex;
+    constructor(endPoint: LazyVertex);
+    build(): void;
+    compareTo(other: TangentArcToPoint): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        endPoint: {};
+    };
+}

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

@@ -0,0 +1,86 @@
+import { Vertex } from "../../common/vertex.js";
+import { Geometry } from "../../oc/geometry.js";
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class TangentArcToPoint extends GeometrySceneObject {
+    endPoint;
+    constructor(endPoint) {
+        super();
+        this.endPoint = endPoint;
+    }
+    build() {
+        const tangent = this.sketch.getTangentAt(this);
+        if (!tangent) {
+            throw new Error('TangentArcToPoint requires a previous sibling with a tangent');
+        }
+        const plane = this.sketch.getPlane();
+        const startPoint = this.getCurrentPosition();
+        const targetPoint = this.endPoint.asPoint2D();
+        // Normal to tangent (perpendicular, pointing left for CCW)
+        const norm = tangent.normalize();
+        const perpendicular = new Point2D(-norm.y, norm.x);
+        // Find circle center using perpendicular bisector constraint:
+        // Center lies on perpendicular to tangent through start, equidistant from both points
+        const d = startPoint.subtract(targetPoint);
+        const distSq = startPoint.distanceToSquared(targetPoint);
+        const dDotN = d.x * perpendicular.x + d.y * perpendicular.y;
+        if (Math.abs(dDotN) < 1e-10) {
+            throw new Error('TangentArcToPoint: endpoint is collinear with tangent direction');
+        }
+        // Signed parameter: positive = CCW, negative = CW
+        const t = -distSq / (2 * dDotN);
+        const radius = Math.abs(t);
+        const cw = t < 0;
+        const centerPoint = startPoint.add(perpendicular.multiplyScalar(t));
+        // Compute angles on the circle
+        const startAngle = Math.atan2(startPoint.y - centerPoint.y, startPoint.x - centerPoint.x);
+        const endAngle = Math.atan2(targetPoint.y - centerPoint.y, targetPoint.x - centerPoint.x);
+        let sweep = endAngle - startAngle;
+        if (cw) {
+            if (sweep > 0) {
+                sweep -= 2 * Math.PI;
+            }
+        }
+        else {
+            if (sweep < 0) {
+                sweep += 2 * Math.PI;
+            }
+        }
+        const normal = cw ? plane.normal.negate() : plane.normal;
+        const center = plane.localToWorld(centerPoint);
+        const start = plane.localToWorld(startPoint);
+        const end = plane.localToWorld(targetPoint);
+        const arc = Geometry.makeArc(center, radius, normal, start, end);
+        const edge = Geometry.makeEdgeFromCurve(arc);
+        // Tangent at end: perpendicular to radius direction at end point
+        // CCW: (-sin θ, cos θ), CW: (sin θ, -cos θ)
+        const sign = cw ? -1 : 1;
+        const endTx = sign * (-Math.sin(endAngle));
+        const endTy = sign * Math.cos(endAngle);
+        this.setTangent(new Point2D(endTx, endTy));
+        this.setState('start', Vertex.fromPoint2D(startPoint));
+        this.setState('end', Vertex.fromPoint2D(targetPoint));
+        this.addShape(edge);
+        this.setCurrentPosition(targetPoint);
+    }
+    compareTo(other) {
+        if (!(other instanceof TangentArcToPoint)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.endPoint.compareTo(other.endPoint);
+    }
+    getType() {
+        return 'tarc';
+    }
+    getUniqueType() {
+        return 'tarc-to-point';
+    }
+    serialize() {
+        return {
+            endPoint: this.endPoint.serialize()
+        };
+    }
+}

package/lib/dist/features/2d/tarc-two-circles.d.ts

@@ -0,0 +1,18 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { LazyVertex } from "../lazy-vertex.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+export declare class TangentArcTwoObjects extends GeometrySceneObject {
+    c1: QualifiedSceneObject;
+    c2: QualifiedSceneObject;
+    radius: number;
+    constructor(c1: QualifiedSceneObject, c2: QualifiedSceneObject, radius: number);
+    build(): void;
+    start(index?: number): LazyVertex;
+    end(index?: number): LazyVertex;
+    compareTo(other: TangentArcTwoObjects): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        radius: number;
+    };
+}

package/lib/dist/features/2d/tarc-two-circles.js

@@ -0,0 +1,61 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { LazyVertex } from "../lazy-vertex.js";
+import { Vertex } from "../../common/vertex.js";
+import { createConstraintSolver } from "../../oc/constraints/create-solver.js";
+export class TangentArcTwoObjects extends GeometrySceneObject {
+    c1;
+    c2;
+    radius;
+    constructor(c1, c2, radius) {
+        super();
+        this.c1 = c1;
+        this.c2 = c2;
+        this.radius = radius;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        const solver = createConstraintSolver();
+        const results = solver.getTangentArcs(plane, this.c1.toQualifiedShape(), this.c2.toQualifiedShape(), this.radius);
+        for (let i = 0; i < results.edges.length; i++) {
+            this.setState(`edge-${i}`, results.edges[i]);
+        }
+        if (results.edges.length > 0) {
+            const lastEdge = results.edges[results.edges.length - 1];
+            const endTangent = results.endTangent;
+            const firstVertex = lastEdge.getFirstVertex();
+            const lastVertex = lastEdge.getLastVertex();
+            const localStart = plane.worldToLocal(firstVertex.toPoint());
+            const localEnd = plane.worldToLocal(lastVertex.toPoint());
+            this.setState('start', Vertex.fromPoint2D(localStart));
+            this.setState('end', Vertex.fromPoint2D(localEnd));
+            this.setTangent(endTangent);
+            this.setCurrentPosition(localEnd);
+        }
+        this.addShapes(results.edges);
+    }
+    start(index = 0) {
+        return new LazyVertex(this.generateUniqueName(`start-vertex-${index}`), () => [this.getState('start')]);
+    }
+    end(index = 0) {
+        return new LazyVertex(this.generateUniqueName(`end-vertex-${index}`), () => [this.getState('end')]);
+    }
+    compareTo(other) {
+        if (!(other instanceof TangentArcTwoObjects)) {
+            return false;
+        }
+        return this.c1.compareTo(other.c1) &&
+            this.c2.compareTo(other.c2) &&
+            this.radius === other.radius;
+    }
+    getType() {
+        return 'tarc';
+    }
+    getUniqueType() {
+        return 'two-objects-tarc';
+    }
+    serialize() {
+        return {
+            radius: this.radius
+        };
+    }
+}

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

@@ -0,0 +1,17 @@
+import { LazyVertex } from "../lazy-vertex.js";
+import { GeometrySceneObject } from "./geometry.js";
+export declare class TangentArcWithTangent extends GeometrySceneObject {
+    radius: number;
+    endAngle: number;
+    startTangent: LazyVertex;
+    constructor(radius: number, endAngle: number, startTangent: LazyVertex);
+    build(): void;
+    compareTo(other: TangentArcWithTangent): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        radius: number;
+        endAngle: number;
+        startTangent: {};
+    };
+}

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

@@ -0,0 +1,71 @@
+import { Vertex } from "../../common/vertex.js";
+import { Geometry } from "../../oc/geometry.js";
+import { rad } from "../../helpers/math-helpers.js";
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class TangentArcWithTangent extends GeometrySceneObject {
+    radius;
+    endAngle;
+    startTangent;
+    constructor(radius, endAngle, startTangent) {
+        super();
+        this.radius = radius;
+        this.endAngle = endAngle;
+        this.startTangent = startTangent;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        const radius = this.radius;
+        const tangent = this.startTangent.asPoint2D();
+        // Derive the base angle from the provided tangent.
+        // Tangent at angle θ on a circle is (-sin θ, cos θ),
+        // so θ = atan2(-tx, ty).
+        const baseAngle = Math.atan2(-tangent.x, tangent.y);
+        const clampedEndAngle = Math.max(this.endAngle, -359.9999);
+        const cw = clampedEndAngle < 0;
+        const startAngleRad = cw ? baseAngle + Math.PI : baseAngle;
+        const endAngleRad = startAngleRad + rad(clampedEndAngle);
+        const normal = cw ? plane.normal.negate() : plane.normal;
+        const startPoint = this.getCurrentPosition();
+        const centerPoint = Geometry.getCircleCenter(startPoint, radius, startAngleRad);
+        const endPoint = Geometry.getPointOnCircle(centerPoint, radius, endAngleRad);
+        const center = plane.localToWorld(centerPoint);
+        const start = plane.localToWorld(startPoint);
+        const end = plane.localToWorld(endPoint);
+        const arc = Geometry.makeArc(center, radius, normal, start, end);
+        const edge = Geometry.makeEdgeFromCurve(arc);
+        this.setState('start', Vertex.fromPoint2D(startPoint));
+        this.setState('end', Vertex.fromPoint2D(endPoint));
+        // Tangent at end point: CCW: (-sin θ, cos θ), CW: (sin θ, -cos θ)
+        const sign = cw ? -1 : 1;
+        const tx = sign * (-Math.sin(endAngleRad));
+        const ty = sign * Math.cos(endAngleRad);
+        this.setTangent(new Point2D(tx, ty));
+        this.addShape(edge);
+        this.setCurrentPosition(endPoint);
+    }
+    compareTo(other) {
+        if (!(other instanceof TangentArcWithTangent)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.radius === other.radius &&
+            this.endAngle === other.endAngle &&
+            this.startTangent.compareTo(other.startTangent);
+    }
+    getType() {
+        return 'tarc';
+    }
+    getUniqueType() {
+        return 'tarc-with-tangent';
+    }
+    serialize() {
+        return {
+            radius: this.radius,
+            endAngle: this.endAngle,
+            startTangent: this.startTangent.serialize()
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+import { GeometrySceneObject } from "./geometry.js";
+export declare class TangentArc extends GeometrySceneObject {
+    radius: number;
+    endAngle: number;
+    constructor(radius: number, endAngle: number);
+    build(): void;
+    compareTo(other: TangentArc): boolean;
+    getType(): string;
+    serialize(): {
+        radius: number;
+        endAngle: number;
+    };
+}

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

@@ -0,0 +1,71 @@
+import { Vertex } from "../../common/vertex.js";
+import { Geometry } from "../../oc/geometry.js";
+import { rad } from "../../helpers/math-helpers.js";
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class TangentArc extends GeometrySceneObject {
+    radius;
+    endAngle;
+    constructor(radius, endAngle) {
+        super();
+        this.radius = radius;
+        this.endAngle = endAngle;
+    }
+    build() {
+        const tangent = this.sketch.getTangentAt(this);
+        if (!tangent) {
+            throw new Error('TangentArc requires a previous sibling with a tangent');
+        }
+        const plane = this.sketch.getPlane();
+        const radius = this.radius;
+        // Derive the base angle from the previous sibling's tangent.
+        // Tangent at angle θ on a circle is (-sin θ, cos θ),
+        // so θ = atan2(-tx, ty).
+        const baseAngle = Math.atan2(-tangent.x, tangent.y);
+        // For CW (negative endAngle), flip the center to the opposite side
+        // and negate the normal so makeArc sweeps in reverse
+        // Clamp to avoid coincident start/end points at exactly ±360°
+        const clampedEndAngle = Math.max(this.endAngle, -359.9999);
+        const cw = clampedEndAngle < 0;
+        const startAngleRad = cw ? baseAngle + Math.PI : baseAngle;
+        const endAngleRad = startAngleRad + rad(clampedEndAngle);
+        const normal = cw ? plane.normal.negate() : plane.normal;
+        const startPoint = this.getCurrentPosition();
+        const centerPoint = Geometry.getCircleCenter(startPoint, radius, startAngleRad);
+        const endPoint = Geometry.getPointOnCircle(centerPoint, radius, endAngleRad);
+        const center = plane.localToWorld(centerPoint);
+        const start = plane.localToWorld(startPoint);
+        const end = plane.localToWorld(endPoint);
+        const arc = Geometry.makeArc(center, radius, normal, start, end);
+        const edge = Geometry.makeEdgeFromCurve(arc);
+        this.setState('start', Vertex.fromPoint2D(startPoint));
+        this.setState('end', Vertex.fromPoint2D(endPoint));
+        // get tangent vector at the end angle
+        // CCW: (-sin θ, cos θ), CW: (sin θ, -cos θ)
+        const sign = cw ? -1 : 1;
+        const tx = sign * (-Math.sin(endAngleRad));
+        const ty = sign * Math.cos(endAngleRad);
+        this.setTangent(new Point2D(tx, ty));
+        this.addShape(edge);
+        this.setCurrentPosition(endPoint);
+    }
+    compareTo(other) {
+        if (!(other instanceof TangentArc)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.radius === other.radius &&
+            this.endAngle === other.endAngle;
+    }
+    getType() {
+        return 'tarc';
+    }
+    serialize() {
+        return {
+            radius: this.radius,
+            endAngle: this.endAngle
+        };
+    }
+}

package/lib/dist/features/2d/tcircle-constrained.d.ts

@@ -0,0 +1,14 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+export declare class TwoObjectsTangentCircle extends GeometrySceneObject {
+    c1: QualifiedSceneObject;
+    c2: QualifiedSceneObject;
+    diameter: number;
+    mustTouch: boolean;
+    constructor(c1: QualifiedSceneObject, c2: QualifiedSceneObject, diameter: number, mustTouch: boolean);
+    build(): void;
+    compareTo(other: TwoObjectsTangentCircle): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {};
+}