@faicad/faijs 0.31.1 → 0.32.3

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

@@ -1,600 +0,0 @@
-/**
- * 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