fluidcad 0.0.33 → 0.0.34

package/lib/dist/core/repeat.js

@@ -1,15 +1,36 @@
 import { registerBuilder } from "../index.js";
-import { normalizeAxis, normalizePlane } from "../helpers/normalize.js";
+import { Axis } from "../math/axis.js";
+import { SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 import { rad } from "../helpers/math-helpers.js";
 import { RepeatLinear } from "../features/repeat-linear.js";
 import { RepeatCircular } from "../features/repeat-circular.js";
 import { cloneWithTransform } from "../helpers/clone-transform.js";
-import { PlaneObjectBase } from "../features/plane-renderable-base.js";
-import { PlaneObject } from "../features/plane.js";
 import { MirrorFeature } from "../features/mirror-feature.js";
 import { RepeatMatrix } from "../features/repeat-matrix.js";
+import { resolveAxis, resolvePlane } from "../helpers/resolve.js";
+import { normalizeAxis } from "../helpers/normalize.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
+/**
+ * Resolve a repeat axis argument to a value usable by LazyMatrix. Scene-
+ * resident sources (AxisObjectBase or an edge SceneObject) go through
+ * resolveAxis so they end up in the scene and get built before consumers.
+ * Primitive inputs (world-axis string, raw Axis) stay as concrete Axis
+ * values — no extra scene object, no rendered world-axis line.
+ */
+function resolveRepeatAxis(arg, context) {
+    if (arg instanceof AxisObjectBase) {
+        return arg;
+    }
+    if (arg instanceof SceneObject) {
+        return resolveAxis(arg, context);
+    }
+    if (arg instanceof Axis) {
+        return arg;
+    }
+    return normalizeAxis(arg);
+}
 function build(context) {
     return (function repeat() {
         const args = Array.from(arguments);
@@ -23,8 +44,9 @@ function build(context) {
             const objects = restObjects.length > 0
                 ? restObjects
                 : [context.getSceneObjects().at(-1)];
-            const feature = new RepeatMatrix(matrix, objects);
-            const cloned = cloneWithTransform(objects, matrix, feature);
+            const lazy = LazyMatrix.of(matrix);
+            const feature = new RepeatMatrix(lazy, objects);
+            const cloned = cloneWithTransform(objects, lazy, feature);
             context.addSceneObject(feature);
             context.addSceneObjects(cloned);
             return feature;
@@ -35,9 +57,9 @@ function build(context) {
         const type = args[0];
         if (type === 'linear' || type === 'circular') {
             const axisArg = args[1];
-            const axes = Array.isArray(axisArg)
-                ? axisArg.map(a => normalizeAxis(a))
-                : [normalizeAxis(axisArg)];
+            const axisSources = Array.isArray(axisArg)
+                ? axisArg.map(a => resolveRepeatAxis(a, context))
+                : [resolveRepeatAxis(axisArg, context)];
             const options = args[2];
             const restObjects = args.slice(3);
             const objects = restObjects.length > 0
@@ -51,9 +73,9 @@ function build(context) {
                 const lengths = 'length' in options && options.length != null
                     ? (Array.isArray(options.length) ? options.length : [options.length])
                     : null;
-                const repeat = new RepeatLinear(axes, options, objects);
+                const repeat = new RepeatLinear(axisSources, options, objects);
                 const transformedObjects = [];
-                const axisOffsets = axes.map((axis, i) => {
+                const axisOffsets = axisSources.map((axis, i) => {
                     const count = counts[i] ?? counts[0];
                     const offset = offsets != null
                         ? (offsets[i] ?? offsets[0])
@@ -88,19 +110,26 @@ function build(context) {
                     if (options.skip?.some(s => s.length === indices.length && s.every((v, i) => v === indices[i]))) {
                         continue;
                     }
-                    // Compose translation from all axes
-                    let dx = 0, dy = 0, dz = 0;
-                    for (let a = 0; a < axisOffsets.length; a++) {
-                        const { axis, offset } = axisOffsets[a];
+                    // Capture per-axis offset + signed index for this instance; the
+                    // axis direction is read lazily at build time so an AxisObjectBase
+                    // can still be unbuilt at parse time.
+                    const perAxis = axisOffsets.map((entry, a) => {
                         const idx = options.centered
-                            ? indices[a] - Math.floor(axisOffsets[a].count / 2)
+                            ? indices[a] - Math.floor(entry.count / 2)
                             : indices[a];
-                        dx += axis.direction.x * offset * idx;
-                        dy += axis.direction.y * offset * idx;
-                        dz += axis.direction.z * offset * idx;
-                    }
-                    const transform = Matrix4.fromTranslation(dx, dy, dz);
-                    const cloned = cloneWithTransform(objects, transform, repeat);
+                        return { axis: entry.axis, offset: entry.offset, idx };
+                    });
+                    const lazy = LazyMatrix.from(() => {
+                        let dx = 0, dy = 0, dz = 0;
+                        for (const { axis, offset, idx } of perAxis) {
+                            const dir = (axis instanceof AxisObjectBase ? axis.getAxis() : axis).direction;
+                            dx += dir.x * offset * idx;
+                            dy += dir.y * offset * idx;
+                            dz += dir.z * offset * idx;
+                        }
+                        return Matrix4.fromTranslation(dx, dy, dz);
+                    });
+                    const cloned = cloneWithTransform(objects, lazy, repeat);
                     transformedObjects.push(...cloned);
                 }
                 context.addSceneObject(repeat);
@@ -108,7 +137,7 @@ function build(context) {
                 return repeat;
             }
             if (type === 'circular') {
-                const axis = axes[0];
+                const axis = axisSources[0];
                 const circularOptions = options;
                 const { count, centered, skip } = circularOptions;
                 const repeat = new RepeatCircular(axis, circularOptions, objects);
@@ -127,8 +156,8 @@ function build(context) {
                         continue;
                     }
                     const angle = startOffset + offset * i;
-                    const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, rad(angle));
-                    const cloned = cloneWithTransform(objects, matrix, repeat);
+                    const lazy = LazyMatrix.rotation(axis, rad(angle));
+                    const cloned = cloneWithTransform(objects, lazy, repeat);
                     transformedObjects.push(...cloned);
                 }
                 context.addSceneObject(repeat);
@@ -142,31 +171,16 @@ function build(context) {
             const targetObjects = restObjects.length > 0
                 ? restObjects
                 : [context.getSceneObjects().at(-1)];
-            let planeObj;
-            let normalizedPlane;
-            if (planeArg instanceof PlaneObjectBase) {
-                planeObj = planeArg;
-                planeObj.build();
-                normalizedPlane = planeObj.getPlane();
-            }
-            else {
-                normalizedPlane = normalizePlane(planeArg);
-                planeObj = new PlaneObject(normalizedPlane);
-                planeObj.build();
-                context.addSceneObject(planeObj);
-            }
-            const matrix = Matrix4.mirrorPlane(normalizedPlane.normal, normalizedPlane.origin);
-            const mirrorFeature = new MirrorFeature(planeObj, matrix);
-            const mirrorTree = cloneWithTransform(targetObjects, matrix, mirrorFeature);
+            const planeObj = resolvePlane(planeArg, context);
+            const lazy = LazyMatrix.mirror(planeObj);
+            const mirrorFeature = new MirrorFeature(planeObj, lazy);
+            const mirrorTree = cloneWithTransform(targetObjects, lazy, mirrorFeature);
             context.addSceneObject(mirrorFeature);
             context.addSceneObjects(mirrorTree);
             return mirrorFeature;
         }
         if (type === 'rotate') {
             const axisArg = args[1];
-            const axis = axisArg instanceof AxisObjectBase
-                ? axisArg.getAxis()
-                : normalizeAxis(axisArg);
             let angle = 90;
             let restStart = 2;
             if (typeof args[2] === 'number') {
@@ -177,9 +191,11 @@ function build(context) {
             const objects = restObjects.length > 0
                 ? restObjects
                 : [context.getSceneObjects().at(-1)];
-            const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, rad(angle));
-            const feature = new RepeatMatrix(matrix, objects);
-            const cloned = cloneWithTransform(objects, matrix, feature);
+            const axis = resolveRepeatAxis(axisArg, context);
+            const lazy = LazyMatrix.rotation(axis, rad(angle));
+            const sources = axis instanceof AxisObjectBase ? [axis] : [];
+            const feature = new RepeatMatrix(lazy, objects, sources);
+            const cloned = cloneWithTransform(objects, lazy, feature);
             context.addSceneObject(feature);
             context.addSceneObjects(cloned);
             return feature;

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

@@ -2,9 +2,9 @@ import { Point2DLike } from "../../math/point.js";
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
 import { LazyVertex } from "../lazy-vertex.js";
-import { IArcPoints, IArcAngles } from "../../core/interfaces.js";
+import { IArcPoints, IArcRadius, IArcCenter, IArcAngles } from "../../core/interfaces.js";
 import { SceneObject } from "../../common/scene-object.js";
-export declare class Arc extends GeometrySceneObject implements IArcPoints, IArcAngles {
+export declare class Arc extends GeometrySceneObject implements IArcPoints, IArcRadius, IArcCenter, IArcAngles {
     private _startPoint;
     private _endPoint;
     private _arcRadius;
@@ -13,18 +13,24 @@ export declare class Arc extends GeometrySceneObject implements IArcPoints, IArc
     private _bulgeRadius;
     private _centerPoint;
     private _centered;
+    private _clockwise;
+    private _major;
     private _targetPlane;
     constructor(targetPlane?: PlaneObjectBase | null);
     static toPoint(endPoint: LazyVertex, targetPlane?: PlaneObjectBase | null): Arc;
     static twoPoints(startPoint: LazyVertex, endPoint: LazyVertex, targetPlane?: PlaneObjectBase | null): Arc;
     static fromAngles(arcRadius: number, startAngle: number, endAngle: number, targetPlane?: PlaneObjectBase | null): Arc;
+    private static circumcenter;
     radius(value: number): this;
     center(value: Point2DLike): this;
     centered(): this;
+    cw(): this;
+    major(): this;
     build(): void;
     private buildTwoPointsCenter;
     private buildTwoPointsBulge;
     private buildToPoint;
+    private makeMajorArc;
     private buildWithCenter;
     private buildFromAngles;
     getType(): string;

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.fromPoint2D(centerPt);
+        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.fromPoint2D(centerPoint);
+        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.fromPoint2D(centerPoint);
+        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.fromPoint2D(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.fromPoint2D(centerPoint);
+        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/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,27 @@ 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 t = previous[j].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/tarc-constrained.d.ts

@@ -1,4 +1,5 @@
 import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
 import { LazyVertex } from "../lazy-vertex.js";
 import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
 import { ITangentArcTwoObjects } from "../../core/interfaces.js";
@@ -11,6 +12,7 @@ export declare class TangentArcTwoObjects extends GeometrySceneObject implements
     build(): void;
     start(index?: number): LazyVertex;
     end(index?: number): LazyVertex;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: TangentArcTwoObjects): boolean;
     getType(): string;
     getUniqueType(): string;

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

@@ -1,6 +1,7 @@
 import { GeometrySceneObject } from "./geometry.js";
 import { LazyVertex } from "../lazy-vertex.js";
 import { Vertex } from "../../common/vertex.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
 import { createConstraintSolver } from "../../oc/constraints/create-solver.js";
 export class TangentArcTwoObjects extends GeometrySceneObject {
     c1;
@@ -41,6 +42,13 @@ export class TangentArcTwoObjects extends GeometrySceneObject {
     end(index = 0) {
         return new LazyVertex(this.generateUniqueName(`end-vertex-${index}`), () => [this.getState('end')]);
     }
+    createCopy(remap) {
+        const remappedC1Object = remap.get(this.c1.object) || this.c1.object;
+        const remappedC2Object = remap.get(this.c2.object) || this.c2.object;
+        const c1 = new QualifiedSceneObject(remappedC1Object, this.c1.qualifier);
+        const c2 = new QualifiedSceneObject(remappedC2Object, this.c2.qualifier);
+        return new TangentArcTwoObjects(c1, c2, this.radius, this.mustTouch);
+    }
     compareTo(other) {
         if (!(other instanceof TangentArcTwoObjects)) {
             return false;

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

@@ -0,0 +1,16 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+export declare class TangentArcRadiusToObject extends GeometrySceneObject {
+    radius: number;
+    target: QualifiedSceneObject;
+    constructor(radius: number, target: QualifiedSceneObject);
+    build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: TangentArcRadiusToObject): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        radius: number;
+    };
+}

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

@@ -0,0 +1,58 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { Vertex } from "../../common/vertex.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+import { solveTangentArcRadiusToObject } from "../../oc/constraints/geometric/tangent-arc-radius-to-object.js";
+export class TangentArcRadiusToObject extends GeometrySceneObject {
+    radius;
+    target;
+    constructor(radius, target) {
+        super();
+        this.radius = radius;
+        this.target = target;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        const startPoint = this.getCurrentPosition();
+        const startTangent = this.sketch.getTangentAt(this);
+        const targetShape = this.target.toQualifiedShape();
+        const result = solveTangentArcRadiusToObject(plane, startPoint, startTangent, this.radius, targetShape);
+        for (let i = 0; i < result.edges.length; i++) {
+            this.setState(`edge-${i}`, result.edges[i]);
+        }
+        if (result.edges.length > 0) {
+            const lastEdge = result.edges[result.edges.length - 1];
+            const localStart = plane.worldToLocal(lastEdge.getFirstVertex().toPoint());
+            const localEnd = plane.worldToLocal(lastEdge.getLastVertex().toPoint());
+            this.setState('start', Vertex.fromPoint2D(localStart));
+            this.setState('end', Vertex.fromPoint2D(localEnd));
+            if (result.endTangent) {
+                this.setTangent(result.endTangent);
+            }
+            this.setCurrentPosition(localEnd);
+        }
+        this.addShapes(result.edges);
+    }
+    createCopy(remap) {
+        const remappedObject = remap.get(this.target.object) || this.target.object;
+        const target = new QualifiedSceneObject(remappedObject, this.target.qualifier);
+        return new TangentArcRadiusToObject(this.radius, target);
+    }
+    compareTo(other) {
+        if (!(other instanceof TangentArcRadiusToObject)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.radius === other.radius && this.target.compareTo(other.target);
+    }
+    getType() {
+        return 'tarc';
+    }
+    getUniqueType() {
+        return 'tarc-radius-to-object';
+    }
+    serialize() {
+        return { radius: this.radius };
+    }
+}

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

@@ -0,0 +1,18 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+import { ITangentArcToObject } from "../../core/interfaces.js";
+export declare class TangentArcToObject extends GeometrySceneObject implements ITangentArcToObject {
+    target: QualifiedSceneObject;
+    private flipped;
+    constructor(target: QualifiedSceneObject);
+    flip(): this;
+    build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: TangentArcToObject): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        flipped: boolean;
+    };
+}