@metamesh/modeling 0.0.0-stage → 0.6.0

package/dist/geometry/sweeps/orientation.js

@@ -0,0 +1,106 @@
+import { GeometryError } from "../errors.js";
+import { cross3, normalize3, projectOntoPlane3, subtract3 } from "../math/vector3.js";
+import { computeClosedParallelTransportFrames, computeParallelTransportFrames, } from "../paths/frames.js";
+import { validateSweepNormal } from "./validation.js";
+const fail = (message, code = "INVALID_ARGUMENT") => {
+    throw new GeometryError(code, message, { operation: "sweep" });
+};
+/** @internal Validates the canonical sweep controls without evaluating authored guides. */
+export function validateSweepOptions(options) {
+    if (typeof options !== "object" || options === null || Array.isArray(options))
+        fail("Sweep options must be an object.");
+    const allowed = [
+        "closed",
+        "limits",
+        "orientation",
+        "resolution",
+        "twistDegrees",
+        "twistBy",
+        "scale",
+        "seamProfileOffset",
+    ];
+    if (Object.keys(options).some((key) => !allowed.includes(key)))
+        fail("Unsupported sweep option.");
+    if (options.closed !== undefined && typeof options.closed !== "boolean")
+        fail("Sweep closed must be boolean.");
+    if (options.twistBy !== undefined &&
+        options.twistBy !== "length" &&
+        options.twistBy !== "stations")
+        fail("Sweep twistBy must be length or stations.");
+    if (!Number.isFinite(options.twistDegrees ?? 0))
+        throw new GeometryError("NON_FINITE_VALUE", "Sweep twistDegrees must be finite.", {
+            operation: "sweep",
+        });
+    const policy = options.orientation;
+    if (policy === undefined)
+        return;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy))
+        fail("Sweep orientation must be a policy object.");
+    let keys;
+    if (policy.kind === "transport") {
+        keys = ["kind", "initialNormal"];
+        if (policy.initialNormal !== undefined)
+            validateSweepNormal(policy.initialNormal, "sweep");
+    }
+    else if (policy.kind === "fixed-normal") {
+        keys = ["kind", "normal"];
+        validateSweepNormal(policy.normal, "sweep");
+    }
+    else if (policy.kind === "guide") {
+        keys = ["kind", "normal"];
+        if (typeof policy.normal !== "function")
+            fail("Guide orientation needs a normal function.");
+    }
+    else if (policy.kind === "frenet")
+        keys = ["kind"];
+    else
+        return fail("Unsupported sweep orientation policy.");
+    if (Object.keys(policy).some((key) => !keys.includes(key)))
+        fail("Unsupported field for the selected sweep orientation.");
+}
+function directedNormal(value, tangent, label) {
+    validateSweepNormal(value, "sweep");
+    const maximum = Math.max(...value.map(Math.abs));
+    const unit = normalize3([value[0] / maximum, value[1] / maximum, value[2] / maximum]);
+    const projected = projectOntoPlane3(unit, tangent);
+    if (Math.hypot(...projected) <= 1e-10)
+        fail(`${label} normal must not be parallel to the path tangent.`, "DEGENERATE_GEOMETRY");
+    return normalize3(projected);
+}
+/** @internal One frame policy for simple and filled sweeps, evaluated once per original normalized station. */
+export function computeSweepFrames(path, options) {
+    validateSweepOptions(options);
+    const closed = options.closed ?? false;
+    const policy = options.orientation ?? { kind: "transport" };
+    const tangentAt = (index) => {
+        const previous = closed ? (index - 1 + path.length) % path.length : Math.max(0, index - 1);
+        const next = closed ? (index + 1) % path.length : Math.min(path.length - 1, index + 1);
+        return normalize3(subtract3(path[next], path[previous]));
+    };
+    if (policy.kind === "transport") {
+        const preferred = policy.initialNormal === undefined
+            ? undefined
+            : directedNormal(policy.initialNormal, tangentAt(0), "Initial transport");
+        return closed
+            ? computeClosedParallelTransportFrames(path, preferred, options.limits)
+            : computeParallelTransportFrames(path, preferred, undefined, options.limits);
+    }
+    const tangents = path.map((_, index) => tangentAt(index));
+    return path.map((point, index) => {
+        const tangent = tangents[index];
+        let normal;
+        if (policy.kind === "fixed-normal")
+            normal = directedNormal(policy.normal, tangent, "Fixed");
+        else if (policy.kind === "guide")
+            normal = directedNormal(policy.normal(point, index), tangent, "Guide");
+        else {
+            const previous = closed ? (index - 1 + path.length) % path.length : Math.max(0, index - 1);
+            const next = closed ? (index + 1) % path.length : Math.min(path.length - 1, index + 1);
+            const curvature = projectOntoPlane3(subtract3(tangents[next], tangents[previous]), tangent);
+            if (Math.hypot(...curvature) <= 1e-10)
+                fail("Frenet orientation needs nonzero sampled curvature at every station.", "DEGENERATE_GEOMETRY");
+            normal = normalize3(curvature);
+        }
+        return { tangent, normal, binormal: normalize3(cross3(tangent, normal)) };
+    });
+}

