fluidcad 0.0.30 → 0.0.32

package/lib/dist/features/extrude-to-face.d.ts

@@ -2,9 +2,11 @@ import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js"
 import { ExtrudeBase } from "./extrude-base.js";
 import { Extrudable } from "../helpers/types.js";
 import { Point } from "../math/point.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 export declare class ExtrudeToFace extends ExtrudeBase {
     face: SceneObject | 'first-face' | 'last-face';
-    constructor(face: SceneObject | 'first-face' | 'last-face', source?: Extrudable | SceneObject);
+    private faceFilters;
+    constructor(face: SceneObject | 'first-face' | 'last-face', source?: Extrudable | SceneObject, faceFilters?: FaceFilterBuilder[]);
     build(context: BuildSceneObjectContext): void;
     private createAdvancedExtrude;
     private resizePlanarFace;
@@ -20,6 +22,7 @@ export declare class ExtrudeToFace extends ExtrudeBase {
     private createSimpleExtrude;
     private getFace;
     private getFirstOrLastFace;
+    private collectFromSceneObjects;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: ExtrudeToFace): boolean;
@@ -39,6 +42,7 @@ export declare class ExtrudeToFace extends ExtrudeBase {
         draft: [number, number];
         endOffset: number;
         face: string;
+        faceFilterCount: number;
         thin: [number, number] | [number];
     };
 }

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

@@ -11,11 +11,15 @@ import { Explorer } from "../oc/explorer.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 import { Point } from "../math/point.js";
+import { ShapeFilter } from "../filters/filter.js";
+import { FromSceneObjectFilter } from "../filters/from-object.js";
 export class ExtrudeToFace extends ExtrudeBase {
     face;
-    constructor(face, source) {
+    faceFilters;
+    constructor(face, source, faceFilters = []) {
         super(source);
         this.face = face;
+        this.faceFilters = faceFilters;
     }
     build(context) {
         const allSceneObjects = context.getSceneObjects();
@@ -252,12 +256,31 @@ export class ExtrudeToFace extends ExtrudeBase {
                 }
             }
         }
-        const result = FaceQuery.findFaceByDistance(allFaces, plane, mode);
+        let candidates = allFaces;
+        if (this.faceFilters.length > 0) {
+            candidates = new ShapeFilter(allFaces, ...this.faceFilters).apply();
+        }
+        const result = FaceQuery.findFaceByDistance(candidates, plane, mode);
         if (!result) {
             throw new Error(`No face found for '${mode}-face' extrusion`);
         }
         return result;
     }
