brepjs 12.7.3 → 12.8.1

package/dist/{operations-DLFzmdFX.cjs → operations-CYpmLSC4.cjs}

@@ -1,11 +1,11 @@
 "use strict";
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const errors = require("./errors-9fDehDNc.cjs");
-const loft = require("./loft-DR1UN5uN.cjs");
-const booleanFns = require("./booleanFns-D7HmkpYt.cjs");
-const shapeFns = require("./shapeFns-D-MOoqJd.cjs");
-const faceFns = require("./faceFns-BLTEPBKq.cjs");
+const result = require("./result-fAX0OZzI.cjs");
+const loft = require("./loft-hp3pc1M7.cjs");
+const booleanFns = require("./booleanFns-gmsX3Cv2.cjs");
+const shapeFns = require("./shapeFns-C2SnNvdH.cjs");
+const faceFns = require("./faceFns-DB1Fc5gy.cjs");
 function uuidv() {
   return (String([1e7]) + String(-1e3) + String(-4e3) + String(-8e3) + String(-1e11)).replace(
     /[018]/g,
@@ -44,10 +44,10 @@ function makeHelixWire(pitch, height, radius, center, dir, _lefthand = false) {
 }
 function extrude(face, extrusionVec) {
   if (shapeTypes.getKernel().isNull(face.wrapped)) {
-    return errors.err(errors.validationError(errors.BrepErrorCode.NULL_SHAPE_INPUT, "extrude: face is a null shape"));
+    return result.err(result.validationError(result.BrepErrorCode.NULL_SHAPE_INPUT, "extrude: face is a null shape"));
   }
   if (vecOps.vecLength(extrusionVec) === 0) {
-    return errors.err(errors.validationError("EXTRUDE_ZERO_VECTOR", "extrude: extrusion vector has zero length"));
+    return result.err(result.validationError("EXTRUDE_ZERO_VECTOR", "extrude: extrusion vector has zero length"));
   }
   try {
     const kernel = shapeTypes.getKernel();
@@ -56,10 +56,10 @@ function extrude(face, extrusionVec) {
     const shape = kernel.extrude(face.wrapped, [...dir], len);
     const downcastShape = kernel.downcast(shape, "solid");
     const solid = shapeTypes.createSolid(downcastShape);
-    return errors.ok(solid);
+    return result.ok(solid);
   } catch (e) {
-    return errors.err(
-      errors.kernelError("EXTRUDE_FAILED", "Extrusion operation failed", e, {
+    return result.err(
+      result.kernelError("EXTRUDE_FAILED", "Extrusion operation failed", e, {
         operation: "extrude",
         vectorLength: vecOps.vecLength(extrusionVec)
       })
@@ -68,15 +68,15 @@ function extrude(face, extrusionVec) {
 }
 function revolve(face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) {
   if (shapeTypes.getKernel().isNull(face.wrapped)) {
-    return errors.err(errors.validationError(errors.BrepErrorCode.NULL_SHAPE_INPUT, "revolve: face is a null shape"));
+    return result.err(result.validationError(result.BrepErrorCode.NULL_SHAPE_INPUT, "revolve: face is a null shape"));
   }
   const kernel = shapeTypes.getKernel();
   const shape = kernel.revolveVec(face.wrapped, [...center], [...direction], angle);
-  const result = shapeTypes.castShape(shape);
-  if (!shapeTypes.isShape3D(result)) {
-    return errors.err(errors.typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
+  const result$1 = shapeTypes.castShape(shape);
+  if (!shapeTypes.isShape3D(result$1)) {
+    return result.err(result.typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
   }
-  return errors.ok(result);
+  return result.ok(result$1);
 }
 function sweep(wire, spine, config = {}, shellMode = false) {
   if (config.mode === "simple" && !shellMode) {
@@ -84,9 +84,9 @@ function sweep(wire, spine, config = {}, shellMode = false) {
     const resultOc = kernel2.simplePipe(wire.wrapped, spine.wrapped);
     const shape2 = shapeTypes.castShape(resultOc);
     if (!shapeTypes.isShape3D(shape2)) {
-      return errors.err(errors.typeCastError("SWEEP_NOT_3D", "Simple pipe did not produce a 3D shape"));
+      return result.err(result.typeCastError("SWEEP_NOT_3D", "Simple pipe did not produce a 3D shape"));
     }
-    return errors.ok(shape2);
+    return result.ok(shape2);
   }
   const {
     frenet = false,
@@ -104,7 +104,7 @@ function sweep(wire, spine, config = {}, shellMode = false) {
   } = config;
   const kernel = shapeTypes.getKernel();
   const withCorrection = transitionMode === "round" ? true : !!forceProfileSpineOthogonality;
-  const result = kernel.sweepPipeShell(wire.wrapped, spine.wrapped, {
+  const result$1 = kernel.sweepPipeShell(wire.wrapped, spine.wrapped, {
     transitionMode,
     contact: !!withContact,
     correction: withCorrection,
@@ -119,26 +119,26 @@ function sweep(wire, spine, config = {}, shellMode = false) {
     maxDegree,
     maxSegments
   });
-  if (shellMode && typeof result === "object" && "firstShape" in result) {
-    const shape2 = shapeTypes.castShape(result.shape);
+  if (shellMode && typeof result$1 === "object" && "firstShape" in result$1) {
+    const shape2 = shapeTypes.castShape(result$1.shape);
     if (!shapeTypes.isShape3D(shape2)) {
-      return errors.err(errors.typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
+      return result.err(result.typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
     }
-    const startWire = shapeTypes.castShape(result.firstShape);
-    const endWire = shapeTypes.castShape(result.lastShape);
+    const startWire = shapeTypes.castShape(result$1.firstShape);
+    const endWire = shapeTypes.castShape(result$1.lastShape);
     if (!shapeTypes.isWire(startWire)) {
-      return errors.err(errors.typeCastError("SWEEP_START_NOT_WIRE", "Sweep did not produce a start Wire"));
+      return result.err(result.typeCastError("SWEEP_START_NOT_WIRE", "Sweep did not produce a start Wire"));
     }
     if (!shapeTypes.isWire(endWire)) {
-      return errors.err(errors.typeCastError("SWEEP_END_NOT_WIRE", "Sweep did not produce an end Wire"));
+      return result.err(result.typeCastError("SWEEP_END_NOT_WIRE", "Sweep did not produce an end Wire"));
     }
-    return errors.ok([shape2, startWire, endWire]);
+    return result.ok([shape2, startWire, endWire]);
   }
-  const shape = shapeTypes.castShape(result);
+  const shape = shapeTypes.castShape(result$1);
   if (!shapeTypes.isShape3D(shape)) {
-    return errors.err(errors.typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
+    return result.err(result.typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
   }
-  return errors.ok(shape);
+  return result.ok(shape);
 }
 function supportExtrude(wire, center, normal, support) {
   const endPoint = vecOps.vecAdd(center, normal);
@@ -148,30 +148,30 @@ function supportExtrude(wire, center, normal, support) {
 function complexExtrude(wire, center, normal, profileShape, shellMode = false) {
   const extrusionLength = vecOps.vecLength(normal);
   if (extrusionLength === 0) {
-    return errors.err(
-      errors.validationError("ZERO_LENGTH_EXTRUSION", "Extrusion vector cannot have zero length")
+    return result.err(
+      result.validationError("ZERO_LENGTH_EXTRUSION", "Extrusion vector cannot have zero length")
     );
   }
   const endPoint = vecOps.vecAdd(center, normal);
   const spine = makeSpineWire(center, endPoint);
-  const law = profileShape ? errors.unwrap(loft.buildLawFromProfile(extrusionLength, profileShape)) : null;
+  const law = profileShape ? result.unwrap(loft.buildLawFromProfile(extrusionLength, profileShape)) : null;
   return sweep(wire, spine, { law }, shellMode);
 }
 function twistExtrude(wire, angleDegrees, center, normal, profileShape, shellMode = false) {
   if (angleDegrees === 0) {
-    return errors.err(errors.validationError("ZERO_TWIST_ANGLE", "Twist angle cannot be zero"));
+    return result.err(result.validationError("ZERO_TWIST_ANGLE", "Twist angle cannot be zero"));
   }
   const extrusionLength = vecOps.vecLength(normal);
   if (extrusionLength === 0) {
-    return errors.err(
-      errors.validationError("ZERO_LENGTH_EXTRUSION", "Extrusion vector cannot have zero length")
+    return result.err(
+      result.validationError("ZERO_LENGTH_EXTRUSION", "Extrusion vector cannot have zero length")
     );
   }
   const endPoint = vecOps.vecAdd(center, normal);
   const spine = makeSpineWire(center, endPoint);
   const pitch = 360 / angleDegrees * extrusionLength;
   const auxiliarySpine = makeHelixWire(pitch, extrusionLength, 1, center, normal);
-  const law = profileShape ? errors.unwrap(loft.buildLawFromProfile(extrusionLength, profileShape)) : null;
+  const law = profileShape ? result.unwrap(loft.buildLawFromProfile(extrusionLength, profileShape)) : null;
   return sweep(wire, spine, { auxiliarySpine, law }, shellMode);
 }
 function exportAssemblySTEP(shapes = [], { unit, modelUnit } = {}) {
@@ -198,19 +198,19 @@ function exportAssemblySTEP(shapes = [], { unit, modelUnit } = {}) {
   try {
     const stepString = kernel.writeXCAFToSTEP(doc, { unit, modelUnit });
     if (!stepString) {
-      return errors.err(errors.ioError("STEP_EXPORT_FAILED", "Failed to write STEP file"));
+      return result.err(result.ioError("STEP_EXPORT_FAILED", "Failed to write STEP file"));
     }
-    return errors.ok(new Blob([stepString], { type: "application/STEP" }));
+    return result.ok(new Blob([stepString], { type: "application/STEP" }));
   } finally {
     doc.delete();
   }
 }
 function linearPattern(shape, direction, count, spacing, options) {
   if (count < 1)
-    return errors.err(errors.validationError("PATTERN_INVALID_COUNT", "Pattern count must be at least 1"));
-  if (count === 1) return errors.ok(shape);
+    return result.err(result.validationError("PATTERN_INVALID_COUNT", "Pattern count must be at least 1"));
+  if (count === 1) return result.ok(shape);
   if (vecOps.vecIsZero(direction))
-    return errors.err(errors.validationError("PATTERN_ZERO_DIRECTION", "Pattern direction cannot be zero"));
+    return result.err(result.validationError("PATTERN_ZERO_DIRECTION", "Pattern direction cannot be zero"));
   const dir = vecOps.vecNormalize(direction);
   const ocShapes = shapeTypes.getKernel().linearPattern(shape.wrapped, [...dir], spacing, count);
   const copies = ocShapes.map((s) => shapeTypes.castShape(s));
@@ -218,10 +218,10 @@ function linearPattern(shape, direction, count, spacing, options) {
 }
 function circularPattern(shape, axis, count, fullAngle = 360, center = [0, 0, 0], options) {
   if (count < 1)
-    return errors.err(errors.validationError("PATTERN_INVALID_COUNT", "Pattern count must be at least 1"));
-  if (count === 1) return errors.ok(shape);
+    return result.err(result.validationError("PATTERN_INVALID_COUNT", "Pattern count must be at least 1"));
+  if (count === 1) return result.ok(shape);
   if (vecOps.vecIsZero(axis))
-    return errors.err(errors.validationError("PATTERN_ZERO_AXIS", "Pattern axis cannot be zero"));
+    return result.err(result.validationError("PATTERN_ZERO_AXIS", "Pattern axis cannot be zero"));
   const angleStep = fullAngle / count;
   const ocShapes = shapeTypes.getKernel().circularPattern(
     shape.wrapped,
@@ -235,12 +235,12 @@ function circularPattern(shape, axis, count, fullAngle = 360, center = [0, 0, 0]
 }
 function gridPattern(shape, directionX, directionY, countX, countY, spacingX, spacingY, options) {
   if (countX < 1 || countY < 1)
-    return errors.err(errors.validationError("PATTERN_INVALID_COUNT", "Grid pattern counts must be at least 1"));
-  if (countX === 1 && countY === 1) return errors.ok(shape);
+    return result.err(result.validationError("PATTERN_INVALID_COUNT", "Grid pattern counts must be at least 1"));
+  if (countX === 1 && countY === 1) return result.ok(shape);
   if (vecOps.vecIsZero(directionX))
-    return errors.err(errors.validationError("PATTERN_ZERO_DIRECTION", "Grid directionX cannot be zero"));
+    return result.err(result.validationError("PATTERN_ZERO_DIRECTION", "Grid directionX cannot be zero"));
   if (vecOps.vecIsZero(directionY))
-    return errors.err(errors.validationError("PATTERN_ZERO_DIRECTION", "Grid directionY cannot be zero"));
+    return result.err(result.validationError("PATTERN_ZERO_DIRECTION", "Grid directionY cannot be zero"));
   const kernel = shapeTypes.getKernel();
   const dirX = vecOps.vecNormalize(directionX);
   const dirY = vecOps.vecNormalize(directionY);
@@ -254,7 +254,7 @@ function gridPattern(shape, directionX, directionY, countX, countY, spacingX, sp
       countX,
       countY
     );
-    return errors.ok(shapeTypes.castShape(compound));
+    return result.ok(shapeTypes.castShape(compound));
   }
   const rowResult = linearPattern(shape, directionX, countX, spacingX, options);
   if (!rowResult.ok) return rowResult;
@@ -378,14 +378,14 @@ function replayHistory(history, registry) {
   for (const step of history.steps) {
     const fn = registry.operations.get(step.type);
     if (!fn) {
-      return errors.err(errors.computationError("REPLAY_UNKNOWN_OP", `Unknown operation type: ${step.type}`));
+      return result.err(result.computationError("REPLAY_UNKNOWN_OP", `Unknown operation type: ${step.type}`));
     }
     const inputs = [];
     for (const inputId of step.inputIds) {
       const shape = current.shapes.get(inputId);
       if (!shape) {
-        return errors.err(
-          errors.computationError(
+        return result.err(
+          result.computationError(
             "REPLAY_MISSING_INPUT",
             `Missing input shape: ${inputId} for step ${step.id}`
           )
@@ -407,20 +407,20 @@ function replayHistory(history, registry) {
         output
       );
     } catch (e) {
-      return errors.err(
-        errors.computationError(
+      return result.err(
+        result.computationError(
           "REPLAY_STEP_FAILED",
           `Step ${step.id} (${step.type}) failed: ${e instanceof Error ? e.message : String(e)}`
         )
       );
     }
   }
-  return errors.ok(current);
+  return result.ok(current);
 }
 function replayFrom(history, stepId, registry) {
   const idx = history.steps.findIndex((s) => s.id === stepId);
   if (idx === -1) {
-    return errors.err(errors.computationError("REPLAY_STEP_NOT_FOUND", `Step not found: ${stepId}`));
+    return result.err(result.computationError("REPLAY_STEP_NOT_FOUND", `Step not found: ${stepId}`));
   }
   const shapesMap = new Map(history.shapes);
   for (let i = idx; i < history.steps.length; i++) {
@@ -438,14 +438,14 @@ function replayFrom(history, stepId, registry) {
     if (!step) continue;
     const fn = registry.operations.get(step.type);
     if (!fn) {
-      return errors.err(errors.computationError("REPLAY_UNKNOWN_OP", `Unknown operation type: ${step.type}`));
+      return result.err(result.computationError("REPLAY_UNKNOWN_OP", `Unknown operation type: ${step.type}`));
     }
     const inputs = [];
     for (const inputId of step.inputIds) {
       const shape = current.shapes.get(inputId);
       if (!shape) {
-        return errors.err(
-          errors.computationError(
+        return result.err(
+          result.computationError(
             "REPLAY_MISSING_INPUT",
             `Missing input shape: ${inputId} for step ${step.id}`
           )
@@ -467,20 +467,20 @@ function replayFrom(history, stepId, registry) {
         output
       );
     } catch (e) {
-      return errors.err(
-        errors.computationError(
+      return result.err(
+        result.computationError(
           "REPLAY_STEP_FAILED",
           `Step ${step.id} (${step.type}) failed: ${e instanceof Error ? e.message : String(e)}`
         )
       );
     }
   }
-  return errors.ok(current);
+  return result.ok(current);
 }
 function modifyStep(history, stepId, newParams, registry) {
   const idx = history.steps.findIndex((s) => s.id === stepId);
   if (idx === -1) {
-    return errors.err(errors.computationError("MODIFY_STEP_NOT_FOUND", `Step not found: ${stepId}`));
+    return result.err(result.computationError("MODIFY_STEP_NOT_FOUND", `Step not found: ${stepId}`));
   }
   const modifiedSteps = history.steps.map(
     (s) => s.id === stepId ? { ...s, parameters: newParams } : s
@@ -494,40 +494,40 @@ function serializeHistory(history) {
     try {
       shapes[id] = shapeFns.toBREP(shape);
     } catch (e) {
-      return errors.err(
-        errors.computationError(
+      return result.err(
+        result.computationError(
           "SERIALIZE_SHAPE_FAILED",
           `Failed to serialize shape "${id}": ${e instanceof Error ? e.message : String(e)}`
         )
       );
     }
   }
-  return errors.ok({ steps: history.steps, shapes });
+  return result.ok({ steps: history.steps, shapes });
 }
 function deserializeHistory(data) {
   const shapes = /* @__PURE__ */ new Map();
   for (const [id, brep] of Object.entries(data.shapes)) {
     try {
-      const result = faceFns.fromBREP(brep);
-      if (!result.ok) {
-        return errors.err(
-          errors.computationError(
+      const result$1 = faceFns.fromBREP(brep);
+      if (!result$1.ok) {
+        return result.err(
+          result.computationError(
             "DESERIALIZE_SHAPE_FAILED",
-            `Failed to deserialize shape "${id}": ${result.error.message}`
+            `Failed to deserialize shape "${id}": ${result$1.error.message}`
           )
         );
       }
-      shapes.set(id, result.value);
+      shapes.set(id, result$1.value);
     } catch (e) {
-      return errors.err(
-        errors.computationError(
+      return result.err(
+        result.computationError(
           "DESERIALIZE_SHAPE_FAILED",
           `Failed to deserialize shape "${id}": ${e instanceof Error ? e.message : String(e)}`
         )
       );
     }
   }
-  return errors.ok({ steps: data.steps, shapes });
+  return result.ok({ steps: data.steps, shapes });
 }
 exports.addChild = addChild;
 exports.addStep = addStep;

package/dist/operations.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const operations = require("./operations-DLFzmdFX.cjs");
-const loft = require("./loft-DR1UN5uN.cjs");
+const operations = require("./operations-CYpmLSC4.cjs");
+const loft = require("./loft-hp3pc1M7.cjs");
 exports.addChild = operations.addChild;
 exports.addStep = operations.addStep;
 exports.circularPattern = operations.circularPattern;

package/dist/operations.js

@@ -1,5 +1,5 @@
-import { a, b, c, d, f, g, h, i, j, k, n, o, p, q, H, l, t, u, v, x, y, z, B, C, D, s, E, F, G, w } from "./operations-Dcz6YlOt.js";
-import { b as b2, g as g2, l as l2, r } from "./loft-BcZUCGKi.js";
+import { a, b, c, d, f, g, h, i, j, k, n, o, p, q, H, l, t, u, v, x, y, z, B, C, D, s, E, F, G, w } from "./operations-BfbkK6DU.js";
+import { b as b2, g as g2, l as l2, r } from "./loft-Bhw-FMoL.js";
 export {
   a as addChild,
   b as addStep,

package/dist/query.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const helpers = require("./helpers-6kn30cSD.cjs");
-const cornerFinder = require("./cornerFinder-3zfbQvXg.cjs");
+const helpers = require("./helpers-C8NoT0Wu.cjs");
+const cornerFinder = require("./cornerFinder-ZmOyOOsh.cjs");
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const curveFns = require("./curveFns-Ch87sD5O.cjs");
+const curveFns = require("./curveFns-BZngcnQ1.cjs");
 function edgeDirectionFilter(dir, angle) {
   const d = vecOps.vecNormalize(helpers.resolveDir(dir));
   return (edge) => {

package/dist/query.js

@@ -1,9 +1,9 @@
-import { l as createTypedFinder, n as distanceFromPointFilter, o as resolveDir } from "./helpers-C9KvE1RW.js";
-import { m, g } from "./helpers-C9KvE1RW.js";
-import { c } from "./cornerFinder-BV-l1BCw.js";
+import { l as createTypedFinder, n as distanceFromPointFilter, o as resolveDir } from "./helpers-X0juxnwj.js";
+import { m, g } from "./helpers-X0juxnwj.js";
+import { c } from "./cornerFinder-Ckz-mPHE.js";
 import { B as getKernel } from "./shapeTypes-CpSaBLDv.js";
 import { j as vecNormalize, d as vecDot, D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
-import { l as getCurveType, f as curveLength } from "./curveFns-CloOqAQ_.js";
+import { l as getCurveType, f as curveLength } from "./curveFns-mROFhiuG.js";
 function edgeDirectionFilter(dir, angle) {
   const d = vecNormalize(resolveDir(dir));
   return (edge) => {

package/dist/{errors-B7kgv0cd.js → result-BaSD1fqR.js}

@@ -117,6 +117,17 @@ function pipeline(input) {
   }
   return makePipeline(initial);
 }
+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);
+}
 const BrepErrorCode = {
   // kernel operation errors
   BSPLINE_FAILED: "BSPLINE_FAILED",
@@ -320,41 +331,50 @@ function translateKernelError(kernelMessage) {
   }
   return kernelMessage;
 }
+function safeIndex(arr, index, context) {
+  if (index < 0 || index >= arr.length) {
+    bug(context ?? "safeIndex", `Index ${index} is out of bounds (array length ${arr.length})`);
+  }
+  return arr[index];
+}
 export {
-  all as A,
-  BrepErrorCode as B,
-  fromNullable as C,
-  or as D,
-  orElse as E,
-  pipeline as F,
-  tap as G,
-  tapErr as H,
-  zip as I,
+  BrepErrorCode as A,
+  BrepBugError as B,
+  safeIndex as C,
+  translateKernelError as D,
+  all as E,
+  fromNullable as F,
+  or as G,
+  orElse as H,
+  pipeline as I,
+  tap as J,
+  tapErr as K,
+  zip as L,
   OK as O,
   andThen as a,
-  computationError as b,
+  bug as b,
   collect as c,
-  isErr as d,
+  computationError as d,
   err as e,
   flatMap as f,
-  isOk as g,
-  mapErr as h,
+  isErr as g,
+  isOk as h,
   ioError as i,
-  match as j,
+  mapErr as j,
   kernelError as k,
-  moduleInitError as l,
+  match as l,
   map as m,
-  tryCatchAsync as n,
+  moduleInitError as n,
   ok as o,
-  typeCastError as p,
+  tryCatchAsync as p,
   queryError as q,
-  unwrap as r,
+  typeCastError as r,
   sketcherStateError as s,
   tryCatch as t,
   unsupportedError as u,
-  unwrapErr as v,
-  unwrapOr as w,
-  unwrapOrElse as x,
-  validationError as y,
-  translateKernelError as z
+  unwrap as v,
+  unwrapErr as w,
+  unwrapOr as x,
+  unwrapOrElse as y,
+  validationError as z
 };

package/dist/{errors-9fDehDNc.cjs → result-fAX0OZzI.cjs}

@@ -118,6 +118,17 @@ function pipeline(input) {
   }
   return makePipeline(initial);
 }
+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);
+}
 const BrepErrorCode = {
   // kernel operation errors
   BSPLINE_FAILED: "BSPLINE_FAILED",
@@ -321,10 +332,18 @@ function translateKernelError(kernelMessage) {
   }
   return kernelMessage;
 }
+function safeIndex(arr, index, context) {
+  if (index < 0 || index >= arr.length) {
+    bug(context ?? "safeIndex", `Index ${index} is out of bounds (array length ${arr.length})`);
+  }
+  return arr[index];
+}
+exports.BrepBugError = BrepBugError;
 exports.BrepErrorCode = BrepErrorCode;
 exports.OK = OK;
 exports.all = all;
 exports.andThen = andThen;
+exports.bug = bug;
 exports.collect = collect;
 exports.computationError = computationError;
 exports.err = err;
@@ -343,6 +362,7 @@ exports.or = or;
 exports.orElse = orElse;
 exports.pipeline = pipeline;
 exports.queryError = queryError;
+exports.safeIndex = safeIndex;
 exports.sketcherStateError = sketcherStateError;
 exports.tap = tap;
 exports.tapErr = tapErr;

package/dist/result.cjs

@@ -1,43 +1,32 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const errors = require("./errors-9fDehDNc.cjs");
-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);
-}
-exports.BrepErrorCode = errors.BrepErrorCode;
-exports.OK = errors.OK;
-exports.andThen = errors.andThen;
-exports.collect = errors.collect;
-exports.computationError = errors.computationError;
-exports.err = errors.err;
-exports.flatMap = errors.flatMap;
-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.pipeline = errors.pipeline;
-exports.queryError = errors.queryError;
-exports.sketcherStateError = errors.sketcherStateError;
-exports.tryCatch = errors.tryCatch;
-exports.tryCatchAsync = errors.tryCatchAsync;
-exports.typeCastError = errors.typeCastError;
-exports.unwrap = errors.unwrap;
-exports.unwrapErr = errors.unwrapErr;
-exports.unwrapOr = errors.unwrapOr;
-exports.unwrapOrElse = errors.unwrapOrElse;
-exports.validationError = errors.validationError;
-exports.BrepBugError = BrepBugError;
-exports.bug = bug;
+const result = require("./result-fAX0OZzI.cjs");
+exports.BrepBugError = result.BrepBugError;
+exports.BrepErrorCode = result.BrepErrorCode;
+exports.OK = result.OK;
+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.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.pipeline = result.pipeline;
+exports.queryError = result.queryError;
+exports.sketcherStateError = result.sketcherStateError;
+exports.tryCatch = result.tryCatch;
+exports.tryCatchAsync = result.tryCatchAsync;
+exports.typeCastError = result.typeCastError;
+exports.unwrap = result.unwrap;
+exports.unwrapErr = result.unwrapErr;
+exports.unwrapOr = result.unwrapOr;
+exports.unwrapOrElse = result.unwrapOrElse;
+exports.validationError = result.validationError;