fluidcad 0.0.27 → 0.0.28

package/lib/dist/features/extrude-base.js

@@ -1,4 +1,5 @@
 import { Face } from "../common/face.js";
+import { Edge } from "../common/edge.js";
 import { SceneObject } from "../common/scene-object.js";
 import { LazySelectionSceneObject } from "./lazy-scene-object.js";
 import { normalizePoint2D } from "../helpers/normalize.js";
@@ -8,6 +9,18 @@ import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
 import { ShapeFilter } from "../filters/filter.js";
 import { EdgeOps } from "../oc/edge-ops.js";
+import { Explorer } from "../oc/explorer.js";
+import { getOC } from "../oc/init.js";
+import { ShapeHistoryTracker } from "../common/shape-history-tracker.js";
+function dedupEdgesByIsSame(edges) {
+    const result = [];
+    for (const edge of edges) {
+        if (!result.some(r => r.getShape().IsSame(edge.getShape()))) {
+            result.push(edge);
+        }
+    }
+    return result;
+}
 export class ExtrudeBase extends SceneObject {
     _extrudable = null;
     _faceSource = null;
@@ -80,19 +93,10 @@ export class ExtrudeBase extends SceneObject {
     startEdges(...args) {
         const suffix = this.buildSuffix('start-edges', args);
         return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            if (this._operationMode === 'remove') {
-                const edges = parent.getState('start-edges') || [];
-                const transform = parent.getTransform();
-                const originalEdges = transform
-                    ? (this.getState('start-edges') || [])
-                    : null;
-                return this.resolveEdges(edges, args, transform, originalEdges);
-            }
-            const faces = parent.getState('start-faces') || [];
-            const edges = faces.flatMap(f => f.getEdges());
+            const edges = this.getClassifiedEdges(parent, 'start-edges', 'start-faces');
             const transform = parent.getTransform();
             const originalEdges = transform
-                ? (this.getState('start-faces') || []).flatMap(f => f.getEdges())
+                ? this.getClassifiedEdges(this, 'start-edges', 'start-faces')
                 : null;
             return this.resolveEdges(edges, args, transform, originalEdges);
         }, this);
@@ -100,19 +104,10 @@ export class ExtrudeBase extends SceneObject {
     endEdges(...args) {
         const suffix = this.buildSuffix('end-edges', args);
         return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            if (this._operationMode === 'remove') {
-                const edges = parent.getState('end-edges') || [];
-                const transform = parent.getTransform();
-                const originalEdges = transform
-                    ? (this.getState('end-edges') || [])
-                    : null;
-                return this.resolveEdges(edges, args, transform, originalEdges);
-            }
-            const faces = parent.getState('end-faces') || [];
-            const edges = faces.flatMap(f => f.getEdges());
+            const edges = this.getClassifiedEdges(parent, 'end-edges', 'end-faces');
             const transform = parent.getTransform();
             const originalEdges = transform
-                ? (this.getState('end-faces') || []).flatMap(f => f.getEdges())
+                ? this.getClassifiedEdges(this, 'end-edges', 'end-faces')
                 : null;
             return this.resolveEdges(edges, args, transform, originalEdges);
         }, this);
@@ -131,13 +126,17 @@ export class ExtrudeBase extends SceneObject {
     sideEdges(...args) {
         const suffix = this.buildSuffix('side-edges', args);
         return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const classified = parent.getState('side-edges');
+            if (classified !== undefined) {
+                return this.resolveEdges(classified, args);
+            }
+            // Fallback for peer ops that haven't called classifyExtrudeEdges: derive on the fly.
             const sideFaces = parent.getState('side-faces') || [];
             const startFaces = parent.getState('start-faces') || [];
             const endFaces = parent.getState('end-faces') || [];
             const excludedEdges = [...startFaces, ...endFaces].flatMap(f => f.getEdges());
-            const edges = sideFaces.flatMap(f => f.getEdges())
-                .filter(e => !excludedEdges.some(ex => e.getShape().IsSame(ex.getShape())))
-                .filter((e, i, arr) => arr.findIndex(o => o.getShape().IsSame(e.getShape())) === i);
+            const edges = dedupEdgesByIsSame(sideFaces.flatMap(f => f.getEdges())
+                .filter(e => !excludedEdges.some(ex => e.getShape().IsSame(ex.getShape()))));
             return this.resolveEdges(edges, args);
         }, this);
     }
