@metamesh/modeling 0.18.0 → 0.20.0

package/dist/geometry/index.js

@@ -1,31 +1,25 @@
-/** Pure geometry foundations without host initialization. @packageDocumentation */
-export { bounds2, bounds3, } from "./bounds-value.js";
-export { boundsSize, boundsCenter, fitBounds, layoutRow, } from "./bounds.js";
-export { resolveCircularSampling, } from "./circular-sampling.js";
-export { fitTextLayout } from "./text-fitting.js";
-export { gridPatternTransforms, linearPatternTransforms, radialPatternTransforms, pathPatternTransforms, } from "./patterns.js";
-export { matchProfiles, } from "./profiles/match-profiles.js";
-export { preflightThreadedRodSolid as preflightThreadedRod, preflightInternalThreadCutterSolid as preflightInternalThreadCutter, preflightThreadedNutSolid as preflightThreadedNut, } from "./mechanical/threads/solids.js";
-export { anchorFrame3, attachmentTransform3, boxAnchor3, anchor3, cylinderAnchor3, } from "./anchors.js";
-export { defaultGeometrySamplingLimits, resolveGeometrySamplingLimits, } from "./sampling-limits.js";
+/** Pure geometry values, descriptors, and algorithms without host initialization. @packageDocumentation */
+export { bounds2, bounds3, } from "./bounds/value.js";
+export { boundsSize, boundsCenter, fitBounds, layoutRow, } from "./bounds/operations.js";
+export { resolveCircularSampling, } from "./sampling/circular.js";
+export { fitTextLayout } from "./text/fitting.js";
+export { gridPatternTransforms, linearPatternTransforms, radialPatternTransforms, pathPatternTransforms, } from "./patterns/transforms.js";
+export { matchProfiles, } from "./profiles/matching.js";
+export { anchorFrame3, attachmentTransform3, boxAnchor3, anchor3, cylinderAnchor3, } from "./transforms/anchors.js";
+export { defaultGeometrySamplingLimits, resolveGeometrySamplingLimits, } from "./sampling/limits.js";
 export { GeometryError, isGeometryError, } from "./errors.js";
-export { resolveExtrusionDivisions, } from "./extrusion.js";
-export { triangulateContour, } from "./loft/loft.js";
-export { transform2, transform3, } from "./transform-value.js";
+export { resolveExtrusionSlices } from "./extrusion/controls.js";
+export {} from "./loft/options.js";
+export { triangulateContour } from "./regions/triangulation.js";
+export { frame3 } from "./transforms/frame.js";
+export { transform2, transform3, } from "./transforms/value.js";
 export { vector2, vector3, } from "./math/vector-value.js";
-export { add2, subtract2, scale2, dot2, cross2, length2, distance2, normalize2, lerp2, rotate2, } from "./math/vector2.js";
-export { add3, cross3, dot3, length3, distance3, lerp3, normalize3, projectOntoPlane3, scale3, subtract3, } from "./math/vector3.js";
-export { minimumCylindricalGearToothCountWithoutUndercut, resolveCylindricalGear, resolveCylindricalGearPair, resolveRackPitch, sampleCylindricalGearOutline, sampleInternalCylindricalGearSpaceOutline, sampleRackToothPath, } from "./mechanical/gears.js";
-export { measureInternalCylindricalGearPairMotion, } from "./mechanical/gear-motion.js";
-export { METRIC_FASTENER_STANDARDS, getMetricClearanceHoleDiameter, getMetricFastenerStandard, } from "./mechanical/standards.js";
-export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, threadProfile, } from "./mechanical/threads/profiles.js";
-export {} from "./mechanical/threads/mesh-plan.js";
-export { sampleConventionalThreadHelices as sampleThreadHelices, } from "./mechanical/threads/helices.js";
-export { PRINTABLE_THREAD_FIT_POLICIES, compensateThreadDiameters, resolvePrintableThreadFitPolicy, resolveThreadCircularSegments, } from "./mechanical/threads/fit.js";
 export { computeClosedParallelTransportFrames, computeParallelTransportFrames, } from "./paths/frames.js";
 export { sampleHelix } from "./paths/helix.js";
-export { path2, path3, } from "./paths/path-value.js";
-export { distributeAlongPath, roundClosedPolylinePath, } from "./paths/planar.js";
+export { path2, path3, } from "./paths/value.js";
+export { spline2, spline3 } from "./paths/spline.js";
+export { distributeAlongPath } from "./paths/distribution.js";
+export { roundClosedPolylinePath } from "./paths/rounding.js";
 export { circleContour } from "./profiles/primitives/circle.js";
 export { rectangleContour } from "./profiles/primitives/rectangle.js";
 export { regularPolygonContour, } from "./profiles/primitives/regular-polygon.js";
