brepjs 18.6.0 → 18.14.3

package/dist/brepjs.cjs

@@ -1,31 +1,37 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_drawFns = require("./drawFns-DmP2o1oF.cjs");
-const require_shapeTypes = require("./shapeTypes-C0MDggKf.cjs");
-const require_occtWasmAdapter = require("./occtWasmAdapter-CuZRRioz.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_shapeFns = require("./shapeFns-183zCtMc.cjs");
-const require_curveFns = require("./curveFns-DrT54cm8.cjs");
-const require_meshFns = require("./meshFns-Cdhtbrhm.cjs");
-const require_arrayAccess = require("./arrayAccess-DsnQpdSD.cjs");
-const require_surfaceBuilders = require("./surfaceBuilders-CbH4FIW5.cjs");
-const require_booleanFns = require("./booleanFns-DQW4lt7H.cjs");
-const require_primitiveFns = require("./primitiveFns-BLxaJ40A.cjs");
-const require_historyFns = require("./historyFns-RHO-QvEZ.cjs");
-const require_boolean2D = require("./boolean2D-k1AJmCMp.cjs");
-const require_helpers = require("./helpers-BpXNcxuJ.cjs");
-const require_solidBuilders = require("./solidBuilders-DACzFqvX.cjs");
-const require_measureFns = require("./measureFns-C751QGI1.cjs");
-const require_cornerFinder = require("./cornerFinder-5BYE2cbd.cjs");
-const require_extrudeFns = require("./extrudeFns-BtblHdaJ.cjs");
-const require_blueprintFns = require("./blueprintFns-DQP4KQHE.cjs");
-const require_importFns = require("./importFns-CG49lyTm.cjs");
-const require_shapeRefFns = require("./shapeRefFns-CFyv5cdW.cjs");
-const require_workerHandler = require("./workerHandler-C-3cFcsQ.cjs");
+const require_textBlueprints = require("./textBlueprints-oWhiABaY.cjs");
+const require_shapeTypes = require("./shapeTypes-BTt_LLbk.cjs");
+const require_vec3 = require("./vec3-S4Oh59IX.cjs");
+const require_occtWasmAdapter = require("./occtWasmAdapter-C2VW-uYg.cjs");
+const require_errors = require("./errors-Dv6pfNct.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-BU0qdNJP.cjs");
+const require_constants = require("./constants-DTorLmes.cjs");
+const require_types = require("./types-CDkxah-M.cjs");
+const require_vecOps = require("./vecOps-D7xplSx8.cjs");
+const require_planeOps = require("./planeOps-CH4ruLuj.cjs");
+const require_faceFns = require("./faceFns-DP7i60yJ.cjs");
+const require_shapeFns = require("./shapeFns-B7x82K11.cjs");
+const require_curveFns = require("./curveFns-CD20-4fM.cjs");
+const require_meshFns = require("./meshFns-BCRVZgPi.cjs");
+const require_arrayAccess = require("./arrayAccess-7pTWqkJu.cjs");
+const require_surfaceBuilders = require("./surfaceBuilders-CYeTNW33.cjs");
+const require_booleanFns = require("./booleanFns-qmgMQyDl.cjs");
+const require_primitiveFns = require("./primitiveFns-BH-JQPzh.cjs");
+const require_historyFns = require("./historyFns-DfyrPjnK.cjs");
+const require_blueprintSketcher = require("./blueprintSketcher-Bei866Bt.cjs");
+const require_helpers = require("./helpers-Cyj6gaqy.cjs");
+const require_drawFns = require("./drawFns-LlOZoFyp.cjs");
+const require_solidBuilders = require("./solidBuilders-CX_197Xm.cjs");
+const require_measureFns = require("./measureFns-6ifSQfJt.cjs");
+const require_cornerFinder = require("./cornerFinder-CC8EBRCR.cjs");
+const require_boolean2D = require("./boolean2D-DGuiEJHA.cjs");
+const require_blueprintFns = require("./blueprintFns-BK3FYYjO.cjs");
+const require_importFns = require("./importFns-C-p0vl_h.cjs");
+const require_extrudeFns = require("./extrudeFns-DD36mWKv.cjs");
+const require_cameraFns = require("./cameraFns-1y1NyACI.cjs");
+const require_textMetrics = require("./textMetrics-CUvtglQE.cjs");
+const require_shapeRefFns = require("./shapeRefFns-wDY88A8u.cjs");
+const require_workerHandler = require("./workerHandler-C7seK7H-.cjs");
 //#region src/topology/shapeBooleans.ts
 var BOPAlgo_GlueShift = 1;
 var BOPAlgo_GlueFull = 2;
@@ -69,9 +75,9 @@ function withNearestPostFilter(baseFinder, nearestPoint) {
 		const candidates = baseFinder.findAll(shape);
 		if (candidates.length === 0) return [];
 		let bestIdx = 0;
-		let bestDist = require_vecOps.vecDistance(require_faceFns.vertexPosition(require_arrayAccess.firstOrThrow(candidates)), nearestPoint);
+		let bestDist = require_vecOps.vecDistance(require_topologyQueryFns.vertexPosition(require_arrayAccess.firstOrThrow(candidates)), nearestPoint);
 		for (let i = 1; i < candidates.length; i++) {
-			const d = require_vecOps.vecDistance(require_faceFns.vertexPosition(require_arrayAccess.getAtOrThrow(candidates, i)), nearestPoint);
+			const d = require_vecOps.vecDistance(require_topologyQueryFns.vertexPosition(require_arrayAccess.getAtOrThrow(candidates, i)), nearestPoint);
 			if (d < bestDist) {
 				bestDist = d;
 				bestIdx = i;
@@ -93,9 +99,9 @@ function withNearestPostFilter(baseFinder, nearestPoint) {
 function buildVertexFinder(filters) {
 	return require_helpers.createTypedFinder("vertex", filters, buildVertexFinder, (_base, withFilter) => ({
 		nearestTo: (point) => withNearestPostFilter(buildVertexFinder(filters), point),
-		atPosition: (point, tolerance = 1e-4) => withFilter((vertex) => require_vecOps.vecDistance(require_faceFns.vertexPosition(vertex), point) < tolerance),
+		atPosition: (point, tolerance = 1e-4) => withFilter((vertex) => require_vecOps.vecDistance(require_topologyQueryFns.vertexPosition(vertex), point) < tolerance),
 		withinBox: (min, max) => withFilter((vertex) => {
-			const pos = require_faceFns.vertexPosition(vertex);
+			const pos = require_topologyQueryFns.vertexPosition(vertex);
 			return pos[0] >= min[0] - 1e-6 && pos[0] <= max[0] + 1e-6 && pos[1] >= min[1] - 1e-6 && pos[1] <= max[1] + 1e-6 && pos[2] >= min[2] - 1e-6 && pos[2] <= max[2] + 1e-6;
 		}),
 		atDistance: (distance, point = [
@@ -103,7 +109,7 @@ function buildVertexFinder(filters) {
 			0,
 			0
 		], tolerance = 1e-4) => withFilter((vertex) => {
-			const pos = require_faceFns.vertexPosition(vertex);
+			const pos = require_topologyQueryFns.vertexPosition(vertex);
 			return Math.abs(require_vecOps.vecDistance(pos, point) - distance) < tolerance;
 		})
 	}));
@@ -411,10 +417,10 @@ function convexHull(points) {
 * type is 'sphere'.
 */
 function detectSphere(shape) {
-	const faces = require_faceFns.getFaces(shape);
+	const faces = require_topologyQueryFns.getFaces(shape);
 	if (faces.length !== 1) return null;
-	const face = faces[0];
-	if (require_faceFns.getCachedSurfaceType(face) !== "sphere") return null;
+	const face = require_vec3.wasmIndex(faces, 0);
+	if (require_topologyQueryFns.getCachedSurfaceType(face) !== "sphere") return null;
 	const faceArea = require_shapeTypes.getKernel().area(face.wrapped);
 	return Math.sqrt(faceArea / (4 * Math.PI));
 }
@@ -444,8 +450,8 @@ function minkowskiSphere(shape, radius, tolerance) {
 function minkowskiGeneral(shape, tool, tolerance) {
 	const kernel = require_shapeTypes.getKernel();
 	try {
-		const shapeVerts = require_faceFns.getVertices(shape);
-		const toolVerts = require_faceFns.getVertices(tool);
+		const shapeVerts = require_topologyQueryFns.getVertices(shape);
+		const toolVerts = require_topologyQueryFns.getVertices(tool);
 		if (shapeVerts.length === 0 || toolVerts.length === 0) return require_errors.err(require_errors.kernelError(require_errors.BrepErrorCode.MINKOWSKI_FAILED, "Minkowski sum: one or both shapes have no vertices", void 0, { operation: "minkowski" }));
 		const sumPoints = [];
 		for (const sv of shapeVerts) {
@@ -938,7 +944,7 @@ function computeStraightSkeletonImpl(polygon) {
 * evaluation. The kernel builds the actual B-Rep faces and solid.
 */
 function extractPolygon(w) {
-	const pts = require_faceFns.getEdges(w).map((e) => {
+	const pts = require_topologyQueryFns.getEdges(w).map((e) => {
 		const pt = require_curveFns.curveStartPoint(e);
 		return {
 			x: pt[0],
@@ -1410,11 +1416,11 @@ function checkInterference(shape1, shape2, tolerance = 1e-6) {
 */
 function checkAllInterferences(shapes, tolerance = 1e-6) {
 	const pairs = [];
-	const boxes = shapes.map((s) => require_faceFns.getBounds(s));
+	const boxes = shapes.map((s) => require_topologyQueryFns.getBounds(s));
 	shapes.forEach((si, i) => {
 		for (let j = i + 1; j < shapes.length; j++) {
-			if (aabbDisjoint(boxes[i], boxes[j], tolerance)) continue;
-			const result = require_errors.unwrap(checkInterference(si, shapes[j], tolerance));
+			if (aabbDisjoint(require_vec3.wasmIndex(boxes, i), require_vec3.wasmIndex(boxes, j), tolerance)) continue;
+			const result = require_errors.unwrap(checkInterference(si, require_vec3.wasmIndex(shapes, j), tolerance));
 			if (result.hasInterference) pairs.push({
 				i,
 				j,
@@ -2118,7 +2124,7 @@ function chamfer(shape, edgesOrDistance, maybeDistance) {
 	}
 	const normalized = normalizeChamferDistance(distance);
 	if (normalized.mode === "distAngle") {
-		const selectedEdges = edges ?? require_faceFns.getEdges(s);
+		const selectedEdges = edges ?? require_topologyQueryFns.getEdges(s);
 		return require_primitiveFns.chamferDistAngle(s, [...selectedEdges], normalized.distance, normalized.angle);
 	}
 	return require_primitiveFns.chamfer(s, edges, normalized.distance);
@@ -2167,7 +2173,7 @@ function meshEdges(shape, options) {
 }
 /** Get a summary description of a shape. */
 function describe(shape) {
-	return require_faceFns.describe(resolve(shape));
+	return require_topologyQueryFns.describe(resolve(shape));
 }
 /** Serialize a shape to BREP format. */
 function toBREP(shape) {
@@ -2223,14 +2229,14 @@ function revolve(face, options) {
 */
 function loft(wires, options) {
 	const resolvedWires = wires.map((w) => resolve(w));
-	return require_boolean2D.loft(resolvedWires, options);
+	return require_textBlueprints.loft(resolvedWires, options);
 }
 //#endregion
 //#region src/operations/compoundOpsFns.ts
 /** Resolve a face selection: Face, FinderFn, or default (top Z-facing face). */
 function resolveTargetFace(shape, faceSpec) {
 	if (faceSpec === void 0) {
-		const faces = require_faceFns.getFaces(shape);
+		const faces = require_topologyQueryFns.getFaces(shape);
 		if (faces.length === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.COMPOUND_NO_FACES, "compoundOps: shape has no faces"));
 		let best = require_arrayAccess.firstOrThrow(faces);
 		let bestZ = require_faceFns.faceCenter(best)[2];
@@ -2247,7 +2253,7 @@ function resolveTargetFace(shape, faceSpec) {
 	if (typeof faceSpec === "function") {
 		const found = faceSpec(require_helpers.faceFinder()).findAll(shape);
 		if (found.length === 0) return require_errors.err(require_errors.queryError(require_errors.BrepErrorCode.COMPOUND_FACE_NOT_FOUND, "compoundOps: face finder matched no faces"));
-		return require_errors.ok(found[0]);
+		return require_errors.ok(require_vec3.wasmIndex(found, 0));
 	}
 	return require_errors.ok(faceSpec);
 }
@@ -2285,7 +2291,7 @@ function drill(shape, options) {
 	let tool;
 	if (options.depth !== void 0) tool = require_solidBuilders.makeCylinder(radius, options.depth, pos, dir);
 	else {
-		const b = require_faceFns.getBounds(s);
+		const b = require_topologyQueryFns.getBounds(s);
 		const corners = [
 			[
 				b.xMin,
@@ -2457,6 +2463,15 @@ function unwrapOrThrow(result) {
 	if (require_errors.isErr(result)) throw new BrepWrapperError(result.error);
 	return result.value;
 }
+function asValidSolid(s) {
+	return s;
+}
+function asOrientedPlanarFace(f) {
+	return f;
+}
+function asClosedWire(w) {
+	return w;
+}
 function createWrappedBase(val) {
 	return {
 		val,
@@ -2496,7 +2511,7 @@ function createWrappedBase(val) {
 			0,
 			1
 		] })),
-		bounds: () => require_faceFns.getBounds(val),
+		bounds: () => require_topologyQueryFns.getBounds(val),
 		describe: () => describe(val),
 		clone: () => wrapAny(unwrapOrThrow(clone(val))),
 		mesh: (opts) => mesh(val, opts),
@@ -2538,16 +2553,16 @@ function createWrapped3D(val) {
 		split: (tools) => wrapAny(unwrapOrThrow(split(val, tools))),
 		slice: (planes, opts) => unwrapOrThrow(slice(val, planes, opts)),
 		fillet(...args) {
-			if (args.length === 1) return wrap3D(unwrapOrThrow(fillet(val, args[0])));
-			return wrap3D(unwrapOrThrow(fillet(val, args[0], args[1])));
+			if (args.length === 1) return wrap3D(unwrapOrThrow(fillet(asValidSolid(val), args[0])));
+			return wrap3D(unwrapOrThrow(fillet(asValidSolid(val), args[0], args[1])));
 		},
 		chamfer(...args) {
-			if (args.length === 1) return wrap3D(unwrapOrThrow(chamfer(val, args[0])));
-			return wrap3D(unwrapOrThrow(chamfer(val, args[0], args[1])));
+			if (args.length === 1) return wrap3D(unwrapOrThrow(chamfer(asValidSolid(val), args[0])));
+			return wrap3D(unwrapOrThrow(chamfer(asValidSolid(val), args[0], args[1])));
 		},
-		shell: (faces, thickness, opts) => wrap3D(unwrapOrThrow(shell(val, faces, thickness, opts))),
-		offset: (distance, opts) => wrap3D(unwrapOrThrow(offset(val, distance, opts))),
-		draft: (faces, opts) => wrap3D(unwrapOrThrow(draft(val, faces, opts))),
+		shell: (faces, thickness, opts) => wrap3D(unwrapOrThrow(shell(asValidSolid(val), faces, thickness, opts))),
+		offset: (distance, opts) => wrap3D(unwrapOrThrow(offset(asValidSolid(val), distance, opts))),
+		draft: (faces, opts) => wrap3D(unwrapOrThrow(draft(asValidSolid(val), faces, opts))),
 		drill: (opts) => wrap3D(unwrapOrThrow(drill(val, opts))),
 		pocket: (opts) => wrap3D(unwrapOrThrow(pocket(val, opts))),
 		boss: (opts) => wrap3D(unwrapOrThrow(boss(val, opts))),
@@ -2557,10 +2572,10 @@ function createWrapped3D(val) {
 		area: () => unwrapOrThrow(require_measureFns.measureArea(val)),
 		volumeProps: () => unwrapOrThrow(require_measureFns.measureVolumeProps(val)),
 		surfaceProps: () => unwrapOrThrow(require_measureFns.measureSurfaceProps(val)),
-		edges: () => require_faceFns.getEdges(val),
-		faces: () => require_faceFns.getFaces(val),
-		wires: () => require_faceFns.getWires(val),
-		vertices: () => require_faceFns.getVertices(val),
+		edges: () => require_topologyQueryFns.getEdges(val),
+		faces: () => require_topologyQueryFns.getFaces(val),
+		wires: () => require_topologyQueryFns.getWires(val),
+		vertices: () => require_topologyQueryFns.getVertices(val),
 		linearPattern: (dir, count, spacing) => wrap3D(unwrapOrThrow(require_historyFns.linearPattern(val, dir, count, spacing))),
 		circularPattern: (axis, count, angle) => wrap3D(unwrapOrThrow(require_historyFns.circularPattern(val, axis, count, angle)))
 	};
@@ -2576,7 +2591,7 @@ function createWrappedCurve(val) {
 		isClosed: () => require_curveFns.curveIsClosed(val),
 		sweep(spine, opts) {
 			if (!require_shapeTypes.isWire(val)) throw new Error("sweep requires a Wire");
-			const result = unwrapOrThrow(require_extrudeFns.sweep(val, resolve(spine), opts));
+			const result = unwrapOrThrow(require_extrudeFns.sweep(asClosedWire(val), resolve(spine), opts));
 			return wrap3D(Array.isArray(result) ? result[0] : result);
 		}
 	};
@@ -2590,8 +2605,8 @@ function createWrappedFace(val) {
 		surfaceType: () => unwrapOrThrow(require_faceFns.getSurfaceType(val)),
 		outerWire: () => require_faceFns.outerWire(val),
 		innerWires: () => require_faceFns.innerWires(val),
-		extrude: (height) => wrap3D(unwrapOrThrow(extrude(val, height))),
-		revolve: (opts) => wrap3D(unwrapOrThrow(revolve(val, opts)))
+		extrude: (height) => wrap3D(unwrapOrThrow(extrude(asOrientedPlanarFace(val), height))),
+		revolve: (opts) => wrap3D(unwrapOrThrow(revolve(asOrientedPlanarFace(val), opts)))
 	};
 }
 function wrapAny(val) {
@@ -2613,9 +2628,644 @@ function shape(s) {
 	}
 	throw new Error("shape() requires a Sketch or branded shape type");
 }
+var DEFAULT_CLEARANCE = .25;
+var inv = (alpha) => Math.tan(alpha) - alpha;
+function involutePoint(rb, alpha, theta0, sign) {
+	const r = rb / Math.cos(alpha);
+	const theta = theta0 + sign * (Math.tan(alpha) - alpha);
+	return [
+		r * Math.cos(theta),
+		r * Math.sin(theta),
+		0
+	];
+}
+function cosineSpaceFlankSamples(rb, alphaMax, theta0, count, sign) {
+	const pts = [];
+	for (let i = 0; i <= count; i++) {
+		const t = .5 - .5 * Math.cos(i / count * Math.PI);
+		pts.push(involutePoint(rb, t * alphaMax, theta0, sign));
+	}
+	return pts;
+}
+function adaptiveSampleCount(moduleSize) {
+	return Math.max(16, Math.round(8 * Math.sqrt(moduleSize)));
+}
+function gearGeometry(z, moduleSize, alpha, shift, clearance, backlashHalf, isInternal) {
+	const rPitch = z * moduleSize / 2;
+	const rb = rPitch * Math.cos(alpha);
+	const addendum = moduleSize * (1 + shift);
+	const dedendum = moduleSize * (1 + clearance - shift);
+	const rTip = isInternal ? rPitch - moduleSize * (1 - shift) : rPitch + addendum;
+	const rRoot = isInternal ? rPitch + moduleSize * (1 + clearance + shift) : rPitch - dedendum;
+	const blAng = backlashHalf / rPitch;
+	const halfToothAngle = (Math.PI / 2 + 2 * shift * Math.tan(alpha)) / z + (isInternal ? blAng : -blAng);
+	const rOuter = isInternal ? rRoot : rTip;
+	return {
+		rPitch,
+		rb,
+		rTip,
+		rRoot,
+		alphaPitch: alpha,
+		halfToothAngle,
+		alphaTip: rOuter <= rb ? 0 : Math.acos(Math.min(1, rb / rOuter)),
+		toothPitch: 2 * Math.PI / z,
+		isInternal
+	};
+}
+/**
+* Solve `inv(αw) = inv(α) + 2·(summedShift)·tan α / totalTeeth` by bisection.
+*
+* For external-external mesh: summedShift = x1 + x2, totalTeeth = z1 + z2.
+* For external-internal mesh: summedShift = xInternal − xExternal, totalTeeth = zInternal − zExternal.
+*
+* Returns Err for shifts that push αw outside (epsilon, π/2).
+*/
+function solveWorkingPressureAngle(alpha, summedShift, totalTeeth) {
+	if (summedShift === 0) return require_errors.ok(alpha);
+	const target = inv(alpha) + 2 * summedShift * Math.tan(alpha) / totalTeeth;
+	const epsilon = 1e-4;
+	let lo, hi;
+	if (target > inv(alpha)) {
+		lo = alpha;
+		hi = Math.PI / 2 - 1e-6;
+	} else {
+		lo = epsilon;
+		hi = alpha;
+	}
+	if (target > inv(hi) || target < inv(lo)) return require_errors.err(require_errors.validationError("GEAR_PA_OUT_OF_RANGE", `working pressure angle out of range — target inv(αw)=${target.toFixed(4)} not in [${inv(lo).toFixed(4)}, ${inv(hi).toFixed(4)}]`, void 0, {
+		target,
+		invLo: inv(lo),
+		invHi: inv(hi)
+	}));
+	for (let i = 0; i < 50; i++) {
+		const mid = .5 * (lo + hi);
+		if (inv(mid) < target) lo = mid;
+		else hi = mid;
+	}
+	return require_errors.ok(.5 * (lo + hi));
+}
+/** Convenience: working PA for an external-external mesh (sun-planet). */
+function solveSunPlanetWorkingPressureAngle(alpha, xSun, xPlanet, zSun, zPlanet) {
+	return solveWorkingPressureAngle(alpha, xSun + xPlanet, zSun + zPlanet);
+}
+/** Convenience: working PA for an external-internal mesh (planet-ring). */
+function solvePlanetRingWorkingPressureAngle(alpha, xPlanet, xRing, zPlanet, zRing) {
+	return solveWorkingPressureAngle(alpha, xRing - xPlanet, zRing - zPlanet);
+}
+function workingCenterDistance(zs, zp, moduleSize, alpha, alphaW) {
+	return (zs + zp) * moduleSize * Math.cos(alpha) / (2 * Math.cos(alphaW));
+}
+function validatePlanetary(zs, zp, n, planetShift) {
+	if (!Number.isInteger(zs) || !Number.isInteger(zp) || !Number.isInteger(n)) return require_errors.err(require_errors.validationError("GEAR_NON_INTEGER_TEETH", "tooth counts and planet count must be integers"));
+	if (zs < 4 || zp < 4 || n < 2) return require_errors.err(require_errors.validationError("GEAR_TEETH_TOO_FEW", "zs ≥ 4, zp ≥ 4, N ≥ 2 required"));
+	if ((2 * zs + 2 * zp) % n !== 0) return require_errors.err(require_errors.validationError("GEAR_ASSEMBLY", `(2·zs + 2·zp) must be divisible by N — got ${2 * zs + 2 * zp} mod ${n} = ${(2 * zs + 2 * zp) % n}`));
+	const planetTipDiameter = zp + 2 + 2 * planetShift;
+	const minClearance = (zs + zp) * Math.sin(Math.PI / n);
+	if (minClearance <= planetTipDiameter) return require_errors.err(require_errors.validationError("GEAR_PLANET_COLLISION", `planet tips would collide: (zs+zp)·sin(π/N) = ${minClearance.toFixed(3)} ≤ planet tip = ${planetTipDiameter.toFixed(3)}`));
+	return require_errors.ok(void 0);
+}
+function externalExternalContactRatio(ra1, rb1, ra2, rb2, centerDistance, moduleSize, alpha, alphaW) {
+	return (Math.sqrt(Math.max(0, ra1 * ra1 - rb1 * rb1)) + Math.sqrt(Math.max(0, ra2 * ra2 - rb2 * rb2)) - centerDistance * Math.sin(alphaW)) / (Math.PI * moduleSize * Math.cos(alpha));
+}
+function externalInternalContactRatio(ra_p, rb_p, ra_r, rb_r, centerDistance, moduleSize, alpha, alphaW) {
+	return (Math.sqrt(Math.max(0, ra_p * ra_p - rb_p * rb_p)) - Math.sqrt(Math.max(0, ra_r * ra_r - rb_r * rb_r)) + centerDistance * Math.sin(alphaW)) / (Math.PI * moduleSize * Math.cos(alpha));
+}
+function undercutMinimumShift(z, alpha) {
+	return 1 - z * Math.sin(alpha) * Math.sin(alpha) / 2;
+}
+function undercutDeficit(z, alpha, shift) {
+	return Math.max(0, undercutMinimumShift(z, alpha) - shift);
+}
+function lewisYFactor(z) {
+	if (z < 8) return .2;
+	return .485 - 2.88 / z;
+}
+function lewisRootStress(appliedTorqueNm, moduleSize, faceWidth, z) {
+	const torqueNmm = appliedTorqueNm * 1e3;
+	const Y = lewisYFactor(z);
+	if (Y <= 0 || faceWidth <= 0 || moduleSize <= 0) return Infinity;
+	return 2 * torqueNmm / (z * moduleSize * moduleSize * faceWidth * Y);
+}
+/**
+* Dolan-Broghamer fit is for *external* spur teeth. Set `isInternal=true` on
+* ring gears to apply Niemann's 0.85× reduction — the concave root fillet has
+* a gentler geometric riser (matches AGMA 908-B89 trend).
+*/
+function filletStressConcentrationFactor(z, alpha, isInternal = false) {
+	const kf20 = 1.4 + 6.5 / z;
+	const alphaDeg = alpha * 180 / Math.PI;
+	const kf = kf20 * Math.pow(20 / alphaDeg, .15);
+	return isInternal ? kf * .85 : kf;
+}
+function lewisRootStressCorrected(appliedTorqueNm, moduleSize, faceWidth, z, alpha, isInternal = false) {
+	return lewisRootStress(appliedTorqueNm, moduleSize, faceWidth, z) * filletStressConcentrationFactor(z, alpha, isInternal);
+}
+function backlashHalf(totalBacklash) {
+	return totalBacklash / 2;
+}
+function ringTeeth(zs, zp) {
+	return zs + 2 * zp;
+}
+function evenToothPhaseOffset(z) {
+	return z % 2 === 0 ? Math.PI / z : 0;
+}
+function planetSelfRotationAngle(orbitalAngle, zs, zp) {
+	return orbitalAngle * (1 + zs / zp) + evenToothPhaseOffset(zp);
+}
+/**
+* Compute the rigid placement of each planet without building any solid.
+*
+* Pairs with one materialized planet from `makeExternalGear` to support
+* GPU-instanced rendering: mesh once, draw N times under these transforms.
+* Defaults match {@link PlanetaryGearParams}.
+*/
+function planetPlacements(params = {}) {
+	const moduleSize = params.moduleSize ?? 3;
+	const sunTeeth = params.sunTeeth ?? 15;
+	const planetTeeth = params.planetTeeth ?? 12;
+	const numPlanets = params.numPlanets ?? 3;
+	const alpha = (params.pressureAngleDeg ?? 20) * Math.PI / 180;
+	const sunShift = params.sunShift ?? 0;
+	const planetShift = params.planetShift ?? 0;
+	const validation = validatePlanetary(sunTeeth, planetTeeth, numPlanets, planetShift);
+	if (require_errors.isErr(validation)) return validation;
+	const sp = solveSunPlanetWorkingPressureAngle(alpha, sunShift, planetShift, sunTeeth, planetTeeth);
+	if (require_errors.isErr(sp)) return sp;
+	const centerDistance = workingCenterDistance(sunTeeth, planetTeeth, moduleSize, alpha, sp.value);
+	const placements = [];
+	for (let i = 0; i < numPlanets; i++) {
+		const orbital = i * 2 * Math.PI / numPlanets;
+		const selfRot = planetSelfRotationAngle(orbital, sunTeeth, planetTeeth);
+		placements.push({
+			rotationDeg: selfRot * 180 / Math.PI,
+			position: [
+				centerDistance * Math.cos(orbital),
+				centerDistance * Math.sin(orbital),
+				0
+			]
+		});
+	}
+	return require_errors.ok(placements);
+}
+//#endregion
+//#region src/gear/gearProfile.ts
+function buildToothPeriodEdges(tm, toothIndex, totalTeeth, samples, scope) {
+	const center = toothIndex * tm.toothPitch;
+	const nextCenter = (toothIndex + 1) % totalTeeth * tm.toothPitch;
+	const invPitch = inv(tm.alphaPitch);
+	const thetaLeft = center - tm.halfToothAngle - invPitch;
+	const thetaRight = center + tm.halfToothAngle + invPitch;
+	const leftFlank = cosineSpaceFlankSamples(tm.rb, tm.alphaTip, thetaLeft, samples, 1);
+	const rightFlank = cosineSpaceFlankSamples(tm.rb, tm.alphaTip, thetaRight, samples, -1).reverse();
+	const leftBase = require_arrayAccess.firstOrThrow(leftFlank);
+	const leftTip = require_arrayAccess.lastOrThrow(leftFlank);
+	const rightTip = require_arrayAccess.firstOrThrow(rightFlank);
+	const rightBase = require_arrayAccess.lastOrThrow(rightFlank);
+	const edges = [];
+	const push = (e) => {
+		scope.register(e);
+		edges.push(e);
+	};
+	const needsRadialBridge = tm.isInternal ? tm.rb < tm.rRoot : tm.rb > tm.rRoot;
+	if (needsRadialBridge) push(require_surfaceBuilders.makeLine([
+		tm.rRoot * Math.cos(thetaLeft),
+		tm.rRoot * Math.sin(thetaLeft),
+		0
+	], leftBase));
+	const interpTol = tm.rPitch * 1e-5;
+	const leftEdge = require_surfaceBuilders.makeBSplineInterpolation(leftFlank, { tolerance: interpTol });
+	if (require_errors.isErr(leftEdge)) return leftEdge;
+	push(leftEdge.value);
+	push(require_surfaceBuilders.makeThreePointArc(leftTip, [
+		tm.rTip * Math.cos(center),
+		tm.rTip * Math.sin(center),
+		0
+	], rightTip));
+	const rightEdge = require_surfaceBuilders.makeBSplineInterpolation(rightFlank, { tolerance: interpTol });
+	if (require_errors.isErr(rightEdge)) return rightEdge;
+	push(rightEdge.value);
+	if (needsRadialBridge) push(require_surfaceBuilders.makeLine(rightBase, [
+		tm.rRoot * Math.cos(thetaRight),
+		tm.rRoot * Math.sin(thetaRight),
+		0
+	]));
+	const rootEndAngle = nextCenter - tm.halfToothAngle - invPitch;
+	let midAngle = .5 * (thetaRight + rootEndAngle);
+	if (rootEndAngle < thetaRight) midAngle += Math.PI;
+	push(require_surfaceBuilders.makeThreePointArc(needsRadialBridge ? [
+		tm.rRoot * Math.cos(thetaRight),
+		tm.rRoot * Math.sin(thetaRight),
+		0
+	] : rightBase, [
+		tm.rRoot * Math.cos(midAngle),
+		tm.rRoot * Math.sin(midAngle),
+		0
+	], needsRadialBridge ? [
+		tm.rRoot * Math.cos(rootEndAngle),
+		tm.rRoot * Math.sin(rootEndAngle),
+		0
+	] : [
+		tm.rb * Math.cos(rootEndAngle),
+		tm.rb * Math.sin(rootEndAngle),
+		0
+	]));
+	return require_errors.ok(edges);
+}
+function makeExternalGearProfileWire(params) {
+	return makeProfileWire(params, false);
+}
+function makeInternalGearProfileWire(params) {
+	return makeProfileWire(params, true);
+}
+function makeProfileWire(params, isInternal) {
+	try {
+		var _usingCtx$2 = require_shapeTypes._usingCtx();
+		const { teeth, moduleSize, pressureAngle, shift, clearance, flankThinning, samples = adaptiveSampleCount(moduleSize) } = params;
+		if (teeth < 4) return require_errors.err(require_errors.validationError("GEAR_TEETH_TOO_FEW", `gear needs ≥ 4 teeth, got ${teeth}`));
+		if (moduleSize <= 0) return require_errors.err(require_errors.validationError("GEAR_MODULE_NONPOSITIVE", `module must be > 0, got ${moduleSize}`));
+		const tm = gearGeometry(teeth, moduleSize, pressureAngle, shift, clearance, flankThinning, isInternal);
+		const scope = _usingCtx$2.u(new require_shapeTypes.DisposalScope());
+		const allEdges = [];
+		for (let i = 0; i < teeth; i++) {
+			const periodEdges = buildToothPeriodEdges(tm, i, teeth, samples, scope);
+			if (require_errors.isErr(periodEdges)) return periodEdges;
+			allEdges.push(...periodEdges.value);
+		}
+		const wireResult = require_surfaceBuilders.assembleWire(allEdges);
+		if (require_errors.isErr(wireResult)) return wireResult;
+		return require_errors.ok(wireResult.value);
+	} catch (_) {
+		_usingCtx$2.e = _;
+	} finally {
+		_usingCtx$2.d();
+	}
+}
+//#endregion
+//#region src/gear/gearFns.ts
+function makeExternalGear(params) {
+	const { teeth, moduleSize, thickness, pressureAngleDeg = 20, shift = 0, clearance = DEFAULT_CLEARANCE, flankThinning = 0, bore = 0, samples } = params;
+	if (thickness <= 0) return require_errors.err(require_errors.validationError("GEAR_THICKNESS_NONPOSITIVE", "thickness must be > 0"));
+	if (samples !== void 0 && (!Number.isInteger(samples) || samples < 1)) return require_errors.err(require_errors.validationError("GEAR_SAMPLES_INVALID", `samples must be a positive integer; got ${String(samples)}`));
+	const alpha = pressureAngleDeg * Math.PI / 180;
+	const geom = gearGeometry(teeth, moduleSize, alpha, shift, clearance, flankThinning, false);
+	if (bore > 0 && bore >= 2 * geom.rRoot) return require_errors.err(require_errors.validationError("GEAR_BORE_TOO_LARGE", `bore diameter ${bore.toFixed(2)} ≥ root diameter ${(2 * geom.rRoot).toFixed(2)} — would erase the gear teeth`));
+	const wireResult = makeExternalGearProfileWire({
+		teeth,
+		moduleSize,
+		pressureAngle: alpha,
+		shift,
+		clearance,
+		flankThinning,
+		...samples !== void 0 ? { samples } : {}
+	});
+	if (require_errors.isErr(wireResult)) return wireResult;
+	const diagnostics = externalGearDiagnostics(teeth, alpha, shift);
+	return finalizeExternalSolid(wireResult.value, thickness, bore, geom, diagnostics);
+}
+function makeInternalGear(params) {
+	const { teeth, moduleSize, thickness, pressureAngleDeg = 20, shift = 0, clearance = DEFAULT_CLEARANCE, flankThinning = 0, ringWallThickness = 2 * params.moduleSize, samples } = params;
+	if (thickness <= 0) return require_errors.err(require_errors.validationError("GEAR_THICKNESS_NONPOSITIVE", "thickness must be > 0"));
+	if (ringWallThickness <= 0) return require_errors.err(require_errors.validationError("GEAR_WALL_NONPOSITIVE", "ringWallThickness must be > 0"));
+	if (samples !== void 0 && (!Number.isInteger(samples) || samples < 1)) return require_errors.err(require_errors.validationError("GEAR_SAMPLES_INVALID", `samples must be a positive integer; got ${String(samples)}`));
+	const alpha = pressureAngleDeg * Math.PI / 180;
+	const innerWireResult = makeInternalGearProfileWire({
+		teeth,
+		moduleSize,
+		pressureAngle: alpha,
+		shift,
+		clearance,
+		flankThinning,
+		...samples !== void 0 ? { samples } : {}
+	});
+	if (require_errors.isErr(innerWireResult)) return innerWireResult;
+	const geom = gearGeometry(teeth, moduleSize, alpha, shift, clearance, flankThinning, true);
+	const outerWireResult = makeOuterCircleWire(geom.rPitch + ringWallThickness);
+	if (require_errors.isErr(outerWireResult)) return outerWireResult;
+	return finalizeInternalSolid(outerWireResult.value, innerWireResult.value, thickness, geom, []);
+}
+/** Diagnostics for an external (rack-cut) gear in isolation. Not valid for internal gears. */
+function externalGearDiagnostics(teeth, alpha, shift) {
+	const deficit = undercutDeficit(teeth, alpha, shift);
+	if (deficit <= 0) return [];
+	return [{
+		code: "UNDERCUT_RISK",
+		severity: "warning",
+		message: `gear is undercut: increase shift by ${deficit.toFixed(3)} to avoid (z=${teeth})`,
+		context: {
+			deficit,
+			teeth
+		}
+	}];
+}
+function makePlanetaryGear(params) {
+	const resolved = resolvePlanetaryParams(params);
+	if (require_errors.isErr(resolved)) return resolved;
+	const cfg = resolved.value;
+	const stages = buildPlanetaryStages(cfg);
+	if (require_errors.isErr(stages)) return stages;
+	const { sun, planet, ring } = stages.value;
+	const metrics = computeMeshMetrics(cfg, sun, planet, ring);
+	const planets = placePlanets(planet.solid, cfg);
+	planet.solid.delete();
+	const ringPhased = applyRingPhase(ring.solid, cfg.zr);
+	const diagnostics = collectDiagnostics(cfg, metrics);
+	return require_errors.ok({
+		sun: sun.solid,
+		planets,
+		ring: ringPhased,
+		ringTeeth: cfg.zr,
+		workingPressureAngle: cfg.alphaW_sp,
+		centerDistance: cfg.centerDistance,
+		contactRatio: {
+			sunPlanet: metrics.crSunPlanet,
+			planetRing: metrics.crPlanetRing
+		},
+		undercutDeficit: {
+			sun: metrics.undercutSun,
+			planet: metrics.undercutPlanet
+		},
+		...metrics.lewisStress ? { lewisStress: metrics.lewisStress } : {},
+		...metrics.stressConcentrationFactor ? { stressConcentrationFactor: metrics.stressConcentrationFactor } : {},
+		diagnostics
+	});
+}
+function buildPlanetaryStages(cfg) {
+	const samplesField = cfg.samples !== void 0 ? { samples: cfg.samples } : {};
+	const common = {
+		moduleSize: cfg.moduleSize,
+		thickness: cfg.thickness,
+		pressureAngleDeg: cfg.pressureAngleDeg,
+		clearance: cfg.clearance,
+		flankThinning: cfg.bHalf,
+		...samplesField
+	};
+	const sun = makeExternalGear({
+		...common,
+		teeth: cfg.sunTeeth,
+		shift: cfg.sunShift,
+		bore: cfg.sunBore
+	});
+	if (require_errors.isErr(sun)) return sun;
+	const planet = makeExternalGear({
+		...common,
+		teeth: cfg.planetTeeth,
+		shift: cfg.planetShift,
+		bore: cfg.planetBore
+	});
+	if (require_errors.isErr(planet)) {
+		sun.value.solid.delete();
+		return planet;
+	}
+	const ring = makeInternalGear({
+		...common,
+		teeth: cfg.zr,
+		shift: cfg.ringShift,
+		ringWallThickness: cfg.ringWallThickness
+	});
+	if (require_errors.isErr(ring)) {
+		sun.value.solid.delete();
+		planet.value.solid.delete();
+		return ring;
+	}
+	return require_errors.ok({
+		sun: sun.value,
+		planet: planet.value,
+		ring: ring.value
+	});
+}
+function resolvePlanetaryParams(params) {
+	const moduleSize = params.moduleSize ?? 3;
+	const sunTeeth = params.sunTeeth ?? 15;
+	const planetTeeth = params.planetTeeth ?? 12;
+	const numPlanets = params.numPlanets ?? 3;
+	const pressureAngleDeg = params.pressureAngleDeg ?? 20;
+	const alpha = pressureAngleDeg * Math.PI / 180;
+	const sunShift = params.sunShift ?? 0;
+	const planetShift = params.planetShift ?? 0;
+	const ringShift = params.ringShift ?? 0;
+	if (params.thickness <= 0) return require_errors.err(require_errors.validationError("GEAR_THICKNESS_NONPOSITIVE", "thickness must be > 0"));
+	const validation = validatePlanetary(sunTeeth, planetTeeth, numPlanets, planetShift);
+	if (require_errors.isErr(validation)) return validation;
+	const zr = ringTeeth(sunTeeth, planetTeeth);
+	const sp = solveSunPlanetWorkingPressureAngle(alpha, sunShift, planetShift, sunTeeth, planetTeeth);
+	if (require_errors.isErr(sp)) return sp;
+	const pr = solvePlanetRingWorkingPressureAngle(alpha, planetShift, ringShift, planetTeeth, zr);
+	if (require_errors.isErr(pr)) return pr;
+	const centerDistance = workingCenterDistance(sunTeeth, planetTeeth, moduleSize, alpha, sp.value);
+	return require_errors.ok({
+		moduleSize,
+		sunTeeth,
+		planetTeeth,
+		numPlanets,
+		pressureAngleDeg,
+		alpha,
+		alphaW_sp: sp.value,
+		alphaW_pr: pr.value,
+		clearance: params.clearance ?? .25,
+		bHalf: backlashHalf(params.backlash ?? 0),
+		sunShift,
+		planetShift,
+		ringShift,
+		ringWallThickness: params.ringWallThickness ?? 2 * moduleSize,
+		thickness: params.thickness,
+		sunBore: params.sunBore ?? 0,
+		planetBore: params.planetBore ?? 0,
+		...params.appliedTorque !== void 0 ? { appliedTorque: params.appliedTorque } : {},
+		...params.samples !== void 0 ? { samples: params.samples } : {},
+		zr,
+		centerDistance
+	});
+}
+function makeOuterCircleWire(radius) {
+	try {
+		var _usingCtx$1 = require_shapeTypes._usingCtx();
+		const wireResult = require_surfaceBuilders.assembleWire([_usingCtx$1.u(new require_shapeTypes.DisposalScope()).register(require_surfaceBuilders.makeCircle(radius, [
+			0,
+			0,
+			0
+		], [
+			0,
+			0,
+			1
+		]))]);
+		if (require_errors.isErr(wireResult)) return wireResult;
+		return require_errors.ok(wireResult.value);
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
+}
+function finalizeExternalSolid(wire, thickness, bore, geom, diagnostics) {
+	try {
+		var _usingCtx3 = require_shapeTypes._usingCtx();
+		const faceResult = require_surfaceBuilders.makeFace(wire);
+		if (require_errors.isErr(faceResult)) return faceResult;
+		const solidResult = require_extrudeFns.extrude(faceResult.value, [
+			0,
+			0,
+			thickness
+		]);
+		if (require_errors.isErr(solidResult)) return solidResult;
+		if (bore <= 0) return require_errors.ok(buildGearResult(solidResult.value, geom, diagnostics));
+		const boreScope = _usingCtx3.u(new require_shapeTypes.DisposalScope());
+		const boreFaceResult = makeBoreFace(bore / 2);
+		if (require_errors.isErr(boreFaceResult)) return boreFaceResult;
+		boreScope.register(boreFaceResult.value);
+		const boreRaw = require_extrudeFns.extrude(boreFaceResult.value, [
+			0,
+			0,
+			thickness + 1
+		]);
+		if (require_errors.isErr(boreRaw)) return boreRaw;
+		boreScope.register(boreRaw.value);
+		const boreSolid = boreScope.register(require_shapeFns.translate(boreRaw.value, [
+			0,
+			0,
+			-.5
+		]));
+		const cutResult = require_booleanFns.cut(solidResult.value, boreSolid);
+		if (require_errors.isErr(cutResult)) return cutResult;
+		return require_errors.ok(buildGearResult(cutResult.value, geom, diagnostics));
+	} catch (_) {
+		_usingCtx3.e = _;
+	} finally {
+		_usingCtx3.d();
+	}
+}
+function makeBoreFace(radius) {
+	const wireResult = makeOuterCircleWire(radius);
+	if (require_errors.isErr(wireResult)) return wireResult;
+	return require_surfaceBuilders.makeFace(wireResult.value);
+}
+function finalizeInternalSolid(outerWire, innerToothedWire, thickness, geom, diagnostics) {
+	const faceResult = require_surfaceBuilders.makeFace(outerWire, [innerToothedWire]);
+	if (require_errors.isErr(faceResult)) return faceResult;
+	const solidResult = require_extrudeFns.extrude(faceResult.value, [
+		0,
+		0,
+		thickness
+	]);
+	if (require_errors.isErr(solidResult)) return solidResult;
+	return require_errors.ok(buildGearResult(solidResult.value, geom, diagnostics));
+}
+function buildGearResult(solid, geom, diagnostics = []) {
+	return {
+		solid,
+		diagnostics,
+		pitchDiameter: 2 * geom.rPitch,
+		baseDiameter: 2 * geom.rb,
+		tipDiameter: 2 * geom.rTip,
+		rootDiameter: 2 * geom.rRoot
+	};
+}
+function placePlanets(planetProto, cfg) {
+	const planets = [];
+	try {
+		for (let i = 0; i < cfg.numPlanets; i++) {
+			const orbital = i * 2 * Math.PI / cfg.numPlanets;
+			const rotated = require_shapeFns.rotate(planetProto, planetSelfRotationAngle(orbital, cfg.sunTeeth, cfg.planetTeeth) * 180 / Math.PI);
+			try {
+				const offset = [
+					cfg.centerDistance * Math.cos(orbital),
+					cfg.centerDistance * Math.sin(orbital),
+					0
+				];
+				planets.push(require_shapeFns.translate(rotated, offset));
+			} finally {
+				rotated.delete();
+			}
+		}
+		return planets;
+	} catch (e) {
+		for (const p of planets) p.delete();
+		throw e;
+	}
+}
+function applyRingPhase(ring, zr) {
+	const phaseRad = evenToothPhaseOffset(zr);
+	if (phaseRad === 0) return ring;
+	const rotated = require_shapeFns.rotate(ring, phaseRad * 180 / Math.PI);
+	ring.delete();
+	return rotated;
+}
+function computeMeshMetrics(cfg, sun, planet, ring) {
+	const metrics = {
+		crSunPlanet: externalExternalContactRatio(sun.tipDiameter / 2, sun.baseDiameter / 2, planet.tipDiameter / 2, planet.baseDiameter / 2, cfg.centerDistance, cfg.moduleSize, cfg.alpha, cfg.alphaW_sp),
+		crPlanetRing: externalInternalContactRatio(planet.tipDiameter / 2, planet.baseDiameter / 2, ring.tipDiameter / 2, ring.baseDiameter / 2, cfg.centerDistance, cfg.moduleSize, cfg.alpha, cfg.alphaW_pr),
+		undercutSun: undercutDeficit(cfg.sunTeeth, cfg.alpha, cfg.sunShift),
+		undercutPlanet: undercutDeficit(cfg.planetTeeth, cfg.alpha, cfg.planetShift)
+	};
+	if (cfg.appliedTorque !== void 0) {
+		const tSun = cfg.appliedTorque;
+		metrics.lewisStress = {
+			sun: lewisRootStressCorrected(tSun, cfg.moduleSize, cfg.thickness, cfg.sunTeeth, cfg.alpha),
+			planet: lewisRootStressCorrected(tSun * cfg.planetTeeth / cfg.sunTeeth, cfg.moduleSize, cfg.thickness, cfg.planetTeeth, cfg.alpha),
+			ring: lewisRootStressCorrected(tSun * cfg.zr / cfg.sunTeeth, cfg.moduleSize, cfg.thickness, cfg.zr, cfg.alpha, true)
+		};
+		metrics.stressConcentrationFactor = {
+			sun: filletStressConcentrationFactor(cfg.sunTeeth, cfg.alpha),
+			planet: filletStressConcentrationFactor(cfg.planetTeeth, cfg.alpha),
+			ring: filletStressConcentrationFactor(cfg.zr, cfg.alpha, true)
+		};
+	}
+	return metrics;
+}
+function collectDiagnostics(cfg, metrics) {
+	const diagnostics = [];
+	if (metrics.crSunPlanet < 1.2) diagnostics.push({
+		code: "CONTACT_RATIO_LOW_SUN_PLANET",
+		severity: "warning",
+		message: `sun-planet contact ratio ${metrics.crSunPlanet.toFixed(2)} is below 1.2 — may run unevenly`,
+		context: { value: metrics.crSunPlanet }
+	});
+	if (metrics.crPlanetRing < 1.2) diagnostics.push({
+		code: "CONTACT_RATIO_LOW_PLANET_RING",
+		severity: "warning",
+		message: `planet-ring contact ratio ${metrics.crPlanetRing.toFixed(2)} is below 1.2 — may run unevenly`,
+		context: { value: metrics.crPlanetRing }
+	});
+	if (metrics.undercutSun > 0) diagnostics.push({
+		code: "UNDERCUT_RISK_SUN",
+		severity: "warning",
+		message: `sun gear is undercut: increase sunShift by ${metrics.undercutSun.toFixed(3)} to avoid`,
+		context: {
+			deficit: metrics.undercutSun,
+			sunTeeth: cfg.sunTeeth
+		}
+	});
+	if (metrics.undercutPlanet > 0) diagnostics.push({
+		code: "UNDERCUT_RISK_PLANET",
+		severity: "warning",
+		message: `planet gear is undercut: increase planetShift by ${metrics.undercutPlanet.toFixed(3)} to avoid`,
+		context: {
+			deficit: metrics.undercutPlanet,
+			planetTeeth: cfg.planetTeeth
+		}
+	});
+	const totalShiftMagnitude = Math.abs(cfg.sunShift) + Math.abs(cfg.planetShift) + Math.abs(cfg.ringShift);
+	if (cfg.appliedTorque !== void 0 && totalShiftMagnitude > .05) diagnostics.push({
+		code: "LEWIS_Y_SHIFT_UNCORRECTED",
+		severity: "info",
+		message: "Lewis stress uses unshifted Y(z) and K_f approximations; expect ±5% per 0.1 of profile shift"
+	});
+	const kinematicError = cfg.ringShift - (cfg.sunShift + 2 * cfg.planetShift);
+	if (Math.abs(kinematicError) > 1e-6) diagnostics.push({
+		code: "PLANETARY_SHIFT_KINEMATIC_MISMATCH",
+		severity: "warning",
+		message: `ringShift should equal sunShift + 2·planetShift for both meshes to share working PA; off by ${kinematicError.toFixed(3)}`,
+		context: {
+			kinematicError,
+			sunShift: cfg.sunShift,
+			planetShift: cfg.planetShift,
+			ringShift: cfg.ringShift
+		}
+	});
+	return diagnostics;
+}
 //#endregion
 //#region src/ns/primitives.ts
-var primitives_exports = /* @__PURE__ */ require_drawFns.__exportAll({
+var primitives_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	addHoles: () => require_primitiveFns.addHoles,
 	bezier: () => require_primitiveFns.bezier,
 	box: () => require_primitiveFns.box,
@@ -2648,7 +3298,7 @@ var primitives_exports = /* @__PURE__ */ require_drawFns.__exportAll({
 });
 //#endregion
 //#region src/ns/booleans.ts
-var booleans_exports = /* @__PURE__ */ require_drawFns.__exportAll({
+var booleans_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	checkBoolean: () => require_primitiveFns.checkBoolean,
 	convexHull: () => convexHull,
 	cut: () => cut,
@@ -2665,7 +3315,7 @@ var booleans_exports = /* @__PURE__ */ require_drawFns.__exportAll({
 });
 //#endregion
 //#region src/ns/modifiers.ts
-var modifiers_exports = /* @__PURE__ */ require_drawFns.__exportAll({
+var modifiers_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	chamfer: () => chamfer,
 	draft: () => draft,
 	fillet: () => fillet,
@@ -2678,7 +3328,7 @@ var modifiers_exports = /* @__PURE__ */ require_drawFns.__exportAll({
 });
 //#endregion
 //#region src/ns/transforms.ts
-var transforms_exports = /* @__PURE__ */ require_drawFns.__exportAll({
+var transforms_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	applyMatrix: () => applyMatrix,
 	clone: () => clone,
 	composeTransforms: () => require_shapeFns.composeTransforms,
@@ -2690,7 +3340,7 @@ var transforms_exports = /* @__PURE__ */ require_drawFns.__exportAll({
 });
 //#endregion
 //#region src/ns/measurement.ts
-var measurement_exports = /* @__PURE__ */ require_drawFns.__exportAll({
+var measurement_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	checkAllInterferences: () => checkAllInterferences,
 	checkInterference: () => checkInterference,
 	createDistanceQuery: () => require_measureFns.createDistanceQuery,
@@ -2707,7 +3357,7 @@ var measurement_exports = /* @__PURE__ */ require_drawFns.__exportAll({
 });
 //#endregion
 //#region src/ns/ioNs.ts
-var ioNs_exports = /* @__PURE__ */ require_drawFns.__exportAll({
+var ioNs_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	blueprintToDXF: () => require_importFns.blueprintToDXF,
 	exportAssemblySTEP: () => require_historyFns.exportAssemblySTEP,
 	exportDXF: () => require_importFns.exportDXF,
@@ -2731,7 +3381,7 @@ var ioNs_exports = /* @__PURE__ */ require_drawFns.__exportAll({
 });
 //#endregion
 //#region src/ns/query.ts
-var query_exports = /* @__PURE__ */ require_drawFns.__exportAll({
+var query_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	cornerFinder: () => require_cornerFinder.cornerFinder,
 	edgeFinder: () => require_helpers.edgeFinder,
 	faceFinder: () => require_helpers.faceFinder,
@@ -2741,7 +3391,7 @@ var query_exports = /* @__PURE__ */ require_drawFns.__exportAll({
 });
 //#endregion
 //#region src/ns/construction.ts
-var construction_exports = /* @__PURE__ */ require_drawFns.__exportAll({
+var construction_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	complexExtrude: () => require_extrudeFns.complexExtrude,
 	extrude: () => extrude,
 	guidedSweep: () => require_extrudeFns.guidedSweep,
@@ -2757,24 +3407,28 @@ var construction_exports = /* @__PURE__ */ require_drawFns.__exportAll({
 });
 //#endregion
 //#region src/ns/patterns.ts
-var patterns_exports = /* @__PURE__ */ require_drawFns.__exportAll({
+var patterns_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	circularPattern: () => require_historyFns.circularPattern,
 	linearPattern: () => require_historyFns.linearPattern
 });
 //#endregion
+exports.BaseSketcher2d = require_blueprintSketcher.BaseSketcher2d;
+exports.BlueprintSketcher = require_blueprintSketcher.BlueprintSketcher;
 exports.BrepBugError = require_errors.BrepBugError;
 exports.BrepErrorCode = require_errors.BrepErrorCode;
 exports.BrepWrapperError = BrepWrapperError;
 exports.BrepkitAdapter = require_shapeTypes.BrepkitAdapter;
-exports.CompoundSketch = require_drawFns.CompoundSketch;
+exports.CompoundSketch = require_textBlueprints.CompoundSketch;
 exports.DEG2RAD = require_constants.DEG2RAD;
 exports.DisposalScope = require_shapeTypes.DisposalScope;
+exports.FaceSketcher = require_drawFns.FaceSketcher;
 exports.HASH_CODE_MAX = require_constants.HASH_CODE_MAX;
 exports.OK = require_errors.OK;
 exports.OcctWasmAdapter = require_occtWasmAdapter.OcctWasmAdapter;
 exports.RAD2DEG = require_constants.RAD2DEG;
-exports.Sketch = require_boolean2D.Sketch;
-exports.Sketches = require_drawFns.Sketches;
+exports.Sketch = require_textBlueprints.Sketch;
+exports.Sketcher = require_drawFns.Sketcher;
+exports.Sketches = require_textBlueprints.Sketches;
 exports.addChild = require_historyFns.addChild;
 exports.addHoles = require_primitiveFns.addHoles;
 exports.addMate = addMate;
@@ -2803,8 +3457,8 @@ exports.boss = boss;
 exports.box = require_primitiveFns.box;
 exports.bsplineApprox = require_primitiveFns.bsplineApprox;
 exports.bug = require_errors.bug;
-exports.cameraFromPlane = require_drawFns.cameraFromPlane;
-exports.cameraLookAt = require_drawFns.cameraLookAt;
+exports.cameraFromPlane = require_cameraFns.cameraFromPlane;
+exports.cameraLookAt = require_cameraFns.cameraLookAt;
 exports.captureHint = require_shapeRefFns.captureHint;
 exports.cast = require_faceFns.cast;
 exports.castShape = require_shapeTypes.castShape;
@@ -2828,10 +3482,10 @@ exports.colorShape = require_shapeFns.colorShape;
 exports.complexExtrude = require_extrudeFns.complexExtrude;
 exports.composeTransforms = require_shapeFns.composeTransforms;
 exports.compound = require_primitiveFns.compound;
-exports.compoundSketchExtrude = require_drawFns.compoundSketchExtrude;
-exports.compoundSketchFace = require_drawFns.compoundSketchFace;
-exports.compoundSketchLoft = require_drawFns.compoundSketchLoft;
-exports.compoundSketchRevolve = require_drawFns.compoundSketchRevolve;
+exports.compoundSketchExtrude = require_textBlueprints.compoundSketchExtrude;
+exports.compoundSketchFace = require_textBlueprints.compoundSketchFace;
+exports.compoundSketchLoft = require_textBlueprints.compoundSketchLoft;
+exports.compoundSketchRevolve = require_textBlueprints.compoundSketchRevolve;
 exports.computationError = require_errors.computationError;
 exports.computeStraightSkeleton = computeStraightSkeleton;
 exports.cone = require_primitiveFns.cone;
@@ -2847,7 +3501,7 @@ exports.countNodes = require_historyFns.countNodes;
 exports.createAssembly = require_historyFns.createAssembly;
 exports.createAssemblyNode = require_historyFns.createAssemblyNode;
 exports.createBlueprint = require_blueprintFns.createBlueprint;
-exports.createCamera = require_drawFns.createCamera;
+exports.createCamera = require_cameraFns.createCamera;
 exports.createCompound = require_shapeTypes.createCompound;
 exports.createCompoundBlueprint = require_blueprintFns.createCompoundBlueprint;
 exports.createDistanceQuery = require_measureFns.createDistanceQuery;
@@ -2957,7 +3611,7 @@ exports.flatMap = require_errors.flatMap;
 exports.flatten = require_errors.flatten;
 exports.flipFaceOrientation = require_faceFns.flipFaceOrientation;
 exports.flipOrientation = require_curveFns.flipOrientation;
-exports.fontMetrics = require_drawFns.fontMetrics;
+exports.fontMetrics = require_textMetrics.fontMetrics;
 exports.fromBREP = fromBREP$1;
 exports.fromKernelDir = fromKernelDir;
 exports.fromKernelPnt = fromKernelPnt;
@@ -2968,16 +3622,17 @@ exports.fuse2D = require_boolean2D.fuse2D;
 exports.fuseAll = require_booleanFns.fuseAll;
 exports.fuseBlueprints = require_boolean2D.fuseBlueprints;
 exports.fuseWithEvolution = require_primitiveFns.fuseWithEvolution;
-exports.getBounds = require_faceFns.getBounds;
+exports.gearGeometry = gearGeometry;
+exports.getBounds = require_topologyQueryFns.getBounds;
 exports.getBounds2D = require_blueprintFns.getBounds2D;
 exports.getCurveType = require_curveFns.getCurveType;
 exports.getDisposalStats = require_shapeTypes.getDisposalStats;
-exports.getEdges = require_faceFns.getEdges;
+exports.getEdges = require_topologyQueryFns.getEdges;
 exports.getFaceColor = require_shapeFns.getFaceColor;
 exports.getFaceOrigins = require_shapeFns.getFaceOrigins;
 exports.getFaceTags = require_shapeFns.getFaceTags;
-exports.getFaces = require_faceFns.getFaces;
-exports.getFont = require_drawFns.getFont;
+exports.getFaces = require_topologyQueryFns.getFaces;
+exports.getFont = require_textBlueprints.getFont;
 exports.getHashCode = require_shapeFns.getHashCode;
 exports.getHistoryShape = require_historyFns.getShape;
 exports.getKernel = require_shapeTypes.getKernel;
@@ -2991,8 +3646,8 @@ exports.getShapeKind = require_shapeTypes.getShapeKind;
 exports.getSingleFace = require_helpers.getSingleFace;
 exports.getSurfaceType = require_faceFns.getSurfaceType;
 exports.getTagMetadata = require_shapeFns.getTagMetadata;
-exports.getVertices = require_faceFns.getVertices;
-exports.getWires = require_faceFns.getWires;
+exports.getVertices = require_topologyQueryFns.getVertices;
+exports.getWires = require_topologyQueryFns.getWires;
 exports.guidedSweep = require_extrudeFns.guidedSweep;
 exports.heal = heal;
 exports.healFace = require_primitiveFns.healFace;
@@ -3017,7 +3672,7 @@ exports.intersect = intersect;
 exports.intersect2D = require_boolean2D.intersect2D;
 exports.intersectBlueprints = require_boolean2D.intersectBlueprints;
 exports.intersectWithEvolution = require_primitiveFns.intersectWithEvolution;
-exports.invalidateShapeCache = require_faceFns.invalidateShapeCache;
+exports.invalidateShapeCache = require_topologyQueryFns.invalidateShapeCache;
 Object.defineProperty(exports, "io", {
 	enumerable: true,
 	get: function() {
@@ -3049,7 +3704,7 @@ exports.isOperationRequest = require_workerHandler.isOperationRequest;
 exports.isOrientedFace = require_shapeTypes.isOrientedFace;
 exports.isPlanarFace = require_shapeTypes.isPlanarFace;
 exports.isPlanarWire = require_shapeTypes.isPlanarWire;
-exports.isProjectionPlane = require_drawFns.isProjectionPlane;
+exports.isProjectionPlane = require_cameraFns.isProjectionPlane;
 exports.isQueueEmpty = require_workerHandler.isEmpty;
 exports.isSameShape = require_shapeFns.isSameShape;
 exports.isShape1D = require_shapeTypes.isShape1D;
@@ -3061,23 +3716,26 @@ exports.isValid = isValid;
 exports.isValidSolid = require_shapeTypes.isValidSolid;
 exports.isVertex = require_shapeTypes.isVertex;
 exports.isWire = require_shapeTypes.isWire;
-exports.iterEdges = require_faceFns.iterEdges;
-exports.iterFaces = require_faceFns.iterFaces;
+exports.iterEdges = require_topologyQueryFns.iterEdges;
+exports.iterFaces = require_topologyQueryFns.iterFaces;
 exports.iterTopo = require_faceFns.iterTopo;
-exports.iterVertices = require_faceFns.iterVertices;
-exports.iterWires = require_faceFns.iterWires;
-exports.kernelCall = require_faceFns.kernelCall;
-exports.kernelCallRaw = require_faceFns.kernelCallRaw;
-exports.kernelCallScoped = require_faceFns.kernelCallScoped;
+exports.iterVertices = require_topologyQueryFns.iterVertices;
+exports.iterWires = require_topologyQueryFns.iterWires;
+exports.kernelCall = require_topologyQueryFns.kernelCall;
+exports.kernelCallRaw = require_topologyQueryFns.kernelCallRaw;
+exports.kernelCallScoped = require_topologyQueryFns.kernelCallScoped;
 exports.kernelError = require_errors.kernelError;
 exports.line = require_primitiveFns.line;
 exports.linearPattern = require_historyFns.linearPattern;
-exports.loadFont = require_drawFns.loadFont;
+exports.loadFont = require_textBlueprints.loadFont;
 exports.loft = loft;
-exports.loftAll = require_boolean2D.loftAll;
+exports.loftAll = require_textBlueprints.loftAll;
 exports.makeBaseBox = require_drawFns.makeBaseBox;
+exports.makeExternalGear = makeExternalGear;
+exports.makeInternalGear = makeInternalGear;
 exports.makePlane = require_planeOps.makePlane;
-exports.makeProjectedEdges = require_drawFns.makeProjectedEdges;
+exports.makePlanetaryGear = makePlanetaryGear;
+exports.makeProjectedEdges = require_cameraFns.makeProjectedEdges;
 exports.manifoldShell = require_shapeTypes.manifoldShell;
 exports.map = require_errors.map;
 exports.mapBoth = require_errors.mapBoth;
@@ -3123,7 +3781,7 @@ exports.offsetWire2D = require_curveFns.offsetWire2D;
 exports.ok = require_errors.ok;
 exports.or = require_errors.or;
 exports.orElse = require_errors.orElse;
-exports.organiseBlueprints = require_boolean2D.organiseBlueprints;
+exports.organiseBlueprints = require_blueprintSketcher.organiseBlueprints;
 exports.orientedFace = require_shapeTypes.orientedFace;
 exports.outerWire = require_faceFns.outerWire;
 Object.defineProperty(exports, "patterns", {
@@ -3137,6 +3795,7 @@ exports.pipeline = require_errors.pipeline;
 exports.pivotPlane = require_planeOps.pivotPlane;
 exports.planarFace = require_shapeTypes.planarFace;
 exports.planarWire = require_shapeTypes.planarWire;
+exports.planetPlacements = planetPlacements;
 exports.pocket = pocket;
 exports.pointOnSurface = require_faceFns.pointOnSurface;
 exports.polygon = require_primitiveFns.polygon;
@@ -3151,7 +3810,7 @@ Object.defineProperty(exports, "primitives", {
 		return primitives_exports;
 	}
 });
-exports.projectEdges = require_drawFns.projectEdges;
+exports.projectEdges = require_cameraFns.projectEdges;
 exports.projectPointOnFace = require_faceFns.projectPointOnFace;
 Object.defineProperty(exports, "query", {
 	enumerable: true,
@@ -3202,21 +3861,21 @@ exports.shellWithEvolution = require_primitiveFns.shellWithEvolution;
 exports.simplify = simplify;
 exports.sketchCircle = require_drawFns.sketchCircle;
 exports.sketchEllipse = require_drawFns.sketchEllipse;
-exports.sketchExtrude = require_drawFns.sketchExtrude;
-exports.sketchFace = require_drawFns.sketchFace;
+exports.sketchExtrude = require_textBlueprints.sketchExtrude;
+exports.sketchFace = require_textBlueprints.sketchFace;
 exports.sketchFaceOffset = require_drawFns.sketchFaceOffset;
 exports.sketchHelix = require_drawFns.sketchHelix;
-exports.sketchLoft = require_drawFns.sketchLoft;
+exports.sketchLoft = require_textBlueprints.sketchLoft;
 exports.sketchOnFace2D = require_blueprintFns.sketchOnFace2D;
 exports.sketchOnPlane2D = require_blueprintFns.sketchOnPlane2D;
 exports.sketchParametricFunction = require_drawFns.sketchParametricFunction;
 exports.sketchPolysides = require_drawFns.sketchPolysides;
 exports.sketchRectangle = require_drawFns.sketchRectangle;
-exports.sketchRevolve = require_drawFns.sketchRevolve;
+exports.sketchRevolve = require_textBlueprints.sketchRevolve;
 exports.sketchRoundedRectangle = require_drawFns.sketchRoundedRectangle;
-exports.sketchSweep = require_drawFns.sketchSweep;
-exports.sketchText = require_drawFns.sketchText;
-exports.sketchWires = require_drawFns.sketchWires;
+exports.sketchSweep = require_textBlueprints.sketchSweep;
+exports.sketchText = require_textMetrics.sketchText;
+exports.sketchWires = require_textBlueprints.sketchWires;
 exports.sketcherStateError = require_errors.sketcherStateError;
 exports.slice = slice;
 exports.solid = require_primitiveFns.solid;
@@ -3238,8 +3897,8 @@ exports.tagFaces = require_shapeFns.tagFaces;
 exports.tangentArc = require_primitiveFns.tangentArc;
 exports.tap = require_errors.tap;
 exports.tapErr = require_errors.tapErr;
-exports.textBlueprints = require_drawFns.textBlueprints;
-exports.textMetrics = require_drawFns.textMetrics;
+exports.textBlueprints = require_textBlueprints.textBlueprints;
+exports.textMetrics = require_textMetrics.textMetrics;
 exports.thicken = thicken;
 exports.threePointArc = require_primitiveFns.threePointArc;
 exports.toBREP = toBREP;
@@ -3278,6 +3937,7 @@ exports.updateRoles = require_shapeRefFns.updateRoles;
 exports.uvBounds = require_faceFns.uvBounds;
 exports.uvCoordinates = require_faceFns.uvCoordinates;
 exports.validSolid = require_shapeTypes.validSolid;
+exports.validatePlanetary = validatePlanetary;
 exports.validationError = require_errors.validationError;
 exports.variableFillet = require_primitiveFns.variableFillet;
 exports.vecAdd = require_vecOps.vecAdd;
@@ -3298,7 +3958,7 @@ exports.vecScale = require_vecOps.vecScale;
 exports.vecSub = require_vecOps.vecSub;
 exports.vertex = require_primitiveFns.vertex;
 exports.vertexFinder = vertexFinder;
-exports.vertexPosition = require_faceFns.vertexPosition;
+exports.vertexPosition = require_topologyQueryFns.vertexPosition;
 exports.verticesOfEdge = require_primitiveFns.verticesOfEdge;
 exports.walkAssembly = require_historyFns.walkAssembly;
 exports.wire = require_primitiveFns.wire;