@metamesh/modeling 0.13.0 → 0.14.0

package/dist/geometry/math/vector2.js

@@ -0,0 +1,80 @@
+import { GeometryError } from "../errors.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. */
+export const subtract2 = (a, b) => [
+    a[0] - b[0],
+    a[1] - b[1],
+];
+/** Multiplies a vector by a dimensionless scalar. */
+export const scale2 = (vector, scale) => [
+    vector[0] * scale,
+    vector[1] * 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`. */
+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`).
+ * Rejects invalid thresholds, nonfinite lengths, and lengths at or below the threshold with
+ * `INVALID_TOLERANCE`, `NON_FINITE_VALUE`, and `DEGENERATE_GEOMETRY` respectively.
+ */
+export const normalize2 = (vector, epsilon = 1e-12) => {
+    const operation = "normalize2";
+    if (!Number.isFinite(epsilon) || epsilon < 0) {
+        throw new GeometryError("INVALID_TOLERANCE", "epsilon must be finite and non-negative.", {
+            operation,
+        });
+    }
+    const length = length2(vector);
+    if (!Number.isFinite(length)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Cannot normalize a vector without finite length.", {
+            operation,
+        });
+    }
+    if (length <= epsilon) {
+        throw new GeometryError("DEGENERATE_GEOMETRY", "Cannot normalize a zero-length vector.", {
+            operation,
+        });
+    }
+    // Subnormal lengths lose relative precision; rescale only this rare case before division.
+    if (length < 2 ** -1022) {
+        const maximum = Math.max(Math.abs(vector[0]), Math.abs(vector[1]));
+        const x = vector[0] / maximum;
+        const y = vector[1] / maximum;
+        const scaledLength = Math.hypot(x, y);
+        return [x / scaledLength, y / scaledLength];
+    }
+    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.
+ * Throws `NON_FINITE_VALUE` for nonfinite coordinates, angles, or derived coordinates.
+ */
+export const rotate2 = (vector, degrees) => {
+    if (!Number.isFinite(vector[0]) || !Number.isFinite(vector[1]) || !Number.isFinite(degrees)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Rotation coordinates and angle must be finite.", {
+            operation: "rotate2",
+        });
+    }
+    const radians = degrees * (Math.PI / 180);
+    const cosine = Math.cos(radians);
+    const sine = Math.sin(radians);
+    const rotated = [
+        vector[0] * cosine - vector[1] * sine,
+        vector[0] * sine + vector[1] * cosine,
+    ];
+    if (!Number.isFinite(rotated[0]) || !Number.isFinite(rotated[1])) {
+        throw new GeometryError("NON_FINITE_VALUE", "Rotated coordinates must remain finite.", {
+            operation: "rotate2",
+        });
+    }
+    return rotated;
+};

package/dist/geometry/math/vector3.js

@@ -1,3 +1,4 @@
+import { GeometryError } from "../errors.js";
 /**
  * Adds two finite XYZ vectors component-wise.
  * @example
@@ -5,7 +6,11 @@
  * add3([1, 2, 3], [4, 5, 6]); // [5, 7, 9]
  * ```
  */
-export const add3 = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+export const add3 = (a, b) => [
+    a[0] + b[0],
+    a[1] + b[1],
+    a[2] + b[2],
+];
 /**
  * Subtracts `b` from `a`.
  * @example
@@ -52,23 +57,48 @@ export const cross3 = (a, b) => [
 ];
 /** Returns Euclidean vector length in the vector's coordinate units. */
 export const length3 = (vector) => Math.hypot(vector[0], vector[1], vector[2]);
