brepjs 18.6.1 → 18.14.3

package/dist/{extrudeFns-O2s-SFf-.js → extrudeFns-7pE8dIWz.js}

@@ -1,4 +1,4 @@
-import { X as getKernel, c as createSolid, h as isShape3D, t as castShape, y as isWire } from "./shapeTypes-AyL8vv_O.js";
+import { X as getKernel, c as createSolid, h as isShape3D, t as castShape, y as isWire } from "./shapeTypes-C--1jaT1.js";
 import { A as ok, b as err, d as validationError, i as kernelError, l as typeCastError, t as BrepErrorCode, w as isErr } from "./errors-0fYW_YnO.js";
 import { c as vecLength, d as vecNormalize, t as vecAdd } from "./vecOps-DVROrqTV.js";
 //#region src/operations/extrudeUtils.ts

package/dist/{extrudeFns-BlJKAnW8.cjs → extrudeFns-DD36mWKv.cjs}

@@ -1,4 +1,4 @@
-const require_shapeTypes = require("./shapeTypes-8vB31RfA.cjs");
+const require_shapeTypes = require("./shapeTypes-BTt_LLbk.cjs");
 const require_errors = require("./errors-Dv6pfNct.cjs");
 const require_vecOps = require("./vecOps-D7xplSx8.cjs");
 //#region src/operations/extrudeUtils.ts

package/dist/faceFns-BFWz17_E.js

