brepjs 12.7.3 → 12.8.1

package/dist/result.js

@@ -1,43 +1,32 @@
-import { B, O, a, c, b, e, f, i, d, g, k, m, h, j, l, o, F, q, s, t, n, p, r, v, w, x, y } from "./errors-B7kgv0cd.js";
-class BrepBugError extends Error {
-  location;
-  constructor(location, message) {
-    super(`Bug in ${location}: ${message}`);
-    this.name = "BrepBugError";
-    this.location = location;
-  }
-}
-function bug(location, message) {
-  throw new BrepBugError(location, message);
-}
+import { B, A, O, a, b, c, d, e, f, i, g, h, k, m, j, l, n, o, I, q, s, t, p, r, v, w, x, y, z } from "./result-BaSD1fqR.js";
 export {
-  BrepBugError,
-  B as BrepErrorCode,
+  B as BrepBugError,
+  A as BrepErrorCode,
   O as OK,
   a as andThen,
-  bug,
+  b as bug,
   c as collect,
-  b as computationError,
+  d as computationError,
   e as err,
   f as flatMap,
   i as ioError,
-  d as isErr,
-  g as isOk,
+  g as isErr,
+  h as isOk,
   k as kernelError,
   m as map,
-  h as mapErr,
-  j as match,
-  l as moduleInitError,
+  j as mapErr,
+  l as match,
+  n as moduleInitError,
   o as ok,
-  F as pipeline,
+  I as pipeline,
   q as queryError,
   s as sketcherStateError,
   t as tryCatch,
-  n as tryCatchAsync,
-  p as typeCastError,
-  r as unwrap,
-  v as unwrapErr,
-  w as unwrapOr,
-  x as unwrapOrElse,
-  y as validationError
+  p as tryCatchAsync,
+  r as typeCastError,
+  v as unwrap,
+  w as unwrapErr,
+  x as unwrapOr,
+  y as unwrapOrElse,
+  z as validationError
 };

package/dist/{shapeFns-D-MOoqJd.cjs → shapeFns-C2SnNvdH.cjs}

@@ -1,10 +1,10 @@
 "use strict";
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const faceFns = require("./faceFns-BLTEPBKq.cjs");
-const errors = require("./errors-9fDehDNc.cjs");
+const faceFns = require("./faceFns-DB1Fc5gy.cjs");
+const result = require("./result-fAX0OZzI.cjs");
 function clone(shape) {
-  return shapeTypes.castShape(errors.unwrap(faceFns.downcast(shape.wrapped)));
+  return shapeTypes.castShape(result.unwrap(faceFns.downcast(shape.wrapped)));
 }
 function toBREP(shape) {
   return shapeTypes.getKernel().toBREP(shape.wrapped);
@@ -45,9 +45,9 @@ function translate(shape, v) {
     inputFaceHashes,
     vecOps.HASH_CODE_MAX
   );
-  const result = shapeTypes.castShape(resultShape);
-  propagateOriginsFromEvolution(evolution, [shape], result);
-  return result;
+  const result2 = shapeTypes.castShape(resultShape);
+  propagateOriginsFromEvolution(evolution, [shape], result2);
+  return result2;
 }
 function rotate(shape, angle, position = [0, 0, 0], direction = [0, 0, 1]) {
   const inputFaceHashes = collectInputFaceHashes([shape]);
@@ -59,9 +59,9 @@ function rotate(shape, angle, position = [0, 0, 0], direction = [0, 0, 1]) {
     direction,
     position
   );
-  const result = shapeTypes.castShape(resultShape);
-  propagateOriginsFromEvolution(evolution, [shape], result);
-  return result;
+  const result2 = shapeTypes.castShape(resultShape);
+  propagateOriginsFromEvolution(evolution, [shape], result2);
+  return result2;
 }
 function mirror(shape, planeNormal = [0, 1, 0], planeOrigin = [0, 0, 0]) {
   const inputFaceHashes = collectInputFaceHashes([shape]);
@@ -72,9 +72,9 @@ function mirror(shape, planeNormal = [0, 1, 0], planeOrigin = [0, 0, 0]) {
     inputFaceHashes,
     vecOps.HASH_CODE_MAX
   );
-  const result = shapeTypes.castShape(resultShape);
-  propagateOriginsFromEvolution(evolution, [shape], result);
-  return result;
+  const result2 = shapeTypes.castShape(resultShape);
+  propagateOriginsFromEvolution(evolution, [shape], result2);
+  return result2;
 }
 function scale(shape, factor, center = [0, 0, 0]) {
   const inputFaceHashes = collectInputFaceHashes([shape]);
@@ -85,9 +85,9 @@ function scale(shape, factor, center = [0, 0, 0]) {
     inputFaceHashes,
     vecOps.HASH_CODE_MAX
   );
-  const result = shapeTypes.castShape(resultShape);
-  propagateOriginsFromEvolution(evolution, [shape], result);
-  return result;
+  const result2 = shapeTypes.castShape(resultShape);
+  propagateOriginsFromEvolution(evolution, [shape], result2);
+  return result2;
 }
 function resize(shape, dimensions, options) {
   const bbox = shapeTypes.getKernel().boundingBox(shape.wrapped);
@@ -174,14 +174,14 @@ function applyMatrix(shape, matrix) {
       inputFaceHashes,
       vecOps.HASH_CODE_MAX
     );
-    const result2 = shapeTypes.castShape(resultShape2);
-    propagateOriginsFromEvolution(evolution, [shape], result2);
-    return result2;
+    const result22 = shapeTypes.castShape(resultShape2);
+    propagateOriginsFromEvolution(evolution, [shape], result22);
+    return result22;
   }
   const resultShape = shapeTypes.getKernel().generalTransformNonOrthogonal(shape.wrapped, linear, translation);
