fluidcad 0.0.22 → 0.0.24

package/lib/dist/core/trim.d.ts

@@ -1,13 +1,20 @@
 import { Point2DLike } from "../math/point.js";
-import { ISceneObject } from "./interfaces.js";
+import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+interface ITrim {
+    /**
+     * Enters interactive trimming mode, optionally trimming edges at the given points.
+     * @param points - Points where geometry should be trimmed; the nearest edge segment to each point is removed.
+     */
+    pick(...points: Point2DLike[]): ITrim;
+}
 interface TrimFunction {
     /** Trims all sketch geometry segments. */
-    (): ISceneObject;
+    (): ITrim;
     /**
-     * Trims sketch geometry segments at the given points.
-     * @param points - The points where geometry should be trimmed
+     * Trims sketch geometry segments matching the given edge filters.
+     * @param filters - Edge filters that select which edges to remove
      */
-    (...points: Point2DLike[]): ISceneObject;
+    (...filters: EdgeFilterBuilder[]): ITrim;
 }
 declare const _default: TrimFunction;
 export default _default;

package/lib/dist/core/trim.js

@@ -9,10 +9,15 @@ function build(context) {
         }
         const trim2d = new Trim2D();
         if (args.length > 0) {
-            trim2d.points(...args.map(p => normalizePoint2D(p)));
+            trim2d.setFilters(...args);
         }
         context.addSceneObject(trim2d);
-        return trim2d;
+        return {
+            pick(...points) {
+                trim2d.pick(...points.map(p => normalizePoint2D(p)));
+                return this;
+            },
+        };
     };
 }
 export default registerBuilder(build);

package/lib/dist/features/2d/sketch.d.ts

