brepjs 12.2.4 → 12.2.5

package/dist/brepjs.cjs

@@ -74,6 +74,4211 @@ const worker = require("./worker.cjs");
 function supportsProjection(kernel) {
   return "projectShape" in kernel;
 }
+function evaluateCurve2d(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(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 scale2 = c.tEnd - c.tStart;
+      return [tan[0] * scale2, tan[1] * scale2];
+    }
+  }
+}
+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(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(cx, cy, radius, sense = true) {
+  return { __bk2d: "circle", cx, cy, radius, sense };
+}
+function makeEllipse2d(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(poles) {
+  return { __bk2d: "bezier", poles: [...poles] };
+}
+function translateCurve2d(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(c.basis, dx, dy) };
+  }
+}
+function rotateCurve2d(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(c.basis, angle, cx, cy) };
+  }
+}
+function scaleCurve2d(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(c.basis, factor, cx, cy) };
+  }
+}
+function mirrorAtPoint(c, cx, cy) {
+  return scaleCurve2d(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) };
+  }
+}
+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: [] };
+  }
+  const isSelf = c1 === c2;
+  return numericalIntersect(c1, c2, tolerance, isSelf);
+}
+function unwrapCurve(c) {
+  let cur = c;
+  while (cur.__bk2d === "trimmed") cur = cur.basis;
+  return cur;
+}
+function inDomain(c, t, tol) {
+  const b = curveBounds(c);
+  return t >= b.first - tol && t <= b.last + tol;
+}
+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 [ex2, ey2] = evaluateCurve2d(c, t);
+    const d = (ex2 - px) ** 2 + (ey2 - py) ** 2;
+    if (d < bestD) {
+      bestD = d;
+      bestT = t;
+    }
+  }
+  const [sx, sy] = evaluateCurve2d(c, bounds.first);
+  const [ex, ey] = evaluateCurve2d(c, bounds.last);
+  const [mx, my] = evaluateCurve2d(c, (bounds.first + bounds.last) / 2);
+  const geomExtent = Math.max(
+    Math.sqrt((ex - sx) ** 2 + (ey - sy) ** 2),
+    Math.sqrt((mx - sx) ** 2 + (my - sy) ** 2),
+    1e-6
+  );
+  const maxDist = geomExtent * 0.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 ex3 = l2.ox - l1.ox;
+    const ey3 = l2.oy - l1.oy;
+    const t1 = (ex3 * l2.dy - ey3 * l2.dx) / det;
+    const t2 = (ex3 * l1.dy - ey3 * 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(c2, b2.first);
+  const p2e = evaluateCurve2d(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: [] };
+  const sx = l1.ox + overlapStart * l1.dx;
+  const sy = l1.oy + overlapStart * l1.dy;
+  const ex2 = l1.ox + overlapEnd * l1.dx;
+  const ey2 = l1.oy + overlapEnd * l1.dy;
+  const seg = makeLine2d(sx, sy, ex2, ey2);
+  return { points: [], segments: [seg] };
+}
+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(cCirc, tCirc);
+    if ((cx2 - px) ** 2 + (cy2 - py) ** 2 > tol * tol * 1e6) continue;
+    results.push([px, py]);
+  }
+  return results;
+}
+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) return [];
+  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(c1, t1);
+    const [x2, y2] = evaluateCurve2d(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;
+}
+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(c1, t1);
+    pts1.push({ t: t1, x: x1, y: y1 });
+    const t2 = b2.first + (b2.last - b2.first) * i / N;
+    const [x2, y2] = evaluateCurve2d(c2, t2);
+    pts2.push({ t: t2, x: x2, y: y2 });
+  }
+  const crossTol = Math.max(tolerance * 100, 0.5);
+  const candidates = [];
+  for (let i = 0; i < N; i++) {
+    const p1a = pts1[i];
+    const p1b = pts1[i + 1];
+    for (let j = 0; j < N; j++) {
+      const p2a = pts2[j];
+      const p2b = pts2[j + 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 x2min = Math.min(p2a.x, p2b.x);
+      const x2max = Math.max(p2a.x, p2b.x);
+      const y2min = Math.min(p2a.y, p2b.y);
+      const y2max = Math.max(p2a.y, p2b.y);
+      if (x1max < x2min || x2max < x1min || y1max < y2min || y2max < y1min) continue;
+      const t1mid = (p1a.t + p1b.t) / 2;
+      const t2mid = (p2a.t + p2b.t) / 2;
+      if (isSelf && Math.abs(t1mid - t2mid) < (b1.last - b1.first) / 5) 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 [x12, y12] = evaluateCurve2d(c1, t1);
+      const [x22, y22] = evaluateCurve2d(c2, t2);
+      const dx = x12 - x22;
+      const dy = y12 - y22;
+      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(c1, t1);
+    const [x2, y2] = evaluateCurve2d(c2, t2);
+    if (isSelf && Math.abs(t1 - t2) < (b1.last - b1.first) * 0.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(c) {
+  return JSON.stringify(c);
+}
+function deserializeCurve2d(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 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 t = bounds.first + i * dt;
+    const [x, y] = evaluateCurve2d(c, t);
+    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 right = fullKnots[i + p - r + 1] ?? 1;
+      const denom = right - 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];
+}
+function isBrepkitHandle(shape2) {
+  return shape2 !== null && shape2 !== void 0 && typeof shape2 === "object" && shape2.__brepkit;
+}
+const noop = () => {
+};
+function handle(type, id) {
+  return {
+    __brepkit: true,
+    type,
+    id,
+    delete: noop,
+    HashCode(upperBound) {
+      return id % upperBound;
+    },
+    IsNull() {
+      return false;
+    }
+  };
+}
+function solidHandle(id) {
+  return handle("solid", id);
+}
+function faceHandle(id) {
+  return handle("face", id);
+}
+function edgeHandle(id) {
+  return handle("edge", id);
+}
+function wireHandle(id) {
+  return handle("wire", id);
+}
+function shellHandle(id) {
+  return handle("shell", id);
+}
+function compoundHandle(id) {
+  const h = handle("compound", id);
+  if (syntheticCompounds.has(id)) {
+    return { ...h, delete: () => syntheticCompounds.delete(id) };
+  }
+  return h;
+}
+function vertexHandle(id) {
+  return handle("vertex", id);
+}
+function unwrap(shape2, expected) {
+  if (!isBrepkitHandle(shape2)) {
+    throw new Error("brepkit: expected a BrepkitHandle, got " + typeof shape2);
+  }
+  if (expected && shape2.type !== expected) {
+    throw new Error(`brepkit: expected ${expected} handle, got ${shape2.type}`);
+  }
+  return shape2.id;
+}
+function toArray(ids) {
+  return Array.from(ids);
+}
+function unwrapSolidOrThrow(shape2, methodName) {
+  if (!isBrepkitHandle(shape2)) {
+    throw new Error("brepkit: expected a BrepkitHandle, got " + typeof shape2);
+  }
+  if (shape2.type !== "solid") {
+    throw new Error(
+      `brepkit: ${methodName} requires a solid, got ${shape2.type}. Consider using makeCompound() to combine shapes first.`
+    );
+  }
+  return shape2.id;
+}
+function unwrapSolidsForExport(bk, shape2, methodName) {
+  if (!isBrepkitHandle(shape2)) {
+    throw new Error("brepkit: expected a BrepkitHandle, got " + typeof shape2);
+  }
+  if (shape2.type === "solid") {
+    return [shape2.id];
+  }
+  if (shape2.type === "compound") {
+    const ids = toArray(bk.getCompoundSolids(shape2.id));
+    if (ids.length > 0) return ids;
+    throw new Error(`brepkit: ${methodName} received a compound with no solids.`);
+  }
+  throw new Error(
+    `brepkit: ${methodName} requires a solid or compound of solids, got ${shape2.type}.`
+  );
+}
+function dist3(x1, y1, z1, x2, y2, z2) {
+  const dx = x1 - x2, dy = y1 - y2, dz = z1 - z2;
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+function translationMatrix(x, y, z) {
+  return [
+    1,
+    0,
+    0,
+    x,
+    0,
+    1,
+    0,
+    y,
+    0,
+    0,
+    1,
+    z,
+    0,
+    0,
+    0,
+    1
+  ];
+}
+function rotationMatrix(angleDeg, axis = [0, 0, 1], center = [0, 0, 0]) {
+  const rad = angleDeg * Math.PI / 180;
+  const c = Math.cos(rad);
+  const s = Math.sin(rad);
+  const t = 1 - c;
+  const len = Math.sqrt(axis[0] ** 2 + axis[1] ** 2 + axis[2] ** 2);
+  const [ux, uy, uz] = [axis[0] / len, axis[1] / len, axis[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;
+  const [cx, cy, cz] = center;
+  const tx = cx - (r00 * cx + r01 * cy + r02 * cz);
+  const ty = cy - (r10 * cx + r11 * cy + r12 * cz);
+  const tz = cz - (r20 * cx + r21 * cy + r22 * cz);
+  return [
+    r00,
+    r01,
+    r02,
+    tx,
+    r10,
+    r11,
+    r12,
+    ty,
+    r20,
+    r21,
+    r22,
+    tz,
+    0,
+    0,
+    0,
+    1
+  ];
+}
+function scaleMatrix(center, factor) {
+  const [cx, cy, cz] = center;
+  const tx = cx * (1 - factor);
+  const ty = cy * (1 - factor);
+  const tz = cz * (1 - factor);
+  return [
+    factor,
+    0,
+    0,
+    tx,
+    0,
+    factor,
+    0,
+    ty,
+    0,
+    0,
+    factor,
+    tz,
+    0,
+    0,
+    0,
+    1
+  ];
+}
+function affineMatrix(linear, translation) {
+  return [
+    linear[0],
+    linear[1],
+    linear[2],
+    translation[0],
+    linear[3],
+    linear[4],
+    linear[5],
+    translation[1],
+    linear[6],
+    linear[7],
+    linear[8],
+    translation[2],
+    0,
+    0,
+    0,
+    1
+  ];
+}
+function mirrorMatrix(origin, normal) {
+  const [ox, oy, oz] = origin;
+  const len = Math.sqrt(normal[0] ** 2 + normal[1] ** 2 + normal[2] ** 2);
+  const nx = normal[0] / len;
+  const ny = normal[1] / len;
+  const nz = normal[2] / len;
+  const d = 2 * (ox * nx + oy * ny + oz * nz);
+  return [
+    1 - 2 * nx * nx,
+    -2 * nx * ny,
+    -2 * nx * nz,
+    d * nx,
+    -2 * ny * nx,
+    1 - 2 * ny * ny,
+    -2 * ny * nz,
+    d * ny,
+    -2 * nz * nx,
+    -2 * nz * ny,
+    1 - 2 * nz * nz,
+    d * nz,
+    0,
+    0,
+    0,
+    1
+  ];
+}
+const DEFAULT_DEFLECTION = 0.01;
+const DEFAULT_SEGMENTS = 32;
+let syntheticCompoundCounter = 9e5;
+const syntheticCompounds = /* @__PURE__ */ new Map();
+const _warned = /* @__PURE__ */ new Set();
+function warnOnce(key, message) {
+  if (_warned.has(key)) return;
+  _warned.add(key);
+  console.warn(`brepkit: ${message}`);
+}
+function hasBooleanOptions(opts) {
+  return opts.optimisation !== void 0 || opts.simplify !== void 0 || opts.strategy !== void 0 || opts.fuzzyValue !== void 0;
+}
+class BrepkitAdapter {
+  oc;
+  kernelId = "brepkit";
+  /** The underlying brepkit WASM kernel instance (typed). */
+  bk;
+  constructor(brepkitKernel) {
+    this.bk = brepkitKernel;
+    this.oc = brepkitKernel;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Boolean operations
+  // ═══════════════════════════════════════════════════════════════════════
+  fuse(shape2, tool, _options) {
+    if (_options && hasBooleanOptions(_options)) {
+      warnOnce(
+        "boolean-options",
+        "BooleanOptions (optimisation, simplify, strategy, fuzzyValue) not supported; ignored."
+      );
+    }
+    const baseId = unwrapSolidOrThrow(shape2, "fuse");
+    const toolHandle = tool;
+    if (toolHandle.type === "compound") {
+      const toolSolidIds = toArray(this.bk.getCompoundSolids(toolHandle.id));
+      let currentId = baseId;
+      for (const toolSolidId of toolSolidIds) {
+        currentId = this.bk.fuse(currentId, toolSolidId);
+      }
+      return solidHandle(currentId);
+    }
+    const result2 = this.bk.fuse(baseId, unwrapSolidOrThrow(tool, "fuse"));
+    return solidHandle(result2);
+  }
+  cut(shape2, tool, _options) {
+    if (_options && hasBooleanOptions(_options)) {
+      warnOnce(
+        "boolean-options",
+        "BooleanOptions (optimisation, simplify, strategy, fuzzyValue) not supported; ignored."
+      );
+    }
+    const baseId = unwrapSolidOrThrow(shape2, "cut");
+    const toolHandle = tool;
+    if (toolHandle.type === "compound") {
+      const toolSolidIds = toArray(this.bk.getCompoundSolids(toolHandle.id));
+      let currentId = baseId;
+      for (const toolSolidId of toolSolidIds) {
+        currentId = this.bk.cut(currentId, toolSolidId);
+      }
+      return solidHandle(currentId);
+    }
+    const result2 = this.bk.cut(baseId, unwrapSolidOrThrow(tool, "cut"));
+    return solidHandle(result2);
+  }
+  intersect(shape2, tool, _options) {
+    if (_options && hasBooleanOptions(_options)) {
+      warnOnce(
+        "boolean-options",
+        "BooleanOptions (optimisation, simplify, strategy, fuzzyValue) not supported; ignored."
+      );
+    }
+    const result2 = this.bk.intersect(
+      unwrapSolidOrThrow(shape2, "intersect"),
+      unwrapSolidOrThrow(tool, "intersect")
+    );
+    return solidHandle(result2);
+  }
+  section(shape2, plane, _approximation) {
+    const { point, normal } = this.extractPlaneFromFace(plane);
+    const solidId = isBrepkitHandle(shape2) && shape2.type === "solid" ? shape2.id : unwrap(shape2, "solid");
+    const faceIds = toArray(
+      this.bk.section(solidId, point[0], point[1], point[2], normal[0], normal[1], normal[2])
+    );
+    if (faceIds.length === 0) {
+      return compoundHandle(this.bk.makeCompound([]));
+    }
+    const firstWireId = this.bk.getFaceOuterWire(faceIds[0]);
+    return wireHandle(firstWireId);
+  }
+  fuseAll(shapes, options) {
+    if (shapes.length === 0) throw new Error("brepkit: fuseAll requires at least one shape");
+    if (shapes.length === 1) return shapes[0];
+    let current = [...shapes];
+    while (current.length > 1) {
+      const next = [];
+      for (let i = 0; i < current.length; i += 2) {
+        if (i + 1 < current.length) {
+          next.push(this.fuse(current[i], current[i + 1], options));
+        } else {
+          next.push(current[i]);
+        }
+      }
+      current = next;
+    }
+    return current[0];
+  }
+  cutAll(shape2, tools, options) {
+    let result2 = shape2;
+    for (const tool of tools) {
+      result2 = this.cut(result2, tool, options);
+    }
+    return result2;
+  }
+  split(shape2, tools) {
+    if (tools.length === 0) throw new Error("brepkit: split requires at least one tool");
+    const { point, normal } = this.extractPlaneFromFace(tools[0]);
+    const result2 = toArray(
+      this.bk.split(
+        unwrap(shape2, "solid"),
+        point[0],
+        point[1],
+        point[2],
+        normal[0],
+        normal[1],
+        normal[2]
+      )
+    );
+    return compoundHandle(this.bk.makeCompound(result2));
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Convex hull (not yet implemented)
+  // ═══════════════════════════════════════════════════════════════════════
+  hull(shapes, _tolerance) {
+    const coords = [];
+    for (const shape2 of shapes) {
+      const h = shape2;
+      if (h.type === "solid") {
+        const vertIds = toArray(this.bk.getSolidVertices(h.id));
+        for (const vid of vertIds) {
+          const pos = this.bk.getVertexPosition(vid);
+          coords.push(pos[0], pos[1], pos[2]);
+        }
+      } else if (h.type === "vertex") {
+        const pos = this.bk.getVertexPosition(h.id);
+        coords.push(pos[0], pos[1], pos[2]);
+      }
+    }
+    if (coords.length < 12) throw new Error("brepkit: hull requires enough points");
+    const id = this.bk.convexHull(coords);
+    return solidHandle(id);
+  }
+  hullFromPoints(points, _tolerance) {
+    if (points.length < 4) throw new Error("brepkit: hull needs at least 4 points");
+    const coords = [];
+    for (const p of points) {
+      coords.push(p.x, p.y, p.z);
+    }
+    const id = this.bk.convexHull(coords);
+    return solidHandle(id);
+  }
+  buildSolidFromFaces(points, faces, _tolerance) {
+    const positions = new Float64Array(points.length * 3);
+    for (let i = 0; i < points.length; i++) {
+      const p = points[i];
+      positions[i * 3] = p.x;
+      positions[i * 3 + 1] = p.y;
+      positions[i * 3 + 2] = p.z;
+    }
+    const indices = new Uint32Array(faces.length * 3);
+    for (let i = 0; i < faces.length; i++) {
+      const f = faces[i];
+      indices[i * 3] = f[0];
+      indices[i * 3 + 1] = f[1];
+      indices[i * 3 + 2] = f[2];
+    }
+    const id = this.bk.importIndexedMesh(positions, indices);
+    return solidHandle(id);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Shape construction
+  // ═══════════════════════════════════════════════════════════════════════
+  makeVertex(x, y, z) {
+    const id = this.bk.makeVertex(x, y, z);
+    return vertexHandle(id);
+  }
+  makeEdge(curve, start, end) {
+    if (curve && typeof curve === "object" && "origin" in curve && "direction" in curve) {
+      const { origin, direction } = curve;
+      const t0 = start ?? 0;
+      const t1 = end ?? 1;
+      return this.makeLineEdge(
+        [
+          origin[0] + direction[0] * t0,
+          origin[1] + direction[1] * t0,
+          origin[2] + direction[2] * t0
+        ],
+        [
+          origin[0] + direction[0] * t1,
+          origin[1] + direction[1] * t1,
+          origin[2] + direction[2] * t1
+        ]
+      );
+    }
+    if (isBrepkitHandle(curve) && curve.type === "edge") {
+      return curve;
+    }
+    throw new Error("brepkit: makeEdge requires a curve with origin/direction, or an edge handle");
+  }
+  makeWire(edges) {
+    const edgeIds = [];
+    for (const e of edges) {
+      const h = e;
+      if (h.type === "wire") {
+        for (const childEdgeId of toArray(this.bk.getWireEdges(h.id))) {
+          edgeIds.push(childEdgeId);
+        }
+      } else {
+        edgeIds.push(unwrap(e, "edge"));
+      }
+    }
+    const id = this.bk.makeWire(edgeIds, true);
+    return wireHandle(id);
+  }
+  makeFace(wire, _planar) {
+    const h = wire;
+    if (h.type === "edge") {
+      const wireId = this.bk.makeWire([h.id], true);
+      const id2 = this.bk.makeFaceFromWire(wireId);
+      return faceHandle(id2);
+    }
+    const id = this.bk.makeFaceFromWire(unwrap(wire, "wire"));
+    return faceHandle(id);
+  }
+  makeBox(width, height, depth) {
+    const id = this.bk.makeBox(width, height, depth);
+    return solidHandle(id);
+  }
+  makeRectangle(width, height) {
+    const id = this.bk.makeRectangle(width, height);
+    return faceHandle(id);
+  }
+  makeCylinder(radius, height, center, direction) {
+    const id = this.bk.makeCylinder(radius, height);
+    const sh = solidHandle(id);
+    if (this.needsTransform(center, direction)) {
+      return this.transformToPlacement(sh, center, direction);
+    }
+    return sh;
+  }
+  makeSphere(radius, center) {
+    const id = this.bk.makeSphere(radius, DEFAULT_SEGMENTS);
+    const sh = solidHandle(id);
+    if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) {
+      return this.translate(sh, center[0], center[1], center[2]);
+    }
+    return sh;
+  }
+  makeCone(radius1, radius2, height, center, direction) {
+    const id = this.bk.makeCone(radius1, radius2, height);
+    const sh = solidHandle(id);
+    if (this.needsTransform(center, direction)) {
+      return this.transformToPlacement(sh, center, direction);
+    }
+    return sh;
+  }
+  makeTorus(majorRadius, minorRadius, center, direction) {
+    const id = this.bk.makeTorus(majorRadius, minorRadius, DEFAULT_SEGMENTS);
+    const sh = solidHandle(id);
+    if (this.needsTransform(center, direction)) {
+      return this.transformToPlacement(sh, center, direction);
+    }
+    return sh;
+  }
+  makeEllipsoid(aLength, bLength, cLength) {
+    const maxR = Math.max(aLength, bLength, cLength);
+    const sphere = this.makeSphere(maxR);
+    const scaleX = aLength / maxR;
+    const scaleY = bLength / maxR;
+    const scaleZ = cLength / maxR;
+    return this.generalTransform(
+      sphere,
+      [scaleX, 0, 0, 0, scaleY, 0, 0, 0, scaleZ],
+      [0, 0, 0],
+      false
+    );
+  }
+  // --- Extended construction ---
+  makeLineEdge(p1, p2) {
+    const id = this.bk.makeLineEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]);
+    return edgeHandle(id);
+  }
+  makeCircleEdge(center, normal, radius) {
+    return this.makeCircleNurbs(center, normal, radius, 0, 2 * Math.PI);
+  }
+  makeCircleArc(center, normal, radius, startAngle, endAngle) {
+    return this.makeCircleNurbs(center, normal, radius, startAngle, endAngle);
+  }
+  makeArcEdge(p1, p2, p3) {
+    const ab = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
+    const ac = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+    const normal = [
+      ab[1] * ac[2] - ab[2] * ac[1],
+      ab[2] * ac[0] - ab[0] * ac[2],
+      ab[0] * ac[1] - ab[1] * ac[0]
+    ];
+    const nLen = Math.sqrt(normal[0] ** 2 + normal[1] ** 2 + normal[2] ** 2);
+    if (nLen < 1e-12) {
+      return this.makeLineEdge(p1, p3);
+    }
+    const nz = [normal[0] / nLen, normal[1] / nLen, normal[2] / nLen];
+    const abLen = Math.sqrt(ab[0] ** 2 + ab[1] ** 2 + ab[2] ** 2);
+    const ux = [ab[0] / abLen, ab[1] / abLen, ab[2] / abLen];
+    const uy = [
+      nz[1] * ux[2] - nz[2] * ux[1],
+      nz[2] * ux[0] - nz[0] * ux[2],
+      nz[0] * ux[1] - nz[1] * ux[0]
+    ];
+    const proj = (p) => {
+      const dx = p[0] - p1[0], dy = p[1] - p1[1], dz = p[2] - p1[2];
+      return [dx * ux[0] + dy * ux[1] + dz * ux[2], dx * uy[0] + dy * uy[1] + dz * uy[2]];
+    };
+    const [ax2, ay2] = proj(p1);
+    const [bx2, by2] = proj(p2);
+    const [cx2, cy2] = proj(p3);
+    const d = 2 * (ax2 * (by2 - cy2) + bx2 * (cy2 - ay2) + cx2 * (ay2 - by2));
+    if (Math.abs(d) < 1e-12) {
+      return this.makeLineEdge(p1, p3);
+    }
+    const ccx = ((ax2 ** 2 + ay2 ** 2) * (by2 - cy2) + (bx2 ** 2 + by2 ** 2) * (cy2 - ay2) + (cx2 ** 2 + cy2 ** 2) * (ay2 - by2)) / d;
+    const ccy = ((ax2 ** 2 + ay2 ** 2) * (cx2 - bx2) + (bx2 ** 2 + by2 ** 2) * (ax2 - cx2) + (cx2 ** 2 + cy2 ** 2) * (bx2 - ax2)) / d;
+    const center = [
+      p1[0] + ccx * ux[0] + ccy * uy[0],
+      p1[1] + ccx * ux[1] + ccy * uy[1],
+      p1[2] + ccx * ux[2] + ccy * uy[2]
+    ];
+    const radius = Math.sqrt(
+      (p1[0] - center[0]) ** 2 + (p1[1] - center[1]) ** 2 + (p1[2] - center[2]) ** 2
+    );
+    const lx = [p1[0] - center[0], p1[1] - center[1], p1[2] - center[2]];
+    const lxLen = Math.sqrt(lx[0] ** 2 + lx[1] ** 2 + lx[2] ** 2);
+    const uxA = [lx[0] / lxLen, lx[1] / lxLen, lx[2] / lxLen];
+    const uyA = [
+      nz[1] * uxA[2] - nz[2] * uxA[1],
+      nz[2] * uxA[0] - nz[0] * uxA[2],
+      nz[0] * uxA[1] - nz[1] * uxA[0]
+    ];
+    const v3 = [p3[0] - center[0], p3[1] - center[1], p3[2] - center[2]];
+    const dotX = v3[0] * uxA[0] + v3[1] * uxA[1] + v3[2] * uxA[2];
+    const dotY = v3[0] * uyA[0] + v3[1] * uyA[1] + v3[2] * uyA[2];
+    let endAngle = Math.atan2(dotY, dotX);
+    if (endAngle <= 0) endAngle += 2 * Math.PI;
+    return this.makeCircleNurbs(center, normal, radius, 0, endAngle);
+  }
+  makeEllipseEdge(center, normal, majorRadius, minorRadius, xDir) {
+    return this.makeEllipseNurbs(center, normal, majorRadius, minorRadius, 0, 2 * Math.PI, xDir);
+  }
+  makeEllipseArc(center, normal, majorRadius, minorRadius, startAngle, endAngle, xDir) {
+    return this.makeEllipseNurbs(
+      center,
+      normal,
+      majorRadius,
+      minorRadius,
+      startAngle,
+      endAngle,
+      xDir
+    );
+  }
+  makeBezierEdge(points) {
+    if (points.length < 2) throw new Error("brepkit: bezier requires at least 2 points");
+    const degree = points.length - 1;
+    const n = points.length;
+    const knots = [...Array(degree + 1).fill(0), ...Array(degree + 1).fill(1)];
+    const weights = Array(n).fill(1);
+    const flatCp = points.flatMap(([x, y, z]) => [x, y, z]);
+    const startPt = points[0];
+    const endPt = points[n - 1];
+    const id = this.bk.makeNurbsEdge(
+      startPt[0],
+      startPt[1],
+      startPt[2],
+      endPt[0],
+      endPt[1],
+      endPt[2],
+      degree,
+      knots,
+      flatCp,
+      weights
+    );
+    return edgeHandle(id);
+  }
+  makeTangentArc(startPoint, startTangent, endPoint) {
+    const cp1 = [
+      startPoint[0] + startTangent[0] / 3,
+      startPoint[1] + startTangent[1] / 3,
+      startPoint[2] + startTangent[2] / 3
+    ];
+    const dx = endPoint[0] - cp1[0];
+    const dy = endPoint[1] - cp1[1];
+    const dz = endPoint[2] - cp1[2];
+    const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    const cp2 = [
+      endPoint[0] - dx / (3 * Math.max(len, 1e-10)),
+      endPoint[1] - dy / (3 * Math.max(len, 1e-10)),
+      endPoint[2] - dz / (3 * Math.max(len, 1e-10))
+    ];
+    return this.makeBezierEdge([startPoint, cp1, cp2, endPoint]);
+  }
+  makeHelixWire(pitch, height, radius, center, _direction, leftHanded) {
+    const turns = height / pitch;
+    const nSamplesPerTurn = 16;
+    const nSamples = Math.max(4, Math.ceil(turns * nSamplesPerTurn));
+    const cx = center?.[0] ?? 0;
+    const cy = center?.[1] ?? 0;
+    const cz = center?.[2] ?? 0;
+    const sign = leftHanded ? -1 : 1;
+    const points = [];
+    for (let i = 0; i <= nSamples; i++) {
+      const t = i / nSamples;
+      const angle = sign * 2 * Math.PI * turns * t;
+      points.push([cx + radius * Math.cos(angle), cy + radius * Math.sin(angle), cz + height * t]);
+    }
+    const edge = this.interpolatePoints(points);
+    return this.makeWire([edge]);
+  }
+  makeWireFromMixed(items) {
+    const edgeIds = [];
+    for (const item of items) {
+      const h = item;
+      if (h.type === "edge") {
+        edgeIds.push(h.id);
+      } else if (h.type === "wire") {
+        for (const childEdgeId of toArray(this.bk.getWireEdges(h.id))) {
+          edgeIds.push(childEdgeId);
+        }
+      }
+    }
+    if (edgeIds.length === 0)
+      throw new Error("brepkit: makeWireFromMixed requires at least one edge");
+    const id = this.bk.makeWire(edgeIds, false);
+    return wireHandle(id);
+  }
+  makeCompound(shapes) {
+    const handles = shapes.filter(isBrepkitHandle);
+    if (handles.length === 0) {
+      throw new Error("brepkit: makeCompound requires at least one shape");
+    }
+    const allSolids = handles.every((h) => h.type === "solid");
+    if (allSolids) {
+      const id2 = this.bk.makeCompound(handles.map((h) => h.id));
+      return compoundHandle(id2);
+    }
+    const id = syntheticCompoundCounter++;
+    syntheticCompounds.set(id, handles);
+    return compoundHandle(id);
+  }
+  makeBoxFromCorners(p1, p2) {
+    const w = Math.abs(p2[0] - p1[0]);
+    const h = Math.abs(p2[1] - p1[1]);
+    const d = Math.abs(p2[2] - p1[2]);
+    const box = this.makeBox(w, h, d);
+    const minX = Math.min(p1[0], p2[0]);
+    const minY = Math.min(p1[1], p2[1]);
+    const minZ = Math.min(p1[2], p2[2]);
+    if (minX !== 0 || minY !== 0 || minZ !== 0) {
+      return this.translate(box, minX, minY, minZ);
+    }
+    return box;
+  }
+  solidFromShell(shell2) {
+    const h = shell2;
+    if (h.type === "solid") return shell2;
+    if (h.type === "shell") {
+      try {
+        this.bk.getSolidFaces(h.id);
+        return solidHandle(h.id);
+      } catch {
+      }
+      const id2 = this.bk.solidFromShell(h.id);
+      return solidHandle(id2);
+    }
+    const id = this.bk.solidFromShell(unwrap(shell2, "shell"));
+    return solidHandle(id);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Extrusion / sweep / loft / revolution
+  // ═══════════════════════════════════════════════════════════════════════
+  extrude(face, direction, length) {
+    const id = this.bk.extrude(
+      unwrap(face, "face"),
+      direction[0],
+      direction[1],
+      direction[2],
+      length
+    );
+    return solidHandle(id);
+  }
+  revolve(shape2, axis, angle) {
+    if (axis && typeof axis === "object" && "origin" in axis && "direction" in axis) {
+      const { origin, direction } = axis;
+      let angleDeg = angle * (180 / Math.PI);
+      if (angleDeg > 360) angleDeg = 360;
+      const id = this.bk.revolve(
+        unwrap(shape2, "face"),
+        origin[0],
+        origin[1],
+        origin[2],
+        direction[0],
+        direction[1],
+        direction[2],
+        angleDeg
+      );
+      return solidHandle(id);
+    }
+    throw new Error("brepkit: revolve requires axis with origin and direction");
+  }
+  revolveVec(shape2, center, direction, angle) {
+    let angleDeg = angle * (180 / Math.PI);
+    if (angleDeg > 360) angleDeg = 360;
+    const id = this.bk.revolve(
+      unwrap(shape2, "face"),
+      center[0],
+      center[1],
+      center[2],
+      direction[0],
+      direction[1],
+      direction[2],
+      angleDeg
+    );
+    return solidHandle(id);
+  }
+  loft(wires, _ruled, _startShape, _endShape) {
+    if (_ruled !== void 0 || _startShape !== void 0 || _endShape !== void 0) {
+      warnOnce(
+        "loft-options",
+        "Loft options (ruled, startShape, endShape) not supported; ignored."
+      );
+    }
+    const faceIds = wires.map((w) => {
+      const h = w;
+      if (h.type === "wire") {
+        return this.bk.makeFaceFromWire(h.id);
+      }
+      return unwrap(w, "face");
+    });
+    const id = this.bk.loft(faceIds);
+    return solidHandle(id);
+  }
+  sweep(wire, spine, _options) {
+    if (_options?.transitionMode !== void 0) {
+      warnOnce("sweep-transition", "Sweep transition mode not supported; ignored.");
+    }
+    const spineHandle = spine;
+    if (spineHandle.type === "wire") {
+      const edges = this.iterShapes(spine, "edge");
+      const edgeIds = edges.map((e) => unwrap(e, "edge"));
+      const id2 = this.bk.sweepAlongEdges(unwrap(wire, "face"), edgeIds);
+      return solidHandle(id2);
+    }
+    const nurbsData = this.extractNurbsFromEdge(spine);
+    if (!nurbsData) {
+      throw new Error("brepkit: sweep spine must be an edge or wire");
+    }
+    const id = this.bk.sweep(
+      unwrap(wire, "face"),
+      nurbsData.degree,
+      nurbsData.knots,
+      nurbsData.controlPoints,
+      nurbsData.weights
+    );
+    return solidHandle(id);
+  }
+  simplePipe(profile, spine) {
+    const profileHandle = profile;
+    const faceId = profileHandle.type === "wire" ? this.bk.makeFaceFromWire(profileHandle.id) : unwrap(profile, "face");
+    const spineHandle = spine;
+    if (spineHandle.type === "wire") {
+      const edges = this.iterShapes(spine, "edge");
+      const edgeIds = edges.map((e) => unwrap(e, "edge"));
+      const id2 = this.bk.sweepAlongEdges(faceId, edgeIds);
+      return solidHandle(id2);
+    }
+    const nurbsData = this.extractNurbsFromEdge(spine);
+    if (!nurbsData) {
+      throw new Error("brepkit: pipe spine must be an edge or wire");
+    }
+    const id = this.bk.pipe(
+      faceId,
+      nurbsData.degree,
+      nurbsData.knots,
+      nurbsData.controlPoints,
+      nurbsData.weights
+    );
+    return solidHandle(id);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Modification
+  // ═══════════════════════════════════════════════════════════════════════
+  fillet(shape2, edges, radius) {
+    const r = typeof radius === "number" ? radius : Array.isArray(radius) ? radius[0] : 1;
+    if (typeof radius !== "number") {
+      warnOnce(
+        "fillet-variable",
+        typeof radius === "function" ? "Per-edge fillet radius function not supported; falling back to radius=1." : "Variable-radius fillet not supported; using first radius only."
+      );
+    }
+    const edgeIds = edges.map((e) => unwrap(e, "edge"));
+    const id = this.bk.fillet(unwrapSolidOrThrow(shape2, "fillet"), edgeIds, r);
+    return solidHandle(id);
+  }
+  chamfer(shape2, edges, distance) {
+    const d = typeof distance === "number" ? distance : Array.isArray(distance) ? distance[0] : 1;
+    if (typeof distance !== "number") {
+      warnOnce(
+        "chamfer-asymmetric",
+        typeof distance === "function" ? "Per-edge chamfer distance function not supported; falling back to distance=1." : "Asymmetric chamfer not supported; using first distance only."
+      );
+    }
+    const edgeIds = edges.map((e) => unwrap(e, "edge"));
+    const id = this.bk.chamfer(unwrapSolidOrThrow(shape2, "chamfer"), edgeIds, d);
+    return solidHandle(id);
+  }
+  chamferDistAngle(shape2, edges, distance, angleDeg) {
+    warnOnce("chamfer-dist-angle", "Distance-angle chamfer approximated as uniform chamfer.");
+    const d2 = distance * Math.tan(angleDeg * Math.PI / 180);
+    const avgDist = (distance + d2) / 2;
+    return this.chamfer(shape2, edges, avgDist);
+  }
+  shell(shape2, faces, thickness, tolerance) {
+    if (tolerance !== void 0) {
+      warnOnce(
+        "shell-tolerance",
+        "shell() tolerance parameter is not supported; brepkit uses its own internal tolerance."
+      );
+    }
+    const solidId = unwrapSolidOrThrow(shape2, "shell");
+    const solidFaces = toArray(this.bk.getSolidFaces(solidId));
+    const solidFaceSet = new Set(solidFaces);
+    const resolvedFaceIds = faces.map((f) => {
+      const fid = unwrap(f, "face");
+      if (solidFaceSet.has(fid)) return fid;
+      try {
+        const origNormal = this.bk.getFaceNormal(fid);
+        let bestMatch = -1;
+        let bestDot = -2;
+        for (const sf of solidFaces) {
+          try {
+            const sn = this.bk.getFaceNormal(sf);
+            const dot = (origNormal[0] ?? 0) * (sn[0] ?? 0) + (origNormal[1] ?? 0) * (sn[1] ?? 0) + (origNormal[2] ?? 0) * (sn[2] ?? 0);
+            if (dot > bestDot) {
+              bestDot = dot;
+              bestMatch = sf;
+            }
+          } catch {
+          }
+        }
+        if (bestMatch >= 0 && bestDot > 0.99) return bestMatch;
+      } catch {
+      }
+      return fid;
+    });
+    const id = this.bk.shell(solidId, thickness, resolvedFaceIds);
+    return solidHandle(id);
+  }
+  thicken(shape2, thickness) {
+    const h = shape2;
+    if (h.type === "face") {
+      const id = this.bk.thicken(h.id, thickness);
+      return solidHandle(id);
+    }
+    throw new Error("brepkit: thicken() requires a face");
+  }
+  offset(shape2, distance, tolerance) {
+    if (tolerance !== void 0) {
+      warnOnce(
+        "offset-tolerance",
+        "offset() tolerance parameter is not supported; brepkit uses its own internal tolerance."
+      );
+    }
+    const h = shape2;
+    if (h.type === "face") {
+      const id2 = this.bk.thicken(h.id, distance);
+      return solidHandle(id2);
+    }
+    const id = this.bk.offsetSolid(unwrapSolidOrThrow(shape2, "offset"), distance);
+    return solidHandle(id);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Transforms
+  // ═══════════════════════════════════════════════════════════════════════
+  transform(shape2, trsf) {
+    if (Array.isArray(trsf) && trsf.length === 16) {
+      return this.applyMatrix(shape2, trsf);
+    }
+    throw new Error("brepkit: transform expects a 16-element matrix array");
+  }
+  translate(shape2, x, y, z) {
+    return this.applyMatrix(shape2, translationMatrix(x, y, z));
+  }
+  rotate(shape2, angle, axis, center) {
+    return this.applyMatrix(shape2, rotationMatrix(angle, axis, center));
+  }
+  mirror(shape2, origin, normal) {
+    const h = shape2;
+    if (h.type === "solid") {
+      const id = this.bk.mirror(
+        h.id,
+        origin[0],
+        origin[1],
+        origin[2],
+        normal[0],
+        normal[1],
+        normal[2]
+      );
+      return solidHandle(id);
+    }
+    return this.applyMatrix(shape2, mirrorMatrix(origin, normal));
+  }
+  scale(shape2, center, factor) {
+    return this.applyMatrix(shape2, scaleMatrix(center, factor));
+  }
+  generalTransform(shape2, linear, translation, _isOrthogonal) {
+    return this.applyMatrix(shape2, affineMatrix(linear, translation));
+  }
+  generalTransformNonOrthogonal(shape2, linear, translation) {
+    return this.applyMatrix(shape2, affineMatrix(linear, translation));
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Operations with shape evolution tracking
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Parse native brepkit evolution JSON and convert face IDs to hash-based
+   * evolution that the brepjs propagation system expects.
+   *
+   * The native API returns:
+   *   `{"solid": u32, "evolution": {"modified": {inputFaceId: [outputFaceIds]}, "generated": {}, "deleted": [faceIds]}}`
+   *
+   * We convert face IDs → hashes via `id % hashUpperBound`.
+   */
+  parseNativeEvolution(json, hashUpperBound) {
+    const parsed = JSON.parse(json);
+    const evo = parsed.evolution;
+    if (!evo || typeof evo.modified !== "object" || typeof evo.generated !== "object") {
+      throw new Error("brepkit: invalid evolution JSON structure");
+    }
+    const resultShape = solidHandle(parsed.solid);
+    const collectHashes = (entries) => {
+      const map = /* @__PURE__ */ new Map();
+      for (const [inputId, outputIds] of Object.entries(entries)) {
+        const inputHash = Number(inputId) % hashUpperBound;
+        const outputHashes = outputIds.map((id) => id % hashUpperBound);
+        const existing = map.get(inputHash);
+        if (existing) {
+          existing.push(...outputHashes);
+        } else {
+          map.set(inputHash, outputHashes);
+        }
+      }
+      return map;
+    };
+    const modified = collectHashes(evo.modified);
+    const generated = collectHashes(evo.generated);
+    const deleted = /* @__PURE__ */ new Set();
+    for (const id of evo.deleted) {
+      deleted.add(id % hashUpperBound);
+    }
+    return { shape: resultShape, evolution: { modified, generated, deleted } };
+  }
+  /**
+   * Build a ShapeEvolution by comparing input face hashes to output face hashes.
+   *
+   * For transforms: 1:1 mapping (modified = identity, no generated/deleted).
+   * For booleans/modifiers: compare sets to detect changes, with geometric
+   * fallback when hash matching fails (brepkit always creates new face IDs).
+   */
+  buildEvolution(resultShape, inputFaceHashes, hashUpperBound, isTransform, originalShape) {
+    const h = resultShape;
+    const modified = /* @__PURE__ */ new Map();
+    const generated = /* @__PURE__ */ new Map();
+    const deleted = /* @__PURE__ */ new Set();
+    if (h.type === "solid") {
+      const outputFaces = toArray(this.bk.getSolidFaces(h.id));
+      const outputHashes = outputFaces.map((fid) => fid % hashUpperBound);
+      if (isTransform) {
+        for (let i = 0; i < inputFaceHashes.length && i < outputHashes.length; i++) {
+          modified.set(inputFaceHashes[i], [outputHashes[i]]);
+        }
+      } else {
+        const inputSet = new Set(inputFaceHashes);
+        let hasOverlap = false;
+        for (const hash of outputHashes) {
+          if (inputSet.has(hash)) {
+            hasOverlap = true;
+            break;
+          }
+        }
+        if (hasOverlap) {
+          const outputSet = new Set(outputHashes);
+          for (const hash of outputHashes) {
+            if (inputSet.has(hash)) {
+              modified.set(hash, [hash]);
+            }
+          }
+          const newFaces = outputHashes.filter((fh) => !inputSet.has(fh));
+          if (newFaces.length > 0 && inputFaceHashes.length > 0) {
+            generated.set(inputFaceHashes[0], newFaces);
+          }
+          for (const hash of inputFaceHashes) {
+            if (!outputSet.has(hash)) {
+              deleted.add(hash);
+            }
+          }
+        } else if (originalShape) {
+          this.matchFacesGeometrically(
+            originalShape,
+            inputFaceHashes,
+            outputFaces,
+            hashUpperBound,
+            modified,
+            generated,
+            deleted
+          );
+        } else {
+          for (let i = 0; i < inputFaceHashes.length && i < outputHashes.length; i++) {
+            modified.set(inputFaceHashes[i], [outputHashes[i]]);
+          }
+          if (outputHashes.length > inputFaceHashes.length && inputFaceHashes.length > 0) {
+            generated.set(inputFaceHashes[0], outputHashes.slice(inputFaceHashes.length));
+          }
+        }
+      }
+    }
+    return { shape: resultShape, evolution: { modified, generated, deleted } };
+  }
+  /**
+   * Chain an evolution map (modified or generated) through one step of a multi-step
+   * boolean. For each entry, each previous output hash is resolved against this
+   * step's evolution: if it was further modified, follow to the new outputs; if
+   * deleted, drop it; otherwise keep it unchanged.
+   *
+   * Mutates `map` in-place and records each resolved prevOut in `intermediateOutputs`.
+   * When `deleteOnEmpty` is provided, entries that reduce to no outputs are added to it.
+   */
+  static chainEvolutionMap(map, stepModified, stepDeleted, intermediateOutputs, deleteOnEmpty) {
+    for (const [origKey, prevOutputs] of map) {
+      const chainedOutputs = [];
+      for (const prevOut of prevOutputs) {
+        intermediateOutputs.add(prevOut);
+        const nextOutputs = stepModified.get(prevOut);
+        if (nextOutputs) {
+          chainedOutputs.push(...nextOutputs);
+        } else if (!stepDeleted.has(prevOut)) {
+          chainedOutputs.push(prevOut);
+        }
+      }
+      if (chainedOutputs.length > 0) {
+        map.set(origKey, chainedOutputs);
+      } else {
+        map.delete(origKey);
+        deleteOnEmpty?.add(origKey);
+      }
+    }
+  }
+  /** Squared Euclidean distance between two 3-component centroids. */
+  static centroidDistSq(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    const dz = a[2] - b[2];
+    return dx * dx + dy * dy + dz * dz;
+  }
+  /** Compute face centroid as the average of tessellation vertices. */
+  faceCentroidById(faceId) {
+    try {
+      const pos = this.bk.tessellateFace(faceId, 1).positions;
+      if (pos.length < 3) return [0, 0, 0];
+      let cx = 0;
+      let cy = 0;
+      let cz = 0;
+      const nVerts = pos.length / 3;
+      for (let i = 0; i < pos.length; i += 3) {
+        cx += pos[i];
+        cy += pos[i + 1];
+        cz += pos[i + 2];
+      }
+      return [cx / nVerts, cy / nVerts, cz / nVerts];
+    } catch {
+      return [0, 0, 0];
+    }
+  }
+  /**
+   * Match input→output faces geometrically using normal dot product and centroid distance.
+   * Mirrors the algorithm in brepkit's `boolean_with_evolution`.
+   */
+  matchFacesGeometrically(originalShape, inputFaceHashes, outputFaceIds, hashUpperBound, modified, generated, deleted) {
+    const orig = originalShape;
+    if (orig.type !== "solid") return;
+    const inputFaceIds = toArray(this.bk.getSolidFaces(orig.id));
+    const hashCount = Math.min(inputFaceIds.length, inputFaceHashes.length);
+    const inputSigs = [];
+    for (let i = 0; i < hashCount; i++) {
+      const fid = inputFaceIds[i];
+      try {
+        const normal = this.bk.getFaceNormal(fid);
+        const centroid = this.faceCentroidById(fid);
+        inputSigs.push({ hash: inputFaceHashes[i] ?? fid % hashUpperBound, normal, centroid });
+      } catch {
+        inputSigs.push({
+          hash: inputFaceHashes[i] ?? fid % hashUpperBound,
+          normal: [0, 0, 0],
+          centroid: this.faceCentroidById(fid)
+        });
+      }
+    }
+    const outputSigs = [];
+    for (const fid of outputFaceIds) {
+      try {
+        const normal = this.bk.getFaceNormal(fid);
+        const centroid = this.faceCentroidById(fid);
+        outputSigs.push({ hash: fid % hashUpperBound, normal, centroid });
+      } catch {
+        outputSigs.push({
+          hash: fid % hashUpperBound,
+          normal: [0, 0, 0],
+          centroid: this.faceCentroidById(fid)
+        });
+      }
+    }
+    const NORMAL_THRESHOLD = 0.707;
+    const CENTROID_DIST_SQ_MAX = 100;
+    const matchedInputIndices = /* @__PURE__ */ new Set();
+    for (const out of outputSigs) {
+      let bestScore = -Infinity;
+      let bestIdx = -1;
+      for (let i = 0; i < inputSigs.length; i++) {
+        const inp = inputSigs[i];
+        const dot = (out.normal[0] ?? 0) * (inp.normal[0] ?? 0) + (out.normal[1] ?? 0) * (inp.normal[1] ?? 0) + (out.normal[2] ?? 0) * (inp.normal[2] ?? 0);
+        if (dot < NORMAL_THRESHOLD) continue;
+        const distSq = BrepkitAdapter.centroidDistSq(out.centroid, inp.centroid);
+        if (distSq > CENTROID_DIST_SQ_MAX) continue;
+        const score = dot - distSq / CENTROID_DIST_SQ_MAX;
+        if (score > bestScore) {
+          bestScore = score;
+          bestIdx = i;
+        }
+      }
+      if (bestIdx >= 0) {
+        const bestInput = inputSigs[bestIdx];
+        const existing = modified.get(bestInput.hash) ?? [];
+        existing.push(out.hash);
+        modified.set(bestInput.hash, existing);
+        matchedInputIndices.add(bestIdx);
+      } else {
+        let bestDistSq = Infinity;
+        let nearestInput;
+        for (const inp of inputSigs) {
+          const distSq = BrepkitAdapter.centroidDistSq(out.centroid, inp.centroid);
+          if (distSq < bestDistSq) {
+            bestDistSq = distSq;
+            nearestInput = inp;
+          }
+        }
+        if (nearestInput) {
+          const existing = generated.get(nearestInput.hash) ?? [];
+          existing.push(out.hash);
+          generated.set(nearestInput.hash, existing);
+        }
+      }
+    }
+    for (let i = 0; i < inputSigs.length; i++) {
+      if (!matchedInputIndices.has(i)) {
+        deleted.add(inputSigs[i].hash);
+      }
+    }
+  }
+  translateWithHistory(shape2, x, y, z, inputFaceHashes, hashUpperBound) {
+    return this.buildEvolution(
+      this.translate(shape2, x, y, z),
+      inputFaceHashes,
+      hashUpperBound,
+      true
+    );
+  }
+  rotateWithHistory(shape2, angle, inputFaceHashes, hashUpperBound, axis, center) {
+    const angleDeg = angle * 180 / Math.PI;
+    return this.buildEvolution(
+      this.rotate(shape2, angleDeg, axis, center),
+      inputFaceHashes,
+      hashUpperBound,
+      true
+    );
+  }
+  mirrorWithHistory(shape2, origin, normal, inputFaceHashes, hashUpperBound) {
+    return this.buildEvolution(
+      this.mirror(shape2, origin, normal),
+      inputFaceHashes,
+      hashUpperBound,
+      true
+    );
+  }
+  scaleWithHistory(shape2, center, factor, inputFaceHashes, hashUpperBound) {
+    return this.buildEvolution(
+      this.scale(shape2, center, factor),
+      inputFaceHashes,
+      hashUpperBound,
+      true
+    );
+  }
+  generalTransformWithHistory(shape2, linear, translation, isOrthogonal, inputFaceHashes, hashUpperBound) {
+    return this.buildEvolution(
+      this.generalTransform(shape2, linear, translation, isOrthogonal),
+      inputFaceHashes,
+      hashUpperBound,
+      true
+    );
+  }
+  booleanWithHistoryImpl(shape2, tool, inputFaceHashes, hashUpperBound, options, nativeFn, fallbackFn, _label) {
+    const sh = shape2;
+    const th = tool;
+    if (inputFaceHashes.length > 0 && sh.type === "solid") {
+      if (th.type === "solid") {
+        const json = nativeFn(sh.id, th.id);
+        return this.parseNativeEvolution(json, hashUpperBound);
+      }
+      if (th.type === "compound") {
+        const childSolidIds = toArray(this.bk.getCompoundSolids(th.id));
+        let currentShape = shape2;
+        const combinedModified = /* @__PURE__ */ new Map();
+        const combinedGenerated = /* @__PURE__ */ new Map();
+        const combinedDeleted = /* @__PURE__ */ new Set();
+        const inputFaceHashSet = new Set(inputFaceHashes);
+        for (const childId of childSolidIds) {
+          const ch = currentShape;
+          if (ch.type !== "solid") break;
+          const json = nativeFn(ch.id, childId);
+          const result2 = this.parseNativeEvolution(json, hashUpperBound);
+          currentShape = result2.shape;
+          const intermediateOutputs = /* @__PURE__ */ new Set();
+          BrepkitAdapter.chainEvolutionMap(
+            combinedModified,
+            result2.evolution.modified,
+            result2.evolution.deleted,
+            intermediateOutputs,
+            combinedDeleted
+          );
+          BrepkitAdapter.chainEvolutionMap(
+            combinedGenerated,
+            result2.evolution.modified,
+            result2.evolution.deleted,
+            intermediateOutputs
+          );
+          for (const [k, v] of result2.evolution.modified) {
+            if (!combinedModified.has(k) && !intermediateOutputs.has(k)) {
+              combinedModified.set(k, [...v]);
+            }
+          }
+          for (const [k, v] of result2.evolution.generated) {
+            if (!intermediateOutputs.has(k)) {
+              const existing = combinedGenerated.get(k) ?? [];
+              combinedGenerated.set(k, [...existing, ...v]);
+            }
+          }
+          for (const d of result2.evolution.deleted) {
+            if (inputFaceHashSet.has(d)) {
+              combinedDeleted.add(d);
+            }
+          }
+        }
+        return {
+          shape: currentShape,
+          evolution: {
+            modified: combinedModified,
+            generated: combinedGenerated,
+            deleted: combinedDeleted
+          }
+        };
+      }
+    }
+    const fallbackResult = fallbackFn(shape2, tool, options);
+    return this.buildEvolution(fallbackResult, inputFaceHashes, hashUpperBound, false, shape2);
+  }
+  fuseWithHistory(shape2, tool, inputFaceHashes, hashUpperBound, options) {
+    return this.booleanWithHistoryImpl(
+      shape2,
+      tool,
+      inputFaceHashes,
+      hashUpperBound,
+      options,
+      (a, b) => this.bk.fuseWithEvolution(a, b),
+      (s, t, o) => this.fuse(s, t, o),
+      "fuseWithHistory"
+    );
+  }
+  cutWithHistory(shape2, tool, inputFaceHashes, hashUpperBound, options) {
+    return this.booleanWithHistoryImpl(
+      shape2,
+      tool,
+      inputFaceHashes,
+      hashUpperBound,
+      options,
+      (a, b) => this.bk.cutWithEvolution(a, b),
+      (s, t, o) => this.cut(s, t, o),
+      "cutWithHistory"
+    );
+  }
+  intersectWithHistory(shape2, tool, inputFaceHashes, hashUpperBound, options) {
+    return this.booleanWithHistoryImpl(
+      shape2,
+      tool,
+      inputFaceHashes,
+      hashUpperBound,
+      options,
+      (a, b) => this.bk.intersectWithEvolution(a, b),
+      (s, t, o) => this.intersect(s, t, o),
+      "intersectWithHistory"
+    );
+  }
+  filletWithHistory(shape2, edges, radius, inputFaceHashes, hashUpperBound) {
+    return this.buildEvolution(
+      this.fillet(shape2, edges, radius),
+      inputFaceHashes,
+      hashUpperBound,
+      false,
+      shape2
+    );
+  }
+  chamferWithHistory(shape2, edges, distance, inputFaceHashes, hashUpperBound) {
+    return this.buildEvolution(
+      this.chamfer(shape2, edges, distance),
+      inputFaceHashes,
+      hashUpperBound,
+      false,
+      shape2
+    );
+  }
+  shellWithHistory(shape2, faces, thickness, inputFaceHashes, hashUpperBound, tolerance) {
+    return this.buildEvolution(
+      this.shell(shape2, faces, thickness, tolerance),
+      inputFaceHashes,
+      hashUpperBound,
+      false,
+      shape2
+    );
+  }
+  thickenWithHistory(shape2, thickness, inputFaceHashes, hashUpperBound) {
+    return this.buildEvolution(
+      this.thicken(shape2, thickness),
+      inputFaceHashes,
+      hashUpperBound,
+      false,
+      shape2
+    );
+  }
+  offsetWithHistory(shape2, distance, inputFaceHashes, hashUpperBound, tolerance) {
+    return this.buildEvolution(
+      this.offset(shape2, distance, tolerance),
+      inputFaceHashes,
+      hashUpperBound,
+      false,
+      shape2
+    );
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Meshing
+  // ═══════════════════════════════════════════════════════════════════════
+  mesh(shape2, options) {
+    if (options.angularTolerance > 0) {
+      warnOnce(
+        "mesh-angular",
+        "mesh angularTolerance is not supported; only linear deflection is used."
+      );
+    }
+    const h = unwrap(shape2);
+    const bkHandle = shape2;
+    const deflection = options.tolerance || DEFAULT_DEFLECTION;
+    let result2;
+    if (bkHandle.type === "solid") {
+      result2 = this.meshSolid(h, deflection);
+    } else if (bkHandle.type === "face") {
+      result2 = this.meshSingleFace(h, deflection, 0);
+    } else {
+      throw new Error(`brepkit: cannot mesh shape of type '${bkHandle.type}'`);
+    }
+    if (options.skipNormals) {
+      result2.normals = new Float32Array(0);
+    }
+    if (!options.includeUVs) {
+      result2.uvs = new Float32Array(0);
+    }
+    return result2;
+  }
+  meshEdges(shape2, tolerance, angularTolerance) {
+    if (angularTolerance > 0) {
+      warnOnce(
+        "mesh-edges-angular",
+        "meshEdges angularTolerance is not supported; only linear deflection is used."
+      );
+    }
+    const bkHandle = shape2;
+    if (bkHandle.type !== "solid") {
+      return { lines: new Float32Array(0), edgeGroups: [] };
+    }
+    const edgeLines = this.bk.meshEdges(bkHandle.id, tolerance);
+    const positions = edgeLines.positions;
+    const offsets = edgeLines.offsets;
+    const edgeCount = edgeLines.edgeCount;
+    const edgeGroups = [];
+    for (let i = 0; i < edgeCount; i++) {
+      const startIdx = offsets[i];
+      const endIdx = i + 1 < edgeCount ? offsets[i + 1] : positions.length;
+      const pointCount = (endIdx - startIdx) / 3;
+      edgeGroups.push({ start: startIdx / 3, count: pointCount, edgeHash: i });
+    }
+    return {
+      lines: new Float32Array(positions),
+      edgeGroups
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // File I/O
+  // ═══════════════════════════════════════════════════════════════════════
+  exportSTEP(shapes) {
+    if (shapes.length === 0) return "";
+    const parts = [];
+    for (const shape2 of shapes) {
+      const solidIds = unwrapSolidsForExport(this.bk, shape2, "exportSTEP");
+      for (const sid of solidIds) {
+        const bytes = this.bk.exportStep(sid);
+        parts.push(new TextDecoder().decode(bytes));
+      }
+    }
+    return parts.join("\n");
+  }
+  exportSTL(shape2, binary) {
+    const solidIds = unwrapSolidsForExport(this.bk, shape2, "exportSTL");
+    if (binary) {
+      const bytes2 = this.bk.exportStl(solidIds[0], DEFAULT_DEFLECTION);
+      return bytes2.buffer;
+    }
+    const bytes = this.bk.exportStlAscii(solidIds[0], DEFAULT_DEFLECTION);
+    return new TextDecoder().decode(bytes);
+  }
+  importSTEP(data) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+    return toArray(this.bk.importStep(bytes)).map(solidHandle);
+  }
+  importSTL(data) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+    const id = this.bk.importStl(bytes);
+    return solidHandle(id);
+  }
+  exportIGES(shapes) {
+    if (shapes.length === 0) return "";
+    const parts = [];
+    for (const shape2 of shapes) {
+      const solidIds = unwrapSolidsForExport(this.bk, shape2, "exportIGES");
+      for (const sid of solidIds) {
+        const bytes = this.bk.exportIges(sid);
+        parts.push(new TextDecoder().decode(bytes));
+      }
+    }
+    return parts.join("\n");
+  }
+  importIGES(data) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+    return toArray(this.bk.importIges(bytes)).map(solidHandle);
+  }
+  exportSTEPAssembly(parts, _options) {
+    if (parts.length === 0) return "";
+    const shapes = parts.map((p) => p.shape);
+    return this.exportSTEP(shapes);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Measurement
+  // ═══════════════════════════════════════════════════════════════════════
+  volume(shape2) {
+    const h = shape2;
+    if (h.type !== "solid") return 0;
+    return this.bk.volume(unwrap(shape2), DEFAULT_DEFLECTION);
+  }
+  area(shape2) {
+    const h = shape2;
+    if (h.type === "face") {
+      return this.bk.faceArea(unwrap(shape2), DEFAULT_DEFLECTION);
+    }
+    if (h.type === "solid") {
+      return this.bk.surfaceArea(unwrap(shape2), DEFAULT_DEFLECTION);
+    }
+    if (h.type === "compound") {
+      const faces = this.iterShapes(shape2, "face");
+      let total = 0;
+      for (const face of faces) {
+        total += this.bk.faceArea(unwrap(face), DEFAULT_DEFLECTION);
+      }
+      return total;
+    }
+    return 0;
+  }
+  length(shape2) {
+    const h = shape2;
+    if (h.type === "edge") {
+      return this.bk.edgeLength(unwrap(shape2));
+    }
+    if (h.type === "face") {
+      return this.bk.facePerimeter(unwrap(shape2));
+    }
+    if (h.type === "wire") {
+      return this.bk.wireLength(h.id);
+    }
+    throw new Error("brepkit: length() requires an edge, wire, or face");
+  }
+  centerOfMass(shape2) {
+    const h = shape2;
+    if (h.type === "solid") {
+      const result2 = this.bk.centerOfMass(unwrap(shape2), DEFAULT_DEFLECTION);
+      return [result2[0], result2[1], result2[2]];
+    }
+    if (h.type === "face") {
+      const domain = this.uvBounds(shape2);
+      const uMid = (domain.uMin + domain.uMax) / 2;
+      const vMid = (domain.vMin + domain.vMax) / 2;
+      return this.pointOnSurface(shape2, uMid, vMid);
+    }
+    if (h.type === "edge") {
+      const verts = this.bk.getEdgeVertices(h.id);
+      return [
+        (verts[0] + verts[3]) / 2,
+        (verts[1] + verts[4]) / 2,
+        (verts[2] + verts[5]) / 2
+      ];
+    }
+    if (h.type === "vertex") {
+      return this.vertexPosition(shape2);
+    }
+    const vertices = this.iterShapes(shape2, "vertex");
+    if (vertices.length > 0) {
+      let sx = 0, sy = 0, sz = 0;
+      for (const v of vertices) {
+        const p = this.vertexPosition(v);
+        sx += p[0];
+        sy += p[1];
+        sz += p[2];
+      }
+      return [sx / vertices.length, sy / vertices.length, sz / vertices.length];
+    }
+    return [0, 0, 0];
+  }
+  linearCenterOfMass(shape2) {
+    const h = shape2;
+    if (h.type === "edge") {
+      const verts = this.bk.getEdgeVertices(h.id);
+      return [
+        (verts[0] + verts[3]) / 2,
+        (verts[1] + verts[4]) / 2,
+        (verts[2] + verts[5]) / 2
+      ];
+    }
+    return this.centerOfMass(shape2);
+  }
+  boundingBox(shape2) {
+    const h = shape2;
+    if (h.type === "solid") {
+      const bb = this.bk.boundingBox(unwrap(shape2));
+      return {
+        min: [bb[0], bb[1], bb[2]],
+        max: [bb[3], bb[4], bb[5]]
+      };
+    }
+    if (h.type === "vertex") {
+      const pos = this.vertexPosition(shape2);
+      return { min: [...pos], max: [...pos] };
+    }
+    const vertices = this.iterShapes(shape2, "vertex");
+    if (vertices.length === 0) {
+      return { min: [0, 0, 0], max: [0, 0, 0] };
+    }
+    const first = this.vertexPosition(vertices[0]);
+    let minX = first[0], minY = first[1], minZ = first[2];
+    let maxX = first[0], maxY = first[1], maxZ = first[2];
+    for (let i = 1; i < vertices.length; i++) {
+      const p = this.vertexPosition(vertices[i]);
+      if (p[0] < minX) minX = p[0];
+      if (p[0] > maxX) maxX = p[0];
+      if (p[1] < minY) minY = p[1];
+      if (p[1] > maxY) maxY = p[1];
+      if (p[2] < minZ) minZ = p[2];
+      if (p[2] > maxZ) maxZ = p[2];
+    }
+    return { min: [minX, minY, minZ], max: [maxX, maxY, maxZ] };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Topology introspection
+  // ═══════════════════════════════════════════════════════════════════════
+  iterShapes(shape2, type) {
+    const h = unwrap(shape2);
+    const bkHandle = shape2;
+    switch (bkHandle.type) {
+      case "compound": {
+        const children = syntheticCompounds.get(h);
+        if (children) {
+          const results = [];
+          for (const child of children) {
+            if (child.type === type) {
+              results.push(child);
+            } else {
+              results.push(...this.iterShapes(child, type));
+            }
+          }
+          return results;
+        }
+        if (type === "solid") {
+          return toArray(this.bk.getCompoundSolids(h)).map(solidHandle);
+        }
+        if (type === "face" || type === "edge" || type === "vertex" || type === "wire") {
+          const solids = toArray(this.bk.getCompoundSolids(h)).map(solidHandle);
+          return solids.flatMap((s) => this.iterShapes(s, type));
+        }
+        return [];
+      }
+      case "solid": {
+        switch (type) {
+          case "face":
+            return toArray(this.bk.getSolidFaces(h)).map(faceHandle);
+          case "edge":
+            return toArray(this.bk.getSolidEdges(h)).map(edgeHandle);
+          case "vertex":
+            return toArray(this.bk.getSolidVertices(h)).map(vertexHandle);
+          case "wire":
+            return toArray(this.bk.getSolidFaces(h)).flatMap(
+              (faceId) => toArray(this.bk.getFaceWires(faceId)).map(wireHandle)
+            );
+          default:
+            return [];
+        }
+      }
+      case "shell": {
+        if (type === "face") {
+          return toArray(this.bk.getShellFaces(h)).map(faceHandle);
+        }
+        if (type === "edge" || type === "vertex") {
+          const faces = toArray(this.bk.getShellFaces(h)).map(faceHandle);
+          const seen = /* @__PURE__ */ new Set();
+          const results = [];
+          for (const face of faces) {
+            for (const child of this.iterShapes(face, type)) {
+              const childId = unwrap(child);
+              if (!seen.has(childId)) {
+                seen.add(childId);
+                results.push(child);
+              }
+            }
+          }
+          return results;
+        }
+        return [];
+      }
+      case "face": {
+        if (type === "face") {
+          return [shape2];
+        }
+        if (type === "edge") {
+          return toArray(this.bk.getFaceEdges(h)).map(edgeHandle);
+        }
+        if (type === "vertex") {
+          return toArray(this.bk.getFaceVertices(h)).map(vertexHandle);
+        }
+        if (type === "wire") {
+          return toArray(this.bk.getFaceWires(h)).map(wireHandle);
+        }
+        return [];
+      }
+      case "wire": {
+        if (type === "wire") {
+          return [shape2];
+        }
+        if (type === "edge") {
+          return toArray(this.bk.getWireEdges(h)).map(edgeHandle);
+        }
+        if (type === "vertex") {
+          const edgeIds = toArray(this.bk.getWireEdges(h));
+          const seen = /* @__PURE__ */ new Set();
+          const results = [];
+          for (const eid of edgeIds) {
+            const verts = this.bk.getEdgeVertices(eid);
+            const coords = [
+              [verts[0], verts[1], verts[2]],
+              [verts[3], verts[4], verts[5]]
+            ];
+            for (const [x, y, z] of coords) {
+              const key = `${x},${y},${z}`;
+              if (!seen.has(key)) {
+                seen.add(key);
+                results.push(vertexHandle(this.bk.makeVertex(x, y, z)));
+              }
+            }
+          }
+          return results;
+        }
+        return [];
+      }
+      case "edge": {
+        if (type === "edge") {
+          return [shape2];
+        }
+        if (type === "vertex") {
+          const verts = this.bk.getEdgeVertices(h);
+          const v1 = this.bk.makeVertex(verts[0], verts[1], verts[2]);
+          const v2 = this.bk.makeVertex(verts[3], verts[4], verts[5]);
+          return [vertexHandle(v1), vertexHandle(v2)];
+        }
+        return [];
+      }
+      default:
+        return [];
+    }
+  }
+  iterShapeList(list, callback) {
+    if (Array.isArray(list)) {
+      for (const item of list) callback(item);
+    }
+  }
+  shapeType(shape2) {
+    if (isBrepkitHandle(shape2)) return shape2.type;
+    throw new Error("brepkit: cannot determine shape type of non-brepkit handle");
+  }
+  isSame(a, b) {
+    return isBrepkitHandle(a) && isBrepkitHandle(b) && a.id === b.id && a.type === b.type;
+  }
+  isEqual(a, b) {
+    return this.isSame(a, b);
+  }
+  downcast(shape2, _type) {
+    return shape2;
+  }
+  hashCode(shape2, upperBound) {
+    if (!isBrepkitHandle(shape2)) return 0;
+    return shape2.id % upperBound;
+  }
+  isNull(shape2) {
+    return !shape2 || !isBrepkitHandle(shape2);
+  }
+  shapeOrientation(shape2) {
+    const h = unwrap(shape2);
+    const orient = this.bk.getShapeOrientation(h);
+    return orient;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Geometry queries: vertex
+  // ═══════════════════════════════════════════════════════════════════════
+  vertexPosition(vertex) {
+    const pos = this.bk.getVertexPosition(unwrap(vertex, "vertex"));
+    return [pos[0], pos[1], pos[2]];
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Geometry queries: face / surface
+  // ═══════════════════════════════════════════════════════════════════════
+  surfaceType(face) {
+    const typeStr = this.bk.getSurfaceType(unwrap(face, "face"));
+    return typeStr;
+  }
+  uvBounds(face) {
+    const domain = this.bk.getSurfaceDomain(unwrap(face, "face"));
+    return { uMin: domain[0], uMax: domain[1], vMin: domain[2], vMax: domain[3] };
+  }
+  outerWire(face) {
+    const id = this.bk.getFaceOuterWire(unwrap(face, "face"));
+    return wireHandle(id);
+  }
+  surfaceNormal(face, u, v) {
+    const n = this.bk.evaluateSurfaceNormal(unwrap(face, "face"), u, v);
+    return [n[0], n[1], n[2]];
+  }
+  pointOnSurface(face, u, v) {
+    const p = this.bk.evaluateSurface(unwrap(face, "face"), u, v);
+    return [p[0], p[1], p[2]];
+  }
+  uvFromPoint(face, point) {
+    try {
+      const result2 = this.bk.projectPointOnSurface(
+        unwrap(face, "face"),
+        point[0],
+        point[1],
+        point[2]
+      );
+      return [result2[0], result2[1]];
+    } catch (e) {
+      console.warn("brepkit: uvFromPoint failed:", e);
+      return null;
+    }
+  }
+  projectPointOnFace(face, point) {
+    const result2 = this.bk.projectPointOnSurface(
+      unwrap(face, "face"),
+      point[0],
+      point[1],
+      point[2]
+    );
+    return [result2[2], result2[3], result2[4]];
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Geometry queries: edge / curve
+  // ═══════════════════════════════════════════════════════════════════════
+  curveTangent(shape2, param) {
+    const h = shape2;
+    let edgeId;
+    let evalParam = param;
+    if (h.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h.id));
+      edgeId = edgeIds[edgeIds.length - 1];
+      let cumulative = 0;
+      for (const eid of edgeIds) {
+        const p = this.bk.getEdgeCurveParameters(eid);
+        const span = p[1] - p[0];
+        if (param <= cumulative + span || eid === edgeId) {
+          edgeId = eid;
+          evalParam = Math.min(p[0] + (param - cumulative), p[1]);
+          break;
+        }
+        cumulative += span;
+      }
+    } else {
+      edgeId = unwrap(shape2, "edge");
+    }
+    const result2 = this.bk.evaluateEdgeCurveD1(edgeId, evalParam);
+    return {
+      point: [result2[0], result2[1], result2[2]],
+      tangent: [result2[3], result2[4], result2[5]]
+    };
+  }
+  curveParameters(shape2) {
+    const h = shape2;
+    if (h.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h.id));
+      if (edgeIds.length === 0) return [0, 0];
+      let total = 0;
+      for (const eid of edgeIds) {
+        const p = this.bk.getEdgeCurveParameters(eid);
+        total += p[1] - p[0];
+      }
+      return [0, total];
+    }
+    const edgeId = unwrap(shape2, "edge");
+    const params = this.bk.getEdgeCurveParameters(edgeId);
+    return [params[0], params[1]];
+  }
+  curvePointAtParam(shape2, param) {
+    const h = shape2;
+    if (h.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h.id));
+      let cumulative = 0;
+      for (const eid of edgeIds) {
+        const p2 = this.bk.getEdgeCurveParameters(eid);
+        const span = p2[1] - p2[0];
+        if (param <= cumulative + span || eid === edgeIds[edgeIds.length - 1]) {
+          const localParam = p2[0] + (param - cumulative);
+          const pt2 = this.bk.evaluateEdgeCurve(eid, Math.min(localParam, p2[1]));
+          return [pt2[0], pt2[1], pt2[2]];
+        }
+        cumulative += span;
+      }
+      const pt = this.bk.evaluateEdgeCurve(edgeIds[0], param);
+      return [pt[0], pt[1], pt[2]];
+    }
+    const edgeId = unwrap(shape2, "edge");
+    const p = this.bk.evaluateEdgeCurve(edgeId, param);
+    return [p[0], p[1], p[2]];
+  }
+  curveIsClosed(shape2) {
+    const h = shape2;
+    if (h.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h.id));
+      if (edgeIds.length === 0) return false;
+      if (edgeIds.length === 1) {
+        const verts2 = this.bk.getEdgeVertices(edgeIds[0]);
+        return dist3(verts2[0], verts2[1], verts2[2], verts2[3], verts2[4], verts2[5]) < 1e-7;
+      }
+      const endpoints = [];
+      for (const eid of edgeIds) {
+        const verts2 = this.bk.getEdgeVertices(eid);
+        endpoints.push([verts2[0], verts2[1], verts2[2]]);
+        endpoints.push([verts2[3], verts2[4], verts2[5]]);
+      }
+      const unmatched = [];
+      for (const pt of endpoints) {
+        const matchIdx = unmatched.findIndex(
+          (u) => dist3(u[0], u[1], u[2], pt[0], pt[1], pt[2]) < 1e-7
+        );
+        if (matchIdx >= 0) {
+          unmatched.splice(matchIdx, 1);
+        } else {
+          unmatched.push(pt);
+        }
+      }
+      return unmatched.length === 0;
+    }
+    const verts = this.bk.getEdgeVertices(unwrap(shape2, "edge"));
+    return dist3(verts[0], verts[1], verts[2], verts[3], verts[4], verts[5]) < 1e-7;
+  }
+  curveIsPeriodic(shape2) {
+    const h = shape2;
+    try {
+      if (h.type === "edge") return this.curveIsClosed(shape2);
+      if (h.type === "wire") {
+        const edgeIds = toArray(this.bk.getWireEdges(h.id));
+        if (edgeIds.length === 1) return this.curveIsClosed(shape2);
+      }
+    } catch {
+    }
+    return false;
+  }
+  curvePeriod(shape2) {
+    try {
+      if (this.curveIsPeriodic(shape2)) {
+        const bounds = this.curveParameters(shape2);
+        return bounds[1] - bounds[0];
+      }
+    } catch {
+    }
+    return 0;
+  }
+  curveType(shape2) {
+    const h = shape2;
+    if (h.type === "wire") {
+      const edges = this.iterShapes(shape2, "edge");
+      const first = edges[0];
+      if (first) return this.bk.getEdgeCurveType(unwrap(first, "edge"));
+      return "LINE";
+    }
+    return this.bk.getEdgeCurveType(unwrap(shape2, "edge"));
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Simplification & repair
+  // ═══════════════════════════════════════════════════════════════════════
+  simplify(shape2) {
+    if (shape2.type === "solid") {
+      try {
+        this.bk.healSolid(unwrap(shape2));
+      } catch (e) {
+        console.warn("brepkit: healing failed in simplify:", e);
+      }
+    }
+    return shape2;
+  }
+  isValid(shape2) {
+    if (!isBrepkitHandle(shape2)) return false;
+    if (shape2.type !== "solid") return true;
+    try {
+      const errors2 = this.bk.validateSolidRelaxed(shape2.id);
+      return errors2 === 0;
+    } catch (e) {
+      console.warn("brepkit: isValid check failed:", e);
+      return false;
+    }
+  }
+  isValidStrict(shape2) {
+    if (!isBrepkitHandle(shape2)) return false;
+    if (shape2.type !== "solid") return true;
+    try {
+      const errors2 = this.bk.validateSolid(shape2.id);
+      return errors2 === 0;
+    } catch (e) {
+      console.warn("brepkit: isValidStrict check failed:", e);
+      return false;
+    }
+  }
+  sew(shapes, tolerance) {
+    const faceIds = [];
+    for (const s of shapes) {
+      const h = s;
+      if (h.type === "face") {
+        faceIds.push(h.id);
+      } else if (h.type === "solid") {
+        for (const fid of toArray(this.bk.getSolidFaces(h.id))) {
+          faceIds.push(fid);
+        }
+      } else if (h.type === "shell") {
+        for (const fid of toArray(this.bk.getShellFaces(h.id))) {
+          faceIds.push(fid);
+        }
+      }
+    }
+    const tol = tolerance ?? 1e-7;
+    try {
+      const id2 = this.bk.weldShellsAndFaces(faceIds, tol);
+      return shellHandle(id2);
+    } catch (e) {
+      console.warn("brepkit: weldShellsAndFaces failed, falling back to sewFaces:", e);
+    }
+    const id = this.bk.sewFaces(faceIds, tol);
+    return shellHandle(id);
+  }
+  healSolid(shape2) {
+    const h = shape2;
+    if (h.type !== "solid") {
+      throw new Error(
+        `brepkit: healSolid requires a solid, got ${h.type}. Consider using makeCompound() to combine shapes first.`
+      );
+    }
+    try {
+      const remaining = this.bk.repairSolid(unwrap(shape2));
+      if (remaining > 0) {
+        console.warn(`brepkit: repairSolid left ${remaining} error(s) on solid.`);
+      }
+      return shape2;
+    } catch (e) {
+      try {
+        this.bk.healSolid(unwrap(shape2));
+        return shape2;
+      } catch (healErr) {
+        console.warn(
+          "brepkit: healSolid failed (repairSolid error:",
+          e,
+          ", healSolid error:",
+          healErr,
+          ")"
+        );
+        return null;
+      }
+    }
+  }
+  healFace(shape2) {
+    return shape2;
+  }
+  healWire(wire, _face) {
+    return wire;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // 2D offset
+  // ═══════════════════════════════════════════════════════════════════════
+  offsetWire2D(wire, offset2, _joinType) {
+    const edges = this.iterShapes(wire, "edge");
+    if (edges.length === 0) return wire;
+    const coords2d = [];
+    for (const edge of edges) {
+      const verts = this.bk.getEdgeVertices(unwrap(edge, "edge"));
+      coords2d.push(verts[0], verts[1]);
+    }
+    if (coords2d.length < 6) return wire;
+    const result2 = this.bk.offsetPolygon2d(coords2d, offset2, 1e-10);
+    const coords3d = [];
+    for (let i = 0; i < result2.length; i += 2) {
+      coords3d.push(result2[i], result2[i + 1], 0);
+    }
+    const wireId = this.bk.makePolygonWire(coords3d);
+    return wireHandle(wireId);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Distance
+  // ═══════════════════════════════════════════════════════════════════════
+  distance(shape1, shape2) {
+    const h1 = shape1;
+    const h2 = shape2;
+    if (h1.type === "solid" && h2.type === "solid") {
+      const d = this.bk.solidToSolidDistance(h1.id, h2.id);
+      return { value: d, point1: [0, 0, 0], point2: [0, 0, 0] };
+    }
+    if (h1.type === "vertex" && h2.type === "solid") {
+      const pos = this.bk.getVertexPosition(h1.id);
+      const result2 = this.bk.pointToSolidDistance(pos[0], pos[1], pos[2], h2.id);
+      return {
+        value: result2[0],
+        point1: [pos[0], pos[1], pos[2]],
+        point2: [result2[1], result2[2], result2[3]]
+      };
+    }
+    if (h1.type === "vertex" && h2.type === "face") {
+      const pos = this.bk.getVertexPosition(h1.id);
+      const result2 = this.bk.pointToFaceDistance(pos[0], pos[1], pos[2], h2.id);
+      return {
+        value: result2[0],
+        point1: [pos[0], pos[1], pos[2]],
+        point2: [result2[1], result2[2], result2[3]]
+      };
+    }
+    if (h1.type === "vertex" && h2.type === "edge") {
+      const pos = this.bk.getVertexPosition(h1.id);
+      const result2 = this.bk.pointToEdgeDistance(pos[0], pos[1], pos[2], h2.id);
+      return {
+        value: result2[0],
+        point1: [pos[0], pos[1], pos[2]],
+        point2: [result2[1], result2[2], result2[3]]
+      };
+    }
+    const getPos = (s) => {
+      if (s.type === "vertex") {
+        const p = this.bk.getVertexPosition(s.id);
+        return [p[0], p[1], p[2]];
+      }
+      if (s.type === "solid") {
+        const bb = this.bk.boundingBox(s.id);
+        return [(bb[0] + bb[3]) / 2, (bb[1] + bb[4]) / 2, (bb[2] + bb[5]) / 2];
+      }
+      return [0, 0, 0];
+    };
+    const p1 = getPos(h1);
+    const p2 = getPos(h2);
+    const dx = p2[0] - p1[0];
+    const dy = p2[1] - p1[1];
+    const dz = p2[2] - p1[2];
+    return { value: Math.sqrt(dx * dx + dy * dy + dz * dz), point1: p1, point2: p2 };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Classification
+  // ═══════════════════════════════════════════════════════════════════════
+  classifyPointOnFace(face, u, v, tolerance) {
+    if (tolerance !== void 0) {
+      warnOnce(
+        "classify-tolerance",
+        "classifyPointOnFace() tolerance parameter is not supported; brepkit uses domain-based classification."
+      );
+    }
+    const faceId = unwrap(face, "face");
+    const domain = this.bk.getSurfaceDomain(faceId);
+    if (u < domain[0] || u > domain[1] || v < domain[2] || v > domain[3]) {
+      return "out";
+    }
+    return "in";
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Curve construction
+  // ═══════════════════════════════════════════════════════════════════════
+  interpolatePoints(points, options) {
+    if (options?.tolerance !== void 0) {
+      warnOnce(
+        "interpolate-tolerance",
+        "interpolatePoints() tolerance parameter is not supported; brepkit uses chord-length parameterisation."
+      );
+    }
+    if (points.length < 2) throw new Error("brepkit: need at least 2 points");
+    if (points.length === 2) {
+      return this.makeLineEdge(points[0], points[1]);
+    }
+    const degree = Math.min(3, points.length - 1);
+    const coords = points.flatMap(([x, y, z]) => [x, y, z]);
+    const id = this.bk.interpolatePoints(coords, degree);
+    return edgeHandle(id);
+  }
+  approximatePoints(points, options) {
+    const degree = options?.degMax ?? 3;
+    const tol = options?.tolerance ?? 1e-6;
+    const coords = [];
+    for (const p of points) coords.push(p[0], p[1], p[2]);
+    const numCps = Math.max(degree + 1, Math.min(points.length, Math.ceil(points.length * 0.7)));
+    const id = this.bk.approximateCurveLspia(coords, degree, numCps, tol, 100);
+    return edgeHandle(id);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Serialization
+  // ═══════════════════════════════════════════════════════════════════════
+  toBREP(shape2) {
+    warnOnce(
+      "brep-format",
+      "toBREP/fromBREP uses STEP format (not OCCT BREP). Cross-kernel BREP round-trips are not supported."
+    );
+    return this.exportSTEP([shape2]);
+  }
+  fromBREP(data) {
+    warnOnce(
+      "brep-format",
+      "toBREP/fromBREP uses STEP format (not OCCT BREP). Cross-kernel BREP round-trips are not supported."
+    );
+    const shapes = this.importSTEP(data);
+    if (shapes.length === 0) throw new Error("brepkit: fromBREP produced no shapes");
+    return shapes[0];
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Mesh preparation
+  // ═══════════════════════════════════════════════════════════════════════
+  hasTriangulation(_shape) {
+    return false;
+  }
+  meshShape(_shape, _tolerance, _angularTolerance) {
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Composed transforms
+  // ═══════════════════════════════════════════════════════════════════════
+  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) {
+      const m = op.type === "translate" ? translationMatrix(op.x, op.y, op.z) : rotationMatrix(op.angle, op.axis, op.center);
+      matrix = multiplyMatrices(m, matrix);
+    }
+    return { handle: matrix, dispose: () => {
+    } };
+  }
+  applyComposedTransformWithHistory(shape2, transformHandle, inputFaceHashes, hashUpperBound) {
+    const result2 = this.applyMatrix(shape2, transformHandle);
+    return this.buildEvolution(result2, inputFaceHashes, hashUpperBound, true);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Advanced sweep/loft
+  // ═══════════════════════════════════════════════════════════════════════
+  sweepPipeShell(profile, spine, options) {
+    const profileHandle = profile;
+    const faceId = profileHandle.type === "wire" ? this.bk.makeFaceFromWire(profileHandle.id) : unwrap(profile, "face");
+    const shellMode = !!(options && options["shellMode"]);
+    const nurbsData = this.extractNurbsFromEdge(spine);
+    if (nurbsData && nurbsData.degree > 1) {
+      try {
+        const id = this.bk.sweepSmooth(
+          faceId,
+          nurbsData.degree,
+          nurbsData.knots,
+          nurbsData.controlPoints,
+          nurbsData.weights
+        );
+        const shape22 = solidHandle(id);
+        if (shellMode) return { shape: shape22, firstShape: profile, lastShape: profile };
+        return shape22;
+      } catch (e) {
+        console.warn("brepkit: sweepSmooth failed, falling back to simplePipe:", e);
+      }
+    }
+    const shape2 = this.simplePipe(profile, spine);
+    if (shellMode) return { shape: shape2, firstShape: profile, lastShape: profile };
+    return shape2;
+  }
+  loftAdvanced(wires, options) {
+    const faceIds = wires.map((w) => {
+      const h = w;
+      if (h.type === "wire") return this.bk.makeFaceFromWire(h.id);
+      return unwrap(w, "face");
+    });
+    try {
+      const opts = {};
+      if (options?.ruled !== void 0) opts["ruled"] = options.ruled;
+      if (options?.solid !== void 0) opts["solid"] = options.solid;
+      if (options?.tolerance !== void 0) opts["tolerance"] = options.tolerance;
+      if (options?.startVertex) {
+        const pos = this.bk.getVertexPosition(unwrap(options.startVertex, "vertex"));
+        opts["startPoint"] = [pos[0], pos[1], pos[2]];
+      }
+      if (options?.endVertex) {
+        const pos = this.bk.getVertexPosition(unwrap(options.endVertex, "vertex"));
+        opts["endPoint"] = [pos[0], pos[1], pos[2]];
+      }
+      const id = this.bk.loftWithOptions(faceIds, JSON.stringify(opts));
+      return solidHandle(id);
+    } catch (e) {
+      console.warn("brepkit: loftWithOptions failed, falling back to smooth/basic loft:", e);
+    }
+    if (!options?.ruled) {
+      try {
+        const id = this.bk.loftSmooth(faceIds);
+        return solidHandle(id);
+      } catch (e) {
+        console.warn("brepkit: loftSmooth failed, falling back to basic loft:", e);
+      }
+    }
+    return this.loft(wires);
+  }
+  buildExtrusionLaw(profile, length, endFactor) {
+    const law = {
+      type: "extrusionLaw",
+      profile,
+      length,
+      endFactor,
+      Trim(_first, _last, _tol) {
+        return law;
+      },
+      delete: noop
+    };
+    return law;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Curve positioning & patterns
+  // ═══════════════════════════════════════════════════════════════════════
+  positionOnCurve(shape2, spine, param) {
+    const { point, tangent } = this.curveTangent(spine, param);
+    const [tx, ty, tz] = tangent;
+    const len = Math.sqrt(tx * tx + ty * ty + tz * tz);
+    if (len < 1e-12) return this.translate(shape2, point[0], point[1], point[2]);
+    const nx = tx / len, ny = ty / len, nz = tz / len;
+    const dot = nz;
+    let result2 = shape2;
+    if (Math.abs(dot + 1) < 1e-10) {
+      result2 = this.rotate(result2, 180, [1, 0, 0]);
+    } else if (Math.abs(dot - 1) > 1e-10) {
+      const axis = [-ny, nx, 0];
+      const angleDeg = Math.acos(Math.max(-1, Math.min(1, dot))) * (180 / Math.PI);
+      result2 = this.rotate(result2, angleDeg, axis);
+    }
+    return this.translate(result2, point[0], point[1], point[2]);
+  }
+  linearPattern(shape2, direction, spacing, count) {
+    const results = [shape2];
+    for (let i = 1; i < count; i++) {
+      const offset2 = spacing * i;
+      results.push(
+        this.translate(shape2, direction[0] * offset2, direction[1] * offset2, direction[2] * offset2)
+      );
+    }
+    return results;
+  }
+  circularPattern(shape2, center, axis, angleStep, count) {
+    const results = [shape2];
+    for (let i = 1; i < count; i++) {
+      results.push(this.rotate(shape2, angleStep * i, axis, center));
+    }
+    return results;
+  }
+  gridPattern(shape2, directionX, directionY, spacingX, spacingY, countX, countY) {
+    const id = this.bk.gridPattern(
+      unwrapSolidOrThrow(shape2, "gridPattern"),
+      directionX[0],
+      directionX[1],
+      directionX[2],
+      directionY[0],
+      directionY[1],
+      directionY[2],
+      spacingX,
+      spacingY,
+      countX,
+      countY
+    );
+    return compoundHandle(id);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Surface construction
+  // ═══════════════════════════════════════════════════════════════════════
+  makeNonPlanarFace(wire) {
+    return this.makeFace(wire, true);
+  }
+  addHolesInFace(face, holeWires) {
+    const wireIds = holeWires.map((w) => unwrap(w, "wire"));
+    const id = this.bk.addHolesToFace(unwrap(face, "face"), wireIds);
+    return faceHandle(id);
+  }
+  // TODO: Expose bk.removeHolesFromFace() — inverse of addHolesInFace.
+  // Useful for defeaturing workflows. See brepkitWasmTypes.ts.
+  makeFaceOnSurface(_surface, wire) {
+    return this.makeFace(wire, true);
+  }
+  bsplineSurface(points, rows, cols) {
+    const coords = [];
+    for (const [x, y, z] of points) {
+      coords.push(x, y, z);
+    }
+    const degreeU = Math.min(3, rows - 1);
+    const degreeV = Math.min(3, cols - 1);
+    try {
+      const faceId = this.bk.interpolateSurface(coords, rows, cols, degreeU, degreeV);
+      return faceHandle(faceId);
+    } catch {
+      return this.triangulatedSurface(points, rows, cols);
+    }
+  }
+  triangulatedSurface(points, rows, cols) {
+    const faces = [];
+    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 f1 = this.buildTriFace(points[i00], points[i10], points[i01]);
+        if (f1) faces.push(f1);
+        const f2 = this.buildTriFace(points[i10], points[i11], points[i01]);
+        if (f2) faces.push(f2);
+      }
+    }
+    if (faces.length === 0) throw new Error("brepkit: no valid faces in surface grid");
+    return this.sew(faces, 1e-6);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Mesh sewing -> solid
+  // ═══════════════════════════════════════════════════════════════════════
+  buildTriFace(a, b, c) {
+    const ab = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+    const ac = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+    const cross = [
+      ab[1] * ac[2] - ab[2] * ac[1],
+      ab[2] * ac[0] - ab[0] * ac[2],
+      ab[0] * ac[1] - ab[1] * ac[0]
+    ];
+    const area = Math.sqrt(cross[0] ** 2 + cross[1] ** 2 + cross[2] ** 2);
+    if (area < 1e-12) return null;
+    try {
+      const e1 = this.makeLineEdge(a, b);
+      const e2 = this.makeLineEdge(b, c);
+      const e3 = this.makeLineEdge(c, a);
+      const wire = this.makeWire([e1, e2, e3]);
+      return this.makeFace(wire);
+    } catch (e) {
+      console.warn("brepkit: makeNonPlanarFace failed:", e);
+      return null;
+    }
+  }
+  sewAndSolidify(faces, tolerance) {
+    const faceIds = faces.map((s) => unwrap(s, "face"));
+    const solidId = this.bk.sewFaces(faceIds, tolerance);
+    return solidHandle(solidId);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Repair
+  // ═══════════════════════════════════════════════════════════════════════
+  fixShape(shape2) {
+    const h = shape2;
+    if (h.type === "solid") {
+      this.bk.healSolid(h.id);
+    }
+    return shape2;
+  }
+  fixSelfIntersection(wire) {
+    return wire;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Measurement (advanced)
+  // ═══════════════════════════════════════════════════════════════════════
+  surfaceCurvature(face, u, v) {
+    const fid = unwrap(face, "face");
+    const data = this.bk.measureCurvatureAtSurface(fid, u, v);
+    if (data.length < 8) {
+      throw new Error(
+        `brepkit: measureCurvatureAtSurface returned ${data.length} values, expected 8`
+      );
+    }
+    const k1 = data[0];
+    const k2 = data[1];
+    const gaussian = k1 * k2;
+    const mean = (k1 + k2) / 2;
+    return {
+      gaussian,
+      mean,
+      max: Math.max(k1, k2),
+      min: Math.min(k1, k2),
+      maxDirection: [data[2], data[3], data[4]],
+      minDirection: [data[5], data[6], data[7]]
+    };
+  }
+  surfaceCenterOfMass(face) {
+    const mesh2 = this.bk.tessellateFace(unwrap(face, "face"), 0.1);
+    const pos = mesh2.positions;
+    const idx = mesh2.indices;
+    let cx = 0, cy = 0, cz = 0, totalArea = 0;
+    for (let t = 0; t < idx.length; t += 3) {
+      const i0 = idx[t] * 3, i1 = idx[t + 1] * 3, i2 = idx[t + 2] * 3;
+      const tcx = (pos[i0] + pos[i1] + pos[i2]) / 3;
+      const tcy = (pos[i0 + 1] + pos[i1 + 1] + pos[i2 + 1]) / 3;
+      const tcz = (pos[i0 + 2] + pos[i1 + 2] + pos[i2 + 2]) / 3;
+      const ux = pos[i1] - pos[i0], uy = pos[i1 + 1] - pos[i0 + 1], uz = pos[i1 + 2] - pos[i0 + 2];
+      const vx = pos[i2] - pos[i0], vy = pos[i2 + 1] - pos[i0 + 1], vz = pos[i2 + 2] - pos[i0 + 2];
+      const area = 0.5 * Math.sqrt((uy * vz - uz * vy) ** 2 + (uz * vx - ux * vz) ** 2 + (ux * vy - uy * vx) ** 2);
+      cx += tcx * area;
+      cy += tcy * area;
+      cz += tcz * area;
+      totalArea += area;
+    }
+    if (totalArea < 1e-30) return [0, 0, 0];
+    return [cx / totalArea, cy / totalArea, cz / totalArea];
+  }
+  createDistanceQuery(referenceShape) {
+    const distanceFn = (shape2) => this.distance(referenceShape, shape2);
+    return {
+      distanceTo(shape2) {
+        return distanceFn(shape2);
+      },
+      dispose() {
+      }
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Projection
+  // ═══════════════════════════════════════════════════════════════════════
+  projectEdges(shape2, _cameraOrigin, _cameraDirection, _cameraXAxis) {
+    const edges = this.iterShapes(shape2, "edge");
+    const emptyCompound = edges.length > 0 ? edges[0] : shape2;
+    return {
+      visible: { outline: emptyCompound, smooth: emptyCompound, sharp: emptyCompound },
+      hidden: { outline: emptyCompound, smooth: emptyCompound, sharp: emptyCompound }
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Draft
+  // ═══════════════════════════════════════════════════════════════════════
+  draftPrism(shape2, face, _baseFace, height, _angleDeg, fuse2) {
+    if (height !== null) {
+      const normal = this.surfaceNormal(face, 0, 0);
+      const extruded = this.extrude(face, normal, height);
+      if (fuse2) {
+        return this.fuse(shape2, extruded);
+      }
+      return extruded;
+    }
+    return shape2;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // XCAF / configured export
+  // ═══════════════════════════════════════════════════════════════════════
+  createXCAFDocument(shapes) {
+    return { __brepkit_xcaf: true, shapes, delete: noop };
+  }
+  writeXCAFToSTEP(doc, _options) {
+    if (doc && doc.__brepkit_xcaf && Array.isArray(doc.shapes)) {
+      return this.exportSTEP(doc.shapes.map((s) => s.shape));
+    }
+    return "";
+  }
+  exportSTEPConfigured(shapes, _options) {
+    return this.exportSTEP(shapes.map((s) => s.shape));
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Export helpers
+  // ═══════════════════════════════════════════════════════════════════════
+  wrapString(str) {
+    return str;
+  }
+  wrapColor(red, green, blue, alpha) {
+    return [red, green, blue, alpha];
+  }
+  configureStepUnits(_unit, _modelUnit) {
+  }
+  configureStepWriter(_writer) {
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Curve adaptor
+  // ═══════════════════════════════════════════════════════════════════════
+  createCurveAdaptor(shape2) {
+    return shape2;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Bezier pole extraction
+  // ═══════════════════════════════════════════════════════════════════════
+  getBezierPenultimatePole(edge) {
+    const nurbsData = this.extractNurbsFromEdge(edge);
+    if (!nurbsData || nurbsData.controlPoints.length < 6) return null;
+    const n = nurbsData.controlPoints.length;
+    return [
+      nurbsData.controlPoints[n - 6],
+      nurbsData.controlPoints[n - 5],
+      nurbsData.controlPoints[n - 4]
+    ];
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Surface geometry extraction
+  // ═══════════════════════════════════════════════════════════════════════
+  getSurfaceCylinderData(surface) {
+    if (isBrepkitHandle(surface) && surface.type === "face") {
+      const faceId = surface.id;
+      const params = JSON.parse(this.bk.getAnalyticSurfaceParams(faceId));
+      if (params.type === "cylinder") {
+        return { radius: params.radius, isDirect: true };
+      }
+    }
+    return null;
+  }
+  reverseSurfaceU(surface) {
+    return surface;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // 3D geometry primitive factories
+  // ═══════════════════════════════════════════════════════════════════════
+  createPoint3d(x, y, z) {
+    return { x, y, z };
+  }
+  createDirection3d(x, y, z) {
+    const len = Math.sqrt(x * x + y * y + z * z);
+    return { x: x / len, y: y / len, z: z / len };
+  }
+  createVector3d(x, y, z) {
+    return { x, y, z };
+  }
+  createAxis1(cx, cy, cz, dx, dy, dz) {
+    return { origin: [cx, cy, cz], direction: [dx, dy, dz] };
+  }
+  createAxis2(ox, oy, oz, zx, zy, zz, xx, xy, xz) {
+    return {
+      origin: [ox, oy, oz],
+      z: [zx, zy, zz],
+      x: xx !== void 0 ? [xx, xy, xz] : void 0
+    };
+  }
+  createAxis3(ox, oy, oz, zx, zy, zz, xx, xy, xz) {
+    return {
+      origin: [ox, oy, oz],
+      z: [zx, zy, zz],
+      x: xx !== void 0 ? [xx, xy, xz] : void 0
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Shape reversal
+  // ═══════════════════════════════════════════════════════════════════════
+  reverseShape(shape2) {
+    const h = shape2;
+    const newId = this.bk.reverseShape(h.id);
+    return handle(h.type, newId);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Dispose
+  // ═══════════════════════════════════════════════════════════════════════
+  // TODO: Expose bk.checkpoint() / bk.restore() / bk.discardCheckpoint() for
+  // transactional arena management. Could back a future undo/redo or speculative
+  // operation API (try operation → restore on failure). See brepkitWasmTypes.ts.
+  dispose(_handle) {
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Kernel2DCapability (stubs — returns false from supportsKernel2D)
+  // ═══════════════════════════════════════════════════════════════════════
+  // ═══════════════════════════════════════════════════════════════════════
+  // Kernel2DCapability — pure TypeScript implementation
+  // ═══════════════════════════════════════════════════════════════════════
+  c2d(h) {
+    return h;
+  }
+  /** Unwrap any trimmed wrappers to get the underlying geometry. */
+  c2dBasis(h) {
+    let c = this.c2d(h);
+    while (c.__bk2d === "trimmed") c = c.basis;
+    return c;
+  }
+  bb2d(h) {
+    return h;
+  }
+  createPoint2d(x, y) {
+    return { x, y };
+  }
+  createDirection2d(x, y) {
+    const l = Math.sqrt(x * x + y * y);
+    return { x: x / l, y: y / l };
+  }
+  createVector2d(x, y) {
+    return { x, y };
+  }
+  createAxis2d(px, py, dx, dy) {
+    return { px, py, dx, dy };
+  }
+  wrapCurve2dHandle(handle2) {
+    return handle2;
+  }
+  createCurve2dAdaptor(handle2) {
+    return handle2;
+  }
+  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) {
+    const d = 2 * (x1 * (ym - y2) + xm * (y2 - y1) + x2 * (y1 - ym));
+    if (Math.abs(d) < 1e-12) {
+      return makeLine2d(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(cx, cy, radius, sense);
+    if (!sense) {
+      return { __bk2d: "trimmed", basis: circle, tStart: -a1, tEnd: -a2 };
+    }
+    return { __bk2d: "trimmed", basis: circle, tStart: a1, tEnd: a2 };
+  }
+  makeArc2dTangent(sx, sy, tx, ty, ex, ey) {
+    const len = Math.sqrt(tx * tx + ty * ty);
+    const ntx = len > 0 ? tx / len : 0;
+    const nty = len > 0 ? ty / len : 0;
+    const chord = Math.sqrt((ex - sx) ** 2 + (ey - sy) ** 2);
+    const offset2 = chord * 0.25;
+    return this.makeArc2dThreePoints(
+      sx,
+      sy,
+      (sx + ex) / 2 + nty * offset2,
+      (sy + ey) / 2 - ntx * offset2,
+      ex,
+      ey
+    );
+  }
+  makeEllipse2d(cx, cy, major, minor, xDirX, xDirY, sense) {
+    return makeEllipse2d(cx, cy, major, minor, xDirX, xDirY, sense);
+  }
+  makeEllipseArc2d(cx, cy, major, minor, start, end, xDirX, xDirY, sense) {
+    const ellipse = makeEllipse2d(cx, cy, major, minor, xDirX, xDirY, sense);
+    return { __bk2d: "trimmed", basis: ellipse, tStart: start, tEnd: end };
+  }
+  makeBezier2d(points) {
+    return makeBezier2d(points);
+  }
+  makeBSpline2d(points, _options) {
+    const n = points.length;
+    const degree = Math.min(3, n - 1);
+    const knots = [];
+    const mults = [];
+    knots.push(0);
+    mults.push(degree + 1);
+    const nInternal = n - degree - 1;
+    for (let i = 1; i <= nInternal; i++) {
+      knots.push(i / (nInternal + 1));
+      mults.push(1);
+    }
+    knots.push(1);
+    mults.push(degree + 1);
+    return {
+      __bk2d: "bspline",
+      poles: [...points],
+      knots,
+      multiplicities: mults,
+      degree,
+      isPeriodic: false
+    };
+  }
+  evaluateCurve2d(curve, param) {
+    return evaluateCurve2d(this.c2d(curve), param);
+  }
+  evaluateCurve2dD1(curve, param) {
+    return {
+      point: evaluateCurve2d(this.c2d(curve), param),
+      tangent: tangentCurve2d(this.c2d(curve), param)
+    };
+  }
+  getCurve2dBounds(curve) {
+    return curveBounds(this.c2d(curve));
+  }
+  getCurve2dType(curve) {
+    return curveTypeName(this.c2dBasis(curve));
+  }
+  trimCurve2d(curve, start, end) {
+    return { __bk2d: "trimmed", basis: this.c2d(curve), tStart: start, tEnd: end };
+  }
+  reverseCurve2d(_curve) {
+  }
+  copyCurve2d(curve) {
+    return JSON.parse(JSON.stringify(curve));
+  }
+  offsetCurve2d(curve, offset2) {
+    const c = this.c2d(curve);
+    const bounds = curveBounds(c);
+    const N = 30;
+    const poles = [];
+    for (let i = 0; i <= N; i++) {
+      const t = bounds.first + (bounds.last - bounds.first) * i / N;
+      const [px, py] = evaluateCurve2d(c, t);
+      const [tx, ty] = tangentCurve2d(c, t);
+      const tLen = Math.sqrt(tx * tx + ty * ty);
+      if (tLen > 1e-12) {
+        poles.push([px - ty / tLen * offset2, py + tx / tLen * offset2]);
+      } else {
+        poles.push([px, py]);
+      }
+    }
+    return this.makeBSpline2d(poles);
+  }
+  translateCurve2d(curve, dx, dy) {
+    return translateCurve2d(this.c2d(curve), dx, dy);
+  }
+  rotateCurve2d(curve, angle, cx, cy) {
+    return rotateCurve2d(this.c2d(curve), angle, cx, cy);
+  }
+  scaleCurve2d(curve, factor, cx, cy) {
+    return scaleCurve2d(this.c2d(curve), factor, cx, cy);
+  }
+  mirrorCurve2dAtPoint(curve, cx, cy) {
+    return mirrorAtPoint(this.c2d(curve), cx, cy);
+  }
+  mirrorCurve2dAcrossAxis(curve, ox, oy, dx, dy) {
+    return mirrorAcrossAxis(this.c2d(curve), ox, oy, dx, dy);
+  }
+  affinityTransform2d(curve, ox, oy, dx, dy, ratio) {
+    const len = Math.sqrt(dx * dx + dy * dy);
+    if (len < 1e-15) return this.c2d(curve);
+    const ax = dx / len, ay = dy / len;
+    const px = -ay, py = ax;
+    const k = ratio - 1;
+    const m00 = 1 + k * px * px, m01 = k * px * py;
+    const m10 = k * py * px, m11 = 1 + k * py * py;
+    const txOff = ox - m00 * ox - m01 * oy;
+    const tyOff = oy - m10 * ox - m11 * oy;
+    const gtrsf = { m: [m00, m01, 0, m10, m11, 0, 0, 0, 1], tx: txOff, ty: tyOff };
+    return this.transformCurve2dGeneral(curve, gtrsf);
+  }
+  // --- General 2D transforms (stored as 3×3 matrices) ---
+  createIdentityGTrsf2d() {
+    return { m: [1, 0, 0, 0, 1, 0, 0, 0, 1], tx: 0, ty: 0 };
+  }
+  createAffinityGTrsf2d(ox, oy, dx, dy, ratio) {
+    const len = Math.sqrt(dx * dx + dy * dy);
+    if (len < 1e-15) return this.createIdentityGTrsf2d();
+    const px = -dy / len, py = dx / len;
+    const k = ratio - 1;
+    const m = [1 + k * px * px, k * px * py, 0, k * py * px, 1 + k * py * py, 0, 0, 0, 1];
+    const txv = ox - m[0] * ox - m[1] * oy;
+    const tyv = oy - m[3] * ox - m[4] * oy;
+    return { m, tx: txv, ty: tyv };
+  }
+  createTranslationGTrsf2d(dx, dy) {
+    return { m: [1, 0, 0, 0, 1, 0, 0, 0, 1], tx: dx, ty: dy };
+  }
+  createMirrorGTrsf2d(cx, cy, mode, ox, oy, dx, dy) {
+    if (mode === "axis" && dx !== void 0 && dy !== void 0) {
+      const len = Math.sqrt(dx * dx + dy * dy);
+      const nx = dx / len, ny = dy / len;
+      const m = [2 * nx * nx - 1, 2 * nx * ny, 0, 2 * nx * ny, 2 * ny * ny - 1, 0, 0, 0, 1];
+      const px = ox ?? cx, py = oy ?? cy;
+      const txv = px - m[0] * px - m[1] * py;
+      const tyv = py - m[3] * px - m[4] * py;
+      return { m, tx: txv, ty: tyv };
+    }
+    return { m: [-1, 0, 0, 0, -1, 0, 0, 0, 1], tx: 2 * cx, ty: 2 * cy };
+  }
+  createRotationGTrsf2d(angle, cx, cy) {
+    const c = Math.cos(angle), s = Math.sin(angle);
+    return { m: [c, -s, 0, s, c, 0, 0, 0, 1], tx: cx - c * cx + s * cy, ty: cy - s * cx - c * cy };
+  }
+  createScaleGTrsf2d(factor, cx, cy) {
+    return {
+      m: [factor, 0, 0, 0, factor, 0, 0, 0, 1],
+      tx: cx * (1 - factor),
+      ty: cy * (1 - factor)
+    };
+  }
+  setGTrsf2dTranslationPart(gtrsf, dx, dy) {
+    gtrsf.tx = dx;
+    gtrsf.ty = dy;
+  }
+  multiplyGTrsf2d(base, other) {
+    const a = base.m, b = other.m;
+    const r = [
+      a[0] * b[0] + a[1] * b[3] + a[2] * b[6],
+      a[0] * b[1] + a[1] * b[4] + a[2] * b[7],
+      a[0] * b[2] + a[1] * b[5] + a[2] * b[8],
+      a[3] * b[0] + a[4] * b[3] + a[5] * b[6],
+      a[3] * b[1] + a[4] * b[4] + a[5] * b[7],
+      a[3] * b[2] + a[4] * b[5] + a[5] * b[8],
+      a[6] * b[0] + a[7] * b[3] + a[8] * b[6],
+      a[6] * b[1] + a[7] * b[4] + a[8] * b[7],
+      a[6] * b[2] + a[7] * b[5] + a[8] * b[8]
+    ];
+    base.m = r;
+    const oldTx = base.tx, oldTy = base.ty;
+    const otx = Number(other.tx) || 0, oty = Number(other.ty) || 0;
+    base.tx = a[0] * otx + a[1] * oty + oldTx;
+    base.ty = a[3] * otx + a[4] * oty + oldTy;
+  }
+  transformCurve2dGeneral(curve, gtrsf) {
+    const c = this.c2d(curve);
+    const m = gtrsf.m ?? [1, 0, 0, 0, 1, 0, 0, 0, 1];
+    const tx = Number(gtrsf.tx) || 0, ty = Number(gtrsf.ty) || 0;
+    const isIdentityMatrix = Math.abs(m[0] - 1) < 1e-12 && Math.abs(m[4] - 1) < 1e-12 && Math.abs(m[1]) < 1e-12 && Math.abs(m[3]) < 1e-12;
+    if (isIdentityMatrix) {
+      return translateCurve2d(c, tx, ty);
+    }
+    const bounds = curveBounds(c);
+    const N = 20;
+    const pts = [];
+    for (let i = 0; i <= N; i++) {
+      const t = bounds.first + (bounds.last - bounds.first) * i / N;
+      const [px, py] = evaluateCurve2d(c, t);
+      pts.push([m[0] * px + m[1] * py + tx, m[3] * px + m[4] * py + ty]);
+    }
+    return makeBezier2d(pts);
+  }
+  // --- 2D intersection & distance ---
+  intersectCurves2d(c1, c2, tolerance) {
+    const result2 = intersectCurves2dFn(this.c2d(c1), this.c2d(c2), tolerance);
+    const segments = result2.segments.map(
+      (s) => Object.assign(s, {
+        delete() {
+        }
+      })
+    );
+    return { points: result2.points, segments };
+  }
+  projectPointOnCurve2d(curve, x, y) {
+    const c = this.c2d(curve);
+    const bounds = curveBounds(c);
+    if (c.__bk2d === "line") {
+      const dx = x - c.ox;
+      const dy = y - c.oy;
+      const t = Math.max(bounds.first, Math.min(bounds.last, dx * c.dx + dy * c.dy));
+      const [px, py] = evaluateCurve2d(c, t);
+      return { param: t, distance: Math.sqrt((px - x) ** 2 + (py - y) ** 2) };
+    }
+    if (c.__bk2d === "circle") {
+      const angle = Math.atan2(y - c.cy, x - c.cx);
+      let t = c.sense ? angle : -angle;
+      while (t < 0) t += 2 * Math.PI;
+      while (t > 2 * Math.PI) t -= 2 * Math.PI;
+      const [px, py] = evaluateCurve2d(c, t);
+      return { param: t, distance: Math.sqrt((px - x) ** 2 + (py - y) ** 2) };
+    }
+    if (!isFinite(bounds.first) || !isFinite(bounds.last)) return null;
+    let bestT = bounds.first;
+    let bestDist = Infinity;
+    const N = 200;
+    const dt = (bounds.last - bounds.first) / N;
+    for (let i = 0; i <= N; i++) {
+      const t = bounds.first + i * dt;
+      const [px, py] = evaluateCurve2d(c, t);
+      const d = (px - x) ** 2 + (py - y) ** 2;
+      if (d < bestDist) {
+        bestDist = d;
+        bestT = t;
+      }
+    }
+    for (let iter = 0; iter < 10; iter++) {
+      const [px, py] = evaluateCurve2d(c, bestT);
+      const [tx, ty] = tangentCurve2d(c, bestT);
+      const dot = (px - x) * tx + (py - y) * ty;
+      const denom = tx * tx + ty * ty;
+      if (denom < 1e-20) break;
+      const step = dot / denom;
+      const newT = Math.max(bounds.first, Math.min(bounds.last, bestT - step));
+      if (Math.abs(newT - bestT) < 1e-14) break;
+      bestT = newT;
+    }
+    const [fx, fy] = evaluateCurve2d(c, bestT);
+    return { param: bestT, distance: Math.sqrt((fx - x) ** 2 + (fy - y) ** 2) };
+  }
+  distanceBetweenCurves2d(c1, c2, p1s, p1e, p2s, p2e) {
+    const curve1 = this.c2d(c1);
+    const curve2 = this.c2d(c2);
+    let bestT1 = p1s;
+    let bestT2 = p2s;
+    let minDistSq = Infinity;
+    const N = 50;
+    for (let i = 0; i <= N; i++) {
+      const t12 = p1s + (p1e - p1s) * i / N;
+      const [x1, y1] = evaluateCurve2d(curve1, t12);
+      for (let j = 0; j <= N; j++) {
+        const t22 = p2s + (p2e - p2s) * j / N;
+        const [x2, y2] = evaluateCurve2d(curve2, t22);
+        const d = (x2 - x1) ** 2 + (y2 - y1) ** 2;
+        if (d < minDistSq) {
+          minDistSq = d;
+          bestT1 = t12;
+          bestT2 = t22;
+        }
+      }
+    }
+    let t1 = bestT1;
+    let t2 = bestT2;
+    for (let iter = 0; iter < 20; iter++) {
+      const [x2, y2] = evaluateCurve2d(curve2, t2);
+      const proj1 = this.projectPointOnCurve2d(c1, x2, y2);
+      if (proj1) {
+        const newT1 = Math.max(p1s, Math.min(p1e, proj1.param));
+        const converged1 = Math.abs(newT1 - t1) < 1e-12;
+        t1 = newT1;
+        if (converged1) break;
+      }
+      const [x1, y1] = evaluateCurve2d(curve1, t1);
+      const proj2 = this.projectPointOnCurve2d(c2, x1, y1);
+      if (proj2) {
+        const newT2 = Math.max(p2s, Math.min(p2e, proj2.param));
+        const converged2 = Math.abs(newT2 - t2) < 1e-12;
+        t2 = newT2;
+        if (converged2) break;
+      }
+    }
+    const [fx1, fy1] = evaluateCurve2d(curve1, t1);
+    const [fx2, fy2] = evaluateCurve2d(curve2, t2);
+    return Math.sqrt((fx2 - fx1) ** 2 + (fy2 - fy1) ** 2);
+  }
+  approximateCurve2dAsBSpline(curve, tol, cont, maxSeg) {
+    const c = this.c2d(curve);
+    const bounds = curveBounds(c);
+    const contDeg = cont === "C0" ? 1 : cont === "C1" ? 2 : cont === "C2" ? 3 : 4;
+    const degree = Math.max(3, contDeg);
+    let N = Math.max(100, maxSeg * 10);
+    let poles = [];
+    let maxErr = Infinity;
+    for (let attempt = 0; attempt < 3 && maxErr > tol; attempt++) {
+      poles = [];
+      for (let i = 0; i <= N; i++) {
+        const t = bounds.first + (bounds.last - bounds.first) * i / N;
+        poles.push(evaluateCurve2d(c, t));
+      }
+      maxErr = 0;
+      for (let i = 0; i < N; i++) {
+        const tMid = bounds.first + (bounds.last - bounds.first) * (i + 0.5) / N;
+        const [ex, ey] = evaluateCurve2d(c, tMid);
+        const p0 = poles[i];
+        const p1 = poles[i + 1];
+        const mx = (p0[0] + p1[0]) / 2;
+        const my = (p0[1] + p1[1]) / 2;
+        const err = Math.sqrt((ex - mx) ** 2 + (ey - my) ** 2);
+        if (err > maxErr) maxErr = err;
+      }
+      if (maxErr > tol) N = Math.min(N * 2, 500);
+    }
+    return this.makeBSpline2d(poles, { degMax: degree });
+  }
+  decomposeBSpline2dToBeziers(curve) {
+    const c = this.c2dBasis(curve);
+    if (c.__bk2d === "bezier") return [curve];
+    if (c.__bk2d !== "bspline") {
+      const approx = this.approximateCurve2dAsBSpline(curve, 1e-6, "C2", 10);
+      return this.decomposeBSpline2dToBeziers(approx);
+    }
+    const trimBounds = curveBounds(this.c2d(curve));
+    const first = trimBounds.first;
+    const last = trimBounds.last;
+    const internalKnots = [];
+    for (const k of c.knots) {
+      if (k > first + 1e-12 && k < last - 1e-12) internalKnots.push(k);
+    }
+    const breakpoints = [first, ...internalKnots, last];
+    const result2 = [];
+    for (let i = 0; i < breakpoints.length - 1; i++) {
+      const t0 = breakpoints[i];
+      const t1 = breakpoints[i + 1];
+      const span = t1 - t0;
+      if (span < 1e-15) continue;
+      const p0 = evaluateCurve2d(c, t0);
+      const p3 = evaluateCurve2d(c, t1);
+      const tan0 = tangentCurve2d(c, t0);
+      const tan3 = tangentCurve2d(c, t1);
+      const s = span / 3;
+      const bezier = {
+        __bk2d: "bezier",
+        poles: [
+          p0,
+          [p0[0] + tan0[0] * s, p0[1] + tan0[1] * s],
+          [p3[0] - tan3[0] * s, p3[1] - tan3[1] * s],
+          p3
+        ]
+      };
+      result2.push(bezier);
+    }
+    return result2.length > 0 ? result2 : [curve];
+  }
+  // --- 2D bounding boxes ---
+  createBoundingBox2d() {
+    return createBBox2d();
+  }
+  addCurveToBBox2d(bbox, curve, tol) {
+    addCurveToBBox(this.bb2d(bbox), this.c2d(curve));
+  }
+  getBBox2dBounds(bbox) {
+    const b = this.bb2d(bbox);
+    return { xMin: b.xMin, yMin: b.yMin, xMax: b.xMax, yMax: b.yMax };
+  }
+  mergeBBox2d(target, other) {
+    const t = this.bb2d(target), o = this.bb2d(other);
+    t.xMin = Math.min(t.xMin, o.xMin);
+    t.yMin = Math.min(t.yMin, o.yMin);
+    t.xMax = Math.max(t.xMax, o.xMax);
+    t.yMax = Math.max(t.yMax, o.yMax);
+  }
+  isBBox2dOut(a, b) {
+    const ba = this.bb2d(a), bb = this.bb2d(b);
+    return ba.xMax < bb.xMin || bb.xMax < ba.xMin || ba.yMax < bb.yMin || bb.yMax < ba.yMin;
+  }
+  isBBox2dOutPoint(bbox, x, y) {
+    const b = this.bb2d(bbox);
+    return x < b.xMin || x > b.xMax || y < b.yMin || y > b.yMax;
+  }
+  // --- 2D type extraction ---
+  getCurve2dCircleData(curve) {
+    const c = this.c2dBasis(curve);
+    if (c.__bk2d === "circle") return { cx: c.cx, cy: c.cy, radius: c.radius, isDirect: c.sense };
+    return null;
+  }
+  getCurve2dEllipseData(curve) {
+    const c = this.c2dBasis(curve);
+    if (c.__bk2d === "ellipse")
+      return {
+        majorRadius: c.majorRadius,
+        minorRadius: c.minorRadius,
+        xAxisAngle: c.xDirAngle,
+        isDirect: c.sense
+      };
+    return null;
+  }
+  getCurve2dBezierPoles(curve) {
+    const c = this.c2dBasis(curve);
+    if (c.__bk2d === "bezier") return [...c.poles];
+    return null;
+  }
+  getCurve2dBezierDegree(curve) {
+    const c = this.c2dBasis(curve);
+    if (c.__bk2d === "bezier") return c.poles.length - 1;
+    return null;
+  }
+  getCurve2dBSplineData(curve) {
+    const c = this.c2dBasis(curve);
+    if (c.__bk2d === "bspline")
+      return {
+        poles: [...c.poles],
+        knots: [...c.knots],
+        multiplicities: [...c.multiplicities],
+        degree: c.degree,
+        isPeriodic: c.isPeriodic
+      };
+    return null;
+  }
+  // --- 2D serialization ---
+  serializeCurve2d(curve) {
+    return serializeCurve2d(this.c2d(curve));
+  }
+  deserializeCurve2d(data) {
+    return deserializeCurve2d(data);
+  }
+  // --- 2D curve splitting ---
+  splitCurve2d(curve, params) {
+    const c = this.c2d(curve);
+    const bounds = curveBounds(c);
+    const sortedParams = [bounds.first, ...params.sort((a, b) => a - b), bounds.last];
+    const result2 = [];
+    for (let i = 0; i < sortedParams.length - 1; i++) {
+      result2.push({
+        __bk2d: "trimmed",
+        basis: c,
+        tStart: sortedParams[i],
+        tEnd: sortedParams[i + 1]
+      });
+    }
+    return result2;
+  }
+  // --- 2D → 3D projection ---
+  liftCurve2dToPlane(curve, origin, planeZ, planeX) {
+    const c = this.c2d(curve);
+    const y = [
+      planeZ[1] * planeX[2] - planeZ[2] * planeX[1],
+      planeZ[2] * planeX[0] - planeZ[0] * planeX[2],
+      planeZ[0] * planeX[1] - planeZ[1] * planeX[0]
+    ];
+    const lift = (u, v) => [
+      origin[0] + u * planeX[0] + v * y[0],
+      origin[1] + u * planeX[1] + v * y[1],
+      origin[2] + u * planeX[2] + v * y[2]
+    ];
+    if (c.__bk2d === "line") {
+      const p1 = lift(c.ox, c.oy);
+      const p2 = lift(c.ox + c.dx * c.len, c.oy + c.dy * c.len);
+      return this.makeLineEdge(p1, p2);
+    }
+    if (c.__bk2d === "circle" || c.__bk2d === "trimmed") {
+      const bounds2 = curveBounds(c);
+      let angularSpan;
+      if (c.__bk2d === "trimmed") {
+        angularSpan = Math.abs(c.tEnd - c.tStart);
+      } else {
+        angularSpan = 2 * Math.PI;
+      }
+      const nSegments = angularSpan > Math.PI ? 4 : angularSpan > Math.PI / 2 ? 2 : 1;
+      const segmentSpan = (bounds2.last - bounds2.first) / nSegments;
+      const samplesPerSegment = Math.max(12, Math.ceil(angularSpan / nSegments / (Math.PI / 45)));
+      if (nSegments === 1) {
+        const points2 = [];
+        for (let i = 0; i <= samplesPerSegment; i++) {
+          const t = bounds2.first + (bounds2.last - bounds2.first) * i / samplesPerSegment;
+          const [u, v] = evaluateCurve2d(c, t);
+          points2.push(lift(u, v));
+        }
+        return this.interpolatePoints(points2);
+      }
+      const edgeIds = [];
+      for (let seg = 0; seg < nSegments; seg++) {
+        const segStart = bounds2.first + seg * segmentSpan;
+        const segEnd = bounds2.first + (seg + 1) * segmentSpan;
+        const points2 = [];
+        for (let i = 0; i <= samplesPerSegment; i++) {
+          const t = segStart + (segEnd - segStart) * i / samplesPerSegment;
+          const [u, v] = evaluateCurve2d(c, t);
+          points2.push(lift(u, v));
+        }
+        const coords = points2.flatMap(([px, py, pz]) => [px, py, pz]);
+        const degree = Math.min(3, points2.length - 1);
+        edgeIds.push(this.bk.interpolatePoints(coords, degree));
+      }
+      const wireId = this.bk.makeWire(edgeIds, false);
+      return wireHandle(wireId);
+    }
+    if (c.__bk2d === "bezier") {
+      const points3d = c.poles.map(([u, v]) => lift(u, v));
+      if (points3d.length === 2) return this.makeLineEdge(points3d[0], points3d[1]);
+      const degree = Math.min(3, points3d.length - 1);
+      const coords = points3d.flatMap(([px, py, pz]) => [px, py, pz]);
+      const id = this.bk.interpolatePoints(coords, degree);
+      return edgeHandle(id);
+    }
+    if (c.__bk2d === "bspline") {
+      const points3d = c.poles.map(([u, v]) => lift(u, v));
+      if (points3d.length === 2) return this.makeLineEdge(points3d[0], points3d[1]);
+      const degree = Math.min(3, points3d.length - 1);
+      const coords = points3d.flatMap(([px, py, pz]) => [px, py, pz]);
+      const id = this.bk.interpolatePoints(coords, degree);
+      return edgeHandle(id);
+    }
+    const bounds = curveBounds(c);
+    const nSamples = 100;
+    const points = [];
+    for (let i = 0; i <= nSamples; i++) {
+      const t = bounds.first + (bounds.last - bounds.first) * i / nSamples;
+      const [u, v] = evaluateCurve2d(c, t);
+      points.push(lift(u, v));
+    }
+    return this.interpolatePoints(points);
+  }
+  buildEdgeOnSurface(curve, surface) {
+    if (!isBrepkitHandle(surface))
+      throw new Error("brepkit: buildEdgeOnSurface requires a face handle as surface");
+    const fid = unwrap(surface, "face");
+    const c = this.c2d(curve);
+    const bounds = curveBounds(c);
+    const surfType = this.bk.getSurfaceType(fid);
+    const N = surfType === "plane" ? 50 : 100;
+    const points = [];
+    for (let i = 0; i <= N; i++) {
+      const t = bounds.first + (bounds.last - bounds.first) * i / N;
+      const [u, v] = evaluateCurve2d(c, t);
+      const p = this.bk.evaluateSurface(fid, u, v);
+      points.push([p[0], p[1], p[2]]);
+    }
+    return this.interpolatePoints(points);
+  }
+  extractSurfaceFromFace(face) {
+    return face;
+  }
+  extractCurve2dFromEdge(edge, face) {
+    const eid = unwrap(edge, "edge");
+    unwrap(face, "face");
+    const params = this.bk.getEdgeCurveParameters(eid);
+    const tMin = params[0] ?? 0;
+    const tMax = params[1] ?? 1;
+    const N = 40;
+    const uvPoints = [];
+    for (let i = 0; i <= N; i++) {
+      const t = tMin + (tMax - tMin) * i / N;
+      const pt = this.bk.evaluateEdgeCurve(eid, t);
+      uvPoints.push([pt[0], pt[1]]);
+    }
+    if (uvPoints.length >= 2) {
+      return this.makeBSpline2d(uvPoints);
+    }
+    const verts = this.bk.getEdgeVertices(eid);
+    return makeLine2d(verts[0], verts[1], verts[3], verts[4]);
+  }
+  buildCurves3d(_wire) {
+  }
+  fixWireOnFace(wire, _face, _tolerance) {
+    return wire;
+  }
+  fillSurface(wires, _options) {
+    if (wires.length >= 1) {
+      const wireEdges = this.iterShapes(wires[0], "edge");
+      if (wireEdges.length === 4) {
+        const allCoords = [];
+        const curveLengths = [];
+        for (const edge of wireEdges) {
+          const edgeId = unwrap(edge, "edge");
+          const params = this.bk.getEdgeCurveParameters(edgeId);
+          const tMin = params[0], tMax = params[1];
+          const N = 10;
+          const pts = [];
+          for (let i = 0; i <= N; i++) {
+            const t = tMin + (tMax - tMin) * i / N;
+            const p = this.bk.evaluateEdgeCurve(edgeId, t);
+            pts.push(p[0], p[1], p[2]);
+          }
+          allCoords.push(...pts);
+          curveLengths.push(N + 1);
+        }
+        try {
+          const faceId = this.bk.fillCoonsPatch(allCoords, curveLengths);
+          return faceHandle(faceId);
+        } catch (e) {
+          console.warn("brepkit: Coons patch failed, falling back:", e);
+        }
+      }
+    }
+    const outerWire = wires[0];
+    if (!outerWire) throw new Error("fillSurface: no wires provided");
+    return this.makeNonPlanarFace(outerWire);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Private helpers
+  // ═══════════════════════════════════════════════════════════════════════
+  applyMatrix(shape2, matrix) {
+    const h = shape2;
+    if (!isBrepkitHandle(shape2)) {
+      throw new Error("brepkit: applyMatrix requires a BrepkitHandle");
+    }
+    switch (h.type) {
+      case "solid": {
+        const copy = this.bk.copySolid(h.id);
+        this.bk.transformSolid(copy, matrix);
+        return solidHandle(copy);
+      }
+      case "face": {
+        if (typeof this.bk.copyFace !== "function" || typeof this.bk.transformFace !== "function") {
+          throw new Error(
+            "brepkit: applyMatrix for faces requires copyFace/transformFace WASM exports"
+          );
+        }
+        const copy = this.bk.copyFace(h.id);
+        this.bk.transformFace(copy, matrix);
+        return faceHandle(copy);
+      }
+      case "wire": {
+        if (typeof this.bk.copyWire !== "function" || typeof this.bk.transformWire !== "function") {
+          throw new Error(
+            "brepkit: applyMatrix for wires requires copyWire/transformWire WASM exports"
+          );
+        }
+        const copy = this.bk.copyWire(h.id);
+        this.bk.transformWire(copy, matrix);
+        return wireHandle(copy);
+      }
+      case "edge": {
+        if (typeof this.bk.copyEdge !== "function" || typeof this.bk.transformEdge !== "function") {
+          throw new Error(
+            "brepkit: applyMatrix for edges requires copyEdge/transformEdge WASM exports"
+          );
+        }
+        const copy = this.bk.copyEdge(h.id);
+        this.bk.transformEdge(copy, matrix);
+        return edgeHandle(copy);
+      }
+      default:
+        throw new Error(`brepkit: applyMatrix does not support '${h.type}' shapes`);
+    }
+  }
+  /** Check if we need to transform from default placement (origin, +Z). */
+  needsTransform(center, direction) {
+    if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) return true;
+    if (direction && (direction[0] !== 0 || direction[1] !== 0 || direction[2] !== 1)) return true;
+    return false;
+  }
+  /** Transform a shape from default placement (origin, +Z) to the given center and direction. */
+  transformToPlacement(shape2, center, direction) {
+    let result2 = shape2;
+    if (direction && (direction[0] !== 0 || direction[1] !== 0 || direction[2] !== 1)) {
+      const [dx, dy, dz] = direction;
+      const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      const nx = dx / len;
+      const ny = dy / len;
+      const nz = dz / len;
+      const dot = nz;
+      if (Math.abs(dot + 1) < 1e-10) {
+        result2 = this.rotate(result2, 180, [1, 0, 0]);
+      } else if (Math.abs(dot - 1) > 1e-10) {
+        const axis = [-ny, nx, 0];
+        const angleDeg = Math.acos(Math.max(-1, Math.min(1, dot))) * (180 / Math.PI);
+        result2 = this.rotate(result2, angleDeg, axis);
+      }
+    }
+    if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) {
+      result2 = this.translate(result2, center[0], center[1], center[2]);
+    }
+    return result2;
+  }
+  /** Tessellate a solid with per-face groups for brepjs mesh format. */
+  // TODO: Replace per-face tessellation loop with bk.tessellateSolidGrouped()
+  // for a single WASM call instead of N. Requires aligning the grouped output
+  // format with KernelMeshResult (faceGroups, index offsets). See brepkitWasmTypes.ts.
+  meshSolid(solidId, deflection) {
+    const faceIds = toArray(this.bk.getSolidFaces(solidId));
+    const allVertices = [];
+    const allNormals = [];
+    const allTriangles = [];
+    const allUVs = [];
+    const faceGroups = [];
+    let vertexOffset = 0;
+    for (const faceId of faceIds) {
+      try {
+        const faceMesh = this.bk.tessellateFace(faceId, deflection);
+        const positions = faceMesh.positions;
+        const normals = faceMesh.normals;
+        const indices = faceMesh.indices;
+        const vertCount = positions.length / 3;
+        if (vertCount === 0) continue;
+        const triStart = allTriangles.length;
+        for (const v of positions) allVertices.push(v);
+        for (const n of normals) allNormals.push(n);
+        for (const idx of indices) {
+          allTriangles.push(idx + vertexOffset);
+        }
+        for (let i = 0; i < vertCount; i++) {
+          allUVs.push(0, 0);
+        }
+        faceGroups.push({
+          start: triStart,
+          count: indices.length,
+          faceHash: faceId
+        });
+        vertexOffset += vertCount;
+      } catch (e) {
+        console.warn(`brepkit: face tessellation failed (faceId=${faceId}):`, e);
+      }
+    }
+    return {
+      vertices: new Float32Array(allVertices),
+      normals: new Float32Array(allNormals),
+      triangles: new Uint32Array(allTriangles),
+      uvs: new Float32Array(allUVs),
+      faceGroups
+    };
+  }
+  /** Tessellate a single face and return brepjs mesh format. */
+  meshSingleFace(faceId, deflection, faceHash) {
+    const faceMesh = this.bk.tessellateFace(faceId, deflection);
+    const positions = faceMesh.positions;
+    const normals = faceMesh.normals;
+    const indices = faceMesh.indices;
+    const vertCount = positions.length / 3;
+    const uvs = [];
+    for (let i = 0; i < vertCount; i++) {
+      uvs.push(0, 0);
+    }
+    return {
+      vertices: new Float32Array(positions),
+      normals: new Float32Array(normals),
+      triangles: new Uint32Array(indices),
+      uvs: new Float32Array(uvs),
+      faceGroups: [{ start: 0, count: indices.length, faceHash }]
+    };
+  }
+  /**
+   * Create a NURBS circle/arc edge in 3D.
+   *
+   * Uses the rational quadratic B-spline circle representation:
+   * 9-point circle for full 2π, fewer arcs for partial.
+   */
+  makeCircleNurbs(center, normal, radius, startAngle, endAngle) {
+    const len = Math.sqrt(normal[0] ** 2 + normal[1] ** 2 + normal[2] ** 2);
+    const nz = [normal[0] / len, normal[1] / len, normal[2] / len];
+    const ref = Math.abs(nz[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+    const xAxis = [
+      nz[1] * ref[2] - nz[2] * ref[1],
+      nz[2] * ref[0] - nz[0] * ref[2],
+      nz[0] * ref[1] - nz[1] * ref[0]
+    ];
+    const xLen = Math.sqrt(xAxis[0] ** 2 + xAxis[1] ** 2 + xAxis[2] ** 2);
+    xAxis[0] /= xLen;
+    xAxis[1] /= xLen;
+    xAxis[2] /= xLen;
+    const yAxis = [
+      nz[1] * xAxis[2] - nz[2] * xAxis[1],
+      nz[2] * xAxis[0] - nz[0] * xAxis[2],
+      nz[0] * xAxis[1] - nz[1] * xAxis[0]
+    ];
+    const nSegments = Math.ceil(Math.abs(endAngle - startAngle) / (Math.PI / 2));
+    const dAngle = (endAngle - startAngle) / nSegments;
+    const controlPoints = [];
+    const weights = [];
+    for (let i = 0; i <= nSegments; i++) {
+      const angle = startAngle + i * dAngle;
+      const cos = Math.cos(angle);
+      const sin = Math.sin(angle);
+      const px = center[0] + radius * (cos * xAxis[0] + sin * yAxis[0]);
+      const py = center[1] + radius * (cos * xAxis[1] + sin * yAxis[1]);
+      const pz = center[2] + radius * (cos * xAxis[2] + sin * yAxis[2]);
+      if (i > 0) {
+        const midAngle = startAngle + (i - 0.5) * dAngle;
+        const midCos = Math.cos(midAngle);
+        const midSin = Math.sin(midAngle);
+        const midR = radius / Math.cos(dAngle / 2);
+        const mx = center[0] + midR * (midCos * xAxis[0] + midSin * yAxis[0]);
+        const my = center[1] + midR * (midCos * xAxis[1] + midSin * yAxis[1]);
+        const mz = center[2] + midR * (midCos * xAxis[2] + midSin * yAxis[2]);
+        controlPoints.push(mx, my, mz);
+        weights.push(Math.cos(dAngle / 2));
+      }
+      controlPoints.push(px, py, pz);
+      weights.push(1);
+    }
+    const degree = 2;
+    const knots = Array(degree + 1).fill(0);
+    for (let i = 1; i < nSegments; i++) {
+      knots.push(i, i);
+    }
+    knots.push(...Array(degree + 1).fill(nSegments));
+    const kMax = knots[knots.length - 1];
+    for (let i = 0; i < knots.length; i++) {
+      knots[i] = knots[i] / kMax;
+    }
+    const startPt = controlPoints.slice(0, 3);
+    const endPt = controlPoints.slice(-3);
+    const id = this.bk.makeNurbsEdge(
+      startPt[0],
+      startPt[1],
+      startPt[2],
+      endPt[0],
+      endPt[1],
+      endPt[2],
+      degree,
+      knots,
+      controlPoints,
+      weights
+    );
+    return edgeHandle(id);
+  }
+  /**
+   * Extract NURBS curve data from an edge handle.
+   * Returns null for line edges (caller can build a linear NURBS).
+   * Returns {degree, knots, controlPoints, weights} for NURBS edges.
+   */
+  extractNurbsFromEdge(shape2) {
+    const h = shape2;
+    if (h.type !== "edge") return null;
+    const nurbsJson = this.bk.getEdgeNurbsData(h.id);
+    if (nurbsJson) {
+      const data = JSON.parse(nurbsJson);
+      return {
+        degree: data.degree,
+        knots: data.knots,
+        controlPoints: data.controlPoints,
+        weights: data.weights
+      };
+    }
+    const verts = this.bk.getEdgeVertices(h.id);
+    return {
+      degree: 1,
+      knots: [0, 0, 1, 1],
+      controlPoints: [verts[0], verts[1], verts[2], verts[3], verts[4], verts[5]],
+      weights: [1, 1]
+    };
+  }
+  /**
+   * Create a NURBS ellipse/ellipse-arc edge in 3D.
+   */
+  makeEllipseNurbs(center, normal, majorRadius, minorRadius, startAngle, endAngle, xDir) {
+    const len = Math.sqrt(normal[0] ** 2 + normal[1] ** 2 + normal[2] ** 2);
+    const nz = [normal[0] / len, normal[1] / len, normal[2] / len];
+    let xAxis;
+    if (xDir) {
+      const xl = Math.sqrt(xDir[0] ** 2 + xDir[1] ** 2 + xDir[2] ** 2);
+      xAxis = [xDir[0] / xl, xDir[1] / xl, xDir[2] / xl];
+    } else {
+      const ref = Math.abs(nz[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+      xAxis = [
+        nz[1] * ref[2] - nz[2] * ref[1],
+        nz[2] * ref[0] - nz[0] * ref[2],
+        nz[0] * ref[1] - nz[1] * ref[0]
+      ];
+      const xLen2 = Math.sqrt(xAxis[0] ** 2 + xAxis[1] ** 2 + xAxis[2] ** 2);
+      xAxis[0] /= xLen2;
+      xAxis[1] /= xLen2;
+      xAxis[2] /= xLen2;
+    }
+    const yAxis = [
+      nz[1] * xAxis[2] - nz[2] * xAxis[1],
+      nz[2] * xAxis[0] - nz[0] * xAxis[2],
+      nz[0] * xAxis[1] - nz[1] * xAxis[0]
+    ];
+    const nSegments = Math.ceil(Math.abs(endAngle - startAngle) / (Math.PI / 2));
+    const dAngle = (endAngle - startAngle) / nSegments;
+    const controlPoints = [];
+    const weights = [];
+    for (let i = 0; i <= nSegments; i++) {
+      const angle = startAngle + i * dAngle;
+      const cos = Math.cos(angle);
+      const sin = Math.sin(angle);
+      const px = center[0] + majorRadius * cos * xAxis[0] + minorRadius * sin * yAxis[0];
+      const py = center[1] + majorRadius * cos * xAxis[1] + minorRadius * sin * yAxis[1];
+      const pz = center[2] + majorRadius * cos * xAxis[2] + minorRadius * sin * yAxis[2];
+      if (i > 0) {
+        const midAngle = startAngle + (i - 0.5) * dAngle;
+        const midCos = Math.cos(midAngle);
+        const midSin = Math.sin(midAngle);
+        const scale2 = 1 / Math.cos(dAngle / 2);
+        const mx = center[0] + majorRadius * scale2 * midCos * xAxis[0] + minorRadius * scale2 * midSin * yAxis[0];
+        const my = center[1] + majorRadius * scale2 * midCos * xAxis[1] + minorRadius * scale2 * midSin * yAxis[1];
+        const mz = center[2] + majorRadius * scale2 * midCos * xAxis[2] + minorRadius * scale2 * midSin * yAxis[2];
+        controlPoints.push(mx, my, mz);
+        weights.push(Math.cos(dAngle / 2));
+      }
+      controlPoints.push(px, py, pz);
+      weights.push(1);
+    }
+    const degree = 2;
+    const knots = Array(degree + 1).fill(0);
+    for (let i = 1; i < nSegments; i++) {
+      knots.push(i, i);
+    }
+    knots.push(...Array(degree + 1).fill(nSegments));
+    const kMax = knots[knots.length - 1];
+    for (let i = 0; i < knots.length; i++) {
+      knots[i] = knots[i] / kMax;
+    }
+    const startPt = controlPoints.slice(0, 3);
+    const endPt = controlPoints.slice(-3);
+    const id = this.bk.makeNurbsEdge(
+      startPt[0],
+      startPt[1],
+      startPt[2],
+      endPt[0],
+      endPt[1],
+      endPt[2],
+      degree,
+      knots,
+      controlPoints,
+      weights
+    );
+    return edgeHandle(id);
+  }
+  /**
+   * Extract a plane definition (point + normal) from a face handle.
+   * Uses tessellation to find a concrete point on the face.
+   */
+  extractPlaneFromFace(faceShape) {
+    let faceId;
+    const h = faceShape;
+    if (h.type === "solid" || h.type === "compound") {
+      const faces = this.iterShapes(faceShape, "face");
+      if (faces.length === 0) throw new Error("brepkit: extractPlaneFromFace: no faces found");
+      const firstFace = faces[0];
+      if (!firstFace) throw new Error("brepkit: extractPlaneFromFace: no faces found");
+      let bestId = unwrap(firstFace, "face");
+      let bestArea = 0;
+      for (const f of faces) {
+        const id = unwrap(f, "face");
+        try {
+          const a = this.bk.faceArea(id, DEFAULT_DEFLECTION);
+          if (a > bestArea) {
+            bestArea = a;
+            bestId = id;
+          }
+        } catch {
+        }
+      }
+      faceId = bestId;
+    } else {
+      faceId = unwrap(faceShape, "face");
+    }
+    const n = this.bk.getFaceNormal(faceId);
+    const normal = [n[0], n[1], n[2]];
+    const mesh2 = this.bk.tessellateFace(faceId, 1);
+    const positions = mesh2.positions;
+    if (positions.length >= 3) {
+      return { point: [positions[0], positions[1], positions[2]], normal };
+    }
+    return { point: [0, 0, 0], normal };
+  }
+}
+function multiplyMatrices(a, b) {
+  const result2 = 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++) {
+        result2[i * 4 + j] = result2[i * 4 + j] + a[i * 4 + k] * b[k * 4 + j];
+      }
+    }
+  }
+  return result2;
+}
 const errorFactories = {
   KERNEL_OPERATION: (code, message, cause) => ({ kind: "KERNEL_OPERATION", code, message, cause }),
   VALIDATION: (code, message, cause) => ({ kind: "VALIDATION", code, message, cause }),
@@ -2987,6 +7192,7 @@ exports.pendingCount = worker.pendingCount;
 exports.registerHandler = worker.registerHandler;
 exports.rejectAll = worker.rejectAll;
 exports.BrepWrapperError = BrepWrapperError;
+exports.BrepkitAdapter = BrepkitAdapter;
 exports.addMate = addMate;
 exports.applyGlue = applyGlue;
 exports.applyMatrix = applyMatrix;