fluidcad 0.0.31 → 0.0.32

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

@@ -5,6 +5,7 @@ import { ConeFilter, NotConeFilter } from "./cone-filter.js";
 import { CylinderCurveFilter, NotCylinderCurveFilter } from "./cylinder-curve.js";
 import { CylinderFilter, NotCylinderFilter } from "./cylinder.js";
 import { TorusFilter, NotTorusFilter } from "./torus-filter.js";
+import { PlanarFilter, NotPlanarFilter } from "./planar-filter.js";
 import { NotOnPlaneFilter, OnPlaneFilter } from "./on-plane.js";
 import { NotParallelFilter, ParallelFilter } from "./parallel.js";
 import { PlaneObject } from "../../features/plane.js";
@@ -15,6 +16,7 @@ import { HasEdgeFromSceneObjectFilter, NotHasEdgeFromSceneObjectFilter } from ".
 import { FromSceneObjectFilter } from "../from-object.js";
 import { EdgeCountFilter, NotEdgeCountFilter } from "./edge-count.js";
 import { IntersectsWithFilter, NotIntersectsWithFilter } from "./intersects-with.js";
+import { AboveFacePlaneFilter, BelowFacePlaneFilter } from "./above-below.js";
 import { SceneObject } from "../../common/scene-object.js";
 export class FaceFilterBuilder extends FilterBuilderBase {
     constructor() {
@@ -204,6 +206,22 @@ export class FaceFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects planar (flat) faces.
+     */
+    planar() {
+        const filter = new PlanarFilter();
+        this.filters.push(filter);
+        return this;
+    }
+    /**
+     * Excludes planar (flat) faces.
+     */
+    notPlanar() {
+        const filter = new NotPlanarFilter();
+        this.filters.push(filter);
+        return this;
+    }
     /**
      * Selects conical faces.
      */
@@ -306,6 +324,52 @@ export class FaceFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects faces 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 AboveFacePlaneFilter(planeObj, partial);
+        this.filters.push(filter);
+        return this;
+    }
+    /**
+     * Selects faces 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 BelowFacePlaneFilter(planeObj, partial);
+        this.filters.push(filter);
+        return this;
+    }
     /**
      * Restricts the selection to faces originating from the given scene objects.
      * Recursive: passing a container picks up faces from its descendants.

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

@@ -0,0 +1,15 @@
+import { Matrix4 } from "../../math/matrix4.js";
+import { Face } from "../../common/shapes.js";
+import { FilterBase } from "../filter-base.js";
+export declare class PlanarFilter extends FilterBase<Face> {
+    constructor();
+    match(shape: Face): boolean;
+    compareTo(other: PlanarFilter): boolean;
+    transform(matrix: Matrix4): PlanarFilter;
+}
+export declare class NotPlanarFilter extends FilterBase<Face> {
+    constructor();
+    match(shape: Face): boolean;
+    compareTo(other: NotPlanarFilter): boolean;
+    transform(matrix: Matrix4): NotPlanarFilter;
+}

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

@@ -0,0 +1,30 @@
+import { FilterBase } from "../filter-base.js";
+import { FaceQuery } from "../../oc/face-query.js";
+export class PlanarFilter extends FilterBase {
+    constructor() {
+        super();
+    }
+    match(shape) {
+        return FaceQuery.isPlanarFace(shape);
+    }
+    compareTo(other) {
+        return true;
+    }
+    transform(matrix) {
+        return new PlanarFilter();
+    }
+}
+export class NotPlanarFilter extends FilterBase {
+    constructor() {
+        super();
+    }
+    match(shape) {
+        return !FaceQuery.isPlanarFace(shape);
+    }
+    compareTo(other) {
+        return true;
+    }
+    transform(matrix) {
+        return new NotPlanarFilter();
+    }
+}

package/lib/dist/filters/from-object.d.ts

@@ -7,6 +7,7 @@ export declare class FromSceneObjectFilter<TShape extends Shape> extends FilterB
     private sceneObjects;
     private shapeType;
     constructor(sceneObjects: SceneObject[], shapeType: ShapeType);
+    getSceneObjects(): SceneObject[];
     match(shape: TShape): boolean;
     compareTo(other: FromSceneObjectFilter<TShape>): boolean;
     transform(_matrix: Matrix4): FromSceneObjectFilter<TShape>;

package/lib/dist/filters/from-object.js

@@ -7,6 +7,9 @@ export class FromSceneObjectFilter extends FilterBase {
         this.sceneObjects = sceneObjects;
         this.shapeType = shapeType;
     }
+    getSceneObjects() {
+        return this.sceneObjects;
+    }
     match(shape) {
         for (const obj of this.sceneObjects) {
             const subShapes = obj.getShapes().flatMap(s => s.getSubShapes(this.shapeType));

package/lib/dist/oc/boolean-ops.js

@@ -168,10 +168,15 @@ export class BooleanOps {
         else if (opts?.glue === 'shift') {
             builder.SetGlue(oc.BOPAlgo_GlueEnum.BOPAlgo_GlueShift);
         }
+        // Wrap all stocks in a single compound argument. OCC's pave-filling step
+        // computes intersections between distinct arguments — so two touching
+        // stocks passed as separate args end up merged with each other even when
+        // the tool doesn't touch them. Bundling them under one TopoDS_Compound
+        // keeps stock-to-stock relationships out of the result; only stock↔tool
+        // interactions are computed.
+        const stockCompound = ShapeOps.makeCompoundRaw(stock.map(s => s.getShape()));
         const stockList = new oc.TopTools_ListOfShape();
-        for (const s of stock) {
-            stockList.Append(s.getShape());
-        }
+        stockList.Append(stockCompound);
         const toolList = new oc.TopTools_ListOfShape();
         for (const t of tools) {
             toolList.Append(t.getShape());

package/lib/dist/oc/face-maker2.d.ts

@@ -6,5 +6,13 @@ export declare class FaceMaker2 {
     static getRegions(shapes: Array<Wire | Edge>, plane: Plane, drill?: boolean): Face[];
     private static getDrilledFaces;
     private static getFaces;
+    /**
+     * Sizes the bounded plane face used by `getFaces`'s splitter so it always
+     * encloses the input edges with margin. The default ±1000 face used to
+     * silently swallow sketches placed far from origin: edges that crossed the
+     * boundary produced regions touching `boundaryEdges`, which the filter at
+     * the end of `getFaces` then dropped — leaving an extrude with zero faces.
+     */
+    private static computePlaneFaceBounds;
     private static getSplitEdges;
 }

