brepjs 20.13.4 → 20.13.6

package/dist/{shapeTypes-CSWkqhe9.js → shapeTypes-w2wyXEis.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-CGsnjMOe.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-CGkZIHyM.js";
 import { i as wasmIndex, r as vec3At } from "./bug-ClMTAJhe.js";
 // src/kernel/quality.ts
 /**
@@ -5401,14 +5401,13 @@ 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.
+* A NURBS edge that happens to be a circle reports CIRCLE too but runs over
+* its knots, so it gets no frame; only an analytic edge has no NURBS data.
 */
 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;
+	if (bk.getEdgeNurbsData(edgeId) !== null) return void 0;
 	const at = (t) => {
 		const p = bk.evaluateEdgeCurve(edgeId, t);
 		return [
@@ -5452,10 +5451,11 @@ function edgeEnds(bk, edgeId) {
 	]];
 }
 /**
-* 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.
+* The curve parameters an edge spans. brepkit before 4.5.10 reports a circle or
+* ellipse edge's domain as the whole [0, 2π] even for an arc, so an arc's span
+* is read off the curve's frame on every kernel: it 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`).
 */
 function edgeParamRange(bk, edgeId) {
 	const params = bk.getEdgeCurveParameters(edgeId);
@@ -5717,6 +5717,35 @@ function nextSyntheticId() {
 }
 /** JS-side storage for compound children (wires, faces, edges). */
 var syntheticCompounds = /* @__PURE__ */ new Map();
+/**
+* Each solid's piece ids, per kernel. getSolidPieces builds new solids and
+* shells for a solid in several pieces on every call, and the arena frees
+* nothing one handle at a time, so a solid is split once and its pieces keep
+* one identity until the solid changes in place or the arena rolls back.
+*/
+var solidPiecesByKernel = /* @__PURE__ */ new WeakMap();
+/** A solid's piece ids, from `split` the first time they are asked for. */
+function cachedSolidPieces(bk, solidId, split) {
+	let known = solidPiecesByKernel.get(bk);
+	if (!known) {
+		known = /* @__PURE__ */ new Map();
+		solidPiecesByKernel.set(bk, known);
+	}
+	const cached = known.get(solidId);
+	if (cached) return cached;
+	const pieces = split();
+	known.set(solidId, pieces);
+	for (const piece of pieces) if (!known.has(piece)) known.set(piece, [piece]);
+	return pieces;
+}
+/**
+* Forget one solid's pieces after the kernel changes it in place, or every
+* solid's after the arena rolls back and its ids can name new entities.
+*/
+function forgetSolidPieces(bk, solidId) {
+	if (solidId === void 0) solidPiecesByKernel.delete(bk);
+	else solidPiecesByKernel.get(bk)?.delete(solidId);
+}
 var _warned = /* @__PURE__ */ new Set();
 /** Emit a console.warn once per key per session. */
 function warnOnce(key, message) {
@@ -5764,17 +5793,35 @@ function resolveUniformAngle(faces, angleDeg) {
 	return uniform;
 }
 // src/kernel/brepkit/topologyOps.ts
+/**
+* One solid per separate piece of material in a solid: a boolean can leave
+* several pieces in one kernel solid, all in one shell. A solid in one piece
+* keeps its own handle, since the kernel answers a solid whose cavity shares
+* its shell with a rebuilt one.
+*/
+function solidPieces(bk, solid) {
+	if (typeof bk.getSolidPieces !== "function") return [solid];
+	const id = unwrap$1(solid, "solid");
+	const pieces = cachedSolidPieces(bk, id, () => {
+		const found = toArray(bk.getSolidPieces(id));
+		return found.length > 1 ? found : [id];
+	});
+	return pieces.length > 1 ? pieces.map(solidHandle) : [solid];
+}
 function iterCompound(bk, h, type) {
 	const children = syntheticCompounds.get(h);
-	if (children) return children.flatMap((child) => child.type === type ? [child] : iterShapes$1(bk, child, type));
-	if (type === "solid") return toArray(bk.getCompoundSolids(h)).map(solidHandle);
+	if (children) return children.flatMap((child) => {
+		if (child.type === "solid" && type === "solid") return solidPieces(bk, child);
+		return child.type === type ? [child] : iterShapes$1(bk, child, type);
+	});
+	if (type === "solid") return toArray(bk.getCompoundSolids(h)).flatMap((id) => solidPieces(bk, solidHandle(id)));
 	if (type === "face" || type === "edge" || type === "vertex" || type === "wire") return toArray(bk.getCompoundSolids(h)).map(solidHandle).flatMap((s) => iterShapes$1(bk, s, type));
 	return [];
 }
 function iterSolid(bk, shape, h, type) {
 	switch (type) {
-		case "solid": return [shape];
-		case "shell": return toArray(bk.getSolidShells(h)).map(shellHandle);
+		case "solid": return solidPieces(bk, shape);
+		case "shell": return solidPieces(bk, shape).flatMap((piece) => toArray(bk.getSolidShells(unwrap$1(piece, "solid"))).map(shellHandle));
 		case "face": return toArray(bk.getSolidFaces(h)).map(faceHandle);
 		case "edge": return toArray(bk.getSolidEdges(h)).map(edgeHandle);
 		case "vertex": return toArray(bk.getSolidVertices(h)).map(vertexHandle);
@@ -5910,12 +5957,23 @@ function faceIdsForSew(bk, shape) {
 function sew(bk, shapes, tolerance) {
 	const faceIds = shapes.flatMap((s) => faceIdsForSew(bk, s));
 	const tol = tolerance ?? 1e-7;
+	let solidId;
 	try {
-		return shellHandle(bk.weldShellsAndFaces(faceIds, tol));
+		solidId = bk.weldShellsAndFaces(faceIds, tol);
 	} catch (e) {
 		console.warn("brepkit: weldShellsAndFaces failed, falling back to sewFaces:", e);
+		solidId = bk.sewFaces(faceIds, tol);
 	}
-	return shellHandle(bk.sewFaces(faceIds, tol));
+	return sewnShell(bk, solidId);
+}
+/**
+* Both sewing bindings wrap the one shell they sew in a solid and return the
+* solid's handle; the shell has its own, which shell queries need.
+*/
+function sewnShell(bk, solidId) {
+	const [shellId] = toArray(bk.getSolidShells(solidId));
+	if (shellId === void 0) throw new Error("brepkit: sewing returned a solid with no shell");
+	return shellHandle(shellId);
 }
 /** Co-located factory: returns the topology-iteration slice of {@link KernelAdapter} bound to `bk`. */
 function makeTopologyOps$1(bk) {
@@ -6174,33 +6232,76 @@ function recognizeFeatures(bk, shape, tolerance) {
 	const solidId = unwrapSolidOrThrow(shape, "recognizeFeatures");
 	return bk.recognizeFeatures(solidId, tolerance);
 }
-function projectEdges(bk, shape, cameraOrigin, cameraDirection, cameraXAxis) {
-	const solidId = unwrap$1(shape);
-	const [ox, oy, oz] = cameraOrigin;
-	const [dx, dy, dz] = cameraDirection;
-	const [xx, xy, xz] = cameraXAxis ?? [
-		1,
-		0,
-		0
+/** The solids whose edges a projection draws: a solid itself, or every solid of a compound. */
+function projectedSolidIds(bk, shape) {
+	const h = shape;
+	if (h.type === "solid") return [h.id];
+	const ids = h.type === "compound" ? iterShapes$1(bk, shape, "solid").map((s) => unwrap$1(s)) : [];
+	if (ids.length === 0) throw new Error(`brepkit: projectEdges needs a solid or a compound of solids, got ${h.type}`);
+	return ids;
+}
+/**
+* brepkit returns polyline approximations of the projection, so tie the
+* tessellation deflection to model scale (1/1000 of the bbox diagonal) to
+* stay resolution-independent across part sizes.
+*/
+function projectionDeflection(bk, solidIds) {
+	const min = [
+		Infinity,
+		Infinity,
+		Infinity
+	];
+	const max = [
+		-Infinity,
+		-Infinity,
+		-Infinity
 	];
-	let deflection = .1;
 	try {
-		const bb = bk.boundingBox(solidId);
-		const [minX, minY, minZ] = vec3At(bb, 0);
-		const [maxX, maxY, maxZ] = vec3At(bb, 3);
-		const diag = dist3(minX, minY, minZ, maxX, maxY, maxZ);
-		if (diag > 0) deflection = Math.max(diag * .001, 1e-6);
-	} catch {}
-	const json = bk.projectEdges(solidId, ox, oy, oz, dx, dy, dz, xx, xy, xz, true, deflection);
-	let parsed;
+		for (const id of solidIds) {
+			const bb = bk.boundingBox(id);
+			for (let k = 0; k < 3; k++) {
+				min[k] = Math.min(wasmIndex(min, k), wasmIndex(bb, k));
+				max[k] = Math.max(wasmIndex(max, k), wasmIndex(bb, k + 3));
+			}
+		}
+	} catch {
+		return .1;
+	}
+	const diag = dist3(...min, ...max);
+	return diag > 0 ? Math.max(diag * .001, 1e-6) : .1;
+}
+function parseProjection(json) {
 	try {
-		parsed = JSON.parse(json);
+		return JSON.parse(json);
 	} catch {
-		parsed = {
+		return {
 			visible: [],
 			hidden: []
 		};
 	}
+}
+/** Each solid's edges, hidden wherever any of the solids lies in front of them. */
+function projectSolids(bk, solidIds, view) {
+	const deflection = projectionDeflection(bk, solidIds);
+	const [only, ...others] = solidIds;
+	if (only !== void 0 && others.length === 0) return parseProjection(bk.projectEdges(only, ...view, true, deflection));
+	if (typeof bk.projectSolidsEdges === "function") return parseProjection(bk.projectSolidsEdges(solidIds, ...view, true, deflection));
+	const parts = solidIds.map((id) => parseProjection(bk.projectEdges(id, ...view, true, deflection)));
+	return {
+		visible: parts.flatMap((p) => p.visible),
+		hidden: parts.flatMap((p) => p.hidden)
+	};
+}
+function projectEdges(bk, shape, cameraOrigin, cameraDirection, cameraXAxis) {
+	const parsed = projectSolids(bk, projectedSolidIds(bk, shape), [
+		...cameraOrigin,
+		...cameraDirection,
+		...cameraXAxis ?? [
+			1,
+			0,
+			0
+		]
+	]);
 	const polylinesToCompound = (polylines) => {
 		const edges = [];
 		for (const poly of polylines) for (let i = 0; i + 3 < poly.length; i += 2) {
@@ -6592,6 +6693,7 @@ function isValidStrict(bk, shape) {
 function healSolid(bk, shape) {
 	const h = shape;
 	if (h.type !== "solid") throw new Error(`brepkit: healSolid requires a solid, got ${h.type}. Consider using makeCompound() to combine shapes first.`);
+	forgetSolidPieces(bk, h.id);
 	try {
 		const remaining = bk.repairSolid(unwrap$1(shape));
 		if (remaining > 0) console.warn(`brepkit: repairSolid left ${remaining} error(s) on solid.`);
@@ -6614,19 +6716,25 @@ function healWire(_bk, wire, _face) {
 }
 function mergeCoincidentVertices(bk, shape, tolerance) {
 	const solidId = unwrapSolidOrThrow(shape, "mergeCoincidentVertices");
+	forgetSolidPieces(bk, solidId);
 	return bk.mergeCoincidentVertices(solidId, tolerance);
 }
 function removeDegenerateEdges(bk, shape, tolerance) {
 	const solidId = unwrapSolidOrThrow(shape, "removeDegenerateEdges");
+	forgetSolidPieces(bk, solidId);
 	return bk.removeDegenerateEdges(solidId, tolerance);
 }
 function fixFaceOrientations(bk, shape) {
 	const solidId = unwrapSolidOrThrow(shape, "fixFaceOrientations");
+	forgetSolidPieces(bk, solidId);
 	return bk.fixFaceOrientations(solidId);
 }
 function fixShape(bk, shape) {
 	const h = shape;
-	if (h.type === "solid") bk.healSolid(h.id);
+	if (h.type === "solid") {
+		forgetSolidPieces(bk, h.id);
+		bk.healSolid(h.id);
+	}
 	return shape;
 }
 function fixSelfIntersection(_bk, wire) {
@@ -6973,7 +7081,7 @@ function makeWire(bk, edges) {
 		if (h.type === "wire") for (const childEdgeId of toArray(bk.getWireEdges(h.id))) edgeIds.push(childEdgeId);
 		else edgeIds.push(unwrap$1(e, "edge"));
 	}
-	return wireHandle(bk.makeWire(edgeIds, true));
+	return wireHandle(bk.makeWire(chainEdges$1(bk, edgeIds), true));
 }
 function makeFace(bk, wire, planar) {
 	const h = wire;
@@ -7170,21 +7278,85 @@ function makeBezierEdge(bk, points) {
 function makeTangentArc(bk, startPoint, startTangent, endPoint) {
 	return edgeHandle(bk.makeTangentArc3d(startPoint[0], startPoint[1], startPoint[2], startTangent[0], startTangent[1], startTangent[2], endPoint[0], endPoint[1], endPoint[2]));
 }
-function makeHelixWire(bk, pitch, height, radius, center, _direction, leftHanded) {
+/** The X axis occt's `gp_Ax3(P, V)` picks when given only a direction, so a helix starts where occt-wasm's does. */
+function occtDefaultXDir(a, b, c) {
+	const [aa, ba, ca] = [
+		Math.abs(a),
+		Math.abs(b),
+		Math.abs(c)
+	];
+	let x;
+	if (ba <= aa && ba <= ca) x = aa > ca ? [
+		-c,
+		0,
+		a
+	] : [
+		c,
+		0,
+		-a
+	];
+	else if (aa <= ba && aa <= ca) x = ba > ca ? [
+		0,
+		-c,
+		b
+	] : [
+		0,
+		c,
+		-b
+	];
+	else x = aa > ba ? [
+		-b,
+		a,
+		0
+	] : [
+		b,
+		-a,
+		0
+	];
+	const len = Math.hypot(x[0], x[1], x[2]);
+	return [
+		x[0] / len,
+		x[1] / len,
+		x[2] / len
+	];
+}
+function makeHelixWire(bk, pitch, height, radius, center, direction, leftHanded) {
 	const turns = height / pitch;
 	const nSamples = Math.max(4, Math.ceil(turns * 16));
-	const cx = center?.[0] ?? 0;
-	const cy = center?.[1] ?? 0;
-	const cz = center?.[2] ?? 0;
+	const [cx, cy, cz] = center ?? [
+		0,
+		0,
+		0
+	];
+	const [dx, dy, dz] = direction ?? [
+		0,
+		0,
+		1
+	];
+	const dLen = Math.hypot(dx, dy, dz);
+	const z = [
+		dx / dLen,
+		dy / dLen,
+		dz / dLen
+	];
+	const x = occtDefaultXDir(z[0], z[1], z[2]);
+	const y = [
+		z[1] * x[2] - z[2] * x[1],
+		z[2] * x[0] - z[0] * x[2],
+		z[0] * x[1] - z[1] * x[0]
+	];
 	const sign = leftHanded ? -1 : 1;
 	const points = [];
 	for (let i = 0; i <= nSamples; i++) {
 		const t = i / nSamples;
 		const angle = sign * 2 * Math.PI * turns * t;
+		const u = radius * Math.cos(angle);
+		const v = radius * Math.sin(angle);
+		const h = height * t;
 		points.push([
-			cx + radius * Math.cos(angle),
-			cy + radius * Math.sin(angle),
-			cz + height * t
+			cx + u * x[0] + v * y[0] + h * z[0],
+			cy + u * x[1] + v * y[1] + h * z[1],
+			cz + u * x[2] + v * y[2] + h * z[2]
 		]);
 	}
 	return makeWire(bk, [interpolatePoints(bk, points)]);
@@ -7197,10 +7369,110 @@ 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, chainCloses(bk, edgeIds)));
+	const chain = chainEdges$1(bk, edgeIds);
+	return wireHandle(bk.makeWire(chain, chainCloses(bk, chain)));
 }
 /** Matches the 1e-7 linear tolerance brepkit's makeWire welds vertices within. */
 var WIRE_CLOSE_TOLERANCE = 1e-7;
+/**
+* The edges in an order where each starts where the one before ends, any edge
+* running the other way rebuilt to run on. brepkit's makeWire takes each edge
+* as it runs and a face refuses a wire whose edges do not run end to end, so a
+* profile closed by its mirror image, whose edges leave from the first half's
+* start, needs that half turned round. Edges that make no single chain, or
+* that cannot be rebuilt, come back as given.
+*/
+function chainEdges$1(bk, edgeIds) {
+	const [first, ...left] = edgeIds;
+	if (first === void 0 || left.length === 0) return edgeIds;
+	const ends = new Map(left.map((id) => [id, edgeEnds(bk, id)]));
+	let [head, tail] = edgeEnds(bk, first);
+	const chain = [first];
+	while (left.length > 0) {
+		const after = takeLink(bk, left, ends, tail, "start");
+		if (after) {
+			chain.push(after.id);
+			tail = after.free;
+			continue;
+		}
+		const before = takeLink(bk, left, ends, head, "end");
+		if (!before) return edgeIds;
+		chain.unshift(before.id);
+		head = before.free;
+	}
+	return chain;
+}
+/**
+* Take from `left` the first edge with an end at `at`, to join the chain there
+* by its `side` end; an edge that meets `at` with its other end is rebuilt to
+* run the other way. Returns the joining edge and the end it leaves free.
+*/
+function takeLink(bk, left, ends, at, side) {
+	const touches = (p) => dist3(...p, ...at) < WIRE_CLOSE_TOLERANCE;
+	for (const [i, id] of left.entries()) {
+		const edge = ends.get(id);
+		if (!edge) continue;
+		const [start, end] = edge;
+		const [joins, free] = side === "start" ? [start, end] : [end, start];
+		if (touches(joins)) {
+			left.splice(i, 1);
+			return {
+				id,
+				free
+			};
+		}
+		if (touches(free)) {
+			const turned = reversedEdge(bk, id, start, end);
+			if (turned === void 0) return void 0;
+			left.splice(i, 1);
+			return {
+				id: turned,
+				free: joins
+			};
+		}
+	}
+}
+/**
+* A new edge on the same curve, running from `end` to `start`, or `undefined`
+* for a curve the adapter cannot rebuild.
+*/
+function reversedEdge(bk, id, start, end) {
+	const nurbs = bk.getEdgeNurbsData(id);
+	if (nurbs !== null) return reversedNurbsEdge(bk, nurbs, start, end);
+	const curveType = bk.getEdgeCurveType(id);
+	if (curveType === "LINE") return bk.makeLineEdge(...end, ...start);
+	const frame = conicFrame(bk, id);
+	if (!frame) return void 0;
+	const { center, u, v } = frame;
+	const n = [
+		v[1] * u[2] - v[2] * u[1],
+		v[2] * u[0] - v[0] * u[2],
+		v[0] * u[1] - v[1] * u[0]
+	];
+	const nLen = Math.hypot(...n);
+	const axis = [
+		n[0] / nLen,
+		n[1] / nLen,
+		n[2] / nLen
+	];
+	if (curveType === "CIRCLE") return bk.makeCircleArc3d(...end, ...start, ...center, ...axis);
+	const major = Math.hypot(...u);
+	const ref = [
+		u[0] / major,
+		u[1] / major,
+		u[2] / major
+	];
+	return bk.makeEllipseArc3d(...end, ...start, ...center, ...axis, ...ref, major, Math.hypot(...v));
+}
+function reversedNurbsEdge(bk, json, start, end) {
+	const data = JSON.parse(json);
+	const lo = wasmIndex(data.knots, 0);
+	const hi = wasmIndex(data.knots, data.knots.length - 1);
+	const knots = data.knots.map((k) => lo + hi - k).reverse();
+	const poles = [];
+	for (let i = data.controlPoints.length - 3; i >= 0; i -= 3) poles.push(...data.controlPoints.slice(i, i + 3));
+	return bk.makeNurbsEdge(...end, ...start, data.degree, knots, poles, [...data.weights].reverse());
+}
 function chainCloses(bk, edgeIds) {
 	const first = bk.getEdgeVertices(wasmIndex(edgeIds, 0));
 	const last = bk.getEdgeVertices(wasmIndex(edgeIds, edgeIds.length - 1));
@@ -7239,15 +7511,7 @@ function makeBoxFromCorners(bk, p1, p2) {
 	return box;
 }
 function solidFromShell(bk, shell) {
-	const h = shell;
-	if (h.type === "solid") return shell;
-	if (h.type === "shell") {
-		try {
-			bk.getSolidFaces(h.id);
-			return solidHandle(h.id);
-		} catch {}
-		return solidHandle(bk.solidFromShell(h.id));
-	}
+	if (shell.type === "solid") return shell;
 	return solidHandle(bk.solidFromShell(unwrap$1(shell, "shell")));
 }
 function makeNonPlanarFace(bk, wire) {
@@ -7734,45 +7998,80 @@ 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 radii = /* @__PURE__ */ new Set();
-	for (const edge of edges) {
+	const laws = edges.map((edge, i) => {
 		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 {
+			edge: wasmIndex(edgeIds, i),
+			start,
+			end
+		};
+	});
+	const [first] = laws;
+	if (!first) throw new Error("brepkit: fillet needs at least one edge");
+	if (laws.every((l) => l.start === first.start && l.end === first.start)) return solidHandle(bk.fillet(solidId, edgeIds, first.start));
+	return filletAlongLaws(bk, solidId, laws);
+}
+var lawProbes = /* @__PURE__ */ new WeakMap();
+/**
+* brepkit-wasm before 4.6.9 cuts a flat bevel along a radius law, and the peer
+* range still admits those builds. Rounding a 10 mm cube edge from 1 to 2 tells
+* them apart: a round removes 5.0 mm3 and a bevel 11.7. The probe runs once per
+* kernel, inside a checkpoint it restores and discards, so it leaves nothing behind.
+*/
+function roundsAlongLaws(bk) {
+	const known = lawProbes.get(bk);
+	if (known !== void 0) return known;
+	let rounds;
+	const mark = bk.checkpoint();
+	try {
+		const cube = bk.makeBox(10, 10, 10);
+		const edge = wasmIndex(bk.getSolidEdges(cube), 0);
+		const spec = JSON.stringify([{
+			edge,
+			law: "linear",
+			start: 1,
+			end: 2
+		}]);
+		rounds = 1e3 - bk.volume(bk.filletVariable(cube, spec), DEFAULT_DEFLECTION) < 8;
+	} catch {
+		rounds = false;
+	} finally {
+		bk.restore(mark);
+		bk.discardCheckpoint(mark);
 	}
-	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));
+	lawProbes.set(bk, rounds);
+	return rounds;
 }
 /**
-* 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.
+* One filletVariable call for every edge, each along its own constant or
+* linear law, running from the edge's start vertex to its end.
 */
-function perEdgeUnsupported(what) {
-	return new UnsupportedKernelOperationError(`brepkit: different ${what} on different edges in one call is not supported`);
+function filletAlongLaws(bk, solidId, laws) {
+	if (!roundsAlongLaws(bk)) throw new UnsupportedKernelOperationError("brepkit: a fillet along a radius law needs brepkit-wasm 4.6.9 or newer");
+	const spec = laws.map(({ edge, start, end }) => ({
+		edge,
+		law: start === end ? "constant" : "linear",
+		start,
+		end
+	}));
+	return solidHandle(bk.filletVariable(solidId, JSON.stringify(spec)));
 }
 /**
-* 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.
+* brepkit takes one distance for every edge of a chamfer call, and a second
+* call on the first one's result cannot name the input's other edges: it fails
+* on them ("no manifold edges to chamfer").
 */
-function varyingFilletUnsupported() {
-	return new UnsupportedKernelOperationError("brepkit: a fillet radius that varies along an edge is not supported");
+function perEdgeUnsupported(what) {
+	return new UnsupportedKernelOperationError(`brepkit: different ${what} on different edges in one call is not supported`);
 }
 /** 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}).
+* from variableFillet, or `{ edgeId, startRadius, endRadius }`. Like occt-wasm, a
+* profile runs linearly from its first radius to its last, so one of more than two
+* points is unsupported rather than flattened to a line.
 */
 function filletVariable$1(bk, shape, spec) {
 	const solidId = unwrapSolidOrThrow(shape, "filletVariable");
@@ -7788,9 +8087,15 @@ function filletVariable$1(bk, shape, spec) {
 		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));
+	if (radii.length > 2) throw new UnsupportedKernelOperationError("brepkit: filletVariable supports only a linear (<=2-point) radius profile");
+	const start = wasmIndex(radii, 0);
+	const end = wasmIndex(radii, radii.length - 1);
+	if (start === end) return solidHandle(bk.fillet(solidId, [edgeId], start));
+	return filletAlongLaws(bk, solidId, [{
+		edge: edgeId,
+		start,
+		end
+	}]);
 }
 /**
 * A symmetric chamfer for two equal distances, brepkit's two-distance chamfer
@@ -7941,10 +8246,13 @@ function offsetWire2D(bk, wire, offsetVal, joinType) {
 	return wireHandle(bk.makePolygonWire(coords3d));
 }
 function simplify$1(bk, shape) {
-	if (shape.type === "solid") try {
-		bk.healSolid(unwrap$1(shape));
-	} catch (e) {
-		console.warn("brepkit: healing failed in simplify:", e);
+	if (shape.type === "solid") {
+		forgetSolidPieces(bk, unwrap$1(shape));
+		try {
+			bk.healSolid(unwrap$1(shape));
+		} catch (e) {
+			console.warn("brepkit: healing failed in simplify:", e);
+		}
 	}
 	return shape;
 }
@@ -10190,7 +10498,7 @@ function area$1(bk, shape) {
 	const h = shape;
 	if (h.type === "face") return bk.faceArea(unwrap$1(shape), DEFAULT_DEFLECTION);
 	if (h.type === "solid") return bk.surfaceArea(unwrap$1(shape), DEFAULT_DEFLECTION);
-	if (h.type === "compound") {
+	if (h.type === "compound" || h.type === "shell") {
 		const faces = iterShapes$1(bk, shape, "face");
 		let total = 0;
 		for (const face of faces) total += bk.faceArea(unwrap$1(face), DEFAULT_DEFLECTION);
@@ -10764,12 +11072,65 @@ function trySmoothPipeShell(bk, faceId, spine) {
 		return;
 	}
 }
+/**
+* The curve a guided sweep runs along: one line, or one edge brepkit stores
+* as NURBS. brepkit gives no NURBS for a circle or an ellipse, and reading one
+* by its end points would sweep along the chord.
+*/
+function guideCurve(bk, shape, role) {
+	const edges = shape.type === "edge" ? [shape] : iterShapes$1(bk, shape, "edge");
+	const [edge] = edges;
+	if (edges.length !== 1 || !edge) throw new UnsupportedKernelOperationError(`brepkit: a guided sweep takes a single-edge ${role}, got ${edges.length} edges`);
+	const edgeId = unwrap$1(edge, "edge");
+	const curveType = bk.getEdgeCurveType(edgeId);
+	if (curveType !== "LINE" && bk.getEdgeNurbsData(edgeId) === null) throw new UnsupportedKernelOperationError(`brepkit: a guided sweep takes a line or NURBS ${role}, got ${curveType}`);
+	const data = extractNurbsFromEdge(bk, edge);
+	if (!data) throw new Error(`brepkit: guided sweep could not read the ${role}`);
+	return data;
+}
+/**
+* brepkit places a guided sweep's sections at twice the spine's control points
+* (at least 4) and rules flat between them, so a straight spine twists through
+* 4 segments whatever the guide does: a square turned 90° comes out 2.5% light.
+* Splitting a straight spine into twice as many collinear spans as the guide
+* has control points samples the twist more finely than the guide is drawn.
+*/
+function densifyStraightSpine(path, spans) {
+	if (path.degree !== 1 || path.controlPoints.length !== 6 || spans <= 1) return path;
+	const start = vec3At(path.controlPoints, 0);
+	const end = vec3At(path.controlPoints, 3);
+	const controlPoints = [];
+	const interior = [];
+	for (let i = 0; i <= spans; i++) {
+		const t = i / spans;
+		controlPoints.push(...start.map((s, k) => s + (wasmIndex(end, k) - s) * t));
+		if (i > 0 && i < spans) interior.push(t);
+	}
+	return {
+		degree: 1,
+		knots: [
+			0,
+			0,
+			...interior,
+			1,
+			1
+		],
+		controlPoints,
+		weights: new Array(spans + 1).fill(1)
+	};
+}
+function guidedPipeShell(bk, faceId, spine, auxiliary) {
+	const aux = guideCurve(bk, auxiliary, "auxiliary spine");
+	const path = densifyStraightSpine(guideCurve(bk, spine, "spine"), 2 * (aux.controlPoints.length / 3));
+	return solidHandle(bk.guidedSweep(faceId, path.degree, path.knots, path.controlPoints, path.weights, aux.degree, aux.knots, aux.controlPoints, aux.weights));
+}
 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"]);
+	const auxiliary = options?.["auxiliary"];
+	if (auxiliary !== void 0) return wrapPipeShellResult(guidedPipeShell(bk, faceId, spine, auxiliary), profile, shellMode);
 	const transitionMode = options?.["transitionMode"];
 	const contactMode = transitionMode ? mapStringTransitionMode(transitionMode) : void 0;
 	if (contactMode) {
@@ -10867,11 +11228,18 @@ function makeSweepOps$1(bk) {
 function makeCoreOps$1(bk) {
 	return {
 		dispose: () => {},
-		executeBatch: (json) => bk.executeBatch(json),
+		executeBatch: (json) => {
+			try {
+				return bk.executeBatch(json);
+			} finally {
+				forgetSolidPieces(bk);
+			}
+		},
 		checkpoint: () => bk.checkpoint(),
 		checkpointCount: () => bk.checkpointCount(),
 		restoreCheckpoint: (cp) => {
 			bk.restore(cp);
+			forgetSolidPieces(bk);
 		},
 		discardCheckpoint: (cp) => {
 			bk.discardCheckpoint(cp);
@@ -17235,7 +17603,10 @@ function createBorrowedHandle(ocShape) {
 * frees *every* slot allocated after the checkpoint, so a live shape handle in
 * the return value would dangle. Use for data-returning batch analysis over many
 * bodies; never to wrap a shape builder. Inputs allocated before the call are
-* untouched (restore only frees from the mark forward).
+* untouched (restore only frees from the mark forward), but `fn` must not query
+* their cached topology (`getFaces`, `getSolids`, adjacency): the cache keeps the
+* sub-shape handles it allocates, and the restore would leave it holding freed
+* slots.
 *
 * No-op wrapper on kernels without arena checkpoints (occt/manifold): `fn` runs
 * directly and those kernels' own disposal applies.