brepjs 18.6.0 → 18.6.1

package/dist/{shapeTypes-C0MDggKf.cjs → shapeTypes-8vB31RfA.cjs}

@@ -1,5 +1,6 @@
-const require_occtWasmAdapter = require("./occtWasmAdapter-CuZRRioz.cjs");
-const require_errors = require("./errors-CXRNVCec.cjs");
+const require_vec3 = require("./vec3-S4Oh59IX.cjs");
+const require_occtWasmAdapter = require("./occtWasmAdapter-C2VW-uYg.cjs");
+const require_errors = require("./errors-Dv6pfNct.cjs");
 //#region src/kernel/kernel2dTypes.ts
 /** Check if the kernel supports 2D geometry operations. */
 function supportsKernel2D(kernel) {
@@ -812,7 +813,7 @@ function fuseAllNative(oc, shapes, options = {}) {
 function fuseAllPairwiseRange(oc, shapes, start, end, options) {
 	options.signal?.throwIfAborted();
 	const count = end - start;
-	if (count === 1) return shapes[start];
+	if (count === 1) return require_vec3.wasmIndex(shapes, start);
 	if (count === 2) return fuse$1(oc, shapes[start], shapes[start + 1], {
 		...options,
 		simplify: false
@@ -842,7 +843,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 shapes[0];
+	if (shapes.length === 1) return require_vec3.wasmIndex(shapes, 0);
 	const { strategy = "native" } = options;
 	if (strategy === "pairwise") return fuseAllPairwise(oc, shapes, options);
 	return fuseAllNative(oc, shapes, options);
@@ -2841,7 +2842,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 = points[i];
+		const p = require_vec3.wasmIndex(points, i);
 		const pnt = new oc.gp_Pnt_3(p[0], p[1], p[2]);
 		arr.SetValue_1(i + 1, pnt);
 		pnt.delete();
@@ -3430,7 +3431,7 @@ function createAffinityGTrsf2d$1(ox, oy, dx, dy, ratio) {
 		0,
 		1
 	];
-	return _gtrsf$1(m, ox - m[0] * ox - m[1] * oy, oy - m[3] * ox - m[4] * oy);
+	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);
 }
 function createTranslationGTrsf2d$1(dx, dy) {
 	return _gtrsf$1([
@@ -3461,7 +3462,7 @@ function createMirrorGTrsf2d$1(cx, cy, mode, ox, oy, dx, dy) {
 			1
 		];
 		const apx = ox ?? cx, apy = oy ?? cy;
-		return _gtrsf$1(m, apx - m[0] * apx - m[1] * apy, apy - m[3] * apx - m[4] * apy);
+		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([
 		-1,
@@ -3508,21 +3509,23 @@ 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);
 	base.m = [
-		a[0] * b[0] + a[1] * b[3] + a[2] * b[6],
-		a[0] * b[1] + a[1] * b[4] + a[2] * b[7],
-		a[0] * b[2] + a[1] * b[5] + a[2] * b[8],
-		a[3] * b[0] + a[4] * b[3] + a[5] * b[6],
-		a[3] * b[1] + a[4] * b[4] + a[5] * b[7],
-		a[3] * b[2] + a[4] * b[5] + a[5] * b[8],
-		a[6] * b[0] + a[7] * b[3] + a[8] * b[6],
-		a[6] * b[1] + a[7] * b[4] + a[8] * b[7],
-		a[6] * b[2] + a[7] * b[5] + a[8] * b[8]
+		ai(0) * bi(0) + ai(1) * bi(3) + ai(2) * bi(6),
+		ai(0) * bi(1) + ai(1) * bi(4) + ai(2) * bi(7),
+		ai(0) * bi(2) + ai(1) * bi(5) + ai(2) * bi(8),
+		ai(3) * bi(0) + ai(4) * bi(3) + ai(5) * bi(6),
+		ai(3) * bi(1) + ai(4) * bi(4) + ai(5) * bi(7),
+		ai(3) * bi(2) + ai(4) * bi(5) + ai(5) * bi(8),
+		ai(6) * bi(0) + ai(7) * bi(3) + ai(8) * bi(6),
+		ai(6) * bi(1) + ai(7) * bi(4) + ai(8) * bi(7),
+		ai(6) * bi(2) + ai(7) * bi(5) + ai(8) * bi(8)
 	];
 	const oldTx = base.tx, oldTy = base.ty;
 	const otx = Number(other.tx) || 0, oty = Number(other.ty) || 0;
-	base.tx = a[0] * otx + a[1] * oty + oldTx;
-	base.ty = a[3] * otx + a[4] * oty + oldTy;
+	base.tx = ai(0) * otx + ai(1) * oty + oldTx;
+	base.ty = ai(3) * otx + ai(4) * oty + oldTy;
 }
 function transformCurve2dGeneral$1(curve, gtrsf) {
 	const c = c2d$1(curve);
@@ -3538,14 +3541,15 @@ function transformCurve2dGeneral$1(curve, gtrsf) {
 		1
 	];
 	const tx = Number(gtrsf.tx) || 0, ty = Number(gtrsf.ty) || 0;
-	if (Math.abs(m[0] - 1) < 1e-12 && Math.abs(m[4] - 1) < 1e-12 && Math.abs(m[1]) < 1e-12 && Math.abs(m[3]) < 1e-12) return require_occtWasmAdapter.translateCurve2d(c, tx, ty);
+	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);
+	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;
 	const pts = [];
 	for (let i = 0; i <= N; i++) {
 		const t = bounds.first + (bounds.last - bounds.first) * i / N;
 		const [px, py] = require_occtWasmAdapter.evaluateCurve2d(c, t);
-		pts.push([m[0] * px + m[1] * py + tx, m[3] * px + m[4] * py + ty]);
+		pts.push([m0 * px + m1 * py + tx, m3 * px + m4 * py + ty]);
 	}
 	return require_occtWasmAdapter.makeBezier2d(pts);
 }
@@ -3679,8 +3683,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 = poles[i];
-			const p1 = poles[i + 1];
+			const p0 = require_vec3.wasmIndex(poles, i);
+			const p1 = require_vec3.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);
@@ -3706,8 +3710,8 @@ function decomposeBSpline2dToBeziers$1(curve) {
 	];
 	const result = [];
 	for (let i = 0; i < breakpoints.length - 1; i++) {
-		const t0 = breakpoints[i];
-		const t1 = breakpoints[i + 1];
+		const t0 = require_vec3.wasmIndex(breakpoints, i);
+		const t1 = require_vec3.wasmIndex(breakpoints, i + 1);
 		const span = t1 - t0;
 		if (span < 1e-15) continue;
 		const p0 = require_occtWasmAdapter.evaluateCurve2d(c, t0);
@@ -3854,7 +3858,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 = points[i];
+		const p = require_vec3.wasmIndex(points, i);
 		reusePnt.SetCoord_2(p[0], p[1], p[2]);
 		pnts.SetValue_1(i + 1, reusePnt);
 	}
@@ -3920,7 +3924,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, pts3d[0], pts3d[1]);
+		if (pts3d.length === 2) return makeLineEdge3d(oc, require_vec3.wasmIndex(pts3d, 0), require_vec3.wasmIndex(pts3d, 1));
 		return interpolatePoints3d(oc, pts3d);
 	}
 	const bounds = require_occtWasmAdapter.curveBounds(c);
@@ -4465,7 +4469,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 = points[r * cols + c];
+		const pt = require_vec3.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();
@@ -4487,10 +4491,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 = points[i00];
-		const p10 = points[i10];
-		const p01 = points[i01];
-		const p11 = points[i11];
+		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 face1 = makeTriFace(oc, p00, p10, p01);
 		sewing.Add(face1);
 		const face2 = makeTriFace(oc, p10, p11, p01);
@@ -6165,18 +6169,19 @@ function scaleMatrix(center, factor) {
 }
 /** Build a row-major 4x4 matrix from a 3x3 linear part + translation. */
 function affineMatrix(linear, translation) {
+	const li = (i) => require_vec3.wasmIndex(linear, i);
 	return [
-		linear[0],
-		linear[1],
-		linear[2],
+		li(0),
+		li(1),
+		li(2),
 		translation[0],
-		linear[3],
-		linear[4],
-		linear[5],
+		li(3),
+		li(4),
+		li(5),
 		translation[1],
-		linear[6],
-		linear[7],
-		linear[8],
+		li(6),
+		li(7),
+		li(8),
 		translation[2],
 		0,
 		0,
@@ -6311,13 +6316,13 @@ function iterShapes(bk, shape, type) {
 				for (const eid of edgeIds) {
 					const verts = bk.getEdgeVertices(eid);
 					const coords = [[
-						verts[0],
-						verts[1],
-						verts[2]
+						require_vec3.wasmIndex(verts, 0),
+						require_vec3.wasmIndex(verts, 1),
+						require_vec3.wasmIndex(verts, 2)
 					], [
-						verts[3],
-						verts[4],
-						verts[5]
+						require_vec3.wasmIndex(verts, 3),
+						require_vec3.wasmIndex(verts, 4),
+						require_vec3.wasmIndex(verts, 5)
 					]];
 					for (const [x, y, z] of coords) {
 						const key = `${x},${y},${z}`;
@@ -6334,8 +6339,8 @@ function iterShapes(bk, shape, type) {
 			if (type === "edge") return [shape];
 			if (type === "vertex") {
 				const verts = bk.getEdgeVertices(h);
-				const v1 = bk.makeVertex(verts[0], verts[1], verts[2]);
-				const v2 = bk.makeVertex(verts[3], verts[4], verts[5]);
+				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));
 				return [vertexHandle(v1), vertexHandle(v2)];
 			}
 			return [];
@@ -6402,12 +6407,7 @@ function sew(bk, shapes, tolerance) {
 //#endregion
 //#region src/kernel/brepkit/geometryOps.ts
 function vertexPosition(bk, vertex) {
-	const pos = bk.getVertexPosition(unwrap(vertex, "vertex"));
-	return [
-		pos[0],
-		pos[1],
-		pos[2]
-	];
+	return require_vec3.vec3At(bk.getVertexPosition(unwrap(vertex, "vertex")));
 }
 function surfaceType(bk, face) {
 	return bk.getSurfaceType(unwrap(face, "face"));
@@ -6415,47 +6415,32 @@ function surfaceType(bk, face) {
 function uvBounds(bk, face) {
 	const domain = bk.getSurfaceDomain(unwrap(face, "face"));
 	return {
-		uMin: domain[0],
-		uMax: domain[1],
-		vMin: domain[2],
-		vMax: domain[3]
+		uMin: require_vec3.wasmIndex(domain, 0),
+		uMax: require_vec3.wasmIndex(domain, 1),
+		vMin: require_vec3.wasmIndex(domain, 2),
+		vMax: require_vec3.wasmIndex(domain, 3)
 	};
 }
 function outerWire(bk, face) {
 	return wireHandle(bk.getFaceOuterWire(unwrap(face, "face")));
 }
 function surfaceNormal(bk, face, u, v) {
-	const n = bk.evaluateSurfaceNormal(unwrap(face, "face"), u, v);
-	return [
-		n[0],
-		n[1],
-		n[2]
-	];
+	return require_vec3.vec3At(bk.evaluateSurfaceNormal(unwrap(face, "face"), u, v));
 }
 function pointOnSurface(bk, face, u, v) {
-	const p = bk.evaluateSurface(unwrap(face, "face"), u, v);
-	return [
-		p[0],
-		p[1],
-		p[2]
-	];
+	return require_vec3.vec3At(bk.evaluateSurface(unwrap(face, "face"), u, v));
 }
 function uvFromPoint(bk, face, point) {
 	try {
 		const result = bk.projectPointOnSurface(unwrap(face, "face"), point[0], point[1], point[2]);
-		return [result[0], result[1]];
+		return [require_vec3.wasmIndex(result, 0), require_vec3.wasmIndex(result, 1)];
 	} catch (e) {
 		console.warn("brepkit: uvFromPoint failed:", e);
 		return null;
 	}
 }
 function projectPointOnFace(bk, face, point) {
-	const result = bk.projectPointOnSurface(unwrap(face, "face"), point[0], point[1], point[2]);
-	return [
-		result[2],
-		result[3],
-		result[4]
-	];
+	return require_vec3.vec3At(bk.projectPointOnSurface(unwrap(face, "face"), point[0], point[1], point[2]), 2);
 }
 function curveTangent(bk, shape, param) {
 	const h = shape;
@@ -6463,14 +6448,14 @@ function curveTangent(bk, shape, param) {
 	let evalParam = param;
 	if (h.type === "wire") {
 		const edgeIds = toArray(bk.getWireEdges(h.id));
-		edgeId = edgeIds[edgeIds.length - 1];
+		edgeId = require_vec3.wasmIndex(edgeIds, edgeIds.length - 1);
 		let cumulative = 0;
 		for (const eid of edgeIds) {
 			const p = bk.getEdgeCurveParameters(eid);
-			const span = p[1] - p[0];
+			const span = require_vec3.wasmIndex(p, 1) - require_vec3.wasmIndex(p, 0);
 			if (param <= cumulative + span || eid === edgeId) {
 				edgeId = eid;
-				evalParam = Math.min(p[0] + (param - cumulative), p[1]);
+				evalParam = Math.min(require_vec3.wasmIndex(p, 0) + (param - cumulative), require_vec3.wasmIndex(p, 1));
 				break;
 			}
 			cumulative += span;
@@ -6478,16 +6463,8 @@ function curveTangent(bk, shape, param) {
 	} else edgeId = unwrap(shape, "edge");
 	const result = bk.evaluateEdgeCurveD1(edgeId, evalParam);
 	return {
-		point: [
-			result[0],
-			result[1],
-			result[2]
-		],
-		tangent: [
-			result[3],
-			result[4],
-			result[5]
-		]
+		point: require_vec3.vec3At(result, 0),
+		tangent: require_vec3.vec3At(result, 3)
 	};
 }
 function curveParameters(bk, shape) {
@@ -6498,13 +6475,12 @@ function curveParameters(bk, shape) {
 		let total = 0;
 		for (const eid of edgeIds) {
 			const p = bk.getEdgeCurveParameters(eid);
-			total += p[1] - p[0];
+			total += require_vec3.wasmIndex(p, 1) - require_vec3.wasmIndex(p, 0);
 		}
 		return [0, total];
 	}
-	const edgeId = unwrap(shape, "edge");
-	const params = bk.getEdgeCurveParameters(edgeId);
-	return [params[0], params[1]];
+	const params = bk.getEdgeCurveParameters(unwrap(shape, "edge"));
+	return [require_vec3.wasmIndex(params, 0), require_vec3.wasmIndex(params, 1)];
 }
 function curvePointAtParam(bk, shape, param) {
 	const h = shape;
@@ -6513,55 +6489,28 @@ function curvePointAtParam(bk, shape, param) {
 		let cumulative = 0;
 		for (const eid of edgeIds) {
 			const p = bk.getEdgeCurveParameters(eid);
-			const span = p[1] - p[0];
+			const span = require_vec3.wasmIndex(p, 1) - require_vec3.wasmIndex(p, 0);
 			if (param <= cumulative + span || eid === edgeIds[edgeIds.length - 1]) {
-				const localParam = p[0] + (param - cumulative);
-				const pt = bk.evaluateEdgeCurve(eid, Math.min(localParam, p[1]));
-				return [
-					pt[0],
-					pt[1],
-					pt[2]
-				];
+				const localParam = require_vec3.wasmIndex(p, 0) + (param - cumulative);
+				return require_vec3.vec3At(bk.evaluateEdgeCurve(eid, Math.min(localParam, require_vec3.wasmIndex(p, 1))));
 			}
 			cumulative += span;
 		}
-		const pt = bk.evaluateEdgeCurve(edgeIds[0], param);
-		return [
-			pt[0],
-			pt[1],
-			pt[2]
-		];
+		return require_vec3.vec3At(bk.evaluateEdgeCurve(require_vec3.wasmIndex(edgeIds, 0), param));
 	}
-	const edgeId = unwrap(shape, "edge");
-	const p = bk.evaluateEdgeCurve(edgeId, param);
-	return [
-		p[0],
-		p[1],
-		p[2]
-	];
+	return require_vec3.vec3At(bk.evaluateEdgeCurve(unwrap(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) {
-			const verts = bk.getEdgeVertices(edgeIds[0]);
-			return dist3(verts[0], verts[1], verts[2], verts[3], verts[4], verts[5]) < 1e-7;
-		}
+		if (edgeIds.length === 1) return edgeIsClosed(bk.getEdgeVertices(require_vec3.wasmIndex(edgeIds, 0)));
 		const endpoints = [];
 		for (const eid of edgeIds) {
 			const verts = bk.getEdgeVertices(eid);
-			endpoints.push([
-				verts[0],
-				verts[1],
-				verts[2]
-			]);
-			endpoints.push([
-				verts[3],
-				verts[4],
-				verts[5]
-			]);
+			endpoints.push(require_vec3.vec3At(verts, 0));
+			endpoints.push(require_vec3.vec3At(verts, 3));
 		}
 		const unmatched = [];
 		for (const pt of endpoints) {
@@ -6571,8 +6520,10 @@ function curveIsClosed(bk, shape) {
 		}
 		return unmatched.length === 0;
 	}
-	const verts = bk.getEdgeVertices(unwrap(shape, "edge"));
-	return dist3(verts[0], verts[1], verts[2], verts[3], verts[4], verts[5]) < 1e-7;
+	return edgeIsClosed(bk.getEdgeVertices(unwrap(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;
 }
 function curveIsPeriodic(bk, shape) {
 	const h = shape;
@@ -6616,7 +6567,7 @@ function curveKnotRemove(bk, edge, knot, tolerance) {
 function curveSplit(bk, edge, param) {
 	const edgeId = unwrap(edge, "edge");
 	const result = bk.curveSplit(edgeId, param);
-	return [edgeHandle(result[0]), edgeHandle(result[1])];
+	return [edgeHandle(require_vec3.wasmIndex(result, 0)), edgeHandle(require_vec3.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));
@@ -6631,12 +6582,7 @@ function createCurveAdaptor(_bk, shape) {
 function getBezierPenultimatePole(bk, edge) {
 	const nurbsData = extractNurbsFromEdge(bk, edge);
 	if (!nurbsData || nurbsData.controlPoints.length < 6) return null;
-	const n = nurbsData.controlPoints.length;
-	return [
-		nurbsData.controlPoints[n - 6],
-		nurbsData.controlPoints[n - 5],
-		nurbsData.controlPoints[n - 4]
-	];
+	return require_vec3.vec3At(nurbsData.controlPoints, nurbsData.controlPoints.length - 6);
 }
 function getSurfaceCylinderData(bk, surface) {
 	if (isBrepkitHandle(surface) && surface.type === "face") {
@@ -6656,7 +6602,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(face, "face");
 	const domain = bk.getSurfaceDomain(faceId);
-	if (u < domain[0] || u > domain[1] || v < domain[2] || v > domain[3]) return "out";
+	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";
 	return "in";
 }
 function classifyPointRobust(bk, shape, point, tolerance) {
@@ -6849,19 +6795,10 @@ function extractPlaneFromFace(bk, faceShape) {
 		}
 		faceId = bestId;
 	} else faceId = unwrap(faceShape, "face");
-	const n = bk.getFaceNormal(faceId);
-	const normal = [
-		n[0],
-		n[1],
-		n[2]
-	];
+	const normal = require_vec3.vec3At(bk.getFaceNormal(faceId));
 	const positions = bk.tessellateFace(faceId, 1).positions;
 	if (positions.length >= 3) return {
-		point: [
-			positions[0],
-			positions[1],
-			positions[2]
-		],
+		point: require_vec3.vec3At(positions),
 		normal
 	};
 	return {
@@ -6901,27 +6838,17 @@ function extractNurbsFromEdge(bk, shape) {
 			1
 		],
 		controlPoints: [
-			verts[0],
-			verts[1],
-			verts[2],
-			verts[3],
-			verts[4],
-			verts[5]
+			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)
 		],
 		weights: [1, 1]
 	};
 }
 //#endregion
-//#region src/utils/vec3.ts
-/**
-* Index into a typed/regular array at a position the caller has structurally
-* guaranteed (WASM ABI fixed-length arrays, post-bounds-check loops, etc.).
-* Equivalent to `arr[i]!` but typed as `T` directly — no eslint-disable needed.
-*/
-function wasmIndex(arr, i) {
-	return arr[i];
-}
-//#endregion
 //#region src/kernel/brepkit/constructionOps.ts
 function makeVertex(bk, x, y, z) {
 	return vertexHandle(bk.makeVertex(x, y, z));
@@ -7091,8 +7018,8 @@ function makeBezierEdge(bk, points) {
 		y,
 		z
 	]);
-	const startPt = wasmIndex(points, 0);
-	const endPt = wasmIndex(points, n - 1);
+	const startPt = require_vec3.wasmIndex(points, 0);
+	const endPt = require_vec3.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) {
@@ -7186,9 +7113,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, wasmIndex(points, i00), wasmIndex(points, i10), wasmIndex(points, i01));
+		const f1 = buildTriFace(bk, require_vec3.wasmIndex(points, i00), require_vec3.wasmIndex(points, i10), require_vec3.wasmIndex(points, i01));
 		if (f1) faces.push(f1);
-		const f2 = buildTriFace(bk, wasmIndex(points, i10), wasmIndex(points, i11), wasmIndex(points, i01));
+		const f2 = buildTriFace(bk, require_vec3.wasmIndex(points, i10), require_vec3.wasmIndex(points, i11), require_vec3.wasmIndex(points, i01));
 		if (f2) faces.push(f2);
 	}
 	if (faces.length === 0) throw new Error("brepkit: no valid faces in surface grid");
@@ -7219,7 +7146,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, wasmIndex(points, 0), wasmIndex(points, 1));
+	if (points.length === 2) return makeLineEdge(bk, require_vec3.wasmIndex(points, 0), require_vec3.wasmIndex(points, 1));
 	const degree = Math.min(3, points.length - 1);
 	const coords = points.flatMap(([x, y, z]) => [
 		x,
@@ -7371,14 +7298,14 @@ function makeCircleNurbs(bk, center, normal, radius, startAngle, endAngle) {
 	const knots = Array(degree + 1).fill(0);
 	for (let i = 1; i < nSegments; i++) knots.push(i, i);
 	knots.push(...Array(degree + 1).fill(nSegments));
-	const kMax = wasmIndex(knots, knots.length - 1);
-	for (let i = 0; i < knots.length; i++) knots[i] = wasmIndex(knots, i) / kMax;
-	const sx = wasmIndex(controlPoints, 0);
-	const sy = wasmIndex(controlPoints, 1);
-	const sz = wasmIndex(controlPoints, 2);
-	const ex = wasmIndex(controlPoints, controlPoints.length - 3);
-	const ey = wasmIndex(controlPoints, controlPoints.length - 2);
-	const ez = wasmIndex(controlPoints, controlPoints.length - 1);
+	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);
 	return edgeHandle(bk.makeNurbsEdge(sx, sy, sz, ex, ey, ez, degree, knots, controlPoints, weights));
 }
 function makeEllipseNurbs(bk, center, normal, majorRadius, minorRadius, startAngle, endAngle, xDir) {
@@ -7452,14 +7379,14 @@ function makeEllipseNurbs(bk, center, normal, majorRadius, minorRadius, startAng
 	const knots = Array(degree + 1).fill(0);
 	for (let i = 1; i < nSegments; i++) knots.push(i, i);
 	knots.push(...Array(degree + 1).fill(nSegments));
-	const kMax = wasmIndex(knots, knots.length - 1);
-	for (let i = 0; i < knots.length; i++) knots[i] = wasmIndex(knots, i) / kMax;
-	const sx = wasmIndex(controlPoints, 0);
-	const sy = wasmIndex(controlPoints, 1);
-	const sz = wasmIndex(controlPoints, 2);
-	const ex = wasmIndex(controlPoints, controlPoints.length - 3);
-	const ey = wasmIndex(controlPoints, controlPoints.length - 2);
-	const ez = wasmIndex(controlPoints, controlPoints.length - 1);
+	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);
 	return edgeHandle(bk.makeNurbsEdge(sx, sy, sz, ex, ey, ez, degree, knots, controlPoints, weights));
 }
 //#endregion
@@ -7497,11 +7424,11 @@ function section(bk, shape, plane, _approximation) {
 	const solidId = isBrepkitHandle(shape) && shape.type === "solid" ? shape.id : unwrap(shape, "solid");
 	const faceIds = toArray(bk.section(solidId, point[0], point[1], point[2], normal[0], normal[1], normal[2]));
 	if (faceIds.length === 0) return compoundHandle(bk.makeCompound([]));
-	return wireHandle(bk.getFaceOuterWire(faceIds[0]));
+	return wireHandle(bk.getFaceOuterWire(require_vec3.wasmIndex(faceIds, 0)));
 }
 function fuseAll(bk, shapes, options) {
 	if (shapes.length === 0) throw new Error("brepkit: fuseAll requires at least one shape");
-	if (shapes.length === 1) return shapes[0];
+	if (shapes.length === 1) return require_vec3.wasmIndex(shapes, 0);
 	if (bk.compoundFuse) {
 		const solidIds = [];
 		for (const shape of shapes) {
@@ -7519,7 +7446,7 @@ function fuseAll(bk, shapes, options) {
 		else next.push(current[i]);
 		current = next;
 	}
-	return current[0];
+	return require_vec3.wasmIndex(current, 0);
 }
 function cutAll(bk, shape, tools, options) {
 	if (tools.length === 0) return shape;
@@ -7598,11 +7525,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(pos[0], pos[1], pos[2]);
+				coords.push(require_vec3.wasmIndex(pos, 0), require_vec3.wasmIndex(pos, 1), require_vec3.wasmIndex(pos, 2));
 			}
 		} else if (h.type === "vertex") {
 			const pos = bk.getVertexPosition(h.id);
-			coords.push(pos[0], pos[1], pos[2]);
+			coords.push(require_vec3.wasmIndex(pos, 0), require_vec3.wasmIndex(pos, 1), require_vec3.wasmIndex(pos, 2));
 		}
 	}
 	if (coords.length < 12) throw new Error("brepkit: hull requires enough points");
@@ -7617,14 +7544,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 = points[i];
+		const p = require_vec3.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 = faces[i];
+		const f = require_vec3.wasmIndex(faces, i);
 		indices[i * 3] = f[0];
 		indices[i * 3 + 1] = f[1];
 		indices[i * 3 + 2] = f[2];
@@ -7922,9 +7849,9 @@ function shell(bk, shape, faces, thickness, tolerance) {
 				let ox = 0, oy = 0, oz = 0;
 				for (const vid of origVerts) {
 					const pos = bk.getVertexPosition(vid);
-					ox += pos[0];
-					oy += pos[1];
-					oz += pos[2];
+					ox += require_vec3.wasmIndex(pos, 0);
+					oy += require_vec3.wasmIndex(pos, 1);
+					oz += require_vec3.wasmIndex(pos, 2);
 				}
 				const n = origVerts.length;
 				ox /= n;
@@ -7938,9 +7865,9 @@ function shell(bk, shape, faces, thickness, tolerance) {
 					let sx = 0, sy = 0, sz = 0;
 					for (const svid of sv) {
 						const spos = bk.getVertexPosition(svid);
-						sx += spos[0];
-						sy += spos[1];
-						sz += spos[2];
+						sx += require_vec3.wasmIndex(spos, 0);
+						sy += require_vec3.wasmIndex(spos, 1);
+						sz += require_vec3.wasmIndex(spos, 2);
 					}
 					const sn = sv.length;
 					sx /= sn;
@@ -7991,12 +7918,12 @@ function offsetWire2D(bk, wire, offsetVal, _joinType) {
 	const coords2d = [];
 	for (const edge of edges) {
 		const verts = bk.getEdgeVertices(unwrap(edge, "edge"));
-		coords2d.push(verts[0], verts[1]);
+		coords2d.push(require_vec3.wasmIndex(verts, 0), require_vec3.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(result[i], result[i + 1], 0);
+	for (let i = 0; i < result.length; i += 2) coords3d.push(require_vec3.wasmIndex(result, i), require_vec3.wasmIndex(result, i + 1), 0);
 	return wireHandle(bk.makePolygonWire(coords3d));
 }
 function simplify(bk, shape) {
@@ -8133,8 +8060,8 @@ function exportSTEP(bk, shapes) {
 }
 function exportSTL(bk, shape, binary) {
 	const solidIds = unwrapSolidsForExport(bk, shape, "exportSTL");
-	if (binary) return bk.exportStl(solidIds[0], DEFAULT_DEFLECTION).buffer;
-	const bytes = bk.exportStlAscii(solidIds[0], DEFAULT_DEFLECTION);
+	if (binary) return bk.exportStl(require_vec3.wasmIndex(solidIds, 0), DEFAULT_DEFLECTION).buffer;
+	const bytes = bk.exportStlAscii(require_vec3.wasmIndex(solidIds, 0), DEFAULT_DEFLECTION);
 	return new TextDecoder().decode(bytes);
 }
 function importSTEP(bk, data) {
@@ -8244,8 +8171,8 @@ function meshEdges(bk, shape, tolerance, angularTolerance) {
 	const edgeCount = edgeLines.edgeCount;
 	const edgeGroups = [];
 	for (let i = 0; i < edgeCount; i++) {
-		const startIdx = offsets[i];
-		const pointCount = ((i + 1 < edgeCount ? offsets[i + 1] : positions.length) - startIdx) / 3;
+		const startIdx = require_vec3.wasmIndex(offsets, i);
+		const pointCount = ((i + 1 < edgeCount ? require_vec3.wasmIndex(offsets, i + 1) : positions.length) - startIdx) / 3;
 		edgeGroups.push({
 			start: startIdx / 3,
 			count: pointCount,
@@ -8284,8 +8211,8 @@ function meshSolidGrouped(bk, solidId, deflection, includeUVs) {
 	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 = data.faceOffsets[i];
-		const count = data.faceOffsets[i + 1] - start;
+		const start = require_vec3.wasmIndex(data.faceOffsets, i);
+		const count = require_vec3.wasmIndex(data.faceOffsets, i + 1) - start;
 		if (count === 0) continue;
 		faceGroups.push({
 			start,
@@ -8404,28 +8331,22 @@ function length(bk, shape) {
 	if (h.type === "wire") return bk.wireLength(h.id);
 	throw new Error("brepkit: length() requires an edge, wire, or face");
 }
+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
+	];
+}
 function centerOfMass(bk, shape) {
 	const h = shape;
-	if (h.type === "solid") {
-		const result = bk.centerOfMass(unwrap(shape), DEFAULT_DEFLECTION);
-		return [
-			result[0],
-			result[1],
-			result[2]
-		];
-	}
+	if (h.type === "solid") return require_vec3.vec3At(bk.centerOfMass(unwrap(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);
 	}
-	if (h.type === "edge") {
-		const verts = bk.getEdgeVertices(h.id);
-		return [
-			(verts[0] + verts[3]) / 2,
-			(verts[1] + verts[4]) / 2,
-			(verts[2] + verts[5]) / 2
-		];
-	}
+	if (h.type === "edge") return edgeMidpoint(bk, h.id);
 	if (h.type === "vertex") return vertexPosition(bk, shape);
 	const vertices = iterShapes(bk, shape, "vertex");
 	if (vertices.length > 0) {
@@ -8450,14 +8371,7 @@ function centerOfMass(bk, shape) {
 }
 function linearCenterOfMass(bk, shape) {
 	const h = shape;
-	if (h.type === "edge") {
-		const verts = bk.getEdgeVertices(h.id);
-		return [
-			(verts[0] + verts[3]) / 2,
-			(verts[1] + verts[4]) / 2,
-			(verts[2] + verts[5]) / 2
-		];
-	}
+	if (h.type === "edge") return edgeMidpoint(bk, h.id);
 	return centerOfMass(bk, shape);
 }
 function boundingBox(bk, shape) {
@@ -8465,16 +8379,8 @@ function boundingBox(bk, shape) {
 	if (h.type === "solid") {
 		const bb = bk.boundingBox(unwrap(shape));
 		return {
-			min: [
-				bb[0],
-				bb[1],
-				bb[2]
-			],
-			max: [
-				bb[3],
-				bb[4],
-				bb[5]
-			]
+			min: require_vec3.vec3At(bb, 0),
+			max: require_vec3.vec3At(bb, 3)
 		};
 	}
 	if (h.type === "vertex") {
@@ -8528,85 +8434,28 @@ function distance(bk, shape1, shape2) {
 	if (h1.type === "solid" && h2.type === "solid") {
 		const buf = bk.solidToSolidDistance(h1.id, h2.id);
 		return {
-			value: buf[0],
-			point1: [
-				buf[1],
-				buf[2],
-				buf[3]
-			],
-			point2: [
-				buf[4],
-				buf[5],
-				buf[6]
-			]
-		};
-	}
-	if (h1.type === "vertex" && h2.type === "solid") {
-		const pos = bk.getVertexPosition(h1.id);
-		const result = bk.pointToSolidDistance(pos[0], pos[1], pos[2], h2.id);
-		return {
-			value: result[0],
-			point1: [
-				pos[0],
-				pos[1],
-				pos[2]
-			],
-			point2: [
-				result[1],
-				result[2],
-				result[3]
-			]
-		};
-	}
-	if (h1.type === "vertex" && h2.type === "face") {
-		const pos = bk.getVertexPosition(h1.id);
-		const result = bk.pointToFaceDistance(pos[0], pos[1], pos[2], h2.id);
-		return {
-			value: result[0],
-			point1: [
-				pos[0],
-				pos[1],
-				pos[2]
-			],
-			point2: [
-				result[1],
-				result[2],
-				result[3]
-			]
+			value: require_vec3.wasmIndex(buf, 0),
+			point1: require_vec3.vec3At(buf, 1),
+			point2: require_vec3.vec3At(buf, 4)
 		};
 	}
-	if (h1.type === "vertex" && h2.type === "edge") {
-		const pos = bk.getVertexPosition(h1.id);
-		const result = bk.pointToEdgeDistance(pos[0], pos[1], pos[2], h2.id);
+	if (h1.type === "vertex" && (h2.type === "solid" || h2.type === "face" || h2.type === "edge")) {
+		const point1 = require_vec3.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: result[0],
-			point1: [
-				pos[0],
-				pos[1],
-				pos[2]
-			],
-			point2: [
-				result[1],
-				result[2],
-				result[3]
-			]
+			value: require_vec3.wasmIndex(result, 0),
+			point1,
+			point2: require_vec3.vec3At(result, 1)
 		};
 	}
 	const getPos = (s) => {
-		if (s.type === "vertex") {
-			const p = bk.getVertexPosition(s.id);
-			return [
-				p[0],
-				p[1],
-				p[2]
-			];
-		}
+		if (s.type === "vertex") return require_vec3.vec3At(bk.getVertexPosition(s.id));
 		if (s.type === "solid") {
 			const bb = bk.boundingBox(s.id);
 			return [
-				(bb[0] + bb[3]) / 2,
-				(bb[1] + bb[4]) / 2,
-				(bb[2] + bb[5]) / 2
+				(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
 			];
 		}
 		return [
@@ -8630,23 +8479,15 @@ function surfaceCurvature(bk, face, u, v) {
 	const fid = unwrap(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 = data[0];
-	const k2 = data[1];
+	const k1 = require_vec3.wasmIndex(data, 0);
+	const k2 = require_vec3.wasmIndex(data, 1);
 	return {
 		gaussian: k1 * k2,
 		mean: (k1 + k2) / 2,
 		max: Math.max(k1, k2),
 		min: Math.min(k1, k2),
-		maxDirection: [
-			data[2],
-			data[3],
-			data[4]
-		],
-		minDirection: [
-			data[5],
-			data[6],
-			data[7]
-		]
+		maxDirection: require_vec3.vec3At(data, 2),
+		minDirection: require_vec3.vec3At(data, 5)
 	};
 }
 function surfaceCenterOfMass(bk, face) {
@@ -8655,12 +8496,23 @@ 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 = idx[t] * 3, i1 = idx[t + 1] * 3, i2 = idx[t + 2] * 3;
-		const tcx = (pos[i0] + pos[i1] + pos[i2]) / 3;
-		const tcy = (pos[i0 + 1] + pos[i1 + 1] + pos[i2 + 1]) / 3;
-		const tcz = (pos[i0 + 2] + pos[i1 + 2] + pos[i2 + 2]) / 3;
-		const ux = pos[i1] - pos[i0], uy = pos[i1 + 1] - pos[i0 + 1], uz = pos[i1 + 2] - pos[i0 + 2];
-		const vx = pos[i2] - pos[i0], vy = pos[i2 + 1] - pos[i0 + 1], vz = pos[i2 + 2] - pos[i0 + 2];
+		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 tcx = (p0x + p1x + p2x) / 3;
+		const tcy = (p0y + p1y + p2y) / 3;
+		const tcz = (p0z + p1z + p2z) / 3;
+		const ux = p1x - p0x, uy = p1y - p0y, uz = p1z - p0z;
+		const vx = p2x - p0x, vy = p2y - p0y, vz = p2z - p0z;
 		const faceArea = .5 * Math.sqrt((uy * vz - uz * vy) ** 2 + (uz * vx - ux * vz) ** 2 + (ux * vy - uy * vx) ** 2);
 		cx += tcx * faceArea;
 		cy += tcy * faceArea;
@@ -8748,9 +8600,9 @@ function faceCentroidById(bk, faceId) {
 		let cz = 0;
 		const nVerts = pos.length / 3;
 		for (let i = 0; i < pos.length; i += 3) {
-			cx += pos[i];
-			cy += pos[i + 1];
-			cz += pos[i + 2];
+			cx += require_vec3.wasmIndex(pos, i);
+			cy += require_vec3.wasmIndex(pos, i + 1);
+			cz += require_vec3.wasmIndex(pos, i + 2);
 		}
 		return [
 			cx / nVerts,
@@ -8776,7 +8628,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 = inputFaceIds[i];
+		const fid = require_vec3.wasmIndex(inputFaceIds, i);
 		try {
 			const normal = bk.getFaceNormal(fid);
 			const centroid = faceCentroidById(bk, fid);
@@ -8824,7 +8676,7 @@ function matchFacesGeometrically(bk, originalShape, inputFaceHashes, outputFaceI
 		let bestScore = -Infinity;
 		let bestIdx = -1;
 		for (let i = 0; i < inputSigs.length; i++) {
-			const inp = inputSigs[i];
+			const inp = require_vec3.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);
@@ -8836,7 +8688,7 @@ function matchFacesGeometrically(bk, originalShape, inputFaceHashes, outputFaceI
 			}
 		}
 		if (bestIdx >= 0) {
-			const bestInput = inputSigs[bestIdx];
+			const bestInput = require_vec3.wasmIndex(inputSigs, bestIdx);
 			const existing = modified.get(bestInput.hash) ?? [];
 			existing.push(out.hash);
 			modified.set(bestInput.hash, existing);
@@ -8858,7 +8710,7 @@ function matchFacesGeometrically(bk, originalShape, inputFaceHashes, outputFaceI
 			}
 		}
 	}
-	for (let i = 0; i < inputSigs.length; i++) if (!matchedInputIndices.has(i)) deleted.add(inputSigs[i].hash);
+	for (let i = 0; i < inputSigs.length; i++) if (!matchedInputIndices.has(i)) deleted.add(require_vec3.wasmIndex(inputSigs, i).hash);
 }
 /**
 * Build a ShapeEvolution by comparing input face hashes to output face hashes.
@@ -8875,7 +8727,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(inputFaceHashes[i], [outputHashes[i]]);
+		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)]);
 		else {
 			const inputSet = new Set(inputFaceHashes);
 			let hasOverlap = false;
@@ -8887,12 +8739,12 @@ function buildEvolution(bk, resultShape, inputFaceHashes, hashUpperBound, isTran
 				const outputSet = new Set(outputHashes);
 				for (const hash of outputHashes) if (inputSet.has(hash)) modified.set(hash, [hash]);
 				const newFaces = outputHashes.filter((fh) => !inputSet.has(fh));
-				if (newFaces.length > 0 && inputFaceHashes.length > 0) generated.set(inputFaceHashes[0], newFaces);
+				if (newFaces.length > 0 && inputFaceHashes.length > 0) generated.set(require_vec3.wasmIndex(inputFaceHashes, 0), newFaces);
 				for (const hash of inputFaceHashes) if (!outputSet.has(hash)) deleted.add(hash);
 			} 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(inputFaceHashes[i], [outputHashes[i]]);
-				if (outputHashes.length > inputFaceHashes.length && inputFaceHashes.length > 0) generated.set(inputFaceHashes[0], outputHashes.slice(inputFaceHashes.length));
+				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));
 			}
 		}
 	}
@@ -9294,7 +9146,7 @@ function createAffinityGTrsf2d(ox, oy, dx, dy, ratio) {
 		0,
 		1
 	];
-	return _gtrsf(m, ox - m[0] * ox - m[1] * oy, oy - m[3] * ox - m[4] * oy);
+	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);
 }
 function createTranslationGTrsf2d(dx, dy) {
 	return _gtrsf([
@@ -9325,7 +9177,7 @@ function createMirrorGTrsf2d(cx, cy, mode, ox, oy, dx, dy) {
 			1
 		];
 		const px = ox ?? cx, py = oy ?? cy;
-		return _gtrsf(m, px - m[0] * px - m[1] * py, py - m[3] * px - m[4] * py);
+		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([
 		-1,
@@ -9372,21 +9224,23 @@ 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);
 	base.m = [
-		a[0] * b[0] + a[1] * b[3] + a[2] * b[6],
-		a[0] * b[1] + a[1] * b[4] + a[2] * b[7],
-		a[0] * b[2] + a[1] * b[5] + a[2] * b[8],
-		a[3] * b[0] + a[4] * b[3] + a[5] * b[6],
-		a[3] * b[1] + a[4] * b[4] + a[5] * b[7],
-		a[3] * b[2] + a[4] * b[5] + a[5] * b[8],
-		a[6] * b[0] + a[7] * b[3] + a[8] * b[6],
-		a[6] * b[1] + a[7] * b[4] + a[8] * b[7],
-		a[6] * b[2] + a[7] * b[5] + a[8] * b[8]
+		ai(0) * bi(0) + ai(1) * bi(3) + ai(2) * bi(6),
+		ai(0) * bi(1) + ai(1) * bi(4) + ai(2) * bi(7),
+		ai(0) * bi(2) + ai(1) * bi(5) + ai(2) * bi(8),
+		ai(3) * bi(0) + ai(4) * bi(3) + ai(5) * bi(6),
+		ai(3) * bi(1) + ai(4) * bi(4) + ai(5) * bi(7),
+		ai(3) * bi(2) + ai(4) * bi(5) + ai(5) * bi(8),
+		ai(6) * bi(0) + ai(7) * bi(3) + ai(8) * bi(6),
+		ai(6) * bi(1) + ai(7) * bi(4) + ai(8) * bi(7),
+		ai(6) * bi(2) + ai(7) * bi(5) + ai(8) * bi(8)
 	];
 	const oldTx = base.tx, oldTy = base.ty;
 	const otx = Number(other.tx) || 0, oty = Number(other.ty) || 0;
-	base.tx = a[0] * otx + a[1] * oty + oldTx;
-	base.ty = a[3] * otx + a[4] * oty + oldTy;
+	base.tx = ai(0) * otx + ai(1) * oty + oldTx;
+	base.ty = ai(3) * otx + ai(4) * oty + oldTy;
 }
 function transformCurve2dGeneral(curve, gtrsf) {
 	const c = c2d(curve);
@@ -9402,14 +9256,15 @@ function transformCurve2dGeneral(curve, gtrsf) {
 		1
 	];
 	const tx = Number(gtrsf.tx) || 0, ty = Number(gtrsf.ty) || 0;
-	if (Math.abs(m[0] - 1) < 1e-12 && Math.abs(m[4] - 1) < 1e-12 && Math.abs(m[1]) < 1e-12 && Math.abs(m[3]) < 1e-12) return require_occtWasmAdapter.translateCurve2d(c, tx, ty);
+	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);
+	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;
 	const pts = [];
 	for (let i = 0; i <= N; i++) {
 		const t = bounds.first + (bounds.last - bounds.first) * i / N;
 		const [px, py] = require_occtWasmAdapter.evaluateCurve2d(c, t);
-		pts.push([m[0] * px + m[1] * py + tx, m[3] * px + m[4] * py + ty]);
+		pts.push([m0 * px + m1 * py + tx, m3 * px + m4 * py + ty]);
 	}
 	return require_occtWasmAdapter.makeBezier2d(pts);
 }
@@ -9543,8 +9398,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 = poles[i];
-			const p1 = poles[i + 1];
+			const p0 = require_vec3.wasmIndex(poles, i);
+			const p1 = require_vec3.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);
@@ -9570,8 +9425,8 @@ function decomposeBSpline2dToBeziers(curve) {
 	];
 	const result = [];
 	for (let i = 0; i < breakpoints.length - 1; i++) {
-		const t0 = breakpoints[i];
-		const t1 = breakpoints[i + 1];
+		const t0 = require_vec3.wasmIndex(breakpoints, i);
+		const t1 = require_vec3.wasmIndex(breakpoints, i + 1);
 		const span = t1 - t0;
 		if (span < 1e-15) continue;
 		const p0 = require_occtWasmAdapter.evaluateCurve2d(c, t0);
@@ -9722,13 +9577,13 @@ 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(edgeIds[0]);
+			if (edgeIds.length === 1) return edgeHandle(require_vec3.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, points3d[0], points3d[1]);
+		if (points3d.length === 2) return makeLineEdge(bk, require_vec3.wasmIndex(points3d, 0), require_vec3.wasmIndex(points3d, 1));
 		const degree = Math.min(3, points3d.length - 1);
 		const coords = points3d.flatMap(([px, py, pz]) => [
 			px,
@@ -9757,58 +9612,40 @@ 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);
-		const p = bk.evaluateSurface(fid, u, v);
-		points.push([
-			p[0],
-			p[1],
-			p[2]
-		]);
+		points.push(require_vec3.vec3At(bk.evaluateSurface(fid, u, v)));
 	}
 	return interpolatePoints(bk, points);
 }
 function extractSurfaceFromFace(face) {
 	return face;
 }
-function extractCurve2dFromEdge(bk, edge, face) {
-	const eid = unwrap(edge, "edge");
-	const fid = unwrap(face, "face");
-	const params = bk.getEdgeCurveParameters(eid);
-	const tMin = params[0] ?? 0;
-	const tMax = params[1] ?? 1;
-	const BASE_N = 20;
-	const MAX_N = 80;
-	const REFINE_THRESHOLD = .05;
-	const tValues = [];
-	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, pt[0], pt[1], pt[2]);
-		return [uv[0], uv[1]];
-	};
-	const uvSamples = tValues.map((t) => ({
-		t,
-		uv: evaluateUV(t)
-	}));
+/**
+* Adaptively refine a UV sample list by inserting midpoints whenever the
+* sampled UV midpoint deviates from the linear interpolation of its
+* neighbors by more than `threshold`. Stops at `maxSamples` or when no
+* pair exceeds the threshold; cap of 3 refinement passes overall.
+*/
+function refineUVSamples(uvSamples, evaluateUV, maxSamples, threshold) {
 	let refinements = 0;
-	while (uvSamples.length < MAX_N) {
+	while (uvSamples.length < maxSamples) {
 		const insertions = [];
 		for (let i = 0; i < uvSamples.length - 1; i++) {
-			const a = uvSamples[i];
-			const b = uvSamples[i + 1];
+			const a = require_vec3.wasmIndex(uvSamples, i);
+			const b = require_vec3.wasmIndex(uvSamples, i + 1);
 			const tMid = (a.t + b.t) / 2;
 			const uvMid = evaluateUV(tMid);
 			const interpU = (a.uv[0] + b.uv[0]) / 2;
 			const interpV = (a.uv[1] + b.uv[1]) / 2;
-			if (Math.sqrt((uvMid[0] - interpU) ** 2 + (uvMid[1] - interpV) ** 2) > REFINE_THRESHOLD) insertions.push({
+			if (Math.sqrt((uvMid[0] - interpU) ** 2 + (uvMid[1] - interpV) ** 2) > threshold) insertions.push({
 				index: i + 1,
 				t: tMid,
 				uv: uvMid
 			});
 		}
 		if (insertions.length === 0) break;
-		let budget = MAX_N - uvSamples.length;
+		let budget = maxSamples - uvSamples.length;
 		for (let j = insertions.length - 1; j >= 0 && budget > 0; j--) {
-			const ins = insertions[j];
+			const ins = require_vec3.wasmIndex(insertions, j);
 			uvSamples.splice(ins.index, 0, {
 				t: ins.t,
 				uv: ins.uv
@@ -9818,13 +9655,35 @@ function extractCurve2dFromEdge(bk, edge, face) {
 		refinements++;
 		if (refinements > 3) break;
 	}
+}
+function extractCurve2dFromEdge(bk, edge, face) {
+	const eid = unwrap(edge, "edge");
+	const fid = unwrap(face, "face");
+	const params = bk.getEdgeCurveParameters(eid);
+	const tMin = params[0] ?? 0;
+	const tMax = params[1] ?? 1;
+	const BASE_N = 20;
+	const MAX_N = 80;
+	const REFINE_THRESHOLD = .05;
+	const tValues = [];
+	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 uvSamples = tValues.map((t) => ({
+		t,
+		uv: evaluateUV(t)
+	}));
+	refineUVSamples(uvSamples, evaluateUV, MAX_N, REFINE_THRESHOLD);
 	const uvPoints = uvSamples.map((s) => s.uv);
 	if (uvPoints.length >= 2) return makeBSpline2d(uvPoints);
 	const verts = bk.getEdgeVertices(eid);
 	if (verts.length >= 6) {
-		const uv1 = bk.projectPointOnSurface(fid, verts[0], verts[1], verts[2]);
-		const uv2 = bk.projectPointOnSurface(fid, verts[3], verts[4], verts[5]);
-		return require_occtWasmAdapter.makeLine2d(uv1[0], uv1[1], uv2[0], uv2[1]);
+		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));
 	}
 	throw new Error(`brepkit: extractCurve2dFromEdge: degenerate edge (${verts.length} coords)`);
 }
@@ -9840,13 +9699,14 @@ function fillSurface(bk, wires, _options) {
 			for (const edge of wireEdges) {
 				const edgeId = unwrap(edge, "edge");
 				const params = bk.getEdgeCurveParameters(edgeId);
-				const tMin = params[0], tMax = params[1];
+				const tMin = require_vec3.wasmIndex(params, 0);
+				const tMax = require_vec3.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(p[0], p[1], p[2]);
+					pts.push(require_vec3.wasmIndex(p, 0), require_vec3.wasmIndex(p, 1), require_vec3.wasmIndex(p, 2));
 				}
 				allCoords.push(...pts);
 				curveLengths.push(N + 1);
@@ -10868,7 +10728,7 @@ async function init() {
 	throw new Error("brepjs: no kernel package found. Install one of:\n  npm install brepjs-opencascade   (recommended)\n  npm install brepkit-wasm\n  npm install occt-wasm            (requires manual registerKernel)");
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.127.0/helpers/usingCtx.js
+//#region \0@oxc-project+runtime@0.128.0/helpers/usingCtx.js
 function _usingCtx() {
 	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
 		var n = Error();