brepjs 12.2.3 → 12.2.5

package/dist/brepjs.js

@@ -43,49 +43,4254 @@ var __callDispose = (stack, error, hasError) => {
   };
   return next();
 };
-import { c as castShape, D as DisposalScope, B as getKernel, k as isFace, q as isShell, r as isSolid, p as isShape3D, F as createSolid, G as createWire, j as isEdge, u as isWire } from "./shapeTypes-Py3LEyDe.js";
-import { M, N, O, a, C, H, I, b, d, P, E, g, Q, i, e, f, h, l, m, n, o, s, t, v, w, R, x, S, y, z, A } from "./shapeTypes-Py3LEyDe.js";
-import { o as ok, z as translateKernelError, e as err, p as typeCastError, q as queryError, y as validationError, B as BrepErrorCode, k as kernelError, i as ioError, d as isErr, r as unwrap } from "./errors-B7kgv0cd.js";
+import { c as castShape, D as DisposalScope, B as getKernel, k as isFace, q as isShell, r as isSolid, p as isShape3D, F as createSolid, G as createWire, j as isEdge, u as isWire } from "./shapeTypes-ByN4-0Hp.js";
+import { M, N, O, a, C, H, I, b, d, P, E, g, Q, i, e, f, h, l, m, n, o, s, t, v, w, R, x, S, y, z, A } from "./shapeTypes-ByN4-0Hp.js";
+import { o as ok, z as translateKernelError, e as err, p as typeCastError, q as queryError, y as validationError, B as BrepErrorCode, k as kernelError, i as ioError, d as isErr, r as unwrap$1 } from "./errors-B7kgv0cd.js";
 import { O as O2, A as A2, a as a2, c, b as b2, f as f2, C as C2, g as g2, m as m2, h as h2, j, l as l2, D, E as E2, F, s as s2, G, H as H2, t as t2, n as n2, u, v as v2, w as w2, x as x2, I as I2 } from "./errors-B7kgv0cd.js";
 import { c as vecDistance, H as HASH_CODE_MAX, n as vecScale, j as vecNormalize, f as vecIsZero } from "./vecOps-ZDdZWbwT.js";
 import { D as D2, R as R2, v as v3, a as a3, b as b3, d as d2, e as e2, g as g3, h as h3, i as i2, k, l as l3, m as m3, o as o2 } from "./vecOps-ZDdZWbwT.js";
-import { B, d as d3, C as C3, t as t3 } from "./Blueprint-DQ18yiAI.js";
-import { b as b4, g as g4, r } from "./loft-BGHICbBS.js";
-import { w as walkAssembly, e as extrude$1, r as revolve$1, s as sweep, c as circularPattern, l as linearPattern } from "./operations-D3BtYsAB.js";
-import { a as a4, b as b5, d as d4, f as f3, g as g5, h as h4, i as i3, j as j2, k as k2, m as m4, n as n3, o as o3, p, q, t as t4, u as u2, v as v4, x as x3, y as y2, z as z2, A as A3, B as B2, C as C4, D as D3, E as E3, F as F2, G as G2 } from "./operations-D3BtYsAB.js";
-import { B as B3, a as a5, e as e3, C as C5, F as F3, S as S2, f as f4, l as l4, g as g6, n as n4, k as k3, q as q2, o as o4, p as p2, r as r2 } from "./boolean2D-Dq3HF-Pd.js";
+import { B, d as d3, C as C3, t as t3 } from "./Blueprint-DlfUXrh0.js";
+import { b as b4, g as g4, r } from "./loft-DTFP5fVL.js";
+import { w as walkAssembly, e as extrude$1, r as revolve$1, s as sweep, c as circularPattern, l as linearPattern } from "./operations-2LVG2jh1.js";
+import { a as a4, b as b5, d as d4, f as f3, g as g5, h as h4, i as i3, j as j2, k as k2, m as m4, n as n3, o as o3, p, q, t as t4, u as u2, v as v4, x as x3, y as y2, z as z2, A as A3, B as B2, C as C4, D as D3, E as E3, F as F2, G as G2 } from "./operations-2LVG2jh1.js";
+import { B as B3, a as a5, e as e3, C as C5, F as F3, S as S2, f as f4, l as l4, g as g6, n as n4, k as k3, q as q2, o as o4, p as p2, r as r2 } from "./boolean2D-COkYlAPe.js";
 import { createBlueprint, curve2dBoundingBox, curve2dDistanceFrom, curve2dFirstPoint, curve2dIsOnCurve, curve2dLastPoint, curve2dParameter, curve2dSplitAt, curve2dTangentAt, getBounds2D, getOrientation2D, isInside2D, mirror2D, reverseCurve, rotate2D, scale2D, sketch2DOnFace, sketch2DOnPlane, stretch2D, toSVGPathD, translate2D } from "./2d.js";
-import { l as createTypedFinder, m as faceFinder } from "./helpers-Vqsg_fss.js";
-import { g as g7 } from "./helpers-Vqsg_fss.js";
+import { l as createTypedFinder, m as faceFinder } from "./helpers-TIGqZBj7.js";
+import { g as g7 } from "./helpers-TIGqZBj7.js";
 import { blueprintToDXF, exportDXF, exportGlb, exportGltf, exportOBJ, exportThreeMF, importIGES, importSTEP, importSTL, importSVG, importSVGPathD } from "./io.js";
-import { C as C6, D as D4, a as a6, S as S3, b as b6, X, Y, c as c2, d as d5, e as e4, f as f5, Z, g as g8, h as h5, i as i4, j as j3, k as k4, l as l5, m as m5, n as n5, o as o5, p as p3, q as q3, r as r3, s as s3, t as t5, u as u3, v as v5, w as w3, x as x4, y as y3, z as z3, _, $, a0, a1, A as A4, a2 as a22, B as B4, E as E4, a3 as a32, F as F4, G as G3, H as H3, I as I3, J, K, L, M as M2, N as N2, O as O3, P as P2, Q as Q2, R as R3, T, U, a4 as a42, V, a5 as a52, a6 as a62, W } from "./drawFns-7fN_tn1I.js";
+import { C as C6, D as D4, a as a6, S as S3, b as b6, X, Y, c as c2, d as d5, e as e4, f as f5, Z, g as g8, h as h5, i as i4, j as j3, k as k4, l as l5, m as m5, n as n5, o as o5, p as p3, q as q3, r as r3, s as s3, t as t5, u as u3, v as v5, w as w3, x as x4, y as y3, z as z3, _, $, a0, a1, A as A4, a2 as a22, B as B4, E as E4, a3 as a32, F as F4, G as G3, H as H3, I as I3, J, K, L, M as M2, N as N2, O as O3, P as P2, Q as Q2, R as R3, T, U, a4 as a42, V, a5 as a52, a6 as a62, W } from "./drawFns-DsB3t0zE.js";
 import { a as toVec3 } from "./types-CWDdqcrq.js";
 import { r as r4, t as t6 } from "./types-CWDdqcrq.js";
 import { c as c3, a as a7, p as p4, r as r5, t as t7 } from "./vectors-cec8p8NQ.js";
-import { v as vertexPosition, a as getFaces, e as getVertices, d as getEdges, h as getBounds, p as propagateOriginsFromEvolution, g as getFaceOrigins, j as applyMatrix$1, k as clone$1, l as describe$1, m as isEmpty$1, n as mirror$1, r as rotate$1, s as scale$1, o as simplify$1, t as toBREP$1, q as transformCopy$1, u as translate$1, c as getWires } from "./shapeFns-smSl7yhL.js";
-import { w as w4, f as f6, x as x5, i as i5, y as y4, z as z4, A as A5, B as B5, C as C7, D as D5 } from "./shapeFns-smSl7yhL.js";
-import { p as propagateFaceTagsFromEvolution, a as propagateColorsFromEvolution, h as hasFaceTags, b as hasColorMetadata, c as cut$1, f as fuse$1, i as intersect$1, s as section$1, d as sectionToFace$1, e as slice$1, g as split$1, j as fuseAll, k as cutAll } from "./booleanFns-DdU6eLxI.js";
-import { l as l6, m as m6, n as n6, o as o6, q as q4, r as r6, t as t8, u as u4, v as v6 } from "./booleanFns-DdU6eLxI.js";
-import { c as chamferDistAngle, h as heal$1, i as isValid$1 } from "./topology-DmQY6469.js";
-import { a as a8, b as b7, d as d6, e as e5, f as f7, g as g9, j as j4, k as k5, l as l7, m as m7, n as n7, o as o7, p as p5, q as q5, r as r7, s as s4, t as t9, u as u5, v as v7, w as w5, x as x6, y as y5, z as z5, A as A6, B as B6, C as C8, D as D6, E as E5, F as F5, G as G4, H as H4, I as I4, J as J2, K as K2, L as L2, M as M3, N as N3, O as O4, P as P3, Q as Q3 } from "./topology-DmQY6469.js";
-import { e as curveIsClosed, d as curveStartPoint, c as curveTangentAt, h as curvePointAt, a as curveEndPoint, i as curveLength } from "./curveFns-GOcBuoCc.js";
-import { j as j5, k as k6, l as l8, f as f8, b as b8, g as g10, m as m8, o as o8 } from "./curveFns-GOcBuoCc.js";
-import { i as iterTopo, e as faceCenter, n as normalAt, j as fromBREP$1, k as innerWires, o as outerWire, g as getSurfaceType } from "./faceFns-g5hzl_xe.js";
-import { l as l9, c as c4, m as m9, d as d7, f as f9, q as q6, r as r8, s as s5, p as p6, t as t10, v as v8, u as u6, h as h6 } from "./faceFns-g5hzl_xe.js";
-import { m as mesh$1, a as meshEdges$1 } from "./meshFns-bHjCcOZp.js";
-import { c as c5, b as b9, e as e6, d as d8, f as f10 } from "./meshFns-bHjCcOZp.js";
-import { m as measureArea, a as measureSurfaceProps, b as measureVolumeProps, c as measureVolume } from "./measurement-Ce4oE8Fg.js";
-import { d as d9, e as e7, f as f11, g as g11, h as h7, i as i6 } from "./measurement-Ce4oE8Fg.js";
-import { m as makeFace } from "./surfaceBuilders-CD_9kc1m.js";
-import { n as n8 } from "./surfaceBuilders-CD_9kc1m.js";
+import { v as vertexPosition, a as getFaces, e as getVertices, d as getEdges, h as getBounds, p as propagateOriginsFromEvolution, g as getFaceOrigins, j as applyMatrix$1, k as clone$1, l as describe$1, m as isEmpty$1, n as mirror$1, r as rotate$1, s as scale$1, o as simplify$1, t as toBREP$1, q as transformCopy$1, u as translate$1, c as getWires } from "./shapeFns-BP-fxfKw.js";
+import { w as w4, f as f6, x as x5, i as i5, y as y4, z as z4, A as A5, B as B5, C as C7, D as D5 } from "./shapeFns-BP-fxfKw.js";
+import { p as propagateFaceTagsFromEvolution, a as propagateColorsFromEvolution, h as hasFaceTags, b as hasColorMetadata, c as cut$1, f as fuse$1, i as intersect$1, s as section$1, d as sectionToFace$1, e as slice$1, g as split$1, j as fuseAll, k as cutAll } from "./booleanFns-5MroD4TZ.js";
+import { l as l6, m as m6, n as n6, o as o6, q as q4, r as r6, t as t8, u as u4, v as v6 } from "./booleanFns-5MroD4TZ.js";
+import { c as chamferDistAngle, h as heal$1, i as isValid$1 } from "./topology-CqhGW5sd.js";
+import { a as a8, b as b7, d as d6, e as e5, f as f7, g as g9, j as j4, k as k5, l as l7, m as m7, n as n7, o as o7, p as p5, q as q5, r as r7, s as s4, t as t9, u as u5, v as v7, w as w5, x as x6, y as y5, z as z5, A as A6, B as B6, C as C8, D as D6, E as E5, F as F5, G as G4, H as H4, I as I4, J as J2, K as K2, L as L2, M as M3, N as N3, O as O4, P as P3, Q as Q3 } from "./topology-CqhGW5sd.js";
+import { e as curveIsClosed, d as curveStartPoint, c as curveTangentAt, h as curvePointAt, a as curveEndPoint, i as curveLength } from "./curveFns-DRb_8jyd.js";
+import { j as j5, k as k6, l as l8, f as f8, b as b8, g as g10, m as m8, o as o8 } from "./curveFns-DRb_8jyd.js";
+import { i as iterTopo, e as faceCenter, n as normalAt, j as fromBREP$1, k as innerWires, o as outerWire, g as getSurfaceType } from "./faceFns-Dka8xvYk.js";
+import { l as l9, c as c4, m as m9, d as d7, f as f9, q as q6, r as r8, s as s5, p as p6, t as t10, v as v8, u as u6, h as h6 } from "./faceFns-Dka8xvYk.js";
+import { m as mesh$1, a as meshEdges$1 } from "./meshFns-B_yFbSte.js";
+import { c as c5, b as b9, e as e6, d as d8, f as f10 } from "./meshFns-B_yFbSte.js";
+import { m as measureArea, a as measureSurfaceProps, b as measureVolumeProps, c as measureVolume } from "./measurement-9v764TRE.js";
+import { d as d9, e as e7, f as f11, g as g11, h as h7, i as i6 } from "./measurement-9v764TRE.js";
+import { m as makeFace } from "./surfaceBuilders-Bdn7iqv5.js";
+import { n as n8 } from "./surfaceBuilders-Bdn7iqv5.js";
 import { edgeFinder } from "./query.js";
