brepjs 18.129.0 → 18.131.0

package/dist/{healingFns-DTr6cgTb.cjs → healingFns-BqmIvfPm.cjs}

@@ -107,6 +107,381 @@ function toLODGeometryLevels(lods, options) {
 	}));
 }
 //#endregion
+//#region src/topology/modifierFns.ts
+/**
+* Functional modifier operations — fillet, chamfer, shell, thicken, offset, draft.
+*
+* These are standalone functions that operate on branded shape types
+* and return Result values.
+*/
+function validateNotNull$1(shape, label) {
+	if (require_shapeTypes.getKernel().isNull(shape.wrapped)) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
+	return require_errors.ok(void 0);
+}
+/**
+* Validate that a scalar or `[a, b]` pair is positive.
+* Returns an Err Result on failure, `undefined` on success.
+*
+* Function-type values (per-edge callbacks) are intentionally skipped here --
+* they are validated lazily in {@link resolveEdgeCallback} when each edge is processed.
+*/
+function validatePositiveParam(value, msgs) {
+	if (typeof value === "number" && value <= 0) return require_errors.err(require_errors.validationError(msgs.code, msgs.scalar, void 0, void 0, msgs.scalarHint));
+	if (Array.isArray(value) && (value[0] <= 0 || value[1] <= 0)) return require_errors.err(require_errors.validationError(msgs.code, msgs.pair, void 0, void 0, msgs.pairHint));
+}
+/**
+* When the user supplies a per-edge callback, pre-filter edges and build a
+* hash-indexed lookup for the kernel. Returns `null` if no edges survive.
+*/
+function resolveEdgeCallback$1(selectedEdges, callbackFn) {
+	const filteredEdges = [];
+	const hashToValue = /* @__PURE__ */ new Map();
+	for (const edge of selectedEdges) {
+		const val = callbackFn(edge) ?? 0;
+		if (typeof val === "number" && val <= 0) continue;
+		if (Array.isArray(val) && (val[0] <= 0 || val[1] <= 0)) continue;
+		filteredEdges.push(edge);
+		hashToValue.set(require_shapeTypes.getKernel().hashCode(edge.wrapped, require_constants.HASH_CODE_MAX), val);
+	}
+	if (filteredEdges.length === 0) return null;
+	const kernelParam = (ocEdge) => {
+		const v = hashToValue.get(require_shapeTypes.getKernel().hashCode(ocEdge, require_constants.HASH_CODE_MAX));
+		if (v === void 0) throw new Error("fillet/chamfer: edge hash not found — possible hash collision");
+		return v;
+	};
+	return {
+		edges: filteredEdges,
+		kernelParam
+	};
+}
+/**
+* Cast a kernel result to a Shape3D, propagate metadata, and wrap in `ok()`.
+* Returns an error if the result is not a 3D shape.
+*/
+function finalizeShape3D(evolution, resultShape, inputs, not3dCode, not3dMessage) {
+	const cast = require_shapeTypes.castResultShape(resultShape);
+	if (!require_shapeTypes.isShape3D(cast)) {
+		require_shapeTypes.disposeResultShape(cast);
+		return require_errors.err(require_errors.kernelError(not3dCode, not3dMessage));
+	}
+	require_solidBuilders.propagateAllMetadata(evolution, inputs, cast);
+	return require_errors.ok(cast);
+}
+/**
+* When the user supplies a per-face callback for draft angle, pre-filter
+* faces and build a hash-indexed lookup for the kernel.
+*/
+function resolveDraftCallback(faces, angle) {
+	if (typeof angle !== "function") return {
+		filteredFaces: [...faces],
+		kernelAngle: angle
+	};
+	const filteredFaces = [];
+	const hashToAngle = /* @__PURE__ */ new Map();
+	for (const face of faces) {
+		const a = angle(face);
+		if (a === null || a === 0 || Math.abs(a) >= 90) continue;
+		filteredFaces.push(face);
+		hashToAngle.set(require_shapeTypes.getKernel().hashCode(face.wrapped, require_constants.HASH_CODE_MAX), a);
+	}
+	const kernelAngle = (ocFace) => {
+		const a = hashToAngle.get(require_shapeTypes.getKernel().hashCode(ocFace, require_constants.HASH_CODE_MAX));
+		if (a === void 0) throw new Error("draft: face hash not found — possible hash collision");
+		return a;
+	};
+	return {
+		filteredFaces,
+		kernelAngle
+	};
+}
+/**
+* Thickens a surface (face or shell) into a solid by offsetting it.
+*
+* Takes a planar or non-planar surface shape and creates a solid
+* by offsetting it by the given thickness. Positive thickness offsets
+* along the surface normal; negative thickness offsets against it.
+*/
+function thicken(shape, thickness) {
+	const check = validateNotNull$1(shape, "thicken: shape");
+	if (require_errors.isErr(check)) return check;
+	try {
+		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().thickenWithHistory(shape.wrapped, thickness, inputFaceHashes, require_constants.HASH_CODE_MAX);
+		const cast = require_shapeTypes.castResultShape(resultShape);
+		require_solidBuilders.propagateAllMetadata(evolution, [shape], cast);
+		return require_errors.ok(cast);
+	} catch (e) {
+		const raw = e instanceof Error ? e.message : String(e);
+		return require_errors.err(require_errors.kernelError("THICKEN_FAILED", `Thicken operation failed: ${raw}`, e));
+	}
+}
+/**
+* Validate fillet inputs and resolve the user-supplied radius into a
+* kernel-ready value paired with the filtered edge list.
+*/
+function normalizeFilletInputs(shape, edges, radius) {
+	const check = validateNotNull$1(shape, "fillet: shape");
+	if (require_errors.isErr(check)) return check;
+	const paramErr = validatePositiveParam(radius, {
+		code: "INVALID_FILLET_RADIUS",
+		scalar: "Fillet radius must be positive",
+		pair: "Fillet radii must both be positive",
+		scalarHint: "Provide a positive radius value greater than 0",
+		pairHint: "Both radius values must be greater than 0"
+	});
+	if (paramErr) return paramErr;
+	const selectedEdges = edges ?? require_topologyQueryFns.getEdges(shape);
+	if (selectedEdges.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.FILLET_NO_EDGES, "No edges found for fillet", void 0, void 0, "Check that the shape has edges, or adjust your edge finder criteria"));
+	if (typeof radius === "function") {
+		const resolved = resolveEdgeCallback$1(selectedEdges, radius);
+		if (!resolved) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.FILLET_NO_EDGES, "No edges with positive radius for fillet", void 0, void 0, "Check that the radius callback returns positive values"));
+		return require_errors.ok({
+			filteredEdges: resolved.edges,
+			kernelRadius: resolved.kernelParam,
+			selectedCount: selectedEdges.length
+		});
+	}
+	return require_errors.ok({
+		filteredEdges: [...selectedEdges],
+		kernelRadius: radius,
+		selectedCount: selectedEdges.length
+	});
+}
+/**
+* Apply a fillet (rounded edge) to selected edges of a 3D shape.
+*
+* @param shape - The shape to modify.
+* @param edges - Edges to fillet. Pass `undefined` to fillet all edges.
+* @param radius - Constant radius, variable radius `[r1, r2]`, or per-edge callback.
+*/
+function fillet(shape, edges, radius, { trackEvolution = true } = {}) {
+	const normalized = normalizeFilletInputs(shape, edges, radius);
+	if (require_errors.isErr(normalized)) return normalized;
+	const { filteredEdges, kernelRadius, selectedCount } = normalized.value;
+	try {
+		const edgeShapes = filteredEdges.map((e) => e.wrapped);
+		if (!trackEvolution) {
+			const resultShape = require_shapeTypes.getKernel().fillet(shape.wrapped, edgeShapes, kernelRadius);
+			const cast = require_shapeTypes.castResultShape(resultShape);
+			if (!require_shapeTypes.isShape3D(cast)) {
+				require_shapeTypes.disposeResultShape(cast);
+				return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape"));
+			}
+			return require_errors.ok(cast);
+		}
+		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().filletWithHistory(shape.wrapped, edgeShapes, kernelRadius, inputFaceHashes, require_constants.HASH_CODE_MAX);
+		return finalizeShape3D(evolution, resultShape, [shape], require_errors.BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape");
+	} catch (e) {
+		const raw = e instanceof Error ? e.message : String(e);
+		return require_errors.err(require_errors.kernelError("FILLET_FAILED", `Fillet operation failed: ${raw}`, e, {
+			operation: "fillet",
+			edgeCount: selectedCount,
+			radius
+		}));
+	}
+}
+/**
+* Apply a chamfer (beveled edge) to selected edges of a 3D shape.
+*
+* @param shape - The shape to modify.
+* @param edges - Edges to chamfer. Pass `undefined` to chamfer all edges.
+* @param distance - Symmetric distance, asymmetric `[d1, d2]`, or per-edge callback.
+*/
+function chamfer(shape, edges, distance) {
+	const check = validateNotNull$1(shape, "chamfer: shape");
+	if (require_errors.isErr(check)) return check;
+	const paramErr = validatePositiveParam(distance, {
+		code: "INVALID_CHAMFER_DISTANCE",
+		scalar: "Chamfer distance must be positive",
+		pair: "Chamfer distances must both be positive",
+		scalarHint: "Provide a positive distance value greater than 0",
+		pairHint: "Both distance values must be greater than 0"
+	});
+	if (paramErr) return paramErr;
+	const selectedEdges = edges ?? require_topologyQueryFns.getEdges(shape);
+	if (selectedEdges.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.CHAMFER_NO_EDGES, "No edges found for chamfer"));
+	try {
+		let filteredEdges;
+		let kernelDistance;
+		if (typeof distance === "function") {
+			const resolved = resolveEdgeCallback$1(selectedEdges, distance);
+			if (!resolved) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.CHAMFER_NO_EDGES, "No edges with positive distance for chamfer"));
+			filteredEdges = resolved.edges;
+			kernelDistance = resolved.kernelParam;
+		} else {
+			filteredEdges = [...selectedEdges];
+			kernelDistance = distance;
+		}
+		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().chamferWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelDistance, inputFaceHashes, require_constants.HASH_CODE_MAX);
+		return finalizeShape3D(evolution, resultShape, [shape], require_errors.BrepErrorCode.CHAMFER_NOT_3D, "Chamfer result is not a 3D shape");
+	} catch (e) {
+		const raw = e instanceof Error ? e.message : String(e);
+		return require_errors.err(require_errors.kernelError("CHAMFER_FAILED", `Chamfer operation failed: ${raw}`, e, {
+			operation: "chamfer",
+			edgeCount: selectedEdges.length,
+			distance
+		}));
+	}
+}
+/**
+* Create a hollow shell by removing faces and offsetting remaining walls.
+*
+* @param shape - The solid to hollow out.
+* @param faces - Faces to remove.
+* @param thickness - Wall thickness.
+* @param tolerance - Shell operation tolerance (default 1e-3).
+*/
+function shell(shape, faces, thickness, tolerance = .001, { trackEvolution = true } = {}) {
+	const check = validateNotNull$1(shape, "shell: shape");
+	if (require_errors.isErr(check)) return check;
+	if (thickness <= 0) return require_errors.err(require_errors.validationError("INVALID_THICKNESS", "Shell thickness must be positive"));
+	if (faces.length === 0) return require_errors.err(require_errors.validationError("NO_FACES", "At least one face must be specified for shell"));
+	try {
+		if (!trackEvolution) {
+			const resultShape = require_shapeTypes.getKernel().shell(shape.wrapped, faces.map((f) => f.wrapped), thickness, tolerance);
+			const cast = require_shapeTypes.castResultShape(resultShape);
+			if (!require_shapeTypes.isShape3D(cast)) {
+				require_shapeTypes.disposeResultShape(cast);
+				return require_errors.err(require_errors.kernelError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
+			}
+			return require_errors.ok(cast);
+		}
+		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().shellWithHistory(shape.wrapped, faces.map((f) => f.wrapped), thickness, inputFaceHashes, require_constants.HASH_CODE_MAX, tolerance);
+		const cast = require_shapeTypes.castResultShape(resultShape);
+		if (!require_shapeTypes.isShape3D(cast)) {
+			require_shapeTypes.disposeResultShape(cast);
+			return require_errors.err(require_errors.kernelError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
+		}
+		require_solidBuilders.propagateAllMetadata(evolution, [shape], cast);
+		return require_errors.ok(cast);
+	} catch (e) {
+		const raw = e instanceof Error ? e.message : String(e);
+		return require_errors.err(require_errors.kernelError("SHELL_FAILED", `Shell operation failed: ${raw}`, e, {
+			operation: "shell",
+			faceCount: faces.length,
+			thickness
+		}));
+	}
+}
+/**
+* Offset all faces of a shape by a given distance.
+*
+* @param shape - The shape to offset (must be a 3D shape with faces).
+* @param distance - Offset distance (positive = outward, negative = inward).
+* @param tolerance - Offset tolerance (default 1e-6).
+*/
+function offset(shape, distance, tolerance = 1e-6) {
+	const check = validateNotNull$1(shape, "offset: shape");
+	if (require_errors.isErr(check)) return check;
+	if (Math.abs(distance) < 1e-10) return require_errors.err(require_errors.validationError("ZERO_OFFSET", "Offset distance cannot be zero"));
+	try {
+		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().offsetWithHistory(shape.wrapped, distance, inputFaceHashes, require_constants.HASH_CODE_MAX, tolerance);
+		const cast = require_shapeTypes.castResultShape(resultShape);
+		if (!require_shapeTypes.isShape3D(cast)) {
+			require_shapeTypes.disposeResultShape(cast);
+			return require_errors.err(require_errors.kernelError("OFFSET_RESULT_NOT_3D", "Offset result is not a 3D shape"));
+		}
+		require_solidBuilders.propagateAllMetadata(evolution, [shape], cast);
+		return require_errors.ok(cast);
+	} catch (e) {
+		const raw = e instanceof Error ? e.message : String(e);
+		return require_errors.err(require_errors.kernelError("OFFSET_FAILED", `Offset operation failed: ${raw}`, e));
+	}
+}
+/**
+* Validate draft inputs (null shape, scalar angle bounds, faces non-empty).
+* Returns an Err Result on failure, `undefined` on success.
+*/
+function validateDraftInputs(shape, faces, angle) {
+	const check = validateNotNull$1(shape, "draft: shape");
+	if (require_errors.isErr(check)) return check;
+	if (typeof angle === "number") {
+		if (Math.abs(angle) < 1e-10) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.DRAFT_INVALID_ANGLE, "Draft angle cannot be zero", void 0, void 0, "Provide a non-zero angle in degrees"));
+		if (Math.abs(angle) >= 90) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.DRAFT_INVALID_ANGLE, "Draft angle must be between -90 and 90 degrees (exclusive)", void 0, void 0, "Typical draft angles are 1-5 degrees for injection molding"));
+	}
+	if (faces.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.DRAFT_NO_FACES, "No faces specified for draft", void 0, void 0, "Select at least one face to apply the draft angle to"));
+}
+/**
+* Apply a draft (taper) to selected faces of a 3D shape.
+*
+* Draft tilts faces by a specified angle relative to a pull direction,
+* pivoting about a neutral plane. This is essential for injection molding
+* and casting workflows where parts must release from a mold.
+*
+* @param shape - The solid to modify.
+* @param faces - Faces to draft.
+* @param pullDirection - Mold opening direction vector.
+* @param neutralPlane - A point on the plane where faces are not displaced.
+* @param angle - Constant angle in degrees, or per-face callback returning degrees (null to skip).
+*/
+function draft(shape, faces, pullDirection, neutralPlane, angle) {
+	const inputErr = validateDraftInputs(shape, faces, angle);
+	if (inputErr) return inputErr;
+	try {
+		const { filteredFaces, kernelAngle } = resolveDraftCallback(faces, angle);
+		if (filteredFaces.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.DRAFT_NO_FACES, "No faces with valid draft angle", void 0, void 0, "Check that the angle callback returns non-zero values between -90 and 90 degrees"));
+		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().draftWithHistory(shape.wrapped, filteredFaces.map((f) => f.wrapped), [
+			pullDirection[0],
+			pullDirection[1],
+			pullDirection[2]
+		], [
+			neutralPlane[0],
+			neutralPlane[1],
+			neutralPlane[2]
+		], kernelAngle, inputFaceHashes, require_constants.HASH_CODE_MAX);
+		return finalizeShape3D(evolution, resultShape, [shape], require_errors.BrepErrorCode.DRAFT_NOT_3D, "Draft result is not a 3D shape");
+	} catch (e) {
+		const raw = e instanceof Error ? e.message : String(e);
+		return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.DRAFT_FAILED, `Draft operation failed: ${raw}`, e, {
+			operation: "draft",
+			faceCount: faces.length,
+			angle
+		}));
+	}
+}
+/**
+* Apply a variable-radius fillet to an edge.
+*
+* The radius varies along the edge according to the provided spec points.
+* Each point specifies a normalized parameter (0 = start, 1 = end) and radius.
+*
+* **Cross-kernel note:** brepkit supports arbitrary multi-point radius profiles.
+* occt-wasm supports a linear (start/end, <=2-point) profile and returns
+* UNSUPPORTED for multi-point; the opencascade.js kernel does not implement it.
+*/
+function variableFillet(shape, edge, radii) {
+	if (radii.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.VARIABLE_FILLET_FAILED, "radii must contain at least one radius spec"));
+	for (const r of radii) if (r.radius <= 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.VARIABLE_FILLET_FAILED, "All radius values must be positive"));
+	const kernel = require_shapeTypes.getKernel();
+	try {
+		const spec = JSON.stringify({
+			edge: kernel.hashCode(edge.wrapped, require_constants.HASH_CODE_MAX),
+			radii: radii.map((r) => ({
+				param: r.param,
+				radius: r.radius
+			}))
+		});
+		const result = kernel.filletVariable(shape.wrapped, spec);
+		const wrapped = require_shapeTypes.castResultShape(result);
+		if (!require_shapeTypes.isShape3D(wrapped)) {
+			require_shapeTypes.disposeResultShape(wrapped);
+			return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.VARIABLE_FILLET_FAILED, "Variable-radius fillet did not produce a 3D shape"));
+		}
+		if (!require_shapeTypes.isSolid(wrapped)) {
+			require_shapeTypes.disposeResultShape(wrapped);
+			return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.VARIABLE_FILLET_FAILED, "Variable-radius fillet did not produce a solid"));
+		}
+		return require_errors.ok(wrapped);
+	} catch (e) {
+		return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.VARIABLE_FILLET_FAILED, "Variable-radius fillet failed", e));
+	}
+}
+//#endregion
 //#region src/topology/chamferAngleFns.ts
 /**
 * Chamfer with distance + angle — functional API.
@@ -272,356 +647,84 @@ function bisectFuse(ops, shapes, startIdx, options, telemetry) {
 	return combineFuseHalves(ops, bisectFuse(ops, shapes.slice(0, mid), startIdx, options, telemetry), bisectFuse(ops, shapes.slice(mid), startIdx + mid, options, telemetry), shapes, startIdx, mid, options, telemetry);
 }
 function combineFuseHalves(ops, left, right, shapes, startIdx, mid, options, telemetry) {
-	if (left.ok && right.ok) {
-		telemetry.singletonFallbacks++;
-		const merged = tryBatch(() => ops.fuse(left.value, right.value, options));
-		if (merged && merged.ok) return merged;
-		for (let i = mid; i < shapes.length; i++) telemetry.failedInputs.add(startIdx + i);
-		return left;
-	}
-	if (left.ok) {
-		for (let i = mid; i < shapes.length; i++) telemetry.failedInputs.add(startIdx + i);
-		return left;
-	}
-	if (right.ok) {
-		for (let i = 0; i < mid; i++) telemetry.failedInputs.add(startIdx + i);
-		return right;
-	}
-	return left;
-}
-/**
-* Run a batch boolean op, returning null on kernel throw (signal-aborts
-* propagate). The caller checks for null and bisects.
-*/
-function tryBatch(fn) {
-	try {
-		return fn();
-	} catch {
-		return null;
-	}
-}
-//#endregion
-//#region src/topology/booleanDiagnosticFns.ts
-/**
-* Boolean pre-validation diagnostics.
-*/
-/**
-* Pre-validate operands before a boolean operation.
-*
-* Checks that both shapes are non-null and topologically valid.
-* Returns a structured report of any issues found.
-*
-* @example
-* ```typescript
-* const check = checkBoolean(base, tool, 'fuse');
-* if (!check.valid) {
-*   console.warn('Boolean will likely fail:', check.issues);
-* }
-* ```
-*/
-function checkBoolean(base, tool, op) {
-	return require_shapeTypes.getKernel().checkBoolean(base.wrapped, tool.wrapped, op);
-}
-//#endregion
-//#region src/topology/evolutionFns.ts
-/**
-* Evolution-tracking variants of boolean and modifier operations.
-*
-* These functions mirror the standard fuse/cut/intersect/fillet/chamfer/shell
-* operations but additionally return the ShapeEvolution data, enabling
-* persistent face selections, constraint tracking, and custom face-level logic.
-*/
-function validateShape3D(shape, label) {
-	if (require_shapeTypes.getKernel().isNull(shape.wrapped)) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
-	return require_errors.ok(void 0);
-}
-function validateNotNull$1(shape, label) {
-	if (require_shapeTypes.getKernel().isNull(shape.wrapped)) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
-	return require_errors.ok(void 0);
-}
-function castToShape3D(shape, errorCode, errorMsg, suggestion) {
-	const wrapped = require_shapeTypes.castShape(shape);
-	if (!require_shapeTypes.isShape3D(wrapped)) {
-		const typeName = require_shapeTypes.getShapeKind(wrapped).toUpperCase();
-		require_shapeTypes.disposeDowncastSource(shape, wrapped);
-		require_shapeTypes.disposeResultShape(wrapped);
-		return require_errors.err(require_errors.typeCastError(errorCode, `${errorMsg}. Got ${typeName} instead.`, void 0, void 0, suggestion));
-	}
-	require_shapeTypes.disposeDowncastSource(shape, wrapped);
-	return require_errors.ok(wrapped);
-}
-function resolveEdgeCallback$1(selectedEdges, callbackFn) {
-	const filteredEdges = [];
-	const hashToValue = /* @__PURE__ */ new Map();
-	for (const edge of selectedEdges) {
-		const val = callbackFn(edge) ?? 0;
-		if (typeof val === "number" && val <= 0) continue;
-		if (Array.isArray(val) && (val[0] <= 0 || val[1] <= 0)) continue;
-		filteredEdges.push(edge);
-		hashToValue.set(require_shapeTypes.getKernel().hashCode(edge.wrapped, require_constants.HASH_CODE_MAX), val);
-	}
-	if (filteredEdges.length === 0) return null;
-	const kernelParam = (ocEdge) => {
-		return hashToValue.get(require_shapeTypes.getKernel().hashCode(ocEdge, 2147483647)) ?? 1;
-	};
-	return {
-		edges: filteredEdges,
-		kernelParam
-	};
-}
-function fuseWithEvolution(a, b, { optimisation = "none", simplify = false, signal, fuzzyValue } = {}) {
-	if (signal?.aborted) throw signal.reason;
-	const checkA = validateShape3D(a, "fuseWithEvolution: first operand");
-	if (require_errors.isErr(checkA)) return checkA;
-	const checkB = validateShape3D(b, "fuseWithEvolution: second operand");
-	if (require_errors.isErr(checkB)) return checkB;
-	const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([a, b]);
-	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().fuseWithHistory(a.wrapped, b.wrapped, inputFaceHashes, require_constants.HASH_CODE_MAX, {
-		optimisation,
-		simplify,
-		fuzzyValue
-	});
-	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.");
-	if (fuseResult.ok) {
-		require_solidBuilders.propagateAllMetadata(evolution, [a, b], fuseResult.value);
-		return require_errors.ok({
-			shape: fuseResult.value,
-			evolution
-		});
-	}
-	return fuseResult;
-}
-function cutWithEvolution(base, tool, { optimisation = "none", simplify = false, signal, fuzzyValue } = {}) {
-	if (signal?.aborted) throw signal.reason;
-	const checkBase = validateShape3D(base, "cutWithEvolution: base");
-	if (require_errors.isErr(checkBase)) return checkBase;
-	const checkTool = validateShape3D(tool, "cutWithEvolution: tool");
-	if (require_errors.isErr(checkTool)) return checkTool;
-	const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([base, tool]);
-	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().cutWithHistory(base.wrapped, tool.wrapped, inputFaceHashes, require_constants.HASH_CODE_MAX, {
-		optimisation,
-		simplify,
-		fuzzyValue
-	});
-	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.");
-	if (cutResult.ok) {
-		require_solidBuilders.propagateAllMetadata(evolution, [base, tool], cutResult.value);
-		return require_errors.ok({
-			shape: cutResult.value,
-			evolution
-		});
-	}
-	return cutResult;
-}
-function intersectWithEvolution(a, b, { simplify = false, signal, fuzzyValue } = {}) {
-	if (signal?.aborted) throw signal.reason;
-	const checkA = validateShape3D(a, "intersectWithEvolution: first operand");
-	if (require_errors.isErr(checkA)) return checkA;
-	const checkB = validateShape3D(b, "intersectWithEvolution: second operand");
-	if (require_errors.isErr(checkB)) return checkB;
-	const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([a, b]);
-	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().intersectWithHistory(a.wrapped, b.wrapped, inputFaceHashes, require_constants.HASH_CODE_MAX, {
-		simplify,
-		fuzzyValue
-	});
-	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.");
-	if (intResult.ok) {
-		require_solidBuilders.propagateAllMetadata(evolution, [a, b], intResult.value);
-		return require_errors.ok({
-			shape: intResult.value,
-			evolution
-		});
-	}
-	return intResult;
-}
-/**
-* Apply a fillet (rounded edge) to selected edges, returning both
-* the result shape and the face evolution data.
-*
-* @param shape - The shape to modify.
-* @param edges - Edges to fillet. Pass `undefined` to fillet all edges.
-* @param radius - Constant radius, variable radius `[r1, r2]`, or per-edge callback.
-*/
-function filletWithEvolution(shape, edges, radius) {
-	const check = validateNotNull$1(shape, "filletWithEvolution: shape");
-	if (require_errors.isErr(check)) return check;
-	if (typeof radius === "number" && radius <= 0) return require_errors.err(require_errors.validationError("INVALID_FILLET_RADIUS", "Fillet radius must be positive", void 0, void 0, "Provide a positive radius value greater than 0"));
-	if (Array.isArray(radius) && (radius[0] <= 0 || radius[1] <= 0)) return require_errors.err(require_errors.validationError("INVALID_FILLET_RADIUS", "Fillet radii must both be positive", void 0, void 0, "Both radius values must be greater than 0"));
-	const selectedEdges = edges ?? require_topologyQueryFns.getEdges(shape);
-	if (selectedEdges.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.FILLET_NO_EDGES, "No edges found for fillet", void 0, void 0, "Check that the shape has edges, or adjust your edge finder criteria"));
-	try {
-		let filteredEdges;
-		let kernelRadius;
-		if (typeof radius === "function") {
-			const resolved = resolveEdgeCallback$1(selectedEdges, radius);
-			if (!resolved) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.FILLET_NO_EDGES, "No edges with positive radius for fillet", void 0, void 0, "Check that the radius callback returns positive values"));
-			filteredEdges = resolved.edges;
-			kernelRadius = resolved.kernelParam;
-		} else {
-			filteredEdges = [...selectedEdges];
-			kernelRadius = radius;
-		}
-		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
-		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().filletWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelRadius, inputFaceHashes, require_constants.HASH_CODE_MAX);
-		const cast = require_shapeTypes.castResultShape(resultShape);
-		if (!require_shapeTypes.isShape3D(cast)) {
-			require_shapeTypes.disposeResultShape(cast);
-			return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape"));
-		}
-		require_solidBuilders.propagateAllMetadata(evolution, [shape], cast);
-		return require_errors.ok({
-			shape: cast,
-			evolution
-		});
-	} catch (e) {
-		const raw = e instanceof Error ? e.message : String(e);
-		return require_errors.err(require_errors.kernelError("FILLET_FAILED", `Fillet operation failed: ${raw}`, e, {
-			operation: "fillet",
-			edgeCount: selectedEdges.length,
-			radius
-		}));
+	if (left.ok && right.ok) {
+		telemetry.singletonFallbacks++;
+		const merged = tryBatch(() => ops.fuse(left.value, right.value, options));
+		if (merged && merged.ok) return merged;
+		for (let i = mid; i < shapes.length; i++) telemetry.failedInputs.add(startIdx + i);
+		return left;
 	}
-}
-/**
-* Apply a chamfer (beveled edge) to selected edges, returning both
-* the result shape and the face evolution data.
-*
-* @param shape - The shape to modify.
-* @param edges - Edges to chamfer. Pass `undefined` to chamfer all edges.
-* @param distance - Symmetric distance, asymmetric `[d1, d2]`, or per-edge callback.
-*/
-function chamferWithEvolution(shape, edges, distance) {
-	const check = validateNotNull$1(shape, "chamferWithEvolution: shape");
-	if (require_errors.isErr(check)) return check;
-	if (typeof distance === "number" && distance <= 0) return require_errors.err(require_errors.validationError("INVALID_CHAMFER_DISTANCE", "Chamfer distance must be positive", void 0, void 0, "Provide a positive distance value greater than 0"));
-	if (Array.isArray(distance) && (distance[0] <= 0 || distance[1] <= 0)) return require_errors.err(require_errors.validationError("INVALID_CHAMFER_DISTANCE", "Chamfer distances must both be positive", void 0, void 0, "Both distance values must be greater than 0"));
-	const selectedEdges = edges ?? require_topologyQueryFns.getEdges(shape);
-	if (selectedEdges.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.CHAMFER_NO_EDGES, "No edges found for chamfer"));
-	try {
-		let filteredEdges;
-		let kernelDistance;
-		if (typeof distance === "function") {
-			const resolved = resolveEdgeCallback$1(selectedEdges, distance);
-			if (!resolved) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.CHAMFER_NO_EDGES, "No edges with positive distance for chamfer"));
-			filteredEdges = resolved.edges;
-			kernelDistance = resolved.kernelParam;
-		} else {
-			filteredEdges = [...selectedEdges];
-			kernelDistance = distance;
-		}
-		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
-		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().chamferWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelDistance, inputFaceHashes, require_constants.HASH_CODE_MAX);
-		const cast = require_shapeTypes.castResultShape(resultShape);
-		if (!require_shapeTypes.isShape3D(cast)) {
-			require_shapeTypes.disposeResultShape(cast);
-			return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.CHAMFER_NOT_3D, "Chamfer result is not a 3D shape"));
-		}
-		require_solidBuilders.propagateAllMetadata(evolution, [shape], cast);
-		return require_errors.ok({
-			shape: cast,
-			evolution
-		});
-	} catch (e) {
-		const raw = e instanceof Error ? e.message : String(e);
-		return require_errors.err(require_errors.kernelError("CHAMFER_FAILED", `Chamfer operation failed: ${raw}`, e, {
-			operation: "chamfer",
-			edgeCount: selectedEdges.length,
-			distance
-		}));
+	if (left.ok) {
+		for (let i = mid; i < shapes.length; i++) telemetry.failedInputs.add(startIdx + i);
+		return left;
+	}
+	if (right.ok) {
+		for (let i = 0; i < mid; i++) telemetry.failedInputs.add(startIdx + i);
+		return right;
 	}
+	return left;
 }
 /**
-* Create a hollow shell by removing faces and offsetting remaining walls,
-* returning both the result shape and the face evolution data.
-*
-* @param shape - The solid to hollow out.
-* @param faces - Faces to remove.
-* @param thickness - Wall thickness.
-* @param tolerance - Shell operation tolerance (default 1e-3).
+* Run a batch boolean op, returning null on kernel throw (signal-aborts
+* propagate). The caller checks for null and bisects.
 */
