fluidcad 0.0.32 → 0.0.34

package/lib/dist/math/lazy-matrix.d.ts

@@ -0,0 +1,31 @@
+import { Matrix4 } from "./matrix4.js";
+import { Axis } from "./axis.js";
+import { Plane } from "./plane.js";
+/** Anything that can be resolved to an `Axis` once built — e.g. `AxisObjectBase`. */
+export interface AxisLazySource {
+    getAxis(): Axis;
+}
+/** Anything that can be resolved to a `Plane` once built — e.g. `PlaneObjectBase`. */
+export interface PlaneLazySource {
+    getPlane(): Plane;
+}
+/**
+ * Memoized thunk over a Matrix4. Lets parse-time code thread a transform
+ * value that depends on scene state (e.g. an AxisObjectBase or
+ * PlaneObjectBase) before that state exists. Resolution is deferred to the
+ * first call to `resolve()`, by which point the renderer has built the source
+ * object. Concrete `Axis` / `Plane` sources resolve eagerly with no extra
+ * indirection.
+ */
+export declare class LazyMatrix {
+    private _resolver;
+    private _cached;
+    private constructor();
+    resolve(): Matrix4;
+    equals(other: LazyMatrix, tolerance?: number): boolean;
+    static of(matrix: Matrix4): LazyMatrix;
+    static from(resolver: () => Matrix4): LazyMatrix;
+    static mirror(plane: Plane | PlaneLazySource): LazyMatrix;
+    static rotation(axis: Axis | AxisLazySource, angle: number): LazyMatrix;
+    static translation(axis: Axis | AxisLazySource, distance: number): LazyMatrix;
+}

package/lib/dist/math/lazy-matrix.js

@@ -0,0 +1,66 @@
+import { Matrix4 } from "./matrix4.js";
+function isAxisLazySource(a) {
+    return typeof a.getAxis === "function";
+}
+function isPlaneLazySource(p) {
+    return typeof p.getPlane === "function";
+}
+/**
+ * Memoized thunk over a Matrix4. Lets parse-time code thread a transform
+ * value that depends on scene state (e.g. an AxisObjectBase or
+ * PlaneObjectBase) before that state exists. Resolution is deferred to the
+ * first call to `resolve()`, by which point the renderer has built the source
+ * object. Concrete `Axis` / `Plane` sources resolve eagerly with no extra
+ * indirection.
+ */
+export class LazyMatrix {
+    _resolver;
+    _cached;
+    constructor(resolver, cached = null) {
+        this._resolver = resolver;
+        this._cached = cached;
+    }
+    resolve() {
+        if (this._cached === null) {
+            this._cached = this._resolver();
+        }
+        return this._cached;
+    }
+    equals(other, tolerance = 0) {
+        return this.resolve().equals(other.resolve(), tolerance);
+    }
+    static of(matrix) {
+        return new LazyMatrix(() => matrix, matrix);
+    }
+    static from(resolver) {
+        return new LazyMatrix(resolver);
+    }
+    static mirror(plane) {
+        if (isPlaneLazySource(plane)) {
+            return new LazyMatrix(() => {
+                const p = plane.getPlane();
+                return Matrix4.mirrorPlane(p.normal, p.origin);
+            });
+        }
+        return LazyMatrix.of(Matrix4.mirrorPlane(plane.normal, plane.origin));
+    }
+    static rotation(axis, angle) {
+        if (isAxisLazySource(axis)) {
+            return new LazyMatrix(() => {
+                const a = axis.getAxis();
+                return Matrix4.fromRotationAroundAxis(a.origin, a.direction, angle);
+            });
+        }
+        return LazyMatrix.of(Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, angle));
+    }
+    static translation(axis, distance) {
+        if (isAxisLazySource(axis)) {
+            return new LazyMatrix(() => {
+                const dir = axis.getAxis().direction;
+                return Matrix4.fromTranslation(dir.x * distance, dir.y * distance, dir.z * distance);
+            });
+        }
+        const dir = axis.direction;
+        return LazyMatrix.of(Matrix4.fromTranslation(dir.x * distance, dir.y * distance, dir.z * distance));
+    }
+}

package/lib/dist/oc/color-transfer.d.ts

