brepjs 12.7.1 → 12.7.3

package/dist/brepjs.js

@@ -26,10 +26,10 @@ var __using = (stack, value, async) => {
   return value;
 };
 var __callDispose = (stack, error, hasError) => {
-  var E6 = typeof SuppressedError === "function" ? SuppressedError : function(e8, s6, m10, _2) {
+  var E7 = typeof SuppressedError === "function" ? SuppressedError : function(e8, s6, m10, _2) {
     return _2 = Error(m10), _2.name = "SuppressedError", _2.error = e8, _2.suppressed = s6, _2;
   };
-  var fail = (e8) => error = hasError ? new E6(e8, error, "An error was suppressed during disposal") : (hasError = true, e8);
+  var fail = (e8) => error = hasError ? new E7(e8, error, "An error was suppressed during disposal") : (hasError = true, e8);
   var next = (it) => {
     while (it = stack.pop()) {
       try {
@@ -49,39 +49,39 @@ import { o as ok, z as translateKernelError, e as err, p as typeCastError, q as
 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-CtuUvzex.js";
-import { b as b4, g as g4, r } from "./loft-DsVv4yxU.js";
-import { w as walkAssembly, e as extrude$1, r as revolve$1, s as sweep, c as circularPattern, l as linearPattern } from "./operations-D_3rrfrE.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-D_3rrfrE.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-x2irapGj.js";
+import { B, e as e3, C as C3, u as u2 } from "./Blueprint-C3lWY1Jf.js";
+import { b as b4, g as g4, r } from "./loft-BcZUCGKi.js";
+import { w as walkAssembly, e as extrude$1, r as revolve$1, s as sweep, c as circularPattern, l as linearPattern } from "./operations-Dcz6YlOt.js";
+import { a as a4, b as b5, d as d3, 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 t3, u as u3, 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-Dcz6YlOt.js";
+import { B as B3, a as a5, c as c2, C as C5, F as F3, S as S2, d as d4, j as j3, f as f4, k as k3, h as h5, l as l4, o as o4, p as p2, r as r2 } from "./boolean2D-CwZAIJDS.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-DeFPsrcI.js";
-import { g as g7 } from "./helpers-DeFPsrcI.js";
+import { l as createTypedFinder, m as faceFinder } from "./helpers-C9KvE1RW.js";
+import { g as g6 } from "./helpers-C9KvE1RW.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-D8QyY7cg.js";
+import { C as C6, D as D4, a as a6, S as S3, b as b6, X, Y, c as c3, d as d5, e as e4, f as f5, Z, g as g7, h as h6, i as i4, j as j4, k as k4, l as l5, m as m5, n as n4, o as o5, p as p3, q as q2, r as r3, s as s3, t as t4, u as u4, 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-5myJTgtX.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, b 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-CbXxLvV_.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-CbXxLvV_.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-DtOkwLHI.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-DtOkwLHI.js";
-import { c as chamferDistAngle, h as heal$1, i as isValid$1 } from "./topology-C1eZ86dI.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-C1eZ86dI.js";
-import { e as curveIsClosed, d as curveStartPoint, c as curveTangentAt, h as curvePointAt, a as curveEndPoint, i as curveLength } from "./curveFns-LRNGcHXh.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-LRNGcHXh.js";
+import { r as r4, t as t5 } from "./types-CWDdqcrq.js";
+import { c as c4, a as a7, p as p4, r as r5, t as t6 } from "./vectors-CESkzEm6.js";
+import { v as vertexPosition, a as getFaces, e as getVertices, d as getEdges, h as getBounds, b 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-D2PlLFE6.js";
+import { w as w4, f as f6, x as x5, y as y4, i as i5, z as z4, A as A5, B as B5, C as C7, D as D5, E as E5 } from "./shapeFns-D2PlLFE6.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-CcNUsgI8.js";
+import { l as l6, m as m6, n as n5, o as o6, q as q3, r as r6, t as t7, u as u5, v as v6 } from "./booleanFns-CcNUsgI8.js";
+import { c as chamferDistAngle, h as heal$1, i as isValid$1 } from "./topology-DxD58iQ6.js";
+import { a as a8, b as b7, d as d6, e as e5, f as f7, g as g8, j as j5, k as k5, l as l7, m as m7, n as n6, o as o7, p as p5, q as q4, r as r7, s as s4, t as t8, u as u6, 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 E6, 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-DxD58iQ6.js";
+import { b as curveIsClosed, c as curveStartPoint, a as curveTangentAt, d as curvePointAt, e as curveEndPoint, f as curveLength } from "./curveFns-CloOqAQ_.js";
+import { h as h7, i as i6, j as j6, k as k6, l as l8, g as g9, m as m8, o as o8 } from "./curveFns-CloOqAQ_.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-B6ebRh5I.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, w as w6, u as u6, h as h6 } from "./faceFns-B6ebRh5I.js";
-import { m as mesh$1, a as meshEdges$1 } from "./meshFns-HNwWuM4v.js";
-import { c as c5, b as b9, e as e6, d as d8, f as f10 } from "./meshFns-HNwWuM4v.js";
+import { l as l9, c as c5, m as m9, d as d7, f as f8, q as q5, r as r8, s as s5, p as p6, t as t9, v as v8, w as w6, u as u7, h as h8 } from "./faceFns-B6ebRh5I.js";
+import { m as mesh$1, a as meshEdges$1 } from "./meshFns-DsLRd3tA.js";
+import { c as c6, b as b8, e as e6, d as d8, f as f9 } from "./meshFns-DsLRd3tA.js";
 import { m as measureArea, a as measureSurfaceProps, b as measureVolumeProps, c as measureVolume } from "./measurement-oWvhSVZG.js";
-import { d as d9, e as e7, f as f11, g as g11, h as h7, i as i6 } from "./measurement-oWvhSVZG.js";
-import { m as makeFace } from "./surfaceBuilders-D7ZH2QNS.js";
-import { n as n8 } from "./surfaceBuilders-D7ZH2QNS.js";
+import { d as d9, e as e7, f as f10, g as g10, h as h9, i as i7 } from "./measurement-oWvhSVZG.js";
+import { m as makeFace } from "./surfaceBuilders-D6iDVPIM.js";
+import { i as i8 } from "./surfaceBuilders-D6iDVPIM.js";
 import { edgeFinder } from "./query.js";
 import { c as makeCylinder } from "./solidBuilders-BXhh5hP2.js";
 import { BrepBugError, bug } from "./result.js";
-import { c as c6 } from "./cornerFinder-FY38t0zq.js";
+import { c as c7 } from "./cornerFinder-BV-l1BCw.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;
@@ -89,91 +89,91 @@ function supportsProjection(kernel) {
 function supportsConstraintSketch(kernel) {
   return "sketchNew" in kernel && "sketchDof" in kernel;
 }
-function evaluateCurve2d(c7, t11) {
-  switch (c7.__bk2d) {
+function evaluateCurve2d(c8, t10) {
+  switch (c8.__bk2d) {
     case "line":
-      return [c7.ox + c7.dx * t11, c7.oy + c7.dy * t11];
+      return [c8.ox + c8.dx * t10, c8.oy + c8.dy * t10];
     case "circle": {
-      const angle = c7.sense ? t11 : -t11;
-      return [c7.cx + c7.radius * Math.cos(angle), c7.cy + c7.radius * Math.sin(angle)];
+      const angle = c8.sense ? t10 : -t10;
+      return [c8.cx + c8.radius * Math.cos(angle), c8.cy + c8.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];
+      const angle = c8.sense ? t10 : -t10;
+      const cos = Math.cos(c8.xDirAngle);
+      const sin = Math.sin(c8.xDirAngle);
+      const x7 = c8.majorRadius * Math.cos(angle);
+      const y6 = c8.minorRadius * Math.sin(angle);
+      return [c8.cx + x7 * cos - y6 * sin, c8.cy + x7 * sin + y6 * cos];
     }
     case "bezier":
-      return evaluateBezier(c7.poles, t11);
+      return evaluateBezier(c8.poles, t10);
     case "bspline":
-      return evaluateBSpline2d(c7, t11);
+      return evaluateBSpline2d(c8, t10);
     case "trimmed": {
-      const mapped = c7.tStart + t11 * (c7.tEnd - c7.tStart);
-      return evaluateCurve2d(c7.basis, mapped);
+      const mapped = c8.tStart + t10 * (c8.tEnd - c8.tStart);
+      return evaluateCurve2d(c8.basis, mapped);
     }
   }
 }
-function tangentCurve2d(c7, t11) {
-  switch (c7.__bk2d) {
+function tangentCurve2d(c8, t10) {
+  switch (c8.__bk2d) {
     case "line":
-      return [c7.dx, c7.dy];
+      return [c8.dx, c8.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];
+      const angle = c8.sense ? t10 : -t10;
+      const sign = c8.sense ? 1 : -1;
+      return [-c8.radius * Math.sin(angle) * sign, c8.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;
+      const angle = c8.sense ? t10 : -t10;
+      const sign = c8.sense ? 1 : -1;
+      const cos = Math.cos(c8.xDirAngle);
+      const sin = Math.sin(c8.xDirAngle);
+      const dx = -c8.majorRadius * Math.sin(angle) * sign;
+      const dy = c8.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);
+      const h10 = 1e-8;
+      const p0 = evaluateBezier(c8.poles, Math.max(0, t10 - h10));
+      const p1 = evaluateBezier(c8.poles, Math.min(1, t10 + h10));
+      const dt = Math.min(1, t10 + h10) - Math.max(0, t10 - h10);
       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);
+      const h10 = 1e-8;
+      const kFirst = c8.knots[0];
+      const kLast = c8.knots[c8.knots.length - 1];
+      const p0 = evaluateBSpline2d(c8, Math.max(kFirst, t10 - h10));
+      const p1 = evaluateBSpline2d(c8, Math.min(kLast, t10 + h10));
+      const dt = Math.min(kLast, t10 + h10) - Math.max(kFirst, t10 - h10);
       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;
+      const mapped = c8.tStart + t10 * (c8.tEnd - c8.tStart);
+      const tan = tangentCurve2d(c8.basis, mapped);
+      const scale2 = c8.tEnd - c8.tStart;
       return [tan[0] * scale2, tan[1] * scale2];
     }
   }
 }
-function curveBounds(c7) {
-  switch (c7.__bk2d) {
+function curveBounds(c8) {
+  switch (c8.__bk2d) {
     case "line":
-      return { first: 0, last: c7.len };
+      return { first: 0, last: c8.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] };
+      return { first: c8.knots[0], last: c8.knots[c8.knots.length - 1] };
     case "trimmed":
       return { first: 0, last: 1 };
   }
 }
-function curveTypeName(c7) {
-  switch (c7.__bk2d) {
+function curveTypeName(c8) {
+  switch (c8.__bk2d) {
     case "line":
       return "LINE";
     case "circle":
@@ -185,7 +185,7 @@ function curveTypeName(c7) {
     case "bspline":
       return "BSPLINE_CURVE";
     case "trimmed":
-      return "TRIMMED_" + curveTypeName(c7.basis);
+      return "TRIMMED_" + curveTypeName(c8.basis);
   }
 }
 function makeLine2d(x1, y1, x22, y22) {
@@ -218,23 +218,23 @@ function makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX = 1, xDirY = 0, s
 function makeBezier2d(poles) {
   return { __bk2d: "bezier", poles: [...poles] };
 }
-function translateCurve2d(c7, dx, dy) {
-  switch (c7.__bk2d) {
+function translateCurve2d(c8, dx, dy) {
+  switch (c8.__bk2d) {
     case "line":
-      return { ...c7, ox: c7.ox + dx, oy: c7.oy + dy };
+      return { ...c8, ox: c8.ox + dx, oy: c8.oy + dy };
     case "circle":
-      return { ...c7, cx: c7.cx + dx, cy: c7.cy + dy };
+      return { ...c8, cx: c8.cx + dx, cy: c8.cy + dy };
     case "ellipse":
-      return { ...c7, cx: c7.cx + dx, cy: c7.cy + dy };
+      return { ...c8, cx: c8.cx + dx, cy: c8.cy + dy };
     case "bezier":
-      return { ...c7, poles: c7.poles.map(([x7, y6]) => [x7 + dx, y6 + dy]) };
+      return { ...c8, poles: c8.poles.map(([x7, y6]) => [x7 + dx, y6 + dy]) };
     case "bspline":
-      return { ...c7, poles: c7.poles.map(([x7, y6]) => [x7 + dx, y6 + dy]) };
+      return { ...c8, poles: c8.poles.map(([x7, y6]) => [x7 + dx, y6 + dy]) };
     case "trimmed":
-      return { ...c7, basis: translateCurve2d(c7.basis, dx, dy) };
+      return { ...c8, basis: translateCurve2d(c8.basis, dx, dy) };
   }
 }
-function rotateCurve2d(c7, angle, cx, cy) {
+function rotateCurve2d(c8, angle, cx, cy) {
   const cos = Math.cos(angle);
   const sin = Math.sin(angle);
   const rotatePoint = (x7, y6) => {
@@ -242,65 +242,65 @@ function rotateCurve2d(c7, angle, cx, cy) {
     const ry = y6 - cy;
     return [cx + rx * cos - ry * sin, cy + rx * sin + ry * cos];
   };
-  switch (c7.__bk2d) {
+  switch (c8.__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 };
+      const [ox, oy] = rotatePoint(c8.ox, c8.oy);
+      const ndx = c8.dx * cos - c8.dy * sin;
+      const ndy = c8.dx * sin + c8.dy * cos;
+      return { ...c8, ox, oy, dx: ndx, dy: ndy };
     }
     case "circle": {
-      const [ncx, ncy] = rotatePoint(c7.cx, c7.cy);
-      return { ...c7, cx: ncx, cy: ncy };
+      const [ncx, ncy] = rotatePoint(c8.cx, c8.cy);
+      return { ...c8, cx: ncx, cy: ncy };
     }
     case "ellipse": {
-      const [ncx, ncy] = rotatePoint(c7.cx, c7.cy);
-      return { ...c7, cx: ncx, cy: ncy, xDirAngle: c7.xDirAngle + angle };
+      const [ncx, ncy] = rotatePoint(c8.cx, c8.cy);
+      return { ...c8, cx: ncx, cy: ncy, xDirAngle: c8.xDirAngle + angle };
     }
     case "bezier":
-      return { ...c7, poles: c7.poles.map(([x7, y6]) => rotatePoint(x7, y6)) };
+      return { ...c8, poles: c8.poles.map(([x7, y6]) => rotatePoint(x7, y6)) };
     case "bspline":
-      return { ...c7, poles: c7.poles.map(([x7, y6]) => rotatePoint(x7, y6)) };
+      return { ...c8, poles: c8.poles.map(([x7, y6]) => rotatePoint(x7, y6)) };
     case "trimmed":
-      return { ...c7, basis: rotateCurve2d(c7.basis, angle, cx, cy) };
+      return { ...c8, basis: rotateCurve2d(c8.basis, angle, cx, cy) };
   }
 }
-function scaleCurve2d(c7, factor, cx, cy) {
+function scaleCurve2d(c8, factor, cx, cy) {
   const scalePoint = (x7, y6) => [
     cx + (x7 - cx) * factor,
     cy + (y6 - cy) * factor
   ];
-  switch (c7.__bk2d) {
+  switch (c8.__bk2d) {
     case "line": {
-      const [ox, oy] = scalePoint(c7.ox, c7.oy);
-      return { ...c7, ox, oy };
+      const [ox, oy] = scalePoint(c8.ox, c8.oy);
+      return { ...c8, ox, oy };
     }
     case "circle": {
-      const [ncx, ncy] = scalePoint(c7.cx, c7.cy);
-      return { ...c7, cx: ncx, cy: ncy, radius: c7.radius * Math.abs(factor) };
+      const [ncx, ncy] = scalePoint(c8.cx, c8.cy);
+      return { ...c8, cx: ncx, cy: ncy, radius: c8.radius * Math.abs(factor) };
     }
     case "ellipse": {
-      const [ncx, ncy] = scalePoint(c7.cx, c7.cy);
+      const [ncx, ncy] = scalePoint(c8.cx, c8.cy);
       return {
-        ...c7,
+        ...c8,
         cx: ncx,
         cy: ncy,
-        majorRadius: c7.majorRadius * Math.abs(factor),
-        minorRadius: c7.minorRadius * Math.abs(factor)
+        majorRadius: c8.majorRadius * Math.abs(factor),
+        minorRadius: c8.minorRadius * Math.abs(factor)
       };
     }
     case "bezier":
-      return { ...c7, poles: c7.poles.map(([x7, y6]) => scalePoint(x7, y6)) };
+      return { ...c8, poles: c8.poles.map(([x7, y6]) => scalePoint(x7, y6)) };
     case "bspline":
-      return { ...c7, poles: c7.poles.map(([x7, y6]) => scalePoint(x7, y6)) };
+      return { ...c8, poles: c8.poles.map(([x7, y6]) => scalePoint(x7, y6)) };
     case "trimmed":
-      return { ...c7, basis: scaleCurve2d(c7.basis, factor, cx, cy) };
+      return { ...c8, basis: scaleCurve2d(c8.basis, factor, cx, cy) };
   }
 }
-function mirrorAtPoint(c7, cx, cy) {
-  return scaleCurve2d(c7, -1, cx, cy);
+function mirrorAtPoint(c8, cx, cy) {
+  return scaleCurve2d(c8, -1, cx, cy);
 }
-function mirrorAcrossAxis(c7, ox, oy, dx, dy) {
+function mirrorAcrossAxis(c8, ox, oy, dx, dy) {
   const len = Math.sqrt(dx * dx + dy * dy);
   const nx = dx / len;
   const ny = dy / len;
@@ -310,33 +310,33 @@ function mirrorAcrossAxis(c7, ox, oy, dx, dy) {
     const dot = rx * nx + ry * ny;
     return [ox + 2 * dot * nx - rx, oy + 2 * dot * ny - ry];
   };
-  switch (c7.__bk2d) {
+  switch (c8.__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 };
+      const [nox, noy] = reflectPoint(c8.ox, c8.oy);
+      const ndx = 2 * (c8.dx * nx + c8.dy * ny) * nx - c8.dx;
+      const ndy = 2 * (c8.dx * nx + c8.dy * ny) * ny - c8.dy;
+      return { ...c8, 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 };
+      const [ncx, ncy] = reflectPoint(c8.cx, c8.cy);
+      return { ...c8, cx: ncx, cy: ncy, sense: !c8.sense };
     }
     case "ellipse": {
-      const [ncx, ncy] = reflectPoint(c7.cx, c7.cy);
+      const [ncx, ncy] = reflectPoint(c8.cx, c8.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)
+        sin2 * Math.cos(c8.xDirAngle) - cos2 * Math.sin(c8.xDirAngle),
+        cos2 * Math.cos(c8.xDirAngle) + sin2 * Math.sin(c8.xDirAngle)
       );
-      return { ...c7, cx: ncx, cy: ncy, xDirAngle: newAngle, sense: !c7.sense };
+      return { ...c8, cx: ncx, cy: ncy, xDirAngle: newAngle, sense: !c8.sense };
     }
     case "bezier":
-      return { ...c7, poles: c7.poles.map(([x7, y6]) => reflectPoint(x7, y6)) };
+      return { ...c8, poles: c8.poles.map(([x7, y6]) => reflectPoint(x7, y6)) };
     case "bspline":
-      return { ...c7, poles: c7.poles.map(([x7, y6]) => reflectPoint(x7, y6)) };
+      return { ...c8, poles: c8.poles.map(([x7, y6]) => reflectPoint(x7, y6)) };
     case "trimmed":
-      return { ...c7, basis: mirrorAcrossAxis(c7.basis, ox, oy, dx, dy) };
+      return { ...c8, basis: mirrorAcrossAxis(c8.basis, ox, oy, dx, dy) };
   }
 }
 function intersectCurves2dFn(c1, c22, tolerance) {
@@ -357,34 +357,34 @@ function intersectCurves2dFn(c1, c22, tolerance) {
   const isSelf = c1 === c22;
   return numericalIntersect(c1, c22, tolerance, isSelf);
 }
-function unwrapCurve(c7) {
-  let cur = c7;
+function unwrapCurve(c8) {
+  let cur = c8;
   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 inDomain(c8, t10, tol) {
+  const b9 = curveBounds(c8);
+  return t10 >= b9.first - tol && t10 <= b9.last + tol;
 }
-function refineParam(c7, px, py) {
-  const bounds = curveBounds(c7);
+function refineParam(c8, px, py) {
+  const bounds = curveBounds(c8);
   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);
+  for (let i9 = 0; i9 <= N4; i9++) {
+    const t10 = bounds.first + i9 * dt;
+    const [ex2, ey2] = evaluateCurve2d(c8, t10);
     const d10 = (ex2 - px) ** 2 + (ey2 - py) ** 2;
     if (d10 < bestD) {
       bestD = d10;
-      bestT = t11;
+      bestT = t10;
     }
   }
-  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 [sx, sy] = evaluateCurve2d(c8, bounds.first);
+  const [ex, ey] = evaluateCurve2d(c8, bounds.last);
+  const [mx, my] = evaluateCurve2d(c8, (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),
@@ -427,14 +427,14 @@ 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;
+  const b9 = 2 * (fx * line.dx + fy * line.dy);
+  const c8 = fx * fx + fy * fy - circ.radius * circ.radius;
+  const disc = b9 * b9 - 4 * a9 * c8;
   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);
+  const t1 = (-b9 - sqrtDisc) / (2 * a9);
+  const t22 = (-b9 + 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;
@@ -456,12 +456,12 @@ function intersectCircleCircle(c1, circ1, c22, circ2, tol) {
   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 h10 = 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 candidates = h10 < tol ? [[mx, my]] : [
+    [mx + h10 * dy / d10, my - h10 * dx / d10],
+    [mx - h10 * dy / d10, my + h10 * dx / d10]
   ];
   const results = [];
   for (const [px, py] of candidates) {
@@ -486,22 +486,22 @@ function numericalIntersect(c1, c22, tolerance, isSelf = false) {
   const N4 = 100;
   const pts1 = [];
   const pts2 = [];
-  for (let i7 = 0; i7 <= N4; i7++) {
-    const t1 = b1.first + (b1.last - b1.first) * i7 / N4;
+  for (let i9 = 0; i9 <= N4; i9++) {
+    const t1 = b1.first + (b1.last - b1.first) * i9 / 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 t22 = b22.first + (b22.last - b22.first) * i9 / 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];
+  for (let i9 = 0; i9 < N4; i9++) {
+    const p1a = pts1[i9];
+    const p1b = pts1[i9 + 1];
+    for (let j7 = 0; j7 < N4; j7++) {
+      const p2a = pts2[j7];
+      const p2b = pts2[j7 + 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;
@@ -557,8 +557,8 @@ function numericalIntersect(c1, c22, tolerance, isSelf = false) {
   }
   return { points: found, segments: [] };
 }
-function serializeCurve2d(c7) {
-  return JSON.stringify(c7);
+function serializeCurve2d(c8) {
+  return JSON.stringify(c8);
 }
 function deserializeCurve2d(data) {
   return JSON.parse(data);
@@ -566,68 +566,68 @@ function deserializeCurve2d(data) {
 function createBBox2d() {
   return { __bk2d_bbox: true, xMin: Infinity, yMin: Infinity, xMax: -Infinity, yMax: -Infinity };
 }
-function addCurveToBBox(bbox, c7, _tol) {
-  const bounds = curveBounds(c7);
+function addCurveToBBox(bbox, c8, _tol) {
+  const bounds = curveBounds(c8);
   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);
+  for (let i9 = 0; i9 <= nSamples; i9++) {
+    const t10 = bounds.first + i9 * dt;
+    const [x7, y6] = evaluateCurve2d(c8, t10);
     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;
+function evaluateBezier(poles, t10) {
+  const n7 = 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];
+  for (let r9 = 1; r9 < n7; r9++) {
+    for (let i9 = 0; i9 < n7 - r9; i9++) {
+      const wi = work[i9];
+      const wi1 = work[i9 + 1];
+      wi[0] = (1 - t10) * wi[0] + t10 * wi1[0];
+      wi[1] = (1 - t10) * wi[1] + t10 * wi1[1];
     }
   }
   return work[0];
 }
-function evaluateBSpline2d(c7, t11) {
+function evaluateBSpline2d(c8, t10) {
   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]);
+  for (let i9 = 0; i9 < c8.knots.length; i9++) {
+    const mult = c8.multiplicities[i9] ?? 1;
+    for (let j7 = 0; j7 < mult; j7++) {
+      fullKnots.push(c8.knots[i9]);
     }
   }
-  const p7 = c7.degree;
-  const n9 = c7.poles.length;
+  const p7 = c8.degree;
+  const n7 = c8.poles.length;
   const k7 = fullKnots.length;
-  const tClamped = Math.max(fullKnots[p7], Math.min(fullKnots[k7 - p7 - 1], t11));
+  const tClamped = Math.max(fullKnots[p7], Math.min(fullKnots[k7 - p7 - 1], t10));
   let span = p7;
-  for (let i7 = p7; i7 < k7 - p7 - 1; i7++) {
-    if (tClamped >= fullKnots[i7] && tClamped < fullKnots[i7 + 1]) {
-      span = i7;
+  for (let i9 = p7; i9 < k7 - p7 - 1; i9++) {
+    if (tClamped >= fullKnots[i9] && tClamped < fullKnots[i9 + 1]) {
+      span = i9;
       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)];
+  for (let j7 = 0; j7 <= p7; j7++) {
+    const idx = Math.min(span - p7 + j7, n7 - 1);
+    const pole = c8.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;
+    for (let j7 = p7; j7 >= r9; j7--) {
+      const i9 = span - p7 + j7;
+      const left = fullKnots[i9] ?? 0;
+      const right = fullKnots[i9 + 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];
+      const dj = d10[j7];
+      const djPrev = d10[j7 - 1];
       dj[0] = (1 - alpha) * djPrev[0] + alpha * dj[0];
       dj[1] = (1 - alpha) * djPrev[1] + alpha * dj[1];
     }
@@ -669,11 +669,11 @@ function shellHandle(id) {
   return handle("shell", id);
 }
 function compoundHandle(id) {
-  const h8 = handle("compound", id);
+  const h10 = handle("compound", id);
   if (syntheticCompounds.has(id)) {
-    return { ...h8, delete: () => syntheticCompounds.delete(id) };
+    return { ...h10, delete: () => syntheticCompounds.delete(id) };
   }
-  return h8;
+  return h10;
 }
 function vertexHandle(id) {
   return handle("vertex", id);
@@ -746,20 +746,20 @@ function translationMatrix(x7, y6, z6) {
 }
 function rotationMatrix(angleDeg, axis = [0, 0, 1], center = [0, 0, 0]) {
   const rad = angleDeg * Math.PI / 180;
-  const c7 = Math.cos(rad);
+  const c8 = Math.cos(rad);
   const s6 = Math.sin(rad);
-  const t11 = 1 - c7;
+  const t10 = 1 - c8;
   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 r00 = t10 * ux * ux + c8;
+  const r01 = t10 * ux * uy - s6 * uz;
+  const r02 = t10 * ux * uz + s6 * uy;
+  const r10 = t10 * uy * ux + s6 * uz;
+  const r11 = t10 * uy * uy + c8;
+  const r12 = t10 * uy * uz - s6 * ux;
+  const r20 = t10 * uz * ux - s6 * uy;
+  const r21 = t10 * uz * uy + s6 * ux;
+  const r22 = t10 * uz * uz + c8;
   const [cx, cy, cz] = center;
   const tx = cx - (r00 * cx + r01 * cy + r02 * cz);
   const ty = cy - (r10 * cx + r11 * cy + r12 * cz);
@@ -949,9 +949,9 @@ class BrepkitAdapter {
     if (this.bk.compoundFuse) {
       const solidIds = [];
       for (const shape2 of shapes) {
-        const h8 = shape2;
-        if (h8.type === "compound") {
-          solidIds.push(...toArray(this.bk.getCompoundSolids(h8.id)));
+        const h10 = shape2;
+        if (h10.type === "compound") {
+          solidIds.push(...toArray(this.bk.getCompoundSolids(h10.id)));
         } else {
           solidIds.push(unwrapSolidOrThrow(shape2, "fuseAll"));
         }
@@ -965,11 +965,11 @@ class BrepkitAdapter {
     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));
+      for (let i9 = 0; i9 < current.length; i9 += 2) {
+        if (i9 + 1 < current.length) {
+          next.push(this.fuse(current[i9], current[i9 + 1], options));
         } else {
-          next.push(current[i7]);
+          next.push(current[i9]);
         }
       }
       current = next;
@@ -982,9 +982,9 @@ class BrepkitAdapter {
     const baseId = unwrapSolidOrThrow(shape2, "cutAll");
     const toolIds = [];
     for (const tool of tools) {
-      const h8 = tool;
-      if (h8.type === "compound") {
-        toolIds.push(...toArray(this.bk.getCompoundSolids(h8.id)));
+      const h10 = tool;
+      if (h10.type === "compound") {
+        toolIds.push(...toArray(this.bk.getCompoundSolids(h10.id)));
       } else {
         toolIds.push(unwrapSolidOrThrow(tool, "cutAll"));
       }
@@ -1015,15 +1015,15 @@ class BrepkitAdapter {
   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));
+      const h10 = shape2;
+      if (h10.type === "solid") {
+        const vertIds = toArray(this.bk.getSolidVertices(h10.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);
+      } else if (h10.type === "vertex") {
+        const pos = this.bk.getVertexPosition(h10.id);
         coords.push(pos[0], pos[1], pos[2]);
       }
     }
@@ -1042,18 +1042,18 @@ class BrepkitAdapter {
   }
   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;
+    for (let i9 = 0; i9 < points.length; i9++) {
+      const p7 = points[i9];
+      positions[i9 * 3] = p7.x;
+      positions[i9 * 3 + 1] = p7.y;
+      positions[i9 * 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];
+    for (let i9 = 0; i9 < faces.length; i9++) {
+      const f11 = faces[i9];
+      indices[i9 * 3] = f11[0];
+      indices[i9 * 3 + 1] = f11[1];
+      indices[i9 * 3 + 2] = f11[2];
     }
     const id = this.bk.importIndexedMesh(positions, indices);
     return solidHandle(id);
@@ -1091,9 +1091,9 @@ class BrepkitAdapter {
   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))) {
+      const h10 = e8;
+      if (h10.type === "wire") {
+        for (const childEdgeId of toArray(this.bk.getWireEdges(h10.id))) {
           edgeIds.push(childEdgeId);
         }
       } else {
@@ -1104,9 +1104,9 @@ class BrepkitAdapter {
     return wireHandle(id);
   }
   makeFace(wire, _planar) {
-    const h8 = wire;
-    if (h8.type === "edge") {
-      const wireId = this.bk.makeWire([h8.id], true);
+    const h10 = wire;
+    if (h10.type === "edge") {
+      const wireId = this.bk.makeWire([h10.id], true);
       const id2 = this.bk.makeFaceFromWire(wireId);
       return faceHandle(id2);
     }
@@ -1215,23 +1215,21 @@ class BrepkitAdapter {
       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 id = this.bk.makeCircleArc3d(
+      p1[0],
+      p1[1],
+      p1[2],
+      p32[0],
+      p32[1],
+      p32[2],
+      center[0],
+      center[1],
+      center[2],
+      nz[0],
+      nz[1],
+      nz[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);
+    return edgeHandle(id);
   }
   makeEllipseEdge(center, normal, majorRadius, minorRadius, xDir) {
     return this.makeEllipseNurbs(center, normal, majorRadius, minorRadius, 0, 2 * Math.PI, xDir);
@@ -1250,12 +1248,12 @@ class BrepkitAdapter {
   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 n7 = points.length;
     const knots = [...Array(degree + 1).fill(0), ...Array(degree + 1).fill(1)];
-    const weights = Array(n9).fill(1);
+    const weights = Array(n7).fill(1);
     const flatCp = points.flatMap(([x7, y6, z6]) => [x7, y6, z6]);
     const startPt = points[0];
-    const endPt = points[n9 - 1];
+    const endPt = points[n7 - 1];
     const id = this.bk.makeNurbsEdge(
       startPt[0],
       startPt[1],
@@ -1271,21 +1269,73 @@ class BrepkitAdapter {
     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 tLen = Math.sqrt(startTangent[0] ** 2 + startTangent[1] ** 2 + startTangent[2] ** 2);
+    if (tLen < 1e-12) return this.makeLineEdge(startPoint, endPoint);
+    const t10 = [
+      startTangent[0] / tLen,
+      startTangent[1] / tLen,
+      startTangent[2] / tLen
+    ];
+    const ch = [
+      startPoint[0] - endPoint[0],
+      startPoint[1] - endPoint[1],
+      startPoint[2] - endPoint[2]
     ];
-    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))
+    const chDotT = ch[0] * t10[0] + ch[1] * t10[1] + ch[2] * t10[2];
+    const perp = [
+      ch[0] - chDotT * t10[0],
+      ch[1] - chDotT * t10[1],
+      ch[2] - chDotT * t10[2]
     ];
-    return this.makeBezierEdge([startPoint, cp1, cp2, endPoint]);
+    const perpLen = Math.sqrt(perp[0] ** 2 + perp[1] ** 2 + perp[2] ** 2);
+    if (perpLen < 1e-12) return this.makeLineEdge(startPoint, endPoint);
+    const n7 = [perp[0] / perpLen, perp[1] / perpLen, perp[2] / perpLen];
+    const chord2 = ch[0] ** 2 + ch[1] ** 2 + ch[2] ** 2;
+    const nDotCh = n7[0] * ch[0] + n7[1] * ch[1] + n7[2] * ch[2];
+    const s6 = -chord2 / (2 * nDotCh);
+    const center = [
+      startPoint[0] + s6 * n7[0],
+      startPoint[1] + s6 * n7[1],
+      startPoint[2] + s6 * n7[2]
+    ];
+    const radius = Math.abs(s6);
+    const e1 = [
+      (startPoint[0] - center[0]) / radius,
+      (startPoint[1] - center[1]) / radius,
+      (startPoint[2] - center[2]) / radius
+    ];
+    const e22 = [
+      (endPoint[0] - center[0]) / radius,
+      (endPoint[1] - center[1]) / radius,
+      (endPoint[2] - center[2]) / radius
+    ];
+    let mx = e1[0] + e22[0];
+    let my = e1[1] + e22[1];
+    let mz = e1[2] + e22[2];
+    let mLen = Math.sqrt(mx * mx + my * my + mz * mz);
+    if (mLen < 1e-12) {
+      mx = t10[0];
+      my = t10[1];
+      mz = t10[2];
+      mLen = 1;
+    }
+    const mid = [
+      center[0] + radius * mx / mLen,
+      center[1] + radius * my / mLen,
+      center[2] + radius * mz / mLen
+    ];
+    const toMid = [
+      mid[0] - startPoint[0],
+      mid[1] - startPoint[1],
+      mid[2] - startPoint[2]
+    ];
+    const dotTM = t10[0] * toMid[0] + t10[1] * toMid[1] + t10[2] * toMid[2];
+    if (dotTM < 0) {
+      mid[0] = center[0] - radius * mx / mLen;
+      mid[1] = center[1] - radius * my / mLen;
+      mid[2] = center[2] - radius * mz / mLen;
+    }
+    return this.makeArcEdge(startPoint, mid, endPoint);
   }
   makeHelixWire(pitch, height, radius, center, _direction, leftHanded) {
     const turns = height / pitch;
@@ -1296,10 +1346,10 @@ class BrepkitAdapter {
     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]);
+    for (let i9 = 0; i9 <= nSamples; i9++) {
+      const t10 = i9 / nSamples;
+      const angle = sign * 2 * Math.PI * turns * t10;
+      points.push([cx + radius * Math.cos(angle), cy + radius * Math.sin(angle), cz + height * t10]);
     }
     const edge = this.interpolatePoints(points);
     return this.makeWire([edge]);
@@ -1307,11 +1357,11 @@ class BrepkitAdapter {
   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))) {
+      const h10 = item;
+      if (h10.type === "edge") {
+        edgeIds.push(h10.id);
+      } else if (h10.type === "wire") {
+        for (const childEdgeId of toArray(this.bk.getWireEdges(h10.id))) {
           edgeIds.push(childEdgeId);
         }
       }
@@ -1326,9 +1376,9 @@ class BrepkitAdapter {
     if (handles.length === 0) {
       throw new Error("brepkit: makeCompound requires at least one shape");
     }
-    const allSolids = handles.every((h8) => h8.type === "solid");
+    const allSolids = handles.every((h10) => h10.type === "solid");
     if (allSolids) {
-      const id2 = this.bk.makeCompound(handles.map((h8) => h8.id));
+      const id2 = this.bk.makeCompound(handles.map((h10) => h10.id));
       return compoundHandle(id2);
     }
     const id = syntheticCompoundCounter++;
@@ -1337,9 +1387,9 @@ class BrepkitAdapter {
   }
   makeBoxFromCorners(p1, p22) {
     const w7 = Math.abs(p22[0] - p1[0]);
-    const h8 = Math.abs(p22[1] - p1[1]);
+    const h10 = Math.abs(p22[1] - p1[1]);
     const d10 = Math.abs(p22[2] - p1[2]);
-    const box = this.makeBox(w7, h8, d10);
+    const box = this.makeBox(w7, h10, 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]);
@@ -1349,15 +1399,15 @@ class BrepkitAdapter {
     return box;
   }
   solidFromShell(shell2) {
-    const h8 = shell2;
-    if (h8.type === "solid") return shell2;
-    if (h8.type === "shell") {
+    const h10 = shell2;
+    if (h10.type === "solid") return shell2;
+    if (h10.type === "shell") {
       try {
-        this.bk.getSolidFaces(h8.id);
-        return solidHandle(h8.id);
+        this.bk.getSolidFaces(h10.id);
+        return solidHandle(h10.id);
       } catch {
       }
-      const id2 = this.bk.solidFromShell(h8.id);
+      const id2 = this.bk.solidFromShell(h10.id);
       return solidHandle(id2);
     }
     const id = this.bk.solidFromShell(unwrap(shell2, "shell"));
@@ -1418,9 +1468,9 @@ class BrepkitAdapter {
       );
     }
     const faceIds = wires.map((w7) => {
-      const h8 = w7;
-      if (h8.type === "wire") {
-        return this.bk.makeFaceFromWire(h8.id);
+      const h10 = w7;
+      if (h10.type === "wire") {
+        return this.bk.makeFaceFromWire(h10.id);
       }
       return unwrap(w7, "face");
     });
@@ -1486,8 +1536,8 @@ class BrepkitAdapter {
       return solidHandle(this.bk.fillet(solidId, edgeIds, radius));
     }
     const spec = [];
-    for (const [i7, edge] of edges.entries()) {
-      const edgeId = edgeIds[i7] ?? 0;
+    for (const [i9, edge] of edges.entries()) {
+      const edgeId = edgeIds[i9] ?? 0;
       let r9;
       if (typeof radius === "function") {
         r9 = radius(edge);
@@ -1530,8 +1580,8 @@ class BrepkitAdapter {
     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");
+    const resolvedFaceIds = faces.map((f11) => {
+      const fid = unwrap(f11, "face");
       if (solidFaceSet.has(fid)) return fid;
       try {
         const origNormal = this.bk.getFaceNormal(fid);
@@ -1557,9 +1607,9 @@ class BrepkitAdapter {
     return solidHandle(id);
   }
   thicken(shape2, thickness) {
-    const h8 = shape2;
-    if (h8.type === "face") {
-      const id = this.bk.thicken(h8.id, thickness);
+    const h10 = shape2;
+    if (h10.type === "face") {
+      const id = this.bk.thicken(h10.id, thickness);
       return solidHandle(id);
     }
     throw new Error("brepkit: thicken() requires a face");
@@ -1571,9 +1621,9 @@ class BrepkitAdapter {
         "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);
+    const h10 = shape2;
+    if (h10.type === "face") {
+      const id2 = this.bk.thicken(h10.id, distance);
       return solidHandle(id2);
     }
     const id = this.bk.offsetSolid(unwrapSolidOrThrow(shape2, "offset"), distance);
@@ -1595,10 +1645,10 @@ class BrepkitAdapter {
     return this.applyMatrix(shape2, rotationMatrix(angle, axis, center));
   }
   mirror(shape2, origin, normal) {
-    const h8 = shape2;
-    if (h8.type === "solid") {
+    const h10 = shape2;
+    if (h10.type === "solid") {
       const id = this.bk.mirror(
-        h8.id,
+        h10.id,
         origin[0],
         origin[1],
         origin[2],
@@ -1668,16 +1718,16 @@ class BrepkitAdapter {
    * fallback when hash matching fails (brepkit always creates new face IDs).
    */
   buildEvolution(resultShape, inputFaceHashes, hashUpperBound, isTransform, originalShape) {
-    const h8 = resultShape;
+    const h10 = 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));
+    if (h10.type === "solid") {
+      const outputFaces = toArray(this.bk.getSolidFaces(h10.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]]);
+        for (let i9 = 0; i9 < inputFaceHashes.length && i9 < outputHashes.length; i9++) {
+          modified.set(inputFaceHashes[i9], [outputHashes[i9]]);
         }
       } else {
         const inputSet = new Set(inputFaceHashes);
@@ -1715,8 +1765,8 @@ class BrepkitAdapter {
             deleted
           );
         } else {
-          for (let i7 = 0; i7 < inputFaceHashes.length && i7 < outputHashes.length; i7++) {
-            modified.set(inputFaceHashes[i7], [outputHashes[i7]]);
+          for (let i9 = 0; i9 < inputFaceHashes.length && i9 < outputHashes.length; i9++) {
+            modified.set(inputFaceHashes[i9], [outputHashes[i9]]);
           }
           if (outputHashes.length > inputFaceHashes.length && inputFaceHashes.length > 0) {
             generated.set(inputFaceHashes[0], outputHashes.slice(inputFaceHashes.length));
@@ -1756,10 +1806,10 @@ class BrepkitAdapter {
     }
   }
   /** 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];
+  static centroidDistSq(a9, b9) {
+    const dx = a9[0] - b9[0];
+    const dy = a9[1] - b9[1];
+    const dz = a9[2] - b9[2];
     return dx * dx + dy * dy + dz * dz;
   }
   /** Compute face centroid as the average of tessellation vertices. */
@@ -1771,10 +1821,10 @@ class BrepkitAdapter {
       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];
+      for (let i9 = 0; i9 < pos.length; i9 += 3) {
+        cx += pos[i9];
+        cy += pos[i9 + 1];
+        cz += pos[i9 + 2];
       }
       return [cx / nVerts, cy / nVerts, cz / nVerts];
     } catch {
@@ -1791,15 +1841,15 @@ class BrepkitAdapter {
     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];
+    for (let i9 = 0; i9 < hashCount; i9++) {
+      const fid = inputFaceIds[i9];
       try {
         const normal = this.bk.getFaceNormal(fid);
         const centroid = this.faceCentroidById(fid);
-        inputSigs.push({ hash: inputFaceHashes[i7] ?? fid % hashUpperBound, normal, centroid });
+        inputSigs.push({ hash: inputFaceHashes[i9] ?? fid % hashUpperBound, normal, centroid });
       } catch {
         inputSigs.push({
-          hash: inputFaceHashes[i7] ?? fid % hashUpperBound,
+          hash: inputFaceHashes[i9] ?? fid % hashUpperBound,
           normal: [0, 0, 0],
           centroid: this.faceCentroidById(fid)
         });
@@ -1825,8 +1875,8 @@ class BrepkitAdapter {
     for (const out of outputSigs) {
       let bestScore = -Infinity;
       let bestIdx = -1;
-      for (let i7 = 0; i7 < inputSigs.length; i7++) {
-        const inp = inputSigs[i7];
+      for (let i9 = 0; i9 < inputSigs.length; i9++) {
+        const inp = inputSigs[i9];
         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);
@@ -1834,7 +1884,7 @@ class BrepkitAdapter {
         const score = dot - distSq / CENTROID_DIST_SQ_MAX;
         if (score > bestScore) {
           bestScore = score;
-          bestIdx = i7;
+          bestIdx = i9;
         }
       }
       if (bestIdx >= 0) {
@@ -1860,9 +1910,9 @@ class BrepkitAdapter {
         }
       }
     }
-    for (let i7 = 0; i7 < inputSigs.length; i7++) {
-      if (!matchedInputIndices.has(i7)) {
-        deleted.add(inputSigs[i7].hash);
+    for (let i9 = 0; i9 < inputSigs.length; i9++) {
+      if (!matchedInputIndices.has(i9)) {
+        deleted.add(inputSigs[i9].hash);
       }
     }
   }
@@ -1979,8 +2029,8 @@ class BrepkitAdapter {
       inputFaceHashes,
       hashUpperBound,
       options,
-      (a9, b10) => this.bk.fuseWithEvolution(a9, b10),
-      (s6, t11, o9) => this.fuse(s6, t11, o9),
+      (a9, b9) => this.bk.fuseWithEvolution(a9, b9),
+      (s6, t10, o9) => this.fuse(s6, t10, o9),
       "fuseWithHistory"
     );
   }
@@ -1991,8 +2041,8 @@ class BrepkitAdapter {
       inputFaceHashes,
       hashUpperBound,
       options,
-      (a9, b10) => this.bk.cutWithEvolution(a9, b10),
-      (s6, t11, o9) => this.cut(s6, t11, o9),
+      (a9, b9) => this.bk.cutWithEvolution(a9, b9),
+      (s6, t10, o9) => this.cut(s6, t10, o9),
       "cutWithHistory"
     );
   }
@@ -2003,8 +2053,8 @@ class BrepkitAdapter {
       inputFaceHashes,
       hashUpperBound,
       options,
-      (a9, b10) => this.bk.intersectWithEvolution(a9, b10),
-      (s6, t11, o9) => this.intersect(s6, t11, o9),
+      (a9, b9) => this.bk.intersectWithEvolution(a9, b9),
+      (s6, t10, o9) => this.intersect(s6, t10, o9),
       "intersectWithHistory"
     );
   }
@@ -2063,14 +2113,14 @@ class BrepkitAdapter {
         "mesh angularTolerance is not supported; only linear deflection is used."
       );
     }
-    const h8 = unwrap(shape2);
+    const h10 = unwrap(shape2);
     const bkHandle = shape2;
     const deflection = options.tolerance || DEFAULT_DEFLECTION;
     let result;
     if (bkHandle.type === "solid") {
-      result = this.meshSolid(h8, deflection, !!options.includeUVs);
+      result = this.meshSolid(h10, deflection, !!options.includeUVs);
     } else if (bkHandle.type === "face") {
-      result = this.meshSingleFace(h8, deflection, 0);
+      result = this.meshSingleFace(h10, deflection, 0);
     } else {
       throw new Error(`brepkit: cannot mesh shape of type '${bkHandle.type}'`);
     }
@@ -2093,16 +2143,16 @@ class BrepkitAdapter {
     if (bkHandle.type !== "solid") {
       return { lines: new Float32Array(0), edgeGroups: [] };
     }
-    const edgeLines = this.bk.meshEdges(bkHandle.id, tolerance);
+    const edgeLines = this.bk.meshEdgesAll ? this.bk.meshEdgesAll(bkHandle.id, tolerance) : 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;
+    for (let i9 = 0; i9 < edgeCount; i9++) {
+      const startIdx = offsets[i9];
+      const endIdx = i9 + 1 < edgeCount ? offsets[i9 + 1] : positions.length;
       const pointCount = (endIdx - startIdx) / 3;
-      edgeGroups.push({ start: startIdx / 3, count: pointCount, edgeHash: i7 });
+      edgeGroups.push({ start: startIdx / 3, count: pointCount, edgeHash: i9 });
     }
     return {
       lines: new Float32Array(positions),
@@ -2167,11 +2217,11 @@ class BrepkitAdapter {
   // Measurement
   // ═══════════════════════════════════════════════════════════════════════
   volume(shape2) {
-    const h8 = shape2;
-    if (h8.type === "solid") {
+    const h10 = shape2;
+    if (h10.type === "solid") {
       return this.bk.volume(unwrap(shape2), DEFAULT_DEFLECTION);
     }
-    if (h8.type === "compound") {
+    if (h10.type === "compound") {
       const solids = this.iterShapes(shape2, "solid");
       let total = 0;
       for (const s6 of solids) {
@@ -2182,14 +2232,14 @@ class BrepkitAdapter {
     return 0;
   }
   area(shape2) {
-    const h8 = shape2;
-    if (h8.type === "face") {
+    const h10 = shape2;
+    if (h10.type === "face") {
       return this.bk.faceArea(unwrap(shape2), DEFAULT_DEFLECTION);
     }
-    if (h8.type === "solid") {
+    if (h10.type === "solid") {
       return this.bk.surfaceArea(unwrap(shape2), DEFAULT_DEFLECTION);
     }
-    if (h8.type === "compound") {
+    if (h10.type === "compound") {
       const faces = this.iterShapes(shape2, "face");
       let total = 0;
       for (const face of faces) {
@@ -2200,39 +2250,39 @@ class BrepkitAdapter {
     return 0;
   }
   length(shape2) {
-    const h8 = shape2;
-    if (h8.type === "edge") {
+    const h10 = shape2;
+    if (h10.type === "edge") {
       return this.bk.edgeLength(unwrap(shape2));
     }
-    if (h8.type === "face") {
+    if (h10.type === "face") {
       return this.bk.facePerimeter(unwrap(shape2));
     }
-    if (h8.type === "wire") {
-      return this.bk.wireLength(h8.id);
+    if (h10.type === "wire") {
+      return this.bk.wireLength(h10.id);
     }
     throw new Error("brepkit: length() requires an edge, wire, or face");
   }
   centerOfMass(shape2) {
-    const h8 = shape2;
-    if (h8.type === "solid") {
+    const h10 = shape2;
+    if (h10.type === "solid") {
       const result = this.bk.centerOfMass(unwrap(shape2), DEFAULT_DEFLECTION);
       return [result[0], result[1], result[2]];
     }
-    if (h8.type === "face") {
+    if (h10.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);
+    if (h10.type === "edge") {
+      const verts = this.bk.getEdgeVertices(h10.id);
       return [
         (verts[0] + verts[3]) / 2,
         (verts[1] + verts[4]) / 2,
         (verts[2] + verts[5]) / 2
       ];
     }
-    if (h8.type === "vertex") {
+    if (h10.type === "vertex") {
       return this.vertexPosition(shape2);
     }
     const vertices = this.iterShapes(shape2, "vertex");
@@ -2249,9 +2299,9 @@ class BrepkitAdapter {
     return [0, 0, 0];
   }
   linearCenterOfMass(shape2) {
-    const h8 = shape2;
-    if (h8.type === "edge") {
-      const verts = this.bk.getEdgeVertices(h8.id);
+    const h10 = shape2;
+    if (h10.type === "edge") {
+      const verts = this.bk.getEdgeVertices(h10.id);
       return [
         (verts[0] + verts[3]) / 2,
         (verts[1] + verts[4]) / 2,
@@ -2261,15 +2311,15 @@ class BrepkitAdapter {
     return this.centerOfMass(shape2);
   }
   boundingBox(shape2) {
-    const h8 = shape2;
-    if (h8.type === "solid") {
+    const h10 = shape2;
+    if (h10.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") {
+    if (h10.type === "vertex") {
       const pos = this.vertexPosition(shape2);
       return { min: [...pos], max: [...pos] };
     }
@@ -2280,8 +2330,8 @@ class BrepkitAdapter {
     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]);
+    for (let i9 = 1; i9 < vertices.length; i9++) {
+      const p7 = this.vertexPosition(vertices[i9]);
       if (p7[0] < minX) minX = p7[0];
       if (p7[0] > maxX) maxX = p7[0];
       if (p7[1] < minY) minY = p7[1];
@@ -2295,11 +2345,11 @@ class BrepkitAdapter {
   // Topology introspection
   // ═══════════════════════════════════════════════════════════════════════
   iterShapes(shape2, type) {
-    const h8 = unwrap(shape2);
+    const h10 = unwrap(shape2);
     const bkHandle = shape2;
     switch (bkHandle.type) {
       case "compound": {
-        const children = syntheticCompounds.get(h8);
+        const children = syntheticCompounds.get(h10);
         if (children) {
           const results = [];
           for (const child of children) {
@@ -2312,10 +2362,10 @@ class BrepkitAdapter {
           return results;
         }
         if (type === "solid") {
-          return toArray(this.bk.getCompoundSolids(h8)).map(solidHandle);
+          return toArray(this.bk.getCompoundSolids(h10)).map(solidHandle);
         }
         if (type === "face" || type === "edge" || type === "vertex" || type === "wire") {
-          const solids = toArray(this.bk.getCompoundSolids(h8)).map(solidHandle);
+          const solids = toArray(this.bk.getCompoundSolids(h10)).map(solidHandle);
           return solids.flatMap((s6) => this.iterShapes(s6, type));
         }
         return [];
@@ -2323,13 +2373,13 @@ class BrepkitAdapter {
       case "solid": {
         switch (type) {
           case "face":
-            return toArray(this.bk.getSolidFaces(h8)).map(faceHandle);
+            return toArray(this.bk.getSolidFaces(h10)).map(faceHandle);
           case "edge":
-            return toArray(this.bk.getSolidEdges(h8)).map(edgeHandle);
+            return toArray(this.bk.getSolidEdges(h10)).map(edgeHandle);
           case "vertex":
-            return toArray(this.bk.getSolidVertices(h8)).map(vertexHandle);
+            return toArray(this.bk.getSolidVertices(h10)).map(vertexHandle);
           case "wire":
-            return toArray(this.bk.getSolidFaces(h8)).flatMap(
+            return toArray(this.bk.getSolidFaces(h10)).flatMap(
               (faceId) => toArray(this.bk.getFaceWires(faceId)).map(wireHandle)
             );
           default:
@@ -2338,10 +2388,10 @@ class BrepkitAdapter {
       }
       case "shell": {
         if (type === "face") {
-          return toArray(this.bk.getShellFaces(h8)).map(faceHandle);
+          return toArray(this.bk.getShellFaces(h10)).map(faceHandle);
         }
         if (type === "edge" || type === "vertex") {
-          const faces = toArray(this.bk.getShellFaces(h8)).map(faceHandle);
+          const faces = toArray(this.bk.getShellFaces(h10)).map(faceHandle);
           const seen = /* @__PURE__ */ new Set();
           const results = [];
           for (const face of faces) {
@@ -2362,13 +2412,13 @@ class BrepkitAdapter {
           return [shape2];
         }
         if (type === "edge") {
-          return toArray(this.bk.getFaceEdges(h8)).map(edgeHandle);
+          return toArray(this.bk.getFaceEdges(h10)).map(edgeHandle);
         }
         if (type === "vertex") {
-          return toArray(this.bk.getFaceVertices(h8)).map(vertexHandle);
+          return toArray(this.bk.getFaceVertices(h10)).map(vertexHandle);
         }
         if (type === "wire") {
-          return toArray(this.bk.getFaceWires(h8)).map(wireHandle);
+          return toArray(this.bk.getFaceWires(h10)).map(wireHandle);
         }
         return [];
       }
@@ -2377,10 +2427,10 @@ class BrepkitAdapter {
           return [shape2];
         }
         if (type === "edge") {
-          return toArray(this.bk.getWireEdges(h8)).map(edgeHandle);
+          return toArray(this.bk.getWireEdges(h10)).map(edgeHandle);
         }
         if (type === "vertex") {
-          const edgeIds = toArray(this.bk.getWireEdges(h8));
+          const edgeIds = toArray(this.bk.getWireEdges(h10));
           const seen = /* @__PURE__ */ new Set();
           const results = [];
           for (const eid of edgeIds) {
@@ -2406,7 +2456,7 @@ class BrepkitAdapter {
           return [shape2];
         }
         if (type === "vertex") {
-          const verts = this.bk.getEdgeVertices(h8);
+          const verts = this.bk.getEdgeVertices(h10);
           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)];
@@ -2426,11 +2476,11 @@ class BrepkitAdapter {
     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;
+  isSame(a9, b9) {
+    return isBrepkitHandle(a9) && isBrepkitHandle(b9) && a9.id === b9.id && a9.type === b9.type;
   }
-  isEqual(a9, b10) {
-    return this.isSame(a9, b10);
+  isEqual(a9, b9) {
+    return this.isSame(a9, b9);
   }
   downcast(shape2, _type) {
     return shape2;
@@ -2443,8 +2493,8 @@ class BrepkitAdapter {
     return !shape2 || !isBrepkitHandle(shape2);
   }
   shapeOrientation(shape2) {
-    const h8 = unwrap(shape2);
-    const orient = this.bk.getShapeOrientation(h8);
+    const h10 = unwrap(shape2);
+    const orient = this.bk.getShapeOrientation(h10);
     return orient;
   }
   // ═══════════════════════════════════════════════════════════════════════
@@ -2469,12 +2519,12 @@ class BrepkitAdapter {
     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]];
+  surfaceNormal(face, u8, v9) {
+    const n7 = this.bk.evaluateSurfaceNormal(unwrap(face, "face"), u8, v9);
+    return [n7[0], n7[1], n7[2]];
   }
-  pointOnSurface(face, u7, v9) {
-    const p7 = this.bk.evaluateSurface(unwrap(face, "face"), u7, v9);
+  pointOnSurface(face, u8, v9) {
+    const p7 = this.bk.evaluateSurface(unwrap(face, "face"), u8, v9);
     return [p7[0], p7[1], p7[2]];
   }
   uvFromPoint(face, point) {
@@ -2504,11 +2554,11 @@ class BrepkitAdapter {
   // Geometry queries: edge / curve
   // ═══════════════════════════════════════════════════════════════════════
   curveTangent(shape2, param) {
-    const h8 = shape2;
+    const h10 = shape2;
     let edgeId;
     let evalParam = param;
-    if (h8.type === "wire") {
-      const edgeIds = toArray(this.bk.getWireEdges(h8.id));
+    if (h10.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h10.id));
       edgeId = edgeIds[edgeIds.length - 1];
       let cumulative = 0;
       for (const eid of edgeIds) {
@@ -2531,9 +2581,9 @@ class BrepkitAdapter {
     };
   }
   curveParameters(shape2) {
-    const h8 = shape2;
-    if (h8.type === "wire") {
-      const edgeIds = toArray(this.bk.getWireEdges(h8.id));
+    const h10 = shape2;
+    if (h10.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h10.id));
       if (edgeIds.length === 0) return [0, 0];
       let total = 0;
       for (const eid of edgeIds) {
@@ -2547,9 +2597,9 @@ class BrepkitAdapter {
     return [params[0], params[1]];
   }
   curvePointAtParam(shape2, param) {
-    const h8 = shape2;
-    if (h8.type === "wire") {
-      const edgeIds = toArray(this.bk.getWireEdges(h8.id));
+    const h10 = shape2;
+    if (h10.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h10.id));
       let cumulative = 0;
       for (const eid of edgeIds) {
         const p22 = this.bk.getEdgeCurveParameters(eid);
@@ -2569,9 +2619,9 @@ class BrepkitAdapter {
     return [p7[0], p7[1], p7[2]];
   }
   curveIsClosed(shape2) {
-    const h8 = shape2;
-    if (h8.type === "wire") {
-      const edgeIds = toArray(this.bk.getWireEdges(h8.id));
+    const h10 = shape2;
+    if (h10.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h10.id));
       if (edgeIds.length === 0) return false;
       if (edgeIds.length === 1) {
         const verts2 = this.bk.getEdgeVertices(edgeIds[0]);
@@ -2586,7 +2636,7 @@ class BrepkitAdapter {
       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
+          (u8) => dist3(u8[0], u8[1], u8[2], pt[0], pt[1], pt[2]) < 1e-7
         );
         if (matchIdx >= 0) {
           unmatched.splice(matchIdx, 1);
@@ -2600,11 +2650,11 @@ class BrepkitAdapter {
     return dist3(verts[0], verts[1], verts[2], verts[3], verts[4], verts[5]) < 1e-7;
   }
   curveIsPeriodic(shape2) {
-    const h8 = shape2;
+    const h10 = shape2;
     try {
-      if (h8.type === "edge") return this.curveIsClosed(shape2);
-      if (h8.type === "wire") {
-        const edgeIds = toArray(this.bk.getWireEdges(h8.id));
+      if (h10.type === "edge") return this.curveIsClosed(shape2);
+      if (h10.type === "wire") {
+        const edgeIds = toArray(this.bk.getWireEdges(h10.id));
         if (edgeIds.length === 1) return this.curveIsClosed(shape2);
       }
     } catch {
@@ -2622,8 +2672,8 @@ class BrepkitAdapter {
     return 0;
   }
   curveType(shape2) {
-    const h8 = shape2;
-    if (h8.type === "wire") {
+    const h10 = shape2;
+    if (h10.type === "wire") {
       const edges = this.iterShapes(shape2, "edge");
       const first = edges[0];
       if (first) return this.bk.getEdgeCurveType(unwrap(first, "edge"));
@@ -2669,15 +2719,15 @@ class BrepkitAdapter {
   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))) {
+      const h10 = s6;
+      if (h10.type === "face") {
+        faceIds.push(h10.id);
+      } else if (h10.type === "solid") {
+        for (const fid of toArray(this.bk.getSolidFaces(h10.id))) {
           faceIds.push(fid);
         }
-      } else if (h8.type === "shell") {
-        for (const fid of toArray(this.bk.getShellFaces(h8.id))) {
+      } else if (h10.type === "shell") {
+        for (const fid of toArray(this.bk.getShellFaces(h10.id))) {
           faceIds.push(fid);
         }
       }
@@ -2693,10 +2743,10 @@ class BrepkitAdapter {
     return shellHandle(id);
   }
   healSolid(shape2) {
-    const h8 = shape2;
-    if (h8.type !== "solid") {
+    const h10 = shape2;
+    if (h10.type !== "solid") {
       throw new Error(
-        `brepkit: healSolid requires a solid, got ${h8.type}. Consider using makeCompound() to combine shapes first.`
+        `brepkit: healSolid requires a solid, got ${h10.type}. Consider using makeCompound() to combine shapes first.`
       );
     }
     try {
@@ -2741,8 +2791,8 @@ class BrepkitAdapter {
     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);
+    for (let i9 = 0; i9 < result.length; i9 += 2) {
+      coords3d.push(result[i9], result[i9 + 1], 0);
     }
     const wireId = this.bk.makePolygonWire(coords3d);
     return wireHandle(wireId);
@@ -2805,7 +2855,7 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // Classification
   // ═══════════════════════════════════════════════════════════════════════
-  classifyPointOnFace(face, u7, v9, tolerance) {
+  classifyPointOnFace(face, u8, v9, tolerance) {
     if (tolerance !== void 0) {
       warnOnce(
         "classify-tolerance",
@@ -2814,7 +2864,7 @@ class BrepkitAdapter {
     }
     const faceId = unwrap(face, "face");
     const domain = this.bk.getSurfaceDomain(faceId);
-    if (u7 < domain[0] || u7 > domain[1] || v9 < domain[2] || v9 > domain[3]) {
+    if (u8 < domain[0] || u8 > domain[1] || v9 < domain[2] || v9 > domain[3]) {
       return "out";
     }
     return "in";
@@ -2920,8 +2970,8 @@ class BrepkitAdapter {
   }
   loftAdvanced(wires, options) {
     const faceIds = wires.map((w7) => {
-      const h8 = w7;
-      if (h8.type === "wire") return this.bk.makeFaceFromWire(h8.id);
+      const h10 = w7;
+      if (h10.type === "wire") return this.bk.makeFaceFromWire(h10.id);
       return unwrap(w7, "face");
     });
     try {
@@ -2987,8 +3037,8 @@ class BrepkitAdapter {
   }
   linearPattern(shape2, direction, spacing, count) {
     const results = [shape2];
-    for (let i7 = 1; i7 < count; i7++) {
-      const offset2 = spacing * i7;
+    for (let i9 = 1; i9 < count; i9++) {
+      const offset2 = spacing * i9;
       results.push(
         this.translate(shape2, direction[0] * offset2, direction[1] * offset2, direction[2] * offset2)
       );
@@ -2997,8 +3047,8 @@ class BrepkitAdapter {
   }
   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));
+    for (let i9 = 1; i9 < count; i9++) {
+      results.push(this.rotate(shape2, angleStep * i9, axis, center));
     }
     return results;
   }
@@ -3053,11 +3103,11 @@ class BrepkitAdapter {
   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);
+      for (let c8 = 0; c8 < cols - 1; c8++) {
+        const i00 = r9 * cols + c8;
+        const i10 = (r9 + 1) * cols + c8;
+        const i01 = r9 * cols + (c8 + 1);
+        const i11 = (r9 + 1) * cols + (c8 + 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]);
@@ -3070,9 +3120,9 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // 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]];
+  buildTriFace(a9, b9, c8) {
+    const ab = [b9[0] - a9[0], b9[1] - a9[1], b9[2] - a9[2]];
+    const ac = [c8[0] - a9[0], c8[1] - a9[1], c8[2] - a9[2]];
     const cross = [
       ab[1] * ac[2] - ab[2] * ac[1],
       ab[2] * ac[0] - ab[0] * ac[2],
@@ -3081,9 +3131,9 @@ class BrepkitAdapter {
     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 e1 = this.makeLineEdge(a9, b9);
+      const e22 = this.makeLineEdge(b9, c8);
+      const e32 = this.makeLineEdge(c8, a9);
       const wire = this.makeWire([e1, e22, e32]);
       return this.makeFace(wire);
     } catch (e8) {
@@ -3100,9 +3150,9 @@ class BrepkitAdapter {
   // Repair
   // ═══════════════════════════════════════════════════════════════════════
   fixShape(shape2) {
-    const h8 = shape2;
-    if (h8.type === "solid") {
-      this.bk.healSolid(h8.id);
+    const h10 = shape2;
+    if (h10.type === "solid") {
+      this.bk.healSolid(h10.id);
     }
     return shape2;
   }
@@ -3112,9 +3162,9 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // Measurement (advanced)
   // ═══════════════════════════════════════════════════════════════════════
-  surfaceCurvature(face, u7, v9) {
+  surfaceCurvature(face, u8, v9) {
     const fid = unwrap(face, "face");
-    const data = this.bk.measureCurvatureAtSurface(fid, u7, v9);
+    const data = this.bk.measureCurvatureAtSurface(fid, u8, v9);
     if (data.length < 8) {
       throw new Error(
         `brepkit: measureCurvatureAtSurface returned ${data.length} values, expected 8`
@@ -3138,8 +3188,8 @@ class BrepkitAdapter {
     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;
+    for (let t10 = 0; t10 < idx.length; t10 += 3) {
+      const i0 = idx[t10] * 3, i1 = idx[t10 + 1] * 3, i22 = idx[t10 + 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;
@@ -3229,11 +3279,11 @@ class BrepkitAdapter {
   getBezierPenultimatePole(edge) {
     const nurbsData = this.extractNurbsFromEdge(edge);
     if (!nurbsData || nurbsData.controlPoints.length < 6) return null;
-    const n9 = nurbsData.controlPoints.length;
+    const n7 = nurbsData.controlPoints.length;
     return [
-      nurbsData.controlPoints[n9 - 6],
-      nurbsData.controlPoints[n9 - 5],
-      nurbsData.controlPoints[n9 - 4]
+      nurbsData.controlPoints[n7 - 6],
+      nurbsData.controlPoints[n7 - 5],
+      nurbsData.controlPoints[n7 - 4]
     ];
   }
   // ═══════════════════════════════════════════════════════════════════════
@@ -3286,9 +3336,9 @@ class BrepkitAdapter {
   // Shape reversal
   // ═══════════════════════════════════════════════════════════════════════
   reverseShape(shape2) {
-    const h8 = shape2;
-    const newId = this.bk.reverseShape(h8.id);
-    return handle(h8.type, newId);
+    const h10 = shape2;
+    const newId = this.bk.reverseShape(h10.id);
+    return handle(h10.type, newId);
   }
   // ═══════════════════════════════════════════════════════════════════════
   // Dispose
@@ -3320,17 +3370,17 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // Kernel2DCapability — pure TypeScript implementation
   // ═══════════════════════════════════════════════════════════════════════
-  c2d(h8) {
-    return h8;
+  c2d(h10) {
+    return h10;
   }
   /** 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;
+  c2dBasis(h10) {
+    let c8 = this.c2d(h10);
+    while (c8.__bk2d === "trimmed") c8 = c8.basis;
+    return c8;
   }
-  bb2d(h8) {
-    return h8;
+  bb2d(h10) {
+    return h10;
   }
   createPoint2d(x7, y6) {
     return { x: x7, y: y6 };
@@ -3375,9 +3425,14 @@ class BrepkitAdapter {
     const sense = da1m < da12;
     const circle = makeCircle2d(cx, cy, radius, sense);
     if (!sense) {
-      return { __bk2d: "trimmed", basis: circle, tStart: -a12, tEnd: -a23 };
+      const tStart = -a12;
+      let tEnd2 = -a23;
+      if (tEnd2 < tStart - 1e-9) tEnd2 += 2 * Math.PI;
+      return { __bk2d: "trimmed", basis: circle, tStart, tEnd: tEnd2 };
     }
-    return { __bk2d: "trimmed", basis: circle, tStart: a12, tEnd: a23 };
+    let tEnd = a23;
+    if (tEnd < a12 - 1e-9) tEnd += 2 * Math.PI;
+    return { __bk2d: "trimmed", basis: circle, tStart: a12, tEnd };
   }
   makeArc2dTangent(sx, sy, tx, ty, ex, ey) {
     const len = Math.sqrt(tx * tx + ty * ty);
@@ -3390,10 +3445,10 @@ class BrepkitAdapter {
       return makeLine2d(sx, sy, ex, ey);
     }
     const chord2 = dx * dx + dy * dy;
-    const t11 = -chord2 / denom;
-    const cx = sx - t11 * nty;
-    const cy = sy + t11 * ntx;
-    const radius = Math.abs(t11);
+    const t10 = -chord2 / denom;
+    const cx = sx - t10 * nty;
+    const cy = sy + t10 * ntx;
+    const radius = Math.abs(t10);
     const a12 = Math.atan2(sy - cy, sx - cx);
     const a23 = Math.atan2(ey - cy, ex - cx);
     const ccwTanX = -(sy - cy) / radius;
@@ -3424,15 +3479,15 @@ class BrepkitAdapter {
     return makeBezier2d(points);
   }
   makeBSpline2d(points, _options) {
-    const n9 = points.length;
-    const degree = Math.min(3, n9 - 1);
+    const n7 = points.length;
+    const degree = Math.min(3, n7 - 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));
+    const nInternal = n7 - degree - 1;
+    for (let i9 = 1; i9 <= nInternal; i9++) {
+      knots.push(i9 / (nInternal + 1));
       mults.push(1);
     }
     knots.push(1);
@@ -3470,14 +3525,14 @@ class BrepkitAdapter {
     return JSON.parse(JSON.stringify(curve));
   }
   offsetCurve2d(curve, offset2) {
-    const c7 = this.c2d(curve);
-    const bounds = curveBounds(c7);
+    const c8 = this.c2d(curve);
+    const bounds = curveBounds(c8);
     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);
+    for (let i9 = 0; i9 <= N4; i9++) {
+      const t10 = bounds.first + (bounds.last - bounds.first) * i9 / N4;
+      const [px, py] = evaluateCurve2d(c8, t10);
+      const [tx, ty] = tangentCurve2d(c8, t10);
       const tLen = Math.sqrt(tx * tx + ty * ty);
       if (tLen > 1e-12) {
         poles.push([px - ty / tLen * offset2, py + tx / tLen * offset2]);
@@ -3550,8 +3605,8 @@ class BrepkitAdapter {
     return this._gtrsf([-1, 0, 0, 0, -1, 0, 0, 0, 1], 2 * cx, 2 * cy);
   }
   createRotationGTrsf2d(angle, cx, cy) {
-    const c7 = Math.cos(angle), s6 = Math.sin(angle);
-    return this._gtrsf([c7, -s6, 0, s6, c7, 0, 0, 0, 1], cx - c7 * cx + s6 * cy, cy - s6 * cx - c7 * cy);
+    const c8 = Math.cos(angle), s6 = Math.sin(angle);
+    return this._gtrsf([c8, -s6, 0, s6, c8, 0, 0, 0, 1], cx - c8 * cx + s6 * cy, cy - s6 * cx - c8 * cy);
   }
   createScaleGTrsf2d(factor, cx, cy) {
     return this._gtrsf([factor, 0, 0, 0, factor, 0, 0, 0, 1], cx * (1 - factor), cy * (1 - factor));
@@ -3561,17 +3616,17 @@ class BrepkitAdapter {
     gtrsf.ty = dy;
   }
   multiplyGTrsf2d(base, other) {
-    const a9 = base.m, b10 = other.m;
+    const a9 = base.m, b9 = 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]
+      a9[0] * b9[0] + a9[1] * b9[3] + a9[2] * b9[6],
+      a9[0] * b9[1] + a9[1] * b9[4] + a9[2] * b9[7],
+      a9[0] * b9[2] + a9[1] * b9[5] + a9[2] * b9[8],
+      a9[3] * b9[0] + a9[4] * b9[3] + a9[5] * b9[6],
+      a9[3] * b9[1] + a9[4] * b9[4] + a9[5] * b9[7],
+      a9[3] * b9[2] + a9[4] * b9[5] + a9[5] * b9[8],
+      a9[6] * b9[0] + a9[7] * b9[3] + a9[8] * b9[6],
+      a9[6] * b9[1] + a9[7] * b9[4] + a9[8] * b9[7],
+      a9[6] * b9[2] + a9[7] * b9[5] + a9[8] * b9[8]
     ];
     base.m = r9;
     const oldTx = base.tx, oldTy = base.ty;
@@ -3580,19 +3635,19 @@ class BrepkitAdapter {
     base.ty = a9[3] * otx + a9[4] * oty + oldTy;
   }
   transformCurve2dGeneral(curve, gtrsf) {
-    const c7 = this.c2d(curve);
+    const c8 = 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);
+      return translateCurve2d(c8, tx, ty);
     }
-    const bounds = curveBounds(c7);
+    const bounds = curveBounds(c8);
     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);
+    for (let i9 = 0; i9 <= N4; i9++) {
+      const t10 = bounds.first + (bounds.last - bounds.first) * i9 / N4;
+      const [px, py] = evaluateCurve2d(c8, t10);
       pts.push([m10[0] * px + m10[1] * py + tx, m10[3] * px + m10[4] * py + ty]);
     }
     return makeBezier2d(pts);
@@ -3609,40 +3664,40 @@ class BrepkitAdapter {
     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) };
+    const c8 = this.c2d(curve);
+    const bounds = curveBounds(c8);
+    if (c8.__bk2d === "line") {
+      const dx = x7 - c8.ox;
+      const dy = y6 - c8.oy;
+      const t10 = Math.max(bounds.first, Math.min(bounds.last, dx * c8.dx + dy * c8.dy));
+      const [px, py] = evaluateCurve2d(c8, t10);
+      return { param: t10, distance: Math.sqrt((px - x7) ** 2 + (py - y6) ** 2) };
+    }
+    if (c8.__bk2d === "circle") {
+      const angle = Math.atan2(y6 - c8.cy, x7 - c8.cx);
+      let t10 = c8.sense ? angle : -angle;
+      while (t10 < 0) t10 += 2 * Math.PI;
+      while (t10 > 2 * Math.PI) t10 -= 2 * Math.PI;
+      const [px, py] = evaluateCurve2d(c8, t10);
+      return { param: t10, 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);
+    for (let i9 = 0; i9 <= N4; i9++) {
+      const t10 = bounds.first + i9 * dt;
+      const [px, py] = evaluateCurve2d(c8, t10);
       const d10 = (px - x7) ** 2 + (py - y6) ** 2;
       if (d10 < bestDist) {
         bestDist = d10;
-        bestT = t11;
+        bestT = t10;
       }
     }
     for (let iter = 0; iter < 10; iter++) {
-      const [px, py] = evaluateCurve2d(c7, bestT);
-      const [tx, ty] = tangentCurve2d(c7, bestT);
+      const [px, py] = evaluateCurve2d(c8, bestT);
+      const [tx, ty] = tangentCurve2d(c8, bestT);
       const dot = (px - x7) * tx + (py - y6) * ty;
       const denom = tx * tx + ty * ty;
       if (denom < 1e-20) break;
@@ -3651,7 +3706,7 @@ class BrepkitAdapter {
       if (Math.abs(newT - bestT) < 1e-14) break;
       bestT = newT;
     }
-    const [fx, fy] = evaluateCurve2d(c7, bestT);
+    const [fx, fy] = evaluateCurve2d(c8, bestT);
     return { param: bestT, distance: Math.sqrt((fx - x7) ** 2 + (fy - y6) ** 2) };
   }
   distanceBetweenCurves2d(c1, c22, p1s, p1e, p2s, p2e) {
@@ -3661,11 +3716,11 @@ class BrepkitAdapter {
     let bestT2 = p2s;
     let minDistSq = Infinity;
     const N4 = 50;
-    for (let i7 = 0; i7 <= N4; i7++) {
-      const t12 = p1s + (p1e - p1s) * i7 / N4;
+    for (let i9 = 0; i9 <= N4; i9++) {
+      const t12 = p1s + (p1e - p1s) * i9 / N4;
       const [x1, y1] = evaluateCurve2d(curve1, t12);
-      for (let j6 = 0; j6 <= N4; j6++) {
-        const t222 = p2s + (p2e - p2s) * j6 / N4;
+      for (let j7 = 0; j7 <= N4; j7++) {
+        const t222 = p2s + (p2e - p2s) * j7 / N4;
         const [x22, y22] = evaluateCurve2d(curve2, t222);
         const d10 = (x22 - x1) ** 2 + (y22 - y1) ** 2;
         if (d10 < minDistSq) {
@@ -3700,8 +3755,8 @@ class BrepkitAdapter {
     return Math.sqrt((fx2 - fx1) ** 2 + (fy2 - fy1) ** 2);
   }
   approximateCurve2dAsBSpline(curve, tol, cont, maxSeg) {
-    const c7 = this.c2d(curve);
-    const bounds = curveBounds(c7);
+    const c8 = this.c2d(curve);
+    const bounds = curveBounds(c8);
     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);
@@ -3709,16 +3764,16 @@ class BrepkitAdapter {
     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));
+      for (let i9 = 0; i9 <= N4; i9++) {
+        const t10 = bounds.first + (bounds.last - bounds.first) * i9 / N4;
+        poles.push(evaluateCurve2d(c8, t10));
       }
       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];
+      for (let i9 = 0; i9 < N4; i9++) {
+        const tMid = bounds.first + (bounds.last - bounds.first) * (i9 + 0.5) / N4;
+        const [ex, ey] = evaluateCurve2d(c8, tMid);
+        const p0 = poles[i9];
+        const p1 = poles[i9 + 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);
@@ -3729,9 +3784,9 @@ class BrepkitAdapter {
     return this.makeBSpline2d(poles, { degMax: degree });
   }
   decomposeBSpline2dToBeziers(curve) {
-    const c7 = this.c2dBasis(curve);
-    if (c7.__bk2d === "bezier") return [curve];
-    if (c7.__bk2d !== "bspline") {
+    const c8 = this.c2dBasis(curve);
+    if (c8.__bk2d === "bezier") return [curve];
+    if (c8.__bk2d !== "bspline") {
       const approx = this.approximateCurve2dAsBSpline(curve, 1e-6, "C2", 10);
       return this.decomposeBSpline2dToBeziers(approx);
     }
@@ -3739,20 +3794,20 @@ class BrepkitAdapter {
     const first = trimBounds.first;
     const last = trimBounds.last;
     const internalKnots = [];
-    for (const k7 of c7.knots) {
+    for (const k7 of c8.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];
+    for (let i9 = 0; i9 < breakpoints.length - 1; i9++) {
+      const t0 = breakpoints[i9];
+      const t1 = breakpoints[i9 + 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 p0 = evaluateCurve2d(c8, t0);
+      const p32 = evaluateCurve2d(c8, t1);
+      const tan0 = tangentCurve2d(c8, t0);
+      const tan3 = tangentCurve2d(c8, t1);
       const s6 = span / 3;
       const bezier = {
         __bk2d: "bezier",
@@ -3775,60 +3830,60 @@ class BrepkitAdapter {
     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 };
+    const b9 = this.bb2d(bbox);
+    return { xMin: b9.xMin, yMin: b9.yMin, xMax: b9.xMax, yMax: b9.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);
+    const t10 = this.bb2d(target), o9 = this.bb2d(other);
+    t10.xMin = Math.min(t10.xMin, o9.xMin);
+    t10.yMin = Math.min(t10.yMin, o9.yMin);
+    t10.xMax = Math.max(t10.xMax, o9.xMax);
+    t10.yMax = Math.max(t10.yMax, o9.yMax);
+  }
+  isBBox2dOut(a9, b9) {
+    const ba = this.bb2d(a9), bb = this.bb2d(b9);
     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;
+    const b9 = this.bb2d(bbox);
+    return x7 < b9.xMin || x7 > b9.xMax || y6 < b9.yMin || y6 > b9.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 };
+    const c8 = this.c2dBasis(curve);
+    if (c8.__bk2d === "circle") return { cx: c8.cx, cy: c8.cy, radius: c8.radius, isDirect: c8.sense };
     return null;
   }
   getCurve2dEllipseData(curve) {
-    const c7 = this.c2dBasis(curve);
-    if (c7.__bk2d === "ellipse")
+    const c8 = this.c2dBasis(curve);
+    if (c8.__bk2d === "ellipse")
       return {
-        majorRadius: c7.majorRadius,
-        minorRadius: c7.minorRadius,
-        xAxisAngle: c7.xDirAngle,
-        isDirect: c7.sense
+        majorRadius: c8.majorRadius,
+        minorRadius: c8.minorRadius,
+        xAxisAngle: c8.xDirAngle,
+        isDirect: c8.sense
       };
     return null;
   }
   getCurve2dBezierPoles(curve) {
-    const c7 = this.c2dBasis(curve);
-    if (c7.__bk2d === "bezier") return [...c7.poles];
+    const c8 = this.c2dBasis(curve);
+    if (c8.__bk2d === "bezier") return [...c8.poles];
     return null;
   }
   getCurve2dBezierDegree(curve) {
-    const c7 = this.c2dBasis(curve);
-    if (c7.__bk2d === "bezier") return c7.poles.length - 1;
+    const c8 = this.c2dBasis(curve);
+    if (c8.__bk2d === "bezier") return c8.poles.length - 1;
     return null;
   }
   getCurve2dBSplineData(curve) {
-    const c7 = this.c2dBasis(curve);
-    if (c7.__bk2d === "bspline")
+    const c8 = this.c2dBasis(curve);
+    if (c8.__bk2d === "bspline")
       return {
-        poles: [...c7.poles],
-        knots: [...c7.knots],
-        multiplicities: [...c7.multiplicities],
-        degree: c7.degree,
-        isPeriodic: c7.isPeriodic
+        poles: [...c8.poles],
+        knots: [...c8.knots],
+        multiplicities: [...c8.multiplicities],
+        degree: c8.degree,
+        isPeriodic: c8.isPeriodic
       };
     return null;
   }
@@ -3841,49 +3896,49 @@ class BrepkitAdapter {
   }
   // --- 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 c8 = this.c2d(curve);
+    const bounds = curveBounds(c8);
+    const sortedParams = [bounds.first, ...params.sort((a9, b9) => a9 - b9), bounds.last];
     const result = [];
-    for (let i7 = 0; i7 < sortedParams.length - 1; i7++) {
+    for (let i9 = 0; i9 < sortedParams.length - 1; i9++) {
       result.push({
         __bk2d: "trimmed",
-        basis: c7,
-        tStart: sortedParams[i7],
-        tEnd: sortedParams[i7 + 1]
+        basis: c8,
+        tStart: sortedParams[i9],
+        tEnd: sortedParams[i9 + 1]
       });
     }
     return result;
   }
   // --- 2D → 3D projection ---
   liftCurve2dToPlane(curve, origin, planeZ, planeX) {
-    const c7 = this.c2d(curve);
+    const c8 = 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]
+    const lift = (u8, v9) => [
+      origin[0] + u8 * planeX[0] + v9 * y6[0],
+      origin[1] + u8 * planeX[1] + v9 * y6[1],
+      origin[2] + u8 * 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);
+    if (c8.__bk2d === "line") {
+      const p1 = lift(c8.ox, c8.oy);
+      const p22 = lift(c8.ox + c8.dx * c8.len, c8.oy + c8.dy * c8.len);
       return this.makeLineEdge(p1, p22);
     }
-    if (c7.__bk2d === "circle" || c7.__bk2d === "trimmed") {
-      let basis = c7;
+    if (c8.__bk2d === "circle" || c8.__bk2d === "trimmed") {
+      let basis = c8;
       while (basis.__bk2d === "trimmed") basis = basis.basis;
       if (basis.__bk2d === "circle") {
         const circ = basis;
         const center3d = lift(circ.cx, circ.cy);
         const axis = circ.sense ? planeZ : [-planeZ[0], -planeZ[1], -planeZ[2]];
-        const bounds2 = curveBounds(c7);
+        const bounds2 = curveBounds(c8);
         let angularSpan;
-        if (c7.__bk2d === "trimmed") {
-          angularSpan = Math.abs(c7.tEnd - c7.tStart);
+        if (c8.__bk2d === "trimmed") {
+          angularSpan = Math.abs(c8.tEnd - c8.tStart);
         } else {
           angularSpan = 2 * Math.PI;
         }
@@ -3891,8 +3946,8 @@ class BrepkitAdapter {
         const segmentSpan = (bounds2.last - bounds2.first) / nSegments;
         const edgeIds = [];
         for (let seg = 0; seg < nSegments; seg++) {
-          const [su, sv] = evaluateCurve2d(c7, bounds2.first + seg * segmentSpan);
-          const [eu, ev] = evaluateCurve2d(c7, bounds2.first + (seg + 1) * segmentSpan);
+          const [su, sv] = evaluateCurve2d(c8, bounds2.first + seg * segmentSpan);
+          const [eu, ev] = evaluateCurve2d(c8, bounds2.first + (seg + 1) * segmentSpan);
           edgeIds.push(
             this.bk.makeCircleArc3d(...lift(su, sv), ...lift(eu, ev), ...center3d, ...axis)
           );
@@ -3901,21 +3956,21 @@ class BrepkitAdapter {
         return wireHandle(this.bk.makeWire(edgeIds, false));
       }
     }
-    if (c7.__bk2d === "bezier" || c7.__bk2d === "bspline") {
-      const points3d = c7.poles.map(([u7, v9]) => lift(u7, v9));
+    if (c8.__bk2d === "bezier" || c8.__bk2d === "bspline") {
+      const points3d = c8.poles.map(([u8, v9]) => lift(u8, 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 bounds = curveBounds(c8);
     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));
+    for (let i9 = 0; i9 <= nSamples; i9++) {
+      const t10 = bounds.first + (bounds.last - bounds.first) * i9 / nSamples;
+      const [u8, v9] = evaluateCurve2d(c8, t10);
+      points.push(lift(u8, v9));
     }
     return this.interpolatePoints(points);
   }
@@ -3923,15 +3978,15 @@ class BrepkitAdapter {
     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 c8 = this.c2d(curve);
+    const bounds = curveBounds(c8);
     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);
+    for (let i9 = 0; i9 <= N4; i9++) {
+      const t10 = bounds.first + (bounds.last - bounds.first) * i9 / N4;
+      const [u8, v9] = evaluateCurve2d(c8, t10);
+      const p7 = this.bk.evaluateSurface(fid, u8, v9);
       points.push([p7[0], p7[1], p7[2]]);
     }
     return this.interpolatePoints(points);
@@ -3949,37 +4004,37 @@ class BrepkitAdapter {
     const MAX_N = 80;
     const REFINE_THRESHOLD = 0.05;
     const tValues = [];
-    for (let i7 = 0; i7 <= BASE_N; i7++) {
-      tValues.push(tMin + (tMax - tMin) * i7 / BASE_N);
+    for (let i9 = 0; i9 <= BASE_N; i9++) {
+      tValues.push(tMin + (tMax - tMin) * i9 / BASE_N);
     }
-    const evaluateUV = (t11) => {
-      const pt = this.bk.evaluateEdgeCurve(eid, t11);
+    const evaluateUV = (t10) => {
+      const pt = this.bk.evaluateEdgeCurve(eid, t10);
       const uv = this.bk.projectPointOnSurface(fid, pt[0], pt[1], pt[2]);
       return [uv[0], uv[1]];
     };
-    const uvSamples = tValues.map((t11) => ({
-      t: t11,
-      uv: evaluateUV(t11)
+    const uvSamples = tValues.map((t10) => ({
+      t: t10,
+      uv: evaluateUV(t10)
     }));
     let refinements = 0;
     while (uvSamples.length < MAX_N) {
       const insertions = [];
-      for (let i7 = 0; i7 < uvSamples.length - 1; i7++) {
-        const a9 = uvSamples[i7];
-        const b10 = uvSamples[i7 + 1];
-        const tMid = (a9.t + b10.t) / 2;
+      for (let i9 = 0; i9 < uvSamples.length - 1; i9++) {
+        const a9 = uvSamples[i9];
+        const b9 = uvSamples[i9 + 1];
+        const tMid = (a9.t + b9.t) / 2;
         const uvMid = evaluateUV(tMid);
-        const interpU = (a9.uv[0] + b10.uv[0]) / 2;
-        const interpV = (a9.uv[1] + b10.uv[1]) / 2;
+        const interpU = (a9.uv[0] + b9.uv[0]) / 2;
+        const interpV = (a9.uv[1] + b9.uv[1]) / 2;
         const deviation = Math.sqrt((uvMid[0] - interpU) ** 2 + (uvMid[1] - interpV) ** 2);
         if (deviation > REFINE_THRESHOLD) {
-          insertions.push({ index: i7 + 1, t: tMid, uv: uvMid });
+          insertions.push({ index: i9 + 1, t: tMid, uv: uvMid });
         }
       }
       if (insertions.length === 0) break;
       let budget = MAX_N - uvSamples.length;
-      for (let j6 = insertions.length - 1; j6 >= 0 && budget > 0; j6--) {
-        const ins = insertions[j6];
+      for (let j7 = insertions.length - 1; j7 >= 0 && budget > 0; j7--) {
+        const ins = insertions[j7];
         uvSamples.splice(ins.index, 0, { t: ins.t, uv: ins.uv });
         budget--;
       }
@@ -4015,9 +4070,9 @@ class BrepkitAdapter {
           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);
+          for (let i9 = 0; i9 <= N4; i9++) {
+            const t10 = tMin + (tMax - tMin) * i9 / N4;
+            const p7 = this.bk.evaluateEdgeCurve(edgeId, t10);
             pts.push(p7[0], p7[1], p7[2]);
           }
           allCoords.push(...pts);
@@ -4039,13 +4094,13 @@ class BrepkitAdapter {
   // Private helpers
   // ═══════════════════════════════════════════════════════════════════════
   applyMatrix(shape2, matrix) {
-    const h8 = shape2;
+    const h10 = shape2;
     if (!isBrepkitHandle(shape2)) {
       throw new Error("brepkit: applyMatrix requires a BrepkitHandle");
     }
-    switch (h8.type) {
+    switch (h10.type) {
       case "solid": {
-        const copy = this.bk.copySolid(h8.id);
+        const copy = this.bk.copySolid(h10.id);
         this.bk.transformSolid(copy, matrix);
         return solidHandle(copy);
       }
@@ -4055,7 +4110,7 @@ class BrepkitAdapter {
             "brepkit: applyMatrix for faces requires copyFace/transformFace WASM exports"
           );
         }
-        const copy = this.bk.copyFace(h8.id);
+        const copy = this.bk.copyFace(h10.id);
         this.bk.transformFace(copy, matrix);
         return faceHandle(copy);
       }
@@ -4065,7 +4120,7 @@ class BrepkitAdapter {
             "brepkit: applyMatrix for wires requires copyWire/transformWire WASM exports"
           );
         }
-        const copy = this.bk.copyWire(h8.id);
+        const copy = this.bk.copyWire(h10.id);
         this.bk.transformWire(copy, matrix);
         return wireHandle(copy);
       }
@@ -4075,12 +4130,12 @@ class BrepkitAdapter {
             "brepkit: applyMatrix for edges requires copyEdge/transformEdge WASM exports"
           );
         }
-        const copy = this.bk.copyEdge(h8.id);
+        const copy = this.bk.copyEdge(h10.id);
         this.bk.transformEdge(copy, matrix);
         return edgeHandle(copy);
       }
       default:
-        throw new Error(`brepkit: applyMatrix does not support '${h8.type}' shapes`);
+        throw new Error(`brepkit: applyMatrix does not support '${h10.type}' shapes`);
     }
   }
   /** Check if we need to transform from default placement (origin, +Z). */
@@ -4142,14 +4197,14 @@ class BrepkitAdapter {
       );
     }
     const faceGroups = [];
-    for (let i7 = 0; i7 < data.faceOffsets.length - 1; i7++) {
-      const start = data.faceOffsets[i7];
-      const count = data.faceOffsets[i7 + 1] - start;
+    for (let i9 = 0; i9 < data.faceOffsets.length - 1; i9++) {
+      const start = data.faceOffsets[i9];
+      const count = data.faceOffsets[i9 + 1] - start;
       if (count === 0) continue;
       faceGroups.push({
         start,
         count,
-        faceHash: faceIds[i7] ?? 0
+        faceHash: faceIds[i9] ?? 0
       });
     }
     let uvs = new Float32Array(0);
@@ -4194,11 +4249,11 @@ class BrepkitAdapter {
         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 n7 of normals) allNormals.push(n7);
         for (const idx of indices) {
           allTriangles.push(idx + vertexOffset);
         }
-        for (let i7 = 0; i7 < vertCount; i7++) {
+        for (let i9 = 0; i9 < vertCount; i9++) {
           allUVs.push(0, 0);
         }
         faceGroups.push({
@@ -4227,7 +4282,7 @@ class BrepkitAdapter {
     const indices = faceMesh.indices;
     const vertCount = positions.length / 3;
     const uvs = [];
-    for (let i7 = 0; i7 < vertCount; i7++) {
+    for (let i9 = 0; i9 < vertCount; i9++) {
       uvs.push(0, 0);
     }
     return {
@@ -4266,15 +4321,15 @@ class BrepkitAdapter {
     const dAngle = (endAngle - startAngle) / nSegments;
     const controlPoints = [];
     const weights = [];
-    for (let i7 = 0; i7 <= nSegments; i7++) {
-      const angle = startAngle + i7 * dAngle;
+    for (let i9 = 0; i9 <= nSegments; i9++) {
+      const angle = startAngle + i9 * 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;
+      if (i9 > 0) {
+        const midAngle = startAngle + (i9 - 0.5) * dAngle;
         const midCos = Math.cos(midAngle);
         const midSin = Math.sin(midAngle);
         const midR = radius / Math.cos(dAngle / 2);
@@ -4289,13 +4344,13 @@ class BrepkitAdapter {
     }
     const degree = 2;
     const knots = Array(degree + 1).fill(0);
-    for (let i7 = 1; i7 < nSegments; i7++) {
-      knots.push(i7, i7);
+    for (let i9 = 1; i9 < nSegments; i9++) {
+      knots.push(i9, i9);
     }
     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;
+    for (let i9 = 0; i9 < knots.length; i9++) {
+      knots[i9] = knots[i9] / kMax;
     }
     const startPt = controlPoints.slice(0, 3);
     const endPt = controlPoints.slice(-3);
@@ -4319,9 +4374,9 @@ class BrepkitAdapter {
    * 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);
+    const h10 = shape2;
+    if (h10.type !== "edge") return null;
+    const nurbsJson = this.bk.getEdgeNurbsData(h10.id);
     if (nurbsJson) {
       const data = JSON.parse(nurbsJson);
       return {
@@ -4331,7 +4386,7 @@ class BrepkitAdapter {
         weights: data.weights
       };
     }
-    const verts = this.bk.getEdgeVertices(h8.id);
+    const verts = this.bk.getEdgeVertices(h10.id);
     return {
       degree: 1,
       knots: [0, 0, 1, 1],
@@ -4370,15 +4425,15 @@ class BrepkitAdapter {
     const dAngle = (endAngle - startAngle) / nSegments;
     const controlPoints = [];
     const weights = [];
-    for (let i7 = 0; i7 <= nSegments; i7++) {
-      const angle = startAngle + i7 * dAngle;
+    for (let i9 = 0; i9 <= nSegments; i9++) {
+      const angle = startAngle + i9 * 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;
+      if (i9 > 0) {
+        const midAngle = startAngle + (i9 - 0.5) * dAngle;
         const midCos = Math.cos(midAngle);
         const midSin = Math.sin(midAngle);
         const scale2 = 1 / Math.cos(dAngle / 2);
@@ -4393,13 +4448,13 @@ class BrepkitAdapter {
     }
     const degree = 2;
     const knots = Array(degree + 1).fill(0);
-    for (let i7 = 1; i7 < nSegments; i7++) {
-      knots.push(i7, i7);
+    for (let i9 = 1; i9 < nSegments; i9++) {
+      knots.push(i9, i9);
     }
     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;
+    for (let i9 = 0; i9 < knots.length; i9++) {
+      knots[i9] = knots[i9] / kMax;
     }
     const startPt = controlPoints.slice(0, 3);
     const endPt = controlPoints.slice(-3);
@@ -4423,16 +4478,16 @@ class BrepkitAdapter {
    */
   extractPlaneFromFace(faceShape) {
     let faceId;
-    const h8 = faceShape;
-    if (h8.type === "solid" || h8.type === "compound") {
+    const h10 = faceShape;
+    if (h10.type === "solid" || h10.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");
+      for (const f11 of faces) {
+        const id = unwrap(f11, "face");
         try {
           const a9 = this.bk.faceArea(id, DEFAULT_DEFLECTION);
           if (a9 > bestArea) {
@@ -4446,8 +4501,8 @@ class BrepkitAdapter {
     } else {
       faceId = unwrap(faceShape, "face");
     }
-    const n9 = this.bk.getFaceNormal(faceId);
-    const normal = [n9[0], n9[1], n9[2]];
+    const n7 = this.bk.getFaceNormal(faceId);
+    const normal = [n7[0], n7[1], n7[2]];
     const mesh2 = this.bk.tessellateFace(faceId, 1);
     const positions = mesh2.positions;
     if (positions.length >= 3) {
@@ -4546,7 +4601,7 @@ class BrepkitAdapter {
   }
   draft(shape2, faces, pullDirection, neutralPlane, angleDeg) {
     const solidId = unwrapSolidOrThrow(shape2, "draft");
-    const faceIds = faces.map((f12) => unwrap(f12, "face"));
+    const faceIds = faces.map((f11) => unwrap(f11, "face"));
     return solidHandle(
       this.bk.draft(
         solidId,
@@ -4563,7 +4618,7 @@ class BrepkitAdapter {
   }
   defeature(shape2, faces) {
     const solidId = unwrapSolidOrThrow(shape2, "defeature");
-    const faceIds = faces.map((f12) => unwrap(f12, "face"));
+    const faceIds = faces.map((f11) => unwrap(f11, "face"));
     return solidHandle(this.bk.defeature(solidId, faceIds));
   }
   // ═══════════════════════════════════════════════════════════════════════
@@ -4681,12 +4736,12 @@ class BrepkitAdapter {
     return this.bk.executeBatch(json);
   }
 }
-function multiplyMatrices(a9, b10) {
+function multiplyMatrices(a9, b9) {
   const result = new Array(16).fill(0);
-  for (let i7 = 0; i7 < 4; i7++) {
-    for (let j6 = 0; j6 < 4; j6++) {
+  for (let i9 = 0; i9 < 4; i9++) {
+    for (let j7 = 0; j7 < 4; j7++) {
       for (let k7 = 0; k7 < 4; k7++) {
-        result[i7 * 4 + j6] = result[i7 * 4 + j6] + a9[i7 * 4 + k7] * b10[k7 * 4 + j6];
+        result[i9 * 4 + j7] = result[i9 * 4 + j7] + a9[i9 * 4 + k7] * b9[k7 * 4 + j7];
       }
     }
   }
@@ -4815,11 +4870,11 @@ function withNearestPostFilter(baseFinder, nearestPoint) {
     if (candidates.length === 0) return [];
     let bestIdx = 0;
     let bestDist = vecDistance(vertexPosition(candidates[0]), nearestPoint);
-    for (let i7 = 1; i7 < candidates.length; i7++) {
-      const d10 = vecDistance(vertexPosition(candidates[i7]), nearestPoint);
+    for (let i9 = 1; i9 < candidates.length; i9++) {
+      const d10 = vecDistance(vertexPosition(candidates[i9]), nearestPoint);
       if (d10 < bestDist) {
         bestDist = d10;
-        bestIdx = i7;
+        bestIdx = i9;
       }
     }
     return [candidates[bestIdx]];
@@ -4953,10 +5008,10 @@ function surfaceFromGrid(heights, options = {}) {
 function buildBSplineSurface(heights, rows, cols, dx, dy, scaleZ) {
   const points = [];
   for (let r9 = 0; r9 < rows; r9++) {
-    for (let c7 = 0; c7 < cols; c7++) {
+    for (let c8 = 0; c8 < cols; c8++) {
       const row = heights[r9];
-      const z6 = (row ? row[c7] ?? 0 : 0) * scaleZ;
-      points.push([c7 * dx, r9 * dy, z6]);
+      const z6 = (row ? row[c8] ?? 0 : 0) * scaleZ;
+      points.push([c8 * dx, r9 * dy, z6]);
     }
   }
   const faceShape = getKernel().bsplineSurface(points, rows, cols);
@@ -4970,10 +5025,10 @@ function buildBSplineSurface(heights, rows, cols, dx, dy, scaleZ) {
 function buildTriangulatedSurface(heights, rows, cols, dx, dy, scaleZ) {
   const points = [];
   for (let r9 = 0; r9 < rows; r9++) {
-    for (let c7 = 0; c7 < cols; c7++) {
+    for (let c8 = 0; c8 < cols; c8++) {
       const row = heights[r9];
-      const z6 = (row ? row[c7] ?? 0 : 0) * scaleZ;
-      points.push([c7 * dx, r9 * dy, z6]);
+      const z6 = (row ? row[c8] ?? 0 : 0) * scaleZ;
+      points.push([c8 * dx, r9 * dy, z6]);
     }
   }
   const resultShape = getKernel().triangulatedSurface(points, rows, cols);
@@ -5012,13 +5067,13 @@ async function surfaceFromImage(blob, options = {}) {
     );
   }
   const w7 = bitmap.width;
-  const h8 = bitmap.height;
-  if (w7 < 2 || h8 < 2) {
+  const h10 = bitmap.height;
+  if (w7 < 2 || h10 < 2) {
     bitmap.close();
     return err(
       validationError(
         BrepErrorCode.SURFACE_GRID_TOO_SMALL,
-        `surfaceFromImage: image too small (${w7}x${h8}), need at least 2x2`
+        `surfaceFromImage: image too small (${w7}x${h10}), need at least 2x2`
       )
     );
   }
@@ -5031,7 +5086,7 @@ async function surfaceFromImage(blob, options = {}) {
       )
     );
   }
-  const canvas = new OffscreenCanvas(w7, h8);
+  const canvas = new OffscreenCanvas(w7, h10);
   const ctx = canvas.getContext("2d");
   if (!ctx) {
     bitmap.close();
@@ -5041,29 +5096,29 @@ async function surfaceFromImage(blob, options = {}) {
   }
   ctx.drawImage(bitmap, 0, 0);
   bitmap.close();
-  const imageData = ctx.getImageData(0, 0, w7, h8);
+  const imageData = ctx.getImageData(0, 0, w7, h10);
   const data = imageData.data;
   const rows = [];
-  for (let y6 = 0; y6 < h8; y6 += downsample) {
+  for (let y6 = 0; y6 < h10; y6 += downsample) {
     const row = [];
     for (let x7 = 0; x7 < w7; x7 += downsample) {
       const idx = (y6 * w7 + x7) * 4;
       const r9 = data[idx] ?? 0;
-      const g12 = data[idx + 1] ?? 0;
-      const b10 = data[idx + 2] ?? 0;
+      const g11 = data[idx + 1] ?? 0;
+      const b9 = data[idx + 2] ?? 0;
       let value;
       switch (channel) {
         case "r":
           value = r9 / 255;
           break;
         case "g":
-          value = g12 / 255;
+          value = g11 / 255;
           break;
         case "b":
-          value = b10 / 255;
+          value = b9 / 255;
           break;
         default:
-          value = (REC601_R * r9 + REC601_G * g12 + REC601_B * b10) / 255;
+          value = (REC601_R * r9 + REC601_G * g11 + REC601_B * b9) / 255;
           break;
       }
       row.push(value);
@@ -5094,8 +5149,8 @@ function hull(shapes, options = {}) {
       )
     );
   }
-  for (const [i7, shape2] of shapes.entries()) {
-    const check = validateNotNull$1(shape2, `hull: shapes[${i7}]`);
+  for (const [i9, shape2] of shapes.entries()) {
+    const check = validateNotNull$1(shape2, `hull: shapes[${i9}]`);
     if (isErr(check)) return check;
   }
   const tolerance = options.tolerance ?? 0.1;
@@ -5251,8 +5306,8 @@ function polyhedron(points, faces, options = {}) {
     }
     if (face.length < 3) continue;
     const v0 = face[0];
-    for (let i7 = 1; i7 < face.length - 1; i7++) {
-      triangles.push([v0, face[i7], face[i7 + 1]]);
+    for (let i9 = 1; i9 < face.length - 1; i9++) {
+      triangles.push([v0, face[i9], face[i9 + 1]]);
     }
   }
   try {
@@ -5283,20 +5338,20 @@ function multiSectionSweep(sections, spine, options) {
   }
   const { solid = true, ruled = false, tolerance = 1e-6 } = options ?? {};
   const explicitLocations = sections.map((s6) => s6.location);
-  for (let i7 = 0; i7 < explicitLocations.length; i7++) {
-    const loc = explicitLocations[i7];
+  for (let i9 = 0; i9 < explicitLocations.length; i9++) {
+    const loc = explicitLocations[i9];
     if (loc !== void 0 && (loc < 0 || loc > 1)) {
       return err(
         validationError(
           BrepErrorCode.MULTI_SWEEP_FAILED,
-          `Section ${i7} location ${loc} is out of range [0, 1]`
+          `Section ${i9} location ${loc} is out of range [0, 1]`
         )
       );
     }
   }
   const definedLocs = explicitLocations.filter((l10) => l10 !== void 0);
-  for (let i7 = 1; i7 < definedLocs.length; i7++) {
-    if ((definedLocs[i7] ?? 0) <= (definedLocs[i7 - 1] ?? 0)) {
+  for (let i9 = 1; i9 < definedLocs.length; i9++) {
+    if ((definedLocs[i9] ?? 0) <= (definedLocs[i9 - 1] ?? 0)) {
       return err(
         validationError(
           BrepErrorCode.MULTI_SWEEP_FAILED,
@@ -5309,16 +5364,16 @@ function multiSectionSweep(sections, spine, options) {
     const kernel = getKernel();
     const [uFirst, uLast] = kernel.curveParameters(spine.wrapped);
     const uRange = uLast - uFirst;
-    const params = sections.map((s6, i7) => {
+    const params = sections.map((s6, i9) => {
       if (s6.location !== void 0) {
         return uFirst + s6.location * uRange;
       }
-      return uFirst + i7 / (sections.length - 1) * uRange;
+      return uFirst + i9 / (sections.length - 1) * uRange;
     });
     const positionedWires = [];
-    for (let i7 = 0; i7 < sections.length; i7++) {
-      const param = params[i7];
-      const section2 = sections[i7];
+    for (let i9 = 0; i9 < sections.length; i9++) {
+      const param = params[i9];
+      const section2 = sections[i9];
       if (param === void 0 || section2 === void 0) continue;
       const positioned = kernel.positionOnCurve(section2.wire.wrapped, spine.wrapped, param);
       positionedWires.push(kernel.downcast(positioned, "wire"));
@@ -5371,25 +5426,25 @@ function dot2(ax, ay, bx, by) {
 function len2(x7, y6) {
   return Math.sqrt(x7 * x7 + y6 * y6);
 }
-function polyAt(poly, i7) {
-  const p7 = poly[(i7 % poly.length + poly.length) % poly.length];
-  if (!p7) throw new Error(`Invalid polygon index ${i7} for length ${poly.length}`);
+function polyAt(poly, i9) {
+  const p7 = poly[(i9 % poly.length + poly.length) % poly.length];
+  if (!p7) throw new Error(`Invalid polygon index ${i9} for length ${poly.length}`);
   return p7;
 }
 function ensureCCW(poly) {
   let area = 0;
-  for (let i7 = 0; i7 < poly.length; i7++) {
-    const cur = polyAt(poly, i7);
-    const nxt = polyAt(poly, i7 + 1);
+  for (let i9 = 0; i9 < poly.length; i9++) {
+    const cur = polyAt(poly, i9);
+    const nxt = polyAt(poly, i9 + 1);
     area += cur.x * nxt.y - nxt.x * cur.y;
   }
   if (area < 0) return [...poly].reverse();
   return poly;
 }
-function bisector(poly, i7) {
-  const prev = polyAt(poly, i7 - 1);
-  const cur = polyAt(poly, i7);
-  const next = polyAt(poly, i7 + 1);
+function bisector(poly, i9) {
+  const prev = polyAt(poly, i9 - 1);
+  const cur = polyAt(poly, i9);
+  const next = polyAt(poly, i9 + 1);
   const e1x = cur.x - prev.x;
   const e1y = cur.y - prev.y;
   const e1l = len2(e1x, e1y);
@@ -5419,23 +5474,23 @@ function isLavNodeReflex(node) {
   return cross2(node.x - prev.x, node.y - prev.y, next.x - node.x, next.y - node.y) < -EPS;
 }
 function createLav(poly) {
-  const nodes = poly.map((p7, i7) => {
-    const b10 = bisector(poly, i7);
+  const nodes = poly.map((p7, i9) => {
+    const b9 = bisector(poly, i9);
     return {
       x: p7.x,
       y: p7.y,
-      bx: b10.dx,
-      by: b10.dy,
-      origIdx: i7,
+      bx: b9.dx,
+      by: b9.dy,
+      origIdx: i9,
       prev: null,
       next: null,
       active: true
     };
   });
-  for (let i7 = 0; i7 < nodes.length; i7++) {
-    const node = nodes[i7];
-    const prevNode = nodes[(i7 - 1 + nodes.length) % nodes.length];
-    const nextNode = nodes[(i7 + 1) % nodes.length];
+  for (let i9 = 0; i9 < nodes.length; i9++) {
+    const node = nodes[i9];
+    const prevNode = nodes[(i9 - 1 + nodes.length) % nodes.length];
+    const nextNode = nodes[(i9 + 1) % nodes.length];
     if (node && prevNode && nextNode) {
       node.prev = prevNode;
       node.next = nextNode;
@@ -5453,26 +5508,26 @@ function lavSize(start) {
   }
   return count;
 }
-function bisectorIntersectTime(a9, b10) {
-  const ddx = a9.bx - b10.bx;
-  const ddy = a9.by - b10.by;
-  const dxp = b10.x - a9.x;
-  const dyp = b10.y - a9.y;
+function bisectorIntersectTime(a9, b9) {
+  const ddx = a9.bx - b9.bx;
+  const ddy = a9.by - b9.by;
+  const dxp = b9.x - a9.x;
+  const dyp = b9.y - a9.y;
   if (Math.abs(ddx) < EPS && Math.abs(ddy) < EPS) return null;
-  let t11;
+  let t10;
   if (Math.abs(ddx) > Math.abs(ddy)) {
-    t11 = dxp / ddx;
+    t10 = dxp / ddx;
   } else {
-    t11 = dyp / ddy;
+    t10 = dyp / ddy;
   }
-  if (t11 < EPS) return null;
+  if (t10 < EPS) return null;
   const otherDd = Math.abs(ddx) > Math.abs(ddy) ? ddy : ddx;
   const otherDp = Math.abs(ddx) > Math.abs(ddy) ? dyp : dxp;
   if (Math.abs(otherDd) > EPS) {
     const t22 = otherDp / otherDd;
-    if (Math.abs(t11 - t22) > 1e-4 * Math.max(1, Math.abs(t11))) return null;
+    if (Math.abs(t10 - t22) > 1e-4 * Math.max(1, Math.abs(t10))) return null;
   }
-  return t11;
+  return t10;
 }
 function raySplitTime(node, eA, eB) {
   const edx = eB.x - eA.x;
@@ -5486,31 +5541,31 @@ function raySplitTime(node, eA, eB) {
   const relBy = node.by - (eA.by + eB.by) / 2;
   const dRate = relBx * enx + relBy * eny;
   if (Math.abs(dRate) < EPS) return null;
-  const t11 = -d0 / dRate;
-  if (t11 < EPS) return null;
-  const px = node.x + t11 * node.bx;
-  const py = node.y + t11 * node.by;
-  const ax = eA.x + t11 * eA.bx;
-  const ay = eA.y + t11 * eA.by;
-  const bxx = eB.x + t11 * eB.bx;
-  const byy = eB.y + t11 * eB.by;
+  const t10 = -d0 / dRate;
+  if (t10 < EPS) return null;
+  const px = node.x + t10 * node.bx;
+  const py = node.y + t10 * node.by;
+  const ax = eA.x + t10 * eA.bx;
+  const ay = eA.y + t10 * eA.by;
+  const bxx = eB.x + t10 * eB.bx;
+  const byy = eB.y + t10 * eB.by;
   const segDx = bxx - ax;
   const segDy = byy - ay;
   const segL = len2(segDx, segDy);
-  if (segL < EPS) return t11;
+  if (segL < EPS) return t10;
   const s6 = dot2(px - ax, py - ay, segDx, segDy) / (segL * segL);
   if (s6 < -0.01 || s6 > 1.01) return null;
-  return t11;
+  return t10;
 }
 function computeEvents(lavNodes) {
   const events = [];
   for (const node of lavNodes) {
     if (!node.active) continue;
-    const t11 = bisectorIntersectTime(node, node.next);
-    if (t11 !== null && t11 > EPS) {
-      const x7 = node.x + t11 * node.bx;
-      const y6 = node.y + t11 * node.by;
-      events.push({ time: t11, x: x7, y: y6, nodeA: node, nodeB: node.next, type: "edge" });
+    const t10 = bisectorIntersectTime(node, node.next);
+    if (t10 !== null && t10 > EPS) {
+      const x7 = node.x + t10 * node.bx;
+      const y6 = node.y + t10 * node.by;
+      events.push({ time: t10, x: x7, y: y6, nodeA: node, nodeB: node.next, type: "edge" });
     }
     if (isLavNodeReflex(node)) {
       let cur = node.next.next;
@@ -5527,7 +5582,7 @@ function computeEvents(lavNodes) {
       }
     }
   }
-  events.sort((a9, b10) => a9.time - b10.time);
+  events.sort((a9, b9) => a9.time - b9.time);
   return events;
 }
 function computeStraightSkeleton(polygon) {
@@ -5535,12 +5590,12 @@ function computeStraightSkeleton(polygon) {
     return { nodes: [], faces: [] };
   }
   const poly = ensureCCW(polygon);
-  const n9 = poly.length;
+  const n7 = poly.length;
   const skeletonNodes = [];
-  const vertexToSkelNodes = Array.from({ length: n9 }, () => []);
+  const vertexToSkelNodes = Array.from({ length: n7 }, () => []);
   const lavNodes = createLav(poly);
   let iterations = 0;
-  const maxIter = n9 * n9 * 2;
+  const maxIter = n7 * n7 * 2;
   while (iterations < maxIter) {
     iterations++;
     const activeStart = lavNodes.find((nd) => nd.active);
@@ -5549,26 +5604,26 @@ function computeStraightSkeleton(polygon) {
     if (sz <= 3) {
       if (sz === 3) {
         const a9 = activeStart;
-        const b10 = a9.next;
-        const c7 = b10.next;
-        const t11 = bisectorIntersectTime(a9, b10);
-        const time = t11 !== null && t11 > EPS ? t11 : 0;
-        const mx = (a9.x + b10.x + c7.x) / 3 + time * (a9.bx + b10.bx + c7.bx) / 3;
-        const my = (a9.y + b10.y + c7.y) / 3 + time * (a9.by + b10.by + c7.by) / 3;
+        const b9 = a9.next;
+        const c8 = b9.next;
+        const t10 = bisectorIntersectTime(a9, b9);
+        const time = t10 !== null && t10 > EPS ? t10 : 0;
+        const mx = (a9.x + b9.x + c8.x) / 3 + time * (a9.bx + b9.bx + c8.bx) / 3;
+        const my = (a9.y + b9.y + c8.y) / 3 + time * (a9.by + b9.by + c8.by) / 3;
         const nodeIdx = skeletonNodes.length;
         skeletonNodes.push({ x: mx, y: my, height: time });
         const aNodes = vertexToSkelNodes[a9.origIdx];
-        const bNodes = vertexToSkelNodes[b10.origIdx];
-        const cNodes = vertexToSkelNodes[c7.origIdx];
+        const bNodes = vertexToSkelNodes[b9.origIdx];
+        const cNodes = vertexToSkelNodes[c8.origIdx];
         if (aNodes) aNodes.push(nodeIdx);
         if (bNodes) bNodes.push(nodeIdx);
         if (cNodes) cNodes.push(nodeIdx);
         a9.active = false;
-        b10.active = false;
-        c7.active = false;
+        b9.active = false;
+        c8.active = false;
       } else {
         let cur = activeStart;
-        for (let i7 = 0; i7 < sz; i7++) {
+        for (let i9 = 0; i9 < sz; i9++) {
           cur.active = false;
           cur = cur.next;
         }
@@ -5587,19 +5642,19 @@ function computeStraightSkeleton(polygon) {
     if (!ev) break;
     if (ev.type === "edge") {
       const a9 = ev.nodeA;
-      const b10 = ev.nodeB;
-      if (!a9.active || !b10.active) continue;
+      const b9 = ev.nodeB;
+      if (!a9.active || !b9.active) continue;
       const nodeIdx = skeletonNodes.length;
       skeletonNodes.push({ x: ev.x, y: ev.y, height: ev.time });
       const aNodes = vertexToSkelNodes[a9.origIdx];
-      const bNodes = vertexToSkelNodes[b10.origIdx];
+      const bNodes = vertexToSkelNodes[b9.origIdx];
       if (aNodes) aNodes.push(nodeIdx);
       if (bNodes) bNodes.push(nodeIdx);
       a9.x = ev.x;
       a9.y = ev.y;
-      a9.next = b10.next;
-      b10.next.prev = a9;
-      b10.active = false;
+      a9.next = b9.next;
+      b9.next.prev = a9;
+      b9.active = false;
       const lavPoly = [];
       let cur = a9;
       do {
@@ -5611,13 +5666,13 @@ function computeStraightSkeleton(polygon) {
       a9.by = bDir.dy;
     } else {
       const a9 = ev.nodeA;
-      const b10 = ev.nodeB;
-      if (!a9.active || !b10.active) continue;
+      const b9 = ev.nodeB;
+      if (!a9.active || !b9.active) continue;
       const nodeIdx = skeletonNodes.length;
       skeletonNodes.push({ x: ev.x, y: ev.y, height: ev.time });
       const aNodes = vertexToSkelNodes[a9.origIdx];
       if (aNodes) aNodes.push(nodeIdx);
-      const bNodes = vertexToSkelNodes[b10.origIdx];
+      const bNodes = vertexToSkelNodes[b9.origIdx];
       if (bNodes) bNodes.push(nodeIdx);
       const aCopy = {
         x: ev.x,
@@ -5633,20 +5688,20 @@ function computeStraightSkeleton(polygon) {
       a9.x = ev.x;
       a9.y = ev.y;
       const aNext = a9.next;
-      const bNext = b10.next;
+      const bNext = b9.next;
       a9.next = bNext;
       bNext.prev = a9;
       aCopy.next = aNext;
       aNext.prev = aCopy;
-      aCopy.prev = b10;
-      b10.next = aCopy;
+      aCopy.prev = b9;
+      b9.next = aCopy;
       const buildLavPoly = (start) => {
         const poly2 = [];
-        let c7 = start;
+        let c8 = start;
         do {
-          poly2.push({ x: c7.x, y: c7.y });
-          c7 = c7.next;
-        } while (c7 !== start);
+          poly2.push({ x: c8.x, y: c8.y });
+          c8 = c8.next;
+        } while (c8 !== start);
         return poly2;
       };
       const lav1Poly = buildLavPoly(a9);
@@ -5660,14 +5715,14 @@ function computeStraightSkeleton(polygon) {
     }
   }
   const faces = [];
-  for (let i7 = 0; i7 < n9; i7++) {
-    const j6 = (i7 + 1) % n9;
-    const pi = polyAt(poly, i7);
-    const pj = polyAt(poly, j6);
+  for (let i9 = 0; i9 < n7; i9++) {
+    const j7 = (i9 + 1) % n7;
+    const pi = polyAt(poly, i9);
+    const pj = polyAt(poly, j7);
     const faceVerts = [pi, pj];
     const faceHeights = [0, 0];
-    const jNodes = vertexToSkelNodes[j6];
-    const iNodes = vertexToSkelNodes[i7];
+    const jNodes = vertexToSkelNodes[j7];
+    const iNodes = vertexToSkelNodes[i9];
     if (jNodes) {
       for (const ni of jNodes) {
         const sn = skeletonNodes[ni];
@@ -5722,8 +5777,8 @@ function extractPolygon(w7) {
 }
 function fanTriangulate(count) {
   const tris = [];
-  for (let i7 = 1; i7 < count - 1; i7++) {
-    tris.push([0, i7, i7 + 1]);
+  for (let i9 = 1; i9 < count - 1; i9++) {
+    tris.push([0, i9, i9 + 1]);
   }
   return tris;
 }
@@ -5739,42 +5794,42 @@ function pointInTriangle(px, py, ax, ay, bx, by, cx, cy) {
   return !(hasNeg && hasPos);
 }
 function earClipTriangulate(poly) {
-  const n9 = poly.length;
-  if (n9 < 3) return [];
-  if (n9 === 3) return [[0, 1, 2]];
+  const n7 = poly.length;
+  if (n7 < 3) return [];
+  if (n7 === 3) return [[0, 1, 2]];
   let area2 = 0;
-  for (let i7 = 0; i7 < n9; i7++) {
-    const a9 = poly[i7];
-    const b10 = poly[(i7 + 1) % n9];
-    if (a9 && b10) area2 += a9.x * b10.y - b10.x * a9.y;
+  for (let i9 = 0; i9 < n7; i9++) {
+    const a9 = poly[i9];
+    const b9 = poly[(i9 + 1) % n7];
+    if (a9 && b9) area2 += a9.x * b9.y - b9.x * a9.y;
   }
   const tris = [];
-  const idx = Array.from({ length: n9 }, (_2, i7) => i7);
+  const idx = Array.from({ length: n7 }, (_2, i9) => i9);
   if (area2 < 0) idx.reverse();
   const isEar = (prev, curr, next) => {
     const a9 = poly[prev];
-    const b10 = poly[curr];
-    const c7 = poly[next];
-    if (!a9 || !b10 || !c7) return false;
-    if (cross2d(a9.x, a9.y, b10.x, b10.y, c7.x, c7.y) <= 0) return false;
+    const b9 = poly[curr];
+    const c8 = poly[next];
+    if (!a9 || !b9 || !c8) return false;
+    if (cross2d(a9.x, a9.y, b9.x, b9.y, c8.x, c8.y) <= 0) return false;
     for (const vi of idx) {
       if (vi === prev || vi === curr || vi === next) continue;
       const p7 = poly[vi];
       if (!p7) continue;
-      if (pointInTriangle(p7.x, p7.y, a9.x, a9.y, b10.x, b10.y, c7.x, c7.y)) return false;
+      if (pointInTriangle(p7.x, p7.y, a9.x, a9.y, b9.x, b9.y, c8.x, c8.y)) return false;
     }
     return true;
   };
   while (idx.length > 3) {
     let clipped = false;
-    for (let i7 = 0; i7 < idx.length; i7++) {
-      const prev = idx[(i7 - 1 + idx.length) % idx.length];
-      const curr = idx[i7];
-      const next = idx[(i7 + 1) % idx.length];
+    for (let i9 = 0; i9 < idx.length; i9++) {
+      const prev = idx[(i9 - 1 + idx.length) % idx.length];
+      const curr = idx[i9];
+      const next = idx[(i9 + 1) % idx.length];
       if (prev === void 0 || curr === void 0 || next === void 0) continue;
       if (isEar(prev, curr, next)) {
         tris.push([prev, curr, next]);
-        idx.splice(i7, 1);
+        idx.splice(i9, 1);
         clipped = true;
         break;
       }
@@ -5782,8 +5837,8 @@ function earClipTriangulate(poly) {
     if (!clipped) break;
   }
   if (idx.length === 3) {
-    const [a9, b10, c7] = idx;
-    if (a9 !== void 0 && b10 !== void 0 && c7 !== void 0) tris.push([a9, b10, c7]);
+    const [a9, b9, c8] = idx;
+    if (a9 !== void 0 && b9 !== void 0 && c8 !== void 0) tris.push([a9, b9, c8]);
   }
   return tris;
 }
@@ -5810,10 +5865,10 @@ function roof(w7, options) {
     const triFaces = [];
     for (const skFace of skeleton.faces) {
       const verts3d = skFace.vertices.map(
-        (v9, i7) => [
+        (v9, i9) => [
           v9.x,
           v9.y,
-          (skFace.heights[i7] ?? 0) * tanAngle
+          (skFace.heights[i9] ?? 0) * tanAngle
         ]
       );
       const tris = fanTriangulate(verts3d.length);
@@ -5888,36 +5943,36 @@ function solveConstraints(nodes, constraints) {
     });
   }
   const unsupported = [];
-  for (const c7 of constraints) {
-    if (c7.type === "coincident" && c7.entityA && c7.entityB) {
-      const a9 = c7.entityA;
-      const b10 = c7.entityB;
-      if (a9.entity.type === "plane" && b10.entity.type === "plane") {
+  for (const c8 of constraints) {
+    if (c8.type === "coincident" && c8.entityA && c8.entityB) {
+      const a9 = c8.entityA;
+      const b9 = c8.entityB;
+      if (a9.entity.type === "plane" && b9.entity.type === "plane") {
         const aNormal = a9.entity.normal ?? [0, 0, 1];
         const aOrigin = a9.entity.origin;
-        const bOrigin = b10.entity.origin;
+        const bOrigin = b9.entity.origin;
         const dot = aNormal[0] * (aOrigin[0] - bOrigin[0]) + aNormal[1] * (aOrigin[1] - bOrigin[1]) + aNormal[2] * (aOrigin[2] - bOrigin[2]);
         const pos = [dot * aNormal[0], dot * aNormal[1], dot * aNormal[2]];
-        transforms.set(b10.node, { position: pos, rotation: [1, 0, 0, 0] });
+        transforms.set(b9.node, { position: pos, rotation: [1, 0, 0, 0] });
       } else {
-        unsupported.push(`coincident(${a9.entity.type}-${b10.entity.type})`);
+        unsupported.push(`coincident(${a9.entity.type}-${b9.entity.type})`);
       }
-    } else if (c7.type === "distance" && c7.entityA && c7.entityB && c7.value !== void 0) {
-      const a9 = c7.entityA;
-      const b10 = c7.entityB;
-      if (a9.entity.type === "plane" && b10.entity.type === "plane") {
+    } else if (c8.type === "distance" && c8.entityA && c8.entityB && c8.value !== void 0) {
+      const a9 = c8.entityA;
+      const b9 = c8.entityB;
+      if (a9.entity.type === "plane" && b9.entity.type === "plane") {
         const aNormal = a9.entity.normal ?? [0, 0, 1];
         const aOrigin = a9.entity.origin;
-        const bOrigin = b10.entity.origin;
+        const bOrigin = b9.entity.origin;
         const currentDist = aNormal[0] * (aOrigin[0] - bOrigin[0]) + aNormal[1] * (aOrigin[1] - bOrigin[1]) + aNormal[2] * (aOrigin[2] - bOrigin[2]);
-        const offset2 = currentDist + c7.value;
+        const offset2 = currentDist + c8.value;
         const pos = [offset2 * aNormal[0], offset2 * aNormal[1], offset2 * aNormal[2]];
-        transforms.set(b10.node, { position: pos, rotation: [1, 0, 0, 0] });
+        transforms.set(b9.node, { position: pos, rotation: [1, 0, 0, 0] });
       } else {
-        unsupported.push(`distance(${a9.entity.type}-${b10.entity.type})`);
+        unsupported.push(`distance(${a9.entity.type}-${b9.entity.type})`);
       }
-    } else if (c7.type === "concentric" || c7.type === "angle") {
-      unsupported.push(c7.type);
+    } else if (c8.type === "concentric" || c8.type === "angle") {
+      unsupported.push(c8.type);
     }
   }
   const dof = unsupported.reduce((sum, type) => {
@@ -5937,9 +5992,9 @@ function extractEntity(mate) {
   }
   return null;
 }
-function extractPair(a9, b10) {
+function extractPair(a9, b9) {
   const entA = extractEntity(a9);
-  const entB = extractEntity(b10);
+  const entB = extractEntity(b9);
   if (!entA || !entB) {
     return err(
       validationError(
@@ -5950,7 +6005,7 @@ function extractPair(a9, b10) {
   }
   return ok({
     entityA: { node: a9.node, entity: entA },
-    entityB: { node: b10.node, entity: entB }
+    entityB: { node: b9.node, entity: entB }
   });
 }
 function addMate(assembly, constraint) {
@@ -6041,28 +6096,28 @@ function checkInterference(shape1, shape2, tolerance = 1e-6) {
 function checkAllInterferences(shapes, tolerance = 1e-6) {
   const pairs = [];
   const boxes = shapes.map((s6) => getBounds(s6));
-  shapes.forEach((si, i7) => {
-    for (let j6 = i7 + 1; j6 < shapes.length; j6++) {
-      if (aabbDisjoint(boxes[i7], boxes[j6], tolerance)) continue;
-      const result = unwrap$1(checkInterference(si, shapes[j6], tolerance));
+  shapes.forEach((si, i9) => {
+    for (let j7 = i9 + 1; j7 < shapes.length; j7++) {
+      if (aabbDisjoint(boxes[i9], boxes[j7], tolerance)) continue;
+      const result = unwrap$1(checkInterference(si, shapes[j7], tolerance));
       if (result.hasInterference) {
-        pairs.push({ i: i7, j: j6, result });
+        pairs.push({ i: i9, j: j7, result });
       }
     }
   });
   return pairs;
 }
-function aabbDisjoint(a9, b10, tolerance) {
-  return a9.xMax + tolerance < b10.xMin || b10.xMax + tolerance < a9.xMin || a9.yMax + tolerance < b10.yMin || b10.yMax + tolerance < a9.yMin || a9.zMax + tolerance < b10.zMin || b10.zMax + tolerance < a9.zMin;
+function aabbDisjoint(a9, b9, tolerance) {
+  return a9.xMax + tolerance < b9.xMin || b9.xMax + tolerance < a9.xMin || a9.yMax + tolerance < b9.yMin || b9.yMax + tolerance < a9.yMin || a9.zMax + tolerance < b9.zMin || b9.zMax + tolerance < a9.zMin;
 }
 function parseEntities(text) {
   const lines = text.split(/\r?\n/);
   const entities = [];
   let inEntities = false;
   let current;
-  for (let i7 = 0; i7 < lines.length - 1; i7 += 2) {
-    const codeLine = lines[i7];
-    const valueLine = lines[i7 + 1];
+  for (let i9 = 0; i9 < lines.length - 1; i9 += 2) {
+    const codeLine = lines[i9];
+    const valueLine = lines[i9 + 1];
     if (codeLine === void 0 || valueLine === void 0) continue;
     const code = parseInt(codeLine.trim(), 10);
     const value = valueLine.trim();
@@ -6094,8 +6149,8 @@ function parseEntities(text) {
 function getNum(data, code, fallback = 0) {
   const v9 = data.get(code);
   if (v9 === void 0) return fallback;
-  const n9 = parseFloat(v9);
-  return isNaN(n9) ? fallback : n9;
+  const n7 = parseFloat(v9);
+  return isNaN(n7) ? fallback : n7;
 }
 function entityToEdge(entity) {
   const { type, data } = entity;
@@ -6199,10 +6254,10 @@ function buildSolidFromMesh$1(vertices, faces) {
   const kernel = getKernel();
   const triFaces = [];
   for (const face of faces) {
-    for (let i7 = 1; i7 < face.length - 1; i7++) {
+    for (let i9 = 1; i9 < face.length - 1; i9++) {
       const rawA = face[0] ?? 0;
-      const rawB = face[i7] ?? 0;
-      const rawC = face[i7 + 1] ?? 0;
+      const rawB = face[i9] ?? 0;
+      const rawC = face[i9 + 1] ?? 0;
       const ai = rawA > 0 ? rawA - 1 : vertices.length + rawA;
       const bi = rawB > 0 ? rawB - 1 : vertices.length + rawB;
       const ci = rawC > 0 ? rawC - 1 : vertices.length + rawC;
@@ -6233,9 +6288,9 @@ function buildSolidFromMesh$1(vertices, faces) {
 }
 function extractFromZip(data, target) {
   let eocdOffset = -1;
-  for (let i7 = data.length - 22; i7 >= 0; i7--) {
-    if (data[i7] === 80 && data[i7 + 1] === 75 && data[i7 + 2] === 5 && data[i7 + 3] === 6) {
-      eocdOffset = i7;
+  for (let i9 = data.length - 22; i9 >= 0; i9--) {
+    if (data[i9] === 80 && data[i9 + 1] === 75 && data[i9 + 2] === 5 && data[i9 + 3] === 6) {
+      eocdOffset = i9;
       break;
     }
   }
@@ -6640,7 +6695,7 @@ function shell$1(shape2, faces, thickness, tolerance = 1e-3) {
     const inputFaceHashes = collectInputFaceHashes([shape2]);
     const { shape: resultShape, evolution } = getKernel().shellWithHistory(
       shape2.wrapped,
-      faces.map((f12) => f12.wrapped),
+      faces.map((f11) => f11.wrapped),
       thickness,
       inputFaceHashes,
       HASH_CODE_MAX,
@@ -6716,14 +6771,14 @@ function applyMatrix(shape2, matrix) {
 function transformCopy(shape2, composed) {
   return transformCopy$1(resolve(shape2), composed);
 }
-function fuse(a9, b10, options) {
-  return fuse$1(resolve(a9), resolve(b10), options);
+function fuse(a9, b9, options) {
+  return fuse$1(resolve(a9), resolve(b9), options);
 }
 function cut(base, tool, options) {
   return cut$1(resolve(base), resolve(tool), options);
 }
-function intersect(a9, b10, options) {
-  return intersect$1(resolve(a9), resolve(b10), options);
+function intersect(a9, b9, options) {
+  return intersect$1(resolve(a9), resolve(b9), options);
 }
 function section(shape2, plane, options) {
   return section$1(resolve(shape2), plane, options);
@@ -6873,9 +6928,9 @@ function loft$1(wires, { ruled = true, startPoint, endPoint, tolerance = 1e-6 }
   }
 }
 function extrude(face, height) {
-  const f12 = resolve(face);
+  const f11 = resolve(face);
   const vec = typeof height === "number" ? [0, 0, height] : height;
-  return extrude$1(f12, vec);
+  return extrude$1(f11, vec);
 }
 function revolve(face, options) {
   const pivotPoint = options?.at ?? [0, 0, 0];
@@ -6900,11 +6955,11 @@ function resolveTargetFace(shape2, faceSpec) {
     }
     let best = faces[0];
     let bestZ = faceCenter(best)[2];
-    for (let i7 = 1; i7 < faces.length; i7++) {
-      const f12 = faces[i7];
-      const z6 = faceCenter(f12)[2];
+    for (let i9 = 1; i9 < faces.length; i9++) {
+      const f11 = faces[i9];
+      const z6 = faceCenter(f11)[2];
       if (z6 > bestZ) {
-        best = f12;
+        best = f11;
         bestZ = z6;
       }
     }
@@ -6947,23 +7002,23 @@ function drill(shape2, options) {
   if (options.depth !== void 0) {
     tool = makeCylinder(radius, options.depth, pos, dir);
   } else {
-    const b10 = getBounds(s6);
+    const b9 = getBounds(s6);
     const corners = [
-      [b10.xMin, b10.yMin, b10.zMin],
-      [b10.xMax, b10.yMin, b10.zMin],
-      [b10.xMin, b10.yMax, b10.zMin],
-      [b10.xMax, b10.yMax, b10.zMin],
-      [b10.xMin, b10.yMin, b10.zMax],
-      [b10.xMax, b10.yMin, b10.zMax],
-      [b10.xMin, b10.yMax, b10.zMax],
-      [b10.xMax, b10.yMax, b10.zMax]
+      [b9.xMin, b9.yMin, b9.zMin],
+      [b9.xMax, b9.yMin, b9.zMin],
+      [b9.xMin, b9.yMax, b9.zMin],
+      [b9.xMax, b9.yMax, b9.zMin],
+      [b9.xMin, b9.yMin, b9.zMax],
+      [b9.xMax, b9.yMin, b9.zMax],
+      [b9.xMin, b9.yMax, b9.zMax],
+      [b9.xMax, b9.yMax, b9.zMax]
     ];
     let tMin = Infinity;
     let tMax = -Infinity;
-    for (const c7 of corners) {
-      const t11 = (c7[0] - pos[0]) * dir[0] + (c7[1] - pos[1]) * dir[1] + (c7[2] - pos[2]) * dir[2];
-      if (t11 < tMin) tMin = t11;
-      if (t11 > tMax) tMax = t11;
+    for (const c8 of corners) {
+      const t10 = (c8[0] - pos[0]) * dir[0] + (c8[1] - pos[1]) * dir[1] + (c8[2] - pos[2]) * dir[2];
+      if (t10 < tMin) tMin = t10;
+      if (t10 > tMax) tMax = t10;
     }
     const overshoot = 1;
     tMin -= overshoot;
@@ -7166,8 +7221,8 @@ function createWrappedCurve(val) {
     length: () => curveLength(val),
     startPoint: () => curveStartPoint(val),
     endPoint: () => curveEndPoint(val),
-    pointAt: (t11) => curvePointAt(val, t11),
-    tangentAt: (t11) => curveTangentAt(val, t11),
+    pointAt: (t10) => curvePointAt(val, t10),
+    tangentAt: (t10) => curveTangentAt(val, t10),
     isClosed: () => curveIsClosed(val),
     sweep(spine, opts) {
       if (!isWire(val)) throw new Error("sweep requires a Wire");
@@ -7218,8 +7273,8 @@ export {
   B3 as BaseSketcher2d,
   B as Blueprint,
   a5 as BlueprintSketcher,
-  e3 as Blueprints,
-  d3 as BoundingBox2d,
+  c2 as Blueprints,
+  e3 as BoundingBox2d,
   BrepBugError,
   BrepErrorCode,
   BrepWrapperError,
@@ -7247,7 +7302,7 @@ export {
   a2 as andThen,
   applyGlue,
   applyMatrix,
-  j5 as approximateCurve,
+  h7 as approximateCurve,
   M as as2D,
   N as as3D,
   l9 as asTopo,
@@ -7257,38 +7312,38 @@ export {
   blueprintToDXF,
   boss,
   f7 as box,
-  g9 as bsplineApprox,
+  g8 as bsplineApprox,
   bug,
   X as cameraFromPlane,
   Y as cameraLookAt,
-  c4 as cast,
+  c5 as cast,
   castShape,
   O as castShape3D,
   chamfer,
   chamferDistAngle as chamferDistAngleShape,
   checkAllInterferences,
   checkInterference,
-  j4 as circle,
+  j5 as circle,
   circularPattern,
   m9 as classifyPointOnFace,
-  c5 as clearMeshCache,
+  c6 as clearMeshCache,
   clone,
   a as closedWire,
   c as collect,
-  d4 as collectShapes,
+  d3 as collectShapes,
   l6 as colorFaces,
   m6 as colorShape,
   f3 as complexExtrude,
   w4 as composeTransforms,
   k5 as compound,
-  c2 as compoundSketchExtrude,
+  c3 as compoundSketchExtrude,
   d5 as compoundSketchFace,
   e4 as compoundSketchLoft,
   f5 as compoundSketchRevolve,
   b2 as computationError,
   computeStraightSkeleton,
   l7 as cone,
-  c6 as cornerFinder,
+  c7 as cornerFinder,
   g5 as countNodes,
   h4 as createAssembly,
   i3 as createAssemblyNode,
@@ -7301,8 +7356,8 @@ export {
   b as createHandle,
   j2 as createHistory,
   d as createKernelHandle,
-  b9 as createMeshCache,
-  c3 as createNamedPlane,
+  b8 as createMeshCache,
+  c4 as createNamedPlane,
   createOperationRegistry,
   a7 as createPlane,
   k2 as createRegistry,
@@ -7323,37 +7378,37 @@ export {
   curve2dTangentAt,
   curveEndPoint,
   curveIsClosed,
-  k6 as curveIsPeriodic,
+  i6 as curveIsPeriodic,
   curveLength,
-  l8 as curvePeriod,
+  j6 as curvePeriod,
   curvePointAt,
   curveStartPoint,
   curveTangentAt,
   cut,
-  f4 as cut2D,
+  d4 as cut2D,
   cutAll,
-  l4 as cutBlueprints,
+  j3 as cutBlueprints,
   m7 as cylinder,
   dequeueTask,
   describe,
-  g8 as deserializeDrawing,
+  g7 as deserializeDrawing,
   m4 as deserializeHistory,
   fromBREP$1 as deserializeShape,
   d7 as downcast,
-  h5 as draw,
+  h6 as draw,
   i4 as drawCircle,
-  j3 as drawEllipse,
+  j4 as drawEllipse,
   k4 as drawFaceOutline,
   l5 as drawParametricFunction,
   m5 as drawPointsInterpolation,
-  n5 as drawPolysides,
+  n4 as drawPolysides,
   o5 as drawProjection,
   p3 as drawRectangle,
-  q3 as drawRoundedRectangle,
+  q2 as drawRoundedRectangle,
   r3 as drawSingleCircle,
   s3 as drawSingleEllipse,
-  t5 as drawText,
-  u3 as drawingChamfer,
+  t4 as drawText,
+  u4 as drawingChamfer,
   v5 as drawingCut,
   w3 as drawingFillet,
   x4 as drawingFuse,
@@ -7361,10 +7416,10 @@ export {
   z3 as drawingToSketchOnPlane,
   drill,
   edgeFinder,
-  n7 as edgesOfFace,
+  n6 as edgesOfFace,
   o7 as ellipse,
   p5 as ellipseArc,
-  q5 as ellipsoid,
+  q4 as ellipsoid,
   enqueueTask,
   err,
   n3 as exportAssemblySTEP,
@@ -7374,25 +7429,25 @@ export {
   e6 as exportIGES,
   exportOBJ,
   d8 as exportSTEP,
-  f10 as exportSTL,
+  f9 as exportSTL,
   exportThreeMF,
   extrude,
   r7 as face,
   faceCenter,
   faceFinder,
-  f9 as faceGeomType,
-  q6 as faceOrientation,
+  f8 as faceGeomType,
+  q5 as faceOrientation,
   s4 as facesOfEdge,
-  n8 as fill,
-  t9 as filledFace,
+  i8 as fill,
+  t8 as filledFace,
   fillet,
   findCurveType,
-  n6 as findFacesByTag,
+  n5 as findFacesByTag,
   o3 as findNode,
   p as findStep,
   f2 as flatMap,
   r8 as flipFaceOrientation,
-  f8 as flipOrientation,
+  k6 as flipOrientation,
   _ as fontMetrics,
   fromBREP,
   fromKernelDir,
@@ -7400,34 +7455,34 @@ export {
   fromKernelVec,
   C2 as fromNullable,
   fuse,
-  g6 as fuse2D,
+  f4 as fuse2D,
   fuseAll,
-  n4 as fuseBlueprints,
+  k3 as fuseBlueprints,
   g4 as genericSweep,
   getBounds,
   getBounds2D,
-  b8 as getCurveType,
+  l8 as getCurveType,
   getEdges,
   o6 as getFaceColor,
   getFaceOrigins,
-  q4 as getFaceTags,
+  q3 as getFaceTags,
   getFaces,
   $ as getFont,
   f6 as getHashCode,
   q as getHistoryShape,
   getKernel,
-  g10 as getOrientation,
+  g9 as getOrientation,
   getOrientation2D,
   r6 as getShapeColor,
   g as getShapeKind,
-  g7 as getSingleFace,
+  g6 as getSingleFace,
   getSurfaceType,
-  t8 as getTagMetadata,
+  t7 as getTagMetadata,
   getVertices,
   getWires,
   guidedSweep,
   heal,
-  u5 as healFace,
+  u6 as healFace,
   v7 as healSolid,
   w5 as healWire,
   x6 as helix,
@@ -7444,8 +7499,9 @@ export {
   innerWires,
   m8 as interpolateCurve,
   intersect,
-  k3 as intersect2D,
-  q2 as intersectBlueprints,
+  h5 as intersect2D,
+  l4 as intersectBlueprints,
+  x5 as invalidateShapeCache,
   ioError,
   i as is2D,
   e as is3D,
@@ -7456,7 +7512,7 @@ export {
   isDisposeRequest,
   isEdge,
   isEmpty,
-  x5 as isEqualShape,
+  y4 as isEqualShape,
   isErr,
   isErrorResponse,
   isFace,
@@ -7481,11 +7537,11 @@ export {
   s as isValidSolid,
   t as isVertex,
   isWire,
-  y4 as iterEdges,
-  z4 as iterFaces,
+  z4 as iterEdges,
+  A5 as iterFaces,
   iterTopo,
-  A5 as iterVertices,
-  B5 as iterWires,
+  B5 as iterVertices,
+  C7 as iterWires,
   kernelCall,
   kernelCallRaw,
   kernelCallScoped,
@@ -7495,7 +7551,7 @@ export {
   a1 as loadFont,
   loft,
   A4 as makeBaseBox,
-  t3 as makePlane,
+  u2 as makePlane,
   a22 as makeProjectedEdges,
   v as manifoldShell,
   m2 as map,
@@ -7503,10 +7559,10 @@ export {
   j as match,
   measureArea,
   e7 as measureCurvatureAt,
-  f11 as measureCurvatureAtMid,
-  g11 as measureDistance,
-  h7 as measureLength,
-  i6 as measureLinearProps,
+  f10 as measureCurvatureAtMid,
+  g10 as measureDistance,
+  h9 as measureLength,
+  i7 as measureLinearProps,
   measureSurfaceProps,
   measureVolume,
   measureVolumeProps,
@@ -7517,7 +7573,7 @@ export {
   mirror2D,
   B4 as mirrorDrawing,
   mirrorJoin,
-  t4 as modifyStep,
+  t3 as modifyStep,
   l2 as moduleInitError,
   multiSectionSweep,
   normalAt,
@@ -7540,19 +7596,19 @@ export {
   E4 as polysideInnerRadius,
   p2 as polysidesBlueprint,
   a32 as projectEdges,
-  t10 as projectPointOnFace,
+  t9 as projectPointOnFace,
   queryError,
   rectangularPattern,
   registerHandler,
   R as registerKernel,
-  u2 as registerOperation,
+  u3 as registerOperation,
   v4 as registerShape,
   rejectAll,
   x3 as removeChild,
   v8 as removeHolesFromFace,
   y2 as replayFrom,
   z2 as replayHistory,
-  C7 as resize,
+  D5 as resize,
   resolve,
   resolve3D,
   r4 as resolveDirection,
@@ -7571,8 +7627,8 @@ export {
   section,
   sectionToFace,
   A3 as serializeHistory,
-  D5 as setShapeOrigin,
-  u4 as setTagMetadata,
+  E5 as setShapeOrigin,
+  u5 as setTagMetadata,
   B6 as sewShells,
   shape,
   w6 as shapeType,
@@ -7600,7 +7656,7 @@ export {
   slice,
   D6 as solid,
   solveAssembly,
-  E5 as sphere,
+  E6 as sphere,
   split,
   B2 as stepCount,
   C4 as stepsFrom,
@@ -7626,14 +7682,14 @@ export {
   toKernelVec,
   K2 as toLineGeometryData,
   toSVGPathD,
-  t6 as toVec2,
+  t5 as toVec2,
   toVec3,
   L2 as torus,
   transformCopy,
   translate,
   translate2D,
   W as translateDrawing,
-  t7 as translatePlane,
+  t6 as translatePlane,
   t2 as tryCatch,
   n2 as tryCatchAsync,
   E3 as twistExtrude,
@@ -7645,8 +7701,8 @@ export {
   w2 as unwrapOr,
   x2 as unwrapOrElse,
   G2 as updateNode,
-  u6 as uvBounds,
-  h6 as uvCoordinates,
+  u7 as uvBounds,
+  h8 as uvCoordinates,
   x as validSolid,
   validationError,
   v3 as vecAdd,