brepjs 13.0.0 → 13.2.0

package/dist/primitiveFns-BXufrcii.cjs

@@ -1,1063 +0,0 @@
-const require_shapeTypes = require("./shapeTypes-GmE4D5Q_.cjs");
-const require_errors = require("./errors-C85KVJr-.cjs");
-const require_vecOps = require("./vecOps-4iBMiet9.cjs");
-const require_faceFns = require("./faceFns-8BurpAGN.cjs");
-const require_arrayAccess = require("./arrayAccess-BF8Hm4-H.cjs");
-const require_surfaceBuilders = require("./surfaceBuilders-BzDQQ4EG.cjs");
-const require_solidBuilders = require("./solidBuilders-BqU0oT2q.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/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
-		}
-	});
-}
-//#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, "chamferDistAngle", {
-	enumerable: true,
-	get: function() {
-		return chamferDistAngle;
-	}
-});
-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, "cylinder", {
-	enumerable: true,
-	get: function() {
-		return cylinder;
-	}
-});
-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, "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, "isValid", {
-	enumerable: true,
-	get: function() {
-		return isValid;
-	}
-});
-Object.defineProperty(exports, "line", {
-	enumerable: true,
-	get: function() {
-		return line;
-	}
-});
-Object.defineProperty(exports, "offsetFace", {
-	enumerable: true,
-	get: function() {
-		return offsetFace;
-	}
-});
-Object.defineProperty(exports, "polygon", {
-	enumerable: true,
-	get: function() {
-		return polygon;
-	}
-});
-Object.defineProperty(exports, "sewShells", {
-	enumerable: true,
-	get: function() {
-		return sewShells;
-	}
-});
-Object.defineProperty(exports, "sharedEdges", {
-	enumerable: true,
-	get: function() {
-		return sharedEdges;
-	}
-});
-Object.defineProperty(exports, "solid", {
-	enumerable: true,
-	get: function() {
-		return solid;
-	}
-});
-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, "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, "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;
-	}
-});