-/** Normalizes a finite vector and rejects nonfinite lengths or lengths at or below `epsilon`. */
+/** 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`).
+ * Rejects invalid thresholds, nonfinite lengths, and lengths at or below the threshold with
+ * `INVALID_TOLERANCE`, `NON_FINITE_VALUE`, and `DEGENERATE_GEOMETRY` respectively.
+ */
 export const normalize3 = (vector, epsilon = 1e-12) => {
+    const operation = "normalize3";
+    if (!Number.isFinite(epsilon) || epsilon < 0) {
+        throw new GeometryError("INVALID_TOLERANCE", "epsilon must be finite and non-negative.", {
+            operation,
+        });
+    }
     const length = length3(vector);
     if (!Number.isFinite(length)) {
-        throw new Error("Cannot normalize a vector without finite length.");
+        throw new GeometryError("NON_FINITE_VALUE", "Cannot normalize a vector without finite length.", {
+            operation,
+        });
     }
     if (length <= epsilon) {
-        throw new Error("Cannot normalize a zero-length vector.");
+        throw new GeometryError("DEGENERATE_GEOMETRY", "Cannot normalize a zero-length vector.", {
+            operation,
+        });
+    }
+    // Subnormal lengths lose relative precision; rescale only this rare case before division.
+    if (length < 2 ** -1022) {
+        const maximum = Math.max(Math.abs(vector[0]), Math.abs(vector[1]), Math.abs(vector[2]));
+        const x = vector[0] / maximum;
+        const y = vector[1] / maximum;
+        const z = vector[2] / maximum;
+        const scaledLength = Math.hypot(x, y, z);
+        return [x / scaledLength, y / scaledLength, z / scaledLength];
     }
-    return scale3(vector, 1 / length);
+    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. */
 export const projectOntoPlane3 = (vector, normal) => subtract3(vector, scale3(normal, dot3(vector, normal)));
-/** Rotates a vector right-handed around an axis by `angle` radians. */
-export const rotateAroundAxis3 = (vector, axis, angle) => {
+/** Rotates a vector right-handed around a unit axis by `angle` radians. */
+export const rotateAroundAxis3Radians = (vector, axis, angle) => {
     const cosine = Math.cos(angle);
     const sine = Math.sin(angle);
     return add3(add3(scale3(vector, cosine), scale3(cross3(axis, vector), sine)), scale3(axis, dot3(axis, vector) * (1 - cosine)));

package/dist/geometry/mechanical/gear-motion.js

@@ -50,7 +50,8 @@ const multiPolygonArea = (multiPolygon) => multiPolygon.reduce((total, polygon)
 /**
  * Measures sampled kinematic interference over one tooth cycle of an internal gear pair.
  *
- * The driver and ring rotate in the same direction at their resolved tooth-count ratio. Each
+ * The driver and ring start with half-tooth offsets for odd tooth counts, then rotate in the
+ * same direction at their resolved tooth-count ratio. Each
  * sampled pinion outline is subtracted from the ring's center-and-space opening; remaining area is
  * solid overlap. This catches involute, tip, and trimming interference that a single assembled pose
  * misses. It is a deterministic model check, not a certified gear-rating calculation.
@@ -71,11 +72,13 @@ export function measureInternalCylindricalGearPairMotion(spec, options = {}) {
     const ringTipRadius = pair.driven.pitchRadius - pair.driven.addendum;
     const contactWindow = contactWindowPolygon(pair.centerDistance, pair.driver.outsideRadius, ringTipRadius);
     const initialRingPhase = pair.driven.toothCount % 2 === 0 ? 0 : pair.driven.angularPitch / 2;
+    const initialDriverPhase = pair.driver.toothCount % 2 === 0 ? 0 : pair.driver.angularPitch / 2;
     let maximumOverlapArea = 0;
-    let maximumPhase = 0;
+    let maximumPhase = initialDriverPhase;
     for (let sample = 0; sample < samples; sample += 1) {
-        const driverPhase = (pair.driver.angularPitch * sample) / samples;
-        const drivenPhase = initialRingPhase + driverPhase / pair.ratio;
+        const phase = (pair.driver.angularPitch * sample) / samples;
+        const driverPhase = initialDriverPhase + phase;
+        const drivenPhase = initialRingPhase + phase / pair.ratio;
         const posedDriver = clippingPolygon(transformedLoop(driver, driverPhase));
         const posedSpace = clippingPolygon(transformedLoop(ringSpace, drivenPhase, pair.centerDistance));
         const contactDriver = polygonClipping.intersection(posedDriver, contactWindow);

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

@@ -1,4 +1,8 @@
-const subtract = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const subtract = (a, b) => [
+    a[0] - b[0],
+    a[1] - b[1],
+    a[2] - b[2],
+];
 const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 const cross = (a, b) => [
     a[1] * b[2] - a[2] * b[1],

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

@@ -0,0 +1,74 @@
+import { GeometryError } from "../errors.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
+export function closestPointOnPath(path, point, options = {}) {
+    const fail = (message, code = "INVALID_ARGUMENT") => {
+        throw new GeometryError(code, message, { operation: "closestPointOnPath" });
+    };
+    const dimensions = point.length;
+    const closed = options.closed ?? false;
+    if (typeof closed !== "boolean" || (dimensions !== 2 && dimensions !== 3))
+        fail("Use a 2D or 3D point and a boolean closed option.");
+    assertSamplingCount(path.length, "closestPointOnPath", resolveGeometrySamplingLimits(options.limits).maxPathPoints);
+    if (path.length < (closed ? 3 : 2))
+        fail("Open paths need two points; closed paths need three.");
+    const validate = (value) => {
+        if (value.length !== dimensions)
+            fail("Path and query points must have the same dimension.");
+        if (!Number.isFinite(value[0]) ||
+            !Number.isFinite(value[1]) ||
+            (dimensions === 3 && !Number.isFinite(value[2])))
+            fail("Path and query coordinates must be finite.", "NON_FINITE_VALUE");
+    };
+    validate(point);
+    validate(path[0]);
+    let bestDistance = Infinity, bestSquared = Infinity, edgeIndex = 0, fraction = 0;
+    let bestX = 0, bestY = 0, bestZ = 0;
+    const count = closed ? path.length : path.length - 1;
+    for (let i = 0; i < count; i++) {
+        const a = path[i], b = path[(i + 1) % path.length];
+        validate(b);
+        const dx = b[0] - a[0], dy = b[1] - a[1], dz = (b[2] ?? 0) - (a[2] ?? 0);
+        const px = point[0] - a[0], py = point[1] - a[1], pz = (point[2] ?? 0) - (a[2] ?? 0);
+        const lengthSquared = dx * dx + dy * dy + dz * dz;
+        let projection = (px * dx + py * dy + pz * dz) / lengthSquared;
+        if (!Number.isFinite(projection)) {
+            // Normalize only extreme extents; ordinary boundary scans use scalar squared arithmetic.
+            const scale = Math.max(Math.abs(dx), Math.abs(dy), Math.abs(dz));
+            if (!Number.isFinite(scale))
+                fail("Path extent exceeds finite arithmetic.", "NON_FINITE_VALUE");
+            if (scale === 0)
+                projection = 0;
+            else {
+                const ux = dx / scale, uy = dy / scale, uz = dz / scale;
+                const denominator = ux * ux + uy * uy + uz * uz;
+                projection =
+                    (px * (ux / denominator) + py * (uy / denominator) + pz * (uz / denominator)) / scale;
+            }
+        }
+        const t = Math.max(0, Math.min(1, projection));
+        const x = a[0] + t * dx, y = a[1] + t * dy, z = (a[2] ?? 0) + t * dz;
+        const rx = point[0] - x, ry = point[1] - y, rz = (point[2] ?? 0) - z;
+        const squared = rx * rx + ry * ry + rz * rz;
+        if (squared > 0 && Number.isFinite(squared) && squared >= bestSquared)
+            continue;
+        const distance = squared > 0 && Number.isFinite(squared) ? Math.sqrt(squared) : Math.hypot(rx, ry, rz);
+        if (!Number.isFinite(distance))
+            fail("Path distance exceeds finite arithmetic.", "NON_FINITE_VALUE");
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            bestSquared = squared;
+            edgeIndex = i;
+            fraction = t;
+            bestX = x;
+            bestY = y;
+            bestZ = z;
+        }
+    }
+    const position = dimensions === 2 ? [bestX, bestY] : [bestX, bestY, bestZ];
+    return Object.freeze({
+        point: Object.freeze(position),
+        distance: bestDistance,
+        edgeIndex,
+        fraction,
+    });
+}

package/dist/geometry/paths/frames.js

@@ -1,4 +1,4 @@
-import { cross3, dot3, length3, normalize3, projectOntoPlane3, rotateAroundAxis3, scale3, subtract3, } from "../math/vector3.js";
+import { cross3, dot3, length3, normalize3, projectOntoPlane3, rotateAroundAxis3Radians, scale3, subtract3, } from "../math/vector3.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
 const tangentAt = (path, index) => {
     if (index === 0) {
@@ -32,7 +32,7 @@ const transportNormal = (normal, previousTangent, tangent) => {
     if (sine > 1e-10) {
         const axis = scale3(rotationAxis, 1 / sine);
         const cosine = Math.max(-1, Math.min(1, dot3(previousTangent, tangent)));
-        transported = rotateAroundAxis3(normal, axis, Math.atan2(sine, cosine));
+        transported = rotateAroundAxis3Radians(normal, axis, Math.atan2(sine, cosine));
     }
     return normalize3(projectOntoPlane3(transported, tangent));
 };
@@ -107,7 +107,7 @@ export const computeClosedParallelTransportFrames = (path, initialNormal, limits
     const seamCorrection = signedAngleAround(seamNormal, transportedNormals[0], tangents[0]);
     return tangents.map((tangent, index) => {
         const correction = (seamCorrection * index) / path.length;
-        const normal = normalize3(projectOntoPlane3(rotateAroundAxis3(transportedNormals[index], tangent, correction), tangent));
+        const normal = normalize3(projectOntoPlane3(rotateAroundAxis3Radians(transportedNormals[index], tangent, correction), tangent));
         return {
             tangent,
             normal,

package/dist/geometry/primitive-resolution.js

@@ -8,7 +8,10 @@ import { assertSamplingCount, resolveGeometrySamplingLimits } from "./sampling-l
  */
 export function resolveCircularPrimitiveSegments(radius, options, operation) {
     if (options.segments === undefined) {
-        return resolveCircularSegments(radius, options.resolution, options.limits);
+        return resolveCircularSegments(radius, {
+            ...options.resolution,
+            sizing: options.sizing ?? "vertex",
+        }, options.limits);
     }
     if (!Number.isSafeInteger(options.segments) || options.segments < 3)
         throw new GeometryError("INVALID_ARGUMENT", "segments must be a safe integer of at least three.", { operation, details: { value: options.segments } });

package/dist/geometry/resolution.js

@@ -55,12 +55,17 @@ export function resolveGeometryResolution(policy = {}, limits = {}) {
         minimumSegments,
     });
 }
-const requiredFullCircleSegments = (radius, resolution) => {
-    const chordAngle = 2 * Math.acos(Math.max(-1, Math.min(1, 1 - resolution.maxChordError / radius)));
+const requiredFullCircleSegments = (radius, resolution, sizing) => {
+    const chordAngle = 2 *
+        Math.acos(sizing === "face"
+            ? 1 / (1 + resolution.maxChordError / radius)
+            : Math.max(-1, Math.min(1, 1 - resolution.maxChordError / radius)));
     const chordSegments = chordAngle === 0 ? Number.POSITIVE_INFINITY : Math.ceil((Math.PI * 2) / chordAngle);
     const lengthSegments = resolution.maxSegmentLength === undefined
         ? 0
-        : Math.ceil((Math.PI * 2 * radius) / resolution.maxSegmentLength);
+        : sizing === "face"
+            ? Math.ceil(Math.PI / Math.atan(resolution.maxSegmentLength / radius / 2))
+            : Math.ceil((Math.PI * 2 * radius) / resolution.maxSegmentLength);
     return Math.max(resolution.minimumSegments, chordSegments, lengthSegments);
 };
 const assertRadius = (radius, operation) => {
@@ -75,7 +80,8 @@ const assertRadius = (radius, operation) => {
  * Resolves a deterministic full-circle segment count for one radius.
  *
  * An exact `circularSegments` value wins. Otherwise the smallest regular polygon satisfying both
- * physical error criteria is used. A safety cap that would violate either criterion raises
+ * physical error criteria is used. Face sizing bounds the circumscribed polygon's outward
+ * excess and actual edge length. A safety cap that would violate either criterion raises
  * `COMPLEXITY_LIMIT` rather than silently reducing quality.
  *
  * @param radius - Circle radius in millimetres.
@@ -94,10 +100,13 @@ const assertRadius = (radius, operation) => {
 export function resolveCircularSegments(radius, policy = {}, limits = {}) {
     const operation = "resolveCircularSegments";
     assertRadius(radius, operation);
+    const sizing = policy.sizing ?? "vertex";
+    if (sizing !== "vertex" && sizing !== "face")
+        invalid("sizing must be vertex or face.");
     const resolution = resolveGeometryResolution(policy, limits);
     if (resolution.circularSegments !== undefined)
         return resolution.circularSegments;
-    const required = requiredFullCircleSegments(radius, resolution);
+    const required = requiredFullCircleSegments(radius, resolution, sizing);
     if (required > resolution.maximumSegments) {
         throw new GeometryError("COMPLEXITY_LIMIT", `The requested physical curve tolerance requires ${required} segments, above the ${resolution.maximumSegments}-segment safety limit.`, {
             operation,
@@ -151,6 +160,8 @@ const checkedLeastCommonMultiple = (left, right, operation) => {
 export function resolveAlignedCircularSegments(radius, options) {
     const operation = "resolveAlignedCircularSegments";
     assertRadius(radius, operation);
+    if (options.sizing !== undefined && options.sizing !== "vertex" && options.sizing !== "face")
+        invalid("sizing must be vertex or face.");
     const alignTo = options.alignTo;
     const hasArrayShape = Array.isArray(alignTo);
     if (!hasArrayShape || alignTo.length === 0) {
@@ -186,6 +197,7 @@ export function resolveAlignedCircularSegments(radius, options) {
     }
     const baseSegments = resolveCircularSegments(radius, {
         ...resolution,
+        sizing: options.sizing ?? "vertex",
     }, options.limits);
     const requiredSegments = Math.max(baseSegments, minimumSegments);
     const multiplier = Math.ceil(requiredSegments / alignment);

package/dist/geometry/stroke-path.js

@@ -23,10 +23,7 @@ function ellipsePoints(center, radius, segments) {
         return [center[0] + Math.cos(angle) * radius, center[1] + Math.sin(angle) * radius];
     });
 }
-function circlePolygon(center, radius, segments) {
-    return [ring(ellipsePoints(center, radius, segments))];
-}
-function cornerPolygon(previous, point, next, halfWidth, join) {
+function cornerContour(previous, point, next, halfWidth, join) {
     const incomingLength = Math.hypot(point[0] - previous[0], point[1] - previous[1]);
     const outgoingLength = Math.hypot(next[0] - point[0], next[1] - point[1]);
     const incoming = [
@@ -54,11 +51,13 @@ function cornerPolygon(previous, point, next, halfWidth, join) {
         ]);
     }
     points.push([point[0] + after[0], point[1] + after[1]]);
-    return [ring(points)];
+    return turn > 0 ? points : points.reverse();
 }
 /** Removes consecutive points that cannot define a visible stroke segment at model scale. */
 function deduplicatePath(path, closed, width) {
-    const scale = Math.max(width, ...path.flatMap(([x, y]) => [Math.abs(x), Math.abs(y)]));
+    let scale = width;
+    for (const [x, y] of path)
+        scale = Math.max(scale, Math.abs(x), Math.abs(y));
     const tolerance = resolveGeometryTolerance(scale).linear;
     const points = [];
     for (const point of path) {
@@ -76,11 +75,27 @@ function deduplicatePath(path, closed, width) {
     }
     return Object.freeze(points);
 }
-/** @internal Polygon-clipping representation shared with the bounded SVG importer. */
-export function strokePathMultiPolygon(path, options, circularSegments) {
+/** @internal Bounded CCW stroke primitives shared by native sections and pure clipping. */
+export function strokePathContours(path, options, exactCircularSegments) {
     const closed = options.closed ?? false;
     const cap = options.cap ?? "butt";
     const join = options.join ?? "miter";
+    if (typeof closed !== "boolean")
+        return fail("closed must be a boolean.");
+    if (!Number.isFinite(options.width) || options.width <= 0)
+        return fail("Stroke width must be finite and greater than zero.");
+    if (path.length < (closed ? 3 : 2))
+        return fail(`${closed ? "Closed" : "Open"} strokes need more sampled path points.`);
+    if (!path.every((point) => point.length === 2 && point.every(Number.isFinite)))
+        return fail("Stroke path coordinates must be finite XY points.");
+    if (!["butt", "round", "square"].includes(cap))
+        return fail("Stroke cap must be butt, round, or square.");
+    if (!["bevel", "miter", "round"].includes(join))
+        return fail("Stroke join must be bevel, miter, or round.");
+    const circularSegments = exactCircularSegments ??
+        (cap === "round" || join === "round"
+            ? resolveCircularSegments(options.width / 2, options.resolution, options.limits)
+            : 3);
     const half = options.width / 2;
     const limits = resolveGeometrySamplingLimits(options.limits);
     assertSamplingCount(path.length, "strokePathRegion", limits.maxPathPoints);
@@ -88,7 +103,7 @@ export function strokePathMultiPolygon(path, options, circularSegments) {
     const normalizedPath = deduplicatePath(path, closed, options.width);
     if (normalizedPath.length < (closed ? 3 : 2))
         return [];
-    const polygons = [];
+    const contours = [];
     const segmentCount = closed ? normalizedPath.length : normalizedPath.length - 1;
     const joinCount = closed ? normalizedPath.length : Math.max(0, normalizedPath.length - 2);
     const constructionVertices = segmentCount * 4 +
@@ -108,34 +123,44 @@ export function strokePathMultiPolygon(path, options, circularSegments) {
             }
         }
         const normal = [-tangent[1] * half, tangent[0] * half];
-        polygons.push([
-            ring([
-                [start[0] + normal[0], start[1] + normal[1]],
-                [end[0] + normal[0], end[1] + normal[1]],
-                [end[0] - normal[0], end[1] - normal[1]],
-                [start[0] - normal[0], start[1] - normal[1]],
-            ]),
+        contours.push([
+            [start[0] - normal[0], start[1] - normal[1]],
+            [end[0] - normal[0], end[1] - normal[1]],
+            [end[0] + normal[0], end[1] + normal[1]],
+            [start[0] + normal[0], start[1] + normal[1]],
         ]);
     }
+    const disk = join === "round" || (!closed && cap === "round")
+        ? ellipsePoints([0, 0], half, circularSegments)
+        : [];
+    const circleAt = ([x, y]) => disk.map(([u, v]) => [x + u, y + v]);
     if (join === "round") {
         const joinPoints = closed ? normalizedPath : normalizedPath.slice(1, -1);
-        polygons.push(...joinPoints.map((point) => circlePolygon(point, half, circularSegments)));
+        for (const point of joinPoints)
+            contours.push(circleAt(point));
     }
     else {
         const first = closed ? 0 : 1;
         const end = closed ? normalizedPath.length : normalizedPath.length - 1;
         for (let index = first; index < end; index += 1) {
-            const corner = cornerPolygon(normalizedPath[(index - 1 + normalizedPath.length) % normalizedPath.length], normalizedPath[index], normalizedPath[(index + 1) % normalizedPath.length], half, join);
+            const corner = cornerContour(normalizedPath[(index - 1 + normalizedPath.length) % normalizedPath.length], normalizedPath[index], normalizedPath[(index + 1) % normalizedPath.length], half, join);
             if (corner !== undefined)
-                polygons.push(corner);
+                contours.push(corner);
         }
     }
     if (!closed && cap === "round") {
-        polygons.push(circlePolygon(normalizedPath[0], half, circularSegments), circlePolygon(normalizedPath.at(-1), half, circularSegments));
+        contours.push(circleAt(normalizedPath[0]), circleAt(normalizedPath.at(-1)));
     }
-    const result = unionPolygonGeometry(polygons);
+    return contours;
+}
+/** @internal Polygon-clipping representation shared with the bounded SVG importer. */
+export function strokePathMultiPolygon(path, options, circularSegments) {
+    const contours = strokePathContours(path, options, circularSegments);
+    if (contours.length === 0)
+        return [];
+    const result = unionPolygonGeometry(contours.map((contour) => [ring(contour)]));
     const outputVertices = result.reduce((count, polygon) => count + polygon.reduce((total, contour) => total + Math.max(0, contour.length - 1), 0), 0);
-    assertSamplingCount(outputVertices, "strokePathRegion", limits.maxProfilePoints);
+    assertSamplingCount(outputVertices, "strokePathRegion", resolveGeometrySamplingLimits(options.limits).maxProfilePoints);
     return result;
 }
 function regionFromMultiPolygon(value) {
@@ -153,28 +178,7 @@ function regionFromMultiPolygon(value) {
  * intersection, falling back to bevels above SVG's default miter limit of 4.
  */
 export function strokePathRegion(path, options) {
-    const closed = options.closed ?? false;
-    if (!Number.isFinite(options.width) || options.width <= 0) {
-        return fail("Stroke width must be finite and greater than zero.");
-    }
-    if (path.length < (closed ? 3 : 2)) {
-        return fail(`${closed ? "Closed" : "Open"} strokes need more sampled path points.`);
-    }
-    if (!path.every((point) => Number.isFinite(point[0]) && Number.isFinite(point[1]))) {
-        return fail("Stroke path coordinates must be finite.");
-    }
-    const cap = options.cap ?? "butt";
-    const join = options.join ?? "miter";
-    if (!["butt", "round", "square"].includes(cap)) {
-        return fail("Stroke cap must be butt, round, or square.");
-    }
-    if (!["bevel", "miter", "round"].includes(join)) {
-        return fail("Stroke join must be bevel, miter, or round.");
-    }
-    const circularSegments = cap === "round" || join === "round"
-        ? resolveCircularSegments(options.width / 2, options.resolution, options.limits)
-        : 3;
-    const result = strokePathMultiPolygon(path, { ...options, cap, closed, join }, circularSegments);
+    const result = strokePathMultiPolygon(path, options);
     if (result.length === 0)
         return fail("The sampled stroke path has no visible length.");
     return regionFromMultiPolygon(result);

package/dist/geometry/sweeps/stations.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../errors.js";
-import { cross3, dot3, lerp3, normalize3, rotateAroundAxis3 } from "../math/vector3.js";
+import { cross3, dot3, lerp3, normalize3, rotateAroundAxis3Radians } 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. */
@@ -144,9 +144,9 @@ export function refineSweepStations(path, scales, frames, options, plan) {
             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),
+                    normal: rotateAroundAxis3Radians(frames[i].normal, rotation.axis, rotation.angle * amount),
+                    binormal: rotateAroundAxis3Radians(frames[i].binormal, rotation.axis, rotation.angle * amount),
+                    tangent: rotateAroundAxis3Radians(frames[i].tangent, rotation.axis, rotation.angle * amount),
                 });
             twists.push(twist * (plan.progress[i] + (plan.progress[i + 1] - plan.progress[i]) * amount));
         }

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

@@ -1,5 +1,5 @@
 import { GeometryError } from "../errors.js";
-import { add3, rotateAroundAxis3, scale3 } from "../math/vector3.js";
+import { add3, rotateAroundAxis3Radians, scale3 } from "../math/vector3.js";
 import { validateTriangleMesh } from "../mesh/mesh.js";
 import { resolveGeometryTolerance } from "../tolerance.js";
 import { resolveSweepScales } from "./options.js";
@@ -63,8 +63,8 @@ export const buildClosedSweepMesh = (profile, path, options = {}) => {
         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 normal = rotateAroundAxis3Radians(baseNormal, tangent, twist);
+        const binormal = rotateAroundAxis3Radians(transportedFrames[ring].binormal, tangent, twist);
         const [scaleX, scaleY] = scales[ring];
         for (let profileIndex = 0; profileIndex < profile.length; profileIndex += 1) {
             const [x, y] = profile[profileIndex];

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

@@ -1,5 +1,5 @@
 import { triangulateContour } from "../loft/loft.js";
-import { add3, rotateAroundAxis3, scale3 } from "../math/vector3.js";
+import { add3, rotateAroundAxis3Radians, scale3 } from "../math/vector3.js";
 import { validateTriangleMesh } from "../mesh/mesh.js";
 import { resolveSweepScales } from "./options.js";
 import { computeSweepFrames, validateSweepOptions } from "./orientation.js";
@@ -37,8 +37,8 @@ export const buildOpenSweepMesh = (profile, path, options = {}) => {
         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 normal = rotateAroundAxis3Radians(frame.normal, frame.tangent, twist);
+        const binormal = rotateAroundAxis3Radians(frame.binormal, frame.tangent, twist);
         const [scaleX, scaleY] = scales[ring];
         for (let profileIndex = 0; profileIndex < profile.length; profileIndex += 1) {
             const [x, y] = profile[profileIndex];