fluidcad 0.0.28 → 0.0.30

package/lib/dist/features/simple-extruder.d.ts

@@ -1,17 +1,19 @@
 import { Face } from "../common/face.js";
 import { Shape } from "../common/shape.js";
 import { Plane } from "../math/plane.js";
+import { Profiler } from "../common/profiler.js";
 export declare class Extruder {
     private faces;
     private plane;
     distance: number;
     draft?: [number, number];
     endOffset?: number;
+    private profiler?;
     private firstFaces;
     private lastFaces;
     private sideFaces;
     private _internalFaces;
-    constructor(faces: Face[], plane: Plane, distance: number, draft?: [number, number], endOffset?: number);
+    constructor(faces: Face[], plane: Plane, distance: number, draft?: [number, number], endOffset?: number, profiler?: Profiler);
     getStartFaces(): Face[];
     getEndFaces(): Face[];
     getSideFaces(): Face[];

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

@@ -8,16 +8,18 @@ export class Extruder {
     distance;
     draft;
     endOffset;
+    profiler;
     firstFaces;
     lastFaces;
     sideFaces;
     _internalFaces;
-    constructor(faces, plane, distance, draft, endOffset) {
+    constructor(faces, plane, distance, draft, endOffset, profiler) {
         this.faces = faces;
         this.plane = plane;
         this.distance = distance;
         this.draft = draft;
         this.endOffset = endOffset;
+        this.profiler = profiler;
     }
     getStartFaces() {
         return this.firstFaces;
@@ -42,16 +44,18 @@ export class Extruder {
         let lastFaces = [];
         let sideFaces = [];
         let internalFaces = [];
-        console.log("Fusing faces before extrusion...", this.faces.length);
-        const tFuseFaces = performance.now();
-        const fusedFaces = BooleanOps.fuseFaces(this.faces);
-        console.log(`[perf] Extruder.fuseFaces (in=${this.faces.length}, out=${fusedFaces.result.length}): ${(performance.now() - tFuseFaces).toFixed(1)} ms`);
+        const p = this.profiler;
+        const fusedFaces = p
+            ? p.record('Fuse profile faces', () => BooleanOps.fuseFaces(this.faces))
+            : BooleanOps.fuseFaces(this.faces);
         for (const face of fusedFaces.result) {
-            const time = performance.now();
-            let { solid, firstFace, lastFace } = ExtrudeOps.makePrismFromVec(face, vec);
-            console.log(`[perf] Extruder.makePrismFromVec: ${(performance.now() - time).toFixed(1)} ms`);
+            let { solid, firstFace, lastFace } = p
+                ? p.record('Make prism from face', () => ExtrudeOps.makePrismFromVec(face, vec))
+                : ExtrudeOps.makePrismFromVec(face, vec);
             if (this.draft) {
-                const draftResult = this.applyDraft(solid, firstFace, lastFace, this.plane);
+                const draftResult = p
+                    ? p.record('Apply draft', () => this.applyDraft(solid, firstFace, lastFace, this.plane))
+                    : this.applyDraft(solid, firstFace, lastFace, this.plane);
                 solid = draftResult.solid;
                 firstFace = draftResult.firstFace;
                 lastFace = draftResult.lastFace;

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

@@ -1,9 +1,9 @@
-import { SceneObject } from "../common/scene-object.js";
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 export declare class Subtract extends SceneObject {
     solid1: SceneObject;
     solid2: SceneObject;
     constructor(solid1: SceneObject, solid2: SceneObject);
-    build(): void;
+    build(context: BuildSceneObjectContext): void;
     compareTo(other: Subtract): boolean;
     getType(): string;
     serialize(): {

package/lib/dist/features/subtract.js

@@ -11,14 +11,14 @@ export class Subtract extends SceneObject {
         this.solid1 = solid1;
         this.solid2 = solid2;
     }
-    build() {
+    build(context) {
+        const p = context.getProfiler();
         const stock = this.solid1.getShapes();
         const toBeRemoved = this.solid2.getShapes();
         const stockCompound = ShapeOps.makeCompound(stock);
         const toBeRemovedCompound = ShapeOps.makeCompound(toBeRemoved);
-        const result = BooleanOps.cutShapes(stockCompound, toBeRemovedCompound);
+        const result = p.record('Cut solids', () => BooleanOps.cutShapes(stockCompound, toBeRemovedCompound));
         const shapes = Explorer.findShapes(result.getShape(), Explorer.getOcShapeType("solid"));
-        console.log('Subtract Result:::::', shapes.length);
         const newShapes = shapes.map(s => ShapeOps.cleanShapeRaw(s)).map(s => Solid.fromTopoDSSolid(Explorer.toSolid(s)));
         for (const shape of toBeRemoved) {
             this.solid2.removeShape(shape, this);

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

@@ -7,6 +7,20 @@ export declare class Sweep extends ExtrudeBase implements ISweep {
     constructor(path: SceneObject, extrudable?: Extrudable);
     get path(): SceneObject;
     build(context: BuildSceneObjectContext): void;
+    /** Plain sweep: classify by inner-wire detection on the start face. */
+    private buildSweep;
+    /** Thin sweep: shell-like profile with inward/outward offsets. */
+    private buildSweepThin;
+    /**
+     * Run the sweep and split the resulting faces using OC's `FirstShape` /
+     * `LastShape` (the profile at each end of the spine). Anything else is a
+     * side face for the caller to refine.
+     */
+    private runSweep;
+    /** Inner-wire classification used by both regular sweep and closed thin profiles. */
+    private classifySweepByInnerWires;
+    /** Remove source + path, then dispatch to cut or fuse path. */
+    private dispatchFinalize;
     private getSpineWire;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;

package/lib/dist/features/sweep.js

@@ -3,7 +3,7 @@ import { SweepOps } from "../oc/sweep-ops.js";
 import { WireOps } from "../oc/wire-ops.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
 import { ExtrudeBase } from "./extrude-base.js";
-import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+import { cutWithSceneObjects } from "../helpers/scene-helpers.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 export class Sweep extends ExtrudeBase {
     _path;
@@ -15,42 +15,72 @@ export class Sweep extends ExtrudeBase {
         return this._path;
     }
     build(context) {
+        const p = context.getProfiler();
         const plane = this.extrudable.getPlane();
-        const pickedFaces = this.resolvePickedFaces(plane);
+        const pickedFaces = p.record('Resolve picked faces', () => this.resolvePickedFaces(plane));
         if (pickedFaces !== null && pickedFaces.length === 0) {
             return;
         }
-        // Extract spine wire from path
-        const spineWire = this.getSpineWire(this._path);
-        // Extract profile faces from extrudable
-        let profileFaces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
-        let inwardEdges;
-        let outwardEdges;
         if (this.isThin()) {
-            const thinResult = ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]);
-            profileFaces = thinResult.faces;
-            inwardEdges = thinResult.inwardEdges;
-            outwardEdges = thinResult.outwardEdges;
+            const thinResult = p.record('Make thin faces', () => ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]));
+            this.buildSweepThin(thinResult, plane, context);
         }
+        else {
+            const profileFaces = pickedFaces ?? p.record('Resolve faces', () => FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill()));
+            this.buildSweep(profileFaces, plane, context);
+        }
+        this.setFinalShapes(this.getShapes());
+    }
+    /** Plain sweep: classify by inner-wire detection on the start face. */
+    buildSweep(profileFaces, plane, context) {
+        const swept = this.runSweep(profileFaces, context);
+        const classified = this.classifySweepByInnerWires(swept, plane);
+        this.dispatchFinalize(swept.solids, classified, plane, context);
+    }
+    /** Thin sweep: shell-like profile with inward/outward offsets. */
+    buildSweepThin(thinResult, plane, context) {
+        const swept = this.runSweep(thinResult.faces, context);
+        let classified;
+        if (thinResult.inwardEdges.length > 0) {
+            const reclass = this.reclassifyThinFaces(swept.sideFaces, swept.startFaces, plane, thinResult.inwardEdges, thinResult.outwardEdges);
+            classified = {
+                startFaces: swept.startFaces,
+                endFaces: swept.endFaces,
+                sideFaces: reclass.sideFaces,
+                internalFaces: reclass.internalFaces,
+                capFaces: reclass.capFaces,
+            };
+        }
+        else {
+            classified = this.classifySweepByInnerWires(swept, plane);
+        }
+        this.dispatchFinalize(swept.solids, classified, plane, context);
+    }
+    /**
+     * Run the sweep and split the resulting faces using OC's `FirstShape` /
+     * `LastShape` (the profile at each end of the spine). Anything else is a
+     * side face for the caller to refine.
+     */
+    runSweep(profileFaces, context) {
         if (profileFaces.length === 0) {
             throw new Error("Could not extract profile faces from extrudable.");
         }
-        // Perform sweep
-        const sweepResult = SweepOps.makeSweep(spineWire, profileFaces);
-        const newShapes = sweepResult.solids;
-        // Classify faces using FirstShape/LastShape from the OC result
+        const p = context.getProfiler();
+        const spineWire = p.record('Get spine wire', () => this.getSpineWire(this._path));
+        const sweepResult = p.record('Make sweep', () => SweepOps.makeSweep(spineWire, profileFaces));
+        const solids = sweepResult.solids;
         const startFaces = [];
         const endFaces = [];
-        let sideFaces = [];
+        const sideFaces = [];
         const firstShapeFromOC = sweepResult.firstShape;
         const lastShapeFromOC = sweepResult.lastShape;
-        for (const shape of newShapes) {
-            const shapeFaces = Explorer.findFacesWrapped(shape);
-            for (const f of shapeFaces) {
-                if (firstShapeFromOC && f.getShape().IsSame(firstShapeFromOC)) {
+        for (const shape of solids) {
+            for (const f of Explorer.findFacesWrapped(shape)) {
+                const raw = f.getShape();
+                if (firstShapeFromOC && raw.IsSame(firstShapeFromOC)) {
                     startFaces.push(f);
                 }
-                else if (lastShapeFromOC && f.getShape().IsSame(lastShapeFromOC)) {
+                else if (lastShapeFromOC && raw.IsSame(lastShapeFromOC)) {
                     endFaces.push(f);
                 }
                 else {
@@ -58,76 +88,59 @@ export class Sweep extends ExtrudeBase {
                 }
             }
         }
-        let internalFaces = [];
-        let capFaces = [];
-        if (inwardEdges && inwardEdges.length > 0) {
-            const result = this.reclassifyThinFaces(sideFaces, startFaces, plane, inwardEdges, outwardEdges || []);
-            sideFaces = result.sideFaces;
-            internalFaces = result.internalFaces;
-            capFaces = result.capFaces;
-        }
-        else {
-            const innerWireEdges = [];
-            for (const sf of startFaces) {
-                for (const wire of sf.getWires()) {
-                    if (!wire.isCW(plane.normal)) {
-                        for (const edge of wire.getEdges()) {
-                            innerWireEdges.push(edge);
-                        }
+        return { solids, startFaces, endFaces, sideFaces };
+    }
+    /** Inner-wire classification used by both regular sweep and closed thin profiles. */
+    classifySweepByInnerWires(swept, plane) {
+        const innerWireEdges = [];
+        for (const sf of swept.startFaces) {
+            for (const wire of sf.getWires()) {
+                if (!wire.isCW(plane.normal)) {
+                    for (const edge of wire.getEdges()) {
+                        innerWireEdges.push(edge);
                     }
                 }
             }
-            if (innerWireEdges.length > 0) {
-                const remaining = [];
-                for (const f of sideFaces) {
-                    const isInternal = f.getEdges().some(fe => innerWireEdges.some(iwe => fe.getShape().IsPartner(iwe.getShape())));
-                    if (isInternal) {
-                        internalFaces.push(f);
-                    }
-                    else {
-                        remaining.push(f);
-                    }
+        }
+        const sideFaces = [];
+        const internalFaces = [];
+        if (innerWireEdges.length === 0) {
+            sideFaces.push(...swept.sideFaces);
+        }
+        else {
+            for (const f of swept.sideFaces) {
+                const isInternal = f.getEdges().some(fe => innerWireEdges.some(iwe => fe.getShape().IsPartner(iwe.getShape())));
+                if (isInternal) {
+                    internalFaces.push(f);
+                }
+                else {
+                    sideFaces.push(f);
                 }
-                sideFaces = remaining;
             }
         }
-        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);
-        // Remove consumed input shapes
+        return {
+            startFaces: swept.startFaces,
+            endFaces: swept.endFaces,
+            sideFaces,
+            internalFaces,
+            capFaces: [],
+        };
+    }
+    /** Remove source + path, then dispatch to cut or fuse path. */
+    dispatchFinalize(solids, classified, plane, context) {
         this.extrudable.removeShapes(this);
         this._path.removeShapes(this);
-        // Handle boolean operation based on operation mode
         if (this._operationMode === 'remove') {
             const scope = this.resolveFusionScope(context.getSceneObjects());
-            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());
+            this.setState('start-faces', classified.startFaces);
+            this.setState('end-faces', classified.endFaces);
+            this.setState('side-faces', classified.sideFaces);
+            this.setState('internal-faces', classified.internalFaces);
+            this.setState('cap-faces', classified.capFaces);
+            cutWithSceneObjects(scope, solids, plane, 0, this, { recordHistoryFor: this });
             return;
         }
-        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());
+        this.finalizeAndFuse(solids, classified, context);
     }
     getSpineWire(pathObj) {
         const shapes = pathObj.getShapes({ excludeMeta: false });

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

@@ -4,8 +4,10 @@ export declare class Translate extends SceneObject {
     private amount;
     private copy;
     private _targetObjects;
+    private _excludedObjects;
     constructor(amount: LazyVertex, copy?: boolean, ...targets: SceneObject[]);
     get targetObjects(): SceneObject[];
+    exclude(...objects: SceneObject[]): this;
     build(context: BuildSceneObjectContext): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;

package/lib/dist/features/translate.js

@@ -5,6 +5,7 @@ export class Translate extends SceneObject {
     amount;
     copy;
     _targetObjects = null;
+    _excludedObjects = [];
     constructor(amount, copy = false, ...targets) {
         super();
         this.amount = amount;
@@ -14,8 +15,15 @@ export class Translate extends SceneObject {
     get targetObjects() {
         return this._targetObjects;
     }
+    exclude(...objects) {
+        this._excludedObjects.push(...objects);
+        return this;
+    }
     build(context) {
-        const objects = this.targetObjects || context.getSceneObjects();
+        let objects = this.targetObjects || context.getSceneObjects();
+        if (this._excludedObjects.length > 0) {
+            objects = objects.filter(obj => !this._excludedObjects.includes(obj));
+        }
         for (const obj of objects) {
             const shapes = obj.getShapes();
             for (const shape of shapes) {
@@ -40,7 +48,12 @@ export class Translate extends SceneObject {
         const targets = this.targetObjects
             ? this.targetObjects.map(obj => remap.get(obj) || obj)
             : [];
-        return new Translate(this.amount, this.copy, ...targets);
+        const copy = new Translate(this.amount, this.copy, ...targets);
+        if (this._excludedObjects.length > 0) {
+            const remappedExcluded = this._excludedObjects.map(obj => remap.get(obj) || obj);
+            copy.exclude(...remappedExcluded);
+        }
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof Translate)) {
@@ -65,6 +78,14 @@ export class Translate extends SceneObject {
                 return false;
             }
         }
+        if (this._excludedObjects.length !== other._excludedObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < this._excludedObjects.length; i++) {
+            if (!this._excludedObjects[i].compareTo(other._excludedObjects[i])) {
+                return false;
+            }
+        }
         return true;
     }
     getType() {

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

@@ -123,5 +123,11 @@ export declare class EdgeFilterBuilder extends FilterBuilderBase<Edge> {
         offset?: number;
         partial?: boolean;
     }): this;
+    /**
+     * Restricts the selection to edges originating from the given scene objects.
+     * Recursive: passing a container picks up edges from its descendants.
+     * @param sceneObjects - Scene objects whose edges (and edges of their sub-shapes) are matched against.
+     */
+    from(...sceneObjects: ISceneObject[]): this;
     static build(): EdgeFilterBuilder;
 }

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

@@ -11,6 +11,7 @@ import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
 import { AtIndexFilter, NotAtIndexFilter } from "./at-index.js";
 import { BelongsToFaceFilter, NotBelongsToFaceFilter } from "./belongs-to-face.js";
 import { BelongsToFaceFromSceneObjectFilter, NotBelongsToFaceFromSceneObjectFilter } from "./belongs-to-object.js";
+import { FromSceneObjectFilter } from "../from-object.js";
 import { IntersectsWithFilter, NotIntersectsWithFilter } from "./intersects-with.js";
 import { AbovePlaneFilter, BelowPlaneFilter } from "./above-below.js";
 import { SceneObject } from "../../common/scene-object.js";
@@ -330,6 +331,16 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Restricts the selection to edges originating from the given scene objects.
+     * Recursive: passing a container picks up edges from its descendants.
+     * @param sceneObjects - Scene objects whose edges (and edges of their sub-shapes) are matched against.
+     */
+    from(...sceneObjects) {
+        const filter = new FromSceneObjectFilter(sceneObjects, "edge");
+        this.filters.push(filter);
+        return this;
+    }
     static build() {
         return new EdgeFilterBuilder();
     }

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

@@ -119,4 +119,10 @@ export declare class FaceFilterBuilder extends FilterBuilderBase<Face> {
      * @param count - The number of edges to exclude.
      */
     notEdgeCount(count: number): this;
+    /**
+     * Restricts the selection to faces originating from the given scene objects.
+     * Recursive: passing a container picks up faces from its descendants.
+     * @param sceneObjects - Scene objects whose faces (and faces of their sub-shapes) are matched against.
+     */
+    from(...sceneObjects: ISceneObject[]): this;
 }

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

@@ -12,6 +12,7 @@ import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
 import { AtIndexFilter, NotAtIndexFilter } from "./at-index.js";
 import { HasEdgeFilter, NotHasEdgeFilter } from "./has-edge.js";
 import { HasEdgeFromSceneObjectFilter, NotHasEdgeFromSceneObjectFilter } from "./has-object.js";
+import { FromSceneObjectFilter } from "../from-object.js";
 import { EdgeCountFilter, NotEdgeCountFilter } from "./edge-count.js";
 import { IntersectsWithFilter, NotIntersectsWithFilter } from "./intersects-with.js";
 import { SceneObject } from "../../common/scene-object.js";
@@ -305,4 +306,14 @@ export class FaceFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Restricts the selection to faces originating from the given scene objects.
+     * Recursive: passing a container picks up faces from its descendants.
+     * @param sceneObjects - Scene objects whose faces (and faces of their sub-shapes) are matched against.
+     */
+    from(...sceneObjects) {
+        const filter = new FromSceneObjectFilter(sceneObjects, "face");
+        this.filters.push(filter);
+        return this;
+    }
 }

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

@@ -1,8 +1,14 @@
 import { Matrix4 } from "../math/matrix4.js";
-import { Comparable } from "../common/scene-object.js";
+import { Comparable, SceneObject } from "../common/scene-object.js";
 import { Shape } from "../common/shapes.js";
 export declare abstract class FilterBase<TShape extends Shape> implements Comparable<FilterBase<TShape>> {
     abstract match(shape: TShape): boolean;
     abstract compareTo(other: FilterBase<TShape>): boolean;
     abstract transform(matrix: Matrix4): FilterBase<TShape>;
+    /**
+     * Returns a copy of this filter with any internal SceneObject references
+     * rewritten through the given remap. Filters that don't hold SceneObject
+     * references can keep the default no-op.
+     */
+    remap(_remap: Map<SceneObject, SceneObject>): FilterBase<TShape>;
 }

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

@@ -1,2 +1,10 @@
 export class FilterBase {
+    /**
+     * Returns a copy of this filter with any internal SceneObject references
+     * rewritten through the given remap. Filters that don't hold SceneObject
+     * references can keep the default no-op.
+     */
+    remap(_remap) {
+        return this;
+    }
 }

package/lib/dist/filters/filter-builder-base.js

@@ -39,6 +39,17 @@ export class FilterBuilderBase {
     /**
       * @internal
     */
+    remap(remap) {
+        const remappedBuilder = new FilterBuilderBase();
+        for (const filter of this.filters) {
+            remappedBuilder.filter(filter.remap(remap));
+        }
+        remappedBuilder._withTangents = this._withTangents;
+        return remappedBuilder;
+    }
+    /**
+      * @internal
+    */
     equals(other) {
         if (this._withTangents !== other._withTangents) {
             return false;

package/lib/dist/filters/from-object.d.ts

@@ -0,0 +1,14 @@
+import { Matrix4 } from "../math/matrix4.js";
+import { Shape } from "../common/shapes.js";
+import { ShapeType } from "../common/shape-type.js";
+import { SceneObject } from "../common/scene-object.js";
+import { FilterBase } from "./filter-base.js";
+export declare class FromSceneObjectFilter<TShape extends Shape> extends FilterBase<TShape> {
+    private sceneObjects;
+    private shapeType;
+    constructor(sceneObjects: SceneObject[], shapeType: ShapeType);
+    match(shape: TShape): boolean;
+    compareTo(other: FromSceneObjectFilter<TShape>): boolean;
+    transform(_matrix: Matrix4): FromSceneObjectFilter<TShape>;
+    remap(remap: Map<SceneObject, SceneObject>): FromSceneObjectFilter<TShape>;
+}

package/lib/dist/filters/from-object.js

@@ -0,0 +1,40 @@
+import { FilterBase } from "./filter-base.js";
+export class FromSceneObjectFilter extends FilterBase {
+    sceneObjects;
+    shapeType;
+    constructor(sceneObjects, shapeType) {
+        super();
+        this.sceneObjects = sceneObjects;
+        this.shapeType = shapeType;
+    }
+    match(shape) {
+        for (const obj of this.sceneObjects) {
+            const subShapes = obj.getShapes().flatMap(s => s.getSubShapes(this.shapeType));
+            if (subShapes.some(sub => sub.isSame(shape))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    compareTo(other) {
+        if (this.shapeType !== other.shapeType) {
+            return false;
+        }
+        if (this.sceneObjects.length !== other.sceneObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < this.sceneObjects.length; i++) {
+            if (!this.sceneObjects[i].compareTo(other.sceneObjects[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    transform(_matrix) {
+        return new FromSceneObjectFilter(this.sceneObjects, this.shapeType);
+    }
+    remap(remap) {
+        const remapped = this.sceneObjects.map(obj => remap.get(obj) ?? obj);
+        return new FromSceneObjectFilter(remapped, this.shapeType);
+    }
+}

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

@@ -2,9 +2,11 @@ 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";
+import { Profiler } from "../common/profiler.js";
 export declare function fuseWithSceneObjects(sceneObjects: SceneObject[], extrusions: Shape<any>[], opts?: {
     glue?: 'full' | 'shift';
     recordHistoryFor?: SceneObject;
+    profiler?: Profiler;
 }): {
     newShapes: Shape<any>[];
     modifiedShapes: any[];