brepjs 12.7.3 → 12.8.1

package/dist/{drawFns-CDNafQhv.cjs → drawFns-CjRc1NfQ.cjs}

@@ -44,23 +44,22 @@ var __callDispose = (stack, error, hasError) => {
   };
   return next();
 };
-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 types = require("./types-CA_xrgDq.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const boolean2D = require("./boolean2D-DyQJt8Na.cjs");
-const faceFns = require("./faceFns-BLTEPBKq.cjs");
-const curveFns = require("./curveFns-Ch87sD5O.cjs");
-const surfaceBuilders = require("./surfaceBuilders-Be_ENWSA.cjs");
+const boolean2D = require("./boolean2D-0blbVtJ8.cjs");
+const faceFns = require("./faceFns-DB1Fc5gy.cjs");
+const curveFns = require("./curveFns-BZngcnQ1.cjs");
+const surfaceBuilders = require("./surfaceBuilders-5VA34a3_.cjs");
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
-const Blueprint = require("./Blueprint-CnDVffSX.cjs");
-const result = require("./result.cjs");
-const helpers = require("./helpers-6kn30cSD.cjs");
-const shapeFns = require("./shapeFns-D-MOoqJd.cjs");
-const solidBuilders = require("./solidBuilders-BzfRBizW.cjs");
-const loft = require("./loft-DR1UN5uN.cjs");
+const Blueprint = require("./Blueprint-CQ28WJhz.cjs");
+const helpers = require("./helpers-C8NoT0Wu.cjs");
+const shapeFns = require("./shapeFns-C2SnNvdH.cjs");
+const solidBuilders = require("./solidBuilders-994_MQwB.cjs");
+const loft = require("./loft-hp3pc1M7.cjs");
 const opentype = require("opentype.js");
-const cornerFinder = require("./cornerFinder-3zfbQvXg.cjs");
+const cornerFinder = require("./cornerFinder-ZmOyOOsh.cjs");
 const stitchCurves = (curves, precision = 1e-7) => {
   const startPoints = new boolean2D.Flatbush(curves.length);
   curves.forEach((c) => {
@@ -138,7 +137,7 @@ class Sketcher extends boolean2D.BaseSketcher2d {
       const edges = Blueprint.curvesAsEdgesOnPlane(this.pendingCurves, this.plane).map(
         (e) => scope.register(e)
       );
-      return errors.unwrap(surfaceBuilders.assembleWire(edges));
+      return result.unwrap(surfaceBuilders.assembleWire(edges));
     } catch (_) {
       var _error = _, _hasError = true;
     } finally {
@@ -175,11 +174,11 @@ class Sketcher extends boolean2D.BaseSketcher2d {
     const diff = vecOps.vecSub(pointer3d, firstPoint3d);
     const startToEndVector = vecOps.vecNormalize(diff);
     const normal = vecOps.vecCross(startToEndVector, this.plane.zDir);
-    const clonedWrapped = errors.unwrap(faceFns.downcast(wire.wrapped));
+    const clonedWrapped = result.unwrap(faceFns.downcast(wire.wrapped));
     const mirroredRaw = Blueprint.mirror(clonedWrapped, normal, pointer3d);
-    const mirroredWrapped = errors.unwrap(faceFns.downcast(mirroredRaw));
+    const mirroredWrapped = result.unwrap(faceFns.downcast(mirroredRaw));
     const mirroredWire = shapeTypes.createWire(mirroredWrapped);
-    const combinedWire = errors.unwrap(surfaceBuilders.assembleWire([wire, mirroredWire]));
+    const combinedWire = result.unwrap(surfaceBuilders.assembleWire([wire, mirroredWire]));
     return new boolean2D.Sketch(combinedWire, {
       defaultOrigin: this.plane.origin,
       defaultDirection: this.plane.zDir
@@ -200,7 +199,7 @@ class Sketcher extends boolean2D.BaseSketcher2d {
 }
 const guessFaceFromWires = (wires) => {
   const wireShapes = wires.map((w) => w.wrapped);
-  const newFace = errors.unwrap(faceFns.cast(shapeTypes.getKernel().fillSurface(wireShapes)));
+  const newFace = result.unwrap(faceFns.cast(shapeTypes.getKernel().fillSurface(wireShapes)));
   if (!shapeTypes.isFace(newFace)) {
     result.bug("guessFaceFromWires", "Failed to create a face");
   }
@@ -214,7 +213,7 @@ const faceFromWires = (wires) => {
   let baseFace;
   let holeWires;
   const faceResult = surfaceBuilders.makeFace(wires[0]);
-  if (errors.isOk(faceResult)) {
+  if (result.isOk(faceResult)) {
     baseFace = faceResult.value;
     holeWires = wires.slice(1);
   } else {
@@ -228,14 +227,14 @@ const solidFromShellGenerator = (sketches, shellGenerator) => {
   const startWires = [];
   const endWires = [];
   sketches.forEach((sketch) => {
-    const [shell, startWire, endWire] = errors.unwrap(shellGenerator(sketch));
+    const [shell, startWire, endWire] = result.unwrap(shellGenerator(sketch));
     shells.push(shell);
     startWires.push(startWire);
     endWires.push(endWire);
   });
   const startFace = faceFromWires(startWires);
   const endFace = faceFromWires(endWires);
-  const solid = errors.unwrap(solidBuilders.makeSolid([startFace, ...shells, endFace]));
+  const solid = result.unwrap(solidBuilders.makeSolid([startFace, ...shells, endFace]));
   return solid;
 };
 class CompoundSketch {
@@ -323,7 +322,7 @@ class CompoundSketch {
    * (defaults to the sketch origin)
    */
   revolve(revolutionAxis, { origin } = {}) {
-    return errors.unwrap(
+    return result.unwrap(
       loft.revolution(
         this.face(),
         origin ? types.toVec3(origin) : this.outerSketch.defaultOrigin,
@@ -343,9 +342,9 @@ class CompoundSketch {
       return base.clone().loftWith(outer.clone(), { ruled: loftConfig.ruled }, true);
     });
     const baseFaceRaw = this.face();
-    const baseFace = shapeTypes.createFace(errors.unwrap(faceFns.downcast(baseFaceRaw.wrapped)));
+    const baseFace = shapeTypes.createFace(result.unwrap(faceFns.downcast(baseFaceRaw.wrapped)));
     shells.push(baseFace, otherCompound.face());
-    return errors.unwrap(solidBuilders.makeSolid(shells));
+    return result.unwrap(solidBuilders.makeSolid(shells));
   }
 }
 class Sketches {
@@ -387,7 +386,7 @@ class Sketches {
 }
 const sketchCircle = (radius, planeConfig = {}) => {
   const plane = planeConfig.plane && typeof planeConfig.plane !== "string" ? { ...planeConfig.plane } : vectors.resolvePlane(planeConfig.plane ?? "XY", planeConfig.origin);
-  const wire = errors.unwrap(surfaceBuilders.assembleWire([surfaceBuilders.makeCircle(radius, plane.origin, plane.zDir)]));
+  const wire = result.unwrap(surfaceBuilders.assembleWire([surfaceBuilders.makeCircle(radius, plane.origin, plane.zDir)]));
   const sketch = new boolean2D.Sketch(wire, {
     defaultOrigin: [...plane.origin],
     defaultDirection: [...plane.zDir]
@@ -404,8 +403,8 @@ const sketchEllipse = (xRadius = 1, yRadius = 2, planeConfig = {}) => {
     majR = yRadius;
     minR = xRadius;
   }
-  const wire = errors.unwrap(
-    surfaceBuilders.assembleWire([errors.unwrap(surfaceBuilders.makeEllipse(majR, minR, plane.origin, plane.zDir, xDir))])
+  const wire = result.unwrap(
+    surfaceBuilders.assembleWire([result.unwrap(surfaceBuilders.makeEllipse(majR, minR, plane.origin, plane.zDir, xDir))])
   );
   const sketch = new boolean2D.Sketch(wire, {
     defaultOrigin: [...plane.origin],
@@ -454,7 +453,7 @@ const polysideInnerRadius = (outerRadius, sidesCount, sagitta = 0) => {
 const sketchFaceOffset = (face, offset2) => {
   const defaultOrigin = [...faceFns.faceCenter(face)];
   const defaultDirection = [...faceFns.normalAt(face)];
-  const wire = errors.unwrap(curveFns.offsetWire2D(faceFns.outerWire(face), offset2));
+  const wire = result.unwrap(curveFns.offsetWire2D(faceFns.outerWire(face), offset2));
   const sketch = new boolean2D.Sketch(wire, { defaultOrigin, defaultDirection });
   return sketch;
 };
@@ -468,8 +467,8 @@ const sketchParametricFunction = (func, planeConfig = {}, { pointsCount = 400, s
       const point = func(start + t * stepSize);
       return vectors.planeToWorld(plane, point);
     });
-    const wire = errors.unwrap(
-      surfaceBuilders.assembleWire([scope.register(errors.unwrap(surfaceBuilders.makeBSplineApproximation(points, approximationConfig)))])
+    const wire = result.unwrap(
+      surfaceBuilders.assembleWire([scope.register(result.unwrap(surfaceBuilders.makeBSplineApproximation(points, approximationConfig)))])
     );
     const sketch = new boolean2D.Sketch(wire, {
       defaultOrigin: [...plane.origin],
@@ -486,7 +485,7 @@ const sketchHelix = (pitch, height, radius, center = [0, 0, 0], dir = [0, 0, 1],
   const centerVec3 = types.toVec3(center);
   const dirVec3 = types.toVec3(dir);
   return new boolean2D.Sketch(
-    errors.unwrap(surfaceBuilders.assembleWire([surfaceBuilders.makeHelix(pitch, height, radius, centerVec3, dirVec3, lefthand)]))
+    result.unwrap(surfaceBuilders.assembleWire([surfaceBuilders.makeHelix(pitch, height, radius, centerVec3, dirVec3, lefthand)]))
   );
 };
 const makeBaseBox = (xLength, yLength, zLength) => {
@@ -586,18 +585,18 @@ function rawOffsets(blueprint, offset2, offsetConfig = {}) {
     }
     let intersections = [];
     if (previousCurve.offset instanceof Blueprint.Curve2D && curve.offset instanceof Blueprint.Curve2D) {
-      const { intersections: pointIntersections, commonSegmentsPoints } = errors.unwrap(
+      const { intersections: pointIntersections, commonSegmentsPoints } = result.unwrap(
         boolean2D.intersectCurves(previousCurve.offset, curve.offset, helpers.PRECISION_OFFSET / 100)
       );
       intersections = [...pointIntersections, ...commonSegmentsPoints];
     }
     if (intersections.length > 0) {
-      let intersection = intersections[0];
+      let intersection = result.safeIndex(intersections, 0, "rawOffsets");
       if (intersections.length > 1) {
         const originalEndpoint = previousCurve.original.lastPoint;
         let minDist = helpers.squareDistance2d(intersection, originalEndpoint);
         for (let i = 1; i < intersections.length; i++) {
-          const point = intersections[i];
+          const point = result.safeIndex(intersections, i, "rawOffsets");
           const d = helpers.squareDistance2d(point, originalEndpoint);
           if (d < minDist) {
             minDist = d;
@@ -605,10 +604,11 @@ function rawOffsets(blueprint, offset2, offsetConfig = {}) {
           }
         }
       }
-      const splitPreviousCurve = previousCurve.offset.splitAt(
-        [intersection],
-        helpers.PRECISION_OFFSET
-      )[0];
+      const splitPreviousCurve = result.safeIndex(
+        previousCurve.offset.splitAt([intersection], helpers.PRECISION_OFFSET),
+        0,
+        "rawOffsets"
+      );
       const splitCurve = curve.offset.splitAt([intersection], helpers.PRECISION_OFFSET).at(-1);
       if (!splitCurve) result.bug("offset.rawOffsets", "Split produced no trailing curve segment");
       appendCurve({
@@ -648,8 +648,8 @@ function offsetBlueprint(blueprint, offset2, offsetConfig = {}) {
       const pairKey = `${firstIndex}-${secondIndex}`;
       if (testedPairs.has(pairKey)) continue;
       testedPairs.add(pairKey);
-      const secondCurve = offsettedArray[secondIndex];
-      const { intersections: rawIntersections, commonSegmentsPoints } = errors.unwrap(
+      const secondCurve = result.safeIndex(offsettedArray, secondIndex, "offsetBlueprint");
+      const { intersections: rawIntersections, commonSegmentsPoints } = result.unwrap(
         boolean2D.intersectCurves(firstCurve, secondCurve, helpers.PRECISION_OFFSET)
       );
       const intersections = [...rawIntersections, ...commonSegmentsPoints].filter(
@@ -686,14 +686,14 @@ function offsetBlueprint(blueprint, offset2, offsetConfig = {}) {
   const blueprints = curvesGrouped.filter((c) => c.length > 1).map((c) => new Blueprint.Blueprint(c)).filter((b) => b.isClosed());
   if (!blueprints.length) return null;
   if (blueprints.length === 1) {
-    return blueprints[0];
+    return result.safeIndex(blueprints, 0, "offsetBlueprint");
   }
   return new boolean2D.Blueprints(blueprints);
 }
 const fuseAll = (blueprints) => {
-  let fused = blueprints[0];
+  let fused = result.safeIndex(blueprints, 0, "fuseAll");
   for (let i = 1; i < blueprints.length; i++) {
-    fused = boolean2D.fuse2D(fused, blueprints[i]);
+    fused = boolean2D.fuse2D(fused, result.safeIndex(blueprints, i, "fuseAll"));
   }
   return fused;
 };
@@ -707,8 +707,7 @@ function offset(bp, offsetDistance, offsetConfig = {}) {
       bp.blueprints.slice(1).map((b) => offset(b, offsetDistance, offsetConfig))
     );
     return boolean2D.cut2D(
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- compound always has outer boundary
-      offset(bp.blueprints[0], offsetDistance, offsetConfig),
+      offset(result.safeIndex(bp.blueprints, 0, "offset"), offsetDistance, offsetConfig),
       innerShape
     );
   }
@@ -950,8 +949,8 @@ function makeProjectedEdges(shape, camera, withHiddenLines = true) {
 function createCamera(position = [0, 0, 0], direction = [0, 0, 1], xAxis) {
   const dirLength = vecOps.vecLength(direction);
   if (dirLength < 1e-12) {
-    return errors.err(
-      errors.validationError("CAMERA_ZERO_DIRECTION", "Camera direction cannot be a zero-length vector")
+    return result.err(
+      result.validationError("CAMERA_ZERO_DIRECTION", "Camera direction cannot be a zero-length vector")
     );
   }
   let resolvedXAxis;
@@ -968,7 +967,7 @@ function createCamera(position = [0, 0, 0], direction = [0, 0, 1], xAxis) {
     resolvedXAxis = vecOps.vecNormalize(cross);
   }
   const yAxis = vecOps.vecNormalize(vecOps.vecCross(direction, resolvedXAxis));
-  return errors.ok({
+  return result.ok({
     position,
     direction: vecOps.vecNormalize(direction),
     xAxis: resolvedXAxis,
@@ -1253,7 +1252,7 @@ const drawPointsInterpolation = (points, approximationConfig = {}, options = {})
       `Need at least 2 points for interpolation, got ${points.length}`
     );
   }
-  const curves = [errors.unwrap(Blueprint.make2dInerpolatedBSplineCurve(points, approximationConfig))];
+  const curves = [result.unwrap(Blueprint.make2dInerpolatedBSplineCurve(points, approximationConfig))];
   const firstPoint = points[0];
   const lastPoint = points[points.length - 1];
   if (options.closeShape && firstPoint && lastPoint && !helpers.samePoint(firstPoint, lastPoint)) {
@@ -1273,7 +1272,7 @@ const edgesToDrawing = (edges) => {
   try {
     const scope = __using(_stack, new shapeTypes.DisposalScope());
     const planeSketch = drawRectangle(1e3, 1e3).sketchOnPlane();
-    const planeFace = scope.register(errors.unwrap(surfaceBuilders.makeFace(planeSketch.wire)));
+    const planeFace = scope.register(result.unwrap(surfaceBuilders.makeFace(planeSketch.wire)));
     const curves = edges.map((e) => Blueprint.edgeToCurve(e, planeFace));
     const stitchedCurves = stitchCurves(curves).map((s) => new Blueprint.Blueprint(s));
     if (stitchedCurves.length === 0) return new Drawing();
@@ -1288,7 +1287,7 @@ const edgesToDrawing = (edges) => {
 function drawProjection(shape, projectionCamera = "front") {
   let camera;
   if (typeof projectionCamera === "string") {
-    camera = errors.unwrap(cameraFromPlane(projectionCamera));
+    camera = result.unwrap(cameraFromPlane(projectionCamera));
   } else {
     camera = projectionCamera;
   }
@@ -1302,7 +1301,7 @@ function drawFaceOutline(face) {
   var _stack = [];
   try {
     const scope = __using(_stack, new shapeTypes.DisposalScope());
-    const clonedFace = scope.register(shapeTypes.createFace(errors.unwrap(faceFns.downcast(face.wrapped))));
+    const clonedFace = scope.register(shapeTypes.createFace(result.unwrap(faceFns.downcast(face.wrapped))));
     const faceOuterWire = scope.register(faceFns.outerWire(clonedFace));
     const curves = shapeFns.getEdges(faceOuterWire).map((e) => Blueprint.edgeToCurve(e, face));
     const stitchedCurves = stitchCurves(curves).map((s) => new Blueprint.Blueprint(s));

package/dist/{faceFns-B6ebRh5I.js → faceFns-B8GnxjdY.js}

@@ -1,6 +1,6 @@
 import { B as getKernel, c as castShape, p as isShape3D$1, u as isWire$1 } from "./shapeTypes-CpSaBLDv.js";
 import { a as toVec3 } from "./types-CWDdqcrq.js";
-import { e as err, p as typeCastError, o as ok, r as unwrap } from "./errors-B7kgv0cd.js";
+import { e as err, r as typeCastError, o as ok, v as unwrap } from "./result-BaSD1fqR.js";
 const TOPO_ENUM = {
   compound: 0,
   solidCompound: 1,

package/dist/{faceFns-BLTEPBKq.cjs → faceFns-DB1Fc5gy.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
 const types = require("./types-CA_xrgDq.cjs");
-const errors = require("./errors-9fDehDNc.cjs");
+const result = require("./result-fAX0OZzI.cjs");
 const TOPO_ENUM = {
   compound: 0,
   solidCompound: 1,
@@ -37,24 +37,24 @@ const iterTopo = function* iterTopo2(shape, topo) {
 };
 const shapeType = (shape) => {
   if (shapeTypes.getKernel().isNull(shape))
-    return errors.err(errors.typeCastError("NULL_SHAPE", "This shape has no type, it is null"));
-  return errors.ok(shape.ShapeType());
+    return result.err(result.typeCastError("NULL_SHAPE", "This shape has no type, it is null"));
+  return result.ok(shape.ShapeType());
 };
 function downcast(shape) {
   if (shapeTypes.getKernel().isNull(shape)) {
-    return errors.err(errors.typeCastError("NULL_SHAPE", "This shape has no type, it is null"));
+    return result.err(result.typeCastError("NULL_SHAPE", "This shape has no type, it is null"));
   }
   try {
-    return errors.ok(shapeTypes.getKernel().downcast(shape));
+    return result.ok(shapeTypes.getKernel().downcast(shape));
   } catch {
-    return errors.err(errors.typeCastError("NO_WRAPPER", "Could not find a wrapper for this shape type"));
+    return result.err(result.typeCastError("NO_WRAPPER", "Could not find a wrapper for this shape type"));
   }
 }
 function cast(shape) {
   if (shapeTypes.getKernel().isNull(shape)) {
-    return errors.err(errors.typeCastError("NULL_SHAPE", "Cannot cast a null shape"));
+    return result.err(result.typeCastError("NULL_SHAPE", "Cannot cast a null shape"));
   }
-  return errors.ok(shapeTypes.castShape(shape));
+  return result.ok(shapeTypes.castShape(shape));
 }
 function isShape3D(shape) {
   return shapeTypes.isShape3D(shape);
@@ -83,10 +83,10 @@ const KERNEL_TO_PUBLIC_SURFACE_TYPE = {
 };
 function getSurfaceType(face) {
   const kernelType = shapeTypes.getKernel().surfaceType(face.wrapped);
-  return errors.ok(KERNEL_TO_PUBLIC_SURFACE_TYPE[kernelType]);
+  return result.ok(KERNEL_TO_PUBLIC_SURFACE_TYPE[kernelType]);
 }
 function faceGeomType(face) {
-  return errors.unwrap(getSurfaceType(face));
+  return result.unwrap(getSurfaceType(face));
 }
 function faceOrientation(face) {
   const orient = shapeTypes.getKernel().shapeOrientation(face.wrapped);
@@ -106,11 +106,11 @@ function pointOnSurface(face, u, v) {
 }
 function uvCoordinates(face, point) {
   const v = types.toVec3(point);
-  const result = shapeTypes.getKernel().uvFromPoint(face.wrapped, v);
-  if (!result) {
+  const result2 = shapeTypes.getKernel().uvFromPoint(face.wrapped, v);
+  if (!result2) {
     return [0, 0];
   }
-  return result;
+  return result2;
 }
 function projectPointOnFace(face, point) {
   const v = types.toVec3(point);
@@ -118,21 +118,21 @@ function projectPointOnFace(face, point) {
     const vMut = v;
     const uvResult = shapeTypes.getKernel().uvFromPoint(face.wrapped, vMut);
     if (!uvResult) {
-      return errors.err(errors.typeCastError("PROJECTION_FAILED", "No projection found on the face"));
+      return result.err(result.typeCastError("PROJECTION_FAILED", "No projection found on the face"));
     }
     const projectedPoint = shapeTypes.getKernel().projectPointOnFace(face.wrapped, vMut);
     const dx = v[0] - projectedPoint[0];
     const dy = v[1] - projectedPoint[1];
     const dz = v[2] - projectedPoint[2];
     const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
-    return errors.ok({
+    return result.ok({
       uv: uvResult,
       point: projectedPoint,
       distance
     });
   } catch (e) {
-    return errors.err(
-      errors.typeCastError(
+    return result.err(
+      result.typeCastError(
         "PROJECTION_FAILED",
         `Point projection failed: ${e instanceof Error ? e.message : String(e)}`
       )
@@ -167,10 +167,10 @@ function removeHolesFromFace(face) {
 function innerWires(face) {
   const outer = outerWire(face);
   const allWires = Array.from(iterTopo(face.wrapped, "wire")).map(
-    (w) => shapeTypes.castShape(errors.unwrap(downcast(w)))
+    (w) => shapeTypes.castShape(result.unwrap(downcast(w)))
   );
-  const result = allWires.filter((w) => !shapeTypes.getKernel().isSame(w.wrapped, outer.wrapped));
-  return result;
+  const result$1 = allWires.filter((w) => !shapeTypes.getKernel().isSame(w.wrapped, outer.wrapped));
+  return result$1;
 }
 exports.asTopo = asTopo;
 exports.cast = cast;

package/dist/{helpers-6kn30cSD.cjs → helpers-C8NoT0Wu.cjs}

@@ -1,10 +1,10 @@
 "use strict";
 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 faceFns = require("./faceFns-BLTEPBKq.cjs");
-const measurement = require("./measurement-DoYXRaKI.cjs");
-const shapeFns = require("./shapeFns-D-MOoqJd.cjs");
+const faceFns = require("./faceFns-DB1Fc5gy.cjs");
+const measurement = require("./measurement-BoNTUBAp.cjs");
+const shapeFns = require("./shapeFns-C2SnNvdH.cjs");
 const PRECISION_INTERSECTION = 1e-9;
 const PRECISION_OFFSET = 1e-8;
 const PRECISION_POINT = 1e-6;
@@ -60,14 +60,14 @@ function createTypedFinder(topoKind, filters, rebuild, extend) {
   const withFilter = (pred) => rebuild([...filters, pred]);
   const shouldKeep = (element) => filters.every((f) => f(element));
   const extractElements = (shape) => {
-    const result = [];
+    const result$1 = [];
     for (const raw of faceFns.iterTopo(shape.wrapped, topoKind)) {
-      const element = shapeTypes.castShape(errors.unwrap(faceFns.downcast(raw)));
+      const element = shapeTypes.castShape(result.unwrap(faceFns.downcast(raw)));
       if (shouldKeep(element)) {
-        result.push(element);
+        result$1.push(element);
       }
     }
-    return result;
+    return result$1;
   };
   const emptyFinder = () => createTypedFinder(topoKind, [], rebuild, extend);
   const base = {
@@ -100,7 +100,7 @@ function createTypedFinder(topoKind, filters, rebuild, extend) {
       let match;
       let count = 0;
       for (const raw of faceFns.iterTopo(shape.wrapped, topoKind)) {
-        const element = shapeTypes.castShape(errors.unwrap(faceFns.downcast(raw)));
+        const element = shapeTypes.castShape(result.unwrap(faceFns.downcast(raw)));
         if (shouldKeep(element)) {
           count++;
           if (count === 1) match = element;
@@ -108,14 +108,14 @@ function createTypedFinder(topoKind, filters, rebuild, extend) {
         }
       }
       if (count !== 1) {
-        return errors.err(
-          errors.queryError(
+        return result.err(
+          result.queryError(
             "FINDER_NOT_UNIQUE",
             `Finder expected a unique match but found ${count === 0 ? 0 : "2+"} element(s)`
           )
         );
       }
-      return errors.ok(match);
+      return result.ok(match);
     },
     shouldKeep
   };
@@ -155,7 +155,7 @@ function buildFaceFinder(filters) {
     (_base, withFilter) => ({
       inDirection: (dir = "Z", angle = 0) => withFilter(faceDirectionFilter(dir, angle)),
       parallelTo: (dir = "Z") => buildFaceFinder(filters).inDirection(dir, 0),
-      ofSurfaceType: (surfaceType) => withFilter((face) => errors.unwrap(faceFns.getSurfaceType(face)) === surfaceType),
+      ofSurfaceType: (surfaceType) => withFilter((face) => result.unwrap(faceFns.getSurfaceType(face)) === surfaceType),
       ofArea: (area, tolerance = 1e-3) => withFilter((face) => Math.abs(measurement.measureArea(face) - area) < tolerance),
       atDistance: (distance, point = [0, 0, 0]) => withFilter(distanceFromPointFilter(distance, point, 1e-6))
     })
@@ -168,7 +168,7 @@ function getSingleFace(f, shape) {
   if (typeof f === "object" && "_topoKind" in f) {
     return f.findUnique(shape);
   }
-  if (typeof f !== "function" && shapeTypes.isFace(f)) return errors.ok(f);
+  if (typeof f !== "function" && shapeTypes.isFace(f)) return result.ok(f);
   const fnResult = f(faceFinder());
   return fnResult.findUnique(shape);
 }

package/dist/{helpers-C9KvE1RW.js → helpers-X0juxnwj.js}

@@ -1,9 +1,9 @@
 import { c as castShape, B as getKernel, k as isFace } from "./shapeTypes-CpSaBLDv.js";
-import { r as unwrap, e as err, q as queryError, o as ok } from "./errors-B7kgv0cd.js";
+import { v as unwrap, e as err, q as queryError, o as ok } from "./result-BaSD1fqR.js";
 import { j as vecNormalize, d as vecDot, D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
-import { i as iterTopo, d as downcast, g as getSurfaceType, n as normalAt } from "./faceFns-B6ebRh5I.js";
-import { m as measureArea } from "./measurement-oWvhSVZG.js";
-import { f as getHashCode, i as isSameShape } from "./shapeFns-D2PlLFE6.js";
+import { i as iterTopo, d as downcast, g as getSurfaceType, n as normalAt } from "./faceFns-B8GnxjdY.js";
+import { m as measureArea } from "./measurement-D8EJ694A.js";
+import { f as getHashCode, i as isSameShape } from "./shapeFns-FDuKkrDR.js";
 const PRECISION_INTERSECTION = 1e-9;
 const PRECISION_OFFSET = 1e-8;
 const PRECISION_POINT = 1e-6;

package/dist/io.cjs

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
-const errors = require("./errors-9fDehDNc.cjs");
-const meshFns = require("./meshFns-3gy0empP.cjs");
-const Blueprint = require("./Blueprint-CnDVffSX.cjs");
+const result = require("./result-fAX0OZzI.cjs");
+const meshFns = require("./meshFns-BnV0ZR8w.cjs");
+const Blueprint = require("./Blueprint-CQ28WJhz.cjs");
 function vec3At(arr, i) {
   const off = i * 3;
   return [arr[off], arr[off + 1], arr[off + 2]];
@@ -465,11 +465,11 @@ function flattenBlueprints(drawing) {
     return [drawing];
   }
   if ("blueprints" in drawing && Array.isArray(drawing.blueprints)) {
-    const result = [];
+    const result2 = [];
     for (const item of drawing.blueprints) {
-      result.push(...flattenBlueprints(item));
+      result2.push(...flattenBlueprints(item));
     }
-    return result;
+    return result2;
   }
   return [];
 }
@@ -923,12 +923,12 @@ function importSVGPathD(pathD) {
   try {
     const curves = parseSVGPathToCurves(pathD);
     if (curves.length === 0) {
-      return errors.err(errors.ioError("SVG_EMPTY_PATH", "SVG path produced no curves"));
+      return result.err(result.ioError("SVG_EMPTY_PATH", "SVG path produced no curves"));
     }
-    return errors.ok(new Blueprint.Blueprint(curves));
+    return result.ok(new Blueprint.Blueprint(curves));
   } catch (e) {
-    return errors.err(
-      errors.ioError(
+    return result.err(
+      result.ioError(
         "SVG_PARSE_FAILED",
         `Failed to parse SVG path: ${e instanceof Error ? e.message : String(e)}`
       )
@@ -951,18 +951,18 @@ function importSVG(svgString) {
       const attrMatch = dAttrRe.exec(tag);
       const d = attrMatch?.[1] ?? attrMatch?.[2];
       if (!d) continue;
-      const result = importSVGPathD(d);
-      if (result.ok) {
-        blueprints.push(result.value);
+      const result2 = importSVGPathD(d);
+      if (result2.ok) {
+        blueprints.push(result2.value);
       }
     }
     if (blueprints.length === 0) {
-      return errors.err(errors.ioError("SVG_NO_PATHS", "No <path> elements found in SVG"));
+      return result.err(result.ioError("SVG_NO_PATHS", "No <path> elements found in SVG"));
     }
-    return errors.ok(blueprints);
+    return result.ok(blueprints);
   } catch (e) {
-    return errors.err(
-      errors.ioError(
+    return result.err(
+      result.ioError(
         "SVG_IMPORT_FAILED",
         `Failed to import SVG: ${e instanceof Error ? e.message : String(e)}`
       )
@@ -974,11 +974,11 @@ async function importSTEP(blob) {
     const data = await blob.arrayBuffer();
     const shapes = shapeTypes.getKernel().importSTEP(data);
     if (shapes.length === 0) {
-      return errors.err(errors.ioError("STEP_IMPORT_FAILED", "STEP file contains no valid geometry"));
+      return result.err(result.ioError("STEP_IMPORT_FAILED", "STEP file contains no valid geometry"));
     }
-    return errors.ok(shapeTypes.castShape(shapes[0]));
+    return result.ok(shapeTypes.castShape(shapes[0]));
   } catch {
-    return errors.err(errors.ioError("STEP_IMPORT_FAILED", "Failed to load STEP file"));
+    return result.err(result.ioError("STEP_IMPORT_FAILED", "Failed to load STEP file"));
   }
 }
 async function importSTL(blob) {
@@ -986,11 +986,11 @@ async function importSTL(blob) {
     const data = await blob.arrayBuffer();
     const shape = shapeTypes.getKernel().importSTL(data);
     if (shape.IsNull()) {
-      return errors.err(errors.ioError("STL_IMPORT_FAILED", "Failed to create solid from STL mesh"));
+      return result.err(result.ioError("STL_IMPORT_FAILED", "Failed to create solid from STL mesh"));
     }
-    return errors.ok(shapeTypes.castShape(shape));
+    return result.ok(shapeTypes.castShape(shape));
   } catch {
-    return errors.err(errors.ioError("STL_IMPORT_FAILED", "Failed to load STL file"));
+    return result.err(result.ioError("STL_IMPORT_FAILED", "Failed to load STL file"));
   }
 }
 async function importIGES(blob) {
@@ -998,11 +998,11 @@ async function importIGES(blob) {
     const data = await blob.arrayBuffer();
     const shapes = shapeTypes.getKernel().importIGES(data);
     if (shapes.length === 0) {
-      return errors.err(errors.ioError("IGES_IMPORT_FAILED", "IGES file contains no valid geometry"));
+      return result.err(result.ioError("IGES_IMPORT_FAILED", "IGES file contains no valid geometry"));
     }
-    return errors.ok(shapeTypes.castShape(shapes[0]));
+    return result.ok(shapeTypes.castShape(shapes[0]));
   } catch {
-    return errors.err(errors.ioError("IGES_IMPORT_FAILED", "Failed to load IGES file"));
+    return result.err(result.ioError("IGES_IMPORT_FAILED", "Failed to load IGES file"));
   }
 }
 exports.exportIGES = meshFns.exportIGES;

package/dist/io.js

@@ -1,7 +1,7 @@
 import { B as getKernel, c as castShape } from "./shapeTypes-CpSaBLDv.js";
-import { e as err, i as ioError, o as ok } from "./errors-B7kgv0cd.js";
-import { e, d, f } from "./meshFns-DsLRd3tA.js";
-import { B as Blueprint, a as make2dSegmentCurve, o as make2dThreePointArc, s as make2dBezierCurve } from "./Blueprint-C3lWY1Jf.js";
+import { e as err, i as ioError, o as ok } from "./result-BaSD1fqR.js";
+import { e, d, f } from "./meshFns-nQjK38EC.js";
+import { B as Blueprint, a as make2dSegmentCurve, o as make2dThreePointArc, s as make2dBezierCurve } from "./Blueprint-DbVaf6k7.js";
 function vec3At(arr, i) {
   const off = i * 3;
   return [arr[off], arr[off + 1], arr[off + 2]];