-function shellWithEvolution(shape, faces, thickness, tolerance = .001) {
-	const check = validateNotNull$1(shape, "shellWithEvolution: shape");
-	if (require_errors.isErr(check)) return check;
-	if (thickness <= 0) return require_errors.err(require_errors.validationError("INVALID_THICKNESS", "Shell thickness must be positive"));
-	if (faces.length === 0) return require_errors.err(require_errors.validationError("NO_FACES", "At least one face must be specified for shell"));
+function tryBatch(fn) {
 	try {
-		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
-		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().shellWithHistory(shape.wrapped, faces.map((f) => f.wrapped), thickness, inputFaceHashes, require_constants.HASH_CODE_MAX, tolerance);
-		const cast = require_shapeTypes.castResultShape(resultShape);
-		if (!require_shapeTypes.isShape3D(cast)) {
-			require_shapeTypes.disposeResultShape(cast);
-			return require_errors.err(require_errors.kernelError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
-		}
-		require_solidBuilders.propagateAllMetadata(evolution, [shape], cast);
-		return require_errors.ok({
-			shape: cast,
-			evolution
-		});
-	} catch (e) {
-		const raw = e instanceof Error ? e.message : String(e);
-		return require_errors.err(require_errors.kernelError("SHELL_FAILED", `Shell operation failed: ${raw}`, e, {
-			operation: "shell",
-			faceCount: faces.length,
-			thickness
-		}));
+		return fn();
+	} catch {
+		return null;
 	}
 }
 //#endregion
-//#region src/topology/positionFns.ts
+//#region src/topology/booleanDiagnosticFns.ts
 /**
-* Curve-based positioning operations.
+* Boolean pre-validation diagnostics.
 */
 /**
-* Position a shape at a point along a spine curve with Frenet frame orientation.
+* Pre-validate operands before a boolean operation.
 *
-* The shape is translated and rotated so its origin aligns with the curve point
-* and its Z axis aligns with the curve tangent at the given parameter.
+* Checks that both shapes are non-null and topologically valid.
+* Returns a structured report of any issues found.
 *
-* @param shape - The shape to position.
-* @param spine - The spine curve (Edge or Wire) to position along.
-* @param param - Normalized parameter (0 = start, 1 = end).
-* @returns The repositioned shape.
+* @example
+* ```typescript
+* const check = checkBoolean(base, tool, 'fuse');
+* if (!check.valid) {
+*   console.warn('Boolean will likely fail:', check.issues);
+* }
+* ```
 */
-function positionOnCurve(shape, spine, param) {
-	try {
-		const result = require_shapeTypes.getKernel().positionOnCurve(shape.wrapped, spine.wrapped, param);
-		const wrapped = require_shapeTypes.castResultShape(result);
-		if (!require_shapeTypes.isShape3D(wrapped)) {
-			require_shapeTypes.disposeResultShape(wrapped);
-			return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.POSITION_ON_CURVE_FAILED, "positionOnCurve did not produce a 3D shape"));
-		}
-		return require_errors.ok(wrapped);
-	} catch (e) {
-		return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.POSITION_ON_CURVE_FAILED, `Failed to position shape on curve at param ${param}`, e));
-	}
+function checkBoolean(base, tool, op) {
+	return require_shapeTypes.getKernel().checkBoolean(base.wrapped, tool.wrapped, op);
 }
 //#endregion