@@ -169,12 +168,7 @@ export class ExtrudeBase extends SceneObject {
     internalEdges(...args) {
         const suffix = this.buildSuffix('internal-edges', args);
         return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            if (this._operationMode === 'remove') {
-                const edges = parent.getState('internal-edges') || [];
-                return this.resolveEdges(edges, args);
-            }
-            const faces = parent.getState('internal-faces') || [];
-            const edges = faces.flatMap(f => f.getEdges());
+            const edges = this.getClassifiedEdges(parent, 'internal-edges', 'internal-faces');
             return this.resolveEdges(edges, args);
         }, this);
     }
@@ -192,11 +186,89 @@ export class ExtrudeBase extends SceneObject {
     capEdges(...args) {
         const suffix = this.buildSuffix('cap-edges', args);
         return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            const faces = parent.getState('cap-faces') || [];
-            const edges = faces.flatMap(f => f.getEdges());
+            const edges = this.getClassifiedEdges(parent, 'cap-edges', 'cap-faces');
             return this.resolveEdges(edges, args);
         }, this);
     }
+    /**
+     * Read edges for a classification category, preferring the pre-computed
+     * state key (set by `classifyExtrudeEdges` during build) and falling back
+     * to deriving from the corresponding face-category state (for peer ops that
+     * haven't opted into the unified classification step yet).
+     */
+    getClassifiedEdges(source, edgeKey, faceKey) {
+        const classified = source.getState(edgeKey);
+        if (classified !== undefined) {
+            return classified;
+        }
+        const faces = source.getState(faceKey) || [];
+        return dedupEdgesByIsSame(faces.flatMap(f => f.getEdges()));
+    }
+    /**
+     * Remap the state-stored face category arrays through a fusion's tool-side
+     * history so each face reference points at the actual post-fusion face in
+     * the final solid. Call after `fuseWithSceneObjects` returns a `toolHistory`.
+     */
+    remapClassifiedFaces(history) {
+        const keys = ['start-faces', 'end-faces', 'side-faces', 'internal-faces', 'cap-faces'];
+        for (const key of keys) {
+            const faces = this.getState(key);
+            if (faces && faces.length > 0) {
+                this.setState(key, ShapeHistoryTracker.remapFaces(faces, history));
+            }
+        }
+    }
+    /**
+     * Record every face/edge of the given shapes as additions on this operation.
+     * Used by 3D ops in the "no scene fusion" path — when the tools land
+     * unchanged in the scene, every face/edge is brand new from this op's POV.
+     */
+    recordShapeFacesAndEdgesAsAdditions(shapes) {
+        const oc = getOC();
+        const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
+        const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+        for (const shape of shapes) {
+            for (const raw of Explorer.findShapes(shape.getShape(), FACE)) {
+                this.recordAddedFace(Face.fromTopoDSFace(Explorer.toFace(raw)), this);
+            }
+            for (const raw of Explorer.findShapes(shape.getShape(), EDGE)) {
+                this.recordAddedEdge(Edge.fromTopoDSEdge(Explorer.toEdge(raw)), this);
+            }
+        }
+    }
+    /**
+     * One-shot edge classification: derive start/end/side/internal/cap edges
+     * from the already-classified face arrays in state and store them as
+     * `start-edges`, `end-edges`, `side-edges`, `internal-edges`, `cap-edges`.
+     *
+     * Call this once after face classification (and after any post-fusion
+     * face remapping) so that the selection accessors can just read the
+     * pre-computed arrays instead of re-deriving on every access. Matches
+     * the classification step from the spec: "Classify the new edges and
+     * faces created by the operation".
+     *
+     * Side edges are the edges of side faces minus any edge that's also on
+     * a start/end face (those already belong to start-edges / end-edges).
+     */
+    classifyExtrudeEdges() {
+        const startFaces = this.getState('start-faces') || [];
+        const endFaces = this.getState('end-faces') || [];
+        const sideFaces = this.getState('side-faces') || [];
+        const internalFaces = this.getState('internal-faces') || [];
+        const capFaces = this.getState('cap-faces') || [];
+        const startEdges = dedupEdgesByIsSame(startFaces.flatMap(f => f.getEdges()));
+        const endEdges = dedupEdgesByIsSame(endFaces.flatMap(f => f.getEdges()));
+        const excludedForSide = [...startEdges, ...endEdges];
+        const sideEdges = dedupEdgesByIsSame(sideFaces.flatMap(f => f.getEdges())
+            .filter(e => !excludedForSide.some(ex => ex.getShape().IsSame(e.getShape()))));
+        const internalEdges = dedupEdgesByIsSame(internalFaces.flatMap(f => f.getEdges()));
+        const capEdges = dedupEdgesByIsSame(capFaces.flatMap(f => f.getEdges()));
+        this.setState('start-edges', startEdges);
+        this.setState('end-edges', endEdges);
+        this.setState('side-edges', sideEdges);
+        this.setState('internal-edges', internalEdges);
+        this.setState('cap-edges', capEdges);
+    }
     buildSuffix(prefix, args) {
         if (args.length === 0) {
             return prefix;

package/lib/dist/features/extrude-to-face.js

@@ -91,20 +91,31 @@ export class ExtrudeToFace extends ExtrudeBase {
         }
         if (this._operationMode === 'remove') {
             const scope = this.resolveFusionScope(allSceneObjects);
-            cutWithSceneObjects(scope, solids, plane, 0, this);
+            cutWithSceneObjects(scope, solids, plane, 0, this, { recordHistoryFor: this });
+            this.setFinalShapes(this.getShapes());
             return;
         }
         if (sceneObjects.length === 0) {
             this.addShapes(solids);
+            this.recordShapeFacesAndEdgesAsAdditions(solids);
+            this.classifyExtrudeEdges();
+            this.setFinalShapes(this.getShapes());
             return;
         }
-        const fusionResult = fuseWithSceneObjects(sceneObjects, solids);
+        const fusionResult = fuseWithSceneObjects(sceneObjects, solids, {
+            recordHistoryFor: this,
+        });
         for (const modifiedShape of fusionResult.modifiedShapes) {
             if (modifiedShape.object) {
                 modifiedShape.object.removeShape(modifiedShape.shape, this);
             }
         }
         this.addShapes(fusionResult.newShapes);
+        if (fusionResult.toolHistory) {
+            this.remapClassifiedFaces(fusionResult.toolHistory);
+        }
+        this.classifyExtrudeEdges();
+        this.setFinalShapes(this.getShapes());
     }
     createAdvancedExtrude(sourceFace, targetFace, isPlanar, sketchPlane) {
         const targetDistance = this.computeSignedDistanceToFace(targetFace, sketchPlane);

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

@@ -49,7 +49,9 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         const extrusions2 = extruder2.extrude();
         const endFaces = extruder2.getEndFaces();
         const all = [...extrusions1, ...extrusions2];
-        const { result: extrusions } = BooleanOps.fuse(all);
+        const halvesFuse = BooleanOps.fuse(all);
+        const extrusions = halvesFuse.result;
+        halvesFuse.dispose();
         const remainingFaces = [];
         const fusedStartFaces = [];
         const fusedEndFaces = [];
@@ -121,14 +123,22 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         this.getSource()?.removeShapes(this);
         if (this._operationMode === 'remove') {
             const scope = this.resolveFusionScope(context.getSceneObjects());
-            cutWithSceneObjects(scope, extrusions, plane, this.distance1 + this.distance2, this);
+            cutWithSceneObjects(scope, extrusions, plane, this.distance1 + this.distance2, this, {
+                recordHistoryFor: this,
+            });
+            this.setFinalShapes(this.getShapes());
             return;
         }
         if (extrusions.length === 0 || sceneObjects.length === 0) {
             this.addShapes(extrusions);
+            this.recordShapeFacesAndEdgesAsAdditions(extrusions);
+            this.classifyExtrudeEdges();
+            this.setFinalShapes(this.getShapes());
             return;
         }
-        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions);
+        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions, {
+            recordHistoryFor: this,
+        });
         for (const modifiedShape of fusionResult.modifiedShapes) {
             if (!modifiedShape.object) {
                 continue;
@@ -136,6 +146,11 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
             modifiedShape.object.removeShape(modifiedShape.shape, this);
         }
         this.addShapes(fusionResult.newShapes);
+        if (fusionResult.toolHistory) {
+            this.remapClassifiedFaces(fusionResult.toolHistory);
+        }
+        this.classifyExtrudeEdges();
+        this.setFinalShapes(this.getShapes());
     }
     getDependencies() {
         const source = this.getSource();

package/lib/dist/features/extrude.js

@@ -53,6 +53,7 @@ export class Extrude extends ExtrudeBase {
         else {
             this.buildAdd(faces, plane, context, inwardEdges, outwardEdges);
         }
+        this.setFinalShapes(this.getShapes());
         console.log(`[perf] Extrude.build TOTAL: ${(performance.now() - tBuild).toFixed(1)} ms`);
     }
     buildAdd(faces, plane, context, inwardEdges, outwardEdges) {
@@ -81,10 +82,15 @@ export class Extrude extends ExtrudeBase {
         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.isFaceSourced() ? { glue: 'full' } : undefined);
+        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions, {
+            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) {
@@ -93,6 +99,10 @@ export class Extrude extends ExtrudeBase {
             modifiedShape.object.removeShape(modifiedShape.shape, this);
         }
         this.addShapes(fusionResult.newShapes);
+        if (fusionResult.toolHistory) {
+            this.remapClassifiedFaces(fusionResult.toolHistory);
+        }
+        this.classifyExtrudeEdges();
     }
     buildSymmetric(faces, plane, context, inwardEdges, outwardEdges) {
         const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
@@ -103,7 +113,9 @@ export class Extrude extends ExtrudeBase {
         const extrusions2 = extruder2.extrude();
         const endFaces = extruder2.getEndFaces();
         const all = [...extrusions1, ...extrusions2];
-        const { result: extrusions } = BooleanOps.fuse(all);
+        const halvesFuse = 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.
         const remainingFaces = [];
@@ -182,9 +194,13 @@ export class Extrude extends ExtrudeBase {
         this.getSource()?.removeShapes(this);
         if (extrusions.length === 0 || sceneObjects.length === 0) {
             this.addShapes(extrusions);
+            this.recordShapeFacesAndEdgesAsAdditions(extrusions);
+            this.classifyExtrudeEdges();
             return;
         }
-        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions);
+        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions, {
+            recordHistoryFor: this,
+        });
         for (const modifiedShape of fusionResult.modifiedShapes) {
             if (!modifiedShape.object) {
                 continue;
@@ -192,6 +208,10 @@ export class Extrude extends ExtrudeBase {
             modifiedShape.object.removeShape(modifiedShape.shape, this);
         }
         this.addShapes(fusionResult.newShapes);
+        if (fusionResult.toolHistory) {
+            this.remapClassifiedFaces(fusionResult.toolHistory);
+        }
+        this.classifyExtrudeEdges();
     }
     buildRemove(faces, plane, context) {
         const scope = this.resolveFusionScope(context.getSceneObjects());
@@ -212,8 +232,9 @@ export class Extrude extends ExtrudeBase {
                 const extruder2 = new Extruder(faces, plane, this.distance / 2, this.getDraft(), this.getEndOffset());
                 const extrusions2 = extruder2.extrude();
                 const all = [...extrusions1, ...extrusions2];
-                const { result } = BooleanOps.fuse(all);
-                toolShapes = result;
+                const halvesFuse = BooleanOps.fuse(all);
+                toolShapes = halvesFuse.result;
+                halvesFuse.dispose();
             }
         }
         else if (isThroughAll) {
@@ -229,7 +250,9 @@ export class Extrude extends ExtrudeBase {
             toolShapes = extruder.extrude();
         }
         this.getSource()?.removeShapes(this);
-        cutWithSceneObjects(scope, toolShapes, plane, this.distance, this);
+        cutWithSceneObjects(scope, toolShapes, plane, this.distance, this, {
+            recordHistoryFor: this,
+        });
     }
     getDependencies() {
         const source = this.getSource();

package/lib/dist/features/fillet.js

@@ -65,12 +65,11 @@ export class Fillet extends SceneObject {
             }
             edges = edges.filter(e => !targetEdges.includes(e));
             try {
-                const newShape = FilletOps.makeFillet(solid, targetEdges, this.radius);
+                const newSolids = FilletOps.makeFillet(solid, targetEdges, this.radius);
                 const obj = sceneShapeObjectMap.get(shape);
                 removedShapes.push({ shape: solid, owner: obj });
-                const subShapes = Explorer.findSolidsWrapped(newShape);
-                for (const subShape of subShapes) {
-                    addedShapes.push(subShape);
+                for (const newSolid of newSolids) {
+                    addedShapes.push(newSolid);
                 }
             }
             catch {

package/lib/dist/features/fuse.js

@@ -1,5 +1,6 @@
 import { SceneObject } from "../common/scene-object.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
+import { ColorTransfer } from "../oc/color-transfer.js";
 export class Fuse extends SceneObject {
     _sceneObjects = [];
     constructor(...objects) {
@@ -26,16 +27,29 @@ export class Fuse extends SceneObject {
         }
         const fuseResult = BooleanOps.fuse(allShapes);
         if (fuseResult.result.length === allShapes.length) {
+            fuseResult.dispose();
             return;
         }
         if (!fuseResult.modifiedShapes.length) {
+            fuseResult.dispose();
             return;
         }
+        // Color rule for the user-facing Fuse op: the FIRST input is dominant.
+        // If it has any colors, propagate those to the result (and bleed across
+        // adjacent faces from any uncolored input). If the first input has no
+        // colors, the fused result stays uncolored — even if other inputs are
+        // colored, those colors are intentionally dropped.
+        const firstShape = allShapes[0];
+        if (firstShape && firstShape.hasColors()) {
+            ColorTransfer.applyThroughMaker([firstShape], fuseResult.newShapes, fuseResult.maker);
+            ColorTransfer.applyBleeding([firstShape], fuseResult.newShapes, fuseResult.maker);
+        }
         for (const shape of fuseResult.modifiedShapes) {
             const obj = objShapeMap.get(shape);
             obj.removeShape(shape, this);
         }
         this.addShapes(fuseResult.newShapes);
+        fuseResult.dispose();
     }
     compareTo(other) {
         if (!(other instanceof Fuse)) {

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

@@ -9,4 +9,5 @@ export declare class ExtrudeThroughAll {
     private shapes;
     constructor(extrudable: Extrudable, symmetric: boolean, reversed: boolean, pickedFaces?: Face[]);
     build(): Solid[];
+    private firstSolidOf;
 }

package/lib/dist/features/infinite-extrude.js

@@ -1,5 +1,12 @@
+import { Solid } from "../common/shapes.js";
 import { ExtrudeOps } from "../oc/extrude-ops.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { Explorer } from "../oc/explorer.js";
+/** A large finite magnitude that stands in for "infinity" in through-all ops.
+ *  True infinite prisms (via OC's `Inf=true` flag) silently fail inside
+ *  `BRepAlgoAPI_Cut` — use a large finite extrusion instead. */
+const THROUGH_ALL_LENGTH = 100000;
 export class ExtrudeThroughAll {
     extrudable;
     symmetric;
@@ -25,19 +32,29 @@ export class ExtrudeThroughAll {
             dir = dir.multiply(-1);
         }
         const shouldDispose = !this.pickedFaces;
+        const bigDir = dir.multiply(THROUGH_ALL_LENGTH);
         if (this.symmetric) {
             for (const face of faces) {
-                const solid = ExtrudeOps.makePrismSymmetric(face, dir);
-                solids.push(solid);
+                // Fuse two finite large prisms — one in each direction — to approximate
+                // a symmetric through-all tool. Cannot use makePrismSymmetric here
+                // because `BRepAlgoAPI_Cut` silently drops infinite shapes.
+                const positive = ExtrudeOps.makePrism(face, bigDir, 1);
+                const negative = ExtrudeOps.makePrism(face, bigDir, -1);
+                const fuseResult = BooleanOps.fuse([positive, negative]);
+                const fusedSolid = fuseResult.result.find(s => s.getType() === 'solid')
+                    ?? this.firstSolidOf(fuseResult.result);
+                if (fusedSolid) {
+                    solids.push(fusedSolid);
+                }
+                fuseResult.dispose();
                 if (shouldDispose) {
                     face.dispose();
                 }
             }
         }
         else {
-            dir = dir.multiply(100000);
             for (const face of faces) {
-                const solid = ExtrudeOps.makePrism(face, dir, 1);
+                const solid = ExtrudeOps.makePrism(face, bigDir, 1);
                 solids.push(solid);
                 if (shouldDispose) {
                     face.dispose();
@@ -47,4 +64,16 @@ export class ExtrudeThroughAll {
         this.shapes = solids;
         return solids;
     }
+    firstSolidOf(shapes) {
+        for (const shape of shapes) {
+            if (shape.getType() === 'solid') {
+                return shape;
+            }
+            const subSolids = Explorer.findShapes(shape.getShape(), Explorer.getOcShapeType('solid'));
+            if (subSolids.length > 0) {
+                return Solid.fromTopoDSSolid(Explorer.toSolid(subSolids[0]));
+            }
+        }
+        return null;
+    }
 }

package/lib/dist/features/loft.js

@@ -66,21 +66,32 @@ export class Loft extends ExtrudeBase {
         if (this._operationMode === 'remove') {
             const scope = this.resolveFusionScope(context.getSceneObjects());
             const plane = firstPlane || lastPlane;
-            cutWithSceneObjects(scope, newShapes, plane, 0, this);
+            cutWithSceneObjects(scope, newShapes, plane, 0, this, { recordHistoryFor: this });
+            this.setFinalShapes(this.getShapes());
             return;
         }
         const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
         if (sceneObjects.length === 0) {
             this.addShapes(newShapes);
+            this.recordShapeFacesAndEdgesAsAdditions(newShapes);
+            this.classifyExtrudeEdges();
+            this.setFinalShapes(this.getShapes());
             return;
         }
-        const fusionResult = fuseWithSceneObjects(sceneObjects, newShapes);
+        const fusionResult = fuseWithSceneObjects(sceneObjects, newShapes, {
+            recordHistoryFor: this,
+        });
         for (const modifiedShape of fusionResult.modifiedShapes) {
             if (modifiedShape.object) {
                 modifiedShape.object.removeShape(modifiedShape.shape, this);
             }
         }
         this.addShapes(fusionResult.newShapes);
+        if (fusionResult.toolHistory) {
+            this.remapClassifiedFaces(fusionResult.toolHistory);
+        }
+        this.classifyExtrudeEdges();
+        this.setFinalShapes(this.getShapes());
     }
     buildThinLoft() {
         const outerWires = [];
@@ -103,9 +114,11 @@ export class Loft extends ExtrudeBase {
         const outerSolids = LoftOps.makeLoft(outerWires);
         if (innerWires.length > 0 && innerWires.length === outerWires.length) {
             const innerSolids = LoftOps.makeLoft(innerWires);
-            const { result: outerFused } = BooleanOps.fuse(outerSolids);
-            const { result: innerFused } = BooleanOps.fuse(innerSolids);
-            const cutResult = BooleanOps.cutShapes(outerFused[0], innerFused[0]);
+            const outerFuse = BooleanOps.fuse(outerSolids);
+            const innerFuse = BooleanOps.fuse(innerSolids);
+            const cutResult = BooleanOps.cutShapes(outerFuse.result[0], innerFuse.result[0]);
+            outerFuse.dispose();
+            innerFuse.dispose();
             return [cutResult];
         }
         return outerSolids;

package/lib/dist/features/revolve.js

@@ -115,21 +115,32 @@ export class Revolve extends ExtrudeBase {
         this.axis.removeShapes(this);
         if (this._operationMode === 'remove') {
             const scope = this.resolveFusionScope(context.getSceneObjects());
-            cutWithSceneObjects(scope, solids, plane, 0, this);
+            cutWithSceneObjects(scope, solids, plane, 0, this, { recordHistoryFor: this });
+            this.setFinalShapes(this.getShapes());
             return;
         }
         const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
         if (sceneObjects.length === 0) {
             this.addShapes(solids);
+            this.recordShapeFacesAndEdgesAsAdditions(solids);
+            this.classifyExtrudeEdges();
+            this.setFinalShapes(this.getShapes());
             return;
         }
-        const fusionResult = fuseWithSceneObjects(sceneObjects, solids);
+        const fusionResult = fuseWithSceneObjects(sceneObjects, solids, {
+            recordHistoryFor: this,
+        });
         for (const modifiedShape of fusionResult.modifiedShapes) {
             if (modifiedShape.object) {
                 modifiedShape.object.removeShape(modifiedShape.shape, this);
             }
         }
         this.addShapes(fusionResult.newShapes);
+        if (fusionResult.toolHistory) {
+            this.remapClassifiedFaces(fusionResult.toolHistory);
+        }
+        this.classifyExtrudeEdges();
+        this.setFinalShapes(this.getShapes());
     }
     getDependencies() {
         return this.extrudable ? [this.extrudable] : [];

package/lib/dist/features/sweep.js

@@ -102,21 +102,32 @@ export class Sweep extends ExtrudeBase {
         // Handle boolean operation based on operation mode
         if (this._operationMode === 'remove') {
             const scope = this.resolveFusionScope(context.getSceneObjects());
-            cutWithSceneObjects(scope, newShapes, plane, 0, this);
+            cutWithSceneObjects(scope, newShapes, plane, 0, this, { recordHistoryFor: this });
+            this.setFinalShapes(this.getShapes());
             return;
         }
         const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
         if (sceneObjects.length === 0) {
             this.addShapes(newShapes);
+            this.recordShapeFacesAndEdgesAsAdditions(newShapes);
+            this.classifyExtrudeEdges();
+            this.setFinalShapes(this.getShapes());
             return;
         }
-        const fusionResult = fuseWithSceneObjects(sceneObjects, newShapes);
+        const fusionResult = fuseWithSceneObjects(sceneObjects, newShapes, {
+            recordHistoryFor: this,
+        });
         for (const modifiedShape of fusionResult.modifiedShapes) {
             if (modifiedShape.object) {
                 modifiedShape.object.removeShape(modifiedShape.shape, this);
             }
         }
         this.addShapes(fusionResult.newShapes);
+        if (fusionResult.toolHistory) {
+            this.remapClassifiedFaces(fusionResult.toolHistory);
+        }
+        this.classifyExtrudeEdges();
+        this.setFinalShapes(this.getShapes());
     }
     getSpineWire(pathObj) {
         const shapes = pathObj.getShapes({ excludeMeta: false });

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

@@ -1,19 +1,25 @@
 import { SceneObject } from "../common/scene-object.js";
 import { Shape } from "../common/shapes.js";
 import { Plane } from "../math/plane.js";
+import { ShapeHistory } from "../common/shape-history-tracker.js";
 export declare function fuseWithSceneObjects(sceneObjects: SceneObject[], extrusions: Shape<any>[], opts?: {
     glue?: 'full' | 'shift';
+    recordHistoryFor?: SceneObject;
 }): {
     newShapes: Shape<any>[];
     modifiedShapes: any[];
+    toolHistory?: undefined;
 } | {
     newShapes: Shape<import("occjs-wrapper").TopoDS_Shape>[];
     modifiedShapes: {
         shape: Shape<any>;
         object: SceneObject;
     }[];
+    toolHistory: ShapeHistory;
 };
-export declare function cutWithSceneObjects(sceneObjects: SceneObject[], toolShapes: Shape[], plane: Plane, distance: number, caller: SceneObject): {
+export declare function cutWithSceneObjects(sceneObjects: SceneObject[], toolShapes: Shape[], plane: Plane, distance: number, caller: SceneObject, options?: {
+    recordHistoryFor?: SceneObject;
+}): {
     cleanedShapes: Shape[];
     stockShapes: Shape[];
 };