fluidcad 0.0.28 → 0.0.30

package/lib/dist/features/extrude-two-distances.js

@@ -15,41 +15,43 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         this.distance2 = distance2;
     }
     build(context) {
-        const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
-        const plane = this.getSourcePlane();
-        const pickedFaces = this.resolvePickedFaces(plane);
+        const p = context.getProfiler();
+        const plane = p.record('Get source plane', () => this.getSourcePlane());
+        const pickedFaces = p.record('Resolve picked faces', () => this.resolvePickedFaces(plane));
         if (pickedFaces !== null && pickedFaces.length === 0) {
             return;
         }
         let faces;
         let inwardEdges;
         let outwardEdges;
-        if (this.isFaceSourced()) {
-            if (this.isThin()) {
-                throw new Error("thin() is not supported with a face-sourced extrude");
+        faces = p.record('Resolve faces', () => {
+            if (this.isFaceSourced()) {
+                if (this.isThin()) {
+                    throw new Error("thin() is not supported with a face-sourced extrude");
+                }
+                return pickedFaces ?? this.getSourceFaces();
             }
-            faces = pickedFaces ?? this.getSourceFaces();
-        }
-        else if (this.isThin()) {
-            const thinResult = ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]);
-            faces = thinResult.faces;
-            inwardEdges = thinResult.inwardEdges;
-            outwardEdges = thinResult.outwardEdges;
-        }
-        else {
-            faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
-        }
+            else if (this.isThin()) {
+                const thinResult = ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]);
+                inwardEdges = thinResult.inwardEdges;
+                outwardEdges = thinResult.outwardEdges;
+                return thinResult.faces;
+            }
+            else {
+                return pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
+            }
+        });
         const draft = this.getDraft();
         const draft1 = draft ? [draft[0], draft[0]] : undefined;
         const draft2 = draft ? [draft[1], draft[1]] : undefined;
-        const extruder1 = new Extruder(faces, plane, this.distance1, draft1, this.getEndOffset());
-        const extrusions1 = extruder1.extrude();
+        const extruder1 = new Extruder(faces, plane, this.distance1, draft1, this.getEndOffset(), p);
+        const extrusions1 = p.record('Extrude direction 1', () => extruder1.extrude());
         const startFaces = extruder1.getEndFaces();
-        const extruder2 = new Extruder(faces, plane, -this.distance2, draft2, this.getEndOffset());
-        const extrusions2 = extruder2.extrude();
+        const extruder2 = new Extruder(faces, plane, -this.distance2, draft2, this.getEndOffset(), p);
+        const extrusions2 = p.record('Extrude direction 2', () => extruder2.extrude());
         const endFaces = extruder2.getEndFaces();
         const all = [...extrusions1, ...extrusions2];
-        const halvesFuse = BooleanOps.fuse(all);
+        const halvesFuse = p.record('Fuse halves', () => BooleanOps.fuse(all));
         const extrusions = halvesFuse.result;
         halvesFuse.dispose();
         const remainingFaces = [];