@@ -0,0 +1,218 @@
+import { X as getKernel, t as castShape } from "./shapeTypes-C--1jaT1.js";
+import { A as ok, R as unwrap, b as err, l as typeCastError } from "./errors-0fYW_YnO.js";
+import { a as getCachedSurfaceType } from "./topologyQueryFns-Dhf85ZBK.js";
+import { r as toVec3 } from "./types-BIdk_GJY.js";
+//#region src/topology/cast.ts
+var TOPO_ENUM = {
+	compound: 0,
+	solidCompound: 1,
+	solid: 2,
+	shell: 3,
+	face: 4,
+	wire: 5,
+	edge: 6,
+	vertex: 7,
+	shape: 8
+};
+/** Convert a TopoEntity string to its kernel TopAbs_ShapeEnum value. */
+var asTopo = (entity) => {
+	return TOPO_ENUM[entity];
+};
+/**
+* Iterate over all sub-shapes of a given type within a shape.
+*
+* @remarks Uses the kernel adapter's iterShapes rather than direct TopExp_Explorer.
+*/
+var TOPO_TO_SHAPE_TYPE = {
+	vertex: "vertex",
+	edge: "edge",
+	wire: "wire",
+	face: "face",
+	shell: "shell",
+	solid: "solid",
+	solidCompound: "compsolid",
+	compound: "compound",
+	shape: "compound"
+};
+var iterTopo = function* iterTopo(shape, topo) {
+	const shapeType = TOPO_TO_SHAPE_TYPE[topo];
+	if (shapeType) {
+		const shapes = getKernel().iterShapes(shape, shapeType);
+		for (const s of shapes) yield s;
+	}
+};
+/** Get the TopAbs_ShapeEnum type of an kernel shape, returning Err for null shapes. */
+var shapeType = (shape) => {
+	if (getKernel().isNull(shape)) return err(typeCastError("NULL_SHAPE", "This shape has no type, it is null"));
+	return ok(shape.ShapeType());
+};
+/**
+* Downcast a generic KernelShape to its concrete kernel type (e.g., kernel topology_Face).
+*
+* @remarks Uses the kernel adapter's downcast method.
+* @returns Ok with the downcasted shape, or Err if the shape type is unknown.
+*/
+function downcast(shape) {
+	if (getKernel().isNull(shape)) return err(typeCastError("NULL_SHAPE", "This shape has no type, it is null"));
+	try {
+		return ok(getKernel().downcast(shape));
+	} catch {
+		return err(typeCastError("NO_WRAPPER", "Could not find a wrapper for this shape type"));
+	}
+}
+/**
+* Cast a raw kernel shape to its corresponding branded brepjs type (Vertex, Edge, Face, etc.).
+*
+* Performs downcast + branded handle creation in one step.
+*
+* @returns Ok with a typed AnyShape, or Err if the shape type is unknown.
+*/
+function cast(shape) {
+	if (getKernel().isNull(shape)) return err(typeCastError("NULL_SHAPE", "Cannot cast a null shape"));
+	return ok(castShape(shape));
+}
+/** Type guard: return true if the shape is a CompSolid. */
+function isCompSolid(shape) {
+	return getKernel().shapeType(shape.wrapped) === "compsolid";
+}
+/**
+* Deserialize a shape from a BREP string representation.
+*
+* @param data - BREP string produced by toBREP().
+* @returns Ok with the deserialized shape, or Err if parsing fails.
+*/
+function fromBREP(data) {
+	return cast(getKernel().fromBREP(data));
+}
+//#endregion
+//#region src/topology/faceFns.ts
+/**
+* Face-specific functions — functional replacements for Face class methods.
+* All functions accept branded Face handles and return plain values or branded shapes.
+*/
+/** Map kernel surface type strings to the public API surface type constants. */
+var KERNEL_TO_PUBLIC_SURFACE_TYPE = {
+	plane: "PLANE",
+	cylinder: "CYLINDRE",
+	cone: "CONE",
+	sphere: "SPHERE",
+	torus: "TORUS",
+	bezier: "BEZIER_SURFACE",
+	bspline: "BSPLINE_SURFACE",
+	revolution: "REVOLUTION_SURFACE",
+	extrusion: "EXTRUSION_SURFACE",
+	offset: "OFFSET_SURFACE",
+	other: "OTHER_SURFACE"
+};
+/**
+* Get the geometric surface type of a face.
+*
+* @returns Ok with the surface type, or Err for unrecognized kernel surface types.
+*/
+function getSurfaceType(face) {
+	return ok(KERNEL_TO_PUBLIC_SURFACE_TYPE[getCachedSurfaceType(face)]);
+}
+/** Get the surface type of a face (unwrapped convenience). */
+function faceGeomType(face) {
+	return unwrap(getSurfaceType(face));
+}
+/** Get the topological orientation of a face. */
+function faceOrientation(face) {
+	return getKernel().shapeOrientation(face.wrapped) === "forward" ? "forward" : "backward";
+}
+/** Flip the orientation of a face. Returns a new face. */
+function flipFaceOrientation(face) {
+	return castShape(getKernel().reverseShape(face.wrapped));
+}
+/** Get the UV parameter bounds of a face. */
+function uvBounds(face) {
+	return getKernel().uvBounds(face.wrapped);
+}
+/**
+* Get a point on a face surface at normalized UV coordinates (0-1 range).
+*
+* @param face - The face to evaluate.
+* @param u - Normalized U parameter (0-1).
+* @param v - Normalized V parameter (0-1).
+*/
+function pointOnSurface(face, u, v) {
+	const bounds = uvBounds(face);
+	const absU = u * (bounds.uMax - bounds.uMin) + bounds.uMin;
+	const absV = v * (bounds.vMax - bounds.vMin) + bounds.vMin;
+	return getKernel().pointOnSurface(face.wrapped, absU, absV);
+}
+/** Get the UV coordinates on a face for a given 3D point. */
+function uvCoordinates(face, point) {
+	const v = toVec3(point);
+	const result = getKernel().uvFromPoint(face.wrapped, v);
+	if (!result) return [0, 0];
+	return result;
+}
+/**
+* Project a 3D point onto a face surface.
+*
+* Returns the projected point, its UV coordinates, and the distance
+* from the original point to the surface.
+*/
+function projectPointOnFace(face, point) {
+	const v = toVec3(point);
+	try {
+		const vMut = v;
+		const uvResult = getKernel().uvFromPoint(face.wrapped, vMut);
+		if (!uvResult) return err(typeCastError("PROJECTION_FAILED", "No projection found on the face"));
+		const projectedPoint = getKernel().projectPointOnFace(face.wrapped, vMut);
+		const dx = v[0] - projectedPoint[0];
+		const dy = v[1] - projectedPoint[1];
+		const dz = v[2] - projectedPoint[2];
+		return ok({
+			uv: uvResult,
+			point: projectedPoint,
+			distance: Math.sqrt(dx * dx + dy * dy + dz * dz)
+		});
+	} catch (e) {
+		return err(typeCastError("PROJECTION_FAILED", `Point projection failed: ${e instanceof Error ? e.message : String(e)}`));
+	}
+}
+/** Get the surface normal at a point (or at the center if no point given). */
+function normalAt(face, locationPoint) {
+	let u;
+	let v;
+	if (!locationPoint) {
+		const bounds = uvBounds(face);
+		u = .5 * (bounds.uMin + bounds.uMax);
+		v = .5 * (bounds.vMin + bounds.vMax);
+	} else [u, v] = uvCoordinates(face, locationPoint);
+	return getKernel().surfaceNormal(face.wrapped, u, v);
+}
+/** Get the center of mass of a face. */
+function faceCenter(face) {
+	return getKernel().surfaceCenterOfMass(face.wrapped);
+}
+/**
+* Classify a 3D point's position relative to a face boundary.
+* Projects the point onto the face's surface and classifies the UV result.
+*
+* @returns 'in' if inside, 'on' if on the boundary, 'out' if outside
+*/
+function classifyPointOnFace(face, point, tolerance = 1e-6) {
+	const [u, v] = uvCoordinates(face, point);
+	return getKernel().classifyPointOnFace(face.wrapped, u, v, tolerance);
+}
+/** Get the outer wire of a face. The outer boundary of a face is always closed. */
+function outerWire(face) {
+	return castShape(getKernel().outerWire(face.wrapped));
+}
+/**
+* Remove all holes (inner wires) from a face, returning a new face with only the outer boundary.
+* Useful for defeaturing workflows where holes need to be temporarily or permanently filled.
+*/
+function removeHolesFromFace(face) {
+	return castShape(getKernel().removeHolesFromFace(face.wrapped));
+}
+/** Get the inner wires (holes) of a face. Hole boundaries are always closed. */
+function innerWires(face) {
+	const outer = outerWire(face);
+	return Array.from(iterTopo(face.wrapped, "wire")).map((w) => castShape(unwrap(downcast(w)))).filter((w) => !getKernel().isSame(w.wrapped, outer.wrapped));
+}
+//#endregion
+export { downcast as _, flipFaceOrientation as a, iterTopo as b, normalAt as c, projectPointOnFace as d, removeHolesFromFace as f, cast as g, asTopo as h, faceOrientation as i, outerWire as l, uvCoordinates as m, faceCenter as n, getSurfaceType as o, uvBounds as p, faceGeomType as r, innerWires as s, classifyPointOnFace as t, pointOnSurface as u, fromBREP as v, shapeType as x, isCompSolid as y };

