fluidcad 0.0.26 → 0.0.27

package/lib/dist/features/mirror-shape.d.ts

@@ -8,7 +8,5 @@ export declare class MirrorShape extends SceneObject {
     compareTo(other: MirrorShape): boolean;
     getType(): string;
     getUniqueType(): string;
-    serialize(): {
-        plane: PlaneObjectBase;
-    };
+    serialize(): {};
 }

package/lib/dist/features/mirror-shape.js

@@ -47,6 +47,7 @@ export class MirrorShape extends SceneObject {
             for (const shape of shapes) {
                 const matrix = Matrix4.mirrorPlane(plane.normal, plane.origin);
                 const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
                 transformedShapes.push(transformed);
             }
         }
@@ -90,7 +91,7 @@ export class MirrorShape extends SceneObject {
     }
     serialize() {
         return {
-            plane: this.plane,
+        // plane: this.plane,
         };
     }
 }

package/lib/dist/features/revolve.js

@@ -9,6 +9,7 @@ import { ExtrudeBase } from "./extrude-base.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
 import { FaceOps } from "../oc/face-ops.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
+import { Matrix4 } from "../math/matrix4.js";
 export class Revolve extends ExtrudeBase {
     axis;
     angle;
@@ -45,8 +46,9 @@ export class Revolve extends ExtrudeBase {
             const solid = ExtrudeOps.makeRevol(face, axis, rad(this.angle));
             let resultSolid;
             if (this._symmetric) {
-                const rotated = ShapeOps.rotateShape(solid.getShape(), axis, -rad(this.angle) / 2);
-                resultSolid = Solid.fromTopoDSSolid(Explorer.toSolid(rotated));
+                const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, -rad(this.angle) / 2);
+                const rotated = ShapeOps.transform(solid, matrix);
+                resultSolid = Solid.fromTopoDSSolid(Explorer.toSolid(rotated.getShape()));
             }
             else {
                 resultSolid = Solid.fromTopoDSSolid(Explorer.toSolid(solid.getShape()));

package/lib/dist/features/rotate.js

@@ -41,6 +41,7 @@ export class Rotate extends SceneObject {
             const shapes = obj.getShapes();
             for (const shape of shapes) {
                 const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
                 this.addShape(transformed);
                 if (!this.copy) {
                     obj.removeShape(shape, this);

package/lib/dist/features/simple-extruder.js

@@ -42,9 +42,14 @@ export class Extruder {
         let lastFaces = [];
         let sideFaces = [];
         let internalFaces = [];
+        console.log("Fusing faces before extrusion...", this.faces.length);
+        const tFuseFaces = performance.now();
         const fusedFaces = BooleanOps.fuseFaces(this.faces);
+        console.log(`[perf] Extruder.fuseFaces (in=${this.faces.length}, out=${fusedFaces.result.length}): ${(performance.now() - tFuseFaces).toFixed(1)} ms`);
         for (const face of fusedFaces.result) {
+            const time = performance.now();
             let { solid, firstFace, lastFace } = ExtrudeOps.makePrismFromVec(face, vec);
+            console.log(`[perf] Extruder.makePrismFromVec: ${(performance.now() - time).toFixed(1)} ms`);
             if (this.draft) {
                 const draftResult = this.applyDraft(solid, firstFace, lastFace, this.plane);
                 solid = draftResult.solid;

package/lib/dist/features/translate.js

@@ -23,7 +23,9 @@ export class Translate extends SceneObject {
                     continue;
                 }
                 const amount = this.amount.asPoint();
-                let transformed = ShapeOps.transform(shape, Matrix4.fromTranslation(amount.x, amount.y, amount.z));
+                const matrix = Matrix4.fromTranslation(amount.x, amount.y, amount.z);
+                const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
                 this.addShape(transformed);
                 if (!this.copy) {
                     obj.removeShape(shape, this);

package/lib/dist/filters/face/face-filter.d.ts

@@ -58,6 +58,18 @@ export declare class FaceFilterBuilder extends FilterBuilderBase<Face> {
      * @param plane - The reference plane.
      */
     notParallelTo(plane: PlaneLike | PlaneObjectBase): this;
+    /**
+     * Selects toroidal faces, optionally matching major and/or minor radius.
+     * @param majorRadius - Optional radius from the torus axis to the tube center.
+     * @param minorRadius - Optional radius of the tube itself.
+     */
+    torus(majorRadius?: number, minorRadius?: number): this;
+    /**
+     * Excludes toroidal faces, optionally matching major and/or minor radius.
+     * @param majorRadius - Optional radius from the torus axis to the tube center.
+     * @param minorRadius - Optional radius of the tube itself.
+     */
+    notTorus(majorRadius?: number, minorRadius?: number): this;
     /**
      * Selects conical faces.
      */

package/lib/dist/filters/face/face-filter.js

@@ -4,6 +4,7 @@ import { CircleFilter, NotCircleFilter } from "./circle-filter.js";
 import { ConeFilter, NotConeFilter } from "./cone-filter.js";
 import { CylinderCurveFilter, NotCylinderCurveFilter } from "./cylinder-curve.js";
 import { CylinderFilter, NotCylinderFilter } from "./cylinder.js";
+import { TorusFilter, NotTorusFilter } from "./torus-filter.js";
 import { NotOnPlaneFilter, OnPlaneFilter } from "./on-plane.js";
 import { NotParallelFilter, ParallelFilter } from "./parallel.js";
 import { PlaneObject } from "../../features/plane.js";
@@ -182,6 +183,26 @@ export class FaceFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects toroidal faces, optionally matching major and/or minor radius.
+     * @param majorRadius - Optional radius from the torus axis to the tube center.
+     * @param minorRadius - Optional radius of the tube itself.
+     */
+    torus(majorRadius, minorRadius) {
+        const filter = new TorusFilter(majorRadius, minorRadius);
+        this.filters.push(filter);
+        return this;
+    }
+    /**
+     * Excludes toroidal faces, optionally matching major and/or minor radius.
+     * @param majorRadius - Optional radius from the torus axis to the tube center.
+     * @param minorRadius - Optional radius of the tube itself.
+     */
+    notTorus(majorRadius, minorRadius) {
+        const filter = new NotTorusFilter(majorRadius, minorRadius);
+        this.filters.push(filter);
+        return this;
+    }
     /**
      * Selects conical faces.
      */

package/lib/dist/filters/face/torus-filter.d.ts

@@ -0,0 +1,19 @@
+import { Matrix4 } from "../../math/matrix4.js";
+import { Face } from "../../common/shapes.js";
+import { FilterBase } from "../filter-base.js";
+export declare class TorusFilter extends FilterBase<Face> {
+    private majorRadius?;
+    private minorRadius?;
+    constructor(majorRadius?: number, minorRadius?: number);
+    match(shape: Face): boolean;
+    compareTo(other: TorusFilter): boolean;
+    transform(matrix: Matrix4): TorusFilter;
+}
+export declare class NotTorusFilter extends FilterBase<Face> {
+    private majorRadius?;
+    private minorRadius?;
+    constructor(majorRadius?: number, minorRadius?: number);
+    match(shape: Face): boolean;
+    compareTo(other: NotTorusFilter): boolean;
+    transform(matrix: Matrix4): NotTorusFilter;
+}

package/lib/dist/filters/face/torus-filter.js

@@ -0,0 +1,38 @@
+import { FilterBase } from "../filter-base.js";
+import { FaceQuery } from "../../oc/face-query.js";
+export class TorusFilter extends FilterBase {
+    majorRadius;
+    minorRadius;
+    constructor(majorRadius, minorRadius) {
+        super();
+        this.majorRadius = majorRadius;
+        this.minorRadius = minorRadius;
+    }
+    match(shape) {
+        return FaceQuery.isTorusFace(shape, this.majorRadius, this.minorRadius);
+    }
+    compareTo(other) {
+        return this.majorRadius === other.majorRadius && this.minorRadius === other.minorRadius;
+    }
+    transform(matrix) {
+        return new TorusFilter(this.majorRadius, this.minorRadius);
+    }
+}
+export class NotTorusFilter extends FilterBase {
+    majorRadius;
+    minorRadius;
+    constructor(majorRadius, minorRadius) {
+        super();
+        this.majorRadius = majorRadius;
+        this.minorRadius = minorRadius;
+    }
+    match(shape) {
+        return !FaceQuery.isTorusFace(shape, this.majorRadius, this.minorRadius);
+    }
+    compareTo(other) {
+        return this.majorRadius === other.majorRadius && this.minorRadius === other.minorRadius;
+    }
+    transform(matrix) {
+        return new NotTorusFilter(this.majorRadius, this.minorRadius);
+    }
+}

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

@@ -1,7 +1,9 @@
 import { SceneObject } from "../common/scene-object.js";
 import { Shape } from "../common/shapes.js";
 import { Plane } from "../math/plane.js";
-export declare function fuseWithSceneObjects(sceneObjects: SceneObject[], extrusions: Shape<any>[]): {
+export declare function fuseWithSceneObjects(sceneObjects: SceneObject[], extrusions: Shape<any>[], opts?: {
+    glue?: 'full' | 'shift';
+}): {
     newShapes: Shape<any>[];
     modifiedShapes: any[];
 } | {

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

@@ -1,8 +1,9 @@
 import { BooleanOps } from "../oc/boolean-ops.js";
 import { ShapeOps } from "../oc/shape-ops.js";
 import { classifyCutResult } from "./cut-helpers.js";
-export function fuseWithSceneObjects(sceneObjects, extrusions) {
+export function fuseWithSceneObjects(sceneObjects, extrusions, opts) {
     const modified = [];
+    const tCollect = performance.now();
     const objShapeMap = new Map();
     for (const obj of sceneObjects) {
         const shapes = obj.getShapes({}, 'solid');
@@ -11,9 +12,11 @@ export function fuseWithSceneObjects(sceneObjects, extrusions) {
         }
     }
     let sceneShapes = Array.from(objShapeMap.keys());
-    console.log("Fusing extrusions with scene objects. Extrusions:", extrusions.length, "Scene object shapes:", sceneShapes.length);
+    console.log(`[perf] fuseWithSceneObjects.collect (scenes=${sceneShapes.length}, extrusions=${extrusions.length}): ${(performance.now() - tCollect).toFixed(1)} ms`);
     const all = [...sceneShapes, ...extrusions];
-    const { result, newShapes, modifiedShapes } = BooleanOps.fuse(all);
+    const tFuse = performance.now();
+    const { result, newShapes, modifiedShapes } = BooleanOps.fuse(all, opts);
+    console.log(`[perf] fuseWithSceneObjects.BooleanOps.fuse (glue=${opts?.glue ?? 'off'}): ${(performance.now() - tFuse).toFixed(1)} ms`);
     if (newShapes.length === 0 && modifiedShapes.length === 0) {
         console.log("No fusions were made.");
         return {

package/lib/dist/index.d.ts

@@ -20,6 +20,7 @@ export declare function registerBuilder<T extends Function>(builder: (context: S
 export declare function init(rootPath?: string): Promise<{
     currentScene: Scene;
     currentFile: string;
+    renderer: import("./rendering/render.js").SceneRenderer;
     rootPath: string;
     setCurrentFile(filePath: string): void;
     startScene(): Scene;

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

@@ -8,15 +8,17 @@ export declare class BooleanOps {
     static cutShapes(shape: Shape, tool: Shape): Shape;
     static cutShapesRaw(shape: TopoDS_Shape, tool: TopoDS_Shape): TopoDS_Shape;
     static cutMultiShape(stocks: Shape[], tools: Shape[], plane?: Plane, cutDistance?: number): {
-        result: import("../common/wire.js").Wire | Edge | Solid | Face;
-        modified: (shape: Shape) => (import("../common/wire.js").Wire | Edge | Solid | Face)[];
+        result: import("../common/wire.js").Wire | Edge | Face | Solid;
+        modified: (shape: Shape) => (import("../common/wire.js").Wire | Edge | Face | Solid)[];
         sectionEdges: Edge[];
         startEdges: Edge[];
         endEdges: Edge[];
         internalEdges: Edge[];
         internalFaces: Face[];
     };
-    static fuse(args: Shape[]): {
+    static fuse(args: Shape[], opts?: {
+        glue?: 'full' | 'shift';
+    }): {
         result: Shape[];
         modifiedShapes: Shape[];
         newShapes: Shape[];

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

@@ -118,12 +118,18 @@ export class BooleanOps {
         toolList.delete();
         return { result: wrappedResult, modified, sectionEdges, startEdges, endEdges, internalEdges, internalFaces };
     }
-    static fuse(args) {
+    static fuse(args, opts) {
         const oc = getOC();
         const builder = new oc.BRepAlgoAPI_Fuse();
         builder.SetNonDestructive(true);
         builder.SetCheckInverted(true);
         builder.SetRunParallel(true);
+        if (opts?.glue === 'full') {
+            builder.SetGlue(oc.BOPAlgo_GlueEnum.BOPAlgo_GlueFull);
+        }
+        else if (opts?.glue === 'shift') {
+            builder.SetGlue(oc.BOPAlgo_GlueEnum.BOPAlgo_GlueShift);
+        }
         const argsList = new oc.TopTools_ListOfShape();
         for (const arg of args) {
             argsList.Append(arg.getShape());
@@ -134,11 +140,16 @@ export class BooleanOps {
         builder.SetArguments(list);
         builder.SetTools(argsList);
         const progress = new oc.Message_ProgressRange();
+        const tBuild = performance.now();
         builder.Build(progress);
+        console.log(`[perf] BooleanOps.fuse.Build (args=${args.length}): ${(performance.now() - tBuild).toFixed(1)} ms`);
+        const tSimplify = performance.now();
         builder.SimplifyResult(false, true, oc.Precision.Angular());
+        console.log(`[perf] BooleanOps.fuse.SimplifyResult: ${(performance.now() - tSimplify).toFixed(1)} ms`);
         const resultShape = builder.Shape();
+        const tExplore = performance.now();
         const rawShapes = Explorer.findAllShapes(resultShape);
-        console.log('FuseMultiShape: Result shapes count:', rawShapes.length);
+        console.log(`[perf] BooleanOps.fuse.findAllShapes (count=${rawShapes.length}): ${(performance.now() - tExplore).toFixed(1)} ms`);
         const result = rawShapes.map(s => ShapeFactory.fromShape(s));
         const modifiedShapes = [];
         for (const shape of args) {
@@ -149,12 +160,14 @@ export class BooleanOps {
         builder.delete();
         progress.delete();
         const newShapes = [];
+        const tPartner = performance.now();
         for (const s of result) {
             const existsInArgs = args.some(arg => arg.getShape().IsPartner(s.getShape()));
             if (!existsInArgs) {
                 newShapes.push(s);
             }
         }
+        console.log(`[perf] BooleanOps.fuse.IsPartner check (result=${result.length} x args=${args.length}): ${(performance.now() - tPartner).toFixed(1)} ms`);
         return { result, newShapes, modifiedShapes };
     }
     static fuseFaces(args) {

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

@@ -20,7 +20,6 @@ export declare class FaceOps {
     static fixFaceOrientation(face: Face | TopoDS_Face): Face;
     static makeFaceWithHoles(outerWire: Wire, holes: Wire[]): Face;
     static isPointInsideFace(point: Point, face: Face | TopoDS_Face): boolean;
-    static getFreeBoundsWire(compound: any): TopoDS_Wire | null;
     static makeFaceFromPlane2(plane: gp_Pln): TopoDS_Face;
     static makeFaceFromPlane(plane: gp_Pln): TopoDS_Face;
     static makeFaceFromCylinder(cylinder: gp_Cylinder): TopoDS_Face;

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

@@ -197,19 +197,6 @@ export class FaceOps {
         disposePnt();
         return isInside;
     }
-    static getFreeBoundsWire(compound) {
-        const oc = getOC();
-        const freeBounds = new oc.ShapeAnalysis_FreeBounds(compound, oc.Precision.Confusion(), true, true);
-        const closedWiresCompound = freeBounds.GetClosedWires();
-        const explorer = new oc.TopExp_Explorer(closedWiresCompound, oc.TopAbs_ShapeEnum.TopAbs_WIRE, oc.TopAbs_ShapeEnum.TopAbs_SHAPE);
-        let result = null;
-        if (explorer.More()) {
-            result = oc.TopoDS.Wire(explorer.Current());
-        }
-        explorer.delete();
-        freeBounds.delete();
-        return result;
-    }
     static makeFaceFromPlane2(plane) {
         const oc = getOC();
         const faceMaker = new oc.BRepBuilderAPI_MakeFace(plane, -1000, 1000, -1000, 1000);

package/lib/dist/oc/face-query.d.ts

@@ -8,6 +8,7 @@ export declare class FaceQuery {
     static isConeFace(face: Shape): boolean;
     static isCylinderFace(face: Shape, diameter?: number): boolean;
     static isCylinderCurveFace(face: Shape, diameter?: number): boolean;
+    static isTorusFace(face: Shape, majorRadius?: number, minorRadius?: number): boolean;
     static isFaceOnPlane(face: Shape, plane: Plane): boolean;
     static doesFaceIntersectPlane(face: Shape, plane: Plane): boolean;
     static isFaceParallelToPlane(face: Shape, plane: Plane): boolean;
@@ -23,6 +24,7 @@ export declare class FaceQuery {
     static isConeFaceRaw(face: TopoDS_Shape): boolean;
     static isCylinderFaceRaw(face: TopoDS_Shape, diameter?: number): boolean;
     static isCylinderCurveFaceRaw(face: TopoDS_Shape, diameter?: number): boolean;
+    static isTorusFaceRaw(face: TopoDS_Shape, majorRadius?: number, minorRadius?: number): boolean;
     static isFaceOnPlaneRaw(face: TopoDS_Shape, plane: gp_Pln): boolean;
     static isFaceParallelToPlaneRaw(face: TopoDS_Shape, plane: gp_Pln): boolean;
     static isPlanarFaceRaw(face: TopoDS_Shape): boolean;

package/lib/dist/oc/face-query.js

@@ -17,6 +17,9 @@ export class FaceQuery {
     static isCylinderCurveFace(face, diameter) {
         return FaceQuery.isCylinderCurveFaceRaw(face.getShape(), diameter);
     }
+    static isTorusFace(face, majorRadius, minorRadius) {
+        return FaceQuery.isTorusFaceRaw(face.getShape(), majorRadius, minorRadius);
+    }
     static isFaceOnPlane(face, plane) {
         const [gpPln, dispose] = Convert.toGpPln(plane);
         const result = FaceQuery.isFaceOnPlaneRaw(face.getShape(), gpPln);
@@ -198,6 +201,33 @@ export class FaceQuery {
         }
         return false;
     }
+    static isTorusFaceRaw(face, majorRadius, minorRadius) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const faceAdaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const type = faceAdaptor.GetType();
+        if (type !== oc.GeomAbs_SurfaceType.GeomAbs_Torus) {
+            faceAdaptor.delete();
+            return false;
+        }
+        if (majorRadius === undefined && minorRadius === undefined) {
+            faceAdaptor.delete();
+            return true;
+        }
+        const torus = faceAdaptor.Torus();
+        const actualMajor = torus.MajorRadius();
+        const actualMinor = torus.MinorRadius();
+        torus.delete();
+        faceAdaptor.delete();
+        const tol = oc.Precision.Confusion();
+        if (majorRadius !== undefined && Math.abs(actualMajor - majorRadius) > tol) {
+            return false;
+        }
+        if (minorRadius !== undefined && Math.abs(actualMinor - minorRadius) > tol) {
+            return false;
+        }
+        return true;
+    }
     static isFaceOnPlaneRaw(face, plane) {
         const oc = getOC();
         return FaceOps.faceOnPlane(oc.TopoDS.Face(face), plane);

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

@@ -74,80 +74,98 @@ export class FilletOps {
     }
     static fillet2dRaw(wire, plane, radius) {
         const oc = getOC();
-        let currentWire = wire;
-        let cornerIndex = 0;
         const isClosed = wire.Closed();
-        try {
-            while (true) {
-                const edges = [];
-                const explorer = new oc.BRepTools_WireExplorer(currentWire);
-                while (explorer.More()) {
-                    edges.push(oc.TopoDS.Edge(explorer.Current()));
-                    explorer.Next();
+        const ownedEdges = [];
+        // Extract edges in wire traversal order and canonicalize: for each REVERSED edge,
+        // build a new FORWARD edge whose natural parameterization matches the wire traversal.
+        // ChFi2d_FilletAPI returns modified edges whose natural direction matches the input's
+        // natural direction, so aligning natural direction with wire traversal makes the
+        // modEdges directly usable when rebuilding the final wire.
+        const wireEdges = [];
+        {
+            const explorer = new oc.BRepTools_WireExplorer(wire);
+            while (explorer.More()) {
+                const raw = oc.TopoDS.Edge(explorer.Current());
+                const isReversed = raw.Orientation().value === oc.TopAbs_Orientation.TopAbs_REVERSED.value;
+                if (!isReversed) {
+                    wireEdges.push(raw);
+                    ownedEdges.push(raw);
                 }
-                explorer.delete();
-                const maxCorners = isClosed ? edges.length : edges.length - 1;
-                if (cornerIndex >= maxCorners) {
-                    edges.forEach(e => e.delete());
-                    break;
-                }
-                const edge1 = edges[cornerIndex];
-                const edge2 = edges[(cornerIndex + 1) % edges.length];
-                const sharedVertex = oc.TopExp.LastVertex(edge1, false);
-                const sharedPoint = oc.BRep_Tool.Pnt(sharedVertex);
-                sharedVertex.delete();
-                const pairWireBuilder = new oc.BRepBuilderAPI_MakeWire(edge1, edge2);
-                const pairWire = pairWireBuilder.Wire();
-                const filletAPI = new oc.ChFi2d_FilletAPI(pairWire, plane);
-                const success = filletAPI.Perform(radius);
-                if (!success) {
-                    filletAPI.delete();
-                    pairWire.delete();
-                    pairWireBuilder.delete();
-                    edges.forEach(e => e.delete());
-                    cornerIndex++;
-                    continue;
+                else {
+                    const adaptor = new oc.BRepAdaptor_Curve(raw);
+                    const edgeFirst = adaptor.FirstParameter();
+                    const edgeLast = adaptor.LastParameter();
+                    adaptor.delete();
+                    const curveHandle = oc.BRep_Tool.Curve(raw, 0, 1);
+                    if (!curveHandle || curveHandle.IsNull()) {
+                        raw.delete();
+                        explorer.delete();
+                        ownedEdges.forEach(e => e.delete());
+                        throw new Error("fillet2d: edge has no 3D curve");
+                    }
+                    const curve = curveHandle.get();
+                    const reversedHandle = curve.Reversed();
+                    const newFirst = curve.ReversedParameter(edgeLast);
+                    const newLast = curve.ReversedParameter(edgeFirst);
+                    const maker = new oc.BRepBuilderAPI_MakeEdge(reversedHandle, newFirst, newLast);
+                    const newEdge = oc.TopoDS.Edge(maker.Edge());
+                    maker.delete();
+                    reversedHandle.delete();
+                    curveHandle.delete();
+                    raw.delete();
+                    wireEdges.push(newEdge);
+                    ownedEdges.push(newEdge);
                 }
-                const modEdge1 = new oc.TopoDS_Edge();
-                const modEdge2 = new oc.TopoDS_Edge();
-                const filletEdge = filletAPI.Result(sharedPoint, modEdge1, modEdge2, -1);
+                explorer.Next();
+            }
+            explorer.delete();
+        }
+        const currentEdges = wireEdges.slice();
+        const filletArcs = new Map();
+        const maxCorners = isClosed ? currentEdges.length : currentEdges.length - 1;
+        for (let cornerIndex = 0; cornerIndex < maxCorners; cornerIndex++) {
+            const nextIndex = (cornerIndex + 1) % currentEdges.length;
+            const edge1 = currentEdges[cornerIndex];
+            const edge2 = currentEdges[nextIndex];
+            const sharedVertex = oc.TopExp.LastVertex(edge1, true);
+            const sharedPoint = oc.BRep_Tool.Pnt(sharedVertex);
+            sharedVertex.delete();
+            const filletAPI = new oc.ChFi2d_FilletAPI(edge1, edge2, plane);
+            const success = filletAPI.Perform(radius);
+            if (!success || filletAPI.NbResults(sharedPoint) === 0) {
                 sharedPoint.delete();
                 filletAPI.delete();
-                pairWire.delete();
-                pairWireBuilder.delete();
-                const newWireBuilder = new oc.BRepBuilderAPI_MakeWire();
-                const nextIndex = (cornerIndex + 1) % edges.length;
-                for (let i = 0; i < edges.length; i++) {
-                    if (i === cornerIndex) {
-                        newWireBuilder.Add(modEdge1);
-                        newWireBuilder.Add(filletEdge);
-                    }
-                    else if (i === nextIndex) {
-                        newWireBuilder.Add(modEdge2);
-                    }
-                    else {
-                        newWireBuilder.Add(edges[i]);
-                    }
-                }
-                const prevWire = currentWire;
-                currentWire = newWireBuilder.Wire();
-                newWireBuilder.delete();
-                if (prevWire !== wire) {
-                    prevWire.delete();
-                }
-                modEdge1.delete();
-                modEdge2.delete();
-                filletEdge.delete();
-                edges.forEach(e => e.delete());
-                cornerIndex += 2;
+                continue;
             }
-            return currentWire;
+            const modEdge1 = new oc.TopoDS_Edge();
+            const modEdge2 = new oc.TopoDS_Edge();
+            const filletEdge = filletAPI.Result(sharedPoint, modEdge1, modEdge2, -1);
+            sharedPoint.delete();
+            filletAPI.delete();
+            currentEdges[cornerIndex] = modEdge1;
+            currentEdges[nextIndex] = modEdge2;
+            filletArcs.set(cornerIndex, filletEdge);
+            ownedEdges.push(modEdge1, modEdge2, filletEdge);
         }
-        catch (e) {
-            if (currentWire !== wire) {
-                currentWire.delete();
+        const edgeList = new oc.TopTools_ListOfShape();
+        for (let i = 0; i < currentEdges.length; i++) {
+            edgeList.Append(oc.TopoDS.Edge(currentEdges[i]));
+            const arc = filletArcs.get(i);
+            if (arc) {
+                edgeList.Append(oc.TopoDS.Edge(arc));
             }
-            throw e;
         }
+        const wireBuilder = new oc.BRepBuilderAPI_MakeWire();
+        wireBuilder.Add(edgeList);
+        edgeList.delete();
+        if (!wireBuilder.IsDone()) {
+            wireBuilder.delete();
+            ownedEdges.forEach(e => e.delete());
+            throw new Error("fillet2d: failed to build filleted wire");
+        }
+        const result = wireBuilder.Wire();
+        wireBuilder.delete();
+        ownedEdges.forEach(e => e.delete());
+        return result;
     }
 }

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Face, TopoDS_Shape } from "occjs-wrapper";
+import type { TopoDS_Edge, TopoDS_Face, TopoDS_Shape } from "occjs-wrapper";
 import { Face } from "../common/face.js";
 import { Shape } from "../common/shape.js";
 export interface MeshData {
@@ -7,11 +7,34 @@ export interface MeshData {
     indices: number[];
     count?: number;
 }
+export interface EnsureTriangulatedOptions {
+    linDefl?: number;
+    angDefl?: number;
+    parallel?: boolean;
+    relative?: boolean;
+    checkFreeEdges?: boolean;
+}
 export declare class Mesh {
     static triangulateFace(face: Face, vertexOffset?: number): MeshData | null;
     static discretizeEdge(edge: Shape): MeshData;
-    static premeshShape(shape: TopoDS_Shape): void;
+    /**
+     * Triangulates `shape` only if it doesn't already have an up-to-date
+     * triangulation at the requested deflection. Returns true when a fresh
+     * mesh was built, false when the stored one was reused.
+     */
+    static ensureTriangulated(shape: TopoDS_Shape, opts?: EnsureTriangulatedOptions): boolean;
     static triangulateFaceRaw(face: TopoDS_Face, vertexOffset?: number): MeshData | null;
     static extractFaceTriangulationRaw(face: TopoDS_Face, vertexOffset?: number): MeshData | null;
+    /**
+     * Reads the polyline stored for `edge` as a polygon-on-triangulation of
+     * `face`. Node indices point into the face's triangulation, so the edge
+     * samples coincide exactly with the face mesh vertices (watertight).
+     */
+    static discretizeEdgeOnFace(edge: TopoDS_Edge, face: TopoDS_Face): MeshData | null;
+    /**
+     * Reads the stored 3D polygon for a free edge (one not attached to a
+     * meshed face). Caller must have already run `ensureTriangulated` on the
+     * edge or its parent wire.
+     */
     static discretizeEdgeRaw(edge: TopoDS_Shape): MeshData;
 }