fluidcad 0.0.28 → 0.0.30

package/lib/dist/helpers/scene-helpers.js

@@ -8,8 +8,8 @@ import { Edge } from "../common/edge.js";
 import { getOC } from "../oc/init.js";
 import { ColorTransfer } from "../oc/color-transfer.js";
 export function fuseWithSceneObjects(sceneObjects, extrusions, opts) {
+    const p = opts?.profiler;
     const modified = [];
-    const tCollect = performance.now();
     const objShapeMap = new Map();
     for (const obj of sceneObjects) {
         const shapes = obj.getShapes({}, 'solid');
@@ -18,15 +18,15 @@ export function fuseWithSceneObjects(sceneObjects, extrusions, opts) {
         }
     }
     let sceneShapes = Array.from(objShapeMap.keys());
-    console.log(`[perf] fuseWithSceneObjects.collect (scenes=${sceneShapes.length}, extrusions=${extrusions.length}): ${(performance.now() - tCollect).toFixed(1)} ms`);
-    const tFuse = performance.now();
-    const { result, newShapes, modifiedShapes, maker, dispose } = BooleanOps.fuseStockAndTools(sceneShapes, extrusions, opts);
-    console.log(`[perf] fuseWithSceneObjects.BooleanOps.fuseStockAndTools (glue=${opts?.glue ?? 'off'}): ${(performance.now() - tFuse).toFixed(1)} ms`);
+    const fuseRun = () => BooleanOps.fuseStockAndTools(sceneShapes, extrusions, opts);
+    const { result, newShapes, modifiedShapes, maker, dispose } = p
+        ? p.record('Boolean fuse', fuseRun)
+        : fuseRun();
     if (newShapes.length === 0 && modifiedShapes.length === 0) {
-        console.log("No fusions were made.");
         dispose();
         if (opts?.recordHistoryFor) {
-            recordShapesAsAdditions(opts.recordHistoryFor, extrusions);
+            const run = () => recordShapesAsAdditions(opts.recordHistoryFor, extrusions);
+            p ? p.record('Record fusion history', run) : run();
         }
         return {
             newShapes: extrusions,
@@ -44,12 +44,18 @@ export function fuseWithSceneObjects(sceneObjects, extrusions, opts) {
     const shapesToAdd = result.filter(s => !unconsumed.some(u => u.getShape().IsPartner(s.getShape())));
     let toolHistory;
     if (opts?.recordHistoryFor) {
-        recordFusionHistory(opts.recordHistoryFor, sceneShapes, objShapeMap, shapesToAdd, maker);
-        // Separately track tool-side (extrusion) lineage so callers can remap
-        // pre-fusion categorizations (start/end/side/…) onto the post-fusion
-        // faces. We don't store these as modifications on any scene object —
-        // from the user's POV they are additions on the caller already.
-        toolHistory = ShapeHistoryTracker.collect(maker, extrusions);
+        const recordHistory = () => {
+            recordFusionHistory(opts.recordHistoryFor, sceneShapes, objShapeMap, shapesToAdd, maker, p);
+            // Separately track tool-side (extrusion) lineage so callers can remap
+            // pre-fusion categorizations (start/end/side/…) onto the post-fusion
+            // faces. We don't store these as modifications on any scene object —
+            // from the user's POV they are additions on the caller already.
+            // Tool-side history is only consumed by `remapClassifiedFaces`, which
+            // touches modifiedFaces only — skip the added* output traversal.
+            const collectTools = () => ShapeHistoryTracker.collect(maker, extrusions, { skipAdded: true });
+            toolHistory = p ? p.record('Collect tool history', collectTools) : collectTools();
+        };
+        p ? p.record('Record fusion history', recordHistory) : recordHistory();
     }
     dispose();
     return { newShapes: shapesToAdd, modifiedShapes: modified, toolHistory };
@@ -80,51 +86,62 @@ function recordShapesAsAdditions(caller, shapes) {
  * of a scene-shape modification. This captures both extrusion-derived faces
  * (which appear in the result via tool-side Modified()) and truly new faces.
  */
-function recordFusionHistory(caller, sceneShapes, owners, newShapes, maker) {
+function recordFusionHistory(caller, sceneShapes, owners, newShapes, maker, p) {
     const oc = getOC();
     const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
     const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
     const claimedFaces = new oc.TopTools_MapOfShape();
     const claimedEdges = new oc.TopTools_MapOfShape();
-    for (const sceneShape of sceneShapes) {
-        const owner = owners.get(sceneShape);
-        if (!owner) {
-            continue;
-        }
-        const history = ShapeHistoryTracker.collect(maker, [sceneShape]);
-        for (const record of history.modifiedFaces) {
-            owner.recordModifiedFaces(record.sources, record.results, caller);
-            for (const r of record.results) {
-                claimedFaces.Add(r.getShape());
+    const collectScene = () => {
+        for (const sceneShape of sceneShapes) {
+            const owner = owners.get(sceneShape);
+            if (!owner) {
+                continue;
             }
-        }
-        for (const record of history.modifiedEdges) {
-            owner.recordModifiedEdges(record.sources, record.results, caller);
-            for (const r of record.results) {
-                claimedEdges.Add(r.getShape());
+            // recordFusionHistory aggregates additions across the full result via
+            // `claimedFaces`/`claimedEdges` below — each per-shape collect doesn't
+            // need to compute its own added* sets.
+            const history = ShapeHistoryTracker.collect(maker, [sceneShape], { skipAdded: true });
+            for (const record of history.modifiedFaces) {
+                owner.recordModifiedFaces(record.sources, record.results, caller);
+                for (const r of record.results) {
+                    claimedFaces.Add(r.getShape());
+                }
             }
-        }
-        for (const face of history.removedFaces) {
-            owner.recordRemovedFace(face, caller);
-        }
-        for (const edge of history.removedEdges) {
-            owner.recordRemovedEdge(edge, caller);
-        }
-    }
-    for (const newShape of newShapes) {
-        for (const raw of Explorer.findShapes(newShape.getShape(), FACE)) {
-            if (!claimedFaces.Contains(raw)) {
-                caller.recordAddedFace(Face.fromTopoDSFace(Explorer.toFace(raw)), caller);
+            for (const record of history.modifiedEdges) {
+                owner.recordModifiedEdges(record.sources, record.results, caller);
+                for (const r of record.results) {
+                    claimedEdges.Add(r.getShape());
+                }
+            }
+            for (const face of history.removedFaces) {
+                owner.recordRemovedFace(face, caller);
+            }
+            for (const edge of history.removedEdges) {
+                owner.recordRemovedEdge(edge, caller);
             }
         }
-        for (const raw of Explorer.findShapes(newShape.getShape(), EDGE)) {
-            if (!claimedEdges.Contains(raw)) {
-                caller.recordAddedEdge(Edge.fromTopoDSEdge(Explorer.toEdge(raw)), caller);
+    };
+    p ? p.record('Collect scene history', collectScene) : collectScene();
+    const recordAdditions = () => {
+        for (const newShape of newShapes) {
+            for (const raw of Explorer.findShapes(newShape.getShape(), FACE)) {
+                if (!claimedFaces.Contains(raw)) {
+                    caller.recordAddedFace(Face.fromTopoDSFace(Explorer.toFace(raw)), caller);
+                }
+            }
+            for (const raw of Explorer.findShapes(newShape.getShape(), EDGE)) {
+                if (!claimedEdges.Contains(raw)) {
+                    caller.recordAddedEdge(Edge.fromTopoDSEdge(Explorer.toEdge(raw)), caller);
+                }
             }
         }
-    }
-    ColorTransfer.applyThroughMaker(sceneShapes, newShapes, maker);
-    ColorTransfer.applyBleeding(sceneShapes, newShapes, maker);
+    };
+    p ? p.record('Record additions', recordAdditions) : recordAdditions();
+    const colorThrough = () => ColorTransfer.applyThroughMaker(sceneShapes, newShapes, maker);
+    p ? p.record('Color through maker', colorThrough) : colorThrough();
+    const colorBleed = () => ColorTransfer.applyBleeding(sceneShapes, newShapes, maker);
+    p ? p.record('Color bleeding', colorBleed) : colorBleed();
     claimedFaces.delete();
     claimedEdges.delete();
 }
@@ -229,7 +246,10 @@ function recordCutHistory(caller, stock, owners, cleanedShapes, maker, cleanups)
         if (!owner) {
             continue;
         }
-        const history = ShapeHistoryTracker.collect(maker, [stockShape]);
+        // Same as the fuse path: additions are aggregated below across the full
+        // cleaned result via `claimedFaces`/`claimedEdges`, so each per-shape
+        // collect can skip its own added* output traversal.
+        const history = ShapeHistoryTracker.collect(maker, [stockShape], { skipAdded: true });
         for (const record of history.modifiedFaces) {
             const postCleanResults = remapPreCleanFaces(record.results);
             if (postCleanResults.length === 0) {

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

@@ -58,6 +58,12 @@ export class ColorTransfer {
      * 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;

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

@@ -9,6 +9,7 @@ export declare class EdgeOps {
     static getLastVertex(edge: Edge): Vertex;
     static edgeToAxis(edge: Edge): Axis;
     static axisToEdge(axis: Axis): Edge;
+    static makeLineEdge(p1: Point, p2: Point): Edge;
     static getVertexPoint(vertex: Vertex): Point;
     static getEdgeMidPoint(edge: Edge): Point;
     static reverseEdge(edge: Edge): Edge;

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

@@ -19,6 +19,23 @@ export class EdgeOps {
     static axisToEdge(axis) {
         return Edge.fromTopoDSEdge(EdgeOps.axisToEdgeRaw(axis));
     }
+    static makeLineEdge(p1, p2) {
+        const oc = getOC();
+        const [gp1, dispose1] = Convert.toGpPnt(p1);
+        const [gp2, dispose2] = Convert.toGpPnt(p2);
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(gp1, gp2);
+        if (!edgeMaker.IsDone()) {
+            edgeMaker.delete();
+            dispose1();
+            dispose2();
+            throw new Error("Failed to create line edge");
+        }
+        const edge = edgeMaker.Edge();
+        edgeMaker.delete();
+        dispose1();
+        dispose2();
+        return Edge.fromTopoDSEdge(edge);
+    }
     static getVertexPoint(vertex) {
         return EdgeOps.getVertexPointRaw(vertex.getShape());
     }

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

@@ -3,6 +3,23 @@ import { Vector3d } from "../math/vector3d.js";
 import { Plane } from "../math/plane.js";
 import { Axis } from "../math/axis.js";
 import { Shape } from "../common/shape.js";
+import { Face } from "../common/face.js";
+/**
+ * History-based result of a `BRepPrimAPI_MakeRevol` operation. `firstFace` /
+ * `lastFace` come from the maker's `FirstShape` / `LastShape` (null on full
+ * revolution where the source face is absorbed). `edgeFaces` maps each edge
+ * of the input face to the swept face it generated, so callers can classify
+ * by input-edge category instead of geometric heuristics.
+ */
+export interface MakeRevolResult {
+    solid: Shape;
+    firstFace: Face | null;
+    lastFace: Face | null;
+    edgeFaces: {
+        edge: TopoDS_Shape;
+        face: Face | null;
+    }[];
+}
 export declare class ExtrudeOps {
     static makePrism(shape: Shape, direction: Vector3d, distance: number): Shape;
     static makePrismFromVec(shape: Shape, vec: Vector3d): {
@@ -12,7 +29,7 @@ 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): Shape;
+    static makeRevol(shape: Shape, axis: Axis, angle: number): MakeRevolResult;
     static applyDraftOnSideFaces(solid: Shape, firstFace: Shape, lastFace: Shape, plane: Plane, angle: number): {
         solid: Shape;
         firstFace: Shape;

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

@@ -1,6 +1,7 @@
 import { getOC } from "./init.js";
 import { Convert } from "./convert.js";
 import { Explorer } from "./explorer.js";
+import { Face } from "../common/face.js";
 import { ShapeFactory } from "../common/shape-factory.js";
 import { ShapeOps } from "./shape-ops.js";
 export class ExtrudeOps {
@@ -73,6 +74,20 @@ export class ExtrudeOps {
             throw new Error("Revolution failed");
         }
         const rawResult = revol.Shape();
+        // Capture history while the maker is alive. For full revolution the
+        // source face is absorbed (IsDeleted), so first/last are meaningless.
+        const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
+        const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+        const sourceDeleted = revol.IsDeleted(shape.getShape());
+        const firstShapeRaw = sourceDeleted ? null : revol.FirstShape();
+        const lastShapeRaw = sourceDeleted ? null : revol.LastShape();
+        const inputEdgesRaw = Explorer.findShapes(shape.getShape(), EDGE);
+        const edgeFacesRaw = [];
+        for (const edge of inputEdgesRaw) {
+            const generated = ShapeOps.shapeListToArray(revol.Generated(edge))
+                .filter(s => s.ShapeType() === FACE);
+            edgeFacesRaw.push({ edge, face: generated[0] ?? null });
+        }
         revol.delete();
         disposeAx1();
         // A profile face whose normal points "backwards" relative to the axis
@@ -86,7 +101,25 @@ export class ExtrudeOps {
             oriented = solid;
         }
         const clean = ShapeOps.cleanShapeRaw(oriented);
-        return ShapeFactory.fromShape(clean);
+        const cleanedFaceRaws = Explorer.findShapes(clean, FACE);
+        const wrappedFaces = cleanedFaceRaws.map(f => Face.fromTopoDSFace(Explorer.toFace(f)));
+        const findFace = (raw) => {
+            if (!raw) {
+                return null;
+            }
+            for (let i = 0; i < cleanedFaceRaws.length; i++) {
+                if (cleanedFaceRaws[i].IsSame(raw)) {
+                    return wrappedFaces[i];
+                }
+            }
+            return null;
+        };
+        return {
+            solid: ShapeFactory.fromShape(clean),
+            firstFace: findFace(firstShapeRaw),
+            lastFace: findFace(lastShapeRaw),
+            edgeFaces: edgeFacesRaw.map(({ edge, face }) => ({ edge, face: findFace(face) })),
+        };
     }
     static applyDraftOnSideFaces(solid, firstFace, lastFace, plane, angle) {
         const oc = getOC();

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

@@ -9,6 +9,7 @@ export declare class Geometry {
     static makeArcFromAngle(center: Point, radius: number, normal: Vector3d, start: Point, angle: number): Geom_TrimmedCurve;
     static makeArcFromTangent(start: Point, end: Point, tangent: Vector3d): Geom_TrimmedCurve;
     static makeCircle(center: Point, radius: number, normal: Vector3d): Geom_Circle;
+    static makeEllipseEdge(center: Point, majorRadius: number, minorRadius: number, normal: Vector3d, majorAxisDir: Vector3d): Edge;
     static makeBezierCurve(poles: Point[]): Geom_BezierCurve;
     static makeEdgeFromBezier(curve: Geom_BezierCurve): Edge;
     static makeEdge(geometry: Geom_TrimmedCurve): Edge;

package/lib/dist/oc/geometry.js

@@ -140,6 +140,33 @@ export class Geometry {
         disposeDir();
         throw new Error('Failed to create circle edge: ' + status);
     }
+    static makeEllipseEdge(center, majorRadius, minorRadius, normal, majorAxisDir) {
+        const oc = getOC();
+        const [gpCenter, disposeCenter] = Convert.toGpPnt(center);
+        const [gpNormal, disposeNormal] = Convert.toGpDir(normal);
+        const [gpAxisDir, disposeAxisDir] = Convert.toGpDir(majorAxisDir);
+        const ax2 = new oc.gp_Ax2(gpCenter, gpNormal, gpAxisDir);
+        const gpEllipse = new oc.gp_Elips(ax2, majorRadius, minorRadius);
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(gpEllipse);
+        if (edgeMaker.IsDone()) {
+            const edge = edgeMaker.Edge();
+            edgeMaker.delete();
+            gpEllipse.delete();
+            ax2.delete();
+            disposeAxisDir();
+            disposeNormal();
+            disposeCenter();
+            return Edge.fromTopoDSEdge(edge);
+        }
+        const status = edgeMaker.Error();
+        edgeMaker.delete();
+        gpEllipse.delete();
+        ax2.delete();
+        disposeAxisDir();
+        disposeNormal();
+        disposeCenter();
+        throw new Error('Failed to create ellipse edge: ' + status);
+    }
     static makeBezierCurve(poles) {
         const oc = getOC();
         const polesArray = new oc.TColgp_Array1OfPnt(1, poles.length);

package/lib/dist/oc/mesh.js

@@ -1,4 +1,5 @@
 import { getOC } from "./init.js";
+import { Explorer } from "./explorer.js";
 // Flip to false to benchmark single-threaded meshing.
 const DEFAULT_LIN_DEFLECTION = 0.1;
 const DEFAULT_ANG_DEFLECTION = 0.5;
@@ -24,6 +25,7 @@ export class Mesh {
         if (oc.BRepTools.Triangulation(shape, linDefl, checkFreeEdges)) {
             return false;
         }
+        console.log('Triangulating shape of type', Explorer.getShapeType(shape));
         const inc = new oc.BRepMesh_IncrementalMesh(shape, linDefl, relative, angDefl, true);
         inc.delete();
         return true;
@@ -45,13 +47,13 @@ export class Mesh {
         const normals = [];
         const indices = [];
         const aLocation = new oc.TopLoc_Location();
-        const myT = oc.BRep_Tool.Triangulation(face, aLocation, 0);
-        if (myT.IsNull()) {
+        const faceTriangulation = oc.BRep_Tool.Triangulation(face, aLocation, 0);
+        if (faceTriangulation.IsNull()) {
             aLocation.delete();
             return null;
         }
-        const pc = new oc.Poly_Connect(myT);
-        const triangulation = myT.get();
+        const pc = new oc.Poly_Connect(faceTriangulation);
+        const triangulation = faceTriangulation.get();
         const nbNodes = triangulation.NbNodes();
         for (let i = 1; i <= nbNodes; i++) {
             const t1 = aLocation.Transformation();
@@ -62,11 +64,11 @@ export class Mesh {
             p1.delete();
             t1.delete();
         }
-        const myNormal = new oc.TColgp_Array1OfDir(1, nbNodes);
-        oc.StdPrs_ToolTriangulatedShape.Normal(face, pc, myNormal);
+        const faceNormals = new oc.TColgp_Array1OfDir(1, nbNodes);
+        oc.StdPrs_ToolTriangulatedShape.Normal(face, pc, faceNormals);
         for (let i = 1; i <= nbNodes; i++) {
             const t1 = aLocation.Transformation();
-            const d1 = myNormal.Value(i);
+            const d1 = faceNormals.Value(i);
             const d = d1.Transformed(t1);
             normals.push(d.X(), d.Y(), d.Z());
             d1.delete();
@@ -87,9 +89,9 @@ export class Mesh {
             t.delete();
         }
         pc.delete();
-        myNormal.delete();
+        faceNormals.delete();
         triangles.delete();
-        myT.delete();
+        faceTriangulation.delete();
         aLocation.delete();
         return { vertices, normals, indices, count: nbNodes };
     }

package/lib/dist/oc/ray-intersect.d.ts

@@ -0,0 +1,16 @@
+import { Plane } from "../math/plane.js";
+import { Point2D } from "../math/point.js";
+import { SceneObject } from "../common/scene-object.js";
+/**
+ * Finds the nearest intersection of an oriented "ray" with a target geometry's
+ * edges, returning the result in sketch-local 2D coordinates.
+ *
+ * The ray is modelled as a long bounded segment centered on `start` along
+ * `direction`, so hits on either side of `start` are considered. The nearest
+ * hit (by absolute signed distance) is returned. Hits that coincide with
+ * `start` (within tolerance) are skipped so a start point already on the
+ * target is not picked.
+ *
+ * Throws if the target produces no usable edge hits.
+ */
+export declare function findNearestRayIntersection(plane: Plane, start: Point2D, direction: Point2D, target: SceneObject): Point2D;

package/lib/dist/oc/ray-intersect.js

@@ -0,0 +1,91 @@
+import { getOC } from "./init.js";
+import { Geometry } from "./geometry.js";
+import { Explorer } from "./explorer.js";
+import { Point, Point2D } from "../math/point.js";
+const PROBE_HALF_LENGTH = 1e6;
+const ON_TARGET_EPSILON = 1e-7;
+/**
+ * Finds the nearest intersection of an oriented "ray" with a target geometry's
+ * edges, returning the result in sketch-local 2D coordinates.
+ *
+ * The ray is modelled as a long bounded segment centered on `start` along
+ * `direction`, so hits on either side of `start` are considered. The nearest
+ * hit (by absolute signed distance) is returned. Hits that coincide with
+ * `start` (within tolerance) are skipped so a start point already on the
+ * target is not picked.
+ *
+ * Throws if the target produces no usable edge hits.
+ */
+export function findNearestRayIntersection(plane, start, direction, target) {
+    const oc = getOC();
+    const dirLen = Math.hypot(direction.x, direction.y);
+    if (dirLen < 1e-12) {
+        throw new Error("findNearestRayIntersection: direction vector is zero");
+    }
+    const dir = new Point2D(direction.x / dirLen, direction.y / dirLen);
+    const probeStart2d = new Point2D(start.x - dir.x * PROBE_HALF_LENGTH, start.y - dir.y * PROBE_HALF_LENGTH);
+    const probeEnd2d = new Point2D(start.x + dir.x * PROBE_HALF_LENGTH, start.y + dir.y * PROBE_HALF_LENGTH);
+    const probeStartWorld = plane.localToWorld(probeStart2d);
+    const probeEndWorld = plane.localToWorld(probeEnd2d);
+    const probeCurve = Geometry.makeSegment(probeStartWorld, probeEndWorld);
+    const probeEdge = Geometry.makeEdgeRaw(probeCurve);
+    const targetEdges = [];
+    for (const shape of target.getShapes({ excludeGuide: false })) {
+        const inner = shape.getShape();
+        if (inner.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_EDGE) {
+            targetEdges.push(inner);
+        }
+        else {
+            const edges = Explorer.findShapes(inner, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+            for (const edge of edges) {
+                targetEdges.push(edge);
+            }
+        }
+    }
+    if (targetEdges.length === 0) {
+        probeEdge.delete();
+        throw new Error("Target geometry has no edges to intersect with");
+    }
+    // Probe edge is parameterized 0..2L by arc-length (GC_MakeSegment), with the
+    // start at param 0. Recover the world point at a given param via the curve
+    // adaptor, then convert to plane-local 2D.
+    const probeAdaptor = new oc.BRepAdaptor_Curve(probeEdge);
+    let bestHit = null;
+    let bestSignedDist = Infinity;
+    for (const targetEdge of targetEdges) {
+        const tool = new oc.IntTools_EdgeEdge(probeEdge, targetEdge);
+        tool.Perform();
+        if (!tool.IsDone()) {
+            tool.delete();
+            continue;
+        }
+        const parts = tool.CommonParts();
+        const partCount = parts.Length();
+        for (let i = 1; i <= partCount; i++) {
+            const cp = parts.Value(i);
+            if (cp.Type() !== oc.TopAbs_ShapeEnum.TopAbs_VERTEX) {
+                continue;
+            }
+            const probeParam = cp.VertexParameter1();
+            const gpHit = probeAdaptor.Value(probeParam);
+            const hitWorld = new Point(gpHit.X(), gpHit.Y(), gpHit.Z());
+            gpHit.delete();
+            const hit2d = plane.worldToLocal(hitWorld);
+            const signedDist = (hit2d.x - start.x) * dir.x + (hit2d.y - start.y) * dir.y;
+            if (Math.abs(signedDist) < ON_TARGET_EPSILON) {
+                continue;
+            }
+            if (Math.abs(signedDist) < Math.abs(bestSignedDist)) {
+                bestSignedDist = signedDist;
+                bestHit = hit2d;
+            }
+        }
+        tool.delete();
+    }
+    probeAdaptor.delete();
+    probeEdge.delete();
+    if (!bestHit) {
+        throw new Error("Line does not intersect target geometry");
+    }
+    return bestHit;
+}

package/lib/dist/oc/thin-face-maker.d.ts

@@ -30,7 +30,6 @@ export declare class ThinFaceMaker {
      * breaking IsPartner identity between original wire edges and face edges.
      */
     private static matchFaceEdgesByMidpoint;
-    private static makeLineEdge;
     /**
      * Creates a closed face from two open wires by capping the ends with straight lines.
      * wire1 goes A->B, wire2 goes C->D.

package/lib/dist/oc/thin-face-maker.js

@@ -1,4 +1,3 @@
-import { Edge } from "../common/edge.js";
 import { Face } from "../common/face.js";
 import { Wire } from "../common/wire.js";
 import { WireOps } from "./wire-ops.js";
@@ -162,23 +161,6 @@ export class ThinFaceMaker {
             return wireMidpoints.some(mp => feMid.distanceTo(mp) < 1e-4);
         });
     }
-    static makeLineEdge(p1, p2) {
-        const oc = getOC();
-        const [gp1, dispose1] = Convert.toGpPnt(p1);
-        const [gp2, dispose2] = Convert.toGpPnt(p2);
-        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(gp1, gp2);
-        if (!edgeMaker.IsDone()) {
-            edgeMaker.delete();
-            dispose1();
-            dispose2();
-            throw new Error("Failed to create cap edge for thin extrude");
-        }
-        const edge = edgeMaker.Edge();
-        edgeMaker.delete();
-        dispose1();
-        dispose2();
-        return Edge.fromTopoDSEdge(edge);
-    }
     /**
      * Creates a closed face from two open wires by capping the ends with straight lines.
      * wire1 goes A->B, wire2 goes C->D.
@@ -189,8 +171,8 @@ export class ThinFaceMaker {
         const wire2Start = wire2.getFirstVertex().toPoint();
         const wire2End = wire2.getLastVertex().toPoint();
         const wire1Start = wire1.getFirstVertex().toPoint();
-        const cap1 = this.makeLineEdge(wire1End, wire2End);
-        const cap2 = this.makeLineEdge(wire2Start, wire1Start);
+        const cap1 = EdgeOps.makeLineEdge(wire1End, wire2End);
+        const cap2 = EdgeOps.makeLineEdge(wire2Start, wire1Start);
         const reversedWire2 = WireOps.reverseWire(wire2);
         const allEdges = [
             ...wire1.getEdges(),

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

@@ -3,7 +3,8 @@ export declare class SceneRenderer {
     private readonly meshBuilder;
     render(scene: Scene): Scene;
     renderRollback(scene: Scene, rollbackIndex: number): Scene;
-    private renderObject;
+    private prepareRenderedShapes;
+    private emitRenderObject;
     private buildObject;
     private getOrBuildMeshes;
     private toRenderedShape;