brepjs 12.7.3 → 12.8.1

package/dist/{boolean2D-CwZAIJDS.js → boolean2D-y3E92F0u.js}

@@ -43,18 +43,17 @@ var __callDispose = (stack, error, hasError) => {
   };
   return next();
 };
-import { a as createPlane } from "./vectors-CESkzEm6.js";
-import { o as ok, e as err, b as computationError, r as unwrap, g as isOk } from "./errors-B7kgv0cd.js";
-import { d as downcast, u as uvBounds, p as pointOnSurface, n as normalAt } from "./faceFns-B6ebRh5I.js";
+import { a as createPlane } from "./vectors-Bx8wkNui.js";
+import { o as ok, e as err, d as computationError, v as unwrap, h as isOk, C as safeIndex, b as bug } from "./result-BaSD1fqR.js";
+import { d as downcast, u as uvBounds, p as pointOnSurface, n as normalAt } from "./faceFns-B8GnxjdY.js";
 import { a as toVec3 } from "./types-CWDdqcrq.js";
 import { n as vecScale, j as vecNormalize, b as vecCross, D as DEG2RAD, R as RAD2DEG } from "./vecOps-ZDdZWbwT.js";
-import { r as revolution, c as complexExtrude, t as twistExtrude, b as basicFaceExtrusion, g as genericSweep, l as loft } from "./loft-BcZUCGKi.js";
+import { r as revolution, c as complexExtrude, t as twistExtrude, b as basicFaceExtrusion, g as genericSweep, l as loft } from "./loft-Bhw-FMoL.js";
 import { J as getKernel2D, I as createFace, G as createWire, B as getKernel, H as createEdge, D as DisposalScope } from "./shapeTypes-CpSaBLDv.js";
