@metamesh/modeling 0.0.0-bootstrap.0 → 0.6.0

package/dist/geometry/extrusion.js

@@ -0,0 +1,150 @@
+import { GeometryError } from "./errors.js";
+import { assertPositivePrimitive, assertPrimitiveOptions } from "./primitive-resolvers.js";
+import { resolveGeometryResolution } from "./resolution.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits } from "./sampling-limits.js";
+const isArray = (value) => Array.isArray(value);
+/** @internal Validates shared extrusion controls and expands top scale before kernel allocation. */
+export function resolveExtrusionControls(height, options, operation) {
+    assertPrimitiveOptions(options, operation);
+    assertPositivePrimitive(height, "height", operation);
+    if (options.center !== undefined && typeof options.center !== "boolean") {
+        throw new GeometryError("INVALID_ARGUMENT", "center must be boolean when supplied.", {
+            operation,
+        });
+    }
+    const twistDegrees = options.twistDegrees ?? 0;
+    if (!Number.isFinite(twistDegrees)) {
+        throw new GeometryError("NON_FINITE_VALUE", "twistDegrees must be finite.", { operation });
+    }
+    const scaleTop = options.scaleTop ?? 1;
+    if (typeof scaleTop !== "number" && (!Array.isArray(scaleTop) || scaleTop.length !== 2)) {
+        throw new GeometryError("INVALID_ARGUMENT", "scaleTop must be a number or an exact XY tuple.", {
+            operation,
+        });
+    }
+    const scales = typeof scaleTop === "number" ? [scaleTop, scaleTop] : scaleTop;
+    if (!Number.isFinite(scales[0]) || !Number.isFinite(scales[1])) {
+        throw new GeometryError("NON_FINITE_VALUE", "scaleTop values must be finite.", { operation });
+    }
+    if (options.divisions !== undefined &&
+        (!Number.isSafeInteger(options.divisions) || options.divisions < 0)) {
+        throw new GeometryError("INVALID_ARGUMENT", "divisions must be a nonnegative safe integer.", {
+            operation,
+        });
+    }
+    if (options.divisions !== undefined)
+        assertSamplingCount(options.divisions + 2, operation, resolveGeometrySamplingLimits(options.limits).maxPathPoints);
+    return { scales, twistDegrees, center: options.center ?? false };
+}
+/**
+ * Resolves intermediate profile copies for linear extrusion from physical curve resolution.
+ *
+ * Accepts one XY loop or a filled XY region, including every hole and disconnected component.
+ * Exact `divisions`, including zero, override physical sampling. Otherwise chord error bounds
+ * the triangulated side surface, including rotation across each profile edge. Optional segment
+ * length bounds station travel including Z. Straight extrusions need no intermediate copies by default.
+ * Exceeding the selected maxPathPoints ceiling raises `COMPLEXITY_LIMIT` instead of reducing fidelity.
+ *
+ * @param profile - Ordered XY millimetre contours with implicit closing edges.
+ * @param height - Positive extrusion height in millimetres.
+ * @param options - Twist, scale, exact divisions, and physical resolution controls.
+ * @returns Number of intermediate copies, excluding the two end profiles.
+ */
+export function resolveExtrusionDivisions(profile, height, options = {}) {
+    if (!isArray(profile) || profile.length === 0)
+        throw new GeometryError("INVALID_ARGUMENT", "Extrusion sampling needs an XY loop or region.", {
+            operation: "resolveExtrusionDivisions",
+        });
+    const contours = [];
+    if (Array.isArray(profile[0]))
+        contours.push(profile);
+    else {
+        let count = 0;
+        const maximum = resolveGeometrySamplingLimits(options.limits).maxProfilePoints;
+        for (const component of profile) {
+            if (typeof component !== "object" ||
+                component === null ||
+                !isArray(component.outer) ||
+                !isArray(component.holes))
+                throw new GeometryError("INVALID_ARGUMENT", "Extrusion regions need outer and hole contours.", {
+                    operation: "resolveExtrusionDivisions",
+                });
+            assertSamplingCount(count + 3 * (component.holes.length + 1), "resolveExtrusionDivisions", maximum);
+            for (const contour of [component.outer, ...component.holes]) {
+                if (!isArray(contour) || contour.length < 3)
+                    throw new GeometryError("INVALID_ARGUMENT", "Extrusion contours need at least three XY points.", {
+                        operation: "resolveExtrusionDivisions",
+                    });
+                count += contour.length;
+                assertSamplingCount(count, "resolveExtrusionDivisions", maximum);
+                contours.push(contour);
+            }
+        }
+    }
+    return resolveExtrusionContourDivisions(contours, height, options);
+}
+/** @internal Shared sampling preflight over explicit contours, without rebuilding filled topology. */
+export function resolveExtrusionContourDivisions(contours, height, options) {
+    const operation = "resolveExtrusionDivisions";
+    const { scales, twistDegrees } = resolveExtrusionControls(height, options, operation);
+    const limits = resolveGeometrySamplingLimits(options.limits);
+    let radius = 0, maximumEdgeLength = 0, profileCount = 0;
+    for (const contour of contours) {
+        if (!isArray(contour) || contour.length < 3)
+            throw new GeometryError("INVALID_ARGUMENT", "Extrusion contours need at least three XY points.", {
+                operation,
+            });
+        profileCount += contour.length;
+        assertSamplingCount(profileCount, operation, limits.maxProfilePoints);
+        for (let index = 0; index < contour.length; index++) {
+            const point = contour[index];
+            if (!isArray(point) ||
+                point.length !== 2 ||
+                !Number.isFinite(point[0]) ||
+                !Number.isFinite(point[1]))
+                throw new GeometryError("NON_FINITE_VALUE", "Extrusion profiles require finite XY points.", {
+                    operation,
+                });
+            radius = Math.max(radius, Math.hypot(...point));
+        }
+        for (let index = 0; index < contour.length; index++) {
+            const point = contour[index], next = contour[(index + 1) % contour.length];
+            maximumEdgeLength = Math.max(maximumEdgeLength, Math.hypot(next[0] - point[0], next[1] - point[1]));
+        }
+    }
+    if (options.divisions !== undefined)
+        return options.divisions;
+    const policy = resolveGeometryResolution(options.resolution, options.limits);
+    const angle = (Math.abs(twistDegrees) * Math.PI) / 180;
+    const maximumScale = Math.max(1, Math.abs(scales[0]), Math.abs(scales[1]));
+    const scaleChange = Math.max(Math.abs(scales[0] - 1), Math.abs(scales[1] - 1));
+    // A linear scale multiplied by a rotation has second derivative bounded by this magnitude.
+    // The interpolation error is at most M / (8*n*n), including nonuniform top scaling.
+    const curvature = radius * (maximumScale * angle * angle + 2 * scaleChange * angle);
+    const a = curvature / 8, 
+    // Uniform untwisted taper is planar. Anisotropic taper can introduce a
+    // mixed edge/station derivative even when the vertex trajectories are straight.
+    b = (maximumEdgeLength * (maximumScale * angle + Math.abs(scales[0] - scales[1]))) / 4;
+    const chordSegments = policy.circularSegments === undefined
+        ? Math.max(1, Math.ceil((b + Math.hypot(b, 2 * Math.sqrt(a * policy.maxChordError))) /
+            (2 * policy.maxChordError)), Math.ceil((policy.minimumSegments * Math.abs(twistDegrees)) / 360))
+        : Math.max(1, Math.ceil((policy.circularSegments * Math.abs(twistDegrees)) / 360));
+    const angularCap = Math.max(1, scales[0] === scales[1] ? 0 : policy.maximumSegments, Math.ceil((policy.maximumSegments * Math.abs(twistDegrees)) / 360));
+    if (chordSegments > angularCap) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "Extrusion surface refinement exceeds the full-circle interval safety limit.", {
+            operation,
+            details: { requiredSegments: chordSegments, maximumSegments: angularCap },
+        });
+    }
+    const angularTravel = radius * maximumScale * angle;
+    const scaleTravel = radius * scaleChange;
+    // Uniform scaling keeps radial and rotational velocities perpendicular. Anisotropic scaling
+    // can align them, so its XY travel needs the triangle inequality rather than a hypot bound.
+    const travel = scales[0] === scales[1]
+        ? Math.hypot(height, angularTravel, scaleTravel)
+        : Math.hypot(height, angularTravel + scaleTravel);
+    const lengthSegments = policy.maxSegmentLength === undefined ? 1 : Math.ceil(travel / policy.maxSegmentLength);
+    const segments = Math.max(1, chordSegments, lengthSegments);
+    assertSamplingCount(segments + 1, operation, resolveGeometrySamplingLimits(options.limits).maxPathPoints);
+    return segments - 1;
+}

