brepjs 12.7.1 → 12.7.3

package/dist/core.cjs

@@ -3,7 +3,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const types = require("./types-CA_xrgDq.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
 const errors = require("./errors-9fDehDNc.cjs");
-const vectors = require("./vectors-TlfO1hu2.cjs");
+const vectors = require("./vectors-BafmMf96.cjs");
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
 const result = require("./result.cjs");
 exports.resolveDirection = types.resolveDirection;

package/dist/core.js

@@ -1,7 +1,7 @@
 import { r, t, a } from "./types-CWDdqcrq.js";
 import { D, H, R, v, a as a2, b, c, d, e, f, g, h, i, j, k, l, m, n, o } from "./vecOps-ZDdZWbwT.js";
 import { O, a as a3, c as c2, b as b2, e as e2, f as f2, i as i2, d as d2, g as g2, k as k2, m as m2, h as h2, j as j2, l as l2, o as o2, q, s, t as t2, n as n2, p, u, r as r2, v as v2, w, x, y } from "./errors-B7kgv0cd.js";
-import { c as c3, a as a4, p as p2, r as r3, t as t3 } from "./vectors-cec8p8NQ.js";
+import { c as c3, a as a4, p as p2, r as r3, t as t3 } from "./vectors-CESkzEm6.js";
 import { D as D2, c as c4, a as a5, b as b3, d as d3, g as g3, i as i3, e as e3, f as f3, h as h3, j as j3, k as k3, l as l3, m as m3, n as n3, o as o3, p as p3, q as q2, r as r4, s as s2, t as t4, u as u2, v as v3, w as w2, x as x2, y as y2, z, A } from "./shapeTypes-CpSaBLDv.js";
 import { BrepBugError, bug } from "./result.js";
 export {

package/dist/{cornerFinder-BESZIitp.cjs → cornerFinder-3zfbQvXg.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const helpers = require("./helpers-DNzVfe-Z.cjs");
+const helpers = require("./helpers-6kn30cSD.cjs");
 const PI_2 = 2 * Math.PI;
 function positiveHalfAngle(angle) {
   const limitedAngle = angle % PI_2;

package/dist/{cornerFinder-FY38t0zq.js → cornerFinder-BV-l1BCw.js}

@@ -1,5 +1,5 @@
 import { D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
-import { a as angle2d, s as samePoint, d as distance2d } from "./helpers-DeFPsrcI.js";
+import { a as angle2d, s as samePoint, d as distance2d } from "./helpers-C9KvE1RW.js";
 const PI_2 = 2 * Math.PI;
 function positiveHalfAngle(angle) {
   const limitedAngle = angle % PI_2;

package/dist/{curveFns-LRNGcHXh.js → curveFns-CloOqAQ_.js}

@@ -97,18 +97,18 @@ function offsetWire2D(wire, offset, kind = "arc") {
   return ok(wrapped);
 }
 export {
-  curveEndPoint as a,
-  getCurveType as b,
-  curveTangentAt as c,
-  curveStartPoint as d,
-  curveIsClosed as e,
-  flipOrientation as f,
+  curveTangentAt as a,
+  curveIsClosed as b,
+  curveStartPoint as c,
+  curvePointAt as d,
+  curveEndPoint as e,
+  curveLength as f,
   getOrientation as g,
-  curvePointAt as h,
-  curveLength as i,
-  approximateCurve as j,
-  curveIsPeriodic as k,
-  curvePeriod as l,
+  approximateCurve as h,
+  curveIsPeriodic as i,
+  curvePeriod as j,
+  flipOrientation as k,
+  getCurveType as l,
   interpolateCurve as m,
   offsetWire2D as o
 };

package/dist/{drawFns-D8QyY7cg.js → drawFns-5myJTgtX.js}

@@ -44,22 +44,22 @@ var __callDispose = (stack, error, hasError) => {
   return next();
 };
 import { r as unwrap, g as isOk, e as err, y as validationError, o as ok } from "./errors-B7kgv0cd.js";
-import { r as resolvePlane, b as planeToWorld, d as planeToLocal } from "./vectors-cec8p8NQ.js";
+import { r as resolvePlane, b as planeToWorld } from "./vectors-CESkzEm6.js";
 import { a as toVec3 } from "./types-CWDdqcrq.js";
-import { n as vecScale, j as vecNormalize, v as vecAdd, o as vecSub, b as vecCross, m as vecRotate, R as RAD2DEG, g as vecLength, e as vecEquals, D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
-import { b as Flatbush, c as convertSvgEllipseParams, d as defaultsSplineOptions, S as Sketch, r as roundedRectangleBlueprint, e as Blueprints, C as CompoundBlueprint, f as cut2D, i as intersectCurves, g as fuse2D, m as make2dOffset, h as filletCurves, j as chamferCurves, o as organiseBlueprints, a as BlueprintSketcher, k as intersect2D, B as BaseSketcher2d, p as polysidesBlueprint } from "./boolean2D-x2irapGj.js";
+import { j as vecNormalize, b as vecCross, o as vecSub, n as vecScale, m as vecRotate, D as DEG2RAD, g as vecLength } from "./vecOps-ZDdZWbwT.js";
+import { b as Flatbush, B as BaseSketcher2d, S as Sketch, r as roundedRectangleBlueprint, c as Blueprints, C as CompoundBlueprint, d as cut2D, i as intersectCurves, f as fuse2D, m as make2dOffset, e as filletCurves, g as chamferCurves, o as organiseBlueprints, a as BlueprintSketcher, h as intersect2D, p as polysidesBlueprint } from "./boolean2D-CwZAIJDS.js";
 import { d as downcast, c as cast, e as faceCenter, n as normalAt, o as outerWire } from "./faceFns-B6ebRh5I.js";
-import { c as curveTangentAt, a as curveEndPoint, f as flipOrientation, b as getCurveType, o as offsetWire2D } from "./curveFns-LRNGcHXh.js";
-import { a as makeLine, d as makeThreePointArc, e as makeTangentArc, f as makeEllipseArc, g as makeBezierCurve, b as assembleWire, h as addHolesInFace, m as makeFace, i as makeCircle, j as makeEllipse, c as makeHelix, k as makeBSplineApproximation } from "./surfaceBuilders-D7ZH2QNS.js";
-import { D as DisposalScope, B as getKernel, G as createWire, I as createFace, k as isFace, c as castShape } from "./shapeTypes-CpSaBLDv.js";
-import { m as mirror, B as Blueprint, C as Curve2D, a as make2dSegmentCurve, b as make2dArcFromCenter, c as approximateAsSvgCompatibleCurve, d as BoundingBox2d, e as edgeToCurve, f as make2dInerpolatedBSplineCurve, g as make2dCircle, h as make2dEllipse, i as deserializeCurve2D } from "./Blueprint-CtuUvzex.js";
+import { o as offsetWire2D } from "./curveFns-CloOqAQ_.js";
+import { b as assembleWire, d as addHolesInFace, m as makeFace, e as makeCircle, f as makeEllipse, c as makeHelix, g as makeBSplineApproximation } from "./surfaceBuilders-D6iDVPIM.js";
+import { D as DisposalScope, G as createWire, I as createFace, B as getKernel, k as isFace, c as castShape } from "./shapeTypes-CpSaBLDv.js";
+import { c as curvesAsEdgesOnPlane, m as mirror, B as Blueprint, C as Curve2D, a as make2dSegmentCurve, b as make2dArcFromCenter, d as approximateAsSvgCompatibleCurve, e as BoundingBox2d, f as edgeToCurve, g as make2dInerpolatedBSplineCurve, h as make2dCircle, i as make2dEllipse, j as deserializeCurve2D } from "./Blueprint-C3lWY1Jf.js";
 import { bug } from "./result.js";
-import { d as distance2d, p as polarAngle2d, f as polarToCartesian, P as PRECISION_OFFSET, h as squareDistance2d, s as samePoint$1, e as subtract2d, c as add2d } from "./helpers-DeFPsrcI.js";
-import { d as getEdges } from "./shapeFns-CbXxLvV_.js";
+import { s as samePoint$1, P as PRECISION_OFFSET, f as squareDistance2d, e as subtract2d, c as add2d } from "./helpers-C9KvE1RW.js";
+import { d as getEdges } from "./shapeFns-D2PlLFE6.js";
 import { a as makeCompound, b as makeSolid } from "./solidBuilders-BXhh5hP2.js";
-import { b as basicFaceExtrusion, r as revolution, c as complexExtrude, t as twistExtrude } from "./loft-DsVv4yxU.js";
+import { b as basicFaceExtrusion, r as revolution, c as complexExtrude, t as twistExtrude } from "./loft-BcZUCGKi.js";
 import opentype from "opentype.js";
-import { c as cornerFinder } from "./cornerFinder-FY38t0zq.js";
+import { c as cornerFinder } from "./cornerFinder-BV-l1BCw.js";
 const stitchCurves = (curves, precision = 1e-7) => {
   const startPoints = new Flatbush(curves.length);
   curves.forEach((c) => {
@@ -108,350 +108,94 @@ const stitchCurves = (curves, precision = 1e-7) => {
   });
   return stitchedCurves;
 };
-class Sketcher {
+class Sketcher extends BaseSketcher2d {
   plane;
-  pointer;
-  firstPoint;
-  pendingEdges;
-  _mirrorWire;
   constructor(plane, origin) {
+    super();
     this.plane = plane && typeof plane !== "string" ? { ...plane } : resolvePlane(plane ?? "XY", origin);
-    this.pointer = [...this.plane.origin];
-    this.firstPoint = [...this.plane.origin];
-    this.pendingEdges = [];
-    this._mirrorWire = false;
   }
-  /** Release all kernel edges held by this sketcher. */
+  /** Release resources held by this sketcher (lightweight — no kernel handles during drawing). */
   delete() {
-    for (const edge of this.pendingEdges) {
-      edge.delete();
-    }
-    this.pendingEdges = [];
-  }
-  _updatePointer(newPointer) {
-    this.pointer = newPointer;
-  }
-  /** Move the pen to an absolute 2D position before drawing any edges. */
-  movePointerTo([x, y]) {
-    if (this.pendingEdges.length)
-      bug("Sketcher.movePointerTo", "You can only move the pointer if there is no edge defined");
-    this._updatePointer(planeToWorld(this.plane, [x, y]));
-    this.firstPoint = this.pointer;
-    return this;
-  }
-  /** Draw a straight line to an absolute 2D point on the sketch plane. */
-  lineTo([x, y]) {
-    const endPoint = planeToWorld(this.plane, [x, y]);
-    this.pendingEdges.push(makeLine(this.pointer, endPoint));
-    this._updatePointer(endPoint);
-    return this;
-  }
-  /** Draw a straight line by relative horizontal and vertical distances. */
-  line(xDist, yDist) {
-    const [px, py] = planeToLocal(this.plane, this.pointer);
-    return this.lineTo([xDist + px, yDist + py]);
-  }
-  /** Draw a vertical line of the given signed distance. */
-  vLine(distance) {
-    return this.line(0, distance);
-  }
-  /** Draw a horizontal line of the given signed distance. */
-  hLine(distance) {
-    return this.line(distance, 0);
-  }
-  /** Draw a vertical line to an absolute Y coordinate. */
-  vLineTo(yPos) {
-    const [px] = planeToLocal(this.plane, this.pointer);
-    return this.lineTo([px, yPos]);
-  }
-  /** Draw a horizontal line to an absolute X coordinate. */
-  hLineTo(xPos) {
-    const [, py] = planeToLocal(this.plane, this.pointer);
-    return this.lineTo([xPos, py]);
-  }
-  /** Draw a line in polar coordinates (distance and angle in degrees) from the current point. */
-  polarLine(distance, angle) {
-    const angleInRads = angle * DEG2RAD;
-    const [x, y] = polarToCartesian(distance, angleInRads);
-    return this.line(x, y);
-  }
-  /** Draw a line to a point given in polar coordinates [r, theta] from the origin. */
-  polarLineTo([r, theta]) {
-    const angleInRads = theta * DEG2RAD;
-    const point = polarToCartesian(r, angleInRads);
-    return this.lineTo(point);
-  }
-  /** Draw a line tangent to the previous edge, extending by the given distance. */
-  tangentLine(distance) {
-    const previousEdge = this.pendingEdges.length ? this.pendingEdges[this.pendingEdges.length - 1] : null;
-    if (!previousEdge)
-      bug("Sketcher.tangentLine", "You need a previous edge to create a tangent line");
-    const tangent = curveTangentAt(previousEdge, 1);
-    const scaledTangent = vecScale(vecNormalize(tangent), distance);
-    const endPoint = vecAdd(scaledTangent, this.pointer);
-    this.pendingEdges.push(makeLine(this.pointer, endPoint));
-    this._updatePointer(endPoint);
-    return this;
-  }
-  /** Draw a circular arc passing through an inner point to an absolute end point. */
-  threePointsArcTo(end, innerPoint) {
-    const gpoint1 = planeToWorld(this.plane, innerPoint);
-    const gpoint2 = planeToWorld(this.plane, end);
-    this.pendingEdges.push(makeThreePointArc(this.pointer, gpoint1, gpoint2));
-    this._updatePointer(gpoint2);
-    return this;
-  }
-  /** Draw a circular arc through a via-point to an end point, both given as relative distances. */
-  threePointsArc(xDist, yDist, viaXDist, viaYDist) {
-    const [px, py] = planeToLocal(this.plane, this.pointer);
-    return this.threePointsArcTo([px + xDist, py + yDist], [px + viaXDist, py + viaYDist]);
-  }
-  /** Draw a circular arc tangent to the previous edge, ending at an absolute point. */
-  tangentArcTo(end) {
-    const endPoint = planeToWorld(this.plane, end);
-    const previousEdge = this.pendingEdges.length ? this.pendingEdges[this.pendingEdges.length - 1] : null;
-    if (!previousEdge)
-      bug("Sketcher.tangentArcTo", "You need a previous edge to create a tangent arc");
-    const prevEnd = curveEndPoint(previousEdge);
-    const prevTangent = curveTangentAt(previousEdge, 1);
-    this.pendingEdges.push(makeTangentArc(prevEnd, prevTangent, endPoint));
-    this._updatePointer(endPoint);
-    return this;
-  }
-  /** Draw a circular arc tangent to the previous edge, ending at a relative offset. */
-  tangentArc(xDist, yDist) {
-    const [px, py] = planeToLocal(this.plane, this.pointer);
-    return this.tangentArcTo([xDist + px, yDist + py]);
-  }
-  /** Draw a circular arc to an absolute end point, bulging by the given sagitta. */
+    this.pendingCurves = [];
+  }
+  /**
+   * Override to preserve the original Sketcher's sagitta direction convention.
+   *
+   * BaseSketcher2d computes the perpendicular as `[-dy, dx]` (counter-clockwise rotation),
+   * but the original Sketcher used `cross(diff, plane.zDir)` which produces `[dy, -dx]`
+   * (clockwise rotation) for standard planes. Negating the sagitta compensates for this,
+   * ensuring all sagitta/bulge arcs curve the same way as the original 3D implementation.
+   */
   sagittaArcTo(end, sagitta) {
-    const startPoint = this.pointer;
-    const endPoint = planeToWorld(this.plane, end);
-    const sum = vecAdd(endPoint, startPoint);
-    const midPoint = vecScale(sum, 0.5);
-    const diff = vecSub(endPoint, startPoint);
-    const crossResult = vecCross(diff, this.plane.zDir);
-    const sagDirection = vecNormalize(crossResult);
-    const sagVector = vecScale(sagDirection, sagitta);
-    const sagPoint = vecAdd(midPoint, sagVector);
-    this.pendingEdges.push(makeThreePointArc(this.pointer, sagPoint, endPoint));
-    this._updatePointer(endPoint);
-    return this;
-  }
-  /** Draw a circular arc to a relative end point, bulging by the given sagitta. */
-  sagittaArc(xDist, yDist, sagitta) {
-    const [px, py] = planeToLocal(this.plane, this.pointer);
-    return this.sagittaArcTo([xDist + px, yDist + py], sagitta);
-  }
-  /** Draw a vertical sagitta arc of the given distance and bulge. */
-  vSagittaArc(distance, sagitta) {
-    return this.sagittaArc(0, distance, sagitta);
-  }
-  /** Draw a horizontal sagitta arc of the given distance and bulge. */
-  hSagittaArc(distance, sagitta) {
-    return this.sagittaArc(distance, 0, sagitta);
-  }
-  /** Draw an arc to an absolute end point using a bulge factor (sagitta as fraction of half-chord). */
-  bulgeArcTo(end, bulge) {
-    if (!bulge) return this.lineTo(end);
-    const [px, py] = planeToLocal(this.plane, this.pointer);
-    const halfChord = distance2d([px, py], end) / 2;
-    const bulgeAsSagitta = -bulge * halfChord;
-    return this.sagittaArcTo(end, bulgeAsSagitta);
-  }
-  /** Draw an arc to a relative end point using a bulge factor. */
-  bulgeArc(xDist, yDist, bulge) {
-    const [px, py] = planeToLocal(this.plane, this.pointer);
-    return this.bulgeArcTo([xDist + px, yDist + py], bulge);
-  }
-  /** Draw a vertical bulge arc of the given distance and bulge factor. */
-  vBulgeArc(distance, bulge) {
-    return this.bulgeArc(0, distance, bulge);
-  }
-  /** Draw a horizontal bulge arc of the given distance and bulge factor. */
-  hBulgeArc(distance, bulge) {
-    return this.bulgeArc(distance, 0, bulge);
-  }
-  /** Draw an elliptical arc to an absolute end point (SVG-style parameters). */
-  ellipseTo(end, horizontalRadius, verticalRadius, rotation = 0, longAxis = false, sweep = false) {
-    const [startX, startY] = planeToLocal(this.plane, this.pointer);
-    let rotationAngle = rotation;
-    let majorRadius = horizontalRadius;
-    let minorRadius = verticalRadius;
-    if (horizontalRadius < verticalRadius) {
-      rotationAngle = rotation + 90;
-      majorRadius = verticalRadius;
-      minorRadius = horizontalRadius;
-    }
-    const { cx, cy, rx, ry, startAngle, endAngle, clockwise } = convertSvgEllipseParams(
-      [startX, startY],
-      end,
-      majorRadius,
-      minorRadius,
-      rotationAngle * DEG2RAD,
-      longAxis,
-      sweep
-    );
-    const xDir = vecRotate(this.plane.xDir, this.plane.zDir, rotationAngle * DEG2RAD);
-    let arc = unwrap(
-      makeEllipseArc(
-        rx,
-        ry,
-        clockwise ? startAngle : endAngle,
-        clockwise ? endAngle : startAngle,
-        planeToWorld(this.plane, [cx, cy]),
-        this.plane.zDir,
-        xDir
-      )
-    );
-    if (!clockwise) {
-      arc = flipOrientation(arc);
-    }
-    this.pendingEdges.push(arc);
-    this._updatePointer(planeToWorld(this.plane, end));
-    return this;
-  }
-  /** Draw an elliptical arc to a relative end point (SVG-style parameters). */
-  ellipse(xDist, yDist, horizontalRadius, verticalRadius, rotation = 0, longAxis = false, sweep = false) {
-    const [px, py] = planeToLocal(this.plane, this.pointer);
-    return this.ellipseTo(
-      [xDist + px, yDist + py],
-      horizontalRadius,
-      verticalRadius,
-      rotation,
-      longAxis,
-      sweep
-    );
+    return super.sagittaArcTo(end, -sagitta);
   }
-  /** Draw a half-ellipse arc to an absolute end point with a given minor radius. */
-  halfEllipseTo(end, verticalRadius, sweep = false) {
-    const [px, py] = planeToLocal(this.plane, this.pointer);
-    const start = [px, py];
-    const angle = polarAngle2d(end, start);
-    const distance = distance2d(end, start);
-    return this.ellipseTo(end, distance / 2, verticalRadius, angle * RAD2DEG, false, sweep);
-  }
-  /** Draw a half-ellipse arc to a relative end point with a given minor radius. */
-  halfEllipse(xDist, yDist, verticalRadius, sweep = false) {
-    const [px, py] = planeToLocal(this.plane, this.pointer);
-    return this.halfEllipseTo([xDist + px, yDist + py], verticalRadius, sweep);
-  }
-  /** Draw a Bezier curve to an absolute end point through one or more control points. */
-  bezierCurveTo(end, controlPoints) {
-    let cp;
-    if (controlPoints.length === 2 && !Array.isArray(controlPoints[0])) {
-      cp = [controlPoints];
-    } else {
-      cp = controlPoints;
-    }
-    const inWorldPoints = cp.map((p) => planeToWorld(this.plane, p));
-    const endPoint = planeToWorld(this.plane, end);
-    this.pendingEdges.push(unwrap(makeBezierCurve([this.pointer, ...inWorldPoints, endPoint])));
-    this._updatePointer(endPoint);
-    return this;
-  }
-  /** Draw a quadratic Bezier curve to an absolute end point with a single control point. */
-  quadraticBezierCurveTo(end, controlPoint) {
-    return this.bezierCurveTo(end, [controlPoint]);
-  }
-  /** Draw a cubic Bezier curve to an absolute end point with start and end control points. */
-  cubicBezierCurveTo(end, startControlPoint, endControlPoint) {
-    return this.bezierCurveTo(end, [startControlPoint, endControlPoint]);
-  }
-  /** Draw a smooth cubic Bezier spline to an absolute end point, blending tangent with the previous edge. */
-  smoothSplineTo(end, config) {
+  buildWire() {
     var _stack = [];
     try {
-      const _scope = __using(_stack, new DisposalScope());
-      const { endTangent, startTangent, startFactor, endFactor } = defaultsSplineOptions(config);
-      const endPoint = planeToWorld(this.plane, end);
-      const previousEdge = this.pendingEdges.length ? this.pendingEdges[this.pendingEdges.length - 1] : null;
-      const diff = vecSub(endPoint, this.pointer);
-      const defaultDistance = vecLength(diff) * 0.25;
-      let startPoleDirection;
-      if (startTangent) {
-        startPoleDirection = planeToWorld(this.plane, startTangent);
-      } else if (!previousEdge) {
-        startPoleDirection = planeToWorld(this.plane, [1, 0]);
-      } else if (getCurveType(previousEdge) === "BEZIER_CURVE") {
-        const previousPole = getKernel().getBezierPenultimatePole(previousEdge.wrapped);
-        if (previousPole) {
-          startPoleDirection = vecSub(this.pointer, previousPole);
-        } else {
-          startPoleDirection = curveTangentAt(previousEdge, 1);
-        }
-      } else {
-        startPoleDirection = curveTangentAt(previousEdge, 1);
-      }
-      const poleDistance = vecScale(vecNormalize(startPoleDirection), startFactor * defaultDistance);
-      const startControl = vecAdd(this.pointer, poleDistance);
-      let endPoleDirection;
-      if (endTangent === "symmetric") {
-        endPoleDirection = vecScale(startPoleDirection, -1);
-      } else {
-        endPoleDirection = planeToWorld(this.plane, endTangent);
-      }
-      const endPoleDistance = vecScale(vecNormalize(endPoleDirection), endFactor * defaultDistance);
-      const endControl = vecSub(endPoint, endPoleDistance);
-      this.pendingEdges.push(
-        unwrap(makeBezierCurve([this.pointer, startControl, endControl, endPoint]))
+      if (!this.pendingCurves.length) bug("Sketcher.buildWire", "No lines to convert into a wire");
+      const scope = __using(_stack, new DisposalScope());
+      const edges = curvesAsEdgesOnPlane(this.pendingCurves, this.plane).map(
+        (e) => scope.register(e)
       );
-      this._updatePointer(endPoint);
-      return this;
+      return unwrap(assembleWire(edges));
     } catch (_) {
       var _error = _, _hasError = true;
     } finally {
       __callDispose(_stack, _error, _hasError);
     }
   }
-  /** Draw a smooth cubic Bezier spline to a relative end point, blending tangent with the previous edge. */
-  smoothSpline(xDist, yDist, splineConfig = {}) {
-    const [px, py] = planeToLocal(this.plane, this.pointer);
-    return this.smoothSplineTo([xDist + px, yDist + py], splineConfig);
+  /** Finish drawing and return the open-wire Sketch (does not close the path). */
+  done() {
+    return new Sketch(this.buildWire(), {
+      defaultOrigin: this.plane.origin,
+      defaultDirection: this.plane.zDir
+    });
+  }
+  /** Close the path with a straight line to the start point and return the Sketch. */
+  close() {
+    this._closeSketch();
+    return this.done();
   }
-  _mirrorWireOnStartEnd(wire) {
-    const diff = vecSub(this.pointer, this.firstPoint);
+  /**
+   * Close the path by mirroring all edges about the line from first to last point.
+   *
+   * Mirrors in 3D after assembling the partial wire to ensure exact endpoint
+   * matching across kernels.
+   */
+  closeWithMirror() {
+    if (samePoint$1(this.pointer, this.firstPoint))
+      bug(
+        "Sketcher.closeWithMirror",
+        "Cannot close with a mirror when the sketch is already closed"
+      );
+    const wire = this.buildWire();
+    const pointer3d = planeToWorld(this.plane, this.pointer);
+    const firstPoint3d = planeToWorld(this.plane, this.firstPoint);
+    const diff = vecSub(pointer3d, firstPoint3d);
     const startToEndVector = vecNormalize(diff);
     const normal = vecCross(startToEndVector, this.plane.zDir);
     const clonedWrapped = unwrap(downcast(wire.wrapped));
-    const mirroredRaw = mirror(clonedWrapped, normal, this.pointer);
+    const mirroredRaw = mirror(clonedWrapped, normal, pointer3d);
     const mirroredWrapped = unwrap(downcast(mirroredRaw));
     const mirroredWire = createWire(mirroredWrapped);
     const combinedWire = unwrap(assembleWire([wire, mirroredWire]));
-    return combinedWire;
-  }
-  buildWire() {
-    if (!this.pendingEdges.length) bug("Sketcher.buildWire", "No lines to convert into a wire");
-    let wire = unwrap(assembleWire(this.pendingEdges));
-    if (this._mirrorWire) {
-      wire = this._mirrorWireOnStartEnd(wire);
-    }
-    return wire;
-  }
-  _closeSketch() {
-    if (!vecEquals(this.pointer, this.firstPoint) && !this._mirrorWire) {
-      const [endX, endY] = planeToLocal(this.plane, this.firstPoint);
-      this.lineTo([endX, endY]);
-    }
-  }
-  /** Finish drawing and return the open-wire Sketch (does not close the path). */
-  done() {
-    const sketch = new Sketch(this.buildWire(), {
+    return new Sketch(combinedWire, {
       defaultOrigin: this.plane.origin,
       defaultDirection: this.plane.zDir
     });
-    return sketch;
   }
-  /** Close the path with a straight line to the start point and return the Sketch. */
-  close() {
+  /**
+   * Close the path and apply a custom corner treatment between the last and first segments.
+   *
+   * @param radius - Fillet/chamfer radius, or a custom corner function.
+   * @param mode - Corner treatment type.
+   * @returns The closed {@link Sketch}.
+   */
+  closeWithCustomCorner(radius, mode = "fillet") {
     this._closeSketch();
+    this._customCornerLastWithFirst(radius, mode);
     return this.done();
   }
-  /** Close the path by mirroring all edges about the line from first to last point. */
-  closeWithMirror() {
-    this._mirrorWire = true;
-    return this.close();
-  }
 }
 const guessFaceFromWires = (wires) => {
   const wireShapes = wires.map((w) => w.wrapped);