@@ -34,15 +28,13 @@ export { closeToAxis, sampleSideProfile, } from "./profiles/side-profile.js";
 export { sampleContour, } from "./profiles/contour.js";
 export { ellipseContour } from "./profiles/primitives/ellipse.js";
 export { rectangleProfile, } from "./profiles/primitives/rectangle.js";
-export { contourContainsPoint, normalizeContour, normalizePolygon, normalizeRegion, regionArea, regionBounds, signedContourArea, } from "./regions.js";
-export { resolveAlignedCircularSegments, resolveArcSegments, resolveCircularSegments, } from "./resolution.js";
+export { contourContainsPoint, normalizeContour, normalizePolygon, normalizeRegion, regionArea, regionBounds, signedContourArea, } from "./regions/operations.js";
+export { resolveAlignedCircularSegments, resolveArcSegments, resolveCircularSegments, } from "./sampling/resolution.js";
 export { preflightSvgRegion, } from "./svg/import.js";
-export { strokeRegionData, } from "./stroke-path.js";
+export { strokeRegionData, } from "./regions/stroke.js";
 export { DEFAULT_GEOMETRY_TOLERANCE, resolveGeometryTolerance, } from "./tolerance.js";
-export { transformRegionData } from "./transform-geometry.js";
-export { IDENTITY_TRANSFORM3, applyTransformDirection3, applyTransformPoint3, composeTransform3, eulerTransform3, frameTransform3, inverseTransform3, rotationTransform3, scaleTransform3, transformDeterminant3, translationTransform3, validateTransform3, validateRigidTransform3, } from "./transform3.js";
-export { sampleTextContours } from "./text-contours.js";
+export { transformRegionData } from "./transforms/apply.js";
+export { sampleTextContours } from "./text/contours.js";
 export { sampleCurve2, sampleCurve3 } from "./curves/sampling.js";
 export { resamplePolyline2, resamplePolyline3, } from "./paths/resampling.js";
-export { resolveKnuckleHinge, } from "./mechanical/knuckle-hinge.js";
-export { immutableBuffer, } from "./immutable-buffer.js";
+export { immutableBuffer } from "./immutable-buffer.js";

package/dist/geometry/{model-limits.js → limits.js}

@@ -1,5 +1,5 @@
 import { GeometryError } from "./errors.js";
-import { defaultGeometrySamplingLimits } from "./sampling-limits.js";
+import { defaultGeometrySamplingLimits } from "./sampling/limits.js";
 /** Default engine ceilings, shared with predictable pure mesh constructor preflights. */
 export const defaultModelingLimits = Object.freeze({
     ...defaultGeometrySamplingLimits,

package/dist/geometry/loft/{loft-correspondence.js → correspondence.js}

@@ -1,7 +1,8 @@
 import { GeometryError } from "../errors.js";
-import { assertMeshAllocationWithinLimits } from "../model-limits.js";
-import { assertSamplingCount } from "../sampling-limits.js";
+import { assertMeshAllocationWithinLimits } from "../limits.js";
+import { assertSamplingCount } from "../sampling/limits.js";
 const maximumComparisons = 8_000_000;
+const maximumCachedDistances = (8 * 1024 * 1024) / Float64Array.BYTES_PER_ELEMENT;
 const fail = (message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "loft" });
 };
@@ -95,14 +96,14 @@ export function reindexLoftRow(a, b, budget) {
 }
 // Ordered cyclic dynamic programming, including the wrap node once. Each move advances
 // one or both contours; a stationary side repeats its vertex to create a triangular fan.