@@ -13,16 +13,27 @@ export declare class ColorTransfer {
     static applyThroughMaker(sources: Shape[], results: Shape[], maker: BRepBuilderAPI_MakeShape): void;
     /**
      * Color bleed pass: spreads colors to result faces that came from new
-     * geometry (tool inputs, generated faces, or just brand-new) by walking
-     * face-edge adjacency in each result solid.
+     * geometry (tool inputs, generated faces, or just brand-new).
      *
-     * Faces that came from `sceneSources` (whether modified or unchanged) are
-     * NOT bled — those represent existing geometry whose color state the user
-     * explicitly chose. Faces NOT from any sceneSource are eligible: this
-     * covers tool extrusions, fillet/chamfer-generated surfaces, and cut
-     * section faces.
+     * Two passes, in order:
+     *
+     *   1. Lineage-based propagation. For each scene-source EDGE / VERTEX,
+     *      ask `maker.Generated(input)` for the new face(s) it produced and
+     *      color each generated face from the source face(s) that *contained*
+     *      that input. This is what makes a fillet on a cylinder's top edge
+     *      inherit the top face's color (the edge belongs to the top face) but
+     *      a fillet on a box's vertical edge stay uncolored even when the top
+     *      face is colored (the vertical edge belongs to two side faces only).
+     *      Faces touched by this pass — colored OR not — are marked as
+     *      lineage-resolved and excluded from pass 2.
+     *
+     *   2. Adjacency-based fallback for result faces that have no Generated
+     *      lineage from any scene source (e.g. a fuse's tool-side faces, or
+     *      brand-new section faces). These spread color via face-edge
+     *      adjacency, iterating until stable. Faces that came from
+     *      `sceneSources` (whether modified or unchanged) stay protected from
+     *      both passes — those are explicit user choices.
      *
-     * Iterates until stable so newly-bled faces can spread color further.
      * Call AFTER `applyThroughMaker` so the colored seeds are in place.
      */
     static applyBleeding(sceneSources: Shape[], results: Shape[], maker: BRepBuilderAPI_MakeShape): void;

package/lib/dist/oc/color-transfer.js

@@ -45,28 +45,37 @@ export class ColorTransfer {
     }
     /**
      * Color bleed pass: spreads colors to result faces that came from new
-     * geometry (tool inputs, generated faces, or just brand-new) by walking
-     * face-edge adjacency in each result solid.
+     * geometry (tool inputs, generated faces, or just brand-new).
      *
-     * Faces that came from `sceneSources` (whether modified or unchanged) are
-     * NOT bled — those represent existing geometry whose color state the user
-     * explicitly chose. Faces NOT from any sceneSource are eligible: this
-     * covers tool extrusions, fillet/chamfer-generated surfaces, and cut
-     * section faces.
+     * Two passes, in order:
+     *
+     *   1. Lineage-based propagation. For each scene-source EDGE / VERTEX,
+     *      ask `maker.Generated(input)` for the new face(s) it produced and
+     *      color each generated face from the source face(s) that *contained*
+     *      that input. This is what makes a fillet on a cylinder's top edge
+     *      inherit the top face's color (the edge belongs to the top face) but
+     *      a fillet on a box's vertical edge stay uncolored even when the top
+     *      face is colored (the vertical edge belongs to two side faces only).
+     *      Faces touched by this pass — colored OR not — are marked as
+     *      lineage-resolved and excluded from pass 2.
+     *
+     *   2. Adjacency-based fallback for result faces that have no Generated
+     *      lineage from any scene source (e.g. a fuse's tool-side faces, or
+     *      brand-new section faces). These spread color via face-edge
+     *      adjacency, iterating until stable. Faces that came from
+     *      `sceneSources` (whether modified or unchanged) stay protected from
+     *      both passes — those are explicit user choices.
      *
-     * Iterates until stable so newly-bled faces can spread color further.
      * Call AFTER `applyThroughMaker` so the colored seeds are in place.
      */
     static applyBleeding(sceneSources, results, maker) {
-        // No colors anywhere on the source side means the bleed loop will iterate
-        // every result face only to find nothing to spread. Short-circuit before
-        // building maps or running the O(N²·E²) adjacency scan.
         if (!sceneSources.some(s => s.hasColors())) {
             return;
         }
         const oc = getOC();
         const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
         const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+        const VERTEX = oc.TopAbs_ShapeEnum.TopAbs_VERTEX;
         const protectedFaces = new oc.TopTools_MapOfShape();
         for (const scene of sceneSources) {
             for (const inputFace of Explorer.findShapes(scene.getShape(), FACE)) {
@@ -84,7 +93,52 @@ export class ColorTransfer {
         }
         for (const result of results) {
             const allFaces = Explorer.findShapes(result.getShape(), FACE);
-            // Cache edges per face — repeated `findShapes` is expensive.
+            // ── Pass 1: lineage via Generated(edge|vertex) ──
+            const lineageResolved = new oc.TopTools_MapOfShape();
+            for (const scene of sceneSources) {
+                const sceneFaces = Explorer.findShapes(scene.getShape(), FACE);
+                for (const subType of [EDGE, VERTEX]) {
+                    // Cache scene-face → contained subshapes so we can find which faces
+                    // own a given edge/vertex without re-walking each time.
+                    const sceneFaceSubs = sceneFaces.map(f => Explorer.findShapes(f, subType));
+                    for (const sub of Explorer.findShapes(scene.getShape(), subType)) {
+                        const generatedFaces = ShapeOps.shapeListToArray(maker.Generated(sub))
+                            .filter(s => s.ShapeType() === FACE);
+                        if (generatedFaces.length === 0) {
+                            continue;
+                        }
+                        // Color the generated face from the first colored owner-face of
+                        // this edge/vertex. Owners with no color don't contribute, so a
+                        // fillet on a vertical box edge (owned only by uncolored sides)
+                        // stays uncolored even though the new fillet face touches a
+                        // colored top via adjacency.
+                        let pickedColor;
+                        for (let i = 0; i < sceneFaces.length; i++) {
+                            if (!sceneFaceSubs[i].some(s => s.IsSame(sub))) {
+                                continue;
+                            }
+                            const c = scene.getColor(sceneFaces[i]);
+                            if (c) {
+                                pickedColor = c;
+                                break;
+                            }
+                        }
+                        for (const g of generatedFaces) {
+                            if (!allFaces.some(rf => rf.IsSame(g))) {
+                                continue;
+                            }
+                            if (protectedFaces.Contains(g)) {
+                                continue;
+                            }
+                            lineageResolved.Add(g);
+                            if (pickedColor && !result.getColor(g)) {
+                                result.setColor(g, pickedColor);
+                            }
+                        }
+                    }
+                }
+            }
+            // ── Pass 2: adjacency fallback for faces with no Generated lineage ──
             const faceEdges = allFaces.map(f => Explorer.findShapes(f, EDGE));
             let changed = true;
             while (changed) {
@@ -94,6 +148,9 @@ export class ColorTransfer {
                     if (protectedFaces.Contains(face)) {
                         continue;
                     }
+                    if (lineageResolved.Contains(face)) {
+                        continue;
+                    }
                     if (result.getColor(face)) {
                         continue;
                     }
@@ -116,6 +173,7 @@ export class ColorTransfer {
                     }
                 }
             }
+            lineageResolved.delete();
         }
         protectedFaces.delete();
     }

package/lib/dist/oc/constraints/constraint-solver-adaptor.d.ts

@@ -17,6 +17,11 @@ export declare class ConstraintSolverAdaptor extends ConstraintSolver {
         edges: Edge[];
         endTangent: Point2D | null;
     };
+    getTangentArcFromPointTangent(plane: Plane, startPoint: Point2D, startTangent: Point2D, target: QualifiedShape, flip: boolean): {
+        edges: Edge[];
+        endTangent: Point2D | null;
+    };
     isCurve(shape: Shape): boolean;
+    private isLine;
     private getShapeGeometry;
 }

package/lib/dist/oc/constraints/constraint-solver-adaptor.js

@@ -36,9 +36,25 @@ export class ConstraintSolverAdaptor extends ConstraintSolver {
         console.log('Using geometric solver for tangent circles');
         return this.geometricSolver.getTangentArcs(plane, shape1, shape2, radius, this.mustTouch);
     }
+    getTangentArcFromPointTangent(plane, startPoint, startTangent, target, flip) {
+        if (this.isLine(target.shape)) {
+            return this.geometricSolver.getTangentArcFromPointTangent(plane, startPoint, startTangent, target, flip);
+        }
+        return this.curveSolver.getTangentArcFromPointTangent(plane, startPoint, startTangent, target, flip);
+    }
     isCurve(shape) {
         return !(shape instanceof Vertex) && this.getShapeGeometry(shape) === 'curve';
     }
+    isLine(shape) {
+        if (shape instanceof Vertex) {
+            return false;
+        }
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const type = adaptor.GetType();
+        adaptor.delete();
+        return type === oc.GeomAbs_CurveType.GeomAbs_Line;
+    }
     getShapeGeometry(shape) {
         const oc = getOC();
         const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());

package/lib/dist/oc/constraints/constraint-solver.d.ts

@@ -15,4 +15,8 @@ export declare abstract class ConstraintSolver implements TangentLineSolver, Tan
         edges: Edge[];
         endTangent: Point2D;
     };
+    abstract getTangentArcFromPointTangent(plane: Plane, startPoint: Point2D, startTangent: Point2D, target: QualifiedShape, flip: boolean): {
+        edges: Edge[];
+        endTangent: Point2D | null;
+    };
 }

