fluidcad 0.0.7 → 0.0.9

package/lib/dist/features/2d/arc-three-points.js

@@ -0,0 +1,75 @@
+import { Vertex } from "../../common/vertex.js";
+import { Geometry } from "../../oc/geometry.js";
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class ArcThreePoints extends GeometrySceneObject {
+    startPoint;
+    endPoint;
+    center;
+    targetPlane;
+    constructor(startPoint, endPoint, center, targetPlane = null) {
+        super();
+        this.startPoint = startPoint;
+        this.endPoint = endPoint;
+        this.center = center;
+        this.targetPlane = targetPlane;
+    }
+    build() {
+        const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
+        const startPt = this.startPoint.asPoint2D();
+        const endPt = this.endPoint.asPoint2D();
+        const centerPt = this.center.asPoint2D();
+        const dx = startPt.x - centerPt.x;
+        const dy = startPt.y - centerPt.y;
+        const radius = Math.sqrt(dx * dx + dy * dy);
+        const endAngle = Math.atan2(endPt.y - centerPt.y, endPt.x - centerPt.x);
+        const center = plane.localToWorld(centerPt);
+        const start = plane.localToWorld(startPt);
+        const end = plane.localToWorld(endPt);
+        const arc = Geometry.makeArc(center, radius, plane.normal, start, end);
+        const edge = Geometry.makeEdgeFromCurve(arc);
+        // Tangent at end: perpendicular to radius direction at end point (CCW)
+        const tx = -Math.sin(endAngle);
+        const ty = Math.cos(endAngle);
+        this.setTangent(new Point2D(tx, ty));
+        this.setState('start', Vertex.fromPoint2D(startPt));
+        this.setState('end', Vertex.fromPoint2D(endPt));
+        this.addShape(edge);
+        if (this.sketch) {
+            this.setCurrentPosition(endPt);
+        }
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+    }
+    compareTo(other) {
+        if (!(other instanceof ArcThreePoints)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        return this.startPoint.compareTo(other.startPoint) &&
+            this.endPoint.compareTo(other.endPoint) &&
+            this.center.compareTo(other.center);
+    }
+    getType() {
+        return 'arc';
+    }
+    getUniqueType() {
+        return 'arc-three-points';
+    }
+    serialize() {
+        return {
+            startPoint: this.startPoint.serialize(),
+            endPoint: this.endPoint.serialize(),
+            center: this.center.serialize()
+        };
+    }
+}

package/lib/dist/features/2d/constraints/geometry-qualifier.d.ts

@@ -1,6 +1,22 @@
 import { ISceneObject } from "../../../core/interfaces.js";
 import { QualifiedSceneObject } from "./qualified-geometry.js";
+/**
+ * Qualifies a geometry as being on the outside of the constraining object.
+ * @param sceneObject - The geometry to qualify.
+ */
 export declare function outside(sceneObject: ISceneObject): QualifiedSceneObject;
+/**
+ * Qualifies a geometry as being enclosed by the constraining object.
+ * @param sceneObject - The geometry to qualify.
+ */
 export declare function enclosed(sceneObject: ISceneObject): QualifiedSceneObject;
+/**
+ * Qualifies a geometry as enclosing the constraining object.
+ * @param sceneObject - The geometry to qualify.
+ */
 export declare function enclosing(sceneObject: ISceneObject): QualifiedSceneObject;
+/**
+ * Removes any existing constraint qualification from a geometry.
+ * @param sceneObject - The geometry to unqualify.
+ */
 export declare function unqualified(sceneObject: ISceneObject): QualifiedSceneObject;

package/lib/dist/features/2d/constraints/geometry-qualifier.js

@@ -1,13 +1,29 @@
 import { QualifiedSceneObject } from "./qualified-geometry.js";
+/**
+ * Qualifies a geometry as being on the outside of the constraining object.
+ * @param sceneObject - The geometry to qualify.
+ */
 export function outside(sceneObject) {
     return new QualifiedSceneObject(sceneObject, 'outside');
 }
+/**
+ * Qualifies a geometry as being enclosed by the constraining object.
+ * @param sceneObject - The geometry to qualify.
+ */
 export function enclosed(sceneObject) {
     return new QualifiedSceneObject(sceneObject, 'enclosed');
 }
+/**
+ * Qualifies a geometry as enclosing the constraining object.
+ * @param sceneObject - The geometry to qualify.
+ */
 export function enclosing(sceneObject) {
     return new QualifiedSceneObject(sceneObject, 'enclosing');
 }
+/**
+ * Removes any existing constraint qualification from a geometry.
+ * @param sceneObject - The geometry to unqualify.
+ */
 export function unqualified(sceneObject) {
     return new QualifiedSceneObject(sceneObject, 'unqualified');
 }

package/lib/dist/features/2d/offset.js

@@ -1,5 +1,6 @@
 import { WireOps } from "../../oc/wire-ops.js";
 import { Edge } from "../../common/edge.js";
+import { Vertex } from "../../common/vertex.js";
 import { Wire } from "../../common/wire.js";
 import { ExtrudableGeometryBase } from "./extrudable-base.js";
 export class Offset extends ExtrudableGeometryBase {
@@ -44,9 +45,11 @@ export class Offset extends ExtrudableGeometryBase {
                 edges: new Map(group.map(edge => [edge, sourceObjects.get(edge)]))
             });
         }