@@ -18,7 +18,6 @@ export declare class Sketch extends SceneObject implements Extrudable {
     build(context?: BuildSceneObjectContext): void;
     getEdges(): Edge[];
     getEdgesWithOwner(): Map<Edge, GeometrySceneObject>;
-    getAllEdges(): Edge[];
     getGeometriesWithOwner(): Map<Edge, GeometrySceneObject>;
     getGeometries(): Edge[];
     getDependencies(): SceneObject[];

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

@@ -83,16 +83,31 @@ export class Sketch extends SceneObject {
         const source = this.getCloneSource();
         const transform = context?.getTransform();
         if (source instanceof Sketch && transform) {
-            const originalEdges = source.getAllEdges();
-            const transformedEdges = originalEdges.map(edge => ShapeOps.transform(edge, transform));
-            this.setState('cloned-edges', transformedEdges);
+            const sourceChildren = source.getChildren();
+            const clonedChildren = this.getChildren();
+            for (let i = 0; i < sourceChildren.length; i++) {
+                const sourceChild = sourceChildren[i];
+                const clonedChild = clonedChildren[i];
+                if (!clonedChild) {
+                    continue;
+                }
+                const shapes = sourceChild.getAddedShapes();
+                const removedShapes = sourceChild.getRemovedShapes();
+                for (const shape of shapes) {
+                    if (shape.isMetaShape() || shape.isGuideShape()) {
+                        continue;
+                    }
+                    const isRemovedBySibling = removedShapes.some(s => s.shape === shape && s.removedBy?.parentId === source.id);
+                    if (isRemovedBySibling) {
+                        continue;
+                    }
+                    const transformed = ShapeOps.transform(shape, transform);
+                    clonedChild.addShape(transformed);
+                }
+            }
         }
     }
     getEdges() {
-        const clonedEdges = this.getState('cloned-edges');
-        if (clonedEdges) {
-            return clonedEdges;
-        }
         return [...this.getEdgesWithOwner().keys()];
     }
     getEdgesWithOwner() {
@@ -113,32 +128,6 @@ export class Sketch extends SceneObject {
         }
         return result;
     }
-    getAllEdges() {
-        const children = this.getChildren();
-        const result = [];
-        for (const child of children) {
-            const shapes = child.getAddedShapes();
-            const removedShapes = child.getRemovedShapes();
-            for (const shape of shapes) {
-                if (shape.isMetaShape() || shape.isGuideShape()) {
-                    continue;
-                }
-                const isRemovedBySibling = removedShapes.some(s => s.shape === shape && s.removedBy?.parentId === this.id);
-                if (isRemovedBySibling) {
-                    continue;
-                }
-                if (shape instanceof Edge) {
-                    result.push(shape);
-                }
-                else if (shape instanceof Wire) {
-                    for (const edge of shape.getEdges()) {
-                        result.push(edge);
-                    }
-                }
-            }
-        }
-        return result;
-    }
     getGeometriesWithOwner() {
         return this.getEdgesWithOwner();
     }

package/lib/dist/features/extrude-base.js

@@ -339,6 +339,7 @@ export class ExtrudeBase extends SceneObject {
         this._picking = other._picking;
         this._pickPoints = other._pickPoints;
         this._thin = other._thin;
+        this._drill = other._drill;
         return this;
     }
     /**

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

@@ -4,6 +4,8 @@ export declare class Remove extends SceneObject {
     constructor(objects: SceneObject[]);
     build(): void;
     compareTo(other: Remove): boolean;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     getType(): string;
     serialize(): {};
 }

package/lib/dist/features/remove.js

@@ -24,6 +24,13 @@ export class Remove extends SceneObject {
         }
         return true;
     }
+    getDependencies() {
+        return this.objects;
+    }
+    createCopy(remap) {
+        const remappedObjects = this.objects.map(obj => remap.get(obj) || obj);
+        return new Remove(remappedObjects);
+    }
     getType() {
         return 'remove';
     }

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

@@ -1,15 +1,27 @@
 import { SceneObject } from "../common/scene-object.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
 import { LazyVertex } from "./lazy-vertex.js";
+import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
 export declare class Trim2D extends GeometrySceneObject {
-    private _points;
+    private _filters;
+    private _picking;
+    private _pickPoints;
     constructor();
-    points(...ps: LazyVertex[]): this;
-    get trimPoints(): LazyVertex[];
+    setFilters(...fs: EdgeFilterBuilder[]): this;
+    pick(...ps: LazyVertex[]): this;
+    isPicking(): boolean;
+    getPickPoints(): LazyVertex[];
+    get filters(): EdgeFilterBuilder[];
     build(): void;
+    private buildWithFilters;
+    private buildWithPicking;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Trim2D): boolean;
     getType(): string;
-    serialize(): {};
+    serialize(): {
+        trigger: "trim-picking";
+        picking: true;
+        pickPoints: number[][];
+    };
 }

package/lib/dist/features/trim2d.js

@@ -2,22 +2,35 @@ import { Wire } from "../common/wire.js";
 import { Edge } from "../common/edge.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
 import { EdgeOps } from "../oc/edge-ops.js";
+import { ShapeFilter } from "../filters/filter.js";
 export class Trim2D extends GeometrySceneObject {
-    _points = [];
+    _filters = [];
+    _picking = false;
+    _pickPoints = [];
     constructor() {
         super();
     }
-    points(...ps) {
-        this._points = ps;
+    setFilters(...fs) {
+        this._filters = fs;
         return this;
     }
-    get trimPoints() {
-        return this._points;
+    pick(...ps) {
+        this._picking = true;
+        this._pickPoints = ps;
+        return this;
+    }
+    isPicking() {
+        return this._picking;
+    }
+    getPickPoints() {
+        return this._pickPoints;
+    }
+    get filters() {
+        return this._filters;
     }
     build() {
         const plane = this.sketch.getPlane();
         const sourceWires = this.sketch.getGeometriesWithOwner();
-        // Collect all individual edges from wires/edges in the sketch
         const allEdges = [];
         const edgeToOwner = new Map();
         for (const [wireOrEdge, owner] of sourceWires) {
@@ -35,25 +48,49 @@ export class Trim2D extends GeometrySceneObject {
         if (allEdges.length === 0) {
             return;
         }
+        if (this._filters.length > 0) {
+            this.buildWithFilters(allEdges, edgeToOwner);
+        }
+        if (this._picking) {
+            let pickableEdges;
+            if (this._filters.length > 0) {
+                const matched = new Set(new ShapeFilter(allEdges, ...this._filters).apply());
+                pickableEdges = allEdges.filter(e => !matched.has(e));
+            }
+            else {
+                pickableEdges = allEdges;
+            }
+            this.buildWithPicking(pickableEdges, edgeToOwner, plane);
+        }
+    }
+    buildWithFilters(allEdges, edgeToOwner) {
+        const matchedEdges = new ShapeFilter(allEdges, ...this._filters).apply();
+        const removedWires = new Set();
+        for (const edge of matchedEdges) {
+            const entry = edgeToOwner.get(edge);
+            if (!removedWires.has(entry.wire)) {
+                removedWires.add(entry.wire);
+                entry.owner.removeShape(entry.wire, this);
+            }
+        }
+    }
+    buildWithPicking(pickableEdges, edgeToOwner, plane) {
         const TRIM_TOLERANCE = 50;
-        // Split all edges at intersection points
-        const splitResult = EdgeOps.splitEdgesWithMapping(allEdges);
+        const splitResult = EdgeOps.splitEdgesWithMapping(pickableEdges);
         const splitEdges = splitResult.edges;
         const sourceIndex = splitResult.sourceIndex;
-        // Find split edges to remove
         const splitEdgesToRemove = new Set();
-        if (this._points.length > 0) {
-            for (const lazyPoint of this._points) {
+        if (this._pickPoints.length > 0) {
+            for (const lazyPoint of this._pickPoints) {
                 const point2d = lazyPoint.asPoint2D();
                 const point3d = plane.localToWorld(point2d);
                 for (const idx of EdgeOps.findNearestEdgeIndices(splitEdges, point3d, TRIM_TOLERANCE)) {
                     splitEdgesToRemove.add(idx);
                 }
             }
-            // Remove affected original wires and re-add surviving split edges
             const removedWires = new Set();
             for (const idx of splitEdgesToRemove) {
-                const origEdge = allEdges[sourceIndex[idx]];
+                const origEdge = pickableEdges[sourceIndex[idx]];
                 const entry = edgeToOwner.get(origEdge);
                 if (!removedWires.has(entry.wire)) {
                     removedWires.add(entry.wire);
@@ -64,7 +101,7 @@ export class Trim2D extends GeometrySceneObject {
                 if (splitEdgesToRemove.has(i)) {
                     continue;
                 }
-                const origEdge = allEdges[sourceIndex[i]];
+                const origEdge = pickableEdges[sourceIndex[i]];
                 const entry = edgeToOwner.get(origEdge);
                 if (removedWires.has(entry.wire)) {
                     this.addShape(splitEdges[i]);
@@ -72,11 +109,8 @@ export class Trim2D extends GeometrySceneObject {
             }
         }
         // --- Meta shapes for segment-level hover ---
-        // Originals with trims need the first-pass split (to preserve trim boundaries).
-        // Originals without trims are re-split against only surviving edges
-        // (so ghost intersections from fully-removed edges disappear).
         const origSurvives = new Set();
-        const origHasTrim = new Array(allEdges.length).fill(false);
+        const origHasTrim = new Array(pickableEdges.length).fill(false);
         for (let i = 0; i < splitEdges.length; i++) {
             if (!splitEdgesToRemove.has(i)) {
                 origSurvives.add(sourceIndex[i]);
@@ -85,17 +119,15 @@ export class Trim2D extends GeometrySceneObject {
                 origHasTrim[sourceIndex[i]] = true;
             }
         }
-        // Re-split only surviving originals (for clean meta shapes of untrimmed edges)
         const metaInputEdges = [];
         const metaInputToOrig = [];
-        for (let i = 0; i < allEdges.length; i++) {
+        for (let i = 0; i < pickableEdges.length; i++) {
             if (origSurvives.has(i)) {
-                metaInputEdges.push(allEdges[i]);
+                metaInputEdges.push(pickableEdges[i]);
                 metaInputToOrig.push(i);
             }
         }
         const metaSplit = EdgeOps.splitEdgesWithMapping(metaInputEdges);
-        // Untrimmed originals: use re-split result (clean, no ghost intersections)
         for (let i = 0; i < metaSplit.edges.length; i++) {
             const origIdx = metaInputToOrig[metaSplit.sourceIndex[i]];
             if (origHasTrim[origIdx]) {
@@ -105,7 +137,6 @@ export class Trim2D extends GeometrySceneObject {
             metaEdge.markAsMetaShape('trim');
             this.addShape(metaEdge);
         }
-        // Trimmed originals: use first-pass surviving split edges (preserve boundaries)
         for (let i = 0; i < splitEdges.length; i++) {
             if (splitEdgesToRemove.has(i)) {
                 continue;
@@ -123,8 +154,11 @@ export class Trim2D extends GeometrySceneObject {
     }
     createCopy(remap) {
         const copy = new Trim2D();
-        if (this._points.length > 0) {
-            copy.points(...this._points);
+        if (this._filters.length > 0) {
+            copy.setFilters(...this._filters);
+        }
+        if (this._picking) {
+            copy.pick(...this._pickPoints);
         }
         return copy;
     }
@@ -135,11 +169,22 @@ export class Trim2D extends GeometrySceneObject {
         if (!super.compareTo(other)) {
             return false;
         }
-        if (this._points.length !== other._points.length) {
+        if (this._filters.length !== other._filters.length) {
+            return false;
+        }
+        for (let i = 0; i < this._filters.length; i++) {
+            if (!this._filters[i].equals(other._filters[i])) {
+                return false;
+            }
+        }
+        if (this._picking !== other._picking) {
+            return false;
+        }
+        if (this._pickPoints.length !== other._pickPoints.length) {
             return false;
         }
-        for (let i = 0; i < this._points.length; i++) {
-            if (!this._points[i].compareTo(other._points[i])) {
+        for (let i = 0; i < this._pickPoints.length; i++) {
+            if (!this._pickPoints[i].compareTo(other._pickPoints[i])) {
                 return false;
             }
         }
@@ -149,6 +194,12 @@ export class Trim2D extends GeometrySceneObject {
         return "trim2d";
     }
     serialize() {
-        return {};
+        return {
+            trigger: 'trim-picking',
+            picking: this._picking || undefined,
+            pickPoints: this._picking
+                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
+                : undefined,
+        };
     }
 }

package/lib/dist/filters/edge/above-below.d.ts

@@ -0,0 +1,20 @@
+import { Matrix4 } from "../../math/matrix4.js";
+import { Edge } from "../../common/shapes.js";
+import { FilterBase } from "../filter-base.js";
+import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
+export declare class AbovePlaneFilter extends FilterBase<Edge> {
+    private plane;
+    private partial;
+    constructor(plane: PlaneObjectBase, partial?: boolean);
+    match(shape: Edge): boolean;
+    compareTo(other: AbovePlaneFilter): boolean;
+    transform(matrix: Matrix4): AbovePlaneFilter;
+}
+export declare class BelowPlaneFilter extends FilterBase<Edge> {
+    private plane;
+    private partial;
+    constructor(plane: PlaneObjectBase, partial?: boolean);
+    match(shape: Edge): boolean;
+    compareTo(other: BelowPlaneFilter): boolean;
+    transform(matrix: Matrix4): BelowPlaneFilter;
+}

package/lib/dist/filters/edge/above-below.js

@@ -0,0 +1,57 @@
+import { FilterBase } from "../filter-base.js";
+import { EdgeOps } from "../../oc/edge-ops.js";
+import { PlaneObject } from "../../features/plane.js";
+export class AbovePlaneFilter extends FilterBase {
+    plane;
+    partial;
+    constructor(plane, partial = false) {
+        super();
+        this.plane = plane;
+        this.partial = partial;
+    }
+    match(shape) {
+        const plane = this.plane.getPlane();
+        const firstPoint = EdgeOps.getVertexPoint(EdgeOps.getFirstVertex(shape));
+        const lastPoint = EdgeOps.getVertexPoint(EdgeOps.getLastVertex(shape));
+        const firstAbove = plane.signedDistanceToPoint(firstPoint) > 0;
+        const lastAbove = plane.signedDistanceToPoint(lastPoint) > 0;
+        if (this.partial) {
+            return firstAbove || lastAbove;
+        }
+        return firstAbove && lastAbove;
+    }
+    compareTo(other) {
+        return this.plane.compareTo(other.plane) && this.partial === other.partial;
+    }
+    transform(matrix) {
+        const transformedPlane = this.plane.getPlane().applyMatrix(matrix);
+        return new AbovePlaneFilter(new PlaneObject(transformedPlane), this.partial);
+    }
+}
+export class BelowPlaneFilter extends FilterBase {
+    plane;
+    partial;
+    constructor(plane, partial = false) {
+        super();
+        this.plane = plane;
+        this.partial = partial;
+    }
+    match(shape) {
+        const plane = this.plane.getPlane();
+        const firstPoint = EdgeOps.getVertexPoint(EdgeOps.getFirstVertex(shape));
+        const lastPoint = EdgeOps.getVertexPoint(EdgeOps.getLastVertex(shape));
+        const firstBelow = plane.signedDistanceToPoint(firstPoint) < 0;
+        const lastBelow = plane.signedDistanceToPoint(lastPoint) < 0;
+        if (this.partial) {
+            return firstBelow || lastBelow;
+        }
+        return firstBelow && lastBelow;
+    }
+    compareTo(other) {
+        return this.plane.compareTo(other.plane) && this.partial === other.partial;
+    }
+    transform(matrix) {
+        const transformedPlane = this.plane.getPlane().applyMatrix(matrix);
+        return new BelowPlaneFilter(new PlaneObject(transformedPlane), this.partial);
+    }
+}

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

@@ -8,17 +8,23 @@ export declare class EdgeFilterBuilder extends FilterBuilderBase<Edge> {
     /**
      * Selects edges that lie on the given plane.
      * @param plane - The reference plane.
-     * @param offset - Optional distance to offset the plane before matching.
-     * @param bothDirections - When true, also matches the plane offset in the opposite direction.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset`, `bothDirections`, and `partial`.
      */
-    onPlane(plane: PlaneLike | PlaneObjectBase, offset?: number, bothDirections?: boolean): this;
+    onPlane(plane: PlaneLike | PlaneObjectBase, offsetOrOptions?: number | {
+        offset?: number;
+        bothDirections?: boolean;
+        partial?: boolean;
+    }): this;
     /**
      * Excludes edges that lie on the given plane.
      * @param plane - The reference plane.
-     * @param offset - Optional distance to offset the plane before matching.
-     * @param bothDirections - When true, also excludes the plane offset in the opposite direction.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset`, `bothDirections`, and `partial`.
      */
-    notOnPlane(plane: PlaneLike | PlaneObjectBase, offset?: number, bothDirections?: boolean): this;
+    notOnPlane(plane: PlaneLike | PlaneObjectBase, offsetOrOptions?: number | {
+        offset?: number;
+        bothDirections?: boolean;
+        partial?: boolean;
+    }): this;
     /**
      * Selects edges that are parallel to the given plane.
      * @param plane - The reference plane.
@@ -89,5 +95,33 @@ export declare class EdgeFilterBuilder extends FilterBuilderBase<Edge> {
      * @param faceFilters - One or more face filter builders to match against.
      */
     notBelongsToFace(...faceFilters: FilterBuilderBase<Face>[]): this;
+    /**
+     * Selects edges that geometrically intersect with edges of the given scene object.
+     * @param sceneObject - A scene object whose edges are tested for intersection.
+     */
+    intersectsWith(sceneObject: ISceneObject): this;
+    /**
+     * Excludes edges that geometrically intersect with edges of the given scene object.
+     * @param sceneObject - A scene object whose edges are tested for intersection.
+     */
+    notIntersectsWith(sceneObject: ISceneObject): this;
+    /**
+     * Selects edges that are entirely above the given plane (in the direction of its normal).
+     * @param plane - The reference plane.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset` and `partial`.
+     */
+    above(plane: PlaneLike | PlaneObjectBase, offsetOrOptions?: number | {
+        offset?: number;
+        partial?: boolean;
+    }): this;
+    /**
+     * Selects edges that are entirely below the given plane (opposite to its normal direction).
+     * @param plane - The reference plane.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset` and `partial`.
+     */
+    below(plane: PlaneLike | PlaneObjectBase, offsetOrOptions?: number | {
+        offset?: number;
+        partial?: boolean;
+    }): this;
     static build(): EdgeFilterBuilder;
 }

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

