brepjs 12.8.2 → 12.10.0

package/dist/brepjs.cjs

@@ -45,31 +45,33 @@ var __callDispose = (stack, error, hasError) => {
   return next();
 };
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
-const result = require("./result-fAX0OZzI.cjs");
+const shapeTypes = require("./shapeTypes-T0n6mRmt.cjs");
+const result = require("./result-DULetAht.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const Blueprint = require("./Blueprint-CQ28WJhz.cjs");
-const loft$2 = require("./loft-hp3pc1M7.cjs");
-const operations = require("./operations-CYpmLSC4.cjs");
-const boolean2D = require("./boolean2D-0blbVtJ8.cjs");
-const _2d = require("./2d.cjs");
-const helpers = require("./helpers-C8NoT0Wu.cjs");
+const vectors = require("./vectors-I_0zdD3O.cjs");
+const operations = require("./operations-Ds4xoyxR.cjs");
+const Blueprint = require("./Blueprint-BoC0DsDm.cjs");
+const boolean2D = require("./boolean2D-N9Pgumgg.cjs");
+const _2d = require("./2d-DCxS_sb_.cjs");
+const helpers = require("./helpers-mipaxDTy.cjs");
 const io = require("./io.cjs");
-const drawFns = require("./drawFns-CjRc1NfQ.cjs");
+const drawFns = require("./drawFns-voV2wEp8.cjs");
 const types = require("./types-CA_xrgDq.cjs");
-const vectors = require("./vectors-D_IiZx0q.cjs");
-const shapeFns = require("./shapeFns-C2SnNvdH.cjs");
-const booleanFns = require("./booleanFns-gmsX3Cv2.cjs");
-const topology = require("./topology-ANwCzGL8.cjs");
-const curveFns = require("./curveFns-BZngcnQ1.cjs");
-const faceFns = require("./faceFns-DB1Fc5gy.cjs");
-const meshFns = require("./meshFns-BnV0ZR8w.cjs");
-const measurement = require("./measurement-BoNTUBAp.cjs");
-const surfaceBuilders = require("./surfaceBuilders-5VA34a3_.cjs");
+const shapeFns = require("./shapeFns-bRkrwI8R.cjs");
+const booleanFns = require("./booleanFns-CxArUj_q.cjs");
+const topology = require("./topology-xyDYbkHW.cjs");
+const curveFns = require("./curveFns-CWZRuXQ3.cjs");
+const faceFns = require("./faceFns-CmIrjdt1.cjs");
+const meshFns = require("./meshFns-B9p4EVV8.cjs");
+const topologyQueryFns = require("./topologyQueryFns-0IptTUCo.cjs");
+const measurement = require("./measurement-ph-kanQ7.cjs");
+const surfaceBuilders = require("./surfaceBuilders-DYS8AMSS.cjs");
+const solidBuilders = require("./solidBuilders-BEAoLYvr.cjs");
+const sweepFns = require("./sweepFns-COqeYIUp.cjs");
+const core = require("./core.cjs");
 const query = require("./query.cjs");
-const solidBuilders = require("./solidBuilders-994_MQwB.cjs");
-const cornerFinder = require("./cornerFinder-ZmOyOOsh.cjs");
 const worker = require("./worker.cjs");
+const originTrackingFns = require("./originTrackingFns-SPU7ly3_.cjs");
 function supportsProjection(kernel) {
   return "projectShape" in kernel;
 }
@@ -850,6 +852,30 @@ function warnOnce(key, message) {
   _warned.add(key);
   console.warn(`brepkit: ${message}`);
 }
+function mapNumericTransition(mode) {
+  switch (mode) {
+    case 0:
+      return "rmf";
+    case 1:
+      return "rightCorner";
+    case 2:
+      return "roundCorner";
+    default:
+      return void 0;
+  }
+}
+function mapStringTransition(mode) {
+  switch (mode) {
+    case "right":
+      return "rightCorner";
+    case "round":
+      return "roundCorner";
+    case "transformed":
+      return "rmf";
+    default:
+      return void 0;
+  }
+}
 function hasBooleanOptions(opts) {
   return opts.optimisation !== void 0 || opts.simplify !== void 0 || opts.strategy !== void 0 || opts.fuzzyValue !== void 0;
 }
@@ -1412,19 +1438,33 @@ class BrepkitAdapter {
     const id = this.bk.loft(faceIds);
     return solidHandle(id);
   }
-  sweep(wire, spine, _options) {
-    if (_options?.transitionMode !== void 0) {
-      warnOnce("sweep-transition", "Sweep transition mode not supported; ignored.");
-    }
+  sweep(wire, spine, options) {
+    const contactMode = options?.transitionMode !== void 0 ? mapNumericTransition(options.transitionMode) : void 0;
     const profileHandle = wire;
     const faceId = profileHandle.type === "wire" ? this.bk.makeFaceFromWire(profileHandle.id) : unwrap(wire, "face");
     const spineHandle = spine;
     if (spineHandle.type === "wire") {
       const edges = this.iterShapes(spine, "edge");
       const edgeIds = edges.map((e) => unwrap(e, "edge"));
+      if (contactMode && edgeIds.length === 1) {
+        const edgeId = edgeIds[0];
+        if (edgeId !== void 0) {
+          return solidHandle(this.bk.sweepWithOptions(faceId, edgeId, contactMode, [], 0));
+        }
+      }
+      if (contactMode && edgeIds.length > 1) {
+        warnOnce(
+          "sweep-transition-multi-edge",
+          "Sweep transition mode not supported for multi-edge wires; ignored."
+        );
+      }
       const id2 = this.bk.sweepAlongEdges(faceId, edgeIds);
       return solidHandle(id2);
     }
+    if (contactMode) {
+      const edgeId = unwrap(spine, "edge");
+      return solidHandle(this.bk.sweepWithOptions(faceId, edgeId, contactMode, [], 0));
+    }
     const nurbsData = this.extractNurbsFromEdge(spine);
     if (!nurbsData) {
       throw new Error("brepkit: sweep spine must be an edge or wire");
@@ -1485,25 +1525,58 @@ class BrepkitAdapter {
     return solidHandle(this.bk.filletVariable(solidId, JSON.stringify(spec)));
   }
   chamfer(shape2, edges, distance) {
-    const d = typeof distance === "number" ? distance : Array.isArray(distance) ? distance[0] : 1;
-    if (typeof distance !== "number") {
-      warnOnce(
-        "chamfer-asymmetric",
-        typeof distance === "function" ? "Per-edge chamfer distance function not supported; falling back to distance=1." : "Asymmetric chamfer not supported; using first distance only."
-      );
-    }
+    const solidId = unwrapSolidOrThrow(shape2, "chamfer");
     const edgeIds = edges.map((e) => unwrap(e, "edge"));
-    const id = this.bk.chamfer(unwrapSolidOrThrow(shape2, "chamfer"), edgeIds, d);
-    return solidHandle(id);
+    if (typeof distance === "number") {
+      return solidHandle(this.bk.chamfer(solidId, edgeIds, distance));
+    }
+    if (Array.isArray(distance)) {
+      const [d1, d2] = distance;
+      if (typeof this.bk.chamferAsymmetric === "function") {
+        return solidHandle(this.bk.chamferAsymmetric(solidId, edgeIds, d1, d2));
+      }
+      warnOnce("chamfer-asymmetric", "chamferAsymmetric not available; using averaged distance.");
+      return solidHandle(this.bk.chamfer(solidId, edgeIds, (d1 + d2) / 2));
+    }
+    const groups = /* @__PURE__ */ new Map();
+    for (const [i, edge] of edges.entries()) {
+      const r = distance(edge);
+      const eid = edgeIds[i];
+      if (eid === void 0) continue;
+      const [d1, d2] = Array.isArray(r) ? r : [r, r];
+      const key = `${d1},${d2}`;
+      const group = groups.get(key);
+      if (group) {
+        group.ids.push(eid);
+      } else {
+        groups.set(key, { ids: [eid], d1, d2 });
+      }
+    }
+    let result2 = solidId;
+    for (const group of groups.values()) {
+      if (group.d1 === group.d2) {
+        result2 = this.bk.chamfer(result2, group.ids, group.d1);
+      } else if (typeof this.bk.chamferAsymmetric === "function") {
+        result2 = this.bk.chamferAsymmetric(result2, group.ids, group.d1, group.d2);
+      } else {
+        warnOnce(
+          "chamfer-callback",
+          "chamferAsymmetric not available; asymmetric edges use averaged distance."
+        );
+        result2 = this.bk.chamfer(result2, group.ids, (group.d1 + group.d2) / 2);
+      }
+    }
+    return solidHandle(result2);
   }
   chamferDistAngle(shape2, edges, distance, angleDeg) {
-    warnOnce(
-      "chamfer-dist-angle",
-      "Distance-angle chamfer approximated as averaged two-distance chamfer."
-    );
     const d2 = distance * Math.tan(angleDeg * Math.PI / 180);
-    const avgDist = (distance + d2) / 2;
-    return this.chamfer(shape2, edges, avgDist);
+    const solidId = unwrapSolidOrThrow(shape2, "chamferDistAngle");
+    const edgeIds = edges.map((e) => unwrap(e, "edge"));
+    if (typeof this.bk.chamferAsymmetric === "function") {
+      return solidHandle(this.bk.chamferAsymmetric(solidId, edgeIds, distance, d2));
+    }
+    warnOnce("chamfer-dist-angle", "chamferAsymmetric not available; using averaged distance.");
+    return solidHandle(this.bk.chamfer(solidId, edgeIds, (distance + d2) / 2));
   }
   shell(shape2, faces, thickness, tolerance) {
     if (tolerance !== void 0) {
@@ -1536,6 +1609,49 @@ class BrepkitAdapter {
         if (bestMatch >= 0 && bestDot > 0.99) return bestMatch;
       } catch {
       }
+      try {
+        const origVerts = toArray(this.bk.getFaceVertices(fid));
+        if (origVerts.length >= 1) {
+          let ox = 0, oy = 0, oz = 0;
+          for (const vid of origVerts) {
+            const pos = this.bk.getVertexPosition(vid);
+            ox += pos[0];
+            oy += pos[1];
+            oz += pos[2];
+          }
+          const n = origVerts.length;
+          ox /= n;
+          oy /= n;
+          oz /= n;
+          let bestCentroidMatch = -1;
+          let bestCentroidDist = Infinity;
+          for (const sf of solidFaces) {
+            try {
+              const sv = toArray(this.bk.getFaceVertices(sf));
+              if (sv.length < 1) continue;
+              let sx = 0, sy = 0, sz = 0;
+              for (const svid of sv) {
+                const spos = this.bk.getVertexPosition(svid);
+                sx += spos[0];
+                sy += spos[1];
+                sz += spos[2];
+              }
+              const sn = sv.length;
+              sx /= sn;
+              sy /= sn;
+              sz /= sn;
+              const dist = Math.sqrt((ox - sx) ** 2 + (oy - sy) ** 2 + (oz - sz) ** 2);
+              if (dist < bestCentroidDist) {
+                bestCentroidDist = dist;
+                bestCentroidMatch = sf;
+              }
+            } catch {
+            }
+          }
+          if (bestCentroidMatch >= 0 && bestCentroidDist < 1e-3) return bestCentroidMatch;
+        }
+      } catch {
+      }
       return fid;
     });
     const id = this.bk.shell(solidId, thickness, resolvedFaceIds);
@@ -2836,20 +2952,22 @@ class BrepkitAdapter {
   // Serialization
   // ═══════════════════════════════════════════════════════════════════════
   toBREP(shape2) {
-    warnOnce(
-      "brep-format",
-      "toBREP/fromBREP uses STEP format (not OCCT BREP). Cross-kernel BREP round-trips are not supported."
-    );
+    const h = shape2;
+    if (h.type === "solid") {
+      return this.bk.toBREP(h.id);
+    }
+    warnOnce("brep-non-solid", "toBREP for non-solid shapes uses STEP format.");
     return this.exportSTEP([shape2]);
   }
   fromBREP(data) {
-    warnOnce(
-      "brep-format",
-      "toBREP/fromBREP uses STEP format (not OCCT BREP). Cross-kernel BREP round-trips are not supported."
-    );
+    if (typeof this.bk.fromBREP === "function" && data.trimStart().startsWith("{")) {
+      const id = this.bk.fromBREP(data);
+      return solidHandle(id);
+    }
     const shapes = this.importSTEP(data);
-    if (shapes.length === 0) throw new Error("brepkit: fromBREP produced no shapes");
-    return shapes[0];
+    const first = shapes[0];
+    if (!first) throw new Error("brepkit: fromBREP produced no shapes");
+    return first;
   }
   // ═══════════════════════════════════════════════════════════════════════
   // Mesh preparation
@@ -2882,6 +3000,49 @@ class BrepkitAdapter {
     const profileHandle = profile;
     const faceId = profileHandle.type === "wire" ? this.bk.makeFaceFromWire(profileHandle.id) : unwrap(profile, "face");
     const shellMode = !!(options && options["shellMode"]);
+    const transitionMode = options?.["transitionMode"];
+    const contactMode = transitionMode ? mapStringTransition(transitionMode) : void 0;
+    if (contactMode) {
+      const spineHandle = spine;
+      if (spineHandle.type !== "wire") {
+        try {
+          const edgeId = unwrap(spine, "edge");
+          const shape22 = solidHandle(this.bk.sweepWithOptions(faceId, edgeId, contactMode, [], 0));
+          if (shellMode) return { shape: shape22, firstShape: profile, lastShape: profile };
+          return shape22;
+        } catch (e) {
+          console.warn(
+            "brepkit: sweepWithOptions failed, falling back to sweepSmooth/simplePipe:",
+            e
+          );
+        }
+      } else {
+        const edges = this.iterShapes(spine, "edge");
+        if (edges.length === 1) {
+          const first = edges[0];
+          if (first) {
+            try {
+              const edgeId = unwrap(first, "edge");
+              const shape22 = solidHandle(
+                this.bk.sweepWithOptions(faceId, edgeId, contactMode, [], 0)
+              );
+              if (shellMode) return { shape: shape22, firstShape: profile, lastShape: profile };
+              return shape22;
+            } catch (e) {
+              console.warn(
+                "brepkit: sweepWithOptions failed, falling back to sweepSmooth/simplePipe:",
+                e
+              );
+            }
+          }
+        } else {
+          warnOnce(
+            "sweepPipeShell-transition-multi-edge",
+            "sweepPipeShell transition mode not supported for multi-edge wires; ignored."
+          );
+        }
+      }
+    }
     const nurbsData = this.extractNurbsFromEdge(spine);
     if (nurbsData && nurbsData.degree > 1) {
       try {
@@ -4682,6 +4843,64 @@ function multiplyMatrices(a, b) {
   }
   return result2;
 }
+const kernel_ERROR_PATTERNS = [
+  {
+    pattern: /invalid edge configuration|edges?.*(not|fail|invalid)/i,
+    translation: "The edges may not form a continuous loop. Check that edges connect end-to-end without gaps."
+  },
+  {
+    pattern: /BRepAlgoAPI.*failed|boolean.*operation.*failed/i,
+    translation: "Boolean operation failed. Common causes: overlapping faces, zero-thickness geometry, or degenerate shapes. Try healing input shapes first."
+  },
+  {
+    pattern: /fillet.*radius.*too.*large|fillet.*failed/i,
+    translation: "Fillet operation failed. The radius may be too large for the selected edges. Try reducing the radius or check that edges have enough room."
+  },
+  {
+    pattern: /chamfer.*failed|chamfer.*distance.*too.*large/i,
+    translation: "Chamfer operation failed. The distance may be too large for the selected edges. Try reducing the distance or check edge geometry."
+  },
+  {
+    pattern: /shell.*failed|offset.*failed/i,
+    translation: "Shell/offset operation failed. The thickness may be too large, or the shape may have complex geometry. Try reducing thickness."
+  },
+  {
+    pattern: /sweep.*failed|pipe.*failed/i,
+    translation: "Sweep operation failed. Check that the profile and spine are compatible, and that the spine has no sharp twists or self-intersections."
+  },
+  {
+    pattern: /loft.*failed/i,
+    translation: "Loft operation failed. Profiles may be incompatible or have different orientations. Ensure profiles are ordered consistently."
+  },
+  {
+    pattern: /extrude.*failed|prism.*failed/i,
+    translation: "Extrusion failed. The profile may be invalid or self-intersecting. Check that the profile forms a valid closed wire."
+  },
+  {
+    pattern: /revolve.*failed|revolution.*failed/i,
+    translation: "Revolution operation failed. The profile may intersect the axis of revolution, or the angle may be invalid."
+  },
+  {
+    pattern: /self.*intersect|self-intersect/i,
+    translation: "Shape has self-intersections. The operation resulted in overlapping geometry. Simplify the input or adjust parameters."
+  },
+  {
+    pattern: /degener|degenerat/i,
+    translation: "Degenerate geometry detected. The shape has edges or faces with zero length/area. Check input geometry for collapsed elements."
+  },
+  {
+    pattern: /BRepCheck.*fail|shape.*invalid|shape.*not.*valid/i,
+    translation: "Shape validation failed. The resulting shape has invalid topology. Try healing the shape or checking input geometry."
+  }
+];
+function translateKernelError(kernelMessage) {
+  for (const { pattern, translation } of kernel_ERROR_PATTERNS) {
+    if (pattern.test(kernelMessage)) {
+      return `${translation} (kernel: ${kernelMessage})`;
+    }
+  }
+  return kernelMessage;
+}
 const errorFactories = {
   KERNEL_OPERATION: (code, message, cause) => ({ kind: "KERNEL_OPERATION", code, message, cause }),
   VALIDATION: (code, message, cause) => ({ kind: "VALIDATION", code, message, cause }),
@@ -4700,7 +4919,7 @@ function kernelCall(fn, code, message, kind = "KERNEL_OPERATION") {
     return result.ok(shapeTypes.castShape(fn()));
   } catch (e) {
     const rawMessage = e instanceof Error ? e.message : String(e);
-    const translatedMessage = kind === "KERNEL_OPERATION" ? result.translateKernelError(rawMessage) : rawMessage;
+    const translatedMessage = kind === "KERNEL_OPERATION" ? translateKernelError(rawMessage) : rawMessage;
     return result.err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e));
   }
 }
@@ -4709,7 +4928,7 @@ function kernelCallRaw(fn, code, message, kind = "KERNEL_OPERATION") {
     return result.ok(fn());
   } catch (e) {
     const rawMessage = e instanceof Error ? e.message : String(e);
-    const translatedMessage = kind === "KERNEL_OPERATION" ? result.translateKernelError(rawMessage) : rawMessage;
+    const translatedMessage = kind === "KERNEL_OPERATION" ? translateKernelError(rawMessage) : rawMessage;
     return result.err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e));
   }
 }
@@ -4724,32 +4943,6 @@ function kernelCallScoped(fn, code, message, kind = "KERNEL_OPERATION") {
     __callDispose(_stack, _error, _hasError);
   }
 }
-const CURVE_TYPE_BY_INT = [
-  "LINE",
-  // 0
-  "CIRCLE",
-  // 1
-  "ELLIPSE",
-  // 2
-  "HYPERBOLA",
-  // 3
-  "PARABOLA",
-  // 4
-  "BEZIER_CURVE",
-  // 5
-  "BSPLINE_CURVE",
-  // 6
-  "OFFSET_CURVE",
-  // 7
-  "OTHER_CURVE"
-  // 8
-];
-const findCurveType = (type) => {
-  const idx = typeof type === "number" ? type : Number(type?.value ?? type);
-  const curveType = CURVE_TYPE_BY_INT[idx];
-  if (!curveType) return result.err(result.typeCastError("UNKNOWN_CURVE_TYPE", "Unknown curve type"));
-  return result.ok(curveType);
-};
 const BOPAlgo_GlueShift = 1;
 const BOPAlgo_GlueFull = 2;
 function applyGlue(op, optimisation) {
@@ -4778,35 +4971,14 @@ function isFilletRadius(r) {
   }
   return false;
 }
-function buildWireFinder(filters) {
-  return helpers.createTypedFinder(
-    "wire",
-    filters,
-    buildWireFinder,
-    (_base, withFilter) => ({
-      isClosed: () => withFilter((wire) => curveFns.curveIsClosed(wire)),
-      isOpen: () => withFilter((wire) => !curveFns.curveIsClosed(wire)),
-      ofEdgeCount: (count) => withFilter((wire) => {
-        let edgeCount = 0;
-        for (const _raw of faceFns.iterTopo(wire.wrapped, "edge")) {
-          edgeCount++;
-        }
-        return edgeCount === count;
-      })
-    })
-  );
-}
-function wireFinder() {
-  return buildWireFinder([]);
-}
 function withNearestPostFilter(baseFinder, nearestPoint) {
   const findAllNearest = (shape2) => {
     const candidates = baseFinder.findAll(shape2);
     if (candidates.length === 0) return [];
     let bestIdx = 0;
-    let bestDist = vecOps.vecDistance(shapeFns.vertexPosition(candidates[0]), nearestPoint);
+    let bestDist = vecOps.vecDistance(topologyQueryFns.vertexPosition(candidates[0]), nearestPoint);
     for (let i = 1; i < candidates.length; i++) {
-      const d = vecOps.vecDistance(shapeFns.vertexPosition(candidates[i]), nearestPoint);
+      const d = vecOps.vecDistance(topologyQueryFns.vertexPosition(candidates[i]), nearestPoint);
       if (d < bestDist) {
         bestDist = d;
         bestIdx = i;
@@ -4836,13 +5008,13 @@ function buildVertexFinder(filters) {
     buildVertexFinder,
     (_base, withFilter) => ({
       nearestTo: (point) => withNearestPostFilter(buildVertexFinder(filters), point),
-      atPosition: (point, tolerance = 1e-4) => withFilter((vertex) => vecOps.vecDistance(shapeFns.vertexPosition(vertex), point) < tolerance),
+      atPosition: (point, tolerance = 1e-4) => withFilter((vertex) => vecOps.vecDistance(topologyQueryFns.vertexPosition(vertex), point) < tolerance),
       withinBox: (min, max) => withFilter((vertex) => {
-        const pos = shapeFns.vertexPosition(vertex);
+        const pos = topologyQueryFns.vertexPosition(vertex);
         return pos[0] >= min[0] - 1e-6 && pos[0] <= max[0] + 1e-6 && pos[1] >= min[1] - 1e-6 && pos[1] <= max[1] + 1e-6 && pos[2] >= min[2] - 1e-6 && pos[2] <= max[2] + 1e-6;
       }),
       atDistance: (distance, point = [0, 0, 0], tolerance = 1e-4) => withFilter((vertex) => {
-        const pos = shapeFns.vertexPosition(vertex);
+        const pos = topologyQueryFns.vertexPosition(vertex);
         return Math.abs(vecOps.vecDistance(pos, point) - distance) < tolerance;
       })
     })
@@ -5111,8 +5283,42 @@ function hull(shapes, options = {}) {
     return result.err(result.kernelError(result.BrepErrorCode.HULL_FAILED, `Hull operation failed: ${raw}`, e));
   }
 }
+function convexHull(points) {
+  if (points.length < 4) {
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.HULL_EMPTY_INPUT,
+        `convexHull: at least 4 points required, got ${points.length}`,
+        void 0,
+        void 0,
+        "Provide 4 or more non-coplanar 3D points"
+      )
+    );
+  }
+  try {
+    const kernel = shapeTypes.getKernel();
+    const objPoints = points.map((p) => ({ x: p[0], y: p[1], z: p[2] }));
+    const result$1 = kernel.hullFromPoints(objPoints, 0.1);
+    const cast = shapeTypes.castShape(result$1);
+    if (!shapeTypes.isSolid(cast)) {
+      return result.err(
+        result.kernelError(
+          result.BrepErrorCode.HULL_NOT_3D,
+          "convexHull result is not a solid; points may be coplanar"
+        )
+      );
+    }
+    return result.ok(cast);
+  } catch (e) {
+    const raw = e instanceof Error ? e.message : String(e);
+    if (raw.includes("coplanar") || raw.includes("fewer than") || raw.includes("degenerate")) {
+      return result.err(result.kernelError(result.BrepErrorCode.HULL_DEGENERATE, `convexHull degenerate: ${raw}`, e));
+    }
+    return result.err(result.kernelError(result.BrepErrorCode.HULL_FAILED, `convexHull failed: ${raw}`, e));
+  }
+}
 function detectSphere(shape2) {
-  const faces = shapeFns.getFaces(shape2);
+  const faces = topologyQueryFns.getFaces(shape2);
   if (faces.length !== 1) return null;
   const face = faces[0];
   const surfType = shapeTypes.getKernel().surfaceType(face.wrapped);
@@ -5148,8 +5354,8 @@ function minkowskiSphere(shape2, radius, tolerance) {
 function minkowskiGeneral(shape2, tool, tolerance) {
   const kernel = shapeTypes.getKernel();
   try {
-    const shapeVerts = shapeFns.getVertices(shape2);
-    const toolVerts = shapeFns.getVertices(tool);
+    const shapeVerts = topologyQueryFns.getVertices(shape2);
+    const toolVerts = topologyQueryFns.getVertices(tool);
     if (shapeVerts.length === 0 || toolVerts.length === 0) {
       return result.err(
         result.kernelError(
@@ -5262,95 +5468,6 @@ function polyhedron(points, faces, options = {}) {
     return result.err(result.kernelError(result.BrepErrorCode.POLYHEDRON_FAILED, `Polyhedron failed: ${raw}`, e));
   }
 }
-function multiSectionSweep(sections, spine, options) {
-  if (sections.length < 2) {
-    return result.err(
-      result.validationError(
-        result.BrepErrorCode.MULTI_SWEEP_INSUFFICIENT_SECTIONS,
-        `Multi-section sweep requires at least 2 sections, got ${sections.length}`
-      )
-    );
-  }
-  const { solid = true, ruled = false, tolerance = 1e-6 } = options ?? {};
-  const explicitLocations = sections.map((s) => s.location);
-  for (let i = 0; i < explicitLocations.length; i++) {
-    const loc = explicitLocations[i];
-    if (loc !== void 0 && (loc < 0 || loc > 1)) {
-      return result.err(
-        result.validationError(
-          result.BrepErrorCode.MULTI_SWEEP_FAILED,
-          `Section ${i} location ${loc} is out of range [0, 1]`
-        )
-      );
-    }
-  }
-  const definedLocs = explicitLocations.filter((l) => l !== void 0);
-  for (let i = 1; i < definedLocs.length; i++) {
-    if ((definedLocs[i] ?? 0) <= (definedLocs[i - 1] ?? 0)) {
-      return result.err(
-        result.validationError(
-          result.BrepErrorCode.MULTI_SWEEP_FAILED,
-          "Section locations must be strictly increasing"
-        )
-      );
-    }
-  }
-  try {
-    const kernel = shapeTypes.getKernel();
-    const [uFirst, uLast] = kernel.curveParameters(spine.wrapped);
-    const uRange = uLast - uFirst;
-    const params = sections.map((s, i) => {
-      if (s.location !== void 0) {
-        return uFirst + s.location * uRange;
-      }
-      return uFirst + i / (sections.length - 1) * uRange;
-    });
-    const positionedWires = [];
-    for (let i = 0; i < sections.length; i++) {
-      const param = params[i];
-      const section2 = sections[i];
-      if (param === void 0 || section2 === void 0) continue;
-      const positioned = kernel.positionOnCurve(section2.wire.wrapped, spine.wrapped, param);
-      positionedWires.push(kernel.downcast(positioned, "wire"));
-    }
-    const loftResult = kernel.loftAdvanced(positionedWires, { solid, ruled, tolerance });
-    const result$1 = shapeTypes.castShape(loftResult);
-    if (!shapeTypes.isShape3D(result$1)) {
-      return result.err(
-        result.typeCastError("MULTI_SWEEP_NOT_3D", "Multi-section sweep did not produce a 3D shape")
-      );
-    }
-    return result.ok(result$1);
-  } catch (e) {
-    const raw = e instanceof Error ? e.message : String(e);
-    return result.err(
-      result.kernelError(result.BrepErrorCode.MULTI_SWEEP_FAILED, `Multi-section sweep failed: ${raw}`, e)
-    );
-  }
-}
-function guidedSweep(profile, spine, guides, options = {}) {
-  const { transition = "transformed", solid = true, tolerance } = options;
-  try {
-    const kernel = shapeTypes.getKernel();
-    const shellMode = !solid;
-    const auxiliary = guides.length > 0 ? guides[0]?.wrapped : void 0;
-    const sweepResult = kernel.sweepPipeShell(profile.wrapped, spine.wrapped, {
-      transitionMode: transition,
-      ...auxiliary ? { auxiliary } : {},
-      shellMode,
-      ...tolerance !== void 0 ? { tolerance, boundTolerance: tolerance } : {}
-    });
-    const ocShape = typeof sweepResult === "object" && "shape" in sweepResult ? sweepResult.shape : sweepResult;
-    const result$1 = shapeTypes.castShape(ocShape);
-    if (!shapeTypes.isShape3D(result$1)) {
-      return result.err(result.typeCastError("GUIDED_SWEEP_NOT_3D", "Guided sweep did not produce a 3D shape"));
-    }
-    return result.ok(result$1);
-  } catch (e) {
-    const raw = e instanceof Error ? e.message : String(e);
-    return result.err(result.kernelError(result.BrepErrorCode.GUIDED_SWEEP_FAILED, `Guided sweep failed: ${raw}`, e));
-  }
-}
 const EPS = 1e-10;
 function cross2(ax, ay, bx, by) {
   return ax * by - ay * bx;
@@ -5404,9 +5521,8 @@ function bisector(poly, i) {
   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;
+  if (!node.prev || !node.next) return false;
+  return cross2(node.x - node.prev.x, node.y - node.prev.y, node.next.x - node.x, node.next.y - node.y) < -EPS;
 }
 function createLav(poly) {
   const nodes = poly.map((p, i) => {
@@ -5495,7 +5611,7 @@ function raySplitTime(node, eA, eB) {
 function computeEvents(lavNodes) {
   const events = [];
   for (const node of lavNodes) {
-    if (!node.active) continue;
+    if (!node.active || !node.next) continue;
     const t = bisectorIntersectTime(node, node.next);
     if (t !== null && t > EPS) {
       const x = node.x + t * node.bx;
@@ -5559,6 +5675,7 @@ function computeStraightSkeleton(polygon) {
       } else {
         let cur = activeStart;
         for (let i = 0; i < sz; i++) {
+          if (!cur) break;
           cur.active = false;
           cur = cur.next;
         }
@@ -5698,7 +5815,7 @@ function computeStraightSkeleton(polygon) {
   return { nodes: uniqueNodes, faces };
 }
 function extractPolygon(w) {
-  const edges = shapeFns.getEdges(w);
+  const edges = topologyQueryFns.getEdges(w);
   const pts = edges.map((e) => {
     const pt = curveFns.curveStartPoint(e);
     return { x: pt[0], y: pt[1] };
@@ -6030,7 +6147,7 @@ function checkInterference(shape1, shape2, tolerance = 1e-6) {
 }
 function checkAllInterferences(shapes, tolerance = 1e-6) {
   const pairs = [];
-  const boxes = shapes.map((s) => shapeFns.getBounds(s));
+  const boxes = shapes.map((s) => topologyQueryFns.getBounds(s));
   shapes.forEach((si, i) => {
     for (let j = i + 1; j < shapes.length; j++) {
       if (aabbDisjoint(boxes[i], boxes[j], tolerance)) continue;
@@ -6151,6 +6268,28 @@ async function importDXF(blob, options) {
     }
   }
 }
+function sewMeshToSolid(triangles, errorCode, tolerance = 1e-6) {
+  const kernel = shapeTypes.getKernel();
+  const triFaces = [];
+  for (const [va, vb, vc] of triangles) {
+    const triFace = kernel.buildTriFace(va, vb, vc);
+    if (triFace !== null) {
+      triFaces.push(triFace);
+    }
+  }
+  if (triFaces.length === 0) {
+    return result.err(result.ioError(errorCode, "No valid triangular faces could be built"));
+  }
+  try {
+    return result.ok(shapeTypes.castShape(kernel.sewAndSolidify(triFaces, tolerance)));
+  } catch {
+    try {
+      return result.ok(shapeTypes.castShape(kernel.sew(triFaces, tolerance)));
+    } catch {
+      return result.err(result.ioError(errorCode, "Failed to sew triangular faces"));
+    }
+  }
+}
 async function importOBJ(blob) {
   const text = await blob.text();
   const lines = text.split("\n");
@@ -6186,8 +6325,7 @@ async function importOBJ(blob) {
   }
 }
 function buildSolidFromMesh$1(vertices, faces) {
-  const kernel = shapeTypes.getKernel();
-  const triFaces = [];
+  const triangles = [];
   for (const face of faces) {
     for (let i = 1; i < face.length - 1; i++) {
       const rawA = face[0] ?? 0;
@@ -6200,26 +6338,10 @@ function buildSolidFromMesh$1(vertices, faces) {
       const vb = vertices[bi];
       const vc = vertices[ci];
       if (!va || !vb || !vc) continue;
-      const triFace = kernel.buildTriFace(va, vb, vc);
-      if (triFace !== null) {
-        triFaces.push(triFace);
-      }
-    }
-  }
-  if (triFaces.length === 0) {
-    return result.err(
-      result.ioError(result.BrepErrorCode.OBJ_IMPORT_FAILED, "No valid triangular faces could be built")
-    );
-  }
-  try {
-    return result.ok(shapeTypes.castShape(kernel.sewAndSolidify(triFaces, 1e-6)));
-  } catch {
-    try {
-      return result.ok(shapeTypes.castShape(kernel.sew(triFaces, 1e-6)));
-    } catch {
-      return result.err(result.ioError(result.BrepErrorCode.OBJ_IMPORT_FAILED, "Failed to sew triangular faces"));
+      triangles.push([va, vb, vc]);
     }
   }
+  return sewMeshToSolid(triangles, result.BrepErrorCode.OBJ_IMPORT_FAILED);
 }
 function extractFromZip(data, target) {
   let eocdOffset = -1;
@@ -6325,31 +6447,15 @@ function buildSolidFromMesh(mesh2) {
     const solid = kernel.buildSolidFromFaces(points, faces, 1e-6);
     return result.ok(shapeTypes.castShape(solid));
   } catch {
-    const triFaces = [];
+    const triangles = [];
     for (const [v1, v2, v3] of mesh2.triangles) {
       const va = mesh2.vertices[v1];
       const vb = mesh2.vertices[v2];
       const vc = mesh2.vertices[v3];
       if (!va || !vb || !vc) continue;
-      const triFace = kernel.buildTriFace(va, vb, vc);
-      if (triFace !== null) {
-        triFaces.push(triFace);
-      }
-    }
-    if (triFaces.length === 0) {
-      return result.err(
-        result.ioError(result.BrepErrorCode.THREEMF_IMPORT_FAILED, "No valid triangular faces could be built")
-      );
-    }
-    try {
-      return result.ok(shapeTypes.castShape(kernel.sewAndSolidify(triFaces, 1e-6)));
-    } catch {
-      try {
-        return result.ok(shapeTypes.castShape(kernel.sew(triFaces, 1e-6)));
-      } catch {
-        return result.err(result.ioError(result.BrepErrorCode.THREEMF_IMPORT_FAILED, "Failed to sew triangular faces"));
-      }
+      triangles.push([va, vb, vc]);
     }
+    return sewMeshToSolid(triangles, result.BrepErrorCode.THREEMF_IMPORT_FAILED);
   }
 }
 async function importThreeMF(blob) {
@@ -6378,6 +6484,16 @@ async function importThreeMF(blob) {
     return result.err(result.ioError(result.BrepErrorCode.THREEMF_IMPORT_FAILED, `3MF import failed: ${msg}`, e));
   }
 }
+async function importGLB(blob) {
+  try {
+    const data = await blob.arrayBuffer();
+    const shape2 = shapeTypes.getKernel().importGLB(data);
+    return result.ok(shapeTypes.castShape(shape2));
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return result.err(result.ioError(result.BrepErrorCode.GLB_IMPORT_FAILED, `Failed to import GLB: ${msg}`, e));
+  }
+}
 function resolve(s) {
   if ("__wrapped" in s) {
     return s.val;
@@ -6393,25 +6509,11 @@ function validateNotNull(shape2, label) {
   }
   return result.ok(void 0);
 }
-function collectInputFaceHashes(inputs) {
-  const hasMetadata = inputs.some((s) => {
-    return shapeFns.getFaceOrigins(s) !== void 0 || booleanFns.hasFaceTags(s) || booleanFns.hasColorMetadata(s);
-  });
-  if (!hasMetadata) return [];
-  const hashes = [];
-  for (const input of inputs) {
-    const faces = shapeTypes.getKernel().iterShapes(input.wrapped, "face");
-    for (const face of faces) {
-      hashes.push(face.HashCode(vecOps.HASH_CODE_MAX));
-    }
-  }
-  return hashes;
-}
 function thicken$1(shape2, thickness) {
   const check = validateNotNull(shape2, "thicken: shape");
   if (result.isErr(check)) return check;
   try {
-    const inputFaceHashes = collectInputFaceHashes([shape2]);
+    const inputFaceHashes = booleanFns.collectInputFaceHashes([shape2]);
     const { shape: resultShape, evolution } = shapeTypes.getKernel().thickenWithHistory(
       shape2.wrapped,
       thickness,
@@ -6419,9 +6521,7 @@ function thicken$1(shape2, thickness) {
       vecOps.HASH_CODE_MAX
     );
     const cast = shapeTypes.castShape(resultShape);
-    shapeFns.propagateOriginsFromEvolution(evolution, [shape2], cast);
-    booleanFns.propagateFaceTagsFromEvolution(evolution, [shape2], cast);
-    booleanFns.propagateColorsFromEvolution(evolution, [shape2], cast);
+    booleanFns.propagateAllMetadata(evolution, [shape2], cast);
     return result.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
@@ -6453,7 +6553,7 @@ function fillet$1(shape2, edges, radius) {
       )
     );
   }
-  const selectedEdges = edges ?? shapeFns.getEdges(shape2);
+  const selectedEdges = edges ?? topologyQueryFns.getEdges(shape2);
   if (selectedEdges.length === 0) {
     return result.err(
       result.validationError(
@@ -6501,7 +6601,7 @@ function fillet$1(shape2, edges, radius) {
         )
       );
     }
-    const inputFaceHashes = collectInputFaceHashes([shape2]);
+    const inputFaceHashes = booleanFns.collectInputFaceHashes([shape2]);
     const { shape: resultShape, evolution } = shapeTypes.getKernel().filletWithHistory(
       shape2.wrapped,
       filteredEdges.map((e) => e.wrapped),
@@ -6513,9 +6613,7 @@ function fillet$1(shape2, edges, radius) {
     if (!shapeTypes.isShape3D(cast)) {
       return result.err(result.kernelError(result.BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape"));
     }
-    shapeFns.propagateOriginsFromEvolution(evolution, [shape2], cast);
-    booleanFns.propagateFaceTagsFromEvolution(evolution, [shape2], cast);
-    booleanFns.propagateColorsFromEvolution(evolution, [shape2], cast);
+    booleanFns.propagateAllMetadata(evolution, [shape2], cast);
     return result.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
@@ -6553,7 +6651,7 @@ function chamfer$1(shape2, edges, distance) {
       )
     );
   }
-  const selectedEdges = edges ?? shapeFns.getEdges(shape2);
+  const selectedEdges = edges ?? topologyQueryFns.getEdges(shape2);
   if (selectedEdges.length === 0) {
     return result.err(result.validationError(result.BrepErrorCode.CHAMFER_NO_EDGES, "No edges found for chamfer"));
   }
@@ -6590,7 +6688,7 @@ function chamfer$1(shape2, edges, distance) {
         )
       );
     }
-    const inputFaceHashes = collectInputFaceHashes([shape2]);
+    const inputFaceHashes = booleanFns.collectInputFaceHashes([shape2]);
     const { shape: resultShape, evolution } = shapeTypes.getKernel().chamferWithHistory(
       shape2.wrapped,
       filteredEdges.map((e) => e.wrapped),
@@ -6602,9 +6700,7 @@ function chamfer$1(shape2, edges, distance) {
     if (!shapeTypes.isShape3D(cast)) {
       return result.err(result.kernelError(result.BrepErrorCode.CHAMFER_NOT_3D, "Chamfer result is not a 3D shape"));
     }
-    shapeFns.propagateOriginsFromEvolution(evolution, [shape2], cast);
-    booleanFns.propagateFaceTagsFromEvolution(evolution, [shape2], cast);
-    booleanFns.propagateColorsFromEvolution(evolution, [shape2], cast);
+    booleanFns.propagateAllMetadata(evolution, [shape2], cast);
     return result.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
@@ -6627,7 +6723,7 @@ function shell$1(shape2, faces, thickness, tolerance = 1e-3) {
     return result.err(result.validationError("NO_FACES", "At least one face must be specified for shell"));
   }
   try {
-    const inputFaceHashes = collectInputFaceHashes([shape2]);
+    const inputFaceHashes = booleanFns.collectInputFaceHashes([shape2]);
     const { shape: resultShape, evolution } = shapeTypes.getKernel().shellWithHistory(
       shape2.wrapped,
       faces.map((f) => f.wrapped),
@@ -6640,9 +6736,7 @@ function shell$1(shape2, faces, thickness, tolerance = 1e-3) {
     if (!shapeTypes.isShape3D(cast)) {
       return result.err(result.kernelError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
     }
-    shapeFns.propagateOriginsFromEvolution(evolution, [shape2], cast);
-    booleanFns.propagateFaceTagsFromEvolution(evolution, [shape2], cast);
-    booleanFns.propagateColorsFromEvolution(evolution, [shape2], cast);
+    booleanFns.propagateAllMetadata(evolution, [shape2], cast);
     return result.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
@@ -6662,7 +6756,7 @@ function offset$1(shape2, distance, tolerance = 1e-6) {
     return result.err(result.validationError("ZERO_OFFSET", "Offset distance cannot be zero"));
   }
   try {
-    const inputFaceHashes = collectInputFaceHashes([shape2]);
+    const inputFaceHashes = booleanFns.collectInputFaceHashes([shape2]);
     const { shape: resultShape, evolution } = shapeTypes.getKernel().offsetWithHistory(
       shape2.wrapped,
       distance,
@@ -6674,9 +6768,7 @@ function offset$1(shape2, distance, tolerance = 1e-6) {
     if (!shapeTypes.isShape3D(cast)) {
       return result.err(result.kernelError("OFFSET_RESULT_NOT_3D", "Offset result is not a 3D shape"));
     }
-    shapeFns.propagateOriginsFromEvolution(evolution, [shape2], cast);
-    booleanFns.propagateFaceTagsFromEvolution(evolution, [shape2], cast);
-    booleanFns.propagateColorsFromEvolution(evolution, [shape2], cast);
+    booleanFns.propagateAllMetadata(evolution, [shape2], cast);
     return result.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
@@ -6684,27 +6776,27 @@ function offset$1(shape2, distance, tolerance = 1e-6) {
   }
 }
 function translate(shape2, v) {
-  return shapeFns.translate(resolve(shape2), v);
+  return topology.translate(resolve(shape2), v);
 }
 function rotate(shape2, angle, options) {
   const pivotPoint = options?.at;
-  return shapeFns.rotate(resolve(shape2), angle, pivotPoint, options?.axis);
+  return topology.rotate(resolve(shape2), angle, pivotPoint, options?.axis);
 }
 function mirror(shape2, options) {
   const planeOrigin = options?.at;
-  return shapeFns.mirror(resolve(shape2), options?.normal ?? [1, 0, 0], planeOrigin);
+  return topology.mirror(resolve(shape2), options?.normal ?? [1, 0, 0], planeOrigin);
 }
 function scale(shape2, factor, options) {
-  return shapeFns.scale(resolve(shape2), factor, options?.center);
+  return topology.scale(resolve(shape2), factor, options?.center);
 }
 function clone(shape2) {
   return shapeFns.clone(resolve(shape2));
 }
 function applyMatrix(shape2, matrix) {
-  return shapeFns.applyMatrix(resolve(shape2), matrix);
+  return topology.applyMatrix(resolve(shape2), matrix);
 }
 function transformCopy(shape2, composed) {
-  return shapeFns.transformCopy(resolve(shape2), composed);
+  return topology.transformCopy(resolve(shape2), composed);
 }
 function fuse(a, b, options) {
   return booleanFns.fuse(resolve(a), resolve(b), options);
@@ -6733,7 +6825,7 @@ function resolveEdges(edgesOrFn, shape2) {
   if (typeof edgesOrFn === "object" && "findAll" in edgesOrFn) {
     return edgesOrFn.findAll(shape2);
   }
-  const finder = edgesOrFn(query.edgeFinder());
+  const finder = edgesOrFn(helpers.edgeFinder());
   return finder.findAll(shape2);
 }
 function resolveFaces(facesOrFn, shape2) {
@@ -6787,7 +6879,7 @@ function chamfer(shape2, edgesOrDistance, maybeDistance) {
   }
   const normalized = normalizeChamferDistance(distance);
   if (normalized.mode === "distAngle") {
-    const selectedEdges = edges ?? shapeFns.getEdges(s);
+    const selectedEdges = edges ?? topologyQueryFns.getEdges(s);
     return topology.chamferDistAngle(
       s,
       [...selectedEdges],
@@ -6821,7 +6913,7 @@ function meshEdges(shape2, options) {
   return meshFns.meshEdges(resolve(shape2), options);
 }
 function describe(shape2) {
-  return shapeFns.describe(resolve(shape2));
+  return topologyQueryFns.describe(resolve(shape2));
 }
 function toBREP(shape2) {
   return shapeFns.toBREP(resolve(shape2));
@@ -6835,41 +6927,14 @@ function isValid(shape2) {
 function isEmpty(shape2) {
   return shapeFns.isEmpty(resolve(shape2));
 }
-function loft$1(wires, { ruled = true, startPoint, endPoint, tolerance = 1e-6 } = {}, returnShell = false) {
-  if (wires.length === 0 && !startPoint && !endPoint) {
-    return result.err(result.validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
-  }
-  const kernel = shapeTypes.getKernel();
-  const startVertex = startPoint ? kernel.makeVertex(...types.toVec3(startPoint)) : void 0;
-  const endVertex = endPoint ? kernel.makeVertex(...types.toVec3(endPoint)) : void 0;
-  try {
-    const shape2 = kernel.loftAdvanced(
-      wires.map((w) => w.wrapped),
-      {
-        solid: !returnShell,
-        ruled,
-        tolerance,
-        ...startVertex ? { startVertex } : {},
-        ...endVertex ? { endVertex } : {}
-      }
-    );
-    const result$1 = shapeTypes.castShape(shape2);
-    if (!shapeTypes.isShape3D(result$1)) {
-      return result.err(result.typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
-    }
-    return result.ok(result$1);
-  } catch {
-    return result.err(result.kernelError("LOFT_FAILED", "Loft operation failed"));
-  }
-}
 function extrude(face, height) {
   const f = resolve(face);
   const vec = typeof height === "number" ? [0, 0, height] : height;
-  return operations.extrude(f, vec);
+  return boolean2D.extrude(f, vec);
 }
 function revolve(face, options) {
   const pivotPoint = options?.at ?? [0, 0, 0];
-  return operations.revolve(
+  return boolean2D.revolve(
     resolve(face),
     pivotPoint,
     options?.axis ?? [0, 0, 1],
@@ -6878,11 +6943,11 @@ function revolve(face, options) {
 }
 function loft(wires, options) {
   const resolvedWires = wires.map((w) => resolve(w));
-  return loft$1(resolvedWires, options);
+  return boolean2D.loft(resolvedWires, options);
 }
 function resolveTargetFace(shape2, faceSpec) {
   if (faceSpec === void 0) {
-    const faces = shapeFns.getFaces(shape2);
+    const faces = topologyQueryFns.getFaces(shape2);
     if (faces.length === 0) {
       return result.err(
         result.validationError(result.BrepErrorCode.COMPOUND_NO_FACES, "compoundOps: shape has no faces")
@@ -6937,7 +7002,7 @@ function drill(shape2, options) {
   if (options.depth !== void 0) {
     tool = solidBuilders.makeCylinder(radius, options.depth, pos, dir);
   } else {
-    const b = shapeFns.getBounds(s);
+    const b = topologyQueryFns.getBounds(s);
     const corners = [
       [b.xMin, b.yMin, b.zMin],
       [b.xMax, b.yMin, b.zMin],
@@ -6978,7 +7043,7 @@ function pocket(shape2, options) {
   const faceResult = surfaceBuilders.makeFace(w);
   if (result.isErr(faceResult)) return faceResult;
   const extDir = vecOps.vecScale(vecOps.vecNormalize(normal), -depth);
-  const toolResult = operations.extrude(faceResult.value, extDir);
+  const toolResult = boolean2D.extrude(faceResult.value, extDir);
   if (result.isErr(toolResult)) return toolResult;
   return booleanFns.cut(s, toolResult.value);
 }
@@ -6996,7 +7061,7 @@ function boss(shape2, options) {
   const faceResult = surfaceBuilders.makeFace(w);
   if (result.isErr(faceResult)) return faceResult;
   const extDir = vecOps.vecScale(vecOps.vecNormalize(normal), height);
-  const toolResult = operations.extrude(faceResult.value, extDir);
+  const toolResult = boolean2D.extrude(faceResult.value, extDir);
   if (result.isErr(toolResult)) return toolResult;
   return booleanFns.fuse(s, toolResult.value);
 }
@@ -7004,7 +7069,7 @@ function mirrorJoin(shape2, options) {
   const s = resolve(shape2);
   const normal = options?.normal ?? [1, 0, 0];
   const planeOrigin = options?.at;
-  const mirrored = shapeFns.mirror(s, normal, planeOrigin);
+  const mirrored = topology.mirror(s, normal, planeOrigin);
   return booleanFns.fuse(s, mirrored);
 }
 function rectangularPattern(shape2, options) {
@@ -7031,7 +7096,7 @@ function rectangularPattern(shape2, options) {
         xNorm[1] * xSpacing * xi + yNorm[1] * ySpacing * yi,
         xNorm[2] * xSpacing * xi + yNorm[2] * ySpacing * yi
       ];
-      copies.push(shapeFns.translate(s, offset2));
+      copies.push(topology.translate(s, offset2));
     }
   }
   return booleanFns.fuseAll(copies);
@@ -7078,7 +7143,7 @@ function createWrappedBase(val) {
     rotateX: (a) => wrapAny(rotate(val, a, { axis: [1, 0, 0] })),
     rotateY: (a) => wrapAny(rotate(val, a, { axis: [0, 1, 0] })),
     rotateZ: (a) => wrapAny(rotate(val, a, { axis: [0, 0, 1] })),
-    bounds: () => shapeFns.getBounds(val),
+    bounds: () => topologyQueryFns.getBounds(val),
     describe: () => describe(val),
     clone: () => wrapAny(clone(val)),
     // Meshing & Rendering
@@ -7134,15 +7199,15 @@ function createWrapped3D(val) {
     mirrorJoin: (opts) => wrap3D(unwrapOrThrow(mirrorJoin(val, opts))),
     rectangularPattern: (opts) => wrap3D(unwrapOrThrow(rectangularPattern(val, opts))),
     // Measurement
-    volume: () => measurement.measureVolume(val),
-    area: () => measurement.measureArea(val),
-    volumeProps: () => measurement.measureVolumeProps(val),
-    surfaceProps: () => measurement.measureSurfaceProps(val),
+    volume: () => unwrapOrThrow(measurement.measureVolume(val)),
+    area: () => unwrapOrThrow(measurement.measureArea(val)),
+    volumeProps: () => unwrapOrThrow(measurement.measureVolumeProps(val)),
+    surfaceProps: () => unwrapOrThrow(measurement.measureSurfaceProps(val)),
     // Queries
-    edges: () => shapeFns.getEdges(val),
-    faces: () => shapeFns.getFaces(val),
-    wires: () => shapeFns.getWires(val),
-    vertices: () => shapeFns.getVertices(val),
+    edges: () => topologyQueryFns.getEdges(val),
+    faces: () => topologyQueryFns.getFaces(val),
+    wires: () => topologyQueryFns.getWires(val),
+    vertices: () => topologyQueryFns.getVertices(val),
     // Patterns
     linearPattern: (dir, count, spacing) => wrap3D(unwrapOrThrow(operations.linearPattern(val, dir, count, spacing))),
     circularPattern: (axis, count, angle) => wrap3D(unwrapOrThrow(operations.circularPattern(val, axis, count, angle)))
@@ -7162,7 +7227,7 @@ function createWrappedCurve(val) {
     sweep(spine, opts) {
       if (!shapeTypes.isWire(val)) throw new Error("sweep requires a Wire");
       const w = val;
-      const result2 = unwrapOrThrow(operations.sweep(w, resolve(spine), opts));
+      const result2 = unwrapOrThrow(sweepFns.sweep(w, resolve(spine), opts));
       const shape3D = Array.isArray(result2) ? result2[0] : result2;
       return wrap3D(shape3D);
     }
@@ -7172,7 +7237,7 @@ function createWrappedFace(val) {
   const base = createWrappedBase(val);
   return {
     ...base,
-    area: () => measurement.measureArea(val),
+    area: () => unwrapOrThrow(measurement.measureArea(val)),
     normalAt: (point) => faceFns.normalAt(val, point),
     center: () => faceFns.faceCenter(val),
     surfaceType: () => unwrapOrThrow(faceFns.getSurfaceType(val)),
@@ -7209,7 +7274,6 @@ exports.as2D = shapeTypes.as2D;
 exports.as3D = shapeTypes.as3D;
 exports.castShape = shapeTypes.castShape;
 exports.castShape3D = shapeTypes.castShape3D;
-exports.closedWire = shapeTypes.closedWire;
 exports.createCompound = shapeTypes.createCompound;
 exports.createEdge = shapeTypes.createEdge;
 exports.createFace = shapeTypes.createFace;
@@ -7219,29 +7283,24 @@ exports.createShell = shapeTypes.createShell;
 exports.createSolid = shapeTypes.createSolid;
 exports.createVertex = shapeTypes.createVertex;
 exports.createWire = shapeTypes.createWire;
+exports.getDisposalStats = shapeTypes.getDisposalStats;
 exports.getKernel = shapeTypes.getKernel;
 exports.getShapeKind = shapeTypes.getShapeKind;
 exports.initFromOC = shapeTypes.initFromOC;
 exports.is2D = shapeTypes.is2D;
 exports.is3D = shapeTypes.is3D;
-exports.isClosedWire = shapeTypes.isClosedWire;
 exports.isCompound = shapeTypes.isCompound;
 exports.isEdge = shapeTypes.isEdge;
 exports.isFace = shapeTypes.isFace;
 exports.isLive = shapeTypes.isLive;
-exports.isManifoldShell = shapeTypes.isManifoldShell;
-exports.isOrientedFace = shapeTypes.isOrientedFace;
 exports.isShape1D = shapeTypes.isShape1D;
 exports.isShape3D = shapeTypes.isShape3D;
 exports.isShell = shapeTypes.isShell;
 exports.isSolid = shapeTypes.isSolid;
-exports.isValidSolid = shapeTypes.isValidSolid;
 exports.isVertex = shapeTypes.isVertex;
 exports.isWire = shapeTypes.isWire;
-exports.manifoldShell = shapeTypes.manifoldShell;
-exports.orientedFace = shapeTypes.orientedFace;
 exports.registerKernel = shapeTypes.registerKernel;
-exports.validSolid = shapeTypes.validSolid;
+exports.resetDisposalStats = shapeTypes.resetDisposalStats;
 exports.withKernel = shapeTypes.withKernel;
 exports.withScope = shapeTypes.withScope;
 exports.withScopeResult = shapeTypes.withScopeResult;
@@ -7256,12 +7315,14 @@ exports.collect = result.collect;
 exports.computationError = result.computationError;
 exports.err = result.err;
 exports.flatMap = result.flatMap;
+exports.flatten = result.flatten;
 exports.fromNullable = result.fromNullable;
 exports.ioError = result.ioError;
 exports.isErr = result.isErr;
 exports.isOk = result.isOk;
 exports.kernelError = result.kernelError;
 exports.map = result.map;
+exports.mapBoth = result.mapBoth;
 exports.mapErr = result.mapErr;
 exports.match = result.match;
 exports.moduleInitError = result.moduleInitError;
@@ -7302,18 +7363,16 @@ exports.vecRepr = vecOps.vecRepr;
 exports.vecRotate = vecOps.vecRotate;
 exports.vecScale = vecOps.vecScale;
 exports.vecSub = vecOps.vecSub;
-exports.Blueprint = Blueprint.Blueprint;
-exports.BoundingBox2d = Blueprint.BoundingBox2d;
-exports.Curve2D = Blueprint.Curve2D;
-exports.makePlane = Blueprint.makePlane;
-exports.basicFaceExtrusion = loft$2.basicFaceExtrusion;
-exports.genericSweep = loft$2.genericSweep;
-exports.revolution = loft$2.revolution;
+exports.createNamedPlane = vectors.createNamedPlane;
+exports.createPlane = vectors.createPlane;
+exports.makePlane = vectors.makePlane;
+exports.pivotPlane = vectors.pivotPlane;
+exports.resolvePlane = vectors.resolvePlane;
+exports.translatePlane = vectors.translatePlane;
 exports.addChild = operations.addChild;
 exports.addStep = operations.addStep;
 exports.circularPattern = operations.circularPattern;
 exports.collectShapes = operations.collectShapes;
-exports.complexExtrude = operations.complexExtrude;
 exports.countNodes = operations.countNodes;
 exports.createAssembly = operations.createAssembly;
 exports.createAssemblyNode = operations.createAssemblyNode;
@@ -7334,12 +7393,12 @@ exports.replayHistory = operations.replayHistory;
 exports.serializeHistory = operations.serializeHistory;
 exports.stepCount = operations.stepCount;
 exports.stepsFrom = operations.stepsFrom;
-exports.supportExtrude = operations.supportExtrude;
-exports.sweep = operations.sweep;
-exports.twistExtrude = operations.twistExtrude;
 exports.undoLast = operations.undoLast;
 exports.updateNode = operations.updateNode;
 exports.walkAssembly = operations.walkAssembly;
+exports.Blueprint = Blueprint.Blueprint;
+exports.BoundingBox2d = Blueprint.BoundingBox2d;
+exports.Curve2D = Blueprint.Curve2D;
 exports.BaseSketcher2d = boolean2D.BaseSketcher2d;
 exports.BlueprintSketcher = boolean2D.BlueprintSketcher;
 exports.Blueprints = boolean2D.Blueprints;
@@ -7356,6 +7415,7 @@ exports.organiseBlueprints = boolean2D.organiseBlueprints;
 exports.polysidesBlueprint = boolean2D.polysidesBlueprint;
 exports.roundedRectangleBlueprint = boolean2D.roundedRectangleBlueprint;
 exports.createBlueprint = _2d.createBlueprint;
+exports.createCompoundBlueprint = _2d.createCompoundBlueprint;
 exports.curve2dBoundingBox = _2d.curve2dBoundingBox;
 exports.curve2dDistanceFrom = _2d.curve2dDistanceFrom;
 exports.curve2dFirstPoint = _2d.curve2dFirstPoint;
@@ -7371,13 +7431,15 @@ exports.mirror2D = _2d.mirror2D;
 exports.reverseCurve = _2d.reverseCurve;
 exports.rotate2D = _2d.rotate2D;
 exports.scale2D = _2d.scale2D;
-exports.sketch2DOnFace = _2d.sketch2DOnFace;
-exports.sketch2DOnPlane = _2d.sketch2DOnPlane;
+exports.sketchOnFace2D = _2d.sketchOnFace2D;
+exports.sketchOnPlane2D = _2d.sketchOnPlane2D;
 exports.stretch2D = _2d.stretch2D;
 exports.toSVGPathD = _2d.toSVGPathD;
 exports.translate2D = _2d.translate2D;
+exports.edgeFinder = helpers.edgeFinder;
 exports.faceFinder = helpers.faceFinder;
 exports.getSingleFace = helpers.getSingleFace;
+exports.wireFinder = helpers.wireFinder;
 exports.blueprintToDXF = io.blueprintToDXF;
 exports.exportDXF = io.exportDXF;
 exports.exportGlb = io.exportGlb;
@@ -7453,29 +7515,9 @@ exports.translateDrawing = drawFns.translateDrawing;
 exports.resolveDirection = types.resolveDirection;
 exports.toVec2 = types.toVec2;
 exports.toVec3 = types.toVec3;
-exports.createNamedPlane = vectors.createNamedPlane;
-exports.createPlane = vectors.createPlane;
-exports.pivotPlane = vectors.pivotPlane;
-exports.resolvePlane = vectors.resolvePlane;
-exports.translatePlane = vectors.translatePlane;
-exports.composeTransforms = shapeFns.composeTransforms;
-exports.getBounds = shapeFns.getBounds;
-exports.getEdges = shapeFns.getEdges;
-exports.getFaceOrigins = shapeFns.getFaceOrigins;
-exports.getFaces = shapeFns.getFaces;
 exports.getHashCode = shapeFns.getHashCode;
-exports.getVertices = shapeFns.getVertices;
-exports.getWires = shapeFns.getWires;
-exports.invalidateShapeCache = shapeFns.invalidateShapeCache;
 exports.isEqualShape = shapeFns.isEqualShape;
 exports.isSameShape = shapeFns.isSameShape;
-exports.iterEdges = shapeFns.iterEdges;
-exports.iterFaces = shapeFns.iterFaces;
-exports.iterVertices = shapeFns.iterVertices;
-exports.iterWires = shapeFns.iterWires;
-exports.resize = shapeFns.resize;
-exports.setShapeOrigin = shapeFns.setShapeOrigin;
-exports.vertexPosition = shapeFns.vertexPosition;
 exports.colorFaces = booleanFns.colorFaces;
 exports.colorShape = booleanFns.colorShape;
 exports.cutAll = booleanFns.cutAll;
@@ -7495,6 +7537,7 @@ exports.box = topology.box;
 exports.bsplineApprox = topology.bsplineApprox;
 exports.chamferDistAngleShape = topology.chamferDistAngle;
 exports.circle = topology.circle;
+exports.composeTransforms = topology.composeTransforms;
 exports.compound = topology.compound;
 exports.cone = topology.cone;
 exports.cylinder = topology.cylinder;
@@ -7512,6 +7555,7 @@ exports.helix = topology.helix;
 exports.line = topology.line;
 exports.offsetFace = topology.offsetFace;
 exports.polygon = topology.polygon;
+exports.resize = topology.resize;
 exports.sewShells = topology.sewShells;
 exports.sharedEdges = topology.sharedEdges;
 exports.solid = topology.solid;
@@ -7568,19 +7612,44 @@ exports.createMeshCache = meshFns.createMeshCache;
 exports.exportIGES = meshFns.exportIGES;
 exports.exportSTEP = meshFns.exportSTEP;
 exports.exportSTL = meshFns.exportSTL;
+exports.getBounds = topologyQueryFns.getBounds;
+exports.getEdges = topologyQueryFns.getEdges;
+exports.getFaces = topologyQueryFns.getFaces;
+exports.getVertices = topologyQueryFns.getVertices;
+exports.getWires = topologyQueryFns.getWires;
+exports.invalidateShapeCache = topologyQueryFns.invalidateShapeCache;
+exports.iterEdges = topologyQueryFns.iterEdges;
+exports.iterFaces = topologyQueryFns.iterFaces;
+exports.iterVertices = topologyQueryFns.iterVertices;
+exports.iterWires = topologyQueryFns.iterWires;
+exports.vertexPosition = topologyQueryFns.vertexPosition;
 exports.createDistanceQuery = measurement.createDistanceQuery;
 exports.measureArea = measurement.measureArea;
 exports.measureCurvatureAt = measurement.measureCurvatureAt;
 exports.measureCurvatureAtMid = measurement.measureCurvatureAtMid;
 exports.measureDistance = measurement.measureDistance;
+exports.measureDistanceProps = measurement.measureDistanceProps;
 exports.measureLength = measurement.measureLength;
 exports.measureLinearProps = measurement.measureLinearProps;
 exports.measureSurfaceProps = measurement.measureSurfaceProps;
 exports.measureVolume = measurement.measureVolume;
 exports.measureVolumeProps = measurement.measureVolumeProps;
 exports.fill = surfaceBuilders.fill;
-exports.edgeFinder = query.edgeFinder;
-exports.cornerFinder = cornerFinder.cornerFinder;
+exports.complexExtrude = sweepFns.complexExtrude;
+exports.guidedSweep = sweepFns.guidedSweep;
+exports.multiSectionSweep = sweepFns.multiSectionSweep;
+exports.supportExtrude = sweepFns.supportExtrude;
+exports.sweep = sweepFns.sweep;
+exports.twistExtrude = sweepFns.twistExtrude;
+exports.closedWire = core.closedWire;
+exports.isClosedWire = core.isClosedWire;
+exports.isManifoldShell = core.isManifoldShell;
+exports.isOrientedFace = core.isOrientedFace;
+exports.isValidSolid = core.isValidSolid;
+exports.manifoldShell = core.manifoldShell;
+exports.orientedFace = core.orientedFace;
+exports.validSolid = core.validSolid;
+exports.cornerFinder = query.cornerFinder;
 exports.createOperationRegistry = worker.createOperationRegistry;
 exports.createTaskQueue = worker.createTaskQueue;
 exports.createWorkerClient = worker.createWorkerClient;
@@ -7596,6 +7665,8 @@ exports.isSuccessResponse = worker.isSuccessResponse;
 exports.pendingCount = worker.pendingCount;
 exports.registerHandler = worker.registerHandler;
 exports.rejectAll = worker.rejectAll;
+exports.getFaceOrigins = originTrackingFns.getFaceOrigins;
+exports.setShapeOrigin = originTrackingFns.setShapeOrigin;
 exports.BrepWrapperError = BrepWrapperError;
 exports.BrepkitAdapter = BrepkitAdapter;
 exports.addMate = addMate;
@@ -7607,21 +7678,21 @@ exports.checkAllInterferences = checkAllInterferences;
 exports.checkInterference = checkInterference;
 exports.clone = clone;
 exports.computeStraightSkeleton = computeStraightSkeleton;
+exports.convexHull = convexHull;
 exports.cut = cut;
 exports.describe = describe;
 exports.drill = drill;
 exports.extrude = extrude;
 exports.fillet = fillet;
-exports.findCurveType = findCurveType;
 exports.fromBREP = fromBREP;
 exports.fromKernelDir = fromKernelDir;
 exports.fromKernelPnt = fromKernelPnt;
 exports.fromKernelVec = fromKernelVec;
 exports.fuse = fuse;
-exports.guidedSweep = guidedSweep;
 exports.heal = heal;
 exports.hull = hull;
 exports.importDXF = importDXF;
+exports.importGLB = importGLB;
 exports.importOBJ = importOBJ;
 exports.importThreeMF = importThreeMF;
 exports.intersect = intersect;
@@ -7639,7 +7710,6 @@ exports.meshEdges = meshEdges;
 exports.minkowski = minkowski;
 exports.mirror = mirror;
 exports.mirrorJoin = mirrorJoin;
-exports.multiSectionSweep = multiSectionSweep;
 exports.offset = offset;
 exports.pocket = pocket;
 exports.polyhedron = polyhedron;
@@ -7668,7 +7738,6 @@ exports.toKernelVec = toKernelVec;
 exports.transformCopy = transformCopy;
 exports.translate = translate;
 exports.vertexFinder = vertexFinder;
-exports.wireFinder = wireFinder;
 exports.withKernelDir = withKernelDir;
 exports.withKernelPnt = withKernelPnt;
 exports.withKernelVec = withKernelVec;