package/dist/geometry/sweeps/stations.js

@@ -0,0 +1,161 @@
+import { GeometryError } from "../errors.js";
+import { cross3, dot3, lerp3, normalize3, rotateAroundAxis3 } from "../math/vector3.js";
+import { resolveGeometryResolution } from "../resolution.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits } from "../sampling-limits.js";
+/** @internal Original station progression, with a virtual final seam endpoint for closed paths. */
+export function sweepProgress(path, options) {
+    if (options.twistBy !== undefined &&
+        options.twistBy !== "length" &&
+        options.twistBy !== "stations")
+        throw new GeometryError("INVALID_ARGUMENT", "Sweep twistBy must be length or stations.", {
+            operation: "sweep",
+        });
+    const closed = options.closed ?? false, gaps = closed ? path.length : path.length - 1;
+    if (options.twistBy === "stations")
+        return Array.from({ length: gaps + 1 }, (_, index) => index / gaps);
+    const cumulative = [0];
+    for (let index = 0; index < gaps; index++) {
+        const next = path[(index + 1) % path.length], previous = path[index];
+        cumulative.push(cumulative[index] +
+            Math.hypot(next[0] - previous[0], next[1] - previous[1], next[2] - previous[2]));
+    }
+    const total = cumulative.at(-1);
+    if (!Number.isFinite(total) || total <= 0)
+        throw new GeometryError("DEGENERATE_GEOMETRY", "Sweep progression needs finite positive path length.", { operation: "sweep" });
+    return cumulative.map((length) => length / total);
+}
+/** Shortest rotation between two right-handed transported frames, including a stable half turn. */
+function frameRotation(from, to) {
+    const cosine = Math.max(-1, Math.min(1, (dot3(from.normal, to.normal) +
+        dot3(from.binormal, to.binormal) +
+        dot3(from.tangent, to.tangent) -
+        1) /
+        2));
+    const axes = [
+        cross3(from.normal, to.normal),
+        cross3(from.binormal, to.binormal),
+        cross3(from.tangent, to.tangent),
+    ];
+    const axis = [
+        axes.reduce((sum, v) => sum + v[0], 0),
+        axes.reduce((sum, v) => sum + v[1], 0),
+        axes.reduce((sum, v) => sum + v[2], 0),
+    ];
+    const angle = Math.atan2(Math.hypot(...axis) / 2, cosine);
+    if (angle <= 1e-12)
+        return { axis: [1, 0, 0], angle: 0 };
+    if (cosine >= 0 || Math.hypot(...axis) > 1e-8)
+        return { axis: normalize3(axis), angle };
+    const matrix = Array.from({ length: 3 }, (_, row) => Array.from({ length: 3 }, (_, column) => to.normal[row] * from.normal[column] +
+        to.binormal[row] * from.binormal[column] +
+        to.tangent[row] * from.tangent[column]));
+    let principal = 0;
+    for (let i = 1; i < 3; i++)
+        if (matrix[i][i] > matrix[principal][principal])
+            principal = i;
+    const component = Math.sqrt(Math.max(0, (matrix[principal][principal] + 1) / 2));
+    const halfTurn = [0, 0, 0];
+    halfTurn[principal] = component;
+    for (let i = 0; i < 3; i++)
+        if (i !== principal)
+            halfTurn[i] = (matrix[i][principal] + matrix[principal][i]) / (4 * component);
+    return { axis: normalize3(halfTurn), angle };
+}
+/** Plans refinement of the whole triangulated surface, including its mixed edge/twist error. */
+export function planSweepStations(contours, path, scales, options, frames) {
+    const closed = options.closed ?? false;
+    const segmentCount = closed ? path.length : path.length - 1;
+    const twist = ((options.twistDegrees ?? 0) / 180) * Math.PI;
+    if (!Number.isFinite(twist))
+        throw new GeometryError("NON_FINITE_VALUE", "Sweep twistDegrees must be finite.", {
+            operation: "sweep",
+        });
+    const intervals = [];
+    const progress = sweepProgress(path, options);
+    if (twist === 0)
+        return { intervals: Array(segmentCount).fill(1), stationCount: path.length, progress };
+    const resolution = resolveGeometryResolution(options.resolution, options.limits);
+    const limits = resolveGeometrySamplingLimits(options.limits);
+    let radius = 0, edgeLength = 0;
+    for (const contour of contours)
+        for (let i = 0; i < contour.length; i++) {
+            const point = contour[i], next = contour[(i + 1) % contour.length];
+            if (!Array.isArray(point) ||
+                point.length !== 2 ||
+                !point.every((coordinate) => typeof coordinate === "number" && Number.isFinite(coordinate)))
+                throw new GeometryError("INVALID_ARGUMENT", "Sweep profiles require finite XY points.", {
+                    operation: "sweep",
+                });
+            radius = Math.max(radius, Math.hypot(...point));
+            edgeLength = Math.max(edgeLength, Math.hypot(next[0] - point[0], next[1] - point[1]));
+        }
+    let stationCount = closed ? 0 : 1;
+    for (let i = 0; i < segmentCount; i++) {
+        const next = (i + 1) % path.length;
+        const twistStep = Math.abs(twist * (progress[i + 1] - progress[i]));
+        const frameAngle = frames === undefined ? 0 : frameRotation(frames[i], frames[next]).angle;
+        const angle = frameAngle + twistStep;
+        const maximumScale = Math.max(...scales[i], ...scales[next]);
+        const scaleChange = Math.max(Math.abs(scales[next][0] - scales[i][0]), Math.abs(scales[next][1] - scales[i][1]));
+        // Interpolation on each triangular side patch has error <= A/n² + B/n. The B
+        // term bounds the mixed profile-edge/station derivative; bounding only vertex
+        // trajectories misses the systematic inward bias of a twisted quad diagonal.
+        const curvature = radius * (maximumScale * (angle * angle + frameAngle * twistStep) + 2 * scaleChange * angle);
+        const a = curvature / 8, b = (edgeLength * (maximumScale * angle + scaleChange)) / 4;
+        const requiredAngular = resolution.circularSegments === undefined
+            ? Math.max(1, Math.ceil((b + Math.hypot(b, 2 * Math.sqrt(a * resolution.maxChordError))) /
+                (2 * resolution.maxChordError)), Math.ceil((resolution.minimumSegments * angle) / (2 * Math.PI)))
+            : Math.max(1, Math.ceil((resolution.circularSegments * angle) / (2 * Math.PI)));
+        const allowedAngular = Math.max(1, scaleChange === 0 ? 0 : resolution.maximumSegments, Math.ceil((resolution.maximumSegments * angle) / (2 * Math.PI)));
+        if (requiredAngular > allowedAngular)
+            throw new GeometryError("COMPLEXITY_LIMIT", `Sweep surface refinement requires ${requiredAngular} intervals; the selected circular ceiling allows ${allowedAngular}.`, {
+                operation: "sweep",
+                details: { requiredCount: requiredAngular, allowedCount: allowedAngular },
+            });
+        const travel = Math.hypot(...[0, 1, 2].map((axis) => path[next][axis] - path[i][axis])) +
+            radius * (maximumScale * angle + scaleChange);
+        const lengthIntervals = resolution.maxSegmentLength === undefined
+            ? 1
+            : Math.ceil(travel / resolution.maxSegmentLength);
+        const count = Math.max(requiredAngular, lengthIntervals);
+        stationCount += count;
+        assertSamplingCount(stationCount, "sweep", limits.maxPathPoints);
+        intervals.push(count);
+    }
+    return { intervals, stationCount, progress };
+}
+/** Inserts twist samples without calling authored guides again or changing original station meaning. */
+export function refineSweepStations(path, scales, frames, options, plan) {
+    const twist = ((options.twistDegrees ?? 0) / 180) * Math.PI;
+    const segmentCount = plan.intervals.length;
+    const points = [], sampledScales = [], sampledFrames = [], twists = [];
+    for (let i = 0; i < segmentCount; i++) {
+        const next = (i + 1) % path.length;
+        const rotation = frameRotation(frames[i], frames[next]);
+        for (let j = 0; j < plan.intervals[i]; j++) {
+            const amount = j / plan.intervals[i];
+            points.push(amount === 0 ? path[i] : lerp3(path[i], path[next], amount));
+            sampledScales.push(amount === 0
+                ? scales[i]
+                : [
+                    scales[i][0] + (scales[next][0] - scales[i][0]) * amount,
+                    scales[i][1] + (scales[next][1] - scales[i][1]) * amount,
+                ]);
+            sampledFrames.push(amount === 0
+                ? frames[i]
+                : {
+                    normal: rotateAroundAxis3(frames[i].normal, rotation.axis, rotation.angle * amount),
+                    binormal: rotateAroundAxis3(frames[i].binormal, rotation.axis, rotation.angle * amount),
+                    tangent: rotateAroundAxis3(frames[i].tangent, rotation.axis, rotation.angle * amount),
+                });
+            twists.push(twist * (plan.progress[i] + (plan.progress[i + 1] - plan.progress[i]) * amount));
+        }
+    }
+    if (options.closed !== true) {
+        points.push(path.at(-1));
+        sampledScales.push(scales.at(-1));
+        sampledFrames.push(frames.at(-1));
+        twists.push(twist);
+    }
+    return { path: points, scales: sampledScales, frames: sampledFrames, twists };
+}