package/dist/geometry/heightfield.js

@@ -0,0 +1,107 @@
+import { GeometryError } from "./errors.js";
+import { validateTriangleMesh } from "./mesh.js";
+import { defaultModelingLimits } from "./model-limits.js";
+import { writeMeshVertex } from "./numeric.js";
+const isArray = (value) => Array.isArray(value);
+/** Checks regular-grid dimensions and bounds allocation before evaluating any height samples. */
+export function preflightHeightfield(options, limits = {}) {
+    const operation = "preflightHeightfield";
+    if (typeof options !== "object" ||
+        options === null ||
+        !isArray(options.size) ||
+        options.size.length !== 2 ||
+        !options.size.every((value) => Number.isFinite(value) && value > 0) ||
+        !isArray(options.segments) ||
+        options.segments.length !== 2 ||
+        !options.segments.every((value) => Number.isSafeInteger(value) && value > 0) ||
+        typeof options.height !== "function" ||
+        !Number.isFinite(options.baseZ ?? 0) ||
+        (options.origin !== undefined &&
+            (!isArray(options.origin) ||
+                options.origin.length !== 2 ||
+                !options.origin.every(Number.isFinite)))) {
+        throw new GeometryError("INVALID_ARGUMENT", "Heightfields need a finite positive footprint, integer intervals, finite base, and a height callback.", { operation });
+    }
+    const [x, y] = options.segments;
+    const sampleCount = (x + 1) * (y + 1);
+    const perimeter = 2 * (x + y);
+    const vertexCount = sampleCount + perimeter + 1;
+    const triangleCount = 2 * x * y + 3 * perimeter;
+    const byteCount = 12 * (vertexCount + triangleCount);
+    const policy = { ...defaultModelingLimits, ...limits };
+    if (![policy.maxVertices, policy.maxTriangles, policy.maxBytes].every((value) => Number.isSafeInteger(value) && value > 0))
+        throw new GeometryError("INVALID_ARGUMENT", "Heightfield ceilings must be positive safe integers.", { operation });
+    if (!Number.isSafeInteger(byteCount) ||
+        vertexCount > 0xffff_ffff ||
+        triangleCount * 3 > 0xffff_ffff ||
+        vertexCount > policy.maxVertices ||
+        triangleCount > policy.maxTriangles ||
+        byteCount > policy.maxBytes) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "Heightfield grid exceeds the configured output limits or numeric index ceiling.", { operation });
+    }
+    return Object.freeze({ sampleCount, vertexCount, triangleCount, byteCount });
+}
+/**
+ * Builds a closed indexed solid from a regularly sampled top, matched boundary walls, and flat base.
+ * Heights are evaluated once per grid point after allocation preflight. Physical XY sizes and all
+ * output coordinates must fit Float32 storage. Shared wall vertices prevent cracks at the base.
+ */
+export function heightfieldMesh(options, limits = {}) {
+    const facts = preflightHeightfield(options, limits);
+    const operation = "heightfieldMesh";
+    const [nx, ny] = options.segments;
+    const [width, depth] = options.size;
+    const [originX, originY] = options.origin ?? [-width / 2, -depth / 2];
+    const baseZ = Math.fround(options.baseZ ?? 0);
+    if (!Number.isFinite(baseZ))
+        throw new GeometryError("NON_FINITE_VALUE", "Heightfield base must fit Float32 storage.", {
+            operation,
+        });
+    const positions = new Float32Array(facts.vertexCount * 3);
+    const indices = new Uint32Array(facts.triangleCount * 3);
+    const grid = (x, y) => y * (nx + 1) + x;
+    for (let y = 0; y <= ny; y += 1) {
+        for (let x = 0; x <= nx; x += 1) {
+            const point = [originX + (width * x) / nx, originY + (depth * y) / ny];
+            const height = Math.fround(options.height(point));
+            if (!Number.isFinite(height) || !(height > baseZ)) {
+                throw new GeometryError("INVALID_ARGUMENT", "Every finite Float32 height must be strictly above the Float32 base.", { operation, details: { x, y } });
+            }
+            writeMeshVertex(positions, grid(x, y) * 3, [point[0], point[1], height], operation);
+        }
+    }
+    let cursor = 0;
+    const triangle = (a, b, c) => {
+        indices[cursor++] = a;
+        indices[cursor++] = b;
+        indices[cursor++] = c;
+    };
+    for (let y = 0; y < ny; y += 1) {
+        for (let x = 0; x < nx; x += 1) {
+            const a = grid(x, y), b = grid(x + 1, y), c = grid(x + 1, y + 1), d = grid(x, y + 1);
+            triangle(a, b, c);
+            triangle(a, c, d);
+        }
+    }
+    const boundary = [];
+    for (let x = 0; x < nx; x += 1)
+        boundary.push(grid(x, 0));
+    for (let y = 0; y < ny; y += 1)
+        boundary.push(grid(nx, y));
+    for (let x = nx; x > 0; x -= 1)
+        boundary.push(grid(x, ny));
+    for (let y = ny; y > 0; y -= 1)
+        boundary.push(grid(0, y));
+    const baseStart = facts.sampleCount;
+    const baseCenter = facts.vertexCount - 1;
+    writeMeshVertex(positions, baseCenter * 3, [originX + width / 2, originY + depth / 2, baseZ], operation);
+    for (let offset = 0; offset < boundary.length; offset += 1) {
+        const top = boundary[offset];
+        writeMeshVertex(positions, (baseStart + offset) * 3, [positions[top * 3], positions[top * 3 + 1], baseZ], operation);
+        const next = (offset + 1) % boundary.length;
+        triangle(top, baseStart + offset, baseStart + next);
+        triangle(top, baseStart + next, boundary[next]);
+        triangle(baseCenter, baseStart + next, baseStart + offset);
+    }
+    return validateTriangleMesh({ positions, indices }, { requireClosed: true });
+}

