@metamesh/modeling 0.0.0-stage → 0.6.0

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

@@ -0,0 +1,358 @@
+/** Thread input resolution, end/bevel boundaries, and allocation preflight. */
+import { GeometryError } from "../errors.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../model-limits.js";
+import { resolveCircularSegments, resolveGeometryResolution, } from "../resolution.js";
+import { resolveGeometryTolerance } from "../tolerance.js";
+import { assertFiniteThreadNumber, createThreadRidgeSection, freezeThreadProfilePoints, MAX_THREAD_PROFILE_POINTS, } from "./thread-profiles.js";
+const validateMeshingProfile = (profile, linearTolerance, operation) => {
+    const pitch = assertFiniteThreadNumber(profile.pitch, "profile.pitch", operation);
+    const depth = assertFiniteThreadNumber(profile.depth, "profile.depth", operation);
+    const crestFlatWidth = assertFiniteThreadNumber(profile.crestFlatWidth, "profile.crestFlatWidth", operation);
+    const rootFlatWidth = assertFiniteThreadNumber(profile.rootFlatWidth, "profile.rootFlatWidth", operation);
+    if (!(pitch > linearTolerance && depth > linearTolerance)) {
+        throw new GeometryError("INVALID_ARGUMENT", "Thread profile pitch and depth must be positive.", {
+            operation,
+        });
+    }
+    if (crestFlatWidth < 0 || rootFlatWidth < 0) {
+        throw new GeometryError("INVALID_ARGUMENT", "Thread profile flat widths cannot be negative.", {
+            operation,
+        });
+    }
+    if (profile.points.length < 4 || profile.points.length > MAX_THREAD_PROFILE_POINTS) {
+        throw new GeometryError(profile.points.length > MAX_THREAD_PROFILE_POINTS ? "COMPLEXITY_LIMIT" : "INVALID_TOPOLOGY", `Thread profiles require 4 through ${MAX_THREAD_PROFILE_POINTS} points.`, { operation, details: { pointCount: profile.points.length } });
+    }
+    let maximum = Number.NEGATIVE_INFINITY;
+    let minimum = Number.POSITIVE_INFINITY;
+    for (let index = 0; index < profile.points.length; index += 1) {
+        const point = profile.points[index];
+        assertFiniteThreadNumber(point[0], `profile.points[${index}].x`, operation);
+        assertFiniteThreadNumber(point[1], `profile.points[${index}].y`, operation);
+        if (index > 0 && point[0] + linearTolerance < profile.points[index - 1][0]) {
+            throw new GeometryError("INVALID_TOPOLOGY", "Thread profile axial coordinates must not decrease.", { operation });
+        }
+        maximum = Math.max(maximum, point[1]);
+        minimum = Math.min(minimum, point[1]);
+    }
+    if (Math.abs(profile.points[0][0] + pitch / 2) > linearTolerance ||
+        Math.abs(profile.points.at(-1)[0] - pitch / 2) > linearTolerance ||
+        Math.abs(profile.points[0][1] + depth) > linearTolerance ||
+        Math.abs(profile.points.at(-1)[1] + depth) > linearTolerance ||
+        Math.abs(maximum) > linearTolerance ||
+        Math.abs(minimum + depth) > linearTolerance) {
+        throw new GeometryError("INVALID_TOPOLOGY", "Thread profiles must span one pitch from the minor envelope and reach radial zero.", { operation });
+    }
+    return createThreadRidgeSection(profile.points, minimum, linearTolerance, operation);
+};
+const reindexThreadSectionForMajorEnvelope = (section, pitch, linearTolerance, operation) => {
+    const maximum = Math.max(...section.map((point) => point[1]));
+    const extremeIndices = section
+        .map((point, index) => (Math.abs(point[1] - maximum) <= linearTolerance ? index : -1))
+        .filter((index) => index >= 0);
+    if (extremeIndices.length === 0) {
+        throw new GeometryError("INVALID_TOPOLOGY", "Thread profile has no major-envelope plateau.", {
+            operation,
+        });
+    }
+    const firstExtreme = extremeIndices[0];
+    const lastExtreme = extremeIndices.at(-1);
+    const cutPoint = (section[firstExtreme][0] + section[lastExtreme][0]) / 2;
+    const reindexed = freezeThreadProfilePoints([
+        ...section
+            .filter(([axial]) => axial >= cutPoint)
+            .map(([axial, radial]) => [axial - cutPoint - pitch / 2, radial]),
+        ...section
+            .filter(([axial]) => axial < cutPoint)
+            .map(([axial, radial]) => [axial - cutPoint + pitch / 2, radial]),
+    ]);
+    if (reindexed.length < 2 ||
+        reindexed.some((point, index) => index > 0 && point[0] < reindexed[index - 1][0]) ||
+        Math.abs(reindexed[0][1] - maximum) > linearTolerance ||
+        Math.abs(reindexed.at(-1)[1] - maximum) > linearTolerance) {
+        throw new GeometryError("INVALID_TOPOLOGY", "Thread profile cannot be reindexed around its major envelope.", { operation });
+    }
+    return Object.freeze({ phaseOffset: cutPoint + pitch / 2, section: reindexed });
+};
+/** @internal Resolves shared ridge and solid sampling before construction. */
+export const resolveHelicalThreadMeshOptions = (options, operation, circularSamplingRadius) => {
+    const diameter = assertFiniteThreadNumber(options.majorDiameter, "majorDiameter", operation);
+    const length = assertFiniteThreadNumber(options.length, "length", operation);
+    assertFiniteThreadNumber(options.profile.pitch, "profile.pitch", operation);
+    assertFiniteThreadNumber(options.profile.depth, "profile.depth", operation);
+    const starts = assertFiniteThreadNumber(options.starts ?? 1, "starts", operation);
+    const endLength = assertFiniteThreadNumber(options.ends?.endLength ?? 0, "endLength", operation);
+    if (!Number.isInteger(starts) || starts < 1 || starts > 32 || endLength < 0)
+        throw new GeometryError("INVALID_ARGUMENT", "starts or endLength are invalid.", { operation });
+    const tolerance = resolveGeometryTolerance(Math.max(diameter, length), options.tolerance);
+    const section = validateMeshingProfile(options.profile, tolerance.linear, operation);
+    const bottom = options.ends?.bottom ?? "blunt";
+    const top = options.ends?.top ?? "blunt";
+    if ((bottom !== "blunt" && bottom !== "standard" && bottom !== "tapered") ||
+        (top !== "blunt" && top !== "standard" && top !== "tapered"))
+        throw new GeometryError("INVALID_ARGUMENT", "Unsupported end style.", { operation });
+    const leadInShape = options.ends?.leadInShape ?? "cut";
+    const leadInEnvelope = options.ends?.leadInEnvelope ?? "minor";
+    const leadInLength = assertFiniteThreadNumber(options.ends?.leadInLength ?? options.profile.depth, "leadInLength", operation);
+    if ((leadInShape !== "cut" &&
+        leadInShape !== "linear" &&
+        leadInShape !== "smooth" &&
+        leadInShape !== "sqrt") ||
+        (leadInEnvelope !== "major" && leadInEnvelope !== "minor") ||
+        leadInLength < 0) {
+        throw new GeometryError("INVALID_ARGUMENT", "Thread lead-in options are invalid.", {
+            operation,
+        });
+    }
+    const bottomBoundary = bottom === "standard" ? 0 : endLength;
+    const topBoundary = top === "standard" ? length : length - endLength;
+    const usable = topBoundary - bottomBoundary;
+    if (!(diameter - 2 * options.profile.depth > tolerance.linear)) {
+        throw new GeometryError("INVALID_ARGUMENT", "A positive minor diameter is required.", {
+            operation,
+        });
+    }
+    if (usable + tolerance.linear < 2 * options.profile.pitch) {
+        throw new GeometryError("INVALID_ARGUMENT", "Thread length must leave at least two usable pitches between its end treatments.", {
+            operation,
+            details: {
+                reason: "insufficient-usable-length",
+                required: 2 * options.profile.pitch,
+                usable,
+            },
+        });
+    }
+    const lead = options.profile.pitch * starts;
+    const surfaceRadius = circularSamplingRadius?.(diameter, length) ?? diameter / 2;
+    if (!Number.isFinite(surfaceRadius) || !(surfaceRadius > tolerance.linear)) {
+        throw new GeometryError("INVALID_ARGUMENT", "Thread circular sampling radius must be finite and greater than tolerance.", { operation });
+    }
+    const effectiveRadius = Math.hypot(Math.PI * surfaceRadius * 2, lead) / (Math.PI * 2);
+    const resolution = resolveGeometryResolution(options.resolution, options.limits);
+    const base = resolveCircularSegments(effectiveRadius, options.resolution, options.limits);
+    if (resolution.circularSegments !== undefined && base % starts !== 0) {
+        throw new GeometryError("INVALID_ARGUMENT", "Exact circularSegments must be divisible by the requested thread starts.", { operation, details: { circularSegments: base, starts } });
+    }
+    const segments = Math.ceil(base / starts) * starts;
+    const maximumSegments = resolution.maximumSegments;
+    if (segments > maximumSegments) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "Start-aligned thread tessellation exceeds the configured segment safety limit.", { operation, details: { maximumSegments, segments } });
+    }
+    const handedness = options.handedness ?? "right";
+    if (handedness !== "left" && handedness !== "right")
+        throw new GeometryError("INVALID_ARGUMENT", "Unsupported handedness.", { operation });
+    const usesMajorEnvelopeLeadIn = leadInEnvelope === "major" &&
+        leadInShape !== "cut" &&
+        leadInLength > 0 &&
+        (bottom === "blunt" || top === "blunt");
+    const surface = usesMajorEnvelopeLeadIn
+        ? reindexThreadSectionForMajorEnvelope(section, options.profile.pitch, tolerance.linear, operation)
+        : Object.freeze({
+            phaseOffset: 0,
+            // The active tooth plus its two envelope transitions is the complete nonredundant
+            // periodic surface. Missing space between copies is the flat envelope.
+            section,
+        });
+    const surfaceSection = surface.section;
+    const facetAxialStep = lead / segments;
+    const rawLeadInAxialLength = leadInShape === "cut" || !(leadInLength > 0) ? 0 : (lead * leadInLength) / (Math.PI * diameter);
+    const leadInAxialLength = rawLeadInAxialLength === 0
+        ? 0
+        : Math.ceil(rawLeadInAxialLength / facetAxialStep - 1e-12) * facetAxialStep;
+    // BOSL2 keeps profile centers on one global pitch lattice. End reservations and role-specific
+    // bevel expansion must not phase-shift the complete helix; independently built male/female parts
+    // can reserve different blunt bands. Reindexing changes only representation, so carry its cyclic
+    // shift while leaving that shared global datum intact.
+    const surfacePhaseBase = surface.phaseOffset;
+    const quantizeUp = (value) => surfacePhaseBase +
+        Math.ceil((value - surfacePhaseBase) / facetAxialStep - 1e-12) * facetAxialStep;
+    const quantizeDown = (value) => surfacePhaseBase +
+        Math.floor((value - surfacePhaseBase) / facetAxialStep + 1e-12) * facetAxialStep;
+    const rawBottomLeadTipCenter = bottomBoundary - surfaceSection[0][0];
+    const bottomLeadTipCenter = quantizeUp(rawBottomLeadTipCenter);
+    const bottomLeadFullCenter = bottomLeadTipCenter + leadInAxialLength;
+    const rawTopLeadFullCenter = topBoundary - surfaceSection.at(-1)[0] - leadInAxialLength;
+    const topLeadFullCenter = quantizeDown(rawTopLeadFullCenter);
+    const topLeadTipCenter = topLeadFullCenter + leadInAxialLength;
+    if (leadInAxialLength > 0 &&
+        ((bottom === "blunt" &&
+            top === "blunt" &&
+            bottomLeadFullCenter >= topLeadFullCenter - tolerance.linear) ||
+            (bottom === "blunt" && bottomLeadFullCenter >= topBoundary - tolerance.linear) ||
+            (top === "blunt" && topLeadFullCenter <= bottomBoundary + tolerance.linear))) {
+        throw new GeometryError("INVALID_ARGUMENT", "Thread lead-ins overlap inside the usable length.", {
+            operation,
+            details: { reason: "overlapping-lead-ins" },
+        });
+    }
+    return {
+        bottom,
+        bottomBoundary,
+        bottomLeadFullCenter,
+        bottomLeadTipCenter,
+        diameter,
+        direction: handedness === "right" ? 1 : -1,
+        endLength,
+        handedness,
+        lead,
+        leadInEnvelope,
+        leadInAxialLength,
+        leadInLength,
+        leadInShape,
+        length,
+        phase: (assertFiniteThreadNumber(options.phaseDegrees ?? 0, "phaseDegrees", operation) * Math.PI) /
+            180,
+        section,
+        segments,
+        starts,
+        surfacePhaseBase,
+        surfaceSection,
+        tolerance,
+        top,
+        topBoundary,
+        topLeadFullCenter,
+        topLeadTipCenter,
+        usable,
+    };
+};
+/** @internal Resolves the active radial bevel boundary at one axial station. */
+export const threadSurfaceBevelBoundaryAt = (axial, profile, resolved, options) => {
+    const bottomBevelSize = Math.min(options.bevelBottomSize ?? options.bevelSize ?? profile.depth, resolved.length / 2);
+    const topBevelSize = Math.min(options.bevelTopSize ?? options.bevelSize ?? profile.depth, resolved.length / 2);
+    const bevelOffset = options.bevelOffset ?? 0;
+    const bottomFace = bevelOffset;
+    const topFace = resolved.length - bevelOffset;
+    // Include the zero-depth stations here so callers can solve the exact point where a linear
+    // thread flank first meets the bevel. Applying the boundary at zero depth remains a no-op.
+    const bottomApplies = options.bevelBottom === true &&
+        bottomBevelSize > 0 &&
+        axial <= bottomFace + bottomBevelSize + resolved.tolerance.linear;
+    const topApplies = options.bevelTop === true &&
+        topBevelSize > 0 &&
+        axial >= topFace - topBevelSize - resolved.tolerance.linear;
+    if (!bottomApplies && !topApplies)
+        return undefined;
+    const bottomDepth = bottomApplies
+        ? Math.max(0, Math.min(bottomBevelSize, bottomFace + bottomBevelSize - axial))
+        : Number.NEGATIVE_INFINITY;
+    const topDepth = topApplies
+        ? Math.max(0, Math.min(topBevelSize, axial - (topFace - topBevelSize)))
+        : Number.NEGATIVE_INFINITY;
+    const bottomWins = bottomDepth >= topDepth;
+    const depth = bottomWins ? bottomDepth : topDepth;
+    const endStyle = bottomWins ? resolved.bottom : resolved.top;
+    const majorRadius = resolved.diameter / 2;
+    if ((options.bevelMode ?? "inset") === "outset") {
+        const recoveryRadius = endStyle === "blunt" ? majorRadius : majorRadius - profile.depth;
+        return { depth, endStyle, kind: "lower", radius: recoveryRadius + depth };
+    }
+    const recoveryRadius = endStyle === "blunt" ? majorRadius - profile.depth : majorRadius;
+    return { depth, endStyle, kind: "upper", radius: recoveryRadius - depth };
+};
+/** @internal Clips a radius against its resolved end bevel boundary. */
+export const applyThreadSurfaceBevel = (radial, axial, profile, resolved, options) => {
+    const boundary = threadSurfaceBevelBoundaryAt(axial, profile, resolved, options);
+    if (boundary === undefined || !(boundary.depth > 0))
+        return radial;
+    return boundary.kind === "lower"
+        ? Math.max(radial, boundary.radius)
+        : Math.min(radial, boundary.radius);
+};
+/** @internal Rejects a collapsed thread surface before emitting vertices. */
+export const requirePositiveThreadSurfaceRadius = (radius, resolved, operation) => {
+    if (!(radius > resolved.tolerance.linear)) {
+        throw new GeometryError("DEGENERATE_GEOMETRY", "Thread surface radius must stay positive.", {
+            operation,
+        });
+    }
+};
+const resolveMaximumThreadSurfaceRadius = (options, diameter, length, operation) => {
+    const bevelSize = assertFiniteThreadNumber(options.bevelSize ?? options.profile.depth, "bevelSize", operation);
+    const bottomBevelSize = assertFiniteThreadNumber(options.bevelBottomSize ?? bevelSize, "bevelBottomSize", operation);
+    const topBevelSize = assertFiniteThreadNumber(options.bevelTopSize ?? bevelSize, "bevelTopSize", operation);
+    const bevelOffset = assertFiniteThreadNumber(options.bevelOffset ?? 0, "bevelOffset", operation);
+    if (bevelSize < 0 ||
+        bottomBevelSize < 0 ||
+        topBevelSize < 0 ||
+        bevelOffset < 0 ||
+        bevelOffset * 2 > length ||
+        (options.bevelMode !== undefined &&
+            options.bevelMode !== "inset" &&
+            options.bevelMode !== "outset")) {
+        throw new GeometryError("INVALID_ARGUMENT", "Thread bevel options are invalid.", {
+            operation,
+        });
+    }
+    const majorRadius = diameter / 2;
+    if (options.bevelMode !== "outset")
+        return majorRadius;
+    const outsetRadius = (style, size) => (style === "blunt" ? majorRadius : majorRadius - options.profile.depth) +
+        Math.min(size, length / 2);
+    return Math.max(majorRadius, options.bevelBottom === true
+        ? outsetRadius(options.ends?.bottom ?? "blunt", bottomBevelSize)
+        : majorRadius, options.bevelTop === true
+        ? outsetRadius(options.ends?.top ?? "blunt", topBevelSize)
+        : majorRadius);
+};
+/** @internal Resolves the solid's sampling and conservative allocation plan. */
+export const resolveHelicalThreadSolidMeshPreflight = (options, operation) => {
+    const requestedEndLength = options.ends?.endLength ?? 0;
+    const sharedBevelSize = options.bevelSize ?? options.profile.depth;
+    const bottomBevelSize = options.bevelBottomSize ?? sharedBevelSize;
+    const topBevelSize = options.bevelTopSize ?? sharedBevelSize;
+    const bluntBevelReservation = Math.max(options.bevelBottom === true && (options.ends?.bottom ?? "blunt") === "blunt"
+        ? bottomBevelSize
+        : 0, options.bevelTop === true && (options.ends?.top ?? "blunt") === "blunt" ? topBevelSize : 0);
+    const effectiveBluntBevelReservation = Math.min(bluntBevelReservation, options.length / 2);
+    const resolvedOptions = effectiveBluntBevelReservation > 0
+        ? {
+            ...options,
+            ends: {
+                ...options.ends,
+                endLength: Math.max(requestedEndLength, effectiveBluntBevelReservation),
+            },
+        }
+        : options;
+    const resolved = resolveHelicalThreadMeshOptions(resolvedOptions, operation, (diameter, length) => resolveMaximumThreadSurfaceRadius(resolvedOptions, diameter, length, operation));
+    if ((options.bevelMode ?? "inset") === "inset") {
+        const majorRadius = resolved.diameter / 2;
+        if (options.bevelBottom === true) {
+            requirePositiveThreadSurfaceRadius(applyThreadSurfaceBevel(majorRadius, 0, options.profile, resolved, resolvedOptions), resolved, operation);
+        }
+        if (options.bevelTop === true) {
+            requirePositiveThreadSurfaceRadius(applyThreadSurfaceBevel(majorRadius, resolved.length, options.profile, resolved, resolvedOptions), resolved, operation);
+        }
+    }
+    const resolution = resolveGeometryResolution(options.resolution, options.limits);
+    // Profile breakpoints already bound the axial error of each helical facet. Sampling an
+    // additional row for every angular phase step squares mesh density as circular quality rises
+    // and produces thousands of near-collinear zipper triangles. Only a caller's physical edge
+    // limit warrants extra axial samples between those semantic stations.
+    const maximumAxialSegmentLength = resolution.maxSegmentLength ?? Number.POSITIVE_INFINITY;
+    const axialIntervals = Math.ceil(resolved.length / maximumAxialSegmentLength);
+    const profilePeriods = Math.ceil(resolved.usable / options.profile.pitch) +
+        (resolved.leadInShape !== "cut" && (resolved.bottom === "blunt" || resolved.top === "blunt")
+            ? 4
+            : 2);
+    const estimatedRows = axialIntervals + 1 + resolved.surfaceSection.length * profilePeriods + 10;
+    const estimatedTriangles = 2 * resolved.segments * estimatedRows;
+    const vertices = (estimatedRows + 2) * resolved.segments;
+    assertMeshAllocationWithinLimits(vertices, estimatedTriangles, (vertices + estimatedTriangles) * 12, operation, resolveModelingLimits(options.limits));
+    return Object.freeze({
+        maximumAxialSegmentLength,
+        preflight: Object.freeze({
+            axialIntervals,
+            circularSegments: resolved.segments,
+            estimatedRows,
+            estimatedTriangles,
+        }),
+        resolved,
+    });
+};
+/**
+ * Validates a direct thread solid and returns its conservative allocation estimate without
+ * constructing vertex or index buffers.
+ */
+export function preflightHelicalThreadSolidMesh(options) {
+    return resolveHelicalThreadSolidMeshPreflight(options, "preflightHelicalThreadSolidMesh")
+        .preflight;
+}

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