package/dist/geometry/sweeps/sweep-closed.js

@@ -0,0 +1,96 @@
+import { GeometryError } from "../errors.js";
+import { add3, rotateAroundAxis3, scale3 } from "../math/vector3.js";
+import { validateTriangleMesh } from "../mesh.js";
+import { resolveGeometryTolerance } from "../tolerance.js";
+import { resolveSweepScales } from "./options.js";
+import { computeSweepFrames, validateSweepOptions } from "./orientation.js";
+import { planSweepStations, refineSweepStations } from "./stations.js";
+import { assertSweepAllocation, normalizeSweepPath, normalizeSweepProfile, writeSweepVertex, } from "./validation.js";
+/** @internal Checks host allocation policy before frames or manufacturing buffers. */
+export const buildClosedSweepMesh = (profile, path, options = {}, allocationGuard) => {
+    const operation = "sweep";
+    validateSweepOptions(options);
+    profile = normalizeSweepProfile(profile, operation, options.limits);
+    path = normalizeSweepPath(path, true, operation, options.limits);
+    assertSweepAllocation(path.length, profile.length, true, operation, allocationGuard, options.limits);
+    let scales = resolveSweepScales(options.scale, path.length);
+    const seamProfileOffset = options.seamProfileOffset ?? 0;
+    if (!Number.isSafeInteger(seamProfileOffset)) {
+        throw new GeometryError("INVALID_ARGUMENT", "seamProfileOffset must be a safe integer.", {
+            operation,
+        });
+    }
+    const twistRadians = ((options.twistDegrees ?? 0) / 180) * Math.PI;
+    if (!Number.isFinite(twistRadians)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Sweep twistDegrees must be finite.", {
+            operation,
+        });
+    }
+    const ringVertexCount = profile.length;
+    const normalizedSeamProfileOffset = ((seamProfileOffset % ringVertexCount) + ringVertexCount) % ringVertexCount;
+    const profileScale = profile.reduce((extent, [x, y]) => Math.max(extent, Math.abs(x), Math.abs(y)), 1);
+    const seamTolerance = resolveGeometryTolerance(profileScale).linear;
+    const cosine = Math.cos(twistRadians);
+    const sine = Math.sin(twistRadians);
+    for (let index = 0; index < profile.length; index++) {
+        const [profileX, profileY] = profile[index];
+        const [scaleX, scaleY] = scales[0];
+        const x = profileX * scaleX;
+        const y = profileY * scaleY;
+        const target = profile[(index + normalizedSeamProfileOffset) % profile.length];
+        if (Math.hypot(x * cosine - y * sine - target[0] * scaleX, x * sine + y * cosine - target[1] * scaleY) > seamTolerance) {
+            throw new GeometryError("INVALID_TOPOLOGY", "Sweep twist must end at the seam's corresponding profile orientation.", { operation });
+        }
+    }
+    if (twistRadians !== 0) {
+        const plan = planSweepStations([profile], path, scales, options);
+        assertSweepAllocation(plan.stationCount, profile.length, true, operation, allocationGuard, options.limits);
+    }
+    let transportedFrames = computeSweepFrames(path, options);
+    let twists;
+    if (twistRadians !== 0) {
+        const plan = planSweepStations([profile], path, scales, options, transportedFrames);
+        assertSweepAllocation(plan.stationCount, profile.length, true, operation, allocationGuard, options.limits);
+        const refined = refineSweepStations(path, scales, transportedFrames, options, plan);
+        path = refined.path;
+        scales = refined.scales;
+        transportedFrames = refined.frames;
+        twists = refined.twists;
+    }
+    const positions = new Float32Array(path.length * ringVertexCount * 3);
+    for (let ring = 0; ring < path.length; ring += 1) {
+        const point = path[ring];
+        const tangent = transportedFrames[ring].tangent;
+        const twist = twists?.[ring] ?? twistRadians * (ring / path.length);
+        const baseNormal = transportedFrames[ring].normal;
+        const normal = rotateAroundAxis3(baseNormal, tangent, twist);
+        const binormal = rotateAroundAxis3(transportedFrames[ring].binormal, tangent, twist);
+        const [scaleX, scaleY] = scales[ring];
+        for (let profileIndex = 0; profileIndex < profile.length; profileIndex += 1) {
+            const [x, y] = profile[profileIndex];
+            const vertex = add3(point, add3(scale3(normal, x * scaleX), scale3(binormal, y * scaleY)));
+            writeSweepVertex(positions, (ring * ringVertexCount + profileIndex) * 3, vertex, operation);
+        }
+    }
+    const indices = new Uint32Array(path.length * ringVertexCount * 2 * 3);
+    let cursor = 0;
+    for (let ring = 0; ring < path.length; ring += 1) {
+        const nextRing = (ring + 1) % path.length;
+        const nextProfileOffset = nextRing === 0 ? normalizedSeamProfileOffset : 0;
+        for (let profileIndex = 0; profileIndex < ringVertexCount; profileIndex += 1) {
+            const following = (profileIndex + 1) % ringVertexCount;
+            const a = ring * ringVertexCount + profileIndex;
+            const b = ring * ringVertexCount + following;
+            const c = nextRing * ringVertexCount + ((following + nextProfileOffset) % ringVertexCount);
+            const d = nextRing * ringVertexCount + ((profileIndex + nextProfileOffset) % ringVertexCount);
+            indices[cursor] = a;
+            indices[cursor + 1] = b;
+            indices[cursor + 2] = c;
+            indices[cursor + 3] = a;
+            indices[cursor + 4] = c;
+            indices[cursor + 5] = d;
+            cursor += 6;
+        }
+    }
+    return validateTriangleMesh({ indices, positions });
+};