package/dist/geometry/index.js

@@ -0,0 +1,42 @@
+/** Pure geometry foundations without host initialization. @packageDocumentation */
+export { matchProfiles, } from "./profiles/matched.js";
+export { heightfieldMesh, preflightHeightfield, } from "./heightfield.js";
+export { preflightThreadedRodSolid as preflightThreadedRod, preflightInternalThreadCutterSolid as preflightInternalThreadCutter, preflightThreadedNutSolid as preflightThreadedNut, } from "./mechanical/thread-solids.js";
+export { anchorFrame3, attachTransform, boxAnchor3, createAnchor3, cylinderAnchor3, } from "./anchors.js";
+export { defaultGeometrySamplingLimits, resolveGeometrySamplingLimits, } from "./sampling-limits.js";
+export { GeometryError, isGeometryError, } from "./errors.js";
+export { resolveExtrusionDivisions, } from "./extrusion.js";
+export { extrudeMesh, loftMesh, triangulateLoop2, } from "./loft.js";
+export { add3, cross3, dot3, length3, lerp3, normalize3, projectOntoPlane3, rotateAroundAxis3, 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, getMetricClearanceHole, getMetricFastenerStandard, } from "./mechanical/standards.js";
+export { buildHelicalThreadRidgeMesh, buildHelicalThreadSolidMesh, } from "./mechanical/thread-mesh.js";
+export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, createThreadProfile, } from "./mechanical/thread-profiles.js";
+export { preflightHelicalThreadSolidMesh, } from "./mechanical/thread-mesh-plan.js";
+export { sampleConventionalThreadHelices as sampleThreadHelices, } from "./mechanical/thread-helices.js";
+export { PRINTABLE_THREAD_FIT_POLICIES, compensateThreadDiameters, resolvePrintableThreadFitPolicy, resolveThreadCircularSegments, } from "./mechanical/threads.js";
+export { analyzeTriangleMesh, joinTriangleMeshes, measureTriangleMesh, meshBounds, reverseTriangleMesh, transformTriangleMesh, validateTriangleMesh, } from "./mesh.js";
+export { createTriangleMeshSignature, } from "./mesh-signature.js";
+export { optimizePlanarPatches, } from "./mesh-planar.js";
+export { analyzeTriangleMeshQuality, } from "./mesh-quality.js";
+export { computeClosedParallelTransportFrames, computeParallelTransportFrames, } from "./paths/frames.js";
+export { sampleHelix } from "./paths/helix.js";
+export { cumulativePathLengths, pathLength } from "./paths/path.js";
+export { distributeAlongPath, roundClosedPolylinePath, } from "./paths/planar.js";
+export { circleLoop, rectangleLoop, regularPolygonLoop, starLoop, } from "./profiles/profiles.js";
+export { sampleOpenProfile, } from "./profiles/open-profile.js";
+export { ellipseLoop } from "./profiles/shapes.js";
+export { rectangleProfile, } from "./profiles/rectangle.js";
+export { loopContainsPoint, normalizeLoop2, normalizePolygon2, normalizeRegion2, regionArea, regionBounds, signedAreaLoop2, } from "./regions.js";
+export { resolveAlignedCircularSegments, resolveArcSegments, resolveCircularSegments, } from "./resolution.js";
+export { revolveMesh } from "./revolve/revolve-mesh.js";
+export { preflightSvgRegion, } from "./svg-import.js";
+export { strokePathRegion, } from "./stroke-path.js";
+export { sweepMesh } from "./sweeps/sweep-mesh.js";
+export { DEFAULT_GEOMETRY_TOLERANCE, resolveGeometryTolerance, } from "./tolerance.js";
+export { transformLoop2, transformPath2, transformPath3, transformRegion2, } from "./transform-geometry.js";
+export { IDENTITY_TRANSFORM3, applyTransformDirection3, applyTransformPoint3, composeTransform3, eulerTransform3, frameTransform3, inverseTransform3, rotationTransform3, scaleTransform3, transformDeterminant3, translationTransform3, validateTransform3, } from "./transform3.js";
+export { sampleTextContours } from "./text-contours.js";
+export { sampleCurve2, sampleCurve3 } from "./curves/sampling.js";
+export { resamplePolyline2, resamplePolyline3, } from "./paths/resampling.js";