-import { c as makeCylinder } from "./solidBuilders-Jh5Bnm02.js";
+import { c as makeCylinder } from "./solidBuilders-Bc6kgqJ9.js";
 import { BrepBugError, bug } from "./result.js";
-import { c as c6 } from "./cornerFinder-Dv3C7Yen.js";
+import { c as c6 } from "./cornerFinder-CGzCuJy3.js";
 import { createOperationRegistry, createTaskQueue, createWorkerClient, createWorkerHandler, dequeueTask, enqueueTask, isDisposeRequest, isErrorResponse, isInitRequest, isOperationRequest, isQueueEmpty, isSuccessResponse, pendingCount, registerHandler, rejectAll } from "./worker.js";
 function supportsProjection(kernel) {
   return "projectShape" in kernel;
 }
+function evaluateCurve2d(c7, t11) {
+  switch (c7.__bk2d) {
+    case "line":
+      return [c7.ox + c7.dx * t11, c7.oy + c7.dy * t11];
+    case "circle": {
+      const angle = c7.sense ? t11 : -t11;
+      return [c7.cx + c7.radius * Math.cos(angle), c7.cy + c7.radius * Math.sin(angle)];
+    }
+    case "ellipse": {
+      const angle = c7.sense ? t11 : -t11;
+      const cos = Math.cos(c7.xDirAngle);
+      const sin = Math.sin(c7.xDirAngle);
+      const x7 = c7.majorRadius * Math.cos(angle);
+      const y6 = c7.minorRadius * Math.sin(angle);
+      return [c7.cx + x7 * cos - y6 * sin, c7.cy + x7 * sin + y6 * cos];
+    }
+    case "bezier":
+      return evaluateBezier(c7.poles, t11);
+    case "bspline":
+      return evaluateBSpline2d(c7, t11);
+    case "trimmed": {
+      const mapped = c7.tStart + t11 * (c7.tEnd - c7.tStart);
+      return evaluateCurve2d(c7.basis, mapped);
+    }
+  }
+}
+function tangentCurve2d(c7, t11) {
+  switch (c7.__bk2d) {
+    case "line":
+      return [c7.dx, c7.dy];
+    case "circle": {
+      const angle = c7.sense ? t11 : -t11;
+      const sign = c7.sense ? 1 : -1;
+      return [-c7.radius * Math.sin(angle) * sign, c7.radius * Math.cos(angle) * sign];
+    }
+    case "ellipse": {
+      const angle = c7.sense ? t11 : -t11;
+      const sign = c7.sense ? 1 : -1;
+      const cos = Math.cos(c7.xDirAngle);
+      const sin = Math.sin(c7.xDirAngle);
+      const dx = -c7.majorRadius * Math.sin(angle) * sign;
+      const dy = c7.minorRadius * Math.cos(angle) * sign;
+      return [dx * cos - dy * sin, dx * sin + dy * cos];
+    }
+    case "bezier": {
+      const h8 = 1e-8;
+      const p0 = evaluateBezier(c7.poles, Math.max(0, t11 - h8));
+      const p1 = evaluateBezier(c7.poles, Math.min(1, t11 + h8));
+      const dt = Math.min(1, t11 + h8) - Math.max(0, t11 - h8);
+      return [(p1[0] - p0[0]) / dt, (p1[1] - p0[1]) / dt];
+    }
+    case "bspline": {
+      const h8 = 1e-8;
+      const kFirst = c7.knots[0];
+      const kLast = c7.knots[c7.knots.length - 1];
+      const p0 = evaluateBSpline2d(c7, Math.max(kFirst, t11 - h8));
+      const p1 = evaluateBSpline2d(c7, Math.min(kLast, t11 + h8));
+      const dt = Math.min(kLast, t11 + h8) - Math.max(kFirst, t11 - h8);
+      return [(p1[0] - p0[0]) / dt, (p1[1] - p0[1]) / dt];
+    }
+    case "trimmed": {
+      const mapped = c7.tStart + t11 * (c7.tEnd - c7.tStart);
+      const tan = tangentCurve2d(c7.basis, mapped);
+      const scale2 = c7.tEnd - c7.tStart;
+      return [tan[0] * scale2, tan[1] * scale2];
+    }
+  }
+}
+function curveBounds(c7) {
+  switch (c7.__bk2d) {
+    case "line":
+      return { first: 0, last: c7.len };
+    case "circle":
+    case "ellipse":
+      return { first: 0, last: 2 * Math.PI };
+    case "bezier":
+      return { first: 0, last: 1 };
+    case "bspline":
+      return { first: c7.knots[0], last: c7.knots[c7.knots.length - 1] };
+    case "trimmed":
+      return { first: 0, last: 1 };
+  }
+}
+function curveTypeName(c7) {
+  switch (c7.__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(c7.basis);
+  }
+}
+function makeLine2d(x1, y1, x22, y22) {
+  const dx = x22 - x1;
+  const dy = y22 - 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(c7, dx, dy) {
+  switch (c7.__bk2d) {
+    case "line":
+      return { ...c7, ox: c7.ox + dx, oy: c7.oy + dy };
+    case "circle":
+      return { ...c7, cx: c7.cx + dx, cy: c7.cy + dy };
+    case "ellipse":
+      return { ...c7, cx: c7.cx + dx, cy: c7.cy + dy };
+    case "bezier":
+      return { ...c7, poles: c7.poles.map(([x7, y6]) => [x7 + dx, y6 + dy]) };
+    case "bspline":
+      return { ...c7, poles: c7.poles.map(([x7, y6]) => [x7 + dx, y6 + dy]) };
+    case "trimmed":
+      return { ...c7, basis: translateCurve2d(c7.basis, dx, dy) };
+  }
+}
+function rotateCurve2d(c7, angle, cx, cy) {
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  const rotatePoint = (x7, y6) => {
+    const rx = x7 - cx;
+    const ry = y6 - cy;
+    return [cx + rx * cos - ry * sin, cy + rx * sin + ry * cos];
+  };
+  switch (c7.__bk2d) {
+    case "line": {
+      const [ox, oy] = rotatePoint(c7.ox, c7.oy);
+      const ndx = c7.dx * cos - c7.dy * sin;
+      const ndy = c7.dx * sin + c7.dy * cos;
+      return { ...c7, ox, oy, dx: ndx, dy: ndy };
+    }
+    case "circle": {
+      const [ncx, ncy] = rotatePoint(c7.cx, c7.cy);
+      return { ...c7, cx: ncx, cy: ncy };
+    }
+    case "ellipse": {
+      const [ncx, ncy] = rotatePoint(c7.cx, c7.cy);
+      return { ...c7, cx: ncx, cy: ncy, xDirAngle: c7.xDirAngle + angle };
+    }
+    case "bezier":
+      return { ...c7, poles: c7.poles.map(([x7, y6]) => rotatePoint(x7, y6)) };
+    case "bspline":
+      return { ...c7, poles: c7.poles.map(([x7, y6]) => rotatePoint(x7, y6)) };
+    case "trimmed":
+      return { ...c7, basis: rotateCurve2d(c7.basis, angle, cx, cy) };
+  }
+}
+function scaleCurve2d(c7, factor, cx, cy) {
+  const scalePoint = (x7, y6) => [
+    cx + (x7 - cx) * factor,
+    cy + (y6 - cy) * factor
+  ];
+  switch (c7.__bk2d) {
+    case "line": {
+      const [ox, oy] = scalePoint(c7.ox, c7.oy);
+      return { ...c7, ox, oy };
+    }
+    case "circle": {
+      const [ncx, ncy] = scalePoint(c7.cx, c7.cy);
+      return { ...c7, cx: ncx, cy: ncy, radius: c7.radius * Math.abs(factor) };
+    }
+    case "ellipse": {
+      const [ncx, ncy] = scalePoint(c7.cx, c7.cy);
+      return {
+        ...c7,
+        cx: ncx,
+        cy: ncy,
+        majorRadius: c7.majorRadius * Math.abs(factor),
+        minorRadius: c7.minorRadius * Math.abs(factor)
+      };
+    }
+    case "bezier":
+      return { ...c7, poles: c7.poles.map(([x7, y6]) => scalePoint(x7, y6)) };
+    case "bspline":
+      return { ...c7, poles: c7.poles.map(([x7, y6]) => scalePoint(x7, y6)) };
+    case "trimmed":
+      return { ...c7, basis: scaleCurve2d(c7.basis, factor, cx, cy) };
+  }
+}
+function mirrorAtPoint(c7, cx, cy) {
+  return scaleCurve2d(c7, -1, cx, cy);
+}
+function mirrorAcrossAxis(c7, ox, oy, dx, dy) {
+  const len = Math.sqrt(dx * dx + dy * dy);
+  const nx = dx / len;
+  const ny = dy / len;
+  const reflectPoint = (x7, y6) => {
+    const rx = x7 - ox;
+    const ry = y6 - oy;
+    const dot = rx * nx + ry * ny;
+    return [ox + 2 * dot * nx - rx, oy + 2 * dot * ny - ry];
+  };
+  switch (c7.__bk2d) {
+    case "line": {
+      const [nox, noy] = reflectPoint(c7.ox, c7.oy);
+      const ndx = 2 * (c7.dx * nx + c7.dy * ny) * nx - c7.dx;
+      const ndy = 2 * (c7.dx * nx + c7.dy * ny) * ny - c7.dy;
+      return { ...c7, ox: nox, oy: noy, dx: ndx, dy: ndy };
+    }
+    case "circle": {
+      const [ncx, ncy] = reflectPoint(c7.cx, c7.cy);
+      return { ...c7, cx: ncx, cy: ncy, sense: !c7.sense };
+    }
+    case "ellipse": {
+      const [ncx, ncy] = reflectPoint(c7.cx, c7.cy);
+      const cos2 = nx * nx - ny * ny;
+      const sin2 = 2 * nx * ny;
+      const newAngle = Math.atan2(
+        sin2 * Math.cos(c7.xDirAngle) - cos2 * Math.sin(c7.xDirAngle),
+        cos2 * Math.cos(c7.xDirAngle) + sin2 * Math.sin(c7.xDirAngle)
+      );
+      return { ...c7, cx: ncx, cy: ncy, xDirAngle: newAngle, sense: !c7.sense };
+    }
+    case "bezier":
+      return { ...c7, poles: c7.poles.map(([x7, y6]) => reflectPoint(x7, y6)) };
+    case "bspline":
+      return { ...c7, poles: c7.poles.map(([x7, y6]) => reflectPoint(x7, y6)) };
+    case "trimmed":
+      return { ...c7, basis: mirrorAcrossAxis(c7.basis, ox, oy, dx, dy) };
+  }
+}
+function intersectCurves2dFn(c1, c22, tolerance) {
+  const b1 = unwrapCurve(c1);
+  const b22 = unwrapCurve(c22);
+  if (b1.__bk2d === "line" && b22.__bk2d === "line") {
+    return intersectLineLine(c1, b1, c22, b22, tolerance);
+  }
+  if (b1.__bk2d === "line" && b22.__bk2d === "circle") {
+    return { points: intersectLineCircle(c1, b1, c22, b22, tolerance), segments: [] };
+  }
+  if (b1.__bk2d === "circle" && b22.__bk2d === "line") {
+    return { points: intersectLineCircle(c22, b22, c1, b1, tolerance), segments: [] };
+  }
+  if (b1.__bk2d === "circle" && b22.__bk2d === "circle") {
+    return { points: intersectCircleCircle(c1, b1, c22, b22, tolerance), segments: [] };
+  }
+  const isSelf = c1 === c22;
+  return numericalIntersect(c1, c22, tolerance, isSelf);
+}
+function unwrapCurve(c7) {
+  let cur = c7;
+  while (cur.__bk2d === "trimmed") cur = cur.basis;
+  return cur;
+}
+function inDomain(c7, t11, tol) {
+  const b10 = curveBounds(c7);
+  return t11 >= b10.first - tol && t11 <= b10.last + tol;
+}
+function refineParam(c7, px, py) {
+  const bounds = curveBounds(c7);
+  if (!isFinite(bounds.first) || !isFinite(bounds.last)) return null;
+  const N4 = 80;
+  const dt = (bounds.last - bounds.first) / N4;
+  let bestT = bounds.first;
+  let bestD = Infinity;
+  for (let i7 = 0; i7 <= N4; i7++) {
+    const t11 = bounds.first + i7 * dt;
+    const [ex2, ey2] = evaluateCurve2d(c7, t11);
+    const d10 = (ex2 - px) ** 2 + (ey2 - py) ** 2;
+    if (d10 < bestD) {
+      bestD = d10;
+      bestT = t11;
+    }
+  }
+  const [sx, sy] = evaluateCurve2d(c7, bounds.first);
+  const [ex, ey] = evaluateCurve2d(c7, bounds.last);
+  const [mx, my] = evaluateCurve2d(c7, (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, c22, l22, tol) {
+  const det = l1.dx * l22.dy - l1.dy * l22.dx;
+  if (Math.abs(det) >= 1e-14) {
+    const ex3 = l22.ox - l1.ox;
+    const ey3 = l22.oy - l1.oy;
+    const t1 = (ex3 * l22.dy - ey3 * l22.dx) / det;
+    const t22 = (ex3 * l1.dy - ey3 * l1.dx) / det;
+    if (!inDomain(c1, t1, tol) || !inDomain(c22, t22, tol)) return { points: [], segments: [] };
+    return { points: [[l1.ox + t1 * l1.dx, l1.oy + t1 * l1.dy]], segments: [] };
+  }
+  const ex = l22.ox - l1.ox;
+  const ey = l22.oy - l1.oy;
+  const cross = ex * l1.dy - ey * l1.dx;
+  if (Math.abs(cross) > tol) return { points: [], segments: [] };
+  const b1 = curveBounds(c1);
+  const b22 = curveBounds(c22);
+  const p2s = evaluateCurve2d(c22, b22.first);
+  const p2e = evaluateCurve2d(c22, b22.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 a9 = line.dx * line.dx + line.dy * line.dy;
+  const b10 = 2 * (fx * line.dx + fy * line.dy);
+  const c7 = fx * fx + fy * fy - circ.radius * circ.radius;
+  const disc = b10 * b10 - 4 * a9 * c7;
+  if (disc < -tol) return [];
+  const results = [];
+  const sqrtDisc = Math.sqrt(Math.max(0, disc));
+  const t1 = (-b10 - sqrtDisc) / (2 * a9);
+  const t22 = (-b10 + sqrtDisc) / (2 * a9);
+  for (const tLine of disc < tol * tol ? [t1] : [t1, t22]) {
+    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, c22, circ2, tol) {
+  const dx = circ2.cx - circ1.cx;
+  const dy = circ2.cy - circ1.cy;
+  const d10 = Math.sqrt(dx * dx + dy * dy);
+  if (d10 > circ1.radius + circ2.radius + tol) return [];
+  if (d10 < Math.abs(circ1.radius - circ2.radius) - tol) return [];
+  if (d10 < 1e-14) return [];
+  const a9 = (circ1.radius * circ1.radius - circ2.radius * circ2.radius + d10 * d10) / (2 * d10);
+  const h22 = circ1.radius * circ1.radius - a9 * a9;
+  const h8 = Math.sqrt(Math.max(0, h22));
+  const mx = circ1.cx + a9 * dx / d10;
+  const my = circ1.cy + a9 * dy / d10;
+  const candidates = h8 < tol ? [[mx, my]] : [
+    [mx + h8 * dy / d10, my - h8 * dx / d10],
+    [mx - h8 * dy / d10, my + h8 * dx / d10]
+  ];
+  const results = [];
+  for (const [px, py] of candidates) {
+    const t1 = refineParam(c1, px, py);
+    const t22 = refineParam(c22, px, py);
+    if (t1 === null || t22 === null) continue;
+    const [x1, y1] = evaluateCurve2d(c1, t1);
+    const [x22, y22] = evaluateCurve2d(c22, t22);
+    const tolSq = (tol * 10) ** 2;
+    if ((x1 - px) ** 2 + (y1 - py) ** 2 > tolSq) continue;
+    if ((x22 - px) ** 2 + (y22 - py) ** 2 > tolSq) continue;
+    results.push([px, py]);
+  }
+  return results;
+}
+function numericalIntersect(c1, c22, tolerance, isSelf = false) {
+  const b1 = curveBounds(c1);
+  const b22 = curveBounds(c22);
+  if (!isFinite(b1.first) || !isFinite(b1.last) || !isFinite(b22.first) || !isFinite(b22.last)) {
+    return { points: [], segments: [] };
+  }
+  const N4 = 100;
+  const pts1 = [];
+  const pts2 = [];
+  for (let i7 = 0; i7 <= N4; i7++) {
+    const t1 = b1.first + (b1.last - b1.first) * i7 / N4;
+    const [x1, y1] = evaluateCurve2d(c1, t1);
+    pts1.push({ t: t1, x: x1, y: y1 });
+    const t22 = b22.first + (b22.last - b22.first) * i7 / N4;
+    const [x22, y22] = evaluateCurve2d(c22, t22);
+    pts2.push({ t: t22, x: x22, y: y22 });
+  }
+  const crossTol = Math.max(tolerance * 100, 0.5);
+  const candidates = [];
+  for (let i7 = 0; i7 < N4; i7++) {
+    const p1a = pts1[i7];
+    const p1b = pts1[i7 + 1];
+    for (let j6 = 0; j6 < N4; j6++) {
+      const p2a = pts2[j6];
+      const p2b = pts2[j6 + 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 t22 = t2Init;
+    for (let iter = 0; iter < 20; iter++) {
+      const [x12, y12] = evaluateCurve2d(c1, t1);
+      const [x222, y222] = evaluateCurve2d(c22, t22);
+      const dx = x12 - x222;
+      const dy = y12 - y222;
+      if (dx * dx + dy * dy < tol2) break;
+      const d1 = tangentCurve2d(c1, t1);
+      const d22 = tangentCurve2d(c22, t22);
+      const det = d1[0] * -d22[1] - -d22[0] * d1[1];
+      if (Math.abs(det) < 1e-14) break;
+      const dt1 = (-dx * -d22[1] - -dy * -d22[0]) / det;
+      const dt2 = (d1[0] * -dy - d1[1] * -dx) / det;
+      t1 += dt1;
+      t22 += dt2;
+      t1 = Math.max(b1.first, Math.min(b1.last, t1));
+      t22 = Math.max(b22.first, Math.min(b22.last, t22));
+    }
+    const [x1, y1] = evaluateCurve2d(c1, t1);
+    const [x22, y22] = evaluateCurve2d(c22, t22);
+    if (isSelf && Math.abs(t1 - t22) < (b1.last - b1.first) * 0.05) continue;
+    if ((x1 - x22) ** 2 + (y1 - y22) ** 2 < tolerance * tolerance * 1e6) {
+      const px = (x1 + x22) / 2;
+      const py = (y1 + y22) / 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(c7) {
+  return JSON.stringify(c7);
+}
+function deserializeCurve2d(data) {
+  return JSON.parse(data);
+}
+function createBBox2d() {
+  return { __bk2d_bbox: true, xMin: Infinity, yMin: Infinity, xMax: -Infinity, yMax: -Infinity };
+}
+function addCurveToBBox(bbox, c7, _tol) {
+  const bounds = curveBounds(c7);
+  if (!isFinite(bounds.first) || !isFinite(bounds.last)) return;
+  const nSamples = 20;
+  const dt = (bounds.last - bounds.first) / nSamples;
+  for (let i7 = 0; i7 <= nSamples; i7++) {
+    const t11 = bounds.first + i7 * dt;
+    const [x7, y6] = evaluateCurve2d(c7, t11);
+    if (x7 < bbox.xMin) bbox.xMin = x7;
+    if (y6 < bbox.yMin) bbox.yMin = y6;
+    if (x7 > bbox.xMax) bbox.xMax = x7;
+    if (y6 > bbox.yMax) bbox.yMax = y6;
+  }
+}
+function evaluateBezier(poles, t11) {
+  const n9 = poles.length;
+  const work = poles.map(([x7, y6]) => [x7, y6]);
+  for (let r9 = 1; r9 < n9; r9++) {
+    for (let i7 = 0; i7 < n9 - r9; i7++) {
+      const wi = work[i7];
+      const wi1 = work[i7 + 1];
+      wi[0] = (1 - t11) * wi[0] + t11 * wi1[0];
+      wi[1] = (1 - t11) * wi[1] + t11 * wi1[1];
+    }
+  }
+  return work[0];
+}
+function evaluateBSpline2d(c7, t11) {
+  const fullKnots = [];
+  for (let i7 = 0; i7 < c7.knots.length; i7++) {
+    const mult = c7.multiplicities[i7] ?? 1;
+    for (let j6 = 0; j6 < mult; j6++) {
+      fullKnots.push(c7.knots[i7]);
+    }
+  }
+  const p7 = c7.degree;
+  const n9 = c7.poles.length;
+  const k7 = fullKnots.length;
+  const tClamped = Math.max(fullKnots[p7], Math.min(fullKnots[k7 - p7 - 1], t11));
+  let span = p7;
+  for (let i7 = p7; i7 < k7 - p7 - 1; i7++) {
+    if (tClamped >= fullKnots[i7] && tClamped < fullKnots[i7 + 1]) {
+      span = i7;
+      break;
+    }
+  }
+  if (tClamped >= fullKnots[k7 - p7 - 1]) span = k7 - p7 - 2;
+  const d10 = [];
+  for (let j6 = 0; j6 <= p7; j6++) {
+    const idx = Math.min(span - p7 + j6, n9 - 1);
+    const pole = c7.poles[Math.max(0, idx)];
+    d10.push([pole[0], pole[1]]);
+  }
+  for (let r9 = 1; r9 <= p7; r9++) {
+    for (let j6 = p7; j6 >= r9; j6--) {
+      const i7 = span - p7 + j6;
+      const left = fullKnots[i7] ?? 0;
+      const right = fullKnots[i7 + p7 - r9 + 1] ?? 1;
+      const denom = right - left;
+      const alpha = denom > 1e-15 ? (tClamped - left) / denom : 0;
+      const dj = d10[j6];
+      const djPrev = d10[j6 - 1];
+      dj[0] = (1 - alpha) * djPrev[0] + alpha * dj[0];
+      dj[1] = (1 - alpha) * djPrev[1] + alpha * dj[1];
+    }
+  }
+  return d10[p7];
+}
+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 h8 = handle("compound", id);
+  if (syntheticCompounds.has(id)) {
+    return { ...h8, delete: () => syntheticCompounds.delete(id) };
+  }
+  return h8;
+}
+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, x22, y22, z22) {
+  const dx = x1 - x22, dy = y1 - y22, dz = z1 - z22;
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+function translationMatrix(x7, y6, z6) {
+  return [
+    1,
+    0,
+    0,
+    x7,
+    0,
+    1,
+    0,
+    y6,
+    0,
+    0,
+    1,
+    z6,
+    0,
+    0,
+    0,
+    1
+  ];
+}
+function rotationMatrix(angleDeg, axis = [0, 0, 1], center = [0, 0, 0]) {
+  const rad = angleDeg * Math.PI / 180;
+  const c7 = Math.cos(rad);
+  const s6 = Math.sin(rad);
+  const t11 = 1 - c7;
+  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 = t11 * ux * ux + c7;
+  const r01 = t11 * ux * uy - s6 * uz;
+  const r02 = t11 * ux * uz + s6 * uy;
+  const r10 = t11 * uy * ux + s6 * uz;
+  const r11 = t11 * uy * uy + c7;
+  const r12 = t11 * uy * uz - s6 * ux;
+  const r20 = t11 * uz * ux - s6 * uy;
+  const r21 = t11 * uz * uy + s6 * ux;
+  const r22 = t11 * uz * uz + c7;
+  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 d10 = 2 * (ox * nx + oy * ny + oz * nz);
+  return [
+    1 - 2 * nx * nx,
+    -2 * nx * ny,
+    -2 * nx * nz,
+    d10 * nx,
+    -2 * ny * nx,
+    1 - 2 * ny * ny,
+    -2 * ny * nz,
+    d10 * ny,
+    -2 * nz * nx,
+    -2 * nz * ny,
+    1 - 2 * nz * nz,
+    d10 * 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 result = this.bk.fuse(baseId, unwrapSolidOrThrow(tool, "fuse"));
+    return solidHandle(result);
+  }
+  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 result = this.bk.cut(baseId, unwrapSolidOrThrow(tool, "cut"));
+    return solidHandle(result);
+  }
+  intersect(shape2, tool, _options) {
+    if (_options && hasBooleanOptions(_options)) {
+      warnOnce(
+        "boolean-options",
+        "BooleanOptions (optimisation, simplify, strategy, fuzzyValue) not supported; ignored."
+      );
+    }
+    const result = this.bk.intersect(
+      unwrapSolidOrThrow(shape2, "intersect"),
+      unwrapSolidOrThrow(tool, "intersect")
+    );
+    return solidHandle(result);
+  }
+  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 i7 = 0; i7 < current.length; i7 += 2) {
+        if (i7 + 1 < current.length) {
+          next.push(this.fuse(current[i7], current[i7 + 1], options));
+        } else {
+          next.push(current[i7]);
+        }
+      }
+      current = next;
+    }
+    return current[0];
+  }
+  cutAll(shape2, tools, options) {
+    let result = shape2;
+    for (const tool of tools) {
+      result = this.cut(result, tool, options);
+    }
+    return result;
+  }
+  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 result = toArray(
+      this.bk.split(
+        unwrap(shape2, "solid"),
+        point[0],
+        point[1],
+        point[2],
+        normal[0],
+        normal[1],
+        normal[2]
+      )
+    );
+    return compoundHandle(this.bk.makeCompound(result));
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Convex hull (not yet implemented)
+  // ═══════════════════════════════════════════════════════════════════════
+  hull(shapes, _tolerance) {
+    const coords = [];
+    for (const shape2 of shapes) {
+      const h8 = shape2;
+      if (h8.type === "solid") {
+        const vertIds = toArray(this.bk.getSolidVertices(h8.id));
+        for (const vid of vertIds) {
+          const pos = this.bk.getVertexPosition(vid);
+          coords.push(pos[0], pos[1], pos[2]);
+        }
+      } else if (h8.type === "vertex") {
+        const pos = this.bk.getVertexPosition(h8.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 p7 of points) {
+      coords.push(p7.x, p7.y, p7.z);
+    }
+    const id = this.bk.convexHull(coords);
+    return solidHandle(id);
+  }
+  buildSolidFromFaces(points, faces, _tolerance) {
+    const positions = new Float64Array(points.length * 3);
+    for (let i7 = 0; i7 < points.length; i7++) {
+      const p7 = points[i7];
+      positions[i7 * 3] = p7.x;
+      positions[i7 * 3 + 1] = p7.y;
+      positions[i7 * 3 + 2] = p7.z;
+    }
+    const indices = new Uint32Array(faces.length * 3);
+    for (let i7 = 0; i7 < faces.length; i7++) {
+      const f12 = faces[i7];
+      indices[i7 * 3] = f12[0];
+      indices[i7 * 3 + 1] = f12[1];
+      indices[i7 * 3 + 2] = f12[2];
+    }
+    const id = this.bk.importIndexedMesh(positions, indices);
+    return solidHandle(id);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Shape construction
+  // ═══════════════════════════════════════════════════════════════════════
+  makeVertex(x7, y6, z6) {
+    const id = this.bk.makeVertex(x7, y6, z6);
+    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 e8 of edges) {
+      const h8 = e8;
+      if (h8.type === "wire") {
+        for (const childEdgeId of toArray(this.bk.getWireEdges(h8.id))) {
+          edgeIds.push(childEdgeId);
+        }
+      } else {
+        edgeIds.push(unwrap(e8, "edge"));
+      }
+    }
+    const id = this.bk.makeWire(edgeIds, true);
+    return wireHandle(id);
+  }
+  makeFace(wire, _planar) {
+    const h8 = wire;
+    if (h8.type === "edge") {
+      const wireId = this.bk.makeWire([h8.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, p22) {
+    const id = this.bk.makeLineEdge(p1[0], p1[1], p1[2], p22[0], p22[1], p22[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, p22, p32) {
+    const ab = [p22[0] - p1[0], p22[1] - p1[1], p22[2] - p1[2]];
+    const ac = [p32[0] - p1[0], p32[1] - p1[1], p32[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, p32);
+    }
+    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 = (p7) => {
+      const dx = p7[0] - p1[0], dy = p7[1] - p1[1], dz = p7[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(p22);
+    const [cx2, cy2] = proj(p32);
+    const d10 = 2 * (ax2 * (by2 - cy2) + bx2 * (cy2 - ay2) + cx2 * (ay2 - by2));
+    if (Math.abs(d10) < 1e-12) {
+      return this.makeLineEdge(p1, p32);
+    }
+    const ccx = ((ax2 ** 2 + ay2 ** 2) * (by2 - cy2) + (bx2 ** 2 + by2 ** 2) * (cy2 - ay2) + (cx2 ** 2 + cy2 ** 2) * (ay2 - by2)) / d10;
+    const ccy = ((ax2 ** 2 + ay2 ** 2) * (cx2 - bx2) + (bx2 ** 2 + by2 ** 2) * (ax2 - cx2) + (cx2 ** 2 + cy2 ** 2) * (bx2 - ax2)) / d10;
+    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 v32 = [p32[0] - center[0], p32[1] - center[1], p32[2] - center[2]];
+    const dotX = v32[0] * uxA[0] + v32[1] * uxA[1] + v32[2] * uxA[2];
+    const dotY = v32[0] * uyA[0] + v32[1] * uyA[1] + v32[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 n9 = points.length;
+    const knots = [...Array(degree + 1).fill(0), ...Array(degree + 1).fill(1)];
+    const weights = Array(n9).fill(1);
+    const flatCp = points.flatMap(([x7, y6, z6]) => [x7, y6, z6]);
+    const startPt = points[0];
+    const endPt = points[n9 - 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 i7 = 0; i7 <= nSamples; i7++) {
+      const t11 = i7 / nSamples;
+      const angle = sign * 2 * Math.PI * turns * t11;
+      points.push([cx + radius * Math.cos(angle), cy + radius * Math.sin(angle), cz + height * t11]);
+    }
+    const edge = this.interpolatePoints(points);
+    return this.makeWire([edge]);
+  }
+  makeWireFromMixed(items) {
+    const edgeIds = [];
+    for (const item of items) {
+      const h8 = item;
+      if (h8.type === "edge") {
+        edgeIds.push(h8.id);
+      } else if (h8.type === "wire") {
+        for (const childEdgeId of toArray(this.bk.getWireEdges(h8.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((h8) => h8.type === "solid");
+    if (allSolids) {
+      const id2 = this.bk.makeCompound(handles.map((h8) => h8.id));
+      return compoundHandle(id2);
+    }
+    const id = syntheticCompoundCounter++;
+    syntheticCompounds.set(id, handles);
+    return compoundHandle(id);
+  }
+  makeBoxFromCorners(p1, p22) {
+    const w6 = Math.abs(p22[0] - p1[0]);
+    const h8 = Math.abs(p22[1] - p1[1]);
+    const d10 = Math.abs(p22[2] - p1[2]);
+    const box = this.makeBox(w6, h8, d10);
+    const minX = Math.min(p1[0], p22[0]);
+    const minY = Math.min(p1[1], p22[1]);
+    const minZ = Math.min(p1[2], p22[2]);
+    if (minX !== 0 || minY !== 0 || minZ !== 0) {
+      return this.translate(box, minX, minY, minZ);
+    }
+    return box;
+  }
+  solidFromShell(shell2) {
+    const h8 = shell2;
+    if (h8.type === "solid") return shell2;
+    if (h8.type === "shell") {
+      try {
+        this.bk.getSolidFaces(h8.id);
+        return solidHandle(h8.id);
+      } catch {
+      }
+      const id2 = this.bk.solidFromShell(h8.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((w6) => {
+      const h8 = w6;
+      if (h8.type === "wire") {
+        return this.bk.makeFaceFromWire(h8.id);
+      }
+      return unwrap(w6, "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((e8) => unwrap(e8, "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((e8) => unwrap(e8, "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 r9 = 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((e8) => unwrap(e8, "edge"));
+    const id = this.bk.fillet(unwrapSolidOrThrow(shape2, "fillet"), edgeIds, r9);
+    return solidHandle(id);
+  }
+  chamfer(shape2, edges, distance) {
+    const d10 = 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((e8) => unwrap(e8, "edge"));
+    const id = this.bk.chamfer(unwrapSolidOrThrow(shape2, "chamfer"), edgeIds, d10);
+    return solidHandle(id);
+  }
+  chamferDistAngle(shape2, edges, distance, angleDeg) {
+    warnOnce("chamfer-dist-angle", "Distance-angle chamfer approximated as uniform chamfer.");
+    const d22 = distance * Math.tan(angleDeg * Math.PI / 180);
+    const avgDist = (distance + d22) / 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((f12) => {
+      const fid = unwrap(f12, "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 h8 = shape2;
+    if (h8.type === "face") {
+      const id = this.bk.thicken(h8.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 h8 = shape2;
+    if (h8.type === "face") {
+      const id2 = this.bk.thicken(h8.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, x7, y6, z6) {
+    return this.applyMatrix(shape2, translationMatrix(x7, y6, z6));
+  }
+  rotate(shape2, angle, axis, center) {
+    return this.applyMatrix(shape2, rotationMatrix(angle, axis, center));
+  }
+  mirror(shape2, origin, normal) {
+    const h8 = shape2;
+    if (h8.type === "solid") {
+      const id = this.bk.mirror(
+        h8.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 h8 = resultShape;
+    const modified = /* @__PURE__ */ new Map();
+    const generated = /* @__PURE__ */ new Map();
+    const deleted = /* @__PURE__ */ new Set();
+    if (h8.type === "solid") {
+      const outputFaces = toArray(this.bk.getSolidFaces(h8.id));
+      const outputHashes = outputFaces.map((fid) => fid % hashUpperBound);
+      if (isTransform) {
+        for (let i7 = 0; i7 < inputFaceHashes.length && i7 < outputHashes.length; i7++) {
+          modified.set(inputFaceHashes[i7], [outputHashes[i7]]);
+        }
+      } 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 i7 = 0; i7 < inputFaceHashes.length && i7 < outputHashes.length; i7++) {
+            modified.set(inputFaceHashes[i7], [outputHashes[i7]]);
+          }
+          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(a9, b10) {
+    const dx = a9[0] - b10[0];
+    const dy = a9[1] - b10[1];
+    const dz = a9[2] - b10[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 i7 = 0; i7 < pos.length; i7 += 3) {
+        cx += pos[i7];
+        cy += pos[i7 + 1];
+        cz += pos[i7 + 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 i7 = 0; i7 < hashCount; i7++) {
+      const fid = inputFaceIds[i7];
+      try {
+        const normal = this.bk.getFaceNormal(fid);
+        const centroid = this.faceCentroidById(fid);
+        inputSigs.push({ hash: inputFaceHashes[i7] ?? fid % hashUpperBound, normal, centroid });
+      } catch {
+        inputSigs.push({
+          hash: inputFaceHashes[i7] ?? 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 i7 = 0; i7 < inputSigs.length; i7++) {
+        const inp = inputSigs[i7];
+        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 = i7;
+        }
+      }
+      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 i7 = 0; i7 < inputSigs.length; i7++) {
+      if (!matchedInputIndices.has(i7)) {
+        deleted.add(inputSigs[i7].hash);
+      }
+    }
+  }
+  translateWithHistory(shape2, x7, y6, z6, inputFaceHashes, hashUpperBound) {
+    return this.buildEvolution(
+      this.translate(shape2, x7, y6, z6),
+      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 result = this.parseNativeEvolution(json, hashUpperBound);
+          currentShape = result.shape;
+          const intermediateOutputs = /* @__PURE__ */ new Set();
+          BrepkitAdapter.chainEvolutionMap(
+            combinedModified,
+            result.evolution.modified,
+            result.evolution.deleted,
+            intermediateOutputs,
+            combinedDeleted
+          );
+          BrepkitAdapter.chainEvolutionMap(
+            combinedGenerated,
+            result.evolution.modified,
+            result.evolution.deleted,
+            intermediateOutputs
+          );
+          for (const [k7, v9] of result.evolution.modified) {
+            if (!combinedModified.has(k7) && !intermediateOutputs.has(k7)) {
+              combinedModified.set(k7, [...v9]);
+            }
+          }
+          for (const [k7, v9] of result.evolution.generated) {
+            if (!intermediateOutputs.has(k7)) {
+              const existing = combinedGenerated.get(k7) ?? [];
+              combinedGenerated.set(k7, [...existing, ...v9]);
+            }
+          }
+          for (const d10 of result.evolution.deleted) {
+            if (inputFaceHashSet.has(d10)) {
+              combinedDeleted.add(d10);
+            }
+          }
+        }
+        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,
+      (a9, b10) => this.bk.fuseWithEvolution(a9, b10),
+      (s6, t11, o9) => this.fuse(s6, t11, o9),
+      "fuseWithHistory"
+    );
+  }
+  cutWithHistory(shape2, tool, inputFaceHashes, hashUpperBound, options) {
+    return this.booleanWithHistoryImpl(
+      shape2,
+      tool,
+      inputFaceHashes,
+      hashUpperBound,
+      options,
+      (a9, b10) => this.bk.cutWithEvolution(a9, b10),
+      (s6, t11, o9) => this.cut(s6, t11, o9),
+      "cutWithHistory"
+    );
+  }
+  intersectWithHistory(shape2, tool, inputFaceHashes, hashUpperBound, options) {
+    return this.booleanWithHistoryImpl(
+      shape2,
+      tool,
+      inputFaceHashes,
+      hashUpperBound,
+      options,
+      (a9, b10) => this.bk.intersectWithEvolution(a9, b10),
+      (s6, t11, o9) => this.intersect(s6, t11, o9),
+      "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 h8 = unwrap(shape2);
+    const bkHandle = shape2;
+    const deflection = options.tolerance || DEFAULT_DEFLECTION;
+    let result;
+    if (bkHandle.type === "solid") {
+      result = this.meshSolid(h8, deflection);
+    } else if (bkHandle.type === "face") {
+      result = this.meshSingleFace(h8, deflection, 0);
+    } else {
+      throw new Error(`brepkit: cannot mesh shape of type '${bkHandle.type}'`);
+    }
+    if (options.skipNormals) {
+      result.normals = new Float32Array(0);
+    }
+    if (!options.includeUVs) {
+      result.uvs = new Float32Array(0);
+    }
+    return result;
+  }
+  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 i7 = 0; i7 < edgeCount; i7++) {
+      const startIdx = offsets[i7];
+      const endIdx = i7 + 1 < edgeCount ? offsets[i7 + 1] : positions.length;
+      const pointCount = (endIdx - startIdx) / 3;
+      edgeGroups.push({ start: startIdx / 3, count: pointCount, edgeHash: i7 });
+    }
+    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((p7) => p7.shape);
+    return this.exportSTEP(shapes);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Measurement
+  // ═══════════════════════════════════════════════════════════════════════
+  volume(shape2) {
+    const h8 = shape2;
+    if (h8.type !== "solid") return 0;
+    return this.bk.volume(unwrap(shape2), DEFAULT_DEFLECTION);
+  }
+  area(shape2) {
+    const h8 = shape2;
+    if (h8.type === "face") {
+      return this.bk.faceArea(unwrap(shape2), DEFAULT_DEFLECTION);
+    }
+    if (h8.type === "solid") {
+      return this.bk.surfaceArea(unwrap(shape2), DEFAULT_DEFLECTION);
+    }
+    if (h8.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 h8 = shape2;
+    if (h8.type === "edge") {
+      return this.bk.edgeLength(unwrap(shape2));
+    }
+    if (h8.type === "face") {
+      return this.bk.facePerimeter(unwrap(shape2));
+    }
+    if (h8.type === "wire") {
+      return this.bk.wireLength(h8.id);
+    }
+    throw new Error("brepkit: length() requires an edge, wire, or face");
+  }
+  centerOfMass(shape2) {
+    const h8 = shape2;
+    if (h8.type === "solid") {
+      const result = this.bk.centerOfMass(unwrap(shape2), DEFAULT_DEFLECTION);
+      return [result[0], result[1], result[2]];
+    }
+    if (h8.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 (h8.type === "edge") {
+      const verts = this.bk.getEdgeVertices(h8.id);
+      return [
+        (verts[0] + verts[3]) / 2,
+        (verts[1] + verts[4]) / 2,
+        (verts[2] + verts[5]) / 2
+      ];
+    }
+    if (h8.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 v9 of vertices) {
+        const p7 = this.vertexPosition(v9);
+        sx += p7[0];
+        sy += p7[1];
+        sz += p7[2];
+      }
+      return [sx / vertices.length, sy / vertices.length, sz / vertices.length];
+    }
+    return [0, 0, 0];
+  }
+  linearCenterOfMass(shape2) {
+    const h8 = shape2;
+    if (h8.type === "edge") {
+      const verts = this.bk.getEdgeVertices(h8.id);
+      return [
+        (verts[0] + verts[3]) / 2,
+        (verts[1] + verts[4]) / 2,
+        (verts[2] + verts[5]) / 2
+      ];
+    }
+    return this.centerOfMass(shape2);
+  }
+  boundingBox(shape2) {
+    const h8 = shape2;
+    if (h8.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 (h8.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 i7 = 1; i7 < vertices.length; i7++) {
+      const p7 = this.vertexPosition(vertices[i7]);
+      if (p7[0] < minX) minX = p7[0];
+      if (p7[0] > maxX) maxX = p7[0];
+      if (p7[1] < minY) minY = p7[1];
+      if (p7[1] > maxY) maxY = p7[1];
+      if (p7[2] < minZ) minZ = p7[2];
+      if (p7[2] > maxZ) maxZ = p7[2];
+    }
+    return { min: [minX, minY, minZ], max: [maxX, maxY, maxZ] };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Topology introspection
+  // ═══════════════════════════════════════════════════════════════════════
+  iterShapes(shape2, type) {
+    const h8 = unwrap(shape2);
+    const bkHandle = shape2;
+    switch (bkHandle.type) {
+      case "compound": {
+        const children = syntheticCompounds.get(h8);
+        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(h8)).map(solidHandle);
+        }
+        if (type === "face" || type === "edge" || type === "vertex" || type === "wire") {
+          const solids = toArray(this.bk.getCompoundSolids(h8)).map(solidHandle);
+          return solids.flatMap((s6) => this.iterShapes(s6, type));
+        }
+        return [];
+      }
+      case "solid": {
+        switch (type) {
+          case "face":
+            return toArray(this.bk.getSolidFaces(h8)).map(faceHandle);
+          case "edge":
+            return toArray(this.bk.getSolidEdges(h8)).map(edgeHandle);
+          case "vertex":
+            return toArray(this.bk.getSolidVertices(h8)).map(vertexHandle);
+          case "wire":
+            return toArray(this.bk.getSolidFaces(h8)).flatMap(
+              (faceId) => toArray(this.bk.getFaceWires(faceId)).map(wireHandle)
+            );
+          default:
+            return [];
+        }
+      }
+      case "shell": {
+        if (type === "face") {
+          return toArray(this.bk.getShellFaces(h8)).map(faceHandle);
+        }
+        if (type === "edge" || type === "vertex") {
+          const faces = toArray(this.bk.getShellFaces(h8)).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(h8)).map(edgeHandle);
+        }
+        if (type === "vertex") {
+          return toArray(this.bk.getFaceVertices(h8)).map(vertexHandle);
+        }
+        if (type === "wire") {
+          return toArray(this.bk.getFaceWires(h8)).map(wireHandle);
+        }
+        return [];
+      }
+      case "wire": {
+        if (type === "wire") {
+          return [shape2];
+        }
+        if (type === "edge") {
+          return toArray(this.bk.getWireEdges(h8)).map(edgeHandle);
+        }
+        if (type === "vertex") {
+          const edgeIds = toArray(this.bk.getWireEdges(h8));
+          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 [x7, y6, z6] of coords) {
+              const key = `${x7},${y6},${z6}`;
+              if (!seen.has(key)) {
+                seen.add(key);
+                results.push(vertexHandle(this.bk.makeVertex(x7, y6, z6)));
+              }
+            }
+          }
+          return results;
+        }
+        return [];
+      }
+      case "edge": {
+        if (type === "edge") {
+          return [shape2];
+        }
+        if (type === "vertex") {
+          const verts = this.bk.getEdgeVertices(h8);
+          const v1 = this.bk.makeVertex(verts[0], verts[1], verts[2]);
+          const v22 = this.bk.makeVertex(verts[3], verts[4], verts[5]);
+          return [vertexHandle(v1), vertexHandle(v22)];
+        }
+        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(a9, b10) {
+    return isBrepkitHandle(a9) && isBrepkitHandle(b10) && a9.id === b10.id && a9.type === b10.type;
+  }
+  isEqual(a9, b10) {
+    return this.isSame(a9, b10);
+  }
+  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 h8 = unwrap(shape2);
+    const orient = this.bk.getShapeOrientation(h8);
+    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, u7, v9) {
+    const n9 = this.bk.evaluateSurfaceNormal(unwrap(face, "face"), u7, v9);
+    return [n9[0], n9[1], n9[2]];
+  }
+  pointOnSurface(face, u7, v9) {
+    const p7 = this.bk.evaluateSurface(unwrap(face, "face"), u7, v9);
+    return [p7[0], p7[1], p7[2]];
+  }
+  uvFromPoint(face, point) {
+    try {
+      const result = this.bk.projectPointOnSurface(
+        unwrap(face, "face"),
+        point[0],
+        point[1],
+        point[2]
+      );
+      return [result[0], result[1]];
+    } catch (e8) {
+      console.warn("brepkit: uvFromPoint failed:", e8);
+      return null;
+    }
+  }
+  projectPointOnFace(face, point) {
+    const result = this.bk.projectPointOnSurface(
+      unwrap(face, "face"),
+      point[0],
+      point[1],
+      point[2]
+    );
+    return [result[2], result[3], result[4]];
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Geometry queries: edge / curve
+  // ═══════════════════════════════════════════════════════════════════════
+  curveTangent(shape2, param) {
+    const h8 = shape2;
+    let edgeId;
+    let evalParam = param;
+    if (h8.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h8.id));
+      edgeId = edgeIds[edgeIds.length - 1];
+      let cumulative = 0;
+      for (const eid of edgeIds) {
+        const p7 = this.bk.getEdgeCurveParameters(eid);
+        const span = p7[1] - p7[0];
+        if (param <= cumulative + span || eid === edgeId) {
+          edgeId = eid;
+          evalParam = Math.min(p7[0] + (param - cumulative), p7[1]);
+          break;
+        }
+        cumulative += span;
+      }
+    } else {
+      edgeId = unwrap(shape2, "edge");
+    }
+    const result = this.bk.evaluateEdgeCurveD1(edgeId, evalParam);
+    return {
+      point: [result[0], result[1], result[2]],
+      tangent: [result[3], result[4], result[5]]
+    };
+  }
+  curveParameters(shape2) {
+    const h8 = shape2;
+    if (h8.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h8.id));
+      if (edgeIds.length === 0) return [0, 0];
+      let total = 0;
+      for (const eid of edgeIds) {
+        const p7 = this.bk.getEdgeCurveParameters(eid);
+        total += p7[1] - p7[0];
+      }
+      return [0, total];
+    }
+    const edgeId = unwrap(shape2, "edge");
+    const params = this.bk.getEdgeCurveParameters(edgeId);
+    return [params[0], params[1]];
+  }
+  curvePointAtParam(shape2, param) {
+    const h8 = shape2;
+    if (h8.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h8.id));
+      let cumulative = 0;
+      for (const eid of edgeIds) {
+        const p22 = this.bk.getEdgeCurveParameters(eid);
+        const span = p22[1] - p22[0];
+        if (param <= cumulative + span || eid === edgeIds[edgeIds.length - 1]) {
+          const localParam = p22[0] + (param - cumulative);
+          const pt2 = this.bk.evaluateEdgeCurve(eid, Math.min(localParam, p22[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 p7 = this.bk.evaluateEdgeCurve(edgeId, param);
+    return [p7[0], p7[1], p7[2]];
+  }
+  curveIsClosed(shape2) {
+    const h8 = shape2;
+    if (h8.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h8.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(
+          (u7) => dist3(u7[0], u7[1], u7[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 h8 = shape2;
+    try {
+      if (h8.type === "edge") return this.curveIsClosed(shape2);
+      if (h8.type === "wire") {
+        const edgeIds = toArray(this.bk.getWireEdges(h8.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 h8 = shape2;
+    if (h8.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 (e8) {
+        console.warn("brepkit: healing failed in simplify:", e8);
+      }
+    }
+    return shape2;
+  }
+  isValid(shape2) {
+    if (!isBrepkitHandle(shape2)) return false;
+    if (shape2.type !== "solid") return true;
+    try {
+      const errors = this.bk.validateSolidRelaxed(shape2.id);
+      return errors === 0;
+    } catch (e8) {
+      console.warn("brepkit: isValid check failed:", e8);
+      return false;
+    }
+  }
+  isValidStrict(shape2) {
+    if (!isBrepkitHandle(shape2)) return false;
+    if (shape2.type !== "solid") return true;
+    try {
+      const errors = this.bk.validateSolid(shape2.id);
+      return errors === 0;
+    } catch (e8) {
+      console.warn("brepkit: isValidStrict check failed:", e8);
+      return false;
+    }
+  }
+  sew(shapes, tolerance) {
+    const faceIds = [];
+    for (const s6 of shapes) {
+      const h8 = s6;
+      if (h8.type === "face") {
+        faceIds.push(h8.id);
+      } else if (h8.type === "solid") {
+        for (const fid of toArray(this.bk.getSolidFaces(h8.id))) {
+          faceIds.push(fid);
+        }
+      } else if (h8.type === "shell") {
+        for (const fid of toArray(this.bk.getShellFaces(h8.id))) {
+          faceIds.push(fid);
+        }
+      }
+    }
+    const tol = tolerance ?? 1e-7;
+    try {
+      const id2 = this.bk.weldShellsAndFaces(faceIds, tol);
+      return shellHandle(id2);
+    } catch (e8) {
+      console.warn("brepkit: weldShellsAndFaces failed, falling back to sewFaces:", e8);
+    }
+    const id = this.bk.sewFaces(faceIds, tol);
+    return shellHandle(id);
+  }
+  healSolid(shape2) {
+    const h8 = shape2;
+    if (h8.type !== "solid") {
+      throw new Error(
+        `brepkit: healSolid requires a solid, got ${h8.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 (e8) {
+      try {
+        this.bk.healSolid(unwrap(shape2));
+        return shape2;
+      } catch (healErr) {
+        console.warn(
+          "brepkit: healSolid failed (repairSolid error:",
+          e8,
+          ", 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 result = this.bk.offsetPolygon2d(coords2d, offset2, 1e-10);
+    const coords3d = [];
+    for (let i7 = 0; i7 < result.length; i7 += 2) {
+      coords3d.push(result[i7], result[i7 + 1], 0);
+    }
+    const wireId = this.bk.makePolygonWire(coords3d);
+    return wireHandle(wireId);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Distance
+  // ═══════════════════════════════════════════════════════════════════════
+  distance(shape1, shape2) {
+    const h1 = shape1;
+    const h22 = shape2;
+    if (h1.type === "solid" && h22.type === "solid") {
+      const d10 = this.bk.solidToSolidDistance(h1.id, h22.id);
+      return { value: d10, point1: [0, 0, 0], point2: [0, 0, 0] };
+    }
+    if (h1.type === "vertex" && h22.type === "solid") {
+      const pos = this.bk.getVertexPosition(h1.id);
+      const result = this.bk.pointToSolidDistance(pos[0], pos[1], pos[2], h22.id);
+      return {
+        value: result[0],
+        point1: [pos[0], pos[1], pos[2]],
+        point2: [result[1], result[2], result[3]]
+      };
+    }
+    if (h1.type === "vertex" && h22.type === "face") {
+      const pos = this.bk.getVertexPosition(h1.id);
+      const result = this.bk.pointToFaceDistance(pos[0], pos[1], pos[2], h22.id);
+      return {
+        value: result[0],
+        point1: [pos[0], pos[1], pos[2]],
+        point2: [result[1], result[2], result[3]]
+      };
+    }
+    if (h1.type === "vertex" && h22.type === "edge") {
+      const pos = this.bk.getVertexPosition(h1.id);
+      const result = this.bk.pointToEdgeDistance(pos[0], pos[1], pos[2], h22.id);
+      return {
+        value: result[0],
+        point1: [pos[0], pos[1], pos[2]],
+        point2: [result[1], result[2], result[3]]
+      };
+    }
+    const getPos = (s6) => {
+      if (s6.type === "vertex") {
+        const p7 = this.bk.getVertexPosition(s6.id);
+        return [p7[0], p7[1], p7[2]];
+      }
+      if (s6.type === "solid") {
+        const bb = this.bk.boundingBox(s6.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 p22 = getPos(h22);
+    const dx = p22[0] - p1[0];
+    const dy = p22[1] - p1[1];
+    const dz = p22[2] - p1[2];
+    return { value: Math.sqrt(dx * dx + dy * dy + dz * dz), point1: p1, point2: p22 };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Classification
+  // ═══════════════════════════════════════════════════════════════════════
+  classifyPointOnFace(face, u7, v9, 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 (u7 < domain[0] || u7 > domain[1] || v9 < domain[2] || v9 > 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(([x7, y6, z6]) => [x7, y6, z6]);
+    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 p7 of points) coords.push(p7[0], p7[1], p7[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 m10 = op.type === "translate" ? translationMatrix(op.x, op.y, op.z) : rotationMatrix(op.angle, op.axis, op.center);
+      matrix = multiplyMatrices(m10, matrix);
+    }
+    return { handle: matrix, dispose: () => {
+    } };
+  }
+  applyComposedTransformWithHistory(shape2, transformHandle, inputFaceHashes, hashUpperBound) {
+    const result = this.applyMatrix(shape2, transformHandle);
+    return this.buildEvolution(result, 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 (e8) {
+        console.warn("brepkit: sweepSmooth failed, falling back to simplePipe:", e8);
+      }
+    }
+    const shape2 = this.simplePipe(profile, spine);
+    if (shellMode) return { shape: shape2, firstShape: profile, lastShape: profile };
+    return shape2;
+  }
+  loftAdvanced(wires, options) {
+    const faceIds = wires.map((w6) => {
+      const h8 = w6;
+      if (h8.type === "wire") return this.bk.makeFaceFromWire(h8.id);
+      return unwrap(w6, "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 (e8) {
+      console.warn("brepkit: loftWithOptions failed, falling back to smooth/basic loft:", e8);
+    }
+    if (!options?.ruled) {
+      try {
+        const id = this.bk.loftSmooth(faceIds);
+        return solidHandle(id);
+      } catch (e8) {
+        console.warn("brepkit: loftSmooth failed, falling back to basic loft:", e8);
+      }
+    }
+    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 result = shape2;
+    if (Math.abs(dot + 1) < 1e-10) {
+      result = this.rotate(result, 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);
+      result = this.rotate(result, angleDeg, axis);
+    }
+    return this.translate(result, point[0], point[1], point[2]);
+  }
+  linearPattern(shape2, direction, spacing, count) {
+    const results = [shape2];
+    for (let i7 = 1; i7 < count; i7++) {
+      const offset2 = spacing * i7;
+      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 i7 = 1; i7 < count; i7++) {
+      results.push(this.rotate(shape2, angleStep * i7, 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((w6) => unwrap(w6, "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 [x7, y6, z6] of points) {
+      coords.push(x7, y6, z6);
+    }
+    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 r9 = 0; r9 < rows - 1; r9++) {
+      for (let c7 = 0; c7 < cols - 1; c7++) {
+        const i00 = r9 * cols + c7;
+        const i10 = (r9 + 1) * cols + c7;
+        const i01 = r9 * cols + (c7 + 1);
+        const i11 = (r9 + 1) * cols + (c7 + 1);
+        const f1 = this.buildTriFace(points[i00], points[i10], points[i01]);
+        if (f1) faces.push(f1);
+        const f22 = this.buildTriFace(points[i10], points[i11], points[i01]);
+        if (f22) faces.push(f22);
+      }
+    }
+    if (faces.length === 0) throw new Error("brepkit: no valid faces in surface grid");
+    return this.sew(faces, 1e-6);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Mesh sewing -> solid
+  // ═══════════════════════════════════════════════════════════════════════
+  buildTriFace(a9, b10, c7) {
+    const ab = [b10[0] - a9[0], b10[1] - a9[1], b10[2] - a9[2]];
+    const ac = [c7[0] - a9[0], c7[1] - a9[1], c7[2] - a9[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(a9, b10);
+      const e22 = this.makeLineEdge(b10, c7);
+      const e32 = this.makeLineEdge(c7, a9);
+      const wire = this.makeWire([e1, e22, e32]);
+      return this.makeFace(wire);
+    } catch (e8) {
+      console.warn("brepkit: makeNonPlanarFace failed:", e8);
+      return null;
+    }
+  }
+  sewAndSolidify(faces, tolerance) {
+    const faceIds = faces.map((s6) => unwrap(s6, "face"));
+    const solidId = this.bk.sewFaces(faceIds, tolerance);
+    return solidHandle(solidId);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Repair
+  // ═══════════════════════════════════════════════════════════════════════
+  fixShape(shape2) {
+    const h8 = shape2;
+    if (h8.type === "solid") {
+      this.bk.healSolid(h8.id);
+    }
+    return shape2;
+  }
+  fixSelfIntersection(wire) {
+    return wire;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Measurement (advanced)
+  // ═══════════════════════════════════════════════════════════════════════
+  surfaceCurvature(face, u7, v9) {
+    const fid = unwrap(face, "face");
+    const data = this.bk.measureCurvatureAtSurface(fid, u7, v9);
+    if (data.length < 8) {
+      throw new Error(
+        `brepkit: measureCurvatureAtSurface returned ${data.length} values, expected 8`
+      );
+    }
+    const k1 = data[0];
+    const k22 = data[1];
+    const gaussian = k1 * k22;
+    const mean = (k1 + k22) / 2;
+    return {
+      gaussian,
+      mean,
+      max: Math.max(k1, k22),
+      min: Math.min(k1, k22),
+      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 t11 = 0; t11 < idx.length; t11 += 3) {
+      const i0 = idx[t11] * 3, i1 = idx[t11 + 1] * 3, i22 = idx[t11 + 2] * 3;
+      const tcx = (pos[i0] + pos[i1] + pos[i22]) / 3;
+      const tcy = (pos[i0 + 1] + pos[i1 + 1] + pos[i22 + 1]) / 3;
+      const tcz = (pos[i0 + 2] + pos[i1 + 2] + pos[i22 + 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[i22] - pos[i0], vy = pos[i22 + 1] - pos[i0 + 1], vz = pos[i22 + 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((s6) => s6.shape));
+    }
+    return "";
+  }
+  exportSTEPConfigured(shapes, _options) {
+    return this.exportSTEP(shapes.map((s6) => s6.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 n9 = nurbsData.controlPoints.length;
+    return [
+      nurbsData.controlPoints[n9 - 6],
+      nurbsData.controlPoints[n9 - 5],
+      nurbsData.controlPoints[n9 - 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(x7, y6, z6) {
+    return { x: x7, y: y6, z: z6 };
+  }
+  createDirection3d(x7, y6, z6) {
+    const len = Math.sqrt(x7 * x7 + y6 * y6 + z6 * z6);
+    return { x: x7 / len, y: y6 / len, z: z6 / len };
+  }
+  createVector3d(x7, y6, z6) {
+    return { x: x7, y: y6, z: z6 };
+  }
+  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 h8 = shape2;
+    const newId = this.bk.reverseShape(h8.id);
+    return handle(h8.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(h8) {
+    return h8;
+  }
+  /** Unwrap any trimmed wrappers to get the underlying geometry. */
+  c2dBasis(h8) {
+    let c7 = this.c2d(h8);
+    while (c7.__bk2d === "trimmed") c7 = c7.basis;
+    return c7;
+  }
+  bb2d(h8) {
+    return h8;
+  }
+  createPoint2d(x7, y6) {
+    return { x: x7, y: y6 };
+  }
+  createDirection2d(x7, y6) {
+    const l10 = Math.sqrt(x7 * x7 + y6 * y6);
+    return { x: x7 / l10, y: y6 / l10 };
+  }
+  createVector2d(x7, y6) {
+    return { x: x7, y: y6 };
+  }
+  createAxis2d(px, py, dx, dy) {
+    return { px, py, dx, dy };
+  }
+  wrapCurve2dHandle(handle2) {
+    return handle2;
+  }
+  createCurve2dAdaptor(handle2) {
+    return handle2;
+  }
+  makeLine2d(x1, y1, x22, y22) {
+    return makeLine2d(x1, y1, x22, y22);
+  }
+  makeCircle2d(cx, cy, radius, sense) {
+    return makeCircle2d(cx, cy, radius, sense);
+  }
+  makeArc2dThreePoints(x1, y1, xm, ym, x22, y22) {
+    const d10 = 2 * (x1 * (ym - y22) + xm * (y22 - y1) + x22 * (y1 - ym));
+    if (Math.abs(d10) < 1e-12) {
+      return makeLine2d(x1, y1, x22, y22);
+    }
+    const cx = ((x1 * x1 + y1 * y1) * (ym - y22) + (xm * xm + ym * ym) * (y22 - y1) + (x22 * x22 + y22 * y22) * (y1 - ym)) / d10;
+    const cy = ((x1 * x1 + y1 * y1) * (x22 - xm) + (xm * xm + ym * ym) * (x1 - x22) + (x22 * x22 + y22 * y22) * (xm - x1)) / d10;
+    const radius = Math.sqrt((x1 - cx) ** 2 + (y1 - cy) ** 2);
+    const a12 = Math.atan2(y1 - cy, x1 - cx);
+    const am = Math.atan2(ym - cy, xm - cx);
+    const a23 = Math.atan2(y22 - cy, x22 - cx);
+    let da1m = am - a12;
+    if (da1m < 0) da1m += 2 * Math.PI;
+    let da12 = a23 - a12;
+    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: -a12, tEnd: -a23 };
+    }
+    return { __bk2d: "trimmed", basis: circle, tStart: a12, tEnd: a23 };
+  }
+  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 n9 = points.length;
+    const degree = Math.min(3, n9 - 1);
+    const knots = [];
+    const mults = [];
+    knots.push(0);
+    mults.push(degree + 1);
+    const nInternal = n9 - degree - 1;
+    for (let i7 = 1; i7 <= nInternal; i7++) {
+      knots.push(i7 / (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 c7 = this.c2d(curve);
+    const bounds = curveBounds(c7);
+    const N4 = 30;
+    const poles = [];
+    for (let i7 = 0; i7 <= N4; i7++) {
+      const t11 = bounds.first + (bounds.last - bounds.first) * i7 / N4;
+      const [px, py] = evaluateCurve2d(c7, t11);
+      const [tx, ty] = tangentCurve2d(c7, t11);
+      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 k7 = ratio - 1;
+    const m00 = 1 + k7 * px * px, m01 = k7 * px * py;
+    const m10 = k7 * py * px, m11 = 1 + k7 * 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 k7 = ratio - 1;
+    const m10 = [1 + k7 * px * px, k7 * px * py, 0, k7 * py * px, 1 + k7 * py * py, 0, 0, 0, 1];
+    const txv = ox - m10[0] * ox - m10[1] * oy;
+    const tyv = oy - m10[3] * ox - m10[4] * oy;
+    return { m: m10, 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 m10 = [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 - m10[0] * px - m10[1] * py;
+      const tyv = py - m10[3] * px - m10[4] * py;
+      return { m: m10, 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 c7 = Math.cos(angle), s6 = Math.sin(angle);
+    return { m: [c7, -s6, 0, s6, c7, 0, 0, 0, 1], tx: cx - c7 * cx + s6 * cy, ty: cy - s6 * cx - c7 * 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 a9 = base.m, b10 = other.m;
+    const r9 = [
+      a9[0] * b10[0] + a9[1] * b10[3] + a9[2] * b10[6],
+      a9[0] * b10[1] + a9[1] * b10[4] + a9[2] * b10[7],
+      a9[0] * b10[2] + a9[1] * b10[5] + a9[2] * b10[8],
+      a9[3] * b10[0] + a9[4] * b10[3] + a9[5] * b10[6],
+      a9[3] * b10[1] + a9[4] * b10[4] + a9[5] * b10[7],
+      a9[3] * b10[2] + a9[4] * b10[5] + a9[5] * b10[8],
+      a9[6] * b10[0] + a9[7] * b10[3] + a9[8] * b10[6],
+      a9[6] * b10[1] + a9[7] * b10[4] + a9[8] * b10[7],
+      a9[6] * b10[2] + a9[7] * b10[5] + a9[8] * b10[8]
+    ];
+    base.m = r9;
+    const oldTx = base.tx, oldTy = base.ty;
+    const otx = Number(other.tx) || 0, oty = Number(other.ty) || 0;
+    base.tx = a9[0] * otx + a9[1] * oty + oldTx;
+    base.ty = a9[3] * otx + a9[4] * oty + oldTy;
+  }
+  transformCurve2dGeneral(curve, gtrsf) {
+    const c7 = this.c2d(curve);
+    const m10 = 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(m10[0] - 1) < 1e-12 && Math.abs(m10[4] - 1) < 1e-12 && Math.abs(m10[1]) < 1e-12 && Math.abs(m10[3]) < 1e-12;
+    if (isIdentityMatrix) {
+      return translateCurve2d(c7, tx, ty);
+    }
+    const bounds = curveBounds(c7);
+    const N4 = 20;
+    const pts = [];
+    for (let i7 = 0; i7 <= N4; i7++) {
+      const t11 = bounds.first + (bounds.last - bounds.first) * i7 / N4;
+      const [px, py] = evaluateCurve2d(c7, t11);
+      pts.push([m10[0] * px + m10[1] * py + tx, m10[3] * px + m10[4] * py + ty]);
+    }
+    return makeBezier2d(pts);
+  }
+  // --- 2D intersection & distance ---
+  intersectCurves2d(c1, c22, tolerance) {
+    const result = intersectCurves2dFn(this.c2d(c1), this.c2d(c22), tolerance);
+    const segments = result.segments.map(
+      (s6) => Object.assign(s6, {
+        delete() {
+        }
+      })
+    );
+    return { points: result.points, segments };
+  }
+  projectPointOnCurve2d(curve, x7, y6) {
+    const c7 = this.c2d(curve);
+    const bounds = curveBounds(c7);
+    if (c7.__bk2d === "line") {
+      const dx = x7 - c7.ox;
+      const dy = y6 - c7.oy;
+      const t11 = Math.max(bounds.first, Math.min(bounds.last, dx * c7.dx + dy * c7.dy));
+      const [px, py] = evaluateCurve2d(c7, t11);
+      return { param: t11, distance: Math.sqrt((px - x7) ** 2 + (py - y6) ** 2) };
+    }
+    if (c7.__bk2d === "circle") {
+      const angle = Math.atan2(y6 - c7.cy, x7 - c7.cx);
+      let t11 = c7.sense ? angle : -angle;
+      while (t11 < 0) t11 += 2 * Math.PI;
+      while (t11 > 2 * Math.PI) t11 -= 2 * Math.PI;
+      const [px, py] = evaluateCurve2d(c7, t11);
+      return { param: t11, distance: Math.sqrt((px - x7) ** 2 + (py - y6) ** 2) };
+    }
+    if (!isFinite(bounds.first) || !isFinite(bounds.last)) return null;
+    let bestT = bounds.first;
+    let bestDist = Infinity;
+    const N4 = 200;
+    const dt = (bounds.last - bounds.first) / N4;
+    for (let i7 = 0; i7 <= N4; i7++) {
+      const t11 = bounds.first + i7 * dt;
+      const [px, py] = evaluateCurve2d(c7, t11);
+      const d10 = (px - x7) ** 2 + (py - y6) ** 2;
+      if (d10 < bestDist) {
+        bestDist = d10;
+        bestT = t11;
+      }
+    }
+    for (let iter = 0; iter < 10; iter++) {
+      const [px, py] = evaluateCurve2d(c7, bestT);
+      const [tx, ty] = tangentCurve2d(c7, bestT);
+      const dot = (px - x7) * tx + (py - y6) * 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(c7, bestT);
+    return { param: bestT, distance: Math.sqrt((fx - x7) ** 2 + (fy - y6) ** 2) };
+  }
+  distanceBetweenCurves2d(c1, c22, p1s, p1e, p2s, p2e) {
+    const curve1 = this.c2d(c1);
+    const curve2 = this.c2d(c22);
+    let bestT1 = p1s;
+    let bestT2 = p2s;
+    let minDistSq = Infinity;
+    const N4 = 50;
+    for (let i7 = 0; i7 <= N4; i7++) {
+      const t12 = p1s + (p1e - p1s) * i7 / N4;
+      const [x1, y1] = evaluateCurve2d(curve1, t12);
+      for (let j6 = 0; j6 <= N4; j6++) {
+        const t222 = p2s + (p2e - p2s) * j6 / N4;
+        const [x22, y22] = evaluateCurve2d(curve2, t222);
+        const d10 = (x22 - x1) ** 2 + (y22 - y1) ** 2;
+        if (d10 < minDistSq) {
+          minDistSq = d10;
+          bestT1 = t12;
+          bestT2 = t222;
+        }
+      }
+    }
+    let t1 = bestT1;
+    let t22 = bestT2;
+    for (let iter = 0; iter < 20; iter++) {
+      const [x22, y22] = evaluateCurve2d(curve2, t22);
+      const proj1 = this.projectPointOnCurve2d(c1, x22, y22);
+      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(c22, x1, y1);
+      if (proj2) {
+        const newT2 = Math.max(p2s, Math.min(p2e, proj2.param));
+        const converged2 = Math.abs(newT2 - t22) < 1e-12;
+        t22 = newT2;
+        if (converged2) break;
+      }
+    }
+    const [fx1, fy1] = evaluateCurve2d(curve1, t1);
+    const [fx2, fy2] = evaluateCurve2d(curve2, t22);
+    return Math.sqrt((fx2 - fx1) ** 2 + (fy2 - fy1) ** 2);
+  }
+  approximateCurve2dAsBSpline(curve, tol, cont, maxSeg) {
+    const c7 = this.c2d(curve);
+    const bounds = curveBounds(c7);
+    const contDeg = cont === "C0" ? 1 : cont === "C1" ? 2 : cont === "C2" ? 3 : 4;
+    const degree = Math.max(3, contDeg);
+    let N4 = Math.max(100, maxSeg * 10);
+    let poles = [];
+    let maxErr = Infinity;
+    for (let attempt = 0; attempt < 3 && maxErr > tol; attempt++) {
+      poles = [];
+      for (let i7 = 0; i7 <= N4; i7++) {
+        const t11 = bounds.first + (bounds.last - bounds.first) * i7 / N4;
+        poles.push(evaluateCurve2d(c7, t11));
+      }
+      maxErr = 0;
+      for (let i7 = 0; i7 < N4; i7++) {
+        const tMid = bounds.first + (bounds.last - bounds.first) * (i7 + 0.5) / N4;
+        const [ex, ey] = evaluateCurve2d(c7, tMid);
+        const p0 = poles[i7];
+        const p1 = poles[i7 + 1];
+        const mx = (p0[0] + p1[0]) / 2;
+        const my = (p0[1] + p1[1]) / 2;
+        const err2 = Math.sqrt((ex - mx) ** 2 + (ey - my) ** 2);
+        if (err2 > maxErr) maxErr = err2;
+      }
+      if (maxErr > tol) N4 = Math.min(N4 * 2, 500);
+    }
+    return this.makeBSpline2d(poles, { degMax: degree });
+  }
+  decomposeBSpline2dToBeziers(curve) {
+    const c7 = this.c2dBasis(curve);
+    if (c7.__bk2d === "bezier") return [curve];
+    if (c7.__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 k7 of c7.knots) {
+      if (k7 > first + 1e-12 && k7 < last - 1e-12) internalKnots.push(k7);
+    }
+    const breakpoints = [first, ...internalKnots, last];
+    const result = [];
+    for (let i7 = 0; i7 < breakpoints.length - 1; i7++) {
+      const t0 = breakpoints[i7];
+      const t1 = breakpoints[i7 + 1];
+      const span = t1 - t0;
+      if (span < 1e-15) continue;
+      const p0 = evaluateCurve2d(c7, t0);
+      const p32 = evaluateCurve2d(c7, t1);
+      const tan0 = tangentCurve2d(c7, t0);
+      const tan3 = tangentCurve2d(c7, t1);
+      const s6 = span / 3;
+      const bezier = {
+        __bk2d: "bezier",
+        poles: [
+          p0,
+          [p0[0] + tan0[0] * s6, p0[1] + tan0[1] * s6],
+          [p32[0] - tan3[0] * s6, p32[1] - tan3[1] * s6],
+          p32
+        ]
+      };
+      result.push(bezier);
+    }
+    return result.length > 0 ? result : [curve];
+  }
+  // --- 2D bounding boxes ---
+  createBoundingBox2d() {
+    return createBBox2d();
+  }
+  addCurveToBBox2d(bbox, curve, tol) {
+    addCurveToBBox(this.bb2d(bbox), this.c2d(curve));
+  }
+  getBBox2dBounds(bbox) {
+    const b10 = this.bb2d(bbox);
+    return { xMin: b10.xMin, yMin: b10.yMin, xMax: b10.xMax, yMax: b10.yMax };
+  }
+  mergeBBox2d(target, other) {
+    const t11 = this.bb2d(target), o9 = this.bb2d(other);
+    t11.xMin = Math.min(t11.xMin, o9.xMin);
+    t11.yMin = Math.min(t11.yMin, o9.yMin);
+    t11.xMax = Math.max(t11.xMax, o9.xMax);
+    t11.yMax = Math.max(t11.yMax, o9.yMax);
+  }
+  isBBox2dOut(a9, b10) {
+    const ba = this.bb2d(a9), bb = this.bb2d(b10);
+    return ba.xMax < bb.xMin || bb.xMax < ba.xMin || ba.yMax < bb.yMin || bb.yMax < ba.yMin;
+  }
+  isBBox2dOutPoint(bbox, x7, y6) {
+    const b10 = this.bb2d(bbox);
+    return x7 < b10.xMin || x7 > b10.xMax || y6 < b10.yMin || y6 > b10.yMax;
+  }
+  // --- 2D type extraction ---
+  getCurve2dCircleData(curve) {
+    const c7 = this.c2dBasis(curve);
+    if (c7.__bk2d === "circle") return { cx: c7.cx, cy: c7.cy, radius: c7.radius, isDirect: c7.sense };
+    return null;
+  }
+  getCurve2dEllipseData(curve) {
+    const c7 = this.c2dBasis(curve);
+    if (c7.__bk2d === "ellipse")
+      return {
+        majorRadius: c7.majorRadius,
+        minorRadius: c7.minorRadius,
+        xAxisAngle: c7.xDirAngle,
+        isDirect: c7.sense
+      };
+    return null;
+  }
+  getCurve2dBezierPoles(curve) {
+    const c7 = this.c2dBasis(curve);
+    if (c7.__bk2d === "bezier") return [...c7.poles];
+    return null;
+  }
+  getCurve2dBezierDegree(curve) {
+    const c7 = this.c2dBasis(curve);
+    if (c7.__bk2d === "bezier") return c7.poles.length - 1;
+    return null;
+  }
+  getCurve2dBSplineData(curve) {
+    const c7 = this.c2dBasis(curve);
+    if (c7.__bk2d === "bspline")
+      return {
+        poles: [...c7.poles],
+        knots: [...c7.knots],
+        multiplicities: [...c7.multiplicities],
+        degree: c7.degree,
+        isPeriodic: c7.isPeriodic
+      };
+    return null;
+  }
+  // --- 2D serialization ---
+  serializeCurve2d(curve) {
+    return serializeCurve2d(this.c2d(curve));
+  }
+  deserializeCurve2d(data) {
+    return deserializeCurve2d(data);
+  }
+  // --- 2D curve splitting ---
+  splitCurve2d(curve, params) {
+    const c7 = this.c2d(curve);
+    const bounds = curveBounds(c7);
+    const sortedParams = [bounds.first, ...params.sort((a9, b10) => a9 - b10), bounds.last];
+    const result = [];
+    for (let i7 = 0; i7 < sortedParams.length - 1; i7++) {
+      result.push({
+        __bk2d: "trimmed",
+        basis: c7,
+        tStart: sortedParams[i7],
+        tEnd: sortedParams[i7 + 1]
+      });
+    }
+    return result;
+  }
+  // --- 2D → 3D projection ---
+  liftCurve2dToPlane(curve, origin, planeZ, planeX) {
+    const c7 = this.c2d(curve);
+    const y6 = [
+      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 = (u7, v9) => [
+      origin[0] + u7 * planeX[0] + v9 * y6[0],
+      origin[1] + u7 * planeX[1] + v9 * y6[1],
+      origin[2] + u7 * planeX[2] + v9 * y6[2]
+    ];
+    if (c7.__bk2d === "line") {
+      const p1 = lift(c7.ox, c7.oy);
+      const p22 = lift(c7.ox + c7.dx * c7.len, c7.oy + c7.dy * c7.len);
+      return this.makeLineEdge(p1, p22);
+    }
+    if (c7.__bk2d === "circle" || c7.__bk2d === "trimmed") {
+      const bounds2 = curveBounds(c7);
+      let angularSpan;
+      if (c7.__bk2d === "trimmed") {
+        angularSpan = Math.abs(c7.tEnd - c7.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 i7 = 0; i7 <= samplesPerSegment; i7++) {
+          const t11 = bounds2.first + (bounds2.last - bounds2.first) * i7 / samplesPerSegment;
+          const [u7, v9] = evaluateCurve2d(c7, t11);
+          points2.push(lift(u7, v9));
+        }
+        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 i7 = 0; i7 <= samplesPerSegment; i7++) {
+          const t11 = segStart + (segEnd - segStart) * i7 / samplesPerSegment;
+          const [u7, v9] = evaluateCurve2d(c7, t11);
+          points2.push(lift(u7, v9));
+        }
+        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 (c7.__bk2d === "bezier") {
+      const points3d = c7.poles.map(([u7, v9]) => lift(u7, v9));
+      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 (c7.__bk2d === "bspline") {
+      const points3d = c7.poles.map(([u7, v9]) => lift(u7, v9));
+      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(c7);
+    const nSamples = 100;
+    const points = [];
+    for (let i7 = 0; i7 <= nSamples; i7++) {
+      const t11 = bounds.first + (bounds.last - bounds.first) * i7 / nSamples;
+      const [u7, v9] = evaluateCurve2d(c7, t11);
+      points.push(lift(u7, v9));
+    }
+    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 c7 = this.c2d(curve);
+    const bounds = curveBounds(c7);
+    const surfType = this.bk.getSurfaceType(fid);
+    const N4 = surfType === "plane" ? 50 : 100;
+    const points = [];
+    for (let i7 = 0; i7 <= N4; i7++) {
+      const t11 = bounds.first + (bounds.last - bounds.first) * i7 / N4;
+      const [u7, v9] = evaluateCurve2d(c7, t11);
+      const p7 = this.bk.evaluateSurface(fid, u7, v9);
+      points.push([p7[0], p7[1], p7[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 N4 = 40;
+    const uvPoints = [];
+    for (let i7 = 0; i7 <= N4; i7++) {
+      const t11 = tMin + (tMax - tMin) * i7 / N4;
+      const pt = this.bk.evaluateEdgeCurve(eid, t11);
+      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 N4 = 10;
+          const pts = [];
+          for (let i7 = 0; i7 <= N4; i7++) {
+            const t11 = tMin + (tMax - tMin) * i7 / N4;
+            const p7 = this.bk.evaluateEdgeCurve(edgeId, t11);
+            pts.push(p7[0], p7[1], p7[2]);
+          }
+          allCoords.push(...pts);
+          curveLengths.push(N4 + 1);
+        }
+        try {
+          const faceId = this.bk.fillCoonsPatch(allCoords, curveLengths);
+          return faceHandle(faceId);
+        } catch (e8) {
+          console.warn("brepkit: Coons patch failed, falling back:", e8);
+        }
+      }
+    }
+    const outerWire2 = wires[0];
+    if (!outerWire2) throw new Error("fillSurface: no wires provided");
+    return this.makeNonPlanarFace(outerWire2);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Private helpers
+  // ═══════════════════════════════════════════════════════════════════════
+  applyMatrix(shape2, matrix) {
+    const h8 = shape2;
+    if (!isBrepkitHandle(shape2)) {
+      throw new Error("brepkit: applyMatrix requires a BrepkitHandle");
+    }
+    switch (h8.type) {
+      case "solid": {
+        const copy = this.bk.copySolid(h8.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(h8.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(h8.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(h8.id);
+        this.bk.transformEdge(copy, matrix);
+        return edgeHandle(copy);
+      }
+      default:
+        throw new Error(`brepkit: applyMatrix does not support '${h8.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 result = 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) {
+        result = this.rotate(result, 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);
+        result = this.rotate(result, angleDeg, axis);
+      }
+    }
+    if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) {
+      result = this.translate(result, center[0], center[1], center[2]);
+    }
+    return result;
+  }
+  /** 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 v9 of positions) allVertices.push(v9);
+        for (const n9 of normals) allNormals.push(n9);
+        for (const idx of indices) {
+          allTriangles.push(idx + vertexOffset);
+        }
+        for (let i7 = 0; i7 < vertCount; i7++) {
+          allUVs.push(0, 0);
+        }
+        faceGroups.push({
+          start: triStart,
+          count: indices.length,
+          faceHash: faceId
+        });
+        vertexOffset += vertCount;
+      } catch (e8) {
+        console.warn(`brepkit: face tessellation failed (faceId=${faceId}):`, e8);
+      }
+    }
+    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 i7 = 0; i7 < vertCount; i7++) {
+      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 i7 = 0; i7 <= nSegments; i7++) {
+      const angle = startAngle + i7 * 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 (i7 > 0) {
+        const midAngle = startAngle + (i7 - 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 i7 = 1; i7 < nSegments; i7++) {
+      knots.push(i7, i7);
+    }
+    knots.push(...Array(degree + 1).fill(nSegments));
+    const kMax = knots[knots.length - 1];
+    for (let i7 = 0; i7 < knots.length; i7++) {
+      knots[i7] = knots[i7] / 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 h8 = shape2;
+    if (h8.type !== "edge") return null;
+    const nurbsJson = this.bk.getEdgeNurbsData(h8.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(h8.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 i7 = 0; i7 <= nSegments; i7++) {
+      const angle = startAngle + i7 * 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 (i7 > 0) {
+        const midAngle = startAngle + (i7 - 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 i7 = 1; i7 < nSegments; i7++) {
+      knots.push(i7, i7);
+    }
+    knots.push(...Array(degree + 1).fill(nSegments));
+    const kMax = knots[knots.length - 1];
+    for (let i7 = 0; i7 < knots.length; i7++) {
+      knots[i7] = knots[i7] / 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 h8 = faceShape;
+    if (h8.type === "solid" || h8.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 f12 of faces) {
+        const id = unwrap(f12, "face");
+        try {
+          const a9 = this.bk.faceArea(id, DEFAULT_DEFLECTION);
+          if (a9 > bestArea) {
+            bestArea = a9;
+            bestId = id;
+          }
+        } catch {
+        }
+      }
+      faceId = bestId;
+    } else {
+      faceId = unwrap(faceShape, "face");
+    }
+    const n9 = this.bk.getFaceNormal(faceId);
+    const normal = [n9[0], n9[1], n9[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(a9, b10) {
+  const result = new Array(16).fill(0);
+  for (let i7 = 0; i7 < 4; i7++) {
+    for (let j6 = 0; j6 < 4; j6++) {
+      for (let k7 = 0; k7 < 4; k7++) {
+        result[i7 * 4 + j6] = result[i7 * 4 + j6] + a9[i7 * 4 + k7] * b10[k7 * 4 + j6];
+      }
+    }
+  }
+  return result;
+}
 const errorFactories = {
   KERNEL_OPERATION: (code, message, cause) => ({ kind: "KERNEL_OPERATION", code, message, cause }),
   VALIDATION: (code, message, cause) => ({ kind: "VALIDATION", code, message, cause }),
@@ -1438,7 +5643,7 @@ function checkAllInterferences(shapes, tolerance = 1e-6) {
   shapes.forEach((si, i7) => {
     for (let j6 = i7 + 1; j6 < shapes.length; j6++) {
       if (aabbDisjoint(boxes[i7], boxes[j6], tolerance)) continue;
-      const result = unwrap(checkInterference(si, shapes[j6], tolerance));
+      const result = unwrap$1(checkInterference(si, shapes[j6], tolerance));
       if (result.hasInterference) {
         pairs.push({ i: i7, j: j6, result });
       }
@@ -2617,6 +6822,7 @@ export {
   BrepBugError,
   BrepErrorCode,
   BrepWrapperError,
+  BrepkitAdapter,
   C5 as CompoundBlueprint,
   C6 as CompoundSketch,
   C3 as Curve2D,
@@ -3031,7 +7237,7 @@ export {
   typeCastError,
   F2 as undoLast,
   u as unsupportedError,
-  unwrap,
+  unwrap$1 as unwrap,
   v2 as unwrapErr,
   w2 as unwrapOr,
   x2 as unwrapOrElse,