brepjs 18.6.0 → 18.14.3

package/dist/{boolean2D-JvgjbESt.js → blueprintSketcher-xDsl9GXO.js}

@@ -1,16 +1,10 @@
-import { R as DisposalScope, X as getKernel, Y as _usingCtx, Z as getKernel2D, a as createEdge, h as isShape3D, o as createFace, t as castShape, u as createWire } from "./shapeTypes-CN0GUoHr.js";
-import { A as ok, R as unwrap, T as isOk, b as err, d as validationError, h as bug, i as kernelError, l as typeCastError, n as computationError, s as safeIndex } from "./errors-DboJwVCf.js";
-import { N as downcast, c as normalAt, p as uvBounds, u as pointOnSurface } from "./faceFns-NbWd8-iR.js";
-import { r as RAD2DEG, t as DEG2RAD } from "./constants-csSEYddm.js";
-import { r as toVec3 } from "./types--GD-LVc6.js";
-import { d as vecNormalize, h as vecScale, r as vecCross } from "./vecOps-B-PCHgyB.js";
-import { n as createPlane } from "./planeOps-sTrM3dcQ.js";
-import { c as curveStartPoint, l as curveTangentAt, r as curveIsClosed } from "./curveFns-DhqUp0EI.js";
-import { r as lastOrThrow, t as firstOrThrow } from "./arrayAccess-tCIbjLs5.js";
-import { _ as zip, i as makeNewFaceWithinFace, r as makeFace, s as assembleWire } from "./surfaceBuilders-BVH2SL-z.js";
-import { _ as samePoint$1, b as subtract2d, d as cartesianToPolar, f as crossProduct2d, g as rotate2d, h as polarToCartesian, l as add2d, m as polarAngle2d, o as normalize2d, p as distance2d, s as PRECISION_INTERSECTION, v as scalarMultiply2d } from "./helpers-S_Ht6gwX.js";
-import { _ as Curve2D, b as removeDuplicatePoints, c as make2dCircle, f as make2dSegmentCurve, h as approximateAsBSpline, m as make2dThreePointArc, n as asSVG, o as make2dArcFromCenter, p as make2dTangentArc, r as viewbox, s as make2dBezierCurve, t as Blueprint, u as make2dEllipseArc, x as isPoint2D, y as BoundingBox2d } from "./blueprint-BCoJbaQN.js";
-import { c as sweep, i as complexExtrude, l as twistExtrude, r as revolve, t as extrude } from "./extrudeFns-B9bVCt3C.js";
+import { X as getKernel, Z as getKernel2D } from "./shapeTypes-C--1jaT1.js";
+import { n as wasmIndex } from "./vec3-BRj3eI54.js";
+import { A as ok, R as unwrap, T as isOk, b as err, h as bug, n as computationError, s as safeIndex } from "./errors-0fYW_YnO.js";
+import { r as RAD2DEG, t as DEG2RAD } from "./constants-Ci5CA3aZ.js";
+import { t as firstOrThrow } from "./arrayAccess-C5IWcxs9.js";
+import { _ as samePoint, b as subtract2d, d as cartesianToPolar, f as crossProduct2d, g as rotate2d, h as polarToCartesian, l as add2d, m as polarAngle2d, o as normalize2d, p as distance2d, v as scalarMultiply2d } from "./helpers-vV2ONZwD.js";
+import { _ as Curve2D, c as make2dCircle, f as make2dSegmentCurve, h as approximateAsBSpline, m as make2dThreePointArc, n as asSVG, o as make2dArcFromCenter, p as make2dTangentArc, r as viewbox, s as make2dBezierCurve, t as Blueprint, u as make2dEllipseArc, x as isPoint2D, y as BoundingBox2d } from "./blueprint-Dv45Evnu.js";
 //#region node_modules/flatqueue/index.js
 /** @template T */
 var FlatQueue = class {
@@ -492,10 +486,10 @@ var intersectCurves = (first, second, precision = 1e-9) => {
 	} catch (e) {
 		return err(computationError("INTERSECTION_FAILED", "Intersections failed between curves", e));
 	}
-	const segmentsAsPoints = commonSegments.filter((c) => samePoint$1(c.firstPoint, c.lastPoint, precision)).map((c) => c.firstPoint);
+	const segmentsAsPoints = commonSegments.filter((c) => samePoint(c.firstPoint, c.lastPoint, precision)).map((c) => c.firstPoint);
 	if (segmentsAsPoints.length) {
 		intersections.push(...segmentsAsPoints);
-		commonSegments = commonSegments.filter((c) => !samePoint$1(c.firstPoint, c.lastPoint, precision));
+		commonSegments = commonSegments.filter((c) => !samePoint(c.firstPoint, c.lastPoint, precision));
 	}
 	const commonSegmentsPoints = commonSegments.flatMap((c) => [c.firstPoint, c.lastPoint]);
 	return ok({
@@ -526,7 +520,7 @@ var selfIntersections = (curve, precision = 1e-9) => {
 var offsetEndPoints = (firstPoint, lastPoint, offset) => {
 	const tangent = normalize2d(subtract2d(lastPoint, firstPoint));
 	const normal = [tangent[1], -tangent[0]];
-	const offsetVec = [normal[0] * offset, normal[1] * offset];
+	const offsetVec = [wasmIndex(normal, 0) * offset, wasmIndex(normal, 1) * offset];
 	return {
 		firstPoint: add2d(firstPoint, offsetVec),
 		lastPoint: add2d(lastPoint, offsetVec)
@@ -623,11 +617,11 @@ function removeCorner(firstCurve, secondCurve, radius) {
 		const splitParam = unwrap(curve.parameter(splitPoint, 1e-6));
 		return curve.splitAt([splitParam]);
 	};
-	const [first] = splitForFillet(firstCurve, firstOffset);
-	const [, second] = splitForFillet(secondCurve, secondOffset);
+	const firstSplit = splitForFillet(firstCurve, firstOffset);
+	const secondSplit = splitForFillet(secondCurve, secondOffset);
 	return {
-		first,
-		second,
+		first: wasmIndex(firstSplit, 0),
+		second: wasmIndex(secondSplit, 1),
 		center
 	};
 }
@@ -692,8 +686,10 @@ function dogboneFilletCurves(firstCurve, secondCurve, radius) {
 	const firstInt = unwrap(intersectCurves(firstCurve, circle)).intersections[0];
 	const secondInt = unwrap(intersectCurves(secondCurve, circle)).intersections.at(-1);
 	if (!firstInt || !secondInt) return [firstCurve, secondCurve];
-	const firstPart = firstCurve.splitAt([firstInt])[0];
-	const secondPart = secondCurve.splitAt([secondInt]).at(-1);
+	const firstSplit = firstCurve.splitAt([firstInt]);
+	const secondSplit = secondCurve.splitAt([secondInt]);
+	const firstPart = wasmIndex(firstSplit, 0);
+	const secondPart = wasmIndex(secondSplit, secondSplit.length - 1);
 	try {
 		return [
 			firstPart,
@@ -994,278 +990,7 @@ var organiseBlueprints = (blueprints) => {
 	}));
 };
 //#endregion
-//#region src/operations/loftFns.ts
-/**
-* Functional loft operation using branded shape types.
-*/
-/**
-* Loft through a set of wire profiles to create a 3D shape.
-*
-* Builds a `BRepOffsetAPI_ThruSections` surface through the given wires,
-* optionally starting and/or ending at point vertices. Produces a solid
-* by default, or a shell when `returnShell` is `true`.
-*
-* @param wires - Ordered wire profiles to loft through.
-* @param config - Loft configuration (ruled interpolation, start/end points).
-* @param returnShell - When `true`, return a shell instead of a solid.
-* @returns `Result` containing the lofted 3D shape, or an error on failure.
-*
-* @example
-* ```ts
-* const result = loft([bottomWire, topWire], { ruled: false });
-* ```
-*
-* @see {@link loft!loft | loft} for the OOP API equivalent.
-*/
-function loft(wires, { ruled = true, startPoint, endPoint, tolerance = 1e-6 } = {}, returnShell = false) {
-	if (wires.length === 0 && !startPoint && !endPoint) return err(validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
-	const kernel = getKernel();
-	const startVertex = startPoint ? kernel.makeVertex(...toVec3(startPoint)) : void 0;
-	const endVertex = endPoint ? kernel.makeVertex(...toVec3(endPoint)) : void 0;
-	try {
-		const result = castShape(kernel.loftAdvanced(wires.map((w) => w.wrapped), {
-			solid: !returnShell,
-			ruled,
-			tolerance,
-			...startVertex ? { startVertex } : {},
-			...endVertex ? { endVertex } : {}
-		}));
-		if (!isShape3D(result)) return err(typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
-		return ok(result);
-	} catch (e) {
-		return err(kernelError("LOFT_FAILED", "Loft operation failed", e, void 0, "Common causes: wire profiles with different edge counts, self-intersecting result, or profiles too far apart. Ensure profiles are compatible and ordered."));
-	}
-}
-/**
-* Batch loft: build N independent lofts in a single kernel call.
-*
-* Uses the C++ LoftBatch extractor when available (single WASM call),
-* falling back to N individual loft operations otherwise.
-*
-* @returns Array of 3D shapes, one per entry.
-*/
-function loftAll(entries) {
-	if (entries.length === 0) return ok([]);
-	const kernel = getKernel();
-	const verticesToDelete = [];
-	const kernelEntries = entries.map((e) => {
-		const startVertex = e.startPoint ? kernel.makeVertex(...toVec3(e.startPoint)) : void 0;
-		const endVertex = e.endPoint ? kernel.makeVertex(...toVec3(e.endPoint)) : void 0;
-		if (startVertex) verticesToDelete.push(startVertex);
-		if (endVertex) verticesToDelete.push(endVertex);
-		return {
-			wires: e.wires.map((w) => w.wrapped),
-			solid: true,
-			ruled: e.ruled ?? true,
-			tolerance: e.tolerance ?? 1e-6,
-			startVertex,
-			endVertex
-		};
-	});
-	try {
-		const shapes = kernel.loftBatch?.(kernelEntries) ?? kernelEntries.map((e) => kernel.loftAdvanced(e.wires, {
-			solid: e.solid,
-			ruled: e.ruled,
-			tolerance: e.tolerance,
-			startVertex: e.startVertex,
-			endVertex: e.endVertex
-		}));
-		const results = [];
-		for (const shape of shapes) {
-			const cast = castShape(shape);
-			if (!isShape3D(cast)) return err(typeCastError("LOFT_ALL_NOT_3D", "Batch loft entry did not produce a 3D shape"));
-			results.push(cast);
-		}
-		return ok(results);
-	} catch (e) {
-		return err(kernelError("LOFT_ALL_FAILED", "Batch loft operation failed", e));
-	} finally {
-		for (const v of verticesToDelete) kernel.dispose(v);
-	}
-}
-//#endregion
-//#region src/sketching/sketch.ts
-/**
-* Represent a closed or open wire profile with a default extrusion origin and direction.
-*
-* A Sketch wraps a single {@link Wire} and carries metadata (origin, direction,
-* optional base face) so that downstream operations like {@link Sketch.extrude},
-* {@link Sketch.revolve}, {@link Sketch.sweepSketch}, and {@link Sketch.loftWith}
-* know how to act on it without extra arguments.
-*
-* @remarks Most operations consume (delete) the sketch after producing a solid.
-*
-* @see {@link Sketcher} to build a Sketch interactively.
-* @see {@link CompoundSketch} for multi-wire (outer + holes) profiles.
-* @category Sketching
-*/
-var Sketch = class Sketch {
-	wire;
-	/**
-	* @ignore
-	*/
-	_defaultOrigin;
-	/**
-	* @ignore
-	*/
-	_defaultDirection;
-	_baseFace;
-	constructor(wire, { defaultOrigin = [
-		0,
-		0,
-		0
-	], defaultDirection = [
-		0,
-		0,
-		1
-	] } = {}) {
-		this.wire = wire;
-		this._defaultOrigin = toVec3(defaultOrigin);
-		this._defaultDirection = toVec3(defaultDirection);
-		this.baseFace = null;
-	}
-	get baseFace() {
-		return this._baseFace;
-	}
-	set baseFace(newFace) {
-		if (this._baseFace) this._baseFace.delete();
-		this._baseFace = newFace ? createFace(unwrap(downcast(newFace.wrapped))) : newFace;
-	}
-	/** Release all kernel resources held by this sketch. */
-	delete() {
-		this.wire.delete();
-		if (this.baseFace) this.baseFace.delete();
-	}
-	/** Create an independent deep copy of this sketch. */
-	clone() {
-		const sketch = new Sketch(createWire(unwrap(downcast(this.wire.wrapped))), {
-			defaultOrigin: this.defaultOrigin,
-			defaultDirection: this.defaultDirection
-		});
-		if (this.baseFace) sketch.baseFace = createFace(unwrap(downcast(this.baseFace.wrapped)));
-		return sketch;
-	}
-	/** Get the 3D origin used as default for extrusion and revolution. */
-	get defaultOrigin() {
-		return this._defaultOrigin;
-	}
-	/** Set the 3D origin used as default for extrusion and revolution. */
-	set defaultOrigin(newOrigin) {
-		this._defaultOrigin = toVec3(newOrigin);
-	}
-	/** Get the default extrusion/normal direction. */
-	get defaultDirection() {
-		return this._defaultDirection;
-	}
-	/** Set the default extrusion/normal direction. */
-	set defaultDirection(newDirection) {
-		this._defaultDirection = toVec3(newDirection);
-	}
-	/**
-	* Transforms the lines into a face. The lines should be closed.
-	*/
-	face() {
-		let face;
-		const closedWire = this.wire;
-		if (!this.baseFace) face = unwrap(makeFace(closedWire));
-		else face = makeNewFaceWithinFace(this.baseFace, closedWire);
-		return face;
-	}
-	/** Return a clone of the underlying wire. */
-	wires() {
-		return createWire(unwrap(downcast(this.wire.wrapped)));
-	}
-	/** Alias for {@link Sketch.face}. */
-	faces() {
-		return this.face();
-	}
-	/**
-	* Revolves the drawing on an axis (defined by its direction and an origin
-	* (defaults to the sketch origin)
-	*/
-	revolve(revolutionAxis, { origin } = {}) {
-		const face = unwrap(makeFace(this.wire));
-		const solid = unwrap(revolve(face, origin ? toVec3(origin) : this.defaultOrigin, revolutionAxis ? toVec3(revolutionAxis) : [
-			0,
-			0,
-			1
-		]));
-		face.delete();
-		this.delete();
-		return solid;
-	}
-	/** Extrudes the sketch to a certain distance (along the default direction
-	* and origin of the sketch).
-	*
-	* You can define another extrusion direction or origin,
-	*
-	* It is also possible to twist extrude with an angle (in degrees), or to
-	* give a profile to the extrusion (the endFactor will scale the face, and
-	* the profile will define how the scale is applied (either linearly or with
-	* a s-shape).
-	*/
-	extrude(extrusionDistance, { extrusionDirection, extrusionProfile, twistAngle, origin } = {}) {
-		const extrusionVec = vecScale(vecNormalize(extrusionDirection ? toVec3(extrusionDirection) : this.defaultDirection), extrusionDistance);
-		const originVec = origin ? toVec3(origin) : this.defaultOrigin;
-		if (extrusionProfile && !twistAngle) {
-			const solid = unwrap(complexExtrude(this.wire, [...originVec], [...extrusionVec], extrusionProfile));
-			this.delete();
-			return solid;
-		}
-		if (twistAngle) {
-			const solid = unwrap(twistExtrude(this.wire, twistAngle, [...originVec], [...extrusionVec], extrusionProfile));
-			this.delete();
-			return solid;
-		}
-		const solid = unwrap(extrude(unwrap(makeFace(this.wire)), [...extrusionVec]));
-		this.delete();
-		return solid;
-	}
-	/**
-	* Sweep along this sketch another sketch defined in the function
-	* `sketchOnPlane`.
-	*/
-	sweepSketch(sketchOnPlane, sweepConfig = {}) {
-		const startPoint = curveStartPoint(this.wire);
-		const normal = vecNormalize(vecScale(curveTangentAt(this.wire, 1e-9), -1));
-		const defaultDir = this.defaultDirection;
-		const xDir = vecScale(vecCross(normal, defaultDir), -1);
-		const result = sketchOnPlane(createPlane([...startPoint], [...xDir], [...normal]), [...startPoint]);
-		let sketch;
-		if ("sketches" in result && Array.isArray(result.sketches)) {
-			const pieces = result.sketches;
-			sketch = pieces[0];
-			for (let i = 1; i < pieces.length; i++) pieces[i]?.delete();
-		} else sketch = result;
-		const config = {
-			forceProfileSpineOthogonality: true,
-			...sweepConfig
-		};
-		if (this.baseFace) config.support = this.baseFace.wrapped;
-		const shape = unwrap(sweep(sketch.wire, this.wire, config));
-		this.delete();
-		return shape;
-	}
-	/** Loft between this sketch and another sketch (or an array of them)
-	*
-	* You can also define a `startPoint` for the loft (that will be placed
-	* before this sketch) and an `endPoint` after the last one.
-	*
-	* You can also define if you want the loft to result in a ruled surface.
-	*
-	* Note that all sketches will be deleted by this operation
-	*/
-	loftWith(otherSketches, loftConfig = {}, returnShell = false) {
-		const sketchArray = Array.isArray(otherSketches) ? [this, ...otherSketches] : [this, otherSketches];
-		const shape = unwrap(loft(sketchArray.map((s) => s.wire), loftConfig, returnShell));
-		sketchArray.forEach((s) => {
-			s.delete();
-		});
-		return shape;
-	}
-};
-//#endregion
-//#region src/sketching/sketcherlib.ts
+//#region src/2d/blueprints/genericSketcher.ts
 var isTangent = (c) => c === "symmetric" || typeof c === "number" || Array.isArray(c) && c.length === 2;
 /** Resolve a {@link SplineOptions} into fully-expanded tangent directions and factors. */
 var defaultsSplineOptions = (config) => {
@@ -1290,6 +1015,49 @@ var defaultsSplineOptions = (config) => {
 		startTangent
 	};
 };
+//#endregion
+//#region src/2d/blueprints/ellipseUtils.ts
+/**
+* Normalize ellipse radii so that major >= minor, adjusting the rotation
+* angle by 90 degrees when the radii need to be swapped.
+*/
+function normalizeEllipseRadii(horizontalRadius, verticalRadius, rotation) {
+	if (horizontalRadius < verticalRadius) return {
+		majorRadius: verticalRadius,
+		minorRadius: horizontalRadius,
+		rotationAngle: rotation + 90
+	};
+	return {
+		majorRadius: horizontalRadius,
+		minorRadius: verticalRadius,
+		rotationAngle: rotation
+	};
+}
+/**
+* Build a 2D elliptical arc curve from SVG-style endpoint parameters,
+* applying the UV coordinate conversions used by {@link BaseSketcher2d}.
+*
+* @param startUV - Start point in UV space.
+* @param endUV - End point in UV space.
+* @param majorRadius - Major radius (already normalized so major >= minor).
+* @param minorRadius - Minor radius.
+* @param rotationAngleDeg - Rotation of the ellipse in degrees.
+* @param longAxis - SVG large-arc flag.
+* @param sweep - SVG sweep flag.
+* @param convertToUV - Coordinate conversion function from user space to UV space.
+*/
+function makeEllipseArcFromSvgParams(startUV, endUV, majorRadius, minorRadius, rotationAngleDeg, longAxis, sweep, convertToUV) {
+	const radRotationAngle = rotationAngleDeg * DEG2RAD;
+	const convertAxis = (ax) => distance2d(convertToUV(ax));
+	const r1 = convertAxis(polarToCartesian(majorRadius, radRotationAngle));
+	const r2 = convertAxis(polarToCartesian(minorRadius, radRotationAngle + Math.PI / 2));
+	const xDir = normalize2d(convertToUV(rotate2d([1, 0], radRotationAngle)));
+	const [, newRotationAngle] = cartesianToPolar(xDir);
+	const { cx, cy, startAngle, endAngle, clockwise, rx, ry } = convertSvgEllipseParams(startUV, endUV, r1, r2, newRotationAngle, longAxis, sweep);
+	const arc = make2dEllipseArc(rx, ry, clockwise ? startAngle : endAngle, clockwise ? endAngle : startAngle, [cx, cy], xDir);
+	if (!clockwise) arc.reverse();
+	return arc;
+}
 /**
 * Compute start/delta/end angles from the unit-circle parameterization
 * of an SVG elliptical arc (F6.5.5–F6.5.6).
@@ -1369,50 +1137,7 @@ function convertSvgEllipseParams([x1, y1], [x2, y2], rx, ry, phi, fA, fS) {
 	};
 }
 //#endregion
-//#region src/sketching/ellipseUtils.ts
-/**
-* Normalize ellipse radii so that major >= minor, adjusting the rotation
-* angle by 90 degrees when the radii need to be swapped.
-*/
-function normalizeEllipseRadii(horizontalRadius, verticalRadius, rotation) {
-	if (horizontalRadius < verticalRadius) return {
-		majorRadius: verticalRadius,
-		minorRadius: horizontalRadius,
-		rotationAngle: rotation + 90
-	};
-	return {
-		majorRadius: horizontalRadius,
-		minorRadius: verticalRadius,
-		rotationAngle: rotation
-	};
-}
-/**
-* Build a 2D elliptical arc curve from SVG-style endpoint parameters,
-* applying the UV coordinate conversions used by {@link BaseSketcher2d}.
-*
-* @param startUV - Start point in UV space.
-* @param endUV - End point in UV space.
-* @param majorRadius - Major radius (already normalized so major >= minor).
-* @param minorRadius - Minor radius.
-* @param rotationAngleDeg - Rotation of the ellipse in degrees.
-* @param longAxis - SVG large-arc flag.
-* @param sweep - SVG sweep flag.
-* @param convertToUV - Coordinate conversion function from user space to UV space.
-*/
-function makeEllipseArcFromSvgParams(startUV, endUV, majorRadius, minorRadius, rotationAngleDeg, longAxis, sweep, convertToUV) {
-	const radRotationAngle = rotationAngleDeg * DEG2RAD;
-	const convertAxis = (ax) => distance2d(convertToUV(ax));
-	const r1 = convertAxis(polarToCartesian(majorRadius, radRotationAngle));
-	const r2 = convertAxis(polarToCartesian(minorRadius, radRotationAngle + Math.PI / 2));
-	const xDir = normalize2d(convertToUV(rotate2d([1, 0], radRotationAngle)));
-	const [, newRotationAngle] = cartesianToPolar(xDir);
-	const { cx, cy, startAngle, endAngle, clockwise, rx, ry } = convertSvgEllipseParams(startUV, endUV, r1, r2, newRotationAngle, longAxis, sweep);
-	const arc = make2dEllipseArc(rx, ry, clockwise ? startAngle : endAngle, clockwise ? endAngle : startAngle, [cx, cy], xDir);
-	if (!clockwise) arc.reverse();
-	return arc;
-}
-//#endregion
-//#region src/sketching/sketcher2d.ts
+//#region src/2d/blueprints/baseSketcher2d.ts
 var cornerModeFns = {
 	chamfer: chamferCurves,
 	dogbone: dogboneFilletCurves,
@@ -1427,7 +1152,7 @@ function buildCornerFunction(radius, mode) {
 * Base class for 2D sketchers that accumulate {@link Curve2D} segments.
 *
 * Provides the shared pen-drawing API (lines, arcs, ellipses, beziers, splines)
-* used by {@link FaceSketcher}, {@link BlueprintSketcher}, and {@link DrawingPen}.
+* used by `FaceSketcher`, `BlueprintSketcher`, and `DrawingPen`.
 * Subclasses implement `done()` / `close()` to produce the appropriate output type.
 *
 * @category Sketching
@@ -1449,23 +1174,19 @@ var BaseSketcher2d = class {
 	_convertFromUV([u, v]) {
 		return [u, v];
 	}
-	/** Return the last curve in the pending list, or null if empty. */
 	_lastCurve() {
 		const len = this.pendingCurves.length;
 		if (len === 0) return null;
 		return this.pendingCurves[len - 1];
 	}
-	/** Require that a previous curve exists, returning it or throwing. */
 	_requireLastCurve(caller, action) {
 		const curve = this._lastCurve();
 		if (!curve) bug(caller, `You need a previous curve to ${action}`);
 		return curve;
 	}
-	/** Resolve a relative offset from the current pointer position. */
 	_resolveRelative(xDist, yDist) {
 		return [this.pointer[0] + xDist, this.pointer[1] + yDist];
 	}
-	/** Save a curve, advance the pointer to the given end point, and return `this`. */
 	_saveCurveAndAdvance(curve, end) {
 		this.saveCurve(curve);
 		this.pointer = end;
@@ -1482,10 +1203,6 @@ var BaseSketcher2d = class {
 	/**
 	* Returns the current pen angle in degrees
 	*
-	* The angle represents the tangent direction at the current pen position,
-	* based on the last drawing operation (line, arc, bezier, etc.).
-	* Returns 0 if nothing has been drawn yet.
-	*
 	* @category Drawing State
 	*/
 	get penAngle() {
@@ -1671,9 +1388,7 @@ var BaseSketcher2d = class {
 	smoothSpline(xDist, yDist, splineConfig) {
 		return this.smoothSplineTo(this._resolveRelative(xDist, yDist), splineConfig);
 	}
-	/**
-	* Changes the corner between the previous and next segments.
-	*/
+	/** Changes the corner between the previous and next segments. */
 	customCorner(radius, mode = "fillet") {
 		if (!this.pendingCurves.length) bug("Sketcher2d.customCorner", "You need a curve defined to fillet the angle");
 		this._nextCorner = buildCornerFunction(radius, mode);
@@ -1687,10 +1402,10 @@ var BaseSketcher2d = class {
 		this.pendingCurves.push(...buildCornerFunction(radius, mode)(previousCurve, curve));
 	}
 	_closeSketch() {
-		if (!samePoint$1(this.pointer, this.firstPoint)) this.lineTo(this.firstPoint);
+		if (!samePoint(this.pointer, this.firstPoint)) this.lineTo(this.firstPoint);
 	}
 	_closeWithMirror() {
-		if (samePoint$1(this.pointer, this.firstPoint)) bug("Sketcher2d._closeWithMirror", "Cannot close with a mirror when the sketch is already closed");
+		if (samePoint(this.pointer, this.firstPoint)) bug("Sketcher2d._closeWithMirror", "Cannot close with a mirror when the sketch is already closed");
 		const startToEndVector = [this.pointer[0] - this.firstPoint[0], this.pointer[1] - this.firstPoint[1]];
 		const uvOrigin = this._convertToUV(this.pointer);
 		const uvDir = this._convertToUV(startToEndVector);
@@ -1701,127 +1416,14 @@ var BaseSketcher2d = class {
 		this.pointer = this.firstPoint;
 	}
 };
-/**
-* The FaceSketcher allows you to sketch on a face that is not planar, for
-* instance the sides of a cylinder.
-*
-* The coordinates passed to the methods corresponds to normalised distances on
-* this surface, between 0 and 1 in both direction.
-*
-* Note that if you are drawing on a closed surface (typically a revolution
-* surface or a cylinder), the first parameters represents the angle and can be
-* smaller than 0 or bigger than 1.
-*
-* @category Sketching
-*/
-var FaceSketcher = class extends BaseSketcher2d {
-	face;
-	_bounds;
-	constructor(face, origin = [0, 0]) {
-		super(origin);
-		this.face = createFace(unwrap(downcast(face.wrapped)));
-		this._bounds = uvBounds(face);
-	}
-	_convertToUV([x, y]) {
-		const { uMin, uMax, vMin, vMax } = this._bounds;
-		return [uMin + x * (uMax - uMin), vMin + y * (vMax - vMin)];
-	}
-	_convertFromUV([u, v]) {
-		const { uMin, uMax, vMin, vMax } = this._bounds;
-		return [(u - uMin) / (uMax - uMin), (v - vMin) / (vMax - vMin)];
-	}
-	_adaptSurface() {
-		return getKernel().extractSurfaceFromFace(this.face.wrapped);
-	}
-	/**
-	* @ignore
-	*/
-	buildWire() {
-		const kernel = getKernel();
-		const geomSurf = this._adaptSurface();
-		const wire = unwrap(assembleWire(this.pendingCurves.map((curve) => {
-			return createEdge(kernel.buildEdgeOnSurface(curve.wrapped, geomSurf));
-		})));
-		kernel.buildCurves3d(wire.wrapped);
-		return wire;
-	}
-	/** Finish drawing and return the resulting {@link Sketch} (does not close the path). */
-	done() {
-		try {
-			var _usingCtx$1 = _usingCtx();
-			const scope = _usingCtx$1.u(new DisposalScope());
-			const wire = this.buildWire();
-			const sketch = new Sketch(wire);
-			if (curveIsClosed(wire)) {
-				const face = scope.register(sketch.clone().face());
-				const origin = pointOnSurface(face, .5, .5);
-				const direction = vecScale(normalAt(face), -1);
-				sketch.defaultOrigin = [
-					origin[0],
-					origin[1],
-					origin[2]
-				];
-				sketch.defaultDirection = [
-					direction[0],
-					direction[1],
-					direction[2]
-				];
-			} else {
-				const startPoint = curveStartPoint(wire);
-				const normal = normalAt(this.face, [
-					startPoint[0],
-					startPoint[1],
-					startPoint[2]
-				]);
-				sketch.defaultOrigin = [
-					startPoint[0],
-					startPoint[1],
-					startPoint[2]
-				];
-				sketch.defaultDirection = [
-					normal[0],
-					normal[1],
-					normal[2]
-				];
-			}
-			sketch.baseFace = this.face;
-			return sketch;
-		} catch (_) {
-			_usingCtx$1.e = _;
-		} finally {
-			_usingCtx$1.d();
-		}
-	}
-	/** Close the path with a straight line to the start point and return the Sketch. */
-	close() {
-		this._closeSketch();
-		return this.done();
-	}
-	/** Close the path by mirroring all curves about the line from first to last point. */
-	closeWithMirror() {
-		this._closeWithMirror();
-		return this.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();
-	}
-};
+//#endregion
+//#region src/2d/blueprints/blueprintSketcher.ts
 /**
 * Draw 2D curves and produce a {@link Blueprint} (pure-2D shape, no kernel wire).
 *
 * Use this when you need a reusable 2D profile that can later be sketched onto
 * different planes or faces.
 *
-* @see {@link DrawingPen} for the higher-level Drawing wrapper.
 * @category Sketching
 */
 var BlueprintSketcher = class extends BaseSketcher2d {
@@ -1859,852 +1461,4 @@ var BlueprintSketcher = class extends BaseSketcher2d {
 	}
 };
 //#endregion
-//#region src/2d/blueprints/cannedBlueprints.ts
-/**
-* Create a regular polygon blueprint inscribed in a circle of the given radius.
-*
-* @param radius - Circumscribed circle radius.
-* @param sidesCount - Number of sides (3 = triangle, 6 = hexagon, etc.).
-* @param sagitta - When non-zero, sides are replaced by sagitta arcs (bulge height).
-* @returns A closed Blueprint representing the polygon.
-*
-* @example
-* ```ts
-* const hexagon = polysidesBlueprint(10, 6);
-* const roundedTriangle = polysidesBlueprint(10, 3, 2);
-* ```
-*/
-var polysidesBlueprint = (radius, sidesCount, sagitta = 0) => {
-	const points = [...Array(sidesCount).keys()].map((i) => {
-		const theta = -(Math.PI * 2 / sidesCount) * i;
-		return [radius * Math.sin(theta), radius * Math.cos(theta)];
-	});
-	const lastPoint = lastOrThrow(points);
-	const blueprint = new BlueprintSketcher().movePointerTo([lastPoint[0], lastPoint[1]]);
-	if (sagitta) points.forEach(([x, y]) => blueprint.sagittaArcTo([x, y], sagitta));
-	else points.forEach(([x, y]) => blueprint.lineTo([x, y]));
-	return blueprint.done();
-};
-/**
-* Create an axis-aligned rectangle blueprint with optional rounded corners.
-*
-* The rectangle is centered at the origin. When `r` is zero the corners
-* are sharp; otherwise they are filleted with circular or elliptical arcs.
-*
-* @param width - Total width of the rectangle.
-* @param height - Total height of the rectangle.
-* @param r - Corner radius. Pass a number for uniform rounding, or
-*   `{ rx, ry }` for elliptical corners. Clamped to half the respective
-*   dimension.
-* @returns A closed Blueprint representing the rectangle.
-*
-* @example
-* ```ts
-* const sharp = roundedRectangleBlueprint(20, 10);
-* const rounded = roundedRectangleBlueprint(20, 10, 3);
-* const elliptical = roundedRectangleBlueprint(20, 10, { rx: 4, ry: 2 });
-* ```
-*/
-var roundedRectangleBlueprint = (width, height, r = 0) => {
-	const { rx: inputRx = 0, ry: inputRy = 0 } = typeof r === "number" ? {
-		ry: r,
-		rx: r
-	} : r;
-	let rx = Math.min(inputRx, width / 2);
-	let ry = Math.min(inputRy, height / 2);
-	const withRadius = rx && ry;
-	if (!withRadius) {
-		rx = 0;
-		ry = 0;
-	}
-	const symmetricRadius = rx === ry;
-	const sk = new BlueprintSketcher([Math.min(0, -(width / 2 - rx)), -height / 2]);
-	const addFillet = (xDist, yDist) => {
-		if (withRadius) if (symmetricRadius) sk.tangentArc(xDist, yDist);
-		else sk.ellipse(xDist, yDist, rx, ry, 0, false, true);
-	};
-	if (rx < width / 2) sk.hLine(width - 2 * rx);
-	addFillet(rx, ry);
-	if (ry < height / 2) sk.vLine(height - 2 * ry);
-	addFillet(-rx, ry);
-	if (rx < width / 2) sk.hLine(-(width - 2 * rx));
-	addFillet(-rx, -ry);
-	if (ry < height / 2) sk.vLine(-(height - 2 * ry));
-	addFillet(rx, -ry);
-	return sk.close();
-};
-//#endregion
-//#region src/2d/blueprints/booleanHelpers.ts
-var samePoint = (x, y) => samePoint$1(x, y, PRECISION_INTERSECTION);
-/**
-* Hash a point for Set/Map lookup using precision rounding.
-* Must match PRECISION_INTERSECTION (1e-9) to avoid hash collisions for
-* nearly-equal points.
-*/
-function hashPoint(p) {
-	return `${p[0].toFixed(9)},${p[1].toFixed(9)}`;
-}
-/**
-* Hash a segment by both orientations for bidirectional lookup.
-* The smaller hash comes first so that (A,B) and (B,A) produce the same key.
-*/
-function hashSegment(first, last) {
-	const h1 = hashPoint(first);
-	const h2 = hashPoint(last);
-	return h1 < h2 ? `${h1}|${h2}` : `${h2}|${h1}`;
-}
-function startOfSegment(s) {
-	const first = s[0];
-	if (first === void 0) bug("startOfSegment", "empty segment");
-	return first.firstPoint;
-}
-function endOfSegment(s) {
-	const last = s[s.length - 1];
-	if (last === void 0) bug("endOfSegment", "empty segment");
-	return last.lastPoint;
-}
-function reverseSegment(segment) {
-	return [...segment].reverse().map((curve) => {
-		const newCurve = curve.clone();
-		newCurve.reverse();
-		return newCurve;
-	});
-}
-function reverseSegments(segments) {
-	return [...segments].reverse().map(reverseSegment);
-}
-function curveMidPoint(curve) {
-	const midParameter = (curve.lastParameter + curve.firstParameter) / 2;
-	return curve.value(midParameter);
-}
-/**
-* Find the index of the first curve in `curves` whose firstPoint matches
-* `point`. Uses hash for a fast first pass, then falls back to tolerance-only
-* comparison to handle floating-point rounding at `toFixed(9)` boundaries.
-* Returns -1 if no match is found.
-*/
-function findCurveIndexByStartPoint(curves, point) {
-	const targetHash = hashPoint(point);
-	for (let i = 0; i < curves.length; i++) {
-		const curve = curves[i];
-		if (curve === void 0) continue;
-		if (hashPoint(curve.firstPoint) === targetHash && samePoint(point, curve.firstPoint)) return i;
-	}
-	for (let i = 0; i < curves.length; i++) {
-		const curve = curves[i];
-		if (curve === void 0) continue;
-		if (samePoint(point, curve.firstPoint)) return i;
-	}
-	return -1;
-}
-/**
-* Find the index of the first curve in `curves` that matches the given
-* segment's start and end points. Uses hash for a fast first pass, then
-* falls back to tolerance-only comparison.
-* Returns -1 if no match is found.
-*/
-function findCurveIndexBySegment(curves, segFirstHash, segLastHash, matchesFn) {
-	for (let i = 0; i < curves.length; i++) {
-		const curve = curves[i];
-		if (curve === void 0) continue;
-		if (hashPoint(curve.firstPoint) === segFirstHash && hashPoint(curve.lastPoint) === segLastHash && matchesFn(curve)) return i;
-	}
-	for (let i = 0; i < curves.length; i++) {
-		const curve = curves[i];
-		if (curve === void 0) continue;
-		if (matchesFn(curve)) return i;
-	}
-	return -1;
-}
-/** Rotate an array so that element at `startIndex` becomes the first element. */
-function rotateArray(arr, startIndex) {
-	if (startIndex <= 0) return arr;
-	return arr.slice(startIndex).concat(arr.slice(0, startIndex));
-}
-/**
-* Rotate the curves array so that it starts at the curve whose firstPoint
-* matches the given point.
-*/
-function rotateToStartAt(curves, point) {
-	return rotateArray(curves, findCurveIndexByStartPoint(curves, point));
-}
-/**
-* Rotate the curves array so that it starts at the curve matching the given
-* segment. Tries both segment orientations (forward and flipped) against both
-* curve orientations (original and reversed chain) to handle cases where
-* `intersectCurves` returns a common segment oriented opposite to the
-* matching curve in the split result.
-*/
-function rotateToStartAtSegment(curves, segment) {
-	const segFirstHash = hashPoint(segment.firstPoint);
-	const segLastHash = hashPoint(segment.lastPoint);
-	const matchesForward = (curve) => samePoint(segment.firstPoint, curve.firstPoint) && samePoint(segment.lastPoint, curve.lastPoint);
-	const matchesFlipped = (curve) => samePoint(segment.lastPoint, curve.firstPoint) && samePoint(segment.firstPoint, curve.lastPoint);
-	function tryRotate(chain, firstHash, lastHash, matchFn) {
-		const idx = findCurveIndexBySegment(chain, firstHash, lastHash, matchFn);
-		return idx !== -1 ? rotateArray(chain, idx) : null;
-	}
-	const fwdFwd = tryRotate(curves, segFirstHash, segLastHash, matchesForward);
-	if (fwdFwd !== null) return fwdFwd;
-	const flipFwd = tryRotate(curves, segLastHash, segFirstHash, matchesFlipped);
-	if (flipFwd !== null) return flipFwd;
-	const reversed = reverseSegment(curves);
-	const fwdRev = tryRotate(reversed, segFirstHash, segLastHash, matchesForward);
-	if (fwdRev !== null) return fwdRev;
-	const flipRev = tryRotate(reversed, segLastHash, segFirstHash, matchesFlipped);
-	if (flipRev !== null) return flipRev;
-	bug("rotateToStartAtSegment", "failed to rotate to segment start");
-}
-//#endregion
-//#region src/2d/blueprints/intersectionSegments.ts
-function* createSegmentOnPoints(curves, allIntersections, allCommonSegments) {
-	const intersectionSet = new Set(allIntersections.map(hashPoint));
-	const commonSegmentSet = new Set(allCommonSegments.map((seg) => hashSegment(seg.firstPoint, seg.lastPoint)));
-	const matchesIntersection = (point) => {
-		if (intersectionSet.has(hashPoint(point))) return true;
-		return allIntersections.some((p) => samePoint(p, point));
-	};
-	const matchesCommonSegment = (first, last) => {
-		if (commonSegmentSet.has(hashSegment(first, last))) return true;
-		return allCommonSegments.some((seg) => samePoint(seg.firstPoint, first) && samePoint(seg.lastPoint, last) || samePoint(seg.firstPoint, last) && samePoint(seg.lastPoint, first));
-	};
-	let currentCurves = [];
-	for (const curve of curves) {
-		if (samePoint(curve.firstPoint, curve.lastPoint)) {
-			currentCurves.push(curve);
-			continue;
-		}
-		const endsAtIntersection = matchesIntersection(curve.lastPoint);
-		const isCommon = matchesCommonSegment(curve.firstPoint, curve.lastPoint);
-		if (endsAtIntersection) {
-			currentCurves.push(curve);
-			yield currentCurves;
-			currentCurves = [];
-		} else if (isCommon) {
-			if (currentCurves.length) {
-				yield currentCurves;
-				currentCurves = [];
-			}
-			yield [curve];
-		} else currentCurves.push(curve);
-	}
-	if (currentCurves.length) yield currentCurves;
-}
-/**
-* Filter out intersection points where the curves only touch but do not
-* actually cross from one side to the other.
-*/
-function removeNonCrossingPoints(allIntersections, segmentedCurve, blueprintToCheck) {
-	return allIntersections.filter((intersection) => {
-		const touching = segmentedCurve.filter((s) => samePoint(s.firstPoint, intersection) || samePoint(s.lastPoint, intersection));
-		const effectiveTouching = touching.length % 2 ? touching.filter((s) => !(samePoint(s.firstPoint, intersection) && samePoint(s.lastPoint, intersection))) : touching;
-		if (effectiveTouching.length === 0 || effectiveTouching.length % 2) return false;
-		const insideFlags = effectiveTouching.map((segment) => blueprintToCheck.isInside(curveMidPoint(segment)));
-		return !(insideFlags.every(Boolean) || insideFlags.every((f) => !f));
-	});
-}
-/**
-* Find all intersection points and common segments between two blueprints'
-* curves. Returns per-curve intersection points for subsequent splitting.
-*/
-function findAllIntersections(first, second) {
-	const allIntersections = [];
-	const allCommonSegments = [];
-	const firstCurvePoints = first.curves.map(() => []);
-	const secondCurvePoints = second.curves.map(() => []);
-	const secondIndex = new Flatbush(second.curves.length);
-	for (const curve of second.curves) {
-		const [[xMin, yMin], [xMax, yMax]] = curve.boundingBox.bounds;
-		secondIndex.add(xMin, yMin, xMax, yMax);
-	}
-	secondIndex.finish();
-	first.curves.forEach((thisCurve, firstIdx) => {
-		const [[xMin, yMin], [xMax, yMax]] = thisCurve.boundingBox.bounds;
-		const candidates = secondIndex.search(xMin, yMin, xMax, yMax);
-		for (const secondIdx of candidates) {
-			const otherCurve = second.curves[secondIdx];
-			const { intersections, commonSegments, commonSegmentsPoints } = unwrap(intersectCurves(thisCurve, otherCurve, PRECISION_INTERSECTION / 100));
-			allIntersections.push(...intersections);
-			firstCurvePoints[firstIdx]?.push(...intersections);
-			secondCurvePoints[secondIdx]?.push(...intersections);
-			allCommonSegments.push(...commonSegments);
-			allIntersections.push(...commonSegmentsPoints);
-			firstCurvePoints[firstIdx]?.push(...commonSegmentsPoints);
-			secondCurvePoints[secondIdx]?.push(...commonSegmentsPoints);
-		}
-	});
-	return {
-		allIntersections: removeDuplicatePoints(allIntersections, PRECISION_INTERSECTION),
-		allCommonSegments,
-		firstCurvePoints,
-		secondCurvePoints
-	};
-}
-/**
-* Split each curve at its intersection points and return the resulting
-* sub-curves.
-*/
-function splitCurvesAtIntersections(curves, curvePoints) {
-	return zip([curves, curvePoints]).flatMap(([curve, intersections]) => {
-		if (intersections.length === 0) return [curve];
-		return curve.splitAt(intersections, PRECISION_INTERSECTION / 100);
-	});
-}
-/**
-* Check whether a segment's start/end points match one of the common segment
-* point pairs.
-*/
-function isCommonSegmentMatch(commonSegmentsPoints, segmentStart, segmentEnd) {
-	return commonSegmentsPoints.some(([startPoint, endPoint]) => {
-		if (startPoint === void 0 || endPoint === void 0) return false;
-		return samePoint(startPoint, segmentStart) && samePoint(endPoint, segmentEnd) || samePoint(startPoint, segmentEnd) && samePoint(endPoint, segmentStart);
-	});
-}
-/**
-* Given two closed blueprints, find their intersection points, split each
-* blueprint's curves at those points, and pair up the resulting segments.
-*
-* Returns an array of paired segments (one from each blueprint) that share
-* the same start/end intersection points, or `null` if the blueprints do not
-* intersect.
-*/
-function blueprintsIntersectionSegments(first, second) {
-	const { allIntersections: rawIntersections, allCommonSegments, firstCurvePoints, secondCurvePoints } = findAllIntersections(first, second);
-	if (rawIntersections.length <= 1) return null;
-	let firstCurveSegments = splitCurvesAtIntersections(first.curves, firstCurvePoints);
-	let secondCurveSegments = splitCurvesAtIntersections(second.curves, secondCurvePoints);
-	const commonSegmentsPoints = allCommonSegments.map((c) => [c.firstPoint, c.lastPoint]);
-	const allIntersections = removeNonCrossingPoints(removeNonCrossingPoints(rawIntersections, firstCurveSegments, second), secondCurveSegments, first);
-	if (allIntersections.length === 0 && allCommonSegments.length === 0) return null;
-	if (allCommonSegments.length === 0) {
-		const startAt = allIntersections[0];
-		if (startAt === void 0) return null;
-		firstCurveSegments = rotateToStartAt(firstCurveSegments, startAt);
-		secondCurveSegments = rotateToStartAt(secondCurveSegments, startAt);
-	} else {
-		const startSegment = allCommonSegments[0];
-		if (startSegment === void 0) return null;
-		firstCurveSegments = rotateToStartAtSegment(firstCurveSegments, startSegment);
-		secondCurveSegments = rotateToStartAtSegment(secondCurveSegments, startSegment);
-	}
-	const firstIntersectedSegments = Array.from(createSegmentOnPoints(firstCurveSegments, allIntersections, allCommonSegments));
-	let secondIntersectedSegments = Array.from(createSegmentOnPoints(secondCurveSegments, allIntersections, allCommonSegments));
-	const firstSeg = firstIntersectedSegments[0];
-	const secondSeg = secondIntersectedSegments[0];
-	if (firstSeg !== void 0 && secondSeg !== void 0) {
-		const endpointsMismatch = !samePoint(endOfSegment(secondSeg), endOfSegment(firstSeg));
-		const commonSegmentLengthMismatch = allCommonSegments.length > 0 && secondSeg.length !== 1;
-		if (endpointsMismatch || commonSegmentLengthMismatch) secondIntersectedSegments = reverseSegments(secondIntersectedSegments);
-	}
-	const maxLen = Math.max(firstIntersectedSegments.length, secondIntersectedSegments.length);
-	const result = [];
-	for (let i = 0; i < maxLen; i++) {
-		const firstSeg2 = firstIntersectedSegments[i];
-		const secondSeg2 = secondIntersectedSegments[i];
-		if (firstSeg2 === void 0 || secondSeg2 === void 0) {
-			const available = firstSeg2 ?? secondSeg2;
-			if (available === void 0) continue;
-			result.push([available, available]);
-			continue;
-		}
-		if (isCommonSegmentMatch(commonSegmentsPoints, startOfSegment(firstSeg2), endOfSegment(firstSeg2))) result.push([firstSeg2, "same"]);
-		else result.push([firstSeg2, secondSeg2]);
-	}
-	return result;
-}
-//#endregion
-//#region src/2d/blueprints/segmentAssembly.ts
-/**
-* Merge adjacent collinear line segments into single segments.
-*
-* Boolean operations can split a line at intersection points that lie on the
-* line itself (e.g. when a cut rectangle's edge is collinear with the
-* profile's edge). The extra split creates a C0 discontinuity in swept
-* surfaces. Merging eliminates unnecessary vertices.
-*/
-function mergeCollinearSegments(curves) {
-	if (curves.length < 2) return curves;
-	const result = [];
-	let i = 0;
-	while (i < curves.length) {
-		const current = curves[i];
-		if (current.geomType !== "LINE") {
-			result.push(current);
-			i++;
-			continue;
-		}
-		let endPoint = current.lastPoint;
-		let j = i + 1;
-		while (j < curves.length) {
-			const next = curves[j];
-			if (next.geomType !== "LINE") break;
-			if (!samePoint(endPoint, next.firstPoint)) break;
-			const dir1 = subtract2d(endPoint, current.firstPoint);
-			const dir2 = subtract2d(next.lastPoint, next.firstPoint);
-			if (Math.abs(crossProduct2d(dir1, dir2)) > 1e-9) break;
-			endPoint = next.lastPoint;
-			j++;
-		}
-		if (j > i + 1) result.push(make2dSegmentCurve(current.firstPoint, endPoint));
-		else result.push(current);
-		i = j;
-	}
-	return result;
-}
-/**
-* Split an array of curves into separate continuous paths. A discontinuity
-* occurs where one curve's lastPoint does not match the next curve's
-* firstPoint.
-*/
-function splitPaths(curves) {
-	const startPoints = curves.map((c) => c.firstPoint);
-	const shiftedEndPoints = curves.map((c) => c.lastPoint);
-	const discontinuities = zip([startPoints, shiftedEndPoints.slice(-1).concat(shiftedEndPoints.slice(0, -1))]).map(([startPoint, endPoint], index) => {
-		if (startPoint === void 0 || endPoint === void 0) return null;
-		return samePoint(startPoint, endPoint) ? null : index;
-	}).filter((f) => f !== null);
-	if (discontinuities.length === 0) return [curves];
-	const paths = zip([discontinuities.slice(0, -1), discontinuities.slice(1)]).map(([start, end]) => curves.slice(start, end));
-	let lastPath = curves.slice(discontinuities[discontinuities.length - 1]);
-	const firstDiscontinuity = discontinuities[0];
-	if (firstDiscontinuity !== void 0 && firstDiscontinuity !== 0) lastPath = lastPath.concat(curves.slice(0, firstDiscontinuity));
-	paths.push(lastPath);
-	return paths;
-}
-/**
-* Handle the case where two segments overlap ("same"). The decision depends
-* on how many segments are entering the current intersection node.
-*/
-function handleSameSegment(firstSegment, segmentsIn, lastWasSame) {
-	if (segmentsIn === 1) return {
-		curves: [...firstSegment],
-		segmentsIn: 1,
-		lastWasSame: null
-	};
-	if (segmentsIn === 2 || segmentsIn === 0) return {
-		curves: [],
-		segmentsIn: null,
-		lastWasSame: null
-	};
-	if (segmentsIn === null) return {
-		curves: [],
-		segmentsIn: null,
-		lastWasSame: lastWasSame ? [...lastWasSame, ...firstSegment] : firstSegment
-	};
-	return {
-		curves: [],
-		segmentsIn,
-		lastWasSame
-	};
-}
-/**
-* Determine which non-overlapping segments to keep based on
-* inside/outside status relative to the other blueprint.
-*/
-function selectSegments(firstSegment, secondSegment, first, second, config, segmentsIn, lastWasSame) {
-	let segments = [];
-	let segmentsOut = 0;
-	const firstCurve = firstSegment[0];
-	if (firstCurve !== void 0) {
-		const firstSegmentPoint = curveMidPoint(firstCurve);
-		const firstInSecond = second.isInside(firstSegmentPoint);
-		if (config.firstInside === "keep" && firstInSecond || config.firstInside === "remove" && !firstInSecond) {
-			segmentsOut += 1;
-			segments.push(...firstSegment);
-		}
-	}
-	const secondCurve = secondSegment[0];
-	if (secondCurve !== void 0) {
-		const secondSegmentPoint = curveMidPoint(secondCurve);
-		const secondInFirst = first.isInside(secondSegmentPoint);
-		if (config.secondInside === "keep" && secondInFirst || config.secondInside === "remove" && !secondInFirst) {
-			let segmentsToAdd = secondSegment;
-			if (segmentsOut === 1) segmentsToAdd = reverseSegment(secondSegment);
-			segmentsOut += 1;
-			segments.push(...segmentsToAdd);
-		}
-	}
-	if (segmentsIn === null && segmentsOut === 1 && lastWasSame !== null) segments = [...lastWasSame, ...segments];
-	return {
-		curves: segments,
-		segmentsIn: segmentsOut === 1 ? segmentsOut : segmentsIn,
-		lastWasSame: segmentsOut === 1 ? null : lastWasSame
-	};
-}
-/**
-* Core boolean operation between two simple (non-compound) blueprints.
-*
-* Segments both blueprints at their intersection points, then selects which
-* segments to keep based on the `firstInside`/`secondInside` configuration.
-*/
-function booleanOperation(first, second, config) {
-	const segments = blueprintsIntersectionSegments(first, second);
-	if (segments === null) return buildNoIntersectionResult(first, second);
-	if (segments.every(([, secondSegment]) => secondSegment === "same")) return { identical: true };
-	let segmentsIn = null;
-	let lastWasSame = null;
-	let assembledCurves = segments.flatMap(([firstSegment, secondSegment]) => {
-		if (secondSegment === "same") {
-			const result = handleSameSegment(firstSegment, segmentsIn, lastWasSame);
-			segmentsIn = result.segmentsIn;
-			lastWasSame = result.lastWasSame;
-			return result.curves;
-		}
-		const result = selectSegments(firstSegment, secondSegment, first, second, config, segmentsIn, lastWasSame);
-		segmentsIn = result.segmentsIn;
-		lastWasSame = result.lastWasSame;
-		return result.curves;
-	});
-	const finalLastWasSame = lastWasSame;
-	if (finalLastWasSame !== null && segmentsIn === 1) assembledCurves = [...finalLastWasSame, ...assembledCurves];
-	const paths = splitPaths(mergeCollinearSegments(assembledCurves)).filter((b) => b.length > 0).map((b) => new Blueprint(b));
-	if (paths.length === 0) return null;
-	if (paths.length === 1) {
-		const single = paths[0];
-		if (single === void 0) return null;
-		return single;
-	}
-	return organiseBlueprints(paths);
-}
-function buildNoIntersectionResult(first, second) {
-	const firstCurve = first.curves[0];
-	const secondCurve = second.curves[0];
-	return {
-		identical: false,
-		firstCurveInSecond: firstCurve !== void 0 && second.isInside(curveMidPoint(firstCurve)),
-		secondCurveInFirst: secondCurve !== void 0 && first.isInside(curveMidPoint(secondCurve))
-	};
-}
-//#endregion
-//#region src/2d/blueprints/booleanOperations.ts
-/**
-* Boolean operations on 2D blueprints: fuse, cut, and intersect.
-*
-* This module is the public API. Internal logic is split across:
-* - `booleanHelpers.ts` — hashing, segment types, rotation utilities
-* - `intersectionSegments.ts` — curve intersection and segment pairing
-* - `segmentAssembly.ts` — segment selection and path assembly
-*/
-/**
-* Compute the boolean union of two simple blueprints.
-*
-* Segments each blueprint at their intersection points, discards segments
-* inside the other shape, and reassembles the remaining curves.
-*
-* @param first - First blueprint operand.
-* @param second - Second blueprint operand.
-* @returns The fused outline, a {@link Blueprints} if the result is
-*   disjoint, or `null` if the operation produces no geometry.
-*
-* @remarks Both blueprints must be closed. For compound or multi-blueprint
-* inputs, use {@link fuse2D} instead.
-*/
-function fuseBlueprints(first, second) {
-	const result = booleanOperation(first, second, {
-		firstInside: "remove",
-		secondInside: "remove"
-	});
-	if (result === null || result instanceof Blueprint || result instanceof Blueprints) return result;
-	if (result.identical) return first.clone();
-	if (result.firstCurveInSecond) return second.clone();
-	if (result.secondCurveInFirst) return first.clone();
-	return new Blueprints([first, second]);
-}
-/**
-* Compute the boolean difference of two simple blueprints (first minus second).
-*
-* Segments the blueprints at their intersections, keeps segments of the first
-* that are outside the second, and segments of the second that are inside the
-* first (reversed to form the boundary of the cut).
-*
-* @param first - Base blueprint to cut from.
-* @param second - Tool blueprint to subtract.
-* @returns The remaining outline, or `null` if nothing remains.
-*
-* @remarks Both blueprints must be closed. For compound inputs use {@link cut2D}.
-*/
-function cutBlueprints(first, second) {
-	const result = booleanOperation(first, second, {
-		firstInside: "remove",
-		secondInside: "keep"
-	});
-	if (result === null || result instanceof Blueprint || result instanceof Blueprints) return result;
-	if (result.identical) return null;
-	if (result.firstCurveInSecond) return null;
-	if (result.secondCurveInFirst) return new Blueprints([new CompoundBlueprint([first, second])]);
-	return first.clone();
-}
-/**
-* Compute the boolean intersection of two simple blueprints.
-*
-* Keeps only the segments of each blueprint that lie inside the other,
-* producing the overlapping region.
-*
-* @param first - First blueprint operand.
-* @param second - Second blueprint operand.
-* @returns The intersection outline, or `null` if the blueprints do not overlap.
-*
-* @remarks Both blueprints must be closed. For compound inputs use {@link intersect2D}.
-*/
-function intersectBlueprints(first, second) {
-	const result = booleanOperation(first, second, {
-		firstInside: "keep",
-		secondInside: "keep"
-	});
-	if (result === null || result instanceof Blueprint || result instanceof Blueprints) return result;
-	if (result.identical) return first.clone();
-	if (result.firstCurveInSecond) return first.clone();
-	if (result.secondCurveInFirst) return second.clone();
-	return null;
-}
-//#endregion
-//#region src/2d/blueprints/boolean2D.ts
-var genericIntersects = (first, second) => {
-	if (first instanceof Blueprint && second instanceof Blueprint) {
-		let allIntersections = [];
-		first.curves.forEach((thisCurve) => {
-			second.curves.forEach((otherCurve) => {
-				const { intersections, commonSegmentsPoints } = unwrap(intersectCurves(thisCurve, otherCurve));
-				allIntersections.push(...intersections);
-				allIntersections.push(...commonSegmentsPoints);
-			});
-		});
-		allIntersections = removeDuplicatePoints(allIntersections);
-		return allIntersections.length > 1;
-	}
-	if (first instanceof CompoundBlueprint || first instanceof Blueprints) return first.blueprints.some((bp) => genericIntersects(bp, second));
-	if (second instanceof CompoundBlueprint || second instanceof Blueprints) return second.blueprints.some((bp) => genericIntersects(first, bp));
-	bug("genericIntersects", "Unhandled shape combination in genericIntersects");
-};
-var genericFuse = (first, second) => {
-	if (first instanceof CompoundBlueprint) {
-		if (second instanceof Blueprint) return fuseBlueprintWithCompound(second, first);
-		if (second instanceof CompoundBlueprint) return fuseCompoundWithCompound(first, second);
-	}
-	if (second instanceof CompoundBlueprint) {
-		if (first instanceof Blueprint) return fuseBlueprintWithCompound(first, second);
-		if (first instanceof CompoundBlueprint) return fuseCompoundWithCompound(first, second);
-	}
-	if (first instanceof Blueprint && second instanceof Blueprint) return fuseBlueprints(first, second);
-	bug("genericFuse", "Unhandled shape combination in genericFuse");
-};
-var fuseIntersectingBlueprints = (blueprints) => {
-	const fused = /* @__PURE__ */ new Map();
-	const output = [];
-	blueprints.forEach((inputBlueprint, i) => {
-		let savedBlueprint;
-		if (fused.has(i)) savedBlueprint = fused.get(i);
-		else {
-			savedBlueprint = {
-				current: inputBlueprint,
-				fusedWith: new Set([i])
-			};
-			output.push(savedBlueprint);
-		}
-		blueprints.slice(i + 1).forEach((inputOtherBlueprint, j) => {
-			const blueprint = savedBlueprint.current;
-			const currentIndex = i + j + 1;
-			if (savedBlueprint.fusedWith.has(currentIndex)) return;
-			let otherBlueprint = inputOtherBlueprint;
-			let otherIsFused = false;
-			if (fused.has(currentIndex)) {
-				otherBlueprint = fused.get(currentIndex).current;
-				otherIsFused = true;
-			}
-			if (blueprint.boundingBox.isOut(otherBlueprint.boundingBox)) return;
-			if (!genericIntersects(blueprint, otherBlueprint)) return;
-			let newFused;
-			if (blueprint instanceof Blueprints || otherBlueprint instanceof Blueprints) {
-				const fused = fuse2D(blueprint, otherBlueprint);
-				if (fused === null) bug("fuseIntersectingBlueprints", "fuse2D returned null for non-null inputs");
-				newFused = fused;
-			} else newFused = genericFuse(blueprint, otherBlueprint);
-			if (!(newFused instanceof Blueprint || newFused instanceof CompoundBlueprint)) {
-				if (newFused instanceof Blueprints && newFused.blueprints.length === 2) return;
-				else if (newFused instanceof Blueprints && newFused.blueprints.length === 1) newFused = safeIndex(newFused.blueprints, 0, "fuseIntersectingBlueprints");
-				else if (!(newFused instanceof Blueprints)) bug("fuseIntersectingBlueprints", "Fuse produced unexpected non-blueprint result");
-			}
-			savedBlueprint.fusedWith.add(currentIndex);
-			savedBlueprint.current = newFused;
-			if (!otherIsFused) fused.set(currentIndex, savedBlueprint);
-		});
-	});
-	return organiseBlueprints(output.map(({ current }) => current).flatMap((b) => allBlueprints(b)));
-};
-var allBlueprints = (shape) => {
-	if (shape instanceof Blueprint) return [shape];
-	if (shape instanceof CompoundBlueprint) return shape.blueprints;
-	if (shape instanceof Blueprints) return shape.blueprints.flatMap((b) => allBlueprints(b));
-	return [];
-};
-var fuseBlueprintWithCompound = (blueprint, compound) => {
-	const outerFused = fuseBlueprints(blueprint, safeIndex(compound.blueprints, 0, "fuseBlueprintWithCompound"));
-	const innerFused = compound.blueprints.slice(1).map((c) => cutBlueprints(c, blueprint));
-	return organiseBlueprints([...allBlueprints(outerFused), ...innerFused.flatMap((fused) => allBlueprints(fused))]);
-};
-function allPairs(list1, list2) {
-	const result = [];
-	for (const l1 of list1) for (const l2 of list2) result.push([l1, l2]);
-	return result;
-}
-var fuseCompoundWithCompound = (first, second) => {
-	const firstOuter = safeIndex(first.blueprints, 0, "fuseCompoundWithCompound");
-	const secondOuter = safeIndex(second.blueprints, 0, "fuseCompoundWithCompound");
-	const outerFused = fuseBlueprints(firstOuter, secondOuter);
-	const inner1Fused = second.blueprints.slice(1).map((c) => cutBlueprints(c, firstOuter));
-	const inner2Fused = first.blueprints.slice(1).map((c) => cutBlueprints(c, secondOuter));
-	const innerIntersections = allPairs(first.blueprints.slice(1), second.blueprints.slice(1)).flatMap(([first, second]) => {
-		return allBlueprints(intersectBlueprints(first, second));
-	});
-	return organiseBlueprints([
-		...allBlueprints(outerFused),
-		...inner1Fused.flatMap((fused) => allBlueprints(fused)),
-		...inner2Fused.flatMap((fused) => allBlueprints(fused)),
-		...innerIntersections
-	]);
-};
-/**
-* Compute the boolean union of two 2D shapes.
-*
-* Handles all combinations of {@link Blueprint}, {@link CompoundBlueprint},
-* {@link Blueprints}, and `null`. When both inputs are simple blueprints the
-* operation delegates to {@link fuseBlueprints}; compound and multi-blueprint
-* cases are decomposed recursively.
-*
-* @param first - First operand (or `null` for empty).
-* @param second - Second operand (or `null` for empty).
-* @returns The fused shape, or `null` if both operands are empty.
-*
-* @example
-* ```ts
-* const union = fuse2D(circleBlueprint, squareBlueprint);
-* ```
-*
-* @see {@link fuse2D} for the functional API.
-*/
-var fuse2D = (first, second) => {
-	if (first === null) return second?.clone() ?? null;
-	if (second === null) return first.clone();
-	if (!(first instanceof Blueprints) && second instanceof Blueprints) return fuseIntersectingBlueprints([first, ...second.blueprints]);
-	if (!(second instanceof Blueprints) && first instanceof Blueprints) return fuseIntersectingBlueprints([second, ...first.blueprints]);
-	if (first instanceof Blueprints && second instanceof Blueprints) {
-		let out = fuse2D(safeIndex(first.blueprints, 0, "fuse2D"), second);
-		first.blueprints.slice(1).forEach((bp) => {
-			out = fuse2D(bp, out);
-		});
-		return out;
-	}
-	if (first instanceof CompoundBlueprint) {
-		if (second instanceof Blueprints) return fuse2D(second, first);
-		if (second instanceof Blueprint) return fuseBlueprintWithCompound(second, first);
-		if (second instanceof CompoundBlueprint) return fuseCompoundWithCompound(first, second);
-	}
-	if (second instanceof CompoundBlueprint) {
-		if (first instanceof Blueprints) return fuse2D(first, second);
-		if (first instanceof Blueprint) return fuseBlueprintWithCompound(first, second);
-		if (first instanceof CompoundBlueprint) return fuseCompoundWithCompound(first, second);
-	}
-	if (first instanceof Blueprint && second instanceof Blueprint) return fuseBlueprints(first, second);
-	return null;
-};
-var mergeNonIntersecting = (shapes) => {
-	const exploded = shapes.flatMap((s) => {
-		if (s === null) return [];
-		if (s instanceof Blueprints) return s.blueprints;
-		return s;
-	});
-	if (exploded.length === 1) return safeIndex(exploded, 0, "mergeNonIntersecting");
-	return new Blueprints(exploded);
-};
-/**
-* Compute the boolean difference of two 2D shapes (first minus second).
-*
-* Removes the region covered by `second` from `first`. When the tool is fully
-* inside the base, the result is a {@link CompoundBlueprint} (base with a
-* hole).
-*
-* @param first - Base shape to cut from.
-* @param second - Tool shape to subtract.
-* @returns The remaining shape, or `null` if nothing remains.
-*
-* @example
-* ```ts
-* const withHole = cut2D(outerRect, innerCircle);
-* ```
-*
-* @see {@link cut2D} for the functional API.
-*/
-var cut2D = (first, second) => {
-	if (first === null) return null;
-	if (second === null) return first.clone();
-	if (first instanceof Blueprints) return mergeNonIntersecting(first.blueprints.map((bp) => cut2D(bp, second)));
-	if (first instanceof CompoundBlueprint) {
-		const wrapper = safeIndex(first.blueprints, 0, "cut2D");
-		if (second instanceof Blueprint && !second.intersects(wrapper)) {
-			if (!wrapper.isInside(second.firstPoint)) return first.clone();
-			return organiseBlueprints([wrapper, ...allBlueprints(fuse2D(second, new Blueprints(first.blueprints.slice(1))))]);
-		} else {
-			let out = cut2D(wrapper, second);
-			first.blueprints.slice(1).forEach((bp) => {
-				out = cut2D(out, bp);
-			});
-			return out;
-		}
-	}
-	if (second instanceof Blueprints) {
-		let out = first;
-		for (const bp of second.blueprints) out = cut2D(out, bp);
-		return out;
-	}
-	if (second instanceof CompoundBlueprint) {
-		let out = cutBlueprints(first, safeIndex(second.blueprints, 0, "cut2D"));
-		second.blueprints.slice(1).forEach((bp) => {
-			out = fuse2D(out, intersectBlueprints(bp, first));
-		});
-		return out;
-	}
-	return cutBlueprints(first, second);
-};
-/**
-* Compute the boolean intersection of two 2D shapes.
-*
-* Returns only the region common to both shapes. Compound and multi-blueprint
-* operands are decomposed recursively, with holes handled via complementary
-* cut operations.
-*
-* @param first - First operand.
-* @param second - Second operand.
-* @returns The intersection shape, or `null` if the shapes do not overlap.
-*
-* @example
-* ```ts
-* const overlap = intersect2D(circle, rectangle);
-* ```
-*
-* @see {@link intersect2D} for the functional API.
-*/
-function intersect2D(first, second) {
-	if (first === null || second === null) return null;
-	if (first instanceof Blueprint && second instanceof Blueprint) return intersectBlueprints(first, second);
-	if (first instanceof Blueprints) return mergeNonIntersecting(first.blueprints.map((bp) => intersect2D(bp, second)));
-	if (first instanceof CompoundBlueprint) {
-		const wrapper = safeIndex(first.blueprints, 0, "intersect2D");
-		const cuts = first.blueprints.slice(1);
-		if (cuts.length === 0) return intersect2D(wrapper, second);
-		let result = intersect2D(wrapper, second);
-		for (const cut of cuts) result = cut2D(result, cut);
-		return result;
-	}
-	if (second instanceof Blueprints) return mergeNonIntersecting(second.blueprints.map((bp) => intersect2D(first, bp)));
-	if (second instanceof CompoundBlueprint) {
-		const wrapper = safeIndex(second.blueprints, 0, "intersect2D");
-		const cuts = second.blueprints.slice(1);
-		if (cuts.length === 0) return intersect2D(wrapper, first);
-		let result = intersect2D(wrapper, first);
-		for (const cut of cuts) result = cut2D(result, cut);
-		return result;
-	}
-	bug("intersect2D", "Unhandled Shape2D combination");
-}
-//#endregion
-export { Flatbush as S, Blueprints as _, fuseBlueprints as a, make2dOffset as b, roundedRectangleBlueprint as c, FaceSketcher as d, Sketch as f, CompoundBlueprint as g, organiseBlueprints as h, cutBlueprints as i, BaseSketcher2d as l, loftAll as m, fuse2D as n, intersectBlueprints as o, loft as p, intersect2D as r, polysidesBlueprint as s, cut2D as t, BlueprintSketcher as u, chamferCurves as v, intersectCurves as x, filletCurves as y };
+export { Blueprints as a, make2dOffset as c, CompoundBlueprint as i, intersectCurves as l, BaseSketcher2d as n, chamferCurves as o, organiseBlueprints as r, filletCurves as s, BlueprintSketcher as t, Flatbush as u };