@faicad/faijs 0.13.0

package/dist/vendored/brepjs/topology/booleanFns.js

@@ -0,0 +1,600 @@
+/**
+ * Boolean and compound operations — functional replacements for _3DShape boolean methods.
+ * All functions are immutable: they return new shapes without disposing inputs.
+ */
+import { getKernel } from '../kernel/index.js';
+import { castShape, castResultShape, disposeDowncastSource, disposeResultShape, getShapeKind, isShape3D, } from '../core/shapeTypes.js';
+import { ok, err, isErr, unwrap } from '../core/result.js';
+import { validationError, typeCastError, kernelError, BrepErrorCode } from '../core/errors.js';
+import { resolvePlane } from '../core/planeOps.js';
+import { vecAdd, vecScale, vecSub, vecDot } from '../core/vecOps.js';
+import { HASH_CODE_MAX } from '../core/constants.js';
+import { getWires, getEdges, getVertices } from './shapeFns.js';
+import { getAtOrThrow, firstOrThrow } from '../utils/arrayAccess.js';
+import { collectInputFaceHashes, propagateAllMetadata, propagateMetadataByHash, } from './metadata/metadataPropagation.js';
+import { makeFace } from './surfaceBuilders.js';
+// ---------------------------------------------------------------------------
+// Pre-validation
+// ---------------------------------------------------------------------------
+function validateShape3D(shape, label) {
+    if (getKernel().isNull(shape.wrapped)) {
+        return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
+    }
+    return ok(undefined);
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function castToShape3D(shape, errorCode, errorMsg, suggestion, diagnostics) {
+    const wrapped = castShape(shape);
+    if (!isShape3D(wrapped)) {
+        const typeName = getShapeKind(wrapped).toUpperCase();
+        disposeDowncastSource(shape, wrapped);
+        disposeResultShape(wrapped);
+        return err(typeCastError(errorCode, `${errorMsg}. Got ${typeName} instead.`, undefined, diagnostics ? { diagnostics } : undefined, suggestion));
+    }
+    disposeDowncastSource(shape, wrapped);
+    return ok(wrapped);
+}
+export function fuse(a, b, { optimisation = 'none', simplify = false, signal, fuzzyValue, unsafe: _unsafe, trackEvolution = true, } = {}) {
+    if (signal?.aborted)
+        throw signal.reason;
+    const checkA = validateShape3D(a, 'fuse: first operand');
+    if (isErr(checkA))
+        return checkA;
+    const checkB = validateShape3D(b, 'fuse: second operand');
+    if (isErr(checkB))
+        return checkB;
+    if (!trackEvolution) {
+        const resultShape = getKernel().fuse(a.wrapped, b.wrapped, {
+            optimisation,
+            simplify,
+            fuzzyValue,
+        });
+        return castToShape3D(resultShape, 'FUSE_NOT_3D', 'Fuse did not produce a 3D shape');
+    }
+    const inputFaceHashes = collectInputFaceHashes([a, b]);
+    const kernelResult = getKernel().fuseWithHistory(a.wrapped, b.wrapped, inputFaceHashes, HASH_CODE_MAX, { optimisation, simplify, fuzzyValue });
+    const { shape: resultShape, evolution, diagnostics } = kernelResult;
+    if (diagnostics.hasErrors) {
+        if (getKernel().isNull(resultShape)) {
+            getKernel().dispose(resultShape);
+            console.warn('faijs: fuse history path produced null result; retrying without evolution tracking.', diagnostics);
+            const fallbackShape = getKernel().fuse(a.wrapped, b.wrapped, {
+                optimisation,
+                simplify,
+                fuzzyValue,
+            });
+            return castToShape3D(fallbackShape, 'FUSE_NOT_3D', 'Fuse did not produce a 3D shape');
+        }
+        console.warn('faijs: fuse reported OCCT warnings/errors but produced a shape. Continuing with result.', diagnostics);
+    }
+    const fuseResult = castToShape3D(resultShape, 'FUSE_NOT_3D', 'Fuse did not produce a 3D shape', 'Common causes: overlapping coplanar faces, zero-thickness geometry, or non-manifold input. Try autoHeal() on inputs first.', diagnostics);
+    if (fuseResult.ok) {
+        propagateAllMetadata(evolution, [a, b], fuseResult.value);
+    }
+    return fuseResult;
+}
+export function cut(base, tool, { optimisation = 'none', simplify = false, signal, fuzzyValue, unsafe: _unsafe, trackEvolution = true, } = {}) {
+    if (signal?.aborted)
+        throw signal.reason;
+    const checkBase = validateShape3D(base, 'cut: base');
+    if (isErr(checkBase))
+        return checkBase;
+    const checkTool = validateShape3D(tool, 'cut: tool');
+    if (isErr(checkTool))
+        return checkTool;
+    if (!trackEvolution) {
+        const resultShape = getKernel().cut(base.wrapped, tool.wrapped, {
+            optimisation,
+            simplify,
+            fuzzyValue,
+        });
+        return castToShape3D(resultShape, 'CUT_NOT_3D', 'Cut did not produce a 3D shape');
+    }
+    const inputFaceHashes = collectInputFaceHashes([base, tool]);
+    const kernelResult = getKernel().cutWithHistory(base.wrapped, tool.wrapped, inputFaceHashes, HASH_CODE_MAX, { optimisation, simplify, fuzzyValue });
+    const { shape: resultShape, evolution, diagnostics } = kernelResult;
+    if (diagnostics.hasErrors) {
+        if (getKernel().isNull(resultShape)) {
+            getKernel().dispose(resultShape);
+            console.warn('faijs: cut history path produced null result; retrying without evolution tracking.', diagnostics);
+            const fallbackShape = getKernel().cut(base.wrapped, tool.wrapped, {
+                optimisation,
+                simplify,
+                fuzzyValue,
+            });
+            return castToShape3D(fallbackShape, 'CUT_NOT_3D', 'Cut did not produce a 3D shape');
+        }
+        console.warn('faijs: cut reported OCCT warnings/errors but produced a shape. Continuing with result.', diagnostics);
+    }
+    const cutResult = castToShape3D(resultShape, 'CUT_NOT_3D', 'Cut did not produce a 3D shape', 'Common causes: tool does not fully intersect the base, or produces a zero-thickness sliver. Ensure the tool extends through the shape.', diagnostics);
+    if (cutResult.ok) {
+        propagateAllMetadata(evolution, [base, tool], cutResult.value);
+    }
+    return cutResult;
+}
+export function intersect(a, b, { simplify = false, signal, fuzzyValue, unsafe: _unsafe, trackEvolution = true, } = {}) {
+    if (signal?.aborted)
+        throw signal.reason;
+    const checkA = validateShape3D(a, 'intersect: first operand');
+    if (isErr(checkA))
+        return checkA;
+    const checkB = validateShape3D(b, 'intersect: second operand');
+    if (isErr(checkB))
+        return checkB;
+    if (!trackEvolution) {
+        const resultShape = getKernel().intersect(a.wrapped, b.wrapped, { simplify, fuzzyValue });
+        return castToShape3D(resultShape, 'INTERSECT_NOT_3D', 'Intersect did not produce a 3D shape');
+    }
+    const inputFaceHashes = collectInputFaceHashes([a, b]);
+    const kernelResult = getKernel().intersectWithHistory(a.wrapped, b.wrapped, inputFaceHashes, HASH_CODE_MAX, { simplify, fuzzyValue });
+    const { shape: resultShape, evolution, diagnostics } = kernelResult;
+    if (diagnostics.hasErrors) {
+        if (getKernel().isNull(resultShape)) {
+            getKernel().dispose(resultShape);
+            console.warn('faijs: intersect history path produced null result; retrying without evolution tracking.', diagnostics);
+            const fallbackShape = getKernel().intersect(a.wrapped, b.wrapped, {
+                simplify,
+                fuzzyValue,
+            });
+            return castToShape3D(fallbackShape, 'INTERSECT_NOT_3D', 'Intersect did not produce a 3D shape');
+        }
+        console.warn('faijs: intersect reported OCCT warnings/errors but produced a shape. Continuing with result.', diagnostics);
+    }
+    const intResult = castToShape3D(resultShape, 'INTERSECT_NOT_3D', 'Intersect did not produce a 3D shape', 'Shapes may not overlap. Verify they share a common volume before intersecting.', diagnostics);
+    if (intResult.ok) {
+        propagateAllMetadata(evolution, [a, b], intResult.value);
+    }
+    return intResult;
+}
+/**
+ * Internal helper for pairwise fuse using index ranges to avoid array allocations.
+ *
+ * `isFinal` marks the subtree whose output is the overall result; only then does
+ * a two-input leaf apply `simplify` (with 3+ inputs the top-level combine already
+ * does, but a two-input fuse is a lone leaf with no combine to reapply it).
+ */
+function fuseAllPairwise(shapes, start, end, optimisation, simplify, isFinal, trackEvolution, signal, fuzzyValue) {
+    if (signal?.aborted)
+        throw signal.reason;
+    const count = end - start;
+    if (count === 1)
+        return ok({ shape: getAtOrThrow(shapes, start), owned: false });
+    if (count === 2) {
+        const pair = fuse(getAtOrThrow(shapes, start), getAtOrThrow(shapes, start + 1), {
+            optimisation,
+            simplify: isFinal ? simplify : false,
+            trackEvolution,
+            fuzzyValue,
+            unsafe: true,
+            ...(signal ? { signal } : {}),
+        });
+        if (isErr(pair))
+            return pair;
+        return ok({ shape: pair.value, owned: true });
+    }
+    const mid = start + Math.ceil(count / 2);
+    const leftResult = fuseAllPairwise(shapes, start, mid, optimisation, simplify, false, trackEvolution, signal, fuzzyValue);
+    if (isErr(leftResult))
+        return leftResult;
+    const rightResult = fuseAllPairwise(shapes, mid, end, optimisation, simplify, false, trackEvolution, signal, fuzzyValue);
+    if (isErr(rightResult)) {
+        if (leftResult.value.owned)
+            disposeResultShape(leftResult.value.shape);
+        return rightResult;
+    }
+    const combined = fuse(leftResult.value.shape, rightResult.value.shape, {
+        optimisation,
+        simplify,
+        trackEvolution,
+        fuzzyValue,
+        unsafe: true,
+        ...(signal ? { signal } : {}),
+    });
+    // The two operands are consumed by the combine; release the ones this
+    // recursion owns (never the caller-owned leaf passthroughs).
+    if (leftResult.value.owned)
+        disposeResultShape(leftResult.value.shape);
+    if (rightResult.value.owned)
+        disposeResultShape(rightResult.value.shape);
+    if (isErr(combined))
+        return combined;
+    return ok({ shape: combined.value, owned: true });
+}
+export function fuseAll(shapes, { optimisation = 'none', simplify = false, strategy = 'native', signal, fuzzyValue, unsafe: _unsafe, trackEvolution = true, } = {}) {
+    if (signal?.aborted)
+        throw signal.reason;
+    if (shapes.length === 0)
+        return err(validationError('FUSE_ALL_EMPTY', 'fuseAll requires at least one shape'));
+    if (shapes.length === 1)
+        return ok(firstOrThrow(shapes));
+    for (let i = 0; i < shapes.length; i++) {
+        const check = validateShape3D(getAtOrThrow(shapes, i), `fuseAll: shape at index ${i}`);
+        if (isErr(check))
+            return check;
+    }
+    if (strategy === 'native') {
+        // Delegate to kernel's native N-way fuse via BRepAlgoAPI_BuilderAlgo
+        const result = getKernel().fuseAll(shapes.map((s) => s.wrapped), { optimisation, simplify, strategy, fuzzyValue, ...(signal ? { signal } : {}) });
+        const fuseAllResult = castToShape3D(result, 'FUSE_ALL_NOT_3D', 'fuseAll did not produce a 3D shape');
+        if (fuseAllResult.ok && trackEvolution) {
+            // Native N-way fuse has no ShapeEvolution — only origins propagate (tags/colors lost)
+            propagateMetadataByHash(shapes, fuseAllResult.value);
+        }
+        return fuseAllResult;
+    }
+    // Pairwise fallback: recursive divide-and-conquer with index ranges
+    // Uses index ranges instead of slice() to avoid array allocations
+    const pairwise = fuseAllPairwise(shapes, 0, shapes.length, optimisation, simplify, true, trackEvolution, signal, fuzzyValue);
+    if (isErr(pairwise))
+        return pairwise;
+    return ok(pairwise.value.shape);
+}
+export function cutAll(base, tools, { optimisation = 'none', simplify = false, signal, fuzzyValue, unsafe: _unsafe, trackEvolution = true, } = {}) {
+    if (signal?.aborted)
+        throw signal.reason;
+    if (tools.length === 0)
+        return ok(base);
+    const checkBase = validateShape3D(base, 'cutAll: base');
+    if (isErr(checkBase))
+        return checkBase;
+    for (let i = 0; i < tools.length; i++) {
+        const check = validateShape3D(getAtOrThrow(tools, i), `cutAll: tool at index ${i}`);
+        if (isErr(check))
+            return check;
+    }
+    const allInputs = [base, ...tools];
+    const result = getKernel().cutAll(base.wrapped, tools.map((s) => s.wrapped), { optimisation, simplify, fuzzyValue });
+    const cutAllResult = castToShape3D(result, 'CUT_ALL_NOT_3D', 'cutAll did not produce a 3D shape');
+    if (cutAllResult.ok && trackEvolution) {
+        // Batch cut has no ShapeEvolution — only origins propagate (tags/colors lost)
+        propagateMetadataByHash(allInputs, cutAllResult.value);
+    }
+    return cutAllResult;
+}
+// ---------------------------------------------------------------------------
+// Section (cross-section / slicing)
+// ---------------------------------------------------------------------------
+/**
+ * Choose the section face's in-plane half-extent and centre so it covers the
+ * whole shape. The rectangle is centred on the shape's bounding-box centre
+ * projected onto the cutting plane (dropping the normal component keeps the cut
+ * at the plane's position while covering an off-origin shape). The half-extent is
+ * the bbox diagonal — large enough for any plane orientation — so a big or
+ * off-origin shape is not silently clipped.
+ *
+ * When the caller passes an explicit `planeSize` they've taken manual control, so
+ * the historical plane-origin centring is preserved (only the auto path re-centres
+ * on the shape) to avoid silently changing behaviour for existing callers.
+ */
+function resolveSectionPlacement(shape, plane, planeSize) {
+    if (planeSize !== undefined) {
+        return { size: planeSize, center: plane.origin };
+    }
+    const { min, max } = getKernel().boundingBox(shape.wrapped);
+    const bboxCenter = [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2];
+    // Project the bbox centre onto the plane: c - ((c - origin)·n) n.
+    const normalOffset = vecDot(vecSub(bboxCenter, plane.origin), plane.zDir);
+    const center = vecSub(bboxCenter, vecScale(plane.zDir, normalOffset));
+    const diagonal = Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]);
+    // Floor guards a degenerate (point/empty) bbox.
+    const size = Math.max(diagonal, 1);
+    return { size, center };
+}
+/**
+ * Build a large bounded planar face from a Plane definition.
+ * The face extends +/-size along xDir and yDir from `center` (a point on the plane).
+ */
+function makeSectionFace(plane, size, center) {
+    const kernel = getKernel();
+    // Compute 4 corners of a large rectangle on the plane
+    const hx = vecScale(plane.xDir, size);
+    const hy = vecScale(plane.yDir, size);
+    const nhx = vecScale(plane.xDir, -size);
+    const nhy = vecScale(plane.yDir, -size);
+    const o = center;
+    const c0 = [...vecAdd(vecAdd(o, nhx), nhy)];
+    const c1 = [...vecAdd(vecAdd(o, hx), nhy)];
+    const c2 = [...vecAdd(vecAdd(o, hx), hy)];
+    const c3 = [...vecAdd(vecAdd(o, nhx), hy)];
+    // Build 4 edges forming a closed rectangle
+    const edges = [
+        kernel.makeLineEdge(c0, c1),
+        kernel.makeLineEdge(c1, c2),
+        kernel.makeLineEdge(c2, c3),
+        kernel.makeLineEdge(c3, c0),
+    ];
+    // Build wire from edges, then face
+    const wire = kernel.makeWire(edges);
+    const face = kernel.makeFace(wire, true);
+    // Cleanup temporaries. `.delete()` is a no-op on arena kernels (occt-wasm) —
+    // route through kernel.dispose so the edge/wire slots are actually reclaimed
+    // (the face shares their refcounted TShape and survives).
+    for (const e of edges)
+        kernel.dispose(e);
+    kernel.dispose(wire);
+    return face;
+}
+/**
+ * Section (cross-section) a shape with a plane, returning the intersection
+ * edges and wires. Useful for slicing solids to get 2D cross-section profiles.
+ *
+ * @param shape The shape to section (typically a solid or shell)
+ * @param plane Plane definition — a named plane ("XY", "XZ", etc.) or a Plane object
+ * @param options.approximation Whether to approximate the section curves (default true)
+ * @param options.planeSize Half-size of the cutting plane. Defaults to the shape's
+ *   bounding-box diagonal so large or off-origin shapes aren't clipped.
+ * @returns The section result as a shape (typically containing wires/edges)
+ */
+export function section(shape, plane, { approximation = true, planeSize } = {}) {
+    if (getKernel().isNull(shape.wrapped)) {
+        return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, 'section: shape is a null shape'));
+    }
+    const resolvedPlane = typeof plane === 'string' ? unwrap(resolvePlane(plane)) : plane;
+    const { size, center } = resolveSectionPlacement(shape, resolvedPlane, planeSize);
+    const sectionFace = makeSectionFace(resolvedPlane, size, center);
+    try {
+        const kernel = getKernel();
+        const resultOc = kernel.section(shape.wrapped, sectionFace, approximation);
+        const wrapped = castResultShape(resultOc);
+        return ok(wrapped);
+    }
+    catch (e) {
+        const raw = e instanceof Error ? e.message : String(e);
+        const planeName = typeof plane === 'string' ? plane : 'custom';
+        return err(kernelError('SECTION_FAILED', `Section with ${planeName} plane failed: ${raw}`, e, { operation: 'section', plane: planeName }, 'The cutting plane may not intersect the shape. Verify plane position relative to shape bounds.'));
+    }
+    finally {
+        // `.delete()` is a no-op on arena kernels; dispose reclaims the slot.
+        getKernel().dispose(sectionFace);
+    }
+}
+/**
+ * Build vertex-hash → edge adjacency map for O(n) wire assembly.
+ * Each edge maps to its two vertex hashes; each hash maps to the edges sharing that vertex.
+ */
+function buildEdgeAdjacency(edges) {
+    const kernel = getKernel();
+    const vertexToEdges = new Map();
+    const edgeVertexHashes = new Map();
+    for (const edge of edges) {
+        const verts = getVertices(edge);
+        const h0 = verts[0] ? kernel.hashCode(verts[0].wrapped, HASH_CODE_MAX) : -1;
+        const h1 = verts.length > 1 && verts[1] ? kernel.hashCode(verts[1].wrapped, HASH_CODE_MAX) : h0;
+        edgeVertexHashes.set(edge, [h0, h1]);
+        for (const h of [h0, h1]) {
+            const bucket = vertexToEdges.get(h) ?? [];
+            bucket.push(edge);
+            vertexToEdges.set(h, bucket);
+        }
+    }
+    return { vertexToEdges, edgeVertexHashes };
+}
+/**
+ * Find the first unvisited adjacent edge reachable from `tip` in the adjacency map.
+ * Returns the matched edge and the new tip hash, or undefined if no match.
+ */
+function findNextEdge(tip, adjacency, visited) {
+    const bucket = adjacency.vertexToEdges.get(tip);
+    if (!bucket)
+        return undefined;
+    for (const candidate of bucket) {
+        if (visited.has(candidate))
+            continue;
+        const ch = adjacency.edgeVertexHashes.get(candidate);
+        if (!ch)
+            continue;
+        visited.add(candidate);
+        const nextTip = ch[0] === tip ? ch[1] : ch[0];
+        return { edge: candidate, nextTip };
+    }
+    return undefined;
+}
+/**
+ * Walk a connected chain of edges starting from `startEdge` in both directions.
+ * Marks all traversed edges as visited. Returns the ordered edge chain.
+ */
+function walkEdgeChain(startEdge, adjacency, visited) {
+    visited.add(startEdge);
+    const wireEdges = [startEdge];
+    const hashes = adjacency.edgeVertexHashes.get(startEdge);
+    if (!hashes)
+        return wireEdges;
+    // Walk forward from hashes[1], then backward from hashes[0]
+    const endpoints = [hashes[1], hashes[0]];
+    for (let dir = 0; dir < 2; dir++) {
+        let tip = endpoints[dir];
+        if (tip === undefined)
+            continue;
+        let match = findNextEdge(tip, adjacency, visited);
+        while (match) {
+            if (dir === 0)
+                wireEdges.push(match.edge);
+            else
+                wireEdges.unshift(match.edge);
+            tip = match.nextTip;
+            match = findNextEdge(tip, adjacency, visited);
+        }
+    }
+    return wireEdges;
+}
+/**
+ * Assemble loose section edges into wires via vertex-hash adjacency.
+ * Walks connected components and builds kernel wires from each chain.
+ */
+function assembleWiresFromEdges(edges) {
+    const kernel = getKernel();
+    const adjacency = buildEdgeAdjacency(edges);
+    const visited = new Set();
+    const wires = [];
+    for (const startEdge of edges) {
+        if (visited.has(startEdge))
+            continue;
+        const wireEdges = walkEdgeChain(startEdge, adjacency, visited);
+        try {
+            const wireOc = kernel.makeWire(wireEdges.map((e) => e.wrapped));
+            wires.push(castResultShape(wireOc));
+        }
+        catch {
+            // Skip malformed wire components
+        }
+    }
+    return wires;
+}
+/**
+ * Find the index of the outermost wire (largest bounding-box diagonal).
+ * Works for any plane orientation.
+ */
+function findOuterWireIndex(wires) {
+    const kernel = getKernel();
+    let outerIdx = 0;
+    let maxDiag = -1;
+    for (let i = 0; i < wires.length; i++) {
+        const w = wires[i];
+        if (!w)
+            continue;
+        const bb = kernel.boundingBox(w.wrapped);
+        const dx = bb.max[0] - bb.min[0];
+        const dy = bb.max[1] - bb.min[1];
+        const dz = bb.max[2] - bb.min[2];
+        const diag = dx * dx + dy * dy + dz * dz;
+        if (diag > maxDiag) {
+            maxDiag = diag;
+            outerIdx = i;
+        }
+    }
+    return outerIdx;
+}
+// ---------------------------------------------------------------------------
+// sectionToFace
+// ---------------------------------------------------------------------------
+/**
+ * Section a shape with a plane and return a filled Face.
+ * The outermost wire (largest bounding-box area) becomes the outer boundary;
+ * any remaining wires are treated as holes.
+ */
+export function sectionToFace(shape, plane, options = {}) {
+    const sectionResult = section(shape, plane, options);
+    if (!sectionResult.ok)
+        return sectionResult;
+    const wires = getWires(sectionResult.value);
+    if (wires.length === 0) {
+        // Section may return loose edges — assemble them into wires
+        const edges = getEdges(sectionResult.value);
+        if (edges.length === 0) {
+            return err(kernelError('SECTION_FAILED', 'sectionToFace: section produced no geometry', undefined, undefined, 'The cutting plane may not intersect the shape. Verify plane position relative to shape bounds.'));
+        }
+        wires.push(...assembleWiresFromEdges(edges));
+    }
+    if (wires.length === 0) {
+        return err(kernelError('SECTION_FAILED', 'sectionToFace: section produced no usable geometry', undefined, undefined, 'The cutting plane may not intersect the shape. Verify plane position relative to shape bounds.'));
+    }
+    const outerIdx = findOuterWireIndex(wires);
+    const outer = getAtOrThrow(wires, outerIdx);
+    const holes = wires.filter((_, i) => i !== outerIdx);
+    // Section result wires are always closed, coplanar boundary loops
+    return makeFace(outer, holes.length > 0 ? holes : undefined);
+}
+// ---------------------------------------------------------------------------
+// Splitting
+// ---------------------------------------------------------------------------
+/**
+ * Split a shape with one or more tool shapes using BRepAlgoAPI_Splitter.
+ * Returns all pieces from the split as a compound.
+ */
+export function split(shape, tools) {
+    if (tools.length === 0)
+        return ok(shape);
+    if (getKernel().isNull(shape.wrapped)) {
+        return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, 'split: shape is a null shape'));
+    }
+    for (let i = 0; i < tools.length; i++) {
+        if (getKernel().isNull(getAtOrThrow(tools, i).wrapped)) {
+            return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `splitShape: tool at index ${i} is a null shape`));
+        }
+    }
+    try {
+        const result = getKernel().split(shape.wrapped, tools.map((t) => t.wrapped));
+        return ok(castResultShape(result));
+    }
+    catch (e) {
+        const raw = e instanceof Error ? e.message : String(e);
+        return err(kernelError('SPLIT_FAILED', `Split operation failed on ${tools.length} tool(s): ${raw}`, e, { operation: 'split', toolCount: tools.length }, "The splitting tools may not intersect the shape. Ensure tools cross through the shape's interior."));
+    }
+}
+// ---------------------------------------------------------------------------
+// Batch slicing
+// ---------------------------------------------------------------------------
+/**
+ * Slice a shape with multiple planes, returning one cross-section per plane.
+ * Each result entry corresponds to the input plane at the same index.
+ */
+export function slice(shape, planes, options = {}) {
+    const results = [];
+    for (const plane of planes) {
+        const result = section(shape, plane, options);
+        if (isErr(result))
+            return result;
+        results.push(result.value);
+    }
+    return ok(results);
+}
+/**
+ * Execute a chained boolean pipeline in a single WASM call.
+ *
+ * More efficient than sequential fuse/cut calls for long chains (e.g., 16-step
+ * spiral staircase). Skips UnifySameDomain on intermediate results — only
+ * simplifies the final shape.
+ *
+ * Falls back to sequential operations when the C++ pipeline class is not
+ * available in the WASM build.
+ */
+export function booleanPipeline(base, steps, options) {
+    if (steps.length === 0)
+        return ok(base);
+    const glueMode = options?.optimisation === 'commonFace' ? 1 : options?.optimisation === 'sameFace' ? 2 : 0;
+    const k = getKernel();
+    const kernelSteps = steps.map((s) => ({
+        op: s.op,
+        tool: s.tool.wrapped,
+    }));
+    try {
+        const result = k.booleanPipeline?.(base.wrapped, kernelSteps, { glueMode });
+        if (result === undefined) {
+            // Kernel doesn't support pipeline — fall back to sequential
+            return booleanPipelineFallback(base, steps, options);
+        }
+        if (result === null) {
+            return err(kernelError('BOOLEAN_PIPELINE_FAILED', 'Boolean pipeline returned null shape'));
+        }
+        const shape = castResultShape(result);
+        if (!isShape3D(shape)) {
+            disposeResultShape(shape);
+            return err(typeCastError('BOOLEAN_PIPELINE_NOT_3D', 'Pipeline result is not a 3D shape'));
+        }
+        return ok(shape);
+    }
+    catch (e) {
+        return err(kernelError('BOOLEAN_PIPELINE_FAILED', e instanceof Error ? e.message : String(e)));
+    }
+}
+function booleanPipelineFallback(base, steps, options) {
+    let current = base;
+    const boolOpts = {
+        ...(options?.optimisation ? { optimisation: options.optimisation } : {}),
+        unsafe: true,
+    };
+    for (const step of steps) {
+        const r = step.op === 'fuse'
+            ? fuse(current, step.tool, boolOpts)
+            : step.op === 'cut'
+                ? cut(current, step.tool, boolOpts)
+                : intersect(current, step.tool, boolOpts);
+        if (isErr(r))
+            return r;
+        current = unwrap(r);
+    }
+    return ok(current);
+}
+//# sourceMappingURL=booleanFns.js.map