fluidcad 0.0.32 → 0.0.34

package/lib/dist/oc/topology-index.js

@@ -0,0 +1,36 @@
+import { getOC } from "./init.js";
+export class TopologyIndex {
+    static buildEdgeToFaces(root) {
+        const oc = getOC();
+        const map = new oc.TopTools_IndexedDataMapOfShapeListOfShape();
+        oc.TopExp.MapShapesAndAncestors(root, oc.TopAbs_ShapeEnum.TopAbs_EDGE, oc.TopAbs_ShapeEnum.TopAbs_FACE, map);
+        return map;
+    }
+    static buildShapeSet(shapes) {
+        const oc = getOC();
+        const map = new oc.TopTools_MapOfShape();
+        for (const s of shapes) {
+            map.Add(s);
+        }
+        return map;
+    }
+    static seekShapes(index, key) {
+        const idx = index.FindIndex(key);
+        if (idx === 0) {
+            return [];
+        }
+        const list = index.ChangeFromIndex(idx);
+        if (!list || list.Size() === 0) {
+            return [];
+        }
+        const oc = getOC();
+        const copy = new oc.TopTools_ListOfShape(list);
+        const out = [];
+        while (copy.Size() > 0) {
+            out.push(copy.First());
+            copy.RemoveFirst();
+        }
+        copy.delete();
+        return out;
+    }
+}

package/lib/dist/rendering/mesh-builder.d.ts

@@ -1,5 +1,8 @@
 import { Shape } from "../common/shape.js";
 import { SceneObjectMesh } from "./scene.js";
+import type { MeshConfig } from "../oc/mesh.js";
 export declare class MeshBuilder {
+    private readonly meshConfig;
+    constructor(meshConfig: MeshConfig);
     build(shapeObj: Shape): SceneObjectMesh[];
 }

package/lib/dist/rendering/mesh-builder.js