@@ -122,13 +124,16 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         this.setState('cap-faces', capFaces);
         this.getSource()?.removeShapes(this);
         if (this._operationMode === 'remove') {
-            const scope = this.resolveFusionScope(context.getSceneObjects());
-            cutWithSceneObjects(scope, extrusions, plane, this.distance1 + this.distance2, this, {
-                recordHistoryFor: this,
+            const scope = p.record('Resolve fusion scope', () => this.resolveFusionScope(context.getSceneObjects()));
+            p.record('Cut with scene objects', () => {
+                cutWithSceneObjects(scope, extrusions, plane, this.distance1 + this.distance2, this, {
+                    recordHistoryFor: this,
+                });
             });
             this.setFinalShapes(this.getShapes());
             return;
         }
+        const sceneObjects = p.record('Resolve fusion scope', () => this.resolveFusionScope(context.getSceneObjects()));
         if (extrusions.length === 0 || sceneObjects.length === 0) {
             this.addShapes(extrusions);
             this.recordShapeFacesAndEdgesAsAdditions(extrusions);
@@ -136,9 +141,9 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
             this.setFinalShapes(this.getShapes());
             return;
         }
-        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions, {
+        const fusionResult = p.record('Fuse with scene objects', () => fuseWithSceneObjects(sceneObjects, extrusions, {
             recordHistoryFor: this,
-        });
+        }));
         for (const modifiedShape of fusionResult.modifiedShapes) {
             if (!modifiedShape.object) {
                 continue;

package/lib/dist/features/extrude.d.ts

@@ -5,8 +5,47 @@ export declare class Extrude extends ExtrudeBase {
     distance: number;
     constructor(distance: number, source?: Extrudable | SceneObject);
     build(context: BuildSceneObjectContext): void;
+    /** Resolve the source faces for a non-thin extrude (add / symmetric / remove). */
+    private resolveSourceFaces;
+    /** Plain extrude: one direction, regular face classification. */
     private buildAdd;
+    /** Thin extrude: shell-like profile with inward/outward offsets. */
+    private buildAddThin;
+    /**
+     * Classify a thin extrusion's faces. For OPEN profiles (`inwardEdges`
+     * non-empty) we reclassify side/internal/cap via the inward/outward edge
+     * matching. For CLOSED profiles (no inward edges, e.g. a rect with `thin(5)`
+     * creating an annulus) the Extruder's own inner-wire detection already
+     * separated start/end/side/internal correctly — keep it as-is.
+     */
+    private classifyThinExtrusion;
+    /** Symmetric extrude: two halves fused together, regular face classification. */
     private buildSymmetric;
+    /**
+     * Classify symmetric-extrusion remaining faces using inner-wire detection.
+     * Used by both `buildSymmetric` and the closed-profile fallback in
+     * `buildSymmetricThin`. Faces of the fused solid that share an edge with a
+     * detected inner wire (a hole) are internal; the rest are side.
+     */
+    private classifySymmetricByInnerWires;
+    /** Symmetric thin extrude: two halves of a shell-like profile fused. */
+    private buildSymmetricThin;
+    /**
+     * Build the two half-extrusions for a symmetric op, fuse them together, and
+     * remap start/end faces onto the fused solid. The "remaining" faces (not
+     * start, not end) are returned for the caller to classify per-mode (regular
+     * inner-wire detection vs thin reclassification).
+     */
+    private buildSymmetricHalves;
+    /**
+     * Find post-fusion edges that came from inner wires of the start face's
+     * pre-fusion profile (holes). Used to classify the symmetric fused solid's
+     * remaining faces into side vs internal. Inner wires are detected as
+     * counter-clockwise wires on the sketch plane; their edges are mapped onto
+     * the fused solid by 2D midpoint matching (SimplifyResult breaks TShape
+     * identity for merged half-faces).
+     */
+    private detectFusedInnerEdges;
     private buildRemove;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;

package/lib/dist/features/extrude.js

@@ -1,5 +1,5 @@
 import { Extruder } from "./simple-extruder.js";
-import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+import { cutWithSceneObjects } from "../helpers/scene-helpers.js";
 import { ExtrudeBase } from "./extrude-base.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
@@ -14,122 +14,193 @@ export class Extrude extends ExtrudeBase {
         this.distance = distance;
     }
     build(context) {
-        const tBuild = performance.now();
-        let t = performance.now();
-        const plane = this.getSourcePlane();
-        console.log(`[perf] Extrude.getSourcePlane: ${(performance.now() - t).toFixed(1)} ms`);
-        t = performance.now();
-        const pickedFaces = this.resolvePickedFaces(plane);
-        console.log(`[perf] Extrude.resolvePickedFaces: ${(performance.now() - t).toFixed(1)} ms`);
+        const p = context.getProfiler();
+        const plane = p.record('Get source plane', () => this.getSourcePlane());
+        const pickedFaces = p.record('Resolve picked faces', () => this.resolvePickedFaces(plane));
         if (pickedFaces !== null && pickedFaces.length === 0) {
             return;
         }
-        let faces;
-        let inwardEdges;
-        let outwardEdges;
-        t = performance.now();
-        if (this.isFaceSourced()) {
-            if (this.isThin()) {
+        if (this.isThin()) {
+            if (this.isFaceSourced()) {
                 throw new Error("thin() is not supported with a face-sourced extrude");
             }
-            faces = pickedFaces ?? this.getSourceFaces();
-        }
-        else if (this.isThin()) {
-            const thinResult = ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]);
-            faces = thinResult.faces;
-            inwardEdges = thinResult.inwardEdges;
-            outwardEdges = thinResult.outwardEdges;
-        }
-        else {
-            faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
-        }
-        console.log(`[perf] Extrude.resolveFaces (faces=${faces.length}, faceSourced=${this.isFaceSourced()}): ${(performance.now() - t).toFixed(1)} ms`);
-        if (this._operationMode === 'remove') {
-            this.buildRemove(faces, plane, context);
-        }
-        else if (this._symmetric) {
-            this.buildSymmetric(faces, plane, context, inwardEdges, outwardEdges);
+            const thinResult = p.record('Resolve thin faces', () => ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]));
+            if (this._operationMode === 'remove') {
+                // Thin + remove: use the thin profile faces as the cut tool source,
+                // but the cut path doesn't apply thin face reclassification.
+                this.buildRemove(thinResult.faces, plane, context);
+            }
+            else if (this._symmetric) {
+                this.buildSymmetricThin(thinResult, plane, context);
+            }
+            else {
+                this.buildAddThin(thinResult, plane, context);
+            }
         }
         else {
-            this.buildAdd(faces, plane, context, inwardEdges, outwardEdges);
+            const faces = p.record('Resolve faces', () => this.resolveSourceFaces(plane, pickedFaces));
+            if (this._operationMode === 'remove') {
+                this.buildRemove(faces, plane, context);
+            }
+            else if (this._symmetric) {
+                this.buildSymmetric(faces, plane, context);
+            }
+            else {
+                this.buildAdd(faces, plane, context);
+            }
         }
         this.setFinalShapes(this.getShapes());
-        console.log(`[perf] Extrude.build TOTAL: ${(performance.now() - tBuild).toFixed(1)} ms`);
     }
-    buildAdd(faces, plane, context, inwardEdges, outwardEdges) {
-        let t = performance.now();
-        const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
-        console.log(`[perf] Extrude.buildAdd.resolveFusionScope (n=${sceneObjects.length}): ${(performance.now() - t).toFixed(1)} ms`);
-        t = performance.now();
-        const extruder = new Extruder(faces, plane, this.distance, this.getDraft(), this.getEndOffset());
-        let extrusions = extruder.extrude();
-        console.log(`[perf] Extrude.buildAdd.extruder.extrude (extrusions=${extrusions.length}): ${(performance.now() - t).toFixed(1)} ms`);
-        let sideFaces = extruder.getSideFaces();
-        let internalFaces = extruder.getInternalFaces();
-        let capFaces = [];
-        if (inwardEdges && inwardEdges.length > 0) {
-            const result = this.reclassifyThinFaces([...sideFaces, ...internalFaces], extruder.getStartFaces(), plane, inwardEdges, outwardEdges || []);
-            sideFaces = result.sideFaces;
-            internalFaces = result.internalFaces;
-            capFaces = result.capFaces;
+    /** Resolve the source faces for a non-thin extrude (add / symmetric / remove). */
+    resolveSourceFaces(plane, pickedFaces) {
+        if (this.isFaceSourced()) {
+            return pickedFaces ?? this.getSourceFaces();
         }
-        this.setState('start-faces', extruder.getStartFaces());
-        this.setState('end-faces', extruder.getEndFaces());
-        this.setState('side-faces', sideFaces);
-        this.setState('internal-faces', internalFaces);
-        this.setState('cap-faces', capFaces);
+        return pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
+    }
+    /** Plain extrude: one direction, regular face classification. */
+    buildAdd(faces, plane, context) {
+        const p = context.getProfiler();
+        const extruder = new Extruder(faces, plane, this.distance, this.getDraft(), this.getEndOffset(), p);
+        const extrusions = p.record('Extrude faces', () => extruder.extrude());
+        const classified = {
+            startFaces: extruder.getStartFaces(),
+            endFaces: extruder.getEndFaces(),
+            sideFaces: extruder.getSideFaces(),
+            internalFaces: extruder.getInternalFaces(),
+            capFaces: [],
+        };
         this.getSource()?.removeShapes(this);
-        console.log("Extrusions before fusion:", extrusions.length);
-        if (extrusions.length === 0 || sceneObjects.length === 0) {
-            this.addShapes(extrusions);
-            this.recordShapeFacesAndEdgesAsAdditions(extrusions);
-            this.classifyExtrudeEdges();
-            return;
-        }
-        const tFuse = performance.now();
-        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions, {
+        this.finalizeAndFuse(extrusions, classified, context, {
             glue: this.isFaceSourced() ? 'full' : undefined,
-            recordHistoryFor: this,
         });
-        console.log(`[perf] Extrude.buildAdd.fuseWithSceneObjects: ${(performance.now() - tFuse).toFixed(1)} ms`);
-        for (const modifiedShape of fusionResult.modifiedShapes) {
-            if (!modifiedShape.object) {
-                continue;
+    }
+    /** Thin extrude: shell-like profile with inward/outward offsets. */
+    buildAddThin(thinResult, plane, context) {
+        const p = context.getProfiler();
+        const extruder = new Extruder(thinResult.faces, plane, this.distance, this.getDraft(), this.getEndOffset(), p);
+        const extrusions = p.record('Extrude thin faces', () => extruder.extrude());
+        const classified = this.classifyThinExtrusion(extruder.getStartFaces(), extruder.getEndFaces(), extruder.getSideFaces(), extruder.getInternalFaces(), extruder.getStartFaces(), plane, thinResult);
+        this.getSource()?.removeShapes(this);
+        this.finalizeAndFuse(extrusions, classified, context, {
+            glue: this.isFaceSourced() ? 'full' : undefined,
+        });
+    }
+    /**
+     * Classify a thin extrusion's faces. For OPEN profiles (`inwardEdges`
+     * non-empty) we reclassify side/internal/cap via the inward/outward edge
+     * matching. For CLOSED profiles (no inward edges, e.g. a rect with `thin(5)`
+     * creating an annulus) the Extruder's own inner-wire detection already
+     * separated start/end/side/internal correctly — keep it as-is.
+     */
+    classifyThinExtrusion(startFaces, endFaces, sideFaces, internalFaces, referenceFaces, plane, thinResult) {
+        if (thinResult.inwardEdges.length === 0) {
+            return {
+                startFaces,
+                endFaces,
+                sideFaces,
+                internalFaces,
+                capFaces: [],
+            };
+        }
+        const reclass = this.reclassifyThinFaces([...sideFaces, ...internalFaces], referenceFaces, plane, thinResult.inwardEdges, thinResult.outwardEdges);
+        return {
+            startFaces,
+            endFaces,
+            sideFaces: reclass.sideFaces,
+            internalFaces: reclass.internalFaces,
+            capFaces: reclass.capFaces,
+        };
+    }
+    /** Symmetric extrude: two halves fused together, regular face classification. */
+    buildSymmetric(faces, plane, context) {
+        const halves = this.buildSymmetricHalves(faces, plane, context);
+        const classified = this.classifySymmetricByInnerWires(halves, plane);
+        this.getSource()?.removeShapes(this);
+        this.finalizeAndFuse(halves.extrusions, classified, context);
+    }
+    /**
+     * Classify symmetric-extrusion remaining faces using inner-wire detection.
+     * Used by both `buildSymmetric` and the closed-profile fallback in
+     * `buildSymmetricThin`. Faces of the fused solid that share an edge with a
+     * detected inner wire (a hole) are internal; the rest are side.
+     */
+    classifySymmetricByInnerWires(halves, plane) {
+        const fusedInnerEdges = this.detectFusedInnerEdges(halves.extruder1, halves.fusedStartFaces, plane);
+        const sideFaces = [];
+        const internalFaces = [];
+        for (const f of halves.remainingFaces) {
+            const isInternal = fusedInnerEdges.length > 0 && f.getEdges().some(fe => fusedInnerEdges.some(ie => fe.getShape().IsPartner(ie.getShape())));
+            if (isInternal) {
+                internalFaces.push(f);
+            }
+            else {
+                sideFaces.push(f);
             }
-            modifiedShape.object.removeShape(modifiedShape.shape, this);
         }
-        this.addShapes(fusionResult.newShapes);
-        if (fusionResult.toolHistory) {
-            this.remapClassifiedFaces(fusionResult.toolHistory);
+        return {
+            startFaces: halves.startFaces,
+            endFaces: halves.endFaces,
+            sideFaces,
+            internalFaces,
+            capFaces: [],
+        };
+    }
+    /** Symmetric thin extrude: two halves of a shell-like profile fused. */
+    buildSymmetricThin(thinResult, plane, context) {
+        const halves = this.buildSymmetricHalves(thinResult.faces, plane, context);
+        let classified;
+        if (thinResult.inwardEdges.length > 0) {
+            // Open profile: reclassify side/internal/cap via inward/outward edge matching.
+            const reclass = this.reclassifyThinFaces(halves.remainingFaces, [...halves.fusedStartFaces, ...halves.fusedEndFaces], plane, thinResult.inwardEdges, thinResult.outwardEdges);
+            classified = {
+                startFaces: halves.startFaces,
+                endFaces: halves.endFaces,
+                sideFaces: reclass.sideFaces,
+                internalFaces: reclass.internalFaces,
+                capFaces: reclass.capFaces,
+            };
         }
-        this.classifyExtrudeEdges();
+        else {
+            // Closed profile (e.g. rect.thin(5) producing an annulus): fall back to
+            // the regular symmetric inner-wire detection — the Extruder's wire
+            // orientation already encoded the hole correctly.
+            classified = this.classifySymmetricByInnerWires(halves, plane);
+        }
+        this.getSource()?.removeShapes(this);
+        this.finalizeAndFuse(halves.extrusions, classified, context);
     }
-    buildSymmetric(faces, plane, context, inwardEdges, outwardEdges) {
-        const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
-        const extruder1 = new Extruder(faces, plane, this.distance / 2, this.getDraft(), this.getEndOffset());
-        const extrusions1 = extruder1.extrude();
+    /**
+     * Build the two half-extrusions for a symmetric op, fuse them together, and
+     * remap start/end faces onto the fused solid. The "remaining" faces (not
+     * start, not end) are returned for the caller to classify per-mode (regular
+     * inner-wire detection vs thin reclassification).
+     */
+    buildSymmetricHalves(faces, plane, context) {
+        const p = context.getProfiler();
+        const extruder1 = new Extruder(faces, plane, this.distance / 2, this.getDraft(), this.getEndOffset(), p);
+        const extrusions1 = p.record('Extrude direction 1', () => extruder1.extrude());
         const startFaces = extruder1.getEndFaces();
-        const extruder2 = new Extruder(faces, plane, -this.distance / 2, this.getDraft(), this.getEndOffset());
-        const extrusions2 = extruder2.extrude();
+        const extruder2 = new Extruder(faces, plane, -this.distance / 2, this.getDraft(), this.getEndOffset(), p);
+        const extrusions2 = p.record('Extrude direction 2', () => extruder2.extrude());
         const endFaces = extruder2.getEndFaces();
         const all = [...extrusions1, ...extrusions2];
-        const halvesFuse = BooleanOps.fuse(all);
+        const halvesFuse = p.record('Fuse halves', () => BooleanOps.fuse(all));
         const extrusions = halvesFuse.result;
         halvesFuse.dispose();
-        // Collect remaining faces and fused start/end faces from the fused solid.
-        // We need the fused face objects (not pre-fusion) for IsPartner matching.
+        // Re-find start/end faces in the fused solid (NonDestructive preserves
+        // their TShape, so IsSame matching works) and collect everything else as
+        // "remaining" for per-mode classification.
         const remainingFaces = [];
         const fusedStartFaces = [];
         const fusedEndFaces = [];
         for (const solid of extrusions) {
-            const allFaces = Explorer.findFacesWrapped(solid);
-            for (const f of allFaces) {
-                const isStart = startFaces.some(sf => f.getShape().IsSame(sf.getShape()));
-                const isEnd = endFaces.some(ef => f.getShape().IsSame(ef.getShape()));
-                if (isStart) {
+            for (const f of Explorer.findFacesWrapped(solid)) {
+                const raw = f.getShape();
+                if (startFaces.some(sf => raw.IsSame(sf.getShape()))) {
                     fusedStartFaces.push(f);
                 }
-                else if (isEnd) {
+                else if (endFaces.some(ef => raw.IsSame(ef.getShape()))) {
                     fusedEndFaces.push(f);
                 }
                 else {
@@ -137,81 +208,50 @@ export class Extrude extends ExtrudeBase {
                 }
             }
         }
-        let sideFaces;
-        let internalFaces;
-        let capFaces = [];
-        if (inwardEdges && inwardEdges.length > 0) {
-            // For thin open profiles: reclassify using 2D midpoint matching on the fused solid
-            const result = this.reclassifyThinFaces(remainingFaces, [...fusedStartFaces, ...fusedEndFaces], plane, inwardEdges, outwardEdges || []);
-            sideFaces = result.sideFaces;
-            internalFaces = result.internalFaces;
-            capFaces = result.capFaces;
-        }
-        else {
-            // Detect inner wire edges from the extruder's firstFaces (at the sketch plane,
-            // pre-fusion). These have the same wire orientation the Extruder uses internally.
-            // Then map to fused solid edges using 2D midpoint matching, since SimplifyResult
-            // merges half-faces and breaks TShape identity.
-            const preInnerEdges = [];
-            for (const sf of extruder1.getStartFaces()) {
-                for (const wire of sf.getWires()) {
-                    if (!wire.isCW(plane.normal)) {
-                        for (const edge of wire.getEdges()) {
-                            preInnerEdges.push(edge);
-                        }
-                    }
-                }
-            }
-            const fusedInnerEdges = [];
-            if (preInnerEdges.length > 0) {
-                const innerMids = preInnerEdges.map(e => plane.worldToLocal(EdgeOps.getEdgeMidPointRaw(e.getShape())));
-                for (const sf of fusedStartFaces) {
-                    for (const sfe of sf.getEdges()) {
-                        const mid = plane.worldToLocal(EdgeOps.getEdgeMidPointRaw(sfe.getShape()));
-                        if (innerMids.some(im => mid.distanceTo(im) < 1e-4)) {
-                            fusedInnerEdges.push(sfe);
-                        }
+        return {
+            extrusions,
+            extruder1,
+            extruder2,
+            startFaces,
+            endFaces,
+            fusedStartFaces,
+            fusedEndFaces,
+            remainingFaces,
+        };
+    }
+    /**
+     * Find post-fusion edges that came from inner wires of the start face's
+     * pre-fusion profile (holes). Used to classify the symmetric fused solid's
+     * remaining faces into side vs internal. Inner wires are detected as
+     * counter-clockwise wires on the sketch plane; their edges are mapped onto
+     * the fused solid by 2D midpoint matching (SimplifyResult breaks TShape
+     * identity for merged half-faces).
+     */
+    detectFusedInnerEdges(extruder1, fusedStartFaces, plane) {
+        const preInnerEdges = [];
+        for (const sf of extruder1.getStartFaces()) {
+            for (const wire of sf.getWires()) {
+                if (!wire.isCW(plane.normal)) {
+                    for (const edge of wire.getEdges()) {
+                        preInnerEdges.push(edge);
                     }
                 }
             }
-            sideFaces = [];
-            internalFaces = [];
-            for (const f of remainingFaces) {
-                const isInternal = fusedInnerEdges.length > 0 && f.getEdges().some(fe => fusedInnerEdges.some(ie => fe.getShape().IsPartner(ie.getShape())));
-                if (isInternal) {
-                    internalFaces.push(f);
-                }
-                else {
-                    sideFaces.push(f);
-                }
-            }
         }
-        this.setState('start-faces', startFaces);
-        this.setState('end-faces', endFaces);
-        this.setState('side-faces', sideFaces);
-        this.setState('internal-faces', internalFaces);
-        this.setState('cap-faces', capFaces);
-        this.getSource()?.removeShapes(this);
-        if (extrusions.length === 0 || sceneObjects.length === 0) {
-            this.addShapes(extrusions);
-            this.recordShapeFacesAndEdgesAsAdditions(extrusions);
-            this.classifyExtrudeEdges();
-            return;
+        if (preInnerEdges.length === 0) {
+            return [];
         }
-        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions, {
-            recordHistoryFor: this,
-        });
-        for (const modifiedShape of fusionResult.modifiedShapes) {
-            if (!modifiedShape.object) {
-                continue;
+        const innerMids = preInnerEdges.map(e => plane.worldToLocal(EdgeOps.getEdgeMidPointRaw(e.getShape())));
+        const fusedInnerEdges = [];
+        for (const sf of fusedStartFaces) {
+            for (const sfe of sf.getEdges()) {
+                const mid = plane.worldToLocal(EdgeOps.getEdgeMidPointRaw(sfe.getShape()));
+                if (innerMids.some(im => mid.distanceTo(im) < 1e-4)) {
+                    fusedInnerEdges.push(sfe);
+                }
             }
-            modifiedShape.object.removeShape(modifiedShape.shape, this);
-        }
-        this.addShapes(fusionResult.newShapes);
-        if (fusionResult.toolHistory) {
-            this.remapClassifiedFaces(fusionResult.toolHistory);
         }
-        this.classifyExtrudeEdges();
+        return fusedInnerEdges;
     }
     buildRemove(faces, plane, context) {
         const scope = this.resolveFusionScope(context.getSceneObjects());

package/lib/dist/features/fuse.js

@@ -11,6 +11,7 @@ export class Fuse extends SceneObject {
         return this._sceneObjects;
     }
     build(context) {
+        const p = context.getProfiler();
         let sceneObjects = this.sceneObjects;
         if (sceneObjects?.length === 0) {
             sceneObjects = context.getSceneObjects();
@@ -25,7 +26,7 @@ export class Fuse extends SceneObject {
         if (allShapes.length < 2) {
             return;
         }
-        const fuseResult = BooleanOps.fuse(allShapes);
+        const fuseResult = p.record('Fuse solids', () => BooleanOps.fuse(allShapes));
         if (fuseResult.result.length === allShapes.length) {
             fuseResult.dispose();
             return;

package/lib/dist/features/lazy-scene-object.d.ts

@@ -7,6 +7,7 @@ export declare class LazySelectionSceneObject extends SceneObject {
     private _originalParent;
     constructor(uniqueName: string, getShapesFn: (parent: SceneObject) => Shape[], sourceParent: SceneObject);
     build(): void;
+    isLazy(): boolean;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: LazySelectionSceneObject): boolean;

package/lib/dist/features/lazy-scene-object.js

@@ -14,6 +14,9 @@ export class LazySelectionSceneObject extends SceneObject {
         const shapes = this.getShapesFn(this.sourceParent);
         this.addShapes(shapes);
     }
+    isLazy() {
+        return true;
+    }
     getDependencies() {
         return [this.sourceParent];
     }

package/lib/dist/features/lazy-vertex.d.ts

@@ -8,6 +8,7 @@ export declare class LazyVertex extends SceneObject {
     private _isBuilt;
     constructor(uniqueName: string, getShapesFn: () => Shape[]);
     build(): void;
+    isLazy(): boolean;
     getShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
     asPoint(): import("../math/point.js").Point;
     asPoint2D(): import("../math/point.js").Point2D;

package/lib/dist/features/lazy-vertex.js

@@ -19,6 +19,9 @@ export class LazyVertex extends SceneObject {
         }
         this.addShapes(shapes);
     }
+    isLazy() {
+        return true;
+    }
     getShapes(filter, type) {
         if (this._isBuilt) {
             return super.getShapes(filter, type);