@metamesh/modeling 0.14.0 → 0.15.0

package/dist/geometry/mechanical/gears.js

@@ -33,22 +33,22 @@ const freezePoints = (points) => {
  * count `z_v = z / cos³(beta)`, so increasing helix angle can reduce the physical tooth count.
  */
 export function minimumCylindricalGearToothCountWithoutUndercut(spec = {}) {
-    const pressureAngleDegrees = finite(spec.pressureAngleDegrees ?? DEFAULT_PRESSURE_ANGLE_DEGREES, "Pressure angle", "minimumCylindricalGearToothCountWithoutUndercut");
-    const helixAngleDegrees = finite(spec.helixAngleDegrees ?? 0, "Helix angle", "minimumCylindricalGearToothCountWithoutUndercut");
-    if (!(pressureAngleDegrees > 0 && pressureAngleDegrees < 45)) {
+    const pressureAngle = finite(spec.pressureAngle ?? DEFAULT_PRESSURE_ANGLE_DEGREES, "Pressure angle", "minimumCylindricalGearToothCountWithoutUndercut");
+    const helixAngle = finite(spec.helixAngle ?? 0, "Helix angle", "minimumCylindricalGearToothCountWithoutUndercut");
+    if (!(pressureAngle > 0 && pressureAngle < 45)) {
         throw new GeometryError("INVALID_ARGUMENT", "Pressure angle must be greater than 0 and less than 45 degrees.", {
             operation: "minimumCylindricalGearToothCountWithoutUndercut",
-            details: { pressureAngleDegrees },
+            details: { pressureAngle },
         });
     }
-    if (!(Math.abs(helixAngleDegrees) < 45)) {
+    if (!(Math.abs(helixAngle) < 45)) {
         throw new GeometryError("INVALID_ARGUMENT", "The absolute helix angle must be less than 45 degrees.", {
             operation: "minimumCylindricalGearToothCountWithoutUndercut",
-            details: { helixAngleDegrees },
+            details: { helixAngle },
         });
     }
-    const pressureAngleRadians = degreesToRadians(pressureAngleDegrees);
-    const helixAngleRadians = degreesToRadians(helixAngleDegrees);
+    const pressureAngleRadians = degreesToRadians(pressureAngle);
+    const helixAngleRadians = degreesToRadians(helixAngle);
     const exact = (2 * Math.cos(helixAngleRadians) ** 3) / Math.sin(pressureAngleRadians) ** 2;
     // Exact boundary cases such as alpha=30° should not round up because of floating-point noise.
     return Math.ceil(exact - Math.max(1, Math.abs(exact)) * 1e-12);
@@ -64,7 +64,7 @@ const resolveSimpleInvoluteProfileFacts = (dimensions, operation) => {
     const halfAngleAtTip = halfAngleAt(dimensions.outsideRadius);
     if (!(startRadius <= dimensions.outsideRadius) ||
         !(halfAngleAtTip > 0) ||
-        !(halfAngleAtStart < dimensions.angularPitch / 2)) {
+        !(halfAngleAtStart < dimensions.angularPitchRadians / 2)) {
         throw new GeometryError("DEGENERATE_GEOMETRY", "The selected tooth proportions cannot form a simple involute outline.", {
             operation,
             details: { halfAngleAtStart, halfAngleAtTip, startRadius },
@@ -73,7 +73,7 @@ const resolveSimpleInvoluteProfileFacts = (dimensions, operation) => {
     return Object.freeze({ halfAngleAt, halfAngleAtStart, halfAngleAtTip, startRadius });
 };
 const internalCylindricalGearSpaceDimensions = (dimensions) => {
-    const circularPitch = dimensions.angularPitch * dimensions.pitchRadius;
+    const circularPitch = dimensions.angularPitchRadians * dimensions.pitchRadius;
     return Object.freeze({
         ...dimensions,
         outsideRadius: dimensions.pitchRadius + dimensions.dedendum,
@@ -90,8 +90,8 @@ const internalCylindricalGearSpaceDimensions = (dimensions) => {
 const resolveCylindricalGearDimensions = (spec, profile) => {
     const toothCount = finite(spec.toothCount, "Tooth count");
     const module = finite(spec.module, "Module");
-    const pressureAngleDegrees = finite(spec.pressureAngleDegrees ?? DEFAULT_PRESSURE_ANGLE_DEGREES, "Pressure angle");
-    const helixAngleDegrees = finite(spec.helixAngleDegrees ?? 0, "Helix angle");
+    const pressureAngle = finite(spec.pressureAngle ?? DEFAULT_PRESSURE_ANGLE_DEGREES, "Pressure angle");
+    const helixAngle = finite(spec.helixAngle ?? 0, "Helix angle");
     const backlash = finite(spec.backlash ?? 0, "Backlash");
     const clearanceFactor = finite(spec.clearanceFactor ?? DEFAULT_CLEARANCE_FACTOR, "Clearance factor");
     if (!Number.isInteger(toothCount) || toothCount < 6 || toothCount > MAXIMUM_TOOTH_COUNT) {
@@ -103,29 +103,29 @@ const resolveCylindricalGearDimensions = (spec, profile) => {
             details: { module },
         });
     }
-    if (!(pressureAngleDegrees > 0 && pressureAngleDegrees < 45)) {
-        throw new GeometryError("INVALID_ARGUMENT", "Pressure angle must be greater than 0 and less than 45 degrees.", { operation: "resolveCylindricalGear", details: { pressureAngleDegrees } });
+    if (!(pressureAngle > 0 && pressureAngle < 45)) {
+        throw new GeometryError("INVALID_ARGUMENT", "Pressure angle must be greater than 0 and less than 45 degrees.", { operation: "resolveCylindricalGear", details: { pressureAngle } });
     }
-    if (!(Math.abs(helixAngleDegrees) < 45)) {
-        throw new GeometryError("INVALID_ARGUMENT", "The absolute helix angle must be less than 45 degrees.", { operation: "resolveCylindricalGear", details: { helixAngleDegrees } });
+    if (!(Math.abs(helixAngle) < 45)) {
+        throw new GeometryError("INVALID_ARGUMENT", "The absolute helix angle must be less than 45 degrees.", { operation: "resolveCylindricalGear", details: { helixAngle } });
     }
     if (backlash < 0 || clearanceFactor < 0) {
         throw new GeometryError("INVALID_ARGUMENT", "Backlash and clearance factor must be non-negative.", { operation: "resolveCylindricalGear" });
     }
-    const pressureAngleRadians = degreesToRadians(pressureAngleDegrees);
-    const helixAngleRadians = degreesToRadians(helixAngleDegrees);
+    const pressureAngleRadians = degreesToRadians(pressureAngle);
+    const helixAngleRadians = degreesToRadians(helixAngle);
     const minimumToothCountWithoutUndercut = minimumCylindricalGearToothCountWithoutUndercut({
-        helixAngleDegrees,
-        pressureAngleDegrees,
+        helixAngle,
+        pressureAngle,
     });
     const virtualToothCount = toothCount / Math.cos(helixAngleRadians) ** 3;
     if (profile === "external" && toothCount < minimumToothCountWithoutUndercut) {
-        throw new GeometryError("INVALID_ARGUMENT", `An unshifted full-depth external involute at ${pressureAngleDegrees}° pressure angle and ${Math.abs(helixAngleDegrees)}° helix angle requires at least ${minimumToothCountWithoutUndercut} teeth to avoid undercut; profile shift is not supported.`, {
+        throw new GeometryError("INVALID_ARGUMENT", `An unshifted full-depth external involute at ${pressureAngle}° pressure angle and ${Math.abs(helixAngle)}° helix angle requires at least ${minimumToothCountWithoutUndercut} teeth to avoid undercut; profile shift is not supported.`, {
             operation: "resolveCylindricalGear",
             details: {
-                helixAngleDegrees,
+                helixAngle,
                 minimumToothCountWithoutUndercut,
-                pressureAngleDegrees,
+                pressureAngle,
                 toothCount,
                 virtualToothCount,
             },
@@ -151,7 +151,7 @@ const resolveCylindricalGearDimensions = (spec, profile) => {
     }
     const dimensions = Object.freeze({
         addendum,
-        angularPitch: (Math.PI * 2) / toothCount,
+        angularPitchRadians: (Math.PI * 2) / toothCount,
         backlash,
         baseRadius: pitchRadius * Math.cos(transversePressureAngleRadians),
         dedendum,
@@ -199,12 +199,12 @@ export function resolveCylindricalGearPair(spec) {
     // separate tip/interference constraints are checked by the pair and coupled-motion validators.
     const driven = resolveCylindricalGearDimensions(spec.driven, spec.mesh);
     const epsilon = 1e-10;
-    const driverHelixDegrees = spec.driver.helixAngleDegrees ?? 0;
-    const drivenHelixDegrees = spec.driven.helixAngleDegrees ?? 0;
-    const requiredDrivenHelixAngleDegrees = spec.mesh === "external" ? -driverHelixDegrees : driverHelixDegrees;
+    const driverHelixDegrees = spec.driver.helixAngle ?? 0;
+    const drivenHelixDegrees = spec.driven.helixAngle ?? 0;
+    const requiredDrivenHelixAngle = spec.mesh === "external" ? -driverHelixDegrees : driverHelixDegrees;
     if (Math.abs(driver.module - driven.module) > epsilon ||
         Math.abs(driver.pressureAngleRadians - driven.pressureAngleRadians) > epsilon ||
-        Math.abs(drivenHelixDegrees - requiredDrivenHelixAngleDegrees) > epsilon) {
+        Math.abs(drivenHelixDegrees - requiredDrivenHelixAngle) > epsilon) {
         throw new GeometryError("INVALID_ARGUMENT", "Mating gears must share normal module and pressure angle with conjugate helix hands.", { operation: "resolveCylindricalGearPair" });
     }
     if (spec.mesh === "internal" && driven.pitchRadius <= driver.outsideRadius) {
@@ -218,7 +218,7 @@ export function resolveCylindricalGearPair(spec) {
         driven,
         drivenDirection: spec.mesh === "external" ? -1 : 1,
         ratio: driven.toothCount / driver.toothCount,
-        requiredDrivenHelixAngleDegrees,
+        requiredDrivenHelixAngle,
     });
 }
 const exactSampleCount = (value, label, minimum, maximum, operation) => {
@@ -345,7 +345,7 @@ const sampleResolvedCylindricalGearOutline = (dimensions, options, operation) =>
     const { halfAngleAt, halfAngleAtStart, halfAngleAtTip, startRadius } = resolveSimpleInvoluteProfileFacts(dimensions, operation);
     const limits = resolveGeometrySamplingLimits(options.limits);
     const resolution = resolveGeometryResolution(options.resolution, limits);
-    const rootArcAngle = dimensions.angularPitch / 2 - halfAngleAtStart;
+    const rootArcAngle = dimensions.angularPitchRadians / 2 - halfAngleAtStart;
     const rootArcSamples = options.rootArcSamples === undefined
         ? resolveAdaptiveArcSamples(dimensions.rootRadius, rootArcAngle, resolution, limits)
         : exactSampleCount(options.rootArcSamples, "Root arc samples", 1, limits.maxCircularSegments, operation);
@@ -361,10 +361,12 @@ const sampleResolvedCylindricalGearOutline = (dimensions, options, operation) =>
         : exactSampleCount(options.flankSamples, "Flank samples", 2, maximumFlankSamples, operation);
     const estimatedPoints = dimensions.toothCount * (flankSamples * 2 + fixedPerTooth);
     assertSamplingCount(estimatedPoints, operation, limits.maxProfilePoints);
-    const points = [polarPoint(dimensions.rootRadius, -dimensions.angularPitch / 2)];
+    const points = [
+        polarPoint(dimensions.rootRadius, -dimensions.angularPitchRadians / 2),
+    ];
     for (let tooth = 0; tooth < dimensions.toothCount; tooth += 1) {
-        const centerAngle = tooth * dimensions.angularPitch;
-        const valleyBefore = centerAngle - dimensions.angularPitch / 2;
+        const centerAngle = tooth * dimensions.angularPitchRadians;
+        const valleyBefore = centerAngle - dimensions.angularPitchRadians / 2;
         const leftRootAngle = centerAngle - halfAngleAtStart;
         for (let sample = 1; sample <= rootArcSamples; sample += 1) {
             const amount = sample / rootArcSamples;
@@ -391,7 +393,7 @@ const sampleResolvedCylindricalGearOutline = (dimensions, options, operation) =>
         if (startRadius > dimensions.rootRadius) {
             points.push(polarPoint(dimensions.rootRadius, rightRootAngle));
         }
-        const valleyAfter = centerAngle + dimensions.angularPitch / 2;
+        const valleyAfter = centerAngle + dimensions.angularPitchRadians / 2;
         for (let sample = 1; sample <= rootArcSamples; sample += 1) {
             const amount = sample / rootArcSamples;
             points.push(polarPoint(dimensions.rootRadius, rightRootAngle + (valleyAfter - rightRootAngle) * amount));
@@ -431,11 +433,9 @@ export function resolveRackPitch(spec) {
     const reference = resolveCylindricalGear({
         ...(spec.backlash === undefined ? {} : { backlash: spec.backlash }),
         ...(spec.clearanceFactor === undefined ? {} : { clearanceFactor: spec.clearanceFactor }),
-        ...(spec.helixAngleDegrees === undefined ? {} : { helixAngleDegrees: spec.helixAngleDegrees }),
+        ...(spec.helixAngle === undefined ? {} : { helixAngle: spec.helixAngle }),
         module: spec.module,
-        ...(spec.pressureAngleDegrees === undefined
-            ? {}
-            : { pressureAngleDegrees: spec.pressureAngleDegrees }),
+        ...(spec.pressureAngle === undefined ? {} : { pressureAngle: spec.pressureAngle }),
         // Rack pitch facts do not depend on this cylindrical reference count. Use the maximum so the
         // reference remains undercut-free for every supported normal pressure and helix angle.
         toothCount: MAXIMUM_TOOTH_COUNT,

package/dist/geometry/mechanical/index.js

@@ -5,9 +5,9 @@
  */
 export { minimumCylindricalGearToothCountWithoutUndercut, resolveCylindricalGear, resolveCylindricalGearPair, resolveRackPitch, sampleCylindricalGearOutline, sampleInternalCylindricalGearSpaceOutline, sampleRackToothPath, } from "./gears.js";
 export { measureInternalCylindricalGearPairMotion } from "./gear-motion.js";
-export { buildHelicalThreadRidgeMesh, buildHelicalThreadSolidMesh } from "./thread-mesh.js";
-export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, createThreadProfile, } from "./thread-profiles.js";
+export { helicalThreadRidgeMesh, helicalThreadSolidMesh } from "./thread-mesh.js";
+export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, threadProfile, } from "./thread-profiles.js";
 export { preflightHelicalThreadSolidMesh } from "./thread-mesh-plan.js";
 export { sampleConventionalThreadHelices as sampleThreadHelices } from "./thread-helices.js";
 export { compensateThreadDiameters, PRINTABLE_THREAD_FIT_POLICIES, resolvePrintableThreadFitPolicy, resolveThreadCircularSegments, } from "./threads.js";
-export { getMetricClearanceHole, getMetricFastenerStandard, METRIC_FASTENER_STANDARDS, } from "./standards.js";
+export { getMetricClearanceHoleDiameter, getMetricFastenerStandard, METRIC_FASTENER_STANDARDS, } from "./standards.js";

package/dist/geometry/mechanical/standards.js

@@ -50,7 +50,7 @@ export function getMetricFastenerStandard(size) {
     return METRIC_FASTENER_STANDARDS[size];
 }
 /** Returns one recommended metric clearance-hole diameter in millimetres. */
-export function getMetricClearanceHole(size, fit = "normal") {
+export function getMetricClearanceHoleDiameter(size, fit = "normal") {
     const holes = getMetricFastenerStandard(size).clearanceHoles;
     const diameter = fit === "close"
         ? holes.close

package/dist/geometry/mechanical/thread-helices.js

@@ -29,10 +29,9 @@ export function sampleConventionalThreadHelices(options) {
     const count = Math.max(1, Math.ceil(turns * density));
     assertSamplingCount(starts * (count + 1), operation, resolveGeometrySamplingLimits(options.limits).maxPathPoints);
     const direction = handedness === "right" ? 1 : -1;
-    const phase = assertFiniteThreadNumber((assertFiniteThreadNumber(options.phaseDegrees ?? 0, "phaseDegrees", operation) * Math.PI) /
-        180, "phase", operation);
+    const phaseRadians = assertFiniteThreadNumber((assertFiniteThreadNumber(options.phase ?? 0, "phase", operation) * Math.PI) / 180, "phase", operation);
     const paths = Object.freeze(Array.from({ length: starts }, (_, start) => {
-        const initial = phase + (direction * 2 * Math.PI * start) / starts;
+        const initial = phaseRadians + (direction * 2 * Math.PI * start) / starts;
         return Object.freeze(Array.from({ length: count + 1 }, (_, index) => {
             const t = index / count;
             const z = length * t;

package/dist/geometry/mechanical/thread-mesh-plan.js

@@ -133,9 +133,9 @@ export const resolveHelicalThreadMeshOptions = (options, operation, circularSamp
         throw new GeometryError("INVALID_ARGUMENT", "Exact circularSegments must be divisible by the requested thread starts.", { operation, details: { circularSegments: base, starts } });
     }
     const segments = Math.ceil(base / starts) * starts;
-    const maximumSegments = resolution.maximumSegments;
-    if (segments > maximumSegments) {
-        throw new GeometryError("COMPLEXITY_LIMIT", "Start-aligned thread tessellation exceeds the configured segment safety limit.", { operation, details: { maximumSegments, segments } });
+    const maxSegments = resolution.maxSegments;
+    if (segments > maxSegments) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "Start-aligned thread tessellation exceeds the configured segment safety limit.", { operation, details: { maxSegments, segments } });
     }
     const handedness = options.handedness ?? "right";
     if (handedness !== "left" && handedness !== "right")
@@ -199,8 +199,7 @@ export const resolveHelicalThreadMeshOptions = (options, operation, circularSamp
         leadInLength,
         leadInShape,
         length,
-        phase: (assertFiniteThreadNumber(options.phaseDegrees ?? 0, "phaseDegrees", operation) * Math.PI) /
-            180,
+        phase: (assertFiniteThreadNumber(options.phase ?? 0, "phase", operation) * Math.PI) / 180,
         section,
         segments,
         starts,

package/dist/geometry/mechanical/thread-mesh.js

@@ -1,6 +1,6 @@
 /** Closed ridge and complete-solid mesh construction from resolved thread plans. */
 import { triangulateContour } from "../loft/loft.js";
-import { joinTriangleMeshes, measureTriangleMesh, reverseTriangleMesh, validateTriangleMesh, } from "../mesh/mesh.js";
+import { analyzeTriangleMesh, joinTriangleMeshes, reverseTriangleMesh, validateTriangleMesh, } from "../mesh/mesh.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits } from "../model-limits.js";
 import { resolveHelicalThreadMeshOptions, resolveHelicalThreadSolidMeshPreflight, } from "./thread-mesh-plan.js";
 import { buildThreadSurfaceColumn, stitchThreadSurfaceColumns } from "./thread-surface.js";
@@ -61,7 +61,7 @@ const buildThreadRidgeComponent = (options) => {
         indices: new Uint32Array(indices),
     };
     validateTriangleMesh(mesh, { requireClosed: true });
-    if (measureTriangleMesh(mesh, { requireClosed: true }).signedVolume < 0)
+    if (analyzeTriangleMesh(mesh, { requireClosed: true }).signedVolume < 0)
         mesh = reverseTriangleMesh(mesh);
     return mesh;
 };
@@ -74,8 +74,8 @@ const buildThreadRidgeComponent = (options) => {
  * conservative pre-allocation estimate rejects excessive meshes before constructing position
  * arrays.
  */
-export function buildHelicalThreadSolidMesh(options) {
-    const operation = "buildHelicalThreadSolidMesh";
+export function helicalThreadSolidMesh(options) {
+    const operation = "helicalThreadSolidMesh";
     const { maximumAxialSegmentLength, resolved } = resolveHelicalThreadSolidMeshPreflight(options, operation);
     const positions = [];
     const columns = Array.from({ length: resolved.segments }, (_, column) => buildThreadSurfaceColumn(options.profile, resolved, options, resolved.phase + (column * 2 * Math.PI) / resolved.segments, maximumAxialSegmentLength, positions));
@@ -103,7 +103,7 @@ export function buildHelicalThreadSolidMesh(options) {
         indices: new Uint32Array(indices),
     };
     validateTriangleMesh(mesh, { requireClosed: true });
-    if (measureTriangleMesh(mesh, { requireClosed: true }).signedVolume < 0) {
+    if (analyzeTriangleMesh(mesh, { requireClosed: true }).signedVolume < 0) {
         mesh = reverseTriangleMesh(mesh);
     }
     return mesh;
@@ -113,8 +113,8 @@ export function buildHelicalThreadSolidMesh(options) {
  * shaft's radial/axial frame. The mesh is intended for union with its
  * minor-envelope cylinder and never owns WASM objects.
  */
-export function buildHelicalThreadRidgeMesh(options) {
-    const operation = "buildHelicalThreadRidgeMesh";
+export function helicalThreadRidgeMesh(options) {
+    const operation = "helicalThreadRidgeMesh";
     const resolved = resolveHelicalThreadMeshOptions(options, operation);
     const z0 = resolved.bottomBoundary - resolved.section[0][0];
     const z1 = resolved.topBoundary - resolved.section.at(-1)[0];

package/dist/geometry/mechanical/thread-profiles.js

@@ -237,11 +237,11 @@ const standardProfile = (kind, pitch, depth, root, crest, leftRun, rightRun) =>
  *
  * @example Printable triangular thread profile
  * ```ts
- * createThreadProfile({ kind: "triangular", pitch: 1.75 });
+ * threadProfile({ kind: "triangular", pitch: 1.75 });
  * ```
  */
-export function createThreadProfile(spec) {
-    const operation = "createThreadProfile";
+export function threadProfile(spec) {
+    const operation = "threadProfile";
     const pitch = assertFiniteThreadNumber(spec.pitch, "pitch", operation);
     const tolerance = resolveGeometryTolerance(Math.abs(pitch), spec.tolerance);
     if (!(pitch > tolerance.linear))
@@ -358,9 +358,9 @@ export function createThreadProfile(spec) {
     }
     const includedAngle = spec.kind === "acme"
         ? 29
-        : assertFiniteThreadNumber(spec.threadAngle ?? 30, "threadAngle", operation);
+        : assertFiniteThreadNumber(spec.includedAngle ?? 30, "includedAngle", operation);
     if (includedAngle < 0 || includedAngle >= 180) {
-        throw new GeometryError("INVALID_ARGUMENT", "threadAngle must be at least 0 degrees and below 180 degrees.", { operation });
+        throw new GeometryError("INVALID_ARGUMENT", "includedAngle must be at least 0 degrees and below 180 degrees.", { operation });
     }
     const halfIncludedAngle = includedAngle / 2;
     const flankRun = depth * (halfIncludedAngle === 45 ? 1 : Math.tan((halfIncludedAngle * Math.PI) / 180));

package/dist/geometry/mechanical/thread-solids.js

@@ -45,12 +45,12 @@ export const resolveCompensatedThreadSolidMesh = (options, role) => {
     const femaleBevelOutset = (style, size) => style === "blunt"
         ? Math.min(size, hypotheticalFemaleLength / 2)
         : Math.max(0, Math.min(size, hypotheticalFemaleLength / 2) - options.profile.depth);
-    const maximumRadialOutset = Math.max(options.bevelBottom === true ? femaleBevelOutset(bottomStyle, femaleBottomBevelSize) : 0, options.bevelTop === true ? femaleBevelOutset(topStyle, femaleTopBevelSize) : 0);
+    const maxRadialOutset = Math.max(options.bevelBottom === true ? femaleBevelOutset(bottomStyle, femaleBottomBevelSize) : 0, options.bevelTop === true ? femaleBevelOutset(topStyle, femaleTopBevelSize) : 0);
     const segments = resolveThreadCircularSegments({
         nominalMajorDiameter: options.nominalMajorDiameter,
         profile: options.profile,
         starts,
-        maximumRadialOutset,
+        maxRadialOutset,
         ...(options.limits === undefined ? {} : { limits: options.limits }),
         ...(options.fit === undefined ? {} : { fit: options.fit }),
         ...(options.resolution === undefined ? {} : { resolution: options.resolution }),

package/dist/geometry/mechanical/thread-surface.js

@@ -348,7 +348,7 @@ export const buildThreadSurfaceColumn = (profile, resolved, options, angle, maxi
     let previousZ;
     for (const sample of sampled) {
         const radius = radiusAt(sample, sample.z);
-        requirePositiveThreadSurfaceRadius(radius, resolved, "buildHelicalThreadSolidMesh");
+        requirePositiveThreadSurfaceRadius(radius, resolved, "helicalThreadSolidMesh");
         if (previousRadius !== undefined &&
             previousZ !== undefined &&
             Math.abs(sample.z - previousZ) <= resolved.tolerance.linear &&

package/dist/geometry/mechanical/threads.js

@@ -81,17 +81,17 @@ export function compensateThreadDiameters(options) {
  * Resolves a role-independent, start-aligned facet count from the larger female mating envelope.
  *
  * An exact `circularSegments` value must already be divisible by `starts`; it is never silently
- * raised. Adaptive policies align upward and fail if that would exceed `maximumSegments`.
+ * raised. Adaptive policies align upward and fail if that would exceed `maxSegments`.
  */
 export function resolveThreadCircularSegments(options) {
     const operation = "resolveThreadCircularSegments";
     const nominalMajorDiameter = finite(options.nominalMajorDiameter, "Nominal major diameter");
-    const maximumRadialOutset = finite(options.maximumRadialOutset ?? 0, "Maximum radial outset");
+    const maxRadialOutset = finite(options.maxRadialOutset ?? 0, "Maximum radial outset");
     const pitch = finite(options.profile.pitch, "Profile pitch");
     const starts = finite(options.starts ?? 1, "Starts");
     if (!(nominalMajorDiameter > 0) ||
         !(pitch > 0) ||
-        maximumRadialOutset < 0 ||
+        maxRadialOutset < 0 ||
         !Number.isInteger(starts) ||
         starts < 1 ||
         starts > 32) {
@@ -100,22 +100,22 @@ export function resolveThreadCircularSegments(options) {
     const policy = resolvePrintableThreadFitPolicy(options.fit);
     const resolution = resolveGeometryResolution(options.resolution, options.limits);
     const femaleMajorDiameter = nominalMajorDiameter + policy.femaleRadialOutset * 2;
-    const maximumFemaleRadius = femaleMajorDiameter / 2 + maximumRadialOutset;
+    const maximumFemaleRadius = femaleMajorDiameter / 2 + maxRadialOutset;
     const effectiveRadius = Math.hypot(Math.PI * maximumFemaleRadius * 2, pitch * starts) / (Math.PI * 2);
     const baseSegments = resolveCircularSegments(effectiveRadius, options.resolution, options.limits);
     if (resolution.circularSegments !== undefined && baseSegments % starts !== 0) {
         throw new GeometryError("INVALID_ARGUMENT", "Exact circularSegments must be divisible by the requested thread starts.", { operation, details: { circularSegments: baseSegments, starts } });
     }
     let segments = Math.ceil(baseSegments / starts) * starts;
-    if (segments > resolution.maximumSegments) {
-        throw new GeometryError("COMPLEXITY_LIMIT", "Start-aligned thread tessellation exceeds the configured segment safety limit.", { operation, details: { maximumSegments: resolution.maximumSegments, segments } });
+    if (segments > resolution.maxSegments) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "Start-aligned thread tessellation exceeds the configured segment safety limit.", { operation, details: { maxSegments: resolution.maxSegments, segments } });
     }
     // Physical circle error is only the lower bound for a mating thread grid. Independently
     // triangulated male and female helices also need enough angular facets to distribute their full
     // phase-span allowance without consuming either profile's crest or root flats. Adaptive policies
     // therefore refine by complete start-aligned steps; an exact caller override remains exact and
     // fails instead of being silently changed.
-    while (segments <= resolution.maximumSegments) {
+    while (segments <= resolution.maxSegments) {
         try {
             compensateThreadProfileForFaceting(options.profile, policy.axialBacklash, "male", starts, segments);
             compensateThreadProfileForFaceting(options.profile, policy.axialBacklash, "female", starts, segments);
@@ -132,6 +132,6 @@ export function resolveThreadCircularSegments(options) {
     }
     throw new GeometryError("COMPLEXITY_LIMIT", "Mating thread faceting requires more segments than the configured safety limit.", {
         operation,
-        details: { maximumSegments: resolution.maximumSegments, starts },
+        details: { maxSegments: resolution.maxSegments, starts },
     });
 }

package/dist/geometry/mesh/mesh-planar.js

@@ -41,29 +41,27 @@ const positiveFinite = (value, label) => {
     return value;
 };
 const resolveOptions = (options) => {
-    const triggerMaximumFanRatio = options.triggerMaximumFanRatio ?? DEFAULT_TRIGGER_MAXIMUM_FAN_RATIO;
-    if (!Number.isFinite(triggerMaximumFanRatio) ||
-        triggerMaximumFanRatio < 0 ||
-        triggerMaximumFanRatio > 1) {
+    const triggerMaxFanRatio = options.triggerMaxFanRatio ?? DEFAULT_TRIGGER_MAXIMUM_FAN_RATIO;
+    if (!Number.isFinite(triggerMaxFanRatio) || triggerMaxFanRatio < 0 || triggerMaxFanRatio > 1) {
         throw new GeometryError("INVALID_ARGUMENT", "Maximum fan ratio trigger must be finite and between zero and one.");
     }
-    const triggerMinimumAngleDegrees = positiveFinite(options.triggerMinimumAngleDegrees ?? DEFAULT_TRIGGER_MINIMUM_ANGLE_DEGREES, "Minimum angle trigger");
-    if (triggerMinimumAngleDegrees >= 180) {
+    const triggerMinAngleDegrees = positiveFinite(options.triggerMinAngleDegrees ?? DEFAULT_TRIGGER_MINIMUM_ANGLE_DEGREES, "Minimum angle trigger");
+    if (triggerMinAngleDegrees >= 180) {
         throw new GeometryError("INVALID_ARGUMENT", "Minimum angle trigger must be below 180 degrees.");
     }
     return {
-        maximumEdgeRevisits: positiveInteger(options.maximumEdgeRevisits ?? DEFAULT_MAXIMUM_EDGE_REVISITS, "Maximum edge revisits"),
-        maximumFlipAttempts: options.maximumFlipAttempts === undefined
+        maxEdgeRevisits: positiveInteger(options.maxEdgeRevisits ?? DEFAULT_MAXIMUM_EDGE_REVISITS, "Maximum edge revisits"),
+        maxFlipAttempts: options.maxFlipAttempts === undefined
             ? undefined
-            : positiveInteger(options.maximumFlipAttempts, "Maximum flip attempts"),
-        maximumPatchTriangleCount: positiveInteger(options.maximumPatchTriangleCount ?? DEFAULT_MAXIMUM_PATCH_TRIANGLE_COUNT, "Maximum patch triangle count"),
-        maximumProcessedTriangleCount: positiveInteger(options.maximumProcessedTriangleCount ?? DEFAULT_MAXIMUM_PROCESSED_TRIANGLE_COUNT, "Maximum processed triangle count"),
-        minimumPatchTriangleCount: positiveInteger(options.minimumPatchTriangleCount ?? DEFAULT_MINIMUM_PATCH_TRIANGLE_COUNT, "Minimum patch triangle count"),
-        triggerMaximumAspectRatio: positiveFinite(options.triggerMaximumAspectRatio ?? DEFAULT_TRIGGER_MAXIMUM_ASPECT_RATIO, "Maximum aspect-ratio trigger"),
-        triggerMaximumFanRatio,
-        triggerMaximumVertexTriangleIncidence: positiveInteger(options.triggerMaximumVertexTriangleIncidence ??
+            : positiveInteger(options.maxFlipAttempts, "Maximum flip attempts"),
+        maxPatchTriangles: positiveInteger(options.maxPatchTriangles ?? DEFAULT_MAXIMUM_PATCH_TRIANGLE_COUNT, "Maximum patch triangle count"),
+        maxProcessedTriangles: positiveInteger(options.maxProcessedTriangles ?? DEFAULT_MAXIMUM_PROCESSED_TRIANGLE_COUNT, "Maximum processed triangle count"),
+        minPatchTriangles: positiveInteger(options.minPatchTriangles ?? DEFAULT_MINIMUM_PATCH_TRIANGLE_COUNT, "Minimum patch triangle count"),
+        triggerMaxAspectRatio: positiveFinite(options.triggerMaxAspectRatio ?? DEFAULT_TRIGGER_MAXIMUM_ASPECT_RATIO, "Maximum aspect-ratio trigger"),
+        triggerMaxFanRatio,
+        triggerMaxVertexTriangleIncidence: positiveInteger(options.triggerMaxVertexTriangleIncidence ??
             DEFAULT_TRIGGER_MAXIMUM_VERTEX_TRIANGLE_INCIDENCE, "Maximum vertex triangle-incidence trigger"),
-        triggerMinimumAngleDegrees,
+        triggerMinAngleDegrees,
     };
 };
 const pairQuality = (positions, first, second) => {
@@ -118,11 +116,11 @@ const localConcentrationPotential = (vertices, incidence, valence, changes = new
 };
 const isTriggeredPatch = (patch, options) => {
     const report = patch.report;
-    return (report.triangleCount >= options.minimumPatchTriangleCount &&
-        (report.minimumTriangleAngleDegrees < options.triggerMinimumAngleDegrees ||
-            report.maximumTriangleAspectRatio > options.triggerMaximumAspectRatio ||
-            report.maximumVertexTriangleIncidence > options.triggerMaximumVertexTriangleIncidence ||
-            report.fanRatio > options.triggerMaximumFanRatio));
+    return (report.triangleCount >= options.minPatchTriangles &&
+        (report.minimumTriangleAngleDegrees < options.triggerMinAngleDegrees ||
+            report.maximumTriangleAspectRatio > options.triggerMaxAspectRatio ||
+            report.maximumVertexTriangleIncidence > options.triggerMaxVertexTriangleIncidence ||
+            report.fanRatio > options.triggerMaxFanRatio));
 };
 const unchangedResult = (mesh, report, skippedPatchCount, budgetExhausted, fallbackReason) => ({
     after: report,
@@ -189,8 +187,8 @@ export function optimizePlanarPatches(mesh, options = {}) {
     for (const patch of before.patches) {
         if (!isTriggeredPatch(patch, resolved))
             continue;
-        if (patch.report.triangleCount > resolved.maximumPatchTriangleCount ||
-            selectedTriangleCount + patch.report.triangleCount > resolved.maximumProcessedTriangleCount) {
+        if (patch.report.triangleCount > resolved.maxPatchTriangles ||
+            selectedTriangleCount + patch.report.triangleCount > resolved.maxProcessedTriangles) {
             skippedPatchCount += 1;
             budgetExhausted = true;
             continue;
@@ -225,9 +223,9 @@ export function optimizePlanarPatches(mesh, options = {}) {
     const initialEdges = [...edges.values()]
         .filter(isCandidateEdge)
         .sort((left, right) => left.first - right.first || left.second - right.second);
-    const maximumFlipAttempts = resolved.maximumFlipAttempts ??
+    const maxFlipAttempts = resolved.maxFlipAttempts ??
         Math.min(DEFAULT_MAXIMUM_FLIP_ATTEMPTS, initialEdges.length * ATTEMPTS_PER_INITIAL_EDGE);
-    if (maximumFlipAttempts === 0) {
+    if (maxFlipAttempts === 0) {
         return unchangedResult(mesh, before.report, skippedPatchCount, budgetExhausted);
     }
     const queue = initialEdges.map(({ key }) => key);
@@ -281,14 +279,14 @@ export function optimizePlanarPatches(mesh, options = {}) {
         }
         const sorted = [...candidates.values()].sort((left, right) => left.first - right.first || left.second - right.second);
         for (const { key } of sorted) {
-            if (queued.has(key) || (revisitCounts.get(key) ?? 0) >= resolved.maximumEdgeRevisits) {
+            if (queued.has(key) || (revisitCounts.get(key) ?? 0) >= resolved.maxEdgeRevisits) {
                 continue;
             }
             queued.add(key);
             queue.push(key);
         }
     };
-    while (queueOffset < queue.length && attemptCount < maximumFlipAttempts) {
+    while (queueOffset < queue.length && attemptCount < maxFlipAttempts) {
         const key = queue[queueOffset++];
         queued.delete(key);
         const revisits = (revisitCounts.get(key) ?? 0) + 1;

package/dist/geometry/mesh/mesh-quality.js

@@ -39,7 +39,7 @@ const positiveInteger = (value, label) => {
     }
     return value;
 };
-const structurallyValidateMesh = (mesh, maximumTriangleCount) => {
+const structurallyValidateMesh = (mesh, maxTriangles) => {
     if (!(mesh.positions instanceof Float32Array) || !(mesh.indices instanceof Uint32Array)) {
         throw new GeometryError("INVALID_MESH", "Triangle meshes require Float32Array positions and Uint32Array indices.");
     }
@@ -50,8 +50,8 @@ const structurallyValidateMesh = (mesh, maximumTriangleCount) => {
         throw new GeometryError("INVALID_MESH", "Mesh indices must contain complete triangles.");
     }
     const triangleCount = mesh.indices.length / 3;
-    if (triangleCount > maximumTriangleCount) {
-        throw new GeometryError("COMPLEXITY_LIMIT", `Mesh quality analysis is limited to ${maximumTriangleCount} triangles.`);
+    if (triangleCount > maxTriangles) {
+        throw new GeometryError("COMPLEXITY_LIMIT", `Mesh quality analysis is limited to ${maxTriangles} triangles.`);
     }
     for (let index = 0; index < mesh.positions.length; index += 1) {
         if (!Number.isFinite(mesh.positions[index])) {
@@ -236,8 +236,8 @@ const buildPatchAnalysis = (faces, edges, faceIndices, id) => {
 /** @internal */
 export function buildTriangleMeshQualityAnalysis(mesh, options = {}) {
     const source = { positions: mesh.positions, indices: mesh.indices };
-    const maximumTriangleCount = positiveInteger(options.maximumTriangleCount ?? DEFAULT_MAXIMUM_TRIANGLE_COUNT, "Maximum analyzed triangle count");
-    structurallyValidateMesh(source, maximumTriangleCount);
+    const maxTriangles = positiveInteger(options.maxTriangles ?? DEFAULT_MAXIMUM_TRIANGLE_COUNT, "Maximum analyzed triangle count");
+    structurallyValidateMesh(source, maxTriangles);
     const { bounds, extent } = meshBoundsAndExtent(source.positions);
     const tolerance = resolveGeometryTolerance(extent, options.tolerance);
     const planarLinearTolerance = Math.max(tolerance.linear, Math.max(extent, 1) * FLOAT32_EPSILON * 8);

package/dist/geometry/mesh/mesh-signature.js

@@ -6,7 +6,7 @@ const DEFAULT_MAXIMUM_TRIANGLE_COUNT = 200_000;
 const validatePositiveTolerance = (value, name) => {
     if (!Number.isFinite(value) || value <= 0) {
         throw new GeometryError("INVALID_TOLERANCE", `${name} must be finite and greater than zero.`, {
-            operation: "createTriangleMeshSignature",
+            operation: "computeTriangleMeshSignature",
             details: { [name]: value },
         });
     }
@@ -17,7 +17,7 @@ const quantizedInteger = (value, tolerance, name) => {
     const quantized = scaled < 0 ? -Math.round(-scaled) : Math.round(scaled);
     if (!Number.isSafeInteger(quantized)) {
         throw new GeometryError("INVALID_TOLERANCE", `${name} cannot be represented safely at the requested signature tolerance.`, {
-            operation: "createTriangleMeshSignature",
+            operation: "computeTriangleMeshSignature",
             details: { tolerance, value },
         });
     }
@@ -70,23 +70,23 @@ const hashCanonicalKeys = (header, groups) => {
  * @returns Compact counts, bounds, volume, topology, tolerances, and canonical fingerprint.
  * @throws {@link GeometryError} When validation, topology, tolerance, or complexity checks fail.
  */
-export function createTriangleMeshSignature(mesh, options = {}) {
+export function computeTriangleMeshSignature(mesh, options = {}) {
     const source = { positions: mesh.positions, indices: mesh.indices };
-    const maximumTriangleCount = options.maximumTriangleCount ?? DEFAULT_MAXIMUM_TRIANGLE_COUNT;
-    if (!Number.isSafeInteger(maximumTriangleCount) || maximumTriangleCount <= 0) {
-        throw new GeometryError("INVALID_ARGUMENT", "maximumTriangleCount must be a positive safe integer.", {
-            operation: "createTriangleMeshSignature",
-            details: { maximumTriangleCount },
+    const maxTriangles = options.maxTriangles ?? DEFAULT_MAXIMUM_TRIANGLE_COUNT;
+    if (!Number.isSafeInteger(maxTriangles) || maxTriangles <= 0) {
+        throw new GeometryError("INVALID_ARGUMENT", "maxTriangles must be a positive safe integer.", {
+            operation: "computeTriangleMeshSignature",
+            details: { maxTriangles },
         });
     }
     if (!(source.positions instanceof Float32Array) || !(source.indices instanceof Uint32Array)) {
         validateTriangleMesh(source, { requireClosed: true });
     }
     const triangleCount = source.indices.length / 3;
-    if (triangleCount > maximumTriangleCount) {
-        throw new GeometryError("COMPLEXITY_LIMIT", `Mesh signature analysis is limited to ${maximumTriangleCount} triangles; received ${triangleCount}.`, {
-            operation: "createTriangleMeshSignature",
-            details: { maximumTriangleCount, triangleCount },
+    if (triangleCount > maxTriangles) {
+        throw new GeometryError("COMPLEXITY_LIMIT", `Mesh signature analysis is limited to ${maxTriangles} triangles; received ${triangleCount}.`, {
+            operation: "computeTriangleMeshSignature",
+            details: { maxTriangles, triangleCount },
         });
     }
     const positionTolerance = validatePositiveTolerance(options.positionTolerance ?? DEFAULT_POSITION_TOLERANCE, "positionTolerance");
@@ -98,7 +98,7 @@ export function createTriangleMeshSignature(mesh, options = {}) {
     const twiceGenus = connectedComponentCount * 2 - eulerCharacteristic;
     if (twiceGenus < 0 || twiceGenus % 2 !== 0) {
         throw new GeometryError("INVALID_TOPOLOGY", "Closed mesh topology does not describe orientable vertex-manifold components.", {
-            operation: "createTriangleMeshSignature",
+            operation: "computeTriangleMeshSignature",
             details: { connectedComponentCount, edgeCount, eulerCharacteristic },
         });
     }