fluidcad 0.0.38 → 0.0.39

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

@@ -1,5 +1,32 @@
 import { Solid } from "../common/solid.js";
 import { Wire } from "../common/wire.js";
+import { LoftEndCondition, LoftConditionKind } from "./loft/constrained-loft.js";
+export type { LoftEndCondition, LoftConditionKind };
+export interface LoftOptions {
+    /** Constrains how the surface leaves the first profile. */
+    startCondition?: LoftEndCondition;
+    /** Constrains how the surface arrives at the last profile. */
+    endCondition?: LoftEndCondition;
+    /** One or two side rails the loft surface must follow. */
+    guides?: Wire[];
+}
 export declare class LoftOps {
-    static makeLoft(wires: Wire[]): Solid[];
+    /**
+     * Lofts through the section wires. Plain lofts run OCC's ThruSections;
+     * guides dispatch to `GuidedLoft` (virtual sections carried onto the
+     * rails) and start/end conditions to `ConstrainedLoft` (derivative-pinned
+     * skinning) — both in-house skins, since OCC can neither constrain end
+     * tangency nor follow rails without distorting sections. Conditions
+     * compose with guides: the condition fades out around each guide contact
+     * (the rails own their sides of the surface).
+     */
+    static makeLoft(wires: Wire[], options?: LoftOptions): Solid[];
+    /**
+     * Thin-walled loft with start/end conditions: both walls are skinned with
+     * the same conditions and assembled directly with ring caps — see
+     * `ConstrainedLoft.buildThin`. (The condition-less thin loft stays on the
+     * legacy ThruSections + boolean path in the feature layer.)
+     */
+    static makeThinLoft(outerWires: Wire[], innerWires: Wire[], options: LoftOptions): Solid[];
+    private static makeThruSectionsLoft;
 }

package/lib/dist/oc/loft-ops.js

@@ -1,8 +1,38 @@
 import { getOC } from "./init.js";
 import { Explorer } from "./explorer.js";
 import { Solid } from "../common/solid.js";