-import { c as curveStartPoint, a as curveTangentAt, b as curveIsClosed } from "./curveFns-CloOqAQ_.js";
-import { m as makeFace, h as makeNewFaceWithinFace, b as assembleWire, z as zip } from "./surfaceBuilders-D6iDVPIM.js";
-import { bug } from "./result.js";
-import { s as samePoint$1, e as subtract2d, c as add2d, h as crossProduct2d, b as scalarMultiply2d, p as polarToCartesian, r as rotate2d, i as cartesianToPolar, d as distance2d, j as polarAngle2d, k as PRECISION_INTERSECTION } from "./helpers-C9KvE1RW.js";
-import { C as Curve2D, a as make2dSegmentCurve, k as approximateAsBSpline, n as normalize2d, b as make2dArcFromCenter, l as isPoint2D, h as make2dCircle, o as make2dThreePointArc, e as BoundingBox2d, v as viewbox, p as asSVG, B as Blueprint, q as make2dEllipseArc, r as make2dTangentArc, s as make2dBezierCurve, t as removeDuplicatePoints } from "./Blueprint-C3lWY1Jf.js";
+import { c as curveStartPoint, a as curveTangentAt, b as curveIsClosed } from "./curveFns-mROFhiuG.js";
+import { m as makeFace, h as makeNewFaceWithinFace, b as assembleWire, z as zip } from "./surfaceBuilders-nQdJ56fe.js";
+import { s as samePoint$1, e as subtract2d, c as add2d, h as crossProduct2d, b as scalarMultiply2d, p as polarToCartesian, r as rotate2d, i as cartesianToPolar, d as distance2d, j as polarAngle2d, k as PRECISION_INTERSECTION } from "./helpers-X0juxnwj.js";
+import { C as Curve2D, a as make2dSegmentCurve, k as approximateAsBSpline, n as normalize2d, b as make2dArcFromCenter, l as isPoint2D, h as make2dCircle, o as make2dThreePointArc, e as BoundingBox2d, v as viewbox, p as asSVG, B as Blueprint, q as make2dEllipseArc, r as make2dTangentArc, s as make2dBezierCurve, t as removeDuplicatePoints } from "./Blueprint-DbVaf6k7.js";
 const intersectCurves = (first, second, precision = 1e-9) => {
   if (first.boundingBox.isOut(second.boundingBox))
     return ok({ intersections: [], commonSegments: [], commonSegmentsPoints: [] });
@@ -863,7 +862,7 @@ class Blueprints {
 }
 const groupByBoundingBoxOverlap = (blueprints) => {
   if (blueprints.length === 0) return [];
-  if (blueprints.length === 1) return [[blueprints[0]]];
+  if (blueprints.length === 1) return [[safeIndex(blueprints, 0, "groupByBoundingBoxOverlap")]];
   const index = new Flatbush(blueprints.length);
   for (const bp of blueprints) {
     const [[xMin, yMin], [xMax, yMax]] = bp.boundingBox.bounds;
@@ -874,8 +873,9 @@ const groupByBoundingBoxOverlap = (blueprints) => {
     const [[xMin, yMin], [xMax, yMax]] = blueprint.boundingBox.bounds;
     const candidates = index.search(xMin, yMin, xMax, yMax);
     return candidates.filter(
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- index from spatial query within bounds
-      (j) => j > i && !blueprint.boundingBox.isOut(blueprints[j].boundingBox)
+      (j) => j > i && !blueprint.boundingBox.isOut(
+        safeIndex(blueprints, j, "groupByBoundingBoxOverlap").boundingBox
+      )
     );
   });
   const groups = [];
@@ -886,7 +886,7 @@ const groupByBoundingBoxOverlap = (blueprints) => {
       myGroup = [];
       groups.push(myGroup);
     }
-    myGroup.push(blueprints[i]);
+    myGroup.push(safeIndex(blueprints, i, "groupByBoundingBoxOverlap"));
     if (indices.length) {
       indices.forEach((idx) => {
         groupsInOverlaps[idx] = myGroup;
@@ -897,7 +897,7 @@ const groupByBoundingBoxOverlap = (blueprints) => {
 };
 const addContainmentInfo = (groupedBlueprints) => {
   return groupedBlueprints.map((blueprint, index) => {
-    const firstCurve = blueprint.curves[0];
+    const firstCurve = safeIndex(blueprint.curves, 0, "addContainmentInfo");
     const point = firstCurve.value((firstCurve.lastParameter + firstCurve.firstParameter) / 2);
     const isIn = groupedBlueprints.filter((potentialOuterBlueprint, j) => {
       if (index === j) return false;
@@ -941,7 +941,7 @@ const organiseBlueprints = (blueprints) => {
   const basicGrouping = groupByBoundingBoxOverlap(blueprints).map(addContainmentInfo);
   return new Blueprints(
     basicGrouping.flatMap(cleanEdgeCases).map((compounds) => {
-      if (compounds.length === 1) return compounds[0].blueprint;
+      if (compounds.length === 1) return safeIndex(compounds, 0, "organiseBlueprints").blueprint;
       compounds.sort((a, b) => a.isIn.length - b.isIn.length);
       return new CompoundBlueprint(compounds.map(({ blueprint }) => blueprint));
     })
@@ -2266,7 +2266,11 @@ const fuseIntersectingBlueprints = (blueprints) => {
       if (!genericIntersects(blueprint, otherBlueprint)) return;
       let newFused;
       if (blueprint instanceof Blueprints || otherBlueprint instanceof Blueprints) {
-        newFused = fuse2D(blueprint, otherBlueprint);
+        const fused2 = fuse2D(blueprint, otherBlueprint);
+        if (fused2 === null) {
+          bug("fuseIntersectingBlueprints", "fuse2D returned null for non-null inputs");
+        }
+        newFused = fused2;
       } else {
         newFused = genericFuse(blueprint, otherBlueprint);
       }
@@ -2274,7 +2278,7 @@ const fuseIntersectingBlueprints = (blueprints) => {
         if (newFused instanceof Blueprints && newFused.blueprints.length === 2) {
           return;
         } else if (newFused instanceof Blueprints && newFused.blueprints.length === 1) {
-          newFused = newFused.blueprints[0];
+          newFused = safeIndex(newFused.blueprints, 0, "fuseIntersectingBlueprints");
         } else if (!(newFused instanceof Blueprints)) {
           bug("fuseIntersectingBlueprints", "Fuse produced unexpected non-blueprint result");
         }
@@ -2293,7 +2297,10 @@ const allBlueprints = (shape) => {
   return [];
 };
 const fuseBlueprintWithCompound = (blueprint, compound) => {
-  const outerFused = fuseBlueprints(blueprint, compound.blueprints[0]);
+  const outerFused = fuseBlueprints(
+    blueprint,
+    safeIndex(compound.blueprints, 0, "fuseBlueprintWithCompound")
+  );
   const innerFused = compound.blueprints.slice(1).map((c) => cutBlueprints(c, blueprint));
   return organiseBlueprints([
     ...allBlueprints(outerFused),
@@ -2310,9 +2317,11 @@ function allPairs(list1, list2) {
   return result;
 }
 const fuseCompoundWithCompound = (first, second) => {
-  const outerFused = fuseBlueprints(first.blueprints[0], second.blueprints[0]);
-  const inner1Fused = second.blueprints.slice(1).map((c) => cutBlueprints(c, first.blueprints[0]));
-  const inner2Fused = first.blueprints.slice(1).map((c) => cutBlueprints(c, second.blueprints[0]));
+  const firstOuter = safeIndex(first.blueprints, 0, "fuseCompoundWithCompound");
+  const secondOuter = safeIndex(second.blueprints, 0, "fuseCompoundWithCompound");
+  const outerFused = fuseBlueprints(firstOuter, secondOuter);
+  const inner1Fused = second.blueprints.slice(1).map((c) => cutBlueprints(c, firstOuter));
+  const inner2Fused = first.blueprints.slice(1).map((c) => cutBlueprints(c, secondOuter));
   const innerIntersections = allPairs(
     first.blueprints.slice(1),
     second.blueprints.slice(1)
@@ -2340,7 +2349,7 @@ const fuse2D = (first, second) => {
     return fuseIntersectingBlueprints([second, ...first.blueprints]);
   }
   if (first instanceof Blueprints && second instanceof Blueprints) {
-    let out = fuse2D(first.blueprints[0], second);
+    let out = fuse2D(safeIndex(first.blueprints, 0, "fuse2D"), second);
     first.blueprints.slice(1).forEach((bp) => {
       out = fuse2D(bp, out);
     });
@@ -2379,7 +2388,7 @@ const mergeNonIntersecting = (shapes) => {
     if (s instanceof Blueprints) return s.blueprints;
     return s;
   });
-  if (exploded.length === 1) return exploded[0];
+  if (exploded.length === 1) return safeIndex(exploded, 0, "mergeNonIntersecting");
   return new Blueprints(exploded);
 };
 const cut2D = (first, second) => {
@@ -2393,13 +2402,13 @@ const cut2D = (first, second) => {
     return mergeNonIntersecting(first.blueprints.map((bp) => cut2D(bp, second)));
   }
   if (first instanceof CompoundBlueprint) {
-    const wrapper = first.blueprints[0];
+    const wrapper = safeIndex(first.blueprints, 0, "cut2D");
     if (second instanceof Blueprint && !second.intersects(wrapper)) {
       if (!wrapper.isInside(second.firstPoint)) return null;
       const cuts = fuse2D(second, new Blueprints(first.blueprints.slice(1)));
       return organiseBlueprints([wrapper, ...allBlueprints(cuts)]);
     } else {
-      let out = cut2D(first.blueprints[0], second);
+      let out = cut2D(wrapper, second);
       first.blueprints.slice(1).forEach((bp) => {
         out = cut2D(out, bp);
       });
@@ -2410,7 +2419,7 @@ const cut2D = (first, second) => {
     return mergeNonIntersecting(second.blueprints.map((bp) => cut2D(first, bp)));
   }
   if (second instanceof CompoundBlueprint) {
-    let out = cutBlueprints(first, second.blueprints[0]);
+    let out = cutBlueprints(first, safeIndex(second.blueprints, 0, "cut2D"));
     second.blueprints.slice(1).forEach((bp) => {
       out = fuse2D(out, intersectBlueprints(bp, first));
     });
@@ -2430,7 +2439,7 @@ function intersect2D(first, second) {
     return mergeNonIntersecting(first.blueprints.map((bp) => intersect2D(bp, second)));
   }
   if (first instanceof CompoundBlueprint) {
-    const wrapper = first.blueprints[0];
+    const wrapper = safeIndex(first.blueprints, 0, "intersect2D");
     const cuts = first.blueprints.slice(1);
     if (cuts.length === 0) {
       return intersect2D(wrapper, second);
@@ -2445,7 +2454,7 @@ function intersect2D(first, second) {
     return mergeNonIntersecting(second.blueprints.map((bp) => intersect2D(first, bp)));
   }
   if (second instanceof CompoundBlueprint) {
-    const wrapper = second.blueprints[0];
+    const wrapper = safeIndex(second.blueprints, 0, "intersect2D");
     const cuts = second.blueprints.slice(1);
     if (cuts.length === 0) {
       return intersect2D(wrapper, first);

package/dist/{booleanFns-CcNUsgI8.js → booleanFns-BCTjYZAg.js}

@@ -1,9 +1,9 @@
 import { B as getKernel, c as castShape, p as isShape3D } from "./shapeTypes-CpSaBLDv.js";
-import { o as ok, d as isErr, e as err, y as validationError, B as BrepErrorCode, p as typeCastError, k as kernelError } from "./errors-B7kgv0cd.js";
-import { r as resolvePlane } from "./vectors-CESkzEm6.js";
+import { o as ok, g as isErr, e as err, z as validationError, A as BrepErrorCode, r as typeCastError, k as kernelError } from "./result-BaSD1fqR.js";
+import { r as resolvePlane } from "./vectors-Bx8wkNui.js";
 import { H as HASH_CODE_MAX, n as vecScale, v as vecAdd } from "./vecOps-ZDdZWbwT.js";
-import { a as getFaces, p as propagateOriginsByHash, b as propagateOriginsFromEvolution, c as getWires, d as getEdges, e as getVertices, g as getFaceOrigins } from "./shapeFns-D2PlLFE6.js";
-import { m as makeFace } from "./surfaceBuilders-D6iDVPIM.js";
+import { a as getFaces, p as propagateOriginsByHash, b as propagateOriginsFromEvolution, c as getWires, d as getEdges, e as getVertices, g as getFaceOrigins } from "./shapeFns-FDuKkrDR.js";
+import { m as makeFace } from "./surfaceBuilders-nQdJ56fe.js";
 const shapeTagStore = /* @__PURE__ */ new WeakMap();
 const tagMetadataStore = /* @__PURE__ */ new WeakMap();
 function hasFaceTags(shape) {

package/dist/{booleanFns-D7HmkpYt.cjs → booleanFns-gmsX3Cv2.cjs}

@@ -1,10 +1,10 @@
 "use strict";
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
-const errors = require("./errors-9fDehDNc.cjs");
-const vectors = require("./vectors-BafmMf96.cjs");
+const result = require("./result-fAX0OZzI.cjs");
+const vectors = require("./vectors-D_IiZx0q.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const shapeFns = require("./shapeFns-D-MOoqJd.cjs");
-const surfaceBuilders = require("./surfaceBuilders-Be_ENWSA.cjs");
+const shapeFns = require("./shapeFns-C2SnNvdH.cjs");
+const surfaceBuilders = require("./surfaceBuilders-5VA34a3_.cjs");
 const shapeTagStore = /* @__PURE__ */ new WeakMap();
 const tagMetadataStore = /* @__PURE__ */ new WeakMap();
 function hasFaceTags(shape) {
@@ -41,19 +41,19 @@ function findFacesByTag(shape, tag) {
   if (!tagMap) return [];
   const hashes = tagMap.get(tag);
   if (!hashes || hashes.size === 0) return [];
-  const result = [];
+  const result2 = [];
   for (const face of shapeFns.getFaces(shape)) {
     const hash = shapeTypes.getKernel().hashCode(face.wrapped, vecOps.HASH_CODE_MAX);
     if (hashes.has(hash)) {
-      result.push(face);
+      result2.push(face);
     }
   }
-  return result;
+  return result2;
 }
 function getFaceTags(shape) {
-  const result = /* @__PURE__ */ new Map();
+  const result2 = /* @__PURE__ */ new Map();
   const tagMap = shapeTagStore.get(shape.wrapped);
-  if (!tagMap) return result;
+  if (!tagMap) return result2;
   const faces = shapeFns.getFaces(shape);
   const faceByHash = /* @__PURE__ */ new Map();
   for (const face of faces) {
@@ -66,10 +66,10 @@ function getFaceTags(shape) {
       if (face) taggedFaces.push(face);
     }
     if (taggedFaces.length > 0) {
-      result.set(tag, taggedFaces);
+      result2.set(tag, taggedFaces);
     }
   }
-  return result;
+  return result2;
 }
 function setTagMetadata(shape, tag, metadata) {
   const metaMap = getMetaMap(shape);
@@ -79,8 +79,8 @@ function setTagMetadata(shape, tag, metadata) {
 function getTagMetadata(shape, tag) {
   return tagMetadataStore.get(shape.wrapped)?.get(tag);
 }
-function propagateFaceTagsFromEvolution(evolution, inputs, result) {
-  const resultTagMap = getTagMap(result);
+function propagateFaceTagsFromEvolution(evolution, inputs, result2) {
+  const resultTagMap = getTagMap(result2);
   for (const input of inputs) {
     const inputTagMap = shapeTagStore.get(input.wrapped);
     if (!inputTagMap) continue;
@@ -113,7 +113,7 @@ function propagateFaceTagsFromEvolution(evolution, inputs, result) {
     }
     const inputMetaMap = tagMetadataStore.get(input.wrapped);
     if (inputMetaMap) {
-      const resultMetaMap = getMetaMap(result);
+      const resultMetaMap = getMetaMap(result2);
       for (const [tag, meta] of inputMetaMap) {
         if (!resultMetaMap.has(tag)) {
           resultMetaMap.set(tag, meta);
@@ -171,15 +171,15 @@ function getFaceColor(shape, face) {
   if (!map) return void 0;
   return map.get(shapeTypes.getKernel().hashCode(face.wrapped, vecOps.HASH_CODE_MAX));
 }
-function propagateColorsFromEvolution(evolution, inputs, result) {
+function propagateColorsFromEvolution(evolution, inputs, result2) {
   for (const input of inputs) {
     const c = shapeColorStore.get(input.wrapped);
     if (c) {
-      shapeColorStore.set(result.wrapped, c);
+      shapeColorStore.set(result2.wrapped, c);
       break;
     }
   }
-  const resultFaceMap = getFaceColorMap(result);
+  const resultFaceMap = getFaceColorMap(result2);
   for (const input of inputs) {
     const inputFaceMap = faceColorStore.get(input.wrapped);
     if (!inputFaceMap || inputFaceMap.size === 0) continue;
@@ -198,9 +198,9 @@ function propagateColorsFromEvolution(evolution, inputs, result) {
 }
 function validateShape3D(shape, label) {
   if (shapeTypes.getKernel().isNull(shape.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 castToShape3D(shape, errorCode, errorMsg) {
   const wrapped = shapeTypes.castShape(shape);
@@ -219,9 +219,9 @@ function castToShape3D(shape, errorCode, errorMsg) {
     ];
     const typeName = typeNames[shapeType] ?? `UNKNOWN(${shapeType})`;
     wrapped[Symbol.dispose]();
-    return errors.err(errors.typeCastError(errorCode, `${errorMsg}. Got ${typeName} instead.`));
+    return result.err(result.typeCastError(errorCode, `${errorMsg}. Got ${typeName} instead.`));
   }
-  return errors.ok(wrapped);
+  return result.ok(wrapped);
 }
 function collectInputFaceHashes(inputs) {
   const hasMetadata = inputs.some(
@@ -240,9 +240,9 @@ function collectInputFaceHashes(inputs) {
 function fuse(a, b, { optimisation = "none", simplify = false, signal, fuzzyValue } = {}) {
   if (signal?.aborted) throw signal.reason;
   const checkA = validateShape3D(a, "fuse: first operand");
-  if (errors.isErr(checkA)) return checkA;
+  if (result.isErr(checkA)) return checkA;
   const checkB = validateShape3D(b, "fuse: second operand");
-  if (errors.isErr(checkB)) return checkB;
+  if (result.isErr(checkB)) return checkB;
   const inputFaceHashes = collectInputFaceHashes([a, b]);
   const { shape: resultShape, evolution } = shapeTypes.getKernel().fuseWithHistory(
     a.wrapped,
@@ -262,9 +262,9 @@ function fuse(a, b, { optimisation = "none", simplify = false, signal, fuzzyValu
 function cut(base, tool, { optimisation = "none", simplify = false, signal, fuzzyValue } = {}) {
   if (signal?.aborted) throw signal.reason;
   const checkBase = validateShape3D(base, "cut: base");
-  if (errors.isErr(checkBase)) return checkBase;
+  if (result.isErr(checkBase)) return checkBase;
   const checkTool = validateShape3D(tool, "cut: tool");
-  if (errors.isErr(checkTool)) return checkTool;
+  if (result.isErr(checkTool)) return checkTool;
   const inputFaceHashes = collectInputFaceHashes([base, tool]);
   const { shape: resultShape, evolution } = shapeTypes.getKernel().cutWithHistory(
     base.wrapped,
@@ -284,9 +284,9 @@ function cut(base, tool, { optimisation = "none", simplify = false, signal, fuzz
 function intersect(a, b, { simplify = false, signal, fuzzyValue } = {}) {
   if (signal?.aborted) throw signal.reason;
   const checkA = validateShape3D(a, "intersect: first operand");
-  if (errors.isErr(checkA)) return checkA;
+  if (result.isErr(checkA)) return checkA;
   const checkB = validateShape3D(b, "intersect: second operand");
-  if (errors.isErr(checkB)) return checkB;
+  if (result.isErr(checkB)) return checkB;
   const inputFaceHashes = collectInputFaceHashes([a, b]);
   const { shape: resultShape, evolution } = shapeTypes.getKernel().intersectWithHistory(
     a.wrapped,
@@ -310,7 +310,7 @@ function intersect(a, b, { simplify = false, signal, fuzzyValue } = {}) {
 function fuseAllPairwise(shapes, start, end, optimisation, simplify, isTopLevel, signal, fuzzyValue) {
   if (signal?.aborted) throw signal.reason;
   const count = end - start;
-  if (count === 1) return errors.ok(shapes[start]);
+  if (count === 1) return result.ok(shapes[start]);
   if (count === 2) {
     return fuse(shapes[start], shapes[start + 1], {
       optimisation,
@@ -330,7 +330,7 @@ function fuseAllPairwise(shapes, start, end, optimisation, simplify, isTopLevel,
     signal,
     fuzzyValue
   );
-  if (errors.isErr(leftResult)) return leftResult;
+  if (result.isErr(leftResult)) return leftResult;
   const rightResult = fuseAllPairwise(
     shapes,
     mid,
@@ -341,7 +341,7 @@ function fuseAllPairwise(shapes, start, end, optimisation, simplify, isTopLevel,
     signal,
     fuzzyValue
   );
-  if (errors.isErr(rightResult)) return rightResult;
+  if (result.isErr(rightResult)) return rightResult;
   return fuse(leftResult.value, rightResult.value, {
     optimisation,
     simplify: isTopLevel ? simplify : false,
@@ -358,19 +358,19 @@ function fuseAll(shapes, {
 } = {}) {
   if (signal?.aborted) throw signal.reason;
   if (shapes.length === 0)
-    return errors.err(errors.validationError("FUSE_ALL_EMPTY", "fuseAll requires at least one shape"));
-  if (shapes.length === 1) return errors.ok(shapes[0]);
+    return result.err(result.validationError("FUSE_ALL_EMPTY", "fuseAll requires at least one shape"));
+  if (shapes.length === 1) return result.ok(shapes[0]);
   for (let i = 0; i < shapes.length; i++) {
     const check = validateShape3D(shapes[i], `fuseAll: shape at index ${i}`);
-    if (errors.isErr(check)) return check;
+    if (result.isErr(check)) return check;
   }
   if (strategy === "native") {
-    const result = shapeTypes.getKernel().fuseAll(
+    const result2 = shapeTypes.getKernel().fuseAll(
       shapes.map((s) => s.wrapped),
       { optimisation, simplify, strategy, fuzzyValue, ...signal ? { signal } : {} }
     );
     const fuseAllResult = castToShape3D(
-      result,
+      result2,
       "FUSE_ALL_NOT_3D",
       "fuseAll did not produce a 3D shape"
     );
@@ -392,20 +392,20 @@ function fuseAll(shapes, {
 }
 function cutAll(base, tools, { optimisation = "none", simplify = false, signal, fuzzyValue } = {}) {
   if (signal?.aborted) throw signal.reason;
-  if (tools.length === 0) return errors.ok(base);
+  if (tools.length === 0) return result.ok(base);
   const checkBase = validateShape3D(base, "cutAll: base");
-  if (errors.isErr(checkBase)) return checkBase;
+  if (result.isErr(checkBase)) return checkBase;
   for (let i = 0; i < tools.length; i++) {
     const check = validateShape3D(tools[i], `cutAll: tool at index ${i}`);
-    if (errors.isErr(check)) return check;
+    if (result.isErr(check)) return check;
   }
   const allInputs = [base, ...tools];
-  const result = shapeTypes.getKernel().cutAll(
+  const result$1 = shapeTypes.getKernel().cutAll(
     base.wrapped,
     tools.map((s) => s.wrapped),
     { optimisation, simplify, fuzzyValue }
   );
-  const cutAllResult = castToShape3D(result, "CUT_ALL_NOT_3D", "cutAll did not produce a 3D shape");
+  const cutAllResult = castToShape3D(result$1, "CUT_ALL_NOT_3D", "cutAll did not produce a 3D shape");
   if (cutAllResult.ok) {
     shapeFns.propagateOriginsByHash(allInputs, cutAllResult.value);
   }
@@ -436,7 +436,7 @@ function makeSectionFace(plane, size) {
 }
 function section(shape, plane, { approximation = true, planeSize = 1e4 } = {}) {
   if (shapeTypes.getKernel().isNull(shape.wrapped)) {
-    return errors.err(errors.validationError(errors.BrepErrorCode.NULL_SHAPE_INPUT, "section: shape is a null shape"));
+    return result.err(result.validationError(result.BrepErrorCode.NULL_SHAPE_INPUT, "section: shape is a null shape"));
   }
   const resolvedPlane = typeof plane === "string" ? vectors.resolvePlane(plane) : plane;
   const sectionFace = makeSectionFace(resolvedPlane, planeSize);
@@ -444,12 +444,12 @@ function section(shape, plane, { approximation = true, planeSize = 1e4 } = {}) {
     const kernel = shapeTypes.getKernel();
     const resultOc = kernel.section(shape.wrapped, sectionFace, approximation);
     const wrapped = shapeTypes.castShape(resultOc);
-    return errors.ok(wrapped);
+    return result.ok(wrapped);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
     const planeName = typeof plane === "string" ? plane : "custom";
-    return errors.err(
-      errors.kernelError("SECTION_FAILED", `Section with ${planeName} plane failed: ${raw}`, e, {
+    return result.err(
+      result.kernelError("SECTION_FAILED", `Section with ${planeName} plane failed: ${raw}`, e, {
         operation: "section",
         plane: planeName
       })
@@ -465,7 +465,7 @@ function sectionToFace(shape, plane, options = {}) {
   if (wires.length === 0) {
     const edges = shapeFns.getEdges(sectionResult.value);
     if (edges.length === 0) {
-      return errors.err(errors.kernelError("SECTION_FAILED", "sectionToFace: section produced no geometry"));
+      return result.err(result.kernelError("SECTION_FAILED", "sectionToFace: section produced no geometry"));
     }
     const kernel = shapeTypes.getKernel();
     const vertexToEdges = /* @__PURE__ */ new Map();
@@ -518,7 +518,7 @@ function sectionToFace(shape, plane, options = {}) {
     }
   }
   if (wires.length === 0) {
-    return errors.err(errors.kernelError("SECTION_FAILED", "sectionToFace: section produced no usable geometry"));
+    return result.err(result.kernelError("SECTION_FAILED", "sectionToFace: section produced no usable geometry"));
   }
   let outerIdx = 0;
   let maxDiag = -1;
@@ -543,30 +543,30 @@ function sectionToFace(shape, plane, options = {}) {
   );
 }
 function split(shape, tools) {
-  if (tools.length === 0) return errors.ok(shape);
+  if (tools.length === 0) return result.ok(shape);
   if (shapeTypes.getKernel().isNull(shape.wrapped)) {
-    return errors.err(errors.validationError(errors.BrepErrorCode.NULL_SHAPE_INPUT, "split: shape is a null shape"));
+    return result.err(result.validationError(result.BrepErrorCode.NULL_SHAPE_INPUT, "split: shape is a null shape"));
   }
   for (let i = 0; i < tools.length; i++) {
     if (shapeTypes.getKernel().isNull(tools[i].wrapped)) {
-      return errors.err(
-        errors.validationError(
-          errors.BrepErrorCode.NULL_SHAPE_INPUT,
+      return result.err(
+        result.validationError(
+          result.BrepErrorCode.NULL_SHAPE_INPUT,
           `splitShape: tool at index ${i} is a null shape`
         )
       );
     }
   }
   try {
-    const result = shapeTypes.getKernel().split(
+    const result$1 = shapeTypes.getKernel().split(
       shape.wrapped,
       tools.map((t) => t.wrapped)
     );
-    return errors.ok(shapeTypes.castShape(result));
+    return result.ok(shapeTypes.castShape(result$1));
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
-    return errors.err(
-      errors.kernelError("SPLIT_FAILED", `Split operation failed on ${tools.length} tool(s): ${raw}`, e, {
+    return result.err(
+      result.kernelError("SPLIT_FAILED", `Split operation failed on ${tools.length} tool(s): ${raw}`, e, {
         operation: "split",
         toolCount: tools.length
       })
@@ -576,11 +576,11 @@ function split(shape, tools) {
 function slice(shape, planes, options = {}) {
   const results = [];
   for (const plane of planes) {
-    const result = section(shape, plane, options);
-    if (errors.isErr(result)) return result;
-    results.push(result.value);
+    const result$1 = section(shape, plane, options);
+    if (result.isErr(result$1)) return result$1;
+    results.push(result$1.value);
   }
-  return errors.ok(results);
+  return result.ok(results);
 }
 exports.colorFaces = colorFaces;
 exports.colorShape = colorShape;