fluidcad 0.0.26 → 0.0.28

package/lib/dist/features/extrude.js

@@ -9,20 +9,32 @@ import { ExtrudeThroughAll } from "./infinite-extrude.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 export class Extrude extends ExtrudeBase {
     distance;
-    constructor(distance, extrudable) {
-        super(extrudable);
+    constructor(distance, source) {
+        super(source);
         this.distance = distance;
     }
     build(context) {
-        const plane = this.extrudable.getPlane();
+        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`);
         if (pickedFaces !== null && pickedFaces.length === 0) {
             return;
         }
         let faces;
         let inwardEdges;
         let outwardEdges;
-        if (this.isThin()) {
+        t = performance.now();
+        if (this.isFaceSourced()) {
+            if (this.isThin()) {
+                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;
@@ -31,6 +43,7 @@ export class Extrude extends ExtrudeBase {
         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);
         }
@@ -40,11 +53,17 @@ 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) {
+        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 = [];
@@ -59,12 +78,20 @@ export class Extrude extends ExtrudeBase {
         this.setState('side-faces', sideFaces);
         this.setState('internal-faces', internalFaces);
         this.setState('cap-faces', capFaces);
-        this.extrudable.removeShapes(this);
+        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 fusionResult = fuseWithSceneObjects(sceneObjects, extrusions);
+        const tFuse = performance.now();
+        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) {
                 continue;
@@ -72,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());
@@ -82,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 = [];
@@ -158,12 +191,16 @@ export class Extrude extends ExtrudeBase {
         this.setState('side-faces', sideFaces);
         this.setState('internal-faces', internalFaces);
         this.setState('cap-faces', capFaces);
-        this.extrudable.removeShapes(this);
+        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;
@@ -171,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());
@@ -179,6 +220,9 @@ export class Extrude extends ExtrudeBase {
         if (this._symmetric) {
             // Symmetric cut: create tool centered on sketch plane
             if (isThroughAll) {
+                if (this.isFaceSourced()) {
+                    throw new Error("through-all is not supported with a face-sourced extrude");
+                }
                 const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, true, true, faces);
                 toolShapes = extrudeThroughAll.build();
             }
@@ -188,11 +232,15 @@ 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) {
+            if (this.isFaceSourced()) {
+                throw new Error("through-all is not supported with a face-sourced extrude");
+            }
             const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, false, true, faces);
             toolShapes = extrudeThroughAll.build();
         }
@@ -201,17 +249,19 @@ export class Extrude extends ExtrudeBase {
             const extruder = new Extruder(faces, plane, distance, this.getDraft(), this.getEndOffset());
             toolShapes = extruder.extrude();
         }
-        this.extrudable.removeShapes(this);
-        cutWithSceneObjects(scope, toolShapes, plane, this.distance, this);
+        this.getSource()?.removeShapes(this);
+        cutWithSceneObjects(scope, toolShapes, plane, this.distance, this, {
+            recordHistoryFor: this,
+        });
     }
     getDependencies() {
-        return this.extrudable ? [this.extrudable] : [];
+        const source = this.getSource();
+        return source ? [source] : [];
     }
     createCopy(remap) {
-        const extrudable = this.extrudable
-            ? (remap.get(this.extrudable) || this.extrudable)
-            : undefined;
-        return new Extrude(this.distance, extrudable).syncWith(this);
+        const source = this.getSource();
+        const remapped = source ? (remap.get(source) || source) : undefined;
+        return new Extrude(this.distance, remapped).syncWith(this);
     }
     compareTo(other) {
         if (!(other instanceof Extrude)) {
@@ -220,7 +270,12 @@ export class Extrude extends ExtrudeBase {
         if (!super.compareTo(other)) {
             return false;
         }
-        if (!this.extrudable.compareTo(other.extrudable)) {
+        const thisSource = this.getSource();
+        const otherSource = other.getSource();
+        if (!thisSource !== !otherSource) {
+            return false;
+        }
+        if (thisSource && otherSource && !thisSource.compareTo(otherSource)) {
             return false;
         }
         if (this.distance !== other.distance) {
@@ -242,7 +297,7 @@ export class Extrude extends ExtrudeBase {
     }
     serialize() {
         return {
-            extrudable: this.extrudable.serialize(),
+            extrudable: this.getSource()?.serialize(),
             distance: this.distance,
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
             symmetric: this._symmetric || undefined,

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/mirror-shape.d.ts

@@ -8,7 +8,5 @@ export declare class MirrorShape extends SceneObject {
     compareTo(other: MirrorShape): boolean;
     getType(): string;
     getUniqueType(): string;
-    serialize(): {
-        plane: PlaneObjectBase;
-    };
+    serialize(): {};
 }

package/lib/dist/features/mirror-shape.js

@@ -47,6 +47,7 @@ export class MirrorShape extends SceneObject {
             for (const shape of shapes) {
                 const matrix = Matrix4.mirrorPlane(plane.normal, plane.origin);
                 const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
                 transformedShapes.push(transformed);
             }
         }
@@ -90,7 +91,7 @@ export class MirrorShape extends SceneObject {
     }
     serialize() {
         return {
-            plane: this.plane,
+        // plane: this.plane,
         };
     }
 }

package/lib/dist/features/revolve.js

@@ -9,6 +9,7 @@ import { ExtrudeBase } from "./extrude-base.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
 import { FaceOps } from "../oc/face-ops.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
+import { Matrix4 } from "../math/matrix4.js";
 export class Revolve extends ExtrudeBase {
     axis;
     angle;
@@ -45,8 +46,9 @@ export class Revolve extends ExtrudeBase {
             const solid = ExtrudeOps.makeRevol(face, axis, rad(this.angle));
             let resultSolid;
             if (this._symmetric) {
-                const rotated = ShapeOps.rotateShape(solid.getShape(), axis, -rad(this.angle) / 2);
-                resultSolid = Solid.fromTopoDSSolid(Explorer.toSolid(rotated));
+                const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, -rad(this.angle) / 2);
+                const rotated = ShapeOps.transform(solid, matrix);
+                resultSolid = Solid.fromTopoDSSolid(Explorer.toSolid(rotated.getShape()));
             }
             else {
                 resultSolid = Solid.fromTopoDSSolid(Explorer.toSolid(solid.getShape()));
@@ -113,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/rotate.js

@@ -41,6 +41,7 @@ export class Rotate extends SceneObject {
             const shapes = obj.getShapes();
             for (const shape of shapes) {
                 const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
                 this.addShape(transformed);
                 if (!this.copy) {
                     obj.removeShape(shape, this);

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

@@ -42,9 +42,14 @@ 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`);
         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`);
             if (this.draft) {
                 const draftResult = this.applyDraft(solid, firstFace, lastFace, this.plane);
                 solid = draftResult.solid;

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/features/translate.js

@@ -23,7 +23,9 @@ export class Translate extends SceneObject {
                     continue;
                 }
                 const amount = this.amount.asPoint();
-                let transformed = ShapeOps.transform(shape, Matrix4.fromTranslation(amount.x, amount.y, amount.z));
+                const matrix = Matrix4.fromTranslation(amount.x, amount.y, amount.z);
+                const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
                 this.addShape(transformed);
                 if (!this.copy) {
                     obj.removeShape(shape, this);

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

@@ -58,6 +58,18 @@ export declare class FaceFilterBuilder extends FilterBuilderBase<Face> {
      * @param plane - The reference plane.
      */
     notParallelTo(plane: PlaneLike | PlaneObjectBase): this;
+    /**
+     * Selects toroidal faces, optionally matching major and/or minor radius.
+     * @param majorRadius - Optional radius from the torus axis to the tube center.
+     * @param minorRadius - Optional radius of the tube itself.
+     */
+    torus(majorRadius?: number, minorRadius?: number): this;
+    /**
+     * Excludes toroidal faces, optionally matching major and/or minor radius.
+     * @param majorRadius - Optional radius from the torus axis to the tube center.
+     * @param minorRadius - Optional radius of the tube itself.
+     */
+    notTorus(majorRadius?: number, minorRadius?: number): this;
     /**
      * Selects conical faces.
      */

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

@@ -4,6 +4,7 @@ import { CircleFilter, NotCircleFilter } from "./circle-filter.js";
 import { ConeFilter, NotConeFilter } from "./cone-filter.js";
 import { CylinderCurveFilter, NotCylinderCurveFilter } from "./cylinder-curve.js";
 import { CylinderFilter, NotCylinderFilter } from "./cylinder.js";
+import { TorusFilter, NotTorusFilter } from "./torus-filter.js";
 import { NotOnPlaneFilter, OnPlaneFilter } from "./on-plane.js";
 import { NotParallelFilter, ParallelFilter } from "./parallel.js";
 import { PlaneObject } from "../../features/plane.js";
@@ -182,6 +183,26 @@ export class FaceFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects toroidal faces, optionally matching major and/or minor radius.
+     * @param majorRadius - Optional radius from the torus axis to the tube center.
+     * @param minorRadius - Optional radius of the tube itself.
+     */
+    torus(majorRadius, minorRadius) {
+        const filter = new TorusFilter(majorRadius, minorRadius);
+        this.filters.push(filter);
+        return this;
+    }
+    /**
+     * Excludes toroidal faces, optionally matching major and/or minor radius.
+     * @param majorRadius - Optional radius from the torus axis to the tube center.
+     * @param minorRadius - Optional radius of the tube itself.
+     */
+    notTorus(majorRadius, minorRadius) {
+        const filter = new NotTorusFilter(majorRadius, minorRadius);
+        this.filters.push(filter);
+        return this;
+    }
     /**
      * Selects conical faces.
      */

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

@@ -0,0 +1,19 @@
+import { Matrix4 } from "../../math/matrix4.js";
+import { Face } from "../../common/shapes.js";
+import { FilterBase } from "../filter-base.js";
+export declare class TorusFilter extends FilterBase<Face> {
+    private majorRadius?;
+    private minorRadius?;
+    constructor(majorRadius?: number, minorRadius?: number);
+    match(shape: Face): boolean;
+    compareTo(other: TorusFilter): boolean;
+    transform(matrix: Matrix4): TorusFilter;
+}
+export declare class NotTorusFilter extends FilterBase<Face> {
+    private majorRadius?;
+    private minorRadius?;
+    constructor(majorRadius?: number, minorRadius?: number);
+    match(shape: Face): boolean;
+    compareTo(other: NotTorusFilter): boolean;
+    transform(matrix: Matrix4): NotTorusFilter;
+}

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

@@ -0,0 +1,38 @@
+import { FilterBase } from "../filter-base.js";
+import { FaceQuery } from "../../oc/face-query.js";
+export class TorusFilter extends FilterBase {
+    majorRadius;
+    minorRadius;
+    constructor(majorRadius, minorRadius) {
+        super();
+        this.majorRadius = majorRadius;
+        this.minorRadius = minorRadius;
+    }
+    match(shape) {
+        return FaceQuery.isTorusFace(shape, this.majorRadius, this.minorRadius);
+    }
+    compareTo(other) {
+        return this.majorRadius === other.majorRadius && this.minorRadius === other.minorRadius;
+    }
+    transform(matrix) {
+        return new TorusFilter(this.majorRadius, this.minorRadius);
+    }
+}
+export class NotTorusFilter extends FilterBase {
+    majorRadius;
+    minorRadius;
+    constructor(majorRadius, minorRadius) {
+        super();
+        this.majorRadius = majorRadius;
+        this.minorRadius = minorRadius;
+    }
+    match(shape) {
+        return !FaceQuery.isTorusFace(shape, this.majorRadius, this.minorRadius);
+    }
+    compareTo(other) {
+        return this.majorRadius === other.majorRadius && this.minorRadius === other.minorRadius;
+    }
+    transform(matrix) {
+        return new NotTorusFilter(this.majorRadius, this.minorRadius);
+    }
+}