fluidcad 0.0.26 → 0.0.28

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

@@ -1,17 +1,25 @@
 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>[]): {
+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[];
 };

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

@@ -1,8 +1,15 @@
 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) {
+import { ShapeHistoryTracker } from "../common/shape-history-tracker.js";
+import { Explorer } from "../oc/explorer.js";
+import { Face } from "../common/face.js";
+import { Edge } from "../common/edge.js";
+import { getOC } from "../oc/init.js";
+import { ColorTransfer } from "../oc/color-transfer.js";
+export function fuseWithSceneObjects(sceneObjects, extrusions, opts) {
     const modified = [];
+    const tCollect = performance.now();
     const objShapeMap = new Map();
     for (const obj of sceneObjects) {
         const shapes = obj.getShapes({}, 'solid');
@@ -11,14 +18,19 @@ 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);
-    const all = [...sceneShapes, ...extrusions];
-    const { result, newShapes, modifiedShapes } = BooleanOps.fuse(all);
+    console.log(`[perf] fuseWithSceneObjects.collect (scenes=${sceneShapes.length}, extrusions=${extrusions.length}): ${(performance.now() - tCollect).toFixed(1)} ms`);
+    const tFuse = performance.now();
+    const { result, newShapes, modifiedShapes, maker, dispose } = BooleanOps.fuseStockAndTools(sceneShapes, extrusions, opts);
+    console.log(`[perf] fuseWithSceneObjects.BooleanOps.fuseStockAndTools (glue=${opts?.glue ?? 'off'}): ${(performance.now() - tFuse).toFixed(1)} ms`);
     if (newShapes.length === 0 && modifiedShapes.length === 0) {
         console.log("No fusions were made.");
+        dispose();
+        if (opts?.recordHistoryFor) {
+            recordShapesAsAdditions(opts.recordHistoryFor, extrusions);
+        }
         return {
             newShapes: extrusions,
-            modifiedShapes: []
+            modifiedShapes: [],
         };
     }
     for (const shape of modifiedShapes) {
@@ -30,9 +42,93 @@ export function fuseWithSceneObjects(sceneObjects, extrusions) {
     // stay on their original owners so we must not duplicate them.
     const unconsumed = sceneShapes.filter(s => !modifiedShapes.includes(s));
     const shapesToAdd = result.filter(s => !unconsumed.some(u => u.getShape().IsPartner(s.getShape())));
-    return { newShapes: shapesToAdd, modifiedShapes: modified };
+    let toolHistory;
+    if (opts?.recordHistoryFor) {
+        recordFusionHistory(opts.recordHistoryFor, sceneShapes, objShapeMap, shapesToAdd, maker);
+        // Separately track tool-side (extrusion) lineage so callers can remap
+        // pre-fusion categorizations (start/end/side/…) onto the post-fusion
+        // faces. We don't store these as modifications on any scene object —
+        // from the user's POV they are additions on the caller already.
+        toolHistory = ShapeHistoryTracker.collect(maker, extrusions);
+    }
+    dispose();
+    return { newShapes: shapesToAdd, modifiedShapes: modified, toolHistory };
+}
+/**
+ * Record faces/edges from each shape as additions on `caller`. Used when a
+ * fusion was a no-op and the new geometry is added to the scene unchanged.
+ */
+function recordShapesAsAdditions(caller, 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)) {
+            caller.recordAddedFace(Face.fromTopoDSFace(Explorer.toFace(raw)), caller);
+        }
+        for (const raw of Explorer.findShapes(shape.getShape(), EDGE)) {
+            caller.recordAddedEdge(Edge.fromTopoDSEdge(Explorer.toEdge(raw)), caller);
+        }
+    }
+}
+/**
+ * Record modifications/removals on each scene-object owner, and additions on
+ * the caller. Modifications are per-scene-shape so we can correctly attribute
+ * each source face/edge back to its owning SceneObject.
+ *
+ * Additions: any face/edge in a new result shape that isn't already the target
+ * of a scene-shape modification. This captures both extrusion-derived faces
+ * (which appear in the result via tool-side Modified()) and truly new faces.
+ */
+function recordFusionHistory(caller, sceneShapes, owners, newShapes, maker) {
+    const oc = getOC();
+    const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
+    const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+    const claimedFaces = new oc.TopTools_MapOfShape();
+    const claimedEdges = new oc.TopTools_MapOfShape();
+    for (const sceneShape of sceneShapes) {
+        const owner = owners.get(sceneShape);
+        if (!owner) {
+            continue;
+        }
+        const history = ShapeHistoryTracker.collect(maker, [sceneShape]);
+        for (const record of history.modifiedFaces) {
+            owner.recordModifiedFaces(record.sources, record.results, caller);
+            for (const r of record.results) {
+                claimedFaces.Add(r.getShape());
+            }
+        }
+        for (const record of history.modifiedEdges) {
+            owner.recordModifiedEdges(record.sources, record.results, caller);
+            for (const r of record.results) {
+                claimedEdges.Add(r.getShape());
+            }
+        }
+        for (const face of history.removedFaces) {
+            owner.recordRemovedFace(face, caller);
+        }
+        for (const edge of history.removedEdges) {
+            owner.recordRemovedEdge(edge, caller);
+        }
+    }
+    for (const newShape of newShapes) {
+        for (const raw of Explorer.findShapes(newShape.getShape(), FACE)) {
+            if (!claimedFaces.Contains(raw)) {
+                caller.recordAddedFace(Face.fromTopoDSFace(Explorer.toFace(raw)), caller);
+            }
+        }
+        for (const raw of Explorer.findShapes(newShape.getShape(), EDGE)) {
+            if (!claimedEdges.Contains(raw)) {
+                caller.recordAddedEdge(Edge.fromTopoDSEdge(Explorer.toEdge(raw)), caller);
+            }
+        }
+    }
+    ColorTransfer.applyThroughMaker(sceneShapes, newShapes, maker);
+    ColorTransfer.applyBleeding(sceneShapes, newShapes, maker);
+    claimedFaces.delete();
+    claimedEdges.delete();
 }