+    collectFromSceneObjects() {
+        const objects = [];
+        for (const builder of this.faceFilters) {
+            for (const filter of builder.getFilters()) {
+                if (filter instanceof FromSceneObjectFilter) {
+                    for (const obj of filter.getSceneObjects()) {
+                        if (!objects.includes(obj)) {
+                            objects.push(obj);
+                        }
+                    }
+                }
+            }
+        }
+        return objects;
+    }
     getDependencies() {
         const deps = [];
         const source = this.getSource();
@@ -267,6 +290,11 @@ export class ExtrudeToFace extends ExtrudeBase {
         if (this.face instanceof SceneObject) {
             deps.push(this.face);
         }
+        for (const obj of this.collectFromSceneObjects()) {
+            if (!deps.includes(obj)) {
+                deps.push(obj);
+            }
+        }
         return deps;
     }
     createCopy(remap) {
@@ -275,7 +303,8 @@ export class ExtrudeToFace extends ExtrudeBase {
             : this.face;
         const source = this.getSource();
         const remapped = source ? (remap.get(source) || source) : undefined;
-        return new ExtrudeToFace(newFace, remapped).syncWith(this);
+        const remappedFilters = this.faceFilters.map(f => f.remap(remap));
+        return new ExtrudeToFace(newFace, remapped, remappedFilters).syncWith(this);
     }
     compareTo(other) {
         if (!(other instanceof ExtrudeToFace)) {
@@ -292,15 +321,27 @@ export class ExtrudeToFace extends ExtrudeBase {
         if (thisSource && otherSource && !thisSource.compareTo(otherSource)) {
             return false;
         }
-        if (typeof (this.face) !== typeof (other.face)) {
-            return false;
+        if (this.face instanceof SceneObject) {
+            if (!(other.face instanceof SceneObject)) {
+                return false;
+            }
+            if (!this.face.compareTo(other.face)) {
+                return false;
+            }
         }
-        if (this.face instanceof SceneObject && other.face instanceof SceneObject && !this.face.compareTo(other.face)) {
-            return false;
+        else {
+            if (this.face !== other.face) {
+                return false;
+            }
         }
-        if (this.face !== other.face) {
+        if (this.faceFilters.length !== other.faceFilters.length) {
             return false;
         }
+        for (let i = 0; i < this.faceFilters.length; i++) {
+            if (!this.faceFilters[i].equals(other.faceFilters[i])) {
+                return false;
+            }
+        }
         return true;
     }
     getUniqueType() {
@@ -316,6 +357,7 @@ export class ExtrudeToFace extends ExtrudeBase {
             draft: this.getDraft(),
             endOffset: this.getEndOffset(),
             face: typeof (this.face) === 'string' ? this.face : 'selection',
+            faceFilterCount: this.faceFilters.length,
             thin: this._thin,
             ...this.serializePickFields(),
         };

package/lib/dist/features/extrude.js

@@ -5,8 +5,11 @@ import { FaceMaker2 } from "../oc/face-maker2.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
 import { EdgeOps } from "../oc/edge-ops.js";
 import { Explorer } from "../oc/explorer.js";
-import { ExtrudeThroughAll } from "./infinite-extrude.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
+/** Finite stand-in for "infinity" in through-all cuts. Truly infinite prisms
+ *  (via OC's `Inf=true` flag) silently fail inside `BRepAlgoAPI_Cut` — verified
+ *  experimentally — so use a large finite extrusion instead. */
+const THROUGH_ALL_LENGTH = 100000;
 export class Extrude extends ExtrudeBase {
     distance;
     constructor(distance, source) {
@@ -257,36 +260,24 @@ export class Extrude extends ExtrudeBase {
         const scope = this.resolveFusionScope(context.getSceneObjects());
         let toolShapes;
         const isThroughAll = this.distance === 0;
-        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();
-            }
-            else {
-                const extruder1 = new Extruder(faces, plane, -this.distance / 2, this.getDraft(), this.getEndOffset());
-                const extrusions1 = extruder1.extrude();
-                const extruder2 = new Extruder(faces, plane, this.distance / 2, this.getDraft(), this.getEndOffset());
-                const extrusions2 = extruder2.extrude();
-                const all = [...extrusions1, ...extrusions2];
-                const halvesFuse = BooleanOps.fuse(all);
-                toolShapes = halvesFuse.result;
-                halvesFuse.dispose();
-            }
+        const draft = this.getDraft();
+        if (isThroughAll && this.isFaceSourced()) {
+            throw new Error("through-all is not supported with a face-sourced extrude");
         }
-        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();
+        if (this._symmetric) {
+            // Symmetric cut: create tool centered on sketch plane, fusing two halves
+            // (one on each side). For through-all, each half uses THROUGH_ALL_LENGTH.
+            const halfDistance = isThroughAll ? THROUGH_ALL_LENGTH : this.distance / 2;
+            const extruder1 = new Extruder(faces, plane, -halfDistance, draft, this.getEndOffset());
+            const extruder2 = new Extruder(faces, plane, halfDistance, draft, this.getEndOffset());
+            const all = [...extruder1.extrude(), ...extruder2.extrude()];
+            const halvesFuse = BooleanOps.fuse(all);
+            toolShapes = halvesFuse.result;
+            halvesFuse.dispose();
         }
         else {
-            const distance = -this.distance;
-            const extruder = new Extruder(faces, plane, distance, this.getDraft(), this.getEndOffset());
+            const distance = isThroughAll ? -THROUGH_ALL_LENGTH : -this.distance;
+            const extruder = new Extruder(faces, plane, distance, draft, this.getEndOffset());
             toolShapes = extruder.extrude();
         }
         this.getSource()?.removeShapes(this);

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

@@ -5,6 +5,7 @@ export declare class Fillet extends SceneObject {
     private _targetEdges;
     constructor(radius: number, ...selections: SceneObject[]);
     get targetEdges(): SceneObject[];
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     doBuild(sceneObjectsMap: Map<SceneObject, Shape[]>, selections: SceneObject[]): {
         addedShapes: Shape<import("occjs-wrapper").TopoDS_Shape>[];

package/lib/dist/features/fillet.js

@@ -1,6 +1,7 @@
 import { SceneObject } from "../common/scene-object.js";
 import { FilletOps } from "../oc/fillet-ops.js";
 import { Explorer } from "../oc/explorer.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Fillet extends SceneObject {
     radius;
     _targetEdges = [];
@@ -12,6 +13,11 @@ export class Fillet extends SceneObject {
     get targetEdges() {
         return this._targetEdges;
     }
+    validate() {
+        for (let i = 0; i < this._targetEdges.length; i++) {
+            requireShapes(this._targetEdges[i], `edge selection ${i + 1}`, "fillet");
+        }
+    }
     build(context) {
         const selections = this.targetEdges;
         let sceneObjects;

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

@@ -5,6 +5,7 @@ export declare class Fillet2D extends GeometrySceneObject {
     private _targetObjects;
     constructor(radius: number, ...targets: SceneObject[]);
     get targetObjects(): GeometrySceneObject[] | null;
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;

package/lib/dist/features/fillet2d.js

@@ -3,6 +3,7 @@ import { GeometrySceneObject } from "./2d/geometry.js";
 import { FilletOps } from "../oc/fillet-ops.js";
 import { Edge } from "../common/edge.js";
 import { WireOps } from "../oc/wire-ops.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Fillet2D extends GeometrySceneObject {
     radius;
     _targetObjects = null;
@@ -14,6 +15,14 @@ export class Fillet2D extends GeometrySceneObject {
     get targetObjects() {
         return this._targetObjects;
     }
+    validate() {
+        if (!this._targetObjects) {
+            return;
+        }
+        for (let i = 0; i < this._targetObjects.length; i++) {
+            requireShapes(this._targetObjects[i], `target ${i + 1}`, "fillet2d");
+        }
+    }
     build(context) {
         let edges = new Map();
         if (this.targetObjects === null) {

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

@@ -3,6 +3,7 @@ export declare class Fuse extends SceneObject {
     private _sceneObjects;
     constructor(...objects: SceneObject[]);
     get sceneObjects(): SceneObject[];
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: Fuse): boolean;
     getType(): string;

package/lib/dist/features/fuse.js

@@ -1,6 +1,7 @@
 import { SceneObject } from "../common/scene-object.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
 import { ColorTransfer } from "../oc/color-transfer.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Fuse extends SceneObject {
     _sceneObjects = [];
     constructor(...objects) {
@@ -10,6 +11,11 @@ export class Fuse extends SceneObject {
     get sceneObjects() {
         return this._sceneObjects;
     }
+    validate() {
+        for (let i = 0; i < this._sceneObjects.length; i++) {
+            requireShapes(this._sceneObjects[i], `operand ${i + 1}`, "fuse");
+        }
+    }
     build(context) {
         const p = context.getProfiler();
         let sceneObjects = this.sceneObjects;

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

@@ -4,6 +4,7 @@ export declare class Fuse2D extends GeometrySceneObject {
     private _targetObjects;
     constructor(...targets: GeometrySceneObject[]);
     get targetObjects(): GeometrySceneObject[] | null;
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;

package/lib/dist/features/fuse2d.js

@@ -3,6 +3,7 @@ import { Edge } from "../common/edge.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Fuse2D extends GeometrySceneObject {
     _targetObjects = null;
     constructor(...targets) {
@@ -12,6 +13,14 @@ export class Fuse2D extends GeometrySceneObject {
     get targetObjects() {
         return this._targetObjects;
     }
+    validate() {
+        if (!this._targetObjects) {
+            return;
+        }
+        for (let i = 0; i < this._targetObjects.length; i++) {
+            requireShapes(this._targetObjects[i], `operand ${i + 1}`, "fuse2d");
+        }
+    }
     build(context) {
         let sourceEdges;
         if (this._targetObjects === null) {

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

@@ -5,6 +5,7 @@ export declare class Loft extends ExtrudeBase implements ILoft {
     private _profiles;
     constructor(...profiles: SceneObject[]);
     get profiles(): SceneObject[];
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     private buildThinLoft;
     private getProfilePlane;

package/lib/dist/features/loft.js

@@ -6,6 +6,7 @@ import { BooleanOps } from "../oc/boolean-ops.js";
 import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
 import { ExtrudeBase } from "./extrude-base.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Loft extends ExtrudeBase {
     _profiles = [];
     constructor(...profiles) {
@@ -15,6 +16,11 @@ export class Loft extends ExtrudeBase {
     get profiles() {
         return this._profiles;
     }
+    validate() {
+        for (let i = 0; i < this._profiles.length; i++) {
+            requireShapes(this._profiles[i], `profile ${i + 1}`, "loft");
+        }
+    }
     build(context) {
         if (this.profiles.length < 2) {
             throw new Error("Loft requires at least two profiles.");

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

@@ -6,6 +6,7 @@ export declare class MirrorShape extends SceneObject {
     private _excludedObjects;
     constructor(plane: PlaneObjectBase, targetObjects?: SceneObject[] | null);
     exclude(...objects: SceneObject[]): this;
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: MirrorShape): boolean;
     getType(): string;

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

@@ -1,7 +1,8 @@
 import { SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
 import { ShapeOps } from "../oc/shape-ops.js";
-import { fuseWithSceneObjects } from "../helpers/scene-helpers.js";
+import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+import { requireShapes } from "../common/operand-check.js";
 export class MirrorShape extends SceneObject {
     plane;
     targetObjects;
@@ -15,6 +16,14 @@ export class MirrorShape extends SceneObject {
         this._excludedObjects.push(...objects);
         return this;
     }
+    validate() {
+        if (!this.targetObjects || this.targetObjects.length === 0) {
+            return;
+        }
+        for (let i = 0; i < this.targetObjects.length; i++) {
+            requireShapes(this.targetObjects[i], `target ${i + 1}`, "mirror");
+        }
+    }
     build(context) {
         let objects;
         let targetObjects = this.targetObjects;
@@ -59,14 +68,25 @@ export class MirrorShape extends SceneObject {
                 transformedShapes.push(transformed);
             }
         }
-        const fusionResult = fuseWithSceneObjects(allSceneObjects, transformedShapes);
-        for (const modifiedShape of fusionResult.modifiedShapes) {
-            if (modifiedShape.object) {
-                modifiedShape.object.removeShape(modifiedShape.shape, this);
-            }
+        const scope = this.resolveFusionScope(allSceneObjects);
+        if (this._operationMode === 'new') {
+            this.addShapes(transformedShapes);
         }
-        for (const shape of fusionResult.newShapes) {
-            this.addShape(shape);
+        else if (this._operationMode === 'remove') {
+            cutWithSceneObjects(scope, transformedShapes, plane, 0, this, {
+                recordHistoryFor: this,
+            });
+        }
+        else {
+            const fusionResult = fuseWithSceneObjects(scope, transformedShapes);
+            for (const modifiedShape of fusionResult.modifiedShapes) {
+                if (modifiedShape.object) {
+                    modifiedShape.object.removeShape(modifiedShape.shape, this);
+                }
+            }
+            for (const shape of fusionResult.newShapes) {
+                this.addShape(shape);
+            }
         }
     }
     compareTo(other) {

package/lib/dist/features/plane-from-object.d.ts

@@ -8,6 +8,7 @@ export declare class PlaneFromObject extends PlaneObjectBase {
     sourceObject: SceneObject;
     options?: PlaneRenderableOptions;
     constructor(sourceObject: SceneObject, options?: PlaneRenderableOptions);
+    validate(): void;
     build(context?: BuildSceneObjectContext): void;
     getFromSceneObject(sceneObject: SceneObject): {
         plane: Plane;

package/lib/dist/features/plane-from-object.js

@@ -2,6 +2,7 @@ import { PlaneObjectBase } from "./plane-renderable-base.js";
 import { FaceOps } from "../oc/face-ops.js";
 import { ShapeOps } from "../oc/shape-ops.js";
 import { Point } from "../math/point.js";
+import { requireShapes } from "../common/operand-check.js";
 export class PlaneFromObject extends PlaneObjectBase {
     sourceObject;
     options;
@@ -10,6 +11,13 @@ export class PlaneFromObject extends PlaneObjectBase {
         this.sourceObject = sourceObject;
         this.options = options;
     }
+    validate() {
+        // PlaneObjectBase sources expose the plane directly — no shapes required.
+        if (this.sourceObject instanceof PlaneObjectBase) {
+            return;
+        }
+        requireShapes(this.sourceObject, "source", "plane");
+    }
     build(context) {
         let plane;
         let sourceFace;

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

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

package/lib/dist/features/rotate.js

@@ -2,6 +2,7 @@ import { SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
 import { rad } from "../helpers/math-helpers.js";
 import { ShapeOps } from "../oc/shape-ops.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Rotate extends SceneObject {
     axis;
     angle;
@@ -22,6 +23,14 @@ export class Rotate extends SceneObject {
         this._excludedObjects.push(...objects);
         return this;
     }
+    validate() {
+        if (!this._targetObjects) {
+            return;
+        }
+        for (let i = 0; i < this._targetObjects.length; i++) {
+            requireShapes(this._targetObjects[i], `target ${i + 1}`, "rotate");
+        }
+    }
     build(context) {
         let objects;
         let targetObjects = this.targetObjects;
@@ -81,7 +90,7 @@ export class Rotate extends SceneObject {
             return false;
         }
         for (let i = 0; i < thisTargetObjects.length; i++) {
-            if (thisTargetObjects[i] !== otherTargetObjects[i]) {
+            if (!thisTargetObjects[i].compareTo(otherTargetObjects[i])) {
                 return false;
             }
         }
@@ -89,7 +98,7 @@ export class Rotate extends SceneObject {
             return false;
         }
         for (let i = 0; i < this._excludedObjects.length; i++) {
-            if (this._excludedObjects[i] !== other._excludedObjects[i]) {
+            if (!this._excludedObjects[i].compareTo(other._excludedObjects[i])) {
                 return false;
             }
         }

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

@@ -11,6 +11,7 @@ export declare class SelectSceneObject extends SceneObject implements ISelect {
     private shapes;
     constructor(filters: FilterBuilderBase<Shape>[], constraintObject?: SceneObject);
     build(context: BuildSceneObjectContext): void;
+    private collectFromSceneObjects;
     private getAllShapes;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;

package/lib/dist/features/select.js

@@ -2,6 +2,7 @@ import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 import { ShapeFilter } from "../filters/filter.js";
 import { SceneObject } from "../common/scene-object.js";
 import { BelongsToFaceFilter, NotBelongsToFaceFilter } from "../filters/edge/belongs-to-face.js";
+import { FromSceneObjectFilter } from "../filters/from-object.js";
 export class SelectSceneObject extends SceneObject {
     filters;
     constraintObject;
@@ -32,30 +33,57 @@ export class SelectSceneObject extends SceneObject {
                 sceneObjects = context.getSceneObjectsFromTo(parent, this);
             }
         }
+        // Objects passed explicitly via `from(...)` bypass the part scope so that
+        // cross-part selection works (e.g. select(face().from(p1)) from inside p2).
+        if (!this.constraintObject) {
+            const fromObjects = this.collectFromSceneObjects(filters);
+            if (fromObjects.length > 0) {
+                sceneObjects = sceneObjects.slice();
+                for (const obj of fromObjects) {
+                    if (!sceneObjects.includes(obj)) {
+                        sceneObjects.push(obj);
+                    }
+                }
+            }
+        }
         const allShapes = this.constraintObject ? this.constraintObject.getShapes() : this.getAllShapes(sceneObjects, excludedObjects);
         if (this.type === "edge") {
             this.injectScopeFaces(filters, sceneObjects);
         }
         const filteredShapes = this.applyFilters(allShapes, filters);
-        console.log(`SelectSceneObject: shapes after filtering: ${filteredShapes[0]}`);
         this.addShapes(filteredShapes);
     }
+    collectFromSceneObjects(filters) {
+        const objects = [];
+        for (const builder of filters) {
+            for (const filter of builder.getFilters()) {
+                if (filter instanceof FromSceneObjectFilter) {
+                    for (const obj of filter.getSceneObjects()) {
+                        if (!objects.includes(obj)) {
+                            objects.push(obj);
+                        }
+                    }
+                }
+            }
+        }
+        return objects;
+    }
     getAllShapes(scope, exludedShapes) {
         const scopeShapes = scope.flatMap(obj => obj.getShapes({}, 'solid').map(s => s.getSubShapes(this.type)).flat());
         exludedShapes = exludedShapes.flatMap(s => s.getSubShapes(this.type));
-        const finalShapes = scopeShapes.filter(shape => !exludedShapes.some(exShape => exShape.isSame(shape)));
-        console.log('=== Scope Objects:', scope.length, ' Shapes:', scopeShapes.length);
-        console.log('=== Excluded Shapes:', exludedShapes.length);
-        console.log('=== Final Shapes after exclusion:', finalShapes.length);
-        let allShapes = [];
-        for (const shape of finalShapes) {
-            allShapes.push(shape);
-        }
-        console.log('SelectSceneObject: total shapes collected for filtering:', allShapes.length);
-        return allShapes;
+        return scopeShapes.filter(shape => !exludedShapes.some(exShape => exShape.isSame(shape)));
     }
     getDependencies() {
-        return this.constraintObject ? [this.constraintObject] : [];
+        const deps = [];
+        if (this.constraintObject) {
+            deps.push(this.constraintObject);
+        }
+        for (const obj of this.collectFromSceneObjects(this.filters)) {
+            if (!deps.includes(obj)) {
+                deps.push(obj);
+            }
+        }
+        return deps;
     }
     createCopy(remap) {
         const remappedConstraint = this.constraintObject

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

@@ -8,6 +8,7 @@ export declare class Shell extends SceneObject implements IShell {
     private _faceSelections;
     constructor(thickness: number, faceSelections?: SelectSceneObject[]);
     get faceSelections(): SelectSceneObject[];
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     internalFaces(...args: (number | FaceFilterBuilder)[]): SceneObject;
     internalEdges(...args: (number | EdgeFilterBuilder)[]): SceneObject;

package/lib/dist/features/shell.js

@@ -7,6 +7,7 @@ import { FaceQuery } from "../oc/face-query.js";
 import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
 import { ShapeFilter } from "../filters/filter.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Shell extends SceneObject {
     thickness;
     _faceSelections = [];
@@ -18,6 +19,11 @@ export class Shell extends SceneObject {
     get faceSelections() {
         return this._faceSelections;
     }
+    validate() {
+        for (let i = 0; i < this._faceSelections.length; i++) {
+            requireShapes(this._faceSelections[i], `face selection ${i + 1}`, "shell");
+        }
+    }
     build(context) {
         const shapeObjMap = new Map();
         for (const obj of context.getSceneObjects()) {

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

@@ -73,13 +73,16 @@ export class Extruder {
                     remainingFaces.push(f);
                 }
             }
-            // Use the firstFace from the solid to detect inner wires
-            // Inner wires (CCW) indicate holes — side faces sharing edges with them are internal
+            // Use the firstFace from the solid to detect inner wires. Test against
+            // the face's actual outward normal — for negative-distance extrudes the
+            // firstFace's outward normal flips relative to plane.normal, which would
+            // otherwise invert outer/inner detection and swap side/internal faces.
             const resolvedFirst = firstFace;
+            const outwardNormal = resolvedFirst.calculateNormal();
             const innerWireEdgeShapes = [];
             const wires = resolvedFirst.getWires();
             for (const wire of wires) {
-                if (!wire.isCW(this.plane.normal)) {
+                if (wire.isCW(outwardNormal)) {
                     for (const edge of wire.getEdges()) {
                         innerWireEdgeShapes.push(edge);
                     }

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

@@ -3,6 +3,7 @@ export declare class Subtract extends SceneObject {
     solid1: SceneObject;
     solid2: SceneObject;
     constructor(solid1: SceneObject, solid2: SceneObject);
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: Subtract): boolean;
     getType(): string;