-function distanceCost(a, b, phase, costs, moves) {
+function distanceCost(a, b, phase, costs, moves, distances) {
     const n = a.points.length, m = b.points.length, stride = m + 1;
     for (let i = 0; i <= n; i++) {
         const current = (i % 2) * stride, previous = ((i + 1) % 2) * stride;
         costs.fill(Infinity, current, current + stride);
         for (let j = 0; j <= m; j++) {
             if (i === 0 && j === 0) {
-                costs[current] = distance(a.world[0], b.world[phase]);
+                costs[current] = distances?.[phase] ?? distance(a.world[0], b.world[phase]);
                 continue;
             }
             const index = i * stride + j;
@@ -112,7 +113,12 @@ function distanceCost(a, b, phase, costs, moves) {
             const best = Math.min(diagonal, up, left);
             moves[index] = diagonal === best ? 0 : up === best ? 1 : 2;
             costs[current + j] =
-                best + (i === n && j === m ? 0 : distance(a.world[i % n], b.world[(j + phase) % m]));
+                best +
+                    (i === n && j === m
+                        ? 0
+                        : distances === undefined
+                            ? distance(a.world[i % n], b.world[(j + phase) % m])
+                            : distances[(i % n) * m + ((j + phase) % m)]);
         }
     }
     return costs[(n % 2) * stride + m];
@@ -137,12 +143,19 @@ export function distanceLoftMap(a, b, method, budget) {
     const phases = method === "distance" ? b.points.length : 1;
     consume(budget, (a.points.length + 1) * (b.points.length + 1) * phases);
     const n = a.points.length, m = b.points.length;
+    // Cyclic phases revisit the same point pairs. Keep the extra Float64 storage within
+    // eight MiB; larger grids and the single-phase route retain direct distance evaluation.
+    const distances = phases > 1 && n * m <= maximumCachedDistances ? new Float64Array(n * m) : undefined;
+    if (distances !== undefined)
+        for (let i = 0; i < n; i++)
+            for (let j = 0; j < m; j++)
+                distances[i * m + j] = distance(a.world[i], b.world[j]);
     // Costs depend only on the preceding row. Reuse both cost rows and the
     // predecessor grid across phases; only an improved phase needs traceback.
     const costs = new Float64Array(2 * (m + 1)), moves = new Uint8Array((n + 1) * (m + 1));
-    let cost = distanceCost(a, b, 0, costs, moves), best = traceDistanceMap(moves, n, m), selectedPhase = 0;
+    let cost = distanceCost(a, b, 0, costs, moves, distances), best = traceDistanceMap(moves, n, m), selectedPhase = 0;
     for (let phase = 1; phase < phases; phase++) {
-        const candidateCost = distanceCost(a, b, phase, costs, moves);
+        const candidateCost = distanceCost(a, b, phase, costs, moves, distances);
         if (candidateCost < cost) {
             cost = candidateCost;
             best = traceDistanceMap(moves, n, m);
@@ -159,16 +172,16 @@ export function alignLoftRows(input, methods, distribution, refine, finalRows, o
         assertLoftGrid(count, finalRows, otherContours, limits);
         return subdivideLoftRow(row, counts);
     });
-    let rows = [refined[0]];
+    const rows = [refined[0]];
     for (let gap = 0; gap < methods.length; gap++) {
         const previous = rows.at(-1), next = refined[gap + 1], method = methods[gap];
         if (method === "distance" || method === "fast-distance") {
             const mapping = distanceLoftMap(previous, next, method, budget);
             assertLoftGrid(mapping.previous.length, finalRows, otherContours, limits);
-            rows = [
-                ...rows.map((row) => indexedRow(row, mapping.previous)),
-                indexedRow(mapping.row, mapping.next),
-            ];
+            if (mapping.previous.some((index, slot) => index !== slot))
+                for (let row = 0; row < rows.length; row++)
+                    rows[row] = indexedRow(rows[row], mapping.previous);
+            rows.push(indexedRow(mapping.row, mapping.next));
         }
         else {
             const target = Math.max(previous.points.length, next.points.length);
@@ -176,12 +189,10 @@ export function alignLoftRows(input, methods, distribution, refine, finalRows, o
             const nextCounts = loftSubdivisions(next, target, distribution);
             assertLoftGrid(target, finalRows, otherContours, limits);
             const expanded = subdivideLoftRow(next, nextCounts);
-            rows = [
-                ...rows.map((row) => subdivideLoftRow(row, previousCounts)),
-                method === "reindex"
-                    ? reindexLoftRow(subdivideLoftRow(previous, previousCounts), expanded, budget)
-                    : expanded,
-            ];
+            if (previousCounts.some((count) => count !== 1))
+                for (let row = 0; row < rows.length; row++)
+                    rows[row] = subdivideLoftRow(rows[row], previousCounts);
+            rows.push(method === "reindex" ? reindexLoftRow(rows.at(-1), expanded, budget) : expanded);
         }
     }
     return rows;
@@ -191,8 +202,8 @@ export function sliceLoftRows(rows, slices) {
     const result = [rows[0]];
     for (let gap = 0; gap < slices.length; gap++) {
         const a = rows[gap], b = rows[gap + 1];
-        for (let slice = 1; slice <= slices[gap]; slice++) {
-            const t = slice / (slices[gap] + 1);
+        for (let slice = 1; slice < slices[gap]; slice++) {
+            const t = slice / slices[gap];
             result.push({
                 points: a.points.map((point, index) => interpolate2(point, b.points[index], t)),
                 world: a.world.map((point, index) => interpolate3(point, b.world[index], t)),

package/dist/geometry/loft/{loft-geometry.js → geometry.js}

@@ -1,10 +1,9 @@
 import { GeometryError } from "../errors.js";
-import { normalizeContour, normalizeRegion, signedContourArea } from "../regions.js";
-import { resolveGeometryResolution } from "../resolution.js";
-import { assertSamplingCount } from "../sampling-limits.js";
-import { frameTransform3 } from "../transform3.js";
-import { alignLoftRows, assertLoftGrid, loftSubdivisions, sliceLoftRows, subdivideLoftRow, } from "./loft-correspondence.js";
-import { loftFrame, resolveLoftControls } from "./loft-options.js";
+import { normalizeContour, normalizeRegion, signedContourArea } from "../regions/operations.js";
+import { assertSamplingCount } from "../sampling/limits.js";
+import { resolveGeometryResolution } from "../sampling/resolution.js";
+import { alignLoftRows, assertLoftGrid, loftSubdivisions, sliceLoftRows, subdivideLoftRow, } from "./correspondence.js";
+import { loftTransform, resolveLoftControls } from "./options.js";
 const fail = (message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "loft" });
 };
@@ -76,10 +75,9 @@ export function prepareLoftGeometry(input, options, limits, authoritative, recip
     assertSamplingCount(input.reduce((sum, station) => sum + loftProfilePointCount(station.profile), 0), "loft", 1_000_000);
     if (authoritative && controls.methods.some((method) => method !== "direct"))
         fail("Identified loft landmarks are authoritative and cannot be remapped by geometric correspondence methods.");
-    const finalRows = input.length + controls.slices.reduce((sum, count) => sum + count, 0);
+    const finalRows = 1 + controls.slices.reduce((sum, count) => sum + count, 0);
     assertSamplingCount(finalRows, "loft", limits.maxPathPoints);
-    const frames = input.map((station) => loftFrame(station));
-    const transforms = frames.map((frame) => frameTransform3(frame));
+    const transforms = input.map((station) => loftTransform(station));
     const first = input[0].profile;
     if (!Array.isArray(first.components) ||
         first.components.length === 0 ||
@@ -153,21 +151,21 @@ export function prepareLoftGeometry(input, options, limits, authoritative, recip
         allSpans.push(spans);
     });
     const templates = first.components;
-    const stationFrames = [frames[0]];
+    const stationTransforms = [transforms[0]];
     for (let gap = 0; gap < controls.slices.length; gap++) {
-        // Intermediate frames are placeholders only. Their vertices use the explicit world grids.
-        for (let index = 0; index < controls.slices[gap]; index++)
-            stationFrames.push(frames[gap]);
-        stationFrames.push(frames[gap + 1]);
+        // Intermediate placements are placeholders; vertices use the explicit world grids.
+        for (let index = 1; index < controls.slices[gap]; index++)
+            stationTransforms.push(transforms[gap]);
+        stationTransforms.push(transforms[gap + 1]);
     }
-    const stations = stationFrames.map((frame, row) => {
+    const stations = stationTransforms.map((transform, row) => {
         let contourIndex = 0;
         const convert = (contour) => {
             const index = contourIndex++;
             return { ...contour, points: allRows[index][row].points, spans: allSpans[index] };
         };
         return {
-            frame,
+            transform,
             profile: {
                 components: templates.map((component) => ({
                     ...component,
@@ -179,6 +177,6 @@ export function prepareLoftGeometry(input, options, limits, authoritative, recip
     });
     return {
         stations,
-        world: stationFrames.map((_, row) => allRows.map((contour) => contour[row].world)),
+        world: stationTransforms.map((_, row) => allRows.map((contour) => contour[row].world)),
     };
 }

package/dist/geometry/loft/mesh.js

@@ -0,0 +1,53 @@
+import { GeometryError } from "../errors.js";
+import { resolveModelingLimits } from "../limits.js";
+import { capturePath2Input, path2InputData } from "../paths/value.js";
+import { assertSamplingCount } from "../sampling/limits.js";
+import { pointLoftProfile, prepareLoftGeometry } from "./geometry.js";
+import { simpleLoftMesh } from "./simple-mesh.js";
+/**
+ * Lofts simple point contours at z heights or explicit affine transforms, in input order.
+ *
+ * Correspondence defaults to direct. CCW-normalized contours retain their
+ * seam and original vertices; unequal counts gain subdivisions or repeated fan slots.
+ * Both ends use ear-clipped caps, supporting concave profiles without center fans.
+ * Intermediate slices interpolate placed world vertices, never frame axes.
+ * Transformed coordinates must fit finite Float32 mesh storage.
+ * Path2 profiles must be closed; raw point collections are interpreted as closed.
+ *
+ * @param stations - At least two XY profiles in connection order, each with Z height or affine placement.
+ *
+ * @example Loft with explicit point correspondence
+ * ```ts
+ * const bottom = rectangleContour({ size: [20, 12] });
+ * const top = rectangleContour({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * mesh.loft([{ profile: bottom, z: 0 }, { profile: top, z: 30 }], { correspondence: "reindex" });
+ * ```
+ */
+export function loftMesh(stations, options = {}) {
+    if (typeof options !== "object" || options === null || Array.isArray(options))
+        throw new GeometryError("INVALID_ARGUMENT", "Loft options must be an object.", {
+            operation: "loftMesh",
+        });
+    const limits = resolveModelingLimits(options.limits);
+    if (!Array.isArray(stations) || stations.length < 2)
+        throw new GeometryError("INVALID_ARGUMENT", "Loft requires at least two stations.", {
+            operation: "loftMesh",
+        });
+    assertSamplingCount(stations.length, "loftMesh", limits.maxPathPoints);
+    const inputs = stations;
+    const input = inputs.map(({ profile, ...placement }) => ({
+        ...placement,
+        source: capturePath2Input(profile, true),
+    }));
+    assertSamplingCount(input.reduce((sum, station) => sum + station.source.count, 0), "loftMesh", 1_000_000);
+    let remaining = 1_000_000;
+    const profiles = input.map(({ source, ...placement }) => {
+        const points = path2InputData(source.input, true, {
+            maxPathPoints: Math.max(1, Math.min(limits.maxProfilePoints, remaining)),
+        }).points;
+        assertSamplingCount(points.length, "loftMesh", remaining);
+        remaining -= points.length;
+        return { ...placement, profile: pointLoftProfile(points) };
+    });
+    return simpleLoftMesh(prepareLoftGeometry(profiles, options, limits, false), limits);
+}

package/dist/geometry/loft/{loft-options.js → options.js}

@@ -1,21 +1,23 @@
 import { GeometryError } from "../errors.js";
-import { frameTransform3 } from "../transform3.js";
-/** @internal Resolves placement without sorting stations or interpolating their axes. */
-export function loftFrame(placement, operation = "loft") {
+import { translationTransform3 } from "../transforms/affine3.js";
+import { transform3 } from "../transforms/value.js";
+/** @internal Resolves placement without sorting stations or interpolating transformations. */
+export function loftTransform(placement, operation = "loft") {
     if (typeof placement !== "object" ||
         placement === null ||
         Array.isArray(placement) ||
-        "z" in placement === "frame" in placement)
-        throw new GeometryError("INVALID_ARGUMENT", "Each loft station must specify exactly one z or frame.", { operation });
+        "frame" in placement ||
+        ("transform" in placement && placement.transform === undefined) ||
+        "z" in placement === "transform" in placement)
+        throw new GeometryError("INVALID_ARGUMENT", "Each loft station must specify exactly one z or transform.", { operation });
     if ("z" in placement) {
         if (!Number.isFinite(placement.z))
             throw new GeometryError("NON_FINITE_VALUE", "Loft station z must be finite millimetres.", {
                 operation,
             });
-        return { origin: [0, 0, placement.z], xAxis: [1, 0, 0], yAxis: [0, 1, 0], zAxis: [0, 0, 1] };
+        return translationTransform3([0, 0, placement.z]);
     }
-    frameTransform3(placement.frame);
-    return placement.frame;
+    return transform3(placement.transform).toData();
 }
 /** @internal Validated controls shared by every loft construction route. */
 export function resolveLoftControls(options, stationCount) {
@@ -42,13 +44,13 @@ export function resolveLoftControls(options, stationCount) {
     if (duplicate && distribution !== "segments")
         fail("Vertex-duplication correspondence requires segments distribution.");
     const refine = expand(options.refine, stationCount, 1, "refine");
-    const slices = expand(options.slices, stationCount - 1, 0, "slices");
+    const slices = expand(options.slices, stationCount - 1, 1, "slices");
     for (const count of refine)
         if (!Number.isSafeInteger(count) || count < 1)
             fail("Loft refine values must be positive safe integers.");
     for (const count of slices)
-        if (!Number.isSafeInteger(count) || count < 0)
-            fail("Loft slices values must be nonnegative safe integers.");
+        if (!Number.isSafeInteger(count) || count < 1)
+            fail("Loft slices values must be positive safe integers.");
     return { methods, distribution, refine, slices };
 }
 const fail = (message) => {

package/dist/geometry/loft/{loft-simple-mesh.js → simple-mesh.js}

@@ -1,12 +1,13 @@
 import { GeometryError } from "../errors.js";
-import { analyzeTriangleMesh, validateTriangleMesh } from "../mesh/mesh.js";
-import { assertMeshAllocationWithinLimits } from "../model-limits.js";
-import { writeMeshVertex } from "../numeric.js";
-import { triangulateContour } from "./loft-triangulation.js";
+import { assertMeshAllocationWithinLimits } from "../limits.js";
+import { analyzeTriangleMesh } from "../mesh/operations.js";
+import { reverseOwnedTriangleWinding } from "../mesh/winding.js";
+import { writeMeshVertex } from "../mesh/write-vertex.js";
+import { triangulateContour } from "../regions/triangulation.js";
 /** @internal Pure closed simple-contour strips, retaining repeated correspondence slots as shared physical vertices. */
-export function simpleLoftMesh(geometry, limits) {
+export function simpleLoftMesh(geometry, limits, closed = false) {
     const count = geometry.world[0][0].length, rowCount = geometry.world.length;
-    const maxVertices = count * rowCount, maximumTriangles = 2 * count * (rowCount - 1) + 2 * (count - 2);
+    const maxVertices = count * rowCount, maximumTriangles = 2 * count * (closed ? rowCount : rowCount - 1) + (closed ? 0 : 2 * (count - 2));
     const bytes = 12 * (maxVertices + maximumTriangles);
     assertMeshAllocationWithinLimits(maxVertices, maximumTriangles, bytes, "loftMesh", limits);
     const positions = new Float32Array(maxVertices * 3), indices = new Uint32Array(maximumTriangles * 3);
@@ -61,9 +62,9 @@ export function simpleLoftMesh(geometry, limits) {
         indices[cursor++] = b;
         indices[cursor++] = c;
     };
-    for (let row = 0; row < rows.length - 1; row++)
+    for (let row = 0; row < (closed ? rows.length : rows.length - 1); row++)
         for (let index = 0; index < count; index++) {
-            const next = (index + 1) % count, a = rows[row], b = rows[row + 1];
+            const next = (index + 1) % count, a = rows[row], b = rows[(row + 1) % rows.length];
             triangle(a.slots[index], a.slots[next], b.slots[next]);
             triangle(a.slots[index], b.slots[next], b.slots[index]);
         }
@@ -72,20 +73,28 @@ export function simpleLoftMesh(geometry, limits) {
         for (let index = 0; index < triangles.length; index += 3)
             triangle(contour.vertices[triangles[index]], contour.vertices[triangles[index + (top ? 1 : 2)]], contour.vertices[triangles[index + (top ? 2 : 1)]]);
     };
-    cap(0, false);
-    cap(rows.length - 1, true);
+    if (!closed) {
+        cap(0, false);
+        cap(rows.length - 1, true);
+    }
     const mesh = {
         positions: positions.slice(0, vertexCount * 3),
         indices: indices.slice(0, cursor),
     };
-    const volume = analyzeTriangleMesh(mesh).signedVolume;
+    let volume;
+    try {
+        volume = analyzeTriangleMesh(mesh, { requireClosed: true }).signedVolume;
+    }
+    catch (error) {
+        // Preserve the zero-volume diagnostic ahead of a closure failure for collapsed lofts.
+        // Only invalid output needs a second traversal; successful meshes are analyzed once.
+        volume = analyzeTriangleMesh(mesh).signedVolume;
+        if (volume !== 0)
+            throw error;
+    }
     if (volume === 0)
         throw new GeometryError("DEGENERATE_GEOMETRY", "Loft stations collapse to zero enclosed volume.", { operation: "loftMesh" });
     if (volume < 0)
-        for (let index = 0; index < mesh.indices.length; index += 3) {
-            const b = mesh.indices[index + 1];
-            mesh.indices[index + 1] = mesh.indices[index + 2];
-            mesh.indices[index + 2] = b;
-        }
-    return validateTriangleMesh(mesh, { requireClosed: true });
+        reverseOwnedTriangleWinding(mesh.indices);
+    return mesh;
 }

package/dist/geometry/math/interpolation.js

@@ -0,0 +1,9 @@
+/** Internal scalar interpolation with exact endpoints and finite convex combinations. */
+export function interpolateCoordinate(a, b, t) {
+    if (t === 0)
+        return a;
+    if (t === 1)
+        return b;
+    // Opposite signs can overflow b - a even when the interpolated coordinate is finite.
+    return a < 0 !== b < 0 ? a * (1 - t) + b * t : a + (b - a) * t;
+}

package/dist/geometry/math/vector-value.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../errors.js";
 import { immutableMathClass } from "./immutable-value.js";
 import { add2, cross2, distance2, dot2, length2, lerp2, normalize2, scale2, subtract2, } from "./vector2.js";
-import { add3, cross3, distance3, dot3, length3, lerp3, normalize3, scale3, subtract3, } from "./vector3.js";
+import { add3, cross3, distance3, dot3, length3, lerp3, normalize3, projectOntoPlane3, scale3, subtract3, } from "./vector3.js";
 const finite = (value, operation) => {
     if (!Number.isFinite(value)) {
         throw new GeometryError("NON_FINITE_VALUE", "Vector coordinates and results must be finite.", {
@@ -130,6 +130,9 @@ const SpatialVector = /* @__PURE__ */ immutableMathClass(class SpatialVector {
     cross(other) {
         return new SpatialVector(cross3(this.values, operand3(other, "vector3.cross")), "vector3.cross");
     }
+    projectOntoPlane(normal) {
+        return new SpatialVector(projectOntoPlane3(this.values, normalize3(operand3(normal, "vector3.projectOntoPlane"), 0)), "vector3.projectOntoPlane");
+    }
     length() {
         return finite(length3(this.values), "vector3.length");
     }
@@ -148,7 +151,9 @@ const SpatialVector = /* @__PURE__ */ immutableMathClass(class SpatialVector {
  * Use transform2().applyDirection(value) for rotations and nonuniform scaling.
  *
  * Use `toData()` for frozen tuple interchange, or
- * [normalize2](/docs/reference/geometry/normalize2) for tuple-based normalization in numerical loops.
+ * [normalize2](/docs/reference/math/normalize2) for tuple-based normalization in numerical loops.
+ *
+ * @param input - Finite XY tuple or vector; coordinates are copied without changing their units.
  */
 export function vector2(input) {
     const values = operand2(input, "vector2");
@@ -162,10 +167,14 @@ export function vector2(input) {
  * Use transform3().applyDirection(value) for rotations and nonuniform scaling.
  *
  * Use `toData()` for frozen tuple interchange, or
- * [normalize3](/docs/reference/geometry/normalize3) for tuple-based normalization in numerical loops.
+ * [normalize3](/docs/reference/math/normalize3) for tuple-based normalization in numerical loops.
+ *
+ * @param input - Finite XYZ tuple or vector; coordinates are copied without changing their units.
  *
  * @example
  * ```ts
+ * import { vector3 } from "@metamesh/modeling/geometry";
+ *
  * const direction = vector3([1, 2, 3]).add([4, 0, 0]).normalize().scale(10);
  * const alignment = direction.dot([0, 0, 1]);
  * ```

package/dist/geometry/math/vector2.js

@@ -1,4 +1,5 @@
 import { GeometryError } from "../errors.js";
+import { interpolateCoordinate } from "./interpolation.js";
 /** Adds two finite XY vectors component-wise. */
 export const add2 = (a, b) => [a[0] + b[0], a[1] + b[1]];
 /** Subtracts `b` from `a` component-wise. */
@@ -13,17 +14,20 @@ export const scale2 = (vector, scale) => [
 ];
 /** Returns the scalar dot product. */
 export const dot2 = (a, b) => a[0] * b[0] + a[1] * b[1];
-/** Returns the signed scalar cross product; positive means `b` is counter-clockwise from `a`. */
+/** Returns the signed scalar cross product; positive means `b` is counterclockwise from `a`. */
 export const cross2 = (a, b) => a[0] * b[1] - a[1] * b[0];
 /** Returns Euclidean vector length in the vector's coordinate units. */
 export const length2 = (vector) => Math.hypot(vector[0], vector[1]);
 /** Returns Euclidean point distance without allocating an intermediate difference vector. */
 export const distance2 = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
 /**
- * Returns a unit vector; `epsilon` is a finite, non-negative length threshold (default `1e-12`).
+ * Returns a unit vector; `epsilon` is a finite, nonnegative length threshold (default `1e-12`).
  *
  * Rejects invalid thresholds, nonfinite lengths, and lengths at or below the threshold with
  * `INVALID_TOLERANCE`, `NON_FINITE_VALUE`, and `DEGENERATE_GEOMETRY` respectively.
+ *
+ * @param vector - Vector with length greater than epsilon.
+ * @param epsilon - Minimum length in coordinate units; finite, nonnegative, default 1e-12.
  */
 export const normalize2 = (vector, epsilon = 1e-12) => {
     const operation = "normalize2";
@@ -53,11 +57,20 @@ export const normalize2 = (vector, epsilon = 1e-12) => {
     }
     return [vector[0] / length, vector[1] / length];
 };
-/** Linearly interpolates two vectors; `t` is dimensionless and may extrapolate. */
-export const lerp2 = (a, b, t) => add2(a, scale2(subtract2(b, a), t));
 /**
- * Rotates a finite vector counter-clockwise in XY by `degrees` about the origin.
+ * Linearly interpolates two vectors; `t` is dimensionless and may extrapolate.
+ *
+ * @param t - Unclamped fraction: 0 selects a, 1 selects b.
+ */
+export const lerp2 = (a, b, t) => [
+    interpolateCoordinate(a[0], b[0], t),
+    interpolateCoordinate(a[1], b[1], t),
+];
+/**
+ * Rotates a finite vector counterclockwise in XY by `degrees` about the origin.
  * Throws `NON_FINITE_VALUE` for nonfinite coordinates, angles, or derived coordinates.
+ *
+ * @param degrees - Counterclockwise angle in degrees.
  */
 export const rotate2 = (vector, degrees) => {
     if (!Number.isFinite(vector[0]) || !Number.isFinite(vector[1]) || !Number.isFinite(degrees)) {

package/dist/geometry/math/vector3.js

@@ -1,8 +1,11 @@
 import { GeometryError } from "../errors.js";
+import { interpolateCoordinate } from "./interpolation.js";
 /**
  * Adds two finite XYZ vectors component-wise.
  * @example
  * ```ts
+ * import { add3 } from "@metamesh/modeling/geometry/math";
+ *
  * add3([1, 2, 3], [4, 5, 6]); // [5, 7, 9]
  * ```
  */
@@ -60,10 +63,13 @@ export const length3 = (vector) => Math.hypot(vector[0], vector[1], vector[2]);
 /** Returns Euclidean point distance without allocating an intermediate difference vector. */
 export const distance3 = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
 /**
- * Returns a unit vector; `epsilon` is a finite, non-negative length threshold (default `1e-12`).
+ * Returns a unit vector; `epsilon` is a finite, nonnegative length threshold (default `1e-12`).
  *
  * Rejects invalid thresholds, nonfinite lengths, and lengths at or below the threshold with
  * `INVALID_TOLERANCE`, `NON_FINITE_VALUE`, and `DEGENERATE_GEOMETRY` respectively.
+ *
+ * @param vector - Vector with length greater than epsilon.
+ * @param epsilon - Minimum length in coordinate units; finite, nonnegative, default 1e-12.
  */
 export const normalize3 = (vector, epsilon = 1e-12) => {
     const operation = "normalize3";
@@ -94,11 +100,28 @@ export const normalize3 = (vector, epsilon = 1e-12) => {
     }
     return [vector[0] / length, vector[1] / length, vector[2] / length];
 };
-/** Linearly interpolates two vectors; `t` is dimensionless and may extrapolate. */
-export const lerp3 = (a, b, t) => add3(a, scale3(subtract3(b, a), t));
-/** Removes the component parallel to a normalized plane normal. */
+/**
+ * Linearly interpolates two vectors; `t` is dimensionless and may extrapolate.
+ *
+ * @param t - Unclamped fraction: 0 selects a, 1 selects b.
+ */
+export const lerp3 = (a, b, t) => [
+    interpolateCoordinate(a[0], b[0], t),
+    interpolateCoordinate(a[1], b[1], t),
+    interpolateCoordinate(a[2], b[2], t),
+];
+/**
+ * Removes the component parallel to a normalized plane normal.
+ *
+ * @param normal - Unit plane normal; used without normalization.
+ */
 export const projectOntoPlane3 = (vector, normal) => subtract3(vector, scale3(normal, dot3(vector, normal)));
-/** Rotates a vector right-handed around a unit axis by `angle` radians. */
+/**
+ * Rotates a vector right-handed around a unit axis by `angle` radians.
+ *
+ * @param axis - Unit rotation axis; used without normalization.
+ * @param angle - Right-handed angle in radians.
+ */
 export const rotateAroundAxis3Radians = (vector, axis, angle) => {
     const cosine = Math.cos(angle);
     const sine = Math.sin(angle);

package/dist/geometry/math-api.js

@@ -0,0 +1,4 @@
+/** Tuple arithmetic and affine matrix kernels without host state. @packageDocumentation */
+export { add2, subtract2, scale2, dot2, cross2, length2, distance2, normalize2, lerp2, rotate2, } from "./math/vector2.js";
+export { add3, cross3, dot3, length3, distance3, lerp3, normalize3, projectOntoPlane3, scale3, subtract3, } from "./math/vector3.js";
+export { IDENTITY_TRANSFORM3, applyTransformDirection3, applyTransformPoint3, multiplyTransform3, eulerTransform3, inverseTransform3, rotationTransform3, scaleTransform3, transformDeterminant3, translationTransform3, validateTransform3, validateRigidTransform3, } from "./transforms/affine3.js";