fluidcad 0.0.28 → 0.0.30

package/lib/dist/features/loft.js

@@ -19,14 +19,15 @@ export class Loft extends ExtrudeBase {
         if (this.profiles.length < 2) {
             throw new Error("Loft requires at least two profiles.");
         }
+        const p = context.getProfiler();
         let newShapes;
         if (this.isThin()) {
-            newShapes = this.buildThinLoft();
+            newShapes = p.record('Build thin loft', () => this.buildThinLoft());
         }
         else {
             const allWires = [];
             for (const profile of this.profiles) {
-                const wires = this.getWiresFromSceneObject(profile);
+                const wires = p.record('Get profile wires', () => this.getWiresFromSceneObject(profile));
                 if (wires.length === 0) {
                     throw new Error("Could not extract wire from profile.");
                 }
@@ -34,7 +35,7 @@ export class Loft extends ExtrudeBase {
                     allWires.push(wire);
                 }
             }
-            newShapes = LoftOps.makeLoft(allWires);
+            newShapes = p.record('Make loft', () => LoftOps.makeLoft(allWires));
         }
         for (const profile of this.profiles) {
             profile.removeShapes(this);
@@ -64,13 +65,15 @@ export class Loft extends ExtrudeBase {
         this.setState('side-faces', sideFaces);
         // Handle boolean operation based on operation mode
         if (this._operationMode === 'remove') {
-            const scope = this.resolveFusionScope(context.getSceneObjects());
+            const scope = p.record('Resolve fusion scope', () => this.resolveFusionScope(context.getSceneObjects()));
             const plane = firstPlane || lastPlane;
-            cutWithSceneObjects(scope, newShapes, plane, 0, this, { recordHistoryFor: this });
+            p.record('Cut with scene objects', () => {
+                cutWithSceneObjects(scope, newShapes, plane, 0, this, { recordHistoryFor: this });
+            });
             this.setFinalShapes(this.getShapes());
             return;
         }
-        const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
+        const sceneObjects = p.record('Resolve fusion scope', () => this.resolveFusionScope(context.getSceneObjects()));
         if (sceneObjects.length === 0) {
             this.addShapes(newShapes);
             this.recordShapeFacesAndEdgesAsAdditions(newShapes);
@@ -78,9 +81,9 @@ export class Loft extends ExtrudeBase {
             this.setFinalShapes(this.getShapes());
             return;
         }
-        const fusionResult = fuseWithSceneObjects(sceneObjects, newShapes, {
+        const fusionResult = p.record('Fuse with scene objects', () => fuseWithSceneObjects(sceneObjects, newShapes, {
             recordHistoryFor: this,
-        });
+        }));
         for (const modifiedShape of fusionResult.modifiedShapes) {
             if (modifiedShape.object) {
                 modifiedShape.object.removeShape(modifiedShape.shape, this);

package/lib/dist/features/mirror-shape.d.ts

@@ -3,7 +3,9 @@ import { PlaneObjectBase } from "./plane-renderable-base.js";
 export declare class MirrorShape extends SceneObject {
     private plane;
     targetObjects: SceneObject[] | null;
+    private _excludedObjects;
     constructor(plane: PlaneObjectBase, targetObjects?: SceneObject[] | null);
+    exclude(...objects: SceneObject[]): this;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: MirrorShape): boolean;
     getType(): string;

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

@@ -5,11 +5,16 @@ import { fuseWithSceneObjects } from "../helpers/scene-helpers.js";
 export class MirrorShape extends SceneObject {
     plane;
     targetObjects;
+    _excludedObjects = [];
     constructor(plane, targetObjects = null) {
         super();
         this.plane = plane;
         this.targetObjects = targetObjects;
     }
+    exclude(...objects) {
+        this._excludedObjects.push(...objects);
+        return this;
+    }
     build(context) {
         let objects;
         let targetObjects = this.targetObjects;
@@ -30,6 +35,9 @@ export class MirrorShape extends SceneObject {
         else {
             targetObjects = lastObj ? [lastObj] : objects;
         }
+        if (this._excludedObjects.length > 0) {
+            targetObjects = targetObjects.filter(obj => !this._excludedObjects.includes(obj));
+        }
         if (this.plane) {
             this.plane.removeShapes(this);
         }
@@ -81,6 +89,14 @@ export class MirrorShape 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/features/mirror-shape2d.d.ts

@@ -5,7 +5,9 @@ import { LazyVertex } from "./lazy-vertex.js";
 export declare class MirrorShape2D extends GeometrySceneObject {
     private axis;
     private targetObjects;
+    private _excludedObjects;
     constructor(axis: AxisObjectBase, targetObjects?: SceneObject[]);
+    exclude(...objects: SceneObject[]): this;
     build(context: BuildSceneObjectContext): void;
     start(): LazyVertex;
     end(): LazyVertex;

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

@@ -6,11 +6,16 @@ import { Vertex } from "../common/vertex.js";
 export class MirrorShape2D extends GeometrySceneObject {
     axis;
     targetObjects;
+    _excludedObjects = [];
     constructor(axis, targetObjects = null) {
         super();
         this.axis = axis;
         this.targetObjects = targetObjects;
     }
+    exclude(...objects) {
+        this._excludedObjects.push(...objects);
+        return this;
+    }
     build(context) {
         let targetObjects = this.targetObjects;
         let sketch = this.sketch;
@@ -23,6 +28,9 @@ export class MirrorShape2D extends GeometrySceneObject {
         else {
             targetObjects = objects;
         }
+        if (this._excludedObjects.length > 0) {
+            targetObjects = targetObjects.filter(obj => !this._excludedObjects.includes(obj));
+        }
         this.axis.removeShapes(this);
         axis = this.axis.getAxis();
         const transformedShapes = [];
@@ -79,7 +87,12 @@ export class MirrorShape2D extends GeometrySceneObject {
         const targetObjects = this.targetObjects
             ? this.targetObjects.map(obj => remap.get(obj) || obj)
             : null;
-        return new MirrorShape2D(axis, targetObjects);
+        const copy = new MirrorShape2D(axis, targetObjects);
+        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 MirrorShape2D)) {
@@ -101,6 +114,14 @@ export class MirrorShape2D extends GeometrySceneObject {
                 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/features/revolve.d.ts

@@ -8,6 +8,37 @@ export declare class Revolve extends ExtrudeBase implements IRevolve {
     angle: number;
     constructor(axis: AxisObjectBase, angle: number, extrudable?: Extrudable);
     build(context: BuildSceneObjectContext): void;
+    /** Plain revolve: classify by inner-wire detection on the source plane. */
+    private buildRevolve;
+    /** Thin revolve: shell-like profile with inward/outward offsets. */
+    private buildRevolveThin;
+    /**
+     * Classify a thin open-profile revolve via the per-edge history captured
+     * during `makeRevol`. Each entry in `revols[i].edgeFaces` pairs an input
+     * edge of the thin face with the swept face it produced; we route that
+     * face into internal / side / cap based on which edge category the input
+     * belongs to (`thinResult.inwardEdges`, `outwardEdges`, or neither →
+     * cap-line edge added by `makeOpenFaceWithCaps`).
+     */
+    private classifyThinByEdgeHistory;
+    /**
+     * Run the revolutions for each fused profile face. Identifies start/end
+     * faces via the maker's `FirstShape` / `LastShape` and tracks which side
+     * face each input edge generated via `Generated()` — both survive the
+     * downstream `cleanShapeRaw`. Caller refines side → side/internal/cap
+     * using the per-edge mapping in `revols[i].edgeFaces`.
+     */
+    private runRevolutions;
+    /**
+     * Rotate the revolved solid by `matrix` (used for `.symmetric()`) and
+     * remap firstFace / lastFace / edgeFaces through the transformer's
+     * `ModifiedShape` so classification keeps pointing at the right TShapes.
+     */
+    private applySymmetricTransform;
+    /** Inner-wire classification used by both regular revolve and closed thin profiles. */
+    private classifyRevolveByInnerWires;
+    /** Remove source + axis, then dispatch to cut or fuse path. */
+    private dispatchFinalize;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Revolve): boolean;

package/lib/dist/features/revolve.js

@@ -1,15 +1,17 @@
 import { rad } from "../helpers/math-helpers.js";
 import { Solid } from "../common/shapes.js";
-import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+import { cutWithSceneObjects } from "../helpers/scene-helpers.js";
 import { ExtrudeOps } from "../oc/extrude-ops.js";
 import { Explorer } from "../oc/explorer.js";
-import { ShapeOps } from "../oc/shape-ops.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
 import { ExtrudeBase } from "./extrude-base.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
-import { FaceOps } from "../oc/face-ops.js";
+import { Face } from "../common/face.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 import { Matrix4 } from "../math/matrix4.js";
+import { Convert } from "../oc/convert.js";
+import { ShapeFactory } from "../common/shape-factory.js";
+import { getOC } from "../oc/init.js";
 export class Revolve extends ExtrudeBase {
     axis;
     angle;
@@ -19,128 +21,209 @@ export class Revolve extends ExtrudeBase {
         this.angle = angle;
     }
     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;
         }
-        const solids = [];
-        const allStartFaces = [];
-        const allEndFaces = [];
-        let allSideFaces = [];
-        let allInternalFaces = [];
-        let allCapFaces = [];
-        let faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
-        let inwardEdges;
-        let outwardEdges;
         if (this.isThin()) {
-            const thinResult = ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]);
-            faces = thinResult.faces;
-            inwardEdges = thinResult.inwardEdges;
-            outwardEdges = thinResult.outwardEdges;
+            const thinResult = p.record('Make thin faces', () => ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]));
+            this.buildRevolveThin(thinResult, plane, context);
+        }
+        else {
+            const faces = pickedFaces ?? p.record('Resolve faces', () => FaceMaker2.getRegions(this.extrudable.getGeometries(), plane));
+            this.buildRevolve(faces, plane, context);
+        }
+        this.setFinalShapes(this.getShapes());
+    }
+    /** Plain revolve: classify by inner-wire detection on the source plane. */
+    buildRevolve(faces, plane, context) {
+        const revolved = this.runRevolutions(faces, context);
+        const classified = this.classifyRevolveByInnerWires(revolved, plane);
+        this.dispatchFinalize(revolved.solids, classified, plane, context);
+    }
+    /** Thin revolve: shell-like profile with inward/outward offsets. */
+    buildRevolveThin(thinResult, plane, context) {
+        const revolved = this.runRevolutions(thinResult.faces, context);
+        let classified;
+        if (thinResult.inwardEdges.length > 0) {
+            // Open profile: each input edge of the thin face categorizes the side
+            // face it generated (inward → internal, outward → side, anything else
+            // is a cap edge → cap face).
+            classified = this.classifyThinByEdgeHistory(revolved, thinResult);
+        }
+        else {
+            // Closed profile: regular inner-wire detection.
+            classified = this.classifyRevolveByInnerWires(revolved, plane);
         }
-        const { result: fusedFaces } = BooleanOps.fuseFaces(faces);
+        this.dispatchFinalize(revolved.solids, classified, plane, context);
+    }
+    /**
+     * Classify a thin open-profile revolve via the per-edge history captured
+     * during `makeRevol`. Each entry in `revols[i].edgeFaces` pairs an input
+     * edge of the thin face with the swept face it produced; we route that
+     * face into internal / side / cap based on which edge category the input
+     * belongs to (`thinResult.inwardEdges`, `outwardEdges`, or neither →
+     * cap-line edge added by `makeOpenFaceWithCaps`).
+     */
+    classifyThinByEdgeHistory(revolved, thinResult) {
+        const sideFaces = [];
+        const internalFaces = [];
+        const capFaces = [];
+        const matchesAny = (edge, refs) => refs.some(r => r.getShape().IsSame(edge));
+        for (const revol of revolved.revols) {
+            for (const { edge, face } of revol.edgeFaces) {
+                if (!face) {
+                    continue;
+                }
+                if (matchesAny(edge, thinResult.inwardEdges)) {
+                    internalFaces.push(face);
+                }
+                else if (matchesAny(edge, thinResult.outwardEdges)) {
+                    sideFaces.push(face);
+                }
+                else {
+                    capFaces.push(face);
+                }
+            }
+        }
+        return {
+            startFaces: revolved.startFaces,
+            endFaces: revolved.endFaces,
+            sideFaces,
+            internalFaces,
+            capFaces,
+        };
+    }
+    /**
+     * Run the revolutions for each fused profile face. Identifies start/end
+     * faces via the maker's `FirstShape` / `LastShape` and tracks which side
+     * face each input edge generated via `Generated()` — both survive the
+     * downstream `cleanShapeRaw`. Caller refines side → side/internal/cap
+     * using the per-edge mapping in `revols[i].edgeFaces`.
+     */
+    runRevolutions(faces, context) {
+        const p = context.getProfiler();
+        const { result: fusedFaces } = p.record('Fuse faces', () => BooleanOps.fuseFaces(faces));
         const axis = this.axis.getAxis();
-        const isFullRevolution = Math.abs(this.angle) >= 360;
+        const solids = [];
+        const startFaces = [];
+        const endFaces = [];
+        const sideFaces = [];
+        const revols = [];
         for (const face of fusedFaces) {
-            const solid = ExtrudeOps.makeRevol(face, axis, rad(this.angle));
-            let resultSolid;
+            let revol = p.record('Revolve face', () => ExtrudeOps.makeRevol(face, axis, rad(this.angle)));
             if (this._symmetric) {
                 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()));
+                revol = this.applySymmetricTransform(revol, matrix);
             }
+            const resultSolid = Solid.fromTopoDSSolid(Explorer.toSolid(revol.solid.getShape()));
             solids.push(resultSolid);
-            // Classify faces of the revolved solid
-            const solidFaces = Explorer.findFacesWrapped(resultSolid);
-            for (const f of solidFaces) {
-                const isOnSourcePlane = FaceOps.faceOnPlaneWrapped(f, plane);
-                if (isOnSourcePlane && !isFullRevolution) {
-                    allStartFaces.push(f);
+            revols.push(revol);
+            const firstRaw = revol.firstFace?.getShape() ?? null;
+            const lastRaw = revol.lastFace?.getShape() ?? null;
+            for (const f of Explorer.findFacesWrapped(resultSolid)) {
+                const raw = f.getShape();
+                if (firstRaw && raw.IsSame(firstRaw)) {
+                    startFaces.push(f);
+                }
+                else if (lastRaw && raw.IsSame(lastRaw)) {
+                    endFaces.push(f);
                 }
                 else {
-                    allSideFaces.push(f);
+                    sideFaces.push(f);
                 }
             }
         }
-        // For partial revolves with symmetric, classify start/end by plane offset
-        if (!isFullRevolution && allStartFaces.length > 1) {
-            const half = Math.floor(allStartFaces.length / 2);
-            const startSlice = allStartFaces.splice(0, half);
-            const endSlice = allStartFaces.splice(0);
-            allStartFaces.length = 0;
-            allStartFaces.push(...startSlice);
-            allEndFaces.push(...endSlice);
-        }
-        if (inwardEdges && inwardEdges.length > 0) {
-            const result = this.reclassifyThinFaces(allSideFaces, allStartFaces, plane, inwardEdges, outwardEdges || []);
-            allSideFaces = result.sideFaces;
-            allInternalFaces = result.internalFaces;
-            allCapFaces = result.capFaces;
-        }
-        else {
-            const innerWireEdges = [];
-            for (const sf of allStartFaces) {
-                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, revols };
+    }
+    /**
+     * Rotate the revolved solid by `matrix` (used for `.symmetric()`) and
+     * remap firstFace / lastFace / edgeFaces through the transformer's
+     * `ModifiedShape` so classification keeps pointing at the right TShapes.
+     */
+    applySymmetricTransform(revol, matrix) {
+        const oc = getOC();
+        const [trsf, disposeTrsf] = Convert.toGpTrsf(matrix);
+        const transformer = new oc.BRepBuilderAPI_Transform(trsf);
+        transformer.Perform(revol.solid.getShape(), true);
+        const transformedSolid = ShapeFactory.fromShape(transformer.Shape());
+        const remapFace = (f) => {
+            if (!f) {
+                return null;
+            }
+            const modified = transformer.ModifiedShape(f.getShape());
+            return Face.fromTopoDSFace(Explorer.toFace(modified));
+        };
+        const result = {
+            solid: transformedSolid,
+            firstFace: remapFace(revol.firstFace),
+            lastFace: remapFace(revol.lastFace),
+            edgeFaces: revol.edgeFaces.map(({ edge, face }) => ({
+                edge,
+                face: remapFace(face),
+            })),
+        };
+        transformer.delete();
+        disposeTrsf();
+        return result;
+    }
+    /** Inner-wire classification used by both regular revolve and closed thin profiles. */
+    classifyRevolveByInnerWires(revolved, plane) {
+        const innerWireEdges = [];
+        for (const sf of revolved.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 allSideFaces) {
-                    const isInternal = f.getEdges().some(fe => innerWireEdges.some(iwe => fe.getShape().IsPartner(iwe.getShape())));
-                    if (isInternal) {
-                        allInternalFaces.push(f);
-                    }
-                    else {
-                        remaining.push(f);
-                    }
+        }
+        const sideFaces = [];
+        const internalFaces = [];
+        if (innerWireEdges.length === 0) {
+            sideFaces.push(...revolved.sideFaces);
+        }
+        else {
+            for (const f of revolved.sideFaces) {
+                const isInternal = f.getEdges().some(fe => innerWireEdges.some(iwe => fe.getShape().IsPartner(iwe.getShape())));
+                if (isInternal) {
+                    internalFaces.push(f);
+                }
+                else {
+                    sideFaces.push(f);
                 }
-                allSideFaces = remaining;
             }
         }
-        this.setState('start-faces', allStartFaces);
-        this.setState('end-faces', allEndFaces);
-        this.setState('side-faces', allSideFaces);
-        this.setState('internal-faces', allInternalFaces);
-        this.setState('cap-faces', allCapFaces);
+        return {
+            startFaces: revolved.startFaces,
+            endFaces: revolved.endFaces,
+            sideFaces,
+            internalFaces,
+            capFaces: [],
+        };
+    }
+    /** Remove source + axis, then dispatch to cut or fuse path. */
+    dispatchFinalize(solids, classified, plane, context) {
         this.extrudable.removeShapes(this);
         this.axis.removeShapes(this);
         if (this._operationMode === 'remove') {
             const scope = this.resolveFusionScope(context.getSceneObjects());
+            // Note: stash classification state up front — cutWithSceneObjects /
+            // classifyCutResult writes its own state keys, but the pre-classified
+            // faces are useful for the remove path's selection accessors when no
+            // cut-specific edges exist for that category.
+            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 });
-            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, {
-            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);
     }
     getDependencies() {
         return this.extrudable ? [this.extrudable] : [];

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

@@ -5,8 +5,10 @@ export declare class Rotate extends SceneObject {
     angle: number;
     private copy;
     private _targetObjects;
+    private _excludedObjects;
     constructor(axis: AxisObjectBase, angle: number, copy?: boolean, ...targets: SceneObject[]);
     get targetObjects(): SceneObject[];
+    exclude(...objects: SceneObject[]): this;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: Rotate): boolean;
     getType(): string;

package/lib/dist/features/rotate.js

@@ -7,6 +7,7 @@ export class Rotate extends SceneObject {
     angle;
     copy;
     _targetObjects = null;
+    _excludedObjects = [];
     constructor(axis, angle, copy = false, ...targets) {
         super();
         this.axis = axis;
@@ -17,6 +18,10 @@ export class Rotate extends SceneObject {
     get targetObjects() {
         return this._targetObjects;
     }
+    exclude(...objects) {
+        this._excludedObjects.push(...objects);
+        return this;
+    }
     build(context) {
         let objects;
         let targetObjects = this.targetObjects;
@@ -34,6 +39,9 @@ export class Rotate extends SceneObject {
         else {
             targetObjects = objects;
         }
+        if (this._excludedObjects.length > 0) {
+            targetObjects = targetObjects.filter(obj => !this._excludedObjects.includes(obj));
+        }
         this.axis.removeShapes(this);
         const axis = this.axis.getAxis();
         const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, rad(this.angle));
@@ -77,6 +85,14 @@ export class Rotate 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] !== other._excludedObjects[i]) {
+                return false;
+            }
+        }
         return true;
     }
     getType() {

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

@@ -4,8 +4,10 @@ export declare class Rotate2D extends GeometrySceneObject {
     angle: number;
     private copy;
     private _targetObjects;
+    private _excludedObjects;
     constructor(angle: number, copy?: boolean, ...targets: SceneObject[]);
     get targetObjects(): SceneObject[] | null;
+    exclude(...objects: SceneObject[]): this;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: Rotate2D): boolean;
     getType(): string;

package/lib/dist/features/rotate2d.js

@@ -7,6 +7,7 @@ export class Rotate2D extends GeometrySceneObject {
     angle;
     copy;
     _targetObjects = null;
+    _excludedObjects = [];
     constructor(angle, copy = false, ...targets) {
         super();
         this.angle = angle;
@@ -16,6 +17,10 @@ export class Rotate2D extends GeometrySceneObject {
     get targetObjects() {
         return this._targetObjects;
     }
+    exclude(...objects) {
+        this._excludedObjects.push(...objects);
+        return this;
+    }
     build(context) {
         let objects;
         let targetObjects = this.targetObjects;
@@ -27,6 +32,9 @@ export class Rotate2D extends GeometrySceneObject {
         else {
             targetObjects = objects;
         }
+        if (this._excludedObjects.length > 0) {
+            targetObjects = targetObjects.filter(obj => !this._excludedObjects.includes(obj));
+        }
         const plane = this.sketch.getPlane();
         const currentPosition = plane.localToWorld(this.sketch.getPositionAt(this));
         axis = new Axis(currentPosition, plane.zAxis.direction);
@@ -67,6 +75,14 @@ export class Rotate2D extends GeometrySceneObject {
                 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;
+            }
+        }
         if (!super.compareTo(other)) {
             return false;
         }

package/lib/dist/features/select.js

@@ -61,7 +61,8 @@ export class SelectSceneObject extends SceneObject {
         const remappedConstraint = this.constraintObject
             ? (remap.get(this.constraintObject) || this.constraintObject)
             : undefined;
-        return new SelectSceneObject(this.filters, remappedConstraint);
+        const remappedFilters = this.filters.map(f => f.remap(remap));
+        return new SelectSceneObject(remappedFilters, remappedConstraint);
     }
     transform(matrix) {
         const mirroredFilters = this.filters.map(f => f.transform(matrix));