brepjs 8.8.2 → 8.8.3

package/dist/Blueprint-BmFJ4caY.cjs

@@ -0,0 +1,1439 @@
+"use strict";
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result2 = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result2).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+const vectors = require("./vectors-CGLqemPY.cjs");
+const occtBoundary = require("./occtBoundary-Cqfsau2c.cjs");
+const shapeTypes = require("./shapeTypes-CWuX602K.cjs");
+const faceFns = require("./faceFns-DNQss51F.cjs");
+const curveFns = require("./curveFns-BsAHC3Qv.cjs");
+const errors = require("./errors-NNmTtM5u.cjs");
+const surfaceBuilders = require("./surfaceBuilders-CLal3WlK.cjs");
+const helpers = require("./helpers-aylLv0_I.cjs");
+const vecOps = require("./vecOps-CjRL1jau.cjs");
+const result = require("./result.cjs");
+function makePlane(plane, origin) {
+  if (plane && typeof plane !== "string") {
+    return { ...plane };
+  } else {
+    return vectors.resolvePlane(plane ?? "XY", origin);
+  }
+}
+function mirror(shape, inputPlane, origin) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    let originVec;
+    let directionVec;
+    if (typeof inputPlane === "string") {
+      const plane = vectors.resolvePlane(inputPlane, origin);
+      originVec = plane.origin;
+      directionVec = plane.zDir;
+    } else if (inputPlane && typeof inputPlane === "object" && "origin" in inputPlane && "zDir" in inputPlane) {
+      originVec = origin ? occtBoundary.toVec3(origin) : inputPlane.origin;
+      directionVec = inputPlane.zDir;
+    } else if (inputPlane) {
+      originVec = origin ? occtBoundary.toVec3(origin) : [0, 0, 0];
+      directionVec = occtBoundary.toVec3(inputPlane);
+    } else {
+      const plane = vectors.resolvePlane("YZ", origin);
+      originVec = plane.origin;
+      directionVec = plane.zDir;
+    }
+    const mirrorAxis = scope.register(occtBoundary.makeOcAx2(originVec, directionVec));
+    const trsf = scope.register(new oc.gp_Trsf_1());
+    trsf.SetMirror_3(mirrorAxis);
+    const transformer = scope.register(new oc.BRepBuilderAPI_Transform_2(shape, trsf, true));
+    const newShape = transformer.ModifiedShape(shape);
+    return newShape;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function isPoint2D(point) {
+  return Array.isArray(point) && point.length === 2 && typeof point[0] === "number" && typeof point[1] === "number";
+}
+function precisionRound(number, precision) {
+  const factor = Math.pow(10, precision);
+  const n = precision < 0 ? number : 0.01 / factor + number;
+  return Math.round(n * factor) / factor;
+}
+function round2(v) {
+  return Math.round(v * 100) / 100;
+}
+const reprPnt = ([x, y]) => {
+  return `(${round2(x)},${round2(y)})`;
+};
+const asFixed = (p, precision = 1e-9) => {
+  let num = p;
+  if (Math.abs(p) < precision) num = 0;
+  return num.toFixed(-Math.log10(precision));
+};
+const removeDuplicatePoints = (points, precision = 1e-9) => {
+  return Array.from(
+    new Map(
+      points.map(([p0, p1]) => [
+        `[${asFixed(p0, precision)},${asFixed(p1, precision)}]`,
+        [p0, p1]
+      ])
+    ).values()
+  );
+};
+const pnt = ([x, y]) => {
+  const oc = occtBoundary.getKernel().oc;
+  return new oc.gp_Pnt2d_3(x, y);
+};
+const direction2d = ([x, y]) => {
+  const oc = occtBoundary.getKernel().oc;
+  return new oc.gp_Dir2d_4(x, y);
+};
+const vec = ([x, y]) => {
+  const oc = occtBoundary.getKernel().oc;
+  return new oc.gp_Vec2d_4(x, y);
+};
+const axis2d = (point, direction) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const axis = new oc.gp_Ax2d_2(scope.register(pnt(point)), scope.register(direction2d(direction)));
+    return axis;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+class BoundingBox2d {
+  _wrapped;
+  _deleted = false;
+  constructor(wrapped) {
+    const oc = occtBoundary.getKernel().oc;
+    this._wrapped = wrapped ?? new oc.Bnd_Box2d();
+    shapeTypes.registerForCleanup(this, this._wrapped);
+  }
+  get wrapped() {
+    if (this._deleted) throw new Error("This object has been deleted");
+    return this._wrapped;
+  }
+  delete() {
+    if (!this._deleted) {
+      this._deleted = true;
+      shapeTypes.unregisterFromCleanup(this._wrapped);
+      this._wrapped.delete();
+    }
+  }
+  /** Return a human-readable string of the form `(xMin,yMin) - (xMax,yMax)`. */
+  get repr() {
+    const [min, max] = this.bounds;
+    return `${reprPnt(min)} - ${reprPnt(max)}`;
+  }
+  /** Return the `[min, max]` corner points of the bounding box. */
+  get bounds() {
+    const xMin = { current: 0 };
+    const yMin = { current: 0 };
+    const xMax = { current: 0 };
+    const yMax = { current: 0 };
+    this.wrapped.Get(xMin, yMin, xMax, yMax);
+    return [
+      [xMin.current, yMin.current],
+      [xMax.current, yMax.current]
+    ];
+  }
+  /** Return the center point of the bounding box. */
+  get center() {
+    const [[xmin, ymin], [xmax, ymax]] = this.bounds;
+    return [xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2];
+  }
+  /** Return the width (x-extent) of the bounding box. */
+  get width() {
+    const [[xmin], [xmax]] = this.bounds;
+    return Math.abs(xmax - xmin);
+  }
+  /** Return the height (y-extent) of the bounding box. */
+  get height() {
+    const [[, ymin], [, ymax]] = this.bounds;
+    return Math.abs(ymax - ymin);
+  }
+  /**
+   * Return a point guaranteed to lie outside the bounding box.
+   *
+   * @param paddingPercent - Extra padding as a percentage of the box dimensions.
+   */
+  outsidePoint(paddingPercent = 1) {
+    const [min, max] = this.bounds;
+    const width = max[0] - min[0];
+    const height = max[1] - min[1];
+    return [
+      max[0] + width / 100 * paddingPercent,
+      max[1] + height / 100 * paddingPercent * 0.9
+    ];
+  }
+  /** Expand this bounding box to include `other`. */
+  add(other) {
+    this.wrapped.Add_1(other.wrapped);
+  }
+  /** Test whether this bounding box and `other` are completely disjoint. */
+  isOut(other) {
+    return this.wrapped.IsOut_4(other.wrapped);
+  }
+  /** Test whether the given point lies inside (or on the boundary of) this box. */
+  containsPoint(other) {
+    var _stack = [];
+    try {
+      const scope = __using(_stack, new shapeTypes.DisposalScope());
+      const point = scope.register(pnt(other));
+      return !this.wrapped.IsOut_1(point);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+}
+function deserializeCurve2D(data) {
+  const oc = occtBoundary.getKernel().oc;
+  const handle = oc.GeomToolsWrapper.Read(data);
+  return new Curve2D(handle);
+}
+class Curve2D {
+  _wrapped;
+  _deleted = false;
+  _boundingBox;
+  _firstPoint = null;
+  _lastPoint = null;
+  constructor(handle) {
+    const oc = occtBoundary.getKernel().oc;
+    const inner = handle.get();
+    this._wrapped = new oc.Handle_Geom2d_Curve_2(inner);
+    this._boundingBox = null;
+    shapeTypes.registerForCleanup(this, this._wrapped);
+  }
+  get wrapped() {
+    if (this._deleted) throw new Error("This object has been deleted");
+    return this._wrapped;
+  }
+  delete() {
+    if (!this._deleted) {
+      this._deleted = true;
+      shapeTypes.unregisterFromCleanup(this._wrapped);
+      this._wrapped.delete();
+    }
+  }
+  /** Compute (and cache) the 2D bounding box of this curve. */
+  get boundingBox() {
+    if (this._boundingBox) return this._boundingBox;
+    const oc = occtBoundary.getKernel().oc;
+    const boundBox = new oc.Bnd_Box2d();
+    oc.BndLib_Add2dCurve.Add_3(this.wrapped, 1e-6, boundBox);
+    this._boundingBox = new BoundingBox2d(boundBox);
+    return this._boundingBox;
+  }
+  /** Return a human-readable representation, e.g. `LINE (0,0) - (1,1)`. */
+  get repr() {
+    return `${this.geomType} ${reprPnt(this.firstPoint)} - ${reprPnt(this.lastPoint)}`;
+  }
+  /** Access the underlying OCCT `Geom2d_Curve` (unwrapped from its handle). */
+  get innerCurve() {
+    return this.wrapped.get();
+  }
+  /** Serialize this curve to a string that can be restored with {@link deserializeCurve2D}. */
+  serialize() {
+    const oc = occtBoundary.getKernel().oc;
+    return oc.GeomToolsWrapper.Write(this.wrapped);
+  }
+  /** Evaluate the curve at the given parameter, returning the 2D point. */
+  value(parameter) {
+    const p = this.innerCurve.Value(parameter);
+    const v = [p.X(), p.Y()];
+    p.delete();
+    return v;
+  }
+  /** Return the point at the start of the curve (cached after first access). */
+  get firstPoint() {
+    if (this._firstPoint === null) {
+      this._firstPoint = this.value(this.firstParameter);
+    }
+    return this._firstPoint;
+  }
+  /** Return the point at the end of the curve (cached after first access). */
+  get lastPoint() {
+    if (this._lastPoint === null) {
+      this._lastPoint = this.value(this.lastParameter);
+    }
+    return this._lastPoint;
+  }
+  /** Return the parameter value at the start of the curve. */
+  get firstParameter() {
+    return this.innerCurve.FirstParameter();
+  }
+  /** Return the parameter value at the end of the curve. */
+  get lastParameter() {
+    return this.innerCurve.LastParameter();
+  }
+  /** Create a `Geom2dAdaptor_Curve` for algorithmic queries (caller must delete). */
+  adaptor() {
+    const oc = occtBoundary.getKernel().oc;
+    return new oc.Geom2dAdaptor_Curve_2(this.wrapped);
+  }
+  /** Return the geometric type of this curve (e.g. `LINE`, `CIRCLE`, `BSPLINE_CURVE`). */
+  get geomType() {
+    const adaptor = this.adaptor();
+    const curveType = errors.unwrap(curveFns.findCurveType(adaptor.GetType()));
+    adaptor.delete();
+    return curveType;
+  }
+  /** Create an independent deep copy of this curve. */
+  clone() {
+    const cloned = new Curve2D(this.innerCurve.Copy());
+    cloned._firstPoint = this._firstPoint;
+    cloned._lastPoint = this._lastPoint;
+    return cloned;
+  }
+  /** Reverse the orientation of this curve in place. */
+  reverse() {
+    this.innerCurve.Reverse();
+    const tmp = this._firstPoint;
+    this._firstPoint = this._lastPoint;
+    this._lastPoint = tmp;
+  }
+  distanceFromPoint(point) {
+    var _stack = [];
+    try {
+      const oc = occtBoundary.getKernel().oc;
+      const scope = __using(_stack, new shapeTypes.DisposalScope());
+      const projector = scope.register(
+        new oc.Geom2dAPI_ProjectPointOnCurve_2(scope.register(pnt(point)), this.wrapped)
+      );
+      let curveToPoint;
+      try {
+        curveToPoint = projector.LowerDistance();
+      } catch {
+        curveToPoint = Infinity;
+      }
+      return Math.min(
+        curveToPoint,
+        helpers.distance2d(point, this.firstPoint),
+        helpers.distance2d(point, this.lastPoint)
+      );
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  distanceFromCurve(curve) {
+    var _stack = [];
+    try {
+      const oc = occtBoundary.getKernel().oc;
+      const scope = __using(_stack, new shapeTypes.DisposalScope());
+      let curveDistance;
+      const projector = scope.register(
+        new oc.Geom2dAPI_ExtremaCurveCurve(
+          this.wrapped,
+          curve.wrapped,
+          this.firstParameter,
+          this.lastParameter,
+          curve.firstParameter,
+          curve.lastParameter
+        )
+      );
+      try {
+        curveDistance = projector.LowerDistance();
+      } catch {
+        curveDistance = Infinity;
+      }
+      return Math.min(
+        curveDistance,
+        this.distanceFromPoint(curve.firstPoint),
+        this.distanceFromPoint(curve.lastPoint),
+        curve.distanceFromPoint(this.firstPoint),
+        curve.distanceFromPoint(this.lastPoint)
+      );
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  /** Compute the minimum distance from this curve to a point or another curve. */
+  distanceFrom(element) {
+    if (isPoint2D(element)) {
+      return this.distanceFromPoint(element);
+    }
+    return this.distanceFromCurve(element);
+  }
+  /** Test whether a point lies on the curve within a tight tolerance (1e-9). */
+  isOnCurve(point) {
+    return this.distanceFromPoint(point) < 1e-9;
+  }
+  /**
+   * Project a point onto the curve and return its parameter value.
+   *
+   * @returns `Ok(parameter)` when the point is on the curve, or an error result otherwise.
+   */
+  parameter(point, precision = 1e-9) {
+    var _stack = [];
+    try {
+      const oc = occtBoundary.getKernel().oc;
+      const scope = __using(_stack, new shapeTypes.DisposalScope());
+      let lowerDistance;
+      let lowerDistanceParameter;
+      try {
+        const projector = scope.register(
+          new oc.Geom2dAPI_ProjectPointOnCurve_2(scope.register(pnt(point)), this.wrapped)
+        );
+        lowerDistance = projector.LowerDistance();
+        lowerDistanceParameter = projector.LowerDistanceParameter();
+      } catch {
+        if (helpers.samePoint(point, this.firstPoint, precision)) return errors.ok(this.firstParameter);
+        if (helpers.samePoint(point, this.lastPoint, precision)) return errors.ok(this.lastParameter);
+        return errors.err(errors.computationError("PARAMETER_NOT_FOUND", "Failed to find parameter"));
+      }
+      if (lowerDistance > precision) {
+        return errors.err(
+          errors.computationError(
+            "POINT_NOT_ON_CURVE",
+            `Point ${reprPnt(point)} not on curve ${this.repr}, ${lowerDistance.toFixed(9)}`
+          )
+        );
+      }
+      return errors.ok(lowerDistanceParameter);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  /**
+   * Compute the tangent vector at a parameter position or at the projection of a point.
+   *
+   * @param index - A normalized parameter (0..1) or a Point2D to project onto the curve.
+   */
+  tangentAt(index) {
+    var _stack = [];
+    try {
+      const oc = occtBoundary.getKernel().oc;
+      const scope = __using(_stack, new shapeTypes.DisposalScope());
+      let param;
+      if (Array.isArray(index)) {
+        param = errors.unwrap(this.parameter(index));
+      } else {
+        const paramLength = this.innerCurve.LastParameter() - this.innerCurve.FirstParameter();
+        param = paramLength * index + Number(this.innerCurve.FirstParameter());
+      }
+      const point = scope.register(new oc.gp_Pnt2d_1());
+      const dir = scope.register(new oc.gp_Vec2d_1());
+      this.innerCurve.D1(param, point, dir);
+      const tgtVec = [dir.X(), dir.Y()];
+      return tgtVec;
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  /**
+   * Split this curve at the given points or parameter values.
+   *
+   * @returns An array of sub-curves whose union covers the original curve.
+   */
+  splitAt(points, precision = 1e-9) {
+    var _stack = [];
+    try {
+      const oc = occtBoundary.getKernel().oc;
+      const scope = __using(_stack, new shapeTypes.DisposalScope());
+      let parameters = points.map((point) => {
+        if (isPoint2D(point)) return errors.unwrap(this.parameter(point, precision));
+        return point;
+      });
+      parameters = Array.from(
+        new Map(parameters.map((p) => [precisionRound(p, -Math.log10(precision)), p])).values()
+      ).sort((a, b) => a - b);
+      const firstParam = this.firstParameter;
+      const lastParam = this.lastParameter;
+      if (firstParam > lastParam) {
+        parameters.reverse();
+      }
+      if (Math.abs(parameters[0] - firstParam) < precision * 100) parameters = parameters.slice(1);
+      if (!parameters.length) return [this];
+      if (
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        Math.abs(parameters[parameters.length - 1] - lastParam) < precision * 100
+      )
+        parameters = parameters.slice(0, -1);
+      if (!parameters.length) return [this];
+      return surfaceBuilders.zip([
+        [firstParam, ...parameters],
+        [...parameters, lastParam]
+      ]).map(([first, last]) => {
+        try {
+          if (this.geomType === "BEZIER_CURVE") {
+            const curveCopy = new oc.Geom2d_BezierCurve_1(
+              scope.register(this.adaptor()).Bezier().get().Poles_2()
+            );
+            curveCopy.Segment(first, last);
+            return new Curve2D(new oc.Handle_Geom2d_Curve_2(curveCopy));
+          }
+          if (this.geomType === "BSPLINE_CURVE") {
+            const adapted = scope.register(this.adaptor()).BSpline().get();
+            const curveCopy = new oc.Geom2d_BSplineCurve_1(
+              adapted.Poles_2(),
+              adapted.Knots_2(),
+              adapted.Multiplicities_2(),
+              adapted.Degree(),
+              adapted.IsPeriodic()
+            );
+            curveCopy.Segment(first, last, precision);
+            return new Curve2D(new oc.Handle_Geom2d_Curve_2(curveCopy));
+          }
+          const trimmed = new oc.Geom2d_TrimmedCurve(this.wrapped, first, last, true, true);
+          return new Curve2D(new oc.Handle_Geom2d_Curve_2(trimmed));
+        } catch (e) {
+          throw new Error(
+            `Failed to split the curve: ${e instanceof Error ? e.message : String(e)}`,
+            { cause: e }
+          );
+        }
+      });
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+}
+const approximateAsBSpline = (adaptor, tolerance = 1e-4, continuity = "C0", maxSegments = 200) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const continuities = {
+      C0: oc.GeomAbs_Shape.GeomAbs_C0,
+      C1: oc.GeomAbs_Shape.GeomAbs_C1,
+      C2: oc.GeomAbs_Shape.GeomAbs_C2,
+      C3: oc.GeomAbs_Shape.GeomAbs_C3
+    };
+    const convert = scope.register(
+      new oc.Geom2dConvert_ApproxCurve_2(
+        adaptor.ShallowCopy(),
+        tolerance,
+        continuities[continuity],
+        maxSegments,
+        3
+      )
+    );
+    return new Curve2D(convert.Curve());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const BSplineToBezier = (adaptor) => {
+  if (errors.unwrap(curveFns.findCurveType(adaptor.GetType())) !== "BSPLINE_CURVE")
+    result.bug("BSplineToBezier", "You can only convert a Bspline");
+  const handle = adaptor.BSpline();
+  const oc = occtBoundary.getKernel().oc;
+  const convert = new oc.Geom2dConvert_BSplineCurveToBezierCurve_1(handle);
+  function* bezierCurves() {
+    const nArcs = convert.NbArcs();
+    if (!nArcs) return;
+    for (let i = 1; i <= nArcs; i++) {
+      const arc = convert.Arc(i);
+      yield new Curve2D(arc);
+    }
+  }
+  const curves = Array.from(bezierCurves());
+  convert.delete();
+  return curves;
+};
+function approximateAsSvgCompatibleCurve(curves, options = {
+  tolerance: 1e-4,
+  continuity: "C0",
+  maxSegments: 300
+}) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    return curves.flatMap((curve) => {
+      const adaptor = scope.register(curve.adaptor());
+      const curveType = errors.unwrap(curveFns.findCurveType(adaptor.GetType()));
+      if (curveType === "ELLIPSE" || curveType === "CIRCLE" && helpers.samePoint(curve.firstPoint, curve.lastPoint)) {
+        return curve.splitAt([0.5]);
+      }
+      if (["LINE", "ELLIPSE", "CIRCLE"].includes(curveType)) {
+        return curve;
+      }
+      if (curveType === "BEZIER_CURVE") {
+        const b = adaptor.Bezier().get();
+        const deg = b.Degree();
+        if ([1, 2, 3].includes(deg)) {
+          return curve;
+        }
+      }
+      if (curveType === "BSPLINE_CURVE") {
+        const c = BSplineToBezier(adaptor);
+        return approximateAsSvgCompatibleCurve(c, options);
+      }
+      const bspline = approximateAsBSpline(
+        adaptor,
+        options.tolerance,
+        options.continuity,
+        options.maxSegments
+      );
+      return approximateAsSvgCompatibleCurve(
+        BSplineToBezier(scope.register(bspline.adaptor())),
+        options
+      );
+    });
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+const make2dSegmentCurve = (startPoint, endPoint) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const segment = scope.register(
+      new oc.GCE2d_MakeSegment_1(scope.register(pnt(startPoint)), scope.register(pnt(endPoint)))
+    ).Value();
+    const curve = new Curve2D(segment);
+    if (!helpers.samePoint(curve.firstPoint, startPoint)) {
+      curve.reverse();
+    }
+    return curve;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const make2dThreePointArc = (startPoint, midPoint, endPoint) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const segment = scope.register(
+      new oc.GCE2d_MakeArcOfCircle_4(
+        scope.register(pnt(startPoint)),
+        scope.register(pnt(midPoint)),
+        scope.register(pnt(endPoint))
+      )
+    ).Value();
+    const curve = new Curve2D(segment);
+    if (!helpers.samePoint(curve.firstPoint, startPoint)) {
+      curve.wrapped.get().SetTrim(curve.lastParameter, curve.firstParameter, true, true);
+    }
+    return curve;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const make2dTangentArc = (startPoint, tangent, endPoint) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const segment = scope.register(
+      new oc.GCE2d_MakeArcOfCircle_5(
+        scope.register(pnt(startPoint)),
+        scope.register(vec(tangent)),
+        scope.register(pnt(endPoint))
+      )
+    ).Value();
+    const curve = new Curve2D(segment);
+    if (!helpers.samePoint(curve.firstPoint, startPoint)) {
+      curve.wrapped.get().SetTrim(curve.lastParameter, curve.firstParameter, true, true);
+    }
+    return curve;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const make2dCircle = (radius, center = [0, 0]) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const segment = scope.register(new oc.GCE2d_MakeCircle_7(scope.register(pnt(center)), radius, true)).Value();
+    return new Curve2D(segment);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const make2dEllipse = (majorRadius, minorRadius, xDir = [1, 0], center = [0, 0], direct = true) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const ellipse = scope.register(
+      new oc.gp_Elips2d_2(scope.register(axis2d(center, xDir)), majorRadius, minorRadius, direct)
+    );
+    const segment = scope.register(new oc.GCE2d_MakeEllipse_1(ellipse)).Value();
+    return new Curve2D(segment);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const make2dEllipseArc = (majorRadius, minorRadius, startAngle, endAngle, center = [0, 0], xDir, direct = true) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const ellipse = scope.register(
+      new oc.gp_Elips2d_2(scope.register(axis2d(center, xDir)), majorRadius, minorRadius, true)
+    );
+    const segment = scope.register(new oc.GCE2d_MakeArcOfEllipse_1(ellipse, startAngle, endAngle, direct)).Value();
+    return new Curve2D(segment);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const make2dBezierCurve = (startPoint, controls, endPoint) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const arrayOfPoints = scope.register(new oc.TColgp_Array1OfPnt2d_2(1, controls.length + 2));
+    arrayOfPoints.SetValue(1, scope.register(pnt(startPoint)));
+    controls.forEach((p, i) => {
+      arrayOfPoints.SetValue(i + 2, scope.register(pnt(p)));
+    });
+    arrayOfPoints.SetValue(controls.length + 2, scope.register(pnt(endPoint)));
+    const bezCurve = new oc.Geom2d_BezierCurve_1(arrayOfPoints);
+    return new Curve2D(new oc.Handle_Geom2d_Curve_2(bezCurve));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+function make2dInerpolatedBSplineCurve(points, {
+  tolerance = 1e-3,
+  smoothing = null,
+  degMax = 3,
+  degMin = 1
+} = {}) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const oc = occtBoundary.getKernel().oc;
+    const pnts = scope.register(new oc.TColgp_Array1OfPnt2d_2(1, points.length));
+    points.forEach((point, index) => {
+      pnts.SetValue(index + 1, scope.register(pnt(point)));
+    });
+    let splineBuilder;
+    if (smoothing) {
+      splineBuilder = scope.register(
+        new oc.Geom2dAPI_PointsToBSpline_6(
+          pnts,
+          smoothing[0],
+          smoothing[1],
+          smoothing[2],
+          degMax,
+          oc.GeomAbs_Shape.GeomAbs_C2,
+          tolerance
+        )
+      );
+    } else {
+      splineBuilder = scope.register(
+        new oc.Geom2dAPI_PointsToBSpline_2(
+          pnts,
+          degMin,
+          degMax,
+          oc.GeomAbs_Shape.GeomAbs_C2,
+          tolerance
+        )
+      );
+    }
+    if (!splineBuilder.IsDone()) {
+      return errors.err(errors.computationError("BSPLINE_2D_FAILED", "B-spline approximation failed"));
+    }
+    return errors.ok(new Curve2D(splineBuilder.Curve()));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+const make2dArcFromCenter = (startPoint, endPoint, center, longArc = false) => {
+  const midChord = helpers.scalarMultiply2d(helpers.add2d(startPoint, endPoint), 0.5);
+  const orientedRadius = helpers.distance2d(center, startPoint) * (longArc ? -1 : 1);
+  const midChordDir = helpers.normalize2d(helpers.subtract2d(midChord, center));
+  return make2dThreePointArc(
+    startPoint,
+    helpers.add2d(helpers.scalarMultiply2d(midChordDir, orientedRadius), center),
+    endPoint
+  );
+};
+function round5(v) {
+  return Math.round(v * 1e5) / 1e5;
+}
+const fromPnt = (pnt2) => `${round2(pnt2.X())} ${round2(pnt2.Y())}`;
+const adaptedCurveToPathElem = (adaptor, lastPoint) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const curveType = errors.unwrap(curveFns.findCurveType(adaptor.GetType()));
+    const [endX, endY] = lastPoint;
+    const endpoint = `${round5(endX)} ${round5(endY)}`;
+    if (curveType === "LINE") {
+      return `L ${endpoint}`;
+    }
+    if (curveType === "BEZIER_CURVE") {
+      const bezierHandle = scope.register(adaptor.Bezier());
+      const curve = bezierHandle.get();
+      const deg = curve.Degree();
+      if (deg === 1) {
+        return `L ${endpoint}`;
+      }
+      if (deg === 2) {
+        const pole2 = scope.register(curve.Pole(2));
+        return `Q ${fromPnt(pole2)} ${endpoint}`;
+      }
+      if (deg === 3) {
+        const pole2 = scope.register(curve.Pole(2));
+        const pole3 = scope.register(curve.Pole(3));
+        const p1 = fromPnt(pole2);
+        const p2 = fromPnt(pole3);
+        return `C ${p1} ${p2} ${endpoint}`;
+      }
+    }
+    if (curveType === "CIRCLE") {
+      const curve = scope.register(adaptor.Circle());
+      const radius = curve.Radius();
+      const p1 = adaptor.FirstParameter();
+      const p2 = adaptor.LastParameter();
+      const paramAngle = (p2 - p1) * vecOps.RAD2DEG;
+      const end = paramAngle !== 360 ? endpoint : `${round5(endX)} ${round5(endY + 1e-4)}`;
+      return `A ${radius} ${radius} 0 ${Math.abs(paramAngle) > 180 ? "1" : "0"} ${curve.IsDirect() ? "1" : "0"} ${end}`;
+    }
+    if (curveType === "ELLIPSE") {
+      const curve = scope.register(adaptor.Ellipse());
+      const rx = curve.MajorRadius();
+      const ry = curve.MinorRadius();
+      const p1 = adaptor.FirstParameter();
+      const p2 = adaptor.LastParameter();
+      const paramAngle = (p2 - p1) * vecOps.RAD2DEG;
+      const end = paramAngle !== 360 ? endpoint : `${round5(endX)} ${round5(endY + 1e-4)}`;
+      const dir0 = scope.register(new oc.gp_Dir2d_1());
+      const xAxis = scope.register(curve.XAxis());
+      const xDir = scope.register(xAxis.Direction());
+      const angle = 180 - xDir.Angle(dir0) * vecOps.RAD2DEG;
+      return `A ${round5(rx)} ${round5(ry)} ${round5(angle)} ${Math.abs(paramAngle) > 180 ? "1" : "0"} ${curve.IsDirect() ? "1" : "0"} ${end}`;
+    }
+    result.bug("adaptedCurveToPathElem", `Unsupported curve type: ${curveType}`);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const curvesBoundingBox = (curves) => {
+  const oc = occtBoundary.getKernel().oc;
+  const boundBox = new oc.Bnd_Box2d();
+  curves.forEach((c) => {
+    oc.BndLib_Add2dCurve.Add_3(c.wrapped, 1e-6, boundBox);
+  });
+  return new BoundingBox2d(boundBox);
+};
+function curvesAsEdgesOnPlane(curves, plane) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const ax = scope.register(occtBoundary.makeOcAx2(plane.origin, plane.zDir, plane.xDir));
+    const oc = occtBoundary.getKernel().oc;
+    const edges = curves.map((curve) => {
+      const curve3d = scope.register(oc.GeomLib.To3d(ax, curve.wrapped));
+      const edgeBuilder = scope.register(new oc.BRepBuilderAPI_MakeEdge_24(curve3d));
+      return shapeTypes.createEdge(edgeBuilder.Edge());
+    });
+    return edges;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+const curvesAsEdgesOnSurface = (curves, geomSurf) => {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const oc = occtBoundary.getKernel().oc;
+    const modifiedCurves = curves.map((curve) => {
+      const edgeBuilder = scope.register(new oc.BRepBuilderAPI_MakeEdge_30(curve.wrapped, geomSurf));
+      return shapeTypes.createEdge(edgeBuilder.Edge());
+    });
+    return modifiedCurves;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const transformCurves = (curves, transformation) => {
+  const oc = occtBoundary.getKernel().oc;
+  const modifiedCurves = curves.map((curve) => {
+    if (!transformation) return curve.clone();
+    return new Curve2D(oc.GeomLib.GTransform(curve.wrapped, transformation));
+  });
+  return modifiedCurves;
+};
+const stretchTransform2d = (ratio, direction, origin = [0, 0]) => {
+  const oc = occtBoundary.getKernel().oc;
+  const ax = axis2d(origin, direction);
+  const transform = new oc.gp_GTrsf2d_1();
+  transform.SetAffinity(ax, ratio);
+  ax.delete();
+  return transform;
+};
+const translationTransform2d = (translation) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const rotation = new oc.gp_Trsf2d_1();
+    rotation.SetTranslation_1(scope.register(vec(translation)));
+    const transform = new oc.gp_GTrsf2d_2(rotation);
+    return transform;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const mirrorTransform2d = (centerOrDirection, origin = [0, 0], mode = "center") => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const rotation = new oc.gp_Trsf2d_1();
+    if (mode === "center") {
+      rotation.SetMirror_1(scope.register(pnt(centerOrDirection)));
+    } else {
+      rotation.SetMirror_2(scope.register(axis2d(origin, centerOrDirection)));
+    }
+    const transform = new oc.gp_GTrsf2d_2(rotation);
+    return transform;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const rotateTransform2d = (angle, center = [0, 0]) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const rotation = new oc.gp_Trsf2d_1();
+    rotation.SetRotation(scope.register(pnt(center)), angle);
+    const transform = new oc.gp_GTrsf2d_2(rotation);
+    return transform;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const scaleTransform2d = (scaleFactor, center = [0, 0]) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const scaling = new oc.gp_Trsf2d_1();
+    scaling.SetScale(scope.register(pnt(center)), scaleFactor);
+    const transform = new oc.gp_GTrsf2d_2(scaling);
+    return transform;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+function curvesAsEdgesOnFace(curves, face, scale = "original") {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const oc = occtBoundary.getKernel().oc;
+    let geomSurf = scope.register(oc.BRep_Tool.Surface_2(face.wrapped));
+    const bounds = faceFns.uvBounds(face);
+    let transformation = null;
+    const uAxis = scope.register(axis2d([0, 0], [0, 1]));
+    const _vAxis = scope.register(axis2d([0, 0], [1, 0]));
+    if (scale === "original" && faceFns.faceGeomType(face) !== "PLANE") {
+      if (faceFns.faceGeomType(face) !== "CYLINDRE")
+        return errors.err(
+          errors.validationError(
+            "UNSUPPORTED_FACE_TYPE",
+            "Only planar and cylindrical faces can be unwrapped for sketching"
+          )
+        );
+      const cylinder = scope.register(geomSurf.get().Cylinder());
+      if (!cylinder.Direct()) {
+        geomSurf = geomSurf.get().UReversed();
+      }
+      const radius = cylinder.Radius();
+      transformation = stretchTransform2d(1 / radius, [0, 1]);
+    }
+    if (scale === "bounds") {
+      transformation = scope.register(new oc.gp_GTrsf2d_1());
+      transformation.SetAffinity(uAxis, bounds.uMax - bounds.uMin);
+      if (bounds.uMin !== 0) {
+        const trans = scope.register(new oc.gp_GTrsf2d_1());
+        trans.SetTranslationPart(new oc.gp_XY_2(0, -bounds.uMin));
+        transformation.Multiply(trans);
+      }
+      const vTransformation = scope.register(new oc.gp_GTrsf2d_1());
+      vTransformation.SetAffinity(_vAxis, bounds.vMax - bounds.vMin);
+      transformation.Multiply(vTransformation);
+      if (bounds.vMin !== 0) {
+        const trans = scope.register(new oc.gp_GTrsf2d_1());
+        trans.SetTranslationPart(scope.register(new oc.gp_XY_2(0, -bounds.vMin)));
+        transformation.Multiply(trans);
+      }
+    }
+    const modifiedCurves = transformCurves(curves, transformation);
+    const edges = curvesAsEdgesOnSurface(modifiedCurves, geomSurf);
+    return errors.ok(edges);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function edgeToCurve(e, face) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const adaptor = scope.register(new oc.BRepAdaptor_Curve2d_2(e.wrapped, face.wrapped));
+    const trimmed = new oc.Geom2d_TrimmedCurve(
+      adaptor.Curve(),
+      adaptor.FirstParameter(),
+      adaptor.LastParameter(),
+      true,
+      true
+    );
+    if (curveFns.getOrientation(e) === "backward") {
+      trimmed.Reverse();
+    }
+    return new Curve2D(new oc.Handle_Geom2d_Curve_2(trimmed));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+const viewbox = (bbox, margin = 1) => {
+  const minX = bbox.bounds[0][0] - margin;
+  const minY = -bbox.bounds[1][1] - margin;
+  return `${minX} ${minY} ${bbox.width + 2 * margin} ${bbox.height + 2 * margin}`;
+};
+const asSVG = (body, boundingBox, margin = 1) => {
+  const vbox = viewbox(boundingBox, margin);
+  return `<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="${vbox}" fill="none" stroke="black" stroke-width="0.6%" vector-effect="non-scaling-stroke">
+    ${body}
+</svg>`;
+};
+function assembleWire(listOfEdges) {
+  const oc = occtBoundary.getKernel().oc;
+  const builder = new oc.BRepBuilderAPI_MakeWire_1();
+  listOfEdges.forEach((e) => {
+    builder.Add_1(e.wrapped);
+  });
+  return shapeTypes.createWire(builder.Wire());
+}
+class Blueprint {
+  /** Ordered 2D curve segments that compose this blueprint. */
+  curves;
+  _boundingBox;
+  _orientation;
+  _guessedOrientation;
+  /** Create a blueprint from an ordered array of 2D curves.
+   *
+   * @throws Error if the curves array is empty.
+   */
+  constructor(curves) {
+    if (curves.length === 0) {
+      throw new Error("Blueprint requires at least one curve");
+    }
+    this.curves = curves;
+    this._boundingBox = null;
+    this._orientation = null;
+    this._guessedOrientation = null;
+  }
+  /** Release WASM resources held by the underlying curves and bounding box. */
+  delete() {
+    this.curves.forEach((c) => {
+      c.delete();
+    });
+    if (this._boundingBox) this._boundingBox.delete();
+  }
+  /** Return a deep copy of this blueprint. */
+  clone() {
+    return new Blueprint(this.curves.map((c) => c.clone()));
+  }
+  /** Return a multi-line string representation for debugging. */
+  get repr() {
+    return ["Blueprint", ...this.curves.map((c) => c.repr)].join("\n");
+  }
+  /** Compute (and cache) the axis-aligned bounding box of all curves. */
+  get boundingBox() {
+    if (!this._boundingBox) {
+      this._boundingBox = curvesBoundingBox(this.curves);
+    }
+    return this._boundingBox;
+  }
+  /** Determine the winding direction of the blueprint via the shoelace formula.
+   *
+   * @remarks Uses an approximation based on curve midpoints for non-linear
+   * segments. The result is cached after the first call.
+   */
+  get orientation() {
+    if (this._orientation) return this._orientation;
+    if (this._guessedOrientation) return this._guessedOrientation;
+    const vertices = this.curves.flatMap((c) => {
+      if (c.geomType !== "LINE") {
+        return [c.firstPoint, c.value(0.5)];
+      }
+      return [c.firstPoint];
+    });
+    const approximateArea = vertices.map((v1, i) => {
+      const v2 = vertices[(i + 1) % vertices.length];
+      return (v2[0] - v1[0]) * (v2[1] + v1[1]);
+    }).reduce((a, b) => a + b, 0);
+    this._guessedOrientation = approximateArea > 0 ? "clockwise" : "counterClockwise";
+    return this._guessedOrientation;
+  }
+  /**
+   * Stretch the blueprint along a direction by a given ratio.
+   *
+   * @param ratio - Stretch factor (1 = unchanged).
+   * @param direction - Unit direction vector to stretch along.
+   * @param origin - Fixed point of the stretch (defaults to the origin).
+   * @returns A new stretched Blueprint.
+   */
+  stretch(ratio, direction, origin = [0, 0]) {
+    const curves = transformCurves(this.curves, stretchTransform2d(ratio, direction, origin));
+    return new Blueprint(curves);
+  }
+  /**
+   * Uniformly scale the blueprint around a center point.
+   *
+   * @param scaleFactor - Scale multiplier (>1 enlarges, <1 shrinks).
+   * @param center - Center of scaling (defaults to the bounding box center).
+   * @returns A new scaled Blueprint.
+   */
+  scale(scaleFactor, center) {
+    const centerPoint = center || this.boundingBox.center;
+    const curves = transformCurves(this.curves, scaleTransform2d(scaleFactor, centerPoint));
+    return new Blueprint(curves);
+  }
+  /**
+   * Rotate the blueprint by an angle in degrees.
+   *
+   * @param angle - Rotation angle in degrees (positive = counter-clockwise).
+   * @param center - Center of rotation (defaults to the origin).
+   * @returns A new rotated Blueprint.
+   */
+  rotate(angle, center) {
+    const curves = transformCurves(this.curves, rotateTransform2d(angle * vecOps.DEG2RAD, center));
+    return new Blueprint(curves);
+  }
+  translate(xDistOrPoint, yDist = 0) {
+    const translationVector = isPoint2D(xDistOrPoint) ? xDistOrPoint : [xDistOrPoint, yDist];
+    const curves = transformCurves(this.curves, translationTransform2d(translationVector));
+    return new Blueprint(curves);
+  }
+  /**
+   * Mirror the blueprint across a point or plane.
+   *
+   * @param centerOrDirection - Mirror center (center mode) or plane normal (plane mode).
+   * @param origin - Origin for plane-mode mirroring.
+   * @param mode - `'center'` for point symmetry, `'plane'` for reflection across an axis.
+   * @returns A new mirrored Blueprint.
+   */
+  mirror(centerOrDirection, origin = [0, 0], mode = "center") {
+    const curves = transformCurves(this.curves, mirrorTransform2d(centerOrDirection, origin, mode));
+    return new Blueprint(curves);
+  }
+  /**
+   * Project this 2D blueprint onto a 3D plane, producing a wire and metadata.
+   *
+   * @param inputPlane - Named plane (`"XY"`, `"XZ"`, etc.) or a custom Plane.
+   * @param origin - Origin offset; a number sets the offset along the plane normal.
+   * @returns Sketch data containing the projected wire and default orientation.
+   */
+  sketchOnPlane(inputPlane, origin) {
+    const plane = inputPlane && typeof inputPlane !== "string" ? { ...inputPlane } : makePlane(inputPlane, origin);
+    const edges = curvesAsEdgesOnPlane(this.curves, plane);
+    const wire = assembleWire(edges);
+    return {
+      wire,
+      defaultOrigin: plane.origin,
+      defaultDirection: plane.zDir
+    };
+  }
+  /**
+   * Map this 2D blueprint onto a 3D face's UV surface.
+   *
+   * @param face - Target face to project onto.
+   * @param scaleMode - How UV coordinates are interpreted (`'original'`, `'bounds'`, or `'native'`).
+   * @returns Sketch data containing the wire mapped onto the face.
+   */
+  sketchOnFace(face, scaleMode) {
+    const oc = occtBoundary.getKernel().oc;
+    const edges = errors.unwrap(curvesAsEdgesOnFace(this.curves, face, scaleMode));
+    const wire = assembleWire(edges);
+    oc.BRepLib.BuildCurves3d_2(wire.wrapped);
+    const wireFixer = new oc.ShapeFix_Wire_2(wire.wrapped, face.wrapped, 1e-9);
+    wireFixer.FixEdgeCurves();
+    wireFixer.delete();
+    return { wire, baseFace: face };
+  }
+  /**
+   * Create a face on a target face's surface defined by this blueprint's profile.
+   *
+   * @param face - The face whose surface the sub-face lies on.
+   * @param origin - Optional UV origin offset (defaults to the face center).
+   * @returns A new Face bounded by the blueprint's profile.
+   */
+  subFace(face, origin) {
+    const originPoint = origin || [...faceFns.faceCenter(face)];
+    const originVec3 = occtBoundary.toVec3(originPoint);
+    const sketch = this.translate(faceFns.uvCoordinates(face, originVec3)).sketchOnFace(face, "original");
+    return errors.unwrap(surfaceBuilders.makeFace(sketch.wire));
+  }
+  /**
+   * Cut a prism-shaped hole through a solid along a face using this blueprint.
+   *
+   * @param shape - The solid to punch through.
+   * @param face - The face on which the hole profile is placed.
+   * @param options - Optional hole parameters.
+   * @param options.height - Hole depth; `null` (default) cuts through the entire solid.
+   * @param options.origin - UV origin on the face for the blueprint placement.
+   * @param options.draftAngle - Taper angle in degrees (0 = straight hole).
+   * @returns The modified shape with the hole removed.
+   */
+  punchHole(shape, face, {
+    height = null,
+    origin = null,
+    draftAngle = 0
+  } = {}) {
+    var _stack = [];
+    try {
+      const oc = occtBoundary.getKernel().oc;
+      const scope = __using(_stack, new shapeTypes.DisposalScope());
+      const foundFace = errors.unwrap(helpers.getSingleFace(face, shape));
+      const hole = this.subFace(foundFace, origin);
+      const maker = scope.register(
+        new oc.BRepFeat_MakeDPrism_1(
+          shape.wrapped,
+          hole.wrapped,
+          foundFace.wrapped,
+          draftAngle * vecOps.DEG2RAD,
+          0,
+          false
+        )
+      );
+      if (height) {
+        maker.Perform_1(height);
+      } else {
+        maker.PerformThruAll();
+      }
+      return errors.unwrap(faceFns.cast(maker.Shape()));
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  /** Convert the blueprint to an SVG path `d` attribute string. */
+  toSVGPathD() {
+    var _stack = [];
+    try {
+      const scope = __using(_stack, new shapeTypes.DisposalScope());
+      const bp = this.clone().mirror([1, 0], [0, 0], "plane");
+      const compatibleCurves = approximateAsSvgCompatibleCurve(bp.curves);
+      const path = compatibleCurves.flatMap((c) => {
+        return adaptedCurveToPathElem(scope.register(c.adaptor()), c.lastPoint);
+      });
+      const [startX, startY] = bp.curves[0].firstPoint;
+      return `M ${round5(startX)} ${round5(startY)} ${path.join(" ")}${bp.isClosed() ? " Z" : ""}`;
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  /** Wrap the SVG path data in a `<path>` element string. */
+  toSVGPath() {
+    return `<path d="${this.toSVGPathD()}" />`;
+  }
+  /**
+   * Compute the SVG `viewBox` attribute for this blueprint.
+   *
+   * @param margin - Extra padding around the bounding box in drawing units.
+   */
+  toSVGViewBox(margin = 1) {
+    return viewbox(this.boundingBox, margin);
+  }
+  /** Return the SVG path `d` strings for this blueprint as an array. */
+  toSVGPaths() {
+    return [this.toSVGPathD()];
+  }
+  /**
+   * Render a complete SVG document string for this blueprint.
+   *
+   * @param margin - Extra padding around the bounding box in drawing units.
+   */
+  toSVG(margin = 1) {
+    return asSVG(this.toSVGPath(), this.boundingBox, margin);
+  }
+  /** Get the start point of the first curve. */
+  get firstPoint() {
+    return this.curves[0].firstPoint;
+  }
+  /** Get the end point of the last curve. */
+  get lastPoint() {
+    return this.curves[this.curves.length - 1].lastPoint;
+  }
+  /**
+   * Test whether a 2D point lies inside this closed blueprint.
+   *
+   * Uses ray-casting (intersection counting) against a segment from the point
+   * to a location guaranteed to be outside the bounding box.
+   *
+   * @remarks Returns `false` for points on the boundary.
+   * @returns `true` if the point is strictly inside the blueprint.
+   */
+  isInside(point) {
+    if (!this.boundingBox.containsPoint(point)) return false;
+    const oc = occtBoundary.getKernel().oc;
+    const intersector = new oc.Geom2dAPI_InterCurveCurve_1();
+    try {
+      const segment = make2dSegmentCurve(point, this.boundingBox.outsidePoint());
+      let crossCounts = 0;
+      const onCurve = this.curves.find((c) => c.isOnCurve(point));
+      if (onCurve) return false;
+      this.curves.forEach((c) => {
+        if (c.boundingBox.isOut(segment.boundingBox)) return;
+        intersector.Init_1(segment.wrapped, c.wrapped, 1e-9);
+        crossCounts += Number(intersector.NbPoints());
+      });
+      return !!(crossCounts % 2);
+    } finally {
+      intersector.delete();
+    }
+  }
+  /** Check whether the first and last points coincide (the profile is closed). */
+  isClosed() {
+    return helpers.samePoint(this.firstPoint, this.lastPoint);
+  }
+  /**
+   * Test whether this blueprint's curves intersect with another blueprint's curves.
+   *
+   * @remarks Uses bounding-box pre-filtering for early rejection.
+   */
+  intersects(other) {
+    if (this.boundingBox.isOut(other.boundingBox)) return false;
+    const oc = occtBoundary.getKernel().oc;
+    const intersector = new oc.Geom2dAPI_InterCurveCurve_1();
+    try {
+      for (const myCurve of this.curves) {
+        for (const otherCurve of other.curves) {
+          if (myCurve.boundingBox.isOut(otherCurve.boundingBox)) continue;
+          intersector.Init_1(myCurve.wrapped, otherCurve.wrapped, 1e-9);
+          if (intersector.NbPoints() || intersector.NbSegments()) return true;
+        }
+      }
+      return false;
+    } finally {
+      intersector.delete();
+    }
+  }
+}
+exports.Blueprint = Blueprint;
+exports.BoundingBox2d = BoundingBox2d;
+exports.Curve2D = Curve2D;
+exports.approximateAsBSpline = approximateAsBSpline;
+exports.approximateAsSvgCompatibleCurve = approximateAsSvgCompatibleCurve;
+exports.asSVG = asSVG;
+exports.axis2d = axis2d;
+exports.deserializeCurve2D = deserializeCurve2D;
+exports.edgeToCurve = edgeToCurve;
+exports.isPoint2D = isPoint2D;
+exports.make2dArcFromCenter = make2dArcFromCenter;
+exports.make2dBezierCurve = make2dBezierCurve;
+exports.make2dCircle = make2dCircle;
+exports.make2dEllipse = make2dEllipse;
+exports.make2dEllipseArc = make2dEllipseArc;
+exports.make2dInerpolatedBSplineCurve = make2dInerpolatedBSplineCurve;
+exports.make2dSegmentCurve = make2dSegmentCurve;
+exports.make2dTangentArc = make2dTangentArc;
+exports.make2dThreePointArc = make2dThreePointArc;
+exports.makePlane = makePlane;
+exports.mirror = mirror;
+exports.removeDuplicatePoints = removeDuplicatePoints;
+exports.viewbox = viewbox;