brepjs 13.0.0 → 13.2.0

package/dist/primitiveFns-DKtvEA0i.cjs

@@ -0,0 +1,1817 @@
+const require_shapeTypes = require("./shapeTypes-CElaawp7.cjs");
+const require_errors = require("./errors-DupKEMqI.cjs");
+const require_vecOps = require("./vecOps-4iBMiet9.cjs");
+const require_faceFns = require("./faceFns-8dGb8q3J.cjs");
+const require_arrayAccess = require("./arrayAccess-peFKE9Ob.cjs");
+const require_surfaceBuilders = require("./surfaceBuilders-ZUTb3z6i.cjs");
+const require_solidBuilders = require("./solidBuilders-Cs4XyL58.cjs");
+//#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 require_errors.err(require_errors.validationError("CHAMFER_ANGLE_NO_EDGES", "chamferDistAngle requires at least one edge", void 0, { edgeCount: 0 }));
+	if (distance <= 0) return require_errors.err(require_errors.validationError("CHAMFER_ANGLE_BAD_DISTANCE", `distance must be positive, got ${distance}`, void 0, { distance }));
+	if (angleDeg <= 0 || angleDeg >= 90) return require_errors.err(require_errors.validationError("CHAMFER_ANGLE_BAD_ANGLE", `angleDeg must be in range (0, 90), got ${angleDeg}`, void 0, { angleDeg }));
+	let raw;
+	try {
+		const kernel = require_shapeTypes.getKernel();
+		const rawEdges = edges.map((e) => e.wrapped);
+		raw = kernel.chamferDistAngle(shape.wrapped, rawEdges, distance, angleDeg);
+	} catch (e) {
+		return require_errors.err(require_errors.kernelError("CHAMFER_ANGLE_FAILED", `chamferDistAngle kernel call failed: ${e instanceof Error ? e.message : String(e)}`, e, {
+			distance,
+			angleDeg,
+			edgeCount: edges.length
+		}));
+	}
+	const downcastResult = require_faceFns.downcast(raw);
+	if (require_errors.isErr(downcastResult)) return downcastResult;
+	const wrapped = require_shapeTypes.castShape(downcastResult.value);
+	if (!require_shapeTypes.isShape3D(wrapped)) {
+		wrapped[Symbol.dispose]();
+		return require_errors.err(require_errors.typeCastError("CHAMFER_ANGLE_NOT_3D", "chamferDistAngle did not produce a 3D shape"));
+	}
+	return require_errors.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) => require_shapeTypes.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 = require_shapeTypes.getKernel();
+	const items = kernel.iterShapes(parentKernel, type);
+	const results = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const hash = kernel.hashCode(item, require_vecOps.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 = require_arrayAccess.getOrCreateCache(parent);
+	if (cache.edgeToFaces) return cache.edgeToFaces;
+	const kernel = require_shapeTypes.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, require_vecOps.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 = require_shapeTypes.getKernel();
+	const edgeToFaces = getEdgeToFacesMap(parent);
+	const hash = kernel.hashCode(edge.wrapped, require_vecOps.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, require_vecOps.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 = require_shapeTypes.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, require_vecOps.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, require_vecOps.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 = require_shapeTypes.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, require_vecOps.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 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 shapeType = shape.ShapeType();
+		const typeName = [
+			"COMPOUND",
+			"COMPSOLID",
+			"SOLID",
+			"SHELL",
+			"FACE",
+			"WIRE",
+			"EDGE",
+			"VERTEX",
+			"SHAPE"
+		][shapeType] ?? `UNKNOWN(${shapeType})`;
+		wrapped[Symbol.dispose]();
+		return require_errors.err(require_errors.typeCastError(errorCode, `${errorMsg}. Got ${typeName} instead.`, void 0, void 0, suggestion));
+	}
+	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_vecOps.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 (require_errors.isErr(checkA)) return checkA;
+	const checkB = validateShape3D(b, "fuseWithEvolution: second operand");
+	if (require_errors.isErr(checkB)) return checkB;
+	const inputFaceHashes = require_arrayAccess.collectInputFaceHashes([a, b]);
+	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().fuseWithHistory(a.wrapped, b.wrapped, inputFaceHashes, require_vecOps.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_arrayAccess.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_arrayAccess.collectInputFaceHashes([base, tool]);
+	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().cutWithHistory(base.wrapped, tool.wrapped, inputFaceHashes, require_vecOps.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_arrayAccess.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_arrayAccess.collectInputFaceHashes([a, b]);
+	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().intersectWithHistory(a.wrapped, b.wrapped, inputFaceHashes, require_vecOps.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_arrayAccess.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_arrayAccess.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_arrayAccess.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().filletWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelRadius, inputFaceHashes, require_vecOps.HASH_CODE_MAX);
+		const cast = require_shapeTypes.castShape(resultShape);
+		if (!require_shapeTypes.isShape3D(cast)) return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape"));
+		require_arrayAccess.propagateAllMetadata(evolution, [shape], cast);
+		return require_errors.ok({
+			shape: cast,
+			evolution
+		});
+	} catch (e) {
+		return require_errors.err(require_errors.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 (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_arrayAccess.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_arrayAccess.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().chamferWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelDistance, inputFaceHashes, require_vecOps.HASH_CODE_MAX);
+		const cast = require_shapeTypes.castShape(resultShape);
+		if (!require_shapeTypes.isShape3D(cast)) return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.CHAMFER_NOT_3D, "Chamfer result is not a 3D shape"));
+		require_arrayAccess.propagateAllMetadata(evolution, [shape], cast);
+		return require_errors.ok({
+			shape: cast,
+			evolution
+		});
+	} catch (e) {
+		return require_errors.err(require_errors.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 (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 {
+		const inputFaceHashes = require_arrayAccess.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().shellWithHistory(shape.wrapped, faces.map((f) => f.wrapped), thickness, inputFaceHashes, require_vecOps.HASH_CODE_MAX, tolerance);
+		const cast = require_shapeTypes.castShape(resultShape);
+		if (!require_shapeTypes.isShape3D(cast)) return require_errors.err(require_errors.kernelError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
+		require_arrayAccess.propagateAllMetadata(evolution, [shape], cast);
+		return require_errors.ok({
+			shape: cast,
+			evolution
+		});
+	} catch (e) {
+		return require_errors.err(require_errors.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 = require_shapeTypes.castShape(require_shapeTypes.getKernel().positionOnCurve(shape.wrapped, spine.wrapped, param));
+		if (!require_shapeTypes.isShape3D(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));
+	}
+}
+//#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 (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(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_vecOps.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 = require_shapeTypes.castShape(resultShape);
+	if (!require_shapeTypes.isShape3D(cast)) return require_errors.err(require_errors.kernelError(not3dCode, not3dMessage));
+	require_arrayAccess.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_vecOps.HASH_CODE_MAX), a);
+	}
+	const kernelAngle = (ocFace) => {
+		const a = hashToAngle.get(ocFace.HashCode(require_vecOps.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 (require_errors.isErr(check)) return check;
+	try {
+		const inputFaceHashes = require_arrayAccess.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().thickenWithHistory(shape.wrapped, thickness, inputFaceHashes, require_vecOps.HASH_CODE_MAX);
+		const cast = require_shapeTypes.castShape(resultShape);
+		require_arrayAccess.propagateAllMetadata(evolution, [shape], cast);
+		return require_errors.ok(cast);
+	} catch (e) {
+		return require_errors.err(require_errors.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 (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_arrayAccess.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(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_arrayAccess.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().filletWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelRadius, inputFaceHashes, require_vecOps.HASH_CODE_MAX);
+		return finalizeShape3D(evolution, resultShape, [shape], require_errors.BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape");
+	} catch (e) {
+		return require_errors.err(require_errors.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 (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_arrayAccess.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(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_arrayAccess.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().chamferWithHistory(shape.wrapped, filteredEdges.map((e) => e.wrapped), kernelDistance, inputFaceHashes, require_vecOps.HASH_CODE_MAX);
+		return finalizeShape3D(evolution, resultShape, [shape], require_errors.BrepErrorCode.CHAMFER_NOT_3D, "Chamfer result is not a 3D shape");
+	} catch (e) {
+		return require_errors.err(require_errors.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 (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 {
+		const inputFaceHashes = require_arrayAccess.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().shellWithHistory(shape.wrapped, faces.map((f) => f.wrapped), thickness, inputFaceHashes, require_vecOps.HASH_CODE_MAX, tolerance);
+		const cast = require_shapeTypes.castShape(resultShape);
+		if (!require_shapeTypes.isShape3D(cast)) return require_errors.err(require_errors.kernelError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
+		require_arrayAccess.propagateAllMetadata(evolution, [shape], cast);
+		return require_errors.ok(cast);
+	} catch (e) {
+		return require_errors.err(require_errors.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 (require_errors.isErr(check)) return check;
+	if (distance === 0) return require_errors.err(require_errors.validationError("ZERO_OFFSET", "Offset distance cannot be zero"));
+	try {
+		const inputFaceHashes = require_arrayAccess.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().offsetWithHistory(shape.wrapped, distance, inputFaceHashes, require_vecOps.HASH_CODE_MAX, tolerance);
+		const cast = require_shapeTypes.castShape(resultShape);
+		if (!require_shapeTypes.isShape3D(cast)) return require_errors.err(require_errors.kernelError("OFFSET_RESULT_NOT_3D", "Offset result is not a 3D shape"));
+		require_arrayAccess.propagateAllMetadata(evolution, [shape], cast);
+		return require_errors.ok(cast);
+	} catch (e) {
+		return require_errors.err(require_errors.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 (require_errors.isErr(check)) return check;
+	if (typeof angle === "number") {
+		if (angle === 0) 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"));
+	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_arrayAccess.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_vecOps.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:** Only brepkit supports variable-radius fillet.
+* Returns UNSUPPORTED_CAPABILITY error on OCCT.
+*/
+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_vecOps.HASH_CODE_MAX),
+			radii: radii.map((r) => ({
+				param: r.param,
+				radius: r.radius
+			}))
+		});
+		const wrapped = require_shapeTypes.castShape(kernel.filletVariable(shape.wrapped, spec));
+		if (!require_shapeTypes.isShape3D(wrapped)) {
+			wrapped[Symbol.dispose]();
+			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)) {
+			wrapped[Symbol.dispose]();
+			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/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 require_shapeTypes.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 (!require_shapeTypes.isSolid(solid)) return require_errors.err(require_errors.validationError("NOT_A_SOLID", "Input shape is not a solid"));
+	const alreadyValid = isValid(solid);
+	try {
+		const result = require_shapeTypes.getKernel().healSolid(solid.wrapped);
+		if (!result) {
+			if (alreadyValid) return require_errors.ok(solid);
+			return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.HEAL_NO_EFFECT, "Solid healing had no effect — shape is still invalid"));
+		}
+		const cast = require_shapeTypes.castShape(result);
+		if (!require_shapeTypes.isSolid(cast)) return require_errors.err(require_errors.kernelError("HEAL_RESULT_NOT_SOLID", "Healed result is not a solid"));
+		if (!isValid(cast)) return require_errors.err(require_errors.kernelError("HEAL_SOLID_INCOMPLETE", "Healed result is still invalid after ShapeFix_Solid"));
+		return require_errors.ok(cast);
+	} catch (e) {
+		return require_errors.err(require_errors.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 (!require_shapeTypes.isFace(face)) return require_errors.err(require_errors.validationError("NOT_A_FACE", "Input shape is not a face"));
+	try {
+		const cast = require_shapeTypes.castShape(require_shapeTypes.getKernel().healFace(face.wrapped));
+		if (!require_shapeTypes.isFace(cast)) return require_errors.err(require_errors.kernelError("HEAL_RESULT_NOT_FACE", "Healed result is not a face"));
+		return require_errors.ok(cast);
+	} catch (e) {
+		return require_errors.err(require_errors.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 (!require_shapeTypes.isWire(wire)) return require_errors.err(require_errors.validationError("NOT_A_WIRE", "Input shape is not a wire"));
+	try {
+		const cast = require_shapeTypes.castShape(require_shapeTypes.getKernel().healWire(wire.wrapped, face?.wrapped));
+		if (!require_shapeTypes.isWire(cast)) return require_errors.err(require_errors.kernelError("HEAL_RESULT_NOT_WIRE", "Healed result is not a wire"));
+		return require_errors.ok(cast);
+	} catch (e) {
+		return require_errors.err(require_errors.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 (require_shapeTypes.isSolid(shape)) return healSolid(shape);
+	if (require_shapeTypes.isFace(shape)) return healFace(shape);
+	if (require_shapeTypes.isWire(shape)) return healWire(shape);
+	return require_errors.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 require_errors.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 = require_arrayAccess.getWires(shape).length;
+	const facesBefore = require_arrayAccess.getFaces(shape).length;
+	let current = shape;
+	let solidHealed = false;
+	if (sewTolerance !== void 0) try {
+		current = require_shapeTypes.castShape(require_shapeTypes.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 = require_arrayAccess.getWires(current);
+		let fixCount = 0;
+		for (const wire of wires) try {
+			require_shapeTypes.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 (require_shapeTypes.isSolid(current) && fixSolids || require_shapeTypes.isFace(current) && fixFaces || require_shapeTypes.isWire(current) && fixWires) {
+		const healResult = heal(current);
+		if (require_errors.isOk(healResult)) {
+			current = healResult.value;
+			if (require_shapeTypes.isSolid(shape)) {
+				solidHealed = true;
+				steps.push("Applied ShapeFix_Solid");
+				diagnostics.push({
+					name: "healSolid",
+					attempted: true,
+					succeeded: true
+				});
+			} else if (require_shapeTypes.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 = require_arrayAccess.getWires(current).length;
+	const facesAfter = require_arrayAccess.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 require_errors.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 require_errors.ok(require_shapeTypes.castShape(require_shapeTypes.getKernel().fixShape(shape.wrapped)));
+	} catch (e) {
+		return require_errors.err(require_errors.kernelError(require_errors.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 = require_shapeTypes.castShape(require_shapeTypes.getKernel().solidFromShell(shell.wrapped));
+		if (!require_shapeTypes.isSolid(wrapped)) return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.SOLID_FROM_SHELL_FAILED, "solidFromShell did not produce a solid"));
+		if (!isValid(wrapped)) return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.SOLID_FROM_SHELL_FAILED, "solidFromShell produced an invalid solid"));
+		return require_errors.ok(wrapped);
+	} catch (e) {
+		return require_errors.err(require_errors.kernelError(require_errors.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 = require_shapeTypes.castShape(require_shapeTypes.getKernel().fixSelfIntersection(wire.wrapped));
+		if (!require_shapeTypes.isWire(wrapped)) return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.FIX_SELF_INTERSECTION_FAILED, "Result is not a wire"));
+		return require_errors.ok(wrapped);
+	} catch (e) {
+		return require_errors.err(require_errors.kernelError(require_errors.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 = require_shapeTypes.createSolid(require_shapeTypes.getKernel().makeBox(width, depth, height));
+	const center = options?.at ?? (options?.centered ? [
+		0,
+		0,
+		0
+	] : void 0);
+	if (center) return require_arrayAccess.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 = require_solidBuilders.makeCylinder(radius, height, at, axis);
+	if (options?.centered) {
+		const halfShift = [
+			-axis[0] * height * .5,
+			-axis[1] * height * .5,
+			-axis[2] * height * .5
+		];
+		solid = require_arrayAccess.translate(solid, halfShift);
+	}
+	return solid;
+}
+/**
+* Create a sphere with the given radius.
+*/
+function sphere(radius, options) {
+	let solid = require_solidBuilders.makeSphere(radius);
+	if (options?.at) solid = require_arrayAccess.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 = require_solidBuilders.makeCone(bottomRadius, topRadius, height, at, axis);
+	if (options?.centered) {
+		const halfShift = [
+			-axis[0] * height * .5,
+			-axis[1] * height * .5,
+			-axis[2] * height * .5
+		];
+		solid = require_arrayAccess.translate(solid, halfShift);
+	}
+	return solid;
+}
+/**
+* Create a torus with the given major and minor radii.
+*/
+function torus(majorRadius, minorRadius, options) {
+	return require_solidBuilders.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 = require_solidBuilders.makeEllipsoid(rx, ry, rz);
+	if (options?.at) solid = require_arrayAccess.translate(solid, options.at);
+	return solid;
+}
+/** Create a straight edge between two 3D points. */
+function line(from, to) {
+	return require_surfaceBuilders.makeLine(from, to);
+}
+/** Create a circular edge with the given radius. */
+function circle(radius, options) {
+	const axisDir = options?.axis ?? [
+		0,
+		0,
+		1
+	];
+	return require_surfaceBuilders.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 require_surfaceBuilders.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 require_surfaceBuilders.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 require_surfaceBuilders.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 require_surfaceBuilders.makeEllipseArc(majorRadius, minorRadius, startAngle * require_vecOps.DEG2RAD, endAngle * require_vecOps.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 require_surfaceBuilders.makeBSplineApproximation(points, config);
+}
+/**
+* Create a Bezier curve edge from control points.
+*
+* @param points - Two or more control points.
+*/
+function bezier(points) {
+	return require_surfaceBuilders.makeBezierCurve(points);
+}
+/**
+* Create a circular arc edge tangent to a direction at the start point.
+*/
+function tangentArc(startPoint, startTgt, endPoint) {
+	return require_surfaceBuilders.makeTangentArc(startPoint, startTgt, endPoint);
+}
+/**
+* Assemble edges and/or wires into a single connected wire.
+*/
+function wire(listOfEdges) {
+	return require_surfaceBuilders.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 require_errors.andThen(require_surfaceBuilders.assembleWire(listOfEdges), (w) => {
+		if (require_shapeTypes.isClosedWire(w)) return require_errors.ok(w);
+		return require_errors.err(require_errors.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 require_surfaceBuilders.makeFace(w, holes);
+}
+/**
+* Create a non-planar face from a wire using surface filling.
+* The resulting face is always oriented.
+*/
+function filledFace(w) {
+	return require_surfaceBuilders.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 require_surfaceBuilders.makeNewFaceWithinFace(originFace, w);
+}
+/**
+* Create a polygonal face from three or more coplanar points.
+* The resulting face is always oriented.
+*/
+function polygon(points) {
+	return require_surfaceBuilders.makePolygon(points);
+}
+/** Create a vertex at a 3D point. */
+function vertex(point) {
+	return require_solidBuilders.makeVertex(point);
+}
+/**
+* Build a compound from multiple shapes.
+*/
+function compound(shapeArray) {
+	return require_solidBuilders.makeCompound(shapeArray);
+}
+/**
+* Weld faces and shells into a single solid.
+* The resulting solid is always validated.
+*/
+function solid(facesOrShells) {
+	return require_solidBuilders.makeSolid(facesOrShells);
+}
+/**
+* Create an offset shape from a face.
+*/
+function offsetFace(f, distance, tolerance) {
+	return require_solidBuilders.makeOffset(f, distance, tolerance);
+}
+/**
+* Weld faces and shells into a single shell.
+*/
+function sewShells(facesOrShells, ignoreType) {
+	return require_solidBuilders.weldShellsAndFaces(facesOrShells, ignoreType);
+}
+function addHoles(f, holes) {
+	return require_surfaceBuilders.addHolesInFace(f, holes);
+}
+//#endregion
+Object.defineProperty(exports, "addHoles", {
+	enumerable: true,
+	get: function() {
+		return addHoles;
+	}
+});
+Object.defineProperty(exports, "adjacentFaces", {
+	enumerable: true,
+	get: function() {
+		return adjacentFaces;
+	}
+});
+Object.defineProperty(exports, "autoHeal", {
+	enumerable: true,
+	get: function() {
+		return autoHeal;
+	}
+});
+Object.defineProperty(exports, "bezier", {
+	enumerable: true,
+	get: function() {
+		return bezier;
+	}
+});
+Object.defineProperty(exports, "box", {
+	enumerable: true,
+	get: function() {
+		return box;
+	}
+});
+Object.defineProperty(exports, "bsplineApprox", {
+	enumerable: true,
+	get: function() {
+		return bsplineApprox;
+	}
+});
+Object.defineProperty(exports, "chamfer", {
+	enumerable: true,
+	get: function() {
+		return chamfer;
+	}
+});
+Object.defineProperty(exports, "chamferDistAngle", {
+	enumerable: true,
+	get: function() {
+		return chamferDistAngle;
+	}
+});
+Object.defineProperty(exports, "chamferWithEvolution", {
+	enumerable: true,
+	get: function() {
+		return chamferWithEvolution;
+	}
+});
+Object.defineProperty(exports, "checkBoolean", {
+	enumerable: true,
+	get: function() {
+		return checkBoolean;
+	}
+});
+Object.defineProperty(exports, "circle", {
+	enumerable: true,
+	get: function() {
+		return circle;
+	}
+});
+Object.defineProperty(exports, "compound", {
+	enumerable: true,
+	get: function() {
+		return compound;
+	}
+});
+Object.defineProperty(exports, "cone", {
+	enumerable: true,
+	get: function() {
+		return cone;
+	}
+});
+Object.defineProperty(exports, "cutWithEvolution", {
+	enumerable: true,
+	get: function() {
+		return cutWithEvolution;
+	}
+});
+Object.defineProperty(exports, "cylinder", {
+	enumerable: true,
+	get: function() {
+		return cylinder;
+	}
+});
+Object.defineProperty(exports, "draft", {
+	enumerable: true,
+	get: function() {
+		return draft;
+	}
+});
+Object.defineProperty(exports, "edgesOfFace", {
+	enumerable: true,
+	get: function() {
+		return edgesOfFace;
+	}
+});
+Object.defineProperty(exports, "ellipse", {
+	enumerable: true,
+	get: function() {
+		return ellipse;
+	}
+});
+Object.defineProperty(exports, "ellipseArc", {
+	enumerable: true,
+	get: function() {
+		return ellipseArc;
+	}
+});
+Object.defineProperty(exports, "ellipsoid", {
+	enumerable: true,
+	get: function() {
+		return ellipsoid;
+	}
+});
+Object.defineProperty(exports, "face", {
+	enumerable: true,
+	get: function() {
+		return face;
+	}
+});
+Object.defineProperty(exports, "facesOfEdge", {
+	enumerable: true,
+	get: function() {
+		return facesOfEdge;
+	}
+});
+Object.defineProperty(exports, "filledFace", {
+	enumerable: true,
+	get: function() {
+		return filledFace;
+	}
+});
+Object.defineProperty(exports, "fillet", {
+	enumerable: true,
+	get: function() {
+		return fillet;
+	}
+});
+Object.defineProperty(exports, "filletWithEvolution", {
+	enumerable: true,
+	get: function() {
+		return filletWithEvolution;
+	}
+});
+Object.defineProperty(exports, "fixSelfIntersection", {
+	enumerable: true,
+	get: function() {
+		return fixSelfIntersection;
+	}
+});
+Object.defineProperty(exports, "fixShape", {
+	enumerable: true,
+	get: function() {
+		return fixShape;
+	}
+});
+Object.defineProperty(exports, "fuseWithEvolution", {
+	enumerable: true,
+	get: function() {
+		return fuseWithEvolution;
+	}
+});
+Object.defineProperty(exports, "heal", {
+	enumerable: true,
+	get: function() {
+		return heal;
+	}
+});
+Object.defineProperty(exports, "healFace", {
+	enumerable: true,
+	get: function() {
+		return healFace;
+	}
+});
+Object.defineProperty(exports, "healSolid", {
+	enumerable: true,
+	get: function() {
+		return healSolid;
+	}
+});
+Object.defineProperty(exports, "healWire", {
+	enumerable: true,
+	get: function() {
+		return healWire;
+	}
+});
+Object.defineProperty(exports, "helix", {
+	enumerable: true,
+	get: function() {
+		return helix;
+	}
+});
+Object.defineProperty(exports, "intersectWithEvolution", {
+	enumerable: true,
+	get: function() {
+		return intersectWithEvolution;
+	}
+});
+Object.defineProperty(exports, "isValid", {
+	enumerable: true,
+	get: function() {
+		return isValid;
+	}
+});
+Object.defineProperty(exports, "line", {
+	enumerable: true,
+	get: function() {
+		return line;
+	}
+});
+Object.defineProperty(exports, "offset", {
+	enumerable: true,
+	get: function() {
+		return offset;
+	}
+});
+Object.defineProperty(exports, "offsetFace", {
+	enumerable: true,
+	get: function() {
+		return offsetFace;
+	}
+});
+Object.defineProperty(exports, "polygon", {
+	enumerable: true,
+	get: function() {
+		return polygon;
+	}
+});
+Object.defineProperty(exports, "positionOnCurve", {
+	enumerable: true,
+	get: function() {
+		return positionOnCurve;
+	}
+});
+Object.defineProperty(exports, "sewShells", {
+	enumerable: true,
+	get: function() {
+		return sewShells;
+	}
+});
+Object.defineProperty(exports, "sharedEdges", {
+	enumerable: true,
+	get: function() {
+		return sharedEdges;
+	}
+});
+Object.defineProperty(exports, "shell", {
+	enumerable: true,
+	get: function() {
+		return shell;
+	}
+});
+Object.defineProperty(exports, "shellWithEvolution", {
+	enumerable: true,
+	get: function() {
+		return shellWithEvolution;
+	}
+});
+Object.defineProperty(exports, "solid", {
+	enumerable: true,
+	get: function() {
+		return solid;
+	}
+});
+Object.defineProperty(exports, "solidFromShell", {
+	enumerable: true,
+	get: function() {
+		return solidFromShell;
+	}
+});
+Object.defineProperty(exports, "sphere", {
+	enumerable: true,
+	get: function() {
+		return sphere;
+	}
+});
+Object.defineProperty(exports, "subFace", {
+	enumerable: true,
+	get: function() {
+		return subFace;
+	}
+});
+Object.defineProperty(exports, "tangentArc", {
+	enumerable: true,
+	get: function() {
+		return tangentArc;
+	}
+});
+Object.defineProperty(exports, "thicken", {
+	enumerable: true,
+	get: function() {
+		return thicken;
+	}
+});
+Object.defineProperty(exports, "threePointArc", {
+	enumerable: true,
+	get: function() {
+		return threePointArc;
+	}
+});
+Object.defineProperty(exports, "toBufferGeometryData", {
+	enumerable: true,
+	get: function() {
+		return toBufferGeometryData;
+	}
+});
+Object.defineProperty(exports, "toGroupedBufferGeometryData", {
+	enumerable: true,
+	get: function() {
+		return toGroupedBufferGeometryData;
+	}
+});
+Object.defineProperty(exports, "toLineGeometryData", {
+	enumerable: true,
+	get: function() {
+		return toLineGeometryData;
+	}
+});
+Object.defineProperty(exports, "torus", {
+	enumerable: true,
+	get: function() {
+		return torus;
+	}
+});
+Object.defineProperty(exports, "variableFillet", {
+	enumerable: true,
+	get: function() {
+		return variableFillet;
+	}
+});
+Object.defineProperty(exports, "vertex", {
+	enumerable: true,
+	get: function() {
+		return vertex;
+	}
+});
+Object.defineProperty(exports, "verticesOfEdge", {
+	enumerable: true,
+	get: function() {
+		return verticesOfEdge;
+	}
+});
+Object.defineProperty(exports, "wire", {
+	enumerable: true,
+	get: function() {
+		return wire;
+	}
+});
+Object.defineProperty(exports, "wireLoop", {
+	enumerable: true,
+	get: function() {
+		return wireLoop;
+	}
+});
+Object.defineProperty(exports, "wiresOfFace", {
+	enumerable: true,
+	get: function() {
+		return wiresOfFace;
+	}
+});