package/dist/geometry/sweeps/sweep-mesh.js

@@ -0,0 +1,20 @@
+import { GeometryError } from "../errors.js";
+import { validateSweepOptions } from "./orientation.js";
+import { buildClosedSweepMesh } from "./sweep-closed.js";
+import { buildOpenSweepMesh } from "./sweep-open.js";
+/** Sweeps one explicitly ordered point loop, with caps or a geometrically matching closed seam. */
+export function sweepMesh(profile, path, options = {}) {
+    return buildSweepMesh(profile, path, options);
+}
+/** @internal Applies host ceilings before frames, caps, or manufacturing buffers. */
+export function buildSweepMesh(profile, path, options = {}, allocationGuard) {
+    validateSweepOptions(options);
+    if (options.closed === true) {
+        return buildClosedSweepMesh(profile, path, options, allocationGuard);
+    }
+    if ((options.seamProfileOffset ?? 0) !== 0)
+        throw new GeometryError("INVALID_ARGUMENT", "A seamProfileOffset requires a closed path.", {
+            operation: "sweep",
+        });
+    return buildOpenSweepMesh(profile, path, options, allocationGuard);
+}

package/dist/geometry/sweeps/sweep-open.js

@@ -0,0 +1,76 @@
+import { triangulateLoop2 } from "../loft.js";
+import { add3, rotateAroundAxis3, scale3 } from "../math/vector3.js";
+import { validateTriangleMesh } from "../mesh.js";
+import { resolveSweepScales } from "./options.js";
+import { computeSweepFrames, validateSweepOptions } from "./orientation.js";
+import { planSweepStations, refineSweepStations } from "./stations.js";
+import { assertSweepAllocation, normalizeSweepPath, normalizeSweepProfile, writeSweepVertex, } from "./validation.js";
+/** @internal Checks host allocation policy before frames, caps or manufacturing buffers. */
+export const buildOpenSweepMesh = (profile, path, options = {}, allocationGuard) => {
+    const operation = "sweep";
+    validateSweepOptions(options);
+    profile = normalizeSweepProfile(profile, operation, options.limits);
+    path = normalizeSweepPath(path, false, operation, options.limits);
+    assertSweepAllocation(path.length, profile.length, false, operation, allocationGuard, options.limits);
+    let scales = resolveSweepScales(options.scale, path.length);
+    const twistRadians = ((options.twistDegrees ?? 0) / 180) * Math.PI;
+    if (twistRadians !== 0) {
+        const plan = planSweepStations([profile], path, scales, options);
+        assertSweepAllocation(plan.stationCount, profile.length, false, operation, allocationGuard, options.limits);
+    }
+    let frames = computeSweepFrames(path, options);
+    let twists;
+    if (twistRadians !== 0) {
+        const plan = planSweepStations([profile], path, scales, options, frames);
+        assertSweepAllocation(plan.stationCount, profile.length, false, operation, allocationGuard, options.limits);
+        const refined = refineSweepStations(path, scales, frames, options, plan);
+        path = refined.path;
+        scales = refined.scales;
+        frames = refined.frames;
+        twists = refined.twists;
+    }
+    const caps = triangulateLoop2(profile);
+    const ringVertexCount = profile.length;
+    const sideVertexCount = path.length * ringVertexCount;
+    const positions = new Float32Array(sideVertexCount * 3);
+    for (let ring = 0; ring < path.length; ring += 1) {
+        const point = path[ring];
+        const frame = frames[ring];
+        const twist = twists?.[ring] ?? (twistRadians * ring) / (path.length - 1);
+        const normal = rotateAroundAxis3(frame.normal, frame.tangent, twist);
+        const binormal = rotateAroundAxis3(frame.binormal, frame.tangent, twist);
+        const [scaleX, scaleY] = scales[ring];
+        for (let profileIndex = 0; profileIndex < profile.length; profileIndex += 1) {
+            const [x, y] = profile[profileIndex];
+            const vertex = add3(point, add3(scale3(normal, x * scaleX), scale3(binormal, y * scaleY)));
+            writeSweepVertex(positions, (ring * ringVertexCount + profileIndex) * 3, vertex, operation);
+        }
+    }
+    const triangleCount = (path.length - 1) * ringVertexCount * 2 + (caps.length / 3) * 2;
+    const indices = new Uint32Array(triangleCount * 3);
+    let cursor = 0;
+    const triangle = (a, b, c) => {
+        indices[cursor] = a;
+        indices[cursor + 1] = b;
+        indices[cursor + 2] = c;
+        cursor += 3;
+    };
+    for (let ring = 0; ring < path.length - 1; ring += 1) {
+        const current = ring * ringVertexCount;
+        const next = current + ringVertexCount;
+        for (let profileIndex = 0; profileIndex < ringVertexCount; profileIndex += 1) {
+            const following = (profileIndex + 1) % ringVertexCount;
+            triangle(current + profileIndex, current + following, next + following);
+            triangle(current + profileIndex, next + following, next + profileIndex);
+        }
+    }
+    const finalRing = (path.length - 1) * ringVertexCount;
+    for (let offset = 0; offset < caps.length; offset += 3) {
+        const a = caps[offset];
+        const b = caps[offset + 1];
+        const c = caps[offset + 2];
+        triangle(a, c, b);
+        triangle(finalRing + a, finalRing + b, finalRing + c);
+    }
+    return validateTriangleMesh({ positions, indices });
+};

