fluidcad 0.0.30 → 0.0.32

package/lib/dist/features/subtract.js

@@ -3,6 +3,7 @@ import { BooleanOps } from "../oc/boolean-ops.js";
 import { Explorer } from "../oc/explorer.js";
 import { ShapeOps } from "../oc/shape-ops.js";
 import { Solid } from "../common/shapes.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Subtract extends SceneObject {
     solid1;
     solid2;
@@ -11,6 +12,10 @@ export class Subtract extends SceneObject {
         this.solid1 = solid1;
         this.solid2 = solid2;
     }
+    validate() {
+        requireShapes(this.solid1, "first operand", "subtract");
+        requireShapes(this.solid2, "second operand", "subtract");
+    }
     build(context) {
         const p = context.getProfiler();
         const stock = this.solid1.getShapes();

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

@@ -4,6 +4,7 @@ export declare class Subtract2D extends GeometrySceneObject {
     target1: GeometrySceneObject;
     target2: GeometrySceneObject;
     constructor(target1: GeometrySceneObject, target2: GeometrySceneObject);
+    validate(): void;
     private collectEdges;
     build(context: BuildSceneObjectContext): void;
     getDependencies(): SceneObject[];

package/lib/dist/features/subtract2d.js

@@ -6,6 +6,7 @@ import { BooleanOps } from "../oc/boolean-ops.js";
 import { ShapeOps } from "../oc/shape-ops.js";
 import { Explorer } from "../oc/explorer.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Subtract2D extends GeometrySceneObject {
     target1;
     target2;
@@ -14,6 +15,10 @@ export class Subtract2D extends GeometrySceneObject {
         this.target1 = target1;
         this.target2 = target2;
     }
+    validate() {
+        requireShapes(this.target1, "first operand", "subtract2d");
+        requireShapes(this.target2, "second operand", "subtract2d");
+    }
     collectEdges(target) {
         const edges = new Map();
         for (const shape of target.getShapes()) {

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

@@ -6,6 +6,7 @@ export declare class Sweep extends ExtrudeBase implements ISweep {
     private _path;
     constructor(path: SceneObject, extrudable?: Extrudable);
     get path(): SceneObject;
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     /** Plain sweep: classify by inner-wire detection on the start face. */
     private buildSweep;

package/lib/dist/features/sweep.js

@@ -5,6 +5,7 @@ import { FaceMaker2 } from "../oc/face-maker2.js";
 import { ExtrudeBase } from "./extrude-base.js";
 import { cutWithSceneObjects } from "../helpers/scene-helpers.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Sweep extends ExtrudeBase {
     _path;
     constructor(path, extrudable) {
@@ -14,6 +15,9 @@ export class Sweep extends ExtrudeBase {
     get path() {
         return this._path;
     }
+    validate() {
+        requireShapes(this._path, "path", "sweep");
+    }
     build(context) {
         const p = context.getProfiler();
         const plane = this.extrudable.getPlane();

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

@@ -8,6 +8,7 @@ export declare class Translate extends SceneObject {
     constructor(amount: LazyVertex, copy?: boolean, ...targets: SceneObject[]);
     get targetObjects(): SceneObject[];
     exclude(...objects: SceneObject[]): this;
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;

package/lib/dist/features/translate.js

@@ -1,6 +1,7 @@
 import { SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
 import { ShapeOps } from "../oc/shape-ops.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Translate extends SceneObject {
     amount;
     copy;
@@ -19,6 +20,14 @@ export class Translate 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}`, "translate");
+        }
+    }
     build(context) {
         let objects = this.targetObjects || context.getSceneObjects();
         if (this._excludedObjects.length > 0) {

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

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

package/lib/dist/filters/face/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";
+function getBoundaryPoints(face) {
+    return face.getEdges().flatMap(edge => [
+        EdgeOps.getVertexPoint(EdgeOps.getFirstVertex(edge)),
+        EdgeOps.getVertexPoint(EdgeOps.getLastVertex(edge)),
+    ]);
+}
+export class AboveFacePlaneFilter extends FilterBase {
+    plane;
+    partial;
+    constructor(plane, partial = false) {
+        super();
+        this.plane = plane;
+        this.partial = partial;
+    }
+    match(shape) {
+        const plane = this.plane.getPlane();
+        const flags = getBoundaryPoints(shape).map(p => plane.signedDistanceToPoint(p) > 0);
+        if (flags.length === 0) {
+            return false;
+        }
+        return this.partial ? flags.some(Boolean) : flags.every(Boolean);
+    }
+    compareTo(other) {
+        return this.plane.compareTo(other.plane) && this.partial === other.partial;
+    }
+    transform(matrix) {
+        const transformedPlane = this.plane.getPlane().applyMatrix(matrix);
+        return new AboveFacePlaneFilter(new PlaneObject(transformedPlane), this.partial);
+    }
+}
+export class BelowFacePlaneFilter extends FilterBase {
+    plane;
+    partial;
+    constructor(plane, partial = false) {
+        super();
+        this.plane = plane;
+        this.partial = partial;
+    }
+    match(shape) {
+        const plane = this.plane.getPlane();
+        const flags = getBoundaryPoints(shape).map(p => plane.signedDistanceToPoint(p) < 0);
+        if (flags.length === 0) {
+            return false;
+        }
+        return this.partial ? flags.some(Boolean) : flags.every(Boolean);
+    }
+    compareTo(other) {
+        return this.plane.compareTo(other.plane) && this.partial === other.partial;
+    }
+    transform(matrix) {
+        const transformedPlane = this.plane.getPlane().applyMatrix(matrix);
+        return new BelowFacePlaneFilter(new PlaneObject(transformedPlane), this.partial);
+    }
+}

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

@@ -70,6 +70,14 @@ export declare class FaceFilterBuilder extends FilterBuilderBase<Face> {
      * @param minorRadius - Optional radius of the tube itself.
      */
     notTorus(majorRadius?: number, minorRadius?: number): this;
+    /**
+     * Selects planar (flat) faces.
+     */
+    planar(): this;
+    /**
+     * Excludes planar (flat) faces.
+     */
+    notPlanar(): this;
     /**
      * Selects conical faces.
      */
@@ -119,6 +127,24 @@ export declare class FaceFilterBuilder extends FilterBuilderBase<Face> {
      * @param count - The number of edges to exclude.
      */
     notEdgeCount(count: number): 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: PlaneLike | PlaneObjectBase, offsetOrOptions?: number | {
+        offset?: number;
+        partial?: boolean;
+    }): 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: PlaneLike | PlaneObjectBase, offsetOrOptions?: number | {
+        offset?: number;
+        partial?: boolean;
+    }): 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/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.d.ts

@@ -8,8 +8,8 @@ export declare class BooleanOps {
     static cutShapes(shape: Shape, tool: Shape): Shape;
     static cutShapesRaw(shape: TopoDS_Shape, tool: TopoDS_Shape): TopoDS_Shape;
     static cutMultiShape(stocks: Shape[], tools: Shape[], plane?: Plane, cutDistance?: number): {
-        result: Solid | Face | Edge | import("../common/wire.js").Wire;
-        modified: (shape: Shape) => (Solid | Face | Edge | import("../common/wire.js").Wire)[];
+        result: Edge | import("../common/wire.js").Wire | Solid | Face;
+        modified: (shape: Shape) => (Edge | import("../common/wire.js").Wire | Solid | Face)[];
         sectionEdges: Edge[];
         startEdges: Edge[];
         endEdges: Edge[];

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/edge-ops.d.ts

@@ -35,4 +35,21 @@ export declare class EdgeOps {
     static findNearestEdgeIndex(edges: Edge[], point: Point, tolerance?: number): number;
     static findNearestEdgeIndices(edges: Edge[], point: Point, tolerance?: number): number[];
     static isClosed(edge: Edge): boolean;
+    /**
+     * Removes coincident edges from an edge set and splits any pairs that
+     * intersect, while preserving each input edge's original boundaries.
+     *
+     * Uses OCCT's General Fuse: it splits inputs at mutual intersections and
+     * detects same-domain (coincident) pieces, keeping a single representative
+     * per group. `SimplifyResult` is intentionally not called — its
+     * edge-unification step concatenates tangent-continuous chains (line + arc
+     * fillets, etc.) into single BSpline curves, which destroys the per-edge
+     * structure callers need for downstream filter/trim operations.
+     *
+     * `fuzzy` overrides the matching tolerance — defaults to a value loose enough
+     * to absorb the vertex-tolerance drift produced by `BRepAlgo_NormalProjection`
+     * on coincident edges from independent face projections.
+     */
+    static unifyCoincident(edges: Edge[], fuzzy?: number): Edge[];
+    static unifyCoincidentRaw(edges: TopoDS_Edge[], fuzzy?: number): TopoDS_Edge[];
 }

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

@@ -320,4 +320,64 @@ export class EdgeOps {
         adaptor.delete();
         return closed;
     }
+    /**
+     * Removes coincident edges from an edge set and splits any pairs that
+     * intersect, while preserving each input edge's original boundaries.
+     *
+     * Uses OCCT's General Fuse: it splits inputs at mutual intersections and
+     * detects same-domain (coincident) pieces, keeping a single representative
+     * per group. `SimplifyResult` is intentionally not called — its
+     * edge-unification step concatenates tangent-continuous chains (line + arc
+     * fillets, etc.) into single BSpline curves, which destroys the per-edge
+     * structure callers need for downstream filter/trim operations.
+     *
+     * `fuzzy` overrides the matching tolerance — defaults to a value loose enough
+     * to absorb the vertex-tolerance drift produced by `BRepAlgo_NormalProjection`
+     * on coincident edges from independent face projections.
+     */
+    static unifyCoincident(edges, fuzzy) {
+        const raw = edges.map(e => e.getShape());
+        const unique = EdgeOps.unifyCoincidentRaw(raw, fuzzy);
+        return unique.map(e => Edge.fromTopoDSEdge(e));
+    }
+    static unifyCoincidentRaw(edges, fuzzy) {
+        const oc = getOC();
+        // Filter out degenerate edges (e.g. projection of an edge parallel to the
+        // projection direction collapses to zero length). These confuse the fuse.
+        const live = edges.filter(e => !oc.BRep_Tool.Degenerated(e));
+        if (live.length <= 1) {
+            return live;
+        }
+        const fuzzValue = fuzzy ?? Math.max(oc.Precision.Confusion() * 100, 1e-6);
+        const args = new oc.TopTools_ListOfShape();
+        let builder = null;
+        let progress = null;
+        try {
+            for (const e of live) {
+                args.Append(e);
+            }
+            builder = new oc.BRepAlgoAPI_BuilderAlgo();
+            builder.SetArguments(args);
+            builder.SetNonDestructive(true);
+            builder.SetFuzzyValue(fuzzValue);
+            progress = new oc.Message_ProgressRange();
+            builder.Build(progress);
+            const result = builder.Shape();
+            const unique = Explorer.findShapes(result, oc.TopAbs_ShapeEnum.TopAbs_EDGE).map(s => oc.TopoDS.Edge(s));
+            return unique;
+        }
+        catch (err) {
+            console.error('EdgeOps.unifyCoincidentRaw failed, falling back to input edges:', err);
+            return live;
+        }
+        finally {
+            args.delete();
+            if (builder) {
+                builder.delete();
+            }
+            if (progress) {
+                progress.delete();
+            }
+        }
+    }
 }

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;