package/lib/dist/oc/constraints/curve/curve-constraint-solver.d.ts

@@ -10,4 +10,8 @@ export declare class CurveConstraintSolver extends ConstraintSolver {
         edges: Edge[];
         endTangent: Point2D | null;
     };
+    getTangentArcFromPointTangent(_plane: Plane, _startPoint: Point2D, _startTangent: Point2D, _target: QualifiedShape, _flip: boolean): {
+        edges: Edge[];
+        endTangent: Point2D | null;
+    };
 }

package/lib/dist/oc/constraints/curve/curve-constraint-solver.js

@@ -15,4 +15,7 @@ export class CurveConstraintSolver extends ConstraintSolver {
         const solver = new CurveTangentCircleSolver();
         return solver.getTangentArcs(plane, shape1, shape2, radius, mustTouch);
     }
+    getTangentArcFromPointTangent(_plane, _startPoint, _startTangent, _target, _flip) {
+        throw new Error('tArc(target): only line targets are supported');
+    }
 }

package/lib/dist/oc/constraints/geometric/geometric-constraint-solver.d.ts

@@ -1,12 +1,17 @@
 import { Edge } from "../../../common/edge.js";
 import { QualifiedShape } from "../../../features/2d/constraints/qualified-geometry.js";
 import { Plane } from "../../../math/plane.js";