@@ -11,6 +11,8 @@ import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
 import { AtIndexFilter, NotAtIndexFilter } from "./at-index.js";
 import { BelongsToFaceFilter, NotBelongsToFaceFilter } from "./belongs-to-face.js";
 import { BelongsToFaceFromSceneObjectFilter, NotBelongsToFaceFromSceneObjectFilter } from "./belongs-to-object.js";
+import { IntersectsWithFilter, NotIntersectsWithFilter } from "./intersects-with.js";
+import { AbovePlaneFilter, BelowPlaneFilter } from "./above-below.js";
 import { SceneObject } from "../../common/scene-object.js";
 export class EdgeFilterBuilder extends FilterBuilderBase {
     constructor() {
@@ -43,13 +45,14 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
     /**
      * Selects edges that lie on the given plane.
      * @param plane - The reference plane.
-     * @param offset - Optional distance to offset the plane before matching.
-     * @param bothDirections - When true, also matches the plane offset in the opposite direction.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset`, `bothDirections`, and `partial`.
      */
-    onPlane(plane, offset = 0, bothDirections = false) {
+    onPlane(plane, offsetOrOptions) {
         if (!plane) {
             throw new Error('Plane is required');
         }
+        const opts = typeof offsetOrOptions === 'number' ? { offset: offsetOrOptions } : (offsetOrOptions ?? {});
+        const { offset = 0, bothDirections = false, partial = false } = opts;
         let planeObj;
         let planeObj2;
         if (plane instanceof PlaneObjectBase) {
@@ -67,20 +70,21 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
                 planeObj = new PlaneObject(normalized);
             }
         }
-        const filter = new OnPlaneFilter(planeObj, planeObj2);
+        const filter = new OnPlaneFilter(planeObj, planeObj2, partial);
         this.filters.push(filter);
         return this;
     }
     /**
      * Excludes edges that lie on the given plane.
      * @param plane - The reference plane.
-     * @param offset - Optional distance to offset the plane before matching.
-     * @param bothDirections - When true, also excludes the plane offset in the opposite direction.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset`, `bothDirections`, and `partial`.
      */
-    notOnPlane(plane, offset = 0, bothDirections = false) {
+    notOnPlane(plane, offsetOrOptions) {
         if (!plane) {
             throw new Error('Plane is required');
         }
+        const opts = typeof offsetOrOptions === 'number' ? { offset: offsetOrOptions } : (offsetOrOptions ?? {});
+        const { offset = 0, bothDirections = false, partial = false } = opts;
         let planeObj;
         let planeObj2;
         if (plane instanceof PlaneObjectBase) {
@@ -98,7 +102,7 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
                 planeObj = new PlaneObject(normalized);
             }
         }
-        const filter = new NotOnPlaneFilter(planeObj, planeObj2);
+        const filter = new NotOnPlaneFilter(planeObj, planeObj2, partial);
         this.filters.push(filter);
         return this;
     }
@@ -262,6 +266,70 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
         }
         return this;
     }