package/dist/faceFns-DP7i60yJ.cjs

@@ -0,0 +1,343 @@
+const require_shapeTypes = require("./shapeTypes-BTt_LLbk.cjs");
+const require_errors = require("./errors-Dv6pfNct.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-BU0qdNJP.cjs");
+const require_types = require("./types-CDkxah-M.cjs");
+//#region src/topology/cast.ts
+var TOPO_ENUM = {
+	compound: 0,
+	solidCompound: 1,
+	solid: 2,
+	shell: 3,
+	face: 4,
+	wire: 5,
+	edge: 6,
+	vertex: 7,
+	shape: 8
+};
+/** Convert a TopoEntity string to its kernel TopAbs_ShapeEnum value. */
+var asTopo = (entity) => {
+	return TOPO_ENUM[entity];
+};
+/**
+* Iterate over all sub-shapes of a given type within a shape.
+*
+* @remarks Uses the kernel adapter's iterShapes rather than direct TopExp_Explorer.
+*/
+var TOPO_TO_SHAPE_TYPE = {
+	vertex: "vertex",
+	edge: "edge",
+	wire: "wire",
+	face: "face",
+	shell: "shell",
+	solid: "solid",
+	solidCompound: "compsolid",
+	compound: "compound",
+	shape: "compound"
+};
+var iterTopo = function* iterTopo(shape, topo) {
+	const shapeType = TOPO_TO_SHAPE_TYPE[topo];
+	if (shapeType) {
+		const shapes = require_shapeTypes.getKernel().iterShapes(shape, shapeType);
+		for (const s of shapes) yield s;
+	}
+};
+/** Get the TopAbs_ShapeEnum type of an kernel shape, returning Err for null shapes. */
+var shapeType = (shape) => {
+	if (require_shapeTypes.getKernel().isNull(shape)) return require_errors.err(require_errors.typeCastError("NULL_SHAPE", "This shape has no type, it is null"));
+	return require_errors.ok(shape.ShapeType());
+};
+/**
+* Downcast a generic KernelShape to its concrete kernel type (e.g., kernel topology_Face).
+*
+* @remarks Uses the kernel adapter's downcast method.
+* @returns Ok with the downcasted shape, or Err if the shape type is unknown.
+*/
+function downcast(shape) {
+	if (require_shapeTypes.getKernel().isNull(shape)) return require_errors.err(require_errors.typeCastError("NULL_SHAPE", "This shape has no type, it is null"));
+	try {
+		return require_errors.ok(require_shapeTypes.getKernel().downcast(shape));
+	} catch {
+		return require_errors.err(require_errors.typeCastError("NO_WRAPPER", "Could not find a wrapper for this shape type"));
+	}
+}
+/**
+* Cast a raw kernel shape to its corresponding branded brepjs type (Vertex, Edge, Face, etc.).
+*
+* Performs downcast + branded handle creation in one step.
+*
+* @returns Ok with a typed AnyShape, or Err if the shape type is unknown.
+*/
+function cast(shape) {
+	if (require_shapeTypes.getKernel().isNull(shape)) return require_errors.err(require_errors.typeCastError("NULL_SHAPE", "Cannot cast a null shape"));
+	return require_errors.ok(require_shapeTypes.castShape(shape));
+}
+/** Type guard: return true if the shape is a CompSolid. */
+function isCompSolid(shape) {
+	return require_shapeTypes.getKernel().shapeType(shape.wrapped) === "compsolid";
+}
+/**
+* Deserialize a shape from a BREP string representation.
+*
+* @param data - BREP string produced by toBREP().
+* @returns Ok with the deserialized shape, or Err if parsing fails.
+*/
+function fromBREP(data) {
+	return cast(require_shapeTypes.getKernel().fromBREP(data));
+}
+//#endregion
+//#region src/topology/faceFns.ts
+/**
+* Face-specific functions — functional replacements for Face class methods.
+* All functions accept branded Face handles and return plain values or branded shapes.
+*/
+/** Map kernel surface type strings to the public API surface type constants. */
+var KERNEL_TO_PUBLIC_SURFACE_TYPE = {
+	plane: "PLANE",
+	cylinder: "CYLINDRE",
+	cone: "CONE",
+	sphere: "SPHERE",
+	torus: "TORUS",
+	bezier: "BEZIER_SURFACE",
+	bspline: "BSPLINE_SURFACE",
+	revolution: "REVOLUTION_SURFACE",
+	extrusion: "EXTRUSION_SURFACE",
+	offset: "OFFSET_SURFACE",
+	other: "OTHER_SURFACE"
+};
+/**
+* Get the geometric surface type of a face.
+*
+* @returns Ok with the surface type, or Err for unrecognized kernel surface types.
+*/
+function getSurfaceType(face) {
+	return require_errors.ok(KERNEL_TO_PUBLIC_SURFACE_TYPE[require_topologyQueryFns.getCachedSurfaceType(face)]);
+}
+/** Get the surface type of a face (unwrapped convenience). */
+function faceGeomType(face) {
+	return require_errors.unwrap(getSurfaceType(face));
+}
+/** Get the topological orientation of a face. */
+function faceOrientation(face) {
+	return require_shapeTypes.getKernel().shapeOrientation(face.wrapped) === "forward" ? "forward" : "backward";
+}
+/** Flip the orientation of a face. Returns a new face. */
+function flipFaceOrientation(face) {
+	return require_shapeTypes.castShape(require_shapeTypes.getKernel().reverseShape(face.wrapped));
+}
+/** Get the UV parameter bounds of a face. */
+function uvBounds(face) {
+	return require_shapeTypes.getKernel().uvBounds(face.wrapped);
+}
+/**
+* Get a point on a face surface at normalized UV coordinates (0-1 range).
+*
+* @param face - The face to evaluate.
+* @param u - Normalized U parameter (0-1).
+* @param v - Normalized V parameter (0-1).
+*/
+function pointOnSurface(face, u, v) {
+	const bounds = uvBounds(face);
+	const absU = u * (bounds.uMax - bounds.uMin) + bounds.uMin;
+	const absV = v * (bounds.vMax - bounds.vMin) + bounds.vMin;
+	return require_shapeTypes.getKernel().pointOnSurface(face.wrapped, absU, absV);
+}
+/** Get the UV coordinates on a face for a given 3D point. */
+function uvCoordinates(face, point) {
+	const v = require_types.toVec3(point);
+	const result = require_shapeTypes.getKernel().uvFromPoint(face.wrapped, v);
+	if (!result) return [0, 0];
+	return result;
+}
+/**
+* Project a 3D point onto a face surface.
+*
+* Returns the projected point, its UV coordinates, and the distance
+* from the original point to the surface.
+*/
+function projectPointOnFace(face, point) {
+	const v = require_types.toVec3(point);
+	try {
+		const vMut = v;
+		const uvResult = require_shapeTypes.getKernel().uvFromPoint(face.wrapped, vMut);
+		if (!uvResult) return require_errors.err(require_errors.typeCastError("PROJECTION_FAILED", "No projection found on the face"));
+		const projectedPoint = require_shapeTypes.getKernel().projectPointOnFace(face.wrapped, vMut);
+		const dx = v[0] - projectedPoint[0];
+		const dy = v[1] - projectedPoint[1];
+		const dz = v[2] - projectedPoint[2];
+		return require_errors.ok({
+			uv: uvResult,
+			point: projectedPoint,
+			distance: Math.sqrt(dx * dx + dy * dy + dz * dz)
+		});
+	} catch (e) {
+		return require_errors.err(require_errors.typeCastError("PROJECTION_FAILED", `Point projection failed: ${e instanceof Error ? e.message : String(e)}`));
+	}
+}
+/** Get the surface normal at a point (or at the center if no point given). */
+function normalAt(face, locationPoint) {
+	let u;
+	let v;
+	if (!locationPoint) {
+		const bounds = uvBounds(face);
+		u = .5 * (bounds.uMin + bounds.uMax);
+		v = .5 * (bounds.vMin + bounds.vMax);
+	} else [u, v] = uvCoordinates(face, locationPoint);
+	return require_shapeTypes.getKernel().surfaceNormal(face.wrapped, u, v);
+}
+/** Get the center of mass of a face. */
+function faceCenter(face) {
+	return require_shapeTypes.getKernel().surfaceCenterOfMass(face.wrapped);
+}
+/**
+* Classify a 3D point's position relative to a face boundary.
+* Projects the point onto the face's surface and classifies the UV result.
+*
+* @returns 'in' if inside, 'on' if on the boundary, 'out' if outside
+*/
+function classifyPointOnFace(face, point, tolerance = 1e-6) {
+	const [u, v] = uvCoordinates(face, point);
+	return require_shapeTypes.getKernel().classifyPointOnFace(face.wrapped, u, v, tolerance);
+}
+/** Get the outer wire of a face. The outer boundary of a face is always closed. */
+function outerWire(face) {
+	return require_shapeTypes.castShape(require_shapeTypes.getKernel().outerWire(face.wrapped));
+}
+/**
+* Remove all holes (inner wires) from a face, returning a new face with only the outer boundary.
+* Useful for defeaturing workflows where holes need to be temporarily or permanently filled.
+*/
+function removeHolesFromFace(face) {
+	return require_shapeTypes.castShape(require_shapeTypes.getKernel().removeHolesFromFace(face.wrapped));
+}
+/** Get the inner wires (holes) of a face. Hole boundaries are always closed. */
+function innerWires(face) {
+	const outer = outerWire(face);
+	return Array.from(iterTopo(face.wrapped, "wire")).map((w) => require_shapeTypes.castShape(require_errors.unwrap(downcast(w)))).filter((w) => !require_shapeTypes.getKernel().isSame(w.wrapped, outer.wrapped));
+}
+//#endregion
+Object.defineProperty(exports, "asTopo", {
+	enumerable: true,
+	get: function() {
+		return asTopo;
+	}
+});
+Object.defineProperty(exports, "cast", {
+	enumerable: true,
+	get: function() {
+		return cast;
+	}
+});
+Object.defineProperty(exports, "classifyPointOnFace", {
+	enumerable: true,
+	get: function() {
+		return classifyPointOnFace;
+	}
+});
+Object.defineProperty(exports, "downcast", {
+	enumerable: true,
+	get: function() {
+		return downcast;
+	}
+});
+Object.defineProperty(exports, "faceCenter", {
+	enumerable: true,
+	get: function() {
+		return faceCenter;
+	}
+});
+Object.defineProperty(exports, "faceGeomType", {
+	enumerable: true,
+	get: function() {
+		return faceGeomType;
+	}
+});
+Object.defineProperty(exports, "faceOrientation", {
+	enumerable: true,
+	get: function() {
+		return faceOrientation;
+	}
+});
+Object.defineProperty(exports, "flipFaceOrientation", {
+	enumerable: true,
+	get: function() {
+		return flipFaceOrientation;
+	}
+});
+Object.defineProperty(exports, "fromBREP", {
+	enumerable: true,
+	get: function() {
+		return fromBREP;
+	}
+});
+Object.defineProperty(exports, "getSurfaceType", {
+	enumerable: true,
+	get: function() {
+		return getSurfaceType;
+	}
+});
+Object.defineProperty(exports, "innerWires", {
+	enumerable: true,
+	get: function() {
+		return innerWires;
+	}
+});
+Object.defineProperty(exports, "isCompSolid", {
+	enumerable: true,
+	get: function() {
+		return isCompSolid;
+	}
+});
+Object.defineProperty(exports, "iterTopo", {
+	enumerable: true,
+	get: function() {
+		return iterTopo;
+	}
+});
+Object.defineProperty(exports, "normalAt", {
+	enumerable: true,
+	get: function() {
+		return normalAt;
+	}
+});
+Object.defineProperty(exports, "outerWire", {
+	enumerable: true,
+	get: function() {
+		return outerWire;
+	}
+});
+Object.defineProperty(exports, "pointOnSurface", {
+	enumerable: true,
+	get: function() {
+		return pointOnSurface;
+	}
+});
+Object.defineProperty(exports, "projectPointOnFace", {
+	enumerable: true,
+	get: function() {
+		return projectPointOnFace;
+	}
+});
+Object.defineProperty(exports, "removeHolesFromFace", {
+	enumerable: true,
+	get: function() {
+		return removeHolesFromFace;
+	}
+});
+Object.defineProperty(exports, "shapeType", {
+	enumerable: true,
+	get: function() {
+		return shapeType;
+	}
+});
+Object.defineProperty(exports, "uvBounds", {
+	enumerable: true,
+	get: function() {
+		return uvBounds;
+	}
+});
+Object.defineProperty(exports, "uvCoordinates", {
+	enumerable: true,
+	get: function() {
+		return uvCoordinates;
+	}
+});

