brepjs 12.7.3 → 12.8.1

package/dist/brepjs.js

@@ -45,43 +45,42 @@ var __callDispose = (stack, error, hasError) => {
 };
 import { c as castShape, D as DisposalScope, B as getKernel, k as isFace, q as isShell, r as isSolid, p as isShape3D, F as createSolid, G as createWire, j as isEdge, u as isWire } from "./shapeTypes-CpSaBLDv.js";
 import { M, N, O, a, C, H, I, b, d, P, E, g, Q, i, e, f, h, l, m, n, o, s, t, v, w, R, x, S, y, z, A } from "./shapeTypes-CpSaBLDv.js";
-import { o as ok, z as translateKernelError, e as err, p as typeCastError, q as queryError, y as validationError, B as BrepErrorCode, k as kernelError, i as ioError, d as isErr, r as unwrap$1 } from "./errors-B7kgv0cd.js";
-import { O as O2, A as A2, a as a2, c, b as b2, f as f2, C as C2, g as g2, m as m2, h as h2, j, l as l2, D, E as E2, F, s as s2, G, H as H2, t as t2, n as n2, u, v as v2, w as w2, x as x2, I as I2 } from "./errors-B7kgv0cd.js";
+import { o as ok, D as translateKernelError, e as err, r as typeCastError, q as queryError, z as validationError, A as BrepErrorCode, k as kernelError, i as ioError, g as isErr, v as unwrap$1 } from "./result-BaSD1fqR.js";
+import { B, O as O2, E as E2, a as a2, b as b2, c, d as d2, f as f2, F, h as h2, m as m2, j, l as l2, n as n2, G, H as H2, I as I2, s as s2, J, K, t as t2, p, u, w as w2, x as x2, y as y2, L } from "./result-BaSD1fqR.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, 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 { D, R as R2, v as v2, a as a3, b as b3, d as d3, e as e2, g as g2, h as h3, i as i2, k, l as l3, m as m3, o as o2 } from "./vecOps-ZDdZWbwT.js";
+import { B as B2, e as e3, C as C2, u as u2 } from "./Blueprint-DbVaf6k7.js";
+import { b as b4, g as g3, r } from "./loft-Bhw-FMoL.js";
+import { w as walkAssembly, e as extrude$1, r as revolve$1, s as sweep, c as circularPattern, l as linearPattern } from "./operations-BfbkK6DU.js";
+import { a as a4, b as b5, d as d4, f as f3, g as g4, h as h4, i as i3, j as j2, k as k2, m as m4, n as n3, o as o3, p as p2, q, t as t3, u as u3, v as v3, x as x3, y as y3, z as z2, A as A2, B as B3, C as C3, D as D2, E as E3, F as F2, G as G2 } from "./operations-BfbkK6DU.js";
+import { B as B4, a as a5, c as c2, C as C4, F as F3, S as S2, d as d5, j as j3, f as f4, k as k3, h as h5, l as l4, o as o4, p as p3, r as r2 } from "./boolean2D-y3E92F0u.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-C9KvE1RW.js";
-import { g as g6 } from "./helpers-C9KvE1RW.js";
+import { l as createTypedFinder, m as faceFinder } from "./helpers-X0juxnwj.js";
+import { g as g5 } from "./helpers-X0juxnwj.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 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 { C as C5, D as D3, a as a6, S as S3, b as b6, X, Y, c as c3, d as d6, e as e4, f as f5, Z, g as g6, 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 p4, q as q2, r as r3, s as s3, t as t4, u as u4, v as v4, w as w3, x as x4, y as y4, z as z3, _, $, a0, a1, A as A3, a2 as a22, B as B5, E as E4, a3 as a32, F as F4, G as G3, H as H3, I as I3, J as J2, K as K2, L as L2, 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-Bwakrq7w.js";
 import { a as toVec3 } from "./types-CWDdqcrq.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 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 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 { c as c4, a as a7, p as p5, r as r5, t as t6 } from "./vectors-Bx8wkNui.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-FDuKkrDR.js";
+import { w as w4, f as f6, x as x5, y as y5, i as i5, z as z4, A as A4, B as B6, C as C6, D as D4, E as E5 } from "./shapeFns-FDuKkrDR.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-BCTjYZAg.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 v5 } from "./booleanFns-BCTjYZAg.js";
+import { c as chamferDistAngle, h as heal$1, i as isValid$1 } from "./topology-C7x98OVn.js";
+import { a as a8, b as b7, d as d7, e as e5, f as f7, g as g7, j as j5, k as k5, l as l7, m as m7, n as n6, o as o7, p as p6, q as q4, r as r7, s as s4, t as t8, u as u6, v as v6, w as w5, x as x6, y as y6, z as z5, A as A5, B as B7, C as C7, D as D5, E as E6, F as F5, G as G4, H as H4, I as I4, J as J3, K as K3, L as L3, M as M3, N as N3, O as O4, P as P3, Q as Q3 } from "./topology-C7x98OVn.js";
+import { b as curveIsClosed, c as curveStartPoint, a as curveTangentAt, d as curvePointAt, e as curveEndPoint, f as curveLength } from "./curveFns-mROFhiuG.js";
+import { h as h7, i as i6, j as j6, k as k6, l as l8, g as g8, m as m8, o as o8 } from "./curveFns-mROFhiuG.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-B8GnxjdY.js";
+import { l as l9, c as c5, m as m9, d as d8, f as f8, q as q5, r as r8, s as s5, p as p7, t as t9, v as v7, w as w6, u as u7, h as h8 } from "./faceFns-B8GnxjdY.js";
+import { m as mesh$1, a as meshEdges$1 } from "./meshFns-nQjK38EC.js";
+import { c as c6, b as b8, e as e6, d as d9, f as f9 } from "./meshFns-nQjK38EC.js";
+import { m as measureArea, a as measureSurfaceProps, b as measureVolumeProps, c as measureVolume } from "./measurement-D8EJ694A.js";
+import { d as d10, e as e7, f as f10, g as g9, h as h9, i as i7 } from "./measurement-D8EJ694A.js";
+import { m as makeFace } from "./surfaceBuilders-nQdJ56fe.js";
+import { i as i8 } from "./surfaceBuilders-nQdJ56fe.js";
 import { edgeFinder } from "./query.js";
-import { c as makeCylinder } from "./solidBuilders-BXhh5hP2.js";
-import { BrepBugError, bug } from "./result.js";
-import { c as c7 } from "./cornerFinder-BV-l1BCw.js";
+import { c as makeCylinder } from "./solidBuilders-DmwhTCCd.js";
+import { c as c7 } from "./cornerFinder-Ckz-mPHE.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;
@@ -102,8 +101,8 @@ function evaluateCurve2d(c8, 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];
+      const y7 = c8.minorRadius * Math.sin(angle);
+      return [c8.cx + x7 * cos - y7 * sin, c8.cy + x7 * sin + y7 * cos];
     }
     case "bezier":
       return evaluateBezier(c8.poles, t10);
@@ -227,9 +226,9 @@ function translateCurve2d(c8, dx, dy) {
     case "ellipse":
       return { ...c8, cx: c8.cx + dx, cy: c8.cy + dy };
     case "bezier":
-      return { ...c8, poles: c8.poles.map(([x7, y6]) => [x7 + dx, y6 + dy]) };
+      return { ...c8, poles: c8.poles.map(([x7, y7]) => [x7 + dx, y7 + dy]) };
     case "bspline":
-      return { ...c8, poles: c8.poles.map(([x7, y6]) => [x7 + dx, y6 + dy]) };
+      return { ...c8, poles: c8.poles.map(([x7, y7]) => [x7 + dx, y7 + dy]) };
     case "trimmed":
       return { ...c8, basis: translateCurve2d(c8.basis, dx, dy) };
   }
