brepjs 20.13.0 → 20.13.2

package/dist/{shapeTypes-DbPghQD3.js → shapeTypes-hLHmANUz.js}

@@ -1,4 +1,4 @@
-import { A as UnsupportedKernelOperationError, C as reverseCurve2d$2, D as tangentCurve2d, E as serializeCurve2d$2, N as EXACT_BREP_CAPABILITIES, O as translateCurve2d$2, P as OCCT_CAPABILITIES, S as offsetCurve2d$2, T as scaleCurve2d$2, _ as makeCircle2d$2, a as buildAsciiSTL, b as mirrorAcrossAxis, c as createBBox2d, d as deserializeCurve2d$2, f as evaluateCurve2d$2, g as makeBezier2d$2, h as makeArc2dThreePoints, i as DEFAULT_STL_TOLERANCE, j as isUnsupportedKernelOperationError, k as quickHull, l as curveBounds, m as makeArc2dTangent, o as buildBinarySTL, p as intersectCurves2dFn, r as DEFAULT_STL_ANGULAR_TOLERANCE, s as addCurveToBBox, t as OcctWasmAdapter, u as curveTypeName, v as makeEllipse2d$2, w as rotateCurve2d$2, x as mirrorAtPoint, y as makeLine2d$2 } from "./occtWasmAdapter-1k4udeb3.js";
+import { A as UnsupportedKernelOperationError, C as reverseCurve2d$2, D as tangentCurve2d, E as serializeCurve2d$2, N as EXACT_BREP_CAPABILITIES, O as translateCurve2d$2, P as OCCT_CAPABILITIES, S as offsetCurve2d$2, T as scaleCurve2d$2, _ as makeCircle2d$2, a as buildAsciiSTL, b as mirrorAcrossAxis, c as createBBox2d, d as deserializeCurve2d$2, f as evaluateCurve2d$2, g as makeBezier2d$2, h as makeArc2dThreePoints, i as DEFAULT_STL_TOLERANCE, j as isUnsupportedKernelOperationError, k as quickHull, l as curveBounds, m as makeArc2dTangent, o as buildBinarySTL, p as intersectCurves2dFn, r as DEFAULT_STL_ANGULAR_TOLERANCE, s as addCurveToBBox, t as OcctWasmAdapter, u as curveTypeName, v as makeEllipse2d$2, w as rotateCurve2d$2, x as mirrorAtPoint, y as makeLine2d$2 } from "./occtWasmAdapter-CGsnjMOe.js";
 import { i as wasmIndex, r as vec3At } from "./bug-ClMTAJhe.js";
 // src/kernel/quality.ts
 /**
@@ -5397,6 +5397,124 @@ function dist3(x1, y1, z1, x2, y2, z2) {
 	const dx = x1 - x2, dy = y1 - y2, dz = z1 - z2;
 	return Math.sqrt(dx * dx + dy * dy + dz * dz);
 }
+var TAU$1 = 2 * Math.PI;
+/**
+* The frame of an analytic circle or ellipse edge, evaluated at t as
+* center + U·cos t + V·sin t, recovered from its points at 0, π/2 and π.
+* brepkit reports such an edge's domain as exactly [0, 2π]; a NURBS edge that
+* happens to be a circle reports its knot domain and gets no frame.
+*/
+function conicFrame(bk, edgeId) {
+	const params = bk.getEdgeCurveParameters(edgeId);
+	if (wasmIndex(params, 0) !== 0 || wasmIndex(params, 1) !== TAU$1) return void 0;
+	const curveType = bk.getEdgeCurveType(edgeId);
+	if (curveType !== "CIRCLE" && curveType !== "ELLIPSE") return void 0;
+	const at = (t) => {
+		const p = bk.evaluateEdgeCurve(edgeId, t);
+		return [
+			wasmIndex(p, 0),
+			wasmIndex(p, 1),
+			wasmIndex(p, 2)
+		];
+	};
+	const p0 = at(0);
+	const pHalf = at(Math.PI / 2);
+	const pPi = at(Math.PI);
+	const center = [
+		(p0[0] + pPi[0]) / 2,
+		(p0[1] + pPi[1]) / 2,
+		(p0[2] + pPi[2]) / 2
+	];
+	return {
+		center,
+		u: [
+			p0[0] - center[0],
+			p0[1] - center[1],
+			p0[2] - center[2]
+		],
+		v: [
+			pHalf[0] - center[0],
+			pHalf[1] - center[1],
+			pHalf[2] - center[2]
+		]
+	};
+}
+function edgeEnds(bk, edgeId) {
+	const verts = bk.getEdgeVertices(edgeId);
+	return [[
+		wasmIndex(verts, 0),
+		wasmIndex(verts, 1),
+		wasmIndex(verts, 2)
+	], [
+		wasmIndex(verts, 3),
+		wasmIndex(verts, 4),
+		wasmIndex(verts, 5)
+	]];
+}
+/**
+* The curve parameters an edge spans. brepkit reports a circle or ellipse edge's
+* domain as the whole [0, 2π] even for an arc; the arc runs counterclockwise
+* about the curve's axis from the angle of its start vertex to that of its end
+* vertex (brepkit's own `circle_param_range`), angles read off the curve's frame.
+*/
+function edgeParamRange(bk, edgeId) {
+	const params = bk.getEdgeCurveParameters(edgeId);
+	const t0 = wasmIndex(params, 0);
+	const t1 = wasmIndex(params, 1);
+	const frame = conicFrame(bk, edgeId);
+	if (!frame) return [t0, t1];
+	const [start, end] = edgeEnds(bk, edgeId);
+	if (dist3(...start, ...end) < 1e-7) return [t0, t1];
+	const { center, u, v } = frame;
+	const uu = u[0] * u[0] + u[1] * u[1] + u[2] * u[2];
+	const vv = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
+	const angleOf = (p) => {
+		const d = [
+			p[0] - center[0],
+			p[1] - center[1],
+			p[2] - center[2]
+		];
+		const cos = (d[0] * u[0] + d[1] * u[1] + d[2] * u[2]) / uu;
+		const sin = (d[0] * v[0] + d[1] * v[1] + d[2] * v[2]) / vv;
+		return Math.atan2(sin, cos);
+	};
+	const ts = angleOf(start);
+	let te = angleOf(end);
+	if (te <= ts) te += TAU$1;
+	return [ts, te];
+}
+var CURVE_BOX_SAMPLES = 32;
+/**
+* Points whose bounding box is the edge's: its ends, plus for a circle or
+* ellipse the points where each coordinate peaks within the arc (exact), and
+* for any other curve samples along its parameter range.
+*/
+function edgeBoxPoints(bk, edgeId) {
+	const points = [...edgeEnds(bk, edgeId)];
+	if (bk.getEdgeCurveType(edgeId) === "LINE") return points;
+	const [t0, t1] = edgeParamRange(bk, edgeId);
+	const at = (t) => {
+		const p = bk.evaluateEdgeCurve(edgeId, t);
+		return [
+			wasmIndex(p, 0),
+			wasmIndex(p, 1),
+			wasmIndex(p, 2)
+		];
+	};
+	const frame = conicFrame(bk, edgeId);
+	if (frame) {
+		for (let k = 0; k < 3; k++) {
+			const peak = Math.atan2(wasmIndex(frame.v, k), wasmIndex(frame.u, k));
+			for (const base of [peak, peak + Math.PI]) {
+				const t = base + TAU$1 * Math.ceil((t0 - base) / TAU$1);
+				if (t <= t1) points.push(at(t));
+			}
+		}
+		return points;
+	}
+	for (let i = 1; i < CURVE_BOX_SAMPLES; i++) points.push(at(t0 + (t1 - t0) * i / CURVE_BOX_SAMPLES));
+	return points;
+}
 /** Copy a WASM-backed Uint8Array into an independent ArrayBuffer. */
 function copyWasmBytes(bytes) {
 	return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
@@ -5866,7 +5984,7 @@ function curveTangent(bk, shape, param) {
 		edgeId = wasmIndex(edgeIds, edgeIds.length - 1);
 		let cumulative = 0;
 		for (const eid of edgeIds) {
-			const p = bk.getEdgeCurveParameters(eid);
+			const p = edgeParamRange(bk, eid);
 			const span = wasmIndex(p, 1) - wasmIndex(p, 0);
 			if (param <= cumulative + span || eid === edgeId) {
 				edgeId = eid;
@@ -5889,13 +6007,12 @@ function curveParameters(bk, shape) {
 		if (edgeIds.length === 0) return [0, 0];
 		let total = 0;
 		for (const eid of edgeIds) {
-			const p = bk.getEdgeCurveParameters(eid);
+			const p = edgeParamRange(bk, eid);
 			total += wasmIndex(p, 1) - wasmIndex(p, 0);
 		}
 		return [0, total];
 	}
-	const params = bk.getEdgeCurveParameters(unwrap$1(shape, "edge"));
-	return [wasmIndex(params, 0), wasmIndex(params, 1)];
+	return edgeParamRange(bk, unwrap$1(shape, "edge"));
 }
 function curvePointAtParam(bk, shape, param) {
 	const h = shape;
@@ -5903,7 +6020,7 @@ function curvePointAtParam(bk, shape, param) {
 		const edgeIds = toArray(bk.getWireEdges(h.id));
 		let cumulative = 0;
 		for (const eid of edgeIds) {
-			const p = bk.getEdgeCurveParameters(eid);
+			const p = edgeParamRange(bk, eid);
 			const span = wasmIndex(p, 1) - wasmIndex(p, 0);
 			if (param <= cumulative + span || eid === edgeIds[edgeIds.length - 1]) {
 				const localParam = wasmIndex(p, 0) + (param - cumulative);
@@ -7080,7 +7197,16 @@ function makeWireFromMixed(bk, items) {
 		else if (h.type === "wire") for (const childEdgeId of toArray(bk.getWireEdges(h.id))) edgeIds.push(childEdgeId);
 	}
 	if (edgeIds.length === 0) throw new Error("brepkit: makeWireFromMixed requires at least one edge");
-	return wireHandle(bk.makeWire(edgeIds, false));
+	return wireHandle(bk.makeWire(edgeIds, chainCloses(bk, edgeIds)));
+}
+/** Matches the 1e-7 linear tolerance brepkit's makeWire welds vertices within. */
+var WIRE_CLOSE_TOLERANCE = 1e-7;
+function chainCloses(bk, edgeIds) {
+	const first = bk.getEdgeVertices(wasmIndex(edgeIds, 0));
+	const last = bk.getEdgeVertices(wasmIndex(edgeIds, edgeIds.length - 1));
+	const [sx, sy, sz] = vec3At(first, 0);
+	const [ex, ey, ez] = vec3At(last, 3);
+	return Math.hypot(ex - sx, ey - sy, ez - sz) < WIRE_CLOSE_TOLERANCE;
 }
 function makeCompound(bk, shapes) {
 	const handles = shapes.filter(isBrepkitHandle);
@@ -7188,6 +7314,7 @@ function sewAndSolidify(bk, faces, tolerance) {
 function interpolatePoints(bk, points, options) {
 	if (options?.tolerance !== void 0) warnOnce("interpolate-tolerance", "interpolatePoints() tolerance parameter is not supported; brepkit uses chord-length parameterisation.");
 	if (points.length < 2) throw new Error("brepkit: need at least 2 points");
+	if (options?.periodic) return interpolateClosed(bk, points);
 	if (points.length === 2) return makeLineEdge(bk, wasmIndex(points, 0), wasmIndex(points, 1));
 	const degree = Math.min(3, points.length - 1);
 	const coords = points.flatMap(([x, y, z]) => [
@@ -7197,6 +7324,132 @@ function interpolatePoints(bk, points, options) {
 	]);
 	return edgeHandle(bk.interpolatePoints(coords, degree));
 }
+/**
+* The closed cubic through `points` that OCCT's periodic GeomAPI_Interpolate
+* builds, which brepkit-wasm has no binding for. The points are parameterised
+* by chord length, the closing chord included; the spline is C2 at every point
+* but the first, where it closes C1 with the tangent of the Lagrange
+* polynomial through the first four points (three when there are only three).
+* It is built as one cubic Bezier segment per chord: a clamped NURBS whose
+* interior knots have multiplicity 3.
+*/
+function interpolateClosed(bk, points) {
+	if (points.length < 3) throw new UnsupportedKernelOperationError("brepkit: a periodic interpolation needs at least 3 points");
+	const loop = [...points, wasmIndex(points, 0)];
+	const h = loop.slice(1).map((p, i) => {
+		const q = wasmIndex(loop, i);
+		return Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
+	});
+	if (h.some((len) => len === 0)) throw new Error("brepkit: periodic interpolation through repeated points");
+	const t = [0];
+	for (const len of h) t.push(wasmIndex(t, t.length - 1) + len);
+	const tangent = lagrangeStartTangent(loop, t, points.length === 3 ? 2 : 3);
+	const derivatives = [
+		tangent,
+		...interiorDerivatives(loop, h, tangent),
+		tangent
+	];
+	const controlPoints = [...wasmIndex(loop, 0)];
+	const knots = [
+		0,
+		0,
+		0,
+		0
+	];
+	for (let i = 0; i < h.length; i++) {
+		const third = wasmIndex(h, i) / 3;
+		const p0 = wasmIndex(loop, i);
+		const p1 = wasmIndex(loop, i + 1);
+		const d0 = wasmIndex(derivatives, i);
+		const d1 = wasmIndex(derivatives, i + 1);
+		controlPoints.push(...p0.map((c, k) => c + third * wasmIndex(d0, k)));
+		controlPoints.push(...p1.map((c, k) => c - third * wasmIndex(d1, k)));
+		controlPoints.push(...p1);
+		const ti = wasmIndex(t, i + 1);
+		knots.push(ti, ti, ti);
+	}
+	knots.push(wasmIndex(t, t.length - 1));
+	const [x, y, z] = wasmIndex(loop, 0);
+	const weights = Array(controlPoints.length / 3).fill(1);
+	return edgeHandle(bk.makeNurbsEdge(x, y, z, x, y, z, 3, knots, controlPoints, weights));
+}
+/** Derivative at t[0] of the Lagrange polynomial through the first degree + 1 points. */
+function lagrangeStartTangent(pts, t, degree) {
+	const t0 = wasmIndex(t, 0);
+	const tangent = [
+		0,
+		0,
+		0
+	];
+	for (let j = 0; j <= degree; j++) {
+		let weight = j === 0 ? 0 : 1;
+		let den = 1;
+		for (let m = 0; m <= degree; m++) {
+			if (m === j) continue;
+			if (j === 0) weight += 1 / (t0 - wasmIndex(t, m));
+			else if (m !== 0) weight *= t0 - wasmIndex(t, m);
+			den *= wasmIndex(t, j) - wasmIndex(t, m);
+		}
+		if (j !== 0) weight /= den;
+		const p = wasmIndex(pts, j);
+		for (let k = 0; k < 3; k++) tangent[k] = wasmIndex(tangent, k) + weight * wasmIndex(p, k);
+	}
+	return tangent;
+}
+/**
+* Derivatives at the interior points of a cubic spline through `pts` (the first
+* point repeated at the end), from C2 continuity at each, with `tangent` at
+* both ends: one tridiagonal system per coordinate.
+*/
+function interiorDerivatives(pts, h, tangent) {
+	const sub = [];
+	const diag = [];
+	const sup = [];
+	const rhs = [
+		[],
+		[],
+		[]
+	];
+	const last = h.length - 1;
+	for (let i = 1; i <= last; i++) {
+		const hp = wasmIndex(h, i - 1);
+		const hn = wasmIndex(h, i);
+		sub.push(hn);
+		diag.push(2 * (hp + hn));
+		sup.push(hp);
+		const prev = wasmIndex(pts, i - 1);
+		const cur = wasmIndex(pts, i);
+		const next = wasmIndex(pts, i + 1);
+		for (let k = 0; k < 3; k++) {
+			const into = wasmIndex(cur, k) - wasmIndex(prev, k);
+			const out = wasmIndex(next, k) - wasmIndex(cur, k);
+			let r = 3 * (hn / hp * into + hp / hn * out);
+			if (i === 1) r -= hn * wasmIndex(tangent, k);
+			if (i === last) r -= hp * wasmIndex(tangent, k);
+			wasmIndex(rhs, k).push(r);
+		}
+	}
+	const [xs, ys, zs] = rhs.map((r) => solveTridiagonal(sub, diag, sup, r));
+	return xs.map((x, i) => [
+		x,
+		wasmIndex(ys, i),
+		wasmIndex(zs, i)
+	]);
+}
+/** Solve a tridiagonal system (sub-, main and super-diagonal) by the Thomas algorithm. */
+function solveTridiagonal(sub, diag, sup, rhs) {
+	const n = diag.length;
+	const c = [];
+	const d = [];
+	for (let i = 0; i < n; i++) {
+		const den = wasmIndex(diag, i) - (i > 0 ? wasmIndex(sub, i) * wasmIndex(c, i - 1) : 0);
+		c.push(wasmIndex(sup, i) / den);
+		d.push((wasmIndex(rhs, i) - (i > 0 ? wasmIndex(sub, i) * wasmIndex(d, i - 1) : 0)) / den);
+	}
+	const x = Array(n).fill(0);
+	for (let i = n - 1; i >= 0; i--) x[i] = wasmIndex(d, i) - (i < n - 1 ? wasmIndex(c, i) * wasmIndex(x, i + 1) : 0);
+	return x;
+}
 function approximatePoints(bk, points, options) {
 	const degree = options?.degMax ?? 3;
 	const tol = options?.tolerance ?? 1e-6;
@@ -7481,59 +7734,96 @@ function fillet(bk, shape, edges, radius) {
 	const solidId = unwrapSolidOrThrow(shape, "fillet");
 	const edgeIds = edges.map((e) => unwrap$1(e, "edge"));
 	if (typeof radius === "number") return solidHandle(bk.fillet(solidId, edgeIds, radius));
-	const spec = [];
-	for (const [i, edge] of edges.entries()) {
-		const edgeId = edgeIds[i] ?? 0;
-		let r;
-		if (typeof radius === "function") r = radius(edge);
-		else r = radius;
-		const [startR, endR] = Array.isArray(r) ? r : [r, r];
-		spec.push({
-			edge: edgeId,
-			startRadius: startR,
-			endRadius: endR
-		});
+	const radii = /* @__PURE__ */ new Set();
+	for (const edge of edges) {
+		const r = typeof radius === "function" ? radius(edge) : radius;
+		const [start, end] = Array.isArray(r) ? r : [r, r];
+		if (start !== end) throw varyingFilletUnsupported();
+		radii.add(start);
 	}
-	return solidHandle(bk.filletVariable(solidId, JSON.stringify(spec)));
+	if (radii.size > 1) throw perEdgeUnsupported("fillet radii");
+	const [only] = radii;
+	if (only === void 0) throw new Error("brepkit: fillet needs at least one edge");
+	return solidHandle(bk.fillet(solidId, edgeIds, only));
+}
+/**
+* brepkit takes one value for every edge of a fillet or chamfer call, and a
+* second call on the first one's result cannot name the input's other edges:
+* a chamfer fails on them ("no manifold edges to chamfer"), and a fillet builds
+* the right body but leaves the input solid corrupt, so that filleting the
+* input's four vertical cube edges at 2 mm afterwards cuts a flat chamfer.
+*/
+function perEdgeUnsupported(what) {
+	return new UnsupportedKernelOperationError(`brepkit: different ${what} on different edges in one call is not supported`);
+}
+/**
+* brepkit-wasm's filletVariable does not build a rolling-ball blend: on the
+* 40 mm top edge of a 40 x 30 x 20 box, a radius running 2 to 5 removes 260 mm3
+* where the blend removes about 113, and even a constant law of 3 removes 180
+* (the flat chamfer) where fillet removes 77.26. A radius that varies along an
+* edge is refused rather than built that way.
+*/
+function varyingFilletUnsupported() {
+	return new UnsupportedKernelOperationError("brepkit: a fillet radius that varies along an edge is not supported");
 }
-/** brepkit's two-distance chamfer, bound to `bk`; throws on builds without it. */
-function requireChamferAsymmetric(bk, what) {
-	if (typeof bk.chamferAsymmetric !== "function") throw new UnsupportedKernelOperationError(`brepkit: ${what} requires chamferAsymmetric, which this brepkit-wasm build lacks`);
-	return bk.chamferAsymmetric.bind(bk);
+/** occt's hashCode upper bound, which the kernel-agnostic filletVariable spec hashes edges with. */
+var HASH_UPPER_BOUND = 2147483647;
+/**
+* A variable fillet spec on one edge: `{ edge: hashCode, radii: [{ param, radius }] }`
+* from variableFillet, or `{ edgeId, startRadius, endRadius }`. A constant radius is
+* an ordinary fillet; a radius that varies is unsupported (see
+* {@link varyingFilletUnsupported}).
+*/
+function filletVariable$1(bk, shape, spec) {
+	const solidId = unwrapSolidOrThrow(shape, "filletVariable");
+	const parsed = JSON.parse(spec);
+	let edgeId;
+	let radii;
+	if (parsed.edge !== void 0 && parsed.radii !== void 0 && parsed.radii.length > 0) {
+		const hash = parsed.edge;
+		edgeId = toArray(bk.getSolidEdges(solidId)).find((id) => id % HASH_UPPER_BOUND === hash);
+		radii = parsed.radii.map((r) => r.radius);
+	} else if (parsed.edgeId !== void 0 && parsed.startRadius !== void 0 && parsed.endRadius !== void 0) {
+		edgeId = parsed.edgeId;
+		radii = [parsed.startRadius, parsed.endRadius];
+	} else throw new UnsupportedKernelOperationError("brepkit: filletVariable: unrecognized spec");
+	if (edgeId === void 0) throw new Error("brepkit: filletVariable: the edge is not an edge of the shape");
+	const [first = 0] = radii;
+	if (radii.some((r) => r !== first)) throw varyingFilletUnsupported();
+	return solidHandle(bk.fillet(solidId, [edgeId], first));
+}
+/**
+* A symmetric chamfer for two equal distances, brepkit's two-distance chamfer
+* otherwise. brepkit sets `d1` back on the edge's first face in its own face
+* order, which need not be the face occt-wasm picks for the same edge.
+*/
+function chamferTwoDistances(bk, solidId, edgeIds, d1, d2) {
+	return d1 === d2 ? bk.chamfer(solidId, edgeIds, d1) : bk.chamferV2(solidId, edgeIds, d1, d2);
 }
 function chamfer(bk, shape, edges, distance) {
 	const solidId = unwrapSolidOrThrow(shape, "chamfer");
 	const edgeIds = edges.map((e) => unwrap$1(e, "edge"));
 	if (typeof distance === "number") return solidHandle(bk.chamfer(solidId, edgeIds, distance));
-	if (Array.isArray(distance)) {
-		const [d1, d2] = distance;
-		if (d1 === d2) return solidHandle(bk.chamfer(solidId, edgeIds, d1));
-		return solidHandle(requireChamferAsymmetric(bk, "an asymmetric chamfer")(solidId, edgeIds, d1, d2));
-	}
-	const groups = /* @__PURE__ */ new Map();
-	for (const [i, edge] of edges.entries()) {
+	if (Array.isArray(distance)) return solidHandle(chamferTwoDistances(bk, solidId, edgeIds, distance[0], distance[1]));
+	const pairs = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
 		const r = distance(edge);
-		const eid = edgeIds[i];
-		if (eid === void 0) continue;
 		const [d1, d2] = Array.isArray(r) ? r : [r, r];
-		const key = `${d1},${d2}`;
-		const group = groups.get(key);
-		if (group) group.ids.push(eid);
-		else groups.set(key, {
-			ids: [eid],
-			d1,
-			d2
-		});
+		pairs.set(`${d1},${d2}`, [d1, d2]);
 	}
-	const asymmetric = [...groups.values()].some((g) => g.d1 !== g.d2) ? requireChamferAsymmetric(bk, "an asymmetric chamfer") : void 0;
-	let result = solidId;
-	for (const group of groups.values()) result = asymmetric && group.d1 !== group.d2 ? asymmetric(result, group.ids, group.d1, group.d2) : bk.chamfer(result, group.ids, group.d1);
-	return solidHandle(result);
+	if (pairs.size > 1) throw perEdgeUnsupported("chamfer distances");
+	const [only] = pairs.values();
+	if (only === void 0) throw new Error("brepkit: chamfer needs at least one edge");
+	return solidHandle(chamferTwoDistances(bk, solidId, edgeIds, only[0], only[1]));
 }
+/**
+* brepkit sets `distance` back on the edge's first face in its own face order
+* and the other face back by distance·tan(angle).
+*/
 function chamferDistAngle$1(bk, shape, edges, distance, angleDeg) {
-	const asymmetric = requireChamferAsymmetric(bk, "chamferDistAngle");
-	const d2 = distance * Math.tan(angleDeg * Math.PI / 180);
-	return solidHandle(asymmetric(unwrapSolidOrThrow(shape, "chamferDistAngle"), edges.map((e) => unwrap$1(e, "edge")), distance, d2));
+	const solidId = unwrapSolidOrThrow(shape, "chamferDistAngle");
+	const edgeIds = edges.map((e) => unwrap$1(e, "edge"));
+	return solidHandle(bk.chamferDistanceAngle(solidId, edgeIds, distance, angleDeg * Math.PI / 180));
 }
 function faceCentroid(bk, faceId) {
 	const verts = toArray(bk.getFaceVertices(faceId));
@@ -7616,10 +7906,6 @@ function offset$1(bk, shape, distance, tolerance) {
 	const solidId = unwrapSolidOrThrow(shape, "offset");
 	return solidHandle(bk.offsetSolidV2(solidId, distance));
 }
-function filletVariable$1(bk, shape, spec) {
-	const solidId = unwrapSolidOrThrow(shape, "filletVariable");
-	return solidHandle(bk.filletVariable(solidId, spec));
-}
 function draft$1(bk, shape, faces, pullDirection, neutralPlane, angleDeg) {
 	const solidId = unwrapSolidOrThrow(shape, "draft");
 	const faceIds = faces.map((f) => unwrap$1(f, "face"));
@@ -8016,22 +8302,151 @@ function fuseToolWithHistory(bk, toolSolidIds, accum, hashUpperBound) {
 	}
 	return union;
 }
+/** Whether this kernel can merge co-surface faces after `op` (brepkit-wasm >= 3.2). */
+function canSimplify(bk, op) {
+	if (op === "fuse") return typeof bk.fuseWithOptions === "function";
+	if (op === "cut") return typeof bk.cutWithOptions === "function";
+	return typeof bk.intersectWithOptions === "function";
+}
+/** A point inside a face: the centroid of its largest tessellation triangle. */
+var FACE_POINT_DEFLECTION = .1;
+function interiorPoint(bk, faceId) {
+	const mesh = bk.tessellateFace(faceId, FACE_POINT_DEFLECTION);
+	const at = (t) => vec3At(mesh.positions, wasmIndex(mesh.indices, t) * 3);
+	let best;
+	let bestArea = -1;
+	for (let t = 0; t + 2 < mesh.indices.length; t += 3) {
+		const [ax, ay, az] = at(t);
+		const [bx, by, bz] = at(t + 1);
+		const [cx, cy, cz] = at(t + 2);
+		const [ux, uy, uz] = [
+			bx - ax,
+			by - ay,
+			bz - az
+		];
+		const [vx, vy, vz] = [
+			cx - ax,
+			cy - ay,
+			cz - az
+		];
+		const area = Math.hypot(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx);
+		if (area > bestArea) {
+			bestArea = area;
+			best = [
+				(ax + bx + cx) / 3,
+				(ay + by + cy) / 3,
+				(az + bz + cz) / 3
+			];
+		}
+	}
+	return best;
+}
+/**
+* The box of a face's tessellation, grown by twice the deflection: the face
+* lies within one deflection of its mesh, and an `interiorPoint` within one
+* deflection of the face, so the box holds every interior point of the face.
+*/
+function faceMeshBox(bk, faceId) {
+	const { positions } = bk.tessellateFace(faceId, FACE_POINT_DEFLECTION);
+	if (positions.length < 3) return void 0;
+	const min = vec3At(positions, 0);
+	const max = [...min];
+	for (let i = 3; i + 2 < positions.length; i += 3) for (let k = 0; k < 3; k++) {
+		const v = wasmIndex(positions, i + k);
+		min[k] = Math.min(wasmIndex(min, k), v);
+		max[k] = Math.max(wasmIndex(max, k), v);
+	}
+	const pad = 2 * FACE_POINT_DEFLECTION;
+	for (let k = 0; k < 3; k++) {
+		min[k] = wasmIndex(min, k) - pad;
+		max[k] = wasmIndex(max, k) + pad;
+	}
+	return {
+		min,
+		max
+	};
+}
+function boxHolds(box, p) {
+	return p.every((v, k) => v >= wasmIndex(box.min, k) && v <= wasmIndex(box.max, k));
+}
+/**
+* Carry a boolean's face evolution over to the simplified result of the same
+* boolean. brepkit tracks face provenance only through its unsimplified
+* boolean, and merging co-surface faces makes new faces, so the boolean runs
+* twice: once with evolution, once simplified. Each face of the first result
+* lies inside one face of the second; a point inside it names that face.
+*/
+function simplifiedWithHistory(bk, tracked, simplified, hashUpperBound) {
+	const from = tracked.shape;
+	const to = simplified;
+	if (from.type !== "solid" || to.type !== "solid") return {
+		shape: simplified,
+		evolution: tracked.evolution
+	};
+	const targets = toArray(bk.getSolidFaces(to.id)).map((id) => ({
+		id,
+		box: faceMeshBox(bk, id)
+	}));
+	const into = /* @__PURE__ */ new Map();
+	for (const faceId of toArray(bk.getSolidFaces(from.id))) {
+		const p = interiorPoint(bk, faceId);
+		if (!p) continue;
+		const near = targets.filter(({ box }) => !box || boxHolds(box, p));
+		let nearest;
+		let nearestDistance = Infinity;
+		for (const { id } of near.length > 0 ? near : targets) {
+			const d = wasmIndex(bk.pointToFaceDistance(p[0], p[1], p[2], id), 0);
+			if (d < nearestDistance) {
+				nearestDistance = d;
+				nearest = id;
+			}
+		}
+		if (nearest !== void 0) into.set(faceId % hashUpperBound, nearest % hashUpperBound);
+	}
+	const remap = (m) => new Map([...m].map(([k, outs]) => [k, [...new Set(outs.map((o) => into.get(o) ?? o))]]));
+	return {
+		shape: simplified,
+		evolution: {
+			modified: remap(tracked.evolution.modified),
+			generated: remap(tracked.evolution.generated),
+			deleted: tracked.evolution.deleted
+		}
+	};
+}
 /**
 * Shared implementation for boolean-with-history operations (fuse, cut, intersect).
+* With `simplify`, the evolution comes from the unsimplified boolean and is
+* carried over to the simplified one (see {@link simplifiedWithHistory}).
 */
 function booleanWithHistoryImpl(bk, shape, tool, inputFaceHashes, hashUpperBound, options, nativeFn, fallbackFn, op) {
+	const tracked = trackedBoolean(bk, shape, tool, inputFaceHashes, hashUpperBound, options, nativeFn, fallbackFn, op);
 	const noDiagnostics = {
 		hasErrors: false,
 		hasWarnings: false,
 		messages: []
 	};
+	if (!tracked.native || !options?.simplify || !canSimplify(bk, op)) return {
+		...tracked.result,
+		diagnostics: noDiagnostics
+	};
+	return {
+		...simplifiedWithHistory(bk, tracked.result, fallbackFn(shape, tool, options), hashUpperBound),
+		diagnostics: noDiagnostics
+	};
+}
+/**
+* The boolean with its face evolution: brepkit's native evolution for a solid
+* base (`native: true`), geometric matching otherwise. The native path ignores
+* `simplify`; the fallback applies it.
+*/
+function trackedBoolean(bk, shape, tool, inputFaceHashes, hashUpperBound, options, nativeFn, fallbackFn, op) {
 	const sh = shape;
 	const th = tool;
 	if (inputFaceHashes.length > 0 && sh.type === "solid") {
 		if (th.type === "solid") try {
 			return {
-				...parseNativeEvolution(nativeFn(sh.id, th.id), hashUpperBound),
-				diagnostics: noDiagnostics
+				result: parseNativeEvolution(nativeFn(sh.id, th.id), hashUpperBound),
+				native: true
 			};
 		} catch (e) {
 			if (!isEmptyBooleanError(e)) throw e;
@@ -8047,19 +8462,21 @@ function booleanWithHistoryImpl(bk, shape, tool, inputFaceHashes, hashUpperBound
 			let steps = toolSolidIds;
 			if (op === "intersect" && toolSolidIds.length > 1) steps = [fuseToolWithHistory(bk, toolSolidIds, accum, hashUpperBound) ?? bk.fuseAll(toolSolidIds)];
 			return {
-				shape: applyCompoundBooleanWithHistory(shape, steps, accum, hashUpperBound, nativeFn),
-				evolution: {
-					modified: accum.combinedModified,
-					generated: accum.combinedGenerated,
-					deleted: accum.combinedDeleted
+				result: {
+					shape: applyCompoundBooleanWithHistory(shape, steps, accum, hashUpperBound, nativeFn),
+					evolution: {
+						modified: accum.combinedModified,
+						generated: accum.combinedGenerated,
+						deleted: accum.combinedDeleted
+					}
 				},
-				diagnostics: noDiagnostics
+				native: true
 			};
 		}
 	}
 	return {
-		...buildEvolution(bk, fallbackFn(shape, tool, options), inputFaceHashes, hashUpperBound, false, shape),
-		diagnostics: noDiagnostics
+		result: buildEvolution(bk, fallbackFn(shape, tool, options), inputFaceHashes, hashUpperBound, false, shape),
+		native: false
 	};
 }
 function translateWithHistory(bk, shape, x, y, z, inputFaceHashes, hashUpperBound) {
@@ -8161,36 +8578,45 @@ function mesh$1(bk, shape, options) {
 	const angularTol = options.angularTolerance > 0 ? options.angularTolerance : void 0;
 	let result;
 	if (bkHandle.type === "solid") result = meshSolid(bk, h, deflection, !!options.includeUVs, angularTol);
-	else if (bkHandle.type === "face") result = meshSingleFace(bk, h, deflection, 0, angularTol);
-	else if (bkHandle.type === "compound") result = meshCompound(bk, h, deflection, !!options.includeUVs, angularTol);
+	else if (bkHandle.type === "face") result = meshSingleFace(bk, h, deflection, angularTol);
+	else if (bkHandle.type === "compound" || bkHandle.type === "shell") result = concatMeshes(meshParts(bk, bkHandle, deflection, !!options.includeUVs, angularTol));
 	else throw new Error(`brepkit: cannot mesh shape of type '${bkHandle.type}'`);
 	if (options.skipNormals) result.normals = /* @__PURE__ */ new Float32Array(0);
 	if (!options.includeUVs) result.uvs = /* @__PURE__ */ new Float32Array(0);
 	return result;
 }
 /**
-* Mesh every solid in a compound and concatenate the results.
+* Mesh each solid and face inside a compound or shell, one part apiece.
 *
-* Text solids are compounds — one solid per glyph — so without this the whole
-* text path throws before any geometry runs, which reads as a geometry failure
-* when it is really a missing adapter capability.
+* Text solids are compounds (one solid per glyph), and a sheet of loose faces
+* is a compound of faces or a sewn shell, so each child is meshed by what it
+* is: a solid as a solid, a shell as its faces, a face as itself.
+*
+* Compounds come in two flavours and only one is arena-backed. A synthetic
+* compound (non-solid children, id from `nextSyntheticId`) exists JS-side only,
+* so asking the kernel to resolve it raises an invalid-handle error; its
+* children are read from `syntheticCompounds` instead. Wires, edges and
+* vertices contribute no triangles and are skipped rather than throwing.
+*/
+function meshParts(bk, h, deflection, includeUVs, angularTolerance) {
+	switch (h.type) {
+		case "solid": return [meshSolid(bk, h.id, deflection, includeUVs, angularTolerance)];
+		case "face": return [meshSingleFace(bk, h.id, deflection, angularTolerance)];
+		case "shell": return toArray(bk.getShellFaces(h.id)).map((faceId) => meshSingleFace(bk, faceId, deflection, angularTolerance));
+		case "compound": return (syntheticCompounds.get(h.id) ?? toArray(bk.getCompoundSolids(h.id)).map(solidHandle)).flatMap((child) => meshParts(bk, child, deflection, includeUVs, angularTolerance));
+		default: return [];
+	}
+}
+/**
+* Concatenate meshes into one.
 *
 * Triangle indices are vertex-relative, so each part's are rebased by the
 * running vertex count; `faceGroups` index into the triangle list, so their
 * `start` is rebased by the running triangle count. `uvs` are only carried
 * when every part supplied them, since a partial UV array would misalign
 * against the concatenated vertices.
-*
-* Compounds come in two flavours and only one is arena-backed. A synthetic
-* compound (non-solid children, id from `nextSyntheticId`) exists JS-side only,
-* so asking the kernel to resolve it raises an invalid-handle error; its
-* children are read from `syntheticCompounds` instead. Non-solid children
-* contribute no triangles and are skipped rather than throwing, matching how a
-* wire or edge meshes to nothing elsewhere in this adapter.
 */
-function meshCompound(bk, compoundId, deflection, includeUVs, angularTolerance) {
-	const synthetic = syntheticCompounds.get(compoundId);
-	const parts = (synthetic ? synthetic.filter((c) => c.type === "solid").map((c) => c.id) : toArray(bk.getCompoundSolids(compoundId))).map((id) => meshSolid(bk, id, deflection, includeUVs, angularTolerance));
+function concatMeshes(parts) {
 	if (parts.length === 1) return wasmIndex(parts, 0);
 	if (parts.length === 0) return {
 		vertices: /* @__PURE__ */ new Float32Array(0),
@@ -8237,12 +8663,21 @@ function meshCompound(bk, compoundId, deflection, includeUVs, angularTolerance)
 }
 function meshEdges$1(bk, shape, tolerance, angularTolerance) {
 	const bkHandle = shape;
-	if (bkHandle.type !== "solid") return {
-		lines: /* @__PURE__ */ new Float32Array(0),
-		edgeGroups: []
-	};
 	const angularTol = angularTolerance > 0 ? angularTolerance : void 0;
+	if (bkHandle.type !== "solid") {
+		const seen = /* @__PURE__ */ new Set();
+		const edgeIds = [];
+		for (const edge of iterShapes$1(bk, shape, "edge")) {
+			const id = unwrap$1(edge);
+			if (seen.has(id)) continue;
+			seen.add(id);
+			edgeIds.push(id);
+		}
+		return sampleEdges(bk, edgeIds, tolerance, angularTol ?? DEFAULT_ANGULAR_TOLERANCE);
+	}
+	const edgeIds = toArray(bk.getSolidEdges(bkHandle.id));
 	const edgeLines = bk.meshEdgesAll(bkHandle.id, tolerance, angularTol);
+	if (edgeLines.edgeCount !== edgeIds.length) return sampleEdges(bk, edgeIds, tolerance, angularTol ?? DEFAULT_ANGULAR_TOLERANCE);
 	const positions = edgeLines.positions;
 	const offsets = edgeLines.offsets;
 	const edgeCount = edgeLines.edgeCount;
@@ -8262,7 +8697,7 @@ function meshEdges$1(bk, shape, tolerance, angularTolerance) {
 		edgeGroups.push({
 			start: segStart,
 			count: segments.length / 3 - segStart,
-			edgeHash: i
+			edgeHash: wasmIndex(edgeIds, i)
 		});
 	}
 	return {
@@ -8270,6 +8705,78 @@ function meshEdges$1(bk, shape, tolerance, angularTolerance) {
 		edgeGroups
 	};
 }
+/** brepkit's own default angular deflection (`DEFAULT_ANGULAR_TOL`, ~20°). */
+var DEFAULT_ANGULAR_TOLERANCE = .35;
+var EDGE_SAMPLE_START_SEGMENTS = 4;
+var EDGE_SAMPLE_MAX_DEPTH = 8;
+/**
+* Sample edges one at a time into line-segment pairs labelled with each edge's
+* id. Edges outside a solid have no batch sampler, so each curve is split until
+* a segment's midpoint sits within `tolerance` of its chord and its end
+* tangents turn by no more than `angularTolerance`.
+*/
+function sampleEdges(bk, edgeIds, tolerance, angularTolerance) {
+	const segments = [];
+	const edgeGroups = [];
+	for (const edgeId of edgeIds) {
+		const points = sampleEdgePoints(bk, edgeId, tolerance, angularTolerance);
+		const segStart = segments.length / 3;
+		for (let i = 0; i + 1 < points.length; i++) segments.push(...wasmIndex(points, i), ...wasmIndex(points, i + 1));
+		edgeGroups.push({
+			start: segStart,
+			count: segments.length / 3 - segStart,
+			edgeHash: edgeId
+		});
+	}
+	return {
+		lines: new Float32Array(segments),
+		edgeGroups
+	};
+}
+function sampleEdgePoints(bk, edgeId, tolerance, angularTolerance) {
+	if (bk.getEdgeCurveType(edgeId) === "LINE") {
+		const v = bk.getEdgeVertices(edgeId);
+		return [vec3At(v, 0), vec3At(v, 3)];
+	}
+	const [t0, t1] = edgeParamRange(bk, edgeId);
+	const at = (t) => {
+		const r = bk.evaluateEdgeCurveD1(edgeId, t);
+		return {
+			p: vec3At(r, 0),
+			d: vec3At(r, 3)
+		};
+	};
+	const points = [];
+	const refine = (a, pa, b, pb, depth) => {
+		const m = (a + b) / 2;
+		const pm = at(m);
+		const sag = Math.hypot(pm.p[0] - (pa.p[0] + pb.p[0]) / 2, pm.p[1] - (pa.p[1] + pb.p[1]) / 2, pm.p[2] - (pa.p[2] + pb.p[2]) / 2);
+		if (depth < EDGE_SAMPLE_MAX_DEPTH && (sag > tolerance || turnAngle(pa.d, pb.d) > angularTolerance)) {
+			refine(a, pa, m, pm, depth + 1);
+			refine(m, pm, b, pb, depth + 1);
+			return;
+		}
+		points.push(pb.p);
+	};
+	let prevT = t0;
+	let prev = at(t0);
+	points.push(prev.p);
+	for (let i = 1; i <= EDGE_SAMPLE_START_SEGMENTS; i++) {
+		const t = t0 + (t1 - t0) * i / EDGE_SAMPLE_START_SEGMENTS;
+		const next = at(t);
+		refine(prevT, prev, t, next, 0);
+		prevT = t;
+		prev = next;
+	}
+	return points;
+}
+function turnAngle(a, b) {
+	const la = Math.hypot(a[0], a[1], a[2]);
+	const lb = Math.hypot(b[0], b[1], b[2]);
+	if (la === 0 || lb === 0) return 0;
+	const cos = (a[0] * b[0] + a[1] * b[1] + a[2] * b[2]) / (la * lb);
+	return Math.acos(Math.min(1, Math.max(-1, cos)));
+}
 function hasTriangulation$1(_bk, _shape) {
 	return false;
 }
@@ -8416,8 +8923,8 @@ function meshSolidPerFace(bk, solidId, deflection, angularTolerance) {
 		faceGroups
 	};
 }
-/** Tessellate a single face and return brepjs mesh format. */
-function meshSingleFace(bk, faceId, deflection, faceHash, angularTolerance) {
+/** Tessellate a single face, its triangles grouped under the face's own hash. */
+function meshSingleFace(bk, faceId, deflection, angularTolerance) {
 	const faceMesh = bk.tessellateFace(faceId, deflection, angularTolerance);
 	const positions = faceMesh.positions;
 	const normals = faceMesh.normals;
@@ -8433,7 +8940,7 @@ function meshSingleFace(bk, faceId, deflection, faceHash, angularTolerance) {
 		faceGroups: [{
 			start: 0,
 			count: indices.length,
-			faceHash
+			faceHash: faceId
 		}]
 	};
 }
@@ -8446,22 +8953,219 @@ function makeMeshOps$1(bk) {
 		meshShape: (shape, tolerance, angularTolerance) => {}
 	};
 }
+// src/kernel/brepkit/igesMerge.ts
+/**
+* Merge single-solid brepkit IGES documents into one.
+*
+* brepkit-wasm's `exportIges` takes one solid, but an IGES file holds one
+* document. brepkit's writer emits only standalone entities that point at no
+* other entity, so the merge appends each later document's directory and
+* parameter entries, renumbering only the fixed-column fields that number or
+* link them, and keeps the first document's start and global sections.
+*
+* @module
+*/
+/** Plane, line, B-spline curve and B-spline surface: the entities brepkit writes. */
+var POINTER_FREE = /* @__PURE__ */ new Set([
+	108,
+	110,
+	126,
+	128
+]);
+var PLANE = 108;
+/** A plane's sixth parameter points at its bounding curve; brepkit writes none. */
+var PLANE_BOUND = 5;
+/** Each line by the section letter in column 73. */
+function sections(doc) {
+	const bySection = /* @__PURE__ */ new Map();
+	for (const line of doc.split("\n")) {
+		if (line.length < 73) continue;
+		const letter = line.charAt(72);
+		const lines = bySection.get(letter) ?? [];
+		lines.push(line.slice(0, 80));
+		bySection.set(letter, lines);
+	}
+	return {
+		start: bySection.get("S") ?? [],
+		global: bySection.get("G") ?? [],
+		directory: bySection.get("D") ?? [],
+		parameter: bySection.get("P") ?? []
+	};
+}
+/** The `index`th 8-column field of a directory line. */
+function field(line, index) {
+	return Number(line.slice(index * 8, index * 8 + 8).trim() || "0");
+}
+function withField(line, index, value) {
+	return line.slice(0, index * 8) + String(value).padStart(8) + line.slice(index * 8 + 8);
+}
+/** `line` with its section letter and sequence number in columns 73-80. */
+function withSequence(line, letter, sequence) {
+	return line.slice(0, 72).padEnd(72) + letter + String(sequence).padStart(7);
+}
+/** Throw unless the entity a directory entry describes points at nothing. */
+function assertPointerFree(line1, line2, parameter) {
+	const type = field(line1, 0);
+	const linked = [
+		2,
+		3,
+		4,
+		5,
+		6,
+		7
+	].some((i) => field(line1, i) !== 0) || field(line2, 2) !== 0;
+	let bounded = false;
+	if (type === PLANE) {
+		const first = field(line1, 1) - 1;
+		bounded = (parameter.slice(first, first + field(line2, 3)).map((l) => l.slice(0, 64)).join("").split(/[,;]/)[PLANE_BOUND]?.trim() ?? "0") !== "0";
+	}
+	if (!POINTER_FREE.has(type) || linked || bounded) throw new Error(`brepkit: cannot merge IGES documents holding a linked entity (type ${type})`);
+}
+/** One IGES document holding the entities of every brepkit IGES document in `docs`. */
+function mergeIgesDocuments(docs) {
+	const [first, ...rest] = docs;
+	if (first === void 0) return "";
+	if (rest.length === 0) return first;
+	const base = sections(first);
+	const directory = [];
+	const parameter = [];
+	for (const doc of docs) {
+		const { directory: d, parameter: p } = sections(doc);
+		const dOffset = directory.length;
+		const pOffset = parameter.length;
+		for (let i = 0; i + 1 < d.length; i += 2) {
+			const line1 = d[i] ?? "";
+			const line2 = d[i + 1] ?? "";
+			assertPointerFree(line1, line2, p);
+			const renumbered = withField(line1, 1, field(line1, 1) + pOffset);
+			directory.push(withSequence(renumbered, "D", dOffset + i + 1));
+			directory.push(withSequence(line2, "D", dOffset + i + 2));
+		}
+		p.forEach((line, j) => {
+			const owner = Number(line.slice(64, 72).trim()) + dOffset;
+			parameter.push(withSequence(line.slice(0, 64) + String(owner).padStart(8), "P", pOffset + j + 1));
+		});
+	}
+	const count = (letter, n) => letter + String(n).padStart(7);
+	const terminate = count("S", base.start.length) + count("G", base.global.length) + count("D", directory.length) + count("P", parameter.length);
+	return [
+		...base.start,
+		...base.global,
+		...directory,
+		...parameter,
+		withSequence(terminate, "T", 1),
+		""
+	].join("\n");
+}
+// src/kernel/brepkit/stepMerge.ts
+var REPRESENTATION = /^(ADVANCED_BREP_SHAPE_REPRESENTATION\s*\(\s*'(?:[^']|'')*'\s*,\s*\()([^)]*)\)/;
+/** A string literal, kept as is, or a `#n` entity reference. */
+var TOKEN = /'(?:[^']|'')*'|#(\d+)/g;
+/** Rewrite every `#n` reference outside a string literal to `#map(n)`. */
+function mapRefs(body, map) {
+	return body.replace(TOKEN, (token, id) => id === void 0 ? token : `#${map(Number(id))}`);
+}
+function refsOf(body) {
+	const refs = [];
+	mapRefs(body, (id) => {
+		refs.push(id);
+		return id;
+	});
+	return refs;
+}
+/** Split the data section into records at semicolons outside string literals. */
+function parseStep(doc) {
+	const dataStart = doc.indexOf("DATA;");
+	if (dataStart < 0) throw new Error("brepkit: STEP document has no DATA section");
+	const bodyStart = dataStart + 5;
+	const records = [];
+	let inString = false;
+	let start = bodyStart;
+	for (let i = bodyStart; i < doc.length; i++) {
+		const ch = doc.charAt(i);
+		if (ch === "'") inString = !inString;
+		if (inString || ch !== ";") continue;
+		const statement = doc.slice(start, i).trim();
+		if (statement === "ENDSEC") return {
+			head: doc.slice(0, bodyStart),
+			tail: doc.slice(start).trimStart(),
+			records
+		};
+		const match = /^#(\d+)\s*=\s*([\s\S]*)$/.exec(statement);
+		if (!match) throw new Error(`brepkit: unreadable STEP record '${statement.slice(0, 40)}'`);
+		records.push({
+			id: Number(match[1]),
+			body: match[2] ?? ""
+		});
+		start = i + 1;
+	}
+	throw new Error("brepkit: STEP document has an unterminated DATA section");
+}
+function representationIndex(records) {
+	const index = records.findIndex((r) => REPRESENTATION.test(r.body));
+	if (index < 0) throw new Error("brepkit: STEP document has no shape representation");
+	return index;
+}
+/** The ids of the solids a document's shape representation lists. */
+function solidIds(records) {
+	const rep = records[representationIndex(records)];
+	return refsOf(REPRESENTATION.exec(rep?.body ?? "")?.[2] ?? "");
+}
+/** The records `roots` reach, in file order, renumbered consecutively from `firstId`. */
+function takeReachable(records, roots, firstId) {
+	const byId = new Map(records.map((r) => [r.id, r.body]));
+	const reached = /* @__PURE__ */ new Set();
+	const pending = [...roots];
+	while (pending.length > 0) {
+		const id = pending.pop() ?? 0;
+		if (reached.has(id)) continue;
+		reached.add(id);
+		for (const ref of refsOf(byId.get(id) ?? "")) pending.push(ref);
+	}
+	const kept = records.filter((r) => reached.has(r.id));
+	const renumber = new Map(kept.map((r, i) => [r.id, firstId + i]));
+	const remap = (id) => renumber.get(id) ?? id;
+	return {
+		lines: kept.map((r) => `#${remap(r.id)} = ${mapRefs(r.body, remap)};`),
+		renumber
+	};
+}
+/** One STEP document holding the solids of every brepkit STEP document in `docs`. */
+function mergeStepDocuments(docs) {
+	const [first, ...rest] = docs;
+	if (first === void 0) return "";
+	if (rest.length === 0) return first;
+	const base = parseStep(first);
+	let nextId = base.records.reduce((max, r) => Math.max(max, r.id), 0) + 1;
+	const added = [];
+	const solids = [];
+	for (const doc of rest) {
+		const { records } = parseStep(doc);
+		const roots = solidIds(records);
+		const { lines, renumber } = takeReachable(records, roots, nextId);
+		for (const line of lines) added.push(line);
+		for (const id of roots) solids.push(renumber.get(id) ?? id);
+		nextId += lines.length;
+	}
+	const repIndex = representationIndex(base.records);
+	const extraItems = solids.map((id) => `, #${id}`).join("");
+	const addItems = (_match, open, items) => `${open}${items}${extraItems})`;
+	const lines = base.records.map(({ id, body }, i) => `#${id} = ${i === repIndex ? body.replace(REPRESENTATION, addItems) : body};`);
+	const merged = [
+		...lines.slice(0, repIndex),
+		...added,
+		...lines.slice(repIndex)
+	];
+	return `${base.head}\n${merged.join("\n")}\n${base.tail}`;
+}
 // src/kernel/brepkit/ioOps.ts
 function exportSTEP(bk, shapes) {
 	if (shapes.length === 0) return "";
-	const parts = [];
-	for (const shape of shapes) {
-		const solidIds = unwrapSolidsForExport(bk, shape, "exportSTEP");
-		for (const sid of solidIds) {
-			const bytes = bk.exportStep(sid);
-			parts.push(new TextDecoder().decode(bytes));
-		}
-	}
-	return parts.join("\n");
+	return mergeStepDocuments(shapes.flatMap((shape) => unwrapSolidsForExport(bk, shape, "exportSTEP")).map((sid) => new TextDecoder().decode(bk.exportStep(sid))));
 }
 function exportSTL$1(bk, shape, binary, tolerance = DEFAULT_STL_TOLERANCE, angularTolerance = DEFAULT_STL_ANGULAR_TOLERANCE) {
-	const solidIds = unwrapSolidsForExport(bk, shape, "exportSTL");
-	const { vertices, triangles } = mesh$1(bk, solidHandle(wasmIndex(solidIds, 0)), {
+	unwrapSolidsForExport(bk, shape, "exportSTL");
+	const { vertices, triangles } = mesh$1(bk, shape, {
 		tolerance,
 		angularTolerance,
 		skipNormals: true
@@ -8478,15 +9182,7 @@ function importSTL(bk, data) {
 }
 function exportIGES(bk, shapes) {
 	if (shapes.length === 0) return "";
-	const parts = [];
-	for (const shape of shapes) {
-		const solidIds = unwrapSolidsForExport(bk, shape, "exportIGES");
-		for (const sid of solidIds) {
-			const bytes = bk.exportIges(sid);
-			parts.push(new TextDecoder().decode(bytes));
-		}
-	}
-	return parts.join("\n");
+	return mergeIgesDocuments(shapes.flatMap((shape) => unwrapSolidsForExport(bk, shape, "exportIGES")).map((sid) => new TextDecoder().decode(bk.exportIges(sid))));
 }
 function importIGES(bk, data) {
 	const bytes = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
@@ -8529,9 +9225,11 @@ function toBREP(bk, shape) {
 }
 function fromBREP(bk, data) {
 	if (typeof bk.fromBREP === "function" && data.trimStart().startsWith("{")) return solidHandle(bk.fromBREP(data));
-	const first = importSTEP(bk, data)[0];
+	const shapes = importSTEP(bk, data);
+	const [first] = shapes;
 	if (!first) throw new Error("brepkit: fromBREP produced no shapes");
-	return first;
+	if (shapes.length === 1) return first;
+	return compoundHandle(bk.makeCompound(shapes.map((s) => unwrap$1(s, "solid"))));
 }
 function createXCAFDocument(_bk, shapes) {
 	return {
@@ -9222,19 +9920,9 @@ function liftCurve2dToPlane(bk, curve, origin, planeZ, planeX) {
 				-planeZ[2]
 			];
 			const bounds = curveBounds(c);
-			let angularSpan;
-			if (c.__bk2d === "trimmed") angularSpan = Math.abs(c.tEnd - c.tStart);
-			else angularSpan = 2 * Math.PI;
-			const nSegments = angularSpan > Math.PI ? 4 : angularSpan > Math.PI / 2 ? 2 : 1;
-			const segmentSpan = (bounds.last - bounds.first) / nSegments;
-			const edgeIds = [];
-			for (let seg = 0; seg < nSegments; seg++) {
-				const [su, sv] = evaluateCurve2d$2(c, bounds.first + seg * segmentSpan);
-				const [eu, ev] = evaluateCurve2d$2(c, bounds.first + (seg + 1) * segmentSpan);
-				edgeIds.push(bk.makeCircleArc3d(...lift(su, sv), ...lift(eu, ev), ...center3d, ...axis));
-			}
-			if (edgeIds.length === 1) return edgeHandle(wasmIndex(edgeIds, 0));
-			return wireHandle(bk.makeWire(edgeIds, false));
+			const [su, sv] = evaluateCurve2d$2(c, bounds.first);
+			const [eu, ev] = evaluateCurve2d$2(c, bounds.last);
+			return edgeHandle(bk.makeCircleArc3d(...lift(su, sv), ...lift(eu, ev), ...center3d, ...axis));
 		}
 		if (basis.__bk2d === "ellipse") {
 			const ell = basis;
@@ -9349,9 +10037,7 @@ function refineUVSamples(uvSamples, evaluateUV, maxSamples, threshold) {
 function extractCurve2dFromEdge(bk, edge, face) {
 	const eid = unwrap$1(edge, "edge");
 	const fid = unwrap$1(face, "face");
-	const params = bk.getEdgeCurveParameters(eid);
-	const tMin = params[0] ?? 0;
-	const tMax = params[1] ?? 1;
+	const [tMin, tMax] = edgeParamRange(bk, eid);
 	const BASE_N = 20;
 	const MAX_N = 80;
 	const REFINE_THRESHOLD = .05;
@@ -9388,9 +10074,7 @@ function fillSurface(bk, wires, _options) {
 			const curveLengths = [];
 			for (const edge of wireEdges) {
 				const edgeId = unwrap$1(edge, "edge");
-				const params = bk.getEdgeCurveParameters(edgeId);
-				const tMin = wasmIndex(params, 0);
-				const tMax = wasmIndex(params, 1);
+				const [tMin, tMax] = edgeParamRange(bk, edgeId);
 				const N = 10;
 				const pts = [];
 				for (let i = 0; i <= N; i++) {
@@ -9565,23 +10249,9 @@ function linearCenterOfMass(bk, shape) {
 	return centerOfMass$1(bk, shape);
 }
 function boundingBox$1(bk, shape) {
-	const h = shape;
-	if (h.type === "solid") {
-		const bb = bk.boundingBox(unwrap$1(shape));
-		return {
-			min: vec3At(bb, 0),
-			max: vec3At(bb, 3)
-		};
-	}
-	if (h.type === "vertex") {
-		const pos = vertexPosition(bk, shape);
-		return {
-			min: [...pos],
-			max: [...pos]
-		};
-	}
-	const vertices = iterShapes$1(bk, shape, "vertex");
-	if (vertices.length === 0) return {
+	const points = boxPoints(bk, shape);
+	const [first] = points;
+	if (!first) return {
 		min: [
 			0,
 			0,
@@ -9593,76 +10263,105 @@ function boundingBox$1(bk, shape) {
 			0
 		]
 	};
-	const first = vertexPosition(bk, vertices[0]);
-	let minX = first[0], minY = first[1], minZ = first[2];
-	let maxX = first[0], maxY = first[1], maxZ = first[2];
-	for (let i = 1; i < vertices.length; i++) {
-		const p = vertexPosition(bk, vertices[i]);
-		if (p[0] < minX) minX = p[0];
-		if (p[0] > maxX) maxX = p[0];
-		if (p[1] < minY) minY = p[1];
-		if (p[1] > maxY) maxY = p[1];
-		if (p[2] < minZ) minZ = p[2];
-		if (p[2] > maxZ) maxZ = p[2];
+	const min = [...first];
+	const max = [...first];
+	for (const p of points) for (let k = 0; k < 3; k++) {
+		min[k] = Math.min(wasmIndex(min, k), wasmIndex(p, k));
+		max[k] = Math.max(wasmIndex(max, k), wasmIndex(p, k));
 	}
 	return {
-		min: [
-			minX,
-			minY,
-			minZ
-		],
-		max: [
-			maxX,
-			maxY,
-			maxZ
-		]
+		min,
+		max
 	};
 }
+/**
+* Points whose bounding box is the shape's: a solid's own box corners, and for
+* anything else the box points of its edges (see `edgeBoxPoints`), so an arc's
+* bulge counts and not just its end vertices.
+*/
+function boxPoints(bk, h) {
+	switch (h.type) {
+		case "solid": {
+			const bb = bk.boundingBox(h.id);
+			return [vec3At(bb, 0), vec3At(bb, 3)];
+		}
+		case "vertex": return [vec3At(bk.getVertexPosition(h.id))];
+		case "edge": return edgeBoxPoints(bk, h.id);
+		case "compound": return (syntheticCompounds.get(h.id) ?? compoundSolidIds(bk, h.id).map(solidHandle)).flatMap((child) => boxPoints(bk, child));
+		default: {
+			const edges = iterShapes$1(bk, h, "edge");
+			if (edges.length > 0) return edges.flatMap((e) => edgeBoxPoints(bk, unwrap$1(e)));
+			return iterShapes$1(bk, h, "vertex").map((v) => vertexPosition(bk, v));
+		}
+	}
+}
+/**
+* Minimum distance between two shapes. brepkit-wasm measures from a point to a
+* solid, face or edge, and between two solids; a wire, shell or compound is
+* measured through its edges, faces or children, taking the closest pair. Any
+* other pairing (face to face, edge to edge, face to solid, ...) has no exact
+* brepkit measure and throws {@link UnsupportedKernelOperationError}.
+*/
 function distance$1(bk, shape1, shape2) {
-	const h1 = shape1;
-	const h2 = shape2;
-	if (h1.type === "solid" && h2.type === "solid") {
-		const buf = bk.solidToSolidDistance(h1.id, h2.id);
+	const parts1 = distanceParts(bk, shape1);
+	const parts2 = distanceParts(bk, shape2);
+	let best;
+	for (const a of parts1) for (const b of parts2) {
+		const d = partDistance(bk, a, b);
+		if (best === void 0 || d.value < best.value) best = d;
+	}
+	if (best === void 0) throw new Error("brepkit: distance needs two non-empty shapes");
+	return best;
+}
+/** The solids, faces, edges and vertices a shape is measured through. */
+function distanceParts(bk, h) {
+	switch (h.type) {
+		case "wire": return toArray(bk.getWireEdges(h.id)).map(edgeHandle);
+		case "shell": return toArray(bk.getShellFaces(h.id)).map(faceHandle);
+		case "compound": return (syntheticCompounds.get(h.id) ?? compoundSolidIds(bk, h.id).map(solidHandle)).flatMap((child) => distanceParts(bk, child));
+		default: return [h];
+	}
+}
+function partDistance(bk, a, b) {
+	if (a.type === "solid" && b.type === "solid") {
+		const buf = bk.solidToSolidDistance(a.id, b.id);
 		return {
 			value: wasmIndex(buf, 0),
 			point1: vec3At(buf, 1),
 			point2: vec3At(buf, 4)
 		};
 	}
-	if (h1.type === "vertex" && (h2.type === "solid" || h2.type === "face" || h2.type === "edge")) {
-		const point1 = vec3At(bk.getVertexPosition(h1.id));
-		const result = h2.type === "solid" ? bk.pointToSolidDistance(point1[0], point1[1], point1[2], h2.id) : h2.type === "face" ? bk.pointToFaceDistance(point1[0], point1[1], point1[2], h2.id) : bk.pointToEdgeDistance(point1[0], point1[1], point1[2], h2.id);
+	if (a.type === "vertex") return pointDistance(bk, a, b);
+	if (b.type === "vertex") {
+		const d = pointDistance(bk, b, a);
+		return {
+			value: d.value,
+			point1: d.point2,
+			point2: d.point1
+		};
+	}
+	throw new UnsupportedKernelOperationError(`brepkit: no distance between a ${a.type} and a ${b.type}; brepkit-wasm measures from a point to a solid, face or edge, and between two solids`);
+}
+function pointDistance(bk, v, to) {
+	const point1 = vec3At(bk.getVertexPosition(v.id));
+	if (to.type === "vertex") {
+		const point2 = vec3At(bk.getVertexPosition(to.id));
 		return {
-			value: wasmIndex(result, 0),
+			value: Math.hypot(point2[0] - point1[0], point2[1] - point1[1], point2[2] - point1[2]),
 			point1,
-			point2: vec3At(result, 1)
+			point2
 		};
 	}
-	const getPos = (s) => {
-		if (s.type === "vertex") return vec3At(bk.getVertexPosition(s.id));
-		if (s.type === "solid") {
-			const bb = bk.boundingBox(s.id);
-			return [
-				(wasmIndex(bb, 0) + wasmIndex(bb, 3)) / 2,
-				(wasmIndex(bb, 1) + wasmIndex(bb, 4)) / 2,
-				(wasmIndex(bb, 2) + wasmIndex(bb, 5)) / 2
-			];
-		}
-		return [
-			0,
-			0,
-			0
-		];
-	};
-	const p1 = getPos(h1);
-	const p2 = getPos(h2);
-	const dx = p2[0] - p1[0];
-	const dy = p2[1] - p1[1];
-	const dz = p2[2] - p1[2];
+	const [x, y, z] = point1;
+	let result;
+	if (to.type === "solid") result = bk.pointToSolidDistance(x, y, z, to.id);
+	else if (to.type === "face") result = bk.pointToFaceDistance(x, y, z, to.id);
+	else if (to.type === "edge") result = bk.pointToEdgeDistance(x, y, z, to.id);
+	else throw new UnsupportedKernelOperationError(`brepkit: no distance from a vertex to a ${to.type}`);
 	return {
-		value: Math.sqrt(dx * dx + dy * dy + dz * dz),
-		point1: p1,
-		point2: p2
+		value: wasmIndex(result, 0),
+		point1,
+		point2: vec3At(result, 1)
 	};
 }
 function surfaceCurvature$1(bk, face, u, v) {
@@ -9937,6 +10636,8 @@ function trySmoothPipeShell(bk, faceId, spine) {
 	}
 }
 function sweepPipeShell(bk, profile, spine, options) {
+	if (options?.["auxiliary"] !== void 0) throw new UnsupportedKernelOperationError("brepkit: sweepPipeShell has no auxiliary spine (twist or guided sweep)");
+	if (options?.["law"] !== void 0) throw new UnsupportedKernelOperationError("brepkit: sweepPipeShell has no scaling law");
 	const profileHandle = profile;
 	const faceId = profileHandle.type === "wire" ? bk.makeFaceFromWire(profileHandle.id) : unwrap$1(profile, "face");
 	const shellMode = !!(options && options["shellMode"]);