package/dist/geometry/sweeps/validation.js

@@ -0,0 +1,116 @@
+import { GeometryError } from "../errors.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../model-limits.js";
+import { writeMeshVertex } from "../numeric.js";
+import { normalizeLoop2 } from "../regions.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
+import { resolveGeometryTolerance } from "../tolerance.js";
+/** @internal Normalizes simple profiles before cap triangulation or side construction. */
+export function normalizeSweepProfile(profile, operation, limits = {}) {
+    const hasArrayShape = Array.isArray(profile);
+    if (!hasArrayShape) {
+        throw new GeometryError("INVALID_ARGUMENT", "Sweep profiles must be arrays of XY points.", {
+            operation,
+        });
+    }
+    if (profile.length < 3) {
+        throw new GeometryError("DEGENERATE_GEOMETRY", "A sweep profile needs at least three points.", {
+            operation,
+        });
+    }
+    assertSamplingCount(profile.length, operation, resolveGeometrySamplingLimits(limits).maxSweepProfilePoints);
+    for (const point of profile) {
+        const hasPointShape = Array.isArray(point);
+        if (!hasPointShape || point.length !== 2) {
+            throw new GeometryError("INVALID_ARGUMENT", "Sweep profile points must be exact XY tuples.", {
+                operation,
+            });
+        }
+    }
+    return normalizeLoop2(profile, true);
+}
+/** @internal Cleans redundant path samples and validates finite, non-degenerate centered tangents. */
+export function normalizeSweepPath(path, closed, operation, limits = {}) {
+    const hasArrayShape = Array.isArray(path);
+    if (!hasArrayShape) {
+        throw new GeometryError("INVALID_ARGUMENT", "Sweep paths must be arrays of XYZ points.", {
+            operation,
+        });
+    }
+    assertSamplingCount(path.length, operation, resolveGeometrySamplingLimits(limits).maxPathPoints);
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    for (const point of path) {
+        const hasPointShape = Array.isArray(point);
+        if (!hasPointShape || point.length !== 3) {
+            throw new GeometryError("INVALID_ARGUMENT", "Sweep path points must be exact XYZ tuples.", {
+                operation,
+            });
+        }
+        if (![point[0], point[1], point[2]].every((coordinate) => Number.isFinite(coordinate) && Number.isFinite(Math.fround(coordinate)))) {
+            throw new GeometryError("NON_FINITE_VALUE", "Sweep path coordinates must be finite XYZ points.", {
+                operation,
+            });
+        }
+        for (let axis = 0; axis < 3; axis += 1) {
+            min[axis] = Math.min(min[axis], point[axis]);
+            max[axis] = Math.max(max[axis], point[axis]);
+        }
+    }
+    const extent = path.length === 0 ? 0 : Math.max(max[0] - min[0], max[1] - min[1], max[2] - min[2]);
+    const tolerance = resolveGeometryTolerance(extent).linear;
+    const distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+    const cleaned = [];
+    for (const point of path) {
+        if (cleaned.length === 0 || distance(point, cleaned.at(-1)) > tolerance) {
+            cleaned.push(Object.freeze([point[0], point[1], point[2]]));
+        }
+    }
+    if (cleaned.length > 1 && distance(cleaned[0], cleaned.at(-1)) <= tolerance) {
+        if (closed)
+            cleaned.pop();
+        else
+            throw new GeometryError("INVALID_TOPOLOGY", "An open sweep path cannot have a closed seam.", {
+                operation,
+            });
+    }
+    const minimum = closed ? 3 : 2;
+    if (cleaned.length < minimum) {
+        throw new GeometryError("DEGENERATE_GEOMETRY", `A ${closed ? "closed" : "open"} sweep path needs at least ${closed ? "three" : "two"} points.`, { operation });
+    }
+    for (let index = closed ? 0 : 1; index < (closed ? cleaned.length : cleaned.length - 1); index++) {
+        const previous = cleaned[(index - 1 + cleaned.length) % cleaned.length];
+        const next = cleaned[(index + 1) % cleaned.length];
+        if (distance(previous, next) <= tolerance) {
+            throw new GeometryError("DEGENERATE_GEOMETRY", "Sweep paths cannot reverse through a zero-length centered tangent.", { operation });
+        }
+    }
+    return Object.freeze(cleaned);
+}
+/** @internal Checks output allocation before creating frames or buffers. */
+export function assertSweepAllocation(pathCount, profileCount, closed, operation, allocationGuard, limits = {}) {
+    const vertexCount = pathCount * profileCount;
+    const triangleCount = (closed ? pathCount : pathCount - 1) * profileCount * 2 + (closed ? 0 : (profileCount - 2) * 2);
+    assertMeshAllocationWithinLimits(vertexCount, triangleCount, (vertexCount + triangleCount) * 12, operation, resolveModelingLimits(limits));
+    allocationGuard?.(vertexCount, triangleCount, (vertexCount + triangleCount) * 12, operation);
+}
+/** @internal Rejects coordinates that cannot be represented in manufacturing mesh buffers. */
+export function writeSweepVertex(positions, offset, point, operation) {
+    writeMeshVertex(positions, offset, point, operation);
+}
+/** @internal Checks user-provided orientation controls before vector normalization. */
+export function validateSweepNormal(normal, operation) {
+    const hasArrayShape = Array.isArray(normal);
+    if (!hasArrayShape || normal.length !== 3) {
+        throw new GeometryError("INVALID_ARGUMENT", "Sweep normals must be exact XYZ tuples.", {
+            operation,
+        });
+    }
+    if (![normal[0], normal[1], normal[2]].every(Number.isFinite)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Sweep normal coordinates must be finite XYZ values.", { operation });
+    }
+    if (Math.max(...normal.map(Math.abs)) === 0) {
+        throw new GeometryError("DEGENERATE_GEOMETRY", "Sweep normals must have non-zero length.", {
+            operation,
+        });
+    }
+}