@@ -4,20 +4,24 @@ import { renderFace } from "./render-face.js";
 import { renderWire } from "./render-wire.js";
 import { renderEdge } from "./render-edge.js";
 export class MeshBuilder {
+    meshConfig;
+    constructor(meshConfig) {
+        this.meshConfig = meshConfig;
+    }
     build(shapeObj) {
         const shape = shapeObj.getShape();
         let result = null;
         if (Explorer.isSolid(shape)) {
-            result = renderSolid(shapeObj);
+            result = renderSolid(shapeObj, this.meshConfig);
         }
         else if (Explorer.isFace(shape)) {
-            result = renderFace(shapeObj);
+            result = renderFace(shapeObj, 0, this.meshConfig);
         }
         else if (Explorer.isWire(shape)) {
-            result = renderWire(shapeObj);
+            result = renderWire(shapeObj, this.meshConfig);
         }
         else if (Explorer.isEdge(shape)) {
-            result = renderEdge(shapeObj);
+            result = renderEdge(shapeObj, this.meshConfig);
         }
         else if (Explorer.isCompound(shape)) {
             console.warn("Compound shapes are not supported yet.");

package/lib/dist/rendering/render-edge.d.ts

@@ -1,3 +1,4 @@
 import { Shape } from "../common/shape.js";
+import type { MeshConfig } from "../oc/mesh.js";
 import type { SceneObjectMesh } from "./scene.js";
-export declare function renderEdge(edgeObj: Shape): SceneObjectMesh;
+export declare function renderEdge(edgeObj: Shape, meshConfig?: MeshConfig): SceneObjectMesh;

package/lib/dist/rendering/render-edge.js

@@ -1,4 +1,4 @@
 import { Mesh } from "../oc/mesh.js";
-export function renderEdge(edgeObj) {
-    return Mesh.discretizeEdge(edgeObj);
+export function renderEdge(edgeObj, meshConfig) {
+    return Mesh.discretizeEdge(edgeObj, meshConfig);
 }

package/lib/dist/rendering/render-face.d.ts

@@ -1,2 +1,3 @@
 import { Shape } from "../common/shape.js";
-export declare function renderFace(faceObj: Shape, vertexOffset?: number): import("../oc/mesh.js").MeshData;
+import type { MeshConfig } from "../oc/mesh.js";
+export declare function renderFace(faceObj: Shape, vertexOffset?: number, meshConfig?: MeshConfig): import("../oc/mesh.js").MeshData;

package/lib/dist/rendering/render-face.js

@@ -1,5 +1,5 @@
 import { Mesh } from "../oc/mesh.js";
-export function renderFace(faceObj, vertexOffset = 0) {
+export function renderFace(faceObj, vertexOffset = 0, meshConfig) {
     const face = faceObj.getShape();
-    return Mesh.triangulateFaceRaw(face, vertexOffset);
+    return Mesh.triangulateFaceRaw(face, vertexOffset, meshConfig);
 }

package/lib/dist/rendering/render-solid.d.ts

@@ -1,3 +1,4 @@
 import { Shape } from "../common/shape.js";
 import { SceneObjectMesh } from "./scene.js";
-export declare function renderSolid(shapeObj: Shape): SceneObjectMesh[];
+import type { MeshConfig } from "../oc/mesh.js";
+export declare function renderSolid(shapeObj: Shape, meshConfig?: MeshConfig): SceneObjectMesh[];

package/lib/dist/rendering/render-solid.js

@@ -1,8 +1,8 @@
 import { Explorer } from "../oc/explorer.js";
 import { Mesh } from "../oc/mesh.js";
 import { getOC } from "../oc/init.js";
-export function renderSolid(shapeObj) {
-    Mesh.ensureTriangulated(shapeObj.getShape());
+export function renderSolid(shapeObj, meshConfig) {
+    Mesh.ensureTriangulated(shapeObj.getShape(), meshConfig);
     const facesMeshes = getFacesMesh(shapeObj);
     const edgesMesh = getEdgesMesh(shapeObj);
     return [...facesMeshes, ...edgesMesh];
@@ -10,8 +10,7 @@ export function renderSolid(shapeObj) {
 function getEdgesMesh(shapeObj) {
     const oc = getOC();
     const result = [];
-    const edgeToFaces = new oc.TopTools_IndexedDataMapOfShapeListOfShape();
-    oc.TopExp.MapShapesAndAncestors(shapeObj.getShape(), oc.TopAbs_ShapeEnum.TopAbs_EDGE, oc.TopAbs_ShapeEnum.TopAbs_FACE, edgeToFaces);
+    const edgeToFaces = shapeObj.getEdgeToFacesIndex();
     const edges = Explorer.findEdgesWrapped(shapeObj);
     for (let edgeIdx = 0; edgeIdx < edges.length; edgeIdx++) {
         const edgeShape = edges[edgeIdx].getShape();
@@ -30,7 +29,6 @@ function getEdgesMesh(shapeObj) {
             });
         }
     }
-    edgeToFaces.delete();
     return result;
 }
 function getFacesMesh(shapeObj) {

package/lib/dist/rendering/render-wire.d.ts

@@ -1,5 +1,6 @@
 import { Shape } from "../common/shape.js";
-export declare function renderWire(shapeObj: Shape): {
+import type { MeshConfig } from "../oc/mesh.js";
+export declare function renderWire(shapeObj: Shape, meshConfig?: MeshConfig): {
     vertices: number[];
     normals: number[];
     indices: number[];

package/lib/dist/rendering/render-wire.js

@@ -2,9 +2,9 @@ import { renderEdge } from "./render-edge.js";
 import { Edge } from "../common/edge.js";
 import { Explorer } from "../oc/explorer.js";
 import { Mesh } from "../oc/mesh.js";
-export function renderWire(shapeObj) {
+export function renderWire(shapeObj, meshConfig) {
     const shape = shapeObj.getShape();
-    Mesh.ensureTriangulated(shape);
+    Mesh.ensureTriangulated(shape, meshConfig);
     const edges = Explorer.findShapes(shape, Explorer.getOcShapeType("edge"));
     const allVertices = [];
     const allNormals = [];

package/lib/dist/rendering/render.d.ts

@@ -1,8 +1,12 @@
 import { Scene } from "./scene.js";
+import type { MeshConfig } from "../oc/mesh.js";
 export declare class SceneRenderer {
+    private readonly meshConfig;
     private readonly meshBuilder;
+    constructor(meshConfig: MeshConfig);
     render(scene: Scene): Scene;
     renderRollback(scene: Scene, rollbackIndex: number): Scene;
+    private batchTriangulate;
     private prepareRenderedShapes;
     private emitRenderObject;
     private buildObject;

package/lib/dist/rendering/render.js

@@ -4,10 +4,16 @@ import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { Sketch } from "../features/2d/sketch.js";
 import { transformMeshes } from "./mesh-transform.js";
 import { ShapeOps } from "../oc/shape-ops.js";
+import { Mesh } from "../oc/mesh.js";
 import { Profiler } from "../common/profiler.js";
 import { describeError } from "../common/describe-error.js";
 export class SceneRenderer {
-    meshBuilder = new MeshBuilder();
+    meshConfig;
+    meshBuilder;
+    constructor(meshConfig) {
+        this.meshConfig = meshConfig;
+        this.meshBuilder = new MeshBuilder(meshConfig);
+    }
     render(scene) {
         const sceneObjects = scene.getAllSceneObjects();
         console.log("============ Rendering ==============", sceneObjects.length);
@@ -40,6 +46,7 @@ export class SceneRenderer {
             }
             object.clean(scene.getPartScopedAllObjects(object));
         }
+        this.batchTriangulate(sceneObjects, skippedContainers);
         const prepared = new Map();
         for (const object of sceneObjects) {
             const profiler = profilers.get(object);
@@ -88,6 +95,44 @@ export class SceneRenderer {
         console.table(result);
         return scene;
     }
+    // Mesh every shape that still needs triangulation in a single
+    // BRepMesh_IncrementalMesh call. OC's parallel mode then balances faces
+    // across all shapes at once instead of running per-shape sequentially.
+    // The triangulation lives on each TFace, so the existing per-shape
+    // extraction in prepareRenderedShapes finds it cached and short-circuits
+    // its own ensureTriangulated call.
+    batchTriangulate(sceneObjects, skippedContainers) {
+        const targets = new Set();
+        for (const object of sceneObjects) {
+            if (skippedContainers.has(object) || object.isLazy()) {
+                continue;
+            }
+            const shapes = object.getOwnShapes({ excludeMeta: false, excludeGuide: false });
+            for (const shape of shapes) {
+                if (shape.getMeshes()) {
+                    continue;
+                }
+                const source = shape.getMeshSource();
+                const target = source ? source.shape : shape;
+                if (target.getMeshes()) {
+                    continue;
+                }
+                targets.add(target);
+            }
+        }
+        if (targets.size <= 1) {
+            return;
+        }
+        const compound = ShapeOps.makeCompoundRaw([...targets].map(s => s.getShape()));
+        try {
+            const t0 = performance.now();
+            Mesh.ensureTriangulated(compound, this.meshConfig);
+            console.log(`Batched mesh: ${targets.size} shapes in ${(performance.now() - t0).toFixed(1)}ms`);
+        }
+        finally {
+            compound.delete();
+        }
+    }
     prepareRenderedShapes(obj, profiler) {
         const renderedSceneShapes = [];
         if (obj.isLazy()) {
@@ -249,9 +294,12 @@ export class SceneRenderer {
     emitRendered(obj, scene, opts) {
         const categories = opts.profiler?.getCategories();
         const profileCategories = categories && categories.length > 0 ? categories : undefined;
+        const displayName = obj.hasCustomName()
+            ? obj.getName()
+            : obj.getType().charAt(0).toUpperCase() + obj.getType().slice(1);
         const rendered = {
             id: obj.id,
-            name: obj.getName(),
+            name: displayName,
             parentId: obj.parentId,
             object: obj.serialize(opts.scope),
             sceneShapes: opts.sceneShapes,

package/lib/dist/rendering/scene-compare.js

@@ -31,6 +31,9 @@ export class SceneCompare {
             }
             oldSttate.set('removedShapes', newRemovedShapes);
             newObj.restoreState(oldSttate);
+            const staleId = newObj.id;
+            newObj.inheritIdentityFrom(oldObj);
+            newScene.reindexObject(newObj, staleId);
             const oldError = oldObj.getError();
             if (oldError) {
                 newObj.setError(oldError);

package/lib/dist/rendering/scene.d.ts

@@ -82,5 +82,6 @@ export declare class Scene {
     indexOf(obj: SceneObject): number;
     getSceneObjectAt(index: number): SceneObject;
     getSceneObjectById(id: string): SceneObject | null;
+    reindexObject(obj: SceneObject, oldId: string): void;
     getChildren(parent: SceneObject): SceneObject[];
 }

package/lib/dist/rendering/scene.js

@@ -201,6 +201,10 @@ export class Scene {
     getSceneObjectById(id) {
         return this.idMap.get(id) || null;
     }
+    reindexObject(obj, oldId) {
+        this.idMap.delete(oldId);
+        this.idMap.set(obj.id, obj);
+    }
     getChildren(parent) {
         return this.sceneObjects.filter(obj => obj.parentId === parent.id);
     }

package/lib/dist/scene-manager.d.ts

@@ -1,5 +1,7 @@
 import { Scene } from "./rendering/scene.js";
 import { SceneRenderer } from "./rendering/render.js";
+import type { MeshConfig } from "./oc/mesh.js";
+import type { FluidCADOptions } from "./index.js";
 import type { ExportOptions } from "./io/file-export.js";
 import type { ShapeProperties } from "./oc/props.js";
 import type { FaceProperties } from "./oc/face-props.js";
@@ -10,7 +12,7 @@ declare class SceneManager {
     currentScene: Scene;
     currentFile: string;
     renderer: SceneRenderer;
-    constructor(rootPath: string);
+    constructor(rootPath: string, meshConfig: MeshConfig);
     setCurrentFile(filePath: string): void;
     startScene(): Scene;
     renderScene(scene: Scene): Scene;
@@ -26,7 +28,7 @@ declare class SceneManager {
     };
     hitTest(scene: Scene, shapeId: string, rayOrigin: [number, number, number], rayDir: [number, number, number], edgeThreshold: number): HitTestResult;
 }
-export declare function createManager(rootPath: string): SceneManager;
+export declare function createManager(rootPath: string, options?: FluidCADOptions): SceneManager;
 export declare function getCurrentScene(): Scene;
 export declare function getCurrentFile(): string;
 export declare function setCurrentFile(filePath: string): void;

package/lib/dist/scene-manager.js

@@ -1,6 +1,7 @@
 import { Scene } from "./rendering/scene.js";
 import { SceneRenderer } from "./rendering/render.js";
 import { SceneCompare } from "./rendering/scene-compare.js";
+import { DEFAULT_MESH_CONFIG } from "./oc/mesh.js";
 import { FileImport } from "./io/file-import.js";
 import { FileExport } from "./io/file-export.js";
 import { ShapeProps } from "./oc/props.js";
@@ -12,9 +13,10 @@ class SceneManager {
     rootPath;
     currentScene = new Scene();
     currentFile = '';
-    renderer = new SceneRenderer();
-    constructor(rootPath) {
+    renderer;
+    constructor(rootPath, meshConfig) {
         this.rootPath = rootPath;
+        this.renderer = new SceneRenderer(meshConfig);
     }
     setCurrentFile(filePath) {
         this.currentFile = filePath;
@@ -100,9 +102,15 @@ class SceneManager {
     }
 }
 let currentManager = null;
-export function createManager(rootPath) {
+function resolveMeshConfig(options) {
+    return {
+        linDefl: options?.mesh?.lineDeflection ?? DEFAULT_MESH_CONFIG.linDefl,
+        angDefl: options?.mesh?.angularDeflection ?? DEFAULT_MESH_CONFIG.angDefl,
+    };
+}
+export function createManager(rootPath, options) {
     console.log(`Creating SceneManager with root path: ${rootPath}`);
-    currentManager = new SceneManager(rootPath);
+    currentManager = new SceneManager(rootPath, resolveMeshConfig(options));
     return currentManager;
 }
 export function getCurrentScene() {

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

@@ -36,6 +36,70 @@ describe("arc", () => {
             expect(arcEdges.length).toBeGreaterThan(0);
         });
     });
+    describe("clockwise arc with .cw()", () => {
+        it("should create a CW arc from start to end around a center point", () => {
+            sketch("xy", () => {
+                arc([0, 0], [20, 0]).center([10, 0]).cw();
+                line([0, 0]);
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+        it("should create a valid arc when chained from current position", () => {
+            sketch("xy", () => {
+                hLine(20);
+                arc([0, 0]).center([10, 0]).cw();
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+    });
+    describe("major arc with .major()", () => {
+        it("should create a major arc (>180°) from current position", () => {
+            sketch("xy", () => {
+                arc([30, 0]).radius(20).major();
+                line([0, 0]);
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+        it("should create a major arc with two explicit points", () => {
+            sketch("xy", () => {
+                arc([0, 0], [30, 0]).radius(20).major();
+                line([0, 0]);
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+        it("should create a CW major arc with negative radius and major", () => {
+            sketch("xy", () => {
+                arc([30, 0]).radius(-20).major();
+                line([0, 0]);
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+    });
     describe("combined with lines", () => {
         it("should create a shape with straight and curved edges", () => {
             sketch("xy", () => {

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

@@ -2,8 +2,9 @@ import { describe, it, expect } from "vitest";
 import { setupOC, render } from "../../setup.js";
 import sketch from "../../../core/sketch.js";
 import extrude from "../../../core/extrude.js";
-import { move, hMove, back, rect } from "../../../core/2d/index.js";
+import { move, hMove, back, rect, hLine, vLine, tLine } from "../../../core/2d/index.js";
 import { ShapeOps } from "../../../oc/shape-ops.js";
+import { Edge } from "../../../common/edge.js";
 describe("back", () => {
     setupOC();
     it("should revert cursor to the previous position", () => {
@@ -57,4 +58,19 @@ describe("back", () => {
         const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
         expect(bbox.minX).toBeCloseTo(40, 0);
     });
+    it("should restore the tangent to its prior value, not just the position", () => {
+        let t;
+        sketch("xy", () => {
+            hLine(10); // tangent (+1, 0), pos (10, 0)
+            vLine(10); // tangent (0, +1), pos (10, 10)
+            back(); // pos reverts to (10, 0); tangent should revert to (+1, 0)
+            t = tLine(5); // with restored tangent, this should go to (15, 0)
+        });
+        render();
+        const edges = t.getOwnShapes().filter((sh) => sh instanceof Edge);
+        expect(edges).toHaveLength(1);
+        const endPoint = edges[0].getLastVertex().toPoint();
+        expect(endPoint.x).toBeCloseTo(15, 1);
+        expect(endPoint.y).toBeCloseTo(0, 1);
+    });
 });

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

@@ -234,4 +234,161 @@ describe("tArc", () => {
             render();
         });
     });
+    describe("tangent arc from current position to target line (target)", () => {
+        it("should create a tangent arc from a horizontal line ending tangent to a vertical line", () => {
+            const s = sketch("xy", () => {
+                const v = vLine([200, 200], 100).guide();
+                move([0, 0]);
+                hLine(100);
+                tArc(v);
+            });
+            render();
+            const shapes = s.getShapes();
+            // hLine + tArc (guide excluded) = at least 2 edges
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should accept a qualified line target", () => {
+            const s = sketch("xy", () => {
+                const v = vLine([200, 200], 100).guide();
+                move([0, 0]);
+                hLine(100);
+                tArc(outside(v));
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should allow chaining geometry after the solved arc", () => {
+            const s = sketch("xy", () => {
+                const v = vLine([200, 200], 100).guide();
+                move([0, 0]);
+                hLine(100);
+                tArc(v);
+                vLine(40);
+            });
+            render();
+            const shapes = s.getShapes();
+            // chain continues — hLine + tArc + vLine
+            expect(shapes.length).toBeGreaterThanOrEqual(3);
+        });
+        it("default arc curves to the left of the start tangent", () => {
+            const s = sketch("xy", () => {
+                const h = hLine([-150, 100], 300).guide();
+                move([0, 0]);
+                vLine(80);
+                tArc(h);
+            });
+            render();
+            const arcs = getEdgesByType(s.getShapes(), "arc");
+            expect(arcs.length).toBe(1);
+            // start tangent is +Y; "left" of +Y is -X. End vertex sits at negative x.
+            const endX = arcs[0].getLastVertex().toPoint().x;
+            expect(endX).toBeLessThan(0);
+        });
+        it(".flip() reverses the curve to the right of the start tangent", () => {
+            const s = sketch("xy", () => {
+                const h = hLine([-150, 100], 300).guide();
+                move([0, 0]);
+                vLine(80);
+                tArc(h).flip();
+            });
+            render();
+            const arcs = getEdgesByType(s.getShapes(), "arc");
+            expect(arcs.length).toBe(1);
+            const endX = arcs[0].getLastVertex().toPoint().x;
+            expect(endX).toBeGreaterThan(0);
+        });
+        it("should reject circle targets", () => {
+            const s = sketch("xy", () => {
+                const c = circle([200, 80], 30).guide();
+                move([0, 0]);
+                hLine(100);
+                tArc(c);
+            });
+            render();
+            const children = s.getChildren();
+            const arc = children[children.length - 1];
+            expect(arc.getError()).toMatch(/only line targets are supported/);
+        });
+    });
+    describe("tangent arc with radius ending at intersection (radius, target)", () => {
+        it("should end at the intersection with a line target", () => {
+            const s = sketch("xy", () => {
+                const h = hLine([-200, 100], 400).guide();
+                move([0, 0]);
+                vLine(50);
+                tArc(60, h);
+            });
+            render();
+            const arcs = getEdgesByType(s.getShapes(), "arc");
+            expect(arcs.length).toBe(1);
+            // End vertex must lie on the target line y = 100.
+            const endY = arcs[0].getLastVertex().toPoint().y;
+            expect(endY).toBeCloseTo(100, 6);
+        });
+        it("should end at the intersection with a circle target", () => {
+            const s = sketch("xy", () => {
+                // circle(diameter); 80 diameter = 40 radius
+                const c = circle([80, 0], 80).guide();
+                move([0, 0]);
+                hLine(40);
+                tArc(50, c);
+            });
+            render();
+            const arcs = getEdgesByType(s.getShapes(), "arc");
+            expect(arcs.length).toBe(1);
+            // End vertex must lie on the target circle (radius 40 from (80, 0)).
+            const end = arcs[0].getLastVertex().toPoint();
+            const dist = Math.hypot(end.x - 80, end.y - 0);
+            expect(dist).toBeCloseTo(40, 6);
+        });
+        it("negative radius flips the sweep direction", () => {
+            // Same line, same start, same tangent — only the sign of the radius
+            // differs. Positive radius (CCW) curves to the left of the tangent;
+            // negative radius (CW) curves to the right.
+            const sCCW = sketch("xy", () => {
+                const h = hLine([-200, 100], 400).guide();
+                move([0, 0]);
+                vLine(50);
+                tArc(60, h);
+            });
+            render();
+            const sCW = sketch("xy", () => {
+                const h = hLine([-200, 100], 400).guide();
+                move([0, 0]);
+                vLine(50);
+                tArc(-60, h);
+            });
+            render();
+            const ccwArc = getEdgesByType(sCCW.getShapes(), "arc")[0];
+            const cwArc = getEdgesByType(sCW.getShapes(), "arc")[0];
+            // T̂ = (0, +1); "left" of the tangent is −x, "right" is +x.
+            expect(ccwArc.getLastVertex().toPoint().x).toBeLessThan(0);
+            expect(cwArc.getLastVertex().toPoint().x).toBeGreaterThan(0);
+        });
+        it("should chain geometry after the solved arc", () => {
+            const s = sketch("xy", () => {
+                const h = hLine([-200, 100], 400).guide();
+                move([0, 0]);
+                vLine(50);
+                tArc(60, h);
+                hLine(40);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(3);
+        });
+        it("should record an error when there is no intersection", () => {
+            const s = sketch("xy", () => {
+                const h = hLine([-200, 500], 400).guide();
+                move([0, 0]);
+                vLine(10);
+                tArc(20, h);
+            });
+            render();
+            const children = s.getChildren();
+            const arc = children[children.length - 1];
+            expect(arc.getError()).toMatch(/does not intersect target/);
+        });
+    });
 });

package/lib/dist/tests/features/color-lineage.test.js

@@ -159,6 +159,24 @@ describe("color preservation through operations (Phase 3 lineage)", () => {
         const orangeFaces = filleted.colorMap.filter(e => e.color === '#ffa500');
         expect(orangeFaces.length).toBeGreaterThanOrEqual(2);
     });
+    it("color does NOT bleed: filleting a side edge of a colored-top box leaves fillet faces uncolored", () => {
+        // The colored top face does NOT own the side (vertical) edges. Filleting
+        // those edges generates new corner faces whose lineage traces back to the
+        // side faces — so they must not inherit the top's color, even though
+        // their top arc is adjacent to the (still-orange) top face.
+        sketch("top", () => {
+            rect(100, 50).centered();
+        });
+        const e = extrude(20);
+        color("orange", e.endFaces());
+        const f = fillet(10, e.sideEdges());
+        render();
+        const filleted = f.getShapes()[0];
+        // Only the (Modified) top face should still be orange. The fillet faces
+        // came from side edges (uncolored), and the bottom was never colored.
+        const orangeCount = filleted.colorMap.filter(e => e.color === '#ffa500').length;
+        expect(orangeCount).toBe(1);
+    });
     it("color survives a chamfer", () => {
         sketch("xy", () => {
             circle(40);

package/lib/dist/tests/features/filter-positional.test.d.ts

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