package/dist/gear/gearFns.d.ts

@@ -0,0 +1,129 @@
+import { Result } from '../core/result.js';
+import { ValidSolid } from '../core/shapeTypes.js';
+import { GearDiagnostic } from './gearMath.js';
+export interface ExternalGearParams {
+    teeth: number;
+    moduleSize: number;
+    thickness: number;
+    pressureAngleDeg?: number;
+    shift?: number;
+    clearance?: number;
+    /**
+     * Per-gear flank thinning (mm); 0 = theoretical involute. For an equal-pair
+     * mesh, total mesh backlash is 2× this value.
+     */
+    flankThinning?: number;
+    /** Diameter (mm) of central bore; 0 or omitted = no bore. */
+    bore?: number;
+    /**
+     * Sample count per involute flank. Lower = faster mesh, coarser surface.
+     * Defaults to `adaptiveSampleCount(moduleSize)` (≈ 16 at module 2). Try
+     * 8 for previews, 24+ for 3D printing.
+     */
+    samples?: number;
+}
+export interface InternalGearParams {
+    teeth: number;
+    moduleSize: number;
+    thickness: number;
+    pressureAngleDeg?: number;
+    shift?: number;
+    clearance?: number;
+    flankThinning?: number;
+    /** Wall thickness from pitch radius outward; defaults to 2·moduleSize. */
+    ringWallThickness?: number;
+    /** See {@link ExternalGearParams.samples}. */
+    samples?: number;
+}
+export interface PlanetaryGearParams {
+    /** Extrusion thickness (mm). */
+    thickness: number;
+    moduleSize?: number;
+    sunTeeth?: number;
+    planetTeeth?: number;
+    numPlanets?: number;
+    pressureAngleDeg?: number;
+    clearance?: number;
+    /** Total mesh backlash (mm); split as b/2 per gear. */
+    backlash?: number;
+    sunShift?: number;
+    planetShift?: number;
+    ringShift?: number;
+    ringWallThickness?: number;
+    /** Diameter (mm) of central bore in the sun gear; 0 or omitted = no bore. */
+    sunBore?: number;
+    /** Diameter (mm) of central bore in each planet gear; 0 or omitted = no bore. */
+    planetBore?: number;
+    /**
+     * Applied torque on the SUN (input) shaft, in N·m. Planet and ring stresses
+     * are derived via force balance (shared tangential force at the mesh).
+     * When supplied, `lewisStress` and `stressConcentrationFactor` are computed.
+     */
+    appliedTorque?: number;
+    /** See {@link ExternalGearParams.samples}. Applied to sun, planet, and ring. */
+    samples?: number;
+}
+export interface GearResult {
+    solid: ValidSolid;
+    pitchDiameter: number;
+    baseDiameter: number;
+    tipDiameter: number;
+    rootDiameter: number;
+    /**
+     * Diagnostics specific to this gear in isolation (e.g. undercut risk for
+     * low-tooth-count gears with no profile shift). Empty when the gear is
+     * geometrically clean. Planetary assemblies emit additional cross-mesh
+     * diagnostics on `PlanetaryGearAssembly.diagnostics`.
+     */
+    diagnostics: GearDiagnostic[];
+}
+export interface PlanetaryGearAssembly {
+    sun: ValidSolid;
+    planets: ValidSolid[];
+    ring: ValidSolid;
+    ringTeeth: number;
+    /** Working pressure angle (radians) under the supplied profile shifts. */
+    workingPressureAngle: number;
+    /** True (working) center distance between sun and planet axes (mm). */
+    centerDistance: number;
+    /** Transverse contact ratios per mesh; ≥ 1.2 is industry-acceptable. */
+    contactRatio: {
+        sunPlanet: number;
+        planetRing: number;
+    };
+    /**
+     * Additional profile shift each gear needs to clear the undercut threshold.
+     * Positive = undercut risk; zero = clear.
+     */
+    undercutDeficit: {
+        sun: number;
+        planet: number;
+    };
+    /**
+     * Root bending stress (MPa) at each gear, with the fillet stress
+     * concentration factor applied: `σ = σ_Lewis · K_f`. Only present when
+     * `appliedTorque` was supplied. See {@link stressConcentrationFactor} for
+     * the K_f values used.
+     */
+    lewisStress?: {
+        sun: number;
+        planet: number;
+        ring: number;
+    };
+    /**
+     * Dolan-Broghamer stress concentration factor `K_f` at each gear's root
+     * fillet, the multiplier already folded into {@link lewisStress}. Exposed
+     * so callers can recover the raw Lewis stress (σ_Lewis = lewisStress / K_f)
+     * or compare against ISO 6336-3 `Y_F·Y_S` from an external check. The ring
+     * value uses the Niemann internal-gear reduction (concave fillet).
+     */
+    stressConcentrationFactor?: {
+        sun: number;
+        planet: number;
+        ring: number;
+    };
+    diagnostics: GearDiagnostic[];
+}
+export declare function makeExternalGear(params: ExternalGearParams): Result<GearResult>;
+export declare function makeInternalGear(params: InternalGearParams): Result<GearResult>;
+export declare function makePlanetaryGear(params: PlanetaryGearParams): Result<PlanetaryGearAssembly>;