package/dist/geometry/text-contours.js

@@ -0,0 +1,32 @@
+import { GeometryError } from "./errors.js";
+import { flattenSvgPath, SvgVertexBudget } from "./svg/path.js";
+/**
+ * Samples a prepared text layout without shaping text again or loading a font.
+ *
+ * @param layout - Immutable millimetre paths and measurements retained from text preparation.
+ * @param resolution - Explicit curve sampling policy; omitted uses the pure default policy.
+ * @param limits - Explicit profile and circular allocation ceilings.
+ * @returns Frozen contours with original glyph winding and no repeated closing vertex.
+ * @throws GeometryError for empty outlines, invalid paths or policies, over 1000 paths or selected sampling ceilings.
+ */
+export function sampleTextContours(layout, resolution = {}, limits = {}) {
+    const operation = "sampleTextContours";
+    if (!Array.isArray(layout.paths) || layout.paths.length === 0) {
+        throw new GeometryError("DEGENERATE_GEOMETRY", "Prepared text has no visible outlines.", {
+            operation,
+        });
+    }
+    if (layout.paths.length > 1000) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "Prepared text exceeds 1000 input paths.", {
+            operation,
+        });
+    }
+    const budget = new SvgVertexBudget(limits);
+    const contours = layout.paths.flatMap((path) => flattenSvgPath(path, [1, 0, 0, 1, 0, 0], resolution, budget, operation));
+    if (contours.length === 0) {
+        throw new GeometryError("DEGENERATE_GEOMETRY", "Prepared text has no visible outlines.", {
+            operation,
+        });
+    }
+    return Object.freeze(contours.map((contour) => Object.freeze(contour.map((point) => Object.freeze(point)))));
+}

package/dist/geometry/text-layout.js

@@ -0,0 +1 @@
+export {};