brepjs 18.118.19 → 18.118.21

package/dist/{shapeTypes-DXLJEolb.cjs → shapeTypes-BfOb9vzc.cjs}

@@ -1,6 +1,6 @@
-const require_occtWasmAdapter = require("./occtWasmAdapter-CWX5KCl8.cjs");
-const require_vec3 = require("./vec3-CFwOI0ZI.cjs");
-const require_errors = require("./errors-CXJtc4I7.cjs");
+const require_occtWasmAdapter = require("./occtWasmAdapter-CIxwUim8.cjs");
+const require_bug = require("./bug-O02CsAmt.cjs");
+const require_errors = require("./errors-CJU8CHng.cjs");
 //#region src/kernel/quality.ts
 /**
 * Extract-time deflection per level. `'standard'` matches brepjs's historical
@@ -711,7 +711,7 @@ function fuseAllNative(oc, shapes, options = {}) {
 function fuseAllPairwiseRange(oc, shapes, start, end, options) {
 	options.signal?.throwIfAborted();
 	const count = end - start;
-	if (count === 1) return require_vec3.wasmIndex(shapes, start);
+	if (count === 1) return require_bug.wasmIndex(shapes, start);
 	if (count === 2) return fuse$1(oc, shapes[start], shapes[start + 1], {
 		...options,
 		simplify: false
@@ -741,7 +741,7 @@ function fuseAllPairwise(oc, shapes, options = {}) {
 */
 function fuseAll$1(oc, shapes, options = {}) {
 	if (shapes.length === 0) throw new Error("fuseAll requires at least one shape");
-	if (shapes.length === 1) return require_vec3.wasmIndex(shapes, 0);
+	if (shapes.length === 1) return require_bug.wasmIndex(shapes, 0);
 	const { strategy = "native" } = options;
 	if (strategy === "pairwise") return fuseAllPairwise(oc, shapes, options);
 	return fuseAllNative(oc, shapes, options);
@@ -1337,7 +1337,7 @@ function makeEllipseArc$1(oc, center, normal, majorRadius, minorRadius, startAng
 function makeBezierEdge$1(oc, points) {
 	const arr = new oc.TColgp_Array1OfPnt_2(1, points.length);
 	for (let i = 0; i < points.length; i++) {
-		const p = require_vec3.wasmIndex(points, i);
+		const p = require_bug.wasmIndex(points, i);
 		const pnt = new oc.gp_Pnt_3(p[0], p[1], p[2]);
 		arr.SetValue_1(i + 1, pnt);
 		pnt.delete();
@@ -3957,7 +3957,7 @@ function makeFaceOnSurface$1(oc, surfaceOrFace, wire) {
 function bsplineSurface$1(oc, points, rows, cols) {
 	const arr = new oc.TColgp_Array2OfPnt_2(1, rows, 1, cols);
 	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
-		const pt = require_vec3.wasmIndex(points, r * cols + c);
+		const pt = require_bug.wasmIndex(points, r * cols + c);
 		const pnt = new oc.gp_Pnt_3(pt[0], pt[1], pt[2]);
 		arr.SetValue_1(r + 1, c + 1, pnt);
 		pnt.delete();
@@ -3979,10 +3979,10 @@ function triangulatedSurface$1(oc, points, rows, cols) {
 		const i10 = (r + 1) * cols + c;
 		const i01 = r * cols + (c + 1);
 		const i11 = (r + 1) * cols + (c + 1);
-		const p00 = require_vec3.wasmIndex(points, i00);
-		const p10 = require_vec3.wasmIndex(points, i10);
-		const p01 = require_vec3.wasmIndex(points, i01);
-		const p11 = require_vec3.wasmIndex(points, i11);
+		const p00 = require_bug.wasmIndex(points, i00);
+		const p10 = require_bug.wasmIndex(points, i10);
+		const p01 = require_bug.wasmIndex(points, i01);
+		const p11 = require_bug.wasmIndex(points, i11);
 		const face1 = makeTriFace(oc, p00, p10, p01);
 		sewing.Add(face1);
 		const face2 = makeTriFace(oc, p10, p11, p01);
@@ -4626,7 +4626,7 @@ function createAffinityGTrsf2d$1(ox, oy, dx, dy, ratio) {
 		0,
 		1
 	];
-	return _gtrsf$1(m, ox - require_vec3.wasmIndex(m, 0) * ox - require_vec3.wasmIndex(m, 1) * oy, oy - require_vec3.wasmIndex(m, 3) * ox - require_vec3.wasmIndex(m, 4) * oy);
+	return _gtrsf$1(m, ox - require_bug.wasmIndex(m, 0) * ox - require_bug.wasmIndex(m, 1) * oy, oy - require_bug.wasmIndex(m, 3) * ox - require_bug.wasmIndex(m, 4) * oy);
 }
 function createTranslationGTrsf2d$1(dx, dy) {
 	return _gtrsf$1([
@@ -4657,7 +4657,7 @@ function createMirrorGTrsf2d$1(cx, cy, mode, ox, oy, dx, dy) {
 			1
 		];
 		const apx = ox ?? cx, apy = oy ?? cy;
-		return _gtrsf$1(m, apx - require_vec3.wasmIndex(m, 0) * apx - require_vec3.wasmIndex(m, 1) * apy, apy - require_vec3.wasmIndex(m, 3) * apx - require_vec3.wasmIndex(m, 4) * apy);
+		return _gtrsf$1(m, apx - require_bug.wasmIndex(m, 0) * apx - require_bug.wasmIndex(m, 1) * apy, apy - require_bug.wasmIndex(m, 3) * apx - require_bug.wasmIndex(m, 4) * apy);
 	}
 	return _gtrsf$1([
 		-1,
@@ -4704,8 +4704,8 @@ function setGTrsf2dTranslationPart$1(gtrsf, dx, dy) {
 }
 function multiplyGTrsf2d$1(base, other) {
 	const a = base.m, b = other.m;
-	const ai = (i) => require_vec3.wasmIndex(a, i);
-	const bi = (i) => require_vec3.wasmIndex(b, i);
+	const ai = (i) => require_bug.wasmIndex(a, i);
+	const bi = (i) => require_bug.wasmIndex(b, i);
 	base.m = [
 		ai(0) * bi(0) + ai(1) * bi(3) + ai(2) * bi(6),
 		ai(0) * bi(1) + ai(1) * bi(4) + ai(2) * bi(7),
@@ -4736,7 +4736,7 @@ function transformCurve2dGeneral$1(curve, gtrsf) {
 		1
 	];
 	const tx = Number(gtrsf.tx) || 0, ty = Number(gtrsf.ty) || 0;
-	const m0 = require_vec3.wasmIndex(m, 0), m1 = require_vec3.wasmIndex(m, 1), m3 = require_vec3.wasmIndex(m, 3), m4 = require_vec3.wasmIndex(m, 4);
+	const m0 = require_bug.wasmIndex(m, 0), m1 = require_bug.wasmIndex(m, 1), m3 = require_bug.wasmIndex(m, 3), m4 = require_bug.wasmIndex(m, 4);
 	if (Math.abs(m0 - 1) < 1e-12 && Math.abs(m4 - 1) < 1e-12 && Math.abs(m1) < 1e-12 && Math.abs(m3) < 1e-12) return require_occtWasmAdapter.translateCurve2d(c, tx, ty);
 	const bounds = require_occtWasmAdapter.curveBounds(c);
 	const N = 20;
@@ -4878,8 +4878,8 @@ function approximateCurve2dAsBSpline$1(curve, tol, cont, maxSeg) {
 		for (let i = 0; i < curN; i++) {
 			const tMid = bounds.first + (bounds.last - bounds.first) * (i + .5) / curN;
 			const [ex, ey] = require_occtWasmAdapter.evaluateCurve2d(c, tMid);
-			const p0 = require_vec3.wasmIndex(poles, i);
-			const p1 = require_vec3.wasmIndex(poles, i + 1);
+			const p0 = require_bug.wasmIndex(poles, i);
+			const p1 = require_bug.wasmIndex(poles, i + 1);
 			const mx = (p0[0] + p1[0]) / 2;
 			const my = (p0[1] + p1[1]) / 2;
 			const err = Math.sqrt((ex - mx) ** 2 + (ey - my) ** 2);
@@ -4905,8 +4905,8 @@ function decomposeBSpline2dToBeziers$1(curve) {
 	];
 	const result = [];
 	for (let i = 0; i < breakpoints.length - 1; i++) {
-		const t0 = require_vec3.wasmIndex(breakpoints, i);
-		const t1 = require_vec3.wasmIndex(breakpoints, i + 1);
+		const t0 = require_bug.wasmIndex(breakpoints, i);
+		const t1 = require_bug.wasmIndex(breakpoints, i + 1);
 		const span = t1 - t0;
 		if (span < 1e-15) continue;
 		const p0 = require_occtWasmAdapter.evaluateCurve2d(c, t0);
@@ -5053,7 +5053,7 @@ function interpolatePoints3d(oc, points) {
 	const pnts = new oc.TColgp_Array1OfPnt_2(1, points.length);
 	const reusePnt = new oc.gp_Pnt_1();
 	for (let i = 0; i < points.length; i++) {
-		const p = require_vec3.wasmIndex(points, i);
+		const p = require_bug.wasmIndex(points, i);
 		reusePnt.SetCoord_2(p[0], p[1], p[2]);
 		pnts.SetValue_1(i + 1, reusePnt);
 	}
@@ -5119,7 +5119,7 @@ function liftCurve2dToPlane$1(oc, curve, planeOrigin, planeZ, planeX) {
 	}
 	if (c.__bk2d === "bezier" || c.__bk2d === "bspline") {
 		const pts3d = c.poles.map(([u, v]) => lift(u, v));
-		if (pts3d.length === 2) return makeLineEdge3d(oc, require_vec3.wasmIndex(pts3d, 0), require_vec3.wasmIndex(pts3d, 1));
+		if (pts3d.length === 2) return makeLineEdge3d(oc, require_bug.wasmIndex(pts3d, 0), require_bug.wasmIndex(pts3d, 1));
 		return interpolatePoints3d(oc, pts3d);
 	}
 	const bounds = require_occtWasmAdapter.curveBounds(c);
@@ -5281,7 +5281,7 @@ function makeKernel2dOps$1(oc) {
 */
 function makeBrepkitOnlyStubs() {
 	const u = (name) => () => {
-		throw new Error(`${name} is only available with the brepkit kernel`);
+		throw new require_occtWasmAdapter.UnsupportedKernelOperationError(`${name} is only available with the brepkit kernel`);
 	};
 	return {
 		export3MF: u("export3MF"),
@@ -5298,7 +5298,7 @@ function makeBrepkitOnlyStubs() {
 		detectSmallFeatures: u("detectSmallFeatures"),
 		recognizeFeatures: u("recognizeFeatures"),
 		meshBoolean: (() => {
-			throw new Error("meshBoolean is only available with the brepkit kernel");
+			throw new require_occtWasmAdapter.UnsupportedKernelOperationError("meshBoolean is only available with the brepkit kernel");
 		}),
 		edgeToFaceMap: u("edgeToFaceMap"),
 		sharedEdges: u("sharedEdges"),
@@ -5565,7 +5565,7 @@ function scaleMatrix$1(centerInput, factor) {
 }
 /** Build a row-major 4x4 matrix from a 3x3 linear part + translation. */
 function affineMatrix$1(linear, translation) {
-	const li = (i) => require_vec3.wasmIndex(linear, i);
+	const li = (i) => require_bug.wasmIndex(linear, i);
 	return [
 		li(0),
 		li(1),
@@ -5729,13 +5729,13 @@ function uniqueWireVertices(bk, h) {
 	for (const eid of edgeIds) {
 		const verts = bk.getEdgeVertices(eid);
 		const coords = [[
-			require_vec3.wasmIndex(verts, 0),
-			require_vec3.wasmIndex(verts, 1),
-			require_vec3.wasmIndex(verts, 2)
+			require_bug.wasmIndex(verts, 0),
+			require_bug.wasmIndex(verts, 1),
+			require_bug.wasmIndex(verts, 2)
 		], [
-			require_vec3.wasmIndex(verts, 3),
-			require_vec3.wasmIndex(verts, 4),
-			require_vec3.wasmIndex(verts, 5)
+			require_bug.wasmIndex(verts, 3),
+			require_bug.wasmIndex(verts, 4),
+			require_bug.wasmIndex(verts, 5)
 		]];
 		for (const [x, y, z] of coords) {
 			const key = `${x},${y},${z}`;
@@ -5756,8 +5756,8 @@ function iterEdge(bk, shape, h, type) {
 	if (type === "edge") return [shape];
 	if (type === "vertex") {
 		const verts = bk.getEdgeVertices(h);
-		const v1 = bk.makeVertex(require_vec3.wasmIndex(verts, 0), require_vec3.wasmIndex(verts, 1), require_vec3.wasmIndex(verts, 2));
-		const v2 = bk.makeVertex(require_vec3.wasmIndex(verts, 3), require_vec3.wasmIndex(verts, 4), require_vec3.wasmIndex(verts, 5));
+		const v1 = bk.makeVertex(require_bug.wasmIndex(verts, 0), require_bug.wasmIndex(verts, 1), require_bug.wasmIndex(verts, 2));
+		const v2 = bk.makeVertex(require_bug.wasmIndex(verts, 3), require_bug.wasmIndex(verts, 4), require_bug.wasmIndex(verts, 5));
 		return [vertexHandle(v1), vertexHandle(v2)];
 	}
 	return [];
@@ -5856,7 +5856,7 @@ function makeTopologyOps$1(bk) {
 //#endregion
 //#region src/kernel/brepkit/geometryOps.ts
 function vertexPosition(bk, vertex) {
-	return require_vec3.vec3At(bk.getVertexPosition(unwrap$1(vertex, "vertex")));
+	return require_bug.vec3At(bk.getVertexPosition(unwrap$1(vertex, "vertex")));
 }
 function surfaceType(bk, face) {
 	return bk.getSurfaceType(unwrap$1(face, "face"));
@@ -5864,32 +5864,32 @@ function surfaceType(bk, face) {
 function uvBounds(bk, face) {
 	const domain = bk.getSurfaceDomain(unwrap$1(face, "face"));
 	return {
-		uMin: require_vec3.wasmIndex(domain, 0),
-		uMax: require_vec3.wasmIndex(domain, 1),
-		vMin: require_vec3.wasmIndex(domain, 2),
-		vMax: require_vec3.wasmIndex(domain, 3)
+		uMin: require_bug.wasmIndex(domain, 0),
+		uMax: require_bug.wasmIndex(domain, 1),
+		vMin: require_bug.wasmIndex(domain, 2),
+		vMax: require_bug.wasmIndex(domain, 3)
 	};
 }
 function outerWire(bk, face) {
 	return wireHandle(bk.getFaceOuterWire(unwrap$1(face, "face")));
 }
 function surfaceNormal(bk, face, u, v) {
-	return require_vec3.vec3At(bk.evaluateSurfaceNormal(unwrap$1(face, "face"), u, v));
+	return require_bug.vec3At(bk.evaluateSurfaceNormal(unwrap$1(face, "face"), u, v));
 }
 function pointOnSurface(bk, face, u, v) {
-	return require_vec3.vec3At(bk.evaluateSurface(unwrap$1(face, "face"), u, v));
+	return require_bug.vec3At(bk.evaluateSurface(unwrap$1(face, "face"), u, v));
 }
 function uvFromPoint(bk, face, point) {
 	try {
 		const result = bk.projectPointOnSurface(unwrap$1(face, "face"), point[0], point[1], point[2]);
-		return [require_vec3.wasmIndex(result, 0), require_vec3.wasmIndex(result, 1)];
+		return [require_bug.wasmIndex(result, 0), require_bug.wasmIndex(result, 1)];
 	} catch (e) {
 		console.warn("brepkit: uvFromPoint failed:", e);
 		return null;
 	}
 }
 function projectPointOnFace(bk, face, point) {
-	return require_vec3.vec3At(bk.projectPointOnSurface(unwrap$1(face, "face"), point[0], point[1], point[2]), 2);
+	return require_bug.vec3At(bk.projectPointOnSurface(unwrap$1(face, "face"), point[0], point[1], point[2]), 2);
 }
 function curveTangent(bk, shape, param) {
 	const h = shape;
@@ -5897,14 +5897,14 @@ function curveTangent(bk, shape, param) {
 	let evalParam = param;
 	if (h.type === "wire") {
 		const edgeIds = toArray(bk.getWireEdges(h.id));
-		edgeId = require_vec3.wasmIndex(edgeIds, edgeIds.length - 1);
+		edgeId = require_bug.wasmIndex(edgeIds, edgeIds.length - 1);
 		let cumulative = 0;
 		for (const eid of edgeIds) {
 			const p = bk.getEdgeCurveParameters(eid);
-			const span = require_vec3.wasmIndex(p, 1) - require_vec3.wasmIndex(p, 0);
+			const span = require_bug.wasmIndex(p, 1) - require_bug.wasmIndex(p, 0);
 			if (param <= cumulative + span || eid === edgeId) {
 				edgeId = eid;
-				evalParam = Math.min(require_vec3.wasmIndex(p, 0) + (param - cumulative), require_vec3.wasmIndex(p, 1));
+				evalParam = Math.min(require_bug.wasmIndex(p, 0) + (param - cumulative), require_bug.wasmIndex(p, 1));
 				break;
 			}
 			cumulative += span;
@@ -5912,8 +5912,8 @@ function curveTangent(bk, shape, param) {
 	} else edgeId = unwrap$1(shape, "edge");
 	const result = bk.evaluateEdgeCurveD1(edgeId, evalParam);
 	return {
-		point: require_vec3.vec3At(result, 0),
-		tangent: require_vec3.vec3At(result, 3)
+		point: require_bug.vec3At(result, 0),
+		tangent: require_bug.vec3At(result, 3)
 	};
 }
 function curveParameters(bk, shape) {
@@ -5924,12 +5924,12 @@ function curveParameters(bk, shape) {
 		let total = 0;
 		for (const eid of edgeIds) {
 			const p = bk.getEdgeCurveParameters(eid);
-			total += require_vec3.wasmIndex(p, 1) - require_vec3.wasmIndex(p, 0);
+			total += require_bug.wasmIndex(p, 1) - require_bug.wasmIndex(p, 0);
 		}
 		return [0, total];
 	}
 	const params = bk.getEdgeCurveParameters(unwrap$1(shape, "edge"));
-	return [require_vec3.wasmIndex(params, 0), require_vec3.wasmIndex(params, 1)];
+	return [require_bug.wasmIndex(params, 0), require_bug.wasmIndex(params, 1)];
 }
 function curvePointAtParam(bk, shape, param) {
 	const h = shape;
@@ -5938,28 +5938,28 @@ function curvePointAtParam(bk, shape, param) {
 		let cumulative = 0;
 		for (const eid of edgeIds) {
 			const p = bk.getEdgeCurveParameters(eid);
-			const span = require_vec3.wasmIndex(p, 1) - require_vec3.wasmIndex(p, 0);
+			const span = require_bug.wasmIndex(p, 1) - require_bug.wasmIndex(p, 0);
 			if (param <= cumulative + span || eid === edgeIds[edgeIds.length - 1]) {
-				const localParam = require_vec3.wasmIndex(p, 0) + (param - cumulative);
-				return require_vec3.vec3At(bk.evaluateEdgeCurve(eid, Math.min(localParam, require_vec3.wasmIndex(p, 1))));
+				const localParam = require_bug.wasmIndex(p, 0) + (param - cumulative);
+				return require_bug.vec3At(bk.evaluateEdgeCurve(eid, Math.min(localParam, require_bug.wasmIndex(p, 1))));
 			}
 			cumulative += span;
 		}
-		return require_vec3.vec3At(bk.evaluateEdgeCurve(require_vec3.wasmIndex(edgeIds, 0), param));
+		return require_bug.vec3At(bk.evaluateEdgeCurve(require_bug.wasmIndex(edgeIds, 0), param));
 	}
-	return require_vec3.vec3At(bk.evaluateEdgeCurve(unwrap$1(shape, "edge"), param));
+	return require_bug.vec3At(bk.evaluateEdgeCurve(unwrap$1(shape, "edge"), param));
 }
 function curveIsClosed(bk, shape) {
 	const h = shape;
 	if (h.type === "wire") {
 		const edgeIds = toArray(bk.getWireEdges(h.id));
 		if (edgeIds.length === 0) return false;
-		if (edgeIds.length === 1) return edgeIsClosed(bk.getEdgeVertices(require_vec3.wasmIndex(edgeIds, 0)));
+		if (edgeIds.length === 1) return edgeIsClosed(bk.getEdgeVertices(require_bug.wasmIndex(edgeIds, 0)));
 		const endpoints = [];
 		for (const eid of edgeIds) {
 			const verts = bk.getEdgeVertices(eid);
-			endpoints.push(require_vec3.vec3At(verts, 0));
-			endpoints.push(require_vec3.vec3At(verts, 3));
+			endpoints.push(require_bug.vec3At(verts, 0));
+			endpoints.push(require_bug.vec3At(verts, 3));
 		}
 		const unmatched = [];
 		for (const pt of endpoints) {
@@ -5972,7 +5972,7 @@ function curveIsClosed(bk, shape) {
 	return edgeIsClosed(bk.getEdgeVertices(unwrap$1(shape, "edge")));
 }
 function edgeIsClosed(verts) {
-	return dist3(require_vec3.wasmIndex(verts, 0), require_vec3.wasmIndex(verts, 1), require_vec3.wasmIndex(verts, 2), require_vec3.wasmIndex(verts, 3), require_vec3.wasmIndex(verts, 4), require_vec3.wasmIndex(verts, 5)) < 1e-7;
+	return dist3(require_bug.wasmIndex(verts, 0), require_bug.wasmIndex(verts, 1), require_bug.wasmIndex(verts, 2), require_bug.wasmIndex(verts, 3), require_bug.wasmIndex(verts, 4), require_bug.wasmIndex(verts, 5)) < 1e-7;
 }
 function curveIsPeriodic(bk, shape) {
 	const h = shape;
@@ -6016,7 +6016,7 @@ function curveKnotRemove(bk, edge, knot, tolerance) {
 function curveSplit(bk, edge, param) {
 	const edgeId = unwrap$1(edge, "edge");
 	const result = bk.curveSplit(edgeId, param);
-	return [edgeHandle(require_vec3.wasmIndex(result, 0)), edgeHandle(require_vec3.wasmIndex(result, 1))];
+	return [edgeHandle(require_bug.wasmIndex(result, 0)), edgeHandle(require_bug.wasmIndex(result, 1))];
 }
 function approximateSurfaceLspia(bk, coords, rows, cols, degreeU, degreeV, numCpsU, numCpsV, tolerance, maxIterations) {
 	return faceHandle(bk.approximateSurfaceLspia(coords, rows, cols, degreeU, degreeV, numCpsU, numCpsV, tolerance, maxIterations));
@@ -6031,7 +6031,7 @@ function createCurveAdaptor(_bk, shape) {
 function getBezierPenultimatePole(bk, edge) {
 	const nurbsData = extractNurbsFromEdge(bk, edge);
 	if (!nurbsData || nurbsData.controlPoints.length < 6) return null;
-	return require_vec3.vec3At(nurbsData.controlPoints, nurbsData.controlPoints.length - 6);
+	return require_bug.vec3At(nurbsData.controlPoints, nurbsData.controlPoints.length - 6);
 }
 function getSurfaceCylinderData(bk, surface) {
 	if (isBrepkitHandle(surface) && surface.type === "face") {
@@ -6072,7 +6072,7 @@ function classifyPointOnFace(bk, face, u, v, tolerance) {
 	if (tolerance !== void 0) warnOnce("classify-tolerance", "classifyPointOnFace() tolerance parameter is not supported; brepkit uses domain-based classification.");
 	const faceId = unwrap$1(face, "face");
 	const domain = bk.getSurfaceDomain(faceId);
-	if (u < require_vec3.wasmIndex(domain, 0) || u > require_vec3.wasmIndex(domain, 1) || v < require_vec3.wasmIndex(domain, 2) || v > require_vec3.wasmIndex(domain, 3)) return "out";
+	if (u < require_bug.wasmIndex(domain, 0) || u > require_bug.wasmIndex(domain, 1) || v < require_bug.wasmIndex(domain, 2) || v > require_bug.wasmIndex(domain, 3)) return "out";
 	return "in";
 }
 function classifyPointRobust(bk, shape, point, tolerance) {
@@ -6103,8 +6103,8 @@ function projectEdges(bk, shape, cameraOrigin, cameraDirection, cameraXAxis) {
 	let deflection = .1;
 	try {
 		const bb = bk.boundingBox(solidId);
-		const [minX, minY, minZ] = require_vec3.vec3At(bb, 0);
-		const [maxX, maxY, maxZ] = require_vec3.vec3At(bb, 3);
+		const [minX, minY, minZ] = require_bug.vec3At(bb, 0);
+		const [maxX, maxY, maxZ] = require_bug.vec3At(bb, 3);
 		const diag = dist3(minX, minY, minZ, maxX, maxY, maxZ);
 		if (diag > 0) deflection = Math.max(diag * .001, 1e-6);
 	} catch {}
@@ -6411,10 +6411,10 @@ function extractPlaneFromFace(bk, faceShape) {
 		}
 		faceId = bestId;
 	} else faceId = unwrap$1(faceShape, "face");
-	const normal = require_vec3.vec3At(bk.getFaceNormal(faceId));
+	const normal = require_bug.vec3At(bk.getFaceNormal(faceId));
 	const positions = bk.tessellateFace(faceId, 1).positions;
 	if (positions.length >= 3) return {
-		point: require_vec3.vec3At(positions),
+		point: require_bug.vec3At(positions),
 		normal
 	};
 	return {
@@ -6454,12 +6454,12 @@ function extractNurbsFromEdge(bk, shape) {
 			1
 		],
 		controlPoints: [
-			require_vec3.wasmIndex(verts, 0),
-			require_vec3.wasmIndex(verts, 1),
-			require_vec3.wasmIndex(verts, 2),
-			require_vec3.wasmIndex(verts, 3),
-			require_vec3.wasmIndex(verts, 4),
-			require_vec3.wasmIndex(verts, 5)
+			require_bug.wasmIndex(verts, 0),
+			require_bug.wasmIndex(verts, 1),
+			require_bug.wasmIndex(verts, 2),
+			require_bug.wasmIndex(verts, 3),
+			require_bug.wasmIndex(verts, 4),
+			require_bug.wasmIndex(verts, 5)
 		],
 		weights: [1, 1]
 	};
@@ -6623,8 +6623,8 @@ function section(bk, shape, plane, _approximation) {
 	if (faceIds.length === 0) return compoundHandle(bk.makeCompound([]));
 	const allWireHandles = [];
 	for (let i = 0; i < faceIds.length; i++) {
-		const wireIds = toArray(bk.getFaceWires(require_vec3.wasmIndex(faceIds, i)));
-		for (let j = 0; j < wireIds.length; j++) allWireHandles.push(wireHandle(require_vec3.wasmIndex(wireIds, j)));
+		const wireIds = toArray(bk.getFaceWires(require_bug.wasmIndex(faceIds, i)));
+		for (let j = 0; j < wireIds.length; j++) allWireHandles.push(wireHandle(require_bug.wasmIndex(wireIds, j)));
 	}
 	const [firstWire] = allWireHandles;
 	if (allWireHandles.length === 1 && firstWire !== void 0) return firstWire;
@@ -6634,7 +6634,7 @@ function section(bk, shape, plane, _approximation) {
 }
 function fuseAll(bk, shapes, options) {
 	if (shapes.length === 0) throw new Error("brepkit: fuseAll requires at least one shape");
-	if (shapes.length === 1) return require_vec3.wasmIndex(shapes, 0);
+	if (shapes.length === 1) return require_bug.wasmIndex(shapes, 0);
 	if (bk.compoundFuse) {
 		const solidIds = [];
 		for (const shape of shapes) {
@@ -6652,7 +6652,7 @@ function fuseAll(bk, shapes, options) {
 		else next.push(current[i]);
 		current = next;
 	}
-	return require_vec3.wasmIndex(current, 0);
+	return require_bug.wasmIndex(current, 0);
 }
 function cutAll(bk, shape, tools, options) {
 	if (tools.length === 0) return shape;
@@ -6731,11 +6731,11 @@ function hull(bk, shapes, _tolerance) {
 			const vertIds = toArray(bk.getSolidVertices(h.id));
 			for (const vid of vertIds) {
 				const pos = bk.getVertexPosition(vid);
-				coords.push(require_vec3.wasmIndex(pos, 0), require_vec3.wasmIndex(pos, 1), require_vec3.wasmIndex(pos, 2));
+				coords.push(require_bug.wasmIndex(pos, 0), require_bug.wasmIndex(pos, 1), require_bug.wasmIndex(pos, 2));
 			}
 		} else if (h.type === "vertex") {
 			const pos = bk.getVertexPosition(h.id);
-			coords.push(require_vec3.wasmIndex(pos, 0), require_vec3.wasmIndex(pos, 1), require_vec3.wasmIndex(pos, 2));
+			coords.push(require_bug.wasmIndex(pos, 0), require_bug.wasmIndex(pos, 1), require_bug.wasmIndex(pos, 2));
 		}
 	}
 	if (coords.length < 12) throw new Error("brepkit: hull requires enough points");
@@ -6750,14 +6750,14 @@ function hullFromPoints(bk, points, _tolerance) {
 function buildSolidFromFaces(bk, points, faces, _tolerance) {
 	const positions = new Float64Array(points.length * 3);
 	for (let i = 0; i < points.length; i++) {
-		const p = require_vec3.wasmIndex(points, i);
+		const p = require_bug.wasmIndex(points, i);
 		positions[i * 3] = p.x;
 		positions[i * 3 + 1] = p.y;
 		positions[i * 3 + 2] = p.z;
 	}
 	const indices = new Uint32Array(faces.length * 3);
 	for (let i = 0; i < faces.length; i++) {
-		const f = require_vec3.wasmIndex(faces, i);
+		const f = require_bug.wasmIndex(faces, i);
 		indices[i * 3] = f[0];
 		indices[i * 3 + 1] = f[1];
 		indices[i * 3 + 2] = f[2];
@@ -7001,8 +7001,8 @@ function makeBezierEdge(bk, points) {
 		y,
 		z
 	]);
-	const startPt = require_vec3.wasmIndex(points, 0);
-	const endPt = require_vec3.wasmIndex(points, n - 1);
+	const startPt = require_bug.wasmIndex(points, 0);
+	const endPt = require_bug.wasmIndex(points, n - 1);
 	return edgeHandle(bk.makeNurbsEdge(startPt[0], startPt[1], startPt[2], endPt[0], endPt[1], endPt[2], degree, knots, flatCp, weights));
 }
 function makeTangentArc(bk, startPoint, startTangent, endPoint) {
@@ -7096,9 +7096,9 @@ function triangulatedSurface(bk, points, rows, cols) {
 		const i10 = (r + 1) * cols + c;
 		const i01 = r * cols + (c + 1);
 		const i11 = (r + 1) * cols + (c + 1);
-		const f1 = buildTriFace(bk, require_vec3.wasmIndex(points, i00), require_vec3.wasmIndex(points, i10), require_vec3.wasmIndex(points, i01));
+		const f1 = buildTriFace(bk, require_bug.wasmIndex(points, i00), require_bug.wasmIndex(points, i10), require_bug.wasmIndex(points, i01));
 		if (f1) faces.push(f1);
-		const f2 = buildTriFace(bk, require_vec3.wasmIndex(points, i10), require_vec3.wasmIndex(points, i11), require_vec3.wasmIndex(points, i01));
+		const f2 = buildTriFace(bk, require_bug.wasmIndex(points, i10), require_bug.wasmIndex(points, i11), require_bug.wasmIndex(points, i01));
 		if (f2) faces.push(f2);
 	}
 	if (faces.length === 0) throw new Error("brepkit: no valid faces in surface grid");
@@ -7129,7 +7129,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 (points.length === 2) return makeLineEdge(bk, require_vec3.wasmIndex(points, 0), require_vec3.wasmIndex(points, 1));
+	if (points.length === 2) return makeLineEdge(bk, require_bug.wasmIndex(points, 0), require_bug.wasmIndex(points, 1));
 	const degree = Math.min(3, points.length - 1);
 	const coords = points.flatMap(([x, y, z]) => [
 		x,
@@ -7281,14 +7281,14 @@ function makeCircleNurbs(bk, center, normal, radius, startAngle, endAngle) {
 	const knots = Array(3).fill(0);
 	for (let i = 1; i < nSegments; i++) knots.push(i, i);
 	knots.push(...Array(3).fill(nSegments));
-	const kMax = require_vec3.wasmIndex(knots, knots.length - 1);
-	for (let i = 0; i < knots.length; i++) knots[i] = require_vec3.wasmIndex(knots, i) / kMax;
-	const sx = require_vec3.wasmIndex(controlPoints, 0);
-	const sy = require_vec3.wasmIndex(controlPoints, 1);
-	const sz = require_vec3.wasmIndex(controlPoints, 2);
-	const ex = require_vec3.wasmIndex(controlPoints, controlPoints.length - 3);
-	const ey = require_vec3.wasmIndex(controlPoints, controlPoints.length - 2);
-	const ez = require_vec3.wasmIndex(controlPoints, controlPoints.length - 1);
+	const kMax = require_bug.wasmIndex(knots, knots.length - 1);
+	for (let i = 0; i < knots.length; i++) knots[i] = require_bug.wasmIndex(knots, i) / kMax;
+	const sx = require_bug.wasmIndex(controlPoints, 0);
+	const sy = require_bug.wasmIndex(controlPoints, 1);
+	const sz = require_bug.wasmIndex(controlPoints, 2);
+	const ex = require_bug.wasmIndex(controlPoints, controlPoints.length - 3);
+	const ey = require_bug.wasmIndex(controlPoints, controlPoints.length - 2);
+	const ez = require_bug.wasmIndex(controlPoints, controlPoints.length - 1);
 	return edgeHandle(bk.makeNurbsEdge(sx, sy, sz, ex, ey, ez, degree, knots, controlPoints, weights));
 }
 function makeEllipseNurbs(bk, center, normal, majorRadius, minorRadius, startAngle, endAngle, xDir) {
@@ -7362,14 +7362,14 @@ function makeEllipseNurbs(bk, center, normal, majorRadius, minorRadius, startAng
 	const knots = Array(3).fill(0);
 	for (let i = 1; i < nSegments; i++) knots.push(i, i);
 	knots.push(...Array(3).fill(nSegments));
-	const kMax = require_vec3.wasmIndex(knots, knots.length - 1);
-	for (let i = 0; i < knots.length; i++) knots[i] = require_vec3.wasmIndex(knots, i) / kMax;
-	const sx = require_vec3.wasmIndex(controlPoints, 0);
-	const sy = require_vec3.wasmIndex(controlPoints, 1);
-	const sz = require_vec3.wasmIndex(controlPoints, 2);
-	const ex = require_vec3.wasmIndex(controlPoints, controlPoints.length - 3);
-	const ey = require_vec3.wasmIndex(controlPoints, controlPoints.length - 2);
-	const ez = require_vec3.wasmIndex(controlPoints, controlPoints.length - 1);
+	const kMax = require_bug.wasmIndex(knots, knots.length - 1);
+	for (let i = 0; i < knots.length; i++) knots[i] = require_bug.wasmIndex(knots, i) / kMax;
+	const sx = require_bug.wasmIndex(controlPoints, 0);
+	const sy = require_bug.wasmIndex(controlPoints, 1);
+	const sz = require_bug.wasmIndex(controlPoints, 2);
+	const ex = require_bug.wasmIndex(controlPoints, controlPoints.length - 3);
+	const ey = require_bug.wasmIndex(controlPoints, controlPoints.length - 2);
+	const ez = require_bug.wasmIndex(controlPoints, controlPoints.length - 1);
 	return edgeHandle(bk.makeNurbsEdge(sx, sy, sz, ex, ey, ez, degree, knots, controlPoints, weights));
 }
 /** Co-located factory: returns the construction slice of {@link KernelAdapter} bound to `bk`. */
@@ -7486,9 +7486,9 @@ function faceCentroid(bk, faceId) {
 	let x = 0, y = 0, z = 0;
 	for (const vid of verts) {
 		const pos = bk.getVertexPosition(vid);
-		x += require_vec3.wasmIndex(pos, 0);
-		y += require_vec3.wasmIndex(pos, 1);
-		z += require_vec3.wasmIndex(pos, 2);
+		x += require_bug.wasmIndex(pos, 0);
+		y += require_bug.wasmIndex(pos, 1);
+		z += require_bug.wasmIndex(pos, 2);
 	}
 	const n = verts.length;
 	return {
@@ -7591,12 +7591,12 @@ function offsetWire2D(bk, wire, offsetVal, joinType) {
 	const coords2d = [];
 	for (const edge of edges) {
 		const verts = bk.getEdgeVertices(unwrap$1(edge, "edge"));
-		coords2d.push(require_vec3.wasmIndex(verts, 0), require_vec3.wasmIndex(verts, 1));
+		coords2d.push(require_bug.wasmIndex(verts, 0), require_bug.wasmIndex(verts, 1));
 	}
 	if (coords2d.length < 6) return wire;
 	const result = bk.offsetPolygon2d(coords2d, offsetVal, 1e-10);
 	const coords3d = [];
-	for (let i = 0; i < result.length; i += 2) coords3d.push(require_vec3.wasmIndex(result, i), require_vec3.wasmIndex(result, i + 1), 0);
+	for (let i = 0; i < result.length; i += 2) coords3d.push(require_bug.wasmIndex(result, i), require_bug.wasmIndex(result, i + 1), 0);
 	return wireHandle(bk.makePolygonWire(coords3d));
 }
 function simplify$1(bk, shape) {
@@ -7690,9 +7690,9 @@ function faceCentroidById(bk, faceId) {
 		let cz = 0;
 		const nVerts = pos.length / 3;
 		for (let i = 0; i < pos.length; i += 3) {
-			cx += require_vec3.wasmIndex(pos, i);
-			cy += require_vec3.wasmIndex(pos, i + 1);
-			cz += require_vec3.wasmIndex(pos, i + 2);
+			cx += require_bug.wasmIndex(pos, i);
+			cy += require_bug.wasmIndex(pos, i + 1);
+			cz += require_bug.wasmIndex(pos, i + 2);
 		}
 		return [
 			cx / nVerts,
@@ -7741,7 +7741,7 @@ function collectOutputMatches(out, inputSigs) {
 	let bestScore = -Infinity;
 	const matches = [];
 	for (let i = 0; i < inputSigs.length; i++) {
-		const inp = require_vec3.wasmIndex(inputSigs, i);
+		const inp = require_bug.wasmIndex(inputSigs, i);
 		const dot = (out.normal[0] ?? 0) * (inp.normal[0] ?? 0) + (out.normal[1] ?? 0) * (inp.normal[1] ?? 0) + (out.normal[2] ?? 0) * (inp.normal[2] ?? 0);
 		if (dot < NORMAL_THRESHOLD) continue;
 		const distSq = centroidDistSq(out.centroid, inp.centroid);
@@ -7782,7 +7782,7 @@ function matchFacesGeometrically(bk, originalShape, inputFaceHashes, outputFaceI
 	const hashCount = Math.min(inputFaceIds.length, inputFaceHashes.length);
 	const inputSigs = [];
 	for (let i = 0; i < hashCount; i++) {
-		const fid = require_vec3.wasmIndex(inputFaceIds, i);
+		const fid = require_bug.wasmIndex(inputFaceIds, i);
 		inputSigs.push(snapshotFaceSignature(bk, fid, inputFaceHashes[i] ?? fid % hashUpperBound));
 	}
 	const outputSigs = outputFaceIds.map((fid) => snapshotFaceSignature(bk, fid, fid % hashUpperBound));
@@ -7791,7 +7791,7 @@ function matchFacesGeometrically(bk, originalShape, inputFaceHashes, outputFaceI
 		const { matches, bestScore } = collectOutputMatches(out, inputSigs);
 		if (matches.length > 0) {
 			for (const m of matches) if (m.score >= bestScore - SCORE_TIE_TOL) {
-				const inp = require_vec3.wasmIndex(inputSigs, m.idx);
+				const inp = require_bug.wasmIndex(inputSigs, m.idx);
 				const existing = modified.get(inp.hash) ?? [];
 				existing.push(out.hash);
 				modified.set(inp.hash, existing);
@@ -7806,7 +7806,7 @@ function matchFacesGeometrically(bk, originalShape, inputFaceHashes, outputFaceI
 			}
 		}
 	}
-	for (let i = 0; i < inputSigs.length; i++) if (!matchedInputIndices.has(i)) deleted.add(require_vec3.wasmIndex(inputSigs, i).hash);
+	for (let i = 0; i < inputSigs.length; i++) if (!matchedInputIndices.has(i)) deleted.add(require_bug.wasmIndex(inputSigs, i).hash);
 }
 /**
 * Apply geometric matching to the unmatched input/output residuals from a
@@ -7832,7 +7832,7 @@ function reconcileUnmatchedResiduals(bk, originalShape, unmatchedInputHashes, un
 */
 function fallbackHashOnlyEvolution(inputFaceHashes, outputHashes, inputSet, outputSet, generated, deleted) {
 	const newFaces = outputHashes.filter((fh) => !inputSet.has(fh));
-	if (newFaces.length > 0 && inputFaceHashes.length > 0) generated.set(require_vec3.wasmIndex(inputFaceHashes, 0), newFaces);
+	if (newFaces.length > 0 && inputFaceHashes.length > 0) generated.set(require_bug.wasmIndex(inputFaceHashes, 0), newFaces);
 	for (const hash of inputFaceHashes) if (!outputSet.has(hash)) deleted.add(hash);
 }
 /**
@@ -7850,8 +7850,8 @@ function buildBooleanEvolution(bk, outputFaces, outputHashes, inputFaceHashes, h
 		else fallbackHashOnlyEvolution(inputFaceHashes, outputHashes, inputSet, outputSet, generated, deleted);
 	} else if (originalShape) matchFacesGeometrically(bk, originalShape, inputFaceHashes, outputFaces, hashUpperBound, modified, generated, deleted);
 	else {
-		for (let i = 0; i < inputFaceHashes.length && i < outputHashes.length; i++) modified.set(require_vec3.wasmIndex(inputFaceHashes, i), [require_vec3.wasmIndex(outputHashes, i)]);
-		if (outputHashes.length > inputFaceHashes.length && inputFaceHashes.length > 0) generated.set(require_vec3.wasmIndex(inputFaceHashes, 0), outputHashes.slice(inputFaceHashes.length));
+		for (let i = 0; i < inputFaceHashes.length && i < outputHashes.length; i++) modified.set(require_bug.wasmIndex(inputFaceHashes, i), [require_bug.wasmIndex(outputHashes, i)]);
+		if (outputHashes.length > inputFaceHashes.length && inputFaceHashes.length > 0) generated.set(require_bug.wasmIndex(inputFaceHashes, 0), outputHashes.slice(inputFaceHashes.length));
 	}
 }
 /**
@@ -7869,7 +7869,7 @@ function buildEvolution(bk, resultShape, inputFaceHashes, hashUpperBound, isTran
 	if (h.type === "solid") {
 		const outputFaces = toArray(bk.getSolidFaces(h.id));
 		const outputHashes = outputFaces.map((fid) => fid % hashUpperBound);
-		if (isTransform) for (let i = 0; i < inputFaceHashes.length && i < outputHashes.length; i++) modified.set(require_vec3.wasmIndex(inputFaceHashes, i), [require_vec3.wasmIndex(outputHashes, i)]);
+		if (isTransform) for (let i = 0; i < inputFaceHashes.length && i < outputHashes.length; i++) modified.set(require_bug.wasmIndex(inputFaceHashes, i), [require_bug.wasmIndex(outputHashes, i)]);
 		else buildBooleanEvolution(bk, outputFaces, outputHashes, inputFaceHashes, hashUpperBound, modified, generated, deleted, originalShape);
 	}
 	return {
@@ -8112,8 +8112,8 @@ function meshEdges$1(bk, shape, tolerance, angularTolerance) {
 	const edgeCount = edgeLines.edgeCount;
 	const edgeGroups = [];
 	for (let i = 0; i < edgeCount; i++) {
-		const startIdx = require_vec3.wasmIndex(offsets, i);
-		const pointCount = ((i + 1 < edgeCount ? require_vec3.wasmIndex(offsets, i + 1) : positions.length) - startIdx) / 3;
+		const startIdx = require_bug.wasmIndex(offsets, i);
+		const pointCount = ((i + 1 < edgeCount ? require_bug.wasmIndex(offsets, i + 1) : positions.length) - startIdx) / 3;
 		edgeGroups.push({
 			start: startIdx / 3,
 			count: pointCount,
@@ -8167,8 +8167,8 @@ function meshSolidGroupedBinary(bk, solidId, deflection, includeUVs, angularTole
 	if (groupCount !== faceIds.length) throw new Error(`faceOffsets/faceIds length mismatch: ${groupCount} groups vs ${faceIds.length} faces`);
 	const faceGroups = [];
 	for (let i = 0; i < faceOffsets.length - 1; i++) {
-		const start = require_vec3.wasmIndex(faceOffsets, i);
-		const count = require_vec3.wasmIndex(faceOffsets, i + 1) - start;
+		const start = require_bug.wasmIndex(faceOffsets, i);
+		const count = require_bug.wasmIndex(faceOffsets, i + 1) - start;
 		if (count === 0) continue;
 		faceGroups.push({
 			start,
@@ -8204,8 +8204,8 @@ function meshSolidGroupedJson(bk, solidId, deflection, includeUVs, angularTolera
 	if (groupCount !== faceIds.length) throw new Error(`faceOffsets/faceIds length mismatch: ${groupCount} groups vs ${faceIds.length} faces`);
 	const faceGroups = [];
 	for (let i = 0; i < data.faceOffsets.length - 1; i++) {
-		const start = require_vec3.wasmIndex(data.faceOffsets, i);
-		const count = require_vec3.wasmIndex(data.faceOffsets, i + 1) - start;
+		const start = require_bug.wasmIndex(data.faceOffsets, i);
+		const count = require_bug.wasmIndex(data.faceOffsets, i + 1) - start;
 		if (count === 0) continue;
 		faceGroups.push({
 			start,
@@ -8316,7 +8316,7 @@ function exportSTEP(bk, shapes) {
 	return parts.join("\n");
 }
 function exportSTL$1(bk, shape, binary, tolerance = require_occtWasmAdapter.DEFAULT_STL_TOLERANCE, angularTolerance = require_occtWasmAdapter.DEFAULT_STL_ANGULAR_TOLERANCE) {
-	const { vertices, triangles } = mesh$1(bk, solidHandle(require_vec3.wasmIndex(unwrapSolidsForExport(bk, shape, "exportSTL"), 0)), {
+	const { vertices, triangles } = mesh$1(bk, solidHandle(require_bug.wasmIndex(unwrapSolidsForExport(bk, shape, "exportSTL"), 0)), {
 		tolerance,
 		angularTolerance,
 		skipNormals: true
@@ -8646,7 +8646,7 @@ function createAffinityGTrsf2d(ox, oy, dx, dy, ratio) {
 		0,
 		1
 	];
-	return _gtrsf(m, ox - require_vec3.wasmIndex(m, 0) * ox - require_vec3.wasmIndex(m, 1) * oy, oy - require_vec3.wasmIndex(m, 3) * ox - require_vec3.wasmIndex(m, 4) * oy);
+	return _gtrsf(m, ox - require_bug.wasmIndex(m, 0) * ox - require_bug.wasmIndex(m, 1) * oy, oy - require_bug.wasmIndex(m, 3) * ox - require_bug.wasmIndex(m, 4) * oy);
 }
 function createTranslationGTrsf2d(dx, dy) {
 	return _gtrsf([
@@ -8677,7 +8677,7 @@ function createMirrorGTrsf2d(cx, cy, mode, ox, oy, dx, dy) {
 			1
 		];
 		const px = ox ?? cx, py = oy ?? cy;
-		return _gtrsf(m, px - require_vec3.wasmIndex(m, 0) * px - require_vec3.wasmIndex(m, 1) * py, py - require_vec3.wasmIndex(m, 3) * px - require_vec3.wasmIndex(m, 4) * py);
+		return _gtrsf(m, px - require_bug.wasmIndex(m, 0) * px - require_bug.wasmIndex(m, 1) * py, py - require_bug.wasmIndex(m, 3) * px - require_bug.wasmIndex(m, 4) * py);
 	}
 	return _gtrsf([
 		-1,
@@ -8724,8 +8724,8 @@ function setGTrsf2dTranslationPart(gtrsf, dx, dy) {
 }
 function multiplyGTrsf2d(base, other) {
 	const a = base.m, b = other.m;
-	const ai = (i) => require_vec3.wasmIndex(a, i);
-	const bi = (i) => require_vec3.wasmIndex(b, i);
+	const ai = (i) => require_bug.wasmIndex(a, i);
+	const bi = (i) => require_bug.wasmIndex(b, i);
 	base.m = [
 		ai(0) * bi(0) + ai(1) * bi(3) + ai(2) * bi(6),
 		ai(0) * bi(1) + ai(1) * bi(4) + ai(2) * bi(7),
@@ -8756,7 +8756,7 @@ function transformCurve2dGeneral(curve, gtrsf) {
 		1
 	];
 	const tx = Number(gtrsf.tx) || 0, ty = Number(gtrsf.ty) || 0;
-	const m0 = require_vec3.wasmIndex(m, 0), m1 = require_vec3.wasmIndex(m, 1), m3 = require_vec3.wasmIndex(m, 3), m4 = require_vec3.wasmIndex(m, 4);
+	const m0 = require_bug.wasmIndex(m, 0), m1 = require_bug.wasmIndex(m, 1), m3 = require_bug.wasmIndex(m, 3), m4 = require_bug.wasmIndex(m, 4);
 	if (Math.abs(m0 - 1) < 1e-12 && Math.abs(m4 - 1) < 1e-12 && Math.abs(m1) < 1e-12 && Math.abs(m3) < 1e-12) return require_occtWasmAdapter.translateCurve2d(c, tx, ty);
 	const bounds = require_occtWasmAdapter.curveBounds(c);
 	const N = 20;
@@ -8898,8 +8898,8 @@ function approximateCurve2dAsBSpline(curve, tol, cont, maxSeg) {
 		for (let i = 0; i < N; i++) {
 			const tMid = bounds.first + (bounds.last - bounds.first) * (i + .5) / N;
 			const [ex, ey] = require_occtWasmAdapter.evaluateCurve2d(c, tMid);
-			const p0 = require_vec3.wasmIndex(poles, i);
-			const p1 = require_vec3.wasmIndex(poles, i + 1);
+			const p0 = require_bug.wasmIndex(poles, i);
+			const p1 = require_bug.wasmIndex(poles, i + 1);
 			const mx = (p0[0] + p1[0]) / 2;
 			const my = (p0[1] + p1[1]) / 2;
 			const err = Math.sqrt((ex - mx) ** 2 + (ey - my) ** 2);
@@ -8925,8 +8925,8 @@ function decomposeBSpline2dToBeziers(curve) {
 	];
 	const result = [];
 	for (let i = 0; i < breakpoints.length - 1; i++) {
-		const t0 = require_vec3.wasmIndex(breakpoints, i);
-		const t1 = require_vec3.wasmIndex(breakpoints, i + 1);
+		const t0 = require_bug.wasmIndex(breakpoints, i);
+		const t1 = require_bug.wasmIndex(breakpoints, i + 1);
 		const span = t1 - t0;
 		if (span < 1e-15) continue;
 		const p0 = require_occtWasmAdapter.evaluateCurve2d(c, t0);
@@ -9077,7 +9077,7 @@ function liftCurve2dToPlane(bk, curve, origin, planeZ, planeX) {
 				const [eu, ev] = require_occtWasmAdapter.evaluateCurve2d(c, bounds.first + (seg + 1) * segmentSpan);
 				edgeIds.push(bk.makeCircleArc3d(...lift(su, sv), ...lift(eu, ev), ...center3d, ...axis));
 			}
-			if (edgeIds.length === 1) return edgeHandle(require_vec3.wasmIndex(edgeIds, 0));
+			if (edgeIds.length === 1) return edgeHandle(require_bug.wasmIndex(edgeIds, 0));
 			return wireHandle(bk.makeWire(edgeIds, false));
 		}
 		if (basis.__bk2d === "ellipse") {
@@ -9109,13 +9109,13 @@ function liftCurve2dToPlane(bk, curve, origin, planeZ, planeX) {
 				const [eu, ev] = require_occtWasmAdapter.evaluateCurve2d(c, bounds.first + (seg + 1) * segmentSpan);
 				edgeIds.push(bk.makeEllipseArc3d(...lift(su, sv), ...lift(eu, ev), ...center3d, ...axis, ...refDir, ell.majorRadius, ell.minorRadius));
 			}
-			if (edgeIds.length === 1) return edgeHandle(require_vec3.wasmIndex(edgeIds, 0));
+			if (edgeIds.length === 1) return edgeHandle(require_bug.wasmIndex(edgeIds, 0));
 			return wireHandle(bk.makeWire(edgeIds, false));
 		}
 	}
 	if (c.__bk2d === "bezier" || c.__bk2d === "bspline") {
 		const points3d = c.poles.map(([u, v]) => lift(u, v));
-		if (points3d.length === 2) return makeLineEdge(bk, require_vec3.wasmIndex(points3d, 0), require_vec3.wasmIndex(points3d, 1));
+		if (points3d.length === 2) return makeLineEdge(bk, require_bug.wasmIndex(points3d, 0), require_bug.wasmIndex(points3d, 1));
 		const degree = Math.min(3, points3d.length - 1);
 		const coords = points3d.flatMap(([px, py, pz]) => [
 			px,
@@ -9144,7 +9144,7 @@ function buildEdgeOnSurface(bk, curve, surface) {
 	for (let i = 0; i <= N; i++) {
 		const t = bounds.first + (bounds.last - bounds.first) * i / N;
 		const [u, v] = require_occtWasmAdapter.evaluateCurve2d(c, t);
-		points.push(require_vec3.vec3At(bk.evaluateSurface(fid, u, v)));
+		points.push(require_bug.vec3At(bk.evaluateSurface(fid, u, v)));
 	}
 	return interpolatePoints(bk, points);
 }
@@ -9162,8 +9162,8 @@ function refineUVSamples(uvSamples, evaluateUV, maxSamples, threshold) {
 	while (uvSamples.length < maxSamples) {
 		const insertions = [];
 		for (let i = 0; i < uvSamples.length - 1; i++) {
-			const a = require_vec3.wasmIndex(uvSamples, i);
-			const b = require_vec3.wasmIndex(uvSamples, i + 1);
+			const a = require_bug.wasmIndex(uvSamples, i);
+			const b = require_bug.wasmIndex(uvSamples, i + 1);
 			const tMid = (a.t + b.t) / 2;
 			const uvMid = evaluateUV(tMid);
 			const interpU = (a.uv[0] + b.uv[0]) / 2;
@@ -9177,7 +9177,7 @@ function refineUVSamples(uvSamples, evaluateUV, maxSamples, threshold) {
 		if (insertions.length === 0) break;
 		let budget = maxSamples - uvSamples.length;
 		for (let j = insertions.length - 1; j >= 0 && budget > 0; j--) {
-			const ins = require_vec3.wasmIndex(insertions, j);
+			const ins = require_bug.wasmIndex(insertions, j);
 			uvSamples.splice(ins.index, 0, {
 				t: ins.t,
 				uv: ins.uv
@@ -9201,8 +9201,8 @@ function extractCurve2dFromEdge(bk, edge, face) {
 	for (let i = 0; i <= BASE_N; i++) tValues.push(tMin + (tMax - tMin) * i / BASE_N);
 	const evaluateUV = (t) => {
 		const pt = bk.evaluateEdgeCurve(eid, t);
-		const uv = bk.projectPointOnSurface(fid, require_vec3.wasmIndex(pt, 0), require_vec3.wasmIndex(pt, 1), require_vec3.wasmIndex(pt, 2));
-		return [require_vec3.wasmIndex(uv, 0), require_vec3.wasmIndex(uv, 1)];
+		const uv = bk.projectPointOnSurface(fid, require_bug.wasmIndex(pt, 0), require_bug.wasmIndex(pt, 1), require_bug.wasmIndex(pt, 2));
+		return [require_bug.wasmIndex(uv, 0), require_bug.wasmIndex(uv, 1)];
 	};
 	const uvSamples = tValues.map((t) => ({
 		t,
@@ -9213,9 +9213,9 @@ function extractCurve2dFromEdge(bk, edge, face) {
 	if (uvPoints.length >= 2) return makeBSpline2d(uvPoints);
 	const verts = bk.getEdgeVertices(eid);
 	if (verts.length >= 6) {
-		const uv1 = bk.projectPointOnSurface(fid, require_vec3.wasmIndex(verts, 0), require_vec3.wasmIndex(verts, 1), require_vec3.wasmIndex(verts, 2));
-		const uv2 = bk.projectPointOnSurface(fid, require_vec3.wasmIndex(verts, 3), require_vec3.wasmIndex(verts, 4), require_vec3.wasmIndex(verts, 5));
-		return require_occtWasmAdapter.makeLine2d(require_vec3.wasmIndex(uv1, 0), require_vec3.wasmIndex(uv1, 1), require_vec3.wasmIndex(uv2, 0), require_vec3.wasmIndex(uv2, 1));
+		const uv1 = bk.projectPointOnSurface(fid, require_bug.wasmIndex(verts, 0), require_bug.wasmIndex(verts, 1), require_bug.wasmIndex(verts, 2));
+		const uv2 = bk.projectPointOnSurface(fid, require_bug.wasmIndex(verts, 3), require_bug.wasmIndex(verts, 4), require_bug.wasmIndex(verts, 5));
+		return require_occtWasmAdapter.makeLine2d(require_bug.wasmIndex(uv1, 0), require_bug.wasmIndex(uv1, 1), require_bug.wasmIndex(uv2, 0), require_bug.wasmIndex(uv2, 1));
 	}
 	throw new Error(`brepkit: extractCurve2dFromEdge: degenerate edge (${verts.length} coords)`);
 }
@@ -9231,14 +9231,14 @@ function fillSurface(bk, wires, _options) {
 			for (const edge of wireEdges) {
 				const edgeId = unwrap$1(edge, "edge");
 				const params = bk.getEdgeCurveParameters(edgeId);
-				const tMin = require_vec3.wasmIndex(params, 0);
-				const tMax = require_vec3.wasmIndex(params, 1);
+				const tMin = require_bug.wasmIndex(params, 0);
+				const tMax = require_bug.wasmIndex(params, 1);
 				const N = 10;
 				const pts = [];
 				for (let i = 0; i <= N; i++) {
 					const t = tMin + (tMax - tMin) * i / N;
 					const p = bk.evaluateEdgeCurve(edgeId, t);
-					pts.push(require_vec3.wasmIndex(p, 0), require_vec3.wasmIndex(p, 1), require_vec3.wasmIndex(p, 2));
+					pts.push(require_bug.wasmIndex(p, 0), require_bug.wasmIndex(p, 1), require_bug.wasmIndex(p, 2));
 				}
 				allCoords.push(...pts);
 				curveLengths.push(11);
@@ -9367,14 +9367,14 @@ function length(bk, shape) {
 function edgeMidpoint(bk, edgeId) {
 	const v = bk.getEdgeVertices(edgeId);
 	return [
-		(require_vec3.wasmIndex(v, 0) + require_vec3.wasmIndex(v, 3)) / 2,
-		(require_vec3.wasmIndex(v, 1) + require_vec3.wasmIndex(v, 4)) / 2,
-		(require_vec3.wasmIndex(v, 2) + require_vec3.wasmIndex(v, 5)) / 2
+		(require_bug.wasmIndex(v, 0) + require_bug.wasmIndex(v, 3)) / 2,
+		(require_bug.wasmIndex(v, 1) + require_bug.wasmIndex(v, 4)) / 2,
+		(require_bug.wasmIndex(v, 2) + require_bug.wasmIndex(v, 5)) / 2
 	];
 }
 function centerOfMass$1(bk, shape) {
 	const h = shape;
-	if (h.type === "solid") return require_vec3.vec3At(bk.centerOfMass(unwrap$1(shape), DEFAULT_DEFLECTION));
+	if (h.type === "solid") return require_bug.vec3At(bk.centerOfMass(unwrap$1(shape), DEFAULT_DEFLECTION));
 	if (h.type === "face") {
 		const domain = uvBounds(bk, shape);
 		return pointOnSurface(bk, shape, (domain.uMin + domain.uMax) / 2, (domain.vMin + domain.vMax) / 2);
@@ -9412,8 +9412,8 @@ function boundingBox$1(bk, shape) {
 	if (h.type === "solid") {
 		const bb = bk.boundingBox(unwrap$1(shape));
 		return {
-			min: require_vec3.vec3At(bb, 0),
-			max: require_vec3.vec3At(bb, 3)
+			min: require_bug.vec3At(bb, 0),
+			max: require_bug.vec3At(bb, 3)
 		};
 	}
 	if (h.type === "vertex") {
@@ -9467,28 +9467,28 @@ function distance$1(bk, shape1, shape2) {
 	if (h1.type === "solid" && h2.type === "solid") {
 		const buf = bk.solidToSolidDistance(h1.id, h2.id);
 		return {
-			value: require_vec3.wasmIndex(buf, 0),
-			point1: require_vec3.vec3At(buf, 1),
-			point2: require_vec3.vec3At(buf, 4)
+			value: require_bug.wasmIndex(buf, 0),
+			point1: require_bug.vec3At(buf, 1),
+			point2: require_bug.vec3At(buf, 4)
 		};
 	}
 	if (h1.type === "vertex" && (h2.type === "solid" || h2.type === "face" || h2.type === "edge")) {
-		const point1 = require_vec3.vec3At(bk.getVertexPosition(h1.id));
+		const point1 = require_bug.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);
 		return {
-			value: require_vec3.wasmIndex(result, 0),
+			value: require_bug.wasmIndex(result, 0),
 			point1,
-			point2: require_vec3.vec3At(result, 1)
+			point2: require_bug.vec3At(result, 1)
 		};
 	}
 	const getPos = (s) => {
-		if (s.type === "vertex") return require_vec3.vec3At(bk.getVertexPosition(s.id));
+		if (s.type === "vertex") return require_bug.vec3At(bk.getVertexPosition(s.id));
 		if (s.type === "solid") {
 			const bb = bk.boundingBox(s.id);
 			return [
-				(require_vec3.wasmIndex(bb, 0) + require_vec3.wasmIndex(bb, 3)) / 2,
-				(require_vec3.wasmIndex(bb, 1) + require_vec3.wasmIndex(bb, 4)) / 2,
-				(require_vec3.wasmIndex(bb, 2) + require_vec3.wasmIndex(bb, 5)) / 2
+				(require_bug.wasmIndex(bb, 0) + require_bug.wasmIndex(bb, 3)) / 2,
+				(require_bug.wasmIndex(bb, 1) + require_bug.wasmIndex(bb, 4)) / 2,
+				(require_bug.wasmIndex(bb, 2) + require_bug.wasmIndex(bb, 5)) / 2
 			];
 		}
 		return [
@@ -9512,15 +9512,15 @@ function surfaceCurvature$1(bk, face, u, v) {
 	const fid = unwrap$1(face, "face");
 	const data = bk.measureCurvatureAtSurface(fid, u, v);
 	if (data.length < 8) throw new Error(`brepkit: measureCurvatureAtSurface returned ${data.length} values, expected 8`);
-	const k1 = require_vec3.wasmIndex(data, 0);
-	const k2 = require_vec3.wasmIndex(data, 1);
+	const k1 = require_bug.wasmIndex(data, 0);
+	const k2 = require_bug.wasmIndex(data, 1);
 	return {
 		gaussian: k1 * k2,
 		mean: (k1 + k2) / 2,
 		max: Math.max(k1, k2),
 		min: Math.min(k1, k2),
-		maxDirection: require_vec3.vec3At(data, 2),
-		minDirection: require_vec3.vec3At(data, 5)
+		maxDirection: require_bug.vec3At(data, 2),
+		minDirection: require_bug.vec3At(data, 5)
 	};
 }
 function surfaceCenterOfMass(bk, face) {
@@ -9529,18 +9529,18 @@ function surfaceCenterOfMass(bk, face) {
 	const idx = mesh.indices;
 	let cx = 0, cy = 0, cz = 0, totalArea = 0;
 	for (let t = 0; t < idx.length; t += 3) {
-		const i0 = require_vec3.wasmIndex(idx, t) * 3;
-		const i1 = require_vec3.wasmIndex(idx, t + 1) * 3;
-		const i2 = require_vec3.wasmIndex(idx, t + 2) * 3;
-		const p0x = require_vec3.wasmIndex(pos, i0);
-		const p0y = require_vec3.wasmIndex(pos, i0 + 1);
-		const p0z = require_vec3.wasmIndex(pos, i0 + 2);
-		const p1x = require_vec3.wasmIndex(pos, i1);
-		const p1y = require_vec3.wasmIndex(pos, i1 + 1);
-		const p1z = require_vec3.wasmIndex(pos, i1 + 2);
-		const p2x = require_vec3.wasmIndex(pos, i2);
-		const p2y = require_vec3.wasmIndex(pos, i2 + 1);
-		const p2z = require_vec3.wasmIndex(pos, i2 + 2);
+		const i0 = require_bug.wasmIndex(idx, t) * 3;
+		const i1 = require_bug.wasmIndex(idx, t + 1) * 3;
+		const i2 = require_bug.wasmIndex(idx, t + 2) * 3;
+		const p0x = require_bug.wasmIndex(pos, i0);
+		const p0y = require_bug.wasmIndex(pos, i0 + 1);
+		const p0z = require_bug.wasmIndex(pos, i0 + 2);
+		const p1x = require_bug.wasmIndex(pos, i1);
+		const p1y = require_bug.wasmIndex(pos, i1 + 1);
+		const p1z = require_bug.wasmIndex(pos, i1 + 2);
+		const p2x = require_bug.wasmIndex(pos, i2);
+		const p2y = require_bug.wasmIndex(pos, i2 + 1);
+		const p2z = require_bug.wasmIndex(pos, i2 + 2);
 		const tcx = (p0x + p1x + p2x) / 3;
 		const tcy = (p0y + p1y + p2y) / 3;
 		const tcz = (p0z + p1z + p2z) / 3;
@@ -10031,7 +10031,7 @@ function resolveOcct() {
 }
 function occtOrThrow(method) {
 	const occt = resolveOcct();
-	if (!occt) throw new Error(`manifold: ${method} requires a registered occt kernel; none is available`);
+	if (!occt) throw new require_occtWasmAdapter.UnsupportedKernelOperationError(`manifold: ${method} requires a registered occt kernel; none is available`);
 	return occt;
 }
 var brepCache = /* @__PURE__ */ new WeakMap();
@@ -13189,7 +13189,7 @@ function measureBulk(shape, _includeLinear = false) {
 }
 function surfaceCurvature(face, u, v) {
 	const occt = resolveOcct();
-	if (!occt) throw new Error("manifold: surfaceCurvature requires a registered occt kernel; none is available");
+	if (!occt) throw new require_occtWasmAdapter.UnsupportedKernelOperationError("manifold: surfaceCurvature requires a registered occt kernel; none is available");
 	const ms = asManifoldShape(face);
 	if (!ms) return occt.surfaceCurvature(face, u, v);
 	if (!ms.node.replayable) throw new Error("manifold: surfaceCurvature unsupported; shape originates from a non-replayable op (raw mesh import or mesh boolean)");
@@ -14358,13 +14358,13 @@ function viaOcct(shape, query) {
 	const witness = shape;
 	if (witness && witness.__manifoldSub && witness.occt) {
 		const occt = resolveOcct();
-		if (!occt) throw new Error("manifold: sub-shape geometry query requires a registered occt kernel");
+		if (!occt) throw new require_occtWasmAdapter.UnsupportedKernelOperationError("manifold: sub-shape geometry query requires a registered occt kernel");
 		return query(witness.occt, occt);
 	}
 	const ms = asManifoldShape(shape);
 	if (!ms) throw new Error("manifold: exact geometry query requires a manifold shape handle");
 	const occt = resolveOcct();
-	if (!occt) throw new Error("manifold: exact geometry query unsupported on manifold kernel; no B-rep kernel registered");
+	if (!occt) throw new require_occtWasmAdapter.UnsupportedKernelOperationError("manifold: exact geometry query unsupported on manifold kernel; no B-rep kernel registered");
 	if (!ms.node.replayable) throw new Error("manifold: exact geometry query unsupported; shape originates from a non-replayable op (raw mesh import or mesh boolean)");
 	let occtShape = brepCache.get(ms.node);
 	if (occtShape === void 0) {