-  const result = shapeTypes.castShape(resultShape);
-  propagateOriginsByHash([shape], result);
-  return result;
+  const result2 = shapeTypes.castShape(resultShape);
+  propagateOriginsByHash([shape], result2);
+  return result2;
 }
 function composeTransforms(ops) {
   const kernelOps = ops.map((op) => {
@@ -191,8 +191,8 @@ function composeTransforms(ops) {
     return {
       type: "rotate",
       angle: op.angle,
-      axis: op.axis ? [...op.axis] : void 0,
-      center: op.center ? [...op.center] : void 0
+      axis: op.axis,
+      center: op.center
     };
   });
   const { handle, dispose } = shapeTypes.getKernel().composeTransform(kernelOps);
@@ -206,9 +206,9 @@ function transformCopy(shape, composed) {
     inputFaceHashes,
     vecOps.HASH_CODE_MAX
   );
-  const result = shapeTypes.castShape(resultShape);
-  propagateOriginsFromEvolution(evolution, [shape], result);
-  return result;
+  const result2 = shapeTypes.castShape(resultShape);
+  propagateOriginsFromEvolution(evolution, [shape], result2);
+  return result2;
 }
 const topoCache = /* @__PURE__ */ new WeakMap();
 function getOrCreateCache(shape) {
@@ -226,7 +226,7 @@ function getEdges(shape) {
   const cache = getOrCreateCache(shape);
   if (cache.edges) return cache.edges;
   const edges = Array.from(faceFns.iterTopo(shape.wrapped, "edge")).map(
-    (e) => shapeTypes.castShape(errors.unwrap(faceFns.downcast(e)))
+    (e) => shapeTypes.castShape(result.unwrap(faceFns.downcast(e)))
   );
   cache.edges = edges;
   return edges;
@@ -235,7 +235,7 @@ function getFaces(shape) {
   const cache = getOrCreateCache(shape);
   if (cache.faces) return cache.faces;
   const faces = Array.from(faceFns.iterTopo(shape.wrapped, "face")).map(
-    (e) => shapeTypes.castShape(errors.unwrap(faceFns.downcast(e)))
+    (e) => shapeTypes.castShape(result.unwrap(faceFns.downcast(e)))
   );
   cache.faces = faces;
   return faces;
@@ -244,7 +244,7 @@ function getWires(shape) {
   const cache = getOrCreateCache(shape);
   if (cache.wires) return cache.wires;
   const wires = Array.from(faceFns.iterTopo(shape.wrapped, "wire")).map(
-    (e) => shapeTypes.castShape(errors.unwrap(faceFns.downcast(e)))
+    (e) => shapeTypes.castShape(result.unwrap(faceFns.downcast(e)))
   );
   cache.wires = wires;
   return wires;
@@ -260,7 +260,7 @@ function setShapeOrigin(shape, origin) {
 function getFaceOrigins(shape) {
   return topoCache.get(shape.wrapped)?.faceOrigins;
 }
-function propagateOriginsFromEvolution(evolution, inputs, result) {
+function propagateOriginsFromEvolution(evolution, inputs, result2) {
   const inputOrigins = /* @__PURE__ */ new Map();
   for (const input of inputs) {
     const origins = getFaceOrigins(input);
@@ -291,11 +291,11 @@ function propagateOriginsFromEvolution(evolution, inputs, result) {
     }
   }
   if (resultMap.size > 0) {
-    const cache = getOrCreateCache(result);
+    const cache = getOrCreateCache(result2);
     cache.faceOrigins = resultMap;
   }
 }
-function propagateOriginsByHash(inputs, result) {
+function propagateOriginsByHash(inputs, result2) {
   const lookup = /* @__PURE__ */ new Map();
   for (const input of inputs) {
     const origins = getFaceOrigins(input);
@@ -307,7 +307,7 @@ function propagateOriginsByHash(inputs, result) {
   if (lookup.size === 0) return;
   const kernel = shapeTypes.getKernel();
   const resultMap = /* @__PURE__ */ new Map();
-  const resultFaces = getFaces(result);
+  const resultFaces = getFaces(result2);
   for (const f of resultFaces) {
     const hash = kernel.hashCode(f.wrapped, vecOps.HASH_CODE_MAX);
     const origin = lookup.get(hash);
@@ -373,7 +373,7 @@ function propagateOriginsByHash(inputs, result) {
     }
   }
   if (resultMap.size > 0) {
-    const cache = getOrCreateCache(result);
+    const cache = getOrCreateCache(result2);
     cache.faceOrigins = resultMap;
   }
 }
@@ -381,29 +381,29 @@ function getVertices(shape) {
   const cache = getOrCreateCache(shape);
   if (cache.vertices) return cache.vertices;
   const vertices = Array.from(faceFns.iterTopo(shape.wrapped, "vertex")).map(
-    (e) => shapeTypes.castShape(errors.unwrap(faceFns.downcast(e)))
+    (e) => shapeTypes.castShape(result.unwrap(faceFns.downcast(e)))
   );
   cache.vertices = vertices;
   return vertices;
 }
 function* iterEdges(shape) {
   for (const e of faceFns.iterTopo(shape.wrapped, "edge")) {
-    yield shapeTypes.castShape(errors.unwrap(faceFns.downcast(e)));
+    yield shapeTypes.castShape(result.unwrap(faceFns.downcast(e)));
   }
 }
 function* iterFaces(shape) {
   for (const f of faceFns.iterTopo(shape.wrapped, "face")) {
-    yield shapeTypes.castShape(errors.unwrap(faceFns.downcast(f)));
+    yield shapeTypes.castShape(result.unwrap(faceFns.downcast(f)));
   }
 }
 function* iterWires(shape) {
   for (const w of faceFns.iterTopo(shape.wrapped, "wire")) {
-    yield shapeTypes.castShape(errors.unwrap(faceFns.downcast(w)));
+    yield shapeTypes.castShape(result.unwrap(faceFns.downcast(w)));
   }
 }
 function* iterVertices(shape) {
   for (const v of faceFns.iterTopo(shape.wrapped, "vertex")) {
-    yield shapeTypes.castShape(errors.unwrap(faceFns.downcast(v)));
+    yield shapeTypes.castShape(result.unwrap(faceFns.downcast(v)));
   }
 }
 function getBounds(shape) {

package/dist/{shapeFns-D2PlLFE6.js → shapeFns-FDuKkrDR.js}

@@ -1,7 +1,7 @@
 import { B as getKernel, c as castShape, g as getShapeKind } from "./shapeTypes-CpSaBLDv.js";
 import { H as HASH_CODE_MAX, D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
-import { i as iterTopo, d as downcast } from "./faceFns-B6ebRh5I.js";
-import { r as unwrap } from "./errors-B7kgv0cd.js";
+import { i as iterTopo, d as downcast } from "./faceFns-B8GnxjdY.js";
+import { v as unwrap } from "./result-BaSD1fqR.js";
 function clone(shape) {
   return castShape(unwrap(downcast(shape.wrapped)));
 }
@@ -190,8 +190,8 @@ function composeTransforms(ops) {
     return {
       type: "rotate",
       angle: op.angle,
-      axis: op.axis ? [...op.axis] : void 0,
-      center: op.center ? [...op.center] : void 0
+      axis: op.axis,
+      center: op.center
     };
   });
   const { handle, dispose } = getKernel().composeTransform(kernelOps);

package/dist/sketching.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const drawFns = require("./drawFns-CDNafQhv.cjs");
-const boolean2D = require("./boolean2D-DyQJt8Na.cjs");
+const drawFns = require("./drawFns-CjRc1NfQ.cjs");
+const boolean2D = require("./boolean2D-0blbVtJ8.cjs");
 exports.CompoundSketch = drawFns.CompoundSketch;
 exports.Drawing = drawFns.Drawing;
 exports.DrawingPen = drawFns.DrawingPen;

package/dist/sketching.js

@@ -1,5 +1,5 @@
-import { C, D, a, S, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, T, U, V, W } from "./drawFns-5myJTgtX.js";
-import { B as B2, a as a2, F as F2, S as S2 } from "./boolean2D-CwZAIJDS.js";
+import { C, D, a, S, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, T, U, V, W } from "./drawFns-Bwakrq7w.js";
+import { B as B2, a as a2, F as F2, S as S2 } from "./boolean2D-y3E92F0u.js";
 export {
   B2 as BaseSketcher2d,
   a2 as BlueprintSketcher,

package/dist/{solidBuilders-BzfRBizW.cjs → solidBuilders-994_MQwB.cjs}

@@ -1,16 +1,16 @@
 "use strict";
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
-const errors = require("./errors-9fDehDNc.cjs");
-const faceFns = require("./faceFns-BLTEPBKq.cjs");
+const result = require("./result-fAX0OZzI.cjs");
+const faceFns = require("./faceFns-DB1Fc5gy.cjs");
 function weldShapes(facesOrShells) {
   const sewn = shapeTypes.getKernel().sew(facesOrShells.map((s) => s.wrapped));
-  return errors.unwrap(faceFns.cast(errors.unwrap(faceFns.downcast(sewn))));
+  return result.unwrap(faceFns.cast(result.unwrap(faceFns.downcast(sewn))));
 }
 function weldShellsAndFaces(facesOrShells, ignoreType = false) {
   const shell = weldShapes(facesOrShells);
   if (!ignoreType && !shapeTypes.isShell(shell))
-    return errors.err(errors.typeCastError("WELD_NOT_SHELL", "Could not make a shell from faces and shells"));
-  return errors.ok(shell);
+    return result.err(result.typeCastError("WELD_NOT_SHELL", "Could not make a shell from faces and shells"));
+  return result.ok(shell);
 }
 function makeCylinder(radius, height, location = [0, 0, 0], direction = [0, 0, 1]) {
   return shapeTypes.createSolid(
@@ -38,12 +38,12 @@ function makeVertex(point) {
 }
 function makeOffset(face, offset, tolerance = 1e-6) {
   const resultShape = shapeTypes.getKernel().offset(face.wrapped, offset, tolerance);
-  return errors.andThen(
+  return result.andThen(
     faceFns.downcast(resultShape),
-    (downcasted) => errors.andThen(faceFns.cast(downcasted), (newShape) => {
+    (downcasted) => result.andThen(faceFns.cast(downcasted), (newShape) => {
       if (!shapeTypes.isShape3D(newShape))
-        return errors.err(errors.typeCastError("OFFSET_NOT_3D", "Could not offset to a 3d shape"));
-      return errors.ok(newShape);
+        return result.err(result.typeCastError("OFFSET_NOT_3D", "Could not offset to a 3d shape"));
+      return result.ok(newShape);
     })
   );
 }
@@ -52,10 +52,10 @@ function makeCompound(shapeArray) {
 }
 function makeSolid(facesOrShells) {
   const shell = weldShapes(facesOrShells);
-  return errors.andThen(faceFns.cast(shapeTypes.getKernel().solidFromShell(shell.wrapped)), (solid) => {
+  return result.andThen(faceFns.cast(shapeTypes.getKernel().solidFromShell(shell.wrapped)), (solid) => {
     if (!shapeTypes.isSolid(solid))
-      return errors.err(errors.typeCastError("SOLID_BUILD_FAILED", "Could not make a solid of faces and shells"));
-    return errors.ok(solid);
+      return result.err(result.typeCastError("SOLID_BUILD_FAILED", "Could not make a solid of faces and shells"));
+    return result.ok(solid);
   });
 }
 exports.makeCompound = makeCompound;

package/dist/{solidBuilders-BXhh5hP2.js → solidBuilders-DmwhTCCd.js}

@@ -1,6 +1,6 @@
 import { B as getKernel, q as isShell, C as createCompound, E as createVertex, F as createSolid, p as isShape3D, r as isSolid } from "./shapeTypes-CpSaBLDv.js";
-import { r as unwrap, e as err, p as typeCastError, o as ok, a as andThen } from "./errors-B7kgv0cd.js";
-import { c as cast, d as downcast } from "./faceFns-B6ebRh5I.js";
+import { v as unwrap, e as err, r as typeCastError, o as ok, a as andThen } from "./result-BaSD1fqR.js";
+import { c as cast, d as downcast } from "./faceFns-B8GnxjdY.js";
 function weldShapes(facesOrShells) {
   const sewn = getKernel().sew(facesOrShells.map((s) => s.wrapped));
   return unwrap(cast(unwrap(downcast(sewn))));

package/dist/{surfaceBuilders-Be_ENWSA.cjs → surfaceBuilders-5VA34a3_.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
-const errors = require("./errors-9fDehDNc.cjs");
-const faceFns = require("./faceFns-BLTEPBKq.cjs");
+const result = require("./result-fAX0OZzI.cjs");
+const faceFns = require("./faceFns-DB1Fc5gy.cjs");
 function range(len) {
   return Array.from(Array(len).keys());
 }
@@ -17,11 +17,11 @@ function makeCircle(radius, center = [0, 0, 0], normal = [0, 0, 1]) {
 }
 function makeEllipse(majorRadius, minorRadius, center = [0, 0, 0], normal = [0, 0, 1], xDir) {
   if (minorRadius > majorRadius) {
-    return errors.err(
-      errors.validationError("ELLIPSE_RADII", "The minor radius must be smaller than the major one")
+    return result.err(
+      result.validationError("ELLIPSE_RADII", "The minor radius must be smaller than the major one")
     );
   }
-  return errors.ok(
+  return result.ok(
     shapeTypes.createEdge(
       shapeTypes.getKernel().makeEllipseEdge(
         [...center],
@@ -43,11 +43,11 @@ function makeThreePointArc(v1, v2, v3) {
 }
 function makeEllipseArc(majorRadius, minorRadius, startAngle, endAngle, center = [0, 0, 0], normal = [0, 0, 1], xDir) {
   if (minorRadius > majorRadius) {
-    return errors.err(
-      errors.validationError("ELLIPSE_RADII", "The minor radius must be smaller than the major one")
+    return result.err(
+      result.validationError("ELLIPSE_RADII", "The minor radius must be smaller than the major one")
     );
   }
-  return errors.ok(
+  return result.ok(
     shapeTypes.createEdge(
       shapeTypes.getKernel().makeEllipseArc(
         [...center],
@@ -64,19 +64,19 @@ function makeEllipseArc(majorRadius, minorRadius, startAngle, endAngle, center =
 function makeBSplineApproximation(points, { tolerance = 1e-3, smoothing = null, degMax = 6, degMin = 1 } = {}) {
   try {
     const mutablePoints = points.map((p) => [...p]);
-    return errors.ok(
+    return result.ok(
       shapeTypes.createEdge(
         shapeTypes.getKernel().approximatePoints(mutablePoints, { tolerance, degMin, degMax, smoothing })
       )
     );
   } catch {
-    return errors.err(errors.kernelError("BSPLINE_FAILED", "B-spline approximation failed"));
+    return result.err(result.kernelError("BSPLINE_FAILED", "B-spline approximation failed"));
   }
 }
 function makeBezierCurve(points) {
   if (points.length < 2) {
-    return errors.err(
-      errors.validationError(
+    return result.err(
+      result.validationError(
         "BEZIER_MIN_POINTS",
         `Need at least 2 points for a Bezier curve, got ${points.length}`,
         void 0,
@@ -87,17 +87,17 @@ function makeBezierCurve(points) {
     );
   }
   const mutablePoints = points.map((p) => [...p]);
-  return errors.ok(shapeTypes.createEdge(shapeTypes.getKernel().makeBezierEdge(mutablePoints)));
+  return result.ok(shapeTypes.createEdge(shapeTypes.getKernel().makeBezierEdge(mutablePoints)));
 }
 function makeTangentArc(startPoint, startTgt, endPoint) {
   return shapeTypes.createEdge(shapeTypes.getKernel().makeTangentArc([...startPoint], [...startTgt], [...endPoint]));
 }
 function assembleWire(listOfEdges) {
   try {
-    return errors.ok(shapeTypes.createWire(shapeTypes.getKernel().makeWireFromMixed(listOfEdges.map((e) => e.wrapped))));
+    return result.ok(shapeTypes.createWire(shapeTypes.getKernel().makeWireFromMixed(listOfEdges.map((e) => e.wrapped))));
   } catch (e) {
-    return errors.err(
-      errors.kernelError(
+    return result.err(
+      result.kernelError(
         "WIRE_BUILD_FAILED",
         `Failed to build the wire: ${e instanceof Error ? e.message : "unknown error"}`
       )
@@ -108,12 +108,12 @@ function makeFace(wire, holes) {
   try {
     const faceShape = shapeTypes.getKernel().makeFace(wire.wrapped, true);
     if (holes && holes.length > 0) {
-      return errors.ok(addHolesInFace(shapeTypes.createFace(faceShape), holes));
+      return result.ok(addHolesInFace(shapeTypes.createFace(faceShape), holes));
     }
-    return errors.ok(shapeTypes.createFace(faceShape));
+    return result.ok(shapeTypes.createFace(faceShape));
   } catch {
-    return errors.err(
-      errors.kernelError("FACE_BUILD_FAILED", "Failed to build the face. Your wire might be non planar.")
+    return result.err(
+      result.kernelError("FACE_BUILD_FAILED", "Failed to build the face. Your wire might be non planar.")
     );
   }
 }
@@ -129,14 +129,14 @@ function makeNewFaceWithinFace(originFace, wire) {
 function makeNonPlanarFace(wire) {
   try {
     const shape = shapeTypes.getKernel().makeNonPlanarFace(wire.wrapped);
-    return errors.andThen(faceFns.cast(shape), (newFace) => {
+    return result.andThen(faceFns.cast(shape), (newFace) => {
       if (!shapeTypes.isFace(newFace)) {
-        return errors.err(errors.kernelError("FACE_BUILD_FAILED", "Failed to create a non-planar face"));
+        return result.err(result.kernelError("FACE_BUILD_FAILED", "Failed to create a non-planar face"));
       }
-      return errors.ok(newFace);
+      return result.ok(newFace);
     });
   } catch {
-    return errors.err(errors.kernelError("FACE_BUILD_FAILED", "Failed to create a non-planar face"));
+    return result.err(result.kernelError("FACE_BUILD_FAILED", "Failed to create a non-planar face"));
   }
 }
 function addHolesInFace(face, holes) {
@@ -149,14 +149,14 @@ function addHolesInFace(face, holes) {
 }
 function makePolygon(points) {
   if (points.length < 3)
-    return errors.err(
-      errors.validationError("POLYGON_MIN_POINTS", "You need at least 3 points to make a polygon")
+    return result.err(
+      result.validationError("POLYGON_MIN_POINTS", "You need at least 3 points to make a polygon")
     );
   const edges = zip([points, [...points.slice(1), points[0]]]).map(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any -- zip returns untyped pairs
     ([p1, p2]) => makeLine(p1, p2)
   );
-  return errors.andThen(assembleWire(edges), (wire) => makeFace(wire));
+  return result.andThen(assembleWire(edges), (wire) => makeFace(wire));
 }
 exports.addHolesInFace = addHolesInFace;
 exports.assembleWire = assembleWire;

package/dist/{surfaceBuilders-D6iDVPIM.js → surfaceBuilders-nQdJ56fe.js}

@@ -1,6 +1,6 @@
 import { G as createWire, B as getKernel, H as createEdge, I as createFace, k as isFace } from "./shapeTypes-CpSaBLDv.js";
-import { o as ok, e as err, k as kernelError, y as validationError, a as andThen } from "./errors-B7kgv0cd.js";
-import { o as outerWire, c as cast } from "./faceFns-B6ebRh5I.js";
+import { o as ok, e as err, k as kernelError, z as validationError, a as andThen } from "./result-BaSD1fqR.js";
+import { o as outerWire, c as cast } from "./faceFns-B8GnxjdY.js";
 function range(len) {
   return Array.from(Array(len).keys());
 }