brepjs 13.0.0 → 13.2.0

package/dist/primitiveFns-CASk8g16.js

@@ -0,0 +1,1452 @@
+import { Y as getKernel, _ as isSolid, c as createSolid, h as isShape3D, p as isFace, r as castShapeWithKnownType, t as castShape, x as isClosedWire, y as isWire } from "./shapeTypes-CYb8Byqj.js";
+import { C as isErr, _ as andThen, d as validationError, i as kernelError, k as ok, l as typeCastError, t as BrepErrorCode, w as isOk, y as err } from "./errors-B_T0aMQF.js";
+import { _ as DEG2RAD, v as HASH_CODE_MAX } from "./vecOps-B9-MTeC8.js";
+import { _ as downcast } from "./faceFns-EnGcKFAr.js";
+import { F as getEdges, I as getFaces, L as getOrCreateCache, b as propagateAllMetadata, v as translate, y as collectInputFaceHashes, z as getWires } from "./arrayAccess-Dps31ERU.js";
+import { a as makeNonPlanarFace, c as makeBSplineApproximation, d as makeEllipse, f as makeEllipseArc, g as makeThreePointArc, h as makeTangentArc, i as makeNewFaceWithinFace, l as makeBezierCurve, m as makeLine, o as makePolygon, p as makeHelix, r as makeFace, s as assembleWire, t as addHolesInFace, u as makeCircle } from "./surfaceBuilders-DnGdDW8i.js";
+import { a as makeOffset, c as makeTorus, i as makeEllipsoid, l as makeVertex, n as makeCone, o as makeSolid, r as makeCylinder, s as makeSphere, t as makeCompound, u as weldShellsAndFaces } from "./solidBuilders-ClJxiUa3.js";
+//#region src/topology/threeHelpers.ts
+/**
+* Convert a ShapeMesh into BufferGeometry-compatible typed arrays.
+*
+* The returned arrays can be used directly with Three.js:
+* ```ts
+* const geo = new THREE.BufferGeometry();
+* geo.setAttribute('position', new THREE.BufferAttribute(data.position, 3));
+* geo.setAttribute('normal', new THREE.BufferAttribute(data.normal, 3));
+* geo.setIndex(new THREE.BufferAttribute(data.index, 1));
+* ```
+*/
+function toBufferGeometryData(mesh) {
+	return {
+		position: mesh.vertices,
+		normal: mesh.normals,
+		index: mesh.triangles
+	};
+}
+/**
+* Convert a ShapeMesh into grouped BufferGeometry data with face material groups.
+*
+* Each face becomes a separate group, allowing per-face materials in Three.js:
+* ```ts
+* const data = toGroupedBufferGeometryData(mesh);
+* const geo = new THREE.BufferGeometry();
+* geo.setAttribute('position', new THREE.BufferAttribute(data.position, 3));
+* geo.setAttribute('normal', new THREE.BufferAttribute(data.normal, 3));
+* geo.setIndex(new THREE.BufferAttribute(data.index, 1));
+* for (const g of data.groups) {
+*   geo.addGroup(g.start, g.count, g.materialIndex);
+* }
+* ```
+*/
+function toGroupedBufferGeometryData(mesh) {
+	return {
+		position: mesh.vertices,
+		normal: mesh.normals,
+		index: mesh.triangles,
+		groups: mesh.faceGroups.map((g, i) => ({
+			start: g.start,
+			count: g.count,
+			materialIndex: i,
+			faceId: g.faceId
+		}))
+	};
+}
+/**
+* Convert an EdgeMesh into position data for THREE.LineSegments.
+*
+* ```ts
+* const geo = new THREE.BufferGeometry();
+* geo.setAttribute('position', new THREE.BufferAttribute(data.position, 3));
+* const lines = new THREE.LineSegments(geo, material);
+* ```
+*/
+function toLineGeometryData(mesh) {
+	return { position: mesh.lines };
+}
+//#endregion
+//#region src/topology/chamferAngleFns.ts
+/**
+* Chamfer with distance + angle — functional API.
+*
+* Provides chamferDistAngle() which chamfers edges using a distance
+* measured along one face and an angle to determine the chamfer on the other.
+*/
+/**
+* Chamfer edges of a shape using distance + angle.
+*
+* The distance is measured along the face that contains the edge, and the
+* angle (in degrees) determines how the chamfer cuts into the adjacent face.
+*
+* @param shape   - The 3D shape to chamfer.
+* @param edges   - Edges to chamfer (must not be empty).
+* @param distance - Chamfer distance along the face (must be positive).
+* @param angleDeg - Chamfer angle in degrees (must be in range (0, 90)).
+* @returns Ok with the chamfered shape, or Err on invalid input or kernel failure.
+*
+* @remarks Uses `BRepFilletAPI_MakeChamfer.AddDA(dist, angle, edge, face)` internally.
+*/
+function chamferDistAngle(shape, edges, distance, angleDeg) {
+	if (edges.length === 0) return err(validationError("CHAMFER_ANGLE_NO_EDGES", "chamferDistAngle requires at least one edge", void 0, { edgeCount: 0 }));
+	if (distance <= 0) return err(validationError("CHAMFER_ANGLE_BAD_DISTANCE", `distance must be positive, got ${distance}`, void 0, { distance }));
+	if (angleDeg <= 0 || angleDeg >= 90) return err(validationError("CHAMFER_ANGLE_BAD_ANGLE", `angleDeg must be in range (0, 90), got ${angleDeg}`, void 0, { angleDeg }));
+	let raw;
+	try {
+		const kernel = getKernel();
+		const rawEdges = edges.map((e) => e.wrapped);
+		raw = kernel.chamferDistAngle(shape.wrapped, rawEdges, distance, angleDeg);
+	} catch (e) {
+		return err(kernelError("CHAMFER_ANGLE_FAILED", `chamferDistAngle kernel call failed: ${e instanceof Error ? e.message : String(e)}`, e, {
+			distance,
+			angleDeg,
+			edgeCount: edges.length
+		}));
+	}
+	const downcastResult = downcast(raw);
+	if (isErr(downcastResult)) return downcastResult;
+	const wrapped = castShape(downcastResult.value);
+	if (!isShape3D(wrapped)) {
+		wrapped[Symbol.dispose]();
+		return err(typeCastError("CHAMFER_ANGLE_NOT_3D", "chamferDistAngle did not produce a 3D shape"));
+	}
+	return ok(wrapped);
+}
+//#endregion
+//#region src/topology/adjacencyFns.ts
+/**
+* Topology adjacency queries — find related sub-shapes within a parent shape.
+*
+* Uses cached topology extraction and an edge→faces adjacency map
+* (built once per parent shape and cached) to avoid redundant WASM calls.
+*/
+function wrapAll(shapes, type) {
+	return shapes.map((s) => castShapeWithKnownType(s, type));
+}
+/**
+* Iterate sub-shapes of `parentKernel` of the given `type`, deduplicate by
+* hash+isSame, and return branded handles of type `T`.
+*
+* Used by edgesOfFace, wiresOfFace, and verticesOfEdge — all of which need
+* the same deduplicated-children pattern on a raw KernelShape.
+*/
+function deduplicatedSubShapes(parentKernel, type) {
+	const kernel = getKernel();
+	const items = kernel.iterShapes(parentKernel, type);
+	const results = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const hash = kernel.hashCode(item, HASH_CODE_MAX);
+		const bucket = seen.get(hash);
+		if (!bucket) {
+			seen.set(hash, [item]);
+			results.push(item);
+		} else if (!bucket.some((r) => kernel.isSame(r, item))) {
+			bucket.push(item);
+			results.push(item);
+		}
+	}
+	return wrapAll(results, type);
+}
+/**
+* Build or retrieve the cached edge→faces adjacency map for a parent shape.
+* Maps edge hash codes to edge-face pairs, storing the edge alongside each
+* face so facesOfEdge can verify via isSame without re-extracting face edges.
+*/
+function getEdgeToFacesMap(parent) {
+	const cache = getOrCreateCache(parent);
+	if (cache.edgeToFaces) return cache.edgeToFaces;
+	const kernel = getKernel();
+	const edgeToFaces = /* @__PURE__ */ new Map();
+	const allFaces = kernel.iterShapes(parent.wrapped, "face");
+	for (const f of allFaces) {
+		const edges = kernel.iterShapes(f, "edge");
+		for (const e of edges) {
+			const hash = kernel.hashCode(e, HASH_CODE_MAX);
+			let bucket = edgeToFaces.get(hash);
+			if (!bucket) {
+				bucket = [];
+				edgeToFaces.set(hash, bucket);
+			}
+			if (!bucket.some((entry) => kernel.isSame(entry.edge, e) && kernel.isSame(entry.face, f))) bucket.push({
+				edge: e,
+				face: f
+			});
+		}
+	}
+	cache.edgeToFaces = edgeToFaces;
+	return edgeToFaces;
+}
+/**
+* Get all faces adjacent to a given edge within a parent shape.
+*
+* An edge typically borders exactly two faces in a solid, or one face
+* if the edge is on a boundary.
+*
+* @param parent - The parent shape to search within.
+* @param edge - The edge whose adjacent faces to find.
+* @returns Array of unique faces containing the given edge.
+*/
+function facesOfEdge(parent, edge) {
+	const kernel = getKernel();
+	const edgeToFaces = getEdgeToFacesMap(parent);
+	const hash = kernel.hashCode(edge.wrapped, HASH_CODE_MAX);
+	const bucket = edgeToFaces.get(hash) ?? [];
+	const results = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const entry of bucket) {
+		if (!kernel.isSame(entry.edge, edge.wrapped)) continue;
+		const fHash = kernel.hashCode(entry.face, HASH_CODE_MAX);
+		const fBucket = seen.get(fHash);
+		if (!fBucket) {
+			seen.set(fHash, [entry.face]);
+			results.push(entry.face);
+		} else if (!fBucket.some((r) => kernel.isSame(r, entry.face))) {
+			fBucket.push(entry.face);
+			results.push(entry.face);
+		}
+	}
+	return wrapAll(results, "face");
+}
+/**
+* Get all edges bounding a face.
+*
+* @param face - The face whose edges to enumerate.
+* @returns Array of unique edges forming the face boundary.
+*/
+function edgesOfFace(face) {
+	return deduplicatedSubShapes(face.wrapped, "edge");
+}
+/**
+* Get all wires of a face (outer wire + inner hole wires).
+* All wires bounding a face are closed by definition.
+*
+* @param face - The face whose wires to enumerate.
+*/
+function wiresOfFace(face) {
+	return deduplicatedSubShapes(face.wrapped, "wire");
+}
+/**
+* Get the start and end vertices of an edge.
+*
+* @param edge - The edge whose vertices to retrieve.
+* @returns Array of 1-2 vertices (1 if degenerate/closed, 2 otherwise).
+*/
+function verticesOfEdge(edge) {
+	return deduplicatedSubShapes(edge.wrapped, "vertex");
+}
+/**
+* Get all faces that share at least one edge with the given face.
+*
+* The returned list does not include the input face itself.
+* Uses the cached edge→faces adjacency map for the parent shape.
+*
+* @param parent - The parent shape to search within.
+* @param face - The face whose neighbors to find.
+* @returns Array of unique adjacent faces (excluding the input face).
+*/
+function adjacentFaces(parent, face) {
+	const kernel = getKernel();
+	const edgeToFaces = getEdgeToFacesMap(parent);
+	const faceEdgeHandles = deduplicatedSubShapes(face.wrapped, "edge");
+	const neighborRaw = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const edgeHandle of faceEdgeHandles) {
+		const hash = kernel.hashCode(edgeHandle.wrapped, HASH_CODE_MAX);
+		const entries = edgeToFaces.get(hash) ?? [];
+		for (const entry of entries) {
+			if (kernel.isSame(entry.face, face.wrapped)) continue;
+			const fHash = kernel.hashCode(entry.face, HASH_CODE_MAX);
+			const bucket = seen.get(fHash);
+			if (!bucket) {
+				seen.set(fHash, [entry.face]);
+				neighborRaw.push(entry.face);
+			} else if (!bucket.some((r) => kernel.isSame(r, entry.face))) {
+				bucket.push(entry.face);
+				neighborRaw.push(entry.face);
+			}
+		}
+	}
+	return wrapAll(neighborRaw, "face");
+}
+/**
+* Get all edges shared between two faces.
+*
+* @param face1 - The first face.
+* @param face2 - The second face.
+* @returns Array of edges present in both faces (via isSame comparison).
+*/
+function sharedEdges(face1, face2) {
+	const kernel = getKernel();
+	const edges1 = kernel.iterShapes(face1.wrapped, "edge");
+	const edges2 = kernel.iterShapes(face2.wrapped, "edge");
+	const edge2Map = /* @__PURE__ */ new Map();
+	for (const e2 of edges2) {
+		const hash = kernel.hashCode(e2, HASH_CODE_MAX);
+		let bucket = edge2Map.get(hash);
+		if (!bucket) {
+			bucket = [];
+			edge2Map.set(hash, bucket);
+		}
+		bucket.push(e2);
+	}
+	const shared = [];
+	for (const e1 of edges1) if (edge2Map.get(kernel.hashCode(e1, 2147483647))?.some((e2) => kernel.isSame(e1, e2))) shared.push(e1);
+	return wrapAll(shared, "edge");
+}
+//#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 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 (getKernel().isNull(shape.wrapped)) return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
+	return ok(void 0);
+}
+function validateNotNull$1(shape, label) {
+	if (getKernel().isNull(shape.wrapped)) return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
+	return ok(void 0);
+}
+function castToShape3D(shape, errorCode, errorMsg, suggestion) {
+	const wrapped = castShape(shape);
+	if (!isShape3D(wrapped)) {
+		const shapeType = shape.ShapeType();
+		const typeName = [
+			"COMPOUND",
+			"COMPSOLID",
+			"SOLID",
+			"SHELL",
+			"FACE",
+			"WIRE",
+			"EDGE",
+			"VERTEX",
+			"SHAPE"
+		][shapeType] ?? `UNKNOWN(${shapeType})`;
+		wrapped[Symbol.dispose]();
+		return err(typeCastError(errorCode, `${errorMsg}. Got ${typeName} instead.`, void 0, void 0, suggestion));
+	}
+	return 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(getKernel().hashCode(edge.wrapped, HASH_CODE_MAX), val);
+	}
+	if (filteredEdges.length === 0) return null;
+	const kernelParam = (ocEdge) => {
+		return hashToValue.get(ocEdge.HashCode(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 (isErr(checkA)) return checkA;
+	const checkB = validateShape3D(b, "fuseWithEvolution: second operand");
+	if (isErr(checkB)) return checkB;
+	const inputFaceHashes = collectInputFaceHashes([a, b]);
+	const { shape: resultShape, evolution } = getKernel().fuseWithHistory(a.wrapped, b.wrapped, inputFaceHashes, 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) {
+		propagateAllMetadata(evolution, [a, b], fuseResult.value);
+		return 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 (isErr(checkBase)) return checkBase;
+	const checkTool = validateShape3D(tool, "cutWithEvolution: tool");
+	if (isErr(checkTool)) return checkTool;
+	const inputFaceHashes = collectInputFaceHashes([base, tool]);
+	const { shape: resultShape, evolution } = getKernel().cutWithHistory(base.wrapped, tool.wrapped, inputFaceHashes, 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) {
+		propagateAllMetadata(evolution, [base, tool], cutResult.value);
+		return 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 (isErr(checkA)) return checkA;
+	const checkB = validateShape3D(b, "intersectWithEvolution: second operand");
+	if (isErr(checkB)) return checkB;
+	const inputFaceHashes = collectInputFaceHashes([a, b]);
+	const { shape: resultShape, evolution } = getKernel().intersectWithHistory(a.wrapped, b.wrapped, inputFaceHashes, 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) {
+		propagateAllMetadata(evolution, [a, b], intResult.value);
+		return 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 (isErr(check)) return check;
+	if (typeof radius === "number" && radius <= 0) return err(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 err(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 ?? getEdges(shape);
+	if (selectedEdges.length === 0) return err(validationError(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 err(validationError(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 = collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = getKernel().filletWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelRadius, inputFaceHashes, HASH_CODE_MAX);
+		const cast = castShape(resultShape);
+		if (!isShape3D(cast)) return err(kernelError(BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape"));
+		propagateAllMetadata(evolution, [shape], cast);
+		return ok({
+			shape: cast,
+			evolution
+		});
+	} catch (e) {
+		return err(kernelError("FILLET_FAILED", `Fillet operation failed: ${e instanceof Error ? e.message : String(e)}`, e, {
+			operation: "fillet",
+			edgeCount: selectedEdges.length,
+			radius
+		}));
+	}
+}
+/**
+* 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 (isErr(check)) return check;
+	if (typeof distance === "number" && distance <= 0) return err(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 err(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 ?? getEdges(shape);
+	if (selectedEdges.length === 0) return err(validationError(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 err(validationError(BrepErrorCode.CHAMFER_NO_EDGES, "No edges with positive distance for chamfer"));
+			filteredEdges = resolved.edges;
+			kernelDistance = resolved.kernelParam;
+		} else {
+			filteredEdges = [...selectedEdges];
+			kernelDistance = distance;
+		}
+		const inputFaceHashes = collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = getKernel().chamferWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelDistance, inputFaceHashes, HASH_CODE_MAX);
+		const cast = castShape(resultShape);
+		if (!isShape3D(cast)) return err(kernelError(BrepErrorCode.CHAMFER_NOT_3D, "Chamfer result is not a 3D shape"));
+		propagateAllMetadata(evolution, [shape], cast);
+		return ok({
+			shape: cast,
+			evolution
+		});
+	} catch (e) {
+		return err(kernelError("CHAMFER_FAILED", `Chamfer operation failed: ${e instanceof Error ? e.message : String(e)}`, e, {
+			operation: "chamfer",
+			edgeCount: selectedEdges.length,
+			distance
+		}));
+	}
+}
+/**
+* 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 shellWithEvolution(shape, faces, thickness, tolerance = .001) {
+	const check = validateNotNull$1(shape, "shellWithEvolution: shape");
+	if (isErr(check)) return check;
+	if (thickness <= 0) return err(validationError("INVALID_THICKNESS", "Shell thickness must be positive"));
+	if (faces.length === 0) return err(validationError("NO_FACES", "At least one face must be specified for shell"));
+	try {
+		const inputFaceHashes = collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = getKernel().shellWithHistory(shape.wrapped, faces.map((f) => f.wrapped), thickness, inputFaceHashes, HASH_CODE_MAX, tolerance);
+		const cast = castShape(resultShape);
+		if (!isShape3D(cast)) return err(kernelError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
+		propagateAllMetadata(evolution, [shape], cast);
+		return ok({
+			shape: cast,
+			evolution
+		});
+	} catch (e) {
+		return err(kernelError("SHELL_FAILED", `Shell operation failed: ${e instanceof Error ? e.message : String(e)}`, e, {
+			operation: "shell",
+			faceCount: faces.length,
+			thickness
+		}));
+	}
+}
+//#endregion
+//#region src/topology/positionFns.ts
+/**
+* Curve-based positioning operations.
+*/
+/**
+* Position a shape at a point along a spine curve with Frenet frame orientation.
+*
+* 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.
+*
+* @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 positionOnCurve(shape, spine, param) {
+	try {
+		const wrapped = castShape(getKernel().positionOnCurve(shape.wrapped, spine.wrapped, param));
+		if (!isShape3D(wrapped)) return err(kernelError(BrepErrorCode.POSITION_ON_CURVE_FAILED, "positionOnCurve did not produce a 3D shape"));
+		return ok(wrapped);
+	} catch (e) {
+		return err(kernelError(BrepErrorCode.POSITION_ON_CURVE_FAILED, `Failed to position shape on curve at param ${param}`, e));
+	}
+}
+//#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(shape, label) {
+	if (getKernel().isNull(shape.wrapped)) return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
+	return 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 err(validationError(msgs.code, msgs.scalar, void 0, void 0, msgs.scalarHint));
+	if (Array.isArray(value) && (value[0] <= 0 || value[1] <= 0)) return err(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(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(getKernel().hashCode(edge.wrapped, HASH_CODE_MAX), val);
+	}
+	if (filteredEdges.length === 0) return null;
+	const kernelParam = (ocEdge) => {
+		return hashToValue.get(ocEdge.HashCode(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 = castShape(resultShape);
+	if (!isShape3D(cast)) return err(kernelError(not3dCode, not3dMessage));
+	propagateAllMetadata(evolution, inputs, cast);
+	return 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(getKernel().hashCode(face.wrapped, HASH_CODE_MAX), a);
+	}
+	const kernelAngle = (ocFace) => {
+		const a = hashToAngle.get(ocFace.HashCode(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(shape, "thicken: shape");
+	if (isErr(check)) return check;
+	try {
+		const inputFaceHashes = collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = getKernel().thickenWithHistory(shape.wrapped, thickness, inputFaceHashes, HASH_CODE_MAX);
+		const cast = castShape(resultShape);
+		propagateAllMetadata(evolution, [shape], cast);
+		return ok(cast);
+	} catch (e) {
+		return err(kernelError("THICKEN_FAILED", `Thicken operation failed: ${e instanceof Error ? e.message : String(e)}`, e));
+	}
+}
+/**
+* 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) {
+	const check = validateNotNull(shape, "fillet: shape");
+	if (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 ?? getEdges(shape);
+	if (selectedEdges.length === 0) return err(validationError(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(selectedEdges, radius);
+			if (!resolved) return err(validationError(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 = collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = getKernel().filletWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelRadius, inputFaceHashes, HASH_CODE_MAX);
+		return finalizeShape3D(evolution, resultShape, [shape], BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape");
+	} catch (e) {
+		return err(kernelError("FILLET_FAILED", `Fillet operation failed: ${e instanceof Error ? e.message : String(e)}`, e, {
+			operation: "fillet",
+			edgeCount: selectedEdges.length,
+			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(shape, "chamfer: shape");
+	if (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 ?? getEdges(shape);
+	if (selectedEdges.length === 0) return err(validationError(BrepErrorCode.CHAMFER_NO_EDGES, "No edges found for chamfer"));
+	try {
+		let filteredEdges;
+		let kernelDistance;
+		if (typeof distance === "function") {
+			const resolved = resolveEdgeCallback(selectedEdges, distance);
+			if (!resolved) return err(validationError(BrepErrorCode.CHAMFER_NO_EDGES, "No edges with positive distance for chamfer"));
+			filteredEdges = resolved.edges;
+			kernelDistance = resolved.kernelParam;
+		} else {
+			filteredEdges = [...selectedEdges];
+			kernelDistance = distance;
+		}
+		const inputFaceHashes = collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = getKernel().chamferWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelDistance, inputFaceHashes, HASH_CODE_MAX);
+		return finalizeShape3D(evolution, resultShape, [shape], BrepErrorCode.CHAMFER_NOT_3D, "Chamfer result is not a 3D shape");
+	} catch (e) {
+		return err(kernelError("CHAMFER_FAILED", `Chamfer operation failed: ${e instanceof Error ? e.message : String(e)}`, 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) {
+	const check = validateNotNull(shape, "shell: shape");
+	if (isErr(check)) return check;
+	if (thickness <= 0) return err(validationError("INVALID_THICKNESS", "Shell thickness must be positive"));
+	if (faces.length === 0) return err(validationError("NO_FACES", "At least one face must be specified for shell"));
+	try {
+		const inputFaceHashes = collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = getKernel().shellWithHistory(shape.wrapped, faces.map((f) => f.wrapped), thickness, inputFaceHashes, HASH_CODE_MAX, tolerance);
+		const cast = castShape(resultShape);
+		if (!isShape3D(cast)) return err(kernelError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
+		propagateAllMetadata(evolution, [shape], cast);
+		return ok(cast);
+	} catch (e) {
+		return err(kernelError("SHELL_FAILED", `Shell operation failed: ${e instanceof Error ? e.message : String(e)}`, 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(shape, "offset: shape");
+	if (isErr(check)) return check;
+	if (distance === 0) return err(validationError("ZERO_OFFSET", "Offset distance cannot be zero"));
+	try {
+		const inputFaceHashes = collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = getKernel().offsetWithHistory(shape.wrapped, distance, inputFaceHashes, HASH_CODE_MAX, tolerance);
+		const cast = castShape(resultShape);
+		if (!isShape3D(cast)) return err(kernelError("OFFSET_RESULT_NOT_3D", "Offset result is not a 3D shape"));
+		propagateAllMetadata(evolution, [shape], cast);
+		return ok(cast);
+	} catch (e) {
+		return err(kernelError("OFFSET_FAILED", `Offset operation failed: ${e instanceof Error ? e.message : String(e)}`, e));
+	}
+}
+/**
+* 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 check = validateNotNull(shape, "draft: shape");
+	if (isErr(check)) return check;
+	if (typeof angle === "number") {
+		if (angle === 0) return err(validationError(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 err(validationError(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 err(validationError(BrepErrorCode.DRAFT_NO_FACES, "No faces specified for draft", void 0, void 0, "Select at least one face to apply the draft angle to"));
+	try {
+		const { filteredFaces, kernelAngle } = resolveDraftCallback(faces, angle);
+		if (filteredFaces.length === 0) return err(validationError(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 = collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = getKernel().draftWithHistory(shape.wrapped, filteredFaces.map((f) => f.wrapped), [
+			pullDirection[0],
+			pullDirection[1],
+			pullDirection[2]
+		], [
+			neutralPlane[0],
+			neutralPlane[1],
+			neutralPlane[2]
+		], kernelAngle, inputFaceHashes, HASH_CODE_MAX);
+		return finalizeShape3D(evolution, resultShape, [shape], BrepErrorCode.DRAFT_NOT_3D, "Draft result is not a 3D shape");
+	} catch (e) {
+		const raw = e instanceof Error ? e.message : String(e);
+		return err(kernelError(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:** Only brepkit supports variable-radius fillet.
+* Returns UNSUPPORTED_CAPABILITY error on OCCT.
+*/
+function variableFillet(shape, edge, radii) {
+	if (radii.length === 0) return err(validationError(BrepErrorCode.VARIABLE_FILLET_FAILED, "radii must contain at least one radius spec"));
+	for (const r of radii) if (r.radius <= 0) return err(validationError(BrepErrorCode.VARIABLE_FILLET_FAILED, "All radius values must be positive"));
+	const kernel = getKernel();
+	try {
+		const spec = JSON.stringify({
+			edge: kernel.hashCode(edge.wrapped, HASH_CODE_MAX),
+			radii: radii.map((r) => ({
+				param: r.param,
+				radius: r.radius
+			}))
+		});
+		const wrapped = castShape(kernel.filletVariable(shape.wrapped, spec));
+		if (!isShape3D(wrapped)) {
+			wrapped[Symbol.dispose]();
+			return err(kernelError(BrepErrorCode.VARIABLE_FILLET_FAILED, "Variable-radius fillet did not produce a 3D shape"));
+		}
+		if (!isSolid(wrapped)) {
+			wrapped[Symbol.dispose]();
+			return err(kernelError(BrepErrorCode.VARIABLE_FILLET_FAILED, "Variable-radius fillet did not produce a solid"));
+		}
+		return ok(wrapped);
+	} catch (e) {
+		return err(kernelError(BrepErrorCode.VARIABLE_FILLET_FAILED, "Variable-radius fillet failed", e));
+	}
+}
+//#endregion
+//#region src/topology/healingFns.ts
+/**
+* Shape healing and validation functions.
+*
+* Uses ShapeFix_Solid, ShapeFix_Face, ShapeFix_Wire, and BRepCheck_Analyzer
+* to validate and repair shapes.
+*/
+/**
+* Check if a shape is valid according to kernel geometry and topology checks.
+*/
+function isValid(shape) {
+	return getKernel().isValid(shape.wrapped);
+}
+/**
+* Attempt to heal/fix a solid shape.
+*
+* Uses ShapeFix_Solid to repair topology issues like gaps, wrong orientation, etc.
+*/
+function healSolid(solid) {
+	if (!isSolid(solid)) return err(validationError("NOT_A_SOLID", "Input shape is not a solid"));
+	const alreadyValid = isValid(solid);
+	try {
+		const result = getKernel().healSolid(solid.wrapped);
+		if (!result) {
+			if (alreadyValid) return ok(solid);
+			return err(kernelError(BrepErrorCode.HEAL_NO_EFFECT, "Solid healing had no effect — shape is still invalid"));
+		}
+		const cast = castShape(result);
+		if (!isSolid(cast)) return err(kernelError("HEAL_RESULT_NOT_SOLID", "Healed result is not a solid"));
+		if (!isValid(cast)) return err(kernelError("HEAL_SOLID_INCOMPLETE", "Healed result is still invalid after ShapeFix_Solid"));
+		return ok(cast);
+	} catch (e) {
+		return err(kernelError("HEAL_SOLID_FAILED", "Solid healing failed", e));
+	}
+}
+/**
+* Attempt to heal/fix a face.
+*
+* Uses ShapeFix_Face to repair wire ordering, orientation, and geometry issues.
+*/
+function healFace(face) {
+	if (!isFace(face)) return err(validationError("NOT_A_FACE", "Input shape is not a face"));
+	try {
+		const cast = castShape(getKernel().healFace(face.wrapped));
+		if (!isFace(cast)) return err(kernelError("HEAL_RESULT_NOT_FACE", "Healed result is not a face"));
+		return ok(cast);
+	} catch (e) {
+		return err(kernelError("HEAL_FACE_FAILED", "Face healing failed", e));
+	}
+}
+/**
+* Attempt to heal/fix a wire.
+*
+* Uses ShapeFix_Wire to repair edge connectivity, gaps, and self-intersections.
+* Requires a face for surface context; pass `undefined` to use a default planar context.
+*/
+function healWire(wire, face) {
+	if (!isWire(wire)) return err(validationError("NOT_A_WIRE", "Input shape is not a wire"));
+	try {
+		const cast = castShape(getKernel().healWire(wire.wrapped, face?.wrapped));
+		if (!isWire(cast)) return err(kernelError("HEAL_RESULT_NOT_WIRE", "Healed result is not a wire"));
+		return ok(cast);
+	} catch (e) {
+		return err(kernelError("HEAL_WIRE_FAILED", "Wire healing failed", e));
+	}
+}
+/**
+* Attempt to heal any shape by dispatching to the appropriate fixer.
+*
+* Supports solids, faces, and wires. For other shape types, returns the
+* input unchanged.
+*/
+function heal(shape) {
+	if (isSolid(shape)) return healSolid(shape);
+	if (isFace(shape)) return healFace(shape);
+	if (isWire(shape)) return healWire(shape);
+	return ok(shape);
+}
+/**
+* Automatically heal a shape using the appropriate shape-level fixer.
+*
+* If the shape is already valid, returns it unchanged with a no-op report.
+* Uses ShapeFix_Solid/Face/Wire depending on shape type, which internally
+* handles sub-shape healing and reconstruction.
+*/
+function autoHeal(shape, options) {
+	const fixWires = options?.fixWires !== false;
+	const fixFaces = options?.fixFaces !== false;
+	const fixSolids = options?.fixSolids !== false;
+	const fixSelfIntersection = options?.fixSelfIntersection === true;
+	const sewTolerance = options?.sewTolerance;
+	const steps = [];
+	const diagnostics = [];
+	if (isValid(shape)) return ok({
+		shape,
+		report: {
+			isValid: true,
+			alreadyValid: true,
+			wiresHealed: 0,
+			facesHealed: 0,
+			solidHealed: false,
+			steps: ["Shape already valid"],
+			diagnostics: [{
+				name: "validation",
+				attempted: true,
+				succeeded: true
+			}]
+		}
+	});
+	steps.push("Shape invalid — applying shape-level healing");
+	const wiresBefore = getWires(shape).length;
+	const facesBefore = getFaces(shape).length;
+	let current = shape;
+	let solidHealed = false;
+	if (sewTolerance !== void 0) try {
+		current = castShape(getKernel().sew([current.wrapped], sewTolerance));
+		steps.push(`Applied sewing with tolerance ${sewTolerance}`);
+		diagnostics.push({
+			name: "sew",
+			attempted: true,
+			succeeded: true,
+			detail: `tolerance=${sewTolerance}`
+		});
+	} catch (e) {
+		const detail = e instanceof Error ? e.message : String(e);
+		steps.push(`Sewing failed: ${detail}`);
+		diagnostics.push({
+			name: "sew",
+			attempted: true,
+			succeeded: false,
+			detail
+		});
+	}
+	if (fixSelfIntersection && fixWires) {
+		const wires = getWires(current);
+		let fixCount = 0;
+		for (const wire of wires) try {
+			getKernel().fixSelfIntersection(wire.wrapped);
+			fixCount++;
+		} catch {}
+		steps.push(`Self-intersection fix: ${fixCount}/${wires.length} wires`);
+		diagnostics.push({
+			name: "fixSelfIntersection",
+			attempted: true,
+			succeeded: fixCount > 0,
+			detail: `${fixCount}/${wires.length} wires fixed`
+		});
+	}
+	if (isSolid(current) && fixSolids || isFace(current) && fixFaces || isWire(current) && fixWires) {
+		const healResult = heal(current);
+		if (isOk(healResult)) {
+			current = healResult.value;
+			if (isSolid(shape)) {
+				solidHealed = true;
+				steps.push("Applied ShapeFix_Solid");
+				diagnostics.push({
+					name: "healSolid",
+					attempted: true,
+					succeeded: true
+				});
+			} else if (isFace(shape)) {
+				steps.push("Applied ShapeFix_Face");
+				diagnostics.push({
+					name: "healFace",
+					attempted: true,
+					succeeded: true
+				});
+			} else {
+				steps.push("Applied ShapeFix_Wire");
+				diagnostics.push({
+					name: "healWire",
+					attempted: true,
+					succeeded: true
+				});
+			}
+		} else {
+			steps.push("Shape-level healing failed");
+			diagnostics.push({
+				name: "healShape",
+				attempted: true,
+				succeeded: false
+			});
+		}
+	} else diagnostics.push({
+		name: "healShape",
+		attempted: false,
+		succeeded: false,
+		detail: "skipped by options"
+	});
+	const wiresAfter = getWires(current).length;
+	const facesAfter = getFaces(current).length;
+	const wiresHealed = Math.abs(wiresAfter - wiresBefore);
+	const facesHealed = Math.abs(facesAfter - facesBefore);
+	if (wiresHealed > 0) steps.push(`Wire count changed by ${wiresHealed}`);
+	if (facesHealed > 0) steps.push(`Face count changed by ${facesHealed}`);
+	const valid = isValid(current);
+	steps.push(valid ? "Final validation: valid" : "Final validation: still invalid");
+	diagnostics.push({
+		name: "finalValidation",
+		attempted: true,
+		succeeded: valid
+	});
+	return ok({
+		shape: current,
+		report: {
+			isValid: valid,
+			alreadyValid: false,
+			wiresHealed,
+			facesHealed,
+			solidHealed,
+			steps,
+			diagnostics
+		}
+	});
+}
+/**
+* General-purpose shape repair using ShapeFix_Shape.
+* Fixes orientations, missing curves, and other common issues.
+*/
+function fixShape(shape) {
+	try {
+		return ok(castShape(getKernel().fixShape(shape.wrapped)));
+	} catch (e) {
+		return err(kernelError(BrepErrorCode.FIX_SHAPE_FAILED, "ShapeFix_Shape failed", e));
+	}
+}
+/**
+* Convert a closed shell into a solid.
+*
+* The shell must be closed (all faces share edges) for the conversion to succeed.
+*/
+function solidFromShell(shell) {
+	try {
+		const wrapped = castShape(getKernel().solidFromShell(shell.wrapped));
+		if (!isSolid(wrapped)) return err(kernelError(BrepErrorCode.SOLID_FROM_SHELL_FAILED, "solidFromShell did not produce a solid"));
+		if (!isValid(wrapped)) return err(kernelError(BrepErrorCode.SOLID_FROM_SHELL_FAILED, "solidFromShell produced an invalid solid"));
+		return ok(wrapped);
+	} catch (e) {
+		return err(kernelError(BrepErrorCode.SOLID_FROM_SHELL_FAILED, "Failed to create solid from shell", e));
+	}
+}
+/**
+* Fix self-intersections in a wire.
+*
+* Uses ShapeFix_Wire to detect and repair self-intersecting edges.
+*/
+function fixSelfIntersection(wire) {
+	try {
+		const wrapped = castShape(getKernel().fixSelfIntersection(wire.wrapped));
+		if (!isWire(wrapped)) return err(kernelError(BrepErrorCode.FIX_SELF_INTERSECTION_FAILED, "Result is not a wire"));
+		return ok(wrapped);
+	} catch (e) {
+		return err(kernelError(BrepErrorCode.FIX_SELF_INTERSECTION_FAILED, "Failed to fix wire self-intersection", e));
+	}
+}
+//#endregion
+//#region src/topology/primitiveFns.ts
+/**
+* Create a box with the given dimensions.
+*
+* @param width  - Size along X.
+* @param depth  - Size along Y.
+* @param height - Size along Z.
+*/
+function box(width, depth, height, options) {
+	const solid = createSolid(getKernel().makeBox(width, depth, height));
+	const center = options?.at ?? (options?.centered ? [
+		0,
+		0,
+		0
+	] : void 0);
+	if (center) return translate(solid, [
+		center[0] - width / 2,
+		center[1] - depth / 2,
+		center[2] - height / 2
+	]);
+	return solid;
+}
+/**
+* Create a cylinder with the given radius and height.
+*/
+function cylinder(radius, height, options) {
+	const at = options?.at ?? [
+		0,
+		0,
+		0
+	];
+	const axis = options?.axis ?? [
+		0,
+		0,
+		1
+	];
+	let solid = makeCylinder(radius, height, at, axis);
+	if (options?.centered) {
+		const halfShift = [
+			-axis[0] * height * .5,
+			-axis[1] * height * .5,
+			-axis[2] * height * .5
+		];
+		solid = translate(solid, halfShift);
+	}
+	return solid;
+}
+/**
+* Create a sphere with the given radius.
+*/
+function sphere(radius, options) {
+	let solid = makeSphere(radius);
+	if (options?.at) solid = translate(solid, options.at);
+	return solid;
+}
+/**
+* Create a cone (or frustum) with the given radii and height.
+*
+* @param bottomRadius - Radius at the base.
+* @param topRadius    - Radius at the top (0 for a full cone).
+* @param height       - Height of the cone.
+*/
+function cone(bottomRadius, topRadius, height, options) {
+	const at = options?.at ?? [
+		0,
+		0,
+		0
+	];
+	const axis = options?.axis ?? [
+		0,
+		0,
+		1
+	];
+	let solid = makeCone(bottomRadius, topRadius, height, at, axis);
+	if (options?.centered) {
+		const halfShift = [
+			-axis[0] * height * .5,
+			-axis[1] * height * .5,
+			-axis[2] * height * .5
+		];
+		solid = translate(solid, halfShift);
+	}
+	return solid;
+}
+/**
+* Create a torus with the given major and minor radii.
+*/
+function torus(majorRadius, minorRadius, options) {
+	return makeTorus(majorRadius, minorRadius, options?.at ?? [
+		0,
+		0,
+		0
+	], options?.axis ?? [
+		0,
+		0,
+		1
+	]);
+}
+/**
+* Create an ellipsoid with the given axis half-lengths.
+*
+* @param rx - Half-length along X.
+* @param ry - Half-length along Y.
+* @param rz - Half-length along Z.
+*/
+function ellipsoid(rx, ry, rz, options) {
+	let solid = makeEllipsoid(rx, ry, rz);
+	if (options?.at) solid = translate(solid, options.at);
+	return solid;
+}
+/** Create a straight edge between two 3D points. */
+function line(from, to) {
+	return makeLine(from, to);
+}
+/** Create a circular edge with the given radius. */
+function circle(radius, options) {
+	const axisDir = options?.axis ?? [
+		0,
+		0,
+		1
+	];
+	return makeCircle(radius, options?.at ?? [
+		0,
+		0,
+		0
+	], axisDir);
+}
+/**
+* Create an elliptical edge.
+*
+* @returns An error if `minorRadius` exceeds `majorRadius`.
+*/
+function ellipse(majorRadius, minorRadius, options) {
+	const axisDir = options?.axis ?? [
+		0,
+		0,
+		1
+	];
+	return makeEllipse(majorRadius, minorRadius, options?.at ?? [
+		0,
+		0,
+		0
+	], axisDir, options?.xDir);
+}
+/**
+* Create a helical wire.
+*
+* @param pitch  - Vertical distance per full turn.
+* @param height - Total height.
+* @param radius - Helix radius.
+*/
+function helix(pitch, height, radius, options) {
+	return makeHelix(pitch, height, radius, options?.at ?? [
+		0,
+		0,
+		0
+	], options?.axis ?? [
+		0,
+		0,
+		1
+	], options?.lefthand ?? false);
+}
+/** Create a circular arc edge passing through three points. */
+function threePointArc(p1, p2, p3) {
+	return makeThreePointArc(p1, p2, p3);
+}
+/**
+* Create an elliptical arc edge between two angles.
+*
+* All angles are in **degrees** (unlike the legacy `makeEllipseArc` which used radians).
+*
+* @param startAngle - Start angle in degrees.
+* @param endAngle   - End angle in degrees.
+*/
+function ellipseArc(majorRadius, minorRadius, startAngle, endAngle, options) {
+	const axisDir = options?.axis ?? [
+		0,
+		0,
+		1
+	];
+	return makeEllipseArc(majorRadius, minorRadius, startAngle * DEG2RAD, endAngle * DEG2RAD, options?.at ?? [
+		0,
+		0,
+		0
+	], axisDir, options?.xDir);
+}
+/**
+* Create a B-spline edge that approximates a set of 3D points.
+*
+* @returns An error if the approximation algorithm fails.
+*/
+function bsplineApprox(points, config) {
+	return makeBSplineApproximation(points, config);
+}
+/**
+* Create a Bezier curve edge from control points.
+*
+* @param points - Two or more control points.
+*/
+function bezier(points) {
+	return makeBezierCurve(points);
+}
+/**
+* Create a circular arc edge tangent to a direction at the start point.
+*/
+function tangentArc(startPoint, startTgt, endPoint) {
+	return makeTangentArc(startPoint, startTgt, endPoint);
+}
+/**
+* Assemble edges and/or wires into a single connected wire.
+*/
+function wire(listOfEdges) {
+	return assembleWire(listOfEdges);
+}
+/**
+* Assemble edges into a wire and verify it forms a closed loop.
+*
+* Combines {@link wire} + the `closedWire` smart constructor in a single step.
+* Returns an error if the edges cannot be assembled or the wire is not closed.
+*
+* @example
+* ```ts
+* const cw = unwrap(wireLoop([e1, e2, e3, e4]));
+* const f = unwrap(face(cw)); // ClosedWire accepted directly
+* ```
+*/
+function wireLoop(listOfEdges) {
+	return andThen(assembleWire(listOfEdges), (w) => {
+		if (isClosedWire(w)) return ok(w);
+		return err(validationError("WIRE_NOT_CLOSED", "Assembled wire is not closed: start and end points do not coincide"));
+	});
+}
+/**
+* Create a planar face from a closed wire, optionally with holes.
+* The resulting face is always oriented (consistent normal direction).
+*/
+function face(w, holes) {
+	return makeFace(w, holes);
+}
+/**
+* Create a non-planar face from a wire using surface filling.
+* The resulting face is always oriented.
+*/
+function filledFace(w) {
+	return makeNonPlanarFace(w);
+}
+/**
+* Create a face bounded by a wire on an existing face's surface.
+* The resulting face inherits orientation from the origin face.
+*/
+function subFace(originFace, w) {
+	return makeNewFaceWithinFace(originFace, w);
+}
+/**
+* Create a polygonal face from three or more coplanar points.
+* The resulting face is always oriented.
+*/
+function polygon(points) {
+	return makePolygon(points);
+}
+/** Create a vertex at a 3D point. */
+function vertex(point) {
+	return makeVertex(point);
+}
+/**
+* Build a compound from multiple shapes.
+*/
+function compound(shapeArray) {
+	return makeCompound(shapeArray);
+}
+/**
+* Weld faces and shells into a single solid.
+* The resulting solid is always validated.
+*/
+function solid(facesOrShells) {
+	return makeSolid(facesOrShells);
+}
+/**
+* Create an offset shape from a face.
+*/
+function offsetFace(f, distance, tolerance) {
+	return makeOffset(f, distance, tolerance);
+}
+/**
+* Weld faces and shells into a single shell.
+*/
+function sewShells(facesOrShells, ignoreType) {
+	return weldShellsAndFaces(facesOrShells, ignoreType);
+}
+function addHoles(f, holes) {
+	return addHolesInFace(f, holes);
+}
+//#endregion
+export { edgesOfFace as $, fixShape as A, offset as B, threePointArc as C, wireLoop as D, wire as E, isValid as F, chamferWithEvolution as G, thicken as H, solidFromShell as I, fuseWithEvolution as J, cutWithEvolution as K, chamfer as L, healFace as M, healSolid as N, autoHeal as O, healWire as P, adjacentFaces as Q, draft as R, tangentArc as S, vertex as T, variableFillet as U, shell as V, positionOnCurve as W, shellWithEvolution as X, intersectWithEvolution as Y, checkBoolean as Z, polygon as _, circle as a, toBufferGeometryData as at, sphere as b, cylinder as c, ellipsoid as d, facesOfEdge as et, face as f, offsetFace as g, line as h, bsplineApprox as i, chamferDistAngle as it, heal as j, fixSelfIntersection as k, ellipse as l, helix as m, bezier as n, verticesOfEdge as nt, compound as o, toGroupedBufferGeometryData as ot, filledFace as p, filletWithEvolution as q, box as r, wiresOfFace as rt, cone as s, toLineGeometryData as st, addHoles as t, sharedEdges as tt, ellipseArc as u, sewShells as v, torus as w, subFace as x, solid as y, fillet as z };