+import { ConstrainedLoft } from "./loft/constrained-loft.js";
+import { GuidedLoft } from "./loft/guided-loft.js";
 export class LoftOps {
-    static makeLoft(wires) {
+    /**
+     * Lofts through the section wires. Plain lofts run OCC's ThruSections;
+     * guides dispatch to `GuidedLoft` (virtual sections carried onto the
+     * rails) and start/end conditions to `ConstrainedLoft` (derivative-pinned
+     * skinning) — both in-house skins, since OCC can neither constrain end
+     * tangency nor follow rails without distorting sections. Conditions
+     * compose with guides: the condition fades out around each guide contact
+     * (the rails own their sides of the surface).
+     */
+    static makeLoft(wires, options) {
+        const guides = options?.guides ?? [];
+        if (guides.length > 0) {
+            return GuidedLoft.build(wires, guides, options?.startCondition, options?.endCondition);
+        }
+        if (options?.startCondition || options?.endCondition) {
+            return ConstrainedLoft.build(wires, options.startCondition, options.endCondition);
+        }
+        return LoftOps.makeThruSectionsLoft(wires);
+    }
+    /**
+     * Thin-walled loft with start/end conditions: both walls are skinned with
+     * the same conditions and assembled directly with ring caps — see
+     * `ConstrainedLoft.buildThin`. (The condition-less thin loft stays on the
+     * legacy ThruSections + boolean path in the feature layer.)
+     */
+    static makeThinLoft(outerWires, innerWires, options) {
+        return ConstrainedLoft.buildThin(outerWires, innerWires, options.startCondition, options.endCondition);
+    }
+    static makeThruSectionsLoft(wires) {
         const oc = getOC();
         const thruSections = new oc.BRepOffsetAPI_ThruSections(true, false, 1e-6);
         for (const wire of wires) {

package/lib/dist/oc/ncollection.d.ts

@@ -0,0 +1,19 @@
+import type { NCollection_Array1_double, NCollection_Array1_int, NCollection_Array1_gp_Pnt, NCollection_Array1_gp_Pnt2d, NCollection_Array2_gp_Pnt, NCollection_Array2_double } from "ocjs-fluidcad";
+import type { Disposable } from "./convert.js";
+import { Point2D } from "../math/point.js";
+/**
+ * Builders for the 1-based NCollection arrays that OCC geometry constructors
+ * consume. Each returns the codebase's `Disposable` pair so call sites free
+ * the native array (and nothing else) once the consumer has copied it.
+ */
+export declare class NCollections {
+    static toArray1Double(values: ReadonlyArray<number>): Disposable<NCollection_Array1_double>;
+    static toArray1Int(values: ReadonlyArray<number>): Disposable<NCollection_Array1_int>;
+    /** Each point is an [x, y, z] triple. */
+    static toArray1Pnt(points: ReadonlyArray<ReadonlyArray<number>>): Disposable<NCollection_Array1_gp_Pnt>;
+    static toArray1Pnt2d(points: ReadonlyArray<Point2D>): Disposable<NCollection_Array1_gp_Pnt2d>;
+    /** Grid of [x, y, z] triples, indexed [row][column]. */
+    static toArray2Pnt(grid: ReadonlyArray<ReadonlyArray<ReadonlyArray<number>>>): Disposable<NCollection_Array2_gp_Pnt>;
+    /** Grid of numbers, indexed [row][column]. */
+    static toArray2Double(grid: ReadonlyArray<ReadonlyArray<number>>): Disposable<NCollection_Array2_double>;
+}

package/lib/dist/oc/ncollection.js

@@ -0,0 +1,69 @@
+import { getOC } from "./init.js";
+/**
+ * Builders for the 1-based NCollection arrays that OCC geometry constructors
+ * consume. Each returns the codebase's `Disposable` pair so call sites free
+ * the native array (and nothing else) once the consumer has copied it.
+ */
+export class NCollections {
+    static toArray1Double(values) {
+        const oc = getOC();
+        const array = new oc.NCollection_Array1_double(1, values.length);
+        for (let i = 0; i < values.length; i++) {
+            array.SetValue(i + 1, values[i]);
+        }
+        return [array, () => array.delete()];
+    }
+    static toArray1Int(values) {
+        const oc = getOC();
+        const array = new oc.NCollection_Array1_int(1, values.length);
+        for (let i = 0; i < values.length; i++) {
+            array.SetValue(i + 1, values[i]);
+        }
+        return [array, () => array.delete()];
+    }
+    /** Each point is an [x, y, z] triple. */
+    static toArray1Pnt(points) {
+        const oc = getOC();
+        const array = new oc.NCollection_Array1_gp_Pnt(1, points.length);
+        for (let i = 0; i < points.length; i++) {
+            const point = new oc.gp_Pnt(points[i][0], points[i][1], points[i][2]);
+            array.SetValue(i + 1, point);
+            point.delete();
+        }
+        return [array, () => array.delete()];
+    }
+    static toArray1Pnt2d(points) {
+        const oc = getOC();
+        const array = new oc.NCollection_Array1_gp_Pnt2d(1, points.length);
+        for (let i = 0; i < points.length; i++) {
+            const point = new oc.gp_Pnt2d(points[i].x, points[i].y);
+            array.SetValue(i + 1, point);
+            point.delete();
+        }
+        return [array, () => array.delete()];
+    }
+    /** Grid of [x, y, z] triples, indexed [row][column]. */
+    static toArray2Pnt(grid) {
+        const oc = getOC();
+        const array = new oc.NCollection_Array2_gp_Pnt(1, grid.length, 1, grid[0].length);
+        for (let row = 0; row < grid.length; row++) {
+            for (let col = 0; col < grid[row].length; col++) {
+                const point = new oc.gp_Pnt(grid[row][col][0], grid[row][col][1], grid[row][col][2]);
+                array.SetValue(row + 1, col + 1, point);
+                point.delete();
+            }
+        }
+        return [array, () => array.delete()];
+    }
+    /** Grid of numbers, indexed [row][column]. */
+    static toArray2Double(grid) {
+        const oc = getOC();
+        const array = new oc.NCollection_Array2_double(1, grid.length, 1, grid[0].length);
+        for (let row = 0; row < grid.length; row++) {
+            for (let col = 0; col < grid[row].length; col++) {
+                array.SetValue(row + 1, col + 1, grid[row][col]);
+            }
+        }
+        return [array, () => array.delete()];
+    }
+}

package/lib/dist/oc/rib-ops.js

@@ -4,6 +4,7 @@ import { Point } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
 import { Matrix4 } from "../math/matrix4.js";
 import { WireOps } from "./wire-ops.js";
+import { WireExtendOps } from "./wire-extend-ops.js";
 import { FaceOps } from "./face-ops.js";
 import { EdgeOps } from "./edge-ops.js";
 import { ShapeOps } from "./shape-ops.js";
@@ -144,17 +145,9 @@ export class RibOps {
     // overlaps every cavity boundary regardless of curvature (drafted cones,
     // fillets, etc.) — so the cut produces a clean blend on every face it touches.
     static extendSpineWire(spineWire, scopeShapes, _plane) {
-        const edges = spineWire.getEdges();
-        if (edges.length === 0) {
+        if (spineWire.getEdges().length === 0) {
             return spineWire;
         }
-        const firstVertex = spineWire.getFirstVertex().toPoint();
-        const lastVertex = spineWire.getLastVertex().toPoint();
-        const lastEdge = edges[edges.length - 1];
-        const endTangent = EdgeOps.getEdgeTangentAtEnd(lastEdge).normalize();
-        const firstEdge = edges[0];
-        const firstEdgeEnd = EdgeOps.getLastVertex(firstEdge).toPoint();
-        const startTangent = firstVertex.vectorTo(firstEdgeEnd).normalize();
         let minX = Infinity, minY = Infinity, minZ = Infinity;
         let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
         for (const s of scopeShapes) {
@@ -184,14 +177,9 @@ export class RibOps {
             return spineWire;
         }
         const ext = 2 * diag;
-        const startExtPoint = firstVertex.add(startTangent.multiply(-ext));
-        const endExtPoint = lastVertex.add(endTangent.multiply(ext));
-        const newEdges = [
-            EdgeOps.makeLineEdge(startExtPoint, firstVertex),
-            ...edges,
-            EdgeOps.makeLineEdge(lastVertex, endExtPoint),
-        ];
-        return WireOps.makeWireFromEdges(newEdges);
+        let extended = WireExtendOps.extendWire(spineWire, "start", ext);
+        extended = WireExtendOps.extendWire(extended, "end", ext);
+        return extended;
     }
     static computeExtrudeDistanceAlongDirection(direction, origin, scopeShapes) {
         let maxDist = 0;

package/lib/dist/oc/wire-extend-ops.d.ts

@@ -0,0 +1,12 @@
+import { Wire } from "../common/wire.js";
+export type WireEnd = "start" | "end";
+export declare class WireExtendOps {
+    /**
+     * Extends an open wire beyond one end by `length`, continuing straight along
+     * the wire's true tangent there. The new straight edge joins the existing
+     * first/last vertex, so the result is a single connected wire.
+     *
+     * No-op for closed wires, empty wires, or `length <= 0`.
+     */
+    static extendWire(wire: Wire, side: WireEnd, length: number): Wire;
+}

package/lib/dist/oc/wire-extend-ops.js

@@ -0,0 +1,42 @@
+import { EdgeOps } from "./edge-ops.js";
+import { WireOps } from "./wire-ops.js";
+import { PathSampler } from "./path-sampler.js";
+export class WireExtendOps {
+    /**
+     * Extends an open wire beyond one end by `length`, continuing straight along
+     * the wire's true tangent there. The new straight edge joins the existing
+     * first/last vertex, so the result is a single connected wire.
+     *
+     * No-op for closed wires, empty wires, or `length <= 0`.
+     */
+    static extendWire(wire, side, length) {
+        if (length <= 0) {
+            return wire;
+        }
+        const edges = wire.getEdges();
+        if (edges.length === 0) {
+            return wire;
+        }
+        const sampler = new PathSampler(wire);
+        try {
+            if (sampler.closed) {
+                return wire;
+            }
+            if (side === "start") {
+                // Tangent at the start points into the wire; extend the opposite way.
+                const startPt = wire.getFirstVertex().toPoint();
+                const inward = sampler.evalAt(0).tangent;
+                const extPt = startPt.add(inward.multiply(-length));
+                return WireOps.makeWireFromEdges([EdgeOps.makeLineEdge(extPt, startPt), ...edges]);
+            }
+            // Tangent at the end already points out of the wire.
+            const endPt = wire.getLastVertex().toPoint();
+            const outward = sampler.evalAt(sampler.length).tangent;
+            const extPt = endPt.add(outward.multiply(length));
+            return WireOps.makeWireFromEdges([...edges, EdgeOps.makeLineEdge(endPt, extPt)]);
+        }
+        finally {
+            sampler.dispose();
+        }
+    }
+}

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

@@ -26,6 +26,17 @@ export declare class WireOps {
      */
     static offsetWireOnPlane(wire: Wire, distance: number, isClosed: boolean, plane: Plane): Wire;
     static isCWRaw(wire: TopoDS_Wire, normal: Vector3d): boolean;
+    /**
+     * Groups edges into connected chains — one wire per chain — via
+     * `ShapeAnalysis_FreeBounds.ConnectEdgesToWires`. Edge ends within
+     * `tolerance` of each other connect; disconnected groups come back as
+     * separate wires (e.g. a guide sketch holding a curve and its mirror).
+     *
+     * V8-binding gotcha: the plain-name dispatcher can resolve to the
+     * deprecated out-parameter overload, which returns a `{ wires }` envelope
+     * instead of the sequence itself — unwrap at runtime.
+     */
+    static connectEdgesToWires(edges: Edge[], tolerance?: number): Wire[];
     static makeWireFromEdgesRaw(edges: TopoDS_Edge[]): TopoDS_Wire;
     static reverseWireRaw(wire: TopoDS_Wire): TopoDS_Wire;
     static buildWireRaw(edges: TopoDS_Edge[]): TopoDS_Wire;

package/lib/dist/oc/wire-ops.js

@@ -70,6 +70,39 @@ export class WireOps {
         adaptor.delete();
         return signedArea < 0;
     }
+    /**
+     * Groups edges into connected chains — one wire per chain — via
+     * `ShapeAnalysis_FreeBounds.ConnectEdgesToWires`. Edge ends within
+     * `tolerance` of each other connect; disconnected groups come back as
+     * separate wires (e.g. a guide sketch holding a curve and its mirror).
+     *
+     * V8-binding gotcha: the plain-name dispatcher can resolve to the
+     * deprecated out-parameter overload, which returns a `{ wires }` envelope
+     * instead of the sequence itself — unwrap at runtime.
+     */
+    static connectEdgesToWires(edges, tolerance = 1e-6) {
+        const oc = getOC();
+        const input = new oc.NCollection_HSequence_TopoDS_Shape();
+        for (const edge of edges) {
+            input.Append(edge.getShape());
+        }
+        const result = oc.ShapeAnalysis_FreeBounds.ConnectEdgesToWires(input, tolerance, false);
+        const isEnvelope = result && typeof result.Sequence !== "function" && result.wires;
+        const handle = isEnvelope ? result.wires : result;
+        const wires = [];
+        const sequence = handle.Sequence();
+        for (let i = 1; i <= sequence.Length(); i++) {
+            wires.push(Wire.fromTopoDSWire(oc.TopoDS.Wire(sequence.Value(i))));
+        }
+        input.delete();
+        if (isEnvelope && typeof result[Symbol.dispose] === "function") {
+            result[Symbol.dispose]();
+        }
+        else if (typeof handle.delete === "function") {
+            handle.delete();
+        }
+        return wires;
+    }
     static makeWireFromEdgesRaw(edges) {
         const oc = getOC();
         const wireMaker = new oc.BRepBuilderAPI_MakeWire();

package/lib/dist/oc/wrap-ops.js

@@ -4,6 +4,8 @@ import { Explorer } from "./explorer.js";
 import { FaceQuery } from "./face-query.js";
 import { WireOps } from "./wire-ops.js";
 import { ShapeFactory } from "../common/shape-factory.js";
+import { NCollections } from "./ncollection.js";
+import { Point2D } from "../math/point.js";
 import { ConeDevelopment, CylinderDevelopment, } from "./wrap-development.js";
 import { interpolateBSpline2d } from "../math/bspline-interpolation.js";
 /** Sample points per curved sketch edge before fitting its UV pcurve. */
@@ -284,22 +286,13 @@ export class WrapOps {
     static fitUvCurve(samples) {
         const oc = getOC();
         const data = interpolateBSpline2d(samples.map(s => ({ x: s.u, y: s.v })));
-        const poles = new oc.NCollection_Array1_gp_Pnt2d(1, data.poles.length);
-        for (let i = 0; i < data.poles.length; i++) {
-            const point = new oc.gp_Pnt2d(data.poles[i].x, data.poles[i].y);
-            poles.SetValue(i + 1, point);
-            point.delete();
-        }
-        const knots = new oc.NCollection_Array1_double(1, data.knots.length);
-        const multiplicities = new oc.NCollection_Array1_int(1, data.knots.length);
-        for (let i = 0; i < data.knots.length; i++) {
-            knots.SetValue(i + 1, data.knots[i]);
-            multiplicities.SetValue(i + 1, data.multiplicities[i]);
-        }
+        const [poles, disposePoles] = NCollections.toArray1Pnt2d(data.poles.map(p => new Point2D(p.x, p.y)));
+        const [knots, disposeKnots] = NCollections.toArray1Double(data.knots);
+        const [multiplicities, disposeMultiplicities] = NCollections.toArray1Int(data.multiplicities);
         const curve = new oc.Geom2d_BSplineCurve(poles, knots, multiplicities, data.degree);
-        poles.delete();
-        knots.delete();
-        multiplicities.delete();
+        disposePoles();
+        disposeKnots();
+        disposeMultiplicities();
         return curve;
     }
     /** Thickens the wrapped face along the surface normal into a solid. */

package/lib/dist/tests/features/2d/circle.test.js

@@ -51,14 +51,4 @@ describe("circle", () => {
             expect(getFacesByType(solid, "cylinder")).toHaveLength(1);
         });
     });
-    describe("standalone with targetPlane", () => {
-        it("should create a circle on a specific plane", () => {
-            circle("xy", 60);
-            const e = extrude(10);
-            render();
-            const solid = e.getShapes()[0];
-            const bbox = ShapeOps.getBoundingBox(solid);
-            expect(bbox.maxX - bbox.minX).toBeCloseTo(60, 0);
-        });
-    });
 });

package/lib/dist/tests/features/2d/ellipse.test.js

@@ -66,35 +66,5 @@ describe("ellipse", () => {
             render();
             expect(negEllipse?.getError()).toMatch(/positive/i);
         });
-        it("throws when given a plane inside a sketch", () => {
-            expect(() => {
-                sketch("xy", () => {
-                    ellipse("xy", 30, 20);
-                });
-                render();
-            }).toThrow();
-        });
-    });
-    describe("standalone with targetPlane", () => {
-        it("creates an ellipse on a specific plane", () => {
-            ellipse("xy", 60, 40);
-            const e = extrude(10);
-            render();
-            const solid = e.getShapes()[0];
-            const bbox = ShapeOps.getBoundingBox(solid);
-            expect(bbox.maxX - bbox.minX).toBeCloseTo(120, 0);
-            expect(bbox.maxY - bbox.minY).toBeCloseTo(80, 0);
-        });
-        it("creates an ellipse on a plane at a given center", () => {
-            ellipse("xy", [10, 20], 30, 15);
-            const e = extrude(10);
-            render();
-            const solid = e.getShapes()[0];
-            const bbox = ShapeOps.getBoundingBox(solid);
-            expect(bbox.centerX).toBeCloseTo(10, 0);
-            expect(bbox.centerY).toBeCloseTo(20, 0);
-            expect(bbox.maxX - bbox.minX).toBeCloseTo(60, 0);
-            expect(bbox.maxY - bbox.minY).toBeCloseTo(30, 0);
-        });
     });
 });

package/lib/dist/tests/features/2d/line.test.js

@@ -32,11 +32,6 @@ describe("line functions", () => {
             expect(bbox.maxX - bbox.minX).toBeCloseTo(80, 0);
             expect(bbox.maxY - bbox.minY).toBeCloseTo(40, 0);
         });
-        it("should support standalone mode with targetPlane", () => {
-            hLine("xy", 50);
-            render();
-            // Just verify no error — standalone line doesn't form a closed shape
-        });
     });
     describe("vLine", () => {
         it("should create a vertical line and form a closed rect", () => {

package/lib/dist/tests/features/2d/offset.test.js

@@ -159,16 +159,6 @@ describe("offset", () => {
             expect(shapes).toHaveLength(1);
         });
     });
-    describe("specific targets (standalone)", () => {
-        it("should offset source geometries onto a target plane", () => {
-            const s = sketch("xy", () => {
-                circle(40);
-            });
-            offset("xy", 5, false, s);
-            render();
-            // Offset edges should exist on the target plane
-        });
-    });
     describe("default distance", () => {
         it("should use default distance of 1", () => {
             const s = sketch("xy", () => {

package/lib/dist/tests/features/2d/polygon.test.js

@@ -131,20 +131,4 @@ describe("polygon", () => {
             expect(bbox.centerY).toBeCloseTo(30, 0);
         });
     });
-    describe("standalone with targetPlane", () => {
-        it("should create a polygon on a specific plane", () => {
-            polygon("xy", 5, 50);
-            const e = extrude(10);
-            render();
-            const solid = e.getShapes()[0];
-            expect(solid.getFaces()).toHaveLength(7);
-        });
-        it("should create a circumscribed polygon on a specific plane", () => {
-            polygon("xy", 6, 60, "circumscribed");
-            const e = extrude(10);
-            render();
-            const solid = e.getShapes()[0];
-            expect(solid.getFaces()).toHaveLength(8);
-        });
-    });
 });

package/lib/dist/tests/features/2d/rect.test.js

@@ -52,15 +52,4 @@ describe("rect", () => {
             expect(solid.getEdges().length).toBeGreaterThan(12);
         });
     });
-    describe("standalone with targetPlane", () => {
-        it("should create a rectangle on a specific plane", () => {
-            rect("xy", 80, 40);
-            const e = extrude(10);
-            render();
-            const solid = e.getShapes()[0];
-            const bbox = ShapeOps.getBoundingBox(solid);
-            expect(bbox.maxX - bbox.minX).toBeCloseTo(80, 0);
-            expect(bbox.maxY - bbox.minY).toBeCloseTo(40, 0);
-        });
-    });
 });

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

@@ -33,12 +33,4 @@ describe("slot", () => {
             expect(arcEdges.length).toBeGreaterThan(0);
         });
     });
