fluidcad 0.0.26 → 0.0.28

package/lib/dist/oc/mesh.js

@@ -1,4 +1,7 @@
 import { getOC } from "./init.js";
+// Flip to false to benchmark single-threaded meshing.
+const DEFAULT_LIN_DEFLECTION = 0.1;
+const DEFAULT_ANG_DEFLECTION = 0.5;
 export class Mesh {
     // Wrapper methods (public API for external callers)
     static triangulateFace(face, vertexOffset = 0) {
@@ -7,23 +10,33 @@ export class Mesh {
     static discretizeEdge(edge) {
         return Mesh.discretizeEdgeRaw(edge.getShape());
     }
-    static premeshShape(shape) {
+    /**
+     * 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, opts = {}) {
         const oc = getOC();
-        const inc = new oc.BRepMesh_IncrementalMesh(shape, 0.3, false, 0.3, true);
+        const linDefl = opts.linDefl ?? DEFAULT_LIN_DEFLECTION;
+        const angDefl = opts.angDefl ?? DEFAULT_ANG_DEFLECTION;
+        const relative = opts.relative ?? false;
+        const checkFreeEdges = opts.checkFreeEdges ?? true;
+        if (oc.BRepTools.Triangulation(shape, linDefl, checkFreeEdges)) {
+            return false;
+        }
+        const inc = new oc.BRepMesh_IncrementalMesh(shape, linDefl, relative, angDefl, true);
         inc.delete();
+        return true;
     }
     // Raw methods (for oc-internal use)
     static triangulateFaceRaw(face, vertexOffset = 0) {
-        const oc = getOC();
-        let inc;
         try {
-            inc = new oc.BRepMesh_IncrementalMesh(face, 0.3, false, 0.3, true);
+            Mesh.ensureTriangulated(face);
         }
         catch (e) {
             console.error("Face mesh failed", e);
             return null;
         }
-        inc.delete();
         return Mesh.extractFaceTriangulationRaw(face, vertexOffset);
     }
     static extractFaceTriangulationRaw(face, vertexOffset = 0) {
@@ -80,39 +93,103 @@ export class Mesh {
         aLocation.delete();
         return { vertices, normals, indices, count: nbNodes };
     }
+    /**
+     * 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, face) {
+        const oc = getOC();
+        if (oc.BRep_Tool.Degenerated(edge)) {
+            return null;
+        }
+        const loc = new oc.TopLoc_Location();
+        const triHandle = oc.BRep_Tool.Triangulation(face, loc, 0);
+        if (triHandle.IsNull()) {
+            triHandle.delete();
+            loc.delete();
+            return null;
+        }
+        const polyHandle = oc.BRep_Tool.PolygonOnTriangulation(edge, triHandle, loc);
+        if (polyHandle.IsNull()) {
+            polyHandle.delete();
+            triHandle.delete();
+            loc.delete();
+            return null;
+        }
+        const tri = triHandle.get();
+        const poly = polyHandle.get();
+        const nbNodes = poly.NbNodes();
+        const tx = loc.Transformation();
+        const vertices = new Array(nbNodes * 3);
+        for (let i = 1; i <= nbNodes; i++) {
+            const nodeIdx = poly.Node(i);
+            const p = tri.Node(nodeIdx);
+            const pT = p.Transformed(tx);
+            const base = (i - 1) * 3;
+            vertices[base] = pT.X();
+            vertices[base + 1] = pT.Y();
+            vertices[base + 2] = pT.Z();
+            p.delete();
+            pT.delete();
+        }
+        const indices = new Array((nbNodes - 1) * 2);
+        for (let i = 0; i < nbNodes - 1; i++) {
+            indices[i * 2] = i;
+            indices[i * 2 + 1] = i + 1;
+        }
+        tx.delete();
+        polyHandle.delete();
+        triHandle.delete();
+        loc.delete();
+        return { vertices, normals: [], indices };
+    }
+    /**
+     * 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) {
         const oc = getOC();
         const ocEdge = oc.TopoDS.Edge(edge);
-        const adaptor = new oc.BRepAdaptor_Curve(ocEdge);
-        const type = adaptor.GetType();
-        const first = adaptor.FirstParameter();
-        const last = adaptor.LastParameter();
-        const points = [];
-        if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
-            const startPnt = adaptor.Value(first);
-            const endPnt = adaptor.Value(last);
-            points.push(startPnt.X(), startPnt.Y(), startPnt.Z());
-            points.push(endPnt.X(), endPnt.Y(), endPnt.Z());
-            startPnt.delete();
-            endPnt.delete();
-        }
-        else {
-            const numSegments = Math.max(1, Math.floor((last - first) / 0.01));
-            for (let i = 0; i <= numSegments; i++) {
-                const t = first + ((last - first) * i) / numSegments;
-                const pnt = adaptor.Value(t);
-                points.push(pnt.X(), pnt.Y(), pnt.Z());
-                pnt.delete();
-            }
+        if (oc.BRep_Tool.Degenerated(ocEdge)) {
+            ocEdge.delete();
+            return { vertices: [], normals: [], indices: [] };
         }
-        adaptor.delete();
-        ocEdge.delete();
-        const pointCount = points.length / 3;
-        const indices = [];
-        for (let i = 0; i < pointCount - 1; i++) {
-            indices[2 * i] = i;
-            indices[2 * i + 1] = i + 1;
+        Mesh.ensureTriangulated(edge);
+        const loc = new oc.TopLoc_Location();
+        const polyHandle = oc.BRep_Tool.Polygon3D(ocEdge, loc);
+        if (polyHandle.IsNull()) {
+            polyHandle.delete();
+            loc.delete();
+            ocEdge.delete();
+            console.warn("Edge has no stored Polygon3D after meshing; returning empty polyline.");
+            return { vertices: [], normals: [], indices: [] };
         }
-        return { vertices: points, normals: [], indices };
+        const poly = polyHandle.get();
+        const nbNodes = poly.NbNodes();
+        const nodes = poly.Nodes();
+        const tx = loc.Transformation();
+        const vertices = new Array(nbNodes * 3);
+        for (let i = 1; i <= nbNodes; i++) {
+            const p = nodes.Value(i);
+            const pT = p.Transformed(tx);
+            const base = (i - 1) * 3;
+            vertices[base] = pT.X();
+            vertices[base + 1] = pT.Y();
+            vertices[base + 2] = pT.Z();
+            p.delete();
+            pT.delete();
+        }
+        const indices = new Array((nbNodes - 1) * 2);
+        for (let i = 0; i < nbNodes - 1; i++) {
+            indices[i * 2] = i;
+            indices[i * 2 + 1] = i + 1;
+        }
+        tx.delete();
+        polyHandle.delete();
+        loc.delete();
+        ocEdge.delete();
+        return { vertices, normals: [], indices };
     }
 }

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

@@ -1,11 +1,26 @@
-import type { TopTools_ListOfShape, TopoDS_Edge, TopoDS_Face, TopoDS_Shape, TopoDS_Solid } from "occjs-wrapper";
+import type { TopTools_ListOfShape, TopoDS_Shape } from "occjs-wrapper";
 import { Matrix4 } from "../math/matrix4.js";
-import { Vector3d } from "../math/vector3d.js";
 import { Shape } from "../common/shape.js";
 import { Face } from "../common/face.js";
-import { Solid } from "../common/solid.js";
+import { Edge } from "../common/edge.js";
 import { BoundingBox } from "../helpers/types.js";
-import { Axis } from "../math/axis.js";
+/**
+ * A cleanShape result that preserves UnifySameDomain lineage so callers can
+ * chain pre-clean → post-clean face/edge remapping. `remapFace(pf)` returns
+ * the post-clean face(s) corresponding to a pre-clean face, or `null` if the
+ * cleanup didn't process it. Caller must invoke `dispose()` exactly once.
+ *
+ * When the post-clean shape fails validation and ShapeFix_Shape has to run,
+ * the UnifySameDomain history is discarded (ShapeFix_Shape creates more new
+ * TShapes without recording lineage). In that case remap returns `[face]`
+ * for any face the cleanup saw, which is best-effort.
+ */
+export type CleanShapeLineage = {
+    shape: Shape;
+    remapFace: (face: Face) => Face[] | null;
+    remapEdge: (edge: Edge) => Edge[] | null;
+    dispose: () => void;
+};
 export declare class ShapeOps {
     static transform(shape: Shape, matrix: Matrix4): Shape;
     static getBoundingBox(shape: Shape | TopoDS_Shape): BoundingBox;
@@ -13,22 +28,12 @@ export declare class ShapeOps {
     static makeCompound(shapes: Shape[]): Shape;
     static makeCompoundRaw(shapes: TopoDS_Shape[]): import("occjs-wrapper").TopoDS_Compound;
     static cleanShape(shape: Shape): Shape;
+    /**
+     * Variant of `cleanShape` that preserves UnifySameDomain lineage via
+     * `BRepTools_History`. Caller must call `dispose()` exactly once to free
+     * the OC wrappers.
+     */
+    static cleanShapeWithLineage(shape: Shape): CleanShapeLineage;
     static cleanShapeRaw(shape: TopoDS_Shape): TopoDS_Shape;
-    static getSolidOutwardNormal(face: Face, solid: Solid): Vector3d;
-    static getSolidOutwardNormalRaw(face: TopoDS_Face, solid: TopoDS_Solid): Vector3d;
-    static mirrorShape(shape: Shape, mirrorPoint: {
-        x: number;
-        y: number;
-        z: number;
-    }): Shape;
-    static mirrorShapeRaw(shape: TopoDS_Shape, mirrorPoint: {
-        x: number;
-        y: number;
-        z: number;
-    }): TopoDS_Shape;
-    static translateShape(shape: Shape, direction: Vector3d): Shape;
-    static translateShapeRaw(shape: TopoDS_Shape, direction: Vector3d): TopoDS_Shape;
-    static rotateShape(shape: TopoDS_Shape, axis: Axis, angle: number): TopoDS_Shape;
     static shapeListToArray(list: TopTools_ListOfShape): TopoDS_Shape[];
-    static edgeMiddlePoint(edge: TopoDS_Edge): import("occjs-wrapper").gp_Pnt;
 }

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

@@ -1,8 +1,10 @@
 import { getOC } from "./init.js";
 import { Convert } from "./convert.js";
-import { Vector3d } from "../math/vector3d.js";
 import { Shape } from "../common/shape.js";
 import { ShapeFactory } from "../common/shape-factory.js";
+import { Face } from "../common/face.js";
+import { Edge } from "../common/edge.js";
+import { Explorer } from "./explorer.js";
 export class ShapeOps {
     static transform(shape, matrix) {
         const oc = getOC();
@@ -71,13 +73,124 @@ export class ShapeOps {
     static cleanShape(shape) {
         return ShapeFactory.fromShape(ShapeOps.cleanShapeRaw(shape.getShape()));
     }
-    static cleanShapeRaw(shape) {
+    /**
+     * Variant of `cleanShape` that preserves UnifySameDomain lineage via
+     * `BRepTools_History`. Caller must call `dispose()` exactly once to free
+     * the OC wrappers.
+     */
+    static cleanShapeWithLineage(shape) {
         const oc = getOC();
-        // Full unification: merge redundant edges AND co-surface faces
-        const unify = new oc.ShapeUpgrade_UnifySameDomain(shape, false, true, false);
+        const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
+        const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+        const unify = new oc.ShapeUpgrade_UnifySameDomain(shape.getShape(), false, true, false);
         unify.Build();
-        let cleaned = unify.Shape();
-        unify.delete();
+        const cleanedRaw = unify.Shape();
+        // Pre-compute which faces/edges this cleanup saw so the remap can
+        // distinguish "didn't know about this shape" (return null) from
+        // "saw but didn't modify" (return [original]).
+        const knownFaces = new oc.TopTools_MapOfShape();
+        const knownEdges = new oc.TopTools_MapOfShape();
+        for (const raw of Explorer.findShapes(shape.getShape(), FACE)) {
+            knownFaces.Add(raw);
+        }
+        for (const raw of Explorer.findShapes(shape.getShape(), EDGE)) {
+            knownEdges.Add(raw);
+        }
+        const checker = new oc.BRepCheck_Analyzer(cleanedRaw, true, true);
+        const valid = checker.IsValid();
+        checker.delete();
+        if (!valid) {
+            // ShapeFix_Shape creates new TShapes without recording history.
+            // Lineage is lost here — remap returns [face] best-effort for
+            // faces the cleanup saw, null otherwise.
+            unify.delete();
+            const fixer = new oc.ShapeFix_Shape(cleanedRaw);
+            const progress = new oc.Message_ProgressRange();
+            fixer.Perform(progress);
+            const fixed = fixer.Shape();
+            fixer.delete();
+            progress.delete();
+            const wrapped = ShapeFactory.fromShape(fixed);
+            let disposed = false;
+            const dispose = () => {
+                if (disposed) {
+                    return;
+                }
+                disposed = true;
+                knownFaces.delete();
+                knownEdges.delete();
+            };
+            return {
+                shape: wrapped,
+                remapFace: (face) => (knownFaces.Contains(face.getShape()) ? [face] : null),
+                remapEdge: (edge) => (knownEdges.Contains(edge.getShape()) ? [edge] : null),
+                dispose,
+            };
+        }
+        const historyHandle = unify.History();
+        const history = historyHandle.get();
+        let disposed = false;
+        const dispose = () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            historyHandle.delete();
+            unify.delete();
+            knownFaces.delete();
+            knownEdges.delete();
+        };
+        return {
+            shape: ShapeFactory.fromShape(cleanedRaw),
+            remapFace: (face) => {
+                const raw = face.getShape();
+                if (!knownFaces.Contains(raw)) {
+                    return null;
+                }
+                if (history.IsRemoved(raw)) {
+                    return [];
+                }
+                const list = ShapeOps.shapeListToArray(history.Modified(raw))
+                    .filter(s => s.ShapeType() === FACE);
+                if (list.length === 0) {
+                    return [face];
+                }
+                return list.map(r => Face.fromTopoDSFace(Explorer.toFace(r)));
+            },
+            remapEdge: (edge) => {
+                const raw = edge.getShape();
+                if (!knownEdges.Contains(raw)) {
+                    return null;
+                }
+                if (history.IsRemoved(raw)) {
+                    return [];
+                }
+                const list = ShapeOps.shapeListToArray(history.Modified(raw))
+                    .filter(s => s.ShapeType() === EDGE);
+                if (list.length === 0) {
+                    return [edge];
+                }
+                return list.map(r => Edge.fromTopoDSEdge(Explorer.toEdge(r)));
+            },
+            dispose,
+        };
+    }
+    static cleanShapeRaw(shape) {
+        const oc = getOC();
+        // Full unification: merge redundant edges AND co-surface faces.
+        // UnifySameDomain can throw on shapes with subtle topology issues
+        // (e.g. boolean output from a profile with reversed face normal).
+        // Fall back to the input shape on failure rather than aborting.
+        let cleaned;
+        try {
+            const unify = new oc.ShapeUpgrade_UnifySameDomain(shape, false, true, false);
+            unify.Build();
+            cleaned = unify.Shape();
+            unify.delete();
+        }
+        catch {
+            return shape;
+        }
         // Validate — UnifySameDomain can corrupt periodic surfaces (e.g. cylinders)
         const checker = new oc.BRepCheck_Analyzer(cleaned, true, true);
         if (checker.IsValid()) {
@@ -86,105 +199,18 @@ export class ShapeOps {
         }
         checker.delete();
         // Repair with ShapeFix_Shape (fixes seam edges, wire orientation, SameParameter)
-        const fixer = new oc.ShapeFix_Shape(cleaned);
-        const progress = new oc.Message_ProgressRange();
-        fixer.Perform(progress);
-        const fixed = fixer.Shape();
-        fixer.delete();
-        progress.delete();
-        return fixed;
-    }
-    static getSolidOutwardNormal(face, solid) {
-        return ShapeOps.getSolidOutwardNormalRaw(face.getShape(), solid.getShape());
-    }
-    static getSolidOutwardNormalRaw(face, solid) {
-        const oc = getOC();
-        const surfaceAdaptor = new oc.BRepAdaptor_Surface(face, true);
-        const type = surfaceAdaptor.GetType();
-        if (type !== oc.GeomAbs_SurfaceType.GeomAbs_Plane) {
-            surfaceAdaptor.delete();
-            throw new Error("Non-planar faces not supported for normal calculation");
-        }
-        const uFirst = surfaceAdaptor.FirstUParameter();
-        const uLast = surfaceAdaptor.LastUParameter();
-        const vFirst = surfaceAdaptor.FirstVParameter();
-        const vLast = surfaceAdaptor.LastVParameter();
-        const u = (uFirst + uLast) / 2.0;
-        const v = (vFirst + vLast) / 2.0;
-        const testPoint = new oc.gp_Pnt();
-        const du = new oc.gp_Vec();
-        const dv = new oc.gp_Vec();
-        surfaceAdaptor.D1(u, v, testPoint, du, dv);
-        const geometricNormal = surfaceAdaptor.Plane().Position().Direction();
-        if (face.Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED) {
-            geometricNormal.Reverse();
+        try {
+            const fixer = new oc.ShapeFix_Shape(cleaned);
+            const progress = new oc.Message_ProgressRange();
+            fixer.Perform(progress);
+            const fixed = fixer.Shape();
+            fixer.delete();
+            progress.delete();
+            return fixed;
         }
-        const offset = 1e-6;
-        const testPointOffset = new oc.gp_Pnt(testPoint.X() + geometricNormal.X() * offset, testPoint.Y() + geometricNormal.Y() * offset, testPoint.Z() + geometricNormal.Z() * offset);
-        const classifier = new oc.BRepClass3d_SolidClassifier(solid, testPointOffset, oc.Precision.Confusion());
-        const state = classifier.State();
-        let result;
-        if (state === oc.TopAbs_State.TopAbs_IN) {
-            result = new Vector3d(-geometricNormal.X(), -geometricNormal.Y(), -geometricNormal.Z());
-        }
-        else {
-            result = new Vector3d(geometricNormal.X(), geometricNormal.Y(), geometricNormal.Z());
+        catch {
+            return cleaned;
         }
-        classifier.delete();
-        testPointOffset.delete();
-        geometricNormal.delete();
-        du.delete();
-        dv.delete();
-        testPoint.delete();
-        surfaceAdaptor.delete();
-        return result;
-    }
-    static mirrorShape(shape, mirrorPoint) {
-        const result = ShapeOps.mirrorShapeRaw(shape.getShape(), mirrorPoint);
-        return ShapeFactory.fromShape(result);
-    }
-    static mirrorShapeRaw(shape, mirrorPoint) {
-        const oc = getOC();
-        const point = new oc.gp_Pnt(mirrorPoint.x, mirrorPoint.y, mirrorPoint.z);
-        const trsf = new oc.gp_Trsf();
-        trsf.SetMirror(point);
-        const transformer = new oc.BRepBuilderAPI_Transform(trsf);
-        transformer.Perform(shape, true);
-        const result = transformer.Shape();
-        transformer.delete();
-        trsf.delete();
-        point.delete();
-        return result;
-    }
-    static translateShape(shape, direction) {
-        const result = ShapeOps.translateShapeRaw(shape.getShape(), direction);
-        return ShapeFactory.fromShape(result);
-    }
-    static translateShapeRaw(shape, direction) {
-        const oc = getOC();
-        const [vec, disposeVec] = Convert.toGpVec(direction);
-        const trsf = new oc.gp_Trsf();
-        trsf.SetTranslation(vec);
-        const transformer = new oc.BRepBuilderAPI_Transform(trsf);
-        transformer.Perform(shape, false);
-        const result = transformer.Shape();
-        transformer.delete();
-        trsf.delete();
-        disposeVec();
-        return result;
-    }
-    static rotateShape(shape, axis, angle) {
-        const oc = getOC();
-        const trsf = new oc.gp_Trsf();
-        const [gpAxis, disposeGpAxis] = Convert.toGpAx1(axis);
-        trsf.SetRotation(gpAxis, angle);
-        const transformer = new oc.BRepBuilderAPI_Transform(trsf);
-        transformer.Perform(shape, false);
-        const result = transformer.Shape();
-        transformer.delete();
-        trsf.delete();
-        disposeGpAxis();
-        return result;
     }
     static shapeListToArray(list) {
         let res = [];
@@ -195,14 +221,4 @@ export class ShapeOps {
         list.delete();
         return res;
     }
-    static edgeMiddlePoint(edge) {
-        const oc = getOC();
-        const curveAdaptor = new oc.BRepAdaptor_Curve(oc.TopoDS.Edge(edge));
-        const curve = curveAdaptor.Curve();
-        const midParam = (curve.FirstParameter() + curve.LastParameter()) / 2.0;
-        const midPoint = curve.Value(midParam);
-        const result = new oc.gp_Pnt(midPoint.X(), midPoint.Y(), midPoint.Z());
-        curveAdaptor.delete();
-        return result;
-    }
 }

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

@@ -1,5 +1,12 @@
 export function transformMeshes(meshes, matrix) {
     const m = matrix.elements;
+    // Determinant of the 3x3 linear part. Negative for mirror/reflection
+    // transforms — those flip triangle winding, so we have to swap indices
+    // to keep faces front-facing after the vertex transform.
+    const det3 = m[0] * (m[5] * m[10] - m[9] * m[6]) -
+        m[4] * (m[1] * m[10] - m[9] * m[2]) +
+        m[8] * (m[1] * m[6] - m[5] * m[2]);
+    const flipWinding = det3 < 0;
     return meshes.map(mesh => {
         const srcV = mesh.vertices;
         const srcN = mesh.normals;
@@ -17,6 +24,15 @@ export function transformMeshes(meshes, matrix) {
             newN[i + 1] = m[1] * nx + m[5] * ny + m[9] * nz;
             newN[i + 2] = m[2] * nx + m[6] * ny + m[10] * nz;
         }
-        return { ...mesh, vertices: newV, normals: newN };
+        let newIndices = mesh.indices;
+        if (flipWinding && mesh.indices.length % 3 === 0) {
+            newIndices = new Array(mesh.indices.length);
+            for (let i = 0; i < mesh.indices.length; i += 3) {
+                newIndices[i] = mesh.indices[i];
+                newIndices[i + 1] = mesh.indices[i + 2];
+                newIndices[i + 2] = mesh.indices[i + 1];
+            }
+        }
+        return { ...mesh, vertices: newV, normals: newN, indices: newIndices };
     });
 }

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

@@ -1,23 +1,36 @@
-import { renderEdge } from "./render-edge.js";
 import { Explorer } from "../oc/explorer.js";
 import { Mesh } from "../oc/mesh.js";
+import { getOC } from "../oc/init.js";
 export function renderSolid(shapeObj) {
-    Mesh.premeshShape(shapeObj.getShape());
+    Mesh.ensureTriangulated(shapeObj.getShape());
     const facesMeshes = getFacesMesh(shapeObj);
     const edgesMesh = getEdgesMesh(shapeObj);
     return [...facesMeshes, ...edgesMesh];
 }
 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 edges = Explorer.findEdgesWrapped(shapeObj);
     for (let edgeIdx = 0; edgeIdx < edges.length; edgeIdx++) {
-        const edgeResult = renderEdge(edges[edgeIdx]);
+        const edgeShape = edges[edgeIdx].getShape();
+        const parents = edgeToFaces.Seek(edgeShape);
+        if (!parents || parents.Size() === 0) {
+            continue;
+        }
+        const parentFace = oc.TopoDS.Face(parents.First());
+        const edgeResult = Mesh.discretizeEdgeOnFace(edgeShape, parentFace);
+        parentFace.delete();
         if (edgeResult) {
-            edgeResult.label = 'solid-edges';
-            edgeResult.edgeIndex = edgeIdx;
-            result.push(edgeResult);
+            result.push({
+                ...edgeResult,
+                label: 'solid-edges',
+                edgeIndex: edgeIdx,
+            });
         }
     }
+    edgeToFaces.delete();
     return result;
 }
 function getFacesMesh(shapeObj) {

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

@@ -1,8 +1,10 @@
 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) {
     const shape = shapeObj.getShape();
+    Mesh.ensureTriangulated(shape);
     const edges = Explorer.findShapes(shape, Explorer.getOcShapeType("edge"));
     const allVertices = [];
     const allNormals = [];

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

@@ -1,3 +1,13 @@
 import { Scene } from "./scene.js";
-export declare function renderSceneRollback(scene: Scene, rollbackIndex: number): Scene;
-export declare function renderScene(scene: Scene): Scene;
+export declare class SceneRenderer {
+    private readonly meshBuilder;
+    render(scene: Scene): Scene;
+    renderRollback(scene: Scene, rollbackIndex: number): Scene;
+    private renderObject;
+    private buildObject;
+    private getOrBuildMeshes;
+    private toRenderedShape;
+    private computeVisibility;
+    private aggregateContainerDurations;
+    private emitRendered;
+}