brepjs 8.3.0 → 8.7.4

package/dist/brepjs.js

@@ -1,44 +1,42 @@
-import { g as getKernel, b as toOcPnt, a as toVec3 } from "./occtBoundary-CoXB2xvx.js";
-import { f, h, i, j, r, c, t, w, k, l } from "./occtBoundary-CoXB2xvx.js";
-import { l as ok, y as translateOcctError, e as err, q as queryError, u as unwrap, x as validationError, B as BrepErrorCode, d as isErr, o as occtError, p as typeCastError } from "./errors-wGhcJMpB.js";
-import { O, a, c as c2, b, f as f2, i as i2, g, m, h as h2, j as j2, k as k2, z, s, t as t2, n, r as r2, v, w as w2 } from "./errors-wGhcJMpB.js";
-import { c as castShape, s as createSolid, p as gcWithScope, h as isShape3D, e as isFace, d as isEdge, m as isWire } from "./shapeTypes-BU2LKv2S.js";
-import { D, q, o, u, a as a2, b as b2, v as v2, r as r3, n as n2, x, g as g2, i as i3, f as f3, j as j3, k as k3, l as l2, t as t3, w as w3 } from "./shapeTypes-BU2LKv2S.js";
+import { g as getKernel, d as toOcPnt, a as toVec3 } from "./occtBoundary-CWzWqBCm.js";
+import { f, h, i, j, r, b, t, w, k, l } from "./occtBoundary-CWzWqBCm.js";
+import { l as ok, y as translateOcctError, e as err, q as queryError, x as validationError, B as BrepErrorCode, o as occtError, i as ioError, d as isErr, p as typeCastError, u as unwrap } from "./errors-Coh_5_19.js";
+import { O, a, c, b as b2, f as f2, g, m, h as h2, j as j2, k as k2, z, s, t as t2, n, r as r2, v, w as w2 } from "./errors-Coh_5_19.js";
+import { c as castShape, e as isFace, j as isShell, k as isSolid, h as isShape3D, n as gcWithScope, u as createSolid, o as createWire, d as isEdge, m as isWire } from "./shapeTypes-D0vfRxWb.js";
+import { D, s as s2, p, q, a as a2, b as b3, y, t as t3, z as z2, g as g2, i as i2, f as f3, l as l2, r as r3, w as w3 } from "./shapeTypes-D0vfRxWb.js";
 import { c as vecDistance, D as DEG2RAD, n as vecScale, j as vecNormalize, f as vecIsZero } from "./vecOps-ZDdZWbwT.js";
-import { H, R, v as v3, a as a3, b as b3, d, e, g as g3, h as h3, i as i4, k as k4, l as l3, m as m2, o as o2 } from "./vecOps-ZDdZWbwT.js";
-import { a as addHolesInFace, m as makeFace, b as makeNonPlanarFace, c as makePolygon, d as makeNewFaceWithinFace } from "./Blueprint-CdVaHDSx.js";
-import { B, e as e2, C, f as f4, g as g4 } from "./Blueprint-CdVaHDSx.js";
-import { c as curveIsClosed, a as curveTangentAt, b as curvePointAt, d as curveEndPoint, e as curveStartPoint, f as curveLength } from "./curveFns-CyHyk29c.js";
-import { g as g5, h as h4, i as i5, j as j4, k as k5, l as l4, m as m3, n as n3, o as o3 } from "./curveFns-CyHyk29c.js";
-import { m as makeCompound, a as makeCone, b as makeCylinder, c as makeEllipsoid, d as makeOffset, w as weldShellsAndFaces, e as makeSolid, f as makeSphere, g as makeTorus, h as makeVertex } from "./loft-BHn7GKm8.js";
-import { i as i6, j as j5, r as r4 } from "./loft-BHn7GKm8.js";
-import { e as extrude$1, r as revolve$1, s as sweep, c as circularPattern, l as linearPattern } from "./operations-B314mytX.js";
-import { a as a4, b as b4, d as d2, f as f5, g as g6, h as h5, i as i7, j as j6, k as k6, m as m4, n as n4, o as o4, p, q as q2, t as t4, u as u2, v as v4, w as w4, x as x2, y, z as z2, A, B as B2, C as C2, D as D2, E } from "./operations-B314mytX.js";
-import { B as B3, a as a5, b as b5, C as C3, F, S, c as c3, d as d3, f as f6, e as e3, i as i8, g as g7, o as o5, p as p2, r as r5 } from "./boolean2D-DzA0STqC.js";
+import { H, R, v as v2, a as a3, b as b4, d, e, g as g3, h as h3, i as i3, k as k3, l as l3, m as m2, o } from "./vecOps-ZDdZWbwT.js";
+import { B, d as d2, C, r as r4, t as t4 } from "./Blueprint-Cmh8lKc4.js";
+import { e as curveIsClosed, d as curveStartPoint, c as curveTangentAt, h as curvePointAt, a as curveEndPoint, i as curveLength } from "./curveFns-B85Glnfo.js";
+import { j as j3, k as k4, l as l4, f as f4, m as m3, b as b5, g as g4, n as n2, o as o2 } from "./curveFns-B85Glnfo.js";
+import { m as makeCompound, d as makeCone, e as makeCylinder, f as makeEllipsoid, h as makeOffset, w as weldShellsAndFaces, a as makeSolid, i as makeSphere, j as makeTorus, k as makeVertex } from "./loft-CJMPx1NQ.js";
+import { b as b6, g as g5, r as r5 } from "./loft-CJMPx1NQ.js";
+import { w as walkAssembly, e as extrude$1, r as revolve$1, s as sweep, c as circularPattern, l as linearPattern } from "./operations-DiXo_4t9.js";
+import { a as a4, b as b7, d as d3, f as f5, g as g6, h as h4, i as i4, j as j4, k as k5, m as m4, n as n3, o as o3, p as p2, q as q2, t as t5, u, v as v3, x, y as y2, z as z3, A, B as B2, C as C2, D as D2, E } from "./operations-DiXo_4t9.js";
+import { B as B3, a as a5, e as e2, C as C3, F, S, f as f6, l as l5, g as g7, n as n4, k as k6, q as q3, o as o4, p as p3, r as r6 } from "./boolean2D-D94Axs3i.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 { c as createTypedFinder, f as faceFinder } from "./helpers-r_e-u1JM.js";
-import { g as g8 } from "./helpers-r_e-u1JM.js";
+import { l as createTypedFinder, m as faceFinder } from "./helpers-SksQIreB.js";
+import { g as g8 } from "./helpers-SksQIreB.js";
 import { blueprintToDXF, exportDXF, exportGlb, exportGltf, exportOBJ, exportThreeMF, importIGES, importSTEP, importSTL, importSVG, importSVGPathD } from "./io.js";
-import { C as C4, D as D3, a as a6, S as S2, b as b6, X, Y, c as c4, d as d4, e as e4, f as f7, Z, g as g9, h as h6, i as i9, j as j7, k as k7, l as l5, m as m5, n as n5, o as o6, p as p3, q as q3, r as r6, s as s2, t as t5, u as u3, v as v5, w as w5, x as x3, y as y2, z as z3, _, $, a0, A as A2, a1, B as B4, E as E2, a2 as a22, F as F2, G, H as H2, I, J, K, L, M, N, O as O2, P, Q, R as R2, T, U, a3 as a32, V, a4 as a42, W } from "./drawFns-CAAE4Z88.js";
-import { c as c5, a as a7, p as p4, r as r7, t as t6 } from "./vectors-BhfKwL9J.js";
-import { v as vertexPosition, t as translate$1, c as getEdges, p as propagateOrigins, d as applyMatrix$1, e as clone$1, f as describe$1, h as isEmpty$1, m as mirror$1, r as rotate$1, s as scale$1, j as simplify$1, k as toBREP$1, l as transformCopy$1, n as getBounds, o as getFaces, q as getVertices, u as getWires } from "./shapeFns-CWd_ASDV.js";
-import { w as w6, g as g10, b as b7, x as x4, i as i10, y as y3, z as z4, A as A3, B as B5, C as C5 } from "./shapeFns-CWd_ASDV.js";
-import { c as chamferDistAngle, h as heal$1, i as isValid$1 } from "./topology-BupialMm.js";
-import { a as a8, b as b8, e as e5, f as f8, d as d5, g as g11, j as j8, s as s3, t as t7, k as k8, l as l6, v as v6, w as w7 } from "./topology-BupialMm.js";
-import { n as normalAt, f as faceCenter, i as innerWires, o as outerWire, g as getSurfaceType } from "./faceFns-ub3CugDN.js";
-import { c as c6, a as a9, b as b9, d as d6, p as p5, e as e6, u as u4, h as h7 } from "./faceFns-ub3CugDN.js";
-import { m as mesh$1, a as meshEdges$1 } from "./meshFns-BEvGVcym.js";
-import { c as c7, b as b10, e as e7, d as d7, f as f9 } from "./meshFns-BEvGVcym.js";
-import { c as cut$1, f as fuse$1, i as intersect$1, s as section$1, a as slice$1, b as split$1, d as fuseAll, e as cutAll } from "./booleanFns-BcQUqjUu.js";
-import { g as g12 } from "./booleanFns-BcQUqjUu.js";
-import { m as measureArea, a as measureSurfaceProps, b as measureVolumeProps, c as measureVolume } from "./measurement-BfhEneUl.js";
-import { d as d8, e as e8, f as f10, g as g13, h as h8, i as i11 } from "./measurement-BfhEneUl.js";
-import { c as makeBezierCurve, d as makeBSplineApproximation, e as makeCircle, f as makeEllipse, g as makeEllipseArc, b as makeHelix, m as makeLine, h as makeTangentArc, i as makeThreePointArc, a as assembleWire } from "./curveBuilders-CN72XaIQ.js";
-import { i as iterTopo, f as fromBREP$1 } from "./cast-D0OhP1nV.js";
-import { e as e9, c as c8, d as d9, g as g14, s as s4 } from "./cast-D0OhP1nV.js";
+import { C as C4, D as D3, a as a6, S as S2, b as b8, X, Y, c as c2, d as d4, e as e3, f as f7, Z, g as g9, h as h5, i as i5, j as j5, k as k7, l as l6, m as m5, n as n5, o as o5, p as p4, q as q4, r as r7, s as s3, t as t6, u as u2, v as v4, w as w4, x as x2, y as y3, z as z4, _, $, a0, a1, A as A2, a2 as a22, B as B4, E as E2, a3 as a32, F as F2, G, H as H2, I, J, K, L, M, N, O as O2, P, Q, R as R2, T, U, a4 as a42, V, a5 as a52, a6 as a62, W } from "./drawFns-B-gJ2WUc.js";
+import { c as c3, a as a7, p as p5, r as r8, t as t7 } from "./vectors-CZV4ZrTz.js";
+import { v as vertexPosition, a as getFaces, f as getVertices, d as getEdges, t as translate$1, p as propagateOrigins, h as applyMatrix$1, j as clone$1, k as describe$1, l as isEmpty$1, m as mirror$1, r as rotate$1, s as scale$1, n as simplify$1, o as toBREP$1, q as transformCopy$1, u as getBounds, c as getWires } from "./shapeFns-4ioRrhih.js";
+import { w as w5, g as g10, e as e4, x as x3, i as i6, y as y4, z as z5, A as A3, B as B5, C as C5, D as D4 } from "./shapeFns-4ioRrhih.js";
+import { p as propagateFaceTags, a as propagateColors, c 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-DdjtpcM6.js";
+import { j as j6, k as k8, l as l7, m as m6, n as n6, o as o6, q as q5, r as r9, t as t8, u as u3 } from "./booleanFns-DdjtpcM6.js";
+import { c as chamferDistAngle, h as heal$1, i as isValid$1 } from "./topology-DRP9zreU.js";
+import { a as a8, b as b9, e as e5, f as f8, d as d5, g as g11, j as j7, s as s4, t as t9, k as k9, l as l8, v as v5, w as w6 } from "./topology-DRP9zreU.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-CltrEfOo.js";
+import { l as l9, c as c4, m as m7, d as d6, f as f9, q as q6, r as r10, s as s5, p as p6, t as t10, v as v6, u as u4, h as h6 } from "./faceFns-CltrEfOo.js";
+import { m as mesh$1, a as meshEdges$1 } from "./meshFns-D2gLyLFt.js";
+import { c as c5, b as b10, e as e6, d as d7, f as f10 } from "./meshFns-D2gLyLFt.js";
+import { m as measureArea, a as measureSurfaceProps, b as measureVolumeProps, c as measureVolume } from "./measurement-ByOztLxb.js";
+import { d as d8, e as e7, f as f11, g as g12, h as h7, i as i7 } from "./measurement-ByOztLxb.js";
+import { h as addHolesInFace, g as makeBezierCurve, k as makeBSplineApproximation, i as makeCircle, j as makeEllipse, f as makeEllipseArc, m as makeFace, n as makeNonPlanarFace, c as makeHelix, a as makeLine, o as makePolygon, l as makeNewFaceWithinFace, e as makeTangentArc, d as makeThreePointArc, b as assembleWire } from "./surfaceBuilders-B7Jxob8g.js";
+import { p as p7 } from "./surfaceBuilders-B7Jxob8g.js";
 import { edgeFinder } from "./query.js";
 import { BrepBugError, bug } from "./result.js";
-import { c as c9 } from "./cornerFinder-DvPiz-VR.js";
+import { c as c6 } from "./cornerFinder-BBOYfsXl.js";
 import { createOperationRegistry, createTaskQueue, createWorkerClient, createWorkerHandler, dequeueTask, enqueueTask, isDisposeRequest, isErrorResponse, isInitRequest, isOperationRequest, isQueueEmpty, isSuccessResponse, pendingCount, registerHandler, rejectAll } from "./worker.js";
 const errorFactories = {
   OCCT_OPERATION: (code, message, cause) => ({ kind: "OCCT_OPERATION", code, message, cause }),
@@ -53,36 +51,36 @@ const errorFactories = {
 function kernelCall(fn, code, message, kind = "OCCT_OPERATION") {
   try {
     return ok(castShape(fn()));
-  } catch (e10) {
-    const rawMessage = e10 instanceof Error ? e10.message : String(e10);
+  } catch (e8) {
+    const rawMessage = e8 instanceof Error ? e8.message : String(e8);
     const translatedMessage = kind === "OCCT_OPERATION" ? translateOcctError(rawMessage) : rawMessage;
-    return err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e10));
+    return err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e8));
   }
 }
 function kernelCallRaw(fn, code, message, kind = "OCCT_OPERATION") {
   try {
     return ok(fn());
-  } catch (e10) {
-    const rawMessage = e10 instanceof Error ? e10.message : String(e10);
+  } catch (e8) {
+    const rawMessage = e8 instanceof Error ? e8.message : String(e8);
     const translatedMessage = kind === "OCCT_OPERATION" ? translateOcctError(rawMessage) : rawMessage;
-    return err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e10));
+    return err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e8));
   }
 }
