brepjs 18.5.3 → 18.6.1

package/dist/occtWasmAdapter-C2VW-uYg.cjs

@@ -0,0 +1,4719 @@
+const require_vec3 = require("./vec3-S4Oh59IX.cjs");
+//#region src/kernel/geometry2d.ts
+function evaluateCurve2d$1(c, t) {
+	switch (c.__bk2d) {
+		case "line": return [c.ox + c.dx * t, c.oy + c.dy * t];
+		case "circle": {
+			const angle = c.sense ? t : -t;
+			return [c.cx + c.radius * Math.cos(angle), c.cy + c.radius * Math.sin(angle)];
+		}
+		case "ellipse": {
+			const angle = c.sense ? t : -t;
+			const cos = Math.cos(c.xDirAngle);
+			const sin = Math.sin(c.xDirAngle);
+			const x = c.majorRadius * Math.cos(angle);
+			const y = c.minorRadius * Math.sin(angle);
+			return [c.cx + x * cos - y * sin, c.cy + x * sin + y * cos];
+		}
+		case "bezier": return evaluateBezier(c.poles, t);
+		case "bspline": return evaluateBSpline2d(c, t);
+		case "trimmed": {
+			const mapped = c.tStart + t * (c.tEnd - c.tStart);
+			return evaluateCurve2d$1(c.basis, mapped);
+		}
+	}
+}
+function tangentCurve2d(c, t) {
+	switch (c.__bk2d) {
+		case "line": return [c.dx, c.dy];
+		case "circle": {
+			const angle = c.sense ? t : -t;
+			const sign = c.sense ? 1 : -1;
+			return [-c.radius * Math.sin(angle) * sign, c.radius * Math.cos(angle) * sign];
+		}
+		case "ellipse": {
+			const angle = c.sense ? t : -t;
+			const sign = c.sense ? 1 : -1;
+			const cos = Math.cos(c.xDirAngle);
+			const sin = Math.sin(c.xDirAngle);
+			const dx = -c.majorRadius * Math.sin(angle) * sign;
+			const dy = c.minorRadius * Math.cos(angle) * sign;
+			return [dx * cos - dy * sin, dx * sin + dy * cos];
+		}
+		case "bezier": {
+			const h = 1e-8;
+			const p0 = evaluateBezier(c.poles, Math.max(0, t - h));
+			const p1 = evaluateBezier(c.poles, Math.min(1, t + h));
+			const dt = Math.min(1, t + h) - Math.max(0, t - h);
+			return [(p1[0] - p0[0]) / dt, (p1[1] - p0[1]) / dt];
+		}
+		case "bspline": {
+			const h = 1e-8;
+			const kFirst = c.knots[0];
+			const kLast = c.knots[c.knots.length - 1];
+			const p0 = evaluateBSpline2d(c, Math.max(kFirst, t - h));
+			const p1 = evaluateBSpline2d(c, Math.min(kLast, t + h));
+			const dt = Math.min(kLast, t + h) - Math.max(kFirst, t - h);
+			return [(p1[0] - p0[0]) / dt, (p1[1] - p0[1]) / dt];
+		}
+		case "trimmed": {
+			const mapped = c.tStart + t * (c.tEnd - c.tStart);
+			const tan = tangentCurve2d(c.basis, mapped);
+			const scale = c.tEnd - c.tStart;
+			return [tan[0] * scale, tan[1] * scale];
+		}
+	}
+}
+function curveBounds(c) {
+	switch (c.__bk2d) {
+		case "line": return {
+			first: 0,
+			last: c.len
+		};
+		case "circle":
+		case "ellipse": return {
+			first: 0,
+			last: 2 * Math.PI
+		};
+		case "bezier": return {
+			first: 0,
+			last: 1
+		};
+		case "bspline": return {
+			first: c.knots[0],
+			last: c.knots[c.knots.length - 1]
+		};
+		case "trimmed": return {
+			first: 0,
+			last: 1
+		};
+	}
+}
+function curveTypeName(c) {
+	switch (c.__bk2d) {
+		case "line": return "LINE";
+		case "circle": return "CIRCLE";
+		case "ellipse": return "ELLIPSE";
+		case "bezier": return "BEZIER_CURVE";
+		case "bspline": return "BSPLINE_CURVE";
+		case "trimmed": return "TRIMMED_" + curveTypeName(c.basis);
+	}
+}
+function makeLine2d$1(x1, y1, x2, y2) {
+	const dx = x2 - x1;
+	const dy = y2 - y1;
+	const len = Math.sqrt(dx * dx + dy * dy);
+	return {
+		__bk2d: "line",
+		ox: x1,
+		oy: y1,
+		dx: len > 0 ? dx / len : 1,
+		dy: len > 0 ? dy / len : 0,
+		len
+	};
+}
+function makeCircle2d$1(cx, cy, radius, sense = true) {
+	return {
+		__bk2d: "circle",
+		cx,
+		cy,
+		radius,
+		sense
+	};
+}
+function makeEllipse2d$1(cx, cy, majorRadius, minorRadius, xDirX = 1, xDirY = 0, sense = true) {
+	return {
+		__bk2d: "ellipse",
+		cx,
+		cy,
+		majorRadius,
+		minorRadius,
+		xDirAngle: Math.atan2(xDirY, xDirX),
+		sense
+	};
+}
+function makeBezier2d$1(poles) {
+	return {
+		__bk2d: "bezier",
+		poles: [...poles]
+	};
+}
+function translateCurve2d$1(c, dx, dy) {
+	switch (c.__bk2d) {
+		case "line": return {
+			...c,
+			ox: c.ox + dx,
+			oy: c.oy + dy
+		};
+		case "circle": return {
+			...c,
+			cx: c.cx + dx,
+			cy: c.cy + dy
+		};
+		case "ellipse": return {
+			...c,
+			cx: c.cx + dx,
+			cy: c.cy + dy
+		};
+		case "bezier": return {
+			...c,
+			poles: c.poles.map(([x, y]) => [x + dx, y + dy])
+		};
+		case "bspline": return {
+			...c,
+			poles: c.poles.map(([x, y]) => [x + dx, y + dy])
+		};
+		case "trimmed": return {
+			...c,
+			basis: translateCurve2d$1(c.basis, dx, dy)
+		};
+	}
+}
+function rotateCurve2d$1(c, angle, cx, cy) {
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	const rotatePoint = (x, y) => {
+		const rx = x - cx;
+		const ry = y - cy;
+		return [cx + rx * cos - ry * sin, cy + rx * sin + ry * cos];
+	};
+	switch (c.__bk2d) {
+		case "line": {
+			const [ox, oy] = rotatePoint(c.ox, c.oy);
+			const ndx = c.dx * cos - c.dy * sin;
+			const ndy = c.dx * sin + c.dy * cos;
+			return {
+				...c,
+				ox,
+				oy,
+				dx: ndx,
+				dy: ndy
+			};
+		}
+		case "circle": {
+			const [ncx, ncy] = rotatePoint(c.cx, c.cy);
+			return {
+				...c,
+				cx: ncx,
+				cy: ncy
+			};
+		}
+		case "ellipse": {
+			const [ncx, ncy] = rotatePoint(c.cx, c.cy);
+			return {
+				...c,
+				cx: ncx,
+				cy: ncy,
+				xDirAngle: c.xDirAngle + angle
+			};
+		}
+		case "bezier": return {
+			...c,
+			poles: c.poles.map(([x, y]) => rotatePoint(x, y))
+		};
+		case "bspline": return {
+			...c,
+			poles: c.poles.map(([x, y]) => rotatePoint(x, y))
+		};
+		case "trimmed": return {
+			...c,
+			basis: rotateCurve2d$1(c.basis, angle, cx, cy)
+		};
+	}
+}
+function scaleCurve2d$1(c, factor, cx, cy) {
+	const scalePoint = (x, y) => [cx + (x - cx) * factor, cy + (y - cy) * factor];
+	switch (c.__bk2d) {
+		case "line": {
+			const [ox, oy] = scalePoint(c.ox, c.oy);
+			return {
+				...c,
+				ox,
+				oy
+			};
+		}
+		case "circle": {
+			const [ncx, ncy] = scalePoint(c.cx, c.cy);
+			return {
+				...c,
+				cx: ncx,
+				cy: ncy,
+				radius: c.radius * Math.abs(factor)
+			};
+		}
+		case "ellipse": {
+			const [ncx, ncy] = scalePoint(c.cx, c.cy);
+			return {
+				...c,
+				cx: ncx,
+				cy: ncy,
+				majorRadius: c.majorRadius * Math.abs(factor),
+				minorRadius: c.minorRadius * Math.abs(factor)
+			};
+		}
+		case "bezier": return {
+			...c,
+			poles: c.poles.map(([x, y]) => scalePoint(x, y))
+		};
+		case "bspline": return {
+			...c,
+			poles: c.poles.map(([x, y]) => scalePoint(x, y))
+		};
+		case "trimmed": return {
+			...c,
+			basis: scaleCurve2d$1(c.basis, factor, cx, cy)
+		};
+	}
+}
+function mirrorAtPoint(c, cx, cy) {
+	return scaleCurve2d$1(c, -1, cx, cy);
+}
+function mirrorAcrossAxis(c, ox, oy, dx, dy) {
+	const len = Math.sqrt(dx * dx + dy * dy);
+	const nx = dx / len;
+	const ny = dy / len;
+	const reflectPoint = (x, y) => {
+		const rx = x - ox;
+		const ry = y - oy;
+		const dot = rx * nx + ry * ny;
+		return [ox + 2 * dot * nx - rx, oy + 2 * dot * ny - ry];
+	};
+	switch (c.__bk2d) {
+		case "line": {
+			const [nox, noy] = reflectPoint(c.ox, c.oy);
+			const ndx = 2 * (c.dx * nx + c.dy * ny) * nx - c.dx;
+			const ndy = 2 * (c.dx * nx + c.dy * ny) * ny - c.dy;
+			return {
+				...c,
+				ox: nox,
+				oy: noy,
+				dx: ndx,
+				dy: ndy
+			};
+		}
+		case "circle": {
+			const [ncx, ncy] = reflectPoint(c.cx, c.cy);
+			return {
+				...c,
+				cx: ncx,
+				cy: ncy,
+				sense: !c.sense
+			};
+		}
+		case "ellipse": {
+			const [ncx, ncy] = reflectPoint(c.cx, c.cy);
+			const cos2 = nx * nx - ny * ny;
+			const sin2 = 2 * nx * ny;
+			const newAngle = Math.atan2(sin2 * Math.cos(c.xDirAngle) - cos2 * Math.sin(c.xDirAngle), cos2 * Math.cos(c.xDirAngle) + sin2 * Math.sin(c.xDirAngle));
+			return {
+				...c,
+				cx: ncx,
+				cy: ncy,
+				xDirAngle: newAngle,
+				sense: !c.sense
+			};
+		}
+		case "bezier": return {
+			...c,
+			poles: c.poles.map(([x, y]) => reflectPoint(x, y))
+		};
+		case "bspline": return {
+			...c,
+			poles: c.poles.map(([x, y]) => reflectPoint(x, y))
+		};
+		case "trimmed": return {
+			...c,
+			basis: mirrorAcrossAxis(c.basis, ox, oy, dx, dy)
+		};
+	}
+}
+/**
+* Compute intersection points (and overlapping segments) between two 2D curves.
+* Handles analytic cases (line-line, line-circle, circle-circle) and falls back
+* to numerical sampling + Newton refinement for general curves.
+*/
+function intersectCurves2dFn(c1, c2, tolerance) {
+	const b1 = unwrapCurve(c1);
+	const b2 = unwrapCurve(c2);
+	if (b1.__bk2d === "line" && b2.__bk2d === "line") return intersectLineLine(c1, b1, c2, b2, tolerance);
+	if (b1.__bk2d === "line" && b2.__bk2d === "circle") return {
+		points: intersectLineCircle(c1, b1, c2, b2, tolerance),
+		segments: []
+	};
+	if (b1.__bk2d === "circle" && b2.__bk2d === "line") return {
+		points: intersectLineCircle(c2, b2, c1, b1, tolerance),
+		segments: []
+	};
+	if (b1.__bk2d === "circle" && b2.__bk2d === "circle") return {
+		points: intersectCircleCircle(c1, b1, c2, b2, tolerance),
+		segments: []
+	};
+	return numericalIntersect(c1, c2, tolerance, c1 === c2);
+}
+/** Unwrap trimmed wrappers to get the basis curve type. */
+function unwrapCurve(c) {
+	let cur = c;
+	while (cur.__bk2d === "trimmed") cur = cur.basis;
+	return cur;
+}
+/** Check if parameter t is within the curve's domain. */
+function inDomain(c, t, tol) {
+	const b = curveBounds(c);
+	return t >= b.first - tol && t <= b.last + tol;
+}
+/** Find the parameter on curve c closest to point (px, py), searching near tGuess. */
+function refineParam(c, px, py) {
+	const bounds = curveBounds(c);
+	if (!isFinite(bounds.first) || !isFinite(bounds.last)) return null;
+	const N = 80;
+	const dt = (bounds.last - bounds.first) / N;
+	let bestT = bounds.first;
+	let bestD = Infinity;
+	for (let i = 0; i <= N; i++) {
+		const t = bounds.first + i * dt;
+		const [ex, ey] = evaluateCurve2d$1(c, t);
+		const d = (ex - px) ** 2 + (ey - py) ** 2;
+		if (d < bestD) {
+			bestD = d;
+			bestT = t;
+		}
+	}
+	const [sx, sy] = evaluateCurve2d$1(c, bounds.first);
+	const [ex, ey] = evaluateCurve2d$1(c, bounds.last);
+	const [mx, my] = evaluateCurve2d$1(c, (bounds.first + bounds.last) / 2);
+	const maxDist = Math.max(Math.sqrt((ex - sx) ** 2 + (ey - sy) ** 2), Math.sqrt((mx - sx) ** 2 + (my - sy) ** 2), 1e-6) * .1;
+	return bestD < maxDist * maxDist ? bestT : null;
+}
+function intersectLineLine(c1, l1, c2, l2, tol) {
+	const det = l1.dx * l2.dy - l1.dy * l2.dx;
+	if (Math.abs(det) >= 1e-14) {
+		const ex = l2.ox - l1.ox;
+		const ey = l2.oy - l1.oy;
+		const t1 = (ex * l2.dy - ey * l2.dx) / det;
+		const t2 = (ex * l1.dy - ey * l1.dx) / det;
+		if (!inDomain(c1, t1, tol) || !inDomain(c2, t2, tol)) return {
+			points: [],
+			segments: []
+		};
+		return {
+			points: [[l1.ox + t1 * l1.dx, l1.oy + t1 * l1.dy]],
+			segments: []
+		};
+	}
+	const ex = l2.ox - l1.ox;
+	const ey = l2.oy - l1.oy;
+	const cross = ex * l1.dy - ey * l1.dx;
+	if (Math.abs(cross) > tol) return {
+		points: [],
+		segments: []
+	};
+	const b1 = curveBounds(c1);
+	const b2 = curveBounds(c2);
+	const p2s = evaluateCurve2d$1(c2, b2.first);
+	const p2e = evaluateCurve2d$1(c2, b2.last);
+	const t2sOn1 = (p2s[0] - l1.ox) * l1.dx + (p2s[1] - l1.oy) * l1.dy;
+	const t2eOn1 = (p2e[0] - l1.ox) * l1.dx + (p2e[1] - l1.oy) * l1.dy;
+	const overlapStart = Math.max(b1.first, Math.min(t2sOn1, t2eOn1));
+	const overlapEnd = Math.min(b1.last, Math.max(t2sOn1, t2eOn1));
+	if (overlapEnd - overlapStart < tol) return {
+		points: [],
+		segments: []
+	};
+	return {
+		points: [],
+		segments: [makeLine2d$1(l1.ox + overlapStart * l1.dx, l1.oy + overlapStart * l1.dy, l1.ox + overlapEnd * l1.dx, l1.oy + overlapEnd * l1.dy)]
+	};
+}
+function intersectLineCircle(cLine, line, cCirc, circ, tol) {
+	const fx = line.ox - circ.cx;
+	const fy = line.oy - circ.cy;
+	const a = line.dx * line.dx + line.dy * line.dy;
+	const b = 2 * (fx * line.dx + fy * line.dy);
+	const c = fx * fx + fy * fy - circ.radius * circ.radius;
+	const disc = b * b - 4 * a * c;
+	if (disc < -tol) return [];
+	const results = [];
+	const sqrtDisc = Math.sqrt(Math.max(0, disc));
+	const t1 = (-b - sqrtDisc) / (2 * a);
+	const t2 = (-b + sqrtDisc) / (2 * a);
+	for (const tLine of disc < tol * tol ? [t1] : [t1, t2]) {
+		if (!inDomain(cLine, tLine, tol)) continue;
+		const px = line.ox + tLine * line.dx;
+		const py = line.oy + tLine * line.dy;
+		const tCirc = refineParam(cCirc, px, py);
+		if (tCirc === null) continue;
+		const [cx2, cy2] = evaluateCurve2d$1(cCirc, tCirc);
+		if ((cx2 - px) ** 2 + (cy2 - py) ** 2 > tol * tol * 1e6) continue;
+		results.push([px, py]);
+	}
+	return results;
+}
+function intersectConcentricArcs(c1, c2, tol) {
+	const b1 = curveBounds(c1);
+	const b2 = curveBounds(c2);
+	const isFullCircle1 = Math.abs(b1.last - b1.first - 2 * Math.PI) < 1e-10;
+	const isFullCircle2 = Math.abs(b2.last - b2.first - 2 * Math.PI) < 1e-10;
+	if (isFullCircle1 && isFullCircle2) return [];
+	if (isFullCircle1) return [evaluateCurve2d$1(c2, b2.first), evaluateCurve2d$1(c2, b2.last)];
+	if (isFullCircle2) return [evaluateCurve2d$1(c1, b1.first), evaluateCurve2d$1(c1, b1.last)];
+	const pts = [];
+	const checks = [
+		[c2, evaluateCurve2d$1(c1, b1.first)],
+		[c2, evaluateCurve2d$1(c1, b1.last)],
+		[c1, evaluateCurve2d$1(c2, b2.first)],
+		[c1, evaluateCurve2d$1(c2, b2.last)]
+	];
+	for (const [target, pt] of checks) {
+		const t = refineParam(target, pt[0], pt[1]);
+		if (t !== null) {
+			const [ex, ey] = evaluateCurve2d$1(target, t);
+			if ((ex - pt[0]) ** 2 + (ey - pt[1]) ** 2 < tol * tol * 100) pts.push(pt);
+		}
+	}
+	const deduped = [];
+	for (const p of pts) if (!deduped.some(([ddx, ddy]) => (ddx - p[0]) ** 2 + (ddy - p[1]) ** 2 < tol * tol * 100)) deduped.push(p);
+	return deduped;
+}
+function intersectCircleCircle(c1, circ1, c2, circ2, tol) {
+	const dx = circ2.cx - circ1.cx;
+	const dy = circ2.cy - circ1.cy;
+	const d = Math.sqrt(dx * dx + dy * dy);
+	if (d > circ1.radius + circ2.radius + tol) return [];
+	if (d < Math.abs(circ1.radius - circ2.radius) - tol) return [];
+	if (d < 1e-14) {
+		if (Math.abs(circ1.radius - circ2.radius) > tol) return [];
+		return intersectConcentricArcs(c1, c2, tol);
+	}
+	const a = (circ1.radius * circ1.radius - circ2.radius * circ2.radius + d * d) / (2 * d);
+	const h2 = circ1.radius * circ1.radius - a * a;
+	const h = Math.sqrt(Math.max(0, h2));
+	const mx = circ1.cx + a * dx / d;
+	const my = circ1.cy + a * dy / d;
+	const candidates = h < tol ? [[mx, my]] : [[mx + h * dy / d, my - h * dx / d], [mx - h * dy / d, my + h * dx / d]];
+	const results = [];
+	for (const [px, py] of candidates) {
+		const t1 = refineParam(c1, px, py);
+		const t2 = refineParam(c2, px, py);
+		if (t1 === null || t2 === null) continue;
+		const [x1, y1] = evaluateCurve2d$1(c1, t1);
+		const [x2, y2] = evaluateCurve2d$1(c2, t2);
+		const tolSq = (tol * 10) ** 2;
+		if ((x1 - px) ** 2 + (y1 - py) ** 2 > tolSq) continue;
+		if ((x2 - px) ** 2 + (y2 - py) ** 2 > tolSq) continue;
+		results.push([px, py]);
+	}
+	return results;
+}
+/**
+* Numerical intersection via sampling + Newton refinement.
+* Samples both curves densely, finds close point pairs, refines with Newton.
+*/
+function numericalIntersect(c1, c2, tolerance, isSelf = false) {
+	const b1 = curveBounds(c1);
+	const b2 = curveBounds(c2);
+	if (!isFinite(b1.first) || !isFinite(b1.last) || !isFinite(b2.first) || !isFinite(b2.last)) return {
+		points: [],
+		segments: []
+	};
+	const N = 100;
+	const pts1 = [];
+	const pts2 = [];
+	for (let i = 0; i <= N; i++) {
+		const t1 = b1.first + (b1.last - b1.first) * i / N;
+		const [x1, y1] = evaluateCurve2d$1(c1, t1);
+		pts1.push({
+			t: t1,
+			x: x1,
+			y: y1
+		});
+		const t2 = b2.first + (b2.last - b2.first) * i / N;
+		const [x2, y2] = evaluateCurve2d$1(c2, t2);
+		pts2.push({
+			t: t2,
+			x: x2,
+			y: y2
+		});
+	}
+	const crossTol = Math.max(tolerance * 100, .5);
+	const seg2Bounds = new Float64Array(N * 6);
+	for (let j = 0; j < N; j++) {
+		const a = pts2[j], b = pts2[j + 1];
+		const off = j * 6;
+		seg2Bounds[off] = Math.min(a.x, b.x);
+		seg2Bounds[off + 1] = Math.max(a.x, b.x);
+		seg2Bounds[off + 2] = Math.min(a.y, b.y);
+		seg2Bounds[off + 3] = Math.max(a.y, b.y);
+		seg2Bounds[off + 4] = (a.t + b.t) / 2;
+	}
+	const candidates = [];
+	const selfMinSep = (b1.last - b1.first) / 5;
+	for (let i = 0; i < N; i++) {
+		const p1a = pts1[i];
+		const p1b = pts1[i + 1];
+		const x1min = Math.min(p1a.x, p1b.x) - crossTol;
+		const x1max = Math.max(p1a.x, p1b.x) + crossTol;
+		const y1min = Math.min(p1a.y, p1b.y) - crossTol;
+		const y1max = Math.max(p1a.y, p1b.y) + crossTol;
+		const t1mid = (p1a.t + p1b.t) / 2;
+		for (let j = 0; j < N; j++) {
+			const off = j * 6;
+			if (x1max < seg2Bounds[off] || seg2Bounds[off + 1] < x1min) continue;
+			if (y1max < seg2Bounds[off + 2] || seg2Bounds[off + 3] < y1min) continue;
+			const t2mid = seg2Bounds[off + 4];
+			if (isSelf && Math.abs(t1mid - t2mid) < selfMinSep) continue;
+			candidates.push({
+				t1: t1mid,
+				t2: t2mid
+			});
+		}
+	}
+	const tol2 = tolerance * tolerance;
+	const found = [];
+	for (const { t1: t1Init, t2: t2Init } of candidates) {
+		let t1 = t1Init;
+		let t2 = t2Init;
+		for (let iter = 0; iter < 20; iter++) {
+			const [x1, y1] = evaluateCurve2d$1(c1, t1);
+			const [x2, y2] = evaluateCurve2d$1(c2, t2);
+			const dx = x1 - x2;
+			const dy = y1 - y2;
+			if (dx * dx + dy * dy < tol2) break;
+			const d1 = tangentCurve2d(c1, t1);
+			const d2 = tangentCurve2d(c2, t2);
+			const det = d1[0] * -d2[1] - -d2[0] * d1[1];
+			if (Math.abs(det) < 1e-14) break;
+			const dt1 = (-dx * -d2[1] - -dy * -d2[0]) / det;
+			const dt2 = (d1[0] * -dy - d1[1] * -dx) / det;
+			t1 += dt1;
+			t2 += dt2;
+			t1 = Math.max(b1.first, Math.min(b1.last, t1));
+			t2 = Math.max(b2.first, Math.min(b2.last, t2));
+		}
+		const [x1, y1] = evaluateCurve2d$1(c1, t1);
+		const [x2, y2] = evaluateCurve2d$1(c2, t2);
+		if (isSelf && Math.abs(t1 - t2) < (b1.last - b1.first) * .05) continue;
+		if ((x1 - x2) ** 2 + (y1 - y2) ** 2 < tolerance * tolerance * 1e6) {
+			const px = (x1 + x2) / 2;
+			const py = (y1 + y2) / 2;
+			let dup = false;
+			for (const [fx, fy] of found) if ((fx - px) ** 2 + (fy - py) ** 2 < tolerance * tolerance * 1e4) {
+				dup = true;
+				break;
+			}
+			if (!dup) found.push([px, py]);
+		}
+	}
+	return {
+		points: found,
+		segments: []
+	};
+}
+function serializeCurve2d$1(c) {
+	return JSON.stringify(c);
+}
+function deserializeCurve2d$1(data) {
+	return JSON.parse(data);
+}
+function createBBox2d() {
+	return {
+		__bk2d_bbox: true,
+		xMin: Infinity,
+		yMin: Infinity,
+		xMax: -Infinity,
+		yMax: -Infinity
+	};
+}
+function addCurveToBBox(bbox, c, _tol) {
+	const basis = c.__bk2d === "trimmed" ? c.basis : c;
+	if (basis.__bk2d === "line") {
+		const bounds = curveBounds(c);
+		if (!isFinite(bounds.first) || !isFinite(bounds.last)) return;
+		const [x0, y0] = evaluateCurve2d$1(c, bounds.first);
+		const [x1, y1] = evaluateCurve2d$1(c, bounds.last);
+		bbox.xMin = Math.min(bbox.xMin, x0, x1);
+		bbox.yMin = Math.min(bbox.yMin, y0, y1);
+		bbox.xMax = Math.max(bbox.xMax, x0, x1);
+		bbox.yMax = Math.max(bbox.yMax, y0, y1);
+		return;
+	}
+	if (basis.__bk2d === "circle") {
+		const bounds = curveBounds(c);
+		if (!isFinite(bounds.first) || !isFinite(bounds.last)) return;
+		const { cx, cy, radius, sense } = basis;
+		const [x0, y0] = evaluateCurve2d$1(c, bounds.first);
+		const [x1, y1] = evaluateCurve2d$1(c, bounds.last);
+		let xMin = Math.min(x0, x1), xMax = Math.max(x0, x1);
+		let yMin = Math.min(y0, y1), yMax = Math.max(y0, y1);
+		const tStart = c.__bk2d === "trimmed" ? c.tStart : bounds.first;
+		const tEnd = c.__bk2d === "trimmed" ? c.tEnd : bounds.last;
+		for (let k = 0; k < 4; k++) {
+			const angle = k * Math.PI / 2;
+			const t = sense ? angle : -angle;
+			for (let wrap = 0; wrap <= 1; wrap++) {
+				const tt = t + wrap * 2 * Math.PI;
+				if (tt >= tStart - 1e-10 && tt <= tEnd + 1e-10) {
+					const ex = cx + radius * Math.cos(angle);
+					const ey = cy + radius * Math.sin(angle);
+					xMin = Math.min(xMin, ex);
+					xMax = Math.max(xMax, ex);
+					yMin = Math.min(yMin, ey);
+					yMax = Math.max(yMax, ey);
+					break;
+				}
+			}
+		}
+		bbox.xMin = Math.min(bbox.xMin, xMin);
+		bbox.yMin = Math.min(bbox.yMin, yMin);
+		bbox.xMax = Math.max(bbox.xMax, xMax);
+		bbox.yMax = Math.max(bbox.yMax, yMax);
+		return;
+	}
+	const bounds = curveBounds(c);
+	if (!isFinite(bounds.first) || !isFinite(bounds.last)) return;
+	const nSamples = 20;
+	const dt = (bounds.last - bounds.first) / nSamples;
+	for (let i = 0; i <= nSamples; i++) {
+		const [x, y] = evaluateCurve2d$1(c, bounds.first + i * dt);
+		if (x < bbox.xMin) bbox.xMin = x;
+		if (y < bbox.yMin) bbox.yMin = y;
+		if (x > bbox.xMax) bbox.xMax = x;
+		if (y > bbox.yMax) bbox.yMax = y;
+	}
+}
+function evaluateBezier(poles, t) {
+	const n = poles.length;
+	const work = poles.map(([x, y]) => [x, y]);
+	for (let r = 1; r < n; r++) for (let i = 0; i < n - r; i++) {
+		const wi = work[i];
+		const wi1 = work[i + 1];
+		wi[0] = (1 - t) * wi[0] + t * wi1[0];
+		wi[1] = (1 - t) * wi[1] + t * wi1[1];
+	}
+	return work[0];
+}
+function evaluateBSpline2d(c, t) {
+	const fullKnots = [];
+	for (let i = 0; i < c.knots.length; i++) {
+		const mult = c.multiplicities[i] ?? 1;
+		for (let j = 0; j < mult; j++) fullKnots.push(c.knots[i]);
+	}
+	const p = c.degree;
+	const n = c.poles.length;
+	const k = fullKnots.length;
+	const tClamped = Math.max(fullKnots[p], Math.min(fullKnots[k - p - 1], t));
+	let span = p;
+	for (let i = p; i < k - p - 1; i++) if (tClamped >= fullKnots[i] && tClamped < fullKnots[i + 1]) {
+		span = i;
+		break;
+	}
+	if (tClamped >= fullKnots[k - p - 1]) span = k - p - 2;
+	const d = [];
+	for (let j = 0; j <= p; j++) {
+		const idx = Math.min(span - p + j, n - 1);
+		const pole = c.poles[Math.max(0, idx)];
+		d.push([pole[0], pole[1]]);
+	}
+	for (let r = 1; r <= p; r++) for (let j = p; j >= r; j--) {
+		const i = span - p + j;
+		const left = fullKnots[i] ?? 0;
+		const denom = (fullKnots[i + p - r + 1] ?? 1) - left;
+		const alpha = denom > 1e-15 ? (tClamped - left) / denom : 0;
+		const dj = d[j];
+		const djPrev = d[j - 1];
+		dj[0] = (1 - alpha) * djPrev[0] + alpha * dj[0];
+		dj[1] = (1 - alpha) * djPrev[1] + alpha * dj[1];
+	}
+	return d[p];
+}
+//#endregion
+//#region src/kernel/occtWasm/helpers.ts
+var noop = () => {};
+/** Build an opaque kernel handle for an arena-allocated WASM shape. */
+function handle(type, id) {
+	return {
+		__occtWasm: true,
+		type,
+		id,
+		delete: noop,
+		HashCode(upperBound) {
+			return id % upperBound;
+		},
+		IsNull() {
+			return false;
+		}
+	};
+}
+function isOcctWasmHandle(shape) {
+	return typeof shape === "object" && shape !== null && shape.__occtWasm;
+}
+/** Extract the u32 id from a handle. */
+function unwrap(shape) {
+	if (isOcctWasmHandle(shape)) return shape.id;
+	if (typeof shape === "number") return shape;
+	throw new Error("occt-wasm: expected an OcctWasmHandle or number, got " + typeof shape);
+}
+/** Map a WASM shape type string to our ShapeType enum. */
+function mapShapeType(wasmType) {
+	switch (wasmType.toLowerCase()) {
+		case "vertex": return "vertex";
+		case "edge": return "edge";
+		case "wire": return "wire";
+		case "face": return "face";
+		case "shell": return "shell";
+		case "solid": return "solid";
+		case "compsolid": return "compsolid";
+		case "compound": return "compound";
+		default: return "compound";
+	}
+}
+/** Wrap a WASM u32 result as a typed handle, querying the kernel for type. */
+function wrapResult(kernel, id) {
+	return handle(mapShapeType(kernel.getShapeType(id)), id);
+}
+function makeVecU32(Module, values) {
+	const vec = new Module.VectorUint32();
+	for (const v of values) vec.push_back(v);
+	return vec;
+}
+function makeVecInt(Module, values) {
+	const vec = new Module.VectorInt();
+	for (const v of values) vec.push_back(v);
+	return vec;
+}
+function makeVecDouble(Module, values) {
+	const vec = new Module.VectorDouble();
+	for (const v of values) vec.push_back(v);
+	return vec;
+}
+function readVecInt(vec) {
+	const result = [];
+	const n = vec.size();
+	for (let i = 0; i < n; i++) result.push(vec.get(i));
+	return result;
+}
+/**
+* 4x4 matrix multiplication in row-major order. Used by composeTransform
+* and any other transform-stack composition.
+*/
+function multiplyMatrices4x4(a, b) {
+	const result = new Array(16).fill(0);
+	for (let i = 0; i < 4; i++) for (let j = 0; j < 4; j++) for (let k = 0; k < 4; k++) result[i * 4 + j] = result[i * 4 + j] + a[i * 4 + k] * b[k * 4 + j];
+	return result;
+}
+/**
+* Resolve a callback-style radius/distance to a uniform number.
+* occt-wasm's fillet/chamfer take a single radius — uniform per call.
+*/
+function resolveUniformRadius(edges, radius) {
+	if (typeof radius === "number") return radius;
+	if (Array.isArray(radius)) return radius[0];
+	if (edges.length === 0) throw new Error("occt-wasm: no edges provided");
+	const val = radius(edges[0]);
+	return typeof val === "number" ? val : val[0];
+}
+/**
+* Rotate a shape from the kernel's default Z-axis to an arbitrary direction.
+* Used by primitives whose creation API only takes a Z-aligned form.
+*/
+function rotateZToDirection(k, shapeId, dir) {
+	const [dx, dy, dz] = dir;
+	const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+	if (len < 1e-10) return shapeId;
+	const nx = dx / len, ny = dy / len, nz = dz / len;
+	if (Math.abs(nz - 1) < 1e-10) return shapeId;
+	if (Math.abs(nz + 1) < 1e-10) return k.rotate(shapeId, 0, 0, 0, 1, 0, 0, Math.PI);
+	const ax = -ny, ay = nx;
+	const axLen = Math.sqrt(ax * ax + ay * ay);
+	if (axLen < 1e-10) return shapeId;
+	const angle = Math.acos(Math.max(-1, Math.min(1, nz)));
+	return k.rotate(shapeId, 0, 0, 0, ax / axLen, ay / axLen, 0, angle);
+}
+//#endregion
+//#region src/kernel/occtWasm/adapterShims.ts
+function wrapKernelExceptions(kernel, mod) {
+	return new Proxy(kernel, { get(target, prop, receiver) {
+		const val = Reflect.get(target, prop, receiver);
+		if (typeof val !== "function") return val;
+		return function(...args) {
+			try {
+				return val.apply(target, args);
+			} catch (ex) {
+				const WasmException = WebAssembly.Exception;
+				if (WasmException && ex instanceof WasmException) try {
+					const [, msg] = mod.getExceptionMessage(ex);
+					throw new Error(msg, { cause: ex });
+				} catch (inner) {
+					if (inner instanceof Error && !(inner instanceof WasmException)) throw inner;
+				}
+				throw ex;
+			}
+		};
+	} });
+}
+function buildOcShim(module, k) {
+	const makeNullCtor = function() {
+		return handle("compound", k.makeNullShape());
+	};
+	return Object.assign(Object.create(module), {
+		TopoDS_Solid: makeNullCtor,
+		TopoDS_Face: makeNullCtor,
+		TopoDS_Shape: makeNullCtor,
+		TopoDS_Wire: makeNullCtor,
+		TopoDS_Edge: makeNullCtor,
+		TopoDS_Vertex: makeNullCtor,
+		TopoDS_Shell: makeNullCtor,
+		TopoDS_Compound: makeNullCtor,
+		gp_Pnt_3: function(x, y, z) {
+			return handle("vertex", k.makeVertex(x, y, z));
+		},
+		BRepBuilderAPI_MakeEdge_3: function(p1, p2) {
+			const v1 = p1;
+			const v2 = p2;
+			const pos1 = k.vertexPosition(v1.id);
+			const pos2 = k.vertexPosition(v2.id);
+			const edgeId = k.makeLineEdge(pos1.get(0), pos1.get(1), pos1.get(2), pos2.get(0), pos2.get(1), pos2.get(2));
+			pos1.delete();
+			pos2.delete();
+			return {
+				Edge: () => handle("edge", edgeId),
+				delete() {}
+			};
+		}
+	});
+}
+//#endregion
+//#region src/kernel/occtWasm/booleanOps.ts
+function fuse(k, shape, tool, _options) {
+	return wrapResult(k, k.fuse(unwrap(shape), unwrap(tool)));
+}
+function cut(k, shape, tool, _options) {
+	return wrapResult(k, k.cut(unwrap(shape), unwrap(tool)));
+}
+function intersect(k, shape, tool, _options) {
+	return wrapResult(k, k.intersect(unwrap(shape), unwrap(tool)));
+}
+function section(k, shape, plane, _approximation) {
+	return wrapResult(k, k.section(unwrap(shape), unwrap(plane)));
+}
+function fuseAll(k, Module, shapes, _options) {
+	const vec = makeVecU32(Module, shapes.map(unwrap));
+	try {
+		return wrapResult(k, k.fuseAll(vec));
+	} finally {
+		vec.delete();
+	}
+}
+function cutAll(k, Module, shape, tools, _options) {
+	const vec = makeVecU32(Module, tools.map(unwrap));
+	try {
+		return wrapResult(k, k.cutAll(unwrap(shape), vec));
+	} finally {
+		vec.delete();
+	}
+}
+function split(k, Module, shape, tools) {
+	const vec = makeVecU32(Module, tools.map(unwrap));
+	try {
+		return wrapResult(k, k.split(unwrap(shape), vec));
+	} finally {
+		vec.delete();
+	}
+}
+function checkBoolean(k, shape, tool, _op) {
+	const issues = [];
+	if (k.isNull(unwrap(shape))) issues.push({
+		operand: "base",
+		issue: "null-shape",
+		message: "Base shape is null"
+	});
+	if (k.isNull(unwrap(tool))) issues.push({
+		operand: "tool",
+		issue: "null-shape",
+		message: "Tool shape is null"
+	});
+	if (issues.length === 0 && !k.isValid(unwrap(shape))) issues.push({
+		operand: "base",
+		issue: "not-valid",
+		message: "Base shape is not valid"
+	});
+	if (issues.length === 0 && !k.isValid(unwrap(tool))) issues.push({
+		operand: "tool",
+		issue: "not-valid",
+		message: "Tool shape is not valid"
+	});
+	return {
+		valid: issues.length === 0,
+		issues
+	};
+}
+function meshBoolean(_positionsA, _indicesA, _positionsB, _indicesB, _op, _tolerance) {
+	throw new Error("occt-wasm: meshBoolean is not supported (use brepkit for mesh booleans)");
+}
+//#endregion
+//#region src/kernel/occtWasm/primitiveOps.ts
+function makeBox(k, width, height, depth) {
+	return handle("solid", k.makeBox(width, height, depth));
+}
+function makeCylinder(k, radius, height, center, direction) {
+	let id = k.makeCylinder(radius, height);
+	if (direction) id = rotateZToDirection(k, id, direction);
+	if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) id = k.translate(id, center[0], center[1], center[2]);
+	return handle("solid", id);
+}
+function makeSphere(k, radius, center) {
+	let id = k.makeSphere(radius);
+	if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) id = k.translate(id, center[0], center[1], center[2]);
+	return handle("solid", id);
+}
+function makeCone(k, radius1, radius2, height, center, direction) {
+	let id = k.makeCone(radius1, radius2, height);
+	if (direction) id = rotateZToDirection(k, id, direction);
+	if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) id = k.translate(id, center[0], center[1], center[2]);
+	return handle("solid", id);
+}
+function makeTorus(k, majorRadius, minorRadius, center, direction) {
+	let id = k.makeTorus(majorRadius, minorRadius);
+	if (direction) id = rotateZToDirection(k, id, direction);
+	if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) id = k.translate(id, center[0], center[1], center[2]);
+	return handle("solid", id);
+}
+function makeEllipsoid(k, aLength, bLength, cLength) {
+	return handle("solid", k.makeEllipsoid(aLength, bLength, cLength));
+}
+function makeBoxFromCorners(k, p1, p2) {
+	return handle("solid", k.makeBoxFromCorners(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
+}
+function makeRectangle(k, width, height) {
+	return handle("face", k.makeRectangle(width, height));
+}
+//#endregion
+//#region src/kernel/occtWasm/topologyOps.ts
+function iterShapes(k, shape, type) {
+	const vec = k.getSubShapes(unwrap(shape), type);
+	const results = [];
+	try {
+		const n = vec.size();
+		for (let i = 0; i < n; i++) results.push(handle(type, vec.get(i)));
+	} finally {
+		vec.delete();
+	}
+	return results;
+}
+function shapeType(k, shape) {
+	if (isOcctWasmHandle(shape)) return shape.type;
+	return mapShapeType(k.getShapeType(unwrap(shape)));
+}
+function isSame(k, a, b) {
+	return k.isSame(unwrap(a), unwrap(b));
+}
+function isEqual(k, a, b) {
+	return k.isEqual(unwrap(a), unwrap(b));
+}
+function downcast(k, shape, type) {
+	if (type) return handle(type, k.downcast(unwrap(shape), type));
+	return shape;
+}
+function hashCode(k, shape, upperBound) {
+	return k.hashCode(unwrap(shape), upperBound);
+}
+function isNull(k, shape) {
+	return k.isNull(unwrap(shape));
+}
+function shapeOrientation(k, shape) {
+	return k.shapeOrientation(unwrap(shape)).toLowerCase();
+}
+function edgeToFaceMap(k, shape) {
+	const vec = k.edgeToFaceMap(unwrap(shape), 1e6);
+	let data;
+	try {
+		data = readVecInt(vec);
+	} finally {
+		vec.delete();
+	}
+	const map = {};
+	for (let i = 0; i + 1 < data.length; i += 2) {
+		const edgeHash = require_vec3.wasmIndex(data, i);
+		const faceHash = require_vec3.wasmIndex(data, i + 1);
+		if (!map[edgeHash]) map[edgeHash] = [];
+		map[edgeHash].push(faceHash);
+	}
+	return JSON.stringify(map);
+}
+function sharedEdges(k, faceA, faceB) {
+	const vec = k.sharedEdges(unwrap(faceA), unwrap(faceB));
+	const results = [];
+	try {
+		const n = vec.size();
+		for (let i = 0; i < n; i++) results.push(handle("edge", vec.get(i)));
+	} finally {
+		vec.delete();
+	}
+	return results;
+}
+function adjacentFaces(k, shape, face) {
+	const vec = k.adjacentFaces(unwrap(shape), unwrap(face));
+	const results = [];
+	try {
+		const n = vec.size();
+		for (let i = 0; i < n; i++) results.push(handle("face", vec.get(i)));
+	} finally {
+		vec.delete();
+	}
+	return results;
+}
+function sew(k, Module, shapes, tolerance) {
+	const vec = makeVecU32(Module, shapes.map(unwrap));
+	try {
+		return wrapResult(k, k.sew(vec, tolerance ?? 1e-6));
+	} finally {
+		vec.delete();
+	}
+}
+//#endregion
+//#region src/kernel/occtWasm/repairOps.ts
+var HEAL_TOLERANCE = 1e-6;
+function isValid(k, shape) {
+	return k.isValid(unwrap(shape));
+}
+function healSolid(k, shape) {
+	const id = k.healSolid(unwrap(shape), HEAL_TOLERANCE);
+	if (id === 0) return null;
+	return wrapResult(k, id);
+}
+function healFace(k, shape) {
+	return wrapResult(k, k.healFace(unwrap(shape), HEAL_TOLERANCE));
+}
+function healWire(k, wire, _face) {
+	return wrapResult(k, k.healWire(unwrap(wire), HEAL_TOLERANCE));
+}
+function mergeCoincidentVertices(_k, _shape, _tolerance) {
+	return 0;
+}
+function removeDegenerateEdges(k, shape, _tolerance) {
+	k.removeDegenerateEdges(unwrap(shape));
+	return 0;
+}
+function fixFaceOrientations(k, shape) {
+	k.fixFaceOrientations(unwrap(shape));
+	return 0;
+}
+function fixShape(k, shape) {
+	return wrapResult(k, k.fixShape(unwrap(shape)));
+}
+//#endregion
+//#region src/kernel/occtWasm/meshOps.ts
+function mesh(k, Module, shape, options) {
+	const meshData = k.tessellate(unwrap(shape), options.tolerance, options.angularTolerance);
+	try {
+		const posCount = meshData.positionCount;
+		const normCount = meshData.normalCount;
+		const idxCount = meshData.indexCount;
+		const posPtr = meshData.getPositionsPtr() >> 2;
+		const normPtr = meshData.getNormalsPtr() >> 2;
+		const idxPtr = meshData.getIndicesPtr() >> 2;
+		const vertices = new Float32Array(posCount);
+		for (let i = 0; i < posCount; i++) vertices[i] = Module.HEAPF32[posPtr + i] ?? 0;
+		const normals = new Float32Array(normCount);
+		if (!options.skipNormals) for (let i = 0; i < normCount; i++) normals[i] = Module.HEAPF32[normPtr + i] ?? 0;
+		const triangles = new Uint32Array(idxCount);
+		for (let i = 0; i < idxCount; i++) triangles[i] = Module.HEAPU32[idxPtr + i] ?? 0;
+		const faceGroups = [];
+		const fgCount = meshData.faceGroupCount;
+		if (fgCount > 0) {
+			const fgPtr = meshData.getFaceGroupsPtr() >> 2;
+			for (let i = 0; i < fgCount; i += 3) faceGroups.push({
+				start: Module.HEAP32[fgPtr + i] ?? 0,
+				count: Module.HEAP32[fgPtr + i + 1] ?? 0,
+				faceHash: Module.HEAP32[fgPtr + i + 2] ?? 0
+			});
+		}
+		return {
+			vertices,
+			normals: options.skipNormals ? new Float32Array(0) : normals,
+			triangles,
+			uvs: new Float32Array(0),
+			faceGroups
+		};
+	} finally {
+		meshData.delete();
+	}
+}
+function meshEdges(k, Module, shape, tolerance, _angularTolerance) {
+	const edgeData = k.wireframe(unwrap(shape), tolerance);
+	try {
+		const pointCount = edgeData.pointCount;
+		const ptr = edgeData.getPointsPtr() >> 2;
+		const lines = new Float32Array(pointCount);
+		for (let i = 0; i < pointCount; i++) lines[i] = Module.HEAPF32[ptr + i] ?? 0;
+		const edgeGroups = [];
+		const egCount = edgeData.edgeGroupCount;
+		if (egCount > 0) {
+			const egPtr = edgeData.getEdgeGroupsPtr() >> 2;
+			for (let i = 0; i < egCount; i += 3) edgeGroups.push({
+				start: Module.HEAP32[egPtr + i] ?? 0,
+				count: Module.HEAP32[egPtr + i + 1] ?? 0,
+				edgeHash: Module.HEAP32[egPtr + i + 2] ?? 0
+			});
+		}
+		return {
+			lines,
+			edgeGroups
+		};
+	} finally {
+		edgeData.delete();
+	}
+}
+function hasTriangulation(k, shape) {
+	return k.hasTriangulation(unwrap(shape));
+}
+function meshShape(k, shape, tolerance, angularTolerance) {
+	k.meshShape(unwrap(shape), tolerance, angularTolerance).delete();
+}
+//#endregion
+//#region src/kernel/occtWasm/curveOps.ts
+var CURVE_TYPE_MAP = {
+	line: "LINE",
+	circle: "CIRCLE",
+	ellipse: "ELLIPSE",
+	hyperbola: "HYPERBOLA",
+	parabola: "PARABOLA",
+	bezier: "BEZIER_CURVE",
+	bspline: "BSPLINE_CURVE",
+	offset: "OFFSET_CURVE",
+	other: "OTHER_CURVE"
+};
+function curveType(k, shape) {
+	const t = k.curveType(unwrap(shape));
+	return CURVE_TYPE_MAP[t] ?? t.toUpperCase();
+}
+function curveParameters(k, shape) {
+	const vec = k.curveParameters(unwrap(shape));
+	try {
+		return [vec.get(0), vec.get(1)];
+	} finally {
+		vec.delete();
+	}
+}
+function curvePointAtParam(k, shape, param) {
+	const vec = k.curvePointAtParam(unwrap(shape), param);
+	try {
+		return [
+			vec.get(0),
+			vec.get(1),
+			vec.get(2)
+		];
+	} finally {
+		vec.delete();
+	}
+}
+function curveTangent(k, shape, param) {
+	const tvec = k.curveTangent(unwrap(shape), param);
+	try {
+		const pvec = k.curvePointAtParam(unwrap(shape), param);
+		try {
+			return {
+				point: [
+					pvec.get(0),
+					pvec.get(1),
+					pvec.get(2)
+				],
+				tangent: [
+					tvec.get(0),
+					tvec.get(1),
+					tvec.get(2)
+				]
+			};
+		} finally {
+			pvec.delete();
+		}
+	} finally {
+		tvec.delete();
+	}
+}
+function curveIsClosed(k, shape) {
+	return k.curveIsClosed(unwrap(shape));
+}
+function curveIsPeriodic(k, shape) {
+	return k.curveIsPeriodic(unwrap(shape));
+}
+function curvePeriod(_k, _shape) {
+	return 2 * Math.PI;
+}
+function interpolatePoints(k, Module, points, options) {
+	const flat = [];
+	for (const p of points) flat.push(p[0], p[1], p[2]);
+	const vec = makeVecDouble(Module, flat);
+	try {
+		return handle("edge", k.interpolatePoints(vec, options?.periodic ?? false));
+	} finally {
+		vec.delete();
+	}
+}
+function approximatePoints(k, Module, points, options) {
+	const flat = [];
+	for (const p of points) flat.push(p[0], p[1], p[2]);
+	const vec = makeVecDouble(Module, flat);
+	try {
+		return handle("edge", k.approximatePoints(vec, options?.tolerance ?? .001));
+	} finally {
+		vec.delete();
+	}
+}
+function getNurbsCurveData(k, edge) {
+	try {
+		const data = k.getNurbsCurveData(unwrap(edge));
+		try {
+			const nPoles = data.poles.size() / 3;
+			const poles = [];
+			for (let i = 0; i < nPoles; i++) poles.push([
+				data.poles.get(i * 3),
+				data.poles.get(i * 3 + 1),
+				data.poles.get(i * 3 + 2)
+			]);
+			const knots = [];
+			for (let i = 0; i < data.knots.size(); i++) knots.push(data.knots.get(i));
+			const multiplicities = [];
+			for (let i = 0; i < data.multiplicities.size(); i++) multiplicities.push(data.multiplicities.get(i));
+			const weights = [];
+			if (data.rational) for (let i = 0; i < data.weights.size(); i++) weights.push(data.weights.get(i));
+			else for (let i = 0; i < nPoles; i++) weights.push(1);
+			return {
+				degree: data.degree,
+				poles,
+				weights,
+				knots,
+				multiplicities,
+				isPeriodic: data.periodic,
+				isRational: data.rational
+			};
+		} finally {
+			data.delete();
+		}
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/kernel/occtWasm/surfaceOps.ts
+function vertexPosition(k, vertex) {
+	const vec = k.vertexPosition(unwrap(vertex));
+	try {
+		return [
+			vec.get(0),
+			vec.get(1),
+			vec.get(2)
+		];
+	} finally {
+		vec.delete();
+	}
+}
+function surfaceType(k, face) {
+	return k.surfaceType(unwrap(face)).toLowerCase();
+}
+function uvBounds(k, face) {
+	const vec = k.uvBounds(unwrap(face));
+	try {
+		return {
+			uMin: vec.get(0),
+			uMax: vec.get(1),
+			vMin: vec.get(2),
+			vMax: vec.get(3)
+		};
+	} finally {
+		vec.delete();
+	}
+}
+function outerWire(k, face) {
+	return handle("wire", k.outerWire(unwrap(face)));
+}
+function surfaceNormal(k, face, u, v) {
+	const vec = k.surfaceNormal(unwrap(face), u, v);
+	try {
+		return [
+			vec.get(0),
+			vec.get(1),
+			vec.get(2)
+		];
+	} finally {
+		vec.delete();
+	}
+}
+function pointOnSurface(k, face, u, v) {
+	const vec = k.pointOnSurface(unwrap(face), u, v);
+	try {
+		return [
+			vec.get(0),
+			vec.get(1),
+			vec.get(2)
+		];
+	} finally {
+		vec.delete();
+	}
+}
+function uvFromPoint(k, face, point) {
+	const vec = k.uvFromPoint(unwrap(face), point[0], point[1], point[2]);
+	try {
+		if (vec.size() < 2) return null;
+		return [vec.get(0), vec.get(1)];
+	} finally {
+		vec.delete();
+	}
+}
+function projectPointOnFace(k, face, point) {
+	const vec = k.projectPointOnFace(unwrap(face), point[0], point[1], point[2]);
+	try {
+		return [
+			vec.get(0),
+			vec.get(1),
+			vec.get(2)
+		];
+	} finally {
+		vec.delete();
+	}
+}
+function classifyPointOnFace(k, face, u, v, _tolerance) {
+	return k.classifyPointOnFace(unwrap(face), u, v).toLowerCase();
+}
+function projectEdges(k, Module, shape, cameraOrigin, cameraDirection, cameraXAxis) {
+	const [ox, oy, oz] = cameraOrigin;
+	const [dx, dy, dz] = cameraDirection;
+	const hasXAxis = !!cameraXAxis;
+	const [xx, xy, xz] = cameraXAxis ?? [
+		1,
+		0,
+		0
+	];
+	const proj = k.projectEdges(unwrap(shape), ox, oy, oz, dx, dy, dz, xx, xy, xz, hasXAxis);
+	const wrapOrNull = (id) => id === 0 ? handle("compound", k.makeCompound(new Module.VectorUint32())) : handle("compound", id);
+	return {
+		visible: {
+			outline: wrapOrNull(proj.visibleOutline),
+			smooth: wrapOrNull(proj.visibleSmooth),
+			sharp: wrapOrNull(proj.visibleSharp)
+		},
+		hidden: {
+			outline: wrapOrNull(proj.hiddenOutline),
+			smooth: wrapOrNull(proj.hiddenSmooth),
+			sharp: wrapOrNull(proj.hiddenSharp)
+		}
+	};
+}
+//#endregion
+//#region src/kernel/occtWasm/measureOps.ts
+function volume(k, shape) {
+	return k.getVolume(unwrap(shape));
+}
+function area(k, shape) {
+	return k.getSurfaceArea(unwrap(shape));
+}
+function length(k, shape) {
+	return k.getLength(unwrap(shape));
+}
+function centerOfMass(k, shape) {
+	const vec = k.getCenterOfMass(unwrap(shape));
+	try {
+		return [
+			vec.get(0),
+			vec.get(1),
+			vec.get(2)
+		];
+	} finally {
+		vec.delete();
+	}
+}
+function linearCenterOfMass(k, shape) {
+	const vec = k.getLinearCenterOfMass(unwrap(shape));
+	try {
+		return [
+			vec.get(0),
+			vec.get(1),
+			vec.get(2)
+		];
+	} finally {
+		vec.delete();
+	}
+}
+function boundingBox(k, shape) {
+	const bb = k.getBoundingBox(unwrap(shape), true);
+	return {
+		min: [
+			bb.xmin,
+			bb.ymin,
+			bb.zmin
+		],
+		max: [
+			bb.xmax,
+			bb.ymax,
+			bb.zmax
+		]
+	};
+}
+function surfaceCenterOfMass(k, face) {
+	try {
+		const v = k.getSurfaceCenterOfMass(unwrap(face));
+		try {
+			return [
+				v.get(0),
+				v.get(1),
+				v.get(2)
+			];
+		} finally {
+			v.delete();
+		}
+	} catch {
+		return [
+			0,
+			0,
+			0
+		];
+	}
+}
+function measureBulk(k, shape, includeLinear) {
+	return {
+		volume: volume(k, shape),
+		area: area(k, shape),
+		length: includeLinear ? length(k, shape) : 0,
+		centerOfMass: centerOfMass(k, shape),
+		boundingBox: boundingBox(k, shape)
+	};
+}
+function createDistanceQuery(k, referenceShape) {
+	const refId = unwrap(referenceShape);
+	return {
+		distanceTo(shape) {
+			return {
+				value: k.distanceBetween(refId, unwrap(shape)),
+				point1: [
+					0,
+					0,
+					0
+				],
+				point2: [
+					0,
+					0,
+					0
+				]
+			};
+		},
+		dispose: noop
+	};
+}
+var MAX_MESH_SAMPLES = 256;
+/**
+* Collect 3D sample points from a shape for nearest-pair queries: every
+* topological vertex, plus tessellation vertices when the shape carries
+* surfaces. Used by distance() to approximate witness points.
+*/
+function collectDistanceSamples(k, mod, shapeId) {
+	const out = [];
+	const verts = k.getSubShapes(shapeId, "vertex");
+	try {
+		const n = verts.size();
+		for (let i = 0; i < n; i++) {
+			const p = k.vertexPosition(verts.get(i));
+			out.push([
+				p.get(0),
+				p.get(1),
+				p.get(2)
+			]);
+			p.delete();
+		}
+	} finally {
+		verts.delete();
+	}
+	const bb = k.getBoundingBox(shapeId, true);
+	const diag = Math.sqrt((bb.xmax - bb.xmin) ** 2 + (bb.ymax - bb.ymin) ** 2 + (bb.zmax - bb.zmin) ** 2);
+	const linDef = Math.max(diag * .01, 1e-4);
+	let mesh;
+	try {
+		mesh = k.tessellate(shapeId, linDef, .5);
+	} catch {
+		return out;
+	}
+	try {
+		const posCount = mesh.positionCount;
+		if (posCount > 0) {
+			const ptr = mesh.getPositionsPtr() >> 2;
+			const heap = mod.HEAPF32;
+			const vertexCount = Math.floor(posCount / 3);
+			const step = (vertexCount > MAX_MESH_SAMPLES ? Math.ceil(vertexCount / MAX_MESH_SAMPLES) : 1) * 3;
+			for (let i = 0; i < posCount; i += step) out.push([
+				heap[ptr + i] ?? 0,
+				heap[ptr + i + 1] ?? 0,
+				heap[ptr + i + 2] ?? 0
+			]);
+		}
+	} finally {
+		mesh.delete();
+	}
+	return out;
+}
+function distance(k, mod, shape1, shape2) {
+	const id1 = unwrap(shape1);
+	const id2 = unwrap(shape2);
+	const value = k.distanceBetween(id1, id2);
+	const samples1 = collectDistanceSamples(k, mod, id1);
+	const samples2 = collectDistanceSamples(k, mod, id2);
+	if (samples1.length === 0 || samples2.length === 0) return {
+		value,
+		point1: [
+			0,
+			0,
+			0
+		],
+		point2: [
+			0,
+			0,
+			0
+		]
+	};
+	let bestD2 = Infinity;
+	let bestP1 = samples1[0] ?? [
+		0,
+		0,
+		0
+	];
+	let bestP2 = samples2[0] ?? [
+		0,
+		0,
+		0
+	];
+	for (const p1 of samples1) for (const p2 of samples2) {
+		const dx = p2[0] - p1[0];
+		const dy = p2[1] - p1[1];
+		const dz = p2[2] - p1[2];
+		const d2 = dx * dx + dy * dy + dz * dz;
+		if (d2 < bestD2) {
+			bestD2 = d2;
+			bestP1 = p1;
+			bestP2 = p2;
+		}
+	}
+	return {
+		value,
+		point1: bestP1,
+		point2: bestP2
+	};
+}
+function pointAt(k, faceId, u, v) {
+	const p = k.pointOnSurface(faceId, u, v);
+	const r = [
+		p.get(0),
+		p.get(1),
+		p.get(2)
+	];
+	p.delete();
+	return r;
+}
+/**
+* Sample a 9-point stencil around (u, v) and return central-difference
+* partial derivatives Pu, Pv, Puu, Pvv, Puv. Step size is 1e-3 of the
+* parametric range (clamped at 1e-6) — the sweet spot between truncation
+* error and float-eval noise. Near the boundary the stencil shifts inward
+* so all sample points stay in the domain.
+*/
+function surfaceDerivatives(k, faceId, u, v) {
+	const bounds = k.uvBounds(faceId);
+	const uMin = bounds.get(0);
+	const uMax = bounds.get(1);
+	const vMin = bounds.get(2);
+	const vMax = bounds.get(3);
+	bounds.delete();
+	const hu = Math.max(Math.max(uMax - uMin, 1e-12) * .001, 1e-6);
+	const hv = Math.max(Math.max(vMax - vMin, 1e-12) * .001, 1e-6);
+	const uc = Math.min(Math.max(u, uMin + hu), uMax - hu);
+	const vc = Math.min(Math.max(v, vMin + hv), vMax - hv);
+	const P = pointAt(k, faceId, uc, vc);
+	const Pup = pointAt(k, faceId, uc + hu, vc);
+	const Pum = pointAt(k, faceId, uc - hu, vc);
+	const Pvp = pointAt(k, faceId, uc, vc + hv);
+	const Pvm = pointAt(k, faceId, uc, vc - hv);
+	const Ppp = pointAt(k, faceId, uc + hu, vc + hv);
+	const Ppm = pointAt(k, faceId, uc + hu, vc - hv);
+	const Pmp = pointAt(k, faceId, uc - hu, vc + hv);
+	const Pmm = pointAt(k, faceId, uc - hu, vc - hv);
+	const huu = hu * hu;
+	const hvv = hv * hv;
+	const huv4 = 4 * hu * hv;
+	return {
+		Pu: [
+			(Pup[0] - Pum[0]) / (2 * hu),
+			(Pup[1] - Pum[1]) / (2 * hu),
+			(Pup[2] - Pum[2]) / (2 * hu)
+		],
+		Pv: [
+			(Pvp[0] - Pvm[0]) / (2 * hv),
+			(Pvp[1] - Pvm[1]) / (2 * hv),
+			(Pvp[2] - Pvm[2]) / (2 * hv)
+		],
+		Puu: [
+			(Pup[0] - 2 * P[0] + Pum[0]) / huu,
+			(Pup[1] - 2 * P[1] + Pum[1]) / huu,
+			(Pup[2] - 2 * P[2] + Pum[2]) / huu
+		],
+		Pvv: [
+			(Pvp[0] - 2 * P[0] + Pvm[0]) / hvv,
+			(Pvp[1] - 2 * P[1] + Pvm[1]) / hvv,
+			(Pvp[2] - 2 * P[2] + Pvm[2]) / hvv
+		],
+		Puv: [
+			(Ppp[0] - Ppm[0] - Pmp[0] + Pmm[0]) / huv4,
+			(Ppp[1] - Ppm[1] - Pmp[1] + Pmm[1]) / huv4,
+			(Ppp[2] - Ppm[2] - Pmp[2] + Pmm[2]) / huv4
+		]
+	};
+}
+/**
+* Return a non-zero eigenvector of the singular matrix [[a,b],[c,d]] (whose
+* eigenvalue is implicit — caller has already subtracted λ from the diagonal).
+* Picks the row with the larger magnitude for numerical stability.
+*/
+function eigenvector2x2(a, b, c, d) {
+	if (Math.abs(a) + Math.abs(b) >= Math.abs(c) + Math.abs(d)) {
+		if (Math.abs(a) + Math.abs(b) < 1e-12) return [1, 0];
+		return [-b, a];
+	}
+	if (Math.abs(c) + Math.abs(d) < 1e-12) return [0, 1];
+	return [-d, c];
+}
+function liftAndNormalize(ab, Pu, Pv) {
+	const x = ab[0] * Pu[0] + ab[1] * Pv[0];
+	const y = ab[0] * Pu[1] + ab[1] * Pv[1];
+	const z = ab[0] * Pu[2] + ab[1] * Pv[2];
+	const len = Math.sqrt(x * x + y * y + z * z);
+	if (len < 1e-12) return [
+		1,
+		0,
+		0
+	];
+	return [
+		x / len,
+		y / len,
+		z / len
+	];
+}
+/**
+* Fallback when curvature is direction-degenerate: return an orthonormal
+* tangent frame derived from Pu and the Gram-Schmidt-corrected Pv.
+*/
+function degenerateOrthoFrame(Pu, Pv) {
+	const uLen = Math.sqrt(Pu[0] * Pu[0] + Pu[1] * Pu[1] + Pu[2] * Pu[2]);
+	if (uLen < 1e-12) return {
+		maxDirection: [
+			1,
+			0,
+			0
+		],
+		minDirection: [
+			0,
+			1,
+			0
+		]
+	};
+	const ux = Pu[0] / uLen, uy = Pu[1] / uLen, uz = Pu[2] / uLen;
+	const dot = ux * Pv[0] + uy * Pv[1] + uz * Pv[2];
+	const vx = Pv[0] - dot * ux;
+	const vy = Pv[1] - dot * uy;
+	const vz = Pv[2] - dot * uz;
+	const vLen = Math.sqrt(vx * vx + vy * vy + vz * vz);
+	if (vLen < 1e-12) {
+		const ax = Math.abs(ux) < .9 ? [
+			1,
+			0,
+			0
+		] : [
+			0,
+			1,
+			0
+		];
+		const ox = uy * ax[2] - uz * ax[1];
+		const oy = uz * ax[0] - ux * ax[2];
+		const oz = ux * ax[1] - uy * ax[0];
+		const oLen = Math.sqrt(ox * ox + oy * oy + oz * oz) || 1;
+		return {
+			maxDirection: [
+				ux,
+				uy,
+				uz
+			],
+			minDirection: [
+				ox / oLen,
+				oy / oLen,
+				oz / oLen
+			]
+		};
+	}
+	return {
+		maxDirection: [
+			ux,
+			uy,
+			uz
+		],
+		minDirection: [
+			vx / vLen,
+			vy / vLen,
+			vz / vLen
+		]
+	};
+}
+/**
+* Compute principal curvature directions at (u, v) via finite-difference
+* fundamental forms. The C++ facade exposes only k1 and k2 as scalars; this
+* helper recovers the corresponding tangent directions in 3D space.
+*/
+function computePrincipalDirections(k, faceId, u, v, maxK, minK) {
+	const { Pu, Pv, Puu, Pvv, Puv } = surfaceDerivatives(k, faceId, u, v);
+	const nx = Pu[1] * Pv[2] - Pu[2] * Pv[1];
+	const ny = Pu[2] * Pv[0] - Pu[0] * Pv[2];
+	const nz = Pu[0] * Pv[1] - Pu[1] * Pv[0];
+	const nlen = Math.sqrt(nx * nx + ny * ny + nz * nz);
+	const E = Pu[0] * Pu[0] + Pu[1] * Pu[1] + Pu[2] * Pu[2];
+	const F = Pu[0] * Pv[0] + Pu[1] * Pv[1] + Pu[2] * Pv[2];
+	const G = Pv[0] * Pv[0] + Pv[1] * Pv[1] + Pv[2] * Pv[2];
+	if (nlen < 1e-12 || E * G - F * F < 1e-24) return degenerateOrthoFrame(Pu, Pv);
+	const e = (Puu[0] * nx + Puu[1] * ny + Puu[2] * nz) / nlen;
+	const f = (Puv[0] * nx + Puv[1] * ny + Puv[2] * nz) / nlen;
+	const g = (Pvv[0] * nx + Pvv[1] * ny + Pvv[2] * nz) / nlen;
+	const det = E * G - F * F;
+	const w11 = (e * G - f * F) / det;
+	const w12 = (f * G - g * F) / det;
+	const w21 = (f * E - e * F) / det;
+	const w22 = (g * E - f * F) / det;
+	if (Math.abs(maxK - minK) < 1e-9 * (Math.abs(maxK) + Math.abs(minK) + 1)) return degenerateOrthoFrame(Pu, Pv);
+	const dirMax2D = eigenvector2x2(w11 - maxK, w12, w21, w22 - maxK);
+	const dirMin2D = eigenvector2x2(w11 - minK, w12, w21, w22 - minK);
+	return {
+		maxDirection: liftAndNormalize(dirMax2D, Pu, Pv),
+		minDirection: liftAndNormalize(dirMin2D, Pu, Pv)
+	};
+}
+function surfaceCurvature(k, face, u, v) {
+	const faceId = unwrap(face);
+	const vec = k.surfaceCurvature(faceId, u, v);
+	const mean = vec.get(0);
+	const gaussian = vec.get(1);
+	const maxK = vec.get(2);
+	const minK = vec.get(3);
+	vec.delete();
+	const { maxDirection, minDirection } = computePrincipalDirections(k, faceId, u, v, maxK, minK);
+	return {
+		gaussian,
+		mean,
+		max: maxK,
+		min: minK,
+		maxDirection,
+		minDirection
+	};
+}
+//#endregion
+//#region src/kernel/occtWasm/modifierOps.ts
+function fillet(k, Module, shape, edges, radius) {
+	const r = resolveUniformRadius(edges, radius);
+	const vec = makeVecU32(Module, edges.map(unwrap));
+	try {
+		return wrapResult(k, k.fillet(unwrap(shape), vec, r));
+	} finally {
+		vec.delete();
+	}
+}
+function chamfer(k, Module, shape, edges, distance) {
+	const d = resolveUniformRadius(edges, distance);
+	const vec = makeVecU32(Module, edges.map(unwrap));
+	try {
+		return wrapResult(k, k.chamfer(unwrap(shape), vec, d));
+	} finally {
+		vec.delete();
+	}
+}
+function chamferDistAngle(k, Module, shape, edges, distance, angleDeg) {
+	const vec = makeVecU32(Module, edges.map(unwrap));
+	try {
+		return wrapResult(k, k.chamferDistAngle(unwrap(shape), vec, distance, angleDeg));
+	} finally {
+		vec.delete();
+	}
+}
+function shell(k, Module, shape, faces, thickness, tolerance) {
+	const vec = makeVecU32(Module, faces.map(unwrap));
+	try {
+		return wrapResult(k, k.shell(unwrap(shape), vec, thickness, tolerance ?? .001));
+	} finally {
+		vec.delete();
+	}
+}
+function thicken(k, shape, thickness) {
+	return wrapResult(k, k.thicken(unwrap(shape), thickness, .001));
+}
+function offset(k, shape, distance, tolerance) {
+	return wrapResult(k, k.offset(unwrap(shape), distance, tolerance ?? 1e-6));
+}
+function filletVariable(k, shape, spec) {
+	const parsed = JSON.parse(spec);
+	if (parsed.edgeId !== void 0 && parsed.startRadius !== void 0 && parsed.endRadius !== void 0) return wrapResult(k, k.filletVariable(unwrap(shape), parsed.edgeId, parsed.startRadius, parsed.endRadius));
+	throw new Error("occt-wasm: filletVariable (complex spec) not implemented");
+}
+function draft(k, shape, faces, pullDirection, _neutralPlane, angleDeg) {
+	let currentId = unwrap(shape);
+	for (const face of faces) {
+		const angleRad = (typeof angleDeg === "function" ? angleDeg(face) : angleDeg) * Math.PI / 180;
+		currentId = k.draft(currentId, unwrap(face), angleRad, pullDirection[0], pullDirection[1], pullDirection[2]);
+	}
+	return wrapResult(k, currentId);
+}
+function defeature(k, Module, shape, faces) {
+	const vec = makeVecU32(Module, faces.map(unwrap));
+	try {
+		return wrapResult(k, k.defeature(unwrap(shape), vec, .001));
+	} finally {
+		vec.delete();
+	}
+}
+function offsetWire2D(k, wire, offset, joinType) {
+	let jt = 0;
+	if (joinType === "intersection" || joinType === 1) jt = 1;
+	else if (joinType === "tangent" || joinType === 2) jt = 2;
+	else if (typeof joinType === "number") jt = joinType;
+	return wrapResult(k, k.offsetWire2D(unwrap(wire), offset, jt));
+}
+function simplify(k, shape) {
+	return wrapResult(k, k.simplify(unwrap(shape)));
+}
+function reverseShape(k, shape) {
+	return wrapResult(k, k.reverseShape(unwrap(shape)));
+}
+//#endregion
+//#region src/kernel/occtWasm/sweepOps.ts
+function extrude(k, face, direction, length) {
+	const dx = direction[0] * length;
+	const dy = direction[1] * length;
+	const dz = direction[2] * length;
+	return wrapResult(k, k.extrude(unwrap(face), dx, dy, dz));
+}
+function revolve(k, shape, axis, angle) {
+	const o = axis.origin;
+	const d = axis.direction;
+	return wrapResult(k, k.revolve(unwrap(shape), o.x, o.y, o.z, d.x, d.y, d.z, angle));
+}
+function loft(k, Module, wires, ruled, _startShape, _endShape) {
+	const vec = makeVecU32(Module, wires.map(unwrap));
+	try {
+		return wrapResult(k, k.loft(vec, true, ruled ?? false));
+	} finally {
+		vec.delete();
+	}
+}
+function sweep(k, wire, spine, options) {
+	const mode = options?.transitionMode ?? 0;
+	return wrapResult(k, k.sweep(unwrap(wire), unwrap(spine), mode));
+}
+function simplePipe(k, profile, spine) {
+	return wrapResult(k, k.simplePipe(unwrap(profile), unwrap(spine)));
+}
+function sweepPipeShell(k, profile, spine, options) {
+	const freenet = options?.frenet ?? false;
+	const smooth = options?.transitionMode === "round";
+	const shellMode = options?.shellMode ?? false;
+	const result = wrapResult(k, k.sweepPipeShell(unwrap(profile), unwrap(spine), freenet, smooth));
+	if (shellMode) {
+		const edges = k.getSubShapes(unwrap(result), "wire");
+		try {
+			return {
+				shape: result,
+				firstShape: edges.size() > 0 ? wrapResult(k, edges.get(0)) : result,
+				lastShape: edges.size() > 1 ? wrapResult(k, edges.get(edges.size() - 1)) : result
+			};
+		} finally {
+			edges.delete();
+		}
+	}
+	return result;
+}
+function loftAdvanced(k, Module, wires, options) {
+	const isSolid = options?.solid ?? true;
+	const ruled = options?.ruled ?? false;
+	const startV = options?.startVertex ? unwrap(options.startVertex) : 0;
+	const endV = options?.endVertex ? unwrap(options.endVertex) : 0;
+	const vec = makeVecU32(Module, wires.map(unwrap));
+	try {
+		if (startV || endV) return wrapResult(k, k.loftWithVertices(vec, isSolid, ruled, startV, endV));
+		return wrapResult(k, k.loft(vec, isSolid, ruled));
+	} finally {
+		vec.delete();
+	}
+}
+function buildExtrusionLaw(_k, profile, length, endFactor) {
+	const law = {
+		__occtWasmLaw: true,
+		profile,
+		length,
+		endFactor,
+		Trim(first, last, _tol) {
+			return {
+				...law,
+				trimFirst: first,
+				trimLast: last
+			};
+		},
+		delete() {}
+	};
+	return law;
+}
+function revolveVec(k, shape, center, direction, angle) {
+	return wrapResult(k, k.revolveVec(unwrap(shape), center[0], center[1], center[2], direction[0], direction[1], direction[2], angle));
+}
+function draftPrism(k, shape, _face, _baseFace, height, angleDeg, _fuse) {
+	const h = height ?? 10;
+	return wrapResult(k, k.draftPrism(unwrap(shape), 0, 0, h, angleDeg));
+}
+//#endregion
+//#region src/kernel/occtWasm/transformOps.ts
+function composeTransform(ops) {
+	let matrix = [
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1
+	];
+	for (const op of ops) if (op.type === "translate") matrix = multiplyMatrices4x4([
+		1,
+		0,
+		0,
+		op.x,
+		0,
+		1,
+		0,
+		op.y,
+		0,
+		0,
+		1,
+		op.z,
+		0,
+		0,
+		0,
+		1
+	], matrix);
+	else {
+		const ax = op.axis ?? [
+			0,
+			0,
+			1
+		];
+		const cn = op.center ?? [
+			0,
+			0,
+			0
+		];
+		const rad = op.angle * Math.PI / 180;
+		const c = Math.cos(rad);
+		const s = Math.sin(rad);
+		const t = 1 - c;
+		const len = Math.sqrt(ax[0] ** 2 + ax[1] ** 2 + ax[2] ** 2);
+		const [ux, uy, uz] = [
+			ax[0] / len,
+			ax[1] / len,
+			ax[2] / len
+		];
+		const r00 = t * ux * ux + c;
+		const r01 = t * ux * uy - s * uz;
+		const r02 = t * ux * uz + s * uy;
+		const r10 = t * uy * ux + s * uz;
+		const r11 = t * uy * uy + c;
+		const r12 = t * uy * uz - s * ux;
+		const r20 = t * uz * ux - s * uy;
+		const r21 = t * uz * uy + s * ux;
+		const r22 = t * uz * uz + c;
+		matrix = multiplyMatrices4x4([
+			r00,
+			r01,
+			r02,
+			cn[0] - (r00 * cn[0] + r01 * cn[1] + r02 * cn[2]),
+			r10,
+			r11,
+			r12,
+			cn[1] - (r10 * cn[0] + r11 * cn[1] + r12 * cn[2]),
+			r20,
+			r21,
+			r22,
+			cn[2] - (r20 * cn[0] + r21 * cn[1] + r22 * cn[2]),
+			0,
+			0,
+			0,
+			1
+		], matrix);
+	}
+	return {
+		handle: {
+			__type: "transform_matrix",
+			matrix,
+			delete: noop
+		},
+		dispose: noop
+	};
+}
+function transform(k, Module, shape, trsf) {
+	const t = trsf;
+	let matrix;
+	if (Array.isArray(t)) matrix = t;
+	else if (typeof t === "object") {
+		if (Array.isArray(t["matrix"])) {
+			matrix = t["matrix"];
+			if (matrix.length === 16) matrix = matrix.slice(0, 12);
+		} else if (Array.isArray(t["elements"])) matrix = t["elements"];
+	}
+	if (matrix) {
+		if (matrix.length === 16) matrix = matrix.slice(0, 12);
+		if (matrix.length >= 12) {
+			const vec = makeVecDouble(Module, matrix);
+			try {
+				return wrapResult(k, k.transform(unwrap(shape), vec));
+			} finally {
+				vec.delete();
+			}
+		}
+	}
+	return handle(k.getShapeType(unwrap(shape)), k.copy(unwrap(shape)));
+}
+function translate(k, shape, x, y, z) {
+	return wrapResult(k, k.translate(unwrap(shape), x, y, z));
+}
+function rotate(k, shape, angle, axis, center) {
+	const ax = axis ?? [
+		0,
+		0,
+		1
+	];
+	const cn = center ?? [
+		0,
+		0,
+		0
+	];
+	return wrapResult(k, k.rotate(unwrap(shape), cn[0], cn[1], cn[2], ax[0], ax[1], ax[2], angle));
+}
+function mirror(k, shape, origin, normal) {
+	return wrapResult(k, k.mirror(unwrap(shape), origin[0], origin[1], origin[2], normal[0], normal[1], normal[2]));
+}
+function scale(k, shape, center, factor) {
+	return wrapResult(k, k.scale(unwrap(shape), center[0], center[1], center[2], factor));
+}
+function generalTransform(k, Module, shape, linear, translation, _isOrthogonal) {
+	const vec = makeVecDouble(Module, [
+		linear[0],
+		linear[1],
+		linear[2],
+		translation[0],
+		linear[3],
+		linear[4],
+		linear[5],
+		translation[1],
+		linear[6],
+		linear[7],
+		linear[8],
+		translation[2]
+	]);
+	try {
+		return wrapResult(k, k.generalTransform(unwrap(shape), vec));
+	} finally {
+		vec.delete();
+	}
+}
+function positionOnCurve(k, Module, shape, spine, param) {
+	const ptVec = k.curvePointAtParam(unwrap(spine), param);
+	const [px, py, pz] = (() => {
+		try {
+			return [
+				ptVec.get(0),
+				ptVec.get(1),
+				ptVec.get(2)
+			];
+		} finally {
+			ptVec.delete();
+		}
+	})();
+	const tgVec = k.curveTangent(unwrap(spine), param);
+	const [tx, ty, tz] = (() => {
+		try {
+			return [
+				tgVec.get(0),
+				tgVec.get(1),
+				tgVec.get(2)
+			];
+		} finally {
+			tgVec.delete();
+		}
+	})();
+	let ux, uy, uz;
+	if (Math.abs(tx) < .9) {
+		ux = 0;
+		uy = tz;
+		uz = -ty;
+	} else {
+		ux = -tz;
+		uy = 0;
+		uz = tx;
+	}
+	const uLen = Math.sqrt(ux * ux + uy * uy + uz * uz);
+	ux /= uLen;
+	uy /= uLen;
+	uz /= uLen;
+	const vx = ty * uz - tz * uy;
+	const vy = tz * ux - tx * uz;
+	const vz = tx * uy - ty * ux;
+	const mat = new Module.VectorDouble();
+	mat.push_back(ux);
+	mat.push_back(vx);
+	mat.push_back(tx);
+	mat.push_back(px);
+	mat.push_back(uy);
+	mat.push_back(vy);
+	mat.push_back(ty);
+	mat.push_back(py);
+	mat.push_back(uz);
+	mat.push_back(vz);
+	mat.push_back(tz);
+	mat.push_back(pz);
+	try {
+		return wrapResult(k, k.transform(unwrap(shape), mat));
+	} finally {
+		mat.delete();
+	}
+}
+function linearPattern(k, shape, direction, spacing, count) {
+	const compoundId = k.linearPattern(unwrap(shape), direction[0], direction[1], direction[2], spacing, count);
+	const subVec = k.getSubShapes(compoundId, "solid");
+	const results = [];
+	try {
+		const n = subVec.size();
+		for (let i = 0; i < n; i++) results.push(handle("solid", subVec.get(i)));
+	} finally {
+		subVec.delete();
+	}
+	if (results.length === 0) {
+		const iter = k.iterShapes(compoundId);
+		try {
+			const n2 = iter.size();
+			for (let i = 0; i < n2; i++) results.push(wrapResult(k, iter.get(i)));
+		} finally {
+			iter.delete();
+		}
+	}
+	return results;
+}
+function circularPattern(k, shape, center, axis, angleStep, count) {
+	const compoundId = k.circularPattern(unwrap(shape), center[0], center[1], center[2], axis[0], axis[1], axis[2], angleStep, count);
+	const subVec = k.getSubShapes(compoundId, "solid");
+	const results = [];
+	try {
+		const n = subVec.size();
+		for (let i = 0; i < n; i++) results.push(handle("solid", subVec.get(i)));
+	} finally {
+		subVec.delete();
+	}
+	if (results.length === 0) {
+		const iter = k.iterShapes(compoundId);
+		try {
+			const n2 = iter.size();
+			for (let i = 0; i < n2; i++) results.push(wrapResult(k, iter.get(i)));
+		} finally {
+			iter.delete();
+		}
+	}
+	return results;
+}
+function transformBatch(k, entries) {
+	return entries.map((entry) => {
+		switch (entry.type) {
+			case "translate": return translate(k, entry.shape, entry.x, entry.y, entry.z);
+			case "rotate": return rotate(k, entry.shape, entry.angle, entry.axis, entry.center);
+			case "scale": return scale(k, entry.shape, entry.center, entry.factor);
+			case "mirror": return mirror(k, entry.shape, entry.origin, entry.normal);
+			default: throw new Error("occt-wasm: transformBatch unknown type");
+		}
+	});
+}
+//#endregion
+//#region src/kernel/occtWasm/ioOps.ts
+function computePositionBounds(positions, vCount) {
+	if (vCount === 0) return {
+		min: [
+			0,
+			0,
+			0
+		],
+		max: [
+			0,
+			0,
+			0
+		]
+	};
+	let minX = Infinity, minY = Infinity, minZ = Infinity;
+	let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+	for (let i = 0; i < vCount; i++) {
+		const o = i * 3;
+		const x = positions[o] ?? 0;
+		const y = positions[o + 1] ?? 0;
+		const z = positions[o + 2] ?? 0;
+		if (x < minX) minX = x;
+		if (y < minY) minY = y;
+		if (z < minZ) minZ = z;
+		if (x > maxX) maxX = x;
+		if (y > maxY) maxY = y;
+		if (z > maxZ) maxZ = z;
+	}
+	return {
+		min: [
+			minX,
+			minY,
+			minZ
+		],
+		max: [
+			maxX,
+			maxY,
+			maxZ
+		]
+	};
+}
+function buildGltfManifest(vCount, nCount, iCount, posBytes, nrmBytes, idxBytes, bufferLength, bounds) {
+	return {
+		asset: {
+			version: "2.0",
+			generator: "brepjs occt-wasm"
+		},
+		scene: 0,
+		scenes: [{ nodes: [0] }],
+		nodes: [{ mesh: 0 }],
+		meshes: [{ primitives: [{
+			attributes: {
+				POSITION: 0,
+				NORMAL: 1
+			},
+			indices: 2,
+			mode: 4
+		}] }],
+		buffers: [{ byteLength: bufferLength }],
+		bufferViews: [
+			{
+				buffer: 0,
+				byteOffset: 0,
+				byteLength: posBytes,
+				target: 34962
+			},
+			{
+				buffer: 0,
+				byteOffset: posBytes,
+				byteLength: nrmBytes,
+				target: 34962
+			},
+			{
+				buffer: 0,
+				byteOffset: posBytes + nrmBytes,
+				byteLength: idxBytes,
+				target: 34963
+			}
+		],
+		accessors: [
+			{
+				bufferView: 0,
+				componentType: 5126,
+				count: vCount,
+				type: "VEC3",
+				min: bounds.min,
+				max: bounds.max
+			},
+			{
+				bufferView: 1,
+				componentType: 5126,
+				count: nCount,
+				type: "VEC3"
+			},
+			{
+				bufferView: 2,
+				componentType: 5125,
+				count: iCount,
+				type: "SCALAR"
+			}
+		]
+	};
+}
+function exportSTEP(k, makeCompound, shapes) {
+	if (shapes.length === 1) return k.exportStep(unwrap(shapes[0]));
+	const compound = makeCompound(shapes);
+	return k.exportStep(unwrap(compound));
+}
+function exportSTL(k, shape, binary) {
+	const ascii = !binary;
+	const result = k.exportStl(unwrap(shape), .1, ascii);
+	if (binary) {
+		const buf = new ArrayBuffer(result.length);
+		const view = new Uint8Array(buf);
+		for (let i = 0; i < result.length; i++) view[i] = result.charCodeAt(i);
+		return buf;
+	}
+	return result;
+}
+function importSTEP(k, data) {
+	const str = typeof data === "string" ? data : new TextDecoder().decode(data);
+	return [wrapResult(k, k.importStep(str))];
+}
+function importSTL(k, Module, data) {
+	const bytes = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+	const mod = Module;
+	if (mod.FS) mod.FS.writeFile("/tmp/import.stl", bytes);
+	else {
+		const str = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+		return wrapResult(k, k.importStl(str));
+	}
+	return wrapResult(k, k.importStl(""));
+}
+function exportIGES(k, makeCompound, shapes) {
+	if (shapes.length === 1) return k.exportIges(unwrap(shapes[0]));
+	const compound = makeCompound(shapes);
+	return k.exportIges(unwrap(compound));
+}
+function importIGES(k, data) {
+	const str = typeof data === "string" ? data : new TextDecoder().decode(data);
+	return [wrapResult(k, k.importIges(str))];
+}
+function exportSTEPAssembly(k, Module, parts, _options) {
+	if (parts.length === 0) return "";
+	const doc = createXCAFDocument(k, Module, parts);
+	try {
+		return writeXCAFToSTEP(k, doc);
+	} finally {
+		doc.delete();
+	}
+}
+function exportGLB(mesh, shape, tolerance) {
+	const result = mesh(shape, {
+		tolerance,
+		angularTolerance: .5,
+		skipNormals: false
+	});
+	const positions = result.vertices;
+	const normals = result.normals;
+	const indices = result.triangles;
+	const vCount = positions.length / 3;
+	const nCount = normals.length / 3;
+	const iCount = indices.length;
+	const posBytes = positions.byteLength;
+	const nrmBytes = normals.byteLength;
+	const idxBytes = indices.byteLength;
+	const binLength = posBytes + nrmBytes + idxBytes;
+	const paddedBinLength = binLength + (4 - binLength % 4) % 4;
+	const manifest = buildGltfManifest(vCount, nCount, iCount, posBytes, nrmBytes, idxBytes, paddedBinLength, computePositionBounds(positions, vCount));
+	const jsonBytes = new TextEncoder().encode(JSON.stringify(manifest));
+	const paddedJsonLength = jsonBytes.byteLength + (4 - jsonBytes.byteLength % 4) % 4;
+	const totalLength = 20 + paddedJsonLength + 8 + paddedBinLength;
+	const glb = new ArrayBuffer(totalLength);
+	const view = new DataView(glb);
+	view.setUint32(0, 1179937895, true);
+	view.setUint32(4, 2, true);
+	view.setUint32(8, totalLength, true);
+	view.setUint32(12, paddedJsonLength, true);
+	view.setUint32(16, 1313821514, true);
+	const jsonDst = new Uint8Array(glb, 20, paddedJsonLength);
+	jsonDst.set(jsonBytes);
+	for (let i = jsonBytes.byteLength; i < paddedJsonLength; i++) jsonDst[i] = 32;
+	const binHeaderOffset = 20 + paddedJsonLength;
+	view.setUint32(binHeaderOffset, paddedBinLength, true);
+	view.setUint32(binHeaderOffset + 4, 5130562, true);
+	const binDataOffset = binHeaderOffset + 8;
+	new Uint8Array(glb, binDataOffset, posBytes).set(new Uint8Array(positions.buffer, positions.byteOffset, posBytes));
+	new Uint8Array(glb, binDataOffset + posBytes, nrmBytes).set(new Uint8Array(normals.buffer, normals.byteOffset, nrmBytes));
+	new Uint8Array(glb, binDataOffset + posBytes + nrmBytes, idxBytes).set(new Uint8Array(indices.buffer, indices.byteOffset, idxBytes));
+	return glb;
+}
+function exportOBJ(mesh, shape, tolerance) {
+	const result = mesh(shape, {
+		tolerance,
+		angularTolerance: .5,
+		skipNormals: false
+	});
+	const v = result.vertices;
+	const n = result.normals;
+	const t = result.triangles;
+	const lines = ["# brepjs OBJ export"];
+	const vCount = v.length / 3;
+	for (let i = 0; i < vCount; i++) {
+		const o = i * 3;
+		lines.push(`v ${v[o] ?? 0} ${v[o + 1] ?? 0} ${v[o + 2] ?? 0}`);
+	}
+	const nCount = n.length / 3;
+	for (let i = 0; i < nCount; i++) {
+		const o = i * 3;
+		lines.push(`vn ${n[o] ?? 0} ${n[o + 1] ?? 0} ${n[o + 2] ?? 0}`);
+	}
+	const pushTri = (offset) => {
+		const a = (t[offset] ?? 0) + 1;
+		const b = (t[offset + 1] ?? 0) + 1;
+		const c = (t[offset + 2] ?? 0) + 1;
+		lines.push(`f ${a}//${a} ${b}//${b} ${c}//${c}`);
+	};
+	if (result.faceGroups.length > 0) for (const group of result.faceGroups) {
+		lines.push(`g face_${group.faceHash}`);
+		const count = group.count / 3;
+		for (let i = 0; i < count; i++) pushTri(group.start + i * 3);
+	}
+	else {
+		const triCount = t.length / 3;
+		for (let i = 0; i < triCount; i++) pushTri(i * 3);
+	}
+	return new TextEncoder().encode(lines.join("\n") + "\n").buffer;
+}
+function exportPLY(mesh, shape, tolerance) {
+	const result = mesh(shape, {
+		tolerance,
+		angularTolerance: .5,
+		skipNormals: false
+	});
+	const v = result.vertices;
+	const n = result.normals;
+	const t = result.triangles;
+	const vCount = v.length / 3;
+	const triCount = t.length / 3;
+	const hasNormals = n.length === v.length;
+	const lines = [
+		"ply",
+		"format ascii 1.0",
+		"comment brepjs PLY export",
+		`element vertex ${vCount}`,
+		"property float x",
+		"property float y",
+		"property float z"
+	];
+	if (hasNormals) lines.push("property float nx", "property float ny", "property float nz");
+	lines.push(`element face ${triCount}`, "property list uchar int vertex_index", "end_header");
+	for (let i = 0; i < vCount; i++) {
+		const o = i * 3;
+		const x = v[o] ?? 0;
+		const y = v[o + 1] ?? 0;
+		const z = v[o + 2] ?? 0;
+		if (hasNormals) {
+			const nx = n[o] ?? 0;
+			const ny = n[o + 1] ?? 0;
+			const nz = n[o + 2] ?? 0;
+			lines.push(`${x} ${y} ${z} ${nx} ${ny} ${nz}`);
+		} else lines.push(`${x} ${y} ${z}`);
+	}
+	for (let i = 0; i < triCount; i++) {
+		const a = t[i * 3] ?? 0;
+		const b = t[i * 3 + 1] ?? 0;
+		const c = t[i * 3 + 2] ?? 0;
+		lines.push(`3 ${a} ${b} ${c}`);
+	}
+	return new TextEncoder().encode(lines.join("\n") + "\n").buffer;
+}
+function toBREP(k, shape) {
+	return k.toBREP(unwrap(shape));
+}
+function fromBREP(k, data) {
+	return wrapResult(k, k.fromBREP(data));
+}
+function createXCAFDocument(k, Module, shapes) {
+	const ids = new Module.VectorUint32();
+	const colors = new Module.VectorDouble();
+	const nameParts = [];
+	for (const entry of shapes) {
+		ids.push_back(unwrap(entry.shape));
+		nameParts.push(entry.name);
+		const [r, g, b, a] = entry.color ?? [
+			.5,
+			.5,
+			.5,
+			1
+		];
+		colors.push_back(r);
+		colors.push_back(g);
+		colors.push_back(b);
+		colors.push_back(a);
+	}
+	try {
+		const joinedNames = nameParts.join("\0");
+		return handle("compound", k.createXCAFDocument(ids, joinedNames, colors));
+	} finally {
+		ids.delete();
+		colors.delete();
+	}
+}
+function writeXCAFToSTEP(k, doc, _options) {
+	const id = unwrap(doc);
+	const subs = k.getSubShapes(id, "solid");
+	if (!(() => {
+		try {
+			return subs.size() > 0;
+		} finally {
+			subs.delete();
+		}
+	})()) {
+		const faces = k.getSubShapes(id, "face");
+		if (!(() => {
+			try {
+				return faces.size() > 0;
+			} finally {
+				faces.delete();
+			}
+		})()) return "";
+	}
+	return k.writeXCAFToSTEP(id);
+}
+function exportSTEPConfigured(k, Module, shapes, _options) {
+	if (shapes.length === 0) return "";
+	const doc = createXCAFDocument(k, Module, shapes.map((s) => ({
+		shape: s.shape,
+		name: s.name ?? "",
+		color: s.color
+	})));
+	try {
+		return writeXCAFToSTEP(k, doc);
+	} finally {
+		doc.delete();
+	}
+}
+//#endregion
+//#region src/kernel/occtWasm/constructionOps.ts
+function makeVertex(k, x, y, z) {
+	return handle("vertex", k.makeVertex(x, y, z));
+}
+function makeEdge(_k, curve) {
+	if (isOcctWasmHandle(curve)) throw new Error("occt-wasm: makeEdge from curve handle is not implemented");
+	throw new Error("occt-wasm: makeEdge is not implemented");
+}
+function makeWire(k, Module, edges) {
+	const vec = makeVecU32(Module, edges.map(unwrap));
+	try {
+		return handle("wire", k.makeWire(vec));
+	} finally {
+		vec.delete();
+	}
+}
+function makeFace(k, wire, _planar) {
+	return handle("face", k.makeFace(unwrap(wire)));
+}
+function makeLineEdge(k, p1, p2) {
+	return handle("edge", k.makeLineEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
+}
+function makeCircleEdge(k, center, normal, radius) {
+	return handle("edge", k.makeCircleEdge(center[0], center[1], center[2], normal[0], normal[1], normal[2], radius));
+}
+function makeCircleArc(k, center, normal, radius, startAngle, endAngle) {
+	return handle("edge", k.makeCircleArc(center[0], center[1], center[2], normal[0], normal[1], normal[2], radius, startAngle, endAngle));
+}
+function makeArcEdge(k, p1, p2, p3) {
+	return handle("edge", k.makeArcEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2], p3[0], p3[1], p3[2]));
+}
+function makeEllipseEdge(k, center, normal, majorRadius, minorRadius) {
+	return handle("edge", k.makeEllipseEdge(center[0], center[1], center[2], normal[0], normal[1], normal[2], majorRadius, minorRadius));
+}
+function makeEllipseArc(k, center, normal, majorRadius, minorRadius, startAngle, endAngle) {
+	return handle("edge", k.makeEllipseArc(center[0], center[1], center[2], normal[0], normal[1], normal[2], majorRadius, minorRadius, startAngle, endAngle));
+}
+function makeBezierEdge(k, Module, points) {
+	const flat = [];
+	for (const p of points) flat.push(p[0], p[1], p[2]);
+	const vec = makeVecDouble(Module, flat);
+	try {
+		return handle("edge", k.makeBezierEdge(vec));
+	} finally {
+		vec.delete();
+	}
+}
+function makeTangentArc(k, startPoint, startTangent, endPoint) {
+	const [x1, y1, z1] = startPoint;
+	const [tx, ty, tz] = startTangent;
+	const [x2, y2, z2] = endPoint;
+	return handle("edge", k.makeTangentArc(x1, y1, z1, tx, ty, tz, x2, y2, z2));
+}
+function makeHelixWire(k, pitch, height, radius, center, direction) {
+	const px = center ? center[0] : 0;
+	const py = center ? center[1] : 0;
+	const pz = center ? center[2] : 0;
+	const dx = direction ? direction[0] : 0;
+	const dy = direction ? direction[1] : 0;
+	const dz = direction ? direction[2] : 1;
+	return handle("wire", k.makeHelixWire(px, py, pz, dx, dy, dz, pitch, height, radius));
+}
+function makeCompound(k, Module, shapes) {
+	const vec = makeVecU32(Module, shapes.map(unwrap));
+	try {
+		return handle("compound", k.makeCompound(vec));
+	} finally {
+		vec.delete();
+	}
+}
+function solidFromShell(k, shell) {
+	return handle("solid", k.solidFromShell(unwrap(shell)));
+}
+function buildSolidFromFaces(k, Module, points, faces, tolerance) {
+	const faceIds = [];
+	for (const [i0, i1, i2] of faces) {
+		const p0 = points[i0];
+		const p1 = points[i1];
+		const p2 = points[i2];
+		if (!p0 || !p1 || !p2) continue;
+		faceIds.push(k.buildTriFace(p0.x, p0.y, p0.z, p1.x, p1.y, p1.z, p2.x, p2.y, p2.z));
+	}
+	const vec = makeVecU32(Module, faceIds);
+	try {
+		let sewn = k.sewAndSolidify(vec, tolerance);
+		sewn = k.fixFaceOrientations(sewn);
+		return wrapResult(k, sewn);
+	} finally {
+		vec.delete();
+	}
+}
+function makeNonPlanarFace(k, wire) {
+	return handle("face", k.makeNonPlanarFace(unwrap(wire)));
+}
+function addHolesInFace(k, Module, face, holeWires) {
+	const vec = makeVecU32(Module, holeWires.map(unwrap));
+	try {
+		return handle("face", k.addHolesInFace(unwrap(face), vec));
+	} finally {
+		vec.delete();
+	}
+}
+function removeHolesFromFace(k, Module, face) {
+	const allWires = k.getSubShapes(unwrap(face), "wire");
+	const holeCount = (() => {
+		try {
+			return allWires.size() - 1;
+		} finally {
+			allWires.delete();
+		}
+	})();
+	const indices = [];
+	for (let i = 0; i < holeCount; i++) indices.push(i);
+	const vec = makeVecInt(Module, indices);
+	try {
+		return handle("face", k.removeHolesFromFace(unwrap(face), vec));
+	} finally {
+		vec.delete();
+	}
+}
+function makeFaceOnSurface(k, surface, wire) {
+	const faceId = unwrap(surface);
+	return handle("face", k.makeFaceOnSurface(faceId, unwrap(wire)));
+}
+function bsplineSurface(k, Module, points, rows, cols) {
+	const vec = new Module.VectorDouble();
+	for (const [x, y, z] of points) {
+		vec.push_back(x);
+		vec.push_back(y);
+		vec.push_back(z);
+	}
+	try {
+		return handle("face", k.bsplineSurface(vec, rows, cols));
+	} finally {
+		vec.delete();
+	}
+}
+function triangulatedSurface(k, Module, points, rows, cols) {
+	const faceIds = [];
+	for (let r = 0; r < rows - 1; r++) for (let c = 0; c < cols - 1; c++) {
+		const i00 = r * cols + c;
+		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];
+		if (p00 && p10 && p01) faceIds.push(k.buildTriFace(p00[0], p00[1], p00[2], p10[0], p10[1], p10[2], p01[0], p01[1], p01[2]));
+		if (p10 && p11 && p01) faceIds.push(k.buildTriFace(p10[0], p10[1], p10[2], p11[0], p11[1], p11[2], p01[0], p01[1], p01[2]));
+	}
+	const vec = makeVecU32(Module, faceIds);
+	try {
+		return wrapResult(k, k.sewAndSolidify(vec, .001));
+	} finally {
+		vec.delete();
+	}
+}
+function buildTriFace(k, a, b, c) {
+	const id = k.buildTriFace(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
+	if (id === 0) return null;
+	return handle("face", id);
+}
+function sewAndSolidify(k, Module, faces, tolerance) {
+	const vec = makeVecU32(Module, faces.map(unwrap));
+	try {
+		let sewn = k.sewAndSolidify(vec, tolerance);
+		sewn = k.fixFaceOrientations(sewn);
+		return handle("solid", sewn);
+	} finally {
+		vec.delete();
+	}
+}
+function createPoint3d(x, y, z) {
+	return {
+		x,
+		y,
+		z,
+		__type: "point3d",
+		delete: noop
+	};
+}
+function createDirection3d(x, y, z) {
+	return {
+		x,
+		y,
+		z,
+		__type: "direction3d",
+		delete: noop
+	};
+}
+function createVector3d(x, y, z) {
+	return {
+		x,
+		y,
+		z,
+		__type: "vector3d",
+		delete: noop
+	};
+}
+function createAxis1(cx, cy, cz, dx, dy, dz) {
+	return {
+		origin: {
+			x: cx,
+			y: cy,
+			z: cz
+		},
+		direction: {
+			x: dx,
+			y: dy,
+			z: dz
+		},
+		__type: "axis1",
+		delete: noop
+	};
+}
+function createAxis2(ox, oy, oz, zx, zy, zz, xx, xy, xz) {
+	return {
+		origin: {
+			x: ox,
+			y: oy,
+			z: oz
+		},
+		zDir: {
+			x: zx,
+			y: zy,
+			z: zz
+		},
+		xDir: xx !== void 0 ? {
+			x: xx,
+			y: xy,
+			z: xz
+		} : void 0,
+		__type: "axis2",
+		delete: noop
+	};
+}
+function createAxis3(ox, oy, oz, zx, zy, zz, xx, xy, xz) {
+	return {
+		origin: {
+			x: ox,
+			y: oy,
+			z: oz
+		},
+		zDir: {
+			x: zx,
+			y: zy,
+			z: zz
+		},
+		xDir: xx !== void 0 ? {
+			x: xx,
+			y: xy,
+			z: xz
+		} : void 0,
+		__type: "axis3",
+		delete: noop
+	};
+}
+//#endregion
+//#region src/kernel/occtWasm/kernel2dOps.ts
+function c2d(h) {
+	return h;
+}
+function c2dWrap(obj) {
+	return obj;
+}
+function createPoint2d(x, y) {
+	return {
+		x,
+		y
+	};
+}
+function createDirection2d(x, y) {
+	const l = Math.sqrt(x * x + y * y);
+	if (l < 1e-15) throw new Error("occt-wasm: createDirection2d called with zero-length vector");
+	return {
+		x: x / l,
+		y: y / l
+	};
+}
+function createVector2d(x, y) {
+	return {
+		x,
+		y
+	};
+}
+function createAxis2d(px, py, dx, dy) {
+	return {
+		px,
+		py,
+		dx,
+		dy,
+		delete() {}
+	};
+}
+function wrapCurve2dHandle(h) {
+	return h;
+}
+function makeLine2d(x1, y1, x2, y2) {
+	return c2dWrap(makeLine2d$1(x1, y1, x2, y2));
+}
+function makeCircle2d(cx, cy, radius, sense) {
+	return c2dWrap(makeCircle2d$1(cx, cy, radius, sense));
+}
+function makeArc2dThreePoints(x1, y1, xm, ym, x2, y2) {
+	const d = 2 * (x1 * (ym - y2) + xm * (y2 - y1) + x2 * (y1 - ym));
+	if (Math.abs(d) < 1e-12) return c2dWrap(makeLine2d$1(x1, y1, x2, y2));
+	const cx = ((x1 * x1 + y1 * y1) * (ym - y2) + (xm * xm + ym * ym) * (y2 - y1) + (x2 * x2 + y2 * y2) * (y1 - ym)) / d;
+	const cy = ((x1 * x1 + y1 * y1) * (x2 - xm) + (xm * xm + ym * ym) * (x1 - x2) + (x2 * x2 + y2 * y2) * (xm - x1)) / d;
+	const radius = Math.sqrt((x1 - cx) ** 2 + (y1 - cy) ** 2);
+	const a1 = Math.atan2(y1 - cy, x1 - cx);
+	const am = Math.atan2(ym - cy, xm - cx);
+	const a2 = Math.atan2(y2 - cy, x2 - cx);
+	let da1m = am - a1;
+	if (da1m < 0) da1m += 2 * Math.PI;
+	let da12 = a2 - a1;
+	if (da12 < 0) da12 += 2 * Math.PI;
+	const sense = da1m < da12;
+	const circle = makeCircle2d$1(cx, cy, radius, sense);
+	if (!sense) {
+		const tStart = -a1;
+		let tEnd = -a2;
+		if (tEnd < tStart - 1e-9) tEnd += 2 * Math.PI;
+		return c2dWrap({
+			__bk2d: "trimmed",
+			basis: circle,
+			tStart,
+			tEnd
+		});
+	}
+	let tEnd = a2;
+	if (tEnd < a1 - 1e-9) tEnd += 2 * Math.PI;
+	return c2dWrap({
+		__bk2d: "trimmed",
+		basis: circle,
+		tStart: a1,
+		tEnd
+	});
+}
+function makeArc2dTangent(startX, startY, tangentX, tangentY, endX, endY) {
+	const len = Math.sqrt(tangentX * tangentX + tangentY * tangentY);
+	const ntx = len > 0 ? tangentX / len : 0;
+	const nty = len > 0 ? tangentY / len : 0;
+	const dx = startX - endX;
+	const dy = startY - endY;
+	const denom = 2 * (dy * ntx - dx * nty);
+	if (Math.abs(denom) < 1e-12) return c2dWrap(makeLine2d$1(startX, startY, endX, endY));
+	const t = -(dx * dx + dy * dy) / denom;
+	const cx = startX - t * nty;
+	const cy = startY + t * ntx;
+	const radius = Math.abs(t);
+	const a1 = Math.atan2(startY - cy, startX - cx);
+	const a2 = Math.atan2(endY - cy, endX - cx);
+	const ccwTanX = -(startY - cy) / radius;
+	const ccwTanY = (startX - cx) / radius;
+	const sense = ccwTanX * ntx + ccwTanY * nty > 0;
+	const circle = makeCircle2d$1(cx, cy, radius, sense);
+	if (!sense) {
+		const tStart = -a1;
+		let tEnd = -a2;
+		if (tEnd < tStart - 1e-9) tEnd += 2 * Math.PI;
+		return c2dWrap({
+			__bk2d: "trimmed",
+			basis: circle,
+			tStart,
+			tEnd
+		});
+	}
+	let tEnd = a2;
+	if (tEnd < a1 - 1e-9) tEnd += 2 * Math.PI;
+	return c2dWrap({
+		__bk2d: "trimmed",
+		basis: circle,
+		tStart: a1,
+		tEnd
+	});
+}
+function makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX, xDirY, sense) {
+	return c2dWrap(makeEllipse2d$1(cx, cy, majorRadius, minorRadius, xDirX ?? 1, xDirY ?? 0, sense ?? true));
+}
+function makeEllipseArc2d(cx, cy, majorRadius, minorRadius, startAngle, endAngle, xDirX, xDirY, sense) {
+	return c2dWrap({
+		...makeEllipse2d$1(cx, cy, majorRadius, minorRadius, xDirX ?? 1, xDirY ?? 0, sense ?? true),
+		__bk2d: "ellipse",
+		startAngle,
+		endAngle
+	});
+}
+function makeBezier2d(points) {
+	return c2dWrap(makeBezier2d$1(points));
+}
+function makeBSpline2d(points) {
+	if (points.length <= 25) return c2dWrap(makeBezier2d$1(points));
+	const step = Math.max(1, Math.floor(points.length / 24));
+	return c2dWrap(makeBezier2d$1(points.filter((_, i) => i % step === 0 || i === points.length - 1)));
+}
+function evaluateCurve2d(curve, param) {
+	return evaluateCurve2d$1(c2d(curve), param);
+}
+function evaluateCurve2dD1(curve, param) {
+	return {
+		point: evaluateCurve2d$1(c2d(curve), param),
+		tangent: tangentCurve2d(c2d(curve), param)
+	};
+}
+function getCurve2dBounds(curve) {
+	return curveBounds(c2d(curve));
+}
+function getCurve2dType(curve) {
+	let cu = c2d(curve);
+	while (cu.__bk2d === "trimmed" && cu.basis) cu = cu.basis;
+	return curveTypeName(cu);
+}
+function trimCurve2d(curve, start, end) {
+	return c2dWrap({
+		__bk2d: "trimmed",
+		basis: c2d(curve),
+		tStart: start,
+		tEnd: end
+	});
+}
+function copyCurve2d(curve) {
+	return c2dWrap(JSON.parse(JSON.stringify(c2d(curve))));
+}
+function offsetCurve2d(curve, offset) {
+	const c = c2d(curve);
+	const bounds = curveBounds(c);
+	const pts = [];
+	for (let i = 0; i <= 20; i++) {
+		const t = bounds.first + (bounds.last - bounds.first) * i / 20;
+		const [px, py] = evaluateCurve2d$1(c, t);
+		const [tx, ty] = tangentCurve2d(c, t);
+		const len = Math.sqrt(tx * tx + ty * ty) || 1;
+		pts.push([px - ty / len * offset, py + tx / len * offset]);
+	}
+	return c2dWrap(makeBezier2d$1(pts.length <= 25 ? pts : pts.filter((_, i) => i % 2 === 0 || i === pts.length - 1)));
+}
+function translateCurve2d(curve, dx, dy) {
+	return c2dWrap(translateCurve2d$1(c2d(curve), dx, dy));
+}
+function rotateCurve2d(curve, angle, cx, cy) {
+	return c2dWrap(rotateCurve2d$1(c2d(curve), angle, cx, cy));
+}
+function scaleCurve2d(curve, factor, cx, cy) {
+	const result = scaleCurve2d$1(c2d(curve), factor, cx, cy);
+	const r = result;
+	if (r.__bk2d === "line" && typeof r.len === "number") r.len = r.len * Math.abs(factor);
+	return c2dWrap(result);
+}
+function mirrorCurve2dAtPoint(curve, cx, cy) {
+	return c2dWrap(mirrorAtPoint(c2d(curve), cx, cy));
+}
+function mirrorCurve2dAcrossAxis(curve, originX, originY, dirX, dirY) {
+	return c2dWrap(mirrorAcrossAxis(c2d(curve), originX, originY, dirX, dirY));
+}
+function affinityTransform2d(curve) {
+	return curve;
+}
+function createIdentityGTrsf2d() {
+	return {
+		type: "identity2d",
+		delete() {}
+	};
+}
+function createAffinityGTrsf2d(originX, originY, dirX, dirY, ratio) {
+	return {
+		type: "affinity2d",
+		axOriginX: originX,
+		axOriginY: originY,
+		axDirX: dirX,
+		axDirY: dirY,
+		ratio,
+		delete() {}
+	};
+}
+function createTranslationGTrsf2d(dx, dy) {
+	return {
+		type: "translate2d",
+		dx,
+		dy,
+		delete() {}
+	};
+}
+function createMirrorGTrsf2d(cx, cy, mode, originX, originY, dirX, dirY) {
+	return {
+		type: "mirror2d",
+		cx,
+		cy,
+		mode,
+		originX,
+		originY,
+		dirX,
+		dirY,
+		delete() {}
+	};
+}
+function createRotationGTrsf2d(angle, cx, cy) {
+	return {
+		type: "rotate2d",
+		angle,
+		cx,
+		cy,
+		delete() {}
+	};
+}
+function createScaleGTrsf2d(factor, cx, cy) {
+	return {
+		type: "scale2d",
+		sx: factor,
+		sy: factor,
+		cx,
+		cy,
+		delete() {}
+	};
+}
+function setGTrsf2dTranslationPart(gtrsf, dx, dy) {
+	const t = gtrsf;
+	t["dx"] = (Number(t["dx"]) || 0) + dx;
+	t["dy"] = (Number(t["dy"]) || 0) + dy;
+}
+function multiplyGTrsf2d(base, other) {
+	const b = base;
+	const o = other;
+	b["dx"] = (Number(b["dx"]) || 0) + (Number(o["dx"]) || 0);
+	b["dy"] = (Number(b["dy"]) || 0) + (Number(o["dy"]) || 0);
+	if (o["type"] === "scale2d") {
+		b["type"] = "scale2d";
+		b["sx"] = o["sx"];
+		b["sy"] = o["sy"];
+	}
+}
+function transformCurve2dGeneral(curve, gtrsf) {
+	const t = gtrsf;
+	if (t["type"] === "translate2d") return translateCurve2d(curve, Number(t["dx"]) || 0, Number(t["dy"]) || 0);
+	if (t["type"] === "rotate2d") return rotateCurve2d(curve, Number(t["angle"]) || 0, Number(t["cx"]) || 0, Number(t["cy"]) || 0);
+	if (t["type"] === "scale2d") return scaleCurve2d(curve, Number(t["sx"]) || 1, Number(t["cx"]) || 0, Number(t["cy"]) || 0);
+	if (t["type"] === "mirror2d") return mirrorCurve2dAtPoint(curve, Number(t["ox"]) || 0, Number(t["oy"]) || 0);
+	if (t["type"] === "affinity2d") return scaleCurve2d(curve, Number(t["ratio"]) || 1, Number(t["axOriginX"]) || 0, Number(t["axOriginY"]) || 0);
+	if (Number(t["dx"]) || Number(t["dy"])) return translateCurve2d(curve, Number(t["dx"]) || 0, Number(t["dy"]) || 0);
+	return curve;
+}
+function intersectCurves2d(c1, c2, tolerance) {
+	const result = intersectCurves2dFn(c2d(c1), c2d(c2), tolerance);
+	return {
+		points: result.points,
+		segments: result.segments.map((s) => c2dWrap(s))
+	};
+}
+function projectPointOnCurve2d(curve, x, y) {
+	const c = c2d(curve);
+	const bounds = curveBounds(c);
+	const projectOnBasis = (basis, bFirst, bLast) => {
+		if (basis.__bk2d === "line") {
+			const rawT = (x - basis.ox) * basis.dx + (y - basis.oy) * basis.dy;
+			const t = Math.max(bFirst, Math.min(bLast, rawT));
+			const [px, py] = evaluateCurve2d$1(basis, t);
+			return {
+				param: t,
+				distance: Math.sqrt((px - x) ** 2 + (py - y) ** 2)
+			};
+		}
+		const N = 200;
+		let bestT = bFirst;
+		let bestDist = Infinity;
+		for (let i = 0; i <= N; i++) {
+			const t = bFirst + (bLast - bFirst) * i / N;
+			const [px, py] = evaluateCurve2d$1(basis, t);
+			const d = (px - x) ** 2 + (py - y) ** 2;
+			if (d < bestDist) {
+				bestDist = d;
+				bestT = t;
+			}
+		}
+		return {
+			param: bestT,
+			distance: Math.sqrt(bestDist)
+		};
+	};
+	if (c.__bk2d === "trimmed" && c.basis) {
+		const tStart = c.tStart;
+		const tEnd = c.tEnd;
+		const basisResult = projectOnBasis(c.basis, tStart, tEnd);
+		if (!basisResult) return null;
+		const range = tEnd - tStart;
+		const trimmedT = range > 1e-15 ? (basisResult.param - tStart) / range : 0;
+		return {
+			param: Math.max(0, Math.min(1, trimmedT)),
+			distance: basisResult.distance
+		};
+	}
+	return projectOnBasis(c, bounds.first, bounds.last);
+}
+function distanceBetweenCurves2d(c1, c2, p1Start, p1End, p2Start, p2End) {
+	const n = 20;
+	let minDist = Infinity;
+	for (let i = 0; i <= n; i++) {
+		const t1 = p1Start + (p1End - p1Start) * (i / n);
+		const [x1, y1] = evaluateCurve2d$1(c2d(c1), t1);
+		for (let j = 0; j <= n; j++) {
+			const t2 = p2Start + (p2End - p2Start) * (j / n);
+			const [x2, y2] = evaluateCurve2d$1(c2d(c2), t2);
+			const d = Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
+			if (d < minDist) minDist = d;
+		}
+	}
+	return minDist;
+}
+function approximateCurve2dAsBSpline(curve, maxSegments) {
+	const cu = c2d(curve);
+	const bounds = curveBounds(cu);
+	const nPts = Math.min(Math.max(maxSegments + 1, 10), 100);
+	const poles = [];
+	for (let i = 0; i < nPts; i++) {
+		const t = bounds.first + (bounds.last - bounds.first) * i / (nPts - 1);
+		poles.push(evaluateCurve2d$1(cu, t));
+	}
+	const degree = Math.min(3, nPts - 1);
+	const n = poles.length;
+	const knots = [];
+	const mults = [];
+	const nInternalKnots = n - degree - 1;
+	knots.push(0);
+	mults.push(degree + 1);
+	for (let i = 1; i <= nInternalKnots; i++) {
+		knots.push(i / (nInternalKnots + 1));
+		mults.push(1);
+	}
+	knots.push(1);
+	mults.push(degree + 1);
+	return c2dWrap({
+		__bk2d: "bspline",
+		poles,
+		knots,
+		multiplicities: mults,
+		degree,
+		isPeriodic: false
+	});
+}
+function decomposeBSpline2dToBeziers(curve) {
+	const knots = c2d(curve).knots ?? [];
+	if (knots.length < 2) return [curve];
+	const result = [];
+	for (let i = 0; i < knots.length - 1; i++) {
+		const k0 = knots[i];
+		const k1 = knots[i + 1];
+		if (Math.abs(k1 - k0) < 1e-15) continue;
+		result.push(trimCurve2d(curve, k0, k1));
+	}
+	return result.length > 0 ? result : [curve];
+}
+function createBoundingBox2d() {
+	return createBBox2d();
+}
+function addCurveToBBox2d(bbox, curve, tolerance) {
+	addCurveToBBox(bbox, c2d(curve), tolerance);
+}
+function getBBox2dBounds(bbox) {
+	return {
+		xMin: bbox.xMin,
+		yMin: bbox.yMin,
+		xMax: bbox.xMax,
+		yMax: bbox.yMax
+	};
+}
+function mergeBBox2d(target, other) {
+	target.xMin = Math.min(target.xMin, other.xMin);
+	target.yMin = Math.min(target.yMin, other.yMin);
+	target.xMax = Math.max(target.xMax, other.xMax);
+	target.yMax = Math.max(target.yMax, other.yMax);
+}
+function isBBox2dOut(a, b) {
+	return a.xMax < b.xMin || a.xMin > b.xMax || a.yMax < b.yMin || a.yMin > b.yMax;
+}
+function isBBox2dOutPoint(bbox, x, y) {
+	return x < bbox.xMin || x > bbox.xMax || y < bbox.yMin || y > bbox.yMax;
+}
+function getCurve2dCircleData(curve) {
+	let c = c2d(curve);
+	while (c.__bk2d === "trimmed" && c.basis) c = c.basis;
+	if (c.__bk2d === "circle") return {
+		cx: c.cx,
+		cy: c.cy,
+		radius: c.radius,
+		isDirect: c.sense !== false
+	};
+	return null;
+}
+function getCurve2dEllipseData(curve) {
+	let c = c2d(curve);
+	while (c.__bk2d === "trimmed" && c.basis) c = c.basis;
+	if (c.__bk2d === "ellipse") return {
+		majorRadius: c.majorRadius,
+		minorRadius: c.minorRadius,
+		xAxisAngle: c.xDirAngle ?? 0,
+		isDirect: c.sense !== false
+	};
+	return null;
+}
+function getCurve2dBezierPoles(curve) {
+	let c = c2d(curve);
+	while (c.__bk2d === "trimmed" && c.basis) c = c.basis;
+	if (c.__bk2d === "bezier" && Array.isArray(c.poles)) return c.poles;
+	return null;
+}
+function getCurve2dBezierDegree(curve) {
+	let c = c2d(curve);
+	while (c.__bk2d === "trimmed" && c.basis) c = c.basis;
+	if (c["__bk2d"] === "bezier" && Array.isArray(c["poles"])) return c["poles"].length - 1;
+	return null;
+}
+function serializeCurve2d(curve) {
+	return serializeCurve2d$1(c2d(curve));
+}
+function deserializeCurve2d(data) {
+	return c2dWrap(deserializeCurve2d$1(data));
+}
+function splitCurve2d(curve, params) {
+	const bounds = curveBounds(c2d(curve));
+	const sorted = [
+		bounds.first,
+		...params.sort((a, b) => a - b),
+		bounds.last
+	];
+	const result = [];
+	for (let i = 0; i < sorted.length - 1; i++) {
+		const start = sorted[i] ?? bounds.first;
+		const end = sorted[i + 1] ?? bounds.last;
+		result.push(trimCurve2d(curve, start, end));
+	}
+	return result;
+}
+function liftCurve2dToPlane(k, Module, curve, planeOrigin, planeZ, planeX) {
+	const cu = c2d(curve);
+	const [ox, oy, oz] = planeOrigin;
+	const [zx, zy, zz] = planeZ;
+	const [xx, xy, xz] = planeX;
+	const yx = zy * xz - zz * xy, yy = zz * xx - zx * xz, yz = zx * xy - zy * xx;
+	const lift = (u, v) => [
+		ox + u * xx + v * yx,
+		oy + u * xy + v * yy,
+		oz + u * xz + v * yz
+	];
+	const bk2dType = cu.__bk2d;
+	if (bk2dType === "line") {
+		const bounds = curveBounds(cu);
+		const [u1, v1] = evaluateCurve2d$1(cu, bounds.first);
+		const [u2, v2] = evaluateCurve2d$1(cu, bounds.last);
+		const p1 = lift(u1, v1);
+		const p2 = lift(u2, v2);
+		return handle("edge", k.makeLineEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
+	}
+	if (bk2dType === "trimmed") {
+		const trimmed = cu;
+		if (trimmed.basis && trimmed.basis.__bk2d === "line") {
+			const [u1, v1] = evaluateCurve2d$1(cu, 0);
+			const [u2, v2] = evaluateCurve2d$1(cu, 1);
+			const p1 = lift(u1, v1);
+			const p2 = lift(u2, v2);
+			return handle("edge", k.makeLineEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
+		}
+		if (trimmed.basis && trimmed.basis.__bk2d === "circle") {
+			const bounds = curveBounds(cu);
+			const [u1, v1] = evaluateCurve2d$1(cu, bounds.first);
+			const [um, vm] = evaluateCurve2d$1(cu, (bounds.first + bounds.last) / 2);
+			const [u2, v2] = evaluateCurve2d$1(cu, bounds.last);
+			const p1 = lift(u1, v1);
+			const pm = lift(um, vm);
+			const p2 = lift(u2, v2);
+			return handle("edge", k.makeArcEdge(p1[0], p1[1], p1[2], pm[0], pm[1], pm[2], p2[0], p2[1], p2[2]));
+		}
+	}
+	if (bk2dType === "circle") {
+		const circleData = cu;
+		if (circleData.cx !== void 0 && circleData.radius !== void 0) {
+			const [pcx, pcy, pcz] = lift(circleData.cx, circleData.cy);
+			return handle("edge", k.makeCircleEdge(pcx, pcy, pcz, zx, zy, zz, circleData.radius));
+		}
+		const bounds = curveBounds(cu);
+		const [u1, v1] = evaluateCurve2d$1(cu, bounds.first);
+		const [um, vm] = evaluateCurve2d$1(cu, (bounds.first + bounds.last) / 2);
+		const [u2, v2] = evaluateCurve2d$1(cu, bounds.last);
+		const p1 = lift(u1, v1);
+		const pm = lift(um, vm);
+		const p2 = lift(u2, v2);
+		return handle("edge", k.makeArcEdge(p1[0], p1[1], p1[2], pm[0], pm[1], pm[2], p2[0], p2[1], p2[2]));
+	}
+	const bounds = curveBounds(cu);
+	const nSamples = 24;
+	const dt = (bounds.last - bounds.first) / nSamples;
+	const pts = [];
+	for (let i = 0; i <= nSamples; i++) {
+		const [u, v] = evaluateCurve2d$1(cu, bounds.first + i * dt);
+		const [px, py, pz] = lift(u, v);
+		pts.push(px, py, pz);
+	}
+	const vec = new Module.VectorDouble();
+	for (const p of pts) vec.push_back(p);
+	try {
+		return handle("edge", k.interpolatePoints(vec, false));
+	} finally {
+		vec.delete();
+	}
+}
+function buildEdgeOnSurface(k, Module, curve, surface) {
+	const cu = c2d(curve);
+	const bounds = curveBounds(cu);
+	const faceId = unwrap(surface);
+	const nSamples = 30;
+	const vec = new Module.VectorDouble();
+	for (let i = 0; i <= nSamples; i++) {
+		const [u, v] = evaluateCurve2d$1(cu, bounds.first + (bounds.last - bounds.first) * i / nSamples);
+		const pt = k.pointOnSurface(faceId, u, v);
+		try {
+			vec.push_back(pt.get(0));
+			vec.push_back(pt.get(1));
+			vec.push_back(pt.get(2));
+		} finally {
+			pt.delete();
+		}
+	}
+	try {
+		return handle("edge", k.interpolatePoints(vec, false));
+	} finally {
+		vec.delete();
+	}
+}
+function extractSurfaceFromFace(face) {
+	return face;
+}
+function extractCurve2dFromEdge() {
+	return c2dWrap(makeLine2d$1(0, 0, 1, 0));
+}
+function buildCurves3d(k, wire) {
+	k.buildCurves3d(unwrap(wire));
+}
+function fixWireOnFace(k, wire, face, tolerance) {
+	return handle("wire", k.fixWireOnFace(unwrap(wire), unwrap(face), tolerance));
+}
+//#endregion
+//#region src/kernel/occtWasm/evolutionOps.ts
+/**
+* Parse an EvolutionData result from the WASM kernel into a ShapeEvolution.
+* The C++ facade returns flat vectors of [inputHash, count, out1, out2, ..., inputHash, count, ...].
+*/
+function parseEvolution(evo) {
+	try {
+		const modifiedRaw = readVecInt(evo.modified);
+		const generatedRaw = readVecInt(evo.generated);
+		const deletedRaw = readVecInt(evo.deleted);
+		const parseMap = (raw) => {
+			const map = /* @__PURE__ */ new Map();
+			let i = 0;
+			while (i + 1 < raw.length) {
+				const inputHash = raw[i] ?? 0;
+				const count = raw[i + 1] ?? 0;
+				i += 2;
+				const outputs = [];
+				for (let j = 0; j < count && i < raw.length; j++, i++) outputs.push(raw[i] ?? 0);
+				map.set(inputHash, outputs);
+			}
+			return map;
+		};
+		return {
+			id: evo.resultId,
+			evolution: {
+				modified: parseMap(modifiedRaw),
+				generated: parseMap(generatedRaw),
+				deleted: new Set(deletedRaw)
+			}
+		};
+	} finally {
+		evo.delete();
+	}
+}
+function translateWithHistory(k, Module, shape, x, y, z, inputFaceHashes, hashUpperBound) {
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.translateWithHistory(unwrap(shape), x, y, z, hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution
+		};
+	} finally {
+		hashVec.delete();
+	}
+}
+function rotateWithHistory(k, Module, shape, angle, inputFaceHashes, hashUpperBound, axis, center) {
+	const ax = axis ?? [
+		0,
+		0,
+		1
+	];
+	const cn = center ?? [
+		0,
+		0,
+		0
+	];
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.rotateWithHistory(unwrap(shape), cn[0], cn[1], cn[2], ax[0], ax[1], ax[2], angle, hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution
+		};
+	} finally {
+		hashVec.delete();
+	}
+}
+function mirrorWithHistory(k, Module, shape, origin, normal, inputFaceHashes, hashUpperBound) {
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.mirrorWithHistory(unwrap(shape), origin[0], origin[1], origin[2], normal[0], normal[1], normal[2], hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution
+		};
+	} finally {
+		hashVec.delete();
+	}
+}
+function scaleWithHistory(k, Module, shape, center, factor, inputFaceHashes, hashUpperBound) {
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.scaleWithHistory(unwrap(shape), center[0], center[1], center[2], factor, hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution
+		};
+	} finally {
+		hashVec.delete();
+	}
+}
+function generalTransformWithHistory(generalTransformFn, shape, linear, translation, isOrthogonal, inputFaceHashes) {
+	const result = generalTransformFn(shape, linear, translation, isOrthogonal);
+	const modified = /* @__PURE__ */ new Map();
+	for (const h of inputFaceHashes) modified.set(h, [h]);
+	return {
+		shape: result,
+		evolution: {
+			modified,
+			generated: /* @__PURE__ */ new Map(),
+			deleted: /* @__PURE__ */ new Set()
+		}
+	};
+}
+function fuseWithHistory(k, Module, shape, tool, inputFaceHashes, hashUpperBound, _options) {
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.fuseWithHistory(unwrap(shape), unwrap(tool), hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution,
+			diagnostics: {
+				hasErrors: false,
+				hasWarnings: false,
+				messages: []
+			}
+		};
+	} finally {
+		hashVec.delete();
+	}
+}
+function cutWithHistory(k, Module, shape, tool, inputFaceHashes, hashUpperBound, _options) {
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.cutWithHistory(unwrap(shape), unwrap(tool), hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution,
+			diagnostics: {
+				hasErrors: false,
+				hasWarnings: false,
+				messages: []
+			}
+		};
+	} finally {
+		hashVec.delete();
+	}
+}
+function intersectWithHistory(k, Module, shape, tool, inputFaceHashes, hashUpperBound, _options) {
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.intersectWithHistory(unwrap(shape), unwrap(tool), hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution,
+			diagnostics: {
+				hasErrors: false,
+				hasWarnings: false,
+				messages: []
+			}
+		};
+	} finally {
+		hashVec.delete();
+	}
+}
+function filletWithHistory(k, Module, shape, edges, radius, inputFaceHashes, hashUpperBound) {
+	const r = resolveUniformRadius(edges, radius);
+	const edgeVec = makeVecU32(Module, edges.map(unwrap));
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.filletWithHistory(unwrap(shape), edgeVec, r, hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution
+		};
+	} finally {
+		edgeVec.delete();
+		hashVec.delete();
+	}
+}
+function chamferWithHistory(k, Module, shape, edges, distance, inputFaceHashes, hashUpperBound) {
+	const d = resolveUniformRadius(edges, distance);
+	const edgeVec = makeVecU32(Module, edges.map(unwrap));
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.chamferWithHistory(unwrap(shape), edgeVec, d, hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution
+		};
+	} finally {
+		edgeVec.delete();
+		hashVec.delete();
+	}
+}
+function shellWithHistory(k, Module, shape, faces, thickness, inputFaceHashes, hashUpperBound, tolerance) {
+	const faceVec = makeVecU32(Module, faces.map(unwrap));
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.shellWithHistory(unwrap(shape), faceVec, thickness, tolerance ?? .001, hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution
+		};
+	} finally {
+		faceVec.delete();
+		hashVec.delete();
+	}
+}
+function thickenWithHistory(k, Module, shape, thickness, inputFaceHashes, hashUpperBound) {
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.thickenWithHistory(unwrap(shape), thickness, .001, hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution
+		};
+	} finally {
+		hashVec.delete();
+	}
+}
+function offsetWithHistory(k, Module, shape, distance, inputFaceHashes, hashUpperBound, tolerance) {
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.offsetWithHistory(unwrap(shape), distance, tolerance ?? 1e-6, hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution
+		};
+	} finally {
+		hashVec.delete();
+	}
+}
+function draftWithHistory(k, shape, faces, pullDirection, angleDeg) {
+	const [dx, dy, dz] = pullDirection;
+	let currentId = unwrap(shape);
+	for (const face of faces) {
+		const angleRad = (typeof angleDeg === "number" ? angleDeg : angleDeg(face)) * Math.PI / 180;
+		currentId = k.draft(currentId, unwrap(face), angleRad, dx, dy, dz);
+	}
+	return {
+		shape: wrapResult(k, currentId),
+		evolution: {
+			modified: /* @__PURE__ */ new Map(),
+			generated: /* @__PURE__ */ new Map(),
+			deleted: /* @__PURE__ */ new Set()
+		}
+	};
+}
+function applyComposedTransformWithHistory(transformFn, iterShapesFn, hashCodeFn, shape, transformHandle, inputFaceHashes, hashUpperBound) {
+	const result = transformFn(shape, transformHandle);
+	const outFaces = iterShapesFn(result, "face");
+	const modified = /* @__PURE__ */ new Map();
+	const limit = Math.min(inputFaceHashes.length, outFaces.length);
+	for (let i = 0; i < limit; i++) {
+		const outFace = outFaces[i];
+		const inHash = inputFaceHashes[i];
+		if (outFace !== void 0 && inHash !== void 0) modified.set(inHash, [hashCodeFn(outFace, hashUpperBound)]);
+	}
+	return {
+		shape: result,
+		evolution: {
+			modified,
+			generated: /* @__PURE__ */ new Map(),
+			deleted: /* @__PURE__ */ new Set()
+		}
+	};
+}
+//#endregion
+//#region src/kernel/occtWasm/hullOps.ts
+function findHorizonEdges(faces, visible) {
+	const visSet = new Set(visible);
+	const horizon = [];
+	for (const fi of visible) {
+		const f = faces[fi];
+		for (let ei = 0; ei < 3; ei++) {
+			const a = f[ei], b = f[(ei + 1) % 3];
+			if (faces.some((g, fj) => fj !== fi && !visSet.has(fj) && [
+				0,
+				1,
+				2
+			].some((ej) => g[ej] === b && g[(ej + 1) % 3] === a))) horizon.push([a, b]);
+		}
+	}
+	return horizon;
+}
+function computeConvexHullFaces(pts) {
+	const cross = (a, b) => ({
+		x: a.y * b.z - a.z * b.y,
+		y: a.z * b.x - a.x * b.z,
+		z: a.x * b.y - a.y * b.x
+	});
+	const sub = (a, b) => ({
+		x: a.x - b.x,
+		y: a.y - b.y,
+		z: a.z - b.z
+	});
+	const dot = (a, b) => a.x * b.x + a.y * b.y + a.z * b.z;
+	const n = pts.length;
+	const faces = [];
+	const p0 = pts[0];
+	let i1 = 1;
+	while (i1 < n) {
+		const p = require_vec3.wasmIndex(pts, i1);
+		if (Math.hypot(p.x - p0.x, p.y - p0.y, p.z - p0.z) >= 1e-10) break;
+		i1++;
+	}
+	let i2 = i1 + 1;
+	const e01 = sub(pts[i1], p0);
+	while (i2 < n) {
+		const c = cross(e01, sub(pts[i2], p0));
+		if (Math.hypot(c.x, c.y, c.z) > 1e-10) break;
+		i2++;
+	}
+	let i3 = i2 + 1;
+	const norm = cross(e01, sub(pts[i2], p0));
+	while (i3 < n) {
+		if (Math.abs(dot(norm, sub(pts[i3], p0))) > 1e-10) break;
+		i3++;
+	}
+	if (i3 >= n) return [[
+		0,
+		1,
+		2
+	]];
+	if (dot(cross(sub(pts[i1], p0), sub(pts[i2], p0)), sub(pts[i3], p0)) > 0) faces.push([
+		0,
+		i1,
+		i2
+	], [
+		0,
+		i2,
+		i3
+	], [
+		0,
+		i3,
+		i1
+	], [
+		i1,
+		i3,
+		i2
+	]);
+	else faces.push([
+		0,
+		i2,
+		i1
+	], [
+		0,
+		i3,
+		i2
+	], [
+		0,
+		i1,
+		i3
+	], [
+		i2,
+		i3,
+		i1
+	]);
+	const used = new Set([
+		0,
+		i1,
+		i2,
+		i3
+	]);
+	for (let pi = 0; pi < n; pi++) {
+		if (used.has(pi)) continue;
+		const p = pts[pi];
+		const visible = [];
+		for (let fi = 0; fi < faces.length; fi++) {
+			const f = faces[fi];
+			if (dot(cross(sub(pts[f[1]], pts[f[0]]), sub(pts[f[2]], pts[f[0]])), sub(p, pts[f[0]])) > 1e-10) visible.push(fi);
+		}
+		if (visible.length === 0) continue;
+		const horizon = findHorizonEdges(faces, visible);
+		visible.sort((a2, b2) => b2 - a2);
+		for (const fi of visible) faces.splice(fi, 1);
+		for (const [a, b] of horizon) faces.push([
+			a,
+			b,
+			pi
+		]);
+	}
+	return faces;
+}
+function hullFromPoints(k, Module, points, tolerance) {
+	if (points.length < 4) throw new Error("hullFromPoints: need at least 4 points");
+	return buildSolidFromFaces(k, Module, points, computeConvexHullFaces(points), tolerance);
+}
+//#endregion
+//#region src/kernel/occtWasm/occtWasmAdapter.ts
+/**
+* Parse an EvolutionData result from the WASM kernel into a ShapeEvolution.
+*
+* The C++ facade returns flat vectors of [inputHash, outputHash, inputHash, outputHash, ...]
+* for modified and generated, and a flat vector of deleted input hashes.
+*/
+function notImplemented(method) {
+	throw new Error(`occt-wasm: ${method} is not yet implemented`);
+}
+var OcctWasmAdapter = class {
+	oc;
+	kernelId = "occt-wasm";
+	Module;
+	k;
+	constructor(module, kernel) {
+		this.Module = module;
+		this.k = wrapKernelExceptions(kernel, module);
+		this.oc = buildOcShim(module, this.k);
+	}
+	dispose(h) {
+		if (isOcctWasmHandle(h)) this.k.release(h.id);
+		else if (typeof h.delete === "function") h.delete();
+	}
+	executeBatch(_json) {
+		notImplemented("executeBatch");
+	}
+	checkpoint() {
+		notImplemented("checkpoint");
+	}
+	checkpointCount() {
+		notImplemented("checkpointCount");
+	}
+	restoreCheckpoint(_cp) {
+		notImplemented("restoreCheckpoint");
+	}
+	discardCheckpoint(_cp) {
+		notImplemented("discardCheckpoint");
+	}
+	makeBox(width, height, depth) {
+		return makeBox(this.k, width, height, depth);
+	}
+	makeCylinder(radius, height, center, direction) {
+		return makeCylinder(this.k, radius, height, center, direction);
+	}
+	makeSphere(radius, center) {
+		return makeSphere(this.k, radius, center);
+	}
+	makeCone(radius1, radius2, height, center, direction) {
+		return makeCone(this.k, radius1, radius2, height, center, direction);
+	}
+	makeTorus(majorRadius, minorRadius, center, direction) {
+		return makeTorus(this.k, majorRadius, minorRadius, center, direction);
+	}
+	makeEllipsoid(aLength, bLength, cLength) {
+		return makeEllipsoid(this.k, aLength, bLength, cLength);
+	}
+	makeBoxFromCorners(p1, p2) {
+		return makeBoxFromCorners(this.k, p1, p2);
+	}
+	makeRectangle(width, height) {
+		return makeRectangle(this.k, width, height);
+	}
+	fuse(shape, tool, options) {
+		return fuse(this.k, shape, tool, options);
+	}
+	cut(shape, tool, options) {
+		return cut(this.k, shape, tool, options);
+	}
+	intersect(shape, tool, options) {
+		return intersect(this.k, shape, tool, options);
+	}
+	section(shape, plane, approximation) {
+		return section(this.k, shape, plane, approximation);
+	}
+	fuseAll(shapes, options) {
+		return fuseAll(this.k, this.Module, shapes, options);
+	}
+	cutAll(shape, tools, options) {
+		return cutAll(this.k, this.Module, shape, tools, options);
+	}
+	split(shape, tools) {
+		return split(this.k, this.Module, shape, tools);
+	}
+	checkBoolean(shape, tool, op) {
+		return checkBoolean(this.k, shape, tool, op);
+	}
+	meshBoolean(positionsA, indicesA, positionsB, indicesB, op, tolerance) {
+		return meshBoolean(positionsA, indicesA, positionsB, indicesB, op, tolerance);
+	}
+	makeVertex(x, y, z) {
+		return makeVertex(this.k, x, y, z);
+	}
+	makeEdge(curve, _start, _end) {
+		return makeEdge(this.k, curve);
+	}
+	makeWire(edges) {
+		return makeWire(this.k, this.Module, edges);
+	}
+	makeFace(wire, planar) {
+		return makeFace(this.k, wire, planar);
+	}
+	makeLineEdge(p1, p2) {
+		return makeLineEdge(this.k, p1, p2);
+	}
+	makeCircleEdge(center, normal, radius) {
+		return makeCircleEdge(this.k, center, normal, radius);
+	}
+	makeCircleArc(center, normal, radius, startAngle, endAngle) {
+		return makeCircleArc(this.k, center, normal, radius, startAngle, endAngle);
+	}
+	makeArcEdge(p1, p2, p3) {
+		return makeArcEdge(this.k, p1, p2, p3);
+	}
+	makeEllipseEdge(center, normal, majorRadius, minorRadius, _xDir) {
+		return makeEllipseEdge(this.k, center, normal, majorRadius, minorRadius);
+	}
+	makeEllipseArc(center, normal, majorRadius, minorRadius, startAngle, endAngle, _xDir) {
+		return makeEllipseArc(this.k, center, normal, majorRadius, minorRadius, startAngle, endAngle);
+	}
+	makeBezierEdge(points) {
+		return makeBezierEdge(this.k, this.Module, points);
+	}
+	makeTangentArc(startPoint, startTangent, endPoint) {
+		return makeTangentArc(this.k, startPoint, startTangent, endPoint);
+	}
+	makeHelixWire(pitch, height, radius, center, direction, _leftHanded) {
+		return makeHelixWire(this.k, pitch, height, radius, center, direction);
+	}
+	makeWireFromMixed(items) {
+		return this.makeWire(items);
+	}
+	makeCompound(shapes) {
+		return makeCompound(this.k, this.Module, shapes);
+	}
+	solidFromShell(shell) {
+		return solidFromShell(this.k, shell);
+	}
+	hull(_shapes, _tolerance) {
+		notImplemented("hull");
+	}
+	hullFromPoints(points, tolerance) {
+		return hullFromPoints(this.k, this.Module, points, tolerance);
+	}
+	buildSolidFromFaces(points, faces, tolerance) {
+		return buildSolidFromFaces(this.k, this.Module, points, faces, tolerance);
+	}
+	makeNonPlanarFace(wire) {
+		return makeNonPlanarFace(this.k, wire);
+	}
+	addHolesInFace(face, holeWires) {
+		return addHolesInFace(this.k, this.Module, face, holeWires);
+	}
+	removeHolesFromFace(face) {
+		return removeHolesFromFace(this.k, this.Module, face);
+	}
+	makeFaceOnSurface(surface, wire) {
+		return makeFaceOnSurface(this.k, surface, wire);
+	}
+	bsplineSurface(points, rows, cols) {
+		return bsplineSurface(this.k, this.Module, points, rows, cols);
+	}
+	triangulatedSurface(points, rows, cols) {
+		return triangulatedSurface(this.k, this.Module, points, rows, cols);
+	}
+	buildTriFace(a, b, c) {
+		return buildTriFace(this.k, a, b, c);
+	}
+	sewAndSolidify(faces, tolerance) {
+		return sewAndSolidify(this.k, this.Module, faces, tolerance);
+	}
+	createPoint3d(x, y, z) {
+		return createPoint3d(x, y, z);
+	}
+	createDirection3d(x, y, z) {
+		return createDirection3d(x, y, z);
+	}
+	createVector3d(x, y, z) {
+		return createVector3d(x, y, z);
+	}
+	createAxis1(cx, cy, cz, dx, dy, dz) {
+		return createAxis1(cx, cy, cz, dx, dy, dz);
+	}
+	createAxis2(ox, oy, oz, zx, zy, zz, xx, xy, xz) {
+		return createAxis2(ox, oy, oz, zx, zy, zz, xx, xy, xz);
+	}
+	createAxis3(ox, oy, oz, zx, zy, zz, xx, xy, xz) {
+		return createAxis3(ox, oy, oz, zx, zy, zz, xx, xy, xz);
+	}
+	extrude(face, direction, length) {
+		return extrude(this.k, face, direction, length);
+	}
+	revolve(shape, axis, angle) {
+		return revolve(this.k, shape, axis, angle);
+	}
+	loft(wires, ruled, startShape, endShape) {
+		return loft(this.k, this.Module, wires, ruled, startShape, endShape);
+	}
+	sweep(wire, spine, options) {
+		return sweep(this.k, wire, spine, options);
+	}
+	simplePipe(profile, spine) {
+		return simplePipe(this.k, profile, spine);
+	}
+	helicalSweep(_profile, _axisOrigin, _axisDirection, _radius, _pitch, _turns) {
+		throw new Error("helicalSweep on occt-wasm requires profile positioning+orientation logic not yet implemented; brepkit has a native implementation");
+	}
+	sweepWithOptions(_profile, _pathEdge, _contactMode, _scaleValues, _segments) {
+		notImplemented("sweepWithOptions");
+	}
+	sweepPipeShell(profile, spine, options) {
+		return sweepPipeShell(this.k, profile, spine, options);
+	}
+	loftAdvanced(wires, options) {
+		return loftAdvanced(this.k, this.Module, wires, options);
+	}
+	buildExtrusionLaw(profile, length, endFactor) {
+		return buildExtrusionLaw(this.k, profile, length, endFactor);
+	}
+	revolveVec(shape, center, direction, angle) {
+		return revolveVec(this.k, shape, center, direction, angle);
+	}
+	draftPrism(shape, face, baseFace, height, angleDeg, fuse) {
+		return draftPrism(this.k, shape, face, baseFace, height, angleDeg, fuse);
+	}
+	fillet(shape, edges, radius) {
+		return fillet(this.k, this.Module, shape, edges, radius);
+	}
+	chamfer(shape, edges, distance) {
+		return chamfer(this.k, this.Module, shape, edges, distance);
+	}
+	chamferDistAngle(shape, edges, distance, angleDeg) {
+		return chamferDistAngle(this.k, this.Module, shape, edges, distance, angleDeg);
+	}
+	shell(shape, faces, thickness, tolerance) {
+		return shell(this.k, this.Module, shape, faces, thickness, tolerance);
+	}
+	thicken(shape, thickness) {
+		return thicken(this.k, shape, thickness);
+	}
+	offset(shape, distance, tolerance) {
+		return offset(this.k, shape, distance, tolerance);
+	}
+	filletVariable(shape, spec) {
+		return filletVariable(this.k, shape, spec);
+	}
+	draft(shape, faces, pullDirection, neutralPlane, angleDeg) {
+		return draft(this.k, shape, faces, pullDirection, neutralPlane, angleDeg);
+	}
+	defeature(shape, faces) {
+		return defeature(this.k, this.Module, shape, faces);
+	}
+	offsetWire2D(wire, offset, joinType) {
+		return offsetWire2D(this.k, wire, offset, joinType);
+	}
+	simplify(shape) {
+		return simplify(this.k, shape);
+	}
+	reverseShape(shape) {
+		return reverseShape(this.k, shape);
+	}
+	composeTransform(ops) {
+		return composeTransform(ops);
+	}
+	transform(shape, trsf) {
+		return transform(this.k, this.Module, shape, trsf);
+	}
+	translate(shape, x, y, z) {
+		return translate(this.k, shape, x, y, z);
+	}
+	rotate(shape, angle, axis, center) {
+		return rotate(this.k, shape, angle, axis, center);
+	}
+	mirror(shape, origin, normal) {
+		return mirror(this.k, shape, origin, normal);
+	}
+	scale(shape, center, factor) {
+		return scale(this.k, shape, center, factor);
+	}
+	generalTransform(shape, linear, translation, isOrthogonal) {
+		return generalTransform(this.k, this.Module, shape, linear, translation, isOrthogonal);
+	}
+	generalTransformNonOrthogonal(shape, linear, translation) {
+		return generalTransform(this.k, this.Module, shape, linear, translation, false);
+	}
+	positionOnCurve(shape, spine, param) {
+		return positionOnCurve(this.k, this.Module, shape, spine, param);
+	}
+	linearPattern(shape, direction, spacing, count) {
+		return linearPattern(this.k, shape, direction, spacing, count);
+	}
+	circularPattern(shape, center, axis, angleStep, count) {
+		return circularPattern(this.k, shape, center, axis, angleStep, count);
+	}
+	transformBatch(entries) {
+		return transformBatch(this.k, entries);
+	}
+	translateWithHistory(shape, x, y, z, inputFaceHashes, hashUpperBound) {
+		return translateWithHistory(this.k, this.Module, shape, x, y, z, inputFaceHashes, hashUpperBound);
+	}
+	rotateWithHistory(shape, angle, inputFaceHashes, hashUpperBound, axis, center) {
+		return rotateWithHistory(this.k, this.Module, shape, angle, inputFaceHashes, hashUpperBound, axis, center);
+	}
+	mirrorWithHistory(shape, origin, normal, inputFaceHashes, hashUpperBound) {
+		return mirrorWithHistory(this.k, this.Module, shape, origin, normal, inputFaceHashes, hashUpperBound);
+	}
+	scaleWithHistory(shape, center, factor, inputFaceHashes, hashUpperBound) {
+		return scaleWithHistory(this.k, this.Module, shape, center, factor, inputFaceHashes, hashUpperBound);
+	}
+	generalTransformWithHistory(shape, linear, translation, isOrthogonal, inputFaceHashes, _hashUpperBound) {
+		return generalTransformWithHistory((s, l, t, o) => this.generalTransform(s, l, t, o), shape, linear, translation, isOrthogonal, inputFaceHashes);
+	}
+	fuseWithHistory(shape, tool, inputFaceHashes, hashUpperBound, options) {
+		return fuseWithHistory(this.k, this.Module, shape, tool, inputFaceHashes, hashUpperBound, options);
+	}
+	cutWithHistory(shape, tool, inputFaceHashes, hashUpperBound, options) {
+		return cutWithHistory(this.k, this.Module, shape, tool, inputFaceHashes, hashUpperBound, options);
+	}
+	intersectWithHistory(shape, tool, inputFaceHashes, hashUpperBound, options) {
+		return intersectWithHistory(this.k, this.Module, shape, tool, inputFaceHashes, hashUpperBound, options);
+	}
+	filletWithHistory(shape, edges, radius, inputFaceHashes, hashUpperBound) {
+		return filletWithHistory(this.k, this.Module, shape, edges, radius, inputFaceHashes, hashUpperBound);
+	}
+	chamferWithHistory(shape, edges, distance, inputFaceHashes, hashUpperBound) {
+		return chamferWithHistory(this.k, this.Module, shape, edges, distance, inputFaceHashes, hashUpperBound);
+	}
+	shellWithHistory(shape, faces, thickness, inputFaceHashes, hashUpperBound, tolerance) {
+		return shellWithHistory(this.k, this.Module, shape, faces, thickness, inputFaceHashes, hashUpperBound, tolerance);
+	}
+	thickenWithHistory(shape, thickness, inputFaceHashes, hashUpperBound) {
+		return thickenWithHistory(this.k, this.Module, shape, thickness, inputFaceHashes, hashUpperBound);
+	}
+	offsetWithHistory(shape, distance, inputFaceHashes, hashUpperBound, tolerance) {
+		return offsetWithHistory(this.k, this.Module, shape, distance, inputFaceHashes, hashUpperBound, tolerance);
+	}
+	draftWithHistory(shape, faces, pullDirection, _neutralPlane, angleDeg, _inputFaceHashes, _hashUpperBound) {
+		return draftWithHistory(this.k, shape, faces, pullDirection, angleDeg);
+	}
+	applyComposedTransformWithHistory(shape, transformHandle, inputFaceHashes, hashUpperBound) {
+		return applyComposedTransformWithHistory((s, t) => this.transform(s, t), (s, t) => this.iterShapes(s, t), (s, ub) => this.hashCode(s, ub), shape, transformHandle, inputFaceHashes, hashUpperBound);
+	}
+	mesh(shape, options) {
+		return mesh(this.k, this.Module, shape, options);
+	}
+	meshEdges(shape, tolerance, angularTolerance) {
+		return meshEdges(this.k, this.Module, shape, tolerance, angularTolerance);
+	}
+	hasTriangulation(shape) {
+		return hasTriangulation(this.k, shape);
+	}
+	meshShape(shape, tolerance, angularTolerance) {
+		meshShape(this.k, shape, tolerance, angularTolerance);
+	}
+	exportSTEP(shapes) {
+		return exportSTEP(this.k, this.makeCompound.bind(this), shapes);
+	}
+	exportSTL(shape, binary) {
+		return exportSTL(this.k, shape, binary);
+	}
+	importSTEP(data) {
+		return importSTEP(this.k, data);
+	}
+	importSTL(data) {
+		return importSTL(this.k, this.Module, data);
+	}
+	exportIGES(shapes) {
+		return exportIGES(this.k, this.makeCompound.bind(this), shapes);
+	}
+	importIGES(data) {
+		return importIGES(this.k, data);
+	}
+	exportSTEPAssembly(parts, options) {
+		return exportSTEPAssembly(this.k, this.Module, parts, options);
+	}
+	export3MF(_shape, _tolerance) {
+		throw new Error("export3MF is only available with the brepkit kernel");
+	}
+	exportGLB(shape, tolerance) {
+		return exportGLB(this.mesh.bind(this), shape, tolerance);
+	}
+	exportOBJ(shape, tolerance) {
+		return exportOBJ(this.mesh.bind(this), shape, tolerance);
+	}
+	exportPLY(shape, tolerance) {
+		return exportPLY(this.mesh.bind(this), shape, tolerance);
+	}
+	import3MF(_data) {
+		throw new Error("import3MF is only available with the brepkit kernel");
+	}
+	importOBJ(_data) {
+		throw new Error("importOBJ is only available with the brepkit kernel");
+	}
+	importGLB(_data) {
+		throw new Error("importGLB is only available with the brepkit kernel");
+	}
+	toBREP(shape) {
+		return toBREP(this.k, shape);
+	}
+	fromBREP(data) {
+		return fromBREP(this.k, data);
+	}
+	createXCAFDocument(shapes) {
+		return createXCAFDocument(this.k, this.Module, shapes);
+	}
+	writeXCAFToSTEP(doc, options) {
+		return writeXCAFToSTEP(this.k, doc, options);
+	}
+	exportSTEPConfigured(shapes, options) {
+		return exportSTEPConfigured(this.k, this.Module, shapes, options);
+	}
+	volume(shape) {
+		return volume(this.k, shape);
+	}
+	area(shape) {
+		return area(this.k, shape);
+	}
+	length(shape) {
+		return length(this.k, shape);
+	}
+	centerOfMass(shape) {
+		return centerOfMass(this.k, shape);
+	}
+	linearCenterOfMass(shape) {
+		return linearCenterOfMass(this.k, shape);
+	}
+	boundingBox(shape) {
+		return boundingBox(this.k, shape);
+	}
+	distance(shape1, shape2) {
+		return distance(this.k, this.Module, shape1, shape2);
+	}
+	surfaceCurvature(face, u, v) {
+		return surfaceCurvature(this.k, face, u, v);
+	}
+	surfaceCenterOfMass(face) {
+		return surfaceCenterOfMass(this.k, face);
+	}
+	measureBulk(shape, includeLinear) {
+		return measureBulk(this.k, shape, includeLinear);
+	}
+	createDistanceQuery(referenceShape) {
+		return createDistanceQuery(this.k, referenceShape);
+	}
+	iterShapes(shape, type) {
+		return iterShapes(this.k, shape, type);
+	}
+	iterShapeList(_list, _callback) {
+		throw new Error("iterShapeList is not applicable to occt-wasm: the arena model has no TopTools_ListOfShape handles");
+	}
+	shapeType(shape) {
+		return shapeType(this.k, shape);
+	}
+	isSame(a, b) {
+		return isSame(this.k, a, b);
+	}
+	isEqual(a, b) {
+		return isEqual(this.k, a, b);
+	}
+	downcast(shape, type) {
+		return downcast(this.k, shape, type);
+	}
+	hashCode(shape, upperBound) {
+		return hashCode(this.k, shape, upperBound);
+	}
+	isNull(shape) {
+		return isNull(this.k, shape);
+	}
+	shapeOrientation(shape) {
+		return shapeOrientation(this.k, shape);
+	}
+	edgeToFaceMap(shape) {
+		return edgeToFaceMap(this.k, shape);
+	}
+	sharedEdges(faceA, faceB) {
+		return sharedEdges(this.k, faceA, faceB);
+	}
+	adjacentFaces(shape, face) {
+		return adjacentFaces(this.k, shape, face);
+	}
+	sew(shapes, tolerance) {
+		return sew(this.k, this.Module, shapes, tolerance);
+	}
+	curveType(shape) {
+		return curveType(this.k, shape);
+	}
+	curveParameters(shape) {
+		return curveParameters(this.k, shape);
+	}
+	curvePointAtParam(shape, param) {
+		return curvePointAtParam(this.k, shape, param);
+	}
+	curveTangent(shape, param) {
+		return curveTangent(this.k, shape, param);
+	}
+	curveIsClosed(shape) {
+		return curveIsClosed(this.k, shape);
+	}
+	curveIsPeriodic(shape) {
+		return curveIsPeriodic(this.k, shape);
+	}
+	curvePeriod(shape) {
+		return curvePeriod(this.k, shape);
+	}
+	interpolatePoints(points, options) {
+		return interpolatePoints(this.k, this.Module, points, options);
+	}
+	approximatePoints(points, options) {
+		return approximatePoints(this.k, this.Module, points, options);
+	}
+	curveDegreeElevate(_edge, _elevateBy) {
+		notImplemented("curveDegreeElevate");
+	}
+	curveKnotInsert(_edge, _knot, _times) {
+		notImplemented("curveKnotInsert");
+	}
+	curveKnotRemove(_edge, _knot, _tolerance) {
+		notImplemented("curveKnotRemove");
+	}
+	curveSplit(_edge, _param) {
+		notImplemented("curveSplit");
+	}
+	createCurveAdaptor(_shape) {
+		notImplemented("createCurveAdaptor");
+	}
+	getBezierPenultimatePole(_edge) {
+		notImplemented("getBezierPenultimatePole");
+	}
+	vertexPosition(vertex) {
+		return vertexPosition(this.k, vertex);
+	}
+	surfaceType(face) {
+		return surfaceType(this.k, face);
+	}
+	uvBounds(face) {
+		return uvBounds(this.k, face);
+	}
+	outerWire(face) {
+		return outerWire(this.k, face);
+	}
+	surfaceNormal(face, u, v) {
+		return surfaceNormal(this.k, face, u, v);
+	}
+	pointOnSurface(face, u, v) {
+		return pointOnSurface(this.k, face, u, v);
+	}
+	uvFromPoint(face, point) {
+		return uvFromPoint(this.k, face, point);
+	}
+	projectPointOnFace(face, point) {
+		return projectPointOnFace(this.k, face, point);
+	}
+	classifyPointOnFace(face, u, v, tolerance) {
+		return classifyPointOnFace(this.k, face, u, v, tolerance);
+	}
+	classifyPointRobust(_shape, _point, _tolerance) {
+		notImplemented("classifyPointRobust");
+	}
+	classifyPointWinding(_shape, _point, _tolerance) {
+		notImplemented("classifyPointWinding");
+	}
+	approximateSurfaceLspia(_coords, _rows, _cols, _degreeU, _degreeV, _numCpsU, _numCpsV, _tolerance, _maxIterations) {
+		notImplemented("approximateSurfaceLspia");
+	}
+	untrimFace(_face, _samplesPerCurve, _interiorSamples) {
+		notImplemented("untrimFace");
+	}
+	getSurfaceCylinderData(_surface) {
+		notImplemented("getSurfaceCylinderData");
+	}
+	reverseSurfaceU(_surface) {
+		notImplemented("reverseSurfaceU");
+	}
+	detectSmallFeatures(_shape, _areaThreshold, _tolerance) {
+		notImplemented("detectSmallFeatures");
+	}
+	recognizeFeatures(_shape, _tolerance) {
+		notImplemented("recognizeFeatures");
+	}
+	projectEdges(shape, cameraOrigin, cameraDirection, cameraXAxis) {
+		return projectEdges(this.k, this.Module, shape, cameraOrigin, cameraDirection, cameraXAxis);
+	}
+	isValid(shape) {
+		return isValid(this.k, shape);
+	}
+	healSolid(shape) {
+		return healSolid(this.k, shape);
+	}
+	healFace(shape) {
+		return healFace(this.k, shape);
+	}
+	healWire(wire, face) {
+		return healWire(this.k, wire, face);
+	}
+	mergeCoincidentVertices(shape, tolerance) {
+		return mergeCoincidentVertices(this.k, shape, tolerance);
+	}
+	removeDegenerateEdges(shape, tolerance) {
+		return removeDegenerateEdges(this.k, shape, tolerance);
+	}
+	fixFaceOrientations(shape) {
+		return fixFaceOrientations(this.k, shape);
+	}
+	fixShape(shape) {
+		return fixShape(this.k, shape);
+	}
+	fixSelfIntersection(_wire) {
+		notImplemented("fixSelfIntersection");
+	}
+	createPoint2d(x, y) {
+		return createPoint2d(x, y);
+	}
+	createDirection2d(x, y) {
+		return createDirection2d(x, y);
+	}
+	createVector2d(x, y) {
+		return createVector2d(x, y);
+	}
+	createAxis2d(px, py, dx, dy) {
+		return createAxis2d(px, py, dx, dy);
+	}
+	wrapCurve2dHandle(h) {
+		return wrapCurve2dHandle(h);
+	}
+	createCurve2dAdaptor(_handle) {
+		notImplemented("createCurve2dAdaptor");
+	}
+	makeLine2d(x1, y1, x2, y2) {
+		return makeLine2d(x1, y1, x2, y2);
+	}
+	makeCircle2d(cx, cy, radius, sense) {
+		return makeCircle2d(cx, cy, radius, sense);
+	}
+	makeArc2dThreePoints(x1, y1, xm, ym, x2, y2) {
+		return makeArc2dThreePoints(x1, y1, xm, ym, x2, y2);
+	}
+	makeArc2dTangent(startX, startY, tangentX, tangentY, endX, endY) {
+		return makeArc2dTangent(startX, startY, tangentX, tangentY, endX, endY);
+	}
+	makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX, xDirY, sense) {
+		return makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX, xDirY, sense);
+	}
+	makeEllipseArc2d(cx, cy, majorRadius, minorRadius, startAngle, endAngle, xDirX, xDirY, sense) {
+		return makeEllipseArc2d(cx, cy, majorRadius, minorRadius, startAngle, endAngle, xDirX, xDirY, sense);
+	}
+	makeBezier2d(points) {
+		return makeBezier2d(points);
+	}
+	makeBSpline2d(points, _options) {
+		return makeBSpline2d(points);
+	}
+	evaluateCurve2d(curve, param) {
+		return evaluateCurve2d(curve, param);
+	}
+	evaluateCurve2dD1(curve, param) {
+		return evaluateCurve2dD1(curve, param);
+	}
+	getCurve2dBounds(curve) {
+		return getCurve2dBounds(curve);
+	}
+	getCurve2dType(curve) {
+		return getCurve2dType(curve);
+	}
+	trimCurve2d(curve, start, end) {
+		return trimCurve2d(curve, start, end);
+	}
+	reverseCurve2d(curve) {}
+	copyCurve2d(curve) {
+		return copyCurve2d(curve);
+	}
+	offsetCurve2d(curve, offset) {
+		return offsetCurve2d(curve, offset);
+	}
+	translateCurve2d(curve, dx, dy) {
+		return translateCurve2d(curve, dx, dy);
+	}
+	rotateCurve2d(curve, angle, cx, cy) {
+		return rotateCurve2d(curve, angle, cx, cy);
+	}
+	scaleCurve2d(curve, factor, cx, cy) {
+		return scaleCurve2d(curve, factor, cx, cy);
+	}
+	mirrorCurve2dAtPoint(curve, cx, cy) {
+		return mirrorCurve2dAtPoint(curve, cx, cy);
+	}
+	mirrorCurve2dAcrossAxis(curve, originX, originY, dirX, dirY) {
+		return mirrorCurve2dAcrossAxis(curve, originX, originY, dirX, dirY);
+	}
+	affinityTransform2d(curve, _axisOriginX, _axisOriginY, _axisDirX, _axisDirY, _ratio) {
+		return affinityTransform2d(curve);
+	}
+	createIdentityGTrsf2d() {
+		return createIdentityGTrsf2d();
+	}
+	createAffinityGTrsf2d(originX, originY, dirX, dirY, ratio) {
+		return createAffinityGTrsf2d(originX, originY, dirX, dirY, ratio);
+	}
+	createTranslationGTrsf2d(dx, dy) {
+		return createTranslationGTrsf2d(dx, dy);
+	}
+	createMirrorGTrsf2d(cx, cy, mode, originX, originY, dirX, dirY) {
+		return createMirrorGTrsf2d(cx, cy, mode, originX, originY, dirX, dirY);
+	}
+	createRotationGTrsf2d(angle, cx, cy) {
+		return createRotationGTrsf2d(angle, cx, cy);
+	}
+	createScaleGTrsf2d(factor, cx, cy) {
+		return createScaleGTrsf2d(factor, cx, cy);
+	}
+	setGTrsf2dTranslationPart(gtrsf, dx, dy) {
+		setGTrsf2dTranslationPart(gtrsf, dx, dy);
+	}
+	multiplyGTrsf2d(base, other) {
+		multiplyGTrsf2d(base, other);
+	}
+	transformCurve2dGeneral(curve, gtrsf) {
+		return transformCurve2dGeneral(curve, gtrsf);
+	}
+	intersectCurves2d(c1, c2, tolerance) {
+		return intersectCurves2d(c1, c2, tolerance);
+	}
+	projectPointOnCurve2d(curve, x, y) {
+		return projectPointOnCurve2d(curve, x, y);
+	}
+	distanceBetweenCurves2d(c1, c2, p1Start, p1End, p2Start, p2End) {
+		return distanceBetweenCurves2d(c1, c2, p1Start, p1End, p2Start, p2End);
+	}
+	approximateCurve2dAsBSpline(curve, _tolerance, _continuity, maxSegments) {
+		return approximateCurve2dAsBSpline(curve, maxSegments);
+	}
+	decomposeBSpline2dToBeziers(curve) {
+		return decomposeBSpline2dToBeziers(curve);
+	}
+	createBoundingBox2d() {
+		return createBoundingBox2d();
+	}
+	addCurveToBBox2d(bbox, curve, tolerance) {
+		addCurveToBBox2d(bbox, curve, tolerance);
+	}
+	getBBox2dBounds(bbox) {
+		return getBBox2dBounds(bbox);
+	}
+	mergeBBox2d(target, other) {
+		mergeBBox2d(target, other);
+	}
+	isBBox2dOut(a, b) {
+		return isBBox2dOut(a, b);
+	}
+	isBBox2dOutPoint(bbox, x, y) {
+		return isBBox2dOutPoint(bbox, x, y);
+	}
+	getCurve2dCircleData(curve) {
+		return getCurve2dCircleData(curve);
+	}
+	getCurve2dEllipseData(curve) {
+		return getCurve2dEllipseData(curve);
+	}
+	getCurve2dBezierPoles(curve) {
+		return getCurve2dBezierPoles(curve);
+	}
+	getCurve2dBezierDegree(curve) {
+		return getCurve2dBezierDegree(curve);
+	}
+	getCurve2dBSplineData(_curve) {
+		notImplemented("getCurve2dBSplineData");
+	}
+	serializeCurve2d(curve) {
+		return serializeCurve2d(curve);
+	}
+	deserializeCurve2d(data) {
+		return deserializeCurve2d(data);
+	}
+	splitCurve2d(curve, params) {
+		return splitCurve2d(curve, params);
+	}
+	liftCurve2dToPlane(curve, planeOrigin, planeZ, planeX) {
+		return liftCurve2dToPlane(this.k, this.Module, curve, planeOrigin, planeZ, planeX);
+	}
+	buildEdgeOnSurface(curve, surface) {
+		return buildEdgeOnSurface(this.k, this.Module, curve, surface);
+	}
+	extractSurfaceFromFace(face) {
+		return extractSurfaceFromFace(face);
+	}
+	extractCurve2dFromEdge(_edge, _face) {
+		return extractCurve2dFromEdge();
+	}
+	buildCurves3d(wire) {
+		buildCurves3d(this.k, wire);
+	}
+	fixWireOnFace(wire, face, tolerance) {
+		return fixWireOnFace(this.k, wire, face, tolerance);
+	}
+	fillSurface(_wires, _options) {
+		notImplemented("fillSurface");
+	}
+	getNurbsCurveData(edge) {
+		return getNurbsCurveData(this.k, edge);
+	}
+};
+//#endregion
+Object.defineProperty(exports, "OcctWasmAdapter", {
+	enumerable: true,
+	get: function() {
+		return OcctWasmAdapter;
+	}
+});
+Object.defineProperty(exports, "addCurveToBBox", {
+	enumerable: true,
+	get: function() {
+		return addCurveToBBox;
+	}
+});
+Object.defineProperty(exports, "createBBox2d", {
+	enumerable: true,
+	get: function() {
+		return createBBox2d;
+	}
+});
+Object.defineProperty(exports, "curveBounds", {
+	enumerable: true,
+	get: function() {
+		return curveBounds;
+	}
+});
+Object.defineProperty(exports, "curveTypeName", {
+	enumerable: true,
+	get: function() {
+		return curveTypeName;
+	}
+});
+Object.defineProperty(exports, "deserializeCurve2d", {
+	enumerable: true,
+	get: function() {
+		return deserializeCurve2d$1;
+	}
+});
+Object.defineProperty(exports, "evaluateCurve2d", {
+	enumerable: true,
+	get: function() {
+		return evaluateCurve2d$1;
+	}
+});
+Object.defineProperty(exports, "intersectCurves2dFn", {
+	enumerable: true,
+	get: function() {
+		return intersectCurves2dFn;
+	}
+});
+Object.defineProperty(exports, "makeBezier2d", {
+	enumerable: true,
+	get: function() {
+		return makeBezier2d$1;
+	}
+});
+Object.defineProperty(exports, "makeCircle2d", {
+	enumerable: true,
+	get: function() {
+		return makeCircle2d$1;
+	}
+});
+Object.defineProperty(exports, "makeEllipse2d", {
+	enumerable: true,
+	get: function() {
+		return makeEllipse2d$1;
+	}
+});
+Object.defineProperty(exports, "makeLine2d", {
+	enumerable: true,
+	get: function() {
+		return makeLine2d$1;
+	}
+});
+Object.defineProperty(exports, "mirrorAcrossAxis", {
+	enumerable: true,
+	get: function() {
+		return mirrorAcrossAxis;
+	}
+});
+Object.defineProperty(exports, "mirrorAtPoint", {
+	enumerable: true,
+	get: function() {
+		return mirrorAtPoint;
+	}
+});
+Object.defineProperty(exports, "rotateCurve2d", {
+	enumerable: true,
+	get: function() {
+		return rotateCurve2d$1;
+	}
+});
+Object.defineProperty(exports, "scaleCurve2d", {
+	enumerable: true,
+	get: function() {
+		return scaleCurve2d$1;
+	}
+});
+Object.defineProperty(exports, "serializeCurve2d", {
+	enumerable: true,
+	get: function() {
+		return serializeCurve2d$1;
+	}
+});
+Object.defineProperty(exports, "tangentCurve2d", {
+	enumerable: true,
+	get: function() {
+		return tangentCurve2d;
+	}
+});
+Object.defineProperty(exports, "translateCurve2d", {
+	enumerable: true,
+	get: function() {
+		return translateCurve2d$1;
+	}
+});