-export function cutWithSceneObjects(sceneObjects, toolShapes, plane, distance, caller) {
+export function cutWithSceneObjects(sceneObjects, toolShapes, plane, distance, caller, options) {
     const sceneObjectMap = new Map();
     for (const obj of sceneObjects) {
         const shapes = obj.getShapes({}, 'solid');
@@ -50,18 +146,190 @@ export function cutWithSceneObjects(sceneObjects, toolShapes, plane, distance, c
     const stock = Array.from(shapeObjectMap.keys());
     const cutResult = BooleanOps.cutMultiShape(stock, toolShapes, plane, distance);
     const cleanedShapes = [];
+    const cleanups = [];
     for (const shape of stock) {
         const list = cutResult.modified(shape);
         if (list.length) {
             for (const newShape of list) {
-                const s = ShapeOps.cleanShape(newShape);
-                caller.addShape(s);
-                cleanedShapes.push(s);
+                const cleanup = ShapeOps.cleanShapeWithLineage(newShape);
+                caller.addShape(cleanup.shape);
+                cleanedShapes.push(cleanup.shape);
+                cleanups.push(cleanup);
             }
             const obj = shapeObjectMap.get(shape);
             obj.removeShape(shape, caller);
         }
     }
+    if (options?.recordHistoryFor) {
+        recordCutHistory(options.recordHistoryFor, stock, shapeObjectMap, cleanedShapes, cutResult.maker, cleanups);
+    }
+    for (const cleanup of cleanups) {
+        cleanup.dispose();
+    }
+    cutResult.dispose();
     classifyCutResult(caller, stock, cleanedShapes, plane, distance);
     return { cleanedShapes, stockShapes: stock };
 }
+/**
+ * Record per-owner modifications/removals and caller-side additions for a cut.
+ * Mirrors the fusion variant but works with `BRepAlgoAPI_Cut`'s `Modified()` /
+ * `IsDeleted()` semantics on stock faces and edges. Additions are the faces
+ * and edges on the cleaned result shapes that aren't targets of any stock
+ * modification — that covers the section faces/edges created by the cut plus
+ * any tool-derived geometry that ended up in the result.
+ */
+function recordCutHistory(caller, stock, owners, cleanedShapes, maker, cleanups) {
+    const oc = getOC();
+    const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
+    const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+    const claimedFaces = new oc.TopTools_MapOfShape();
+    const claimedEdges = new oc.TopTools_MapOfShape();
+    // Remap pre-clean faces through the UnifySameDomain history of whichever
+    // cleanup handled them. Returns flattened post-clean faces.
+    const remapPreCleanFaces = (preCleanFaces) => {
+        const out = [];
+        for (const face of preCleanFaces) {
+            let matched = false;
+            for (const cleanup of cleanups) {
+                const remapped = cleanup.remapFace(face);
+                if (remapped !== null) {
+                    out.push(...remapped);
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                // No cleanup claimed this face — it's somehow outside the cleaned
+                // solids. Fall through as-is.
+                out.push(face);
+            }
+        }
+        return out;
+    };
+    const remapPreCleanEdges = (preCleanEdges) => {
+        const out = [];
+        for (const edge of preCleanEdges) {
+            let matched = false;
+            for (const cleanup of cleanups) {
+                const remapped = cleanup.remapEdge(edge);
+                if (remapped !== null) {
+                    out.push(...remapped);
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                out.push(edge);
+            }
+        }
+        return out;
+    };
+    for (const stockShape of stock) {
+        const owner = owners.get(stockShape);
+        if (!owner) {
+            continue;
+        }
+        const history = ShapeHistoryTracker.collect(maker, [stockShape]);
+        for (const record of history.modifiedFaces) {
+            const postCleanResults = remapPreCleanFaces(record.results);
+            if (postCleanResults.length === 0) {
+                // Entire modification was removed by UnifySameDomain — record as removal instead.
+                for (const src of record.sources) {
+                    owner.recordRemovedFace(src, caller);
+                }
+                continue;
+            }
+            owner.recordModifiedFaces(record.sources, postCleanResults, caller);
+            for (const r of postCleanResults) {
+                claimedFaces.Add(r.getShape());
+            }
+        }
+        for (const record of history.modifiedEdges) {
+            const postCleanResults = remapPreCleanEdges(record.results);
+            if (postCleanResults.length === 0) {
+                for (const src of record.sources) {
+                    owner.recordRemovedEdge(src, caller);
+                }
+                continue;
+            }
+            owner.recordModifiedEdges(record.sources, postCleanResults, caller);
+            for (const r of postCleanResults) {
+                claimedEdges.Add(r.getShape());
+            }
+        }
+        for (const face of history.removedFaces) {
+            owner.recordRemovedFace(face, caller);
+        }
+        for (const edge of history.removedEdges) {
+            owner.recordRemovedEdge(edge, caller);
+        }
+    }
+    for (const cleaned of cleanedShapes) {
+        for (const raw of Explorer.findShapes(cleaned.getShape(), FACE)) {
+            if (!claimedFaces.Contains(raw)) {
+                caller.recordAddedFace(Face.fromTopoDSFace(Explorer.toFace(raw)), caller);
+            }
+        }
+        for (const raw of Explorer.findShapes(cleaned.getShape(), EDGE)) {
+            if (!claimedEdges.Contains(raw)) {
+                caller.recordAddedEdge(Edge.fromTopoDSEdge(Explorer.toEdge(raw)), caller);
+            }
+        }
+    }
+    propagateFaceColorsViaCut(stock, cleanedShapes, maker, cleanups);
+    claimedFaces.delete();
+    claimedEdges.delete();
+}
+/**
+ * Cut-path color propagation. Chains through UnifySameDomain's history via
+ * the `cleanups[]` remapFace callbacks so colors land on the actual
+ * post-clean faces in `cleanedShapes`.
+ */
+function propagateFaceColorsViaCut(stock, cleanedShapes, maker, cleanups) {
+    const oc = getOC();
+    const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
+    for (const stockShape of stock) {
+        if (!stockShape.hasColors()) {
+            continue;
+        }
+        for (const entry of stockShape.colorMap) {
+            const modifiedRaws = ShapeOps.shapeListToArray(maker.Modified(entry.shape))
+                .filter(s => s.ShapeType() === FACE);
+            let preCleanFaces;
+            if (modifiedRaws.length > 0) {
+                preCleanFaces = modifiedRaws.map(r => Face.fromTopoDSFace(Explorer.toFace(r)));
+            }
+            else if (!maker.IsDeleted(entry.shape)) {
+                preCleanFaces = [Face.fromTopoDSFace(Explorer.toFace(entry.shape))];
+            }
+            else {
+                continue;
+            }
+            // Chain through each cleanup's UnifySameDomain lineage
+            const postCleanFaces = [];
+            for (const preFace of preCleanFaces) {
+                let matched = false;
+                for (const cleanup of cleanups) {
+                    const remapped = cleanup.remapFace(preFace);
+                    if (remapped !== null) {
+                        postCleanFaces.push(...remapped);
+                        matched = true;
+                        break;
+                    }
+                }
+                if (!matched) {
+                    postCleanFaces.push(preFace);
+                }
+            }
+            for (const postFace of postCleanFaces) {
+                for (const cleaned of cleanedShapes) {
+                    const faces = Explorer.findShapes(cleaned.getShape(), FACE);
+                    if (faces.some(f => f.IsSame(postFace.getShape()))) {
+                        cleaned.setColor(postFace.getShape(), entry.color);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Shape } from "occjs-wrapper";
+import type { BRepAlgoAPI_Cut, TopoDS_Shape } from "occjs-wrapper";
 import { Shape } from "../common/shape.js";
 import { Solid } from "../common/solid.js";
 import { Edge } from "../common/edge.js";
@@ -8,18 +8,46 @@ 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: Solid | Face | Edge | import("../common/wire.js").Wire;
+        modified: (shape: Shape) => (Solid | Face | Edge | import("../common/wire.js").Wire)[];
         sectionEdges: Edge[];
         startEdges: Edge[];
         endEdges: Edge[];
         internalEdges: Edge[];
         internalFaces: Face[];
+        maker: BRepAlgoAPI_Cut;
+        dispose: () => void;
     };
-    static fuse(args: Shape[]): {
+    /**
+     * Fuse with proper OpenCascade argument-vs-tool separation. Use this for
+     * operations that fuse newly built geometry into an existing scene (extrude,
+     * revolve, sweep, loft) where we need `maker.Modified(stockFace)` lineage to
+     * track which existing face became which result face.
+     *
+     * Returns the underlying `BRepAlgoAPI_Fuse` so the caller can query
+     * `Modified()` / `Generated()` / `IsDeleted()` for history tracking. The
+     * caller MUST invoke `dispose()` exactly once to release the maker.
+     *
+     * Do not use this for the user-facing `Fuse` scene object (keep
+     * `BooleanOps.fuse` for that — it treats all inputs as symmetric peers).
+     */
+    static fuseStockAndTools(stock: Shape[], tools: Shape[], opts?: {
+        glue?: 'full' | 'shift';
+    }): {
         result: Shape[];
         modifiedShapes: Shape[];
         newShapes: Shape[];
+        maker: any;
+        dispose: () => void;
+    };
+    static fuse(args: Shape[], opts?: {
+        glue?: 'full' | 'shift';
+    }): {
+        result: Shape[];
+        modifiedShapes: Shape[];
+        newShapes: Shape[];
+        maker: any;
+        dispose: () => void;
     };
     static fuseFaces(args: Shape[]): {
         result: Shape[];

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

@@ -14,12 +14,19 @@ export class BooleanOps {
     static cutShapesRaw(shape, tool) {
         const oc = getOC();
         const progress = new oc.Message_ProgressRange();
-        const cutter = new oc.BRepAlgoAPI_Cut(shape, tool, progress);
-        cutter.Build(progress);
-        if (!cutter.IsDone()) {
+        let cutter;
+        try {
+            cutter = new oc.BRepAlgoAPI_Cut(shape, tool, progress);
+            cutter.Build(progress);
+        }
+        catch {
+            progress.delete();
+            throw new Error("Cut failed");
+        }
+        if (!cutter.IsDone() || cutter.HasErrors()) {
             cutter.delete();
             progress.delete();
-            throw new Error("Cut operation failed");
+            throw new Error("Cut failed");
         }
         const result = cutter.Shape();
         cutter.delete();
@@ -113,17 +120,107 @@ export class BooleanOps {
             .map(rf => Face.fromTopoDSFace(Explorer.toFace(rf)));
         stockEdgeMap.delete();
         stockFaceMap.delete();
-        progress.delete();
         stockList.delete();
         toolList.delete();
-        return { result: wrappedResult, modified, sectionEdges, startEdges, endEdges, internalEdges, internalFaces };
+        let disposed = false;
+        const dispose = () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            cutMaker.delete();
+            progress.delete();
+        };
+        return {
+            result: wrappedResult,
+            modified,
+            sectionEdges,
+            startEdges,
+            endEdges,
+            internalEdges,
+            internalFaces,
+            maker: cutMaker,
+            dispose,
+        };
     }
-    static fuse(args) {
+    /**
+     * Fuse with proper OpenCascade argument-vs-tool separation. Use this for
+     * operations that fuse newly built geometry into an existing scene (extrude,
+     * revolve, sweep, loft) where we need `maker.Modified(stockFace)` lineage to
+     * track which existing face became which result face.
+     *
+     * Returns the underlying `BRepAlgoAPI_Fuse` so the caller can query
+     * `Modified()` / `Generated()` / `IsDeleted()` for history tracking. The
+     * caller MUST invoke `dispose()` exactly once to release the maker.
+     *
+     * Do not use this for the user-facing `Fuse` scene object (keep
+     * `BooleanOps.fuse` for that — it treats all inputs as symmetric peers).
+     */
+    static fuseStockAndTools(stock, tools, 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 stockList = new oc.TopTools_ListOfShape();
+        for (const s of stock) {
+            stockList.Append(s.getShape());
+        }
+        const toolList = new oc.TopTools_ListOfShape();
+        for (const t of tools) {
+            toolList.Append(t.getShape());
+        }
+        builder.SetArguments(stockList);
+        builder.SetTools(toolList);
+        const progress = new oc.Message_ProgressRange();
+        builder.Build(progress);
+        builder.SimplifyResult(false, true, oc.Precision.Angular());
+        const resultShape = builder.Shape();
+        const rawShapes = Explorer.findAllShapes(resultShape);
+        const result = rawShapes.map(s => ShapeFactory.fromShape(s));
+        const allInputs = [...stock, ...tools];
+        const modifiedShapes = [];
+        for (const shape of allInputs) {
+            if (builder.IsDeleted(shape.getShape())) {
+                modifiedShapes.push(shape);
+            }
+        }
+        const newShapes = [];
+        for (const s of result) {
+            const existsInArgs = allInputs.some(arg => arg.getShape().IsPartner(s.getShape()));
+            if (!existsInArgs) {
+                newShapes.push(s);
+            }
+        }
+        let disposed = false;
+        const dispose = () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            builder.delete();
+            progress.delete();
+        };
+        return { result, newShapes, modifiedShapes, maker: builder, dispose };
+    }
+    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 +231,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) {
@@ -146,16 +248,25 @@ export class BooleanOps {
                 modifiedShapes.push(shape);
             }
         }
-        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);
             }
         }
-        return { result, newShapes, modifiedShapes };
+        console.log(`[perf] BooleanOps.fuse.IsPartner check (result=${result.length} x args=${args.length}): ${(performance.now() - tPartner).toFixed(1)} ms`);
+        let disposed = false;
+        const dispose = () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            builder.delete();
+            progress.delete();
+        };
+        return { result, newShapes, modifiedShapes, maker: builder, dispose };
     }
     static fuseFaces(args) {
         const oc = getOC();

package/lib/dist/oc/color-transfer.d.ts

@@ -0,0 +1,37 @@
+import type { BRepBuilderAPI_MakeShape } from "occjs-wrapper";
+import { Shape } from "../common/shape.js";
+import type { CleanShapeLineage } from "./shape-ops.js";
+/**
+ * Walk each source shape's `colorMap`, find where each colored face ended up in
+ * the result shapes via `maker.Modified()` (falling back to the unchanged face
+ * if `!IsDeleted`), and apply the color to whichever result shape now owns it.
+ *
+ * Works for any `BRepBuilderAPI_MakeShape`-derived maker — fuse, cut, fillet,
+ * chamfer, transform, etc.
+ */
+export declare class ColorTransfer {
+    static applyThroughMaker(sources: Shape[], results: Shape[], maker: BRepBuilderAPI_MakeShape): void;
+    /**
+     * Color bleed pass: spreads colors to result faces that came from new
+     * geometry (tool inputs, generated faces, or just brand-new) by walking
+     * face-edge adjacency in each result solid.
+     *
+     * Faces that came from `sceneSources` (whether modified or unchanged) are
+     * NOT bled — those represent existing geometry whose color state the user
+     * explicitly chose. Faces NOT from any sceneSource are eligible: this
+     * covers tool extrusions, fillet/chamfer-generated surfaces, and cut
+     * section faces.
+     *
+     * Iterates until stable so newly-bled faces can spread color further.
+     * Call AFTER `applyThroughMaker` so the colored seeds are in place.
+     */
+    static applyBleeding(sceneSources: Shape[], results: Shape[], maker: BRepBuilderAPI_MakeShape): void;
+    /**
+     * Transfer colors from a pre-clean source shape through a `cleanShapeWithLineage`
+     * cleanup's `BRepTools_History` onto the post-clean result. Use this when an
+     * op is chained as `maker → cleanShape` — first apply `applyThroughMaker` to
+     * move colors from the original source onto the pre-clean result, then call
+     * this to chain them through the cleanup's UnifySameDomain history.
+     */
+    static applyThroughCleanup(source: Shape, cleanup: CleanShapeLineage): void;
+}