+    /**
+     * Selects edges that geometrically intersect with edges of the given scene object.
+     * @param sceneObject - A scene object whose edges are tested for intersection.
+     */
+    intersectsWith(sceneObject) {
+        const filter = new IntersectsWithFilter(sceneObject);
+        this.filters.push(filter);
+        return this;
+    }
+    /**
+     * Excludes edges that geometrically intersect with edges of the given scene object.
+     * @param sceneObject - A scene object whose edges are tested for intersection.
+     */
+    notIntersectsWith(sceneObject) {
+        const filter = new NotIntersectsWithFilter(sceneObject);
+        this.filters.push(filter);
+        return this;
+    }
+    /**
+     * Selects edges that are entirely above the given plane (in the direction of its normal).
+     * @param plane - The reference plane.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset` and `partial`.
+     */
+    above(plane, offsetOrOptions) {
+        if (!plane) {
+            throw new Error('Plane is required');
+        }
+        const opts = typeof offsetOrOptions === 'number' ? { offset: offsetOrOptions } : (offsetOrOptions ?? {});
+        const { offset = 0, partial = false } = opts;
+        let planeObj;
+        if (plane instanceof PlaneObjectBase) {
+            planeObj = plane;
+        }
+        else {
+            let normalized = normalizePlane(plane);
+            planeObj = offset ? new PlaneObject(normalized.offset(offset)) : new PlaneObject(normalized);
+        }
+        const filter = new AbovePlaneFilter(planeObj, partial);
+        this.filters.push(filter);
+        return this;
+    }
+    /**
+     * Selects edges that are entirely below the given plane (opposite to its normal direction).
+     * @param plane - The reference plane.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset` and `partial`.
+     */
+    below(plane, offsetOrOptions) {
+        if (!plane) {
+            throw new Error('Plane is required');
+        }
+        const opts = typeof offsetOrOptions === 'number' ? { offset: offsetOrOptions } : (offsetOrOptions ?? {});
+        const { offset = 0, partial = false } = opts;
+        let planeObj;
+        if (plane instanceof PlaneObjectBase) {
+            planeObj = plane;
+        }
+        else {
+            let normalized = normalizePlane(plane);
+            planeObj = offset ? new PlaneObject(normalized.offset(offset)) : new PlaneObject(normalized);
+        }
+        const filter = new BelowPlaneFilter(planeObj, partial);
+        this.filters.push(filter);
+        return this;
+    }
     static build() {
         return new EdgeFilterBuilder();
     }