brepjs 20.13.3 → 20.13.5

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

@@ -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;
@@ -7197,10 +7305,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 +7447,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) {
@@ -7941,10 +8141,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 +10393,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);
@@ -10275,9 +10478,10 @@ function boundingBox$1(bk, shape) {
 	};
 }
 /**
-* 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.
+* Points whose bounding box is the shape's: a solid's own box corners, a
+* face's or shell's face box points (see `faceBoxPoints`), 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) {
@@ -10287,13 +10491,141 @@ function boxPoints(bk, h) {
 		}
 		case "vertex": return [vec3At(bk.getVertexPosition(h.id))];
 		case "edge": return edgeBoxPoints(bk, h.id);
+		case "face": return faceBoxPoints(bk, h);
+		case "shell": return iterShapes$1(bk, h, "face").flatMap((f) => faceBoxPoints(bk, f));
 		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));
+		default: return boundaryBoxPoints(bk, h);
+	}
+}
+function boundaryBoxPoints(bk, h) {
+	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));
+}
+/**
+* A face's extreme along an axis lies on its boundary or at a point inside it
+* where that coordinate peaks on the surface. Planes, cylinders, and cones have
+* no such interior peak (a straight line through any inner point runs to the
+* boundary), so their edges bound them. A sphere or torus adds the surface's
+* peak points that lie on the face, which bounds it exactly; any other surface
+* adds the vertices of its tessellation, which bound it to within the
+* deflection.
+*/
+function faceBoxPoints(bk, face) {
+	const points = boundaryBoxPoints(bk, face);
+	const surfaceType = bk.getSurfaceType(face.id);
+	if (surfaceType === "plane" || surfaceType === "cylinder" || surfaceType === "cone") return points;
+	const peaks = surfacePeaks(bk, face.id);
+	if (peaks) {
+		const tolerance = ON_FACE_TOLERANCE * Math.max(1, peaks.size);
+		const onFace = (p) => wasmIndex(bk.pointToFaceDistance(p[0], p[1], p[2], face.id), 0) <= tolerance;
+		return [...points, ...peaks.points.filter(onFace)];
+	}
+	const { positions } = bk.tessellateFace(face.id, MESH_BOX_DEFLECTION * (diagonal(points) || 1));
+	const vertices = [];
+	for (let i = 0; i + 2 < positions.length; i += 3) vertices.push(vec3At(positions, i));
+	return [...points, ...vertices];
+}
+var ON_FACE_TOLERANCE = 1e-7;
+var MESH_BOX_DEFLECTION = .001;
+var TORUS_CIRCLE_SAMPLES = 64;
+var AXES = [
+	[
+		1,
+		0,
+		0
+	],
+	[
+		0,
+		1,
+		0
+	],
+	[
+		0,
+		0,
+		1
+	]
+];
+function diagonal(points) {
+	if (points.length === 0) return 0;
+	const span = [
+		0,
+		1,
+		2
+	].map((k) => {
+		const values = points.map((p) => wasmIndex(p, k));
+		return Math.max(...values) - Math.min(...values);
+	});
+	return Math.hypot(...span);
+}
+var add$1 = (a, b, s = 1) => [
+	a[0] + s * b[0],
+	a[1] + s * b[1],
+	a[2] + s * b[2]
+];
+var dot$1 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+/**
+* The points where a coordinate peaks on a sphere or torus surface, with the
+* surface's size for the on-face tolerance; undefined for any other surface or
+* a torus whose frame does not read back as orthonormal.
+*/
+function surfacePeaks(bk, faceId) {
+	let params;
+	try {
+		params = JSON.parse(bk.getAnalyticSurfaceParams(faceId));
+	} catch {
+		return;
+	}
+	const c = params.center;
+	if (c?.length !== 3) return void 0;
+	if (params.type === "sphere" && typeof params.radius === "number") {
+		const r = params.radius;
+		return {
+			points: AXES.flatMap((e) => [add$1(c, e, r), add$1(c, e, -r)]),
+			size: r
+		};
+	}
+	if (params.type === "torus" && typeof params.majorRadius === "number" && typeof params.minorRadius === "number") return torusPeaks(bk, faceId, c, params.majorRadius, params.minorRadius);
+}
+/**
+* brepkit's torus params carry no axis, so the frame is read off the surface,
+* which brepkit parametrizes as c + (R + r cos v)(cos u X + sin u Y) + r sin v Z.
+* Along a direction d with a component w across the axis, the coordinate peaks
+* at c ± (R w/|w| + r d). Along the axis it peaks on the whole circle at c ± r Z,
+* which is sampled.
+*/
+function torusPeaks(bk, faceId, c, majorR, minorR) {
+	const at = (u, v) => vec3At(bk.evaluateSurface(faceId, u, v));
+	const x = add$1(at(0, 0), c, -1).map((n) => n / (majorR + minorR));
+	const z = add$1(add$1(at(0, Math.PI / 2), c, -1), x, -majorR).map((n) => n / minorR);
+	const unit = (p) => Math.abs(Math.hypot(...p) - 1) < 1e-6;
+	if (!unit(x) || !unit(z) || Math.abs(dot$1(x, z)) > 1e-6) return void 0;
+	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 points = [];
+	for (const d of AXES) {
+		const across = add$1(d, z, -dot$1(d, z));
+		const len = Math.hypot(...across);
+		if (len > 1e-9) {
+			const peak = add$1(across.map((n) => n * majorR / len), d, minorR);
+			points.push(add$1(c, peak), add$1(c, peak, -1));
+			continue;
+		}
+		for (const side of [1, -1]) {
+			const rim = add$1(c, z, side * minorR);
+			for (let i = 0; i < TORUS_CIRCLE_SAMPLES; i++) {
+				const t = 2 * Math.PI * i / TORUS_CIRCLE_SAMPLES;
+				points.push(add$1(add$1(rim, x, majorR * Math.cos(t)), y, majorR * Math.sin(t)));
+			}
 		}
 	}
+	return {
+		points,
+		size: majorR + minorR
+	};
 }
 /**
 * Minimum distance between two shapes. brepkit-wasm measures from a point to a
@@ -10738,11 +11070,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);
@@ -17106,7 +17445,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.

package/dist/sketching.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_blueprintSketcher = require("./blueprintSketcher-Bxkp-vjK.cjs");
-const require_drawFns = require("./drawFns-Bqs4HPzo.cjs");
-const require_textBlueprints = require("./textBlueprints-CPJ6sBZZ.cjs");
+const require_blueprintSketcher = require("./blueprintSketcher-JoLn4vSB.cjs");
+const require_drawFns = require("./drawFns-BrRyiHKp.cjs");
+const require_textBlueprints = require("./textBlueprints-DSiQKpe8.cjs");
 // src/sketching.ts
 /**
 * brepjs/sketching — Sketcher, Drawing, and sketch-to-shape operations.

package/dist/sketching.js

@@ -1,6 +1,6 @@
-import { n as BaseSketcher2d, t as BlueprintSketcher } from "./blueprintSketcher-DG_2zJg7.js";
-import { A as sketchEllipse, C as DrawingPen, D as makeBaseBox, E as deserializeDrawing, F as sketchRectangle, I as sketchRoundedRectangle, L as FaceSketcher, M as sketchHelix, N as sketchParametricFunction, O as polysideInnerRadius, P as sketchPolysides, R as Sketcher, S as drawText, T as Drawing, _ as drawPolysides, a as drawingIntersect, b as drawSingleCircle, c as rotateDrawing, d as drawFaceOutline, f as drawProjection, g as drawPointsInterpolation, h as drawParametricFunction, i as drawingFuse, j as sketchFaceOffset, k as sketchCircle, l as scaleDrawing, m as drawEllipse, n as drawingCut, o as drawingToSketchOnPlane, p as drawCircle, r as drawingFillet, s as mirrorDrawing, t as drawingChamfer, u as translateDrawing, v as drawRectangle, w as draw, x as drawSingleEllipse, y as drawRoundedRectangle } from "./drawFns-g9FrZ_P4.js";
-import { a as Sketches, c as compoundSketchFace, d as sketchExtrude, f as sketchFace, g as sketchWires, h as sketchSweep, l as compoundSketchLoft, m as sketchRevolve, o as Sketch, p as sketchLoft, s as compoundSketchExtrude, u as compoundSketchRevolve, y as CompoundSketch } from "./textBlueprints-B4w-_4_D.js";
+import { n as BaseSketcher2d, t as BlueprintSketcher } from "./blueprintSketcher-CeMrC8k-.js";
+import { A as sketchEllipse, C as DrawingPen, D as makeBaseBox, E as deserializeDrawing, F as sketchRectangle, I as sketchRoundedRectangle, L as FaceSketcher, M as sketchHelix, N as sketchParametricFunction, O as polysideInnerRadius, P as sketchPolysides, R as Sketcher, S as drawText, T as Drawing, _ as drawPolysides, a as drawingIntersect, b as drawSingleCircle, c as rotateDrawing, d as drawFaceOutline, f as drawProjection, g as drawPointsInterpolation, h as drawParametricFunction, i as drawingFuse, j as sketchFaceOffset, k as sketchCircle, l as scaleDrawing, m as drawEllipse, n as drawingCut, o as drawingToSketchOnPlane, p as drawCircle, r as drawingFillet, s as mirrorDrawing, t as drawingChamfer, u as translateDrawing, v as drawRectangle, w as draw, x as drawSingleEllipse, y as drawRoundedRectangle } from "./drawFns-RuUOUlSC.js";
+import { a as Sketches, c as compoundSketchFace, d as sketchExtrude, f as sketchFace, g as sketchWires, h as sketchSweep, l as compoundSketchLoft, m as sketchRevolve, o as Sketch, p as sketchLoft, s as compoundSketchExtrude, u as compoundSketchRevolve, y as CompoundSketch } from "./textBlueprints-CLwy1uWM.js";
 // src/sketching.ts
 /**
 * brepjs/sketching — Sketcher, Drawing, and sketch-to-shape operations.

package/dist/{solidBuilders-BVHK-era.cjs → solidBuilders-CETSjBW2.cjs}

@@ -1,8 +1,8 @@
-const require_shapeTypes = require("./shapeTypes-CIw6-GFy.cjs");
+const require_shapeTypes = require("./shapeTypes-BK53GmLC.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-BNDmjz7x.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns--p_-tywe.cjs");
 const require_constants = require("./constants-oee0S_x6.cjs");
-const require_faceFns = require("./faceFns-BeSpw0Dz.cjs");
+const require_faceFns = require("./faceFns-DfEUZlnf.cjs");
 // src/topology/metadata/originTrackingFns.ts
 /**
 * Face origin tracking — tag faces with integer origins and propagate

package/dist/{solidBuilders-IA8xNuxJ.js → solidBuilders-DMfqtfIG.js}

@@ -1,8 +1,8 @@
-import { C as isSolid, G as _usingCtx, S as isShell, d as createSolid, f as createVertex, h as disposeResultShape, n as castResultShape, q as getKernel, s as createCompound, x as isShape3D } from "./shapeTypes-hLHmANUz.js";
+import { C as isSolid, G as _usingCtx, S as isShell, d as createSolid, f as createVertex, h as disposeResultShape, n as castResultShape, q as getKernel, s as createCompound, x as isShape3D } from "./shapeTypes-Ckz9bpYW.js";
 import { E as ok, g as err, l as typeCastError, m as andThen } from "./errors-BTccWbtE.js";
-import { C as subShapeHashes, c as getFaces, l as getOrCreateCache, r as getCacheEntry } from "./topologyQueryFns-BYqsNs6q.js";
+import { C as subShapeHashes, c as getFaces, l as getOrCreateCache, r as getCacheEntry } from "./topologyQueryFns-SINsBrMe.js";
 import { n as HASH_CODE_MAX } from "./constants-iraOnb2p.js";
-import { _ as cast, y as downcast } from "./faceFns-BzHfvPea.js";
+import { _ as cast, y as downcast } from "./faceFns-Dz3eRgNR.js";
 // src/topology/metadata/originTrackingFns.ts
 /**
 * Face origin tracking — tag faces with integer origins and propagate