brepjs 18.6.0 → 18.14.3

package/dist/{boolean2D-k1AJmCMp.cjs → blueprintSketcher-Bei866Bt.cjs}

@@ -1,16 +1,10 @@
-const require_shapeTypes = require("./shapeTypes-C0MDggKf.cjs");
-const require_errors = require("./errors-CXRNVCec.cjs");
-const require_faceFns = require("./faceFns-22idS-ht.cjs");
-const require_constants = require("./constants-BNP_xnBN.cjs");
-const require_types = require("./types-gLi9wL0N.cjs");
-const require_vecOps = require("./vecOps-CODplJp3.cjs");
-const require_planeOps = require("./planeOps-BJOIbn4K.cjs");
-const require_curveFns = require("./curveFns-DrT54cm8.cjs");
-const require_arrayAccess = require("./arrayAccess-DsnQpdSD.cjs");
-const require_surfaceBuilders = require("./surfaceBuilders-CbH4FIW5.cjs");
-const require_helpers = require("./helpers-BpXNcxuJ.cjs");
-const require_blueprint = require("./blueprint-CscZ0-wr.cjs");
-const require_extrudeFns = require("./extrudeFns-BtblHdaJ.cjs");
+const require_shapeTypes = require("./shapeTypes-BTt_LLbk.cjs");
+const require_vec3 = require("./vec3-S4Oh59IX.cjs");
+const require_errors = require("./errors-Dv6pfNct.cjs");
+const require_constants = require("./constants-DTorLmes.cjs");
+const require_arrayAccess = require("./arrayAccess-7pTWqkJu.cjs");
+const require_helpers = require("./helpers-Cyj6gaqy.cjs");
+const require_blueprint = require("./blueprint-B8ogGJiQ.cjs");
 //#region node_modules/flatqueue/index.js
 /** @template T */
 var FlatQueue = class {
@@ -526,7 +520,7 @@ var selfIntersections = (curve, precision = 1e-9) => {
 var offsetEndPoints = (firstPoint, lastPoint, offset) => {
 	const tangent = require_helpers.normalize2d(require_helpers.subtract2d(lastPoint, firstPoint));
 	const normal = [tangent[1], -tangent[0]];
-	const offsetVec = [normal[0] * offset, normal[1] * offset];
+	const offsetVec = [require_vec3.wasmIndex(normal, 0) * offset, require_vec3.wasmIndex(normal, 1) * offset];
 	return {
 		firstPoint: require_helpers.add2d(firstPoint, offsetVec),
 		lastPoint: require_helpers.add2d(lastPoint, offsetVec)
@@ -623,11 +617,11 @@ function removeCorner(firstCurve, secondCurve, radius) {
 		const splitParam = require_errors.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: require_vec3.wasmIndex(firstSplit, 0),
+		second: require_vec3.wasmIndex(secondSplit, 1),
 		center
 	};
 }
@@ -692,8 +686,10 @@ function dogboneFilletCurves(firstCurve, secondCurve, radius) {
 	const firstInt = require_errors.unwrap(intersectCurves(firstCurve, circle)).intersections[0];
 	const secondInt = require_errors.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 = require_vec3.wasmIndex(firstSplit, 0);
+	const secondPart = require_vec3.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 require_errors.err(require_errors.validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
-	const kernel = require_shapeTypes.getKernel();
-	const startVertex = startPoint ? kernel.makeVertex(...require_types.toVec3(startPoint)) : void 0;
-	const endVertex = endPoint ? kernel.makeVertex(...require_types.toVec3(endPoint)) : void 0;
-	try {
-		const result = require_shapeTypes.castShape(kernel.loftAdvanced(wires.map((w) => w.wrapped), {
-			solid: !returnShell,
-			ruled,
-			tolerance,
-			...startVertex ? { startVertex } : {},
-			...endVertex ? { endVertex } : {}
-		}));
-		if (!require_shapeTypes.isShape3D(result)) return require_errors.err(require_errors.typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
-		return require_errors.ok(result);
-	} catch (e) {
-		return require_errors.err(require_errors.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 require_errors.ok([]);
-	const kernel = require_shapeTypes.getKernel();
-	const verticesToDelete = [];
-	const kernelEntries = entries.map((e) => {
-		const startVertex = e.startPoint ? kernel.makeVertex(...require_types.toVec3(e.startPoint)) : void 0;
-		const endVertex = e.endPoint ? kernel.makeVertex(...require_types.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 = require_shapeTypes.castShape(shape);
-			if (!require_shapeTypes.isShape3D(cast)) return require_errors.err(require_errors.typeCastError("LOFT_ALL_NOT_3D", "Batch loft entry did not produce a 3D shape"));
-			results.push(cast);
-		}
-		return require_errors.ok(results);
-	} catch (e) {
-		return require_errors.err(require_errors.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 = require_types.toVec3(defaultOrigin);
-		this._defaultDirection = require_types.toVec3(defaultDirection);
-		this.baseFace = null;
-	}
-	get baseFace() {
-		return this._baseFace;
-	}
-	set baseFace(newFace) {
-		if (this._baseFace) this._baseFace.delete();
-		this._baseFace = newFace ? require_shapeTypes.createFace(require_errors.unwrap(require_faceFns.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(require_shapeTypes.createWire(require_errors.unwrap(require_faceFns.downcast(this.wire.wrapped))), {
-			defaultOrigin: this.defaultOrigin,
-			defaultDirection: this.defaultDirection
-		});
-		if (this.baseFace) sketch.baseFace = require_shapeTypes.createFace(require_errors.unwrap(require_faceFns.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 = require_types.toVec3(newOrigin);
-	}
-	/** Get the default extrusion/normal direction. */
-	get defaultDirection() {
-		return this._defaultDirection;
-	}
-	/** Set the default extrusion/normal direction. */
-	set defaultDirection(newDirection) {
-		this._defaultDirection = require_types.toVec3(newDirection);
-	}
-	/**
-	* Transforms the lines into a face. The lines should be closed.
-	*/
-	face() {
-		let face;
-		const closedWire = this.wire;
-		if (!this.baseFace) face = require_errors.unwrap(require_surfaceBuilders.makeFace(closedWire));
-		else face = require_surfaceBuilders.makeNewFaceWithinFace(this.baseFace, closedWire);
-		return face;
-	}
-	/** Return a clone of the underlying wire. */
-	wires() {
-		return require_shapeTypes.createWire(require_errors.unwrap(require_faceFns.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 = require_errors.unwrap(require_surfaceBuilders.makeFace(this.wire));
-		const solid = require_errors.unwrap(require_extrudeFns.revolve(face, origin ? require_types.toVec3(origin) : this.defaultOrigin, revolutionAxis ? require_types.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 = require_vecOps.vecScale(require_vecOps.vecNormalize(extrusionDirection ? require_types.toVec3(extrusionDirection) : this.defaultDirection), extrusionDistance);
-		const originVec = origin ? require_types.toVec3(origin) : this.defaultOrigin;
-		if (extrusionProfile && !twistAngle) {
-			const solid = require_errors.unwrap(require_extrudeFns.complexExtrude(this.wire, [...originVec], [...extrusionVec], extrusionProfile));
-			this.delete();
-			return solid;
-		}
-		if (twistAngle) {
-			const solid = require_errors.unwrap(require_extrudeFns.twistExtrude(this.wire, twistAngle, [...originVec], [...extrusionVec], extrusionProfile));
-			this.delete();
-			return solid;
-		}
-		const solid = require_errors.unwrap(require_extrudeFns.extrude(require_errors.unwrap(require_surfaceBuilders.makeFace(this.wire)), [...extrusionVec]));
-		this.delete();
-		return solid;
-	}
-	/**
-	* Sweep along this sketch another sketch defined in the function
-	* `sketchOnPlane`.
-	*/
-	sweepSketch(sketchOnPlane, sweepConfig = {}) {
-		const startPoint = require_curveFns.curveStartPoint(this.wire);
-		const normal = require_vecOps.vecNormalize(require_vecOps.vecScale(require_curveFns.curveTangentAt(this.wire, 1e-9), -1));
-		const defaultDir = this.defaultDirection;
-		const xDir = require_vecOps.vecScale(require_vecOps.vecCross(normal, defaultDir), -1);
-		const result = sketchOnPlane(require_planeOps.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 = require_errors.unwrap(require_extrudeFns.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 = require_errors.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 * require_constants.DEG2RAD;
+	const convertAxis = (ax) => require_helpers.distance2d(convertToUV(ax));
+	const r1 = convertAxis(require_helpers.polarToCartesian(majorRadius, radRotationAngle));
+	const r2 = convertAxis(require_helpers.polarToCartesian(minorRadius, radRotationAngle + Math.PI / 2));
+	const xDir = require_helpers.normalize2d(convertToUV(require_helpers.rotate2d([1, 0], radRotationAngle)));
+	const [, newRotationAngle] = require_helpers.cartesianToPolar(xDir);
+	const { cx, cy, startAngle, endAngle, clockwise, rx, ry } = convertSvgEllipseParams(startUV, endUV, r1, r2, newRotationAngle, longAxis, sweep);
+	const arc = require_blueprint.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 * require_constants.DEG2RAD;
-	const convertAxis = (ax) => require_helpers.distance2d(convertToUV(ax));
-	const r1 = convertAxis(require_helpers.polarToCartesian(majorRadius, radRotationAngle));
-	const r2 = convertAxis(require_helpers.polarToCartesian(minorRadius, radRotationAngle + Math.PI / 2));
-	const xDir = require_helpers.normalize2d(convertToUV(require_helpers.rotate2d([1, 0], radRotationAngle)));
-	const [, newRotationAngle] = require_helpers.cartesianToPolar(xDir);
-	const { cx, cy, startAngle, endAngle, clockwise, rx, ry } = convertSvgEllipseParams(startUV, endUV, r1, r2, newRotationAngle, longAxis, sweep);
-	const arc = require_blueprint.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) require_errors.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) require_errors.bug("Sketcher2d.customCorner", "You need a curve defined to fillet the angle");
 		this._nextCorner = buildCornerFunction(radius, mode);
@@ -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 = require_shapeTypes.createFace(require_errors.unwrap(require_faceFns.downcast(face.wrapped)));
-		this._bounds = require_faceFns.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 require_shapeTypes.getKernel().extractSurfaceFromFace(this.face.wrapped);
-	}
-	/**
-	* @ignore
-	*/
-	buildWire() {
-		const kernel = require_shapeTypes.getKernel();
-		const geomSurf = this._adaptSurface();
-		const wire = require_errors.unwrap(require_surfaceBuilders.assembleWire(this.pendingCurves.map((curve) => {
-			return require_shapeTypes.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 = require_shapeTypes._usingCtx();
-			const scope = _usingCtx$1.u(new require_shapeTypes.DisposalScope());
-			const wire = this.buildWire();
-			const sketch = new Sketch(wire);
-			if (require_curveFns.curveIsClosed(wire)) {
-				const face = scope.register(sketch.clone().face());
-				const origin = require_faceFns.pointOnSurface(face, .5, .5);
-				const direction = require_vecOps.vecScale(require_faceFns.normalAt(face), -1);
-				sketch.defaultOrigin = [
-					origin[0],
-					origin[1],
-					origin[2]
-				];
-				sketch.defaultDirection = [
-					direction[0],
-					direction[1],
-					direction[2]
-				];
-			} else {
-				const startPoint = require_curveFns.curveStartPoint(wire);
-				const normal = require_faceFns.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,854 +1461,6 @@ 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 = require_arrayAccess.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) => require_helpers.samePoint(x, y, require_helpers.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) require_errors.bug("startOfSegment", "empty segment");
-	return first.firstPoint;
-}
-function endOfSegment(s) {
-	const last = s[s.length - 1];
-	if (last === void 0) require_errors.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;
-	require_errors.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 } = require_errors.unwrap(intersectCurves(thisCurve, otherCurve, require_helpers.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: require_blueprint.removeDuplicatePoints(allIntersections, require_helpers.PRECISION_INTERSECTION),
-		allCommonSegments,
-		firstCurvePoints,
-		secondCurvePoints
-	};
-}
-/**
-* Split each curve at its intersection points and return the resulting
-* sub-curves.
-*/
-function splitCurvesAtIntersections(curves, curvePoints) {
-	return require_surfaceBuilders.zip([curves, curvePoints]).flatMap(([curve, intersections]) => {
-		if (intersections.length === 0) return [curve];
-		return curve.splitAt(intersections, require_helpers.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 = require_helpers.subtract2d(endPoint, current.firstPoint);
-			const dir2 = require_helpers.subtract2d(next.lastPoint, next.firstPoint);
-			if (Math.abs(require_helpers.crossProduct2d(dir1, dir2)) > 1e-9) break;
-			endPoint = next.lastPoint;
-			j++;
-		}
-		if (j > i + 1) result.push(require_blueprint.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 = require_surfaceBuilders.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 = require_surfaceBuilders.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 require_blueprint.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 require_blueprint.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 require_blueprint.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 require_blueprint.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 require_blueprint.Blueprint && second instanceof require_blueprint.Blueprint) {
-		let allIntersections = [];
-		first.curves.forEach((thisCurve) => {
-			second.curves.forEach((otherCurve) => {
-				const { intersections, commonSegmentsPoints } = require_errors.unwrap(intersectCurves(thisCurve, otherCurve));
-				allIntersections.push(...intersections);
-				allIntersections.push(...commonSegmentsPoints);
-			});
-		});
-		allIntersections = require_blueprint.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));
-	require_errors.bug("genericIntersects", "Unhandled shape combination in genericIntersects");
-};
-var genericFuse = (first, second) => {
-	if (first instanceof CompoundBlueprint) {
-		if (second instanceof require_blueprint.Blueprint) return fuseBlueprintWithCompound(second, first);
-		if (second instanceof CompoundBlueprint) return fuseCompoundWithCompound(first, second);
-	}
-	if (second instanceof CompoundBlueprint) {
-		if (first instanceof require_blueprint.Blueprint) return fuseBlueprintWithCompound(first, second);
-		if (first instanceof CompoundBlueprint) return fuseCompoundWithCompound(first, second);
-	}
-	if (first instanceof require_blueprint.Blueprint && second instanceof require_blueprint.Blueprint) return fuseBlueprints(first, second);
-	require_errors.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) require_errors.bug("fuseIntersectingBlueprints", "fuse2D returned null for non-null inputs");
-				newFused = fused;
-			} else newFused = genericFuse(blueprint, otherBlueprint);
-			if (!(newFused instanceof require_blueprint.Blueprint || newFused instanceof CompoundBlueprint)) {
-				if (newFused instanceof Blueprints && newFused.blueprints.length === 2) return;
-				else if (newFused instanceof Blueprints && newFused.blueprints.length === 1) newFused = require_errors.safeIndex(newFused.blueprints, 0, "fuseIntersectingBlueprints");
-				else if (!(newFused instanceof Blueprints)) require_errors.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 require_blueprint.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, require_errors.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 = require_errors.safeIndex(first.blueprints, 0, "fuseCompoundWithCompound");
-	const secondOuter = require_errors.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(require_errors.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 require_blueprint.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 require_blueprint.Blueprint) return fuseBlueprintWithCompound(first, second);
-		if (first instanceof CompoundBlueprint) return fuseCompoundWithCompound(first, second);
-	}
-	if (first instanceof require_blueprint.Blueprint && second instanceof require_blueprint.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 require_errors.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 = require_errors.safeIndex(first.blueprints, 0, "cut2D");
-		if (second instanceof require_blueprint.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, require_errors.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 require_blueprint.Blueprint && second instanceof require_blueprint.Blueprint) return intersectBlueprints(first, second);
-	if (first instanceof Blueprints) return mergeNonIntersecting(first.blueprints.map((bp) => intersect2D(bp, second)));
-	if (first instanceof CompoundBlueprint) {
-		const wrapper = require_errors.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 = require_errors.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;
-	}
-	require_errors.bug("intersect2D", "Unhandled Shape2D combination");
-}
-//#endregion
 Object.defineProperty(exports, "BaseSketcher2d", {
 	enumerable: true,
 	get: function() {
@@ -2731,90 +1485,30 @@ Object.defineProperty(exports, "CompoundBlueprint", {
 		return CompoundBlueprint;
 	}
 });
-Object.defineProperty(exports, "FaceSketcher", {
-	enumerable: true,
-	get: function() {
-		return FaceSketcher;
-	}
-});
 Object.defineProperty(exports, "Flatbush", {
 	enumerable: true,
 	get: function() {
 		return Flatbush;
 	}
 });
-Object.defineProperty(exports, "Sketch", {
-	enumerable: true,
-	get: function() {
-		return Sketch;
-	}
-});
 Object.defineProperty(exports, "chamferCurves", {
 	enumerable: true,
 	get: function() {
 		return chamferCurves;
 	}
 });
-Object.defineProperty(exports, "cut2D", {
-	enumerable: true,
-	get: function() {
-		return cut2D;
-	}
-});
-Object.defineProperty(exports, "cutBlueprints", {
-	enumerable: true,
-	get: function() {
-		return cutBlueprints;
-	}
-});
 Object.defineProperty(exports, "filletCurves", {
 	enumerable: true,
 	get: function() {
 		return filletCurves;
 	}
 });
-Object.defineProperty(exports, "fuse2D", {
-	enumerable: true,
-	get: function() {
-		return fuse2D;
-	}
-});
-Object.defineProperty(exports, "fuseBlueprints", {
-	enumerable: true,
-	get: function() {
-		return fuseBlueprints;
-	}
-});
-Object.defineProperty(exports, "intersect2D", {
-	enumerable: true,
-	get: function() {
-		return intersect2D;
-	}
-});
-Object.defineProperty(exports, "intersectBlueprints", {
-	enumerable: true,
-	get: function() {
-		return intersectBlueprints;
-	}
-});
 Object.defineProperty(exports, "intersectCurves", {
 	enumerable: true,
 	get: function() {
 		return intersectCurves;
 	}
 });
-Object.defineProperty(exports, "loft", {
-	enumerable: true,
-	get: function() {
-		return loft;
-	}
-});
-Object.defineProperty(exports, "loftAll", {
-	enumerable: true,
-	get: function() {
-		return loftAll;
-	}
-});
 Object.defineProperty(exports, "make2dOffset", {
 	enumerable: true,
 	get: function() {
@@ -2827,15 +1521,3 @@ Object.defineProperty(exports, "organiseBlueprints", {
 		return organiseBlueprints;
 	}
 });
-Object.defineProperty(exports, "polysidesBlueprint", {
-	enumerable: true,
-	get: function() {
-		return polysidesBlueprint;
-	}
-});
-Object.defineProperty(exports, "roundedRectangleBlueprint", {
-	enumerable: true,
-	get: function() {
-		return roundedRectangleBlueprint;
-	}
-});