+import { Point2D } from "../../../math/point.js";
 import { ConstraintSolver } from "../constraint-solver.js";
 export declare class GeometricConstraintSolver extends ConstraintSolver {
     getTangentLines(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, mustTouch: boolean): Edge[];
     getTangentCircles(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch: boolean): Edge[];
     getTangentArcs(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch: boolean): {
         edges: Edge[];
-        endTangent: import("../../../math/point.js").Point2D | null;
+        endTangent: Point2D | null;
+    };
+    getTangentArcFromPointTangent(plane: Plane, startPoint: Point2D, startTangent: Point2D, target: QualifiedShape, flip: boolean): {
+        edges: Edge[];
+        endTangent: Point2D | null;
     };
 }

package/lib/dist/oc/constraints/geometric/geometric-constraint-solver.js

@@ -1,6 +1,7 @@
 import { ConstraintSolver } from "../constraint-solver.js";
 import { GeometricTangentCircleSolver } from "./tangent-circle-solver.js";
 import { GeometricTangentLineSolver } from "./tangent-line-solver.js";
+import { solveTangentArcFromPointTangent } from "./tangent-arc-from-point-tangent.js";
 export class GeometricConstraintSolver extends ConstraintSolver {
     getTangentLines(plane, shape1, shape2, mustTouch) {
         const tangentLineSolver = new GeometricTangentLineSolver();
@@ -14,4 +15,7 @@ export class GeometricConstraintSolver extends ConstraintSolver {
         const solver = new GeometricTangentCircleSolver();
         return solver.getTangentArcs(plane, shape1, shape2, radius, mustTouch);
     }
+    getTangentArcFromPointTangent(plane, startPoint, startTangent, target, flip) {
+        return solveTangentArcFromPointTangent(plane, startPoint, startTangent, target, flip);
+    }
 }

package/lib/dist/oc/constraints/geometric/tangent-arc-from-point-tangent.d.ts

@@ -0,0 +1,8 @@
+import { Edge } from "../../../common/edge.js";
+import { QualifiedShape } from "../../../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../../../math/plane.js";
+import { Point2D } from "../../../math/point.js";
+export declare function solveTangentArcFromPointTangent(plane: Plane, startPoint: Point2D, startTangent: Point2D, target: QualifiedShape, flip: boolean): {
+    edges: Edge[];
+    endTangent: Point2D | null;
+};

package/lib/dist/oc/constraints/geometric/tangent-arc-from-point-tangent.js

@@ -0,0 +1,111 @@
+import { Edge } from "../../../common/edge.js";
+import { Point2D } from "../../../math/point.js";
+import { Geometry } from "../../geometry.js";
+import { getOC } from "../../init.js";
+const EPS = 1e-10;
+export function solveTangentArcFromPointTangent(plane, startPoint, startTangent, target, flip) {
+    const lineTarget = extractLineTarget(plane, target);
+    const tlen = startTangent.length();
+    if (tlen < EPS) {
+        throw new Error('tArc(target): start tangent has zero magnitude');
+    }
+    const Tx = startTangent.x / tlen;
+    const Ty = startTangent.y / tlen;
+    const Nx = -Ty;
+    const Ny = Tx;
+    const Qx = lineTarget.pointOnLine.x;
+    const Qy = lineTarget.pointOnLine.y;
+    const dx = lineTarget.direction.x;
+    const dy = lineTarget.direction.y;
+    const nx = -dy;
+    const ny = dx;
+    const dPL = (startPoint.x - Qx) * nx + (startPoint.y - Qy) * ny;
+    const k = Nx * nx + Ny * ny;
+    // Two candidate signed radii from the line tangency equation:
+    //   d_PL + r·k = s·r  ⇒  r = d_PL / (s − k)  for s ∈ {+1, −1}
+    // Generically one yields r > 0 (center on the +N̂ side = "primary/left")
+    // and the other yields r < 0 ("flipped/right"). Pick by sign so the
+    // user-facing default is deterministic regardless of input geometry.
+    const candidates = [];
+    for (const s of [+1, -1]) {
+        const denom = s - k;
+        if (Math.abs(denom) < EPS) {
+            continue;
+        }
+        const r = dPL / denom;
+        if (Math.abs(r) < EPS) {
+            continue;
+        }
+        candidates.push(buildCandidate(startPoint, Nx, Ny, r, lineTarget));
+    }
+    if (candidates.length === 0) {
+        return { edges: [], endTangent: null };
+    }
+    const primary = candidates.find(c => c.ccw) ?? null;
+    const flipped = candidates.find(c => !c.ccw) ?? null;
+    let chosen;
+    if (flip) {
+        chosen = flipped ?? primary;
+    }
+    else {
+        chosen = primary ?? flipped;
+    }
+    const edge = buildArcEdge(plane, chosen);
+    return { edges: [edge], endTangent: chosen.endTangent };
+}
+function extractLineTarget(plane, target) {
+    const oc = getOC();
+    const shape = target.shape;
+    if (!(shape instanceof Edge)) {
+        throw new Error('tArc(target): target must be a line edge');
+    }
+    const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+    const type = adaptor.GetType();
+    if (type !== oc.GeomAbs_CurveType.GeomAbs_Line) {
+        adaptor.delete();
+        throw new Error('tArc(target): only line targets are supported');
+    }
+    adaptor.delete();
+    const start = plane.worldToLocal(shape.getFirstVertex().toPoint());
+    const end = plane.worldToLocal(shape.getLastVertex().toPoint());
+    const diff = end.subtract(start);
+    const len = diff.length();
+    if (len < EPS) {
+        throw new Error('tArc(target): target line has zero length');
+    }
+    return {
+        pointOnLine: start,
+        direction: diff.multiplyScalar(1 / len)
+    };
+}
+function buildCandidate(P, Nx, Ny, r, target) {
+    const Ox = P.x + r * Nx;
+    const Oy = P.y + r * Ny;
+    const dx = target.direction.x;
+    const dy = target.direction.y;
+    const t = (Ox - target.pointOnLine.x) * dx + (Oy - target.pointOnLine.y) * dy;
+    const Qx = target.pointOnLine.x + t * dx;
+    const Qy = target.pointOnLine.y + t * dy;
+    const radius = Math.abs(r);
+    const ccw = r > 0;
+    const endAngle = Math.atan2(Qy - Oy, Qx - Ox);
+    const sign = ccw ? 1 : -1;
+    const endTangent = new Point2D(sign * (-Math.sin(endAngle)), sign * Math.cos(endAngle));
+    return {
+        center: new Point2D(Ox, Oy),
+        radius,
+        ccw,
+        startPoint: P,
+        endPoint: new Point2D(Qx, Qy),
+        endAngle,
+        endTangent
+    };
+}
+function buildArcEdge(plane, c) {
+    const normal = c.ccw ? plane.normal : plane.normal.negate();
+    const center = plane.localToWorld(c.center);
+    const start = plane.localToWorld(c.startPoint);
+    const end = plane.localToWorld(c.endPoint);
+    const arc = Geometry.makeArc(center, c.radius, normal, start, end);
+    return Geometry.makeEdgeFromCurve(arc);
+}

package/lib/dist/oc/constraints/geometric/tangent-arc-radius-to-object.d.ts

@@ -0,0 +1,8 @@
+import { Edge } from "../../../common/edge.js";
+import { QualifiedShape } from "../../../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../../../math/plane.js";
+import { Point2D } from "../../../math/point.js";
+export declare function solveTangentArcRadiusToObject(plane: Plane, startPoint: Point2D, startTangent: Point2D, signedRadius: number, target: QualifiedShape): {
+    edges: Edge[];
+    endTangent: Point2D | null;
+};

package/lib/dist/oc/constraints/geometric/tangent-arc-radius-to-object.js

@@ -0,0 +1,161 @@
+import { Edge } from "../../../common/edge.js";
+import { Point2D } from "../../../math/point.js";
+import { Convert } from "../../convert.js";
+import { Geometry } from "../../geometry.js";
+import { getOC } from "../../init.js";
+const EPS = 1e-10;
+export function solveTangentArcRadiusToObject(plane, startPoint, startTangent, signedRadius, target) {
+    if (Math.abs(signedRadius) < EPS) {
+        throw new Error('tArc(radius, target): radius must be non-zero');
+    }
+    const tlen = startTangent.length();
+    if (tlen < EPS) {
+        throw new Error('tArc(radius, target): start tangent has zero magnitude');
+    }
+    const Tx = startTangent.x / tlen;
+    const Ty = startTangent.y / tlen;
+    // N̂: 90° CCW from T̂. Signed radius > 0 puts center on +N̂ (left) → CCW arc.
+    const Nx = -Ty;
+    const Ny = Tx;
+    const Ox = startPoint.x + signedRadius * Nx;
+    const Oy = startPoint.y + signedRadius * Ny;
+    const center = new Point2D(Ox, Oy);
+    const radius = Math.abs(signedRadius);
+    const ccw = signedRadius > 0;
+    const targetGeom = extractTargetGeometry(plane, target);
+    const intersections = findIntersections(center, radius, targetGeom);
+    if (intersections.length === 0) {
+        throw new Error('tArc(radius, target): arc circle does not intersect target');
+    }
+    const startAngle = Math.atan2(startPoint.y - Oy, startPoint.x - Ox);
+    let best = null;
+    for (const Q of intersections) {
+        const endAngle = Math.atan2(Q.y - Oy, Q.x - Ox);
+        let sweep = endAngle - startAngle;
+        if (ccw) {
+            if (sweep < 0) {
+                sweep += 2 * Math.PI;
+            }
+        }
+        else {
+            if (sweep > 0) {
+                sweep -= 2 * Math.PI;
+            }
+        }
+        // Skip degenerate "no-sweep" intersections (start point itself on target).
+        if (Math.abs(sweep) < EPS) {
+            continue;
+        }
+        if (!best || Math.abs(sweep) < Math.abs(best.sweep)) {
+            best = { endPoint: Q, sweep, endAngle };
+        }
+    }
+    if (!best) {
+        throw new Error('tArc(radius, target): no intersection reachable in the arc direction');
+    }
+    const normal = ccw ? plane.normal : plane.normal.negate();
+    const worldCenter = plane.localToWorld(center);
+    const worldStart = plane.localToWorld(startPoint);
+    const worldEnd = plane.localToWorld(best.endPoint);
+    const arc = Geometry.makeArc(worldCenter, radius, normal, worldStart, worldEnd);
+    const edge = Geometry.makeEdgeFromCurve(arc);
+    const sign = ccw ? 1 : -1;
+    const endTangent = new Point2D(sign * (-Math.sin(best.endAngle)), sign * Math.cos(best.endAngle));
+    return { edges: [edge], endTangent };
+}
+function extractTargetGeometry(plane, target) {
+    const oc = getOC();
+    const shape = target.shape;
+    if (!(shape instanceof Edge)) {
+        throw new Error('tArc(radius, target): target must be a line, circle, or arc edge');
+    }
+    const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+    const type = adaptor.GetType();
+    if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
+        adaptor.delete();
+        const start = plane.worldToLocal(shape.getFirstVertex().toPoint());
+        const end = plane.worldToLocal(shape.getLastVertex().toPoint());
+        const diff = end.subtract(start);
+        const len = diff.length();
+        if (len < EPS) {
+            throw new Error('tArc(radius, target): target line has zero length');
+        }
+        return {
+            type: 'line',
+            pointOnLine: start,
+            direction: diff.multiplyScalar(1 / len)
+        };
+    }
+    if (type === oc.GeomAbs_CurveType.GeomAbs_Circle) {
+        const circle = adaptor.Circle();
+        const r = circle.Radius();
+        const cWorld = Convert.toPoint(circle.Location());
+        adaptor.delete();
+        return {
+            type: 'circle',
+            center: plane.worldToLocal(cWorld),
+            radius: r
+        };
+    }
+    adaptor.delete();
+    throw new Error('tArc(radius, target): target must be a line, circle, or arc');
+}
+function findIntersections(center, radius, target) {
+    if (target.type === 'line') {
+        return lineCircleIntersections(center, radius, target.pointOnLine, target.direction);
+    }
+    return circleCircleIntersections(center, radius, target.center, target.radius);
+}
+function lineCircleIntersections(O, radius, Q_L, d_L) {
+    // Line unit normal (rotate direction +90° CCW).
+    const nx = -d_L.y;
+    const ny = d_L.x;
+    const d_OL = (O.x - Q_L.x) * nx + (O.y - Q_L.y) * ny;
+    const absD = Math.abs(d_OL);
+    if (absD > radius + EPS) {
+        return [];
+    }
+    // Foot of perpendicular from O onto the line.
+    const Fx = O.x - d_OL * nx;
+    const Fy = O.y - d_OL * ny;
+    const inside = Math.max(radius * radius - d_OL * d_OL, 0);
+    const h = Math.sqrt(inside);
+    if (h < EPS) {
+        return [new Point2D(Fx, Fy)];
+    }
+    return [
+        new Point2D(Fx + h * d_L.x, Fy + h * d_L.y),
+        new Point2D(Fx - h * d_L.x, Fy - h * d_L.y)
+    ];
+}
+function circleCircleIntersections(O, r1, Cc, r2) {
+    const dx = Cc.x - O.x;
+    const dy = Cc.y - O.y;
+    const d2 = dx * dx + dy * dy;
+    const d = Math.sqrt(d2);
+    if (d < EPS) {
+        return [];
+    }
+    if (d > r1 + r2 + EPS) {
+        return [];
+    }
+    if (d < Math.abs(r1 - r2) - EPS) {
+        return [];
+    }
+    const a = (d2 + r1 * r1 - r2 * r2) / (2 * d);
+    const inside = Math.max(r1 * r1 - a * a, 0);
+    const h = Math.sqrt(inside);
+    // Midpoint M = O + (a/d) * (Cc - O).
+    const Mx = O.x + (a / d) * dx;
+    const My = O.y + (a / d) * dy;
+    if (h < EPS) {
+        return [new Point2D(Mx, My)];
+    }
+    // Perpendicular (unit) to (Cc - O).
+    const px = -dy / d;
+    const py = dx / d;
+    return [
+        new Point2D(Mx + h * px, My + h * py),
+        new Point2D(Mx - h * px, My - h * py)
+    ];
+}

package/lib/dist/oc/extrude-ops.d.ts

@@ -30,10 +30,11 @@ export declare class ExtrudeOps {
     static makePrismInfinite(shape: Shape, direction: Vector3d): Shape;
     static makePrismSymmetric(shape: Shape, direction: Vector3d): Shape;
     static makeRevol(shape: Shape, axis: Axis, angle: number): MakeRevolResult;
-    static applyDraftOnSideFaces(solid: Shape, firstFace: Shape, lastFace: Shape, plane: Plane, angle: number): {
+    static applyDraftOnSideFaces(solid: Shape, firstFace: Shape, lastFace: Shape, plane: Plane, angle: number, excludeFaces?: Shape[]): {
         solid: Shape;
         firstFace: Shape;
         lastFace: Shape;
+        remapFace: (face: Shape) => Shape[];
     };
     static applyDraft(shape: TopoDS_Shape, direction: Vector3d, angle: number): TopoDS_Shape;
 }