@@ -237,9 +236,9 @@ function translateCurve2d(c8, dx, dy) {
 function rotateCurve2d(c8, angle, cx, cy) {
   const cos = Math.cos(angle);
   const sin = Math.sin(angle);
-  const rotatePoint = (x7, y6) => {
+  const rotatePoint = (x7, y7) => {
     const rx = x7 - cx;
-    const ry = y6 - cy;
+    const ry = y7 - cy;
     return [cx + rx * cos - ry * sin, cy + rx * sin + ry * cos];
   };
   switch (c8.__bk2d) {
@@ -258,17 +257,17 @@ function rotateCurve2d(c8, angle, cx, cy) {
       return { ...c8, cx: ncx, cy: ncy, xDirAngle: c8.xDirAngle + angle };
     }
     case "bezier":
-      return { ...c8, poles: c8.poles.map(([x7, y6]) => rotatePoint(x7, y6)) };
+      return { ...c8, poles: c8.poles.map(([x7, y7]) => rotatePoint(x7, y7)) };
     case "bspline":
-      return { ...c8, poles: c8.poles.map(([x7, y6]) => rotatePoint(x7, y6)) };
+      return { ...c8, poles: c8.poles.map(([x7, y7]) => rotatePoint(x7, y7)) };
     case "trimmed":
       return { ...c8, basis: rotateCurve2d(c8.basis, angle, cx, cy) };
   }
 }
 function scaleCurve2d(c8, factor, cx, cy) {
-  const scalePoint = (x7, y6) => [
+  const scalePoint = (x7, y7) => [
     cx + (x7 - cx) * factor,
-    cy + (y6 - cy) * factor
+    cy + (y7 - cy) * factor
   ];
   switch (c8.__bk2d) {
     case "line": {
@@ -290,9 +289,9 @@ function scaleCurve2d(c8, factor, cx, cy) {
       };
     }
     case "bezier":
-      return { ...c8, poles: c8.poles.map(([x7, y6]) => scalePoint(x7, y6)) };
+      return { ...c8, poles: c8.poles.map(([x7, y7]) => scalePoint(x7, y7)) };
     case "bspline":
-      return { ...c8, poles: c8.poles.map(([x7, y6]) => scalePoint(x7, y6)) };
+      return { ...c8, poles: c8.poles.map(([x7, y7]) => scalePoint(x7, y7)) };
     case "trimmed":
       return { ...c8, basis: scaleCurve2d(c8.basis, factor, cx, cy) };
   }
@@ -304,9 +303,9 @@ function mirrorAcrossAxis(c8, ox, oy, dx, dy) {
   const len = Math.sqrt(dx * dx + dy * dy);
   const nx = dx / len;
   const ny = dy / len;
-  const reflectPoint = (x7, y6) => {
+  const reflectPoint = (x7, y7) => {
     const rx = x7 - ox;
-    const ry = y6 - oy;
+    const ry = y7 - oy;
     const dot = rx * nx + ry * ny;
     return [ox + 2 * dot * nx - rx, oy + 2 * dot * ny - ry];
   };
@@ -332,9 +331,9 @@ function mirrorAcrossAxis(c8, ox, oy, dx, dy) {
       return { ...c8, cx: ncx, cy: ncy, xDirAngle: newAngle, sense: !c8.sense };
     }
     case "bezier":
-      return { ...c8, poles: c8.poles.map(([x7, y6]) => reflectPoint(x7, y6)) };
+      return { ...c8, poles: c8.poles.map(([x7, y7]) => reflectPoint(x7, y7)) };
     case "bspline":
-      return { ...c8, poles: c8.poles.map(([x7, y6]) => reflectPoint(x7, y6)) };
+      return { ...c8, poles: c8.poles.map(([x7, y7]) => reflectPoint(x7, y7)) };
     case "trimmed":
       return { ...c8, basis: mirrorAcrossAxis(c8.basis, ox, oy, dx, dy) };
   }
@@ -376,9 +375,9 @@ function refineParam(c8, px, py) {
   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;
+    const d11 = (ex2 - px) ** 2 + (ey2 - py) ** 2;
+    if (d11 < bestD) {
+      bestD = d11;
       bestT = t10;
     }
   }
@@ -450,18 +449,18 @@ function intersectLineCircle(cLine, line, cCirc, circ, tol) {
 function intersectCircleCircle(c1, circ1, c22, circ2, tol) {
   const dx = circ2.cx - circ1.cx;
   const dy = circ2.cy - circ1.cy;
-  const d10 = Math.sqrt(dx * dx + dy * dy);
-  if (d10 > circ1.radius + circ2.radius + tol) return [];
-  if (d10 < Math.abs(circ1.radius - circ2.radius) - tol) return [];
-  if (d10 < 1e-14) return [];
-  const a9 = (circ1.radius * circ1.radius - circ2.radius * circ2.radius + d10 * d10) / (2 * d10);
+  const d11 = Math.sqrt(dx * dx + dy * dy);
+  if (d11 > circ1.radius + circ2.radius + tol) return [];
+  if (d11 < Math.abs(circ1.radius - circ2.radius) - tol) return [];
+  if (d11 < 1e-14) return [];
+  const a9 = (circ1.radius * circ1.radius - circ2.radius * circ2.radius + d11 * d11) / (2 * d11);
   const h22 = circ1.radius * circ1.radius - a9 * a9;
   const h10 = Math.sqrt(Math.max(0, h22));
-  const mx = circ1.cx + a9 * dx / d10;
-  const my = circ1.cy + a9 * dy / d10;
+  const mx = circ1.cx + a9 * dx / d11;
+  const my = circ1.cy + a9 * dy / d11;
   const candidates = h10 < tol ? [[mx, my]] : [
-    [mx + h10 * dy / d10, my - h10 * dx / d10],
-    [mx - h10 * dy / d10, my + h10 * dx / d10]
+    [mx + h10 * dy / d11, my - h10 * dx / d11],
+    [mx - h10 * dy / d11, my + h10 * dx / d11]
   ];
   const results = [];
   for (const [px, py] of candidates) {
@@ -573,16 +572,16 @@ function addCurveToBBox(bbox, c8, _tol) {
   const dt = (bounds.last - bounds.first) / nSamples;
   for (let i9 = 0; i9 <= nSamples; i9++) {
     const t10 = bounds.first + i9 * dt;
-    const [x7, y6] = evaluateCurve2d(c8, t10);
+    const [x7, y7] = evaluateCurve2d(c8, t10);
     if (x7 < bbox.xMin) bbox.xMin = x7;
-    if (y6 < bbox.yMin) bbox.yMin = y6;
+    if (y7 < bbox.yMin) bbox.yMin = y7;
     if (x7 > bbox.xMax) bbox.xMax = x7;
-    if (y6 > bbox.yMax) bbox.yMax = y6;
+    if (y7 > bbox.yMax) bbox.yMax = y7;
   }
 }
 function evaluateBezier(poles, t10) {
   const n7 = poles.length;
-  const work = poles.map(([x7, y6]) => [x7, y6]);
+  const work = poles.map(([x7, y7]) => [x7, y7]);
   for (let r9 = 1; r9 < n7; r9++) {
     for (let i9 = 0; i9 < n7 - r9; i9++) {
       const wi = work[i9];
@@ -601,38 +600,38 @@ function evaluateBSpline2d(c8, t10) {
       fullKnots.push(c8.knots[i9]);
     }
   }
-  const p7 = c8.degree;
+  const p8 = c8.degree;
   const n7 = c8.poles.length;
   const k7 = fullKnots.length;
-  const tClamped = Math.max(fullKnots[p7], Math.min(fullKnots[k7 - p7 - 1], t10));
-  let span = p7;
-  for (let i9 = p7; i9 < k7 - p7 - 1; i9++) {
+  const tClamped = Math.max(fullKnots[p8], Math.min(fullKnots[k7 - p8 - 1], t10));
+  let span = p8;
+  for (let i9 = p8; i9 < k7 - p8 - 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 j7 = 0; j7 <= p7; j7++) {
-    const idx = Math.min(span - p7 + j7, n7 - 1);
+  if (tClamped >= fullKnots[k7 - p8 - 1]) span = k7 - p8 - 2;
+  const d11 = [];
+  for (let j7 = 0; j7 <= p8; j7++) {
+    const idx = Math.min(span - p8 + j7, n7 - 1);
     const pole = c8.poles[Math.max(0, idx)];
-    d10.push([pole[0], pole[1]]);
+    d11.push([pole[0], pole[1]]);
   }
-  for (let r9 = 1; r9 <= p7; r9++) {
-    for (let j7 = p7; j7 >= r9; j7--) {
-      const i9 = span - p7 + j7;
+  for (let r9 = 1; r9 <= p8; r9++) {
+    for (let j7 = p8; j7 >= r9; j7--) {
+      const i9 = span - p8 + j7;
       const left = fullKnots[i9] ?? 0;
-      const right = fullKnots[i9 + p7 - r9 + 1] ?? 1;
+      const right = fullKnots[i9 + p8 - r9 + 1] ?? 1;
       const denom = right - left;
       const alpha = denom > 1e-15 ? (tClamped - left) / denom : 0;
-      const dj = d10[j7];
-      const djPrev = d10[j7 - 1];
+      const dj = d11[j7];
+      const djPrev = d11[j7 - 1];
       dj[0] = (1 - alpha) * djPrev[0] + alpha * dj[0];
       dj[1] = (1 - alpha) * djPrev[1] + alpha * dj[1];
     }
   }
-  return d10[p7];
+  return d11[p8];
 }
 function isBrepkitHandle(shape2) {
   return shape2 !== null && shape2 !== void 0 && typeof shape2 === "object" && shape2.__brepkit;
@@ -724,7 +723,7 @@ function dist3(x1, y1, z1, x22, y22, z22) {
 function copyWasmBytes(bytes) {
   return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
 }
-function translationMatrix(x7, y6, z6) {
+function translationMatrix(x7, y7, z6) {
   return [
     1,
     0,
@@ -733,7 +732,7 @@ function translationMatrix(x7, y6, z6) {
     0,
     1,
     0,
-    y6,
+    y7,
     0,
     0,
     1,
@@ -833,20 +832,20 @@ function mirrorMatrix(origin, normal) {
   const nx = normal[0] / len;
   const ny = normal[1] / len;
   const nz = normal[2] / len;
-  const d10 = 2 * (ox * nx + oy * ny + oz * nz);
+  const d11 = 2 * (ox * nx + oy * ny + oz * nz);
   return [
     1 - 2 * nx * nx,
     -2 * nx * ny,
     -2 * nx * nz,
-    d10 * nx,
+    d11 * nx,
     -2 * ny * nx,
     1 - 2 * ny * ny,
     -2 * ny * nz,
-    d10 * ny,
+    d11 * ny,
     -2 * nz * nx,
     -2 * nz * ny,
     1 - 2 * nz * nz,
-    d10 * nz,
+    d11 * nz,
     0,
     0,
     0,
@@ -1034,8 +1033,8 @@ class BrepkitAdapter {
   hullFromPoints(points, _tolerance) {
     if (points.length < 4) throw new Error("brepkit: hull needs at least 4 points");
     const coords = [];
-    for (const p7 of points) {
-      coords.push(p7.x, p7.y, p7.z);
+    for (const p8 of points) {
+      coords.push(p8.x, p8.y, p8.z);
     }
     const id = this.bk.convexHull(coords);
     return solidHandle(id);
@@ -1043,10 +1042,10 @@ class BrepkitAdapter {
   buildSolidFromFaces(points, faces, _tolerance) {
     const positions = new Float64Array(points.length * 3);
     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 p8 = points[i9];
+      positions[i9 * 3] = p8.x;
+      positions[i9 * 3 + 1] = p8.y;
+      positions[i9 * 3 + 2] = p8.z;
     }
     const indices = new Uint32Array(faces.length * 3);
     for (let i9 = 0; i9 < faces.length; i9++) {
@@ -1061,8 +1060,8 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // Shape construction
   // ═══════════════════════════════════════════════════════════════════════
-  makeVertex(x7, y6, z6) {
-    const id = this.bk.makeVertex(x7, y6, z6);
+  makeVertex(x7, y7, z6) {
+    const id = this.bk.makeVertex(x7, y7, z6);
     return vertexHandle(id);
   }
   makeEdge(curve, start, end) {
@@ -1197,19 +1196,19 @@ class BrepkitAdapter {
       nz[2] * ux[0] - nz[0] * ux[2],
       nz[0] * ux[1] - nz[1] * ux[0]
     ];
-    const proj = (p7) => {
-      const dx = p7[0] - p1[0], dy = p7[1] - p1[1], dz = p7[2] - p1[2];
+    const proj = (p8) => {
+      const dx = p8[0] - p1[0], dy = p8[1] - p1[1], dz = p8[2] - p1[2];
       return [dx * ux[0] + dy * ux[1] + dz * ux[2], dx * uy[0] + dy * uy[1] + dz * uy[2]];
     };
     const [ax2, ay2] = proj(p1);
     const [bx2, by2] = proj(p22);
     const [cx2, cy2] = proj(p32);
-    const d10 = 2 * (ax2 * (by2 - cy2) + bx2 * (cy2 - ay2) + cx2 * (ay2 - by2));
-    if (Math.abs(d10) < 1e-12) {
+    const d11 = 2 * (ax2 * (by2 - cy2) + bx2 * (cy2 - ay2) + cx2 * (ay2 - by2));
+    if (Math.abs(d11) < 1e-12) {
       return this.makeLineEdge(p1, p32);
     }
-    const ccx = ((ax2 ** 2 + ay2 ** 2) * (by2 - cy2) + (bx2 ** 2 + by2 ** 2) * (cy2 - ay2) + (cx2 ** 2 + cy2 ** 2) * (ay2 - by2)) / d10;
-    const ccy = ((ax2 ** 2 + ay2 ** 2) * (cx2 - bx2) + (bx2 ** 2 + by2 ** 2) * (ax2 - cx2) + (cx2 ** 2 + cy2 ** 2) * (bx2 - ax2)) / d10;
+    const ccx = ((ax2 ** 2 + ay2 ** 2) * (by2 - cy2) + (bx2 ** 2 + by2 ** 2) * (cy2 - ay2) + (cx2 ** 2 + cy2 ** 2) * (ay2 - by2)) / d11;
+    const ccy = ((ax2 ** 2 + ay2 ** 2) * (cx2 - bx2) + (bx2 ** 2 + by2 ** 2) * (ax2 - cx2) + (cx2 ** 2 + cy2 ** 2) * (bx2 - ax2)) / d11;
     const center = [
       p1[0] + ccx * ux[0] + ccy * uy[0],
       p1[1] + ccx * ux[1] + ccy * uy[1],
@@ -1251,7 +1250,7 @@ class BrepkitAdapter {
     const n7 = points.length;
     const knots = [...Array(degree + 1).fill(0), ...Array(degree + 1).fill(1)];
     const weights = Array(n7).fill(1);
-    const flatCp = points.flatMap(([x7, y6, z6]) => [x7, y6, z6]);
+    const flatCp = points.flatMap(([x7, y7, z6]) => [x7, y7, z6]);
     const startPt = points[0];
     const endPt = points[n7 - 1];
     const id = this.bk.makeNurbsEdge(
@@ -1269,73 +1268,21 @@ class BrepkitAdapter {
     return edgeHandle(id);
   }
   makeTangentArc(startPoint, startTangent, endPoint) {
-    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 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]
-    ];
-    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);
+    if (!this.bk.makeTangentArc3d) {
+      throw new Error("makeTangentArc requires brepkit-wasm >= 1.1.0");
+    }
+    const id = this.bk.makeTangentArc3d(
+      startPoint[0],
+      startPoint[1],
+      startPoint[2],
+      startTangent[0],
+      startTangent[1],
+      startTangent[2],
+      endPoint[0],
+      endPoint[1],
+      endPoint[2]
+    );
+    return edgeHandle(id);
   }
   makeHelixWire(pitch, height, radius, center, _direction, leftHanded) {
     const turns = height / pitch;
@@ -1388,8 +1335,8 @@ class BrepkitAdapter {
   makeBoxFromCorners(p1, p22) {
     const w7 = Math.abs(p22[0] - p1[0]);
     const h10 = Math.abs(p22[1] - p1[1]);
-    const d10 = Math.abs(p22[2] - p1[2]);
-    const box = this.makeBox(w7, h10, d10);
+    const d11 = Math.abs(p22[2] - p1[2]);
+    const box = this.makeBox(w7, h10, d11);
     const minX = Math.min(p1[0], p22[0]);
     const minY = Math.min(p1[1], p22[1]);
     const minZ = Math.min(p1[2], p22[2]);
@@ -1550,7 +1497,7 @@ class BrepkitAdapter {
     return solidHandle(this.bk.filletVariable(solidId, JSON.stringify(spec)));
   }
   chamfer(shape2, edges, distance) {
-    const d10 = typeof distance === "number" ? distance : Array.isArray(distance) ? distance[0] : 1;
+    const d11 = typeof distance === "number" ? distance : Array.isArray(distance) ? distance[0] : 1;
     if (typeof distance !== "number") {
       warnOnce(
         "chamfer-asymmetric",
@@ -1558,7 +1505,7 @@ class BrepkitAdapter {
       );
     }
     const edgeIds = edges.map((e8) => unwrap(e8, "edge"));
-    const id = this.bk.chamfer(unwrapSolidOrThrow(shape2, "chamfer"), edgeIds, d10);
+    const id = this.bk.chamfer(unwrapSolidOrThrow(shape2, "chamfer"), edgeIds, d11);
     return solidHandle(id);
   }
   chamferDistAngle(shape2, edges, distance, angleDeg) {
@@ -1638,8 +1585,8 @@ class BrepkitAdapter {
     }
     throw new Error("brepkit: transform expects a 16-element matrix array");
   }
-  translate(shape2, x7, y6, z6) {
-    return this.applyMatrix(shape2, translationMatrix(x7, y6, z6));
+  translate(shape2, x7, y7, z6) {
+    return this.applyMatrix(shape2, translationMatrix(x7, y7, z6));
   }
   rotate(shape2, angle, axis, center) {
     return this.applyMatrix(shape2, rotationMatrix(angle, axis, center));
@@ -1916,9 +1863,9 @@ class BrepkitAdapter {
       }
     }
   }
-  translateWithHistory(shape2, x7, y6, z6, inputFaceHashes, hashUpperBound) {
+  translateWithHistory(shape2, x7, y7, z6, inputFaceHashes, hashUpperBound) {
     return this.buildEvolution(
-      this.translate(shape2, x7, y6, z6),
+      this.translate(shape2, x7, y7, z6),
       inputFaceHashes,
       hashUpperBound,
       true
@@ -1992,20 +1939,20 @@ class BrepkitAdapter {
             result.evolution.deleted,
             intermediateOutputs
           );
-          for (const [k7, v9] of result.evolution.modified) {
+          for (const [k7, v8] of result.evolution.modified) {
             if (!combinedModified.has(k7) && !intermediateOutputs.has(k7)) {
-              combinedModified.set(k7, [...v9]);
+              combinedModified.set(k7, [...v8]);
             }
           }
-          for (const [k7, v9] of result.evolution.generated) {
+          for (const [k7, v8] of result.evolution.generated) {
             if (!intermediateOutputs.has(k7)) {
               const existing = combinedGenerated.get(k7) ?? [];
-              combinedGenerated.set(k7, [...existing, ...v9]);
+              combinedGenerated.set(k7, [...existing, ...v8]);
             }
           }
-          for (const d10 of result.evolution.deleted) {
-            if (inputFaceHashSet.has(d10)) {
-              combinedDeleted.add(d10);
+          for (const d11 of result.evolution.deleted) {
+            if (inputFaceHashSet.has(d11)) {
+              combinedDeleted.add(d11);
             }
           }
         }
@@ -2210,7 +2157,7 @@ class BrepkitAdapter {
   }
   exportSTEPAssembly(parts, _options) {
     if (parts.length === 0) return "";
-    const shapes = parts.map((p7) => p7.shape);
+    const shapes = parts.map((p8) => p8.shape);
     return this.exportSTEP(shapes);
   }
   // ═══════════════════════════════════════════════════════════════════════
@@ -2288,11 +2235,11 @@ class BrepkitAdapter {
     const vertices = this.iterShapes(shape2, "vertex");
     if (vertices.length > 0) {
       let sx = 0, sy = 0, sz = 0;
-      for (const v9 of vertices) {
-        const p7 = this.vertexPosition(v9);
-        sx += p7[0];
-        sy += p7[1];
-        sz += p7[2];
+      for (const v8 of vertices) {
+        const p8 = this.vertexPosition(v8);
+        sx += p8[0];
+        sy += p8[1];
+        sz += p8[2];
       }
       return [sx / vertices.length, sy / vertices.length, sz / vertices.length];
     }
@@ -2331,13 +2278,13 @@ class BrepkitAdapter {
     let minX = first[0], minY = first[1], minZ = first[2];
     let maxX = first[0], maxY = first[1], maxZ = first[2];
     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];
-      if (p7[1] > maxY) maxY = p7[1];
-      if (p7[2] < minZ) minZ = p7[2];
-      if (p7[2] > maxZ) maxZ = p7[2];
+      const p8 = this.vertexPosition(vertices[i9]);
+      if (p8[0] < minX) minX = p8[0];
+      if (p8[0] > maxX) maxX = p8[0];
+      if (p8[1] < minY) minY = p8[1];
+      if (p8[1] > maxY) maxY = p8[1];
+      if (p8[2] < minZ) minZ = p8[2];
+      if (p8[2] > maxZ) maxZ = p8[2];
     }
     return { min: [minX, minY, minZ], max: [maxX, maxY, maxZ] };
   }
@@ -2439,11 +2386,11 @@ class BrepkitAdapter {
               [verts[0], verts[1], verts[2]],
               [verts[3], verts[4], verts[5]]
             ];
-            for (const [x7, y6, z6] of coords) {
-              const key = `${x7},${y6},${z6}`;
+            for (const [x7, y7, z6] of coords) {
+              const key = `${x7},${y7},${z6}`;
               if (!seen.has(key)) {
                 seen.add(key);
-                results.push(vertexHandle(this.bk.makeVertex(x7, y6, z6)));
+                results.push(vertexHandle(this.bk.makeVertex(x7, y7, z6)));
               }
             }
           }
@@ -2519,13 +2466,13 @@ class BrepkitAdapter {
     const id = this.bk.getFaceOuterWire(unwrap(face, "face"));
     return wireHandle(id);
   }
-  surfaceNormal(face, u8, v9) {
-    const n7 = this.bk.evaluateSurfaceNormal(unwrap(face, "face"), u8, v9);
+  surfaceNormal(face, u8, v8) {
+    const n7 = this.bk.evaluateSurfaceNormal(unwrap(face, "face"), u8, v8);
     return [n7[0], n7[1], n7[2]];
   }
-  pointOnSurface(face, u8, v9) {
-    const p7 = this.bk.evaluateSurface(unwrap(face, "face"), u8, v9);
-    return [p7[0], p7[1], p7[2]];
+  pointOnSurface(face, u8, v8) {
+    const p8 = this.bk.evaluateSurface(unwrap(face, "face"), u8, v8);
+    return [p8[0], p8[1], p8[2]];
   }
   uvFromPoint(face, point) {
     try {
@@ -2562,11 +2509,11 @@ class BrepkitAdapter {
       edgeId = edgeIds[edgeIds.length - 1];
       let cumulative = 0;
       for (const eid of edgeIds) {
-        const p7 = this.bk.getEdgeCurveParameters(eid);
-        const span = p7[1] - p7[0];
+        const p8 = this.bk.getEdgeCurveParameters(eid);
+        const span = p8[1] - p8[0];
         if (param <= cumulative + span || eid === edgeId) {
           edgeId = eid;
-          evalParam = Math.min(p7[0] + (param - cumulative), p7[1]);
+          evalParam = Math.min(p8[0] + (param - cumulative), p8[1]);
           break;
         }
         cumulative += span;
@@ -2587,8 +2534,8 @@ class BrepkitAdapter {
       if (edgeIds.length === 0) return [0, 0];
       let total = 0;
       for (const eid of edgeIds) {
-        const p7 = this.bk.getEdgeCurveParameters(eid);
-        total += p7[1] - p7[0];
+        const p8 = this.bk.getEdgeCurveParameters(eid);
+        total += p8[1] - p8[0];
       }
       return [0, total];
     }
@@ -2615,8 +2562,8 @@ class BrepkitAdapter {
       return [pt[0], pt[1], pt[2]];
     }
     const edgeId = unwrap(shape2, "edge");
-    const p7 = this.bk.evaluateEdgeCurve(edgeId, param);
-    return [p7[0], p7[1], p7[2]];
+    const p8 = this.bk.evaluateEdgeCurve(edgeId, param);
+    return [p8[0], p8[1], p8[2]];
   }
   curveIsClosed(shape2) {
     const h10 = shape2;
@@ -2804,8 +2751,8 @@ class BrepkitAdapter {
     const h1 = shape1;
     const h22 = shape2;
     if (h1.type === "solid" && h22.type === "solid") {
-      const d10 = this.bk.solidToSolidDistance(h1.id, h22.id);
-      return { value: d10, point1: [0, 0, 0], point2: [0, 0, 0] };
+      const d11 = this.bk.solidToSolidDistance(h1.id, h22.id);
+      return { value: d11, point1: [0, 0, 0], point2: [0, 0, 0] };
     }
     if (h1.type === "vertex" && h22.type === "solid") {
       const pos = this.bk.getVertexPosition(h1.id);
@@ -2836,8 +2783,8 @@ class BrepkitAdapter {
     }
     const getPos = (s6) => {
       if (s6.type === "vertex") {
-        const p7 = this.bk.getVertexPosition(s6.id);
-        return [p7[0], p7[1], p7[2]];
+        const p8 = this.bk.getVertexPosition(s6.id);
+        return [p8[0], p8[1], p8[2]];
       }
       if (s6.type === "solid") {
         const bb = this.bk.boundingBox(s6.id);
@@ -2855,7 +2802,7 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // Classification
   // ═══════════════════════════════════════════════════════════════════════
-  classifyPointOnFace(face, u8, v9, tolerance) {
+  classifyPointOnFace(face, u8, v8, tolerance) {
     if (tolerance !== void 0) {
       warnOnce(
         "classify-tolerance",
@@ -2864,7 +2811,7 @@ class BrepkitAdapter {
     }
     const faceId = unwrap(face, "face");
     const domain = this.bk.getSurfaceDomain(faceId);
-    if (u8 < domain[0] || u8 > domain[1] || v9 < domain[2] || v9 > domain[3]) {
+    if (u8 < domain[0] || u8 > domain[1] || v8 < domain[2] || v8 > domain[3]) {
       return "out";
     }
     return "in";
@@ -2884,7 +2831,7 @@ class BrepkitAdapter {
       return this.makeLineEdge(points[0], points[1]);
     }
     const degree = Math.min(3, points.length - 1);
-    const coords = points.flatMap(([x7, y6, z6]) => [x7, y6, z6]);
+    const coords = points.flatMap(([x7, y7, z6]) => [x7, y7, z6]);
     const id = this.bk.interpolatePoints(coords, degree);
     return edgeHandle(id);
   }
@@ -2892,7 +2839,7 @@ class BrepkitAdapter {
     const degree = options?.degMax ?? 3;
     const tol = options?.tolerance ?? 1e-6;
     const coords = [];
-    for (const p7 of points) coords.push(p7[0], p7[1], p7[2]);
+    for (const p8 of points) coords.push(p8[0], p8[1], p8[2]);
     const numCps = Math.max(degree + 1, Math.min(points.length, Math.ceil(points.length * 0.7)));
     const id = this.bk.approximateCurveLspia(coords, degree, numCps, tol, 100);
     return edgeHandle(id);
@@ -3088,8 +3035,8 @@ class BrepkitAdapter {
   }
   bsplineSurface(points, rows, cols) {
     const coords = [];
-    for (const [x7, y6, z6] of points) {
-      coords.push(x7, y6, z6);
+    for (const [x7, y7, z6] of points) {
+      coords.push(x7, y7, z6);
     }
     const degreeU = Math.min(3, rows - 1);
     const degreeV = Math.min(3, cols - 1);
@@ -3162,9 +3109,9 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // Measurement (advanced)
   // ═══════════════════════════════════════════════════════════════════════
-  surfaceCurvature(face, u8, v9) {
+  surfaceCurvature(face, u8, v8) {
     const fid = unwrap(face, "face");
-    const data = this.bk.measureCurvatureAtSurface(fid, u8, v9);
+    const data = this.bk.measureCurvatureAtSurface(fid, u8, v8);
     if (data.length < 8) {
       throw new Error(
         `brepkit: measureCurvatureAtSurface returned ${data.length} values, expected 8`
@@ -3305,15 +3252,15 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // 3D geometry primitive factories
   // ═══════════════════════════════════════════════════════════════════════
-  createPoint3d(x7, y6, z6) {
-    return { x: x7, y: y6, z: z6 };
+  createPoint3d(x7, y7, z6) {
+    return { x: x7, y: y7, z: z6 };
   }
-  createDirection3d(x7, y6, z6) {
-    const len = Math.sqrt(x7 * x7 + y6 * y6 + z6 * z6);
-    return { x: x7 / len, y: y6 / len, z: z6 / len };
+  createDirection3d(x7, y7, z6) {
+    const len = Math.sqrt(x7 * x7 + y7 * y7 + z6 * z6);
+    return { x: x7 / len, y: y7 / len, z: z6 / len };
   }
-  createVector3d(x7, y6, z6) {
-    return { x: x7, y: y6, z: z6 };
+  createVector3d(x7, y7, z6) {
+    return { x: x7, y: y7, z: z6 };
   }
   createAxis1(cx, cy, cz, dx, dy, dz) {
     return { origin: [cx, cy, cz], direction: [dx, dy, dz] };
@@ -3382,15 +3329,15 @@ class BrepkitAdapter {
   bb2d(h10) {
     return h10;
   }
-  createPoint2d(x7, y6) {
-    return { x: x7, y: y6 };
+  createPoint2d(x7, y7) {
+    return { x: x7, y: y7 };
   }
-  createDirection2d(x7, y6) {
-    const l10 = Math.sqrt(x7 * x7 + y6 * y6);
-    return { x: x7 / l10, y: y6 / l10 };
+  createDirection2d(x7, y7) {
+    const l10 = Math.sqrt(x7 * x7 + y7 * y7);
+    return { x: x7 / l10, y: y7 / l10 };
   }
-  createVector2d(x7, y6) {
-    return { x: x7, y: y6 };
+  createVector2d(x7, y7) {
+    return { x: x7, y: y7 };
   }
   createAxis2d(px, py, dx, dy) {
     return { px, py, dx, dy, delete: noop };
@@ -3408,12 +3355,12 @@ class BrepkitAdapter {
     return makeCircle2d(cx, cy, radius, sense);
   }
   makeArc2dThreePoints(x1, y1, xm, ym, x22, y22) {
-    const d10 = 2 * (x1 * (ym - y22) + xm * (y22 - y1) + x22 * (y1 - ym));
-    if (Math.abs(d10) < 1e-12) {
+    const d11 = 2 * (x1 * (ym - y22) + xm * (y22 - y1) + x22 * (y1 - ym));
+    if (Math.abs(d11) < 1e-12) {
       return makeLine2d(x1, y1, x22, y22);
     }
-    const cx = ((x1 * x1 + y1 * y1) * (ym - y22) + (xm * xm + ym * ym) * (y22 - y1) + (x22 * x22 + y22 * y22) * (y1 - ym)) / d10;
-    const cy = ((x1 * x1 + y1 * y1) * (x22 - xm) + (xm * xm + ym * ym) * (x1 - x22) + (x22 * x22 + y22 * y22) * (xm - x1)) / d10;
+    const cx = ((x1 * x1 + y1 * y1) * (ym - y22) + (xm * xm + ym * ym) * (y22 - y1) + (x22 * x22 + y22 * y22) * (y1 - ym)) / d11;
+    const cy = ((x1 * x1 + y1 * y1) * (x22 - xm) + (xm * xm + ym * ym) * (x1 - x22) + (x22 * x22 + y22 * y22) * (xm - x1)) / d11;
     const radius = Math.sqrt((x1 - cx) ** 2 + (y1 - cy) ** 2);
     const a12 = Math.atan2(y1 - cy, x1 - cx);
     const am = Math.atan2(ym - cy, xm - cx);
@@ -3663,23 +3610,23 @@ class BrepkitAdapter {
     );
     return { points: result.points, segments };
   }
-  projectPointOnCurve2d(curve, x7, y6) {
+  projectPointOnCurve2d(curve, x7, y7) {
     const c8 = this.c2d(curve);
     const bounds = curveBounds(c8);
     if (c8.__bk2d === "line") {
       const dx = x7 - c8.ox;
-      const dy = y6 - c8.oy;
+      const dy = y7 - 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) };
+      return { param: t10, distance: Math.sqrt((px - x7) ** 2 + (py - y7) ** 2) };
     }
     if (c8.__bk2d === "circle") {
-      const angle = Math.atan2(y6 - c8.cy, x7 - c8.cx);
+      const angle = Math.atan2(y7 - 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) };
+      return { param: t10, distance: Math.sqrt((px - x7) ** 2 + (py - y7) ** 2) };
     }
     if (!isFinite(bounds.first) || !isFinite(bounds.last)) return null;
     let bestT = bounds.first;
@@ -3689,16 +3636,16 @@ class BrepkitAdapter {
     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;
+      const d11 = (px - x7) ** 2 + (py - y7) ** 2;
+      if (d11 < bestDist) {
+        bestDist = d11;
         bestT = t10;
       }
     }
     for (let iter = 0; iter < 10; iter++) {
       const [px, py] = evaluateCurve2d(c8, bestT);
       const [tx, ty] = tangentCurve2d(c8, bestT);
-      const dot = (px - x7) * tx + (py - y6) * ty;
+      const dot = (px - x7) * tx + (py - y7) * ty;
       const denom = tx * tx + ty * ty;
       if (denom < 1e-20) break;
       const step = dot / denom;
@@ -3707,7 +3654,7 @@ class BrepkitAdapter {
       bestT = newT;
     }
     const [fx, fy] = evaluateCurve2d(c8, bestT);
-    return { param: bestT, distance: Math.sqrt((fx - x7) ** 2 + (fy - y6) ** 2) };
+    return { param: bestT, distance: Math.sqrt((fx - x7) ** 2 + (fy - y7) ** 2) };
   }
   distanceBetweenCurves2d(c1, c22, p1s, p1e, p2s, p2e) {
     const curve1 = this.c2d(c1);
@@ -3722,9 +3669,9 @@ class BrepkitAdapter {
       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) {
-          minDistSq = d10;
+        const d11 = (x22 - x1) ** 2 + (y22 - y1) ** 2;
+        if (d11 < minDistSq) {
+          minDistSq = d11;
           bestT1 = t12;
           bestT2 = t222;
         }
@@ -3844,9 +3791,9 @@ class BrepkitAdapter {
     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) {
+  isBBox2dOutPoint(bbox, x7, y7) {
     const b9 = this.bb2d(bbox);
-    return x7 < b9.xMin || x7 > b9.xMax || y6 < b9.yMin || y6 > b9.yMax;
+    return x7 < b9.xMin || x7 > b9.xMax || y7 < b9.yMin || y7 > b9.yMax;
   }
   // --- 2D type extraction ---
   getCurve2dCircleData(curve) {
@@ -3913,15 +3860,15 @@ class BrepkitAdapter {
   // --- 2D → 3D projection ---
   liftCurve2dToPlane(curve, origin, planeZ, planeX) {
     const c8 = this.c2d(curve);
-    const y6 = [
+    const y7 = [
       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 = (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]
+    const lift = (u8, v8) => [
+      origin[0] + u8 * planeX[0] + v8 * y7[0],
+      origin[1] + u8 * planeX[1] + v8 * y7[1],
+      origin[2] + u8 * planeX[2] + v8 * y7[2]
     ];
     if (c8.__bk2d === "line") {
       const p1 = lift(c8.ox, c8.oy);
@@ -3957,7 +3904,7 @@ class BrepkitAdapter {
       }
     }
     if (c8.__bk2d === "bezier" || c8.__bk2d === "bspline") {
-      const points3d = c8.poles.map(([u8, v9]) => lift(u8, v9));
+      const points3d = c8.poles.map(([u8, v8]) => lift(u8, v8));
       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]);
@@ -3969,8 +3916,8 @@ class BrepkitAdapter {
     const points = [];
     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));
+      const [u8, v8] = evaluateCurve2d(c8, t10);
+      points.push(lift(u8, v8));
     }
     return this.interpolatePoints(points);
   }
@@ -3985,9 +3932,9 @@ class BrepkitAdapter {
     const points = [];
     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]]);
+      const [u8, v8] = evaluateCurve2d(c8, t10);
+      const p8 = this.bk.evaluateSurface(fid, u8, v8);
+      points.push([p8[0], p8[1], p8[2]]);
     }
     return this.interpolatePoints(points);
   }
@@ -4072,8 +4019,8 @@ class BrepkitAdapter {
           const pts = [];
           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]);
+            const p8 = this.bk.evaluateEdgeCurve(edgeId, t10);
+            pts.push(p8[0], p8[1], p8[2]);
           }
           allCoords.push(...pts);
           curveLengths.push(N4 + 1);
@@ -4248,7 +4195,7 @@ class BrepkitAdapter {
         const vertCount = positions.length / 3;
         if (vertCount === 0) continue;
         const triStart = allTriangles.length;
-        for (const v9 of positions) allVertices.push(v9);
+        for (const v8 of positions) allVertices.push(v8);
         for (const n7 of normals) allNormals.push(n7);
         for (const idx of indices) {
           allTriangles.push(idx + vertexOffset);
@@ -4518,8 +4465,8 @@ class BrepkitAdapter {
     return this.bk.sketchNew();
   }
   /** Add a point to a constraint sketch. Returns the point index. */
-  sketchAddPoint(sketch, x7, y6, fixed) {
-    return this.bk.sketchAddPoint(sketch, x7, y6, fixed);
+  sketchAddPoint(sketch, x7, y7, fixed) {
+    return this.bk.sketchAddPoint(sketch, x7, y7, fixed);
   }
   /** Add a constraint to a sketch (JSON-encoded constraint descriptor). */
   sketchAddConstraint(sketch, constraintJson) {
@@ -4871,9 +4818,9 @@ function withNearestPostFilter(baseFinder, nearestPoint) {
     let bestIdx = 0;
     let bestDist = vecDistance(vertexPosition(candidates[0]), nearestPoint);
     for (let i9 = 1; i9 < candidates.length; i9++) {
-      const d10 = vecDistance(vertexPosition(candidates[i9]), nearestPoint);
-      if (d10 < bestDist) {
-        bestDist = d10;
+      const d11 = vecDistance(vertexPosition(candidates[i9]), nearestPoint);
+      if (d11 < bestDist) {
+        bestDist = d11;
         bestIdx = i9;
       }
     }
@@ -4916,14 +4863,14 @@ function buildVertexFinder(filters) {
 function vertexFinder() {
   return buildVertexFinder([]);
 }
-function toKernelVec(v9) {
-  return getKernel().createVector3d(v9[0], v9[1], v9[2]);
+function toKernelVec(v8) {
+  return getKernel().createVector3d(v8[0], v8[1], v8[2]);
 }
-function toKernelPnt(v9) {
-  return getKernel().createPoint3d(v9[0], v9[1], v9[2]);
+function toKernelPnt(v8) {
+  return getKernel().createPoint3d(v8[0], v8[1], v8[2]);
 }
-function toKernelDir(v9) {
-  return getKernel().createDirection3d(v9[0], v9[1], v9[2]);
+function toKernelDir(v8) {
+  return getKernel().createDirection3d(v8[0], v8[1], v8[2]);
 }
 function fromKernelVec(ocVec) {
   return [ocVec.X(), ocVec.Y(), ocVec.Z()];
@@ -4934,24 +4881,24 @@ function fromKernelPnt(ocPnt) {
 function fromKernelDir(ocDir) {
   return [ocDir.X(), ocDir.Y(), ocDir.Z()];
 }
-function withKernelVec(v9, fn) {
-  const ocVec = toKernelVec(v9);
+function withKernelVec(v8, fn) {
+  const ocVec = toKernelVec(v8);
   try {
     return fn(ocVec);
   } finally {
     ocVec.delete();
   }
 }
-function withKernelPnt(v9, fn) {
-  const ocPnt = toKernelPnt(v9);
+function withKernelPnt(v8, fn) {
+  const ocPnt = toKernelPnt(v8);
   try {
     return fn(ocPnt);
   } finally {
     ocPnt.delete();
   }
 }
-function withKernelDir(v9, fn) {
-  const ocDir = toKernelDir(v9);
+function withKernelDir(v8, fn) {
+  const ocDir = toKernelDir(v8);
   try {
     return fn(ocDir);
   } finally {
@@ -5099,12 +5046,12 @@ async function surfaceFromImage(blob, options = {}) {
   const imageData = ctx.getImageData(0, 0, w7, h10);
   const data = imageData.data;
   const rows = [];
-  for (let y6 = 0; y6 < h10; y6 += downsample) {
+  for (let y7 = 0; y7 < h10; y7 += downsample) {
     const row = [];
     for (let x7 = 0; x7 < w7; x7 += downsample) {
-      const idx = (y6 * w7 + x7) * 4;
+      const idx = (y7 * w7 + x7) * 4;
       const r9 = data[idx] ?? 0;
-      const g11 = data[idx + 1] ?? 0;
+      const g10 = data[idx + 1] ?? 0;
       const b9 = data[idx + 2] ?? 0;
       let value;
       switch (channel) {
@@ -5112,13 +5059,13 @@ async function surfaceFromImage(blob, options = {}) {
           value = r9 / 255;
           break;
         case "g":
-          value = g11 / 255;
+          value = g10 / 255;
           break;
         case "b":
           value = b9 / 255;
           break;
         default:
-          value = (REC601_R * r9 + REC601_G * g11 + REC601_B * b9) / 255;
+          value = (REC601_R * r9 + REC601_G * g10 + REC601_B * b9) / 255;
           break;
       }
       row.push(value);
@@ -5312,7 +5259,7 @@ function polyhedron(points, faces, options = {}) {
   }
   try {
     const kernel = getKernel();
-    const ptObjs = points.map(([x7, y6, z6]) => ({ x: x7, y: y6, z: z6 }));
+    const ptObjs = points.map(([x7, y7, z6]) => ({ x: x7, y: y7, z: z6 }));
     const resultOc = kernel.buildSolidFromFaces(ptObjs, triangles, tolerance);
     const cast = castShape(resultOc);
     if (!isSolid(cast)) {
@@ -5423,13 +5370,13 @@ function cross2(ax, ay, bx, by) {
 function dot2(ax, ay, bx, by) {
   return ax * bx + ay * by;
 }
-function len2(x7, y6) {
-  return Math.sqrt(x7 * x7 + y6 * y6);
+function len2(x7, y7) {
+  return Math.sqrt(x7 * x7 + y7 * y7);
 }
 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;
+  const p8 = poly[(i9 % poly.length + poly.length) % poly.length];
+  if (!p8) throw new Error(`Invalid polygon index ${i9} for length ${poly.length}`);
+  return p8;
 }
 function ensureCCW(poly) {
   let area = 0;
@@ -5474,11 +5421,11 @@ 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, i9) => {
+  const nodes = poly.map((p8, i9) => {
     const b9 = bisector(poly, i9);
     return {
-      x: p7.x,
-      y: p7.y,
+      x: p8.x,
+      y: p8.y,
       bx: b9.dx,
       by: b9.dy,
       origIdx: i9,
@@ -5564,8 +5511,8 @@ function computeEvents(lavNodes) {
     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" });
+      const y7 = node.y + t10 * node.by;
+      events.push({ time: t10, x: x7, y: y7, nodeA: node, nodeB: node.next, type: "edge" });
     }
     if (isLavNodeReflex(node)) {
       let cur = node.next.next;
@@ -5574,8 +5521,8 @@ function computeEvents(lavNodes) {
         const st = raySplitTime(node, cur, cur.next);
         if (st !== null && st > EPS) {
           const x7 = node.x + st * node.bx;
-          const y6 = node.y + st * node.by;
-          events.push({ time: st, x: x7, y: y6, nodeA: node, nodeB: cur, type: "split" });
+          const y7 = node.y + st * node.by;
+          events.push({ time: st, x: x7, y: y7, nodeA: node, nodeB: cur, type: "split" });
         }
         cur = cur.next;
         count++;
@@ -5814,9 +5761,9 @@ function earClipTriangulate(poly) {
     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, b9.x, b9.y, c8.x, c8.y)) return false;
+      const p8 = poly[vi];
+      if (!p8) continue;
+      if (pointInTriangle(p8.x, p8.y, a9.x, a9.y, b9.x, b9.y, c8.x, c8.y)) return false;
     }
     return true;
   };
@@ -5865,9 +5812,9 @@ function roof(w7, options) {
     const triFaces = [];
     for (const skFace of skeleton.faces) {
       const verts3d = skFace.vertices.map(
-        (v9, i9) => [
-          v9.x,
-          v9.y,
+        (v8, i9) => [
+          v8.x,
+          v8.y,
           (skFace.heights[i9] ?? 0) * tanAngle
         ]
       );
@@ -6147,9 +6094,9 @@ function parseEntities(text) {
   return entities;
 }
 function getNum(data, code, fallback = 0) {
-  const v9 = data.get(code);
-  if (v9 === void 0) return fallback;
-  const n7 = parseFloat(v9);
+  const v8 = data.get(code);
+  if (v8 === void 0) return fallback;
+  const n7 = parseFloat(v8);
   return isNaN(n7) ? fallback : n7;
 }
 function entityToEdge(entity) {
@@ -6226,15 +6173,15 @@ async function importOBJ(blob) {
     if (line.startsWith("v ")) {
       const parts = line.split(/\s+/);
       const x7 = parseFloat(parts[1] ?? "");
-      const y6 = parseFloat(parts[2] ?? "");
+      const y7 = parseFloat(parts[2] ?? "");
       const z6 = parseFloat(parts[3] ?? "");
-      if (isNaN(x7) || isNaN(y6) || isNaN(z6)) continue;
-      vertices.push([x7, y6, z6]);
+      if (isNaN(x7) || isNaN(y7) || isNaN(z6)) continue;
+      vertices.push([x7, y7, z6]);
     } else if (line.startsWith("f ")) {
       const parts = line.split(/\s+/).slice(1);
       const indices = [];
-      for (const p7 of parts) {
-        const idx = parseInt(p7.split("/")[0] ?? "", 10);
+      for (const p8 of parts) {
+        const idx = parseInt(p8.split("/")[0] ?? "", 10);
         if (!isNaN(idx)) indices.push(idx);
       }
       if (indices.length >= 3) faces.push(indices);
@@ -6384,7 +6331,7 @@ function parseModelXml(xml) {
 }
 function buildSolidFromMesh(mesh2) {
   const kernel = getKernel();
-  const points = mesh2.vertices.map(([x7, y6, z6]) => ({ x: x7, y: y6, z: z6 }));
+  const points = mesh2.vertices.map(([x7, y7, z6]) => ({ x: x7, y: y7, z: z6 }));
   const faces = mesh2.triangles;
   try {
     const solid = kernel.buildSolidFromFaces(points, faces, 1e-6);
@@ -6629,19 +6576,19 @@ function chamfer$1(shape2, edges, distance) {
       filteredEdges = [];
       const distMap = /* @__PURE__ */ new Map();
       for (const edge of selectedEdges) {
-        const d10 = distance(edge) ?? 0;
-        if (typeof d10 === "number" && d10 <= 0) continue;
-        if (Array.isArray(d10) && (d10[0] <= 0 || d10[1] <= 0)) continue;
+        const d11 = distance(edge) ?? 0;
+        if (typeof d11 === "number" && d11 <= 0) continue;
+        if (Array.isArray(d11) && (d11[0] <= 0 || d11[1] <= 0)) continue;
         filteredEdges.push(edge);
-        distMap.set(edge, d10);
+        distMap.set(edge, d11);
       }
       const hashToDist = /* @__PURE__ */ new Map();
-      for (const [edge, d10] of distMap) {
-        hashToDist.set(getKernel().hashCode(edge.wrapped, HASH_CODE_MAX), d10);
+      for (const [edge, d11] of distMap) {
+        hashToDist.set(getKernel().hashCode(edge.wrapped, HASH_CODE_MAX), d11);
       }
       kernelDistance = (ocEdge) => {
-        const d10 = hashToDist.get(ocEdge.HashCode(HASH_CODE_MAX));
-        return d10 ?? 1;
+        const d11 = hashToDist.get(ocEdge.HashCode(HASH_CODE_MAX));
+        return d11 ?? 1;
       };
     } else {
       filteredEdges = [...selectedEdges];
@@ -6748,8 +6695,8 @@ function offset$1(shape2, distance, tolerance = 1e-6) {
     return err(kernelError("OFFSET_FAILED", `Offset operation failed: ${raw}`, e8));
   }
 }
-function translate(shape2, v9) {
-  return translate$1(resolve(shape2), v9);
+function translate(shape2, v8) {
+  return translate$1(resolve(shape2), v8);
 }
 function rotate(shape2, angle, options) {
   const pivotPoint = options?.at;
@@ -7132,14 +7079,14 @@ function createWrappedBase(val) {
   const self = {
     val,
     __wrapped: true,
-    translate: (v9) => wrapAny(translate(val, v9)),
+    translate: (v8) => wrapAny(translate(val, v8)),
     rotate: (angle, opts) => wrapAny(rotate(val, angle, opts)),
     mirror: (opts) => wrapAny(mirror(val, opts)),
     scale: (factor, opts) => wrapAny(scale(val, factor, opts)),
     applyMatrix: (matrix) => wrapAny(applyMatrix(val, matrix)),
-    moveX: (d10) => wrapAny(translate(val, [d10, 0, 0])),
-    moveY: (d10) => wrapAny(translate(val, [0, d10, 0])),
-    moveZ: (d10) => wrapAny(translate(val, [0, 0, d10])),
+    moveX: (d11) => wrapAny(translate(val, [d11, 0, 0])),
+    moveY: (d11) => wrapAny(translate(val, [0, d11, 0])),
+    moveZ: (d11) => wrapAny(translate(val, [0, 0, d11])),
     rotateX: (a9) => wrapAny(rotate(val, a9, { axis: [1, 0, 0] })),
     rotateY: (a9) => wrapAny(rotate(val, a9, { axis: [0, 1, 0] })),
     rotateZ: (a9) => wrapAny(rotate(val, a9, { axis: [0, 0, 1] })),
@@ -7270,21 +7217,21 @@ function shape(s6) {
   throw new Error("shape() requires a Sketch or branded shape type");
 }
 export {
-  B3 as BaseSketcher2d,
-  B as Blueprint,
+  B4 as BaseSketcher2d,
+  B2 as Blueprint,
   a5 as BlueprintSketcher,
   c2 as Blueprints,
   e3 as BoundingBox2d,
-  BrepBugError,
+  B as BrepBugError,
   BrepErrorCode,
   BrepWrapperError,
   BrepkitAdapter,
-  C5 as CompoundBlueprint,
-  C6 as CompoundSketch,
-  C3 as Curve2D,
-  D2 as DEG2RAD,
+  C4 as CompoundBlueprint,
+  C5 as CompoundSketch,
+  C2 as Curve2D,
+  D as DEG2RAD,
   DisposalScope,
-  D4 as Drawing,
+  D3 as Drawing,
   a6 as DrawingPen,
   F3 as FaceSketcher,
   HASH_CODE_MAX,
@@ -7298,7 +7245,7 @@ export {
   addMate,
   b5 as addStep,
   b7 as adjacentFaces,
-  A2 as all,
+  E2 as all,
   a2 as andThen,
   applyGlue,
   applyMatrix,
@@ -7306,14 +7253,14 @@ export {
   M as as2D,
   N as as3D,
   l9 as asTopo,
-  d6 as autoHeal,
+  d7 as autoHeal,
   b4 as basicFaceExtrusion,
   e5 as bezier,
   blueprintToDXF,
   boss,
   f7 as box,
-  g8 as bsplineApprox,
-  bug,
+  g7 as bsplineApprox,
+  b2 as bug,
   X as cameraFromPlane,
   Y as cameraLookAt,
   c5 as cast,
@@ -7330,27 +7277,27 @@ export {
   clone,
   a as closedWire,
   c as collect,
-  d3 as collectShapes,
+  d4 as collectShapes,
   l6 as colorFaces,
   m6 as colorShape,
   f3 as complexExtrude,
   w4 as composeTransforms,
   k5 as compound,
   c3 as compoundSketchExtrude,
-  d5 as compoundSketchFace,
+  d6 as compoundSketchFace,
   e4 as compoundSketchLoft,
   f5 as compoundSketchRevolve,
-  b2 as computationError,
+  d2 as computationError,
   computeStraightSkeleton,
   l7 as cone,
   c7 as cornerFinder,
-  g5 as countNodes,
+  g4 as countNodes,
   h4 as createAssembly,
   i3 as createAssemblyNode,
   createBlueprint,
   Z as createCamera,
   C as createCompound,
-  d9 as createDistanceQuery,
+  d10 as createDistanceQuery,
   H as createEdge,
   I as createFace,
   b as createHandle,
@@ -7385,16 +7332,16 @@ export {
   curveStartPoint,
   curveTangentAt,
   cut,
-  d4 as cut2D,
+  d5 as cut2D,
   cutAll,
   j3 as cutBlueprints,
   m7 as cylinder,
   dequeueTask,
   describe,
-  g7 as deserializeDrawing,
+  g6 as deserializeDrawing,
   m4 as deserializeHistory,
   fromBREP$1 as deserializeShape,
-  d7 as downcast,
+  d8 as downcast,
   h6 as draw,
   i4 as drawCircle,
   j4 as drawEllipse,
@@ -7403,22 +7350,22 @@ export {
   m5 as drawPointsInterpolation,
   n4 as drawPolysides,
   o5 as drawProjection,
-  p3 as drawRectangle,
+  p4 as drawRectangle,
   q2 as drawRoundedRectangle,
   r3 as drawSingleCircle,
   s3 as drawSingleEllipse,
   t4 as drawText,
   u4 as drawingChamfer,
-  v5 as drawingCut,
+  v4 as drawingCut,
   w3 as drawingFillet,
   x4 as drawingFuse,
-  y3 as drawingIntersect,
+  y4 as drawingIntersect,
   z3 as drawingToSketchOnPlane,
   drill,
   edgeFinder,
   n6 as edgesOfFace,
   o7 as ellipse,
-  p5 as ellipseArc,
+  p6 as ellipseArc,
   q4 as ellipsoid,
   enqueueTask,
   err,
@@ -7428,7 +7375,7 @@ export {
   exportGltf,
   e6 as exportIGES,
   exportOBJ,
-  d8 as exportSTEP,
+  d9 as exportSTEP,
   f9 as exportSTL,
   exportThreeMF,
   extrude,
@@ -7444,7 +7391,7 @@ export {
   findCurveType,
   n5 as findFacesByTag,
   o3 as findNode,
-  p as findStep,
+  p2 as findStep,
   f2 as flatMap,
   r8 as flipFaceOrientation,
   k6 as flipOrientation,
@@ -7453,12 +7400,12 @@ export {
   fromKernelDir,
   fromKernelPnt,
   fromKernelVec,
-  C2 as fromNullable,
+  F as fromNullable,
   fuse,
   f4 as fuse2D,
   fuseAll,
   k3 as fuseBlueprints,
-  g4 as genericSweep,
+  g3 as genericSweep,
   getBounds,
   getBounds2D,
   l8 as getCurveType,
@@ -7471,11 +7418,11 @@ export {
   f6 as getHashCode,
   q as getHistoryShape,
   getKernel,
-  g9 as getOrientation,
+  g8 as getOrientation,
   getOrientation2D,
   r6 as getShapeColor,
   g as getShapeKind,
-  g6 as getSingleFace,
+  g5 as getSingleFace,
   getSurfaceType,
   t7 as getTagMetadata,
   getVertices,
@@ -7483,7 +7430,7 @@ export {
   guidedSweep,
   heal,
   u6 as healFace,
-  v7 as healSolid,
+  v6 as healSolid,
   w5 as healWire,
   x6 as helix,
   hull,
@@ -7512,7 +7459,7 @@ export {
   isDisposeRequest,
   isEdge,
   isEmpty,
-  y4 as isEqualShape,
+  y5 as isEqualShape,
   isErr,
   isErrorResponse,
   isFace,
@@ -7522,7 +7469,7 @@ export {
   l as isLive,
   m as isManifoldShell,
   isNumber,
-  g2 as isOk,
+  h2 as isOk,
   isOperationRequest,
   n as isOrientedFace,
   a0 as isProjectionPlane,
@@ -7538,29 +7485,29 @@ export {
   t as isVertex,
   isWire,
   z4 as iterEdges,
-  A5 as iterFaces,
+  A4 as iterFaces,
   iterTopo,
-  B5 as iterVertices,
-  C7 as iterWires,
+  B6 as iterVertices,
+  C6 as iterWires,
   kernelCall,
   kernelCallRaw,
   kernelCallScoped,
   kernelError,
-  y5 as line,
+  y6 as line,
   linearPattern,
   a1 as loadFont,
   loft,
-  A4 as makeBaseBox,
+  A3 as makeBaseBox,
   u2 as makePlane,
   a22 as makeProjectedEdges,
   v as manifoldShell,
   m2 as map,
-  h2 as mapErr,
-  j as match,
+  j as mapErr,
+  l2 as match,
   measureArea,
   e7 as measureCurvatureAt,
   f10 as measureCurvatureAtMid,
-  g10 as measureDistance,
+  g9 as measureDistance,
   h9 as measureLength,
   i7 as measureLinearProps,
   measureSurfaceProps,
@@ -7571,30 +7518,30 @@ export {
   minkowski,
   mirror,
   mirror2D,
-  B4 as mirrorDrawing,
+  B5 as mirrorDrawing,
   mirrorJoin,
   t3 as modifyStep,
-  l2 as moduleInitError,
+  n2 as moduleInitError,
   multiSectionSweep,
   normalAt,
   offset,
   z5 as offsetFace,
   o8 as offsetWire2D,
   ok,
-  D as or,
-  E2 as orElse,
+  G as or,
+  H2 as orElse,
   o4 as organiseBlueprints,
   w as orientedFace,
   outerWire,
   pendingCount,
-  F as pipeline,
-  p4 as pivotPlane,
+  I2 as pipeline,
+  p5 as pivotPlane,
   pocket,
-  p6 as pointOnSurface,
-  A6 as polygon,
+  p7 as pointOnSurface,
+  A5 as polygon,
   polyhedron,
   E4 as polysideInnerRadius,
-  p2 as polysidesBlueprint,
+  p3 as polysidesBlueprint,
   a32 as projectEdges,
   t9 as projectPointOnFace,
   queryError,
@@ -7602,13 +7549,13 @@ export {
   registerHandler,
   R as registerKernel,
   u3 as registerOperation,
-  v4 as registerShape,
+  v3 as registerShape,
   rejectAll,
   x3 as removeChild,
-  v8 as removeHolesFromFace,
-  y2 as replayFrom,
+  v7 as removeHolesFromFace,
+  y3 as replayFrom,
   z2 as replayHistory,
-  D5 as resize,
+  D4 as resize,
   resolve,
   resolve3D,
   r4 as resolveDirection,
@@ -7626,22 +7573,22 @@ export {
   G3 as scaleDrawing,
   section,
   sectionToFace,
-  A3 as serializeHistory,
+  A2 as serializeHistory,
   E5 as setShapeOrigin,
   u5 as setTagMetadata,
-  B6 as sewShells,
+  B7 as sewShells,
   shape,
   w6 as shapeType,
-  C8 as sharedEdges,
+  C7 as sharedEdges,
   shell,
   simplify,
   sketch2DOnFace,
   sketch2DOnPlane,
   H3 as sketchCircle,
   I3 as sketchEllipse,
-  J as sketchExtrude,
-  K as sketchFace,
-  L as sketchFaceOffset,
+  J2 as sketchExtrude,
+  K2 as sketchFace,
+  L2 as sketchFaceOffset,
   M2 as sketchHelix,
   N2 as sketchLoft,
   O3 as sketchParametricFunction,
@@ -7654,65 +7601,65 @@ export {
   V as sketchWires,
   s2 as sketcherStateError,
   slice,
-  D6 as solid,
+  D5 as solid,
   solveAssembly,
   E6 as sphere,
   split,
-  B2 as stepCount,
-  C4 as stepsFrom,
+  B3 as stepCount,
+  C3 as stepsFrom,
   stretch2D,
   F5 as subFace,
-  D3 as supportExtrude,
+  D2 as supportExtrude,
   supportsConstraintSketch,
   supportsProjection,
   surfaceFromGrid,
   surfaceFromImage,
   sweep,
-  v6 as tagFaces,
+  v5 as tagFaces,
   G4 as tangentArc,
-  G as tap,
-  H2 as tapErr,
+  J as tap,
+  K as tapErr,
   a52 as textBlueprints,
   a62 as textMetrics,
   thicken,
   H4 as threePointArc,
   toBREP,
   I4 as toBufferGeometryData,
-  J2 as toGroupedBufferGeometryData,
+  J3 as toGroupedBufferGeometryData,
   toKernelVec,
-  K2 as toLineGeometryData,
+  K3 as toLineGeometryData,
   toSVGPathD,
   t5 as toVec2,
   toVec3,
-  L2 as torus,
+  L3 as torus,
   transformCopy,
   translate,
   translate2D,
   W as translateDrawing,
   t6 as translatePlane,
   t2 as tryCatch,
-  n2 as tryCatchAsync,
+  p as tryCatchAsync,
   E3 as twistExtrude,
   typeCastError,
   F2 as undoLast,
   u as unsupportedError,
   unwrap$1 as unwrap,
-  v2 as unwrapErr,
-  w2 as unwrapOr,
-  x2 as unwrapOrElse,
+  w2 as unwrapErr,
+  x2 as unwrapOr,
+  y2 as unwrapOrElse,
   G2 as updateNode,
   u7 as uvBounds,
   h8 as uvCoordinates,
   x as validSolid,
   validationError,
-  v3 as vecAdd,
+  v2 as vecAdd,
   a3 as vecAngle,
   b3 as vecCross,
   vecDistance,
-  d2 as vecDot,
+  d3 as vecDot,
   e2 as vecEquals,
   vecIsZero,
-  g3 as vecLength,
+  g2 as vecLength,
   h3 as vecLengthSq,
   i2 as vecNegate,
   vecNormalize,
@@ -7737,5 +7684,5 @@ export {
   y as withScope,
   z as withScopeResult,
   A as withScopeResultAsync,
-  I2 as zipResults
+  L as zipResults
 };