package/lib/dist/oc/face-maker2.js

@@ -1,4 +1,5 @@
 import { Edge } from "../common/edge.js";
+import { Point } from "../math/point.js";
 import { Explorer } from "./explorer.js";
 import { getOC } from "./init.js";
 import { Convert } from "./convert.js";
@@ -67,7 +68,7 @@ export class FaceMaker2 {
     static getFaces(edges, plane) {
         const [gpPln, dispose] = Convert.toGpPln(plane);
         const oc = getOC();
-        const planeFace = FaceOps.makeFaceFromPlane2(gpPln);
+        const planeFace = FaceOps.makeFaceFromPlane2(gpPln, this.computePlaneFaceBounds(edges, plane));
         // Collect boundary edges of the big face before splitting
         const boundaryEdges = Explorer.findShapes(planeFace, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
         const splitter = new oc.BRepAlgoAPI_Splitter();
@@ -108,6 +109,46 @@ export class FaceMaker2 {
         dispose();
         return filtered.map(f => Face.fromTopoDSFace(oc.TopoDS.Face(f)));
     }
+    /**
+     * Sizes the bounded plane face used by `getFaces`'s splitter so it always
+     * encloses the input edges with margin. The default ±1000 face used to
+     * silently swallow sketches placed far from origin: edges that crossed the
+     * boundary produced regions touching `boundaryEdges`, which the filter at
+     * the end of `getFaces` then dropped — leaving an extrude with zero faces.
+     */
+    static computePlaneFaceBounds(edges, plane) {
+        let uMin = Infinity, uMax = -Infinity, vMin = Infinity, vMax = -Infinity;
+        for (const edge of edges) {
+            const bbox = ShapeOps.getBoundingBox(edge);
+            const corners = [
+                new Point(bbox.minX, bbox.minY, bbox.minZ),
+                new Point(bbox.maxX, bbox.minY, bbox.minZ),
+                new Point(bbox.minX, bbox.maxY, bbox.minZ),
+                new Point(bbox.maxX, bbox.maxY, bbox.minZ),
+                new Point(bbox.minX, bbox.minY, bbox.maxZ),
+                new Point(bbox.maxX, bbox.minY, bbox.maxZ),
+                new Point(bbox.minX, bbox.maxY, bbox.maxZ),
+                new Point(bbox.maxX, bbox.maxY, bbox.maxZ),
+            ];
+            for (const c of corners) {
+                const uv = plane.worldToLocal(c);
+                if (uv.x < uMin) {
+                    uMin = uv.x;
+                }
+                if (uv.x > uMax) {
+                    uMax = uv.x;
+                }
+                if (uv.y < vMin) {
+                    vMin = uv.y;
+                }
+                if (uv.y > vMax) {
+                    vMax = uv.y;
+                }
+            }
+        }
+        const half = Math.max(Math.abs(uMin), Math.abs(uMax), Math.abs(vMin), Math.abs(vMax), 1000) * 1.5;
+        return { uMin: -half, uMax: half, vMin: -half, vMax: half };
+    }
     static getSplitEdges(shapes) {
         const oc = getOC();
         console.log('Getting split edges for shapes:', shapes.length);

package/lib/dist/oc/face-ops.d.ts

@@ -20,7 +20,12 @@ export declare class FaceOps {
     static fixFaceOrientation(face: Face | TopoDS_Face): Face;
     static makeFaceWithHoles(outerWire: Wire, holes: Wire[]): Face;
     static isPointInsideFace(point: Point, face: Face | TopoDS_Face): boolean;
-    static makeFaceFromPlane2(plane: gp_Pln): TopoDS_Face;
+    static makeFaceFromPlane2(plane: gp_Pln, bounds?: {
+        uMin: number;
+        uMax: number;
+        vMin: number;
+        vMax: number;
+    }): TopoDS_Face;
     static makeFaceFromPlane(plane: gp_Pln): TopoDS_Face;
     static makeFaceFromCylinder(cylinder: gp_Cylinder): TopoDS_Face;
     static planeToFace(plane: Plane, center?: Point): Face;

package/lib/dist/oc/face-ops.js

@@ -197,9 +197,10 @@ export class FaceOps {
         disposePnt();
         return isInside;
     }
-    static makeFaceFromPlane2(plane) {
+    static makeFaceFromPlane2(plane, bounds) {
         const oc = getOC();
-        const faceMaker = new oc.BRepBuilderAPI_MakeFace(plane, -1000, 1000, -1000, 1000);
+        const b = bounds ?? { uMin: -1000, uMax: 1000, vMin: -1000, vMax: 1000 };
+        const faceMaker = new oc.BRepBuilderAPI_MakeFace(plane, b.uMin, b.uMax, b.vMin, b.vMax);
         const face = faceMaker.Face();
         faceMaker.delete();
         return face;

package/lib/dist/oc/face-query.js

@@ -346,8 +346,8 @@ export class FaceQuery {
         let bestFace = null;
         let bestDistance = mode === 'first' ? Infinity : -Infinity;
         for (const face of faces) {
-            const distance = plane.distanceToPoint(face.center());
-            if (distance < tolerance) {
+            const distance = plane.signedDistanceToPoint(face.center());
+            if (distance <= tolerance) {
                 continue;
             }
             if (mode === 'first' ? distance < bestDistance : distance > bestDistance) {

package/lib/dist/tests/features/cut.test.js

@@ -78,6 +78,46 @@ describe("cut", () => {
             // Circle edges at top and bottom of the hole
             expect(getEdgesByType(solid, "circle").length).toBeGreaterThanOrEqual(2);
         });
+        it("should apply draft to a through-all cut", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([50, 50]);
+                circle(40);
+            });
+            cut().draft(-5);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            // Drafted through-all cut: hole wall is a cone, not a cylinder
+            expect(getFacesByType(solid, "cone").length).toBeGreaterThanOrEqual(1);
+            expect(getFacesByType(solid, "cylinder")).toHaveLength(0);
+        });
+        it("should apply draft to a through-all cut on a small profile", () => {
+            // Mirrors the user's repro: small radius (1.5) and steep draft (-8°).
+            // With THROUGH_ALL_LENGTH=100000, lateral draft = 100000 * tan(8°) ≈ 14054
+            // would invert a 1.5-radius profile if applied over the full prism length.
+            sketch("xy", () => {
+                rect(7, 5).centered();
+            });
+            const e = extrude(1.5);
+            sketch(e.endFaces(), () => {
+                circle(1.5);
+            });
+            cut().draft(-8);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            // Drafted through-all cut: hole wall is a cone, not a cylinder
+            expect(getFacesByType(solid, "cone").length).toBeGreaterThanOrEqual(1);
+            expect(getFacesByType(solid, "cylinder")).toHaveLength(0);
+        });
     });
     describe("section edges", () => {
         it("should expose section edges", () => {

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

@@ -121,6 +121,58 @@ describe("extrude to face", () => {
             expect(lastBBox.maxZ).toBeGreaterThan(firstBBox.maxZ);
         });
     });
+    describe("first-face / last-face with filters", () => {
+        it("should narrow the candidate set with a face filter", () => {
+            // Cylinder at origin and a planar slab nearby. Without a filter,
+            // 'first-face' would pick the slab's top (at z=20). The cylinder
+            // filter forces selection of the cylindrical side face (z=40).
+            cylinder(50, 80);
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(50, 50);
+            });
+            extrude(20).new();
+            sketch("xy", () => {
+                move([200, 100]);
+                rect(30, 30);
+            });
+            const e = extrude("first-face", face().cylinder());
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should record an error when the filter eliminates all candidate faces", () => {
+            // Scene contains only planar geometry — cylinder filter matches nothing
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(50, 50);
+            });
+            extrude(30).new();
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e = extrude("first-face", face().cylinder());
+            render();
+            expect(e.getError()).toMatch(/No face found for 'first-face' extrusion/);
+        });
+        it("should accept a filter together with an explicit target", () => {
+            cylinder(50, 80);
+            const target = sketch("xy", () => {
+                move([200, 100]);
+                rect(20, 20);
+            });
+            // Some other sketch in scope so the sketch context is non-trivial.
+            sketch("xy", () => {
+                rect(10, 10);
+            });
+            const e = extrude("first-face", face().cylinder(), target);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+    });
     describe("non-parallel planar face", () => {
         it("should extrude up to a drafted side face", () => {
             // Create a box with drafted sides — side faces are inclined planes

package/lib/dist/tests/features/extrude.test.js

@@ -84,6 +84,27 @@ describe("extrude", () => {
             const scene = render();
             expect(countShapes(scene)).toBe(2);
         });
+        it("should only fuse with scene objects the new extrusion actually touches", () => {
+            // C1: cylinder at origin, z = 0..50
+            sketch("top", () => {
+                circle(50);
+            });
+            const e = extrude(50);
+            // C2: cylinder stacked on C1, z = 50..100, kept as a separate scene object
+            sketch(e.endFaces(), () => {
+                circle(50);
+            });
+            extrude(50).new();
+            // C3: cylinder at [100, 0] radius 50, externally tangent to C1, doesn't touch C2 at all
+            sketch("top", () => {
+                circle([100, 0], 50);
+            });
+            extrude();
+            const scene = render();
+            // C1 and C2 must remain separate solids — the third extrude should not
+            // pull them into a fusion with each other.
+            expect(countShapes(scene)).toBe(3);
+        });
     });
     describe("startFaces / endFaces", () => {
         it("should expose start face", () => {
@@ -259,6 +280,25 @@ describe("extrude", () => {
             expect(bbox.minZ).toBeCloseTo(0, 0);
             expect(bbox.maxZ).toBeCloseTo(30, 0);
         });
+        it("reverse-direction extrude classifies side/internal faces correctly", () => {
+            sketch("xy", () => {
+                rect(7, 5).centered();
+            });
+            const e = extrude(-1.5);
+            const sf = e.sideFaces();
+            const inf = e.internalFaces();
+            const se = e.sideEdges();
+            const ine = e.internalEdges();
+            addToScene(sf);
+            addToScene(inf);
+            addToScene(se);
+            addToScene(ine);
+            render();
+            expect(sf.getShapes()).toHaveLength(4);
+            expect(inf.getShapes()).toHaveLength(0);
+            expect(se.getShapes()).toHaveLength(4);
+            expect(ine.getShapes()).toHaveLength(0);
+        });
     });
     describe("startEdges / endEdges", () => {
         it("should expose start edges", () => {
@@ -446,17 +486,15 @@ describe("extrude", () => {
         it("should not include guide shapes in getShapes()", () => {
             sketch("xy", () => {
                 rect(100, 50);
+                circle([50, 25], 20).guide();
             });
-            const e = extrude(30).guide();
+            const e = extrude(30);
             render();
+            // The guide circle is excluded from the extrusion — the result is a
+            // plain box (6 faces), not a box with a circular hole (8 faces).
             const shapes = e.getShapes();
-            expect(shapes).toHaveLength(0);
-            // All added shapes should be marked as guide
-            const allShapes = e.getAddedShapes();
-            expect(allShapes.length).toBeGreaterThan(0);
-            for (const shape of allShapes) {
-                expect(shape.isGuideShape()).toBe(true);
-            }
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getFaces()).toHaveLength(6);
         });
         it("should include meta shapes when filter is disabled", () => {
             sketch("xy", () => {

package/lib/dist/tests/features/select.test.js

@@ -7,6 +7,7 @@ import cylinder from "../../core/cylinder.js";
 import fillet from "../../core/fillet.js";
 import { circle, move, rect } from "../../core/2d/index.js";
 import { face, edge } from "../../filters/index.js";
+import part from "../../core/part.js";
 describe("select", () => {
     setupOC();
     describe("face filters", () => {
@@ -227,6 +228,30 @@ describe("select", () => {
                 expect(sel.getShapes()).toHaveLength(3);
             });
         });
+        describe("planar / notPlanar", () => {
+            it("should select planar faces from a drafted extrusion", () => {
+                sketch("xy", () => {
+                    circle(60);
+                });
+                extrude(50).draft(10);
+                const sel = select(face().planar());
+                render();
+                // Drafted cylinder: top + bottom flat circles are planar (1 cone side is not)
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(2);
+            });
+            it("should exclude planar faces", () => {
+                sketch("xy", () => {
+                    circle(60);
+                });
+                extrude(50).draft(10);
+                const sel = select(face().notPlanar());
+                render();
+                // Only the conical side face is non-planar
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(1);
+            });
+        });
         describe("cone / notCone", () => {
             it("should select conical faces from a drafted extrusion", () => {
                 sketch("xy", () => {
@@ -251,6 +276,72 @@ describe("select", () => {
                 expect(shapes).toHaveLength(2);
             });
         });
+        describe("above / below", () => {
+            it("should select faces entirely above a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Faces above z=15: only the top face (all verts at z=30) qualifies.
+                // Side faces have 2 verts at z=0 (not above), so they don't match.
+                const sel = select(face().above("xy", { offset: 15 }));
+                render();
+                expect(sel.getShapes()).toHaveLength(1);
+            });
+            it("should select faces entirely below a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Faces below z=15: only the bottom face (all verts at z=0) qualifies.
+                const sel = select(face().below("xy", { offset: 15 }));
+                render();
+                expect(sel.getShapes()).toHaveLength(1);
+            });
+            it("should not match faces on the plane itself", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Faces above z=0: bottom face is ON the plane (dist=0), not above.
+                // Side faces straddle (2 verts on plane). Only top face qualifies.
+                const sel = select(face().above("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(1);
+            });
+            it("should select partially above faces", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // partial: true — match faces with at least one vertex above z=0.
+                // Top face + 4 side faces (each has 2 verts at z=30) = 5.
+                const sel = select(face().above("xy", { partial: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(5);
+            });
+            it("should select partially below faces", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // partial: true — match faces with at least one vertex below z=30.
+                // Bottom face + 4 side faces (each has 2 verts at z=0) = 5.
+                const sel = select(face().below("xy", { offset: 30, partial: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(5);
+            });
+            it("should return empty when no faces match", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Nothing is below z=0 on a box sitting on XY.
+                const sel = select(face().below("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(0);
+            });
+        });
     });
     describe("edge filters", () => {
         describe("onPlane / notOnPlane", () => {
@@ -834,4 +925,54 @@ describe("select", () => {
             });
         });
     });
+    describe("cross-part selection", () => {
+        it("should select faces from another part via from()", () => {
+            const p1 = part("p1", () => {
+                cylinder(50, 100);
+            });
+            let sel;
+            part("p2", () => {
+                sel = select(face().from(p1));
+            });
+            render();
+            // A cylinder has 3 faces (top, bottom, lateral)
+            expect(sel.getShapes()).toHaveLength(3);
+        });
+        it("should narrow cross-part selection by additional filters", () => {
+            const p1 = part("p1", () => {
+                cylinder(50, 100);
+            });
+            let sel;
+            part("p2", () => {
+                sel = select(face().cylinder().from(p1));
+            });
+            render();
+            // Only the lateral cylindrical face
+            expect(sel.getShapes()).toHaveLength(1);
+        });
+        it("should select edges from another part via edge().from()", () => {
+            const p1 = part("p1", () => {
+                cylinder(50, 100);
+            });
+            let sel;
+            part("p2", () => {
+                sel = select(edge().from(p1));
+            });
+            render();
+            // A cylinder has 3 edges (top circle, bottom circle, seam)
+            expect(sel.getShapes()).toHaveLength(3);
+        });
+        it("should narrow cross-part edge selection by additional filters", () => {
+            const p1 = part("p1", () => {
+                cylinder(50, 100);
+            });
+            let sel;
+            part("p2", () => {
+                sel = select(edge().circle().from(p1));
+            });
+            render();
+            // The two circular edges (top + bottom) — seam is excluded
+            expect(sel.getShapes()).toHaveLength(2);
+        });
+    });
 });