@metamesh/modeling 0.14.0 → 0.16.0

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 }),
@@ -96,11 +96,30 @@ export const resolveCompensatedThreadSolidMesh = (options, role) => {
     });
 };
 const preflightCompensatedThreadSolid = (options, role) => preflightHelicalThreadSolidMesh(resolveCompensatedThreadSolidMesh(options, role).meshOptions);
-/** Preflights the exact compensated direct mesh used by the threaded rod constructor. */
+/**
+ * Resolves compensated rod dimensions and checks conservative mesh estimates against output limits.
+ *
+ * This pure operation uses explicit resolution and limits or package defaults, without an active
+ * host execution. It creates planning data without mesh buffers or native objects; returned row
+ * and triangle counts are estimates. Mesh validity and native construction are checked later.
+ *
+ * @see {@link preflightHelicalThreadSolidMesh}
+ * @see {@link helicalThreadSolidMesh}
+ */
 export function preflightThreadedRodSolid(options) {
     return preflightCompensatedThreadSolid(options, "male");
 }
-/** Preflights the exact extended mesh used by the internal thread cutter constructor. */
+/**
+ * Resolves compensated cutter dimensions and checks extended mesh estimates against output limits.
+ *
+ * This pure operation uses explicit resolution and limits or package defaults, without an active
+ * host execution. It includes the cutter's one-pitch extension beyond each requested face and
+ * creates planning data without mesh buffers or native objects. Row and triangle counts are
+ * estimates; mesh validity and native construction are checked later.
+ *
+ * @see {@link preflightHelicalThreadSolidMesh}
+ * @see {@link helicalThreadSolidMesh}
+ */
 export function preflightInternalThreadCutterSolid(options) {
     return preflightCompensatedThreadSolid(options, "female");
 }