package/dist/geometry/loft-correspondence.js

@@ -0,0 +1,204 @@
+import { GeometryError } from "./errors.js";
+import { assertMeshAllocationWithinLimits } from "./model-limits.js";
+import { assertSamplingCount } from "./sampling-limits.js";
+const maximumComparisons = 8_000_000;
+const fail = (message) => {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "loft" });
+};
+const consume = (budget, count) => {
+    budget.comparisons += count;
+    assertSamplingCount(budget.comparisons, "loft", maximumComparisons, "Loft correspondence exceeds its eight-million-comparison work limit.");
+};
+/** @internal Checks a propagated column grid before allocating any expanded rows. */
+export function assertLoftGrid(count, rows, otherContours, limits) {
+    const perRow = count + otherContours;
+    assertSamplingCount(perRow, "loft", limits.maxProfilePoints);
+    assertSamplingCount(perRow * rows, "loft", 1_000_000, "Loft profile grids exceed the one-million-logical-slot work limit.");
+    const vertices = perRow * rows;
+    assertMeshAllocationWithinLimits(vertices, 0, 12 * vertices, "loft", limits);
+}
+/** @internal Retains every input vertex while distributing extra intervals deterministically. */
+export function loftSubdivisions(row, target, distribution, maxLength) {
+    if (!Number.isSafeInteger(target) || target < row.points.length)
+        fail("Loft refinement cannot remove original vertices.");
+    const lengths = row.world.map((point, index) => {
+        const next = row.world[(index + 1) % row.world.length];
+        return Math.hypot(next[0] - point[0], next[1] - point[1], next[2] - point[2]);
+    });
+    const perimeter = lengths.reduce((sum, length) => sum + length, 0);
+    if (!Number.isFinite(perimeter) || perimeter <= 0)
+        fail("Loft contours need a finite positive perimeter.");
+    const extra = target - row.points.length;
+    const shares = lengths.map((length) => extra * (distribution === "segments" ? 1 / lengths.length : length / perimeter));
+    const counts = shares.map((share) => 1 + Math.floor(share));
+    const order = shares
+        .map((share, index) => ({ index, fraction: share - Math.floor(share) }))
+        .sort((a, b) => b.fraction - a.fraction || a.index - b.index);
+    const remaining = target - counts.reduce((sum, count) => sum + count, 0);
+    for (let index = 0; index < remaining; index++)
+        counts[order[index].index]++;
+    if (maxLength !== undefined)
+        lengths.forEach((length, index) => {
+            counts[index] = Math.max(counts[index], Math.ceil(length / maxLength));
+        });
+    return counts;
+}
+const interpolate2 = (a, b, t) => [
+    a[0] * (1 - t) + b[0] * t,
+    a[1] * (1 - t) + b[1] * t,
+];
+const interpolate3 = (a, b, t) => [
+    a[0] * (1 - t) + b[0] * t,
+    a[1] * (1 - t) + b[1] * t,
+    a[2] * (1 - t) + b[2] * t,
+];
+/** @internal Applies the same column insertions to local and world data. */
+export function subdivideLoftRow(row, counts) {
+    const points = [], world = [];
+    counts.forEach((count, index) => {
+        const next = (index + 1) % counts.length;
+        for (let step = 0; step < count; step++) {
+            points.push(step === 0
+                ? row.points[index]
+                : interpolate2(row.points[index], row.points[next], step / count));
+            world.push(step === 0
+                ? row.world[index]
+                : interpolate3(row.world[index], row.world[next], step / count));
+        }
+    });
+    return { points, world };
+}
+const distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+const rotate = (values, offset) => values.slice(offset).concat(values.slice(0, offset));
+const phaseRow = (row, offset) => ({
+    points: rotate(row.points, offset),
+    world: rotate(row.world, offset),
+});
+const indexedRow = (row, indices) => ({
+    points: indices.map((index) => row.points[index]),
+    world: indices.map((index) => row.world[index]),
+});
+/** @internal Selects a cyclic shift by total placed edge distance; ties keep the lowest offset. */
+export function reindexLoftRow(a, b, budget) {
+    consume(budget, a.points.length * b.points.length);
+    let best = Infinity, offset = 0;
+    for (let phase = 0; phase < b.points.length; phase++) {
+        let cost = 0;
+        for (let index = 0; index < a.points.length; index++)
+            cost += distance(a.world[index], b.world[(index + phase) % b.points.length]);
+        if (cost < best) {
+            best = cost;
+            offset = phase;
+        }
+    }
+    return phaseRow(b, offset);
+}
+// 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) {
+    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]);
+                continue;
+            }
+            const index = i * stride + j;
+            const diagonal = i > 0 && j > 0 ? costs[previous + j - 1] : Infinity;
+            const up = i > 0 ? costs[previous + j] : Infinity;
+            const left = j > 0 ? costs[current + j - 1] : Infinity;
+            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]));
+        }
+    }
+    return costs[(n % 2) * stride + m];
+}
+function traceDistanceMap(moves, n, m) {
+    const stride = m + 1;
+    const previous = [], next = [];
+    let i = n, j = m;
+    while (i !== 0 || j !== 0) {
+        const move = moves[i * stride + j];
+        if (move !== 2)
+            i--;
+        if (move !== 1)
+            j--;
+        previous.push(i % n);
+        next.push(j % m);
+    }
+    return { previous: previous.reverse(), next: next.reverse() };
+}
+/** @internal Seam-anchored or cyclic-phase distance association, always bounded before DP allocation. */
+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;
+    // 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;
+    for (let phase = 1; phase < phases; phase++) {
+        const candidateCost = distanceCost(a, b, phase, costs, moves);
+        if (candidateCost < cost) {
+            cost = candidateCost;
+            best = traceDistanceMap(moves, n, m);
+            selectedPhase = phase;
+        }
+    }
+    return { ...best, cost, row: selectedPhase === 0 ? b : phaseRow(b, selectedPhase) };
+}
+/** @internal Aligns one indexed contour across all stations, propagating every insertion to earlier rows. */
+export function alignLoftRows(input, methods, distribution, refine, finalRows, otherContours, limits, budget, maxLengths) {
+    const refined = input.map((row, index) => {
+        const counts = loftSubdivisions(row, row.points.length * refine[index], distribution, maxLengths?.[index]);
+        const count = counts.reduce((sum, count) => sum + count, 0);
+        assertLoftGrid(count, finalRows, otherContours, limits);
+        return subdivideLoftRow(row, counts);
+    });
+    let 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),
+            ];
+        }
+        else {
+            const target = Math.max(previous.points.length, next.points.length);
+            const previousCounts = loftSubdivisions(previous, target, distribution);
+            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,
+            ];
+        }
+    }
+    return rows;
+}
+/** @internal Inserts profiles on straight world-space trajectories, without interpolating frames. */
+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);
+            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)),
+            });
+        }
+        result.push(b);
+    }
+    return result;
+}