-    describe("standalone with targetPlane", () => {
-        it("should create a slot on a specific plane", () => {
-            slot("xy", 60, 10);
-            const e = extrude(10);
-            render();
-            expect(e.getShapes()).toHaveLength(1);
-        });
-    });
 });

package/lib/dist/tests/features/fillet2d.test.js

@@ -4,7 +4,7 @@ import sketch from "../../core/sketch.js";
 import extrude from "../../core/extrude.js";
 import fillet from "../../core/fillet.js";
 import fuse from "../../core/fuse.js";
-import { hMove, rect } from "../../core/2d/index.js";
+import { arc, hMove, rect, vLine, hLine, vMove, back } from "../../core/2d/index.js";
 import { getEdgesByType } from "../utils.js";
 describe("fillet2d", () => {
     setupOC();
@@ -51,6 +51,42 @@ describe("fillet2d", () => {
             // 4 shortened sides per face (8) + 4 vertical edges each split into segments (8) = 16
             expect(getEdgesByType(solid, "line")).toHaveLength(16);
         });
+        it("should fillet a corner passed as radius-first spread args", () => {
+            const s = sketch("xy", () => {
+                const l1 = hLine(40);
+                const l2 = vLine(-40);
+                fillet(8, l1, l2);
+            });
+            render();
+            // The corner is rounded: each line is shortened and one fillet arc inserted.
+            // Before the radius-first spread dispatch existed, fillet(8, l1, l2) was a
+            // silent no-op (returned undefined) and produced 0 arcs.
+            expect(getEdgesByType(s.getEdges(), "arc")).toHaveLength(1);
+            expect(getEdgesByType(s.getEdges(), "line")).toHaveLength(2);
+        });
+        it("fillets an arc/line corner passed as radius-first spread args", () => {
+            // The exact shape from the original bug report: a fillet between an arc (l1)
+            // and a line (l2) requested as fillet(radius, l2, l1). Before the radius-first
+            // spread form was dispatched, this was a silent no-op while fillet(8) (all
+            // corners) rounded the same arc/line corner.
+            const s = sketch("front", () => {
+                vMove(10);
+                const gl = hLine(140).guide().centered();
+                back();
+                vMove(33 + 16);
+                hLine(8);
+                vLine(-16);
+                hLine(15 - 8);
+                const l1 = arc(gl.end()).radius(55);
+                const l2 = vLine(-10);
+                fillet(8, l2, l1);
+            });
+            render();
+            // Baseline (no fillet) is 1 arc; rounding the arc/line corner shortens the
+            // original arc and inserts the fillet arc -> 2 arcs. The array form
+            // fillet([l2, l1], 8) produces the identical result.
+            expect(getEdgesByType(s.getEdges(), "arc")).toHaveLength(2);
+        });
     });
     describe("fillet radius", () => {
         it("should use default radius of 1", () => {

package/lib/dist/tests/features/loft-conditions.test.d.ts

@@ -0,0 +1 @@
+export {};