brepjs 12.8.2 → 12.9.1

package/dist/brepjs.js

@@ -26,10 +26,10 @@ var __using = (stack, value, async) => {
   return value;
 };
 var __callDispose = (stack, error, hasError) => {
-  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 E6 = typeof SuppressedError === "function" ? SuppressedError : function(e8, s5, m11, _2) {
+    return _2 = Error(m11), _2.name = "SuppressedError", _2.error = e8, _2.suppressed = s5, _2;
   };
-  var fail = (e8) => error = hasError ? new E7(e8, error, "An error was suppressed during disposal") : (hasError = true, e8);
+  var fail = (e8) => error = hasError ? new E6(e8, error, "An error was suppressed during disposal") : (hasError = true, e8);
   var next = (it) => {
     while (it = stack.pop()) {
       try {
@@ -43,136 +43,138 @@ var __callDispose = (stack, error, hasError) => {
   };
   return next();
 };
-import { c as castShape, D as DisposalScope, B as getKernel, k as isFace, q as isShell, r as isSolid, p as isShape3D, F as createSolid, G as createWire, j as isEdge, u as isWire } from "./shapeTypes-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, 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, 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 { c as castShape, D as DisposalScope, g as getKernel, o as isFace, d as isShell, k as isSolid, j as isShape3D, h as createSolid, l as createWire, i as isEdge, b as isWire } from "./shapeTypes-CAEAyk8j.js";
+import { q, s, t, e, m, n, v, w, x, f, y, z, a, A, B, C, E, F, G, H, I, J, K, L, M, N } from "./shapeTypes-CAEAyk8j.js";
+import { o as ok, e as err, q as queryError, v as validationError, B as BrepErrorCode, k as kernelError, i as ioError, b as isErr, t as typeCastError, u as unwrap$1 } from "./result-DtuwWSUD.js";
+import { g, O, h, a as a2, c, j, d, l, m as m2, n as n2, f as f2, p, r, w as w2, x as x2, y as y2, z as z2, A as A2, C as C2, D, E as E2, F as F2, G as G2, H as H2, I as I2, J as J2, K as K2, L as L2, M as M2 } from "./result-DtuwWSUD.js";
+import { h as vecDistance, v as vecLength, c as vecNormalize, H as HASH_CODE_MAX, b as vecScale, i as vecIsZero } from "./vecOps-LTN--A58.js";
+import { D as D2, R, a as a3, j as j2, e as e2, d as d2, k, l as l2, m as m3, n as n3, o, g as g2, f as f3 } from "./vecOps-LTN--A58.js";
+import { a as a4, c as c2, m as m4, b, r as r2, t as t2 } from "./vectors-DTREgnVp.js";
+import { w as walkAssembly, s as sweep, c as circularPattern, l as linearPattern } from "./operations-DisJ5F8s.js";
+import { a as a5, b as b2, d as d3, e as e3, f as f4, g as g3, h as h2, i, j as j3, k as k2, m as m5, n as n4, o as o2, p as p2, q as q2, r as r3, t as t3, u, v as v2, x as x3, y as y3, z as z3, A as A3, B as B2, C as C3, D as D3, E as E3, F as F3, G as G3 } from "./operations-DisJ5F8s.js";
+import { B as B3, d as d4, C as C4 } from "./Blueprint-1HGbugaC.js";
+import { B as B4, a as a6, c as c3, C as C5, F as F4, S, d as d5, j as j4, f as f5, k as k3, h as h3, l as l3, o as o3, p as p3, r as r4 } from "./boolean2D-CR4efa35.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-X0juxnwj.js";
-import { g as g5 } from "./helpers-X0juxnwj.js";
+import { k as createTypedFinder, l as edgeFinder, m as faceFinder } from "./helpers-sJjnIXDA.js";
+import { g as g4, w as w3 } from "./helpers-sJjnIXDA.js";
 import { blueprintToDXF, exportDXF, exportGlb, exportGltf, exportOBJ, exportThreeMF, importIGES, importSTEP, importSTL, importSVG, importSVGPathD } from "./io.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 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-DmwhTCCd.js";
-import { c as c7 } from "./cornerFinder-Ckz-mPHE.js";
+import { C as C6, D as D4, a as a7, S as S2, b as b3, X, Y, c as c4, d as d6, e as e4, f as f6, Z, g as g5, h as h4, i as i2, j as j5, k as k4, l as l4, m as m6, n as n5, o as o4, p as p4, q as q3, r as r5, s as s2, t as t4, u as u2, v as v3, w as w4, x as x4, y as y4, z as z4, _, $, a0, a1, A as A4, a2 as a22, B as B5, E as E4, a3 as a32, F as F5, G as G4, H as H3, I as I3, J as J3, K as K3, L as L3, M as M3, N as N2, O as O2, P, Q, R as R2, T, U, a4 as a42, V, a5 as a52, a6 as a62, W } from "./drawFns-B0na6sbo.js";
+import { t as toVec3 } from "./types-CcKqsmd0.js";
+import { r as r6, a as a8 } from "./types-CcKqsmd0.js";
+import { c as clone$1, a as isEmpty$1, s as simplify$1, t as toBREP$1 } from "./shapeFns-BJbua5kT.js";
+import { g as g6, b as b4, i as i3 } from "./shapeFns-BJbua5kT.js";
+import { c as collectInputFaceHashes, p as propagateAllMetadata, a as cut$1, f as fuse$1, i as intersect$1, s as section$1, b as sectionToFace$1, d as slice$1, e as split$1, g as fuseAll, h as cutAll } from "./booleanFns-Br2KdGJq.js";
+import { j as j6, k as k5, l as l5, m as m7, n as n6, o as o5, q as q4, r as r7, t as t5 } from "./booleanFns-Br2KdGJq.js";
+import { a as applyMatrix$1, c as chamferDistAngle, h as heal$1, i as isValid$1, m as mirror$1, r as rotate$1, s as scale$1, t as transformCopy$1, b as translate$1 } from "./topology-D6LeuhI_.js";
+import { d as d7, e as e5, f as f7, g as g7, j as j7, k as k6, l as l6, n as n7, o as o6, p as p5, q as q5, u as u3, v as v4, w as w5, x as x5, y as y5, z as z5, A as A5, B as B6, C as C7, D as D5, E as E5, F as F6, G as G5, H as H4, I as I4, J as J4, K as K4, L as L4, M as M4, N as N3, O as O3, P as P2, Q as Q2, R as R3, S as S3, T as T2, U as U2, V as V2, W as W2, X as X2, Y as Y2 } from "./topology-D6LeuhI_.js";
+import { d as curveStartPoint, a as curveIsClosed, e as curveTangentAt, f as curvePointAt, h as curveEndPoint, c as curveLength } from "./curveFns-1u0oZ0u0.js";
+import { i as i4, j as j8, k as k7, l as l7, g as g8, b as b5, m as m8, o as o7 } from "./curveFns-1u0oZ0u0.js";
+import { e as faceCenter, n as normalAt, j as fromBREP$1, k as innerWires, o as outerWire, g as getSurfaceType } from "./faceFns-DGMp47Os.js";
+import { l as l8, c as c5, m as m9, d as d8, f as f8, q as q6, r as r8, s as s3, i as i5, p as p6, t as t6, v as v5, w as w6, u as u4, h as h5 } from "./faceFns-DGMp47Os.js";
+import { m as mesh$1, a as meshEdges$1 } from "./meshFns-CtUl9fGY.js";
+import { c as c6, b as b6, e as e6, d as d9, f as f9 } from "./meshFns-CtUl9fGY.js";
+import { v as vertexPosition, b as getFaces, e as getVertices, d as getEdges, f as getBounds, h as describe$1, c as getWires } from "./topologyQueryFns-De439iBP.js";
+import { i as i6, j as j9, k as k8, l as l9, m as m10 } from "./topologyQueryFns-De439iBP.js";
+import { m as measureArea, a as measureSurfaceProps, b as measureVolumeProps, c as measureVolume } from "./measurement-C7o5jE6G.js";
+import { d as d10, e as e7, f as f10, g as g9, h as h6, i as i7 } from "./measurement-C7o5jE6G.js";
+import { c as makeFace } from "./surfaceBuilders-Dj6AjhOv.js";
+import { i as i8 } from "./surfaceBuilders-Dj6AjhOv.js";
+import { c as makeCylinder } from "./solidBuilders-BS-1220W.js";
+import { closedWire, isClosedWire, isManifoldShell, isOrientedFace, isValidSolid, manifoldShell, orientedFace, validSolid } from "./core.js";
+import { cornerFinder } from "./query.js";
 import { createOperationRegistry, createTaskQueue, createWorkerClient, createWorkerHandler, dequeueTask, enqueueTask, isDisposeRequest, isErrorResponse, isInitRequest, isOperationRequest, isQueueEmpty, isSuccessResponse, pendingCount, registerHandler, rejectAll } from "./worker.js";
+import { g as g10, s as s4 } from "./originTrackingFns-NJ1dWoiF.js";
 function supportsProjection(kernel) {
   return "projectShape" in kernel;
 }
 function supportsConstraintSketch(kernel) {
   return "sketchNew" in kernel && "sketchDof" in kernel;
 }
-function evaluateCurve2d(c8, t10) {
-  switch (c8.__bk2d) {
+function evaluateCurve2d(c7, t7) {
+  switch (c7.__bk2d) {
     case "line":
-      return [c8.ox + c8.dx * t10, c8.oy + c8.dy * t10];
+      return [c7.ox + c7.dx * t7, c7.oy + c7.dy * t7];
     case "circle": {
-      const angle = c8.sense ? t10 : -t10;
-      return [c8.cx + c8.radius * Math.cos(angle), c8.cy + c8.radius * Math.sin(angle)];
+      const angle = c7.sense ? t7 : -t7;
+      return [c7.cx + c7.radius * Math.cos(angle), c7.cy + c7.radius * Math.sin(angle)];
     }
     case "ellipse": {
-      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 y7 = c8.minorRadius * Math.sin(angle);
-      return [c8.cx + x7 * cos - y7 * sin, c8.cy + x7 * sin + y7 * cos];
+      const angle = c7.sense ? t7 : -t7;
+      const cos = Math.cos(c7.xDirAngle);
+      const sin = Math.sin(c7.xDirAngle);
+      const x6 = c7.majorRadius * Math.cos(angle);
+      const y6 = c7.minorRadius * Math.sin(angle);
+      return [c7.cx + x6 * cos - y6 * sin, c7.cy + x6 * sin + y6 * cos];
     }
     case "bezier":
-      return evaluateBezier(c8.poles, t10);
+      return evaluateBezier(c7.poles, t7);
     case "bspline":
-      return evaluateBSpline2d(c8, t10);
+      return evaluateBSpline2d(c7, t7);
     case "trimmed": {
-      const mapped = c8.tStart + t10 * (c8.tEnd - c8.tStart);
-      return evaluateCurve2d(c8.basis, mapped);
+      const mapped = c7.tStart + t7 * (c7.tEnd - c7.tStart);
+      return evaluateCurve2d(c7.basis, mapped);
     }
   }
 }
-function tangentCurve2d(c8, t10) {
-  switch (c8.__bk2d) {
+function tangentCurve2d(c7, t7) {
+  switch (c7.__bk2d) {
     case "line":
-      return [c8.dx, c8.dy];
+      return [c7.dx, c7.dy];
     case "circle": {
-      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];
+      const angle = c7.sense ? t7 : -t7;
+      const sign = c7.sense ? 1 : -1;
+      return [-c7.radius * Math.sin(angle) * sign, c7.radius * Math.cos(angle) * sign];
     }
     case "ellipse": {
-      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;
+      const angle = c7.sense ? t7 : -t7;
+      const sign = c7.sense ? 1 : -1;
+      const cos = Math.cos(c7.xDirAngle);
+      const sin = Math.sin(c7.xDirAngle);
+      const dx = -c7.majorRadius * Math.sin(angle) * sign;
+      const dy = c7.minorRadius * Math.cos(angle) * sign;
       return [dx * cos - dy * sin, dx * sin + dy * cos];
     }
     case "bezier": {
-      const 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);
+      const h7 = 1e-8;
+      const p0 = evaluateBezier(c7.poles, Math.max(0, t7 - h7));
+      const p1 = evaluateBezier(c7.poles, Math.min(1, t7 + h7));
+      const dt = Math.min(1, t7 + h7) - Math.max(0, t7 - h7);
       return [(p1[0] - p0[0]) / dt, (p1[1] - p0[1]) / dt];
     }
     case "bspline": {
-      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);
+      const h7 = 1e-8;
+      const kFirst = c7.knots[0];
+      const kLast = c7.knots[c7.knots.length - 1];
+      const p0 = evaluateBSpline2d(c7, Math.max(kFirst, t7 - h7));
+      const p1 = evaluateBSpline2d(c7, Math.min(kLast, t7 + h7));
+      const dt = Math.min(kLast, t7 + h7) - Math.max(kFirst, t7 - h7);
       return [(p1[0] - p0[0]) / dt, (p1[1] - p0[1]) / dt];
     }
     case "trimmed": {
-      const mapped = c8.tStart + t10 * (c8.tEnd - c8.tStart);
-      const tan = tangentCurve2d(c8.basis, mapped);
-      const scale2 = c8.tEnd - c8.tStart;
+      const mapped = c7.tStart + t7 * (c7.tEnd - c7.tStart);
+      const tan = tangentCurve2d(c7.basis, mapped);
+      const scale2 = c7.tEnd - c7.tStart;
       return [tan[0] * scale2, tan[1] * scale2];
     }
   }
 }
-function curveBounds(c8) {
-  switch (c8.__bk2d) {
+function curveBounds(c7) {
+  switch (c7.__bk2d) {
     case "line":
-      return { first: 0, last: c8.len };
+      return { first: 0, last: c7.len };
     case "circle":
     case "ellipse":
       return { first: 0, last: 2 * Math.PI };
     case "bezier":
       return { first: 0, last: 1 };
     case "bspline":
-      return { first: c8.knots[0], last: c8.knots[c8.knots.length - 1] };
+      return { first: c7.knots[0], last: c7.knots[c7.knots.length - 1] };
     case "trimmed":
       return { first: 0, last: 1 };
   }
 }
-function curveTypeName(c8) {
-  switch (c8.__bk2d) {
+function curveTypeName(c7) {
+  switch (c7.__bk2d) {
     case "line":
       return "LINE";
     case "circle":
@@ -184,7 +186,7 @@ function curveTypeName(c8) {
     case "bspline":
       return "BSPLINE_CURVE";
     case "trimmed":
-      return "TRIMMED_" + curveTypeName(c8.basis);
+      return "TRIMMED_" + curveTypeName(c7.basis);
   }
 }
 function makeLine2d(x1, y1, x22, y22) {
@@ -217,125 +219,125 @@ function makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX = 1, xDirY = 0, s
 function makeBezier2d(poles) {
   return { __bk2d: "bezier", poles: [...poles] };
 }
-function translateCurve2d(c8, dx, dy) {
-  switch (c8.__bk2d) {
+function translateCurve2d(c7, dx, dy) {
+  switch (c7.__bk2d) {
     case "line":
-      return { ...c8, ox: c8.ox + dx, oy: c8.oy + dy };
+      return { ...c7, ox: c7.ox + dx, oy: c7.oy + dy };
     case "circle":
-      return { ...c8, cx: c8.cx + dx, cy: c8.cy + dy };
+      return { ...c7, cx: c7.cx + dx, cy: c7.cy + dy };
     case "ellipse":
-      return { ...c8, cx: c8.cx + dx, cy: c8.cy + dy };
+      return { ...c7, cx: c7.cx + dx, cy: c7.cy + dy };
     case "bezier":
-      return { ...c8, poles: c8.poles.map(([x7, y7]) => [x7 + dx, y7 + dy]) };
+      return { ...c7, poles: c7.poles.map(([x6, y6]) => [x6 + dx, y6 + dy]) };
     case "bspline":
-      return { ...c8, poles: c8.poles.map(([x7, y7]) => [x7 + dx, y7 + dy]) };
+      return { ...c7, poles: c7.poles.map(([x6, y6]) => [x6 + dx, y6 + dy]) };
     case "trimmed":
-      return { ...c8, basis: translateCurve2d(c8.basis, dx, dy) };
+      return { ...c7, basis: translateCurve2d(c7.basis, dx, dy) };
   }
 }
-function rotateCurve2d(c8, angle, cx, cy) {
+function rotateCurve2d(c7, angle, cx, cy) {
   const cos = Math.cos(angle);
   const sin = Math.sin(angle);
-  const rotatePoint = (x7, y7) => {
-    const rx = x7 - cx;
-    const ry = y7 - cy;
+  const rotatePoint = (x6, y6) => {
+    const rx = x6 - cx;
+    const ry = y6 - cy;
     return [cx + rx * cos - ry * sin, cy + rx * sin + ry * cos];
   };
-  switch (c8.__bk2d) {
+  switch (c7.__bk2d) {
     case "line": {
-      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 };
+      const [ox, oy] = rotatePoint(c7.ox, c7.oy);
+      const ndx = c7.dx * cos - c7.dy * sin;
+      const ndy = c7.dx * sin + c7.dy * cos;
+      return { ...c7, ox, oy, dx: ndx, dy: ndy };
     }
     case "circle": {
-      const [ncx, ncy] = rotatePoint(c8.cx, c8.cy);
-      return { ...c8, cx: ncx, cy: ncy };
+      const [ncx, ncy] = rotatePoint(c7.cx, c7.cy);
+      return { ...c7, cx: ncx, cy: ncy };
     }
     case "ellipse": {
-      const [ncx, ncy] = rotatePoint(c8.cx, c8.cy);
-      return { ...c8, cx: ncx, cy: ncy, xDirAngle: c8.xDirAngle + angle };
+      const [ncx, ncy] = rotatePoint(c7.cx, c7.cy);
+      return { ...c7, cx: ncx, cy: ncy, xDirAngle: c7.xDirAngle + angle };
     }
     case "bezier":
-      return { ...c8, poles: c8.poles.map(([x7, y7]) => rotatePoint(x7, y7)) };
+      return { ...c7, poles: c7.poles.map(([x6, y6]) => rotatePoint(x6, y6)) };
     case "bspline":
-      return { ...c8, poles: c8.poles.map(([x7, y7]) => rotatePoint(x7, y7)) };
+      return { ...c7, poles: c7.poles.map(([x6, y6]) => rotatePoint(x6, y6)) };
     case "trimmed":
-      return { ...c8, basis: rotateCurve2d(c8.basis, angle, cx, cy) };
+      return { ...c7, basis: rotateCurve2d(c7.basis, angle, cx, cy) };
   }
 }
-function scaleCurve2d(c8, factor, cx, cy) {
-  const scalePoint = (x7, y7) => [
-    cx + (x7 - cx) * factor,
-    cy + (y7 - cy) * factor
+function scaleCurve2d(c7, factor, cx, cy) {
+  const scalePoint = (x6, y6) => [
+    cx + (x6 - cx) * factor,
+    cy + (y6 - cy) * factor
   ];
-  switch (c8.__bk2d) {
+  switch (c7.__bk2d) {
     case "line": {
-      const [ox, oy] = scalePoint(c8.ox, c8.oy);
-      return { ...c8, ox, oy };
+      const [ox, oy] = scalePoint(c7.ox, c7.oy);
+      return { ...c7, ox, oy };
     }
     case "circle": {
-      const [ncx, ncy] = scalePoint(c8.cx, c8.cy);
-      return { ...c8, cx: ncx, cy: ncy, radius: c8.radius * Math.abs(factor) };
+      const [ncx, ncy] = scalePoint(c7.cx, c7.cy);
+      return { ...c7, cx: ncx, cy: ncy, radius: c7.radius * Math.abs(factor) };
     }
     case "ellipse": {
-      const [ncx, ncy] = scalePoint(c8.cx, c8.cy);
+      const [ncx, ncy] = scalePoint(c7.cx, c7.cy);
       return {
-        ...c8,
+        ...c7,
         cx: ncx,
         cy: ncy,
-        majorRadius: c8.majorRadius * Math.abs(factor),
-        minorRadius: c8.minorRadius * Math.abs(factor)
+        majorRadius: c7.majorRadius * Math.abs(factor),
+        minorRadius: c7.minorRadius * Math.abs(factor)
       };
     }
     case "bezier":
-      return { ...c8, poles: c8.poles.map(([x7, y7]) => scalePoint(x7, y7)) };
+      return { ...c7, poles: c7.poles.map(([x6, y6]) => scalePoint(x6, y6)) };
     case "bspline":
-      return { ...c8, poles: c8.poles.map(([x7, y7]) => scalePoint(x7, y7)) };
+      return { ...c7, poles: c7.poles.map(([x6, y6]) => scalePoint(x6, y6)) };
     case "trimmed":
-      return { ...c8, basis: scaleCurve2d(c8.basis, factor, cx, cy) };
+      return { ...c7, basis: scaleCurve2d(c7.basis, factor, cx, cy) };
   }
 }
-function mirrorAtPoint(c8, cx, cy) {
-  return scaleCurve2d(c8, -1, cx, cy);
+function mirrorAtPoint(c7, cx, cy) {
+  return scaleCurve2d(c7, -1, cx, cy);
 }
-function mirrorAcrossAxis(c8, ox, oy, dx, dy) {
+function mirrorAcrossAxis(c7, ox, oy, dx, dy) {
   const len = Math.sqrt(dx * dx + dy * dy);
   const nx = dx / len;
   const ny = dy / len;
-  const reflectPoint = (x7, y7) => {
-    const rx = x7 - ox;
-    const ry = y7 - oy;
+  const reflectPoint = (x6, y6) => {
+    const rx = x6 - ox;
+    const ry = y6 - oy;
     const dot = rx * nx + ry * ny;
     return [ox + 2 * dot * nx - rx, oy + 2 * dot * ny - ry];
   };
-  switch (c8.__bk2d) {
+  switch (c7.__bk2d) {
     case "line": {
-      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 };
+      const [nox, noy] = reflectPoint(c7.ox, c7.oy);
+      const ndx = 2 * (c7.dx * nx + c7.dy * ny) * nx - c7.dx;
+      const ndy = 2 * (c7.dx * nx + c7.dy * ny) * ny - c7.dy;
+      return { ...c7, ox: nox, oy: noy, dx: ndx, dy: ndy };
     }
     case "circle": {
-      const [ncx, ncy] = reflectPoint(c8.cx, c8.cy);
-      return { ...c8, cx: ncx, cy: ncy, sense: !c8.sense };
+      const [ncx, ncy] = reflectPoint(c7.cx, c7.cy);
+      return { ...c7, cx: ncx, cy: ncy, sense: !c7.sense };
     }
     case "ellipse": {
-      const [ncx, ncy] = reflectPoint(c8.cx, c8.cy);
+      const [ncx, ncy] = reflectPoint(c7.cx, c7.cy);
       const cos2 = nx * nx - ny * ny;
       const sin2 = 2 * nx * ny;
       const newAngle = Math.atan2(
-        sin2 * Math.cos(c8.xDirAngle) - cos2 * Math.sin(c8.xDirAngle),
-        cos2 * Math.cos(c8.xDirAngle) + sin2 * Math.sin(c8.xDirAngle)
+        sin2 * Math.cos(c7.xDirAngle) - cos2 * Math.sin(c7.xDirAngle),
+        cos2 * Math.cos(c7.xDirAngle) + sin2 * Math.sin(c7.xDirAngle)
       );
-      return { ...c8, cx: ncx, cy: ncy, xDirAngle: newAngle, sense: !c8.sense };
+      return { ...c7, cx: ncx, cy: ncy, xDirAngle: newAngle, sense: !c7.sense };
     }
     case "bezier":
-      return { ...c8, poles: c8.poles.map(([x7, y7]) => reflectPoint(x7, y7)) };
+      return { ...c7, poles: c7.poles.map(([x6, y6]) => reflectPoint(x6, y6)) };
     case "bspline":
-      return { ...c8, poles: c8.poles.map(([x7, y7]) => reflectPoint(x7, y7)) };
+      return { ...c7, poles: c7.poles.map(([x6, y6]) => reflectPoint(x6, y6)) };
     case "trimmed":
-      return { ...c8, basis: mirrorAcrossAxis(c8.basis, ox, oy, dx, dy) };
+      return { ...c7, basis: mirrorAcrossAxis(c7.basis, ox, oy, dx, dy) };
   }
 }
 function intersectCurves2dFn(c1, c22, tolerance) {
@@ -356,34 +358,34 @@ function intersectCurves2dFn(c1, c22, tolerance) {
   const isSelf = c1 === c22;
   return numericalIntersect(c1, c22, tolerance, isSelf);
 }
-function unwrapCurve(c8) {
-  let cur = c8;
+function unwrapCurve(c7) {
+  let cur = c7;
   while (cur.__bk2d === "trimmed") cur = cur.basis;
   return cur;
 }
-function inDomain(c8, t10, tol) {
-  const b9 = curveBounds(c8);
-  return t10 >= b9.first - tol && t10 <= b9.last + tol;
+function inDomain(c7, t7, tol) {
+  const b7 = curveBounds(c7);
+  return t7 >= b7.first - tol && t7 <= b7.last + tol;
 }
-function refineParam(c8, px, py) {
-  const bounds = curveBounds(c8);
+function refineParam(c7, px, py) {
+  const bounds = curveBounds(c7);
   if (!isFinite(bounds.first) || !isFinite(bounds.last)) return null;
   const N4 = 80;
   const dt = (bounds.last - bounds.first) / N4;
   let bestT = bounds.first;
   let bestD = Infinity;
   for (let i9 = 0; i9 <= N4; i9++) {
-    const t10 = bounds.first + i9 * dt;
-    const [ex2, ey2] = evaluateCurve2d(c8, t10);
+    const t7 = bounds.first + i9 * dt;
+    const [ex2, ey2] = evaluateCurve2d(c7, t7);
     const d11 = (ex2 - px) ** 2 + (ey2 - py) ** 2;
     if (d11 < bestD) {
       bestD = d11;
-      bestT = t10;
+      bestT = t7;
     }
   }
-  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 [sx, sy] = evaluateCurve2d(c7, bounds.first);
+  const [ex, ey] = evaluateCurve2d(c7, bounds.last);
+  const [mx, my] = evaluateCurve2d(c7, (bounds.first + bounds.last) / 2);
   const geomExtent = Math.max(
     Math.sqrt((ex - sx) ** 2 + (ey - sy) ** 2),
     Math.sqrt((mx - sx) ** 2 + (my - sy) ** 2),
@@ -426,14 +428,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 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;
+  const b7 = 2 * (fx * line.dx + fy * line.dy);
+  const c7 = fx * fx + fy * fy - circ.radius * circ.radius;
+  const disc = b7 * b7 - 4 * a9 * c7;
   if (disc < -tol) return [];
   const results = [];
   const sqrtDisc = Math.sqrt(Math.max(0, disc));
-  const t1 = (-b9 - sqrtDisc) / (2 * a9);
-  const t22 = (-b9 + sqrtDisc) / (2 * a9);
+  const t1 = (-b7 - sqrtDisc) / (2 * a9);
+  const t22 = (-b7 + 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;
@@ -455,12 +457,12 @@ function intersectCircleCircle(c1, circ1, c22, circ2, tol) {
   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 h7 = Math.sqrt(Math.max(0, h22));
   const mx = circ1.cx + a9 * dx / d11;
   const my = circ1.cy + a9 * dy / d11;
-  const candidates = h10 < tol ? [[mx, my]] : [
-    [mx + h10 * dy / d11, my - h10 * dx / d11],
-    [mx - h10 * dy / d11, my + h10 * dx / d11]
+  const candidates = h7 < tol ? [[mx, my]] : [
+    [mx + h7 * dy / d11, my - h7 * dx / d11],
+    [mx - h7 * dy / d11, my + h7 * dx / d11]
   ];
   const results = [];
   for (const [px, py] of candidates) {
@@ -498,9 +500,9 @@ function numericalIntersect(c1, c22, tolerance, isSelf = false) {
   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];
+    for (let j10 = 0; j10 < N4; j10++) {
+      const p2a = pts2[j10];
+      const p2b = pts2[j10 + 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;
@@ -556,8 +558,8 @@ function numericalIntersect(c1, c22, tolerance, isSelf = false) {
   }
   return { points: found, segments: [] };
 }
-function serializeCurve2d(c8) {
-  return JSON.stringify(c8);
+function serializeCurve2d(c7) {
+  return JSON.stringify(c7);
 }
 function deserializeCurve2d(data) {
   return JSON.parse(data);
@@ -565,73 +567,73 @@ function deserializeCurve2d(data) {
 function createBBox2d() {
   return { __bk2d_bbox: true, xMin: Infinity, yMin: Infinity, xMax: -Infinity, yMax: -Infinity };
 }
-function addCurveToBBox(bbox, c8, _tol) {
-  const bounds = curveBounds(c8);
+function addCurveToBBox(bbox, c7, _tol) {
+  const bounds = curveBounds(c7);
   if (!isFinite(bounds.first) || !isFinite(bounds.last)) return;
   const nSamples = 20;
   const dt = (bounds.last - bounds.first) / nSamples;
   for (let i9 = 0; i9 <= nSamples; i9++) {
-    const t10 = bounds.first + i9 * dt;
-    const [x7, y7] = evaluateCurve2d(c8, t10);
-    if (x7 < bbox.xMin) bbox.xMin = x7;
-    if (y7 < bbox.yMin) bbox.yMin = y7;
-    if (x7 > bbox.xMax) bbox.xMax = x7;
-    if (y7 > bbox.yMax) bbox.yMax = y7;
-  }
-}
-function evaluateBezier(poles, t10) {
-  const n7 = poles.length;
-  const work = poles.map(([x7, y7]) => [x7, y7]);
-  for (let r9 = 1; r9 < n7; r9++) {
-    for (let i9 = 0; i9 < n7 - r9; i9++) {
+    const t7 = bounds.first + i9 * dt;
+    const [x6, y6] = evaluateCurve2d(c7, t7);
+    if (x6 < bbox.xMin) bbox.xMin = x6;
+    if (y6 < bbox.yMin) bbox.yMin = y6;
+    if (x6 > bbox.xMax) bbox.xMax = x6;
+    if (y6 > bbox.yMax) bbox.yMax = y6;
+  }
+}
+function evaluateBezier(poles, t7) {
+  const n8 = poles.length;
+  const work = poles.map(([x6, y6]) => [x6, y6]);
+  for (let r9 = 1; r9 < n8; r9++) {
+    for (let i9 = 0; i9 < n8 - 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];
+      wi[0] = (1 - t7) * wi[0] + t7 * wi1[0];
+      wi[1] = (1 - t7) * wi[1] + t7 * wi1[1];
     }
   }
   return work[0];
 }
-function evaluateBSpline2d(c8, t10) {
+function evaluateBSpline2d(c7, t7) {
   const fullKnots = [];
-  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 p8 = c8.degree;
-  const n7 = c8.poles.length;
-  const k7 = fullKnots.length;
-  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++) {
+  for (let i9 = 0; i9 < c7.knots.length; i9++) {
+    const mult = c7.multiplicities[i9] ?? 1;
+    for (let j10 = 0; j10 < mult; j10++) {
+      fullKnots.push(c7.knots[i9]);
+    }
+  }
+  const p7 = c7.degree;
+  const n8 = c7.poles.length;
+  const k9 = fullKnots.length;
+  const tClamped = Math.max(fullKnots[p7], Math.min(fullKnots[k9 - p7 - 1], t7));
+  let span = p7;
+  for (let i9 = p7; i9 < k9 - p7 - 1; i9++) {
     if (tClamped >= fullKnots[i9] && tClamped < fullKnots[i9 + 1]) {
       span = i9;
       break;
     }
   }
-  if (tClamped >= fullKnots[k7 - p8 - 1]) span = k7 - p8 - 2;
+  if (tClamped >= fullKnots[k9 - p7 - 1]) span = k9 - p7 - 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)];
+  for (let j10 = 0; j10 <= p7; j10++) {
+    const idx = Math.min(span - p7 + j10, n8 - 1);
+    const pole = c7.poles[Math.max(0, idx)];
     d11.push([pole[0], pole[1]]);
   }
-  for (let r9 = 1; r9 <= p8; r9++) {
-    for (let j7 = p8; j7 >= r9; j7--) {
-      const i9 = span - p8 + j7;
+  for (let r9 = 1; r9 <= p7; r9++) {
+    for (let j10 = p7; j10 >= r9; j10--) {
+      const i9 = span - p7 + j10;
       const left = fullKnots[i9] ?? 0;
-      const right = fullKnots[i9 + p8 - r9 + 1] ?? 1;
+      const right = fullKnots[i9 + p7 - r9 + 1] ?? 1;
       const denom = right - left;
       const alpha = denom > 1e-15 ? (tClamped - left) / denom : 0;
-      const dj = d11[j7];
-      const djPrev = d11[j7 - 1];
+      const dj = d11[j10];
+      const djPrev = d11[j10 - 1];
       dj[0] = (1 - alpha) * djPrev[0] + alpha * dj[0];
       dj[1] = (1 - alpha) * djPrev[1] + alpha * dj[1];
     }
   }
-  return d11[p8];
+  return d11[p7];
 }
 function isBrepkitHandle(shape2) {
   return shape2 !== null && shape2 !== void 0 && typeof shape2 === "object" && shape2.__brepkit;
@@ -668,11 +670,11 @@ function shellHandle(id) {
   return handle("shell", id);
 }
 function compoundHandle(id) {
-  const h10 = handle("compound", id);
+  const h7 = handle("compound", id);
   if (syntheticCompounds.has(id)) {
-    return { ...h10, delete: () => syntheticCompounds.delete(id) };
+    return { ...h7, delete: () => syntheticCompounds.delete(id) };
   }
-  return h10;
+  return h7;
 }
 function vertexHandle(id) {
   return handle("vertex", id);
@@ -723,16 +725,16 @@ function dist3(x1, y1, z1, x22, y22, z22) {
 function copyWasmBytes(bytes) {
   return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
 }
-function translationMatrix(x7, y7, z6) {
+function translationMatrix(x6, y6, z6) {
   return [
     1,
     0,
     0,
-    x7,
+    x6,
     0,
     1,
     0,
-    y7,
+    y6,
     0,
     0,
     1,
@@ -745,20 +747,20 @@ function translationMatrix(x7, y7, z6) {
 }
 function rotationMatrix(angleDeg, axis = [0, 0, 1], center = [0, 0, 0]) {
   const rad = angleDeg * Math.PI / 180;
-  const c8 = Math.cos(rad);
-  const s6 = Math.sin(rad);
-  const t10 = 1 - c8;
+  const c7 = Math.cos(rad);
+  const s5 = Math.sin(rad);
+  const t7 = 1 - c7;
   const len = Math.sqrt(axis[0] ** 2 + axis[1] ** 2 + axis[2] ** 2);
   const [ux, uy, uz] = [axis[0] / len, axis[1] / len, axis[2] / len];
-  const r00 = 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 r00 = t7 * ux * ux + c7;
+  const r01 = t7 * ux * uy - s5 * uz;
+  const r02 = t7 * ux * uz + s5 * uy;
+  const r10 = t7 * uy * ux + s5 * uz;
+  const r11 = t7 * uy * uy + c7;
+  const r12 = t7 * uy * uz - s5 * ux;
+  const r20 = t7 * uz * ux - s5 * uy;
+  const r21 = t7 * uz * uy + s5 * ux;
+  const r22 = t7 * uz * uz + c7;
   const [cx, cy, cz] = center;
   const tx = cx - (r00 * cx + r01 * cy + r02 * cz);
   const ty = cy - (r10 * cx + r11 * cy + r12 * cz);
@@ -862,6 +864,30 @@ function warnOnce(key, message) {
   _warned.add(key);
   console.warn(`brepkit: ${message}`);
 }
+function mapNumericTransition(mode) {
+  switch (mode) {
+    case 0:
+      return "rmf";
+    case 1:
+      return "rightCorner";
+    case 2:
+      return "roundCorner";
+    default:
+      return void 0;
+  }
+}
+function mapStringTransition(mode) {
+  switch (mode) {
+    case "right":
+      return "rightCorner";
+    case "round":
+      return "roundCorner";
+    case "transformed":
+      return "rmf";
+    default:
+      return void 0;
+  }
+}
 function hasBooleanOptions(opts) {
   return opts.optimisation !== void 0 || opts.simplify !== void 0 || opts.strategy !== void 0 || opts.fuzzyValue !== void 0;
 }
@@ -948,9 +974,9 @@ class BrepkitAdapter {
     if (this.bk.compoundFuse) {
       const solidIds = [];
       for (const shape2 of shapes) {
-        const h10 = shape2;
-        if (h10.type === "compound") {
-          solidIds.push(...toArray(this.bk.getCompoundSolids(h10.id)));
+        const h7 = shape2;
+        if (h7.type === "compound") {
+          solidIds.push(...toArray(this.bk.getCompoundSolids(h7.id)));
         } else {
           solidIds.push(unwrapSolidOrThrow(shape2, "fuseAll"));
         }
@@ -981,9 +1007,9 @@ class BrepkitAdapter {
     const baseId = unwrapSolidOrThrow(shape2, "cutAll");
     const toolIds = [];
     for (const tool of tools) {
-      const h10 = tool;
-      if (h10.type === "compound") {
-        toolIds.push(...toArray(this.bk.getCompoundSolids(h10.id)));
+      const h7 = tool;
+      if (h7.type === "compound") {
+        toolIds.push(...toArray(this.bk.getCompoundSolids(h7.id)));
       } else {
         toolIds.push(unwrapSolidOrThrow(tool, "cutAll"));
       }
@@ -1014,15 +1040,15 @@ class BrepkitAdapter {
   hull(shapes, _tolerance) {
     const coords = [];
     for (const shape2 of shapes) {
-      const h10 = shape2;
-      if (h10.type === "solid") {
-        const vertIds = toArray(this.bk.getSolidVertices(h10.id));
+      const h7 = shape2;
+      if (h7.type === "solid") {
+        const vertIds = toArray(this.bk.getSolidVertices(h7.id));
         for (const vid of vertIds) {
           const pos = this.bk.getVertexPosition(vid);
           coords.push(pos[0], pos[1], pos[2]);
         }
-      } else if (h10.type === "vertex") {
-        const pos = this.bk.getVertexPosition(h10.id);
+      } else if (h7.type === "vertex") {
+        const pos = this.bk.getVertexPosition(h7.id);
         coords.push(pos[0], pos[1], pos[2]);
       }
     }
@@ -1033,8 +1059,8 @@ class BrepkitAdapter {
   hullFromPoints(points, _tolerance) {
     if (points.length < 4) throw new Error("brepkit: hull needs at least 4 points");
     const coords = [];
-    for (const p8 of points) {
-      coords.push(p8.x, p8.y, p8.z);
+    for (const p7 of points) {
+      coords.push(p7.x, p7.y, p7.z);
     }
     const id = this.bk.convexHull(coords);
     return solidHandle(id);
@@ -1042,10 +1068,10 @@ class BrepkitAdapter {
   buildSolidFromFaces(points, faces, _tolerance) {
     const positions = new Float64Array(points.length * 3);
     for (let i9 = 0; i9 < points.length; i9++) {
-      const p8 = points[i9];
-      positions[i9 * 3] = p8.x;
-      positions[i9 * 3 + 1] = p8.y;
-      positions[i9 * 3 + 2] = p8.z;
+      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 i9 = 0; i9 < faces.length; i9++) {
@@ -1060,8 +1086,8 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // Shape construction
   // ═══════════════════════════════════════════════════════════════════════
-  makeVertex(x7, y7, z6) {
-    const id = this.bk.makeVertex(x7, y7, z6);
+  makeVertex(x6, y6, z6) {
+    const id = this.bk.makeVertex(x6, y6, z6);
     return vertexHandle(id);
   }
   makeEdge(curve, start, end) {
@@ -1090,9 +1116,9 @@ class BrepkitAdapter {
   makeWire(edges) {
     const edgeIds = [];
     for (const e8 of edges) {
-      const h10 = e8;
-      if (h10.type === "wire") {
-        for (const childEdgeId of toArray(this.bk.getWireEdges(h10.id))) {
+      const h7 = e8;
+      if (h7.type === "wire") {
+        for (const childEdgeId of toArray(this.bk.getWireEdges(h7.id))) {
           edgeIds.push(childEdgeId);
         }
       } else {
@@ -1103,9 +1129,9 @@ class BrepkitAdapter {
     return wireHandle(id);
   }
   makeFace(wire, _planar) {
-    const h10 = wire;
-    if (h10.type === "edge") {
-      const wireId = this.bk.makeWire([h10.id], true);
+    const h7 = wire;
+    if (h7.type === "edge") {
+      const wireId = this.bk.makeWire([h7.id], true);
       const id2 = this.bk.makeFaceFromWire(wireId);
       return faceHandle(id2);
     }
@@ -1196,8 +1222,8 @@ class BrepkitAdapter {
       nz[2] * ux[0] - nz[0] * ux[2],
       nz[0] * ux[1] - nz[1] * ux[0]
     ];
-    const proj = (p8) => {
-      const dx = p8[0] - p1[0], dy = p8[1] - p1[1], dz = p8[2] - p1[2];
+    const proj = (p7) => {
+      const dx = p7[0] - p1[0], dy = p7[1] - p1[1], dz = p7[2] - p1[2];
       return [dx * ux[0] + dy * ux[1] + dz * ux[2], dx * uy[0] + dy * uy[1] + dz * uy[2]];
     };
     const [ax2, ay2] = proj(p1);
@@ -1247,12 +1273,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 n7 = points.length;
+    const n8 = 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, y7, z6]) => [x7, y7, z6]);
+    const weights = Array(n8).fill(1);
+    const flatCp = points.flatMap(([x6, y6, z6]) => [x6, y6, z6]);
     const startPt = points[0];
-    const endPt = points[n7 - 1];
+    const endPt = points[n8 - 1];
     const id = this.bk.makeNurbsEdge(
       startPt[0],
       startPt[1],
@@ -1294,9 +1320,9 @@ class BrepkitAdapter {
     const sign = leftHanded ? -1 : 1;
     const points = [];
     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 t7 = i9 / nSamples;
+      const angle = sign * 2 * Math.PI * turns * t7;
+      points.push([cx + radius * Math.cos(angle), cy + radius * Math.sin(angle), cz + height * t7]);
     }
     const edge = this.interpolatePoints(points);
     return this.makeWire([edge]);
@@ -1304,11 +1330,11 @@ class BrepkitAdapter {
   makeWireFromMixed(items) {
     const edgeIds = [];
     for (const item of items) {
-      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))) {
+      const h7 = item;
+      if (h7.type === "edge") {
+        edgeIds.push(h7.id);
+      } else if (h7.type === "wire") {
+        for (const childEdgeId of toArray(this.bk.getWireEdges(h7.id))) {
           edgeIds.push(childEdgeId);
         }
       }
@@ -1323,9 +1349,9 @@ class BrepkitAdapter {
     if (handles.length === 0) {
       throw new Error("brepkit: makeCompound requires at least one shape");
     }
-    const allSolids = handles.every((h10) => h10.type === "solid");
+    const allSolids = handles.every((h7) => h7.type === "solid");
     if (allSolids) {
-      const id2 = this.bk.makeCompound(handles.map((h10) => h10.id));
+      const id2 = this.bk.makeCompound(handles.map((h7) => h7.id));
       return compoundHandle(id2);
     }
     const id = syntheticCompoundCounter++;
@@ -1334,9 +1360,9 @@ class BrepkitAdapter {
   }
   makeBoxFromCorners(p1, p22) {
     const w7 = Math.abs(p22[0] - p1[0]);
-    const h10 = Math.abs(p22[1] - p1[1]);
+    const h7 = Math.abs(p22[1] - p1[1]);
     const d11 = Math.abs(p22[2] - p1[2]);
-    const box = this.makeBox(w7, h10, d11);
+    const box = this.makeBox(w7, h7, 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]);
@@ -1346,15 +1372,15 @@ class BrepkitAdapter {
     return box;
   }
   solidFromShell(shell2) {
-    const h10 = shell2;
-    if (h10.type === "solid") return shell2;
-    if (h10.type === "shell") {
+    const h7 = shell2;
+    if (h7.type === "solid") return shell2;
+    if (h7.type === "shell") {
       try {
-        this.bk.getSolidFaces(h10.id);
-        return solidHandle(h10.id);
+        this.bk.getSolidFaces(h7.id);
+        return solidHandle(h7.id);
       } catch {
       }
-      const id2 = this.bk.solidFromShell(h10.id);
+      const id2 = this.bk.solidFromShell(h7.id);
       return solidHandle(id2);
     }
     const id = this.bk.solidFromShell(unwrap(shell2, "shell"));
@@ -1415,28 +1441,42 @@ class BrepkitAdapter {
       );
     }
     const faceIds = wires.map((w7) => {
-      const h10 = w7;
-      if (h10.type === "wire") {
-        return this.bk.makeFaceFromWire(h10.id);
+      const h7 = w7;
+      if (h7.type === "wire") {
+        return this.bk.makeFaceFromWire(h7.id);
       }
       return unwrap(w7, "face");
     });
     const id = this.bk.loft(faceIds);
     return solidHandle(id);
   }
-  sweep(wire, spine, _options) {
-    if (_options?.transitionMode !== void 0) {
-      warnOnce("sweep-transition", "Sweep transition mode not supported; ignored.");
-    }
+  sweep(wire, spine, options) {
+    const contactMode = options?.transitionMode !== void 0 ? mapNumericTransition(options.transitionMode) : void 0;
     const profileHandle = wire;
     const faceId = profileHandle.type === "wire" ? this.bk.makeFaceFromWire(profileHandle.id) : unwrap(wire, "face");
     const spineHandle = spine;
     if (spineHandle.type === "wire") {
       const edges = this.iterShapes(spine, "edge");
       const edgeIds = edges.map((e8) => unwrap(e8, "edge"));
+      if (contactMode && edgeIds.length === 1) {
+        const edgeId = edgeIds[0];
+        if (edgeId !== void 0) {
+          return solidHandle(this.bk.sweepWithOptions(faceId, edgeId, contactMode, [], 0));
+        }
+      }
+      if (contactMode && edgeIds.length > 1) {
+        warnOnce(
+          "sweep-transition-multi-edge",
+          "Sweep transition mode not supported for multi-edge wires; ignored."
+        );
+      }
       const id2 = this.bk.sweepAlongEdges(faceId, edgeIds);
       return solidHandle(id2);
     }
+    if (contactMode) {
+      const edgeId = unwrap(spine, "edge");
+      return solidHandle(this.bk.sweepWithOptions(faceId, edgeId, contactMode, [], 0));
+    }
     const nurbsData = this.extractNurbsFromEdge(spine);
     if (!nurbsData) {
       throw new Error("brepkit: sweep spine must be an edge or wire");
@@ -1497,25 +1537,58 @@ class BrepkitAdapter {
     return solidHandle(this.bk.filletVariable(solidId, JSON.stringify(spec)));
   }
   chamfer(shape2, edges, distance) {
-    const d11 = typeof distance === "number" ? distance : Array.isArray(distance) ? distance[0] : 1;
-    if (typeof distance !== "number") {
-      warnOnce(
-        "chamfer-asymmetric",
-        typeof distance === "function" ? "Per-edge chamfer distance function not supported; falling back to distance=1." : "Asymmetric chamfer not supported; using first distance only."
-      );
-    }
+    const solidId = unwrapSolidOrThrow(shape2, "chamfer");
     const edgeIds = edges.map((e8) => unwrap(e8, "edge"));
-    const id = this.bk.chamfer(unwrapSolidOrThrow(shape2, "chamfer"), edgeIds, d11);
-    return solidHandle(id);
+    if (typeof distance === "number") {
+      return solidHandle(this.bk.chamfer(solidId, edgeIds, distance));
+    }
+    if (Array.isArray(distance)) {
+      const [d1, d22] = distance;
+      if (typeof this.bk.chamferAsymmetric === "function") {
+        return solidHandle(this.bk.chamferAsymmetric(solidId, edgeIds, d1, d22));
+      }
+      warnOnce("chamfer-asymmetric", "chamferAsymmetric not available; using averaged distance.");
+      return solidHandle(this.bk.chamfer(solidId, edgeIds, (d1 + d22) / 2));
+    }
+    const groups = /* @__PURE__ */ new Map();
+    for (const [i9, edge] of edges.entries()) {
+      const r9 = distance(edge);
+      const eid = edgeIds[i9];
+      if (eid === void 0) continue;
+      const [d1, d22] = Array.isArray(r9) ? r9 : [r9, r9];
+      const key = `${d1},${d22}`;
+      const group = groups.get(key);
+      if (group) {
+        group.ids.push(eid);
+      } else {
+        groups.set(key, { ids: [eid], d1, d2: d22 });
+      }
+    }
+    let result = solidId;
+    for (const group of groups.values()) {
+      if (group.d1 === group.d2) {
+        result = this.bk.chamfer(result, group.ids, group.d1);
+      } else if (typeof this.bk.chamferAsymmetric === "function") {
+        result = this.bk.chamferAsymmetric(result, group.ids, group.d1, group.d2);
+      } else {
+        warnOnce(
+          "chamfer-callback",
+          "chamferAsymmetric not available; asymmetric edges use averaged distance."
+        );
+        result = this.bk.chamfer(result, group.ids, (group.d1 + group.d2) / 2);
+      }
+    }
+    return solidHandle(result);
   }
   chamferDistAngle(shape2, edges, distance, angleDeg) {
-    warnOnce(
-      "chamfer-dist-angle",
-      "Distance-angle chamfer approximated as averaged two-distance chamfer."
-    );
     const d22 = distance * Math.tan(angleDeg * Math.PI / 180);
-    const avgDist = (distance + d22) / 2;
-    return this.chamfer(shape2, edges, avgDist);
+    const solidId = unwrapSolidOrThrow(shape2, "chamferDistAngle");
+    const edgeIds = edges.map((e8) => unwrap(e8, "edge"));
+    if (typeof this.bk.chamferAsymmetric === "function") {
+      return solidHandle(this.bk.chamferAsymmetric(solidId, edgeIds, distance, d22));
+    }
+    warnOnce("chamfer-dist-angle", "chamferAsymmetric not available; using averaged distance.");
+    return solidHandle(this.bk.chamfer(solidId, edgeIds, (distance + d22) / 2));
   }
   shell(shape2, faces, thickness, tolerance) {
     if (tolerance !== void 0) {
@@ -1548,15 +1621,58 @@ class BrepkitAdapter {
         if (bestMatch >= 0 && bestDot > 0.99) return bestMatch;
       } catch {
       }
+      try {
+        const origVerts = toArray(this.bk.getFaceVertices(fid));
+        if (origVerts.length >= 1) {
+          let ox = 0, oy = 0, oz = 0;
+          for (const vid of origVerts) {
+            const pos = this.bk.getVertexPosition(vid);
+            ox += pos[0];
+            oy += pos[1];
+            oz += pos[2];
+          }
+          const n8 = origVerts.length;
+          ox /= n8;
+          oy /= n8;
+          oz /= n8;
+          let bestCentroidMatch = -1;
+          let bestCentroidDist = Infinity;
+          for (const sf of solidFaces) {
+            try {
+              const sv = toArray(this.bk.getFaceVertices(sf));
+              if (sv.length < 1) continue;
+              let sx = 0, sy = 0, sz = 0;
+              for (const svid of sv) {
+                const spos = this.bk.getVertexPosition(svid);
+                sx += spos[0];
+                sy += spos[1];
+                sz += spos[2];
+              }
+              const sn = sv.length;
+              sx /= sn;
+              sy /= sn;
+              sz /= sn;
+              const dist = Math.sqrt((ox - sx) ** 2 + (oy - sy) ** 2 + (oz - sz) ** 2);
+              if (dist < bestCentroidDist) {
+                bestCentroidDist = dist;
+                bestCentroidMatch = sf;
+              }
+            } catch {
+            }
+          }
+          if (bestCentroidMatch >= 0 && bestCentroidDist < 1e-3) return bestCentroidMatch;
+        }
+      } catch {
+      }
       return fid;
     });
     const id = this.bk.shell(solidId, thickness, resolvedFaceIds);
     return solidHandle(id);
   }
   thicken(shape2, thickness) {
-    const h10 = shape2;
-    if (h10.type === "face") {
-      const id = this.bk.thicken(h10.id, thickness);
+    const h7 = shape2;
+    if (h7.type === "face") {
+      const id = this.bk.thicken(h7.id, thickness);
       return solidHandle(id);
     }
     throw new Error("brepkit: thicken() requires a face");
@@ -1568,9 +1684,9 @@ class BrepkitAdapter {
         "offset() tolerance parameter is not supported; brepkit uses its own internal tolerance."
       );
     }
-    const h10 = shape2;
-    if (h10.type === "face") {
-      const id2 = this.bk.thicken(h10.id, distance);
+    const h7 = shape2;
+    if (h7.type === "face") {
+      const id2 = this.bk.thicken(h7.id, distance);
       return solidHandle(id2);
     }
     const id = this.bk.offsetSolid(unwrapSolidOrThrow(shape2, "offset"), distance);
@@ -1585,17 +1701,17 @@ class BrepkitAdapter {
     }
     throw new Error("brepkit: transform expects a 16-element matrix array");
   }
-  translate(shape2, x7, y7, z6) {
-    return this.applyMatrix(shape2, translationMatrix(x7, y7, z6));
+  translate(shape2, x6, y6, z6) {
+    return this.applyMatrix(shape2, translationMatrix(x6, y6, z6));
   }
   rotate(shape2, angle, axis, center) {
     return this.applyMatrix(shape2, rotationMatrix(angle, axis, center));
   }
   mirror(shape2, origin, normal) {
-    const h10 = shape2;
-    if (h10.type === "solid") {
+    const h7 = shape2;
+    if (h7.type === "solid") {
       const id = this.bk.mirror(
-        h10.id,
+        h7.id,
         origin[0],
         origin[1],
         origin[2],
@@ -1665,12 +1781,12 @@ class BrepkitAdapter {
    * fallback when hash matching fails (brepkit always creates new face IDs).
    */
   buildEvolution(resultShape, inputFaceHashes, hashUpperBound, isTransform, originalShape) {
-    const h10 = resultShape;
+    const h7 = resultShape;
     const modified = /* @__PURE__ */ new Map();
     const generated = /* @__PURE__ */ new Map();
     const deleted = /* @__PURE__ */ new Set();
-    if (h10.type === "solid") {
-      const outputFaces = toArray(this.bk.getSolidFaces(h10.id));
+    if (h7.type === "solid") {
+      const outputFaces = toArray(this.bk.getSolidFaces(h7.id));
       const outputHashes = outputFaces.map((fid) => fid % hashUpperBound);
       if (isTransform) {
         for (let i9 = 0; i9 < inputFaceHashes.length && i9 < outputHashes.length; i9++) {
@@ -1753,10 +1869,10 @@ class BrepkitAdapter {
     }
   }
   /** Squared Euclidean distance between two 3-component centroids. */
-  static centroidDistSq(a9, b9) {
-    const dx = a9[0] - b9[0];
-    const dy = a9[1] - b9[1];
-    const dz = a9[2] - b9[2];
+  static centroidDistSq(a9, b7) {
+    const dx = a9[0] - b7[0];
+    const dy = a9[1] - b7[1];
+    const dz = a9[2] - b7[2];
     return dx * dx + dy * dy + dz * dz;
   }
   /** Compute face centroid as the average of tessellation vertices. */
@@ -1863,9 +1979,9 @@ class BrepkitAdapter {
       }
     }
   }
-  translateWithHistory(shape2, x7, y7, z6, inputFaceHashes, hashUpperBound) {
+  translateWithHistory(shape2, x6, y6, z6, inputFaceHashes, hashUpperBound) {
     return this.buildEvolution(
-      this.translate(shape2, x7, y7, z6),
+      this.translate(shape2, x6, y6, z6),
       inputFaceHashes,
       hashUpperBound,
       true
@@ -1939,15 +2055,15 @@ class BrepkitAdapter {
             result.evolution.deleted,
             intermediateOutputs
           );
-          for (const [k7, v8] of result.evolution.modified) {
-            if (!combinedModified.has(k7) && !intermediateOutputs.has(k7)) {
-              combinedModified.set(k7, [...v8]);
+          for (const [k9, v6] of result.evolution.modified) {
+            if (!combinedModified.has(k9) && !intermediateOutputs.has(k9)) {
+              combinedModified.set(k9, [...v6]);
             }
           }
-          for (const [k7, v8] of result.evolution.generated) {
-            if (!intermediateOutputs.has(k7)) {
-              const existing = combinedGenerated.get(k7) ?? [];
-              combinedGenerated.set(k7, [...existing, ...v8]);
+          for (const [k9, v6] of result.evolution.generated) {
+            if (!intermediateOutputs.has(k9)) {
+              const existing = combinedGenerated.get(k9) ?? [];
+              combinedGenerated.set(k9, [...existing, ...v6]);
             }
           }
           for (const d11 of result.evolution.deleted) {
@@ -1976,8 +2092,8 @@ class BrepkitAdapter {
       inputFaceHashes,
       hashUpperBound,
       options,
-      (a9, b9) => this.bk.fuseWithEvolution(a9, b9),
-      (s6, t10, o9) => this.fuse(s6, t10, o9),
+      (a9, b7) => this.bk.fuseWithEvolution(a9, b7),
+      (s5, t7, o8) => this.fuse(s5, t7, o8),
       "fuseWithHistory"
     );
   }
@@ -1988,8 +2104,8 @@ class BrepkitAdapter {
       inputFaceHashes,
       hashUpperBound,
       options,
-      (a9, b9) => this.bk.cutWithEvolution(a9, b9),
-      (s6, t10, o9) => this.cut(s6, t10, o9),
+      (a9, b7) => this.bk.cutWithEvolution(a9, b7),
+      (s5, t7, o8) => this.cut(s5, t7, o8),
       "cutWithHistory"
     );
   }
@@ -2000,8 +2116,8 @@ class BrepkitAdapter {
       inputFaceHashes,
       hashUpperBound,
       options,
-      (a9, b9) => this.bk.intersectWithEvolution(a9, b9),
-      (s6, t10, o9) => this.intersect(s6, t10, o9),
+      (a9, b7) => this.bk.intersectWithEvolution(a9, b7),
+      (s5, t7, o8) => this.intersect(s5, t7, o8),
       "intersectWithHistory"
     );
   }
@@ -2060,14 +2176,14 @@ class BrepkitAdapter {
         "mesh angularTolerance is not supported; only linear deflection is used."
       );
     }
-    const h10 = unwrap(shape2);
+    const h7 = unwrap(shape2);
     const bkHandle = shape2;
     const deflection = options.tolerance || DEFAULT_DEFLECTION;
     let result;
     if (bkHandle.type === "solid") {
-      result = this.meshSolid(h10, deflection, !!options.includeUVs);
+      result = this.meshSolid(h7, deflection, !!options.includeUVs);
     } else if (bkHandle.type === "face") {
-      result = this.meshSingleFace(h10, deflection, 0);
+      result = this.meshSingleFace(h7, deflection, 0);
     } else {
       throw new Error(`brepkit: cannot mesh shape of type '${bkHandle.type}'`);
     }
@@ -2157,36 +2273,36 @@ class BrepkitAdapter {
   }
   exportSTEPAssembly(parts, _options) {
     if (parts.length === 0) return "";
-    const shapes = parts.map((p8) => p8.shape);
+    const shapes = parts.map((p7) => p7.shape);
     return this.exportSTEP(shapes);
   }
   // ═══════════════════════════════════════════════════════════════════════
   // Measurement
   // ═══════════════════════════════════════════════════════════════════════
   volume(shape2) {
-    const h10 = shape2;
-    if (h10.type === "solid") {
+    const h7 = shape2;
+    if (h7.type === "solid") {
       return this.bk.volume(unwrap(shape2), DEFAULT_DEFLECTION);
     }
-    if (h10.type === "compound") {
+    if (h7.type === "compound") {
       const solids = this.iterShapes(shape2, "solid");
       let total = 0;
-      for (const s6 of solids) {
-        total += this.bk.volume(unwrap(s6), DEFAULT_DEFLECTION);
+      for (const s5 of solids) {
+        total += this.bk.volume(unwrap(s5), DEFAULT_DEFLECTION);
       }
       return total;
     }
     return 0;
   }
   area(shape2) {
-    const h10 = shape2;
-    if (h10.type === "face") {
+    const h7 = shape2;
+    if (h7.type === "face") {
       return this.bk.faceArea(unwrap(shape2), DEFAULT_DEFLECTION);
     }
-    if (h10.type === "solid") {
+    if (h7.type === "solid") {
       return this.bk.surfaceArea(unwrap(shape2), DEFAULT_DEFLECTION);
     }
-    if (h10.type === "compound") {
+    if (h7.type === "compound") {
       const faces = this.iterShapes(shape2, "face");
       let total = 0;
       for (const face of faces) {
@@ -2197,58 +2313,58 @@ class BrepkitAdapter {
     return 0;
   }
   length(shape2) {
-    const h10 = shape2;
-    if (h10.type === "edge") {
+    const h7 = shape2;
+    if (h7.type === "edge") {
       return this.bk.edgeLength(unwrap(shape2));
     }
-    if (h10.type === "face") {
+    if (h7.type === "face") {
       return this.bk.facePerimeter(unwrap(shape2));
     }
-    if (h10.type === "wire") {
-      return this.bk.wireLength(h10.id);
+    if (h7.type === "wire") {
+      return this.bk.wireLength(h7.id);
     }
     throw new Error("brepkit: length() requires an edge, wire, or face");
   }
   centerOfMass(shape2) {
-    const h10 = shape2;
-    if (h10.type === "solid") {
+    const h7 = shape2;
+    if (h7.type === "solid") {
       const result = this.bk.centerOfMass(unwrap(shape2), DEFAULT_DEFLECTION);
       return [result[0], result[1], result[2]];
     }
-    if (h10.type === "face") {
+    if (h7.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 (h10.type === "edge") {
-      const verts = this.bk.getEdgeVertices(h10.id);
+    if (h7.type === "edge") {
+      const verts = this.bk.getEdgeVertices(h7.id);
       return [
         (verts[0] + verts[3]) / 2,
         (verts[1] + verts[4]) / 2,
         (verts[2] + verts[5]) / 2
       ];
     }
-    if (h10.type === "vertex") {
+    if (h7.type === "vertex") {
       return this.vertexPosition(shape2);
     }
     const vertices = this.iterShapes(shape2, "vertex");
     if (vertices.length > 0) {
       let sx = 0, sy = 0, sz = 0;
-      for (const v8 of vertices) {
-        const p8 = this.vertexPosition(v8);
-        sx += p8[0];
-        sy += p8[1];
-        sz += p8[2];
+      for (const v6 of vertices) {
+        const p7 = this.vertexPosition(v6);
+        sx += p7[0];
+        sy += p7[1];
+        sz += p7[2];
       }
       return [sx / vertices.length, sy / vertices.length, sz / vertices.length];
     }
     return [0, 0, 0];
   }
   linearCenterOfMass(shape2) {
-    const h10 = shape2;
-    if (h10.type === "edge") {
-      const verts = this.bk.getEdgeVertices(h10.id);
+    const h7 = shape2;
+    if (h7.type === "edge") {
+      const verts = this.bk.getEdgeVertices(h7.id);
       return [
         (verts[0] + verts[3]) / 2,
         (verts[1] + verts[4]) / 2,
@@ -2258,15 +2374,15 @@ class BrepkitAdapter {
     return this.centerOfMass(shape2);
   }
   boundingBox(shape2) {
-    const h10 = shape2;
-    if (h10.type === "solid") {
+    const h7 = shape2;
+    if (h7.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 (h10.type === "vertex") {
+    if (h7.type === "vertex") {
       const pos = this.vertexPosition(shape2);
       return { min: [...pos], max: [...pos] };
     }
@@ -2278,13 +2394,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 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];
+      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];
     }
     return { min: [minX, minY, minZ], max: [maxX, maxY, maxZ] };
   }
@@ -2292,11 +2408,11 @@ class BrepkitAdapter {
   // Topology introspection
   // ═══════════════════════════════════════════════════════════════════════
   iterShapes(shape2, type) {
-    const h10 = unwrap(shape2);
+    const h7 = unwrap(shape2);
     const bkHandle = shape2;
     switch (bkHandle.type) {
       case "compound": {
-        const children = syntheticCompounds.get(h10);
+        const children = syntheticCompounds.get(h7);
         if (children) {
           const results = [];
           for (const child of children) {
@@ -2309,24 +2425,24 @@ class BrepkitAdapter {
           return results;
         }
         if (type === "solid") {
-          return toArray(this.bk.getCompoundSolids(h10)).map(solidHandle);
+          return toArray(this.bk.getCompoundSolids(h7)).map(solidHandle);
         }
         if (type === "face" || type === "edge" || type === "vertex" || type === "wire") {
-          const solids = toArray(this.bk.getCompoundSolids(h10)).map(solidHandle);
-          return solids.flatMap((s6) => this.iterShapes(s6, type));
+          const solids = toArray(this.bk.getCompoundSolids(h7)).map(solidHandle);
+          return solids.flatMap((s5) => this.iterShapes(s5, type));
         }
         return [];
       }
       case "solid": {
         switch (type) {
           case "face":
-            return toArray(this.bk.getSolidFaces(h10)).map(faceHandle);
+            return toArray(this.bk.getSolidFaces(h7)).map(faceHandle);
           case "edge":
-            return toArray(this.bk.getSolidEdges(h10)).map(edgeHandle);
+            return toArray(this.bk.getSolidEdges(h7)).map(edgeHandle);
           case "vertex":
-            return toArray(this.bk.getSolidVertices(h10)).map(vertexHandle);
+            return toArray(this.bk.getSolidVertices(h7)).map(vertexHandle);
           case "wire":
-            return toArray(this.bk.getSolidFaces(h10)).flatMap(
+            return toArray(this.bk.getSolidFaces(h7)).flatMap(
               (faceId) => toArray(this.bk.getFaceWires(faceId)).map(wireHandle)
             );
           default:
@@ -2335,10 +2451,10 @@ class BrepkitAdapter {
       }
       case "shell": {
         if (type === "face") {
-          return toArray(this.bk.getShellFaces(h10)).map(faceHandle);
+          return toArray(this.bk.getShellFaces(h7)).map(faceHandle);
         }
         if (type === "edge" || type === "vertex") {
-          const faces = toArray(this.bk.getShellFaces(h10)).map(faceHandle);
+          const faces = toArray(this.bk.getShellFaces(h7)).map(faceHandle);
           const seen = /* @__PURE__ */ new Set();
           const results = [];
           for (const face of faces) {
@@ -2359,13 +2475,13 @@ class BrepkitAdapter {
           return [shape2];
         }
         if (type === "edge") {
-          return toArray(this.bk.getFaceEdges(h10)).map(edgeHandle);
+          return toArray(this.bk.getFaceEdges(h7)).map(edgeHandle);
         }
         if (type === "vertex") {
-          return toArray(this.bk.getFaceVertices(h10)).map(vertexHandle);
+          return toArray(this.bk.getFaceVertices(h7)).map(vertexHandle);
         }
         if (type === "wire") {
-          return toArray(this.bk.getFaceWires(h10)).map(wireHandle);
+          return toArray(this.bk.getFaceWires(h7)).map(wireHandle);
         }
         return [];
       }
@@ -2374,10 +2490,10 @@ class BrepkitAdapter {
           return [shape2];
         }
         if (type === "edge") {
-          return toArray(this.bk.getWireEdges(h10)).map(edgeHandle);
+          return toArray(this.bk.getWireEdges(h7)).map(edgeHandle);
         }
         if (type === "vertex") {
-          const edgeIds = toArray(this.bk.getWireEdges(h10));
+          const edgeIds = toArray(this.bk.getWireEdges(h7));
           const seen = /* @__PURE__ */ new Set();
           const results = [];
           for (const eid of edgeIds) {
@@ -2386,11 +2502,11 @@ class BrepkitAdapter {
               [verts[0], verts[1], verts[2]],
               [verts[3], verts[4], verts[5]]
             ];
-            for (const [x7, y7, z6] of coords) {
-              const key = `${x7},${y7},${z6}`;
+            for (const [x6, y6, z6] of coords) {
+              const key = `${x6},${y6},${z6}`;
               if (!seen.has(key)) {
                 seen.add(key);
-                results.push(vertexHandle(this.bk.makeVertex(x7, y7, z6)));
+                results.push(vertexHandle(this.bk.makeVertex(x6, y6, z6)));
               }
             }
           }
@@ -2403,7 +2519,7 @@ class BrepkitAdapter {
           return [shape2];
         }
         if (type === "vertex") {
-          const verts = this.bk.getEdgeVertices(h10);
+          const verts = this.bk.getEdgeVertices(h7);
           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)];
@@ -2423,11 +2539,11 @@ class BrepkitAdapter {
     if (isBrepkitHandle(shape2)) return shape2.type;
     throw new Error("brepkit: cannot determine shape type of non-brepkit handle");
   }
-  isSame(a9, b9) {
-    return isBrepkitHandle(a9) && isBrepkitHandle(b9) && a9.id === b9.id && a9.type === b9.type;
+  isSame(a9, b7) {
+    return isBrepkitHandle(a9) && isBrepkitHandle(b7) && a9.id === b7.id && a9.type === b7.type;
   }
-  isEqual(a9, b9) {
-    return this.isSame(a9, b9);
+  isEqual(a9, b7) {
+    return this.isSame(a9, b7);
   }
   downcast(shape2, _type) {
     return shape2;
@@ -2440,8 +2556,8 @@ class BrepkitAdapter {
     return !shape2 || !isBrepkitHandle(shape2);
   }
   shapeOrientation(shape2) {
-    const h10 = unwrap(shape2);
-    const orient = this.bk.getShapeOrientation(h10);
+    const h7 = unwrap(shape2);
+    const orient = this.bk.getShapeOrientation(h7);
     return orient;
   }
   // ═══════════════════════════════════════════════════════════════════════
@@ -2466,13 +2582,13 @@ class BrepkitAdapter {
     const id = this.bk.getFaceOuterWire(unwrap(face, "face"));
     return wireHandle(id);
   }
-  surfaceNormal(face, u8, v8) {
-    const n7 = this.bk.evaluateSurfaceNormal(unwrap(face, "face"), u8, v8);
-    return [n7[0], n7[1], n7[2]];
+  surfaceNormal(face, u5, v6) {
+    const n8 = this.bk.evaluateSurfaceNormal(unwrap(face, "face"), u5, v6);
+    return [n8[0], n8[1], n8[2]];
   }
-  pointOnSurface(face, u8, v8) {
-    const p8 = this.bk.evaluateSurface(unwrap(face, "face"), u8, v8);
-    return [p8[0], p8[1], p8[2]];
+  pointOnSurface(face, u5, v6) {
+    const p7 = this.bk.evaluateSurface(unwrap(face, "face"), u5, v6);
+    return [p7[0], p7[1], p7[2]];
   }
   uvFromPoint(face, point) {
     try {
@@ -2501,19 +2617,19 @@ class BrepkitAdapter {
   // Geometry queries: edge / curve
   // ═══════════════════════════════════════════════════════════════════════
   curveTangent(shape2, param) {
-    const h10 = shape2;
+    const h7 = shape2;
     let edgeId;
     let evalParam = param;
-    if (h10.type === "wire") {
-      const edgeIds = toArray(this.bk.getWireEdges(h10.id));
+    if (h7.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h7.id));
       edgeId = edgeIds[edgeIds.length - 1];
       let cumulative = 0;
       for (const eid of edgeIds) {
-        const p8 = this.bk.getEdgeCurveParameters(eid);
-        const span = p8[1] - p8[0];
+        const p7 = this.bk.getEdgeCurveParameters(eid);
+        const span = p7[1] - p7[0];
         if (param <= cumulative + span || eid === edgeId) {
           edgeId = eid;
-          evalParam = Math.min(p8[0] + (param - cumulative), p8[1]);
+          evalParam = Math.min(p7[0] + (param - cumulative), p7[1]);
           break;
         }
         cumulative += span;
@@ -2528,14 +2644,14 @@ class BrepkitAdapter {
     };
   }
   curveParameters(shape2) {
-    const h10 = shape2;
-    if (h10.type === "wire") {
-      const edgeIds = toArray(this.bk.getWireEdges(h10.id));
+    const h7 = shape2;
+    if (h7.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h7.id));
       if (edgeIds.length === 0) return [0, 0];
       let total = 0;
       for (const eid of edgeIds) {
-        const p8 = this.bk.getEdgeCurveParameters(eid);
-        total += p8[1] - p8[0];
+        const p7 = this.bk.getEdgeCurveParameters(eid);
+        total += p7[1] - p7[0];
       }
       return [0, total];
     }
@@ -2544,9 +2660,9 @@ class BrepkitAdapter {
     return [params[0], params[1]];
   }
   curvePointAtParam(shape2, param) {
-    const h10 = shape2;
-    if (h10.type === "wire") {
-      const edgeIds = toArray(this.bk.getWireEdges(h10.id));
+    const h7 = shape2;
+    if (h7.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h7.id));
       let cumulative = 0;
       for (const eid of edgeIds) {
         const p22 = this.bk.getEdgeCurveParameters(eid);
@@ -2562,13 +2678,13 @@ class BrepkitAdapter {
       return [pt[0], pt[1], pt[2]];
     }
     const edgeId = unwrap(shape2, "edge");
-    const p8 = this.bk.evaluateEdgeCurve(edgeId, param);
-    return [p8[0], p8[1], p8[2]];
+    const p7 = this.bk.evaluateEdgeCurve(edgeId, param);
+    return [p7[0], p7[1], p7[2]];
   }
   curveIsClosed(shape2) {
-    const h10 = shape2;
-    if (h10.type === "wire") {
-      const edgeIds = toArray(this.bk.getWireEdges(h10.id));
+    const h7 = shape2;
+    if (h7.type === "wire") {
+      const edgeIds = toArray(this.bk.getWireEdges(h7.id));
       if (edgeIds.length === 0) return false;
       if (edgeIds.length === 1) {
         const verts2 = this.bk.getEdgeVertices(edgeIds[0]);
@@ -2583,7 +2699,7 @@ class BrepkitAdapter {
       const unmatched = [];
       for (const pt of endpoints) {
         const matchIdx = unmatched.findIndex(
-          (u8) => dist3(u8[0], u8[1], u8[2], pt[0], pt[1], pt[2]) < 1e-7
+          (u5) => dist3(u5[0], u5[1], u5[2], pt[0], pt[1], pt[2]) < 1e-7
         );
         if (matchIdx >= 0) {
           unmatched.splice(matchIdx, 1);
@@ -2597,11 +2713,11 @@ class BrepkitAdapter {
     return dist3(verts[0], verts[1], verts[2], verts[3], verts[4], verts[5]) < 1e-7;
   }
   curveIsPeriodic(shape2) {
-    const h10 = shape2;
+    const h7 = shape2;
     try {
-      if (h10.type === "edge") return this.curveIsClosed(shape2);
-      if (h10.type === "wire") {
-        const edgeIds = toArray(this.bk.getWireEdges(h10.id));
+      if (h7.type === "edge") return this.curveIsClosed(shape2);
+      if (h7.type === "wire") {
+        const edgeIds = toArray(this.bk.getWireEdges(h7.id));
         if (edgeIds.length === 1) return this.curveIsClosed(shape2);
       }
     } catch {
@@ -2619,8 +2735,8 @@ class BrepkitAdapter {
     return 0;
   }
   curveType(shape2) {
-    const h10 = shape2;
-    if (h10.type === "wire") {
+    const h7 = shape2;
+    if (h7.type === "wire") {
       const edges = this.iterShapes(shape2, "edge");
       const first = edges[0];
       if (first) return this.bk.getEdgeCurveType(unwrap(first, "edge"));
@@ -2665,16 +2781,16 @@ class BrepkitAdapter {
   }
   sew(shapes, tolerance) {
     const faceIds = [];
-    for (const s6 of shapes) {
-      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))) {
+    for (const s5 of shapes) {
+      const h7 = s5;
+      if (h7.type === "face") {
+        faceIds.push(h7.id);
+      } else if (h7.type === "solid") {
+        for (const fid of toArray(this.bk.getSolidFaces(h7.id))) {
           faceIds.push(fid);
         }
-      } else if (h10.type === "shell") {
-        for (const fid of toArray(this.bk.getShellFaces(h10.id))) {
+      } else if (h7.type === "shell") {
+        for (const fid of toArray(this.bk.getShellFaces(h7.id))) {
           faceIds.push(fid);
         }
       }
@@ -2690,10 +2806,10 @@ class BrepkitAdapter {
     return shellHandle(id);
   }
   healSolid(shape2) {
-    const h10 = shape2;
-    if (h10.type !== "solid") {
+    const h7 = shape2;
+    if (h7.type !== "solid") {
       throw new Error(
-        `brepkit: healSolid requires a solid, got ${h10.type}. Consider using makeCompound() to combine shapes first.`
+        `brepkit: healSolid requires a solid, got ${h7.type}. Consider using makeCompound() to combine shapes first.`
       );
     }
     try {
@@ -2781,13 +2897,13 @@ class BrepkitAdapter {
         point2: [result[1], result[2], result[3]]
       };
     }
-    const getPos = (s6) => {
-      if (s6.type === "vertex") {
-        const p8 = this.bk.getVertexPosition(s6.id);
-        return [p8[0], p8[1], p8[2]];
+    const getPos = (s5) => {
+      if (s5.type === "vertex") {
+        const p7 = this.bk.getVertexPosition(s5.id);
+        return [p7[0], p7[1], p7[2]];
       }
-      if (s6.type === "solid") {
-        const bb = this.bk.boundingBox(s6.id);
+      if (s5.type === "solid") {
+        const bb = this.bk.boundingBox(s5.id);
         return [(bb[0] + bb[3]) / 2, (bb[1] + bb[4]) / 2, (bb[2] + bb[5]) / 2];
       }
       return [0, 0, 0];
@@ -2802,7 +2918,7 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // Classification
   // ═══════════════════════════════════════════════════════════════════════
-  classifyPointOnFace(face, u8, v8, tolerance) {
+  classifyPointOnFace(face, u5, v6, tolerance) {
     if (tolerance !== void 0) {
       warnOnce(
         "classify-tolerance",
@@ -2811,7 +2927,7 @@ class BrepkitAdapter {
     }
     const faceId = unwrap(face, "face");
     const domain = this.bk.getSurfaceDomain(faceId);
-    if (u8 < domain[0] || u8 > domain[1] || v8 < domain[2] || v8 > domain[3]) {
+    if (u5 < domain[0] || u5 > domain[1] || v6 < domain[2] || v6 > domain[3]) {
       return "out";
     }
     return "in";
@@ -2831,7 +2947,7 @@ class BrepkitAdapter {
       return this.makeLineEdge(points[0], points[1]);
     }
     const degree = Math.min(3, points.length - 1);
-    const coords = points.flatMap(([x7, y7, z6]) => [x7, y7, z6]);
+    const coords = points.flatMap(([x6, y6, z6]) => [x6, y6, z6]);
     const id = this.bk.interpolatePoints(coords, degree);
     return edgeHandle(id);
   }
@@ -2839,7 +2955,7 @@ class BrepkitAdapter {
     const degree = options?.degMax ?? 3;
     const tol = options?.tolerance ?? 1e-6;
     const coords = [];
-    for (const p8 of points) coords.push(p8[0], p8[1], p8[2]);
+    for (const p7 of points) coords.push(p7[0], p7[1], p7[2]);
     const numCps = Math.max(degree + 1, Math.min(points.length, Math.ceil(points.length * 0.7)));
     const id = this.bk.approximateCurveLspia(coords, degree, numCps, tol, 100);
     return edgeHandle(id);
@@ -2848,20 +2964,22 @@ class BrepkitAdapter {
   // Serialization
   // ═══════════════════════════════════════════════════════════════════════
   toBREP(shape2) {
-    warnOnce(
-      "brep-format",
-      "toBREP/fromBREP uses STEP format (not OCCT BREP). Cross-kernel BREP round-trips are not supported."
-    );
+    const h7 = shape2;
+    if (h7.type === "solid") {
+      return this.bk.toBREP(h7.id);
+    }
+    warnOnce("brep-non-solid", "toBREP for non-solid shapes uses STEP format.");
     return this.exportSTEP([shape2]);
   }
   fromBREP(data) {
-    warnOnce(
-      "brep-format",
-      "toBREP/fromBREP uses STEP format (not OCCT BREP). Cross-kernel BREP round-trips are not supported."
-    );
+    if (typeof this.bk.fromBREP === "function" && data.trimStart().startsWith("{")) {
+      const id = this.bk.fromBREP(data);
+      return solidHandle(id);
+    }
     const shapes = this.importSTEP(data);
-    if (shapes.length === 0) throw new Error("brepkit: fromBREP produced no shapes");
-    return shapes[0];
+    const first = shapes[0];
+    if (!first) throw new Error("brepkit: fromBREP produced no shapes");
+    return first;
   }
   // ═══════════════════════════════════════════════════════════════════════
   // Mesh preparation
@@ -2877,8 +2995,8 @@ class BrepkitAdapter {
   composeTransform(ops) {
     let matrix = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
     for (const op of ops) {
-      const m10 = op.type === "translate" ? translationMatrix(op.x, op.y, op.z) : rotationMatrix(op.angle, op.axis, op.center);
-      matrix = multiplyMatrices(m10, matrix);
+      const m11 = op.type === "translate" ? translationMatrix(op.x, op.y, op.z) : rotationMatrix(op.angle, op.axis, op.center);
+      matrix = multiplyMatrices(m11, matrix);
     }
     return { handle: matrix, dispose: () => {
     } };
@@ -2894,6 +3012,49 @@ class BrepkitAdapter {
     const profileHandle = profile;
     const faceId = profileHandle.type === "wire" ? this.bk.makeFaceFromWire(profileHandle.id) : unwrap(profile, "face");
     const shellMode = !!(options && options["shellMode"]);
+    const transitionMode = options?.["transitionMode"];
+    const contactMode = transitionMode ? mapStringTransition(transitionMode) : void 0;
+    if (contactMode) {
+      const spineHandle = spine;
+      if (spineHandle.type !== "wire") {
+        try {
+          const edgeId = unwrap(spine, "edge");
+          const shape22 = solidHandle(this.bk.sweepWithOptions(faceId, edgeId, contactMode, [], 0));
+          if (shellMode) return { shape: shape22, firstShape: profile, lastShape: profile };
+          return shape22;
+        } catch (e8) {
+          console.warn(
+            "brepkit: sweepWithOptions failed, falling back to sweepSmooth/simplePipe:",
+            e8
+          );
+        }
+      } else {
+        const edges = this.iterShapes(spine, "edge");
+        if (edges.length === 1) {
+          const first = edges[0];
+          if (first) {
+            try {
+              const edgeId = unwrap(first, "edge");
+              const shape22 = solidHandle(
+                this.bk.sweepWithOptions(faceId, edgeId, contactMode, [], 0)
+              );
+              if (shellMode) return { shape: shape22, firstShape: profile, lastShape: profile };
+              return shape22;
+            } catch (e8) {
+              console.warn(
+                "brepkit: sweepWithOptions failed, falling back to sweepSmooth/simplePipe:",
+                e8
+              );
+            }
+          }
+        } else {
+          warnOnce(
+            "sweepPipeShell-transition-multi-edge",
+            "sweepPipeShell transition mode not supported for multi-edge wires; ignored."
+          );
+        }
+      }
+    }
     const nurbsData = this.extractNurbsFromEdge(spine);
     if (nurbsData && nurbsData.degree > 1) {
       try {
@@ -2917,8 +3078,8 @@ class BrepkitAdapter {
   }
   loftAdvanced(wires, options) {
     const faceIds = wires.map((w7) => {
-      const h10 = w7;
-      if (h10.type === "wire") return this.bk.makeFaceFromWire(h10.id);
+      const h7 = w7;
+      if (h7.type === "wire") return this.bk.makeFaceFromWire(h7.id);
       return unwrap(w7, "face");
     });
     try {
@@ -3035,8 +3196,8 @@ class BrepkitAdapter {
   }
   bsplineSurface(points, rows, cols) {
     const coords = [];
-    for (const [x7, y7, z6] of points) {
-      coords.push(x7, y7, z6);
+    for (const [x6, y6, z6] of points) {
+      coords.push(x6, y6, z6);
     }
     const degreeU = Math.min(3, rows - 1);
     const degreeV = Math.min(3, cols - 1);
@@ -3050,11 +3211,11 @@ class BrepkitAdapter {
   triangulatedSurface(points, rows, cols) {
     const faces = [];
     for (let r9 = 0; r9 < rows - 1; r9++) {
-      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);
+      for (let c7 = 0; c7 < cols - 1; c7++) {
+        const i00 = r9 * cols + c7;
+        const i10 = (r9 + 1) * cols + c7;
+        const i01 = r9 * cols + (c7 + 1);
+        const i11 = (r9 + 1) * cols + (c7 + 1);
         const f1 = this.buildTriFace(points[i00], points[i10], points[i01]);
         if (f1) faces.push(f1);
         const f22 = this.buildTriFace(points[i10], points[i11], points[i01]);
@@ -3067,9 +3228,9 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // Mesh sewing -> solid
   // ═══════════════════════════════════════════════════════════════════════
-  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]];
+  buildTriFace(a9, b7, c7) {
+    const ab = [b7[0] - a9[0], b7[1] - a9[1], b7[2] - a9[2]];
+    const ac = [c7[0] - a9[0], c7[1] - a9[1], c7[2] - a9[2]];
     const cross = [
       ab[1] * ac[2] - ab[2] * ac[1],
       ab[2] * ac[0] - ab[0] * ac[2],
@@ -3078,9 +3239,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, b9);
-      const e22 = this.makeLineEdge(b9, c8);
-      const e32 = this.makeLineEdge(c8, a9);
+      const e1 = this.makeLineEdge(a9, b7);
+      const e22 = this.makeLineEdge(b7, c7);
+      const e32 = this.makeLineEdge(c7, a9);
       const wire = this.makeWire([e1, e22, e32]);
       return this.makeFace(wire);
     } catch (e8) {
@@ -3089,7 +3250,7 @@ class BrepkitAdapter {
     }
   }
   sewAndSolidify(faces, tolerance) {
-    const faceIds = faces.map((s6) => unwrap(s6, "face"));
+    const faceIds = faces.map((s5) => unwrap(s5, "face"));
     const solidId = this.bk.sewFaces(faceIds, tolerance);
     return solidHandle(solidId);
   }
@@ -3097,9 +3258,9 @@ class BrepkitAdapter {
   // Repair
   // ═══════════════════════════════════════════════════════════════════════
   fixShape(shape2) {
-    const h10 = shape2;
-    if (h10.type === "solid") {
-      this.bk.healSolid(h10.id);
+    const h7 = shape2;
+    if (h7.type === "solid") {
+      this.bk.healSolid(h7.id);
     }
     return shape2;
   }
@@ -3109,9 +3270,9 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // Measurement (advanced)
   // ═══════════════════════════════════════════════════════════════════════
-  surfaceCurvature(face, u8, v8) {
+  surfaceCurvature(face, u5, v6) {
     const fid = unwrap(face, "face");
-    const data = this.bk.measureCurvatureAtSurface(fid, u8, v8);
+    const data = this.bk.measureCurvatureAtSurface(fid, u5, v6);
     if (data.length < 8) {
       throw new Error(
         `brepkit: measureCurvatureAtSurface returned ${data.length} values, expected 8`
@@ -3135,8 +3296,8 @@ class BrepkitAdapter {
     const pos = mesh2.positions;
     const idx = mesh2.indices;
     let cx = 0, cy = 0, cz = 0, totalArea = 0;
-    for (let t10 = 0; t10 < idx.length; t10 += 3) {
-      const i0 = idx[t10] * 3, i1 = idx[t10 + 1] * 3, i22 = idx[t10 + 2] * 3;
+    for (let t7 = 0; t7 < idx.length; t7 += 3) {
+      const i0 = idx[t7] * 3, i1 = idx[t7 + 1] * 3, i22 = idx[t7 + 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;
@@ -3194,12 +3355,12 @@ class BrepkitAdapter {
   }
   writeXCAFToSTEP(doc, _options) {
     if (doc && doc.__brepkit_xcaf && Array.isArray(doc.shapes)) {
-      return this.exportSTEP(doc.shapes.map((s6) => s6.shape));
+      return this.exportSTEP(doc.shapes.map((s5) => s5.shape));
     }
     return "";
   }
   exportSTEPConfigured(shapes, _options) {
-    return this.exportSTEP(shapes.map((s6) => s6.shape));
+    return this.exportSTEP(shapes.map((s5) => s5.shape));
   }
   // ═══════════════════════════════════════════════════════════════════════
   // Export helpers
@@ -3226,11 +3387,11 @@ class BrepkitAdapter {
   getBezierPenultimatePole(edge) {
     const nurbsData = this.extractNurbsFromEdge(edge);
     if (!nurbsData || nurbsData.controlPoints.length < 6) return null;
-    const n7 = nurbsData.controlPoints.length;
+    const n8 = nurbsData.controlPoints.length;
     return [
-      nurbsData.controlPoints[n7 - 6],
-      nurbsData.controlPoints[n7 - 5],
-      nurbsData.controlPoints[n7 - 4]
+      nurbsData.controlPoints[n8 - 6],
+      nurbsData.controlPoints[n8 - 5],
+      nurbsData.controlPoints[n8 - 4]
     ];
   }
   // ═══════════════════════════════════════════════════════════════════════
@@ -3252,15 +3413,15 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // 3D geometry primitive factories
   // ═══════════════════════════════════════════════════════════════════════
-  createPoint3d(x7, y7, z6) {
-    return { x: x7, y: y7, z: z6 };
+  createPoint3d(x6, y6, z6) {
+    return { x: x6, y: y6, z: z6 };
   }
-  createDirection3d(x7, y7, z6) {
-    const len = Math.sqrt(x7 * x7 + y7 * y7 + z6 * z6);
-    return { x: x7 / len, y: y7 / len, z: z6 / len };
+  createDirection3d(x6, y6, z6) {
+    const len = Math.sqrt(x6 * x6 + y6 * y6 + z6 * z6);
+    return { x: x6 / len, y: y6 / len, z: z6 / len };
   }
-  createVector3d(x7, y7, z6) {
-    return { x: x7, y: y7, z: z6 };
+  createVector3d(x6, y6, z6) {
+    return { x: x6, y: y6, z: z6 };
   }
   createAxis1(cx, cy, cz, dx, dy, dz) {
     return { origin: [cx, cy, cz], direction: [dx, dy, dz] };
@@ -3283,9 +3444,9 @@ class BrepkitAdapter {
   // Shape reversal
   // ═══════════════════════════════════════════════════════════════════════
   reverseShape(shape2) {
-    const h10 = shape2;
-    const newId = this.bk.reverseShape(h10.id);
-    return handle(h10.type, newId);
+    const h7 = shape2;
+    const newId = this.bk.reverseShape(h7.id);
+    return handle(h7.type, newId);
   }
   // ═══════════════════════════════════════════════════════════════════════
   // Dispose
@@ -3317,27 +3478,27 @@ class BrepkitAdapter {
   // ═══════════════════════════════════════════════════════════════════════
   // Kernel2DCapability — pure TypeScript implementation
   // ═══════════════════════════════════════════════════════════════════════
-  c2d(h10) {
-    return h10;
+  c2d(h7) {
+    return h7;
   }
   /** Unwrap any trimmed wrappers to get the underlying geometry. */
-  c2dBasis(h10) {
-    let c8 = this.c2d(h10);
-    while (c8.__bk2d === "trimmed") c8 = c8.basis;
-    return c8;
+  c2dBasis(h7) {
+    let c7 = this.c2d(h7);
+    while (c7.__bk2d === "trimmed") c7 = c7.basis;
+    return c7;
   }
-  bb2d(h10) {
-    return h10;
+  bb2d(h7) {
+    return h7;
   }
-  createPoint2d(x7, y7) {
-    return { x: x7, y: y7 };
+  createPoint2d(x6, y6) {
+    return { x: x6, y: y6 };
   }
-  createDirection2d(x7, y7) {
-    const l10 = Math.sqrt(x7 * x7 + y7 * y7);
-    return { x: x7 / l10, y: y7 / l10 };
+  createDirection2d(x6, y6) {
+    const l10 = Math.sqrt(x6 * x6 + y6 * y6);
+    return { x: x6 / l10, y: y6 / l10 };
   }
-  createVector2d(x7, y7) {
-    return { x: x7, y: y7 };
+  createVector2d(x6, y6) {
+    return { x: x6, y: y6 };
   }
   createAxis2d(px, py, dx, dy) {
     return { px, py, dx, dy, delete: noop };
@@ -3392,10 +3553,10 @@ class BrepkitAdapter {
       return makeLine2d(sx, sy, ex, ey);
     }
     const chord2 = dx * dx + dy * dy;
-    const t10 = -chord2 / denom;
-    const cx = sx - t10 * nty;
-    const cy = sy + t10 * ntx;
-    const radius = Math.abs(t10);
+    const t7 = -chord2 / denom;
+    const cx = sx - t7 * nty;
+    const cy = sy + t7 * ntx;
+    const radius = Math.abs(t7);
     const a12 = Math.atan2(sy - cy, sx - cx);
     const a23 = Math.atan2(ey - cy, ex - cx);
     const ccwTanX = -(sy - cy) / radius;
@@ -3426,13 +3587,13 @@ class BrepkitAdapter {
     return makeBezier2d(points);
   }
   makeBSpline2d(points, _options) {
-    const n7 = points.length;
-    const degree = Math.min(3, n7 - 1);
+    const n8 = points.length;
+    const degree = Math.min(3, n8 - 1);
     const knots = [];
     const mults = [];
     knots.push(0);
     mults.push(degree + 1);
-    const nInternal = n7 - degree - 1;
+    const nInternal = n8 - degree - 1;
     for (let i9 = 1; i9 <= nInternal; i9++) {
       knots.push(i9 / (nInternal + 1));
       mults.push(1);
@@ -3472,14 +3633,14 @@ class BrepkitAdapter {
     return JSON.parse(JSON.stringify(curve));
   }
   offsetCurve2d(curve, offset2) {
-    const c8 = this.c2d(curve);
-    const bounds = curveBounds(c8);
+    const c7 = this.c2d(curve);
+    const bounds = curveBounds(c7);
     const N4 = 30;
     const poles = [];
     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 t7 = bounds.first + (bounds.last - bounds.first) * i9 / N4;
+      const [px, py] = evaluateCurve2d(c7, t7);
+      const [tx, ty] = tangentCurve2d(c7, t7);
       const tLen = Math.sqrt(tx * tx + ty * ty);
       if (tLen > 1e-12) {
         poles.push([px - ty / tLen * offset2, py + tx / tLen * offset2]);
@@ -3509,19 +3670,19 @@ class BrepkitAdapter {
     if (len < 1e-15) return this.c2d(curve);
     const ax = dx / len, ay = dy / len;
     const px = -ay, py = ax;
-    const k7 = ratio - 1;
-    const m00 = 1 + k7 * px * px, m01 = k7 * px * py;
-    const m10 = k7 * py * px, m11 = 1 + k7 * py * py;
+    const k9 = ratio - 1;
+    const m00 = 1 + k9 * px * px, m01 = k9 * px * py;
+    const m102 = k9 * py * px, m11 = 1 + k9 * py * py;
     const txOff = ox - m00 * ox - m01 * oy;
-    const tyOff = oy - m10 * ox - m11 * oy;
-    const gtrsf = { m: [m00, m01, 0, m10, m11, 0, 0, 0, 1], tx: txOff, ty: tyOff };
+    const tyOff = oy - m102 * ox - m11 * oy;
+    const gtrsf = { m: [m00, m01, 0, m102, m11, 0, 0, 0, 1], tx: txOff, ty: tyOff };
     return this.transformCurve2dGeneral(curve, gtrsf);
   }
   // --- General 2D transforms (stored as 3×3 matrices) ---
   // All GTrsf2d methods return objects with a no-op .delete() to match OCCT's
   // Emscripten WASM objects, which callers (e.g. curves.ts) rely on for cleanup.
-  _gtrsf(m10, tx, ty) {
-    return { m: m10, tx, ty, delete: noop };
+  _gtrsf(m11, tx, ty) {
+    return { m: m11, tx, ty, delete: noop };
   }
   createIdentityGTrsf2d() {
     return this._gtrsf([1, 0, 0, 0, 1, 0, 0, 0, 1], 0, 0);
@@ -3530,11 +3691,11 @@ class BrepkitAdapter {
     const len = Math.sqrt(dx * dx + dy * dy);
     if (len < 1e-15) return this.createIdentityGTrsf2d();
     const px = -dy / len, py = dx / len;
-    const k7 = ratio - 1;
-    const m10 = [1 + k7 * px * px, k7 * px * py, 0, k7 * py * px, 1 + k7 * py * py, 0, 0, 0, 1];
-    const txv = ox - m10[0] * ox - m10[1] * oy;
-    const tyv = oy - m10[3] * ox - m10[4] * oy;
-    return this._gtrsf(m10, txv, tyv);
+    const k9 = ratio - 1;
+    const m11 = [1 + k9 * px * px, k9 * px * py, 0, k9 * py * px, 1 + k9 * py * py, 0, 0, 0, 1];
+    const txv = ox - m11[0] * ox - m11[1] * oy;
+    const tyv = oy - m11[3] * ox - m11[4] * oy;
+    return this._gtrsf(m11, txv, tyv);
   }
   createTranslationGTrsf2d(dx, dy) {
     return this._gtrsf([1, 0, 0, 0, 1, 0, 0, 0, 1], dx, dy);
@@ -3543,17 +3704,17 @@ class BrepkitAdapter {
     if (mode === "axis" && dx !== void 0 && dy !== void 0) {
       const len = Math.sqrt(dx * dx + dy * dy);
       const nx = dx / len, ny = dy / len;
-      const m10 = [2 * nx * nx - 1, 2 * nx * ny, 0, 2 * nx * ny, 2 * ny * ny - 1, 0, 0, 0, 1];
+      const m11 = [2 * nx * nx - 1, 2 * nx * ny, 0, 2 * nx * ny, 2 * ny * ny - 1, 0, 0, 0, 1];
       const px = ox ?? cx, py = oy ?? cy;
-      const txv = px - m10[0] * px - m10[1] * py;
-      const tyv = py - m10[3] * px - m10[4] * py;
-      return this._gtrsf(m10, txv, tyv);
+      const txv = px - m11[0] * px - m11[1] * py;
+      const tyv = py - m11[3] * px - m11[4] * py;
+      return this._gtrsf(m11, txv, tyv);
     }
     return this._gtrsf([-1, 0, 0, 0, -1, 0, 0, 0, 1], 2 * cx, 2 * cy);
   }
   createRotationGTrsf2d(angle, cx, 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);
+    const c7 = Math.cos(angle), s5 = Math.sin(angle);
+    return this._gtrsf([c7, -s5, 0, s5, c7, 0, 0, 0, 1], cx - c7 * cx + s5 * cy, cy - s5 * cx - c7 * cy);
   }
   createScaleGTrsf2d(factor, cx, cy) {
     return this._gtrsf([factor, 0, 0, 0, factor, 0, 0, 0, 1], cx * (1 - factor), cy * (1 - factor));
@@ -3563,17 +3724,17 @@ class BrepkitAdapter {
     gtrsf.ty = dy;
   }
   multiplyGTrsf2d(base, other) {
-    const a9 = base.m, b9 = other.m;
+    const a9 = base.m, b7 = other.m;
     const r9 = [
-      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]
+      a9[0] * b7[0] + a9[1] * b7[3] + a9[2] * b7[6],
+      a9[0] * b7[1] + a9[1] * b7[4] + a9[2] * b7[7],
+      a9[0] * b7[2] + a9[1] * b7[5] + a9[2] * b7[8],
+      a9[3] * b7[0] + a9[4] * b7[3] + a9[5] * b7[6],
+      a9[3] * b7[1] + a9[4] * b7[4] + a9[5] * b7[7],
+      a9[3] * b7[2] + a9[4] * b7[5] + a9[5] * b7[8],
+      a9[6] * b7[0] + a9[7] * b7[3] + a9[8] * b7[6],
+      a9[6] * b7[1] + a9[7] * b7[4] + a9[8] * b7[7],
+      a9[6] * b7[2] + a9[7] * b7[5] + a9[8] * b7[8]
     ];
     base.m = r9;
     const oldTx = base.tx, oldTy = base.ty;
@@ -3582,20 +3743,20 @@ class BrepkitAdapter {
     base.ty = a9[3] * otx + a9[4] * oty + oldTy;
   }
   transformCurve2dGeneral(curve, gtrsf) {
-    const c8 = this.c2d(curve);
-    const m10 = gtrsf.m ?? [1, 0, 0, 0, 1, 0, 0, 0, 1];
+    const c7 = this.c2d(curve);
+    const m11 = 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;
+    const isIdentityMatrix = Math.abs(m11[0] - 1) < 1e-12 && Math.abs(m11[4] - 1) < 1e-12 && Math.abs(m11[1]) < 1e-12 && Math.abs(m11[3]) < 1e-12;
     if (isIdentityMatrix) {
-      return translateCurve2d(c8, tx, ty);
+      return translateCurve2d(c7, tx, ty);
     }
-    const bounds = curveBounds(c8);
+    const bounds = curveBounds(c7);
     const N4 = 20;
     const pts = [];
     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]);
+      const t7 = bounds.first + (bounds.last - bounds.first) * i9 / N4;
+      const [px, py] = evaluateCurve2d(c7, t7);
+      pts.push([m11[0] * px + m11[1] * py + tx, m11[3] * px + m11[4] * py + ty]);
     }
     return makeBezier2d(pts);
   }
@@ -3603,30 +3764,30 @@ class BrepkitAdapter {
   intersectCurves2d(c1, c22, tolerance) {
     const result = intersectCurves2dFn(this.c2d(c1), this.c2d(c22), tolerance);
     const segments = result.segments.map(
-      (s6) => Object.assign(s6, {
+      (s5) => Object.assign(s5, {
         delete() {
         }
       })
     );
     return { points: result.points, segments };
   }
-  projectPointOnCurve2d(curve, x7, y7) {
-    const c8 = this.c2d(curve);
-    const bounds = curveBounds(c8);
-    if (c8.__bk2d === "line") {
-      const dx = x7 - c8.ox;
-      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 - y7) ** 2) };
-    }
-    if (c8.__bk2d === "circle") {
-      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 - y7) ** 2) };
+  projectPointOnCurve2d(curve, x6, y6) {
+    const c7 = this.c2d(curve);
+    const bounds = curveBounds(c7);
+    if (c7.__bk2d === "line") {
+      const dx = x6 - c7.ox;
+      const dy = y6 - c7.oy;
+      const t7 = Math.max(bounds.first, Math.min(bounds.last, dx * c7.dx + dy * c7.dy));
+      const [px, py] = evaluateCurve2d(c7, t7);
+      return { param: t7, distance: Math.sqrt((px - x6) ** 2 + (py - y6) ** 2) };
+    }
+    if (c7.__bk2d === "circle") {
+      const angle = Math.atan2(y6 - c7.cy, x6 - c7.cx);
+      let t7 = c7.sense ? angle : -angle;
+      while (t7 < 0) t7 += 2 * Math.PI;
+      while (t7 > 2 * Math.PI) t7 -= 2 * Math.PI;
+      const [px, py] = evaluateCurve2d(c7, t7);
+      return { param: t7, distance: Math.sqrt((px - x6) ** 2 + (py - y6) ** 2) };
     }
     if (!isFinite(bounds.first) || !isFinite(bounds.last)) return null;
     let bestT = bounds.first;
@@ -3634,18 +3795,18 @@ class BrepkitAdapter {
     const N4 = 200;
     const dt = (bounds.last - bounds.first) / N4;
     for (let i9 = 0; i9 <= N4; i9++) {
-      const t10 = bounds.first + i9 * dt;
-      const [px, py] = evaluateCurve2d(c8, t10);
-      const d11 = (px - x7) ** 2 + (py - y7) ** 2;
+      const t7 = bounds.first + i9 * dt;
+      const [px, py] = evaluateCurve2d(c7, t7);
+      const d11 = (px - x6) ** 2 + (py - y6) ** 2;
       if (d11 < bestDist) {
         bestDist = d11;
-        bestT = t10;
+        bestT = t7;
       }
     }
     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 - y7) * ty;
+      const [px, py] = evaluateCurve2d(c7, bestT);
+      const [tx, ty] = tangentCurve2d(c7, bestT);
+      const dot = (px - x6) * tx + (py - y6) * ty;
       const denom = tx * tx + ty * ty;
       if (denom < 1e-20) break;
       const step = dot / denom;
@@ -3653,8 +3814,8 @@ class BrepkitAdapter {
       if (Math.abs(newT - bestT) < 1e-14) break;
       bestT = newT;
     }
-    const [fx, fy] = evaluateCurve2d(c8, bestT);
-    return { param: bestT, distance: Math.sqrt((fx - x7) ** 2 + (fy - y7) ** 2) };
+    const [fx, fy] = evaluateCurve2d(c7, bestT);
+    return { param: bestT, distance: Math.sqrt((fx - x6) ** 2 + (fy - y6) ** 2) };
   }
   distanceBetweenCurves2d(c1, c22, p1s, p1e, p2s, p2e) {
     const curve1 = this.c2d(c1);
@@ -3666,8 +3827,8 @@ class BrepkitAdapter {
     for (let i9 = 0; i9 <= N4; i9++) {
       const t12 = p1s + (p1e - p1s) * i9 / N4;
       const [x1, y1] = evaluateCurve2d(curve1, t12);
-      for (let j7 = 0; j7 <= N4; j7++) {
-        const t222 = p2s + (p2e - p2s) * j7 / N4;
+      for (let j10 = 0; j10 <= N4; j10++) {
+        const t222 = p2s + (p2e - p2s) * j10 / N4;
         const [x22, y22] = evaluateCurve2d(curve2, t222);
         const d11 = (x22 - x1) ** 2 + (y22 - y1) ** 2;
         if (d11 < minDistSq) {
@@ -3702,8 +3863,8 @@ class BrepkitAdapter {
     return Math.sqrt((fx2 - fx1) ** 2 + (fy2 - fy1) ** 2);
   }
   approximateCurve2dAsBSpline(curve, tol, cont, maxSeg) {
-    const c8 = this.c2d(curve);
-    const bounds = curveBounds(c8);
+    const c7 = this.c2d(curve);
+    const bounds = curveBounds(c7);
     const contDeg = cont === "C0" ? 1 : cont === "C1" ? 2 : cont === "C2" ? 3 : 4;
     const degree = Math.max(3, contDeg);
     let N4 = Math.max(100, maxSeg * 10);
@@ -3712,13 +3873,13 @@ class BrepkitAdapter {
     for (let attempt = 0; attempt < 3 && maxErr > tol; attempt++) {
       poles = [];
       for (let i9 = 0; i9 <= N4; i9++) {
-        const t10 = bounds.first + (bounds.last - bounds.first) * i9 / N4;
-        poles.push(evaluateCurve2d(c8, t10));
+        const t7 = bounds.first + (bounds.last - bounds.first) * i9 / N4;
+        poles.push(evaluateCurve2d(c7, t7));
       }
       maxErr = 0;
       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 [ex, ey] = evaluateCurve2d(c7, tMid);
         const p0 = poles[i9];
         const p1 = poles[i9 + 1];
         const mx = (p0[0] + p1[0]) / 2;
@@ -3731,9 +3892,9 @@ class BrepkitAdapter {
     return this.makeBSpline2d(poles, { degMax: degree });
   }
   decomposeBSpline2dToBeziers(curve) {
-    const c8 = this.c2dBasis(curve);
-    if (c8.__bk2d === "bezier") return [curve];
-    if (c8.__bk2d !== "bspline") {
+    const c7 = this.c2dBasis(curve);
+    if (c7.__bk2d === "bezier") return [curve];
+    if (c7.__bk2d !== "bspline") {
       const approx = this.approximateCurve2dAsBSpline(curve, 1e-6, "C2", 10);
       return this.decomposeBSpline2dToBeziers(approx);
     }
@@ -3741,8 +3902,8 @@ class BrepkitAdapter {
     const first = trimBounds.first;
     const last = trimBounds.last;
     const internalKnots = [];
-    for (const k7 of c8.knots) {
-      if (k7 > first + 1e-12 && k7 < last - 1e-12) internalKnots.push(k7);
+    for (const k9 of c7.knots) {
+      if (k9 > first + 1e-12 && k9 < last - 1e-12) internalKnots.push(k9);
     }
     const breakpoints = [first, ...internalKnots, last];
     const result = [];
@@ -3751,17 +3912,17 @@ class BrepkitAdapter {
       const t1 = breakpoints[i9 + 1];
       const span = t1 - t0;
       if (span < 1e-15) continue;
-      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 p0 = evaluateCurve2d(c7, t0);
+      const p32 = evaluateCurve2d(c7, t1);
+      const tan0 = tangentCurve2d(c7, t0);
+      const tan3 = tangentCurve2d(c7, t1);
+      const s5 = span / 3;
       const bezier = {
         __bk2d: "bezier",
         poles: [
           p0,
-          [p0[0] + tan0[0] * s6, p0[1] + tan0[1] * s6],
-          [p32[0] - tan3[0] * s6, p32[1] - tan3[1] * s6],
+          [p0[0] + tan0[0] * s5, p0[1] + tan0[1] * s5],
+          [p32[0] - tan3[0] * s5, p32[1] - tan3[1] * s5],
           p32
         ]
       };
@@ -3777,60 +3938,60 @@ class BrepkitAdapter {
     addCurveToBBox(this.bb2d(bbox), this.c2d(curve));
   }
   getBBox2dBounds(bbox) {
-    const b9 = this.bb2d(bbox);
-    return { xMin: b9.xMin, yMin: b9.yMin, xMax: b9.xMax, yMax: b9.yMax };
+    const b7 = this.bb2d(bbox);
+    return { xMin: b7.xMin, yMin: b7.yMin, xMax: b7.xMax, yMax: b7.yMax };
   }
   mergeBBox2d(target, other) {
-    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);
+    const t7 = this.bb2d(target), o8 = this.bb2d(other);
+    t7.xMin = Math.min(t7.xMin, o8.xMin);
+    t7.yMin = Math.min(t7.yMin, o8.yMin);
+    t7.xMax = Math.max(t7.xMax, o8.xMax);
+    t7.yMax = Math.max(t7.yMax, o8.yMax);
+  }
+  isBBox2dOut(a9, b7) {
+    const ba = this.bb2d(a9), bb = this.bb2d(b7);
     return ba.xMax < bb.xMin || bb.xMax < ba.xMin || ba.yMax < bb.yMin || bb.yMax < ba.yMin;
   }
-  isBBox2dOutPoint(bbox, x7, y7) {
-    const b9 = this.bb2d(bbox);
-    return x7 < b9.xMin || x7 > b9.xMax || y7 < b9.yMin || y7 > b9.yMax;
+  isBBox2dOutPoint(bbox, x6, y6) {
+    const b7 = this.bb2d(bbox);
+    return x6 < b7.xMin || x6 > b7.xMax || y6 < b7.yMin || y6 > b7.yMax;
   }
   // --- 2D type extraction ---
   getCurve2dCircleData(curve) {
-    const c8 = this.c2dBasis(curve);
-    if (c8.__bk2d === "circle") return { cx: c8.cx, cy: c8.cy, radius: c8.radius, isDirect: c8.sense };
+    const c7 = this.c2dBasis(curve);
+    if (c7.__bk2d === "circle") return { cx: c7.cx, cy: c7.cy, radius: c7.radius, isDirect: c7.sense };
     return null;
   }
   getCurve2dEllipseData(curve) {
-    const c8 = this.c2dBasis(curve);
-    if (c8.__bk2d === "ellipse")
+    const c7 = this.c2dBasis(curve);
+    if (c7.__bk2d === "ellipse")
       return {
-        majorRadius: c8.majorRadius,
-        minorRadius: c8.minorRadius,
-        xAxisAngle: c8.xDirAngle,
-        isDirect: c8.sense
+        majorRadius: c7.majorRadius,
+        minorRadius: c7.minorRadius,
+        xAxisAngle: c7.xDirAngle,
+        isDirect: c7.sense
       };
     return null;
   }
   getCurve2dBezierPoles(curve) {
-    const c8 = this.c2dBasis(curve);
-    if (c8.__bk2d === "bezier") return [...c8.poles];
+    const c7 = this.c2dBasis(curve);
+    if (c7.__bk2d === "bezier") return [...c7.poles];
     return null;
   }
   getCurve2dBezierDegree(curve) {
-    const c8 = this.c2dBasis(curve);
-    if (c8.__bk2d === "bezier") return c8.poles.length - 1;
+    const c7 = this.c2dBasis(curve);
+    if (c7.__bk2d === "bezier") return c7.poles.length - 1;
     return null;
   }
   getCurve2dBSplineData(curve) {
-    const c8 = this.c2dBasis(curve);
-    if (c8.__bk2d === "bspline")
+    const c7 = this.c2dBasis(curve);
+    if (c7.__bk2d === "bspline")
       return {
-        poles: [...c8.poles],
-        knots: [...c8.knots],
-        multiplicities: [...c8.multiplicities],
-        degree: c8.degree,
-        isPeriodic: c8.isPeriodic
+        poles: [...c7.poles],
+        knots: [...c7.knots],
+        multiplicities: [...c7.multiplicities],
+        degree: c7.degree,
+        isPeriodic: c7.isPeriodic
       };
     return null;
   }
@@ -3843,14 +4004,14 @@ class BrepkitAdapter {
   }
   // --- 2D curve splitting ---
   splitCurve2d(curve, params) {
-    const c8 = this.c2d(curve);
-    const bounds = curveBounds(c8);
-    const sortedParams = [bounds.first, ...params.sort((a9, b9) => a9 - b9), bounds.last];
+    const c7 = this.c2d(curve);
+    const bounds = curveBounds(c7);
+    const sortedParams = [bounds.first, ...params.sort((a9, b7) => a9 - b7), bounds.last];
     const result = [];
     for (let i9 = 0; i9 < sortedParams.length - 1; i9++) {
       result.push({
         __bk2d: "trimmed",
-        basis: c8,
+        basis: c7,
         tStart: sortedParams[i9],
         tEnd: sortedParams[i9 + 1]
       });
@@ -3859,33 +4020,33 @@ class BrepkitAdapter {
   }
   // --- 2D → 3D projection ---
   liftCurve2dToPlane(curve, origin, planeZ, planeX) {
-    const c8 = this.c2d(curve);
-    const y7 = [
+    const c7 = this.c2d(curve);
+    const y6 = [
       planeZ[1] * planeX[2] - planeZ[2] * planeX[1],
       planeZ[2] * planeX[0] - planeZ[0] * planeX[2],
       planeZ[0] * planeX[1] - planeZ[1] * planeX[0]
     ];
-    const lift = (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]
+    const lift = (u5, v6) => [
+      origin[0] + u5 * planeX[0] + v6 * y6[0],
+      origin[1] + u5 * planeX[1] + v6 * y6[1],
+      origin[2] + u5 * planeX[2] + v6 * y6[2]
     ];
-    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);
+    if (c7.__bk2d === "line") {
+      const p1 = lift(c7.ox, c7.oy);
+      const p22 = lift(c7.ox + c7.dx * c7.len, c7.oy + c7.dy * c7.len);
       return this.makeLineEdge(p1, p22);
     }
-    if (c8.__bk2d === "circle" || c8.__bk2d === "trimmed") {
-      let basis = c8;
+    if (c7.__bk2d === "circle" || c7.__bk2d === "trimmed") {
+      let basis = c7;
       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(c8);
+        const bounds2 = curveBounds(c7);
         let angularSpan;
-        if (c8.__bk2d === "trimmed") {
-          angularSpan = Math.abs(c8.tEnd - c8.tStart);
+        if (c7.__bk2d === "trimmed") {
+          angularSpan = Math.abs(c7.tEnd - c7.tStart);
         } else {
           angularSpan = 2 * Math.PI;
         }
@@ -3893,8 +4054,8 @@ class BrepkitAdapter {
         const segmentSpan = (bounds2.last - bounds2.first) / nSegments;
         const edgeIds = [];
         for (let seg = 0; seg < nSegments; seg++) {
-          const [su, sv] = evaluateCurve2d(c8, bounds2.first + seg * segmentSpan);
-          const [eu, ev] = evaluateCurve2d(c8, bounds2.first + (seg + 1) * segmentSpan);
+          const [su, sv] = evaluateCurve2d(c7, bounds2.first + seg * segmentSpan);
+          const [eu, ev] = evaluateCurve2d(c7, bounds2.first + (seg + 1) * segmentSpan);
           edgeIds.push(
             this.bk.makeCircleArc3d(...lift(su, sv), ...lift(eu, ev), ...center3d, ...axis)
           );
@@ -3903,21 +4064,21 @@ class BrepkitAdapter {
         return wireHandle(this.bk.makeWire(edgeIds, false));
       }
     }
-    if (c8.__bk2d === "bezier" || c8.__bk2d === "bspline") {
-      const points3d = c8.poles.map(([u8, v8]) => lift(u8, v8));
+    if (c7.__bk2d === "bezier" || c7.__bk2d === "bspline") {
+      const points3d = c7.poles.map(([u5, v6]) => lift(u5, v6));
       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(c8);
+    const bounds = curveBounds(c7);
     const nSamples = 100;
     const points = [];
     for (let i9 = 0; i9 <= nSamples; i9++) {
-      const t10 = bounds.first + (bounds.last - bounds.first) * i9 / nSamples;
-      const [u8, v8] = evaluateCurve2d(c8, t10);
-      points.push(lift(u8, v8));
+      const t7 = bounds.first + (bounds.last - bounds.first) * i9 / nSamples;
+      const [u5, v6] = evaluateCurve2d(c7, t7);
+      points.push(lift(u5, v6));
     }
     return this.interpolatePoints(points);
   }
@@ -3925,16 +4086,16 @@ class BrepkitAdapter {
     if (!isBrepkitHandle(surface))
       throw new Error("brepkit: buildEdgeOnSurface requires a face handle as surface");
     const fid = unwrap(surface, "face");
-    const c8 = this.c2d(curve);
-    const bounds = curveBounds(c8);
+    const c7 = this.c2d(curve);
+    const bounds = curveBounds(c7);
     const surfType = this.bk.getSurfaceType(fid);
     const N4 = surfType === "plane" ? 50 : 100;
     const points = [];
     for (let i9 = 0; i9 <= N4; i9++) {
-      const t10 = bounds.first + (bounds.last - bounds.first) * i9 / N4;
-      const [u8, v8] = evaluateCurve2d(c8, t10);
-      const p8 = this.bk.evaluateSurface(fid, u8, v8);
-      points.push([p8[0], p8[1], p8[2]]);
+      const t7 = bounds.first + (bounds.last - bounds.first) * i9 / N4;
+      const [u5, v6] = evaluateCurve2d(c7, t7);
+      const p7 = this.bk.evaluateSurface(fid, u5, v6);
+      points.push([p7[0], p7[1], p7[2]]);
     }
     return this.interpolatePoints(points);
   }
@@ -3954,25 +4115,25 @@ class BrepkitAdapter {
     for (let i9 = 0; i9 <= BASE_N; i9++) {
       tValues.push(tMin + (tMax - tMin) * i9 / BASE_N);
     }
-    const evaluateUV = (t10) => {
-      const pt = this.bk.evaluateEdgeCurve(eid, t10);
+    const evaluateUV = (t7) => {
+      const pt = this.bk.evaluateEdgeCurve(eid, t7);
       const uv = this.bk.projectPointOnSurface(fid, pt[0], pt[1], pt[2]);
       return [uv[0], uv[1]];
     };
-    const uvSamples = tValues.map((t10) => ({
-      t: t10,
-      uv: evaluateUV(t10)
+    const uvSamples = tValues.map((t7) => ({
+      t: t7,
+      uv: evaluateUV(t7)
     }));
     let refinements = 0;
     while (uvSamples.length < MAX_N) {
       const insertions = [];
       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 b7 = uvSamples[i9 + 1];
+        const tMid = (a9.t + b7.t) / 2;
         const uvMid = evaluateUV(tMid);
-        const interpU = (a9.uv[0] + b9.uv[0]) / 2;
-        const interpV = (a9.uv[1] + b9.uv[1]) / 2;
+        const interpU = (a9.uv[0] + b7.uv[0]) / 2;
+        const interpV = (a9.uv[1] + b7.uv[1]) / 2;
         const deviation = Math.sqrt((uvMid[0] - interpU) ** 2 + (uvMid[1] - interpV) ** 2);
         if (deviation > REFINE_THRESHOLD) {
           insertions.push({ index: i9 + 1, t: tMid, uv: uvMid });
@@ -3980,15 +4141,15 @@ class BrepkitAdapter {
       }
       if (insertions.length === 0) break;
       let budget = MAX_N - uvSamples.length;
-      for (let j7 = insertions.length - 1; j7 >= 0 && budget > 0; j7--) {
-        const ins = insertions[j7];
+      for (let j10 = insertions.length - 1; j10 >= 0 && budget > 0; j10--) {
+        const ins = insertions[j10];
         uvSamples.splice(ins.index, 0, { t: ins.t, uv: ins.uv });
         budget--;
       }
       refinements++;
       if (refinements > 3) break;
     }
-    const uvPoints = uvSamples.map((s6) => s6.uv);
+    const uvPoints = uvSamples.map((s5) => s5.uv);
     if (uvPoints.length >= 2) {
       return this.makeBSpline2d(uvPoints);
     }
@@ -4018,9 +4179,9 @@ class BrepkitAdapter {
           const N4 = 10;
           const pts = [];
           for (let i9 = 0; i9 <= N4; i9++) {
-            const t10 = tMin + (tMax - tMin) * i9 / N4;
-            const p8 = this.bk.evaluateEdgeCurve(edgeId, t10);
-            pts.push(p8[0], p8[1], p8[2]);
+            const t7 = tMin + (tMax - tMin) * i9 / N4;
+            const p7 = this.bk.evaluateEdgeCurve(edgeId, t7);
+            pts.push(p7[0], p7[1], p7[2]);
           }
           allCoords.push(...pts);
           curveLengths.push(N4 + 1);
@@ -4041,13 +4202,13 @@ class BrepkitAdapter {
   // Private helpers
   // ═══════════════════════════════════════════════════════════════════════
   applyMatrix(shape2, matrix) {
-    const h10 = shape2;
+    const h7 = shape2;
     if (!isBrepkitHandle(shape2)) {
       throw new Error("brepkit: applyMatrix requires a BrepkitHandle");
     }
-    switch (h10.type) {
+    switch (h7.type) {
       case "solid": {
-        const copy = this.bk.copySolid(h10.id);
+        const copy = this.bk.copySolid(h7.id);
         this.bk.transformSolid(copy, matrix);
         return solidHandle(copy);
       }
@@ -4057,7 +4218,7 @@ class BrepkitAdapter {
             "brepkit: applyMatrix for faces requires copyFace/transformFace WASM exports"
           );
         }
-        const copy = this.bk.copyFace(h10.id);
+        const copy = this.bk.copyFace(h7.id);
         this.bk.transformFace(copy, matrix);
         return faceHandle(copy);
       }
@@ -4067,7 +4228,7 @@ class BrepkitAdapter {
             "brepkit: applyMatrix for wires requires copyWire/transformWire WASM exports"
           );
         }
-        const copy = this.bk.copyWire(h10.id);
+        const copy = this.bk.copyWire(h7.id);
         this.bk.transformWire(copy, matrix);
         return wireHandle(copy);
       }
@@ -4077,12 +4238,12 @@ class BrepkitAdapter {
             "brepkit: applyMatrix for edges requires copyEdge/transformEdge WASM exports"
           );
         }
-        const copy = this.bk.copyEdge(h10.id);
+        const copy = this.bk.copyEdge(h7.id);
         this.bk.transformEdge(copy, matrix);
         return edgeHandle(copy);
       }
       default:
-        throw new Error(`brepkit: applyMatrix does not support '${h10.type}' shapes`);
+        throw new Error(`brepkit: applyMatrix does not support '${h7.type}' shapes`);
     }
   }
   /** Check if we need to transform from default placement (origin, +Z). */
@@ -4195,8 +4356,8 @@ class BrepkitAdapter {
         const vertCount = positions.length / 3;
         if (vertCount === 0) continue;
         const triStart = allTriangles.length;
-        for (const v8 of positions) allVertices.push(v8);
-        for (const n7 of normals) allNormals.push(n7);
+        for (const v6 of positions) allVertices.push(v6);
+        for (const n8 of normals) allNormals.push(n8);
         for (const idx of indices) {
           allTriangles.push(idx + vertexOffset);
         }
@@ -4321,9 +4482,9 @@ class BrepkitAdapter {
    * Returns {degree, knots, controlPoints, weights} for NURBS edges.
    */
   extractNurbsFromEdge(shape2) {
-    const h10 = shape2;
-    if (h10.type !== "edge") return null;
-    const nurbsJson = this.bk.getEdgeNurbsData(h10.id);
+    const h7 = shape2;
+    if (h7.type !== "edge") return null;
+    const nurbsJson = this.bk.getEdgeNurbsData(h7.id);
     if (nurbsJson) {
       const data = JSON.parse(nurbsJson);
       return {
@@ -4333,7 +4494,7 @@ class BrepkitAdapter {
         weights: data.weights
       };
     }
-    const verts = this.bk.getEdgeVertices(h10.id);
+    const verts = this.bk.getEdgeVertices(h7.id);
     return {
       degree: 1,
       knots: [0, 0, 1, 1],
@@ -4425,8 +4586,8 @@ class BrepkitAdapter {
    */
   extractPlaneFromFace(faceShape) {
     let faceId;
-    const h10 = faceShape;
-    if (h10.type === "solid" || h10.type === "compound") {
+    const h7 = faceShape;
+    if (h7.type === "solid" || h7.type === "compound") {
       const faces = this.iterShapes(faceShape, "face");
       if (faces.length === 0) throw new Error("brepkit: extractPlaneFromFace: no faces found");
       const firstFace = faces[0];
@@ -4448,8 +4609,8 @@ class BrepkitAdapter {
     } else {
       faceId = unwrap(faceShape, "face");
     }
-    const n7 = this.bk.getFaceNormal(faceId);
-    const normal = [n7[0], n7[1], n7[2]];
+    const n8 = this.bk.getFaceNormal(faceId);
+    const normal = [n8[0], n8[1], n8[2]];
     const mesh2 = this.bk.tessellateFace(faceId, 1);
     const positions = mesh2.positions;
     if (positions.length >= 3) {
@@ -4465,8 +4626,8 @@ class BrepkitAdapter {
     return this.bk.sketchNew();
   }
   /** Add a point to a constraint sketch. Returns the point index. */
-  sketchAddPoint(sketch, x7, y7, fixed) {
-    return this.bk.sketchAddPoint(sketch, x7, y7, fixed);
+  sketchAddPoint(sketch, x6, y6, fixed) {
+    return this.bk.sketchAddPoint(sketch, x6, y6, fixed);
   }
   /** Add a constraint to a sketch (JSON-encoded constraint descriptor). */
   sketchAddConstraint(sketch, constraintJson) {
@@ -4683,17 +4844,75 @@ class BrepkitAdapter {
     return this.bk.executeBatch(json);
   }
 }
-function multiplyMatrices(a9, b9) {
+function multiplyMatrices(a9, b7) {
   const result = new Array(16).fill(0);
   for (let i9 = 0; i9 < 4; i9++) {
-    for (let j7 = 0; j7 < 4; j7++) {
-      for (let k7 = 0; k7 < 4; k7++) {
-        result[i9 * 4 + j7] = result[i9 * 4 + j7] + a9[i9 * 4 + k7] * b9[k7 * 4 + j7];
+    for (let j10 = 0; j10 < 4; j10++) {
+      for (let k9 = 0; k9 < 4; k9++) {
+        result[i9 * 4 + j10] = result[i9 * 4 + j10] + a9[i9 * 4 + k9] * b7[k9 * 4 + j10];
       }
     }
   }
   return result;
 }
+const kernel_ERROR_PATTERNS = [
+  {
+    pattern: /invalid edge configuration|edges?.*(not|fail|invalid)/i,
+    translation: "The edges may not form a continuous loop. Check that edges connect end-to-end without gaps."
+  },
+  {
+    pattern: /BRepAlgoAPI.*failed|boolean.*operation.*failed/i,
+    translation: "Boolean operation failed. Common causes: overlapping faces, zero-thickness geometry, or degenerate shapes. Try healing input shapes first."
+  },
+  {
+    pattern: /fillet.*radius.*too.*large|fillet.*failed/i,
+    translation: "Fillet operation failed. The radius may be too large for the selected edges. Try reducing the radius or check that edges have enough room."
+  },
+  {
+    pattern: /chamfer.*failed|chamfer.*distance.*too.*large/i,
+    translation: "Chamfer operation failed. The distance may be too large for the selected edges. Try reducing the distance or check edge geometry."
+  },
+  {
+    pattern: /shell.*failed|offset.*failed/i,
+    translation: "Shell/offset operation failed. The thickness may be too large, or the shape may have complex geometry. Try reducing thickness."
+  },
+  {
+    pattern: /sweep.*failed|pipe.*failed/i,
+    translation: "Sweep operation failed. Check that the profile and spine are compatible, and that the spine has no sharp twists or self-intersections."
+  },
+  {
+    pattern: /loft.*failed/i,
+    translation: "Loft operation failed. Profiles may be incompatible or have different orientations. Ensure profiles are ordered consistently."
+  },
+  {
+    pattern: /extrude.*failed|prism.*failed/i,
+    translation: "Extrusion failed. The profile may be invalid or self-intersecting. Check that the profile forms a valid closed wire."
+  },
+  {
+    pattern: /revolve.*failed|revolution.*failed/i,
+    translation: "Revolution operation failed. The profile may intersect the axis of revolution, or the angle may be invalid."
+  },
+  {
+    pattern: /self.*intersect|self-intersect/i,
+    translation: "Shape has self-intersections. The operation resulted in overlapping geometry. Simplify the input or adjust parameters."
+  },
+  {
+    pattern: /degener|degenerat/i,
+    translation: "Degenerate geometry detected. The shape has edges or faces with zero length/area. Check input geometry for collapsed elements."
+  },
+  {
+    pattern: /BRepCheck.*fail|shape.*invalid|shape.*not.*valid/i,
+    translation: "Shape validation failed. The resulting shape has invalid topology. Try healing the shape or checking input geometry."
+  }
+];
+function translateKernelError(kernelMessage) {
+  for (const { pattern, translation } of kernel_ERROR_PATTERNS) {
+    if (pattern.test(kernelMessage)) {
+      return `${translation} (kernel: ${kernelMessage})`;
+    }
+  }
+  return kernelMessage;
+}
 const errorFactories = {
   KERNEL_OPERATION: (code, message, cause) => ({ kind: "KERNEL_OPERATION", code, message, cause }),
   VALIDATION: (code, message, cause) => ({ kind: "VALIDATION", code, message, cause }),
@@ -4736,32 +4955,6 @@ function kernelCallScoped(fn, code, message, kind = "KERNEL_OPERATION") {
     __callDispose(_stack, _error, _hasError);
   }
 }
-const CURVE_TYPE_BY_INT = [
-  "LINE",
-  // 0
-  "CIRCLE",
-  // 1
-  "ELLIPSE",
-  // 2
-  "HYPERBOLA",
-  // 3
-  "PARABOLA",
-  // 4
-  "BEZIER_CURVE",
-  // 5
-  "BSPLINE_CURVE",
-  // 6
-  "OFFSET_CURVE",
-  // 7
-  "OTHER_CURVE"
-  // 8
-];
-const findCurveType = (type) => {
-  const idx = typeof type === "number" ? type : Number(type?.value ?? type);
-  const curveType = CURVE_TYPE_BY_INT[idx];
-  if (!curveType) return err(typeCastError("UNKNOWN_CURVE_TYPE", "Unknown curve type"));
-  return ok(curveType);
-};
 const BOPAlgo_GlueShift = 1;
 const BOPAlgo_GlueFull = 2;
 function applyGlue(op, optimisation) {
@@ -4790,27 +4983,6 @@ function isFilletRadius(r9) {
   }
   return false;
 }
-function buildWireFinder(filters) {
-  return createTypedFinder(
-    "wire",
-    filters,
-    buildWireFinder,
-    (_base, withFilter) => ({
-      isClosed: () => withFilter((wire) => curveIsClosed(wire)),
-      isOpen: () => withFilter((wire) => !curveIsClosed(wire)),
-      ofEdgeCount: (count) => withFilter((wire) => {
-        let edgeCount = 0;
-        for (const _raw of iterTopo(wire.wrapped, "edge")) {
-          edgeCount++;
-        }
-        return edgeCount === count;
-      })
-    })
-  );
-}
-function wireFinder() {
-  return buildWireFinder([]);
-}
 function withNearestPostFilter(baseFinder, nearestPoint) {
   const findAllNearest = (shape2) => {
     const candidates = baseFinder.findAll(shape2);
@@ -4863,14 +5035,14 @@ function buildVertexFinder(filters) {
 function vertexFinder() {
   return buildVertexFinder([]);
 }
-function toKernelVec(v8) {
-  return getKernel().createVector3d(v8[0], v8[1], v8[2]);
+function toKernelVec(v6) {
+  return getKernel().createVector3d(v6[0], v6[1], v6[2]);
 }
-function toKernelPnt(v8) {
-  return getKernel().createPoint3d(v8[0], v8[1], v8[2]);
+function toKernelPnt(v6) {
+  return getKernel().createPoint3d(v6[0], v6[1], v6[2]);
 }
-function toKernelDir(v8) {
-  return getKernel().createDirection3d(v8[0], v8[1], v8[2]);
+function toKernelDir(v6) {
+  return getKernel().createDirection3d(v6[0], v6[1], v6[2]);
 }
 function fromKernelVec(ocVec) {
   return [ocVec.X(), ocVec.Y(), ocVec.Z()];
@@ -4881,24 +5053,24 @@ function fromKernelPnt(ocPnt) {
 function fromKernelDir(ocDir) {
   return [ocDir.X(), ocDir.Y(), ocDir.Z()];
 }
-function withKernelVec(v8, fn) {
-  const ocVec = toKernelVec(v8);
+function withKernelVec(v6, fn) {
+  const ocVec = toKernelVec(v6);
   try {
     return fn(ocVec);
   } finally {
     ocVec.delete();
   }
 }
-function withKernelPnt(v8, fn) {
-  const ocPnt = toKernelPnt(v8);
+function withKernelPnt(v6, fn) {
+  const ocPnt = toKernelPnt(v6);
   try {
     return fn(ocPnt);
   } finally {
     ocPnt.delete();
   }
 }
-function withKernelDir(v8, fn) {
-  const ocDir = toKernelDir(v8);
+function withKernelDir(v6, fn) {
+  const ocDir = toKernelDir(v6);
   try {
     return fn(ocDir);
   } finally {
@@ -4955,10 +5127,10 @@ function surfaceFromGrid(heights, options = {}) {
 function buildBSplineSurface(heights, rows, cols, dx, dy, scaleZ) {
   const points = [];
   for (let r9 = 0; r9 < rows; r9++) {
-    for (let c8 = 0; c8 < cols; c8++) {
+    for (let c7 = 0; c7 < cols; c7++) {
       const row = heights[r9];
-      const z6 = (row ? row[c8] ?? 0 : 0) * scaleZ;
-      points.push([c8 * dx, r9 * dy, z6]);
+      const z6 = (row ? row[c7] ?? 0 : 0) * scaleZ;
+      points.push([c7 * dx, r9 * dy, z6]);
     }
   }
   const faceShape = getKernel().bsplineSurface(points, rows, cols);
@@ -4972,10 +5144,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 c8 = 0; c8 < cols; c8++) {
+    for (let c7 = 0; c7 < cols; c7++) {
       const row = heights[r9];
-      const z6 = (row ? row[c8] ?? 0 : 0) * scaleZ;
-      points.push([c8 * dx, r9 * dy, z6]);
+      const z6 = (row ? row[c7] ?? 0 : 0) * scaleZ;
+      points.push([c7 * dx, r9 * dy, z6]);
     }
   }
   const resultShape = getKernel().triangulatedSurface(points, rows, cols);
@@ -5014,13 +5186,13 @@ async function surfaceFromImage(blob, options = {}) {
     );
   }
   const w7 = bitmap.width;
-  const h10 = bitmap.height;
-  if (w7 < 2 || h10 < 2) {
+  const h7 = bitmap.height;
+  if (w7 < 2 || h7 < 2) {
     bitmap.close();
     return err(
       validationError(
         BrepErrorCode.SURFACE_GRID_TOO_SMALL,
-        `surfaceFromImage: image too small (${w7}x${h10}), need at least 2x2`
+        `surfaceFromImage: image too small (${w7}x${h7}), need at least 2x2`
       )
     );
   }
@@ -5033,7 +5205,7 @@ async function surfaceFromImage(blob, options = {}) {
       )
     );
   }
-  const canvas = new OffscreenCanvas(w7, h10);
+  const canvas = new OffscreenCanvas(w7, h7);
   const ctx = canvas.getContext("2d");
   if (!ctx) {
     bitmap.close();
@@ -5043,29 +5215,29 @@ async function surfaceFromImage(blob, options = {}) {
   }
   ctx.drawImage(bitmap, 0, 0);
   bitmap.close();
-  const imageData = ctx.getImageData(0, 0, w7, h10);
+  const imageData = ctx.getImageData(0, 0, w7, h7);
   const data = imageData.data;
   const rows = [];
-  for (let y7 = 0; y7 < h10; y7 += downsample) {
+  for (let y6 = 0; y6 < h7; y6 += downsample) {
     const row = [];
-    for (let x7 = 0; x7 < w7; x7 += downsample) {
-      const idx = (y7 * w7 + x7) * 4;
+    for (let x6 = 0; x6 < w7; x6 += downsample) {
+      const idx = (y6 * w7 + x6) * 4;
       const r9 = data[idx] ?? 0;
-      const g10 = data[idx + 1] ?? 0;
-      const b9 = data[idx + 2] ?? 0;
+      const g11 = data[idx + 1] ?? 0;
+      const b7 = data[idx + 2] ?? 0;
       let value;
       switch (channel) {
         case "r":
           value = r9 / 255;
           break;
         case "g":
-          value = g10 / 255;
+          value = g11 / 255;
           break;
         case "b":
-          value = b9 / 255;
+          value = b7 / 255;
           break;
         default:
-          value = (REC601_R * r9 + REC601_G * g10 + REC601_B * b9) / 255;
+          value = (REC601_R * r9 + REC601_G * g11 + REC601_B * b7) / 255;
           break;
       }
       row.push(value);
@@ -5103,7 +5275,7 @@ function hull(shapes, options = {}) {
   const tolerance = options.tolerance ?? 0.1;
   try {
     const kernel = getKernel();
-    const ocShapes = shapes.map((s6) => s6.wrapped);
+    const ocShapes = shapes.map((s5) => s5.wrapped);
     const resultOc = kernel.hull(ocShapes, tolerance);
     const cast = castShape(resultOc);
     if (!isSolid(cast)) {
@@ -5259,7 +5431,7 @@ function polyhedron(points, faces, options = {}) {
   }
   try {
     const kernel = getKernel();
-    const ptObjs = points.map(([x7, y7, z6]) => ({ x: x7, y: y7, z: z6 }));
+    const ptObjs = points.map(([x6, y6, z6]) => ({ x: x6, y: y6, z: z6 }));
     const resultOc = kernel.buildSolidFromFaces(ptObjs, triangles, tolerance);
     const cast = castShape(resultOc);
     if (!isSolid(cast)) {
@@ -5274,94 +5446,41 @@ function polyhedron(points, faces, options = {}) {
     return err(kernelError(BrepErrorCode.POLYHEDRON_FAILED, `Polyhedron failed: ${raw}`, e8));
   }
 }
-function multiSectionSweep(sections, spine, options) {
-  if (sections.length < 2) {
-    return err(
-      validationError(
-        BrepErrorCode.MULTI_SWEEP_INSUFFICIENT_SECTIONS,
-        `Multi-section sweep requires at least 2 sections, got ${sections.length}`
-      )
-    );
+function extrude$1(face, extrusionVec) {
+  if (getKernel().isNull(face.wrapped)) {
+    return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, "extrude: face is a null shape"));
   }
-  const { solid = true, ruled = false, tolerance = 1e-6 } = options ?? {};
-  const explicitLocations = sections.map((s6) => s6.location);
-  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 ${i9} location ${loc} is out of range [0, 1]`
-        )
-      );
-    }
-  }
-  const definedLocs = explicitLocations.filter((l10) => l10 !== void 0);
-  for (let i9 = 1; i9 < definedLocs.length; i9++) {
-    if ((definedLocs[i9] ?? 0) <= (definedLocs[i9 - 1] ?? 0)) {
-      return err(
-        validationError(
-          BrepErrorCode.MULTI_SWEEP_FAILED,
-          "Section locations must be strictly increasing"
-        )
-      );
-    }
+  if (vecLength(extrusionVec) === 0) {
+    return err(validationError("EXTRUDE_ZERO_VECTOR", "extrude: extrusion vector has zero length"));
   }
   try {
     const kernel = getKernel();
-    const [uFirst, uLast] = kernel.curveParameters(spine.wrapped);
-    const uRange = uLast - uFirst;
-    const params = sections.map((s6, i9) => {
-      if (s6.location !== void 0) {
-        return uFirst + s6.location * uRange;
-      }
-      return uFirst + i9 / (sections.length - 1) * uRange;
-    });
-    const positionedWires = [];
-    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"));
-    }
-    const loftResult = kernel.loftAdvanced(positionedWires, { solid, ruled, tolerance });
-    const result = castShape(loftResult);
-    if (!isShape3D(result)) {
-      return err(
-        typeCastError("MULTI_SWEEP_NOT_3D", "Multi-section sweep did not produce a 3D shape")
-      );
-    }
-    return ok(result);
+    const len = vecLength(extrusionVec);
+    const dir = vecNormalize(extrusionVec);
+    const shape2 = kernel.extrude(face.wrapped, [...dir], len);
+    const downcastShape = kernel.downcast(shape2, "solid");
+    const solid = createSolid(downcastShape);
+    return ok(solid);
   } catch (e8) {
-    const raw = e8 instanceof Error ? e8.message : String(e8);
     return err(
-      kernelError(BrepErrorCode.MULTI_SWEEP_FAILED, `Multi-section sweep failed: ${raw}`, e8)
+      kernelError("EXTRUDE_FAILED", "Extrusion operation failed", e8, {
+        operation: "extrude",
+        vectorLength: vecLength(extrusionVec)
+      })
     );
   }
 }
-function guidedSweep(profile, spine, guides, options = {}) {
-  const { transition = "transformed", solid = true, tolerance } = options;
-  try {
-    const kernel = getKernel();
-    const shellMode = !solid;
-    const auxiliary = guides.length > 0 ? guides[0]?.wrapped : void 0;
-    const sweepResult = kernel.sweepPipeShell(profile.wrapped, spine.wrapped, {
-      transitionMode: transition,
-      ...auxiliary ? { auxiliary } : {},
-      shellMode,
-      ...tolerance !== void 0 ? { tolerance, boundTolerance: tolerance } : {}
-    });
-    const ocShape = typeof sweepResult === "object" && "shape" in sweepResult ? sweepResult.shape : sweepResult;
-    const result = castShape(ocShape);
-    if (!isShape3D(result)) {
-      return err(typeCastError("GUIDED_SWEEP_NOT_3D", "Guided sweep did not produce a 3D shape"));
-    }
-    return ok(result);
-  } catch (e8) {
-    const raw = e8 instanceof Error ? e8.message : String(e8);
-    return err(kernelError(BrepErrorCode.GUIDED_SWEEP_FAILED, `Guided sweep failed: ${raw}`, e8));
+function revolve$1(face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) {
+  if (getKernel().isNull(face.wrapped)) {
+    return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, "revolve: face is a null shape"));
   }
+  const kernel = getKernel();
+  const shape2 = kernel.revolveVec(face.wrapped, [...center], [...direction], angle);
+  const result = castShape(shape2);
+  if (!isShape3D(result)) {
+    return err(typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
+  }
+  return ok(result);
 }
 const EPS = 1e-10;
 function cross2(ax, ay, bx, by) {
@@ -5370,13 +5489,13 @@ function cross2(ax, ay, bx, by) {
 function dot2(ax, ay, bx, by) {
   return ax * bx + ay * by;
 }
-function len2(x7, y7) {
-  return Math.sqrt(x7 * x7 + y7 * y7);
+function len2(x6, y6) {
+  return Math.sqrt(x6 * x6 + y6 * y6);
 }
 function polyAt(poly, i9) {
-  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;
+  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;
@@ -5421,13 +5540,13 @@ 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((p8, i9) => {
-    const b9 = bisector(poly, i9);
+  const nodes = poly.map((p7, i9) => {
+    const b7 = bisector(poly, i9);
     return {
-      x: p8.x,
-      y: p8.y,
-      bx: b9.dx,
-      by: b9.dy,
+      x: p7.x,
+      y: p7.y,
+      bx: b7.dx,
+      by: b7.dy,
       origIdx: i9,
       prev: null,
       next: null,
@@ -5455,26 +5574,26 @@ function lavSize(start) {
   }
   return count;
 }
-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;
+function bisectorIntersectTime(a9, b7) {
+  const ddx = a9.bx - b7.bx;
+  const ddy = a9.by - b7.by;
+  const dxp = b7.x - a9.x;
+  const dyp = b7.y - a9.y;
   if (Math.abs(ddx) < EPS && Math.abs(ddy) < EPS) return null;
-  let t10;
+  let t7;
   if (Math.abs(ddx) > Math.abs(ddy)) {
-    t10 = dxp / ddx;
+    t7 = dxp / ddx;
   } else {
-    t10 = dyp / ddy;
+    t7 = dyp / ddy;
   }
-  if (t10 < EPS) return null;
+  if (t7 < 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(t10 - t22) > 1e-4 * Math.max(1, Math.abs(t10))) return null;
+    if (Math.abs(t7 - t22) > 1e-4 * Math.max(1, Math.abs(t7))) return null;
   }
-  return t10;
+  return t7;
 }
 function raySplitTime(node, eA, eB) {
   const edx = eB.x - eA.x;
@@ -5488,31 +5607,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 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 t7 = -d0 / dRate;
+  if (t7 < EPS) return null;
+  const px = node.x + t7 * node.bx;
+  const py = node.y + t7 * node.by;
+  const ax = eA.x + t7 * eA.bx;
+  const ay = eA.y + t7 * eA.by;
+  const bxx = eB.x + t7 * eB.bx;
+  const byy = eB.y + t7 * eB.by;
   const segDx = bxx - ax;
   const segDy = byy - ay;
   const segL = len2(segDx, segDy);
-  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 t10;
+  if (segL < EPS) return t7;
+  const s5 = dot2(px - ax, py - ay, segDx, segDy) / (segL * segL);
+  if (s5 < -0.01 || s5 > 1.01) return null;
+  return t7;
 }
 function computeEvents(lavNodes) {
   const events = [];
   for (const node of lavNodes) {
     if (!node.active) continue;
-    const t10 = bisectorIntersectTime(node, node.next);
-    if (t10 !== null && t10 > EPS) {
-      const x7 = node.x + t10 * node.bx;
-      const y7 = node.y + t10 * node.by;
-      events.push({ time: t10, x: x7, y: y7, nodeA: node, nodeB: node.next, type: "edge" });
+    const t7 = bisectorIntersectTime(node, node.next);
+    if (t7 !== null && t7 > EPS) {
+      const x6 = node.x + t7 * node.bx;
+      const y6 = node.y + t7 * node.by;
+      events.push({ time: t7, x: x6, y: y6, nodeA: node, nodeB: node.next, type: "edge" });
     }
     if (isLavNodeReflex(node)) {
       let cur = node.next.next;
@@ -5520,16 +5639,16 @@ function computeEvents(lavNodes) {
       while (cur !== node.prev && cur !== node && count < 1e3) {
         const st = raySplitTime(node, cur, cur.next);
         if (st !== null && st > EPS) {
-          const x7 = node.x + st * node.bx;
-          const y7 = node.y + st * node.by;
-          events.push({ time: st, x: x7, y: y7, nodeA: node, nodeB: cur, type: "split" });
+          const x6 = node.x + st * node.bx;
+          const y6 = node.y + st * node.by;
+          events.push({ time: st, x: x6, y: y6, nodeA: node, nodeB: cur, type: "split" });
         }
         cur = cur.next;
         count++;
       }
     }
   }
-  events.sort((a9, b9) => a9.time - b9.time);
+  events.sort((a9, b7) => a9.time - b7.time);
   return events;
 }
 function computeStraightSkeleton(polygon) {
@@ -5537,12 +5656,12 @@ function computeStraightSkeleton(polygon) {
     return { nodes: [], faces: [] };
   }
   const poly = ensureCCW(polygon);
-  const n7 = poly.length;
+  const n8 = poly.length;
   const skeletonNodes = [];
-  const vertexToSkelNodes = Array.from({ length: n7 }, () => []);
+  const vertexToSkelNodes = Array.from({ length: n8 }, () => []);
   const lavNodes = createLav(poly);
   let iterations = 0;
-  const maxIter = n7 * n7 * 2;
+  const maxIter = n8 * n8 * 2;
   while (iterations < maxIter) {
     iterations++;
     const activeStart = lavNodes.find((nd) => nd.active);
@@ -5551,23 +5670,23 @@ function computeStraightSkeleton(polygon) {
     if (sz <= 3) {
       if (sz === 3) {
         const a9 = activeStart;
-        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 b7 = a9.next;
+        const c7 = b7.next;
+        const t7 = bisectorIntersectTime(a9, b7);
+        const time = t7 !== null && t7 > EPS ? t7 : 0;
+        const mx = (a9.x + b7.x + c7.x) / 3 + time * (a9.bx + b7.bx + c7.bx) / 3;
+        const my = (a9.y + b7.y + c7.y) / 3 + time * (a9.by + b7.by + c7.by) / 3;
         const nodeIdx = skeletonNodes.length;
         skeletonNodes.push({ x: mx, y: my, height: time });
         const aNodes = vertexToSkelNodes[a9.origIdx];
-        const bNodes = vertexToSkelNodes[b9.origIdx];
-        const cNodes = vertexToSkelNodes[c8.origIdx];
+        const bNodes = vertexToSkelNodes[b7.origIdx];
+        const cNodes = vertexToSkelNodes[c7.origIdx];
         if (aNodes) aNodes.push(nodeIdx);
         if (bNodes) bNodes.push(nodeIdx);
         if (cNodes) cNodes.push(nodeIdx);
         a9.active = false;
-        b9.active = false;
-        c8.active = false;
+        b7.active = false;
+        c7.active = false;
       } else {
         let cur = activeStart;
         for (let i9 = 0; i9 < sz; i9++) {
@@ -5589,19 +5708,19 @@ function computeStraightSkeleton(polygon) {
     if (!ev) break;
     if (ev.type === "edge") {
       const a9 = ev.nodeA;
-      const b9 = ev.nodeB;
-      if (!a9.active || !b9.active) continue;
+      const b7 = ev.nodeB;
+      if (!a9.active || !b7.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[b9.origIdx];
+      const bNodes = vertexToSkelNodes[b7.origIdx];
       if (aNodes) aNodes.push(nodeIdx);
       if (bNodes) bNodes.push(nodeIdx);
       a9.x = ev.x;
       a9.y = ev.y;
-      a9.next = b9.next;
-      b9.next.prev = a9;
-      b9.active = false;
+      a9.next = b7.next;
+      b7.next.prev = a9;
+      b7.active = false;
       const lavPoly = [];
       let cur = a9;
       do {
@@ -5613,13 +5732,13 @@ function computeStraightSkeleton(polygon) {
       a9.by = bDir.dy;
     } else {
       const a9 = ev.nodeA;
-      const b9 = ev.nodeB;
-      if (!a9.active || !b9.active) continue;
+      const b7 = ev.nodeB;
+      if (!a9.active || !b7.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[b9.origIdx];
+      const bNodes = vertexToSkelNodes[b7.origIdx];
       if (bNodes) bNodes.push(nodeIdx);
       const aCopy = {
         x: ev.x,
@@ -5635,20 +5754,20 @@ function computeStraightSkeleton(polygon) {
       a9.x = ev.x;
       a9.y = ev.y;
       const aNext = a9.next;
-      const bNext = b9.next;
+      const bNext = b7.next;
       a9.next = bNext;
       bNext.prev = a9;
       aCopy.next = aNext;
       aNext.prev = aCopy;
-      aCopy.prev = b9;
-      b9.next = aCopy;
+      aCopy.prev = b7;
+      b7.next = aCopy;
       const buildLavPoly = (start) => {
         const poly2 = [];
-        let c8 = start;
+        let c7 = start;
         do {
-          poly2.push({ x: c8.x, y: c8.y });
-          c8 = c8.next;
-        } while (c8 !== start);
+          poly2.push({ x: c7.x, y: c7.y });
+          c7 = c7.next;
+        } while (c7 !== start);
         return poly2;
       };
       const lav1Poly = buildLavPoly(a9);
@@ -5662,13 +5781,13 @@ function computeStraightSkeleton(polygon) {
     }
   }
   const faces = [];
-  for (let i9 = 0; i9 < n7; i9++) {
-    const j7 = (i9 + 1) % n7;
+  for (let i9 = 0; i9 < n8; i9++) {
+    const j10 = (i9 + 1) % n8;
     const pi = polyAt(poly, i9);
-    const pj = polyAt(poly, j7);
+    const pj = polyAt(poly, j10);
     const faceVerts = [pi, pj];
     const faceHeights = [0, 0];
-    const jNodes = vertexToSkelNodes[j7];
+    const jNodes = vertexToSkelNodes[j10];
     const iNodes = vertexToSkelNodes[i9];
     if (jNodes) {
       for (const ni of jNodes) {
@@ -5680,8 +5799,8 @@ function computeStraightSkeleton(polygon) {
       }
     }
     if (iNodes) {
-      for (let k7 = iNodes.length - 1; k7 >= 0; k7--) {
-        const idx = iNodes[k7];
+      for (let k9 = iNodes.length - 1; k9 >= 0; k9--) {
+        const idx = iNodes[k9];
         if (idx === void 0) continue;
         const sn = skeletonNodes[idx];
         if (!sn) continue;
@@ -5741,29 +5860,29 @@ function pointInTriangle(px, py, ax, ay, bx, by, cx, cy) {
   return !(hasNeg && hasPos);
 }
 function earClipTriangulate(poly) {
-  const n7 = poly.length;
-  if (n7 < 3) return [];
-  if (n7 === 3) return [[0, 1, 2]];
+  const n8 = poly.length;
+  if (n8 < 3) return [];
+  if (n8 === 3) return [[0, 1, 2]];
   let area2 = 0;
-  for (let i9 = 0; i9 < n7; i9++) {
+  for (let i9 = 0; i9 < n8; i9++) {
     const a9 = poly[i9];
-    const b9 = poly[(i9 + 1) % n7];
-    if (a9 && b9) area2 += a9.x * b9.y - b9.x * a9.y;
+    const b7 = poly[(i9 + 1) % n8];
+    if (a9 && b7) area2 += a9.x * b7.y - b7.x * a9.y;
   }
   const tris = [];
-  const idx = Array.from({ length: n7 }, (_2, i9) => i9);
+  const idx = Array.from({ length: n8 }, (_2, i9) => i9);
   if (area2 < 0) idx.reverse();
   const isEar = (prev, curr, next) => {
     const a9 = poly[prev];
-    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;
+    const b7 = poly[curr];
+    const c7 = poly[next];
+    if (!a9 || !b7 || !c7) return false;
+    if (cross2d(a9.x, a9.y, b7.x, b7.y, c7.x, c7.y) <= 0) return false;
     for (const vi of idx) {
       if (vi === prev || vi === curr || vi === next) continue;
-      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;
+      const p7 = poly[vi];
+      if (!p7) continue;
+      if (pointInTriangle(p7.x, p7.y, a9.x, a9.y, b7.x, b7.y, c7.x, c7.y)) return false;
     }
     return true;
   };
@@ -5784,8 +5903,8 @@ function earClipTriangulate(poly) {
     if (!clipped) break;
   }
   if (idx.length === 3) {
-    const [a9, b9, c8] = idx;
-    if (a9 !== void 0 && b9 !== void 0 && c8 !== void 0) tris.push([a9, b9, c8]);
+    const [a9, b7, c7] = idx;
+    if (a9 !== void 0 && b7 !== void 0 && c7 !== void 0) tris.push([a9, b7, c7]);
   }
   return tris;
 }
@@ -5812,9 +5931,9 @@ function roof(w7, options) {
     const triFaces = [];
     for (const skFace of skeleton.faces) {
       const verts3d = skFace.vertices.map(
-        (v8, i9) => [
-          v8.x,
-          v8.y,
+        (v6, i9) => [
+          v6.x,
+          v6.y,
           (skFace.heights[i9] ?? 0) * tanAngle
         ]
       );
@@ -5890,36 +6009,36 @@ function solveConstraints(nodes, constraints) {
     });
   }
   const unsupported = [];
-  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") {
+  for (const c7 of constraints) {
+    if (c7.type === "coincident" && c7.entityA && c7.entityB) {
+      const a9 = c7.entityA;
+      const b7 = c7.entityB;
+      if (a9.entity.type === "plane" && b7.entity.type === "plane") {
         const aNormal = a9.entity.normal ?? [0, 0, 1];
         const aOrigin = a9.entity.origin;
-        const bOrigin = b9.entity.origin;
+        const bOrigin = b7.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(b9.node, { position: pos, rotation: [1, 0, 0, 0] });
+        transforms.set(b7.node, { position: pos, rotation: [1, 0, 0, 0] });
       } else {
-        unsupported.push(`coincident(${a9.entity.type}-${b9.entity.type})`);
+        unsupported.push(`coincident(${a9.entity.type}-${b7.entity.type})`);
       }
-    } 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") {
+    } else if (c7.type === "distance" && c7.entityA && c7.entityB && c7.value !== void 0) {
+      const a9 = c7.entityA;
+      const b7 = c7.entityB;
+      if (a9.entity.type === "plane" && b7.entity.type === "plane") {
         const aNormal = a9.entity.normal ?? [0, 0, 1];
         const aOrigin = a9.entity.origin;
-        const bOrigin = b9.entity.origin;
+        const bOrigin = b7.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 + c8.value;
+        const offset2 = currentDist + c7.value;
         const pos = [offset2 * aNormal[0], offset2 * aNormal[1], offset2 * aNormal[2]];
-        transforms.set(b9.node, { position: pos, rotation: [1, 0, 0, 0] });
+        transforms.set(b7.node, { position: pos, rotation: [1, 0, 0, 0] });
       } else {
-        unsupported.push(`distance(${a9.entity.type}-${b9.entity.type})`);
+        unsupported.push(`distance(${a9.entity.type}-${b7.entity.type})`);
       }
-    } else if (c8.type === "concentric" || c8.type === "angle") {
-      unsupported.push(c8.type);
+    } else if (c7.type === "concentric" || c7.type === "angle") {
+      unsupported.push(c7.type);
     }
   }
   const dof = unsupported.reduce((sum, type) => {
@@ -5939,9 +6058,9 @@ function extractEntity(mate) {
   }
   return null;
 }
-function extractPair(a9, b9) {
+function extractPair(a9, b7) {
   const entA = extractEntity(a9);
-  const entB = extractEntity(b9);
+  const entB = extractEntity(b7);
   if (!entA || !entB) {
     return err(
       validationError(
@@ -5952,7 +6071,7 @@ function extractPair(a9, b9) {
   }
   return ok({
     entityA: { node: a9.node, entity: entA },
-    entityB: { node: b9.node, entity: entB }
+    entityB: { node: b7.node, entity: entB }
   });
 }
 function addMate(assembly, constraint) {
@@ -6042,20 +6161,20 @@ function checkInterference(shape1, shape2, tolerance = 1e-6) {
 }
 function checkAllInterferences(shapes, tolerance = 1e-6) {
   const pairs = [];
-  const boxes = shapes.map((s6) => getBounds(s6));
+  const boxes = shapes.map((s5) => getBounds(s5));
   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));
+    for (let j10 = i9 + 1; j10 < shapes.length; j10++) {
+      if (aabbDisjoint(boxes[i9], boxes[j10], tolerance)) continue;
+      const result = unwrap$1(checkInterference(si, shapes[j10], tolerance));
       if (result.hasInterference) {
-        pairs.push({ i: i9, j: j7, result });
+        pairs.push({ i: i9, j: j10, result });
       }
     }
   });
   return pairs;
 }
-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 aabbDisjoint(a9, b7, tolerance) {
+  return a9.xMax + tolerance < b7.xMin || b7.xMax + tolerance < a9.xMin || a9.yMax + tolerance < b7.yMin || b7.yMax + tolerance < a9.yMin || a9.zMax + tolerance < b7.zMin || b7.zMax + tolerance < a9.zMin;
 }
 function parseEntities(text) {
   const lines = text.split(/\r?\n/);
@@ -6094,10 +6213,10 @@ function parseEntities(text) {
   return entities;
 }
 function getNum(data, code, fallback = 0) {
-  const v8 = data.get(code);
-  if (v8 === void 0) return fallback;
-  const n7 = parseFloat(v8);
-  return isNaN(n7) ? fallback : n7;
+  const v6 = data.get(code);
+  if (v6 === void 0) return fallback;
+  const n8 = parseFloat(v6);
+  return isNaN(n8) ? fallback : n8;
 }
 function entityToEdge(entity) {
   const { type, data } = entity;
@@ -6172,16 +6291,16 @@ async function importOBJ(blob) {
     const line = raw.trim();
     if (line.startsWith("v ")) {
       const parts = line.split(/\s+/);
-      const x7 = parseFloat(parts[1] ?? "");
-      const y7 = parseFloat(parts[2] ?? "");
+      const x6 = parseFloat(parts[1] ?? "");
+      const y6 = parseFloat(parts[2] ?? "");
       const z6 = parseFloat(parts[3] ?? "");
-      if (isNaN(x7) || isNaN(y7) || isNaN(z6)) continue;
-      vertices.push([x7, y7, z6]);
+      if (isNaN(x6) || isNaN(y6) || isNaN(z6)) continue;
+      vertices.push([x6, y6, z6]);
     } else if (line.startsWith("f ")) {
       const parts = line.split(/\s+/).slice(1);
       const indices = [];
-      for (const p8 of parts) {
-        const idx = parseInt(p8.split("/")[0] ?? "", 10);
+      for (const p7 of parts) {
+        const idx = parseInt(p7.split("/")[0] ?? "", 10);
         if (!isNaN(idx)) indices.push(idx);
       }
       if (indices.length >= 3) faces.push(indices);
@@ -6331,7 +6450,7 @@ function parseModelXml(xml) {
 }
 function buildSolidFromMesh(mesh2) {
   const kernel = getKernel();
-  const points = mesh2.vertices.map(([x7, y7, z6]) => ({ x: x7, y: y7, z: z6 }));
+  const points = mesh2.vertices.map(([x6, y6, z6]) => ({ x: x6, y: y6, z: z6 }));
   const faces = mesh2.triangles;
   try {
     const solid = kernel.buildSolidFromFaces(points, faces, 1e-6);
@@ -6390,14 +6509,14 @@ async function importThreeMF(blob) {
     return err(ioError(BrepErrorCode.THREEMF_IMPORT_FAILED, `3MF import failed: ${msg}`, e8));
   }
 }
-function resolve(s6) {
-  if ("__wrapped" in s6) {
-    return s6.val;
+function resolve(s5) {
+  if ("__wrapped" in s5) {
+    return s5.val;
   }
-  return s6;
+  return s5;
 }
-function resolve3D(s6) {
-  return resolve(s6);
+function resolve3D(s5) {
+  return resolve(s5);
 }
 function validateNotNull(shape2, label) {
   if (getKernel().isNull(shape2.wrapped)) {
@@ -6405,20 +6524,6 @@ function validateNotNull(shape2, label) {
   }
   return ok(void 0);
 }
-function collectInputFaceHashes(inputs) {
-  const hasMetadata = inputs.some((s6) => {
-    return getFaceOrigins(s6) !== void 0 || hasFaceTags(s6) || hasColorMetadata(s6);
-  });
-  if (!hasMetadata) return [];
-  const hashes = [];
-  for (const input of inputs) {
-    const faces = getKernel().iterShapes(input.wrapped, "face");
-    for (const face of faces) {
-      hashes.push(face.HashCode(HASH_CODE_MAX));
-    }
-  }
-  return hashes;
-}
 function thicken$1(shape2, thickness) {
   const check = validateNotNull(shape2, "thicken: shape");
   if (isErr(check)) return check;
@@ -6431,9 +6536,7 @@ function thicken$1(shape2, thickness) {
       HASH_CODE_MAX
     );
     const cast = castShape(resultShape);
-    propagateOriginsFromEvolution(evolution, [shape2], cast);
-    propagateFaceTagsFromEvolution(evolution, [shape2], cast);
-    propagateColorsFromEvolution(evolution, [shape2], cast);
+    propagateAllMetadata(evolution, [shape2], cast);
     return ok(cast);
   } catch (e8) {
     const raw = e8 instanceof Error ? e8.message : String(e8);
@@ -6525,9 +6628,7 @@ function fillet$1(shape2, edges, radius) {
     if (!isShape3D(cast)) {
       return err(kernelError(BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape"));
     }
-    propagateOriginsFromEvolution(evolution, [shape2], cast);
-    propagateFaceTagsFromEvolution(evolution, [shape2], cast);
-    propagateColorsFromEvolution(evolution, [shape2], cast);
+    propagateAllMetadata(evolution, [shape2], cast);
     return ok(cast);
   } catch (e8) {
     const raw = e8 instanceof Error ? e8.message : String(e8);
@@ -6614,9 +6715,7 @@ function chamfer$1(shape2, edges, distance) {
     if (!isShape3D(cast)) {
       return err(kernelError(BrepErrorCode.CHAMFER_NOT_3D, "Chamfer result is not a 3D shape"));
     }
-    propagateOriginsFromEvolution(evolution, [shape2], cast);
-    propagateFaceTagsFromEvolution(evolution, [shape2], cast);
-    propagateColorsFromEvolution(evolution, [shape2], cast);
+    propagateAllMetadata(evolution, [shape2], cast);
     return ok(cast);
   } catch (e8) {
     const raw = e8 instanceof Error ? e8.message : String(e8);
@@ -6652,9 +6751,7 @@ function shell$1(shape2, faces, thickness, tolerance = 1e-3) {
     if (!isShape3D(cast)) {
       return err(kernelError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
     }
-    propagateOriginsFromEvolution(evolution, [shape2], cast);
-    propagateFaceTagsFromEvolution(evolution, [shape2], cast);
-    propagateColorsFromEvolution(evolution, [shape2], cast);
+    propagateAllMetadata(evolution, [shape2], cast);
     return ok(cast);
   } catch (e8) {
     const raw = e8 instanceof Error ? e8.message : String(e8);
@@ -6686,17 +6783,15 @@ function offset$1(shape2, distance, tolerance = 1e-6) {
     if (!isShape3D(cast)) {
       return err(kernelError("OFFSET_RESULT_NOT_3D", "Offset result is not a 3D shape"));
     }
-    propagateOriginsFromEvolution(evolution, [shape2], cast);
-    propagateFaceTagsFromEvolution(evolution, [shape2], cast);
-    propagateColorsFromEvolution(evolution, [shape2], cast);
+    propagateAllMetadata(evolution, [shape2], cast);
     return ok(cast);
   } catch (e8) {
     const raw = e8 instanceof Error ? e8.message : String(e8);
     return err(kernelError("OFFSET_FAILED", `Offset operation failed: ${raw}`, e8));
   }
 }
-function translate(shape2, v8) {
-  return translate$1(resolve(shape2), v8);
+function translate(shape2, v6) {
+  return translate$1(resolve(shape2), v6);
 }
 function rotate(shape2, angle, options) {
   const pivotPoint = options?.at;
@@ -6718,14 +6813,14 @@ function applyMatrix(shape2, matrix) {
 function transformCopy(shape2, composed) {
   return transformCopy$1(resolve(shape2), composed);
 }
-function fuse(a9, b9, options) {
-  return fuse$1(resolve(a9), resolve(b9), options);
+function fuse(a9, b7, options) {
+  return fuse$1(resolve(a9), resolve(b7), options);
 }
 function cut(base, tool, options) {
   return cut$1(resolve(base), resolve(tool), options);
 }
-function intersect(a9, b9, options) {
-  return intersect$1(resolve(a9), resolve(b9), options);
+function intersect(a9, b7, options) {
+  return intersect$1(resolve(a9), resolve(b7), options);
 }
 function section(shape2, plane, options) {
   return section$1(resolve(shape2), plane, options);
@@ -6774,24 +6869,24 @@ function normalizeChamferDistance(distance) {
   return { mode: "standard", distance };
 }
 function fillet(shape2, edgesOrRadius, maybeRadius) {
-  const s6 = resolve(shape2);
+  const s5 = resolve(shape2);
   let edges;
   let radius;
   if (maybeRadius !== void 0) {
-    edges = resolveEdges(edgesOrRadius, s6);
+    edges = resolveEdges(edgesOrRadius, s5);
     radius = maybeRadius;
   } else {
     edges = void 0;
     radius = edgesOrRadius;
   }
-  return fillet$1(s6, edges, radius);
+  return fillet$1(s5, edges, radius);
 }
 function chamfer(shape2, edgesOrDistance, maybeDistance) {
-  const s6 = resolve(shape2);
+  const s5 = resolve(shape2);
   let edges;
   let distance;
   if (maybeDistance !== void 0) {
-    edges = resolveEdges(edgesOrDistance, s6);
+    edges = resolveEdges(edgesOrDistance, s5);
     distance = maybeDistance;
   } else {
     edges = void 0;
@@ -6799,20 +6894,20 @@ function chamfer(shape2, edgesOrDistance, maybeDistance) {
   }
   const normalized = normalizeChamferDistance(distance);
   if (normalized.mode === "distAngle") {
-    const selectedEdges = edges ?? getEdges(s6);
+    const selectedEdges = edges ?? getEdges(s5);
     return chamferDistAngle(
-      s6,
+      s5,
       [...selectedEdges],
       normalized.distance,
       normalized.angle
     );
   }
-  return chamfer$1(s6, edges, normalized.distance);
+  return chamfer$1(s5, edges, normalized.distance);
 }
 function shell(shape2, faces, thickness, options) {
-  const s6 = resolve(shape2);
-  const resolvedFaces = resolveFaces(faces, s6);
-  return shell$1(s6, resolvedFaces, thickness, options?.tolerance);
+  const s5 = resolve(shape2);
+  const resolvedFaces = resolveFaces(faces, s5);
+  return shell$1(s5, resolvedFaces, thickness, options?.tolerance);
 }
 function offset(shape2, distance, options) {
   return offset$1(resolve(shape2), distance, options?.tolerance);
@@ -6934,7 +7029,7 @@ function toWire(profile) {
   return profile;
 }
 function drill(shape2, options) {
-  const s6 = resolve(shape2);
+  const s5 = resolve(shape2);
   const { at, radius, axis: rawAxis } = options;
   const axis = rawAxis ?? [0, 0, 1];
   if (radius <= 0) {
@@ -6949,23 +7044,23 @@ function drill(shape2, options) {
   if (options.depth !== void 0) {
     tool = makeCylinder(radius, options.depth, pos, dir);
   } else {
-    const b9 = getBounds(s6);
+    const b7 = getBounds(s5);
     const corners = [
-      [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]
+      [b7.xMin, b7.yMin, b7.zMin],
+      [b7.xMax, b7.yMin, b7.zMin],
+      [b7.xMin, b7.yMax, b7.zMin],
+      [b7.xMax, b7.yMax, b7.zMin],
+      [b7.xMin, b7.yMin, b7.zMax],
+      [b7.xMax, b7.yMin, b7.zMax],
+      [b7.xMin, b7.yMax, b7.zMax],
+      [b7.xMax, b7.yMax, b7.zMax]
     ];
     let tMin = Infinity;
     let tMax = -Infinity;
-    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;
+    for (const c7 of corners) {
+      const t7 = (c7[0] - pos[0]) * dir[0] + (c7[1] - pos[1]) * dir[1] + (c7[2] - pos[2]) * dir[2];
+      if (t7 < tMin) tMin = t7;
+      if (t7 > tMax) tMax = t7;
     }
     const overshoot = 1;
     tMin -= overshoot;
@@ -6974,15 +7069,15 @@ function drill(shape2, options) {
     const startPos = [pos[0] + dir[0] * tMin, pos[1] + dir[1] * tMin, pos[2] + dir[2] * tMin];
     tool = makeCylinder(radius, depth, startPos, dir);
   }
-  return cut$1(s6, tool);
+  return cut$1(s5, tool);
 }
 function pocket(shape2, options) {
-  const s6 = resolve(shape2);
+  const s5 = resolve(shape2);
   const { profile, depth } = options;
   if (depth <= 0) {
     return err(validationError("POCKET_INVALID_DEPTH", "Pocket depth must be positive"));
   }
-  const targetResult = resolveTargetFace(s6, options.face);
+  const targetResult = resolveTargetFace(s5, options.face);
   if (isErr(targetResult)) return targetResult;
   const targetFace = targetResult.value;
   const normal = normalAt(targetFace);
@@ -6992,15 +7087,15 @@ function pocket(shape2, options) {
   const extDir = vecScale(vecNormalize(normal), -depth);
   const toolResult = extrude$1(faceResult.value, extDir);
   if (isErr(toolResult)) return toolResult;
-  return cut$1(s6, toolResult.value);
+  return cut$1(s5, toolResult.value);
 }
 function boss(shape2, options) {
-  const s6 = resolve(shape2);
+  const s5 = resolve(shape2);
   const { profile, height } = options;
   if (height <= 0) {
     return err(validationError("BOSS_INVALID_HEIGHT", "Boss height must be positive"));
   }
-  const targetResult = resolveTargetFace(s6, options.face);
+  const targetResult = resolveTargetFace(s5, options.face);
   if (isErr(targetResult)) return targetResult;
   const targetFace = targetResult.value;
   const normal = normalAt(targetFace);
@@ -7010,17 +7105,17 @@ function boss(shape2, options) {
   const extDir = vecScale(vecNormalize(normal), height);
   const toolResult = extrude$1(faceResult.value, extDir);
   if (isErr(toolResult)) return toolResult;
-  return fuse$1(s6, toolResult.value);
+  return fuse$1(s5, toolResult.value);
 }
 function mirrorJoin(shape2, options) {
-  const s6 = resolve(shape2);
+  const s5 = resolve(shape2);
   const normal = options?.normal ?? [1, 0, 0];
   const planeOrigin = options?.at;
-  const mirrored = mirror$1(s6, normal, planeOrigin);
-  return fuse$1(s6, mirrored);
+  const mirrored = mirror$1(s5, normal, planeOrigin);
+  return fuse$1(s5, mirrored);
 }
 function rectangularPattern(shape2, options) {
-  const s6 = resolve(shape2);
+  const s5 = resolve(shape2);
   const { xDir, xCount, xSpacing, yDir, yCount, ySpacing } = options;
   if (xCount < 1 || yCount < 1) {
     return err(validationError("PATTERN_INVALID_COUNT", "Pattern counts must be at least 1"));
@@ -7031,10 +7126,10 @@ function rectangularPattern(shape2, options) {
   if (vecIsZero(yDir)) {
     return err(validationError("PATTERN_ZERO_DIRECTION", "Y direction cannot be zero"));
   }
-  if (xCount === 1 && yCount === 1) return ok(s6);
+  if (xCount === 1 && yCount === 1) return ok(s5);
   const xNorm = vecNormalize(xDir);
   const yNorm = vecNormalize(yDir);
-  const copies = [s6];
+  const copies = [s5];
   for (let xi = 0; xi < xCount; xi++) {
     for (let yi = 0; yi < yCount; yi++) {
       if (xi === 0 && yi === 0) continue;
@@ -7043,7 +7138,7 @@ function rectangularPattern(shape2, options) {
         xNorm[1] * xSpacing * xi + yNorm[1] * ySpacing * yi,
         xNorm[2] * xSpacing * xi + yNorm[2] * ySpacing * yi
       ];
-      copies.push(translate$1(s6, offset2));
+      copies.push(translate$1(s5, offset2));
     }
   }
   return fuseAll(copies);
@@ -7079,7 +7174,7 @@ function createWrappedBase(val) {
   const self = {
     val,
     __wrapped: true,
-    translate: (v8) => wrapAny(translate(val, v8)),
+    translate: (v6) => wrapAny(translate(val, v6)),
     rotate: (angle, opts) => wrapAny(rotate(val, angle, opts)),
     mirror: (opts) => wrapAny(mirror(val, opts)),
     scale: (factor, opts) => wrapAny(scale(val, factor, opts)),
@@ -7168,8 +7263,8 @@ function createWrappedCurve(val) {
     length: () => curveLength(val),
     startPoint: () => curveStartPoint(val),
     endPoint: () => curveEndPoint(val),
-    pointAt: (t10) => curvePointAt(val, t10),
-    tangentAt: (t10) => curveTangentAt(val, t10),
+    pointAt: (t7) => curvePointAt(val, t7),
+    tangentAt: (t7) => curveTangentAt(val, t7),
     isClosed: () => curveIsClosed(val),
     sweep(spine, opts) {
       if (!isWire(val)) throw new Error("sweep requires a Wire");
@@ -7204,114 +7299,113 @@ function wrapAny(val) {
 function wrap3D(val) {
   return createWrapped3D(val);
 }
-function shape(s6) {
-  if (s6 && typeof s6 === "object" && "face" in s6 && typeof s6.face === "function" && "_defaultOrigin" in s6) {
-    return createWrappedFace(s6.face());
+function shape(s5) {
+  if (s5 && typeof s5 === "object" && "face" in s5 && typeof s5.face === "function" && "_defaultOrigin" in s5) {
+    return createWrappedFace(s5.face());
   }
-  if (s6 && typeof s6 === "object" && "wrapped" in s6) {
-    if (isFace(s6)) return createWrappedFace(s6);
-    if (isShape3D(s6)) return createWrapped3D(s6);
-    if (isEdge(s6) || isWire(s6)) return createWrappedCurve(s6);
-    return createWrappedBase(s6);
+  if (s5 && typeof s5 === "object" && "wrapped" in s5) {
+    if (isFace(s5)) return createWrappedFace(s5);
+    if (isShape3D(s5)) return createWrapped3D(s5);
+    if (isEdge(s5) || isWire(s5)) return createWrappedCurve(s5);
+    return createWrappedBase(s5);
   }
   throw new Error("shape() requires a Sketch or branded shape type");
 }
 export {
   B4 as BaseSketcher2d,
-  B2 as Blueprint,
-  a5 as BlueprintSketcher,
-  c2 as Blueprints,
-  e3 as BoundingBox2d,
-  B as BrepBugError,
+  B3 as Blueprint,
+  a6 as BlueprintSketcher,
+  c3 as Blueprints,
+  d4 as BoundingBox2d,
+  g as BrepBugError,
   BrepErrorCode,
   BrepWrapperError,
   BrepkitAdapter,
-  C4 as CompoundBlueprint,
-  C5 as CompoundSketch,
-  C2 as Curve2D,
-  D as DEG2RAD,
+  C5 as CompoundBlueprint,
+  C6 as CompoundSketch,
+  C4 as Curve2D,
+  D2 as DEG2RAD,
   DisposalScope,
-  D3 as Drawing,
-  a6 as DrawingPen,
-  F3 as FaceSketcher,
+  D4 as Drawing,
+  a7 as DrawingPen,
+  F4 as FaceSketcher,
   HASH_CODE_MAX,
-  O2 as OK,
-  R2 as RAD2DEG,
-  S2 as Sketch,
-  S3 as Sketcher,
-  b6 as Sketches,
-  a4 as addChild,
-  a8 as addHoles,
+  O as OK,
+  R as RAD2DEG,
+  S as Sketch,
+  S2 as Sketcher,
+  b3 as Sketches,
+  a5 as addChild,
+  d7 as addHoles,
   addMate,
-  b5 as addStep,
-  b7 as adjacentFaces,
-  E2 as all,
+  b2 as addStep,
+  e5 as adjacentFaces,
+  h as all,
   a2 as andThen,
   applyGlue,
   applyMatrix,
-  h7 as approximateCurve,
-  M as as2D,
-  N as as3D,
-  l9 as asTopo,
-  d7 as autoHeal,
-  b4 as basicFaceExtrusion,
-  e5 as bezier,
+  i4 as approximateCurve,
+  q as as2D,
+  s as as3D,
+  l8 as asTopo,
+  f7 as autoHeal,
+  g7 as bezier,
   blueprintToDXF,
   boss,
-  f7 as box,
-  g7 as bsplineApprox,
-  b2 as bug,
+  j7 as box,
+  k6 as bsplineApprox,
+  c as bug,
   X as cameraFromPlane,
   Y as cameraLookAt,
   c5 as cast,
   castShape,
-  O as castShape3D,
+  t as castShape3D,
   chamfer,
   chamferDistAngle as chamferDistAngleShape,
   checkAllInterferences,
   checkInterference,
-  j5 as circle,
+  l6 as circle,
   circularPattern,
   m9 as classifyPointOnFace,
   c6 as clearMeshCache,
   clone,
-  a as closedWire,
-  c as collect,
-  d4 as collectShapes,
-  l6 as colorFaces,
-  m6 as colorShape,
-  f3 as complexExtrude,
-  w4 as composeTransforms,
-  k5 as compound,
-  c3 as compoundSketchExtrude,
+  closedWire,
+  j as collect,
+  d3 as collectShapes,
+  j6 as colorFaces,
+  k5 as colorShape,
+  e3 as complexExtrude,
+  n7 as composeTransforms,
+  o6 as compound,
+  c4 as compoundSketchExtrude,
   d6 as compoundSketchFace,
   e4 as compoundSketchLoft,
-  f5 as compoundSketchRevolve,
-  d2 as computationError,
+  f6 as compoundSketchRevolve,
+  d as computationError,
   computeStraightSkeleton,
-  l7 as cone,
-  c7 as cornerFinder,
-  g4 as countNodes,
-  h4 as createAssembly,
-  i3 as createAssemblyNode,
+  p5 as cone,
+  cornerFinder,
+  f4 as countNodes,
+  g3 as createAssembly,
+  h2 as createAssemblyNode,
   createBlueprint,
   Z as createCamera,
-  C as createCompound,
+  e as createCompound,
   d10 as createDistanceQuery,
-  H as createEdge,
-  I as createFace,
-  b as createHandle,
-  j2 as createHistory,
-  d as createKernelHandle,
-  b8 as createMeshCache,
-  c4 as createNamedPlane,
+  m as createEdge,
+  n as createFace,
+  v as createHandle,
+  i as createHistory,
+  w as createKernelHandle,
+  b6 as createMeshCache,
+  a4 as createNamedPlane,
   createOperationRegistry,
-  a7 as createPlane,
-  k2 as createRegistry,
-  P as createShell,
+  c2 as createPlane,
+  j3 as createRegistry,
+  x as createShell,
   createSolid,
   createTaskQueue,
-  E as createVertex,
+  f as createVertex,
   createWire,
   createWorkerClient,
   createWorkerHandler,
@@ -7325,51 +7419,51 @@ export {
   curve2dTangentAt,
   curveEndPoint,
   curveIsClosed,
-  i6 as curveIsPeriodic,
+  j8 as curveIsPeriodic,
   curveLength,
-  j6 as curvePeriod,
+  k7 as curvePeriod,
   curvePointAt,
   curveStartPoint,
   curveTangentAt,
   cut,
   d5 as cut2D,
   cutAll,
-  j3 as cutBlueprints,
-  m7 as cylinder,
+  j4 as cutBlueprints,
+  q5 as cylinder,
   dequeueTask,
   describe,
-  g6 as deserializeDrawing,
-  m4 as deserializeHistory,
+  g5 as deserializeDrawing,
+  k2 as deserializeHistory,
   fromBREP$1 as deserializeShape,
   d8 as downcast,
-  h6 as draw,
-  i4 as drawCircle,
-  j4 as drawEllipse,
+  h4 as draw,
+  i2 as drawCircle,
+  j5 as drawEllipse,
   k4 as drawFaceOutline,
-  l5 as drawParametricFunction,
-  m5 as drawPointsInterpolation,
-  n4 as drawPolysides,
-  o5 as drawProjection,
+  l4 as drawParametricFunction,
+  m6 as drawPointsInterpolation,
+  n5 as drawPolysides,
+  o4 as drawProjection,
   p4 as drawRectangle,
-  q2 as drawRoundedRectangle,
-  r3 as drawSingleCircle,
-  s3 as drawSingleEllipse,
+  q3 as drawRoundedRectangle,
+  r5 as drawSingleCircle,
+  s2 as drawSingleEllipse,
   t4 as drawText,
-  u4 as drawingChamfer,
-  v4 as drawingCut,
-  w3 as drawingFillet,
+  u2 as drawingChamfer,
+  v3 as drawingCut,
+  w4 as drawingFillet,
   x4 as drawingFuse,
   y4 as drawingIntersect,
-  z3 as drawingToSketchOnPlane,
+  z4 as drawingToSketchOnPlane,
   drill,
   edgeFinder,
-  n6 as edgesOfFace,
-  o7 as ellipse,
-  p6 as ellipseArc,
-  q4 as ellipsoid,
+  u3 as edgesOfFace,
+  v4 as ellipse,
+  w5 as ellipseArc,
+  x5 as ellipsoid,
   enqueueTask,
   err,
-  n3 as exportAssemblySTEP,
+  m5 as exportAssemblySTEP,
   exportDXF,
   exportGlb,
   exportGltf,
@@ -7379,60 +7473,61 @@ export {
   f9 as exportSTL,
   exportThreeMF,
   extrude,
-  r7 as face,
+  y5 as face,
   faceCenter,
   faceFinder,
   f8 as faceGeomType,
-  q5 as faceOrientation,
-  s4 as facesOfEdge,
+  q6 as faceOrientation,
+  z5 as facesOfEdge,
   i8 as fill,
-  t8 as filledFace,
+  A5 as filledFace,
   fillet,
-  findCurveType,
-  n5 as findFacesByTag,
-  o3 as findNode,
-  p2 as findStep,
-  f2 as flatMap,
+  y as findCurveType,
+  l5 as findFacesByTag,
+  n4 as findNode,
+  o2 as findStep,
+  l as flatMap,
+  m2 as flatten,
   r8 as flipFaceOrientation,
-  k6 as flipOrientation,
+  l7 as flipOrientation,
   _ as fontMetrics,
   fromBREP,
   fromKernelDir,
   fromKernelPnt,
   fromKernelVec,
-  F as fromNullable,
+  n2 as fromNullable,
   fuse,
-  f4 as fuse2D,
+  f5 as fuse2D,
   fuseAll,
   k3 as fuseBlueprints,
-  g3 as genericSweep,
   getBounds,
   getBounds2D,
-  l8 as getCurveType,
+  g8 as getCurveType,
+  z as getDisposalStats,
   getEdges,
-  o6 as getFaceColor,
-  getFaceOrigins,
-  q3 as getFaceTags,
+  m7 as getFaceColor,
+  g10 as getFaceOrigins,
+  n6 as getFaceTags,
   getFaces,
   $ as getFont,
-  f6 as getHashCode,
-  q as getHistoryShape,
+  g6 as getHashCode,
+  p2 as getHistoryShape,
   getKernel,
-  g8 as getOrientation,
+  b5 as getOrientation,
   getOrientation2D,
-  r6 as getShapeColor,
-  g as getShapeKind,
-  g5 as getSingleFace,
+  o5 as getShapeColor,
+  a as getShapeKind,
+  g4 as getSingleFace,
   getSurfaceType,
-  t7 as getTagMetadata,
+  q4 as getTagMetadata,
   getVertices,
   getWires,
-  guidedSweep,
+  q2 as guidedSweep,
   heal,
-  u6 as healFace,
-  v6 as healSolid,
-  w5 as healWire,
-  x6 as helix,
+  B6 as healFace,
+  C7 as healSolid,
+  D5 as healWire,
+  E5 as helix,
   hull,
   importDXF,
   importIGES,
@@ -7442,73 +7537,74 @@ export {
   importSVG,
   importSVGPathD,
   importThreeMF,
-  Q as initFromOC,
+  A as initFromOC,
   innerWires,
   m8 as interpolateCurve,
   intersect,
-  h5 as intersect2D,
-  l4 as intersectBlueprints,
-  x5 as invalidateShapeCache,
+  h3 as intersect2D,
+  l3 as intersectBlueprints,
+  i6 as invalidateShapeCache,
   ioError,
-  i as is2D,
-  e as is3D,
+  B as is2D,
+  C as is3D,
   isChamferRadius,
-  f as isClosedWire,
-  s5 as isCompSolid,
-  h as isCompound,
+  isClosedWire,
+  s3 as isCompSolid,
+  E as isCompound,
   isDisposeRequest,
   isEdge,
   isEmpty,
-  y5 as isEqualShape,
+  b4 as isEqualShape,
   isErr,
   isErrorResponse,
   isFace,
   isFilletRadius,
   isInitRequest,
   isInside2D,
-  l as isLive,
-  m as isManifoldShell,
+  F as isLive,
+  isManifoldShell,
   isNumber,
-  h2 as isOk,
+  f2 as isOk,
   isOperationRequest,
-  n as isOrientedFace,
+  isOrientedFace,
   a0 as isProjectionPlane,
   isQueueEmpty,
-  i5 as isSameShape,
-  o as isShape1D,
+  i3 as isSameShape,
+  G as isShape1D,
   isShape3D,
   isShell,
   isSolid,
   isSuccessResponse,
   isValid,
-  s as isValidSolid,
-  t as isVertex,
+  isValidSolid,
+  H as isVertex,
   isWire,
-  z4 as iterEdges,
-  A4 as iterFaces,
-  iterTopo,
-  B6 as iterVertices,
-  C6 as iterWires,
+  j9 as iterEdges,
+  k8 as iterFaces,
+  i5 as iterTopo,
+  l9 as iterVertices,
+  m10 as iterWires,
   kernelCall,
   kernelCallRaw,
   kernelCallScoped,
   kernelError,
-  y6 as line,
+  F6 as line,
   linearPattern,
   a1 as loadFont,
   loft,
-  A3 as makeBaseBox,
-  u2 as makePlane,
+  A4 as makeBaseBox,
+  m4 as makePlane,
   a22 as makeProjectedEdges,
-  v as manifoldShell,
-  m2 as map,
-  j as mapErr,
-  l2 as match,
+  manifoldShell,
+  p as map,
+  r as mapBoth,
+  w2 as mapErr,
+  x2 as match,
   measureArea,
   e7 as measureCurvatureAt,
   f10 as measureCurvatureAtMid,
   g9 as measureDistance,
-  h9 as measureLength,
+  h6 as measureLength,
   i7 as measureLinearProps,
   measureSurfaceProps,
   measureVolume,
@@ -7520,169 +7616,169 @@ export {
   mirror2D,
   B5 as mirrorDrawing,
   mirrorJoin,
-  t3 as modifyStep,
-  n2 as moduleInitError,
-  multiSectionSweep,
+  r3 as modifyStep,
+  y2 as moduleInitError,
+  t3 as multiSectionSweep,
   normalAt,
   offset,
-  z5 as offsetFace,
-  o8 as offsetWire2D,
+  G5 as offsetFace,
+  o7 as offsetWire2D,
   ok,
-  G as or,
-  H2 as orElse,
-  o4 as organiseBlueprints,
-  w as orientedFace,
+  z2 as or,
+  A2 as orElse,
+  o3 as organiseBlueprints,
+  orientedFace,
   outerWire,
   pendingCount,
-  I2 as pipeline,
-  p5 as pivotPlane,
+  C2 as pipeline,
+  b as pivotPlane,
   pocket,
-  p7 as pointOnSurface,
-  A5 as polygon,
+  p6 as pointOnSurface,
+  H4 as polygon,
   polyhedron,
   E4 as polysideInnerRadius,
   p3 as polysidesBlueprint,
   a32 as projectEdges,
-  t9 as projectPointOnFace,
+  t6 as projectPointOnFace,
   queryError,
   rectangularPattern,
   registerHandler,
-  R as registerKernel,
-  u3 as registerOperation,
-  v3 as registerShape,
+  I as registerKernel,
+  u as registerOperation,
+  v2 as registerShape,
   rejectAll,
   x3 as removeChild,
-  v7 as removeHolesFromFace,
+  v5 as removeHolesFromFace,
   y3 as replayFrom,
-  z2 as replayHistory,
-  D4 as resize,
+  z3 as replayHistory,
+  J as resetDisposalStats,
+  I4 as resize,
   resolve,
   resolve3D,
-  r4 as resolveDirection,
-  r5 as resolvePlane,
+  r6 as resolveDirection,
+  r2 as resolvePlane,
   reverseCurve,
-  r as revolution,
   revolve,
   roof,
   rotate,
   rotate2D,
-  F4 as rotateDrawing,
-  r2 as roundedRectangleBlueprint,
+  F5 as rotateDrawing,
+  r4 as roundedRectangleBlueprint,
   scale,
   scale2D,
-  G3 as scaleDrawing,
+  G4 as scaleDrawing,
   section,
   sectionToFace,
-  A2 as serializeHistory,
-  E5 as setShapeOrigin,
-  u5 as setTagMetadata,
-  B7 as sewShells,
+  A3 as serializeHistory,
+  s4 as setShapeOrigin,
+  r7 as setTagMetadata,
+  J4 as sewShells,
   shape,
   w6 as shapeType,
-  C7 as sharedEdges,
+  K4 as sharedEdges,
   shell,
   simplify,
   sketch2DOnFace,
   sketch2DOnPlane,
   H3 as sketchCircle,
   I3 as sketchEllipse,
-  J2 as sketchExtrude,
-  K2 as sketchFace,
-  L2 as sketchFaceOffset,
-  M2 as sketchHelix,
+  J3 as sketchExtrude,
+  K3 as sketchFace,
+  L3 as sketchFaceOffset,
+  M3 as sketchHelix,
   N2 as sketchLoft,
-  O3 as sketchParametricFunction,
-  P2 as sketchPolysides,
-  Q2 as sketchRectangle,
-  R3 as sketchRevolve,
+  O2 as sketchParametricFunction,
+  P as sketchPolysides,
+  Q as sketchRectangle,
+  R2 as sketchRevolve,
   T as sketchRoundedRectangle,
   U as sketchSweep,
   a42 as sketchText,
   V as sketchWires,
-  s2 as sketcherStateError,
+  D as sketcherStateError,
   slice,
-  D5 as solid,
+  L4 as solid,
   solveAssembly,
-  E6 as sphere,
+  M4 as sphere,
   split,
-  B3 as stepCount,
+  B2 as stepCount,
   C3 as stepsFrom,
   stretch2D,
-  F5 as subFace,
-  D2 as supportExtrude,
+  N3 as subFace,
+  D3 as supportExtrude,
   supportsConstraintSketch,
   supportsProjection,
   surfaceFromGrid,
   surfaceFromImage,
   sweep,
-  v5 as tagFaces,
-  G4 as tangentArc,
-  J as tap,
-  K as tapErr,
+  t5 as tagFaces,
+  O3 as tangentArc,
+  E2 as tap,
+  F2 as tapErr,
   a52 as textBlueprints,
   a62 as textMetrics,
   thicken,
-  H4 as threePointArc,
+  P2 as threePointArc,
   toBREP,
-  I4 as toBufferGeometryData,
-  J3 as toGroupedBufferGeometryData,
+  Q2 as toBufferGeometryData,
+  R3 as toGroupedBufferGeometryData,
   toKernelVec,
-  K3 as toLineGeometryData,
+  S3 as toLineGeometryData,
   toSVGPathD,
-  t5 as toVec2,
+  a8 as toVec2,
   toVec3,
-  L3 as torus,
+  T2 as torus,
   transformCopy,
   translate,
   translate2D,
   W as translateDrawing,
-  t6 as translatePlane,
-  t2 as tryCatch,
-  p as tryCatchAsync,
+  t2 as translatePlane,
+  G2 as tryCatch,
+  H2 as tryCatchAsync,
   E3 as twistExtrude,
   typeCastError,
-  F2 as undoLast,
-  u as unsupportedError,
+  F3 as undoLast,
+  I2 as unsupportedError,
   unwrap$1 as unwrap,
-  w2 as unwrapErr,
-  x2 as unwrapOr,
-  y2 as unwrapOrElse,
-  G2 as updateNode,
-  u7 as uvBounds,
-  h8 as uvCoordinates,
-  x as validSolid,
+  J2 as unwrapErr,
+  K2 as unwrapOr,
+  L2 as unwrapOrElse,
+  G3 as updateNode,
+  u4 as uvBounds,
+  h5 as uvCoordinates,
+  validSolid,
   validationError,
-  v2 as vecAdd,
-  a3 as vecAngle,
-  b3 as vecCross,
+  a3 as vecAdd,
+  j2 as vecAngle,
+  e2 as vecCross,
   vecDistance,
-  d3 as vecDot,
-  e2 as vecEquals,
+  d2 as vecDot,
+  k as vecEquals,
   vecIsZero,
-  g2 as vecLength,
-  h3 as vecLengthSq,
-  i2 as vecNegate,
+  vecLength,
+  l2 as vecLengthSq,
+  m3 as vecNegate,
   vecNormalize,
-  k as vecProjectToPlane,
-  l3 as vecRepr,
-  m3 as vecRotate,
+  n3 as vecProjectToPlane,
+  o as vecRepr,
+  g2 as vecRotate,
   vecScale,
-  o2 as vecSub,
-  M3 as vertex,
+  f3 as vecSub,
+  U2 as vertex,
   vertexFinder,
   vertexPosition,
-  N3 as verticesOfEdge,
+  V2 as verticesOfEdge,
   walkAssembly,
-  O4 as wire,
-  wireFinder,
-  P3 as wireLoop,
-  Q3 as wiresOfFace,
-  S as withKernel,
+  W2 as wire,
+  w3 as wireFinder,
+  X2 as wireLoop,
+  Y2 as wiresOfFace,
+  K as withKernel,
   withKernelDir,
   withKernelPnt,
   withKernelVec,
-  y as withScope,
-  z as withScopeResult,
-  A as withScopeResultAsync,
-  L as zipResults
+  L as withScope,
+  M as withScopeResult,
+  N as withScopeResultAsync,
+  M2 as zipResults
 };