-function isNumber(r8) {
-  return typeof r8 === "number";
+function isNumber(r11) {
+  return typeof r11 === "number";
 }
-function isChamferRadius(r8) {
-  if (typeof r8 === "number") return true;
-  if (typeof r8 === "object" && r8 !== null) {
-    const obj = r8;
+function isChamferRadius(r11) {
+  if (typeof r11 === "number") return true;
+  if (typeof r11 === "object" && r11 !== null) {
+    const obj = r11;
     return "distances" in obj && Array.isArray(obj["distances"]) && "selectedFace" in obj || "distance" in obj && "angle" in obj && "selectedFace" in obj;
   }
   return false;
 }
-function isFilletRadius(r8) {
-  if (typeof r8 === "number") return true;
-  if (Array.isArray(r8) && r8.length === 2) {
-    return r8.every(isNumber);
+function isFilletRadius(r11) {
+  if (typeof r11 === "number") return true;
+  if (Array.isArray(r11) && r11.length === 2) {
+    return r11.every(isNumber);
   }
   return false;
 }
@@ -113,11 +111,11 @@ function withNearestPostFilter(baseFinder, nearestPoint) {
     if (candidates.length === 0) return [];
     let bestIdx = 0;
     let bestDist = vecDistance(vertexPosition(candidates[0]), nearestPoint);
-    for (let i12 = 1; i12 < candidates.length; i12++) {
-      const d10 = vecDistance(vertexPosition(candidates[i12]), nearestPoint);
-      if (d10 < bestDist) {
-        bestDist = d10;
-        bestIdx = i12;
+    for (let i8 = 1; i8 < candidates.length; i8++) {
+      const d9 = vecDistance(vertexPosition(candidates[i8]), nearestPoint);
+      if (d9 < bestDist) {
+        bestDist = d9;
+        bestIdx = i8;
       }
     }
     return [candidates[bestIdx]];
@@ -159,6 +157,1228 @@ function buildVertexFinder(filters) {
 function vertexFinder() {
   return buildVertexFinder([]);
 }
+function surfaceFromGrid(heights, options = {}) {
+  if (heights.length < 2) {
+    return err(
+      validationError(
+        BrepErrorCode.SURFACE_GRID_TOO_SMALL,
+        `surfaceFromGrid: need at least 2 rows, got ${heights.length}`
+      )
+    );
+  }
+  const rows = heights.length;
+  const cols = heights[0]?.length ?? 0;
+  if (cols < 2) {
+    return err(
+      validationError(
+        BrepErrorCode.SURFACE_GRID_TOO_SMALL,
+        `surfaceFromGrid: need at least 2 columns, got ${cols}`
+      )
+    );
+  }
+  for (let r11 = 0; r11 < rows; r11++) {
+    const row = heights[r11];
+    if (!row || row.length !== cols) {
+      return err(
+        validationError(
+          BrepErrorCode.SURFACE_GRID_JAGGED,
+          `surfaceFromGrid: row ${r11} has ${row?.length ?? 0} columns, expected ${cols}`
+        )
+      );
+    }
+  }
+  const { width = cols - 1, depth = rows - 1, scaleZ = 1 } = options;
+  const dx = width / (cols - 1);
+  const dy = depth / (rows - 1);
+  try {
+    return buildBSplineSurface(heights, rows, cols, dx, dy, scaleZ);
+  } catch {
+  }
+  try {
+    return buildTriangulatedSurface(heights, rows, cols, dx, dy, scaleZ);
+  } catch (e8) {
+    const raw = e8 instanceof Error ? e8.message : String(e8);
+    return err(occtError(BrepErrorCode.SURFACE_FAILED, `surfaceFromGrid failed: ${raw}`, e8));
+  }
+}
+function buildBSplineSurface(heights, rows, cols, dx, dy, scaleZ) {
+  const oc = getKernel().oc;
+  const OC = oc;
+  const pntArray = new OC.TColgp_Array2OfPnt_2(1, rows, 1, cols);
+  try {
+    for (let r11 = 0; r11 < rows; r11++) {
+      for (let c7 = 0; c7 < cols; c7++) {
+        const row = heights[r11];
+        const z6 = (row ? row[c7] ?? 0 : 0) * scaleZ;
+        const pnt = new oc.gp_Pnt_3(c7 * dx, r11 * dy, z6);
+        pntArray.SetValue(r11 + 1, c7 + 1, pnt);
+        pnt.delete();
+      }
+    }
+    const fitter = new OC.GeomAPI_PointsToBSplineSurface_2(pntArray, 3, 8, 0, 1e-3);
+    const surface = fitter.Surface();
+    const faceMaker = new OC.BRepBuilderAPI_MakeFace_8(surface, 1e-6);
+    let result;
+    if (faceMaker.IsDone()) {
+      const shape2 = castShape(faceMaker.Face());
+      if (isFace(shape2)) {
+        result = ok(shape2);
+      } else {
+        shape2[Symbol.dispose]();
+        result = err(
+          occtError(BrepErrorCode.SURFACE_FAILED, "B-spline surface did not produce a face")
+        );
+      }
+    } else {
+      result = err(
+        occtError(
+          BrepErrorCode.SURFACE_FAILED,
+          "BRepBuilderAPI_MakeFace failed for B-spline surface"
+        )
+      );
+    }
+    faceMaker.delete();
+    fitter.delete();
+    return result;
+  } finally {
+    pntArray.delete();
+  }
+}
+function buildTriangulatedSurface(heights, rows, cols, dx, dy, scaleZ) {
+  const oc = getKernel().oc;
+  function pt(r11, c7) {
+    const row = heights[r11];
+    const z6 = (row ? row[c7] ?? 0 : 0) * scaleZ;
+    return { x: c7 * dx, y: r11 * dy, z: z6 };
+  }
+  function buildTriFace2(a9, b11, c7) {
+    const gpA = new oc.gp_Pnt_3(a9.x, a9.y, a9.z);
+    const gpB = new oc.gp_Pnt_3(b11.x, b11.y, b11.z);
+    const gpC = new oc.gp_Pnt_3(c7.x, c7.y, c7.z);
+    const e1 = new oc.BRepBuilderAPI_MakeEdge_3(gpA, gpB);
+    const e22 = new oc.BRepBuilderAPI_MakeEdge_3(gpB, gpC);
+    const e32 = new oc.BRepBuilderAPI_MakeEdge_3(gpC, gpA);
+    const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+    wireBuilder.Add_1(e1.Edge());
+    wireBuilder.Add_1(e22.Edge());
+    wireBuilder.Add_1(e32.Edge());
+    let face2 = null;
+    if (wireBuilder.IsDone()) {
+      const makeFace2 = new oc.BRepBuilderAPI_MakeFace_15(wireBuilder.Wire(), false);
+      if (makeFace2.IsDone()) {
+        face2 = makeFace2.Face();
+      }
+      makeFace2.delete();
+    }
+    wireBuilder.delete();
+    e1.delete();
+    e22.delete();
+    e32.delete();
+    gpA.delete();
+    gpB.delete();
+    gpC.delete();
+    return face2;
+  }
+  const sewing = new oc.BRepBuilderAPI_Sewing(1e-6, true, true, true, false);
+  let faceCount = 0;
+  try {
+    for (let r11 = 0; r11 < rows - 1; r11++) {
+      for (let c7 = 0; c7 < cols - 1; c7++) {
+        const p00 = pt(r11, c7);
+        const p10 = pt(r11 + 1, c7);
+        const p11 = pt(r11 + 1, c7 + 1);
+        const p01 = pt(r11, c7 + 1);
+        const f1 = buildTriFace2(p00, p10, p11);
+        if (f1 !== null) {
+          sewing.Add(f1);
+          faceCount++;
+        }
+        const f22 = buildTriFace2(p00, p11, p01);
+        if (f22 !== null) {
+          sewing.Add(f22);
+          faceCount++;
+        }
+      }
+    }
+    if (faceCount === 0) {
+      sewing.delete();
+      return err(
+        occtError(BrepErrorCode.SURFACE_FAILED, "surfaceFromGrid: no valid triangular faces built")
+      );
+    }
+    const sewProgress = new oc.Message_ProgressRange_1();
+    sewing.Perform(sewProgress);
+    sewProgress.delete();
+    const sewn = sewing.SewedShape();
+    const shape2 = castShape(sewn);
+    if (isFace(shape2)) {
+      return ok(shape2);
+    }
+    if (isShell(shape2)) {
+      return ok(shape2);
+    }
+    shape2[Symbol.dispose]();
+    return err(
+      occtError(BrepErrorCode.SURFACE_FAILED, "surfaceFromGrid: unexpected shape type from sewing")
+    );
+  } finally {
+    sewing.delete();
+  }
+}
+async function surfaceFromImage(blob, options = {}) {
+  const channel = options.channel ?? "luminance";
+  const downsample = Math.max(1, Math.round(options.downsample ?? 1));
+  if (typeof createImageBitmap !== "function") {
+    return err(
+      ioError(
+        BrepErrorCode.SURFACE_FAILED,
+        "surfaceFromImage requires createImageBitmap (not available in this environment)"
+      )
+    );
+  }
+  let bitmap;
+  try {
+    bitmap = await createImageBitmap(blob);
+  } catch (e8) {
+    return err(
+      ioError(
+        BrepErrorCode.SURFACE_FAILED,
+        `surfaceFromImage: failed to decode image — ${e8 instanceof Error ? e8.message : String(e8)}`
+      )
+    );
+  }
+  const w7 = bitmap.width;
+  const h8 = bitmap.height;
+  if (w7 < 2 || h8 < 2) {
+    bitmap.close();
+    return err(
+      validationError(
+        BrepErrorCode.SURFACE_GRID_TOO_SMALL,
+        `surfaceFromImage: image too small (${w7}x${h8}), need at least 2x2`
+      )
+    );
+  }
+  if (typeof OffscreenCanvas !== "function") {
+    bitmap.close();
+    return err(
+      ioError(
+        BrepErrorCode.SURFACE_FAILED,
+        "surfaceFromImage requires OffscreenCanvas (not available in this environment)"
+      )
+    );
+  }
+  const canvas = new OffscreenCanvas(w7, h8);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    bitmap.close();
+    return err(
+      ioError(BrepErrorCode.SURFACE_FAILED, "surfaceFromImage: could not get 2D canvas context")
+    );
+  }
+  ctx.drawImage(bitmap, 0, 0);
+  bitmap.close();
+  const imageData = ctx.getImageData(0, 0, w7, h8);
+  const data = imageData.data;
+  const rows = [];
+  for (let y5 = 0; y5 < h8; y5 += downsample) {
+    const row = [];
+    for (let x4 = 0; x4 < w7; x4 += downsample) {
+      const idx = (y5 * w7 + x4) * 4;
+      const r11 = data[idx] ?? 0;
+      const g13 = data[idx + 1] ?? 0;
+      const b11 = data[idx + 2] ?? 0;
+      let value;
+      switch (channel) {
+        case "r":
+          value = r11 / 255;
+          break;
+        case "g":
+          value = g13 / 255;
+          break;
+        case "b":
+          value = b11 / 255;
+          break;
+        default:
+          value = (0.299 * r11 + 0.587 * g13 + 0.114 * b11) / 255;
+          break;
+      }
+      row.push(value);
+    }
+    rows.push(row);
+  }
+  const gridOpts = {};
+  if (options.width !== void 0) gridOpts.width = options.width;
+  if (options.depth !== void 0) gridOpts.depth = options.depth;
+  if (options.scaleZ !== void 0) gridOpts.scaleZ = options.scaleZ;
+  return surfaceFromGrid(rows, gridOpts);
+}
+function validateNotNull$1(shape2, label) {
+  if (shape2.wrapped.IsNull()) {
+    return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
+  }
+  return ok(void 0);
+}
+function hull(shapes, options = {}) {
+  if (shapes.length === 0) {
+    return err(
+      validationError(
+        BrepErrorCode.HULL_EMPTY_INPUT,
+        "hull: at least one shape is required",
+        void 0,
+        void 0,
+        "Provide one or more shapes to compute a convex hull"
+      )
+    );
+  }
+  for (const [i8, shape2] of shapes.entries()) {
+    const check = validateNotNull$1(shape2, `hull: shapes[${i8}]`);
+    if (isErr(check)) return check;
+  }
+  const tolerance = options.tolerance ?? 0.1;
+  try {
+    const kernel = getKernel();
+    const ocShapes = shapes.map((s6) => s6.wrapped);
+    const resultOc = kernel.hull(ocShapes, tolerance);
+    const cast = castShape(resultOc);
+    if (!isSolid(cast)) {
+      return err(
+        occtError(BrepErrorCode.HULL_NOT_3D, "Hull result is not a solid; input may be degenerate")
+      );
+    }
+    return ok(cast);
+  } catch (e8) {
+    const raw = e8 instanceof Error ? e8.message : String(e8);
+    if (raw.includes("coplanar") || raw.includes("fewer than") || raw.includes("degenerate")) {
+      return err(occtError(BrepErrorCode.HULL_DEGENERATE, `Hull degenerate: ${raw}`, e8));
+    }
+    return err(occtError(BrepErrorCode.HULL_FAILED, `Hull operation failed: ${raw}`, e8));
+  }
+}
+function detectSphere(shape2) {
+  const oc = getKernel().oc;
+  const faces = getFaces(shape2);
+  if (faces.length !== 1) return null;
+  const face2 = faces[0];
+  const r11 = gcWithScope();
+  const adaptor = r11(new oc.BRepAdaptor_Surface_2(face2.wrapped, true));
+  const surfType = adaptor.GetType();
+  if (surfType !== oc.GeomAbs_SurfaceType.GeomAbs_Sphere) return null;
+  const ocSphere = adaptor.Sphere();
+  const radius = ocSphere.Radius();
+  ocSphere.delete();
+  return radius;
+}
+function minkowskiSphere(shape2, radius, tolerance) {
+  const oc = getKernel().oc;
+  const r11 = gcWithScope();
+  try {
+    const offsetMaker = r11(new oc.BRepOffsetAPI_MakeOffsetShape());
+    const progress = r11(new oc.Message_ProgressRange_1());
+    offsetMaker.PerformByJoin(
+      shape2.wrapped,
+      radius,
+      tolerance,
+      oc.BRepOffset_Mode.BRepOffset_Skin,
+      false,
+      false,
+      oc.GeomAbs_JoinType.GeomAbs_Arc,
+      false,
+      progress
+    );
+    const resultShape = offsetMaker.Shape();
+    const wrapped = castShape(resultShape);
+    if (!isShape3D(wrapped)) {
+      wrapped[Symbol.dispose]();
+      return err(
+        typeCastError(
+          BrepErrorCode.MINKOWSKI_NOT_3D,
+          "Minkowski sphere offset did not produce a 3D shape"
+        )
+      );
+    }
+    return ok(wrapped);
+  } catch (e8) {
+    const raw = e8 instanceof Error ? e8.message : String(e8);
+    return err(
+      occtError(BrepErrorCode.MINKOWSKI_FAILED, `Minkowski sphere offset failed: ${raw}`, e8, {
+        operation: "minkowski",
+        fastPath: "sphere"
+      })
+    );
+  }
+}
+function minkowskiGeneral(shape2, tool, _tolerance) {
+  const oc = getKernel().oc;
+  try {
+    const shapeVerts = getVertices(shape2);
+    const toolVerts = getVertices(tool);
+    if (shapeVerts.length === 0 || toolVerts.length === 0) {
+      return err(
+        occtError(
+          BrepErrorCode.MINKOWSKI_FAILED,
+          "Minkowski sum: one or both shapes have no vertices",
+          void 0,
+          {
+            operation: "minkowski"
+          }
+        )
+      );
+    }
+    const sumPoints = [];
+    for (const sv of shapeVerts) {
+      const r1 = gcWithScope();
+      const pa = r1(oc.BRep_Tool.Pnt(sv.wrapped));
+      const ax = pa.X(), ay = pa.Y(), az = pa.Z();
+      for (const tv of toolVerts) {
+        const r22 = gcWithScope();
+        const pb = r22(oc.BRep_Tool.Pnt(tv.wrapped));
+        const bx = pb.X(), by = pb.Y(), bz = pb.Z();
+        sumPoints.push({ x: ax + bx, y: ay + by, z: az + bz });
+      }
+    }
+    const kernel = getKernel();
+    const hullShape = kernel.hullFromPoints(sumPoints, _tolerance);
+    const wrapped = castShape(hullShape);
+    if (!isShape3D(wrapped)) {
+      wrapped[Symbol.dispose]();
+      return err(
+        typeCastError(BrepErrorCode.MINKOWSKI_NOT_3D, "Minkowski hull did not produce a 3D shape")
+      );
+    }
+    return ok(wrapped);
+  } catch (e8) {
+    const raw = e8 instanceof Error ? e8.message : String(e8);
+    return err(
+      occtError(BrepErrorCode.MINKOWSKI_FAILED, `Minkowski general path failed: ${raw}`, e8, {
+        operation: "minkowski"
+      })
+    );
+  }
+}
+function minkowski(shape2, tool, options = {}) {
+  const { tolerance = 1e-6 } = options;
+  if (shape2.wrapped.IsNull()) {
+    return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, "minkowski: shape is a null shape"));
+  }
+  if (tool.wrapped.IsNull()) {
+    return err(
+      validationError(BrepErrorCode.MINKOWSKI_NULL_TOOL, "minkowski: tool is a null shape")
+    );
+  }
+  if (!isShape3D(shape2) || !isShape3D(tool)) {
+    return err(
+      validationError(BrepErrorCode.MINKOWSKI_NOT_3D, "minkowski: both shape and tool must be 3D")
+    );
+  }
+  const sphereRadius = detectSphere(tool);
+  if (sphereRadius !== null) {
+    return minkowskiSphere(shape2, sphereRadius, tolerance);
+  }
+  return minkowskiGeneral(shape2, tool, tolerance);
+}
+function polyhedron(points, faces, options = {}) {
+  const { tolerance = 1e-6 } = options;
+  if (points.length < 4) {
+    return err(
+      validationError(
+        BrepErrorCode.POLYHEDRON_INSUFFICIENT_POINTS,
+        `polyhedron: need at least 4 points, got ${points.length}`
+      )
+    );
+  }
+  if (faces.length < 4) {
+    return err(
+      validationError(
+        BrepErrorCode.POLYHEDRON_INSUFFICIENT_FACES,
+        `polyhedron: need at least 4 faces, got ${faces.length}`
+      )
+    );
+  }
+  const triangles = [];
+  for (const [fi, face2] of faces.entries()) {
+    for (const idx of face2) {
+      if (idx < 0 || idx >= points.length) {
+        return err(
+          validationError(
+            BrepErrorCode.POLYHEDRON_INVALID_INDEX,
+            `polyhedron: face ${fi} has out-of-range index ${idx} (${points.length} points)`
+          )
+        );
+      }
+    }
+    if (face2.length < 3) continue;
+    const v0 = face2[0];
+    for (let i8 = 1; i8 < face2.length - 1; i8++) {
+      triangles.push([v0, face2[i8], face2[i8 + 1]]);
+    }
+  }
+  try {
+    const kernel = getKernel();
+    const ptObjs = points.map(([x4, y5, z6]) => ({ x: x4, y: y5, z: z6 }));
+    const resultOc = kernel.buildSolidFromFaces(ptObjs, triangles, tolerance);
+    const cast = castShape(resultOc);
+    if (!isSolid(cast)) {
+      cast[Symbol.dispose]();
+      return err(occtError(BrepErrorCode.POLYHEDRON_FAILED, "Polyhedron did not produce a solid"));
+    }
+    return ok(cast);
+  } catch (e8) {
+    const raw = e8 instanceof Error ? e8.message : String(e8);
+    return err(occtError(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}`
+      )
+    );
+  }
+  const { solid: solid2 = true, ruled = false, tolerance = 1e-6 } = options ?? {};
+  try {
+    const oc = getKernel().oc;
+    const r11 = gcWithScope();
+    const adaptor = r11(new oc.BRepAdaptor_CompCurve_2(spine.wrapped, false));
+    const uFirst = Number(adaptor.FirstParameter());
+    const uLast = Number(adaptor.LastParameter());
+    const uRange = uLast - uFirst;
+    const params = sections.map((s6, i8) => {
+      if (s6.location !== void 0) {
+        return uFirst + s6.location * uRange;
+      }
+      return uFirst + i8 / (sections.length - 1) * uRange;
+    });
+    const builder = r11(new oc.BRepOffsetAPI_ThruSections(solid2, ruled, tolerance));
+    for (let i8 = 0; i8 < sections.length; i8++) {
+      const param = params[i8];
+      const section2 = sections[i8];
+      if (param === void 0 || section2 === void 0) continue;
+      const pnt = r11(new oc.gp_Pnt_1());
+      const tangent = r11(new oc.gp_Vec_1());
+      adaptor.D1(param, pnt, tangent);
+      const tangentDir = r11(new oc.gp_Dir_2(tangent));
+      const toAx3 = r11(new oc.gp_Ax3_4(pnt, tangentDir));
+      const trsf = r11(new oc.gp_Trsf_1());
+      trsf.SetTransformation_2(toAx3);
+      trsf.Invert();
+      const transformer = r11(new oc.BRepBuilderAPI_Transform_2(section2.wire.wrapped, trsf, true));
+      const transformedShape = transformer.Shape();
+      const transformedWire = oc.TopoDS.Wire_1(transformedShape);
+      builder.AddWire(transformedWire);
+    }
+    const progress = r11(new oc.Message_ProgressRange_1());
+    builder.Build(progress);
+    if (!builder.IsDone()) {
+      return err(occtError(BrepErrorCode.MULTI_SWEEP_FAILED, "Multi-section sweep build failed"));
+    }
+    const result = castShape(builder.Shape());
+    if (!isShape3D(result)) {
+      return err(
+        typeCastError("MULTI_SWEEP_NOT_3D", "Multi-section sweep did not produce a 3D shape")
+      );
+    }
+    return ok(result);
+  } catch (e8) {
+    const raw = e8 instanceof Error ? e8.message : String(e8);
+    return err(
+      occtError(BrepErrorCode.MULTI_SWEEP_FAILED, `Multi-section sweep failed: ${raw}`, e8)
+    );
+  }
+}
+function guidedSweep(profile, spine, guides, options = {}) {
+  const { transition = "transformed", solid: solid2 = true, tolerance } = options;
+  try {
+    const oc = getKernel().oc;
+    const r11 = gcWithScope();
+    const builder = r11(new oc.BRepOffsetAPI_MakePipeShell(spine.wrapped));
+    const modeMap = {
+      transformed: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_Transformed,
+      round: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_RoundCorner,
+      right: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_RightCorner
+    };
+    builder.SetTransitionMode(modeMap[transition]);
+    if (tolerance !== void 0) {
+      builder.SetTolerance(tolerance, tolerance, 1e-7);
+    }
+    if (guides.length > 0) {
+      const firstGuide = guides[0];
+      builder.SetMode_5(firstGuide.wrapped, false, oc.BRepFill_TypeOfContact.BRepFill_NoContact);
+    }
+    builder.Add_1(profile.wrapped, false, false);
+    const progress = r11(new oc.Message_ProgressRange_1());
+    builder.Build(progress);
+    if (!builder.IsDone()) {
+      return err(occtError(BrepErrorCode.GUIDED_SWEEP_FAILED, "Guided sweep build failed"));
+    }
+    if (solid2) {
+      builder.MakeSolid();
+    }
+    const result = castShape(builder.Shape());
+    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(occtError(BrepErrorCode.GUIDED_SWEEP_FAILED, `Guided sweep failed: ${raw}`, e8));
+  }
+}
+const EPS = 1e-10;
+function cross2(ax, ay, bx, by) {
+  return ax * by - ay * bx;
+}
+function dot2(ax, ay, bx, by) {
+  return ax * bx + ay * by;
+}
+function len2(x4, y5) {
+  return Math.sqrt(x4 * x4 + y5 * y5);
+}
+function polyAt(poly, i8) {
+  const p8 = poly[(i8 % poly.length + poly.length) % poly.length];
+  if (!p8) throw new Error(`Invalid polygon index ${i8} for length ${poly.length}`);
+  return p8;
+}
+function ensureCCW(poly) {
+  let area = 0;
+  for (let i8 = 0; i8 < poly.length; i8++) {
+    const cur = polyAt(poly, i8);
+    const nxt = polyAt(poly, i8 + 1);
+    area += cur.x * nxt.y - nxt.x * cur.y;
+  }
+  if (area < 0) return [...poly].reverse();
+  return poly;
+}
+function bisector(poly, i8) {
+  const prev = polyAt(poly, i8 - 1);
+  const cur = polyAt(poly, i8);
+  const next = polyAt(poly, i8 + 1);
+  const e1x = cur.x - prev.x;
+  const e1y = cur.y - prev.y;
+  const e1l = len2(e1x, e1y);
+  const e2x = next.x - cur.x;
+  const e2y = next.y - cur.y;
+  const e2l = len2(e2x, e2y);
+  if (e1l < EPS || e2l < EPS) return { dx: 0, dy: 0 };
+  const n1x = -e1y / e1l;
+  const n1y = e1x / e1l;
+  const n2x = -e2y / e2l;
+  const n2y = e2x / e2l;
+  let bx = n1x + n2x;
+  let by = n1y + n2y;
+  const bl = len2(bx, by);
+  if (bl < EPS) {
+    return { dx: n1x, dy: n1y };
+  }
+  bx /= bl;
+  by /= bl;
+  const cosHalf = dot2(bx, by, n1x, n1y);
+  const speed = Math.abs(cosHalf) > EPS ? 1 / cosHalf : 1;
+  return { dx: bx * speed, dy: by * speed };
+}
+function isLavNodeReflex(node) {
+  const prev = node.prev;
+  const next = node.next;
+  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, i8) => {
+    const b11 = bisector(poly, i8);
+    return {
+      x: p8.x,
+      y: p8.y,
+      bx: b11.dx,
+      by: b11.dy,
+      origIdx: i8,
+      prev: null,
+      next: null,
+      active: true
+    };
+  });
+  for (let i8 = 0; i8 < nodes.length; i8++) {
+    const node = nodes[i8];
+    const prevNode = nodes[(i8 - 1 + nodes.length) % nodes.length];
+    const nextNode = nodes[(i8 + 1) % nodes.length];
+    if (node && prevNode && nextNode) {
+      node.prev = prevNode;
+      node.next = nextNode;
+    }
+  }
+  return nodes;
+}
+function lavSize(start) {
+  let count = 1;
+  let cur = start.next;
+  while (cur !== start) {
+    count++;
+    cur = cur.next;
+    if (count > 1e4) break;
+  }
+  return count;
+}
+function bisectorIntersectTime(a9, b11) {
+  const ddx = a9.bx - b11.bx;
+  const ddy = a9.by - b11.by;
+  const dxp = b11.x - a9.x;
+  const dyp = b11.y - a9.y;
+  if (Math.abs(ddx) < EPS && Math.abs(ddy) < EPS) return null;
+  let t11;
+  if (Math.abs(ddx) > Math.abs(ddy)) {
+    t11 = dxp / ddx;
+  } else {
+    t11 = dyp / ddy;
+  }
+  if (t11 < EPS) return null;
+  const otherDd = Math.abs(ddx) > Math.abs(ddy) ? ddy : ddx;
+  const otherDp = Math.abs(ddx) > Math.abs(ddy) ? dyp : dxp;
+  if (Math.abs(otherDd) > EPS) {
+    const t22 = otherDp / otherDd;
+    if (Math.abs(t11 - t22) > 1e-4 * Math.max(1, Math.abs(t11))) return null;
+  }
+  return t11;
+}
+function raySplitTime(node, eA, eB) {
+  const edx = eB.x - eA.x;
+  const edy = eB.y - eA.y;
+  const el = len2(edx, edy);
+  if (el < EPS) return null;
+  const enx = -edy / el;
+  const eny = edx / el;
+  const d0 = (node.x - eA.x) * enx + (node.y - eA.y) * eny;
+  const relBx = node.bx - (eA.bx + eB.bx) / 2;
+  const relBy = node.by - (eA.by + eB.by) / 2;
+  const dRate = relBx * enx + relBy * eny;
+  if (Math.abs(dRate) < EPS) return null;
+  const t11 = -d0 / dRate;
+  if (t11 < EPS) return null;
+  const px = node.x + t11 * node.bx;
+  const py = node.y + t11 * node.by;
+  const ax = eA.x + t11 * eA.bx;
+  const ay = eA.y + t11 * eA.by;
+  const bxx = eB.x + t11 * eB.bx;
+  const byy = eB.y + t11 * eB.by;
+  const segDx = bxx - ax;
+  const segDy = byy - ay;
+  const segL = len2(segDx, segDy);
+  if (segL < EPS) return t11;
+  const s6 = dot2(px - ax, py - ay, segDx, segDy) / (segL * segL);
+  if (s6 < -0.01 || s6 > 1.01) return null;
+  return t11;
+}
+function computeEvents(lavNodes) {
+  const events = [];
+  for (const node of lavNodes) {
+    if (!node.active) continue;
+    const t11 = bisectorIntersectTime(node, node.next);
+    if (t11 !== null && t11 > EPS) {
+      const x4 = node.x + t11 * node.bx;
+      const y5 = node.y + t11 * node.by;
+      events.push({ time: t11, x: x4, y: y5, nodeA: node, nodeB: node.next, type: "edge" });
+    }
+    if (isLavNodeReflex(node)) {
+      let cur = node.next.next;
+      let count = 0;
+      while (cur !== node.prev && cur !== node && count < 1e3) {
+        const st = raySplitTime(node, cur, cur.next);
+        if (st !== null && st > EPS) {
+          const x4 = node.x + st * node.bx;
+          const y5 = node.y + st * node.by;
+          events.push({ time: st, x: x4, y: y5, nodeA: node, nodeB: cur, type: "split" });
+        }
+        cur = cur.next;
+        count++;
+      }
+    }
+  }
+  events.sort((a9, b11) => a9.time - b11.time);
+  return events;
+}
+function computeStraightSkeleton(polygon2) {
+  if (polygon2.length < 3) {
+    return { nodes: [], faces: [] };
+  }
+  const poly = ensureCCW(polygon2);
+  const n7 = poly.length;
+  const skeletonNodes = [];
+  const vertexToSkelNodes = Array.from({ length: n7 }, () => []);
+  const lavNodes = createLav(poly);
+  let iterations = 0;
+  const maxIter = n7 * n7 * 2;
+  while (iterations < maxIter) {
+    iterations++;
+    const activeStart = lavNodes.find((nd) => nd.active);
+    if (!activeStart) break;
+    const sz = lavSize(activeStart);
+    if (sz <= 3) {
+      if (sz === 3) {
+        const a9 = activeStart;
+        const b11 = a9.next;
+        const c7 = b11.next;
+        const t11 = bisectorIntersectTime(a9, b11);
+        const time = t11 !== null && t11 > EPS ? t11 : 0;
+        const mx = (a9.x + b11.x + c7.x) / 3 + time * (a9.bx + b11.bx + c7.bx) / 3;
+        const my = (a9.y + b11.y + c7.y) / 3 + time * (a9.by + b11.by + c7.by) / 3;
+        const nodeIdx = skeletonNodes.length;
+        skeletonNodes.push({ x: mx, y: my, height: time });
+        const aNodes = vertexToSkelNodes[a9.origIdx];
+        const bNodes = vertexToSkelNodes[b11.origIdx];
+        const cNodes = vertexToSkelNodes[c7.origIdx];
+        if (aNodes) aNodes.push(nodeIdx);
+        if (bNodes) bNodes.push(nodeIdx);
+        if (cNodes) cNodes.push(nodeIdx);
+        a9.active = false;
+        b11.active = false;
+        c7.active = false;
+      } else {
+        let cur = activeStart;
+        for (let i8 = 0; i8 < sz; i8++) {
+          cur.active = false;
+          cur = cur.next;
+        }
+      }
+      continue;
+    }
+    const activeNodes = lavNodes.filter((nd) => nd.active);
+    const events = computeEvents(activeNodes);
+    if (events.length === 0) {
+      for (const nd of activeNodes) {
+        nd.active = false;
+      }
+      break;
+    }
+    const ev = events[0];
+    if (!ev) break;
+    if (ev.type === "edge") {
+      const a9 = ev.nodeA;
+      const b11 = ev.nodeB;
+      if (!a9.active || !b11.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[b11.origIdx];
+      if (aNodes) aNodes.push(nodeIdx);
+      if (bNodes) bNodes.push(nodeIdx);
+      a9.x = ev.x;
+      a9.y = ev.y;
+      a9.next = b11.next;
+      b11.next.prev = a9;
+      b11.active = false;
+      const lavPoly = [];
+      let cur = a9;
+      do {
+        lavPoly.push({ x: cur.x, y: cur.y });
+        cur = cur.next;
+      } while (cur !== a9);
+      const bDir = bisector(lavPoly, 0);
+      a9.bx = bDir.dx;
+      a9.by = bDir.dy;
+    } else {
+      const a9 = ev.nodeA;
+      const b11 = ev.nodeB;
+      if (!a9.active || !b11.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[b11.origIdx];
+      if (bNodes) bNodes.push(nodeIdx);
+      const aCopy = {
+        x: ev.x,
+        y: ev.y,
+        bx: 0,
+        by: 0,
+        origIdx: a9.origIdx,
+        prev: null,
+        next: null,
+        active: true
+      };
+      lavNodes.push(aCopy);
+      a9.x = ev.x;
+      a9.y = ev.y;
+      const aNext = a9.next;
+      const bNext = b11.next;
+      a9.next = bNext;
+      bNext.prev = a9;
+      aCopy.next = aNext;
+      aNext.prev = aCopy;
+      aCopy.prev = b11;
+      b11.next = aCopy;
+      const buildLavPoly = (start) => {
+        const poly2 = [];
+        let c7 = start;
+        do {
+          poly2.push({ x: c7.x, y: c7.y });
+          c7 = c7.next;
+        } while (c7 !== start);
+        return poly2;
+      };
+      const lav1Poly = buildLavPoly(a9);
+      const bDir1 = bisector(lav1Poly, 0);
+      a9.bx = bDir1.dx;
+      a9.by = bDir1.dy;
+      const lav2Poly = buildLavPoly(aCopy);
+      const bDir2 = bisector(lav2Poly, 0);
+      aCopy.bx = bDir2.dx;
+      aCopy.by = bDir2.dy;
+    }
+  }
+  const faces = [];
+  for (let i8 = 0; i8 < n7; i8++) {
+    const j8 = (i8 + 1) % n7;
+    const pi = polyAt(poly, i8);
+    const pj = polyAt(poly, j8);
+    const faceVerts = [pi, pj];
+    const faceHeights = [0, 0];
+    const jNodes = vertexToSkelNodes[j8];
+    const iNodes = vertexToSkelNodes[i8];
+    if (jNodes) {
+      for (const ni of jNodes) {
+        const sn = skeletonNodes[ni];
+        if (sn) {
+          faceVerts.push({ x: sn.x, y: sn.y });
+          faceHeights.push(sn.height);
+        }
+      }
+    }
+    if (iNodes) {
+      for (let k10 = iNodes.length - 1; k10 >= 0; k10--) {
+        const idx = iNodes[k10];
+        if (idx === void 0) continue;
+        const sn = skeletonNodes[idx];
+        if (!sn) continue;
+        const lastVert = faceVerts[faceVerts.length - 1];
+        if (!lastVert) continue;
+        const dist = len2(sn.x - lastVert.x, sn.y - lastVert.y);
+        if (dist > EPS) {
+          faceVerts.push({ x: sn.x, y: sn.y });
+          faceHeights.push(sn.height);
+        }
+      }
+    }
+    if (faceVerts.length >= 3) {
+      faces.push({ vertices: faceVerts, heights: faceHeights });
+    }
+  }
+  const uniqueNodes = [];
+  for (const sn of skeletonNodes) {
+    const exists = uniqueNodes.some(
+      (un) => Math.abs(un.x - sn.x) < 0.01 && Math.abs(un.y - sn.y) < 0.01
+    );
+    if (!exists) {
+      uniqueNodes.push(sn);
+    }
+  }
+  return { nodes: uniqueNodes, faces };
+}
+function extractPolygon(w7) {
+  const edges = getEdges(w7);
+  const pts = edges.map((e8) => {
+    const pt = curveStartPoint(e8);
+    return { x: pt[0], y: pt[1] };
+  });
+  const first = pts[0];
+  const last = pts[pts.length - 1];
+  if (pts.length > 1 && first && last && Math.abs(first.x - last.x) < 1e-10 && Math.abs(first.y - last.y) < 1e-10) {
+    pts.pop();
+  }
+  return pts;
+}
+function fanTriangulate(count) {
+  const tris = [];
+  for (let i8 = 1; i8 < count - 1; i8++) {
+    tris.push([0, i8, i8 + 1]);
+  }
+  return tris;
+}
+function buildTriFace$2(oc, a9, b11, c7) {
+  const gpA = new oc.gp_Pnt_3(a9[0], a9[1], a9[2]);
+  const gpB = new oc.gp_Pnt_3(b11[0], b11[1], b11[2]);
+  const gpC = new oc.gp_Pnt_3(c7[0], c7[1], c7[2]);
+  const e1 = new oc.BRepBuilderAPI_MakeEdge_3(gpA, gpB);
+  const e22 = new oc.BRepBuilderAPI_MakeEdge_3(gpB, gpC);
+  const e32 = new oc.BRepBuilderAPI_MakeEdge_3(gpC, gpA);
+  const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+  wireBuilder.Add_1(e1.Edge());
+  wireBuilder.Add_1(e22.Edge());
+  wireBuilder.Add_1(e32.Edge());
+  let face2 = null;
+  if (wireBuilder.IsDone()) {
+    const makeFace2 = new oc.BRepBuilderAPI_MakeFace_15(wireBuilder.Wire(), false);
+    if (makeFace2.IsDone()) {
+      face2 = makeFace2.Face();
+    }
+    makeFace2.delete();
+  }
+  wireBuilder.delete();
+  e1.delete();
+  e22.delete();
+  e32.delete();
+  gpA.delete();
+  gpB.delete();
+  gpC.delete();
+  return face2;
+}
+function roof(w7, options) {
+  const angle = (options?.angle ?? 45) * (Math.PI / 180);
+  const tanAngle = Math.tan(angle);
+  try {
+    const polygon2 = extractPolygon(w7);
+    if (polygon2.length < 3) {
+      return err(
+        occtError(BrepErrorCode.ROOF_FAILED, "Wire must have at least 3 edges for roof generation")
+      );
+    }
+    const skeleton = computeStraightSkeleton(polygon2);
+    if (skeleton.faces.length === 0) {
+      return err(
+        occtError(BrepErrorCode.ROOF_FAILED, "Straight skeleton computation produced no faces")
+      );
+    }
+    const oc = getKernel().oc;
+    const sewing = new oc.BRepBuilderAPI_Sewing(1e-6, true, true, true, false);
+    let faceCount = 0;
+    try {
+      for (const skFace of skeleton.faces) {
+        const verts3d = skFace.vertices.map(
+          (v7, i8) => [
+            v7.x,
+            v7.y,
+            (skFace.heights[i8] ?? 0) * tanAngle
+          ]
+        );
+        const tris = fanTriangulate(verts3d.length);
+        for (const [ai, bi, ci] of tris) {
+          const va = verts3d[ai];
+          const vb = verts3d[bi];
+          const vc = verts3d[ci];
+          if (!va || !vb || !vc) continue;
+          const abx = vb[0] - va[0];
+          const aby = vb[1] - va[1];
+          const abz = vb[2] - va[2];
+          const acx = vc[0] - va[0];
+          const acy = vc[1] - va[1];
+          const acz = vc[2] - va[2];
+          const nx = aby * acz - abz * acy;
+          const ny = abz * acx - abx * acz;
+          const nz = abx * acy - aby * acx;
+          const areaSq = nx * nx + ny * ny + nz * nz;
+          if (areaSq < 1e-20) continue;
+          const triFace = buildTriFace$2(oc, va, vb, vc);
+          if (triFace !== null) {
+            sewing.Add(triFace);
+            faceCount++;
+          }
+        }
+      }
+      const p0 = polygon2[0];
+      if (p0) {
+        for (let i8 = 1; i8 < polygon2.length - 1; i8++) {
+          const pi = polygon2[i8];
+          const pi1 = polygon2[i8 + 1];
+          if (!pi || !pi1) continue;
+          const va = [p0.x, p0.y, 0];
+          const vb = [pi.x, pi.y, 0];
+          const vc = [pi1.x, pi1.y, 0];
+          const triFace = buildTriFace$2(oc, va, vc, vb);
+          if (triFace !== null) {
+            sewing.Add(triFace);
+            faceCount++;
+          }
+        }
+      }
+      if (faceCount === 0) {
+        return err(
+          occtError(BrepErrorCode.ROOF_FAILED, "No valid triangular faces could be built")
+        );
+      }
+      const progress = new oc.Message_ProgressRange_1();
+      sewing.Perform(progress);
+      progress.delete();
+      const sewn = sewing.SewedShape();
+      const fixer = new oc.ShapeFix_Solid_1();
+      try {
+        const shell2 = oc.TopoDS.Shell_1(sewn);
+        const solid2 = fixer.SolidFromShell(shell2);
+        const shapeFixer = new oc.ShapeFix_Shape_1(solid2);
+        const shapeFixProgress = new oc.Message_ProgressRange_1();
+        try {
+          shapeFixer.Perform(shapeFixProgress);
+          const fixed = shapeFixer.Shape();
+          return ok(createSolid(fixed));
+        } finally {
+          shapeFixProgress.delete();
+          shapeFixer.delete();
+        }
+      } catch {
+        return ok(castShape(sewn));
+      } finally {
+        fixer.delete();
+      }
+    } finally {
+      sewing.delete();
+    }
+  } catch (e8) {
+    const msg = e8 instanceof Error ? e8.message : String(e8);
+    return err(occtError(BrepErrorCode.ROOF_FAILED, `Roof generation failed: ${msg}`, e8));
+  }
+}
+function solveConstraints(nodes, constraints) {
+  const transforms = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    transforms.set(node, {
+      position: [0, 0, 0],
+      rotation: [1, 0, 0, 0]
+    });
+  }
+  for (const c7 of constraints) {
+    if (c7.type === "coincident" && c7.entityA && c7.entityB) {
+      const a9 = c7.entityA;
+      const b11 = c7.entityB;
+      if (a9.entity.type === "plane" && b11.entity.type === "plane") {
+        const aNormal = a9.entity.normal ?? [0, 0, 1];
+        const aOrigin = a9.entity.origin;
+        const bOrigin = b11.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(b11.node, { position: pos, rotation: [1, 0, 0, 0] });
+      }
+    }
+    if (c7.type === "distance" && c7.entityA && c7.entityB && c7.value !== void 0) {
+      const a9 = c7.entityA;
+      const b11 = c7.entityB;
+      if (a9.entity.type === "plane" && b11.entity.type === "plane") {
+        const aNormal = a9.entity.normal ?? [0, 0, 1];
+        const aOrigin = a9.entity.origin;
+        const bOrigin = b11.entity.origin;
+        const currentDist = aNormal[0] * (aOrigin[0] - bOrigin[0]) + aNormal[1] * (aOrigin[1] - bOrigin[1]) + aNormal[2] * (aOrigin[2] - bOrigin[2]);
+        const offset2 = currentDist + c7.value;
+        const pos = [offset2 * aNormal[0], offset2 * aNormal[1], offset2 * aNormal[2]];
+        transforms.set(b11.node, { position: pos, rotation: [1, 0, 0, 0] });
+      }
+    }
+  }
+  return { transforms, dof: 0, converged: true };
+}
+function extractEntity(mate) {
+  if (mate.face) {
+    const origin = faceCenter(mate.face);
+    const normal = normalAt(mate.face);
+    return { type: "plane", origin, normal };
+  }
+  if (mate.point) {
+    return { type: "point", origin: mate.point };
+  }
+  return null;
+}
+function addMate(assembly, constraint) {
+  const existing = assembly.mates ?? [];
+  return { ...assembly, mates: [...existing, constraint] };
+}
+function solveAssembly(assembly) {
+  const mates = assembly.mates;
+  if (!mates || mates.length === 0) {
+    return err(
+      validationError(BrepErrorCode.ASSEMBLY_MATE_INVALID, "solveAssembly: no mates defined")
+    );
+  }
+  try {
+    const nodes = [];
+    walkAssembly(assembly, (node) => {
+      nodes.push(node.name);
+    });
+    const solverConstraints = [];
+    for (const mate of mates) {
+      if (mate.type === "fixed") {
+        solverConstraints.push({
+          type: "fixed",
+          entityA: { node: mate.entity.node, entity: { type: "point", origin: [0, 0, 0] } }
+        });
+        continue;
+      }
+      if (mate.type === "coincident") {
+        const entA = extractEntity(mate.entityA);
+        const entB = extractEntity(mate.entityB);
+        if (!entA || !entB) {
+          return err(
+            validationError(
+              BrepErrorCode.ASSEMBLY_MATE_INVALID,
+              "solveAssembly: could not extract geometry from mate entities"
+            )
+          );
+        }
+        solverConstraints.push({
+          type: "coincident",
+          entityA: { node: mate.entityA.node, entity: entA },
+          entityB: { node: mate.entityB.node, entity: entB }
+        });
+      }
+      if (mate.type === "distance") {
+        const entA = extractEntity(mate.entityA);
+        const entB = extractEntity(mate.entityB);
+        if (!entA || !entB) {
+          return err(
+            validationError(
+              BrepErrorCode.ASSEMBLY_MATE_INVALID,
+              "solveAssembly: could not extract geometry from mate entities"
+            )
+          );
+        }
+        solverConstraints.push({
+          type: "distance",
+          entityA: { node: mate.entityA.node, entity: entA },
+          entityB: { node: mate.entityB.node, entity: entB },
+          value: mate.distance
+        });
+      }
+      if (mate.type === "angle") {
+        const entA = extractEntity(mate.entityA);
+        const entB = extractEntity(mate.entityB);
+        if (!entA || !entB) {
+          return err(
+            validationError(
+              BrepErrorCode.ASSEMBLY_MATE_INVALID,
+              "solveAssembly: could not extract geometry from mate entities"
+            )
+          );
+        }
+        solverConstraints.push({
+          type: "angle",
+          entityA: { node: mate.entityA.node, entity: entA },
+          entityB: { node: mate.entityB.node, entity: entB },
+          value: mate.angle
+        });
+      }
+      if (mate.type === "concentric") {
+        const entA = extractEntity(mate.axisA);
+        const entB = extractEntity(mate.axisB);
+        if (!entA || !entB) {
+          return err(
+            validationError(
+              BrepErrorCode.ASSEMBLY_MATE_INVALID,
+              "solveAssembly: could not extract geometry from mate entities"
+            )
+          );
+        }
+        solverConstraints.push({
+          type: "concentric",
+          entityA: { node: mate.axisA.node, entity: entA },
+          entityB: { node: mate.axisB.node, entity: entB }
+        });
+      }
+    }
+    const result = solveConstraints(nodes, solverConstraints);
+    if (!result.converged) ;
+    return ok({
+      transforms: result.transforms,
+      dof: result.dof,
+      converged: result.converged
+    });
+  } catch (e8) {
+    const raw = e8 instanceof Error ? e8.message : String(e8);
+    return err(occtError(BrepErrorCode.ASSEMBLY_SOLVE_FAILED, `Assembly solve failed: ${raw}`, e8));
+  }
+}
 function checkInterference(shape1, shape2, tolerance = 1e-6) {
   if (shape1.wrapped.IsNull()) {
     return err(
@@ -186,29 +1406,481 @@ function checkInterference(shape1, shape2, tolerance = 1e-6) {
 }
 function checkAllInterferences(shapes, tolerance = 1e-6) {
   const pairs = [];
-  shapes.forEach((si, i12) => {
-    for (let j9 = i12 + 1; j9 < shapes.length; j9++) {
-      const result = unwrap(checkInterference(si, shapes[j9], tolerance));
+  shapes.forEach((si, i8) => {
+    for (let j8 = i8 + 1; j8 < shapes.length; j8++) {
+      const result = unwrap(checkInterference(si, shapes[j8], tolerance));
       if (result.hasInterference) {
-        pairs.push({ i: i12, j: j9, result });
+        pairs.push({ i: i8, j: j8, result });
       }
     }
   });
   return pairs;
 }
-function resolve(s5) {
-  if ("__wrapped" in s5) {
-    return s5.val;
+function parseEntities(text) {
+  const lines = text.split(/\r?\n/);
+  const entities = [];
+  let inEntities = false;
+  let current;
+  for (let i8 = 0; i8 < lines.length - 1; i8 += 2) {
+    const codeLine = lines[i8];
+    const valueLine = lines[i8 + 1];
+    if (codeLine === void 0 || valueLine === void 0) continue;
+    const code = parseInt(codeLine.trim(), 10);
+    const value = valueLine.trim();
+    if (isNaN(code)) continue;
+    if (code === 2 && value === "ENTITIES") {
+      inEntities = true;
+      continue;
+    }
+    if (!inEntities) continue;
+    if (code === 0) {
+      if (value === "ENDSEC" || value === "EOF") {
+        if (current) entities.push(current);
+        break;
+      }
+      if (current) entities.push(current);
+      current = { type: value, layer: "0", data: /* @__PURE__ */ new Map() };
+      continue;
+    }
+    if (current) {
+      if (code === 8) {
+        current.layer = value;
+      } else {
+        current.data.set(code, value);
+      }
+    }
+  }
+  return entities;
+}
+function getNum(data, code, fallback = 0) {
+  const v7 = data.get(code);
+  if (v7 === void 0) return fallback;
+  const n7 = parseFloat(v7);
+  return isNaN(n7) ? fallback : n7;
+}
+function entityToEdge(entity, oc) {
+  const { type, data } = entity;
+  if (type === "LINE") {
+    const p1 = new oc.gp_Pnt_3(getNum(data, 10), getNum(data, 20), getNum(data, 30));
+    const p22 = new oc.gp_Pnt_3(getNum(data, 11), getNum(data, 21), getNum(data, 31));
+    try {
+      const builder = new oc.BRepBuilderAPI_MakeEdge_3(p1, p22);
+      const edge = builder.Edge();
+      builder.delete();
+      return edge;
+    } finally {
+      p1.delete();
+      p22.delete();
+    }
+  }
+  if (type === "CIRCLE") {
+    const cx = getNum(data, 10);
+    const cy = getNum(data, 20);
+    const cz = getNum(data, 30);
+    const radius = getNum(data, 40);
+    const center = new oc.gp_Pnt_3(cx, cy, cz);
+    const dir = new oc.gp_Dir_4(0, 0, 1);
+    const ax2 = new oc.gp_Ax2_3(center, dir);
+    const circ = new oc.gp_Circ_2(ax2, radius);
+    try {
+      const builder = new oc.BRepBuilderAPI_MakeEdge_8(circ);
+      const edge = builder.Edge();
+      builder.delete();
+      return edge;
+    } finally {
+      center.delete();
+      dir.delete();
+      ax2.delete();
+      circ.delete();
+    }
+  }
+  if (type === "ARC") {
+    const cx = getNum(data, 10);
+    const cy = getNum(data, 20);
+    const cz = getNum(data, 30);
+    const radius = getNum(data, 40);
+    const startAngleDeg = getNum(data, 50);
+    const endAngleDeg = getNum(data, 51);
+    const startAngle = startAngleDeg * Math.PI / 180;
+    const endAngle = endAngleDeg * Math.PI / 180;
+    const center = new oc.gp_Pnt_3(cx, cy, cz);
+    const dir = new oc.gp_Dir_4(0, 0, 1);
+    const ax2 = new oc.gp_Ax2_3(center, dir);
+    const circ = new oc.gp_Circ_2(ax2, radius);
+    try {
+      const builder = new oc.BRepBuilderAPI_MakeEdge_9(circ, startAngle, endAngle);
+      const edge = builder.Edge();
+      builder.delete();
+      return edge;
+    } finally {
+      center.delete();
+      dir.delete();
+      ax2.delete();
+      circ.delete();
+    }
+  }
+  return void 0;
+}
+async function importDXF(blob, options) {
+  const oc = getKernel().oc;
+  let text;
+  try {
+    text = await blob.text();
+  } catch (cause) {
+    return err(ioError(BrepErrorCode.DXF_IMPORT_FAILED, "Failed to read DXF blob", cause));
+  }
+  const allEntities = parseEntities(text);
+  const entities = options?.layer !== void 0 ? allEntities.filter((e8) => e8.layer === options.layer) : allEntities;
+  if (entities.length === 0) {
+    return ok([]);
+  }
+  const edges = [];
+  try {
+    for (const entity of entities) {
+      const edge = entityToEdge(entity, oc);
+      if (edge !== void 0) {
+        edges.push(edge);
+      }
+    }
+    if (edges.length === 0) {
+      return ok([]);
+    }
+    const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+    try {
+      for (const edge of edges) {
+        wireBuilder.Add_1(edge);
+      }
+      if (wireBuilder.IsDone()) {
+        const wire2 = wireBuilder.Wire();
+        return ok([createWire(wire2)]);
+      }
+      return err(
+        ioError(BrepErrorCode.DXF_IMPORT_FAILED, "Failed to assemble DXF edges into a wire")
+      );
+    } finally {
+      wireBuilder.delete();
+    }
+  } catch (cause) {
+    return err(
+      ioError(BrepErrorCode.DXF_IMPORT_FAILED, "Failed to convert DXF entities to geometry", cause)
+    );
+  } finally {
+    for (const edge of edges) {
+      edge.delete();
+    }
+  }
+}
+async function importOBJ(blob) {
+  const text = await blob.text();
+  const lines = text.split("\n");
+  const vertices = [];
+  const faces = [];
+  for (const raw of lines) {
+    const line2 = raw.trim();
+    if (line2.startsWith("v ")) {
+      const parts = line2.split(/\s+/);
+      const x4 = parseFloat(parts[1] ?? "");
+      const y5 = parseFloat(parts[2] ?? "");
+      const z6 = parseFloat(parts[3] ?? "");
+      if (isNaN(x4) || isNaN(y5) || isNaN(z6)) continue;
+      vertices.push([x4, y5, z6]);
+    } else if (line2.startsWith("f ")) {
+      const parts = line2.split(/\s+/).slice(1);
+      const indices = [];
+      for (const p8 of parts) {
+        const idx = parseInt(p8.split("/")[0] ?? "", 10);
+        if (!isNaN(idx)) indices.push(idx);
+      }
+      if (indices.length >= 3) faces.push(indices);
+    }
+  }
+  if (vertices.length === 0 || faces.length === 0) {
+    return err(ioError(BrepErrorCode.OBJ_IMPORT_FAILED, "OBJ file contains no valid geometry"));
+  }
+  try {
+    return buildSolidFromMesh$1(vertices, faces);
+  } catch (e8) {
+    const msg = e8 instanceof Error ? e8.message : String(e8);
+    return err(ioError(BrepErrorCode.OBJ_IMPORT_FAILED, `OBJ import failed: ${msg}`, e8));
+  }
+}
+function buildSolidFromMesh$1(vertices, faces) {
+  const oc = getKernel().oc;
+  const sewing = new oc.BRepBuilderAPI_Sewing(1e-6, true, true, true, false);
+  let faceCount = 0;
+  try {
+    for (const face2 of faces) {
+      for (let i8 = 1; i8 < face2.length - 1; i8++) {
+        const rawA = face2[0] ?? 0;
+        const rawB = face2[i8] ?? 0;
+        const rawC = face2[i8 + 1] ?? 0;
+        const ai = rawA > 0 ? rawA - 1 : vertices.length + rawA;
+        const bi = rawB > 0 ? rawB - 1 : vertices.length + rawB;
+        const ci = rawC > 0 ? rawC - 1 : vertices.length + rawC;
+        const va = vertices[ai];
+        const vb = vertices[bi];
+        const vc = vertices[ci];
+        if (!va || !vb || !vc) continue;
+        const triFace = buildTriFace$1(oc, va, vb, vc);
+        if (triFace !== null) {
+          sewing.Add(triFace);
+          faceCount++;
+        }
+      }
+    }
+    if (faceCount === 0) {
+      return err(
+        ioError(BrepErrorCode.OBJ_IMPORT_FAILED, "No valid triangular faces could be built")
+      );
+    }
+    const progress = new oc.Message_ProgressRange_1();
+    sewing.Perform(progress);
+    progress.delete();
+    const sewn = sewing.SewedShape();
+    const fixer = new oc.ShapeFix_Solid_1();
+    try {
+      const shell2 = oc.TopoDS.Shell_1(sewn);
+      const solid2 = fixer.SolidFromShell(shell2);
+      return ok(castShape(solid2));
+    } catch {
+      return ok(castShape(sewn));
+    } finally {
+      fixer.delete();
+    }
+  } finally {
+    sewing.delete();
+  }
+}
+function buildTriFace$1(oc, a9, b11, c7) {
+  const gpA = new oc.gp_Pnt_3(a9[0], a9[1], a9[2]);
+  const gpB = new oc.gp_Pnt_3(b11[0], b11[1], b11[2]);
+  const gpC = new oc.gp_Pnt_3(c7[0], c7[1], c7[2]);
+  const e1 = new oc.BRepBuilderAPI_MakeEdge_3(gpA, gpB);
+  const e22 = new oc.BRepBuilderAPI_MakeEdge_3(gpB, gpC);
+  const e32 = new oc.BRepBuilderAPI_MakeEdge_3(gpC, gpA);
+  const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+  wireBuilder.Add_1(e1.Edge());
+  wireBuilder.Add_1(e22.Edge());
+  wireBuilder.Add_1(e32.Edge());
+  let face2 = null;
+  if (wireBuilder.IsDone()) {
+    const makeFace2 = new oc.BRepBuilderAPI_MakeFace_15(wireBuilder.Wire(), false);
+    if (makeFace2.IsDone()) {
+      face2 = makeFace2.Face();
+    }
+    makeFace2.delete();
+  }
+  wireBuilder.delete();
+  e1.delete();
+  e22.delete();
+  e32.delete();
+  gpA.delete();
+  gpB.delete();
+  gpC.delete();
+  return face2;
+}
+function extractFromZip(data, target) {
+  let eocdOffset = -1;
+  for (let i8 = data.length - 22; i8 >= 0; i8--) {
+    if (data[i8] === 80 && data[i8 + 1] === 75 && data[i8 + 2] === 5 && data[i8 + 3] === 6) {
+      eocdOffset = i8;
+      break;
+    }
+  }
+  if (eocdOffset < 0) return null;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const cdOffset = view.getUint32(eocdOffset + 16, true);
+  const cdSize = view.getUint32(eocdOffset + 12, true);
+  const cdEnd = cdOffset + cdSize;
+  let pos = cdOffset;
+  const decoder = new TextDecoder();
+  while (pos < cdEnd) {
+    const sig = view.getUint32(pos, true);
+    if (sig !== 33639248) break;
+    const nameLen = view.getUint16(pos + 28, true);
+    const extraLen = view.getUint16(pos + 30, true);
+    const commentLen = view.getUint16(pos + 32, true);
+    const localOffset = view.getUint32(pos + 42, true);
+    const name = decoder.decode(data.subarray(pos + 46, pos + 46 + nameLen));
+    if (name === target) {
+      const compressionMethod = view.getUint16(localOffset + 8, true);
+      if (compressionMethod !== 0) {
+        return null;
+      }
+      const localNameLen = view.getUint16(localOffset + 26, true);
+      const localExtraLen = view.getUint16(localOffset + 28, true);
+      const compressedSize = view.getUint32(localOffset + 18, true);
+      const dataStart = localOffset + 30 + localNameLen + localExtraLen;
+      return data.subarray(dataStart, dataStart + compressedSize);
+    }
+    pos += 46 + nameLen + extraLen + commentLen;
+  }
+  return null;
+}
+function isAttrChar(code) {
+  return code >= 97 && code <= 122 || // a-z
+  code >= 65 && code <= 90 || // A-Z
+  code >= 48 && code <= 57 || // 0-9
+  code === 95;
+}
+function parseTagAttrs(tag) {
+  const attrs = {};
+  let pos = 0;
+  while (pos < tag.length) {
+    const eq = tag.indexOf('="', pos);
+    if (eq < 0) break;
+    let nameStart = eq;
+    while (nameStart > 0 && isAttrChar(tag.charCodeAt(nameStart - 1))) nameStart--;
+    if (nameStart === eq) {
+      pos = eq + 2;
+      continue;
+    }
+    const name = tag.slice(nameStart, eq);
+    const valStart = eq + 2;
+    const closeQuote = tag.indexOf('"', valStart);
+    if (closeQuote < 0) break;
+    attrs[name] = tag.slice(valStart, closeQuote);
+    pos = closeQuote + 1;
+  }
+  return attrs;
+}
+function findTags(xml, tagName) {
+  const tags = [];
+  const needle = `<${tagName} `;
+  let pos = 0;
+  while (pos < xml.length) {
+    const start = xml.indexOf(needle, pos);
+    if (start < 0) break;
+    const end = xml.indexOf(">", start);
+    if (end < 0) break;
+    tags.push(xml.slice(start, end + 1));
+    pos = end + 1;
+  }
+  return tags;
+}
+function parseModelXml(xml) {
+  const vertices = [];
+  const triangles = [];
+  for (const tag of findTags(xml, "vertex")) {
+    const a9 = parseTagAttrs(tag);
+    if (a9["x"] !== void 0 && a9["y"] !== void 0 && a9["z"] !== void 0) {
+      vertices.push([parseFloat(a9["x"]), parseFloat(a9["y"]), parseFloat(a9["z"])]);
+    }
+  }
+  for (const tag of findTags(xml, "triangle")) {
+    const a9 = parseTagAttrs(tag);
+    if (a9["v1"] !== void 0 && a9["v2"] !== void 0 && a9["v3"] !== void 0) {
+      triangles.push([parseInt(a9["v1"], 10), parseInt(a9["v2"], 10), parseInt(a9["v3"], 10)]);
+    }
+  }
+  return { vertices, triangles };
+}
+function buildTriFace(oc, a9, b11, c7) {
+  const gpA = new oc.gp_Pnt_3(a9[0], a9[1], a9[2]);
+  const gpB = new oc.gp_Pnt_3(b11[0], b11[1], b11[2]);
+  const gpC = new oc.gp_Pnt_3(c7[0], c7[1], c7[2]);
+  const e1 = new oc.BRepBuilderAPI_MakeEdge_3(gpA, gpB);
+  const e22 = new oc.BRepBuilderAPI_MakeEdge_3(gpB, gpC);
+  const e32 = new oc.BRepBuilderAPI_MakeEdge_3(gpC, gpA);
+  const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+  wireBuilder.Add_1(e1.Edge());
+  wireBuilder.Add_1(e22.Edge());
+  wireBuilder.Add_1(e32.Edge());
+  let face2 = null;
+  if (wireBuilder.IsDone()) {
+    const makeFace2 = new oc.BRepBuilderAPI_MakeFace_15(wireBuilder.Wire(), false);
+    if (makeFace2.IsDone()) {
+      face2 = makeFace2.Face();
+    }
+    makeFace2.delete();
+  }
+  wireBuilder.delete();
+  e1.delete();
+  e22.delete();
+  e32.delete();
+  gpA.delete();
+  gpB.delete();
+  gpC.delete();
+  return face2;
+}
+function buildSolidFromMesh(mesh2) {
+  const oc = getKernel().oc;
+  const sewing = new oc.BRepBuilderAPI_Sewing(1e-6, true, true, true, false);
+  let faceCount = 0;
+  try {
+    for (const [v1, v22, v32] of mesh2.triangles) {
+      const va = mesh2.vertices[v1];
+      const vb = mesh2.vertices[v22];
+      const vc = mesh2.vertices[v32];
+      if (!va || !vb || !vc) continue;
+      const triFace = buildTriFace(oc, va, vb, vc);
+      if (triFace !== null) {
+        sewing.Add(triFace);
+        faceCount++;
+      }
+    }
+    if (faceCount === 0) {
+      return err(
+        ioError(BrepErrorCode.THREEMF_IMPORT_FAILED, "No valid triangular faces could be built")
+      );
+    }
+    const progress = new oc.Message_ProgressRange_1();
+    sewing.Perform(progress);
+    progress.delete();
+    const sewn = sewing.SewedShape();
+    const fixer = new oc.ShapeFix_Solid_1();
+    try {
+      const shell2 = oc.TopoDS.Shell_1(sewn);
+      const solid2 = fixer.SolidFromShell(shell2);
+      return ok(castShape(solid2));
+    } catch {
+      return ok(castShape(sewn));
+    } finally {
+      fixer.delete();
+    }
+  } finally {
+    sewing.delete();
   }
-  return s5;
 }
-function resolve3D(s5) {
-  return resolve(s5);
+async function importThreeMF(blob) {
+  try {
+    const arrayBuf = await blob.arrayBuffer();
+    const data = new Uint8Array(arrayBuf);
+    const modelData = extractFromZip(data, "3D/3dmodel.model");
+    if (!modelData) {
+      return err(
+        ioError(
+          BrepErrorCode.THREEMF_IMPORT_FAILED,
+          "3MF archive does not contain 3D/3dmodel.model (or uses unsupported compression)"
+        )
+      );
+    }
+    const xml = new TextDecoder().decode(modelData);
+    const parsed = parseModelXml(xml);
+    if (parsed.vertices.length === 0 || parsed.triangles.length === 0) {
+      return err(
+        ioError(BrepErrorCode.THREEMF_IMPORT_FAILED, "3MF model contains no valid geometry")
+      );
+    }
+    return buildSolidFromMesh(parsed);
+  } catch (e8) {
+    const msg = e8 instanceof Error ? e8.message : String(e8);
+    return err(ioError(BrepErrorCode.THREEMF_IMPORT_FAILED, `3MF import failed: ${msg}`, e8));
+  }
+}
+function resolve(s6) {
+  if ("__wrapped" in s6) {
+    return s6.val;
+  }
+  return s6;
+}
+function resolve3D(s6) {
+  return resolve(s6);
 }
 function box(width, depth, height, options) {
   const oc = getKernel().oc;
-  const r8 = gcWithScope();
-  const maker = r8(new oc.BRepPrimAPI_MakeBox_2(width, depth, height));
+  const r11 = gcWithScope();
+  const maker = r11(new oc.BRepPrimAPI_MakeBox_2(width, depth, height));
   const solid2 = createSolid(maker.Solid());
   const center = options?.at ?? (options?.centered ? [0, 0, 0] : void 0);
   if (center) {
@@ -309,14 +1981,14 @@ function tangentArc(startPoint, startTgt, endPoint) {
 function wire(listOfEdges) {
   return assembleWire(listOfEdges);
 }
-function face(w8, holes) {
-  return makeFace(w8, holes);
+function face(w7, holes) {
+  return makeFace(w7, holes);
 }
-function filledFace(w8) {
-  return makeNonPlanarFace(w8);
+function filledFace(w7) {
+  return makeNonPlanarFace(w7);
 }
-function subFace(originFace, w8) {
-  return makeNewFaceWithinFace(originFace, w8);
+function subFace(originFace, w7) {
+  return makeNewFaceWithinFace(originFace, w7);
 }
 function polygon(points) {
   return makePolygon(points);
@@ -330,14 +2002,14 @@ function compound(shapeArray) {
 function solid(facesOrShells) {
   return makeSolid(facesOrShells);
 }
-function offsetFace(f11, distance, tolerance) {
-  return makeOffset(f11, distance, tolerance);
+function offsetFace(f12, distance, tolerance) {
+  return makeOffset(f12, distance, tolerance);
 }
 function sewShells(facesOrShells, ignoreType) {
   return weldShellsAndFaces(facesOrShells, ignoreType);
 }
-function addHoles(f11, holes) {
-  return addHolesInFace(f11, holes);
+function addHoles(f12, holes) {
+  return addHolesInFace(f12, holes);
 }
 function validateNotNull(shape2, label) {
   if (shape2.wrapped.IsNull()) {
@@ -350,18 +2022,20 @@ function thicken$1(shape2, thickness) {
   if (isErr(check)) return check;
   try {
     const oc = getKernel().oc;
-    const r8 = gcWithScope();
-    const builder = r8(new oc.BRepOffsetAPI_MakeThickSolid());
+    const r11 = gcWithScope();
+    const builder = r11(new oc.BRepOffsetAPI_MakeThickSolid());
     builder.MakeThickSolidBySimple(shape2.wrapped, thickness);
-    const progress = r8(new oc.Message_ProgressRange_1());
+    const progress = r11(new oc.Message_ProgressRange_1());
     builder.Build(progress);
     const resultOc = builder.Shape();
     const cast = castShape(resultOc);
     propagateOrigins(builder, [shape2], cast);
+    propagateFaceTags(builder, [shape2], cast);
+    propagateColors(builder, [shape2], cast);
     return ok(cast);
-  } catch (e10) {
-    const raw = e10 instanceof Error ? e10.message : String(e10);
-    return err(occtError("THICKEN_FAILED", `Thicken operation failed: ${raw}`, e10));
+  } catch (e8) {
+    const raw = e8 instanceof Error ? e8.message : String(e8);
+    return err(occtError("THICKEN_FAILED", `Thicken operation failed: ${raw}`, e8));
   }
 }
 function fillet$1(shape2, edges, radius) {
@@ -403,8 +2077,8 @@ function fillet$1(shape2, edges, radius) {
   }
   try {
     const oc = getKernel().oc;
-    const r8 = gcWithScope();
-    const builder = r8(
+    const r11 = gcWithScope();
+    const builder = r11(
       new oc.BRepFilletAPI_MakeFillet(shape2.wrapped, oc.ChFi3d_FilletShape.ChFi3d_Rational)
     );
     for (const edge of selectedEdges) {
@@ -422,11 +2096,13 @@ function fillet$1(shape2, edges, radius) {
       return err(occtError("FILLET_RESULT_NOT_3D", "Fillet result is not a 3D shape"));
     }
     propagateOrigins(builder, [shape2], cast);
+    propagateFaceTags(builder, [shape2], cast);
+    propagateColors(builder, [shape2], cast);
     return ok(cast);
-  } catch (e10) {
-    const raw = e10 instanceof Error ? e10.message : String(e10);
+  } catch (e8) {
+    const raw = e8 instanceof Error ? e8.message : String(e8);
     return err(
-      occtError("FILLET_FAILED", `Fillet operation failed: ${raw}`, e10, {
+      occtError("FILLET_FAILED", `Fillet operation failed: ${raw}`, e8, {
         operation: "fillet",
         edgeCount: selectedEdges.length,
         radius
@@ -493,15 +2169,15 @@ function chamfer$1(shape2, edges, distance) {
       return edgeFaceMap;
     };
     const oc = getKernel().oc;
-    const r8 = gcWithScope();
-    const builder = r8(new oc.BRepFilletAPI_MakeChamfer(shape2.wrapped));
+    const r11 = gcWithScope();
+    const builder = r11(new oc.BRepFilletAPI_MakeChamfer(shape2.wrapped));
     let edgeFaceMap = null;
     for (const edge of selectedEdges) {
-      const d10 = typeof distance === "function" ? distance(edge) ?? 0 : distance;
-      if (typeof d10 === "number") {
-        if (d10 > 0) builder.Add_2(d10, edge.wrapped);
+      const d9 = typeof distance === "function" ? distance(edge) ?? 0 : distance;
+      if (typeof d9 === "number") {
+        if (d9 > 0) builder.Add_2(d9, edge.wrapped);
       } else {
-        const [d1, d22] = d10;
+        const [d1, d22] = d9;
         if (d1 > 0 && d22 > 0) {
           const face2 = getEdgeFaceMap().get(edge.wrapped.HashCode(2147483647));
           if (face2) {
@@ -516,11 +2192,13 @@ function chamfer$1(shape2, edges, distance) {
       return err(occtError("CHAMFER_RESULT_NOT_3D", "Chamfer result is not a 3D shape"));
     }
     propagateOrigins(builder, [shape2], cast);
+    propagateFaceTags(builder, [shape2], cast);
+    propagateColors(builder, [shape2], cast);
     return ok(cast);
-  } catch (e10) {
-    const raw = e10 instanceof Error ? e10.message : String(e10);
+  } catch (e8) {
+    const raw = e8 instanceof Error ? e8.message : String(e8);
     return err(
-      occtError("CHAMFER_FAILED", `Chamfer operation failed: ${raw}`, e10, {
+      occtError("CHAMFER_FAILED", `Chamfer operation failed: ${raw}`, e8, {
         operation: "chamfer",
         edgeCount: selectedEdges.length,
         distance
@@ -539,13 +2217,13 @@ function shell$1(shape2, faces, thickness, tolerance = 1e-3) {
   }
   try {
     const oc = getKernel().oc;
-    const r8 = gcWithScope();
-    const facesToRemove = r8(new oc.TopTools_ListOfShape_1());
+    const r11 = gcWithScope();
+    const facesToRemove = r11(new oc.TopTools_ListOfShape_1());
     for (const face2 of faces) {
       facesToRemove.Append_1(face2.wrapped);
     }
-    const progress = r8(new oc.Message_ProgressRange_1());
-    const builder = r8(new oc.BRepOffsetAPI_MakeThickSolid());
+    const progress = r11(new oc.Message_ProgressRange_1());
+    const builder = r11(new oc.BRepOffsetAPI_MakeThickSolid());
     builder.MakeThickSolidByJoin(
       shape2.wrapped,
       facesToRemove,
@@ -564,11 +2242,13 @@ function shell$1(shape2, faces, thickness, tolerance = 1e-3) {
       return err(occtError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
     }
     propagateOrigins(builder, [shape2], cast);
+    propagateFaceTags(builder, [shape2], cast);
+    propagateColors(builder, [shape2], cast);
     return ok(cast);
-  } catch (e10) {
-    const raw = e10 instanceof Error ? e10.message : String(e10);
+  } catch (e8) {
+    const raw = e8 instanceof Error ? e8.message : String(e8);
     return err(
-      occtError("SHELL_FAILED", `Shell operation failed: ${raw}`, e10, {
+      occtError("SHELL_FAILED", `Shell operation failed: ${raw}`, e8, {
         operation: "shell",
         faceCount: faces.length,
         thickness
@@ -584,9 +2264,9 @@ function offset$1(shape2, distance, tolerance = 1e-6) {
   }
   try {
     const oc = getKernel().oc;
-    const r8 = gcWithScope();
-    const progress = r8(new oc.Message_ProgressRange_1());
-    const builder = r8(new oc.BRepOffsetAPI_MakeOffsetShape());
+    const r11 = gcWithScope();
+    const progress = r11(new oc.Message_ProgressRange_1());
+    const builder = r11(new oc.BRepOffsetAPI_MakeOffsetShape());
     builder.PerformByJoin(
       shape2.wrapped,
       distance,
@@ -604,10 +2284,12 @@ function offset$1(shape2, distance, tolerance = 1e-6) {
       return err(occtError("OFFSET_RESULT_NOT_3D", "Offset result is not a 3D shape"));
     }
     propagateOrigins(builder, [shape2], cast);
+    propagateFaceTags(builder, [shape2], cast);
+    propagateColors(builder, [shape2], cast);
     return ok(cast);
-  } catch (e10) {
-    const raw = e10 instanceof Error ? e10.message : String(e10);
-    return err(occtError("OFFSET_FAILED", `Offset operation failed: ${raw}`, e10));
+  } catch (e8) {
+    const raw = e8 instanceof Error ? e8.message : String(e8);
+    return err(occtError("OFFSET_FAILED", `Offset operation failed: ${raw}`, e8));
   }
 }
 function translate(shape2, v7) {
@@ -633,18 +2315,21 @@ function applyMatrix(shape2, matrix) {
 function transformCopy(shape2, composed) {
   return transformCopy$1(resolve(shape2), composed);
 }
-function fuse(a10, b11, options) {
-  return fuse$1(resolve(a10), resolve(b11), options);
+function fuse(a9, b11, options) {
+  return fuse$1(resolve(a9), resolve(b11), options);
 }
 function cut(base, tool, options) {
   return cut$1(resolve(base), resolve(tool), options);
 }
-function intersect(a10, b11, options) {
-  return intersect$1(resolve(a10), resolve(b11), options);
+function intersect(a9, b11, options) {
+  return intersect$1(resolve(a9), resolve(b11), options);
 }
 function section(shape2, plane, options) {
   return section$1(resolve(shape2), plane, options);
 }
+function sectionToFace(shape2, plane, options) {
+  return sectionToFace$1(resolve(shape2), plane, options);
+}
 function split(shape2, tools) {
   return split$1(resolve(shape2), tools);
 }
@@ -689,24 +2374,24 @@ function normalizeChamferDistance(distance) {
   return { mode: "standard", distance };
 }
 function fillet(shape2, edgesOrRadius, maybeRadius) {
-  const s5 = resolve(shape2);
+  const s6 = resolve(shape2);
   let edges;
   let radius;
   if (maybeRadius !== void 0) {
-    edges = resolveEdges(edgesOrRadius, s5);
+    edges = resolveEdges(edgesOrRadius, s6);
     radius = maybeRadius;
   } else {
     edges = void 0;
     radius = edgesOrRadius;
   }
-  return fillet$1(s5, edges, normalizeFilletRadius(radius));
+  return fillet$1(s6, edges, normalizeFilletRadius(radius));
 }
 function chamfer(shape2, edgesOrDistance, maybeDistance) {
-  const s5 = resolve(shape2);
+  const s6 = resolve(shape2);
   let edges;
   let distance;
   if (maybeDistance !== void 0) {
-    edges = resolveEdges(edgesOrDistance, s5);
+    edges = resolveEdges(edgesOrDistance, s6);
     distance = maybeDistance;
   } else {
     edges = void 0;
@@ -714,20 +2399,20 @@ function chamfer(shape2, edgesOrDistance, maybeDistance) {
   }
   const normalized = normalizeChamferDistance(distance);
   if (normalized.mode === "distAngle") {
-    const selectedEdges = edges ?? getEdges(s5);
+    const selectedEdges = edges ?? getEdges(s6);
     return chamferDistAngle(
-      s5,
+      s6,
       [...selectedEdges],
       normalized.distance,
       normalized.angle
     );
   }
-  return chamfer$1(s5, edges, normalized.distance);
+  return chamfer$1(s6, edges, normalized.distance);
 }
 function shell(shape2, faces, thickness, options) {
-  const s5 = resolve(shape2);
-  const resolvedFaces = resolveFaces(faces, s5);
-  return shell$1(s5, resolvedFaces, thickness, options?.tolerance);
+  const s6 = resolve(shape2);
+  const resolvedFaces = resolveFaces(faces, s6);
+  return shell$1(s6, resolvedFaces, thickness, options?.tolerance);
 }
 function offset(shape2, distance, options) {
   return offset$1(resolve(shape2), distance, options?.tolerance);
@@ -767,22 +2452,22 @@ function loft$1(wires, { ruled = true, startPoint, endPoint } = {}, returnShell
     return err(validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
   }
   const oc = getKernel().oc;
-  const r8 = gcWithScope();
-  const builder = r8(new oc.BRepOffsetAPI_ThruSections(!returnShell, ruled, 1e-6));
+  const r11 = gcWithScope();
+  const builder = r11(new oc.BRepOffsetAPI_ThruSections(!returnShell, ruled, 1e-6));
   if (startPoint) {
-    const pnt = r8(toOcPnt(toVec3(startPoint)));
-    const vMaker = r8(new oc.BRepBuilderAPI_MakeVertex(pnt));
+    const pnt = r11(toOcPnt(toVec3(startPoint)));
+    const vMaker = r11(new oc.BRepBuilderAPI_MakeVertex(pnt));
     builder.AddVertex(vMaker.Vertex());
   }
-  for (const w8 of wires) {
-    builder.AddWire(w8.wrapped);
+  for (const w7 of wires) {
+    builder.AddWire(w7.wrapped);
   }
   if (endPoint) {
-    const pnt = r8(toOcPnt(toVec3(endPoint)));
-    const vMaker = r8(new oc.BRepBuilderAPI_MakeVertex(pnt));
+    const pnt = r11(toOcPnt(toVec3(endPoint)));
+    const vMaker = r11(new oc.BRepBuilderAPI_MakeVertex(pnt));
     builder.AddVertex(vMaker.Vertex());
   }
-  const progress = r8(new oc.Message_ProgressRange_1());
+  const progress = r11(new oc.Message_ProgressRange_1());
   builder.Build(progress);
   if (!builder.IsDone()) {
     return err(occtError("LOFT_FAILED", "Loft operation failed"));
@@ -794,9 +2479,9 @@ function loft$1(wires, { ruled = true, startPoint, endPoint } = {}, returnShell
   return ok(result);
 }
 function extrude(face2, height) {
-  const f11 = resolve(face2);
+  const f12 = resolve(face2);
   const vec = typeof height === "number" ? [0, 0, height] : height;
-  return extrude$1(f11, vec);
+  return extrude$1(f12, vec);
 }
 function revolve(face2, options) {
   const pivotPoint = options?.at ?? [0, 0, 0];
@@ -808,7 +2493,7 @@ function revolve(face2, options) {
   );
 }
 function loft(wires, options) {
-  const resolvedWires = wires.map((w8) => resolve(w8));
+  const resolvedWires = wires.map((w7) => resolve(w7));
   return loft$1(resolvedWires, options);
 }
 function resolveTargetFace(shape2, faceSpec) {
@@ -819,12 +2504,12 @@ function resolveTargetFace(shape2, faceSpec) {
     }
     let best = faces[0];
     let bestZ = faceCenter(best)[2];
-    for (let i12 = 1; i12 < faces.length; i12++) {
-      const f11 = faces[i12];
-      const z5 = faceCenter(f11)[2];
-      if (z5 > bestZ) {
-        best = f11;
-        bestZ = z5;
+    for (let i8 = 1; i8 < faces.length; i8++) {
+      const f12 = faces[i8];
+      const z6 = faceCenter(f12)[2];
+      if (z6 > bestZ) {
+        best = f12;
+        bestZ = z6;
       }
     }
     return best;
@@ -846,7 +2531,7 @@ function toWire(profile) {
   return profile;
 }
 function drill(shape2, options) {
-  const s5 = resolve(shape2);
+  const s6 = resolve(shape2);
   const { at, radius, axis: rawAxis } = options;
   const axis = rawAxis ?? [0, 0, 1];
   if (radius <= 0) {
@@ -859,7 +2544,7 @@ function drill(shape2, options) {
   const pos = at.length === 2 ? [at[0], at[1], 0] : [at[0], at[1], at[2]];
   let depth = options.depth;
   if (depth === void 0) {
-    const b11 = getBounds(s5);
+    const b11 = getBounds(s6);
     const dx = b11.xMax - b11.xMin;
     const dy = b11.yMax - b11.yMin;
     const dz = b11.zMax - b11.zMin;
@@ -868,49 +2553,49 @@ function drill(shape2, options) {
   const cyl = makeCylinder(radius, depth, pos, dir);
   const startOffset = options.depth === void 0 ? vecScale(dir, -depth / 2) : [0, 0, 0];
   const tool = startOffset[0] !== 0 || startOffset[1] !== 0 || startOffset[2] !== 0 ? translate$1(cyl, startOffset) : cyl;
-  return cut$1(s5, tool);
+  return cut$1(s6, tool);
 }
 function pocket(shape2, options) {
-  const s5 = resolve(shape2);
+  const s6 = resolve(shape2);
   const { profile, depth } = options;
   if (depth <= 0) {
     return err(validationError("POCKET_INVALID_DEPTH", "Pocket depth must be positive"));
   }
-  const targetFace = resolveTargetFace(s5, options.face);
+  const targetFace = resolveTargetFace(s6, options.face);
   const normal = normalAt(targetFace);
-  const w8 = toWire(profile);
-  const faceResult = makeFace(w8);
+  const w7 = toWire(profile);
+  const faceResult = makeFace(w7);
   if (isErr(faceResult)) return faceResult;
   const extDir = vecScale(vecNormalize(normal), -depth);
   const toolResult = extrude$1(faceResult.value, extDir);
   if (isErr(toolResult)) return toolResult;
-  return cut$1(s5, toolResult.value);
+  return cut$1(s6, toolResult.value);
 }
 function boss(shape2, options) {
-  const s5 = resolve(shape2);
+  const s6 = resolve(shape2);
   const { profile, height } = options;
   if (height <= 0) {
     return err(validationError("BOSS_INVALID_HEIGHT", "Boss height must be positive"));
   }
-  const targetFace = resolveTargetFace(s5, options.face);
+  const targetFace = resolveTargetFace(s6, options.face);
   const normal = normalAt(targetFace);
-  const w8 = toWire(profile);
-  const faceResult = makeFace(w8);
+  const w7 = toWire(profile);
+  const faceResult = makeFace(w7);
   if (isErr(faceResult)) return faceResult;
   const extDir = vecScale(vecNormalize(normal), height);
   const toolResult = extrude$1(faceResult.value, extDir);
   if (isErr(toolResult)) return toolResult;
-  return fuse$1(s5, toolResult.value);
+  return fuse$1(s6, toolResult.value);
 }
 function mirrorJoin(shape2, options) {
-  const s5 = resolve(shape2);
+  const s6 = resolve(shape2);
   const normal = options?.normal ?? [1, 0, 0];
   const planeOrigin = options?.at;
-  const mirrored = mirror$1(s5, normal, planeOrigin);
-  return fuse$1(s5, mirrored);
+  const mirrored = mirror$1(s6, normal, planeOrigin);
+  return fuse$1(s6, mirrored);
 }
 function rectangularPattern(shape2, options) {
-  const s5 = resolve(shape2);
+  const s6 = 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"));
@@ -921,10 +2606,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(s5);
+  if (xCount === 1 && yCount === 1) return ok(s6);
   const xNorm = vecNormalize(xDir);
   const yNorm = vecNormalize(yDir);
-  const copies = [s5];
+  const copies = [s6];
   for (let xi = 0; xi < xCount; xi++) {
     for (let yi = 0; yi < yCount; yi++) {
       if (xi === 0 && yi === 0) continue;
@@ -933,7 +2618,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(s5, offset2));
+      copies.push(translate$1(s6, offset2));
     }
   }
   return fuseAll(copies);
@@ -974,12 +2659,12 @@ function createWrappedBase(val) {
     mirror: (opts) => wrapAny(mirror(val, opts)),
     scale: (factor, opts) => wrapAny(scale(val, factor, opts)),
     applyMatrix: (matrix) => wrapAny(applyMatrix(val, matrix)),
-    moveX: (d10) => wrapAny(translate(val, [d10, 0, 0])),
-    moveY: (d10) => wrapAny(translate(val, [0, d10, 0])),
-    moveZ: (d10) => wrapAny(translate(val, [0, 0, d10])),
-    rotateX: (a10) => wrapAny(rotate(val, a10, { axis: [1, 0, 0] })),
-    rotateY: (a10) => wrapAny(rotate(val, a10, { axis: [0, 1, 0] })),
-    rotateZ: (a10) => wrapAny(rotate(val, a10, { axis: [0, 0, 1] })),
+    moveX: (d9) => wrapAny(translate(val, [d9, 0, 0])),
+    moveY: (d9) => wrapAny(translate(val, [0, d9, 0])),
+    moveZ: (d9) => wrapAny(translate(val, [0, 0, d9])),
+    rotateX: (a9) => wrapAny(rotate(val, a9, { axis: [1, 0, 0] })),
+    rotateY: (a9) => wrapAny(rotate(val, a9, { axis: [0, 1, 0] })),
+    rotateZ: (a9) => wrapAny(rotate(val, a9, { axis: [0, 0, 1] })),
     bounds: () => getBounds(val),
     describe: () => describe(val),
     clone: () => wrapAny(clone(val)),
@@ -1058,13 +2743,13 @@ function createWrappedCurve(val) {
     length: () => curveLength(val),
     startPoint: () => curveStartPoint(val),
     endPoint: () => curveEndPoint(val),
-    pointAt: (t8) => curvePointAt(val, t8),
-    tangentAt: (t8) => curveTangentAt(val, t8),
+    pointAt: (t11) => curvePointAt(val, t11),
+    tangentAt: (t11) => curveTangentAt(val, t11),
     isClosed: () => curveIsClosed(val),
     sweep(spine, opts) {
       if (!isWire(val)) throw new Error("sweep requires a Wire");
-      const w8 = val;
-      const result = unwrapOrThrow(sweep(w8, resolve(spine), opts));
+      const w7 = val;
+      const result = unwrapOrThrow(sweep(w7, resolve(spine), opts));
       const shape3D = Array.isArray(result) ? result[0] : result;
       return wrap3D(shape3D);
     }
@@ -1093,15 +2778,15 @@ function wrapAny(val) {
 function wrap3D(val) {
   return createWrapped3D(val);
 }
-function shape(s5) {
-  if (s5 && typeof s5 === "object" && "face" in s5 && typeof s5.face === "function" && "_defaultOrigin" in s5) {
-    return createWrappedFace(s5.face());
+function shape(s6) {
+  if (s6 && typeof s6 === "object" && "face" in s6 && typeof s6.face === "function" && "_defaultOrigin" in s6) {
+    return createWrappedFace(s6.face());
   }
-  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);
+  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);
   }
   throw new Error("shape() requires a Sketch or branded shape type");
 }
@@ -1109,8 +2794,8 @@ export {
   B3 as BaseSketcher2d,
   B as Blueprint,
   a5 as BlueprintSketcher,
-  b5 as Blueprints,
-  e2 as BoundingBox2d,
+  e2 as Blueprints,
+  d2 as BoundingBox2d,
   BrepBugError,
   BrepErrorCode,
   BrepWrapperError,
@@ -1127,19 +2812,20 @@ export {
   R as RAD2DEG,
   S as Sketch,
   S2 as Sketcher,
-  b6 as Sketches,
+  b8 as Sketches,
   a4 as addChild,
   addHoles,
-  b4 as addStep,
+  addMate,
+  b7 as addStep,
   a8 as adjacentFaces,
   a as andThen,
-  g12 as applyGlue,
+  j6 as applyGlue,
   applyMatrix,
-  g5 as approximateCurve,
-  e9 as asTopo,
-  b8 as autoHeal,
-  f4 as axis2d,
-  i6 as basicFaceExtrusion,
+  j3 as approximateCurve,
+  l9 as asTopo,
+  b9 as autoHeal,
+  r4 as axis2d,
+  b6 as basicFaceExtrusion,
   bezier,
   blueprintToDXF,
   boss,
@@ -1148,7 +2834,7 @@ export {
   bug,
   X as cameraFromPlane,
   Y as cameraLookAt,
-  c8 as cast,
+  c4 as cast,
   castShape,
   chamfer,
   chamferDistAngle as chamferDistAngleShape,
@@ -1156,43 +2842,46 @@ export {
   checkInterference,
   circle,
   circularPattern,
-  c6 as classifyPointOnFace,
-  c7 as clearMeshCache,
+  m7 as classifyPointOnFace,
+  c5 as clearMeshCache,
   clone,
-  c2 as collect,
-  d2 as collectShapes,
+  c as collect,
+  d3 as collectShapes,
+  k8 as colorFaces,
+  l7 as colorShape,
   f5 as complexExtrude,
-  w6 as composeTransforms,
+  w5 as composeTransforms,
   compound,
-  c4 as compoundSketchExtrude,
+  c2 as compoundSketchExtrude,
   d4 as compoundSketchFace,
-  e4 as compoundSketchLoft,
+  e3 as compoundSketchLoft,
   f7 as compoundSketchRevolve,
-  b as computationError,
+  b2 as computationError,
+  computeStraightSkeleton,
   cone,
-  c9 as cornerFinder,
+  c6 as cornerFinder,
   g6 as countNodes,
-  h5 as createAssembly,
-  i7 as createAssemblyNode,
+  h4 as createAssembly,
+  i4 as createAssemblyNode,
   createBlueprint,
   Z as createCamera,
-  q as createCompound,
+  s2 as createCompound,
   d8 as createDistanceQuery,
-  o as createEdge,
-  u as createFace,
+  p as createEdge,
+  q as createFace,
   a2 as createHandle,
-  j6 as createHistory,
+  j4 as createHistory,
   b10 as createMeshCache,
-  c5 as createNamedPlane,
-  b2 as createOcHandle,
+  c3 as createNamedPlane,
+  b3 as createOcHandle,
   createOperationRegistry,
   a7 as createPlane,
-  k6 as createRegistry,
-  v2 as createShell,
+  k5 as createRegistry,
+  y as createShell,
   createSolid,
   createTaskQueue,
-  r3 as createVertex,
-  n2 as createWire,
+  t3 as createVertex,
+  createWire,
   createWorkerClient,
   createWorkerHandler,
   curve2dBoundingBox,
@@ -1205,41 +2894,41 @@ export {
   curve2dTangentAt,
   curveEndPoint,
   curveIsClosed,
-  h4 as curveIsPeriodic,
+  k4 as curveIsPeriodic,
   curveLength,
-  i5 as curvePeriod,
+  l4 as curvePeriod,
   curvePointAt,
   curveStartPoint,
   curveTangentAt,
   cut,
-  c3 as cut2D,
+  f6 as cut2D,
   cutAll,
-  d3 as cutBlueprints,
+  l5 as cutBlueprints,
   cylinder,
   dequeueTask,
   describe,
   g9 as deserializeDrawing,
   fromBREP$1 as deserializeShape,
-  d9 as downcast,
-  h6 as draw,
-  i9 as drawCircle,
-  j7 as drawEllipse,
+  d6 as downcast,
+  h5 as draw,
+  i5 as drawCircle,
+  j5 as drawEllipse,
   k7 as drawFaceOutline,
-  l5 as drawParametricFunction,
+  l6 as drawParametricFunction,
   m5 as drawPointsInterpolation,
   n5 as drawPolysides,
-  o6 as drawProjection,
-  p3 as drawRectangle,
-  q3 as drawRoundedRectangle,
-  r6 as drawSingleCircle,
-  s2 as drawSingleEllipse,
-  t5 as drawText,
-  u3 as drawingChamfer,
-  v5 as drawingCut,
-  w5 as drawingFillet,
-  x3 as drawingFuse,
-  y2 as drawingIntersect,
-  z3 as drawingToSketchOnPlane,
+  o5 as drawProjection,
+  p4 as drawRectangle,
+  q4 as drawRoundedRectangle,
+  r7 as drawSingleCircle,
+  s3 as drawSingleEllipse,
+  t6 as drawText,
+  u2 as drawingChamfer,
+  v4 as drawingCut,
+  w4 as drawingFillet,
+  x2 as drawingFuse,
+  y3 as drawingIntersect,
+  z4 as drawingToSketchOnPlane,
   drill,
   edgeFinder,
   e5 as edgesOfFace,
@@ -1252,78 +2941,90 @@ export {
   exportDXF,
   exportGlb,
   exportGltf,
-  e7 as exportIGES,
+  e6 as exportIGES,
   exportOBJ,
   d7 as exportSTEP,
-  f9 as exportSTL,
+  f10 as exportSTL,
   exportThreeMF,
   extrude,
   face,
   faceCenter,
   faceFinder,
-  a9 as faceGeomType,
-  b9 as faceOrientation,
+  f9 as faceGeomType,
+  q6 as faceOrientation,
   f8 as facesOfEdge,
+  p7 as fill,
   filledFace,
   fillet,
-  j4 as findCurveType,
-  n4 as findNode,
-  o4 as findStep,
+  f4 as findCurveType,
+  m6 as findFacesByTag,
+  n3 as findNode,
+  o3 as findStep,
   f2 as flatMap,
-  d6 as flipFaceOrientation,
-  k5 as flipOrientation,
+  r10 as flipFaceOrientation,
+  m3 as flipOrientation,
+  _ as fontMetrics,
   fromBREP,
   f as fromOcDir,
   h as fromOcPnt,
   i as fromOcVec,
   fuse,
-  f6 as fuse2D,
+  g7 as fuse2D,
   fuseAll,
-  e3 as fuseBlueprints,
-  x as gcWithObject,
+  n4 as fuseBlueprints,
+  z2 as gcWithObject,
   gcWithScope,
-  j5 as genericSweep,
+  g5 as genericSweep,
   getBounds,
   getBounds2D,
-  l4 as getCurveType,
+  b5 as getCurveType,
   getEdges,
+  n6 as getFaceColor,
   g10 as getFaceOrigins,
+  o6 as getFaceTags,
   getFaces,
-  _ as getFont,
-  b7 as getHashCode,
-  p as getHistoryShape,
+  $ as getFont,
+  e4 as getHashCode,
+  p2 as getHistoryShape,
   getKernel,
-  m3 as getOrientation,
+  g4 as getOrientation,
   getOrientation2D,
+  q5 as getShapeColor,
   g2 as getShapeKind,
   g8 as getSingleFace,
   getSurfaceType,
+  r9 as getTagMetadata,
   getVertices,
   getWires,
+  guidedSweep,
   heal,
   d5 as healFace,
   g11 as healSolid,
-  j8 as healWire,
+  j7 as healWire,
   helix,
+  hull,
+  importDXF,
   importIGES,
+  importOBJ,
   importSTEP,
   importSTL,
   importSVG,
   importSVGPathD,
+  importThreeMF,
   j as initFromOC,
   innerWires,
-  n3 as interpolateCurve,
+  n2 as interpolateCurve,
   intersect,
-  i8 as intersect2D,
-  g7 as intersectBlueprints,
-  i2 as ioError,
+  k6 as intersect2D,
+  q3 as intersectBlueprints,
+  ioError,
   isChamferRadius,
-  g14 as isCompSolid,
-  i3 as isCompound,
+  s5 as isCompSolid,
+  i2 as isCompound,
   isDisposeRequest,
   isEdge,
   isEmpty,
-  x4 as isEqualShape,
+  x3 as isEqualShape,
   isErr,
   isErrorResponse,
   isFace,
@@ -1333,19 +3034,19 @@ export {
   isNumber,
   g as isOk,
   isOperationRequest,
-  $ as isProjectionPlane,
+  a0 as isProjectionPlane,
   isQueueEmpty,
-  i10 as isSameShape,
+  i6 as isSameShape,
   f3 as isShape1D,
   isShape3D,
-  j3 as isShell,
-  k3 as isSolid,
+  isShell,
+  isSolid,
   isSuccessResponse,
   isValid,
   l2 as isVertex,
   isWire,
-  y3 as iterEdges,
-  z4 as iterFaces,
+  y4 as iterEdges,
+  z5 as iterFaces,
   iterTopo,
   A3 as iterVertices,
   B5 as iterWires,
@@ -1353,79 +3054,86 @@ export {
   kernelCallRaw,
   line,
   linearPattern,
-  a0 as loadFont,
-  t3 as localGC,
+  a1 as loadFont,
+  r3 as localGC,
   loft,
   A2 as makeBaseBox,
-  g4 as makePlane,
-  a1 as makeProjectedEdges,
+  t4 as makePlane,
+  a22 as makeProjectedEdges,
   m as map,
   h2 as mapErr,
   j2 as match,
   measureArea,
-  e8 as measureCurvatureAt,
-  f10 as measureCurvatureAtMid,
-  g13 as measureDistance,
-  h8 as measureLength,
-  i11 as measureLinearProps,
+  e7 as measureCurvatureAt,
+  f11 as measureCurvatureAtMid,
+  g12 as measureDistance,
+  h7 as measureLength,
+  i7 as measureLinearProps,
   measureSurfaceProps,
   measureVolume,
   measureVolumeProps,
   mesh,
   meshEdges,
+  minkowski,
   mirror,
   mirror2D,
   B4 as mirrorDrawing,
   mirrorJoin,
   q2 as modifyStep,
   k2 as moduleInitError,
+  multiSectionSweep,
   normalAt,
   occtError,
   offset,
   offsetFace,
-  o3 as offsetWire2D,
+  o2 as offsetWire2D,
   ok,
-  o5 as organiseBlueprints,
+  o4 as organiseBlueprints,
   outerWire,
   pendingCount,
   z as pipeline,
-  p4 as pivotPlane,
+  p5 as pivotPlane,
   pocket,
-  p5 as pointOnSurface,
+  p6 as pointOnSurface,
   polygon,
+  polyhedron,
   E2 as polysideInnerRadius,
-  p2 as polysidesBlueprint,
-  a22 as projectEdges,
-  e6 as projectPointOnFace,
+  p3 as polysidesBlueprint,
+  a32 as projectEdges,
+  t10 as projectPointOnFace,
   queryError,
   rectangularPattern,
   registerHandler,
-  t4 as registerOperation,
-  u2 as registerShape,
+  t5 as registerOperation,
+  u as registerShape,
   rejectAll,
-  v4 as removeChild,
-  w4 as replayFrom,
-  x2 as replayHistory,
+  v3 as removeChild,
+  x as replayFrom,
+  y2 as replayHistory,
+  C5 as resize,
   resolve,
   resolve3D,
   r as resolveDirection,
-  r7 as resolvePlane,
+  r8 as resolvePlane,
   reverseCurve,
-  r4 as revolution,
+  r5 as revolution,
   revolve,
+  roof,
   rotate,
   rotate2D,
   F2 as rotateDrawing,
-  r5 as roundedRectangleBlueprint,
+  r6 as roundedRectangleBlueprint,
   scale,
   scale2D,
   G as scaleDrawing,
   section,
-  C5 as setShapeOrigin,
+  sectionToFace,
+  D4 as setShapeOrigin,
+  t8 as setTagMetadata,
   sewShells,
   shape,
-  s4 as shapeType,
-  s3 as sharedEdges,
+  v6 as shapeType,
+  s4 as sharedEdges,
   shell,
   simplify,
   sketch2DOnFace,
@@ -1443,28 +3151,33 @@ export {
   R2 as sketchRevolve,
   T as sketchRoundedRectangle,
   U as sketchSweep,
-  a32 as sketchText,
+  a42 as sketchText,
   V as sketchWires,
   s as sketcherStateError,
   slice,
   solid,
+  solveAssembly,
   sphere,
   split,
-  y as stepCount,
-  z2 as stepsFrom,
+  z3 as stepCount,
+  A as stepsFrom,
   stretch2D,
   subFace,
-  A as supportExtrude,
+  B2 as supportExtrude,
+  surfaceFromGrid,
+  surfaceFromImage,
   sweep,
+  u3 as tagFaces,
   tangentArc,
-  a42 as textBlueprints,
+  a52 as textBlueprints,
+  a62 as textMetrics,
   thicken,
   threePointArc,
   toBREP,
-  t7 as toBufferGeometryData,
-  k8 as toGroupedBufferGeometryData,
-  l6 as toLineGeometryData,
-  c as toOcVec,
+  t9 as toBufferGeometryData,
+  k9 as toGroupedBufferGeometryData,
+  l8 as toLineGeometryData,
+  b as toOcVec,
   toSVGPathD,
   t as toVec2,
   toVec3,
@@ -1473,44 +3186,44 @@ export {
   translate,
   translate2D,
   W as translateDrawing,
-  t6 as translatePlane,
+  t7 as translatePlane,
   t2 as tryCatch,
   n as tryCatchAsync,
-  B2 as twistExtrude,
+  C2 as twistExtrude,
   typeCastError,
-  C2 as undoLast,
+  D2 as undoLast,
   unwrap,
   r2 as unwrapErr,
   v as unwrapOr,
   w2 as unwrapOrElse,
-  D2 as updateNode,
+  E as updateNode,
   u4 as uvBounds,
-  h7 as uvCoordinates,
+  h6 as uvCoordinates,
   validationError,
-  v3 as vecAdd,
+  v2 as vecAdd,
   a3 as vecAngle,
-  b3 as vecCross,
+  b4 as vecCross,
   vecDistance,
   d as vecDot,
   e as vecEquals,
   vecIsZero,
   g3 as vecLength,
   h3 as vecLengthSq,
-  i4 as vecNegate,
+  i3 as vecNegate,
   vecNormalize,
-  k4 as vecProjectToPlane,
+  k3 as vecProjectToPlane,
   l3 as vecRepr,
   m2 as vecRotate,
   vecScale,
-  o2 as vecSub,
+  o as vecSub,
   vertex,
   vertexFinder,
   vertexPosition,
-  v6 as verticesOfEdge,
-  E as walkAssembly,
+  v5 as verticesOfEdge,
+  walkAssembly,
   wire,
   wireFinder,
-  w7 as wiresOfFace,
+  w6 as wiresOfFace,
   w as withOcDir,
   k as withOcPnt,
   l as withOcVec,