+        let lastOffsetWire = null;
         for (const wireInfo of wires) {
             const isOpen = !wireInfo.wire.isClosed();
             const offsetWire = WireOps.offsetWire(wireInfo.wire, this.distance, isOpen);
+            lastOffsetWire = offsetWire;
             const edges = offsetWire.getEdges();
             for (const edge of edges) {
                 this.addShape(edge);
@@ -57,6 +60,13 @@ export class Offset extends ExtrudableGeometryBase {
                 }
             }
         }
+        if (lastOffsetWire) {
+            const plane = this.getPlane();
+            const localStart = plane.worldToLocal(lastOffsetWire.getFirstVertex().toPoint());
+            const localEnd = plane.worldToLocal(lastOffsetWire.getLastVertex().toPoint());
+            this.setState('start', Vertex.fromPoint2D(localStart));
+            this.setState('end', Vertex.fromPoint2D(localEnd));
+        }
     }
     getDependencies() {
         const deps = [];

package/lib/dist/features/2d/projection.js

@@ -1,6 +1,7 @@
 import { Face } from "../../common/face.js";
 import { ShapeOps } from "../../oc/shape-ops.js";
 import { Edge } from "../../common/edge.js";
+import { Vertex } from "../../common/vertex.js";
 import { ProjectionOps } from "../../oc/intersection.js";
 import { Wire } from "../../common/wire.js";
 import { ExtrudableGeometryBase } from "./extrudable-base.js";
@@ -14,6 +15,7 @@ export class Projection extends ExtrudableGeometryBase {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         const shapes = this.sourceObjects.flatMap(obj => obj.getShapes());
         const transform = context?.getTransform() ?? null;
+        let lastWire = null;
         console.log('Projection: building with shapes:', shapes.length);
         for (let shape of shapes) {
             if (transform) {
@@ -31,9 +33,16 @@ export class Projection extends ExtrudableGeometryBase {
                 wires = ProjectionOps.projectEdgeOntoPlane(plane, shape);
             }
             for (const wire of wires) {
+                lastWire = wire;
                 this.addShapes(wire.getEdges());
             }
         }
+        if (lastWire) {
+            const localStart = plane.worldToLocal(lastWire.getFirstVertex().toPoint());
+            const localEnd = plane.worldToLocal(lastWire.getLastVertex().toPoint());
+            this.setState('start', Vertex.fromPoint2D(localStart));
+            this.setState('end', Vertex.fromPoint2D(localEnd));
+        }
         for (const obj of this.sourceObjects) {
             obj.removeShapes(this);
         }

package/lib/dist/features/2d/rect.js

@@ -77,41 +77,44 @@ export class Rect extends ExtrudableGeometryBase {
         const [bottomLeftRadius, bottomRightRadius, topRightRadius, topLeftRadius] = radius;
         const bottomLeft = start;
         const topRight = new Point2D(bottomLeft.x + this.width, bottomLeft.y + this.height);
-        const bottomLeftArcCenter = new Point2D(bottomLeft.x + bottomLeftRadius, bottomLeft.y + bottomLeftRadius);
-        const bottomRightArcCenter = new Point2D(topRight.x - bottomRightRadius, bottomLeft.y + bottomRightRadius);
-        const topRightArcCenter = new Point2D(topRight.x - topRightRadius, topRight.y - topRightRadius);
-        const topLeftArcCenter = new Point2D(bottomLeft.x + topLeftRadius, topRight.y - topLeftRadius);
-        const bottomLineStart = new Point2D(bottomLeft.x + bottomLeftRadius, bottomLeft.y);
-        const bottomLineEnd = new Point2D(topRight.x - bottomRightRadius, bottomLeft.y);
-        const rightLineStart = new Point2D(topRight.x, bottomLeft.y + bottomRightRadius);
-        const rightLineEnd = new Point2D(topRight.x, topRight.y - topRightRadius);
-        const topLineStart = new Point2D(topRight.x - topRightRadius, topRight.y);
-        const topLineEnd = new Point2D(bottomLeft.x + topLeftRadius, topRight.y);
-        const leftLineStart = new Point2D(bottomLeft.x, topRight.y - topLeftRadius);
-        const leftLineEnd = new Point2D(bottomLeft.x, bottomLeft.y + bottomLeftRadius);
+        const signW = Math.sign(this.width);
+        const signH = Math.sign(this.height);
+        const bottomLeftArcCenter = new Point2D(bottomLeft.x + bottomLeftRadius * signW, bottomLeft.y + bottomLeftRadius * signH);
+        const bottomRightArcCenter = new Point2D(topRight.x - bottomRightRadius * signW, bottomLeft.y + bottomRightRadius * signH);
+        const topRightArcCenter = new Point2D(topRight.x - topRightRadius * signW, topRight.y - topRightRadius * signH);
+        const topLeftArcCenter = new Point2D(bottomLeft.x + topLeftRadius * signW, topRight.y - topLeftRadius * signH);
+        const bottomLineStart = new Point2D(bottomLeft.x + bottomLeftRadius * signW, bottomLeft.y);
+        const bottomLineEnd = new Point2D(topRight.x - bottomRightRadius * signW, bottomLeft.y);
+        const rightLineStart = new Point2D(topRight.x, bottomLeft.y + bottomRightRadius * signH);
+        const rightLineEnd = new Point2D(topRight.x, topRight.y - topRightRadius * signH);
+        const topLineStart = new Point2D(topRight.x - topRightRadius * signW, topRight.y);
+        const topLineEnd = new Point2D(bottomLeft.x + topLeftRadius * signW, topRight.y);
+        const leftLineStart = new Point2D(bottomLeft.x, topRight.y - topLeftRadius * signH);
+        const leftLineEnd = new Point2D(bottomLeft.x, bottomLeft.y + bottomLeftRadius * signH);
         const localToWorld = plane.localToWorld.bind(plane);
+        const arcNormal = signW * signH < 0 ? plane.normal.negate() : plane.normal;
         const bottomLineSegment = Geometry.makeSegment(localToWorld(bottomLineStart), localToWorld(bottomLineEnd));
         const rightLineSegment = Geometry.makeSegment(localToWorld(rightLineStart), localToWorld(rightLineEnd));
         const topLineSegment = Geometry.makeSegment(localToWorld(topLineStart), localToWorld(topLineEnd));
         const leftLineSegment = Geometry.makeSegment(localToWorld(leftLineStart), localToWorld(leftLineEnd));
         let bottomRightArcEdge = null;
         if (bottomRightRadius > 0) {
-            const arc = Geometry.makeArc(localToWorld(bottomRightArcCenter), bottomRightRadius, plane.normal, localToWorld(bottomLineEnd), localToWorld(rightLineStart));
+            const arc = Geometry.makeArc(localToWorld(bottomRightArcCenter), bottomRightRadius, arcNormal, localToWorld(bottomLineEnd), localToWorld(rightLineStart));
             bottomRightArcEdge = Geometry.makeEdgeFromCurve(arc);
         }
         let topRightArcEdge = null;
         if (topRightRadius > 0) {
-            const arc = Geometry.makeArc(localToWorld(topRightArcCenter), topRightRadius, plane.normal, localToWorld(rightLineEnd), localToWorld(topLineStart));
+            const arc = Geometry.makeArc(localToWorld(topRightArcCenter), topRightRadius, arcNormal, localToWorld(rightLineEnd), localToWorld(topLineStart));
             topRightArcEdge = Geometry.makeEdgeFromCurve(arc);
         }
         let topLeftArcEdge = null;
         if (topLeftRadius > 0) {
-            const arc = Geometry.makeArc(localToWorld(topLeftArcCenter), topLeftRadius, plane.normal, localToWorld(topLineEnd), localToWorld(leftLineStart));
+            const arc = Geometry.makeArc(localToWorld(topLeftArcCenter), topLeftRadius, arcNormal, localToWorld(topLineEnd), localToWorld(leftLineStart));
             topLeftArcEdge = Geometry.makeEdgeFromCurve(arc);
         }
         let bottomLeftArcEdge = null;
         if (bottomLeftRadius > 0) {
-            const arc = Geometry.makeArc(localToWorld(bottomLeftArcCenter), bottomLeftRadius, plane.normal, localToWorld(leftLineEnd), localToWorld(bottomLineStart));
+            const arc = Geometry.makeArc(localToWorld(bottomLeftArcCenter), bottomLeftRadius, arcNormal, localToWorld(leftLineEnd), localToWorld(bottomLineStart));
             bottomLeftArcEdge = Geometry.makeEdgeFromCurve(arc);
         }
         const bottomEdge = Geometry.makeEdge(bottomLineSegment);

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

@@ -3,16 +3,16 @@ export declare class Chamfer extends SceneObject {
     private distance;
     private distance2;
     private isAngle;
-    private _selection;
-    constructor(distance: number, distance2: number, isAngle?: boolean, selection?: SceneObject);
-    get selection(): SceneObject;
+    private _selections;
+    constructor(distance: number, distance2: number, isAngle?: boolean, ...selections: SceneObject[]);
+    get selections(): SceneObject[];
     build(context: BuildSceneObjectContext): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: SceneObject): boolean;
     getType(): string;
     serialize(): {
-        edges: any;
+        edges: any[];
         distance: number;
         distance2: number;
         isAngle: boolean;

package/lib/dist/features/chamfer.js

@@ -6,16 +6,16 @@ export class Chamfer extends SceneObject {
     distance;
     distance2;
     isAngle;
-    _selection = null;
-    constructor(distance, distance2, isAngle = false, selection) {
+    _selections = [];
+    constructor(distance, distance2, isAngle = false, ...selections) {
         super();
         this.distance = distance;
         this.distance2 = distance2;
         this.isAngle = isAngle;
-        this._selection = selection ?? null;
+        this._selections = selections;
     }
-    get selection() {
-        return this._selection;
+    get selections() {
+        return this._selections;
     }
     build(context) {
         let sceneObjects;
@@ -26,8 +26,18 @@ export class Chamfer extends SceneObject {
                 sceneObjects.set(obj, shapes);
             }
         }
-        const allEdgeShapes = this.selection.getShapes();
-        let edges = allEdgeShapes;
+        let edges = [];
+        for (const selection of this.selections) {
+            const allEdgeShapes = selection.getShapes();
+            for (const shape of allEdgeShapes) {
+                if (shape.isEdge()) {
+                    edges.push(shape);
+                }
+                else {
+                    edges.push(...Explorer.findEdgesWrapped(shape));
+                }
+            }
+        }
         const newShapes = [];
         const shapeObjectMap = new Map();
         for (const [obj, shapes] of sceneObjects) {
@@ -82,17 +92,20 @@ export class Chamfer extends SceneObject {
                 continue;
             }
         }
-        this.selection.removeShapes(this);
+        for (const selection of this.selections) {
+            const shapes = selection.getShapes();
+            for (const shape of shapes) {
+                selection.removeShape(shape, this);
+            }
+        }
         this.addShapes(newShapes);
     }
     getDependencies() {
-        return this.selection ? [this.selection] : [];
+        return [...this.selections];
     }
     createCopy(remap) {
-        const selection = this.selection
-            ? (remap.get(this.selection) || this.selection)
-            : undefined;
-        return new Chamfer(this.distance, this.distance2, this.isAngle, selection);
+        const selections = this.selections.map(s => remap.get(s) || s);
+        return new Chamfer(this.distance, this.distance2, this.isAngle, ...selections);
     }
     compareTo(other) {
         if (!(other instanceof Chamfer)) {
@@ -110,9 +123,14 @@ export class Chamfer extends SceneObject {
         if (this.isAngle !== other.isAngle) {
             return false;
         }
-        if (!this.selection.compareTo(other.selection)) {
+        if (this.selections.length !== other.selections.length) {
             return false;
         }
+        for (let i = 0; i < this.selections.length; i++) {
+            if (!this.selections[i].compareTo(other.selections[i])) {
+                return false;
+            }
+        }
         return true;
     }
     getType() {
@@ -120,7 +138,7 @@ export class Chamfer extends SceneObject {
     }
     serialize() {
         return {
-            edges: this.selection.serialize(),
+            edges: this.selections.map(s => s.serialize()),
             distance: this.distance,
             distance2: this.distance2,
             isAngle: this.isAngle

package/lib/dist/features/common2d.js

@@ -2,8 +2,7 @@ import { Wire } from "../common/wire.js";
 import { Edge } from "../common/edge.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
-import { FaceOps } from "../oc/face-ops.js";
-import { WireOps } from "../oc/wire-ops.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
 export class Common2D extends GeometrySceneObject {
     _targetObjects = null;
     _keepOriginal = false;
@@ -38,20 +37,39 @@ export class Common2D extends GeometrySceneObject {
                 }
             }
         }
-        const allEdges = Array.from(sourceEdges.keys()).filter(edge => edge.isClosed());
-        const wires = allEdges.map(edge => WireOps.makeWireFromEdges([edge]));
-        const faces = wires.map(wire => FaceOps.makeFaceWrapped(wire));
+        const plane = this.sketch.getPlane();
+        // Group edges by owner
+        const ownerToEdges = new Map();
+        for (const [edge, owner] of sourceEdges) {
+            if (!ownerToEdges.has(owner)) {
+                ownerToEdges.set(owner, []);
+            }
+            ownerToEdges.get(owner).push(edge);
+        }
+        // Convert each owner's edges to faces via FaceMaker2
+        const faces = [];
+        const processedOwners = new Set();
+        for (const [owner, edges] of ownerToEdges) {
+            const ownerFaces = FaceMaker2.getRegions(edges, plane);
+            if (ownerFaces.length > 0) {
+                faces.push(...ownerFaces);
+                processedOwners.add(owner);
+            }
+        }
+        if (faces.length === 0) {
+            return;
+        }
         const { newShapes } = BooleanOps.common(faces);
         if (newShapes.length === 0) {
             return;
         }
         const newEdges = newShapes.flatMap((face) => face.getEdges());
         if (!this._keepOriginal) {
-            for (const [wire, owner] of sourceEdges) {
-                if (!allEdges.includes(wire)) {
+            for (const [edge, owner] of sourceEdges) {
+                if (!processedOwners.has(owner)) {
                     continue;
                 }
-                owner.removeShape(wire, this);
+                owner.removeShape(edge, this);
             }
         }
         this.addShapes(newEdges);

package/lib/dist/features/fuse2d.js

@@ -2,8 +2,7 @@ import { Wire } from "../common/wire.js";
 import { Edge } from "../common/edge.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
-import { WireOps } from "../oc/wire-ops.js";
-import { FaceOps } from "../oc/face-ops.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
 export class Fuse2D extends GeometrySceneObject {
     _targetObjects = null;
     constructor(...targets) {
@@ -33,16 +32,35 @@ export class Fuse2D extends GeometrySceneObject {
                 }
             }
         }
-        const allEdges = Array.from(sourceEdges.keys()).filter(edge => edge.isClosed());
-        const wires = allEdges.map(edge => WireOps.makeWireFromEdges([edge]));
-        const faces = wires.map(wire => FaceOps.makeFaceWrapped(wire));
+        const plane = this.sketch.getPlane();
+        // Group edges by owner
+        const ownerToEdges = new Map();
+        for (const [edge, owner] of sourceEdges) {
+            if (!ownerToEdges.has(owner)) {
+                ownerToEdges.set(owner, []);
+            }
+            ownerToEdges.get(owner).push(edge);
+        }
+        // Convert each owner's edges to faces via FaceMaker2
+        const faces = [];
+        const processedOwners = new Set();
+        for (const [owner, edges] of ownerToEdges) {
+            const ownerFaces = FaceMaker2.getRegions(edges, plane);
+            if (ownerFaces.length > 0) {
+                faces.push(...ownerFaces);
+                processedOwners.add(owner);
+            }
+        }
+        if (faces.length === 0) {
+            return;
+        }
         const { newShapes } = BooleanOps.fuseFaces(faces);
         if (newShapes.length === 0) {
             return;
         }
         const newEdges = newShapes.flatMap((face) => face.getEdges());
         for (const [edge, owner] of sourceEdges) {
-            if (!allEdges.includes(edge)) {
+            if (!processedOwners.has(owner)) {
                 continue;
             }
             owner.removeShape(edge, this);

package/lib/dist/features/repeat-matrix.d.ts

@@ -0,0 +1,14 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { Matrix4 } from "../math/matrix4.js";
+export declare class RepeatMatrix extends SceneObject {
+    private _matrix;
+    targetObjects: SceneObject[];
+    constructor(_matrix: Matrix4, targetObjects: SceneObject[]);
+    getTransformMatrix(): Matrix4 | null;
+    isContainer(): boolean;
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: RepeatMatrix): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {};
+}

package/lib/dist/features/repeat-matrix.js

@@ -0,0 +1,41 @@
+import { SceneObject } from "../common/scene-object.js";
+export class RepeatMatrix extends SceneObject {
+    _matrix;
+    targetObjects;
+    constructor(_matrix, targetObjects) {
+        super();
+        this._matrix = _matrix;
+        this.targetObjects = targetObjects;
+        this.setAlwaysVisible();
+    }
+    getTransformMatrix() {
+        return this._matrix;
+    }
+    isContainer() {
+        return true;
+    }
+    build(context) {
+        this.saveShapesSnapshot(context);
+    }
+    compareTo(other) {
+        if (!(other instanceof RepeatMatrix)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this._matrix.equals(other._matrix)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "repeat-matrix";
+    }
+    getUniqueType() {
+        return "repeat-matrix";
+    }
+    serialize() {
+        return {};
+    }
+}

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

@@ -15,6 +15,7 @@ export declare class SelectSceneObject extends SceneObject implements ISelect {
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     transform(matrix: Matrix4): SelectSceneObject;
+    private injectScopeFaces;
     applyFilters(shapes: Shape[], filters: FilterBuilderBase<Shape>[]): Shape[];
     compareTo(other: SelectSceneObject): boolean;
     shapeType(): string;

package/lib/dist/features/select.js

@@ -1,6 +1,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";
 export class SelectSceneObject extends SceneObject {
     filters;
     constraintObject;
@@ -32,6 +33,9 @@ export class SelectSceneObject extends SceneObject {
             }
         }
         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);
@@ -64,6 +68,21 @@ export class SelectSceneObject extends SceneObject {
         console.log('SelectSceneObject: transform applied to selection filters.', mirroredFilters);
         return new SelectSceneObject(mirroredFilters, this.constraintObject);
     }
+    injectScopeFaces(filters, sceneObjects) {
+        let scopeFaces = null;
+        for (const builder of filters) {
+            for (const filter of builder.getFilters()) {
+                if (filter instanceof BelongsToFaceFilter || filter instanceof NotBelongsToFaceFilter) {
+                    if (!scopeFaces) {
+                        scopeFaces = this.constraintObject
+                            ? this.constraintObject.getShapes().flatMap(s => s.getSubShapes("face"))
+                            : sceneObjects.flatMap(obj => obj.getShapes({}, 'solid').flatMap(s => s.getSubShapes("face")));
+                    }
+                    filter.setScopeFaces(scopeFaces);
+                }
+            }
+        }
+    }
     applyFilters(shapes, filters) {
         const shapeFilter = new ShapeFilter(shapes, ...filters);
         return shapeFilter.apply();

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

@@ -0,0 +1,14 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+export declare class Subtract2D extends GeometrySceneObject {
+    target1: GeometrySceneObject;
+    target2: GeometrySceneObject;
+    constructor(target1: GeometrySceneObject, target2: GeometrySceneObject);
+    private collectEdges;
+    build(context: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Subtract2D): boolean;
+    getType(): string;
+    serialize(): {};
+}