@@ -222,8 +241,14 @@ export const resolveThreadedNutSolid = (options, operation) => {
     });
 };
 /**
- * Resolves a nut's exact body/cutter chamfer and preflights its extended thread mesh without
- * allocating Manifold WASM objects.
+ * Checks nut dimensions, chamfers, end-face wall, and the extended compensated cutter's allocation plan.
+ *
+ * This pure operation uses explicit resolution and limits or package defaults, without an active
+ * host execution. It resolves body/cutter dimensions without mesh buffers or native objects.
+ * `thread` contains conservative cutter estimates, excluding the body and Boolean result.
+ * Successful preflight leaves mesh validity, native construction, and manufacturing fit to later checks.
+ *
+ * @see {@link preflightHelicalThreadSolidMesh}
  */
 export function preflightThreadedNutSolid(options) {
     return resolveThreadedNutSolid(options, "preflightThreadedNutSolid").preflight;

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-centroid.js

@@ -2,6 +2,7 @@ import { GeometryError } from "../errors.js";
 import { analyzeTriangleMesh } from "./mesh.js";
 /**
  * Computes the uniform-density volume centroid of an oriented closed solid, including cavity shells.
+ *
  * Coordinates are millimetres. Indexed closure and positive aggregate volume are required; callers
  * may use validateSolidMesh first when geometric intersections and shell orientation are untrusted.
  * Fresh mutable input is inspected on every call, and buffers are never changed.

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 },
         });
     }

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

@@ -7,6 +7,7 @@ const MAXIMUM_TRIANGLES = 200_000;
 const MAXIMUM_TESTS = 2_000_000;
 /**
  * Checks closed indexed topology, triangle intersections, and alternating nested shell orientation.
+ *
  * Outward exterior shells and inward cavity shells are accepted. Separate shells must not touch,
  * intersect, or overlap as material. Indexed neighbours may share their own vertex or edge.
  *
@@ -36,9 +37,9 @@ function validationWork(mesh, options) {
             operation: "validateSolidMesh",
         });
     const count = mesh.indices.length / 3;
-    const maximumTests = options.maximumTests ?? MAXIMUM_TESTS;
-    if (!Number.isSafeInteger(maximumTests) || maximumTests < 1 || maximumTests > MAXIMUM_TESTS)
-        throw new GeometryError("INVALID_ARGUMENT", "Solid validation maximumTests must be an integer from 1 through 2,000,000.", { operation: "validateSolidMesh" });
+    const maxTests = options.maxTests ?? MAXIMUM_TESTS;
+    if (!Number.isSafeInteger(maxTests) || maxTests < 1 || maxTests > MAXIMUM_TESTS)
+        throw new GeometryError("INVALID_ARGUMENT", "Solid validation maxTests must be an integer from 1 through 2,000,000.", { operation: "validateSolidMesh" });
     if (count > MAXIMUM_TRIANGLES)
         throw new GeometryError("COMPLEXITY_LIMIT", "Solid validation exceeds its triangle ceiling.", {
             operation: "validateSolidMesh",
@@ -46,7 +47,7 @@ function validationWork(mesh, options) {
         });
     if (mesh.positions.length / 3 > mesh.indices.length)
         throw new GeometryError("INVALID_MESH", "Solid validation requires every position-buffer vertex to be referenced.", { operation: "validateSolidMesh" });
-    return { count, maximumTests };
+    return { count, maxTests };
 }
 /** @internal Fresh measurements precede one adjacency traversal for closure, fans, and shells. */
 export function analyzeSolidMesh(mesh, options = {}) {
@@ -71,14 +72,14 @@ export function validateAnalyzedSolidMesh(mesh, measurements, options = {}) {
         : mesh;
     checkSolidGeometry(source, measurements, options, validationWork(source, options));
 }
-function checkSolidGeometry(mesh, facts, options, { count, maximumTests }) {
+function checkSolidGeometry(mesh, facts, options, { count, maxTests }) {
     const epsilon = resolveGeometryTolerance(Math.hypot(...facts.bounds.max.map((value, axis) => value - facts.bounds.min[axis])), options.tolerance).linear;
     let tests = 0;
     const spend = () => {
-        if (++tests > maximumTests)
+        if (++tests > maxTests)
             throw new GeometryError("COMPLEXITY_LIMIT", "Solid validation exhausted its work ceiling.", {
                 operation: "validateSolidMesh",
-                details: { required: tests, allowed: maximumTests },
+                details: { required: tests, allowed: maxTests },
             });
     };
     const vertex = (index) => [

package/dist/geometry/mesh/mesh.js

@@ -1,6 +1,7 @@
 import { GeometryError } from "../errors.js";
 import { writeMeshVertex } from "../numeric.js";
 import { resolveGeometryTolerance } from "../tolerance.js";
+import { readTransformMatrix } from "../transform-matrix.js";
 import { transformDeterminant3, validateTransform3 } from "../transform3.js";
 import { IndexedMeshEdgeTable } from "./mesh-edge-table.js";
 function inspectTriangleMesh(mesh, options = {}, mode = "validate", topology = false) {
@@ -184,19 +185,6 @@ export function validateTriangleMesh(mesh, options = {}) {
 export const meshBounds = (mesh) => {
     return inspectTriangleMesh(mesh, {}, "bounds");
 };
-/**
- * Measures bounds, surface area, and signed volume without changing the mesh.
- *
- * Signed volume is meaningful for a consistently wound closed mesh. Set
- * `requireClosed` when measurements will be used as manufacturing assertions.
- *
- * @param mesh - Mesh to validate and measure.
- * @param options - Validation policy applied before measurement.
- * @returns Immutable deterministic scalar and bounds measurements.
- */
-export function measureTriangleMesh(mesh, options = {}) {
-    return inspectTriangleMesh(mesh, options, "measure");
-}
 /**
  * Concatenates meshes into one indexed mesh without welding coincident vertices.
  *
@@ -257,12 +245,13 @@ export function reverseTriangleMesh(mesh) {
  * automatically reverses every triangle. Singular transforms are rejected.
  *
  * @param mesh - Mesh to transform without mutation.
- * @param transform - Row-major affine transform.
+ * @param placement - Immutable spatial placement or canonical row-major affine matrix.
  * @returns A mesh with fresh transformed positions and copied or reversed indices.
  */
-export function transformTriangleMesh(mesh, transform) {
+export function transformTriangleMesh(mesh, placement) {
     const source = { positions: mesh.positions, indices: mesh.indices };
     validateTriangleMesh(source);
+    const transform = readTransformMatrix(placement, 3);
     validateTransform3(transform);
     const positions = new Float32Array(source.positions.length);
     for (let offset = 0; offset < source.positions.length; offset += 3) {

package/dist/geometry/paths/closest-point.js

@@ -1,37 +1,26 @@
 import { GeometryError } from "../errors.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
-export function closestPointOnPath(path, point, options = {}) {
+/** Internal scalar scan. Immutable paths validate their coordinates and ceiling once at construction. */
+export function closestPointOnValidatedPath(path, point, closed) {
     const fail = (message, code = "INVALID_ARGUMENT") => {
-        throw new GeometryError(code, message, { operation: "closestPointOnPath" });
+        throw new GeometryError(code, message, { operation: "path.closestPoint" });
     };
     const dimensions = point.length;
-    const closed = options.closed ?? false;
-    if (typeof closed !== "boolean" || (dimensions !== 2 && dimensions !== 3))
-        fail("Use a 2D or 3D point and a boolean closed option.");
-    assertSamplingCount(path.length, "closestPointOnPath", resolveGeometrySamplingLimits(options.limits).maxPathPoints);
     if (path.length < (closed ? 3 : 2))
         fail("Open paths need two points; closed paths need three.");
-    const validate = (value) => {
-        if (value.length !== dimensions)
-            fail("Path and query points must have the same dimension.");
-        if (!Number.isFinite(value[0]) ||
-            !Number.isFinite(value[1]) ||
-            (dimensions === 3 && !Number.isFinite(value[2])))
-            fail("Path and query coordinates must be finite.", "NON_FINITE_VALUE");
-    };
-    validate(point);
-    validate(path[0]);
+    if (!Number.isFinite(point[0]) ||
+        !Number.isFinite(point[1]) ||
+        (dimensions === 3 && !Number.isFinite(point[2])))
+        fail("Query coordinates must be finite.", "NON_FINITE_VALUE");
     let bestDistance = Infinity, bestSquared = Infinity, edgeIndex = 0, fraction = 0;
     let bestX = 0, bestY = 0, bestZ = 0;
     const count = closed ? path.length : path.length - 1;
     for (let i = 0; i < count; i++) {
         const a = path[i], b = path[(i + 1) % path.length];
-        validate(b);
         const dx = b[0] - a[0], dy = b[1] - a[1], dz = (b[2] ?? 0) - (a[2] ?? 0);
         const px = point[0] - a[0], py = point[1] - a[1], pz = (point[2] ?? 0) - (a[2] ?? 0);
         const lengthSquared = dx * dx + dy * dy + dz * dz;
         let projection = (px * dx + py * dy + pz * dz) / lengthSquared;
-        if (!Number.isFinite(projection)) {
+        if (!Number.isFinite(lengthSquared) || !Number.isFinite(projection)) {
             // Normalize only extreme extents; ordinary boundary scans use scalar squared arithmetic.
             const scale = Math.max(Math.abs(dx), Math.abs(dy), Math.abs(dz));
             if (!Number.isFinite(scale))

package/dist/geometry/paths/frames.js

@@ -1,5 +1,15 @@
+import { GeometryError } from "../errors.js";
+import { vector3Data } from "../math/vector-value.js";
 import { cross3, dot3, length3, normalize3, projectOntoPlane3, rotateAroundAxis3Radians, scale3, subtract3, } from "../math/vector3.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
+import { path3InputData } from "./path-value.js";
+const guideData = (input, operation) => {
+    const coordinates = vector3Data(input);
+    if (!coordinates.every(Number.isFinite))
+        throw new GeometryError("NON_FINITE_VALUE", "Path frame guides must have finite coordinates.", {
+            operation,
+        });
+    return coordinates;
+};
 const tangentAt = (path, index) => {
     if (index === 0) {
         return normalize3(subtract3(path[1], path[0]));
@@ -23,7 +33,9 @@ const chooseInitialNormal = (tangent, preferred) => {
             return normalize3(projected);
         }
     }
-    throw new Error("Unable to choose an initial path normal.");
+    throw new GeometryError("DEGENERATE_GEOMETRY", "Unable to choose an initial path normal.", {
+        operation: "computeParallelTransportFrames",
+    });
 };
 const transportNormal = (normal, previousTangent, tangent) => {
     const rotationAxis = cross3(previousTangent, tangent);
@@ -38,17 +50,23 @@ const transportNormal = (normal, previousTangent, tangent) => {
 };
 /**
  * Builds rotation-minimizing frames by parallel-transporting the previous normal.
+ *
  * This avoids the sudden profile flips produced by picking a fresh up-vector per ring.
  * Paths exceeding maxPathPoints (default 100000) reject before frame allocation or guide evaluation.
+ * Requires open path values; raw tuples are interpreted as an open path. Invalid paths throw GeometryError.
+ * Nonfinite normals and guide results reject. A finite initial guide parallel to the tangent selects a canonical fallback.
  */
-export const computeParallelTransportFrames = (path, initialNormal, normalGuide, limits = {}) => {
+export const computeParallelTransportFrames = (input, initialNormal, normalGuide, limits = {}) => {
+    const { points: path } = path3InputData(input, false, limits);
     if (path.length < 2) {
-        throw new Error("A framed path needs at least two points.");
+        throw new GeometryError("INVALID_ARGUMENT", "A framed path needs at least two points.", {
+            operation: "computeParallelTransportFrames",
+        });
     }
-    assertSamplingCount(path.length, "computeParallelTransportFrames", resolveGeometrySamplingLimits(limits).maxPathPoints);
     const tangents = path.map((_, index) => tangentAt(path, index));
     const firstTangent = tangents[0];
-    let normal = chooseInitialNormal(firstTangent, normalGuide?.(path[0], 0) ?? initialNormal);
+    const firstGuide = normalGuide?.(path[0], 0) ?? initialNormal;
+    let normal = chooseInitialNormal(firstTangent, firstGuide === undefined ? undefined : guideData(firstGuide, "computeParallelTransportFrames"));
     const frames = [
         {
             tangent: firstTangent,
@@ -64,7 +82,7 @@ export const computeParallelTransportFrames = (path, initialNormal, normalGuide,
             normal = transportNormal(normal, previousTangent, tangent);
         }
         else {
-            const guided = normalize3(projectOntoPlane3(guide, tangent));
+            const guided = normalize3(projectOntoPlane3(guideData(guide, "computeParallelTransportFrames"), tangent));
             // A guide describes an unoriented plane direction. Preserve the prior
             // sign so noisy guide inputs cannot create a 180-degree seam flip.
             normal = dot3(guided, normal) < 0 ? scale3(guided, -1) : guided;
@@ -92,14 +110,27 @@ const signedAngleAround = (from, to, axis) => Math.atan2(dot3(axis, cross3(from,
  * normal back to the first tangent measures seam holonomy; distributing that residual rotation
  * uniformly over all path intervals avoids a visible seam or accumulated frame flip.
  * The maxPathPoints ceiling (default 100000) bounds path points and frames.
+ * Requires closed path values; raw tuples are interpreted as closed and must omit their seam point.
+ * Invalid paths throw GeometryError.
+ * Nonfinite initial normals reject; finite parallel preferences select a canonical fallback.
  */
-export const computeClosedParallelTransportFrames = (path, initialNormal, limits = {}) => {
+export const computeClosedParallelTransportFrames = (input, initialNormal, limits = {}) => {
+    const { points: path } = path3InputData(input, true, limits);
     if (path.length < 3) {
-        throw new Error("A closed framed path needs at least three points.");
+        throw new GeometryError("INVALID_ARGUMENT", "A closed framed path needs at least three points.", {
+            operation: "computeClosedParallelTransportFrames",
+        });
     }
-    assertSamplingCount(path.length, "computeClosedParallelTransportFrames", resolveGeometrySamplingLimits(limits).maxPathPoints);
+    if (path[0].every((coordinate, axis) => coordinate === path.at(-1)[axis]))
+        throw new GeometryError("INVALID_ARGUMENT", "Closed framed paths omit their repeated seam point.", {
+            operation: "computeClosedParallelTransportFrames",
+        });
     const tangents = path.map((_, index) => closedTangentAt(path, index));
-    const transportedNormals = [chooseInitialNormal(tangents[0], initialNormal)];
+    const transportedNormals = [
+        chooseInitialNormal(tangents[0], initialNormal === undefined
+            ? undefined
+            : guideData(initialNormal, "computeClosedParallelTransportFrames")),
+    ];
     for (let index = 1; index < tangents.length; index += 1) {
         transportedNormals.push(transportNormal(transportedNormals[index - 1], tangents[index - 1], tangents[index]));
     }

package/dist/geometry/paths/helix.js

@@ -1,31 +1,40 @@
+import { GeometryError } from "../errors.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
 /**
  * Creates `segments + 1` points including exact helix endpoints from finite positive dimensions.
+ *
  * Integrated weights must remain finite. The maxPathPoints ceiling defaults to 100000; excessive
  * exact counts reject before evaluating axial weights or allocating sample arrays.
+ * Invalid inputs use GeometryError; exceptions thrown by axialWeight propagate unchanged.
  */
 export const sampleHelix = ({ turns, radius, height, segments, limits, axialWeight = () => 1, }) => {
     if (![turns, radius, height].every(Number.isFinite) || !(turns > 0 && radius > 0 && height > 0)) {
-        throw new Error("Helix turns, radius, and height must be finite and positive.");
+        throw new GeometryError([turns, radius, height].every(Number.isFinite) ? "INVALID_ARGUMENT" : "NON_FINITE_VALUE", "Helix turns, radius, and height must be finite and positive.", { operation: "sampleHelix" });
     }
     if (!Number.isInteger(segments) || segments < 3) {
-        throw new Error("A helix needs at least three segments.");
+        throw new GeometryError("INVALID_ARGUMENT", "A helix needs at least three segments.", {
+            operation: "sampleHelix",
+        });
     }
     assertSamplingCount(segments + 1, "sampleHelix", resolveGeometrySamplingLimits(limits).maxPathPoints);
     const angleRange = Math.PI * 2 * turns;
     if (!Number.isFinite(angleRange)) {
-        throw new Error("Helix angle range must be finite.");
+        throw new GeometryError("NON_FINITE_VALUE", "Helix angle range must be finite.", {
+            operation: "sampleHelix",
+        });
     }
     const weights = Array.from({ length: segments }, (_, index) => {
         const value = axialWeight((index + 0.5) / segments);
         if (!Number.isFinite(value) || value <= 0) {
-            throw new Error("Helix axial weights must be finite and positive.");
+            throw new GeometryError(Number.isFinite(value) ? "INVALID_ARGUMENT" : "NON_FINITE_VALUE", "Helix axial weights must be finite and positive.", { operation: "sampleHelix" });
         }
         return value;
     });
     const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
     if (!Number.isFinite(totalWeight)) {
-        throw new Error("Helix integrated axial weight must be finite.");
+        throw new GeometryError("NON_FINITE_VALUE", "Helix integrated axial weight must be finite.", {
+            operation: "sampleHelix",
+        });
     }
     let accumulatedWeight = 0;
     const result = [];
@@ -41,7 +50,9 @@ export const sampleHelix = ({ turns, radius, height, segments, limits, axialWeig
             height * (accumulatedWeight / totalWeight),
         ];
         if (!point.every(Number.isFinite)) {
-            throw new Error("Helix sampled coordinates must be finite.");
+            throw new GeometryError("NON_FINITE_VALUE", "Helix sampled coordinates must be finite.", {
+                operation: "sampleHelix",
+            });
         }
         result.push(point);
     }