brepjs 12.7.3 → 12.8.1

package/dist/brepjs.cjs

@@ -46,30 +46,29 @@ var __callDispose = (stack, error, hasError) => {
 };
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
-const errors = require("./errors-9fDehDNc.cjs");
+const result = require("./result-fAX0OZzI.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const Blueprint = require("./Blueprint-CnDVffSX.cjs");
-const loft$2 = require("./loft-DR1UN5uN.cjs");
-const operations = require("./operations-DLFzmdFX.cjs");
-const boolean2D = require("./boolean2D-DyQJt8Na.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-6kn30cSD.cjs");
+const helpers = require("./helpers-C8NoT0Wu.cjs");
 const io = require("./io.cjs");
-const drawFns = require("./drawFns-CDNafQhv.cjs");
+const drawFns = require("./drawFns-CjRc1NfQ.cjs");
 const types = require("./types-CA_xrgDq.cjs");
-const vectors = require("./vectors-BafmMf96.cjs");
-const shapeFns = require("./shapeFns-D-MOoqJd.cjs");
-const booleanFns = require("./booleanFns-D7HmkpYt.cjs");
-const topology = require("./topology-CKtCGLmb.cjs");
-const curveFns = require("./curveFns-Ch87sD5O.cjs");
-const faceFns = require("./faceFns-BLTEPBKq.cjs");
-const meshFns = require("./meshFns-3gy0empP.cjs");
-const measurement = require("./measurement-DoYXRaKI.cjs");
-const surfaceBuilders = require("./surfaceBuilders-Be_ENWSA.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 query = require("./query.cjs");
-const solidBuilders = require("./solidBuilders-BzfRBizW.cjs");
-const result = require("./result.cjs");
-const cornerFinder = require("./cornerFinder-3zfbQvXg.cjs");
+const solidBuilders = require("./solidBuilders-994_MQwB.cjs");
+const cornerFinder = require("./cornerFinder-ZmOyOOsh.cjs");
 const worker = require("./worker.cjs");
 function supportsProjection(kernel) {
   return "projectShape" in kernel;
@@ -1257,73 +1256,21 @@ class BrepkitAdapter {
     return edgeHandle(id);
   }
   makeTangentArc(startPoint, startTangent, endPoint) {
-    const tLen = Math.sqrt(startTangent[0] ** 2 + startTangent[1] ** 2 + startTangent[2] ** 2);
-    if (tLen < 1e-12) return this.makeLineEdge(startPoint, endPoint);
-    const t = [
-      startTangent[0] / tLen,
-      startTangent[1] / tLen,
-      startTangent[2] / tLen
-    ];
-    const ch = [
-      startPoint[0] - endPoint[0],
-      startPoint[1] - endPoint[1],
-      startPoint[2] - endPoint[2]
-    ];
-    const chDotT = ch[0] * t[0] + ch[1] * t[1] + ch[2] * t[2];
-    const perp = [
-      ch[0] - chDotT * t[0],
-      ch[1] - chDotT * t[1],
-      ch[2] - chDotT * t[2]
-    ];
-    const perpLen = Math.sqrt(perp[0] ** 2 + perp[1] ** 2 + perp[2] ** 2);
-    if (perpLen < 1e-12) return this.makeLineEdge(startPoint, endPoint);
-    const n = [perp[0] / perpLen, perp[1] / perpLen, perp[2] / perpLen];
-    const chord2 = ch[0] ** 2 + ch[1] ** 2 + ch[2] ** 2;
-    const nDotCh = n[0] * ch[0] + n[1] * ch[1] + n[2] * ch[2];
-    const s = -chord2 / (2 * nDotCh);
-    const center = [
-      startPoint[0] + s * n[0],
-      startPoint[1] + s * n[1],
-      startPoint[2] + s * n[2]
-    ];
-    const radius = Math.abs(s);
-    const e1 = [
-      (startPoint[0] - center[0]) / radius,
-      (startPoint[1] - center[1]) / radius,
-      (startPoint[2] - center[2]) / radius
-    ];
-    const e2 = [
-      (endPoint[0] - center[0]) / radius,
-      (endPoint[1] - center[1]) / radius,
-      (endPoint[2] - center[2]) / radius
-    ];
-    let mx = e1[0] + e2[0];
-    let my = e1[1] + e2[1];
-    let mz = e1[2] + e2[2];
-    let mLen = Math.sqrt(mx * mx + my * my + mz * mz);
-    if (mLen < 1e-12) {
-      mx = t[0];
-      my = t[1];
-      mz = t[2];
-      mLen = 1;
-    }
-    const mid = [
-      center[0] + radius * mx / mLen,
-      center[1] + radius * my / mLen,
-      center[2] + radius * mz / mLen
-    ];
-    const toMid = [
-      mid[0] - startPoint[0],
-      mid[1] - startPoint[1],
-      mid[2] - startPoint[2]
-    ];
-    const dotTM = t[0] * toMid[0] + t[1] * toMid[1] + t[2] * toMid[2];
-    if (dotTM < 0) {
-      mid[0] = center[0] - radius * mx / mLen;
-      mid[1] = center[1] - radius * my / mLen;
-      mid[2] = center[2] - radius * mz / mLen;
-    }
-    return this.makeArcEdge(startPoint, mid, endPoint);
+    if (!this.bk.makeTangentArc3d) {
+      throw new Error("makeTangentArc requires brepkit-wasm >= 1.1.0");
+    }
+    const id = this.bk.makeTangentArc3d(
+      startPoint[0],
+      startPoint[1],
+      startPoint[2],
+      startTangent[0],
+      startTangent[1],
+      startTangent[2],
+      endPoint[0],
+      endPoint[1],
+      endPoint[2]
+    );
+    return edgeHandle(id);
   }
   makeHelixWire(pitch, height, radius, center, _direction, leftHanded) {
     const turns = height / pitch;
@@ -2686,8 +2633,8 @@ class BrepkitAdapter {
     if (!isBrepkitHandle(shape2)) return false;
     if (shape2.type !== "solid") return true;
     try {
-      const errors2 = this.bk.validateSolidRelaxed(shape2.id);
-      return errors2 === 0;
+      const errors = this.bk.validateSolidRelaxed(shape2.id);
+      return errors === 0;
     } catch (e) {
       console.warn("brepkit: isValid check failed:", e);
       return false;
@@ -2697,8 +2644,8 @@ class BrepkitAdapter {
     if (!isBrepkitHandle(shape2)) return false;
     if (shape2.type !== "solid") return true;
     try {
-      const errors2 = this.bk.validateSolid(shape2.id);
-      return errors2 === 0;
+      const errors = this.bk.validateSolid(shape2.id);
+      return errors === 0;
     } catch (e) {
       console.warn("brepkit: isValidStrict check failed:", e);
       return false;
@@ -4750,20 +4697,20 @@ const errorFactories = {
 };
 function kernelCall(fn, code, message, kind = "KERNEL_OPERATION") {
   try {
-    return errors.ok(shapeTypes.castShape(fn()));
+    return result.ok(shapeTypes.castShape(fn()));
   } catch (e) {
     const rawMessage = e instanceof Error ? e.message : String(e);
-    const translatedMessage = kind === "KERNEL_OPERATION" ? errors.translateKernelError(rawMessage) : rawMessage;
-    return errors.err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e));
+    const translatedMessage = kind === "KERNEL_OPERATION" ? result.translateKernelError(rawMessage) : rawMessage;
+    return result.err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e));
   }
 }
 function kernelCallRaw(fn, code, message, kind = "KERNEL_OPERATION") {
   try {
-    return errors.ok(fn());
+    return result.ok(fn());
   } catch (e) {
     const rawMessage = e instanceof Error ? e.message : String(e);
-    const translatedMessage = kind === "KERNEL_OPERATION" ? errors.translateKernelError(rawMessage) : rawMessage;
-    return errors.err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e));
+    const translatedMessage = kind === "KERNEL_OPERATION" ? result.translateKernelError(rawMessage) : rawMessage;
+    return result.err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e));
   }
 }
 function kernelCallScoped(fn, code, message, kind = "KERNEL_OPERATION") {
@@ -4800,8 +4747,8 @@ const CURVE_TYPE_BY_INT = [
 const findCurveType = (type) => {
   const idx = typeof type === "number" ? type : Number(type?.value ?? type);
   const curveType = CURVE_TYPE_BY_INT[idx];
-  if (!curveType) return errors.err(errors.typeCastError("UNKNOWN_CURVE_TYPE", "Unknown curve type"));
-  return errors.ok(curveType);
+  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;
@@ -4870,11 +4817,11 @@ function withNearestPostFilter(baseFinder, nearestPoint) {
   const findUniqueNearest = (shape2) => {
     const nearest = findAllNearest(shape2);
     if (nearest.length === 0) {
-      return errors.err(
-        errors.queryError("FINDER_NOT_UNIQUE", "Finder expected a unique match but found 0 element(s)")
+      return result.err(
+        result.queryError("FINDER_NOT_UNIQUE", "Finder expected a unique match but found 0 element(s)")
       );
     }
-    return errors.ok(nearest[0]);
+    return result.ok(nearest[0]);
   };
   return {
     ...baseFinder,
@@ -4951,9 +4898,9 @@ const REC601_G = 0.587;
 const REC601_B = 0.114;
 function surfaceFromGrid(heights, options = {}) {
   if (heights.length < 2) {
-    return errors.err(
-      errors.validationError(
-        errors.BrepErrorCode.SURFACE_GRID_TOO_SMALL,
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.SURFACE_GRID_TOO_SMALL,
         `surfaceFromGrid: need at least 2 rows, got ${heights.length}`
       )
     );
@@ -4961,9 +4908,9 @@ function surfaceFromGrid(heights, options = {}) {
   const rows = heights.length;
   const cols = heights[0]?.length ?? 0;
   if (cols < 2) {
-    return errors.err(
-      errors.validationError(
-        errors.BrepErrorCode.SURFACE_GRID_TOO_SMALL,
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.SURFACE_GRID_TOO_SMALL,
         `surfaceFromGrid: need at least 2 columns, got ${cols}`
       )
     );
@@ -4971,9 +4918,9 @@ function surfaceFromGrid(heights, options = {}) {
   for (let r = 0; r < rows; r++) {
     const row = heights[r];
     if (!row || row.length !== cols) {
-      return errors.err(
-        errors.validationError(
-          errors.BrepErrorCode.SURFACE_GRID_JAGGED,
+      return result.err(
+        result.validationError(
+          result.BrepErrorCode.SURFACE_GRID_JAGGED,
           `surfaceFromGrid: row ${r} has ${row?.length ?? 0} columns, expected ${cols}`
         )
       );
@@ -4990,7 +4937,7 @@ function surfaceFromGrid(heights, options = {}) {
     return buildTriangulatedSurface(heights, rows, cols, dx, dy, scaleZ);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(errors.kernelError(errors.BrepErrorCode.SURFACE_FAILED, `surfaceFromGrid failed: ${raw}`, e));
+    return result.err(result.kernelError(result.BrepErrorCode.SURFACE_FAILED, `surfaceFromGrid failed: ${raw}`, e));
   }
 }
 function buildBSplineSurface(heights, rows, cols, dx, dy, scaleZ) {
@@ -5005,10 +4952,10 @@ function buildBSplineSurface(heights, rows, cols, dx, dy, scaleZ) {
   const faceShape = shapeTypes.getKernel().bsplineSurface(points, rows, cols);
   const shape2 = shapeTypes.castShape(faceShape);
   if (shapeTypes.isFace(shape2)) {
-    return errors.ok(shape2);
+    return result.ok(shape2);
   }
   shape2[Symbol.dispose]();
-  return errors.err(errors.kernelError(errors.BrepErrorCode.SURFACE_FAILED, "B-spline surface did not produce a face"));
+  return result.err(result.kernelError(result.BrepErrorCode.SURFACE_FAILED, "B-spline surface did not produce a face"));
 }
 function buildTriangulatedSurface(heights, rows, cols, dx, dy, scaleZ) {
   const points = [];
@@ -5022,23 +4969,23 @@ function buildTriangulatedSurface(heights, rows, cols, dx, dy, scaleZ) {
   const resultShape = shapeTypes.getKernel().triangulatedSurface(points, rows, cols);
   const shape2 = shapeTypes.castShape(resultShape);
   if (shapeTypes.isFace(shape2)) {
-    return errors.ok(shape2);
+    return result.ok(shape2);
   }
   if (shapeTypes.isShell(shape2)) {
-    return errors.ok(shape2);
+    return result.ok(shape2);
   }
   shape2[Symbol.dispose]();
-  return errors.err(
-    errors.kernelError(errors.BrepErrorCode.SURFACE_FAILED, "surfaceFromGrid: unexpected shape type from sewing")
+  return result.err(
+    result.kernelError(result.BrepErrorCode.SURFACE_FAILED, "surfaceFromGrid: unexpected shape type from sewing")
   );
 }
 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 errors.err(
-      errors.ioError(
-        errors.BrepErrorCode.SURFACE_FAILED,
+    return result.err(
+      result.ioError(
+        result.BrepErrorCode.SURFACE_FAILED,
         "surfaceFromImage requires createImageBitmap (not available in this environment)"
       )
     );
@@ -5047,9 +4994,9 @@ async function surfaceFromImage(blob, options = {}) {
   try {
     bitmap = await createImageBitmap(blob);
   } catch (e) {
-    return errors.err(
-      errors.ioError(
-        errors.BrepErrorCode.SURFACE_FAILED,
+    return result.err(
+      result.ioError(
+        result.BrepErrorCode.SURFACE_FAILED,
         `surfaceFromImage: failed to decode image — ${e instanceof Error ? e.message : String(e)}`
       )
     );
@@ -5058,18 +5005,18 @@ async function surfaceFromImage(blob, options = {}) {
   const h = bitmap.height;
   if (w < 2 || h < 2) {
     bitmap.close();
-    return errors.err(
-      errors.validationError(
-        errors.BrepErrorCode.SURFACE_GRID_TOO_SMALL,
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.SURFACE_GRID_TOO_SMALL,
         `surfaceFromImage: image too small (${w}x${h}), need at least 2x2`
       )
     );
   }
   if (typeof OffscreenCanvas !== "function") {
     bitmap.close();
-    return errors.err(
-      errors.ioError(
-        errors.BrepErrorCode.SURFACE_FAILED,
+    return result.err(
+      result.ioError(
+        result.BrepErrorCode.SURFACE_FAILED,
         "surfaceFromImage requires OffscreenCanvas (not available in this environment)"
       )
     );
@@ -5078,8 +5025,8 @@ async function surfaceFromImage(blob, options = {}) {
   const ctx = canvas.getContext("2d");
   if (!ctx) {
     bitmap.close();
-    return errors.err(
-      errors.ioError(errors.BrepErrorCode.SURFACE_FAILED, "surfaceFromImage: could not get 2D canvas context")
+    return result.err(
+      result.ioError(result.BrepErrorCode.SURFACE_FAILED, "surfaceFromImage: could not get 2D canvas context")
     );
   }
   ctx.drawImage(bitmap, 0, 0);
@@ -5121,15 +5068,15 @@ async function surfaceFromImage(blob, options = {}) {
 }
 function validateNotNull$1(shape2, label) {
   if (shapeTypes.getKernel().isNull(shape2.wrapped)) {
-    return errors.err(errors.validationError(errors.BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
+    return result.err(result.validationError(result.BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
   }
-  return errors.ok(void 0);
+  return result.ok(void 0);
 }
 function hull(shapes, options = {}) {
   if (shapes.length === 0) {
-    return errors.err(
-      errors.validationError(
-        errors.BrepErrorCode.HULL_EMPTY_INPUT,
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.HULL_EMPTY_INPUT,
         "hull: at least one shape is required",
         void 0,
         void 0,
@@ -5139,7 +5086,7 @@ function hull(shapes, options = {}) {
   }
   for (const [i, shape2] of shapes.entries()) {
     const check = validateNotNull$1(shape2, `hull: shapes[${i}]`);
-    if (errors.isErr(check)) return check;
+    if (result.isErr(check)) return check;
   }
   const tolerance = options.tolerance ?? 0.1;
   try {
@@ -5148,20 +5095,20 @@ function hull(shapes, options = {}) {
     const resultOc = kernel.hull(ocShapes, tolerance);
     const cast = shapeTypes.castShape(resultOc);
     if (!shapeTypes.isSolid(cast)) {
-      return errors.err(
-        errors.kernelError(
-          errors.BrepErrorCode.HULL_NOT_3D,
+      return result.err(
+        result.kernelError(
+          result.BrepErrorCode.HULL_NOT_3D,
           "Hull result is not a solid; input may be degenerate"
         )
       );
     }
-    return errors.ok(cast);
+    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 errors.err(errors.kernelError(errors.BrepErrorCode.HULL_DEGENERATE, `Hull degenerate: ${raw}`, e));
+      return result.err(result.kernelError(result.BrepErrorCode.HULL_DEGENERATE, `Hull degenerate: ${raw}`, e));
     }
-    return errors.err(errors.kernelError(errors.BrepErrorCode.HULL_FAILED, `Hull operation failed: ${raw}`, e));
+    return result.err(result.kernelError(result.BrepErrorCode.HULL_FAILED, `Hull operation failed: ${raw}`, e));
   }
 }
 function detectSphere(shape2) {
@@ -5180,18 +5127,18 @@ function minkowskiSphere(shape2, radius, tolerance) {
     const wrapped = shapeTypes.castShape(resultShape);
     if (!shapeTypes.isShape3D(wrapped)) {
       wrapped[Symbol.dispose]();
-      return errors.err(
-        errors.typeCastError(
-          errors.BrepErrorCode.MINKOWSKI_NOT_3D,
+      return result.err(
+        result.typeCastError(
+          result.BrepErrorCode.MINKOWSKI_NOT_3D,
           "Minkowski sphere offset did not produce a 3D shape"
         )
       );
     }
-    return errors.ok(wrapped);
+    return result.ok(wrapped);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(
-      errors.kernelError(errors.BrepErrorCode.MINKOWSKI_FAILED, `Minkowski sphere offset failed: ${raw}`, e, {
+    return result.err(
+      result.kernelError(result.BrepErrorCode.MINKOWSKI_FAILED, `Minkowski sphere offset failed: ${raw}`, e, {
         operation: "minkowski",
         fastPath: "sphere"
       })
@@ -5204,9 +5151,9 @@ function minkowskiGeneral(shape2, tool, tolerance) {
     const shapeVerts = shapeFns.getVertices(shape2);
     const toolVerts = shapeFns.getVertices(tool);
     if (shapeVerts.length === 0 || toolVerts.length === 0) {
-      return errors.err(
-        errors.kernelError(
-          errors.BrepErrorCode.MINKOWSKI_FAILED,
+      return result.err(
+        result.kernelError(
+          result.BrepErrorCode.MINKOWSKI_FAILED,
           "Minkowski sum: one or both shapes have no vertices",
           void 0,
           {
@@ -5227,15 +5174,15 @@ function minkowskiGeneral(shape2, tool, tolerance) {
     const wrapped = shapeTypes.castShape(hullShape);
     if (!shapeTypes.isShape3D(wrapped)) {
       wrapped[Symbol.dispose]();
-      return errors.err(
-        errors.typeCastError(errors.BrepErrorCode.MINKOWSKI_NOT_3D, "Minkowski hull did not produce a 3D shape")
+      return result.err(
+        result.typeCastError(result.BrepErrorCode.MINKOWSKI_NOT_3D, "Minkowski hull did not produce a 3D shape")
       );
     }
-    return errors.ok(wrapped);
+    return result.ok(wrapped);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(
-      errors.kernelError(errors.BrepErrorCode.MINKOWSKI_FAILED, `Minkowski general path failed: ${raw}`, e, {
+    return result.err(
+      result.kernelError(result.BrepErrorCode.MINKOWSKI_FAILED, `Minkowski general path failed: ${raw}`, e, {
         operation: "minkowski"
       })
     );
@@ -5244,16 +5191,16 @@ function minkowskiGeneral(shape2, tool, tolerance) {
 function minkowski(shape2, tool, options = {}) {
   const { tolerance = 1e-6 } = options;
   if (shapeTypes.getKernel().isNull(shape2.wrapped)) {
-    return errors.err(errors.validationError(errors.BrepErrorCode.NULL_SHAPE_INPUT, "minkowski: shape is a null shape"));
+    return result.err(result.validationError(result.BrepErrorCode.NULL_SHAPE_INPUT, "minkowski: shape is a null shape"));
   }
   if (shapeTypes.getKernel().isNull(tool.wrapped)) {
-    return errors.err(
-      errors.validationError(errors.BrepErrorCode.MINKOWSKI_NULL_TOOL, "minkowski: tool is a null shape")
+    return result.err(
+      result.validationError(result.BrepErrorCode.MINKOWSKI_NULL_TOOL, "minkowski: tool is a null shape")
     );
   }
   if (!shapeTypes.isShape3D(shape2) || !shapeTypes.isShape3D(tool)) {
-    return errors.err(
-      errors.validationError(errors.BrepErrorCode.MINKOWSKI_NOT_3D, "minkowski: both shape and tool must be 3D")
+    return result.err(
+      result.validationError(result.BrepErrorCode.MINKOWSKI_NOT_3D, "minkowski: both shape and tool must be 3D")
     );
   }
   const sphereRadius = detectSphere(tool);
@@ -5265,17 +5212,17 @@ function minkowski(shape2, tool, options = {}) {
 function polyhedron(points, faces, options = {}) {
   const { tolerance = 1e-6 } = options;
   if (points.length < 4) {
-    return errors.err(
-      errors.validationError(
-        errors.BrepErrorCode.POLYHEDRON_INSUFFICIENT_POINTS,
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.POLYHEDRON_INSUFFICIENT_POINTS,
         `polyhedron: need at least 4 points, got ${points.length}`
       )
     );
   }
   if (faces.length < 4) {
-    return errors.err(
-      errors.validationError(
-        errors.BrepErrorCode.POLYHEDRON_INSUFFICIENT_FACES,
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.POLYHEDRON_INSUFFICIENT_FACES,
         `polyhedron: need at least 4 faces, got ${faces.length}`
       )
     );
@@ -5284,9 +5231,9 @@ function polyhedron(points, faces, options = {}) {
   for (const [fi, face] of faces.entries()) {
     for (const idx of face) {
       if (idx < 0 || idx >= points.length) {
-        return errors.err(
-          errors.validationError(
-            errors.BrepErrorCode.POLYHEDRON_INVALID_INDEX,
+        return result.err(
+          result.validationError(
+            result.BrepErrorCode.POLYHEDRON_INVALID_INDEX,
             `polyhedron: face ${fi} has out-of-range index ${idx} (${points.length} points)`
           )
         );
@@ -5305,21 +5252,21 @@ function polyhedron(points, faces, options = {}) {
     const cast = shapeTypes.castShape(resultOc);
     if (!shapeTypes.isSolid(cast)) {
       cast[Symbol.dispose]();
-      return errors.err(
-        errors.kernelError(errors.BrepErrorCode.POLYHEDRON_FAILED, "Polyhedron did not produce a solid")
+      return result.err(
+        result.kernelError(result.BrepErrorCode.POLYHEDRON_FAILED, "Polyhedron did not produce a solid")
       );
     }
-    return errors.ok(cast);
+    return result.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(errors.kernelError(errors.BrepErrorCode.POLYHEDRON_FAILED, `Polyhedron failed: ${raw}`, e));
+    return result.err(result.kernelError(result.BrepErrorCode.POLYHEDRON_FAILED, `Polyhedron failed: ${raw}`, e));
   }
 }
 function multiSectionSweep(sections, spine, options) {
   if (sections.length < 2) {
-    return errors.err(
-      errors.validationError(
-        errors.BrepErrorCode.MULTI_SWEEP_INSUFFICIENT_SECTIONS,
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.MULTI_SWEEP_INSUFFICIENT_SECTIONS,
         `Multi-section sweep requires at least 2 sections, got ${sections.length}`
       )
     );
@@ -5329,9 +5276,9 @@ function multiSectionSweep(sections, spine, options) {
   for (let i = 0; i < explicitLocations.length; i++) {
     const loc = explicitLocations[i];
     if (loc !== void 0 && (loc < 0 || loc > 1)) {
-      return errors.err(
-        errors.validationError(
-          errors.BrepErrorCode.MULTI_SWEEP_FAILED,
+      return result.err(
+        result.validationError(
+          result.BrepErrorCode.MULTI_SWEEP_FAILED,
           `Section ${i} location ${loc} is out of range [0, 1]`
         )
       );
@@ -5340,9 +5287,9 @@ function multiSectionSweep(sections, spine, options) {
   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 errors.err(
-        errors.validationError(
-          errors.BrepErrorCode.MULTI_SWEEP_FAILED,
+      return result.err(
+        result.validationError(
+          result.BrepErrorCode.MULTI_SWEEP_FAILED,
           "Section locations must be strictly increasing"
         )
       );
@@ -5367,17 +5314,17 @@ function multiSectionSweep(sections, spine, options) {
       positionedWires.push(kernel.downcast(positioned, "wire"));
     }
     const loftResult = kernel.loftAdvanced(positionedWires, { solid, ruled, tolerance });
-    const result2 = shapeTypes.castShape(loftResult);
-    if (!shapeTypes.isShape3D(result2)) {
-      return errors.err(
-        errors.typeCastError("MULTI_SWEEP_NOT_3D", "Multi-section sweep did not produce a 3D shape")
+    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 errors.ok(result2);
+    return result.ok(result$1);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(
-      errors.kernelError(errors.BrepErrorCode.MULTI_SWEEP_FAILED, `Multi-section sweep failed: ${raw}`, e)
+    return result.err(
+      result.kernelError(result.BrepErrorCode.MULTI_SWEEP_FAILED, `Multi-section sweep failed: ${raw}`, e)
     );
   }
 }
@@ -5394,14 +5341,14 @@ function guidedSweep(profile, spine, guides, options = {}) {
       ...tolerance !== void 0 ? { tolerance, boundTolerance: tolerance } : {}
     });
     const ocShape = typeof sweepResult === "object" && "shape" in sweepResult ? sweepResult.shape : sweepResult;
-    const result2 = shapeTypes.castShape(ocShape);
-    if (!shapeTypes.isShape3D(result2)) {
-      return errors.err(errors.typeCastError("GUIDED_SWEEP_NOT_3D", "Guided sweep did not produce a 3D shape"));
+    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 errors.ok(result2);
+    return result.ok(result$1);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(errors.kernelError(errors.BrepErrorCode.GUIDED_SWEEP_FAILED, `Guided sweep failed: ${raw}`, e));
+    return result.err(result.kernelError(result.BrepErrorCode.GUIDED_SWEEP_FAILED, `Guided sweep failed: ${raw}`, e));
   }
 }
 const EPS = 1e-10;
@@ -5836,17 +5783,17 @@ function roof(w, options) {
   try {
     const polygon = extractPolygon(w);
     if (polygon.length < 3) {
-      return errors.err(
-        errors.kernelError(
-          errors.BrepErrorCode.ROOF_FAILED,
+      return result.err(
+        result.kernelError(
+          result.BrepErrorCode.ROOF_FAILED,
           "Wire must have at least 3 edges for roof generation"
         )
       );
     }
     const skeleton = computeStraightSkeleton(polygon);
     if (skeleton.faces.length === 0) {
-      return errors.err(
-        errors.kernelError(errors.BrepErrorCode.ROOF_FAILED, "Straight skeleton computation produced no faces")
+      return result.err(
+        result.kernelError(result.BrepErrorCode.ROOF_FAILED, "Straight skeleton computation produced no faces")
       );
     }
     const kernel = shapeTypes.getKernel();
@@ -5896,24 +5843,24 @@ function roof(w, options) {
       }
     }
     if (triFaces.length === 0) {
-      return errors.err(
-        errors.kernelError(errors.BrepErrorCode.ROOF_FAILED, "No valid triangular faces could be built")
+      return result.err(
+        result.kernelError(result.BrepErrorCode.ROOF_FAILED, "No valid triangular faces could be built")
       );
     }
     try {
       const solid = kernel.sewAndSolidify(triFaces, 1e-6);
       const fixed = kernel.fixShape(solid);
-      return errors.ok(shapeTypes.createSolid(fixed));
+      return result.ok(shapeTypes.createSolid(fixed));
     } catch {
       try {
-        return errors.ok(shapeTypes.createSolid(kernel.sew(triFaces, 1e-6)));
+        return result.ok(shapeTypes.createSolid(kernel.sew(triFaces, 1e-6)));
       } catch {
-        return errors.err(errors.kernelError(errors.BrepErrorCode.ROOF_FAILED, "Failed to sew roof faces"));
+        return result.err(result.kernelError(result.BrepErrorCode.ROOF_FAILED, "Failed to sew roof faces"));
       }
     }
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
-    return errors.err(errors.kernelError(errors.BrepErrorCode.ROOF_FAILED, `Roof generation failed: ${msg}`, e));
+    return result.err(result.kernelError(result.BrepErrorCode.ROOF_FAILED, `Roof generation failed: ${msg}`, e));
   }
 }
 const UNSUPPORTED_DOF = {
@@ -5984,14 +5931,14 @@ function extractPair(a, b) {
   const entA = extractEntity(a);
   const entB = extractEntity(b);
   if (!entA || !entB) {
-    return errors.err(
-      errors.validationError(
-        errors.BrepErrorCode.ASSEMBLY_MATE_INVALID,
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.ASSEMBLY_MATE_INVALID,
         "solveAssembly: could not extract geometry from mate entities"
       )
     );
   }
-  return errors.ok({
+  return result.ok({
     entityA: { node: a.node, entity: entA },
     entityB: { node: b.node, entity: entB }
   });
@@ -6003,8 +5950,8 @@ function addMate(assembly, constraint) {
 function solveAssembly(assembly) {
   const mates = assembly.mates;
   if (!mates || mates.length === 0) {
-    return errors.err(
-      errors.validationError(errors.BrepErrorCode.ASSEMBLY_MATE_INVALID, "solveAssembly: no mates defined")
+    return result.err(
+      result.validationError(result.BrepErrorCode.ASSEMBLY_MATE_INVALID, "solveAssembly: no mates defined")
     );
   }
   try {
@@ -6039,42 +5986,42 @@ function solveAssembly(assembly) {
         solverConstraints.push({ type: "concentric", ...pair.value });
       }
     }
-    const result2 = solveConstraints(nodes, solverConstraints);
-    if (!result2.converged) {
-      const detail = result2.unsupported.length > 0 ? `Unsupported constraint types: ${result2.unsupported.join(", ")} (${result2.dof} DOF unresolved)` : "Assembly constraint solver did not converge";
-      return errors.err(errors.kernelError(errors.BrepErrorCode.ASSEMBLY_NOT_CONVERGED, detail));
+    const result$1 = solveConstraints(nodes, solverConstraints);
+    if (!result$1.converged) {
+      const detail = result$1.unsupported.length > 0 ? `Unsupported constraint types: ${result$1.unsupported.join(", ")} (${result$1.dof} DOF unresolved)` : "Assembly constraint solver did not converge";
+      return result.err(result.kernelError(result.BrepErrorCode.ASSEMBLY_NOT_CONVERGED, detail));
     }
-    return errors.ok({
-      transforms: result2.transforms,
-      dof: result2.dof,
-      converged: result2.converged
+    return result.ok({
+      transforms: result$1.transforms,
+      dof: result$1.dof,
+      converged: result$1.converged
     });
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(
-      errors.kernelError(errors.BrepErrorCode.ASSEMBLY_SOLVE_FAILED, `Assembly solve failed: ${raw}`, e)
+    return result.err(
+      result.kernelError(result.BrepErrorCode.ASSEMBLY_SOLVE_FAILED, `Assembly solve failed: ${raw}`, e)
     );
   }
 }
 function checkInterference(shape1, shape2, tolerance = 1e-6) {
   if (shapeTypes.getKernel().isNull(shape1.wrapped)) {
-    return errors.err(
-      errors.validationError(
-        errors.BrepErrorCode.NULL_SHAPE_INPUT,
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.NULL_SHAPE_INPUT,
         "checkInterference: first shape is a null shape"
       )
     );
   }
   if (shapeTypes.getKernel().isNull(shape2.wrapped)) {
-    return errors.err(
-      errors.validationError(
-        errors.BrepErrorCode.NULL_SHAPE_INPUT,
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.NULL_SHAPE_INPUT,
         "checkInterference: second shape is a null shape"
       )
     );
   }
   const dist = shapeTypes.getKernel().distance(shape1.wrapped, shape2.wrapped);
-  return errors.ok({
+  return result.ok({
     hasInterference: dist.value <= tolerance,
     minDistance: dist.value,
     pointOnShape1: dist.point1,
@@ -6087,9 +6034,9 @@ function checkAllInterferences(shapes, tolerance = 1e-6) {
   shapes.forEach((si, i) => {
     for (let j = i + 1; j < shapes.length; j++) {
       if (aabbDisjoint(boxes[i], boxes[j], tolerance)) continue;
-      const result2 = errors.unwrap(checkInterference(si, shapes[j], tolerance));
-      if (result2.hasInterference) {
-        pairs.push({ i, j, result: result2 });
+      const result$1 = result.unwrap(checkInterference(si, shapes[j], tolerance));
+      if (result$1.hasInterference) {
+        pairs.push({ i, j, result: result$1 });
       }
     }
   });
@@ -6174,12 +6121,12 @@ async function importDXF(blob, options) {
   try {
     text = await blob.text();
   } catch (cause) {
-    return errors.err(errors.ioError(errors.BrepErrorCode.DXF_IMPORT_FAILED, "Failed to read DXF blob", cause));
+    return result.err(result.ioError(result.BrepErrorCode.DXF_IMPORT_FAILED, "Failed to read DXF blob", cause));
   }
   const allEntities = parseEntities(text);
   const entities = options?.layer !== void 0 ? allEntities.filter((e) => e.layer === options.layer) : allEntities;
   if (entities.length === 0) {
-    return errors.ok([]);
+    return result.ok([]);
   }
   const edges = [];
   try {
@@ -6190,13 +6137,13 @@ async function importDXF(blob, options) {
       }
     }
     if (edges.length === 0) {
-      return errors.ok([]);
+      return result.ok([]);
     }
     const wire = shapeTypes.getKernel().makeWire(edges);
-    return errors.ok([shapeTypes.createWire(wire)]);
+    return result.ok([shapeTypes.createWire(wire)]);
   } catch (cause) {
-    return errors.err(
-      errors.ioError(errors.BrepErrorCode.DXF_IMPORT_FAILED, "Failed to convert DXF entities to geometry", cause)
+    return result.err(
+      result.ioError(result.BrepErrorCode.DXF_IMPORT_FAILED, "Failed to convert DXF entities to geometry", cause)
     );
   } finally {
     for (const edge of edges) {
@@ -6229,13 +6176,13 @@ async function importOBJ(blob) {
     }
   }
   if (vertices.length === 0 || faces.length === 0) {
-    return errors.err(errors.ioError(errors.BrepErrorCode.OBJ_IMPORT_FAILED, "OBJ file contains no valid geometry"));
+    return result.err(result.ioError(result.BrepErrorCode.OBJ_IMPORT_FAILED, "OBJ file contains no valid geometry"));
   }
   try {
     return buildSolidFromMesh$1(vertices, faces);
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
-    return errors.err(errors.ioError(errors.BrepErrorCode.OBJ_IMPORT_FAILED, `OBJ import failed: ${msg}`, e));
+    return result.err(result.ioError(result.BrepErrorCode.OBJ_IMPORT_FAILED, `OBJ import failed: ${msg}`, e));
   }
 }
 function buildSolidFromMesh$1(vertices, faces) {
@@ -6260,17 +6207,17 @@ function buildSolidFromMesh$1(vertices, faces) {
     }
   }
   if (triFaces.length === 0) {
-    return errors.err(
-      errors.ioError(errors.BrepErrorCode.OBJ_IMPORT_FAILED, "No valid triangular faces could be built")
+    return result.err(
+      result.ioError(result.BrepErrorCode.OBJ_IMPORT_FAILED, "No valid triangular faces could be built")
     );
   }
   try {
-    return errors.ok(shapeTypes.castShape(kernel.sewAndSolidify(triFaces, 1e-6)));
+    return result.ok(shapeTypes.castShape(kernel.sewAndSolidify(triFaces, 1e-6)));
   } catch {
     try {
-      return errors.ok(shapeTypes.castShape(kernel.sew(triFaces, 1e-6)));
+      return result.ok(shapeTypes.castShape(kernel.sew(triFaces, 1e-6)));
     } catch {
-      return errors.err(errors.ioError(errors.BrepErrorCode.OBJ_IMPORT_FAILED, "Failed to sew triangular faces"));
+      return result.err(result.ioError(result.BrepErrorCode.OBJ_IMPORT_FAILED, "Failed to sew triangular faces"));
     }
   }
 }
@@ -6376,7 +6323,7 @@ function buildSolidFromMesh(mesh2) {
   const faces = mesh2.triangles;
   try {
     const solid = kernel.buildSolidFromFaces(points, faces, 1e-6);
-    return errors.ok(shapeTypes.castShape(solid));
+    return result.ok(shapeTypes.castShape(solid));
   } catch {
     const triFaces = [];
     for (const [v1, v2, v3] of mesh2.triangles) {
@@ -6390,17 +6337,17 @@ function buildSolidFromMesh(mesh2) {
       }
     }
     if (triFaces.length === 0) {
-      return errors.err(
-        errors.ioError(errors.BrepErrorCode.THREEMF_IMPORT_FAILED, "No valid triangular faces could be built")
+      return result.err(
+        result.ioError(result.BrepErrorCode.THREEMF_IMPORT_FAILED, "No valid triangular faces could be built")
       );
     }
     try {
-      return errors.ok(shapeTypes.castShape(kernel.sewAndSolidify(triFaces, 1e-6)));
+      return result.ok(shapeTypes.castShape(kernel.sewAndSolidify(triFaces, 1e-6)));
     } catch {
       try {
-        return errors.ok(shapeTypes.castShape(kernel.sew(triFaces, 1e-6)));
+        return result.ok(shapeTypes.castShape(kernel.sew(triFaces, 1e-6)));
       } catch {
-        return errors.err(errors.ioError(errors.BrepErrorCode.THREEMF_IMPORT_FAILED, "Failed to sew triangular faces"));
+        return result.err(result.ioError(result.BrepErrorCode.THREEMF_IMPORT_FAILED, "Failed to sew triangular faces"));
       }
     }
   }
@@ -6411,9 +6358,9 @@ async function importThreeMF(blob) {
     const data = new Uint8Array(arrayBuf);
     const modelData = extractFromZip(data, "3D/3dmodel.model");
     if (!modelData) {
-      return errors.err(
-        errors.ioError(
-          errors.BrepErrorCode.THREEMF_IMPORT_FAILED,
+      return result.err(
+        result.ioError(
+          result.BrepErrorCode.THREEMF_IMPORT_FAILED,
           "3MF archive does not contain 3D/3dmodel.model (or uses unsupported compression)"
         )
       );
@@ -6421,14 +6368,14 @@ async function importThreeMF(blob) {
     const xml = new TextDecoder().decode(modelData);
     const parsed = parseModelXml(xml);
     if (parsed.vertices.length === 0 || parsed.triangles.length === 0) {
-      return errors.err(
-        errors.ioError(errors.BrepErrorCode.THREEMF_IMPORT_FAILED, "3MF model contains no valid geometry")
+      return result.err(
+        result.ioError(result.BrepErrorCode.THREEMF_IMPORT_FAILED, "3MF model contains no valid geometry")
       );
     }
     return buildSolidFromMesh(parsed);
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
-    return errors.err(errors.ioError(errors.BrepErrorCode.THREEMF_IMPORT_FAILED, `3MF import failed: ${msg}`, e));
+    return result.err(result.ioError(result.BrepErrorCode.THREEMF_IMPORT_FAILED, `3MF import failed: ${msg}`, e));
   }
 }
 function resolve(s) {
@@ -6442,9 +6389,9 @@ function resolve3D(s) {
 }
 function validateNotNull(shape2, label) {
   if (shapeTypes.getKernel().isNull(shape2.wrapped)) {
-    return errors.err(errors.validationError(errors.BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
+    return result.err(result.validationError(result.BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
   }
-  return errors.ok(void 0);
+  return result.ok(void 0);
 }
 function collectInputFaceHashes(inputs) {
   const hasMetadata = inputs.some((s) => {
@@ -6462,7 +6409,7 @@ function collectInputFaceHashes(inputs) {
 }
 function thicken$1(shape2, thickness) {
   const check = validateNotNull(shape2, "thicken: shape");
-  if (errors.isErr(check)) return check;
+  if (result.isErr(check)) return check;
   try {
     const inputFaceHashes = collectInputFaceHashes([shape2]);
     const { shape: resultShape, evolution } = shapeTypes.getKernel().thickenWithHistory(
@@ -6475,18 +6422,18 @@ function thicken$1(shape2, thickness) {
     shapeFns.propagateOriginsFromEvolution(evolution, [shape2], cast);
     booleanFns.propagateFaceTagsFromEvolution(evolution, [shape2], cast);
     booleanFns.propagateColorsFromEvolution(evolution, [shape2], cast);
-    return errors.ok(cast);
+    return result.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(errors.kernelError("THICKEN_FAILED", `Thicken operation failed: ${raw}`, e));
+    return result.err(result.kernelError("THICKEN_FAILED", `Thicken operation failed: ${raw}`, e));
   }
 }
 function fillet$1(shape2, edges, radius) {
   const check = validateNotNull(shape2, "fillet: shape");
-  if (errors.isErr(check)) return check;
+  if (result.isErr(check)) return check;
   if (typeof radius === "number" && radius <= 0) {
-    return errors.err(
-      errors.validationError(
+    return result.err(
+      result.validationError(
         "INVALID_FILLET_RADIUS",
         "Fillet radius must be positive",
         void 0,
@@ -6496,8 +6443,8 @@ function fillet$1(shape2, edges, radius) {
     );
   }
   if (Array.isArray(radius) && (radius[0] <= 0 || radius[1] <= 0)) {
-    return errors.err(
-      errors.validationError(
+    return result.err(
+      result.validationError(
         "INVALID_FILLET_RADIUS",
         "Fillet radii must both be positive",
         void 0,
@@ -6508,9 +6455,9 @@ function fillet$1(shape2, edges, radius) {
   }
   const selectedEdges = edges ?? shapeFns.getEdges(shape2);
   if (selectedEdges.length === 0) {
-    return errors.err(
-      errors.validationError(
-        errors.BrepErrorCode.FILLET_NO_EDGES,
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.FILLET_NO_EDGES,
         "No edges found for fillet",
         void 0,
         void 0,
@@ -6544,9 +6491,9 @@ function fillet$1(shape2, edges, radius) {
       kernelRadius = radius;
     }
     if (filteredEdges.length === 0) {
-      return errors.err(
-        errors.validationError(
-          errors.BrepErrorCode.FILLET_NO_EDGES,
+      return result.err(
+        result.validationError(
+          result.BrepErrorCode.FILLET_NO_EDGES,
           "No edges with positive radius for fillet",
           void 0,
           void 0,
@@ -6564,16 +6511,16 @@ function fillet$1(shape2, edges, radius) {
     );
     const cast = shapeTypes.castShape(resultShape);
     if (!shapeTypes.isShape3D(cast)) {
-      return errors.err(errors.kernelError(errors.BrepErrorCode.FILLET_NOT_3D, "Fillet result is not a 3D shape"));
+      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);
-    return errors.ok(cast);
+    return result.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(
-      errors.kernelError("FILLET_FAILED", `Fillet operation failed: ${raw}`, e, {
+    return result.err(
+      result.kernelError("FILLET_FAILED", `Fillet operation failed: ${raw}`, e, {
         operation: "fillet",
         edgeCount: selectedEdges.length,
         radius
@@ -6583,10 +6530,10 @@ function fillet$1(shape2, edges, radius) {
 }
 function chamfer$1(shape2, edges, distance) {
   const check = validateNotNull(shape2, "chamfer: shape");
-  if (errors.isErr(check)) return check;
+  if (result.isErr(check)) return check;
   if (typeof distance === "number" && distance <= 0) {
-    return errors.err(
-      errors.validationError(
+    return result.err(
+      result.validationError(
         "INVALID_CHAMFER_DISTANCE",
         "Chamfer distance must be positive",
         void 0,
@@ -6596,8 +6543,8 @@ function chamfer$1(shape2, edges, distance) {
     );
   }
   if (Array.isArray(distance) && (distance[0] <= 0 || distance[1] <= 0)) {
-    return errors.err(
-      errors.validationError(
+    return result.err(
+      result.validationError(
         "INVALID_CHAMFER_DISTANCE",
         "Chamfer distances must both be positive",
         void 0,
@@ -6608,7 +6555,7 @@ function chamfer$1(shape2, edges, distance) {
   }
   const selectedEdges = edges ?? shapeFns.getEdges(shape2);
   if (selectedEdges.length === 0) {
-    return errors.err(errors.validationError(errors.BrepErrorCode.CHAMFER_NO_EDGES, "No edges found for chamfer"));
+    return result.err(result.validationError(result.BrepErrorCode.CHAMFER_NO_EDGES, "No edges found for chamfer"));
   }
   try {
     let filteredEdges;
@@ -6636,9 +6583,9 @@ function chamfer$1(shape2, edges, distance) {
       kernelDistance = distance;
     }
     if (filteredEdges.length === 0) {
-      return errors.err(
-        errors.validationError(
-          errors.BrepErrorCode.CHAMFER_NO_EDGES,
+      return result.err(
+        result.validationError(
+          result.BrepErrorCode.CHAMFER_NO_EDGES,
           "No edges with positive distance for chamfer"
         )
       );
@@ -6653,16 +6600,16 @@ function chamfer$1(shape2, edges, distance) {
     );
     const cast = shapeTypes.castShape(resultShape);
     if (!shapeTypes.isShape3D(cast)) {
-      return errors.err(errors.kernelError(errors.BrepErrorCode.CHAMFER_NOT_3D, "Chamfer result is not a 3D shape"));
+      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);
-    return errors.ok(cast);
+    return result.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(
-      errors.kernelError("CHAMFER_FAILED", `Chamfer operation failed: ${raw}`, e, {
+    return result.err(
+      result.kernelError("CHAMFER_FAILED", `Chamfer operation failed: ${raw}`, e, {
         operation: "chamfer",
         edgeCount: selectedEdges.length,
         distance
@@ -6672,12 +6619,12 @@ function chamfer$1(shape2, edges, distance) {
 }
 function shell$1(shape2, faces, thickness, tolerance = 1e-3) {
   const check = validateNotNull(shape2, "shell: shape");
-  if (errors.isErr(check)) return check;
+  if (result.isErr(check)) return check;
   if (thickness <= 0) {
-    return errors.err(errors.validationError("INVALID_THICKNESS", "Shell thickness must be positive"));
+    return result.err(result.validationError("INVALID_THICKNESS", "Shell thickness must be positive"));
   }
   if (faces.length === 0) {
-    return errors.err(errors.validationError("NO_FACES", "At least one face must be specified for shell"));
+    return result.err(result.validationError("NO_FACES", "At least one face must be specified for shell"));
   }
   try {
     const inputFaceHashes = collectInputFaceHashes([shape2]);
@@ -6691,16 +6638,16 @@ function shell$1(shape2, faces, thickness, tolerance = 1e-3) {
     );
     const cast = shapeTypes.castShape(resultShape);
     if (!shapeTypes.isShape3D(cast)) {
-      return errors.err(errors.kernelError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
+      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);
-    return errors.ok(cast);
+    return result.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(
-      errors.kernelError("SHELL_FAILED", `Shell operation failed: ${raw}`, e, {
+    return result.err(
+      result.kernelError("SHELL_FAILED", `Shell operation failed: ${raw}`, e, {
         operation: "shell",
         faceCount: faces.length,
         thickness
@@ -6710,9 +6657,9 @@ function shell$1(shape2, faces, thickness, tolerance = 1e-3) {
 }
 function offset$1(shape2, distance, tolerance = 1e-6) {
   const check = validateNotNull(shape2, "offset: shape");
-  if (errors.isErr(check)) return check;
+  if (result.isErr(check)) return check;
   if (distance === 0) {
-    return errors.err(errors.validationError("ZERO_OFFSET", "Offset distance cannot be zero"));
+    return result.err(result.validationError("ZERO_OFFSET", "Offset distance cannot be zero"));
   }
   try {
     const inputFaceHashes = collectInputFaceHashes([shape2]);
@@ -6725,15 +6672,15 @@ function offset$1(shape2, distance, tolerance = 1e-6) {
     );
     const cast = shapeTypes.castShape(resultShape);
     if (!shapeTypes.isShape3D(cast)) {
-      return errors.err(errors.kernelError("OFFSET_RESULT_NOT_3D", "Offset result is not a 3D shape"));
+      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);
-    return errors.ok(cast);
+    return result.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(errors.kernelError("OFFSET_FAILED", `Offset operation failed: ${raw}`, e));
+    return result.err(result.kernelError("OFFSET_FAILED", `Offset operation failed: ${raw}`, e));
   }
 }
 function translate(shape2, v) {
@@ -6890,7 +6837,7 @@ function isEmpty(shape2) {
 }
 function loft$1(wires, { ruled = true, startPoint, endPoint, tolerance = 1e-6 } = {}, returnShell = false) {
   if (wires.length === 0 && !startPoint && !endPoint) {
-    return errors.err(errors.validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
+    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;
@@ -6906,13 +6853,13 @@ function loft$1(wires, { ruled = true, startPoint, endPoint, tolerance = 1e-6 }
         ...endVertex ? { endVertex } : {}
       }
     );
-    const result2 = shapeTypes.castShape(shape2);
-    if (!shapeTypes.isShape3D(result2)) {
-      return errors.err(errors.typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
+    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 errors.ok(result2);
+    return result.ok(result$1);
   } catch {
-    return errors.err(errors.kernelError("LOFT_FAILED", "Loft operation failed"));
+    return result.err(result.kernelError("LOFT_FAILED", "Loft operation failed"));
   }
 }
 function extrude(face, height) {
@@ -6937,8 +6884,8 @@ function resolveTargetFace(shape2, faceSpec) {
   if (faceSpec === void 0) {
     const faces = shapeFns.getFaces(shape2);
     if (faces.length === 0) {
-      return errors.err(
-        errors.validationError(errors.BrepErrorCode.COMPOUND_NO_FACES, "compoundOps: shape has no faces")
+      return result.err(
+        result.validationError(result.BrepErrorCode.COMPOUND_NO_FACES, "compoundOps: shape has no faces")
       );
     }
     let best = faces[0];
@@ -6951,22 +6898,22 @@ function resolveTargetFace(shape2, faceSpec) {
         bestZ = z;
       }
     }
-    return errors.ok(best);
+    return result.ok(best);
   }
   if (typeof faceSpec === "function") {
     const finder = faceSpec(helpers.faceFinder());
     const found = finder.findAll(shape2);
     if (found.length === 0) {
-      return errors.err(
-        errors.queryError(
-          errors.BrepErrorCode.COMPOUND_FACE_NOT_FOUND,
+      return result.err(
+        result.queryError(
+          result.BrepErrorCode.COMPOUND_FACE_NOT_FOUND,
           "compoundOps: face finder matched no faces"
         )
       );
     }
-    return errors.ok(found[0]);
+    return result.ok(found[0]);
   }
-  return errors.ok(faceSpec);
+  return result.ok(faceSpec);
 }
 function toWire(profile) {
   if ("sketchOnPlane" in profile && typeof profile.sketchOnPlane === "function") {
@@ -6979,10 +6926,10 @@ function drill(shape2, options) {
   const { at, radius, axis: rawAxis } = options;
   const axis = rawAxis ?? [0, 0, 1];
   if (radius <= 0) {
-    return errors.err(errors.validationError("DRILL_INVALID_RADIUS", "Drill radius must be positive"));
+    return result.err(result.validationError("DRILL_INVALID_RADIUS", "Drill radius must be positive"));
   }
   if (vecOps.vecIsZero(axis)) {
-    return errors.err(errors.validationError("DRILL_ZERO_AXIS", "Drill axis cannot be zero"));
+    return result.err(result.validationError("DRILL_ZERO_AXIS", "Drill axis cannot be zero"));
   }
   const dir = vecOps.vecNormalize(axis);
   const pos = at.length === 2 ? [at[0], at[1], 0] : [at[0], at[1], at[2]];
@@ -7021,36 +6968,36 @@ function pocket(shape2, options) {
   const s = resolve(shape2);
   const { profile, depth } = options;
   if (depth <= 0) {
-    return errors.err(errors.validationError("POCKET_INVALID_DEPTH", "Pocket depth must be positive"));
+    return result.err(result.validationError("POCKET_INVALID_DEPTH", "Pocket depth must be positive"));
   }
   const targetResult = resolveTargetFace(s, options.face);
-  if (errors.isErr(targetResult)) return targetResult;
+  if (result.isErr(targetResult)) return targetResult;
   const targetFace = targetResult.value;
   const normal = faceFns.normalAt(targetFace);
   const w = toWire(profile);
   const faceResult = surfaceBuilders.makeFace(w);
-  if (errors.isErr(faceResult)) return faceResult;
+  if (result.isErr(faceResult)) return faceResult;
   const extDir = vecOps.vecScale(vecOps.vecNormalize(normal), -depth);
   const toolResult = operations.extrude(faceResult.value, extDir);
-  if (errors.isErr(toolResult)) return toolResult;
+  if (result.isErr(toolResult)) return toolResult;
   return booleanFns.cut(s, toolResult.value);
 }
 function boss(shape2, options) {
   const s = resolve(shape2);
   const { profile, height } = options;
   if (height <= 0) {
-    return errors.err(errors.validationError("BOSS_INVALID_HEIGHT", "Boss height must be positive"));
+    return result.err(result.validationError("BOSS_INVALID_HEIGHT", "Boss height must be positive"));
   }
   const targetResult = resolveTargetFace(s, options.face);
-  if (errors.isErr(targetResult)) return targetResult;
+  if (result.isErr(targetResult)) return targetResult;
   const targetFace = targetResult.value;
   const normal = faceFns.normalAt(targetFace);
   const w = toWire(profile);
   const faceResult = surfaceBuilders.makeFace(w);
-  if (errors.isErr(faceResult)) return faceResult;
+  if (result.isErr(faceResult)) return faceResult;
   const extDir = vecOps.vecScale(vecOps.vecNormalize(normal), height);
   const toolResult = operations.extrude(faceResult.value, extDir);
-  if (errors.isErr(toolResult)) return toolResult;
+  if (result.isErr(toolResult)) return toolResult;
   return booleanFns.fuse(s, toolResult.value);
 }
 function mirrorJoin(shape2, options) {
@@ -7064,15 +7011,15 @@ function rectangularPattern(shape2, options) {
   const s = resolve(shape2);
   const { xDir, xCount, xSpacing, yDir, yCount, ySpacing } = options;
   if (xCount < 1 || yCount < 1) {
-    return errors.err(errors.validationError("PATTERN_INVALID_COUNT", "Pattern counts must be at least 1"));
+    return result.err(result.validationError("PATTERN_INVALID_COUNT", "Pattern counts must be at least 1"));
   }
   if (vecOps.vecIsZero(xDir)) {
-    return errors.err(errors.validationError("PATTERN_ZERO_DIRECTION", "X direction cannot be zero"));
+    return result.err(result.validationError("PATTERN_ZERO_DIRECTION", "X direction cannot be zero"));
   }
   if (vecOps.vecIsZero(yDir)) {
-    return errors.err(errors.validationError("PATTERN_ZERO_DIRECTION", "Y direction cannot be zero"));
+    return result.err(result.validationError("PATTERN_ZERO_DIRECTION", "Y direction cannot be zero"));
   }
-  if (xCount === 1 && yCount === 1) return errors.ok(s);
+  if (xCount === 1 && yCount === 1) return result.ok(s);
   const xNorm = vecOps.vecNormalize(xDir);
   const yNorm = vecOps.vecNormalize(yDir);
   const copies = [s];
@@ -7110,11 +7057,11 @@ Suggestion: ${brepError.suggestion}` : brepError.message;
     }
   }
 }
-function unwrapOrThrow(result2) {
-  if (errors.isErr(result2)) {
-    throw new BrepWrapperError(result2.error);
+function unwrapOrThrow(result$1) {
+  if (result.isErr(result$1)) {
+    throw new BrepWrapperError(result$1.error);
   }
-  return result2.value;
+  return result$1.value;
 }
 function createWrappedBase(val) {
   const self = {
@@ -7299,41 +7246,43 @@ exports.withKernel = shapeTypes.withKernel;
 exports.withScope = shapeTypes.withScope;
 exports.withScopeResult = shapeTypes.withScopeResult;
 exports.withScopeResultAsync = shapeTypes.withScopeResultAsync;
-exports.BrepErrorCode = errors.BrepErrorCode;
-exports.OK = errors.OK;
-exports.all = errors.all;
-exports.andThen = errors.andThen;
-exports.collect = errors.collect;
-exports.computationError = errors.computationError;
-exports.err = errors.err;
-exports.flatMap = errors.flatMap;
-exports.fromNullable = errors.fromNullable;
-exports.ioError = errors.ioError;
-exports.isErr = errors.isErr;
-exports.isOk = errors.isOk;
-exports.kernelError = errors.kernelError;
-exports.map = errors.map;
-exports.mapErr = errors.mapErr;
-exports.match = errors.match;
-exports.moduleInitError = errors.moduleInitError;
-exports.ok = errors.ok;
-exports.or = errors.or;
-exports.orElse = errors.orElse;
-exports.pipeline = errors.pipeline;
-exports.queryError = errors.queryError;
-exports.sketcherStateError = errors.sketcherStateError;
-exports.tap = errors.tap;
-exports.tapErr = errors.tapErr;
-exports.tryCatch = errors.tryCatch;
-exports.tryCatchAsync = errors.tryCatchAsync;
-exports.typeCastError = errors.typeCastError;
-exports.unsupportedError = errors.unsupportedError;
-exports.unwrap = errors.unwrap;
-exports.unwrapErr = errors.unwrapErr;
-exports.unwrapOr = errors.unwrapOr;
-exports.unwrapOrElse = errors.unwrapOrElse;
-exports.validationError = errors.validationError;
-exports.zipResults = errors.zip;
+exports.BrepBugError = result.BrepBugError;
+exports.BrepErrorCode = result.BrepErrorCode;
+exports.OK = result.OK;
+exports.all = result.all;
+exports.andThen = result.andThen;
+exports.bug = result.bug;
+exports.collect = result.collect;
+exports.computationError = result.computationError;
+exports.err = result.err;
+exports.flatMap = result.flatMap;
+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.mapErr = result.mapErr;
+exports.match = result.match;
+exports.moduleInitError = result.moduleInitError;
+exports.ok = result.ok;
+exports.or = result.or;
+exports.orElse = result.orElse;
+exports.pipeline = result.pipeline;
+exports.queryError = result.queryError;
+exports.sketcherStateError = result.sketcherStateError;
+exports.tap = result.tap;
+exports.tapErr = result.tapErr;
+exports.tryCatch = result.tryCatch;
+exports.tryCatchAsync = result.tryCatchAsync;
+exports.typeCastError = result.typeCastError;
+exports.unsupportedError = result.unsupportedError;
+exports.unwrap = result.unwrap;
+exports.unwrapErr = result.unwrapErr;
+exports.unwrapOr = result.unwrapOr;
+exports.unwrapOrElse = result.unwrapOrElse;
+exports.validationError = result.validationError;
+exports.zipResults = result.zip;
 exports.DEG2RAD = vecOps.DEG2RAD;
 exports.HASH_CODE_MAX = vecOps.HASH_CODE_MAX;
 exports.RAD2DEG = vecOps.RAD2DEG;
@@ -7631,8 +7580,6 @@ exports.measureVolume = measurement.measureVolume;
 exports.measureVolumeProps = measurement.measureVolumeProps;
 exports.fill = surfaceBuilders.fill;
 exports.edgeFinder = query.edgeFinder;
-exports.BrepBugError = result.BrepBugError;
-exports.bug = result.bug;
 exports.cornerFinder = cornerFinder.cornerFinder;
 exports.createOperationRegistry = worker.createOperationRegistry;
 exports.createTaskQueue = worker.createTaskQueue;