@@ -0,0 +1,142 @@
+/** Closed ridge and complete-solid mesh construction from resolved thread plans. */
+import { triangulateLoop2 } from "../loft.js";
+import { joinTriangleMeshes, measureTriangleMesh, reverseTriangleMesh, validateTriangleMesh, } from "../mesh.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits } from "../model-limits.js";
+import { resolveHelicalThreadMeshOptions, resolveHelicalThreadSolidMeshPreflight, } from "./thread-mesh-plan.js";
+import { buildThreadSurfaceColumn, stitchThreadSurfaceColumns } from "./thread-surface.js";
+const MINIMUM_TAPERED_RIDGE_HEIGHT = 0.0005;
+const buildThreadRidgeComponent = (options) => {
+    const { profile } = options;
+    const { section } = options;
+    const lead = profile.pitch * options.starts;
+    const z0 = options.bottomBoundary - section[0][0];
+    const z1 = options.topBoundary - section.at(-1)[0];
+    const axialStep = lead / options.segments;
+    const exactSpans = (z1 - z0) / axialStep;
+    const roundedSpans = Math.round(exactSpans);
+    // Decimal metric dimensions can land a few ulps above an integral column
+    // count. Do not add a microscopic terminal span that collapses in Float32.
+    const spans = Math.max(1, Math.abs(exactSpans - roundedSpans) <= 1e-6 ? roundedSpans : Math.ceil(exactSpans));
+    const size = section.length;
+    const positions = [];
+    const initial = options.phase + (options.direction * 2 * Math.PI * options.start) / options.starts;
+    for (let column = 0; column <= spans; column += 1) {
+        // Keep complete columns on the same angular grid as a cylinder with the
+        // requested circular segment count. Only a fractional terminal column is
+        // allowed to leave that grid so arbitrary lengths still end exactly.
+        const centerZ = column === spans ? z1 : z0 + column * axialStep;
+        const angle = initial + (options.direction * 2 * Math.PI * (centerZ - z0)) / lead;
+        const bottomFactor = options.bottom === "tapered" ? (centerZ - z0) / profile.depth : 1;
+        const topFactor = options.top === "tapered" ? (z1 - centerZ) / profile.depth : 1;
+        // Keep the terminal cross-section non-degenerate in the standalone ridge mesh with a 0.5 µm
+        // radial remnant. Complete thread solids use their integrated end surface instead.
+        const minimumFactor = Math.min(1, MINIMUM_TAPERED_RIDGE_HEIGHT / profile.depth);
+        const factor = Math.max(minimumFactor, Math.min(bottomFactor, topFactor, 1));
+        for (const [axial, radial] of section) {
+            const radius = options.majorDiameter / 2 - profile.depth + (radial + profile.depth) * factor;
+            positions.push(radius * Math.cos(angle), radius * Math.sin(angle), centerZ + axial);
+        }
+    }
+    const indices = [];
+    for (let column = 0; column < spans; column += 1)
+        for (let point = 0; point < size; point += 1) {
+            const next = (point + 1) % size;
+            const a = column * size + point, b = column * size + next;
+            const c = (column + 1) * size + next, d = (column + 1) * size + point;
+            indices.push(a, b, c, a, c, d);
+        }
+    const capTriangles = triangulateLoop2([...section].reverse());
+    const cap = (column, top) => {
+        for (let offset = 0; offset < capTriangles.length; offset += 3) {
+            const a = column * size + (size - 1 - capTriangles[offset]);
+            const b = column * size + (size - 1 - capTriangles[offset + 1]);
+            const c = column * size + (size - 1 - capTriangles[offset + 2]);
+            indices.push(...(top ? [a, c, b] : [a, b, c]));
+        }
+    };
+    cap(0, false);
+    cap(spans, true);
+    let mesh = {
+        positions: new Float32Array(positions),
+        indices: new Uint32Array(indices),
+    };
+    validateTriangleMesh(mesh, { requireClosed: true });
+    if (measureTriangleMesh(mesh, { requireClosed: true }).signedVolume < 0)
+        mesh = reverseTriangleMesh(mesh);
+    return mesh;
+};
+/**
+ * Builds one closed threaded cylinder without a ridge/core Boolean seam.
+ *
+ * Each circular facet includes its exact phase-shifted profile breakpoints, including duplicate-Z
+ * samples for vertical flanks and blunt transitions. Adjacent variable grids are stitched as a
+ * monotone strip, with optional intermediate rows bounded by physical `maxSegmentLength`. A
+ * conservative pre-allocation estimate rejects excessive meshes before constructing position
+ * arrays.
+ */
+export function buildHelicalThreadSolidMesh(options) {
+    const operation = "buildHelicalThreadSolidMesh";
+    const { maximumAxialSegmentLength, resolved } = resolveHelicalThreadSolidMeshPreflight(options, operation);
+    const positions = [];
+    const columns = Array.from({ length: resolved.segments }, (_, column) => buildThreadSurfaceColumn(options.profile, resolved, options, resolved.phase + (column * 2 * Math.PI) / resolved.segments, maximumAxialSegmentLength, positions));
+    const indices = [];
+    for (let column = 0; column < columns.length; column += 1) {
+        stitchThreadSurfaceColumns(columns[column], columns[(column + 1) % columns.length], resolved.direction, column === columns.length - 1
+            ? resolved.direction * resolved.starts * resolved.surfaceSection.length
+            : 0, resolved.tolerance.linear, positions, resolved.leadInEnvelope === "major", indices);
+    }
+    const bottomCenter = positions.length / 3;
+    positions.push(0, 0, 0);
+    const topCenter = positions.length / 3;
+    positions.push(0, 0, resolved.length);
+    for (let column = 0; column < columns.length; column += 1) {
+        const next = (column + 1) % columns.length;
+        const bottom = columns[column].indices[0];
+        const nextBottom = columns[next].indices[0];
+        const top = columns[column].indices.at(-1);
+        const nextTop = columns[next].indices.at(-1);
+        indices.push(bottomCenter, nextBottom, bottom, topCenter, top, nextTop);
+    }
+    assertMeshAllocationWithinLimits(positions.length / 3, indices.length / 3, (positions.length + indices.length) * 4, operation, resolveModelingLimits(options.limits));
+    let mesh = {
+        positions: new Float32Array(positions),
+        indices: new Uint32Array(indices),
+    };
+    validateTriangleMesh(mesh, { requireClosed: true });
+    if (measureTriangleMesh(mesh, { requireClosed: true }).signedVolume < 0) {
+        mesh = reverseTriangleMesh(mesh);
+    }
+    return mesh;
+}
+/**
+ * Builds closed thread-ridge components with every profile locked to the
+ * shaft's radial/axial frame. The mesh is intended for union with its
+ * minor-envelope cylinder and never owns WASM objects.
+ */
+export function buildHelicalThreadRidgeMesh(options) {
+    const operation = "buildHelicalThreadRidgeMesh";
+    const resolved = resolveHelicalThreadMeshOptions(options, operation);
+    const z0 = resolved.bottomBoundary - resolved.section[0][0];
+    const z1 = resolved.topBoundary - resolved.section.at(-1)[0];
+    const exactSpans = (z1 - z0) / ((options.profile.pitch * resolved.starts) / resolved.segments);
+    const roundedSpans = Math.round(exactSpans);
+    const spans = Math.max(1, Math.abs(exactSpans - roundedSpans) <= 1e-6 ? roundedSpans : Math.ceil(exactSpans));
+    const vertices = resolved.starts * (spans + 1) * resolved.section.length;
+    const triangles = resolved.starts * (spans * resolved.section.length * 2 + (resolved.section.length - 2) * 2);
+    assertMeshAllocationWithinLimits(vertices, triangles, (vertices + triangles) * 12, operation, resolveModelingLimits(options.limits));
+    return joinTriangleMeshes(Array.from({ length: resolved.starts }, (_, start) => buildThreadRidgeComponent({
+        length: resolved.length,
+        majorDiameter: resolved.diameter,
+        profile: options.profile,
+        start,
+        starts: resolved.starts,
+        phase: resolved.phase,
+        direction: resolved.direction,
+        segments: resolved.segments,
+        bottomBoundary: resolved.bottomBoundary,
+        topBoundary: resolved.topBoundary,
+        bottom: resolved.bottom,
+        top: resolved.top,
+        section: resolved.section,
+    })));
+}