-//#region src/topology/modifierFns.ts
+//#region src/topology/evolutionFns.ts
 /**
-* Functional modifier operations — fillet, chamfer, shell, thicken, offset, draft.
+* Evolution-tracking variants of boolean and modifier operations.
 *
-* These are standalone functions that operate on branded shape types
-* and return Result values.
+* These functions mirror the standard fuse/cut/intersect/fillet/chamfer/shell
+* operations but additionally return the ShapeEvolution data, enabling
+* persistent face selections, constraint tracking, and custom face-level logic.
 */
+function validateShape3D(shape, label) {
+	if (require_shapeTypes.getKernel().isNull(shape.wrapped)) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
+	return require_errors.ok(void 0);
+}
 function validateNotNull(shape, label) {
 	if (require_shapeTypes.getKernel().isNull(shape.wrapped)) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
 	return require_errors.ok(void 0);
 }
-/**
-* Validate that a scalar or `[a, b]` pair is positive.
-* Returns an Err Result on failure, `undefined` on success.
-*
-* Function-type values (per-edge callbacks) are intentionally skipped here --
-* they are validated lazily in {@link resolveEdgeCallback} when each edge is processed.
-*/
-function validatePositiveParam(value, msgs) {
-	if (typeof value === "number" && value <= 0) return require_errors.err(require_errors.validationError(msgs.code, msgs.scalar, void 0, void 0, msgs.scalarHint));
-	if (Array.isArray(value) && (value[0] <= 0 || value[1] <= 0)) return require_errors.err(require_errors.validationError(msgs.code, msgs.pair, void 0, void 0, msgs.pairHint));
+function castToShape3D(shape, errorCode, errorMsg, suggestion) {
+	const wrapped = require_shapeTypes.castShape(shape);
+	if (!require_shapeTypes.isShape3D(wrapped)) {
+		const typeName = require_shapeTypes.getShapeKind(wrapped).toUpperCase();
+		require_shapeTypes.disposeDowncastSource(shape, wrapped);
+		require_shapeTypes.disposeResultShape(wrapped);
+		return require_errors.err(require_errors.typeCastError(errorCode, `${errorMsg}. Got ${typeName} instead.`, void 0, void 0, suggestion));
+	}
+	require_shapeTypes.disposeDowncastSource(shape, wrapped);
+	return require_errors.ok(wrapped);
 }
-/**
-* When the user supplies a per-edge callback, pre-filter edges and build a
-* hash-indexed lookup for the kernel. Returns `null` if no edges survive.
-*/
 function resolveEdgeCallback(selectedEdges, callbackFn) {
 	const filteredEdges = [];
 	const hashToValue = /* @__PURE__ */ new Map();
@@ -634,160 +737,139 @@ function resolveEdgeCallback(selectedEdges, callbackFn) {
 	}
 	if (filteredEdges.length === 0) return null;
 	const kernelParam = (ocEdge) => {
-		const v = hashToValue.get(require_shapeTypes.getKernel().hashCode(ocEdge, require_constants.HASH_CODE_MAX));
-		if (v === void 0) throw new Error("fillet/chamfer: edge hash not found — possible hash collision");
-		return v;
+		return hashToValue.get(require_shapeTypes.getKernel().hashCode(ocEdge, 2147483647)) ?? 1;
 	};
 	return {
 		edges: filteredEdges,
 		kernelParam
 	};
 }
-/**
-* Cast a kernel result to a Shape3D, propagate metadata, and wrap in `ok()`.
-* Returns an error if the result is not a 3D shape.
-*/
-function finalizeShape3D(evolution, resultShape, inputs, not3dCode, not3dMessage) {
-	const cast = require_shapeTypes.castResultShape(resultShape);
-	if (!require_shapeTypes.isShape3D(cast)) {
-		require_shapeTypes.disposeResultShape(cast);
-		return require_errors.err(require_errors.kernelError(not3dCode, not3dMessage));
-	}
-	require_solidBuilders.propagateAllMetadata(evolution, inputs, cast);
-	return require_errors.ok(cast);
-}
-/**
-* When the user supplies a per-face callback for draft angle, pre-filter
-* faces and build a hash-indexed lookup for the kernel.
-*/
-function resolveDraftCallback(faces, angle) {
-	if (typeof angle !== "function") return {
-		filteredFaces: [...faces],
-		kernelAngle: angle
-	};
-	const filteredFaces = [];
-	const hashToAngle = /* @__PURE__ */ new Map();
-	for (const face of faces) {
-		const a = angle(face);
-		if (a === null || a === 0 || Math.abs(a) >= 90) continue;
-		filteredFaces.push(face);
-		hashToAngle.set(require_shapeTypes.getKernel().hashCode(face.wrapped, require_constants.HASH_CODE_MAX), a);
+function fuseWithEvolution(a, b, { optimisation = "none", simplify = false, signal, fuzzyValue } = {}) {
+	if (signal?.aborted) throw signal.reason;
+	const checkA = validateShape3D(a, "fuseWithEvolution: first operand");
+	if (require_errors.isErr(checkA)) return checkA;
+	const checkB = validateShape3D(b, "fuseWithEvolution: second operand");
+	if (require_errors.isErr(checkB)) return checkB;
+	const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([a, b]);
+	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().fuseWithHistory(a.wrapped, b.wrapped, inputFaceHashes, require_constants.HASH_CODE_MAX, {
+		optimisation,
+		simplify,
+		fuzzyValue
+	});
+	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.");
+	if (fuseResult.ok) {
+		require_solidBuilders.propagateAllMetadata(evolution, [a, b], fuseResult.value);
+		return require_errors.ok({
+			shape: fuseResult.value,
+			evolution
+		});
 	}
-	const kernelAngle = (ocFace) => {
-		const a = hashToAngle.get(require_shapeTypes.getKernel().hashCode(ocFace, require_constants.HASH_CODE_MAX));
-		if (a === void 0) throw new Error("draft: face hash not found — possible hash collision");
-		return a;
-	};
-	return {
-		filteredFaces,
-		kernelAngle
-	};
+	return fuseResult;
 }
-/**
-* Thickens a surface (face or shell) into a solid by offsetting it.
-*
-* Takes a planar or non-planar surface shape and creates a solid
-* by offsetting it by the given thickness. Positive thickness offsets
-* along the surface normal; negative thickness offsets against it.
-*/
-function thicken(shape, thickness) {
-	const check = validateNotNull(shape, "thicken: shape");
-	if (require_errors.isErr(check)) return check;
-	try {
-		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
-		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().thickenWithHistory(shape.wrapped, thickness, inputFaceHashes, require_constants.HASH_CODE_MAX);
-		const cast = require_shapeTypes.castResultShape(resultShape);
-		require_solidBuilders.propagateAllMetadata(evolution, [shape], cast);
-		return require_errors.ok(cast);
-	} catch (e) {
-		const raw = e instanceof Error ? e.message : String(e);
-		return require_errors.err(require_errors.kernelError("THICKEN_FAILED", `Thicken operation failed: ${raw}`, e));
+function cutWithEvolution(base, tool, { optimisation = "none", simplify = false, signal, fuzzyValue } = {}) {
+	if (signal?.aborted) throw signal.reason;
+	const checkBase = validateShape3D(base, "cutWithEvolution: base");
+	if (require_errors.isErr(checkBase)) return checkBase;
+	const checkTool = validateShape3D(tool, "cutWithEvolution: tool");
+	if (require_errors.isErr(checkTool)) return checkTool;
+	const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([base, tool]);
+	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().cutWithHistory(base.wrapped, tool.wrapped, inputFaceHashes, require_constants.HASH_CODE_MAX, {
+		optimisation,
+		simplify,
+		fuzzyValue
+	});
+	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.");
+	if (cutResult.ok) {
+		require_solidBuilders.propagateAllMetadata(evolution, [base, tool], cutResult.value);
+		return require_errors.ok({
+			shape: cutResult.value,
+			evolution
+		});
 	}
+	return cutResult;
 }
-/**
-* Validate fillet inputs and resolve the user-supplied radius into a
-* kernel-ready value paired with the filtered edge list.
-*/
-function normalizeFilletInputs(shape, edges, radius) {
-	const check = validateNotNull(shape, "fillet: shape");
-	if (require_errors.isErr(check)) return check;
-	const paramErr = validatePositiveParam(radius, {
-		code: "INVALID_FILLET_RADIUS",
-		scalar: "Fillet radius must be positive",
-		pair: "Fillet radii must both be positive",
-		scalarHint: "Provide a positive radius value greater than 0",
-		pairHint: "Both radius values must be greater than 0"
+function intersectWithEvolution(a, b, { simplify = false, signal, fuzzyValue } = {}) {
+	if (signal?.aborted) throw signal.reason;
+	const checkA = validateShape3D(a, "intersectWithEvolution: first operand");
+	if (require_errors.isErr(checkA)) return checkA;
+	const checkB = validateShape3D(b, "intersectWithEvolution: second operand");
+	if (require_errors.isErr(checkB)) return checkB;
+	const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([a, b]);
+	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().intersectWithHistory(a.wrapped, b.wrapped, inputFaceHashes, require_constants.HASH_CODE_MAX, {
+		simplify,
+		fuzzyValue
 	});
-	if (paramErr) return paramErr;
-	const selectedEdges = edges ?? require_topologyQueryFns.getEdges(shape);
-	if (selectedEdges.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.FILLET_NO_EDGES, "No edges found for fillet", void 0, void 0, "Check that the shape has edges, or adjust your edge finder criteria"));
-	if (typeof radius === "function") {
-		const resolved = resolveEdgeCallback(selectedEdges, radius);
-		if (!resolved) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.FILLET_NO_EDGES, "No edges with positive radius for fillet", void 0, void 0, "Check that the radius callback returns positive values"));
+	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.");
+	if (intResult.ok) {
+		require_solidBuilders.propagateAllMetadata(evolution, [a, b], intResult.value);
 		return require_errors.ok({
-			filteredEdges: resolved.edges,
-			kernelRadius: resolved.kernelParam,
-			selectedCount: selectedEdges.length
+			shape: intResult.value,
+			evolution
 		});
 	}
-	return require_errors.ok({
-		filteredEdges: [...selectedEdges],
-		kernelRadius: radius,
-		selectedCount: selectedEdges.length
-	});
+	return intResult;
 }
 /**
-* Apply a fillet (rounded edge) to selected edges of a 3D shape.
+* Apply a fillet (rounded edge) to selected edges, returning both
+* the result shape and the face evolution data.
 *
 * @param shape - The shape to modify.
 * @param edges - Edges to fillet. Pass `undefined` to fillet all edges.
 * @param radius - Constant radius, variable radius `[r1, r2]`, or per-edge callback.
 */
-function fillet(shape, edges, radius, { trackEvolution = true } = {}) {
-	const normalized = normalizeFilletInputs(shape, edges, radius);
-	if (require_errors.isErr(normalized)) return normalized;
-	const { filteredEdges, kernelRadius, selectedCount } = normalized.value;
+function filletWithEvolution(shape, edges, radius) {
+	const check = validateNotNull(shape, "filletWithEvolution: shape");
+	if (require_errors.isErr(check)) return check;
+	if (typeof radius === "number" && radius <= 0) return require_errors.err(require_errors.validationError("INVALID_FILLET_RADIUS", "Fillet radius must be positive", void 0, void 0, "Provide a positive radius value greater than 0"));
+	if (Array.isArray(radius) && (radius[0] <= 0 || radius[1] <= 0)) return require_errors.err(require_errors.validationError("INVALID_FILLET_RADIUS", "Fillet radii must both be positive", void 0, void 0, "Both radius values must be greater than 0"));
+	const selectedEdges = edges ?? require_topologyQueryFns.getEdges(shape);
+	if (selectedEdges.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.FILLET_NO_EDGES, "No edges found for fillet", void 0, void 0, "Check that the shape has edges, or adjust your edge finder criteria"));
 	try {
-		const edgeShapes = filteredEdges.map((e) => e.wrapped);
-		if (!trackEvolution) {
-			const resultShape = require_shapeTypes.getKernel().fillet(shape.wrapped, edgeShapes, kernelRadius);
-			const cast = require_shapeTypes.castResultShape(resultShape);
-			if (!require_shapeTypes.isShape3D(cast)) {
-				require_shapeTypes.disposeResultShape(cast);
-				return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape"));
-			}
-			return require_errors.ok(cast);
+		let filteredEdges;
+		let kernelRadius;
+		if (typeof radius === "function") {
+			const resolved = resolveEdgeCallback(selectedEdges, radius);
+			if (!resolved) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.FILLET_NO_EDGES, "No edges with positive radius for fillet", void 0, void 0, "Check that the radius callback returns positive values"));
+			filteredEdges = resolved.edges;
+			kernelRadius = resolved.kernelParam;
+		} else {
+			filteredEdges = [...selectedEdges];
+			kernelRadius = radius;
 		}
 		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
-		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().filletWithHistory(shape.wrapped, edgeShapes, kernelRadius, inputFaceHashes, require_constants.HASH_CODE_MAX);
-		return finalizeShape3D(evolution, resultShape, [shape], require_errors.BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape");
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().filletWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelRadius, inputFaceHashes, require_constants.HASH_CODE_MAX);
+		const cast = require_shapeTypes.castResultShape(resultShape);
+		if (!require_shapeTypes.isShape3D(cast)) {
+			require_shapeTypes.disposeResultShape(cast);
+			return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape"));
+		}
+		require_solidBuilders.propagateAllMetadata(evolution, [shape], cast);
+		return require_errors.ok({
+			shape: cast,
+			evolution
+		});
 	} catch (e) {
 		const raw = e instanceof Error ? e.message : String(e);
 		return require_errors.err(require_errors.kernelError("FILLET_FAILED", `Fillet operation failed: ${raw}`, e, {
 			operation: "fillet",
-			edgeCount: selectedCount,
+			edgeCount: selectedEdges.length,
 			radius
 		}));
 	}
 }
 /**
-* Apply a chamfer (beveled edge) to selected edges of a 3D shape.
+* Apply a chamfer (beveled edge) to selected edges, returning both
+* the result shape and the face evolution data.
 *
 * @param shape - The shape to modify.
 * @param edges - Edges to chamfer. Pass `undefined` to chamfer all edges.
 * @param distance - Symmetric distance, asymmetric `[d1, d2]`, or per-edge callback.
 */
-function chamfer(shape, edges, distance) {
-	const check = validateNotNull(shape, "chamfer: shape");
+function chamferWithEvolution(shape, edges, distance) {
+	const check = validateNotNull(shape, "chamferWithEvolution: shape");
 	if (require_errors.isErr(check)) return check;
-	const paramErr = validatePositiveParam(distance, {
-		code: "INVALID_CHAMFER_DISTANCE",
-		scalar: "Chamfer distance must be positive",
-		pair: "Chamfer distances must both be positive",
-		scalarHint: "Provide a positive distance value greater than 0",
-		pairHint: "Both distance values must be greater than 0"
-	});
-	if (paramErr) return paramErr;
+	if (typeof distance === "number" && distance <= 0) return require_errors.err(require_errors.validationError("INVALID_CHAMFER_DISTANCE", "Chamfer distance must be positive", void 0, void 0, "Provide a positive distance value greater than 0"));
+	if (Array.isArray(distance) && (distance[0] <= 0 || distance[1] <= 0)) return require_errors.err(require_errors.validationError("INVALID_CHAMFER_DISTANCE", "Chamfer distances must both be positive", void 0, void 0, "Both distance values must be greater than 0"));
 	const selectedEdges = edges ?? require_topologyQueryFns.getEdges(shape);
 	if (selectedEdges.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.CHAMFER_NO_EDGES, "No edges found for chamfer"));
 	try {
@@ -804,7 +886,16 @@ function chamfer(shape, edges, distance) {
 		}
 		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
 		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().chamferWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelDistance, inputFaceHashes, require_constants.HASH_CODE_MAX);
-		return finalizeShape3D(evolution, resultShape, [shape], require_errors.BrepErrorCode.CHAMFER_NOT_3D, "Chamfer result is not a 3D shape");
+		const cast = require_shapeTypes.castResultShape(resultShape);
+		if (!require_shapeTypes.isShape3D(cast)) {
+			require_shapeTypes.disposeResultShape(cast);
+			return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.CHAMFER_NOT_3D, "Chamfer result is not a 3D shape"));
+		}
+		require_solidBuilders.propagateAllMetadata(evolution, [shape], cast);
+		return require_errors.ok({
+			shape: cast,
+			evolution
+		});
 	} catch (e) {
 		const raw = e instanceof Error ? e.message : String(e);
 		return require_errors.err(require_errors.kernelError("CHAMFER_FAILED", `Chamfer operation failed: ${raw}`, e, {
@@ -815,28 +906,20 @@ function chamfer(shape, edges, distance) {
 	}
 }
 /**
-* Create a hollow shell by removing faces and offsetting remaining walls.
+* Create a hollow shell by removing faces and offsetting remaining walls,
+* returning both the result shape and the face evolution data.
 *
 * @param shape - The solid to hollow out.
 * @param faces - Faces to remove.
 * @param thickness - Wall thickness.
 * @param tolerance - Shell operation tolerance (default 1e-3).
 */
-function shell(shape, faces, thickness, tolerance = .001, { trackEvolution = true } = {}) {
-	const check = validateNotNull(shape, "shell: shape");
+function shellWithEvolution(shape, faces, thickness, tolerance = .001) {
+	const check = validateNotNull(shape, "shellWithEvolution: shape");
 	if (require_errors.isErr(check)) return check;
 	if (thickness <= 0) return require_errors.err(require_errors.validationError("INVALID_THICKNESS", "Shell thickness must be positive"));
 	if (faces.length === 0) return require_errors.err(require_errors.validationError("NO_FACES", "At least one face must be specified for shell"));
 	try {
-		if (!trackEvolution) {
-			const resultShape = require_shapeTypes.getKernel().shell(shape.wrapped, faces.map((f) => f.wrapped), thickness, tolerance);
-			const cast = require_shapeTypes.castResultShape(resultShape);
-			if (!require_shapeTypes.isShape3D(cast)) {
-				require_shapeTypes.disposeResultShape(cast);
-				return require_errors.err(require_errors.kernelError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
-			}
-			return require_errors.ok(cast);
-		}
 		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
 		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().shellWithHistory(shape.wrapped, faces.map((f) => f.wrapped), thickness, inputFaceHashes, require_constants.HASH_CODE_MAX, tolerance);
 		const cast = require_shapeTypes.castResultShape(resultShape);
@@ -845,7 +928,10 @@ function shell(shape, faces, thickness, tolerance = .001, { trackEvolution = tru
 			return require_errors.err(require_errors.kernelError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
 		}
 		require_solidBuilders.propagateAllMetadata(evolution, [shape], cast);
-		return require_errors.ok(cast);
+		return require_errors.ok({
+			shape: cast,
+			evolution
+		});
 	} catch (e) {
 		const raw = e instanceof Error ? e.message : String(e);
 		return require_errors.err(require_errors.kernelError("SHELL_FAILED", `Shell operation failed: ${raw}`, e, {
@@ -855,119 +941,33 @@ function shell(shape, faces, thickness, tolerance = .001, { trackEvolution = tru
 		}));
 	}
 }
+//#endregion
+//#region src/topology/positionFns.ts
 /**
-* Offset all faces of a shape by a given distance.
-*
-* @param shape - The shape to offset (must be a 3D shape with faces).
-* @param distance - Offset distance (positive = outward, negative = inward).
-* @param tolerance - Offset tolerance (default 1e-6).
-*/
-function offset(shape, distance, tolerance = 1e-6) {
-	const check = validateNotNull(shape, "offset: shape");
-	if (require_errors.isErr(check)) return check;
-	if (Math.abs(distance) < 1e-10) return require_errors.err(require_errors.validationError("ZERO_OFFSET", "Offset distance cannot be zero"));
-	try {
-		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
-		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().offsetWithHistory(shape.wrapped, distance, inputFaceHashes, require_constants.HASH_CODE_MAX, tolerance);
-		const cast = require_shapeTypes.castResultShape(resultShape);
-		if (!require_shapeTypes.isShape3D(cast)) {
-			require_shapeTypes.disposeResultShape(cast);
-			return require_errors.err(require_errors.kernelError("OFFSET_RESULT_NOT_3D", "Offset result is not a 3D shape"));
-		}
-		require_solidBuilders.propagateAllMetadata(evolution, [shape], cast);
-		return require_errors.ok(cast);
-	} catch (e) {
-		const raw = e instanceof Error ? e.message : String(e);
-		return require_errors.err(require_errors.kernelError("OFFSET_FAILED", `Offset operation failed: ${raw}`, e));
-	}
-}
-/**
-* Validate draft inputs (null shape, scalar angle bounds, faces non-empty).
-* Returns an Err Result on failure, `undefined` on success.
-*/
-function validateDraftInputs(shape, faces, angle) {
-	const check = validateNotNull(shape, "draft: shape");
-	if (require_errors.isErr(check)) return check;
-	if (typeof angle === "number") {
-		if (Math.abs(angle) < 1e-10) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.DRAFT_INVALID_ANGLE, "Draft angle cannot be zero", void 0, void 0, "Provide a non-zero angle in degrees"));
-		if (Math.abs(angle) >= 90) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.DRAFT_INVALID_ANGLE, "Draft angle must be between -90 and 90 degrees (exclusive)", void 0, void 0, "Typical draft angles are 1-5 degrees for injection molding"));
-	}
-	if (faces.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.DRAFT_NO_FACES, "No faces specified for draft", void 0, void 0, "Select at least one face to apply the draft angle to"));
-}
-/**
-* Apply a draft (taper) to selected faces of a 3D shape.
-*
-* Draft tilts faces by a specified angle relative to a pull direction,
-* pivoting about a neutral plane. This is essential for injection molding
-* and casting workflows where parts must release from a mold.
-*
-* @param shape - The solid to modify.
-* @param faces - Faces to draft.
-* @param pullDirection - Mold opening direction vector.
-* @param neutralPlane - A point on the plane where faces are not displaced.
-* @param angle - Constant angle in degrees, or per-face callback returning degrees (null to skip).
+* Curve-based positioning operations.
 */
-function draft(shape, faces, pullDirection, neutralPlane, angle) {
-	const inputErr = validateDraftInputs(shape, faces, angle);
-	if (inputErr) return inputErr;
-	try {
-		const { filteredFaces, kernelAngle } = resolveDraftCallback(faces, angle);
-		if (filteredFaces.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.DRAFT_NO_FACES, "No faces with valid draft angle", void 0, void 0, "Check that the angle callback returns non-zero values between -90 and 90 degrees"));
-		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
-		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().draftWithHistory(shape.wrapped, filteredFaces.map((f) => f.wrapped), [
-			pullDirection[0],
-			pullDirection[1],
-			pullDirection[2]
-		], [
-			neutralPlane[0],
-			neutralPlane[1],
-			neutralPlane[2]
-		], kernelAngle, inputFaceHashes, require_constants.HASH_CODE_MAX);
-		return finalizeShape3D(evolution, resultShape, [shape], require_errors.BrepErrorCode.DRAFT_NOT_3D, "Draft result is not a 3D shape");
-	} catch (e) {
-		const raw = e instanceof Error ? e.message : String(e);
-		return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.DRAFT_FAILED, `Draft operation failed: ${raw}`, e, {
-			operation: "draft",
-			faceCount: faces.length,
-			angle
-		}));
-	}
-}
 /**
-* Apply a variable-radius fillet to an edge.
+* Position a shape at a point along a spine curve with Frenet frame orientation.
 *
-* The radius varies along the edge according to the provided spec points.
-* Each point specifies a normalized parameter (0 = start, 1 = end) and radius.
+* The shape is translated and rotated so its origin aligns with the curve point
+* and its Z axis aligns with the curve tangent at the given parameter.
 *
-* **Cross-kernel note:** brepkit supports arbitrary multi-point radius profiles.
-* occt-wasm supports a linear (start/end, <=2-point) profile and returns
-* UNSUPPORTED for multi-point; the opencascade.js kernel does not implement it.
+* @param shape - The shape to position.
+* @param spine - The spine curve (Edge or Wire) to position along.
+* @param param - Normalized parameter (0 = start, 1 = end).
+* @returns The repositioned shape.
 */
-function variableFillet(shape, edge, radii) {
-	if (radii.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.VARIABLE_FILLET_FAILED, "radii must contain at least one radius spec"));
-	for (const r of radii) if (r.radius <= 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.VARIABLE_FILLET_FAILED, "All radius values must be positive"));
-	const kernel = require_shapeTypes.getKernel();
+function positionOnCurve(shape, spine, param) {
 	try {
-		const spec = JSON.stringify({
-			edge: kernel.hashCode(edge.wrapped, require_constants.HASH_CODE_MAX),
-			radii: radii.map((r) => ({
-				param: r.param,
-				radius: r.radius
-			}))
-		});
-		const result = kernel.filletVariable(shape.wrapped, spec);
+		const result = require_shapeTypes.getKernel().positionOnCurve(shape.wrapped, spine.wrapped, param);
 		const wrapped = require_shapeTypes.castResultShape(result);
 		if (!require_shapeTypes.isShape3D(wrapped)) {
 			require_shapeTypes.disposeResultShape(wrapped);
-			return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.VARIABLE_FILLET_FAILED, "Variable-radius fillet did not produce a 3D shape"));
-		}
-		if (!require_shapeTypes.isSolid(wrapped)) {
-			require_shapeTypes.disposeResultShape(wrapped);
-			return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.VARIABLE_FILLET_FAILED, "Variable-radius fillet did not produce a solid"));
+			return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.POSITION_ON_CURVE_FAILED, "positionOnCurve did not produce a 3D shape"));
 		}
 		return require_errors.ok(wrapped);
 	} catch (e) {
-		return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.VARIABLE_FILLET_FAILED, "Variable-radius fillet failed", e));
+		return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.POSITION_ON_CURVE_FAILED, `Failed to position shape on curve at param ${param}`, e));
 	}
 }
 //#endregion