fluidcad 0.0.31 → 0.0.33

package/lib/dist/common/scene-object.d.ts

@@ -59,6 +59,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     constructor();
     get id(): string;
     get parentId(): string | null;
+    inheritIdentityFrom(other: SceneObject): void;
     private setParent;
     protected setAlwaysVisible(): void;
     isAlwaysVisible(): boolean;
@@ -150,6 +151,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     setOrder(order: number): void;
     getOrder(): number;
     getName(): string;
+    hasCustomName(): boolean;
     name(value: string): this;
     guide(): this;
     reusable(): this;

package/lib/dist/common/scene-object.js

@@ -36,6 +36,9 @@ export class SceneObject {
     get parentId() {
         return this._parent?.id || null;
     }
+    inheritIdentityFrom(other) {
+        this._id = other._id;
+    }
     setParent(parent) {
         this._parent = parent;
     }
@@ -452,6 +455,9 @@ export class SceneObject {
     getName() {
         return this._name ?? this.getType();
     }
+    hasCustomName() {
+        return this._name !== null;
+    }
     name(value) {
         this._name = value;
         return this;

package/lib/dist/common/solid.d.ts

@@ -1,4 +1,4 @@
-import type { TopoDS_Edge, TopoDS_Face, TopoDS_Solid } from "occjs-wrapper";
+import type { TopoDS_Edge, TopoDS_Face, TopoDS_Solid, TopTools_IndexedDataMapOfShapeListOfShape } from "occjs-wrapper";
 import { ShapeType } from "./shape-type.js";
 import { Shape } from "./shape.js";
 import { Face } from "./face.js";
@@ -6,6 +6,7 @@ import { Edge } from "./edge.js";
 export declare class Solid extends Shape<TopoDS_Solid> {
     private faces;
     private edges;
+    private edgeToFacesIndex;
     constructor(solid: TopoDS_Solid);
     getType(): ShapeType;
     isSolid(): boolean;
@@ -15,6 +16,8 @@ export declare class Solid extends Shape<TopoDS_Solid> {
     getFace(face: TopoDS_Face): Face | null;
     hasFace(face: TopoDS_Face): boolean;
     hasEdge(edge: TopoDS_Edge): TopoDS_Edge;
+    getEdgeToFacesIndex(): TopTools_IndexedDataMapOfShapeListOfShape;
+    dispose(): void;
     copy(): Shape;
     static fromTopoDSSolid(solid: TopoDS_Solid): Solid;
 }

package/lib/dist/common/solid.js

@@ -1,8 +1,10 @@
 import { Explorer } from "../oc/explorer.js";
+import { TopologyIndex } from "../oc/topology-index.js";
 import { Shape } from "./shape.js";
 export class Solid extends Shape {
     faces = null;
     edges = null;
+    edgeToFacesIndex = null;
     constructor(solid) {
         super(solid);
     }
@@ -59,6 +61,17 @@ export class Solid extends Shape {
         }
         return null;
     }
+    getEdgeToFacesIndex() {
+        if (!this.edgeToFacesIndex) {
+            this.edgeToFacesIndex = TopologyIndex.buildEdgeToFaces(this.getShape());
+        }
+        return this.edgeToFacesIndex;
+    }
+    dispose() {
+        this.edgeToFacesIndex?.delete();
+        this.edgeToFacesIndex = null;
+        super.dispose();
+    }
     copy() {
         const copied = new Solid(this.getShape());
         for (const entry of this.colorMap) {

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

@@ -1,4 +1,5 @@
 import { IExtrude, ISceneObject } from "./interfaces.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 interface ExtrudeFunction {
     /**
      * Extrudes the last sketch with a default distance.
@@ -33,15 +34,27 @@ interface ExtrudeFunction {
     /**
      * Extrudes up to the first intersecting face.
      * @param face - The literal `'first-face'`
-     * @param target - The sketch or face-bearing scene object to extrude
+     * @param filters - Optional face filters to narrow the candidate set
+     */
+    (face: 'first-face', ...filters: FaceFilterBuilder[]): IExtrude;
+    /**
+     * Extrudes up to the first intersecting face.
+     * @param face - The literal `'first-face'`
+     * @param filtersAndTarget - Optional face filters followed by the target to extrude
      */
-    (face: 'first-face', target?: ISceneObject): IExtrude;
+    (face: 'first-face', ...filtersAndTarget: [...FaceFilterBuilder[], ISceneObject]): IExtrude;
     /**
      * Extrudes up to the last intersecting face.
      * @param face - The literal `'last-face'`
-     * @param target - The sketch or face-bearing scene object to extrude
+     * @param filters - Optional face filters to narrow the candidate set
+     */
+    (face: 'last-face', ...filters: FaceFilterBuilder[]): IExtrude;
+    /**
+     * Extrudes up to the last intersecting face.
+     * @param face - The literal `'last-face'`
+     * @param filtersAndTarget - Optional face filters followed by the target to extrude
      */
-    (face: 'last-face', target?: ISceneObject): IExtrude;
+    (face: 'last-face', ...filtersAndTarget: [...FaceFilterBuilder[], ISceneObject]): IExtrude;
 }
 declare const _default: ExtrudeFunction;
 export default _default;

package/lib/dist/core/extrude.js

@@ -4,6 +4,7 @@ import { Extrude } from "../features/extrude.js";
 import { ExtrudeTwoDistances } from "../features/extrude-two-distances.js";
 import { ExtrudeToFace } from "../features/extrude-to-face.js";
 import { SelectSceneObject } from "../features/select.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 function isExtrudable(obj) {
     return obj instanceof SceneObject && obj.isExtrudable();
 }
@@ -25,16 +26,17 @@ function build(context) {
         if (params.length === 0) {
             return new Extrude(defaultDistance, extrudable);
         }
+        if (params[0] === 'first-face' || params[0] === 'last-face') {
+            const rest = params.slice(1);
+            if (!rest.every(a => a instanceof FaceFilterBuilder)) {
+                throw new Error("Invalid parameter for extrude function.");
+            }
+            return new ExtrudeToFace(params[0], extrudable, rest);
+        }
         if (params.length === 1) {
             if (typeof params[0] === 'number') {
                 return new Extrude(params[0], extrudable);
             }
-            else if (params[0] === 'first-face') {
-                return new ExtrudeToFace('first-face', extrudable);
-            }
-            else if (params[0] === 'last-face') {
-                return new ExtrudeToFace('last-face', extrudable);
-            }
             else if (params[0] instanceof SceneObject) {
                 context.addSceneObject(params[0]);
                 return new ExtrudeToFace(params[0], extrudable);

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

@@ -1,4 +1,4 @@
-export type { ISceneObject, ITransformable, IBooleanOperation, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft } from "./interfaces.js";
+export type { ISceneObject, ITransformable, IBooleanOperation, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft, IRib } from "./interfaces.js";
 export { default as axis } from "./axis.js";
 export { default as local } from "./local.js";
 export { default as plane } from "./plane.js";
@@ -23,6 +23,7 @@ export { default as repeat } from "./repeat.js";
 export { default as load } from "./load.js";
 export { default as loft } from "./loft.js";
 export { default as sweep } from "./sweep.js";
+export { default as rib } from "./rib.js";
 export { default as color } from "./color.js";
 export { default as draft } from "./draft.js";
 export { default as remove } from "./remove.js";

package/lib/dist/core/index.js

@@ -22,6 +22,7 @@ export { default as repeat } from "./repeat.js";
 export { default as load } from "./load.js";
 export { default as loft } from "./loft.js";
 export { default as sweep } from "./sweep.js";
+export { default as rib } from "./rib.js";
 export { default as color } from "./color.js";
 export { default as draft } from "./draft.js";
 export { default as remove } from "./remove.js";

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

@@ -11,11 +11,6 @@ export interface ISceneObject {
      * @param value - The display name to assign.
      */
     name(value: string): this;
-    /**
-     * Marks this object as construction geometry. Guide objects are excluded from
-     * final geometry output unless explicitly included.
-     */
-    guide(): this;
     /**
      * Marks this object as reusable. Reusable objects retain their shapes when
      * consumed by features (e.g., extrude, revolve), allowing multiple features
@@ -24,6 +19,25 @@ export interface ISceneObject {
      */
     reusable(): this;
 }
+export interface ILoadFile extends ISceneObject {
+    /**
+     * Skip applying colors from the imported file's color metadata sidecar.
+     */
+    noColors(): this;
+    /**
+     * Keep only the solids at the given 0-based indices (in load order).
+     * Combined with {@link exclude} by applying include first, then exclude.
+     * Repeated calls accumulate.
+     * @param indices - The 0-based solid indices to keep.
+     */
+    include(...indices: number[]): this;
+    /**
+     * Drop the solids at the given 0-based indices. Applied after {@link include}.
+     * Repeated calls accumulate.
+     * @param indices - The 0-based solid indices to drop.
+     */
+    exclude(...indices: number[]): this;
+}
 export interface IBooleanOperation extends ISceneObject {
     /**
      * Additive boolean operation — fuses the result with all intersecting scene objects.
@@ -107,6 +121,12 @@ export interface IAxis extends ISceneObject {
 export interface ISelect extends ISceneObject {
 }
 export interface IGeometry extends ISceneObject {
+    /**
+     * Marks this sketch geometry as construction geometry. Guide geometries are
+     * excluded from the final sketch output (e.g., extrude, revolve) unless
+     * explicitly included.
+     */
+    guide(): this;
     /**
      * Returns a lazy-evaluated vertex at the start point of this geometry element.
      */
@@ -665,6 +685,15 @@ export interface IMirror extends IBooleanOperation {
      */
     exclude(...objects: ISceneObject[]): this;
 }
+export interface IMirror2D extends IGeometry {
+    /**
+     * Excludes the given sketch geometries from the mirror operation. Useful
+     * when mirroring "everything" but a few specific geometries should be
+     * skipped, or when narrowing an explicit target list.
+     * @param objects - The sketch geometries to exclude from mirroring.
+     */
+    exclude(...objects: ISceneObject[]): this;
+}
 export interface ITranslate extends ISceneObject {
     /**
      * Excludes the given objects from the translate operation. Useful when
@@ -685,6 +714,63 @@ export interface IRotate extends ISceneObject {
 }
 export interface IDraft extends ISceneObject {
 }
+export interface IRib extends IBooleanOperation {
+    /**
+     * Selects faces at the start (base) of the rib — the profile face at the sketch plane.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    startFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects faces at the end (top) of the rib — where the rib meets the boundary.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    endFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects the lateral wall faces of the rib.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    sideFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects the small cap faces at the spine endpoints.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    capFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the start faces.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    startEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the end faces.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    endEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the side faces, excluding edges shared with start/end faces.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    sideEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the cap faces.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Applies a draft (taper) angle to the rib walls.
+     * @param value - A single angle for uniform draft, or a `[start, end]` tuple for asymmetric draft.
+     */
+    draft(value: number | [number, number]): this;
+    /**
+     * Switches the extrusion direction to parallel to the sketch plane
+     * (perpendicular to the spine within the plane) instead of normal to it.
+     */
+    parallel(): this;
+    /**
+     * Extends the rib's side faces at the spine endpoints outward to blend
+     * with the target solids' walls.
+     */
+    extend(): this;
+}
 export interface IShell extends ISceneObject {
     /**
      * Selects the inner wall faces created by the shell operation (from thickness removal).

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

@@ -1,10 +1,10 @@
-import { ISceneObject } from "./interfaces.js";
+import { ILoadFile } from "./interfaces.js";
 interface LoadFunction {
     /**
      * Loads a 3D model file (STEP, STL, etc.) by filename.
      * @param fileName - The path to the model file
      */
-    (fileName: string): ISceneObject;
+    (fileName: string): ILoadFile;
 }
 declare const _default: LoadFunction;
 export default _default;

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

@@ -1,29 +1,29 @@
 import { PlaneLike } from "../math/plane.js";
 import { AxisLike } from "../math/axis.js";
-import { IMirror, ISceneObject } from "./interfaces.js";
+import { IMirror, IMirror2D, ISceneObject } from "./interfaces.js";
 interface MirrorFunction {
     /**
     * [2D] Mirror all sketch geometries across a given line.
     * @param line The line to mirror across
     */
-    (line: ISceneObject): IMirror;
+    (line: ISceneObject): IMirror2D;
     /**
     * [2D] Mirror all sketch geometries across a given axis.
     * @param axis The local axis to mirror across
     */
-    (axis: AxisLike): IMirror;
+    (axis: AxisLike): IMirror2D;
     /**
     * [2D] Mirror given sketch geometries across a given line.
     * @param line The line to mirror across
     * @param geometries The geometries to mirror
     */
-    (line: ISceneObject, ...geometries: ISceneObject[]): IMirror;
+    (line: ISceneObject, ...geometries: ISceneObject[]): IMirror2D;
     /**
     * [2D] Mirror given sketch geometries across a given axis.
     * @param axis The local axis to mirror across
     * @param geometries The geometries to mirror
     */
-    (axis: AxisLike, ...geometries: ISceneObject[]): IMirror;
+    (axis: AxisLike, ...geometries: ISceneObject[]): IMirror2D;
     /**
     * [3D] Mirror all scene shapes across a given plane.
     * @param plane The plane to mirror across

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

@@ -0,0 +1,18 @@
+import { IRib, ISceneObject } from "./interfaces.js";
+interface RibFunction {
+    /**
+     * Creates a rib from the last sketch with the given thickness.
+     * The rib extends in the sketch normal direction until it reaches
+     * surrounding solids. Positive thickness = forward, negative = reverse.
+     * @param thickness - Wall thickness (sign controls direction)
+     */
+    (thickness: number): IRib;
+    /**
+     * Creates a rib from an explicit sketch spine with the given thickness.
+     * @param thickness - Wall thickness (sign controls direction)
+     * @param spine - The sketch providing the rib spine wire and plane
+     */
+    (thickness: number, spine: ISceneObject): IRib;
+}
+declare const _default: RibFunction;
+export default _default;

package/lib/dist/core/rib.js

@@ -0,0 +1,37 @@
+import { SceneObject } from "../common/scene-object.js";
+import { registerBuilder } from "../index.js";
+import { Rib } from "../features/rib.js";
+function isExtrudable(obj) {
+    return obj instanceof SceneObject && obj.isExtrudable();
+}
+function build(context) {
+    //@ts-ignore
+    return function rib() {
+        const args = [...arguments];
+        if (args.length === 0) {
+            throw new Error("rib() requires at least a thickness argument.");
+        }
+        const thickness = args[0];
+        if (typeof thickness !== 'number' || thickness === 0) {
+            throw new Error("rib() thickness must be a non-zero number.");
+        }
+        let spine;
+        let extrudable;
+        if (args.length > 1 && isExtrudable(args[1])) {
+            spine = args[1];
+            extrudable = args[1];
+        }
+        else {
+            const lastExtrudable = context.getLastExtrudable();
+            if (!lastExtrudable) {
+                throw new Error("rib() requires a sketch. No sketch found in the scene.");
+            }
+            spine = lastExtrudable;
+            extrudable = lastExtrudable;
+        }
+        const result = new Rib(thickness, spine, extrudable);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

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

@@ -1,3 +1,4 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { LazyVertex } from "../lazy-vertex.js";
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
@@ -6,6 +7,7 @@ export declare class LineTo extends GeometrySceneObject {
     private targetPlane;
     constructor(endPoint: LazyVertex, targetPlane?: PlaneObjectBase);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: LineTo): boolean;
     getType(): string;
     getUniqueType(): string;

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

@@ -30,6 +30,10 @@ export class LineTo extends GeometrySceneObject {
             this.targetPlane.removeShapes(this);
         }
     }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        return new LineTo(this.endPoint, targetPlane);
+    }
     compareTo(other) {
         if (!(other instanceof LineTo)) {
             return false;

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

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

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

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

package/lib/dist/features/extrude.js

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