@metamesh/modeling 0.13.0 → 0.15.0

package/dist/geometry/profiles/contour.js

@@ -16,7 +16,7 @@ function invalid(message) {
  * coordinate range are required. No native engine, SDK, or ambient resolution is used.
  *
  * @param curve - Closed contour in millimetres unless positive scales convert its coordinates.
- * @param options - Physical resolution and unique vertex budget; defaults to 4096 vertices.
+ * @param options - Physical resolution and unique vertex budget; defaults to min(4096, maxProfilePoints).
  * @returns Frozen counterclockwise loop in millimetres, without a repeated seam endpoint.
  * @throws {@link GeometryError} for invalid data, topology, scale, or exceeded sampling budgets.
  *
@@ -38,8 +38,8 @@ export function sampleContour(curve, options = {}) {
     if (![widthScale, heightScale].every((scale) => Number.isFinite(scale) && scale > 0))
         invalid("Cross-section scales must be finite and positive.");
     const limits = resolveGeometrySamplingLimits(options.limits);
-    const maximumVertices = options.maximumVertices ?? Math.min(4096, limits.maxProfilePoints);
-    requireProfileVertexCount(maximumVertices, 3, OPERATION, limits);
+    const maxVertices = options.maxVertices ?? Math.min(4096, limits.maxProfilePoints);
+    requireProfileVertexCount(maxVertices, 3, OPERATION, limits);
     const segmentInput = curve?.segments;
     if (!curve ||
         !Array.isArray(segmentInput) ||
@@ -66,11 +66,11 @@ export function sampleContour(curve, options = {}) {
             invalid("Cross-section segments must be lines or cubics.");
         const end = physical(segment.end);
         const closed = index === curve.segments.length - 1;
-        const remainingVertices = Math.min(limits.maxPathPoints, maximumVertices - output.length + 1 + (closed ? 1 : 0));
+        const remainingVertices = Math.min(limits.maxPathPoints, maxVertices - output.length + 1 + (closed ? 1 : 0));
         if (remainingVertices < 2)
             throw new GeometryError("COMPLEXITY_LIMIT", "Cross-section sampling exceeds its vertex budget.", {
                 operation: OPERATION,
-                details: { maximumVertices },
+                details: { maxVertices },
             });
         let span;
         if (segment.type === "line") {
@@ -90,7 +90,7 @@ export function sampleContour(curve, options = {}) {
         }
         const sampled = sampleCurve2(span, {
             ...(options.resolution === undefined ? {} : { resolution: options.resolution }),
-            maximumVertices: remainingVertices,
+            maxVertices: remainingVertices,
             limits,
         }).points;
         const endIndex = sampled.length - (closed ? 1 : 0);

package/dist/geometry/profiles/matched.js

@@ -39,10 +39,10 @@ const validateContour = (contour) => {
         }
         else if (span.kind === "arc") {
             point(span.center);
-            if (![span.radius, span.startDegrees, span.sweepDegrees].every(Number.isFinite) ||
+            if (![span.radius, span.startAngle, span.sweepAngle].every(Number.isFinite) ||
                 span.radius < 0 ||
-                Math.abs(span.sweepDegrees) > 360 ||
-                span.sweepDegrees === 0)
+                Math.abs(span.sweepAngle) > 360 ||
+                span.sweepAngle === 0)
                 fail("Arc spans need nonnegative radius and a nonzero finite sweep no larger than 360 degrees.");
         }
         else
@@ -132,7 +132,7 @@ export function matchProfiles(profiles, options = {}) {
             if (span.kind === "arc")
                 return span.radius === 0
                     ? 1
-                    : resolveArcSegments(span.radius, Math.abs(span.sweepDegrees), selectedResolution, limits);
+                    : resolveArcSegments(span.radius, Math.abs(span.sweepAngle), selectedResolution, limits);
             if (span.kind === "cubic")
                 return resolveUniformCubicSegments(planarCubicControl(span), selectedResolution, cubicBudget);
             return resolveLineSegmentCount(Math.hypot(span.end[0] - span.start[0], span.end[1] - span.start[1]), selectedResolution.maxSegmentLength);

package/dist/geometry/profiles/profiles.js

@@ -49,8 +49,8 @@ export const circleContour = (options) => {
  */
 export const regularPolygonContour = (options) => {
     const operation = "regularPolygonContour";
-    const { radius, sides, rotationDegrees = 0, sizing = "vertex" } = options;
-    requireFiniteProfileValues([radius, rotationDegrees], operation);
+    const { radius, sides, rotation = 0, sizing = "vertex" } = options;
+    requireFiniteProfileValues([radius, rotation], operation);
     if (!(radius > 0)) {
         throw new GeometryError("INVALID_ARGUMENT", "Polygon radius must be positive.", { operation });
     }
@@ -61,9 +61,9 @@ export const regularPolygonContour = (options) => {
         });
     const sampledRadius = sizing === "face" ? radius / Math.cos(Math.PI / sides) : radius;
     requireFiniteProfileValues([sampledRadius], operation);
-    const rotation = ((rotationDegrees % 360) * Math.PI) / 180;
+    const rotationRadians = ((rotation % 360) * Math.PI) / 180;
     return Array.from({ length: sides }, (_, index) => {
-        const angle = rotation + (Math.PI * 2 * index) / sides;
+        const angle = rotationRadians + (Math.PI * 2 * index) / sides;
         return [sampledRadius * Math.cos(angle), sampledRadius * Math.sin(angle)];
     });
 };

package/dist/geometry/profiles/rectangle.js

@@ -72,7 +72,7 @@ export function rectangleCornerSegments(corner, limits) {
         return 1;
     return (resolveAlignedCircularSegments(Math.max(corner.radius, Number.MIN_VALUE), {
         alignTo: [4],
-        minimumSegments: 4,
+        minSegments: 4,
         ...(corner.segments === undefined ? {} : { segments: corner.segments }),
         ...(corner.resolution === undefined ? {} : { resolution: corner.resolution }),
         limits: selected,
@@ -194,7 +194,7 @@ export function rectangleProfile(options) {
         center: map(index, a, b),
     }));
     corners.forEach((corner, index) => {
-        const shape = endpoints[index], startDegrees = vertices[index][2];
+        const shape = endpoints[index], startAngle = vertices[index][2];
         if (corner.kind === "chamfer")
             spans.push({ id: names[index], kind: "line", start: shape.start, end: shape.end });
         else if (corner.kind === "smooth") {
@@ -230,8 +230,8 @@ export function rectangleProfile(options) {
                 kind: "arc",
                 center: shape.center,
                 radius: setbacks[index][0],
-                startDegrees,
-                sweepDegrees: 90,
+                startAngle,
+                sweepAngle: 90,
                 ...(exact ? { segments: rectangleCornerSegments(corner, limits) } : {}),
                 ...(corner.kind === "round" && corner.resolution !== undefined
                     ? { resolution: { ...corner.resolution } }

package/dist/geometry/profiles/side-profile.js

@@ -30,7 +30,7 @@ function distanceToChord(point, start, end) {
  * no axis closure, winding normalization, or manufacturing repair is performed.
  *
  * @param curve - Open outline in millimetres unless the positive scales convert its coordinates.
- * @param options - Physical resolution and output budget; defaults to 4096 vertices.
+ * @param options - Physical resolution and output budget; defaults to min(4096, maxProfilePoints).
  * @returns Frozen open polyline in millimetres, ordered from lowest to highest anchor.
  * @throws {@link GeometryError} for invalid coordinates, order, scale, or exceeded subdivision budget.
  *
@@ -48,9 +48,9 @@ export function sampleSideProfile(curve, options = {}) {
     if (![radiusScale, heightScale].every((scale) => Number.isFinite(scale) && scale > 0)) {
         invalid("Profile scales must be finite and positive.");
     }
-    const maximumVertices = options.maximumVertices ??
+    const maxVertices = options.maxVertices ??
         Math.min(4096, resolveGeometrySamplingLimits(options.limits).maxProfilePoints);
-    requireProfileVertexCount(maximumVertices, 2, OPERATION, options.limits);
+    requireProfileVertexCount(maxVertices, 2, OPERATION, options.limits);
     const maximumProfilePoints = resolveGeometrySamplingLimits(options.limits).maxProfilePoints;
     const segmentInput = curve.segments;
     if (!Array.isArray(segmentInput) ||
@@ -72,10 +72,10 @@ export function sampleSideProfile(curve, options = {}) {
     };
     const output = [];
     const append = (point) => {
-        if (output.length >= maximumVertices || output.length >= maximumProfilePoints) {
+        if (output.length >= maxVertices || output.length >= maximumProfilePoints) {
             throw new GeometryError("COMPLEXITY_LIMIT", "Profile sampling exceeds its vertex budget.", {
                 operation: OPERATION,
-                details: { maximumVertices },
+                details: { maxVertices },
             });
         }
         output.push(Object.freeze(point));
@@ -109,10 +109,10 @@ export function sampleSideProfile(curve, options = {}) {
             const count = resolution.maxSegmentLength === undefined
                 ? 1
                 : Math.max(1, Math.ceil(length / resolution.maxSegmentLength));
-            if (count > maximumVertices - output.length) {
+            if (count > maxVertices - output.length) {
                 throw new GeometryError("COMPLEXITY_LIMIT", "Profile line exceeds its vertex budget.", {
                     operation: OPERATION,
-                    details: { maximumVertices },
+                    details: { maxVertices },
                 });
             }
             for (let index = 1; index <= count; index++) {

package/dist/geometry/profiles/span-sampling.js

@@ -8,7 +8,7 @@ export function createProfileSpanSampler(span) {
         ];
     if (span.kind === "arc")
         return (t) => {
-            const angle = ((span.startDegrees + span.sweepDegrees * t) * Math.PI) / 180;
+            const angle = ((span.startAngle + span.sweepAngle * t) * Math.PI) / 180;
             const snap = (value) => Math.abs(value) < 1e-14
                 ? 0
                 : Math.abs(Math.abs(value) - 1) < 1e-14

package/dist/geometry/resolution.js

@@ -13,20 +13,20 @@ export function resolveGeometryResolution(policy = {}, limits = {}) {
     const merged = policy;
     const circularSegments = merged.circularSegments;
     const allowedMaximum = resolveGeometrySamplingLimits(limits).maxCircularSegments;
-    const minimumSegments = merged.minimumSegments ?? Math.min(DEFAULT_MINIMUM_SEGMENTS, allowedMaximum);
-    const maximumSegments = merged.maximumSegments ?? allowedMaximum;
+    const minSegments = merged.minSegments ?? Math.min(DEFAULT_MINIMUM_SEGMENTS, allowedMaximum);
+    const maxSegments = merged.maxSegments ?? allowedMaximum;
     const maxChordError = merged.maxChordError ?? DEFAULT_MAX_CHORD_ERROR;
     const maxSegmentLength = merged.maxSegmentLength;
-    if (!Number.isSafeInteger(minimumSegments) || minimumSegments < 3) {
-        invalid("minimumSegments must be an integer of at least three.", { minimumSegments });
+    if (!Number.isSafeInteger(minSegments) || minSegments < 3) {
+        invalid("minSegments must be an integer of at least three.", { minSegments });
     }
-    if (!Number.isSafeInteger(maximumSegments) ||
-        maximumSegments < minimumSegments ||
-        maximumSegments > allowedMaximum) {
-        invalid("maximumSegments must be a safe integer between minimumSegments and maxCircularSegments.", {
+    if (!Number.isSafeInteger(maxSegments) ||
+        maxSegments < minSegments ||
+        maxSegments > allowedMaximum) {
+        invalid("maxSegments must be a safe integer between minSegments and maxCircularSegments.", {
             allowedMaximum,
-            maximumSegments,
-            minimumSegments,
+            maxSegments,
+            minSegments,
         });
     }
     if (!Number.isFinite(maxChordError) || maxChordError <= 0) {
@@ -41,27 +41,32 @@ export function resolveGeometryResolution(policy = {}, limits = {}) {
     if (circularSegments !== undefined &&
         (!Number.isSafeInteger(circularSegments) ||
             circularSegments < 3 ||
-            circularSegments > maximumSegments)) {
-        invalid("circularSegments must be an integer from three through maximumSegments.", {
+            circularSegments > maxSegments)) {
+        invalid("circularSegments must be an integer from three through maxSegments.", {
             circularSegments,
-            maximumSegments,
+            maxSegments,
         });
     }
     return Object.freeze({
         ...(circularSegments === undefined ? {} : { circularSegments }),
         maxChordError,
         ...(maxSegmentLength === undefined ? {} : { maxSegmentLength }),
-        maximumSegments,
-        minimumSegments,
+        maxSegments,
+        minSegments,
     });
 }
-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);
-    return Math.max(resolution.minimumSegments, chordSegments, lengthSegments);
+        : sizing === "face"
+            ? Math.ceil(Math.PI / Math.atan(resolution.maxSegmentLength / radius / 2))
+            : Math.ceil((Math.PI * 2 * radius) / resolution.maxSegmentLength);
+    return Math.max(resolution.minSegments, chordSegments, lengthSegments);
 };
 const assertRadius = (radius, operation) => {
     if (!Number.isFinite(radius) || radius <= 0) {
@@ -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,15 +100,18 @@ 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);
-    if (required > resolution.maximumSegments) {
-        throw new GeometryError("COMPLEXITY_LIMIT", `The requested physical curve tolerance requires ${required} segments, above the ${resolution.maximumSegments}-segment safety limit.`, {
+    const required = requiredFullCircleSegments(radius, resolution, sizing);
+    if (required > resolution.maxSegments) {
+        throw new GeometryError("COMPLEXITY_LIMIT", `The requested physical curve tolerance requires ${required} segments, above the ${resolution.maxSegments}-segment safety limit.`, {
             operation,
             details: {
-                maximumSegments: resolution.maximumSegments,
+                maxSegments: resolution.maxSegments,
                 radius,
                 requiredSegments: required,
             },
@@ -133,7 +142,7 @@ const checkedLeastCommonMultiple = (left, right, operation) => {
  * `alignTo` must be non-empty and contain only positive safe integers. Its checked least common
  * multiple defines the alignment grid. An exact `segments` value wins over
  * `resolution.circularSegments` and adaptive sampling, but is never rounded: it must already be
- * aligned and meet `minimumSegments`. Adaptive counts are rounded upward and fail with
+ * aligned and meet `minSegments`. Adaptive counts are rounded upward and fail with
  * `COMPLEXITY_LIMIT` when the aligned result exceeds the configured safety cap.
  *
  * @param radius - Positive circle radius in millimetres used for adaptive physical sampling.
@@ -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) {
@@ -165,9 +176,9 @@ export function resolveAlignedCircularSegments(radius, options) {
         }
         alignment = checkedLeastCommonMultiple(alignment, factor, operation);
     }
-    const minimumSegments = options.minimumSegments ?? 3;
-    if (!Number.isSafeInteger(minimumSegments) || minimumSegments < 3) {
-        throw new GeometryError("INVALID_ARGUMENT", "minimumSegments must be a safe integer of at least three.", { operation, details: { minimumSegments } });
+    const minSegments = options.minSegments ?? 3;
+    if (!Number.isSafeInteger(minSegments) || minSegments < 3) {
+        throw new GeometryError("INVALID_ARGUMENT", "minSegments must be a safe integer of at least three.", { operation, details: { minSegments } });
     }
     const resolution = options.segments === undefined
         ? resolveGeometryResolution(options.resolution, options.limits)
@@ -176,29 +187,30 @@ export function resolveAlignedCircularSegments(radius, options) {
         }, options.limits);
     if (resolution.circularSegments !== undefined) {
         const exactSegments = resolution.circularSegments;
-        if (exactSegments < minimumSegments || exactSegments % alignment !== 0) {
-            throw new GeometryError("INVALID_ARGUMENT", "The exact segment count must meet minimumSegments and every alignTo factor.", {
+        if (exactSegments < minSegments || exactSegments % alignment !== 0) {
+            throw new GeometryError("INVALID_ARGUMENT", "The exact segment count must meet minSegments and every alignTo factor.", {
                 operation,
-                details: { alignment, exactSegments, minimumSegments },
+                details: { alignment, exactSegments, minSegments },
             });
         }
         return exactSegments;
     }
     const baseSegments = resolveCircularSegments(radius, {
         ...resolution,
+        sizing: options.sizing ?? "vertex",
     }, options.limits);
-    const requiredSegments = Math.max(baseSegments, minimumSegments);
+    const requiredSegments = Math.max(baseSegments, minSegments);
     const multiplier = Math.ceil(requiredSegments / alignment);
     if (!Number.isSafeInteger(multiplier) || multiplier > Number.MAX_SAFE_INTEGER / alignment) {
         throw new GeometryError("COMPLEXITY_LIMIT", "The aligned segment count exceeds safe integer complexity.", { operation, details: { alignment, requiredSegments } });
     }
     const alignedSegments = multiplier * alignment;
-    if (alignedSegments > resolution.maximumSegments) {
+    if (alignedSegments > resolution.maxSegments) {
         throw new GeometryError("COMPLEXITY_LIMIT", "Aligned circular tessellation exceeds the configured segment safety limit.", {
             operation,
             details: {
                 alignment,
-                maximumSegments: resolution.maximumSegments,
+                maxSegments: resolution.maxSegments,
                 requiredSegments,
                 segments: alignedSegments,
             },
@@ -213,7 +225,7 @@ export function resolveAlignedCircularSegments(radius, options) {
  * the reusable BOSL2-style convention while retaining at least one segment.
  *
  * @param radius - Arc radius in millimetres.
- * @param angleDegrees - Non-zero signed sweep angle no greater than 360 degrees in magnitude.
+ * @param angle - Non-zero signed sweep angle no greater than 360 degrees in magnitude.
  * @param policy - Optional operation-level policy over the active model scope.
  * @returns Segment count for the requested arc span.
  * @throws {@link GeometryError} when radius, angle, or resolution policy is invalid, or the
@@ -225,12 +237,12 @@ export function resolveAlignedCircularSegments(radius, options) {
  * const quarterTurnSegments = resolveArcSegments(10, 90);
  * ```
  */
-export function resolveArcSegments(radius, angleDegrees, policy = {}, limits = {}) {
+export function resolveArcSegments(radius, angle, policy = {}, limits = {}) {
     const operation = "resolveArcSegments";
     assertRadius(radius, operation);
-    if (!Number.isFinite(angleDegrees) || angleDegrees === 0 || Math.abs(angleDegrees) > 360) {
-        throw new GeometryError("INVALID_ARGUMENT", "angleDegrees must be finite, non-zero, and no greater than 360 degrees in magnitude.", { operation, details: { angleDegrees } });
+    if (!Number.isFinite(angle) || angle === 0 || Math.abs(angle) > 360) {
+        throw new GeometryError("INVALID_ARGUMENT", "angle must be finite, non-zero, and no greater than 360 degrees in magnitude.", { operation, details: { angle } });
     }
-    const ratio = Math.abs(angleDegrees) / 360;
+    const ratio = Math.abs(angle) / 360;
     return Math.max(1, Math.ceil(resolveCircularSegments(radius, policy, limits) * ratio));
 }

package/dist/geometry/revolve/revolve-mesh.js

@@ -3,6 +3,7 @@ import { triangulateContour } from "../loft/loft.js";
 import { validateTriangleMesh } from "../mesh/mesh.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../model-limits.js";
 import { writeMeshVertex } from "../numeric.js";
+import { path2InputData } from "../paths/path-value.js";
 import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
 import { normalizeContour } from "../regions.js";
 import { assertSamplingCount } from "../sampling-limits.js";
@@ -16,6 +17,7 @@ const AXIS_EPSILON = 1e-10;
  * vertices and zero-area quads. Profile edges that lie entirely on the axis
  * collapse to the solid's interior and are intentionally omitted.
  * Profile coordinates must fit finite Float32 mesh storage.
+ * Path2 profiles must be closed; raw point collections have an implicit closing edge.
  *
  * @param profile - Closed CCW `[radius, z]` profile without a duplicated seam point.
  * @param options - Optional physical or exact circumferential sampling controls. Defaults to `{}`.
@@ -24,28 +26,31 @@ const AXIS_EPSILON = 1e-10;
  * @example Partial revolution with end caps
  * ```ts
  * // Each point is [radius, Z]; the profile seam is implicit.
- * revolveMesh([[0, 0], [12, 0], [8, 20], [0, 20]], { revolveDegrees: 270 });
+ * revolveMesh([[0, 0], [12, 0], [8, 20], [0, 20]], { degrees: 270 });
  * ```
  */
-export const revolveMesh = (profile, options = {}) => {
+export const revolveMesh = (input, options = {}) => {
     if (typeof options !== "object" || options === null || Array.isArray(options))
         throw new GeometryError("INVALID_ARGUMENT", "Revolution options require an object.", {
             operation: "revolveMesh",
         });
-    const degrees = options.revolveDegrees ?? 360;
+    const degrees = options.degrees ?? 360;
     if (!Number.isFinite(degrees) || degrees <= 0 || degrees > 360)
-        throw new GeometryError("INVALID_ARGUMENT", "revolveDegrees must be in (0, 360].", {
+        throw new GeometryError("INVALID_ARGUMENT", "degrees must be in (0, 360].", {
             operation: "revolveMesh",
         });
+    const limits = resolveModelingLimits(options.limits);
+    let profile = path2InputData(input, true, { maxPathPoints: limits.maxProfilePoints }).points;
     if (profile.length < 3) {
-        throw new Error("A revolved profile needs at least three points.");
+        throw new GeometryError("DEGENERATE_GEOMETRY", "A revolved profile needs at least three points.", {
+            operation: "revolveMesh",
+        });
     }
-    const limits = resolveModelingLimits(options.limits);
     assertSamplingCount(profile.length, "revolveMesh", limits.maxProfilePoints);
     let maximumRadius = 0;
     for (const [radius, z] of profile) {
         if (!Number.isFinite(radius) || !Number.isFinite(z) || radius < 0) {
-            throw new Error("Revolved profile coordinates must be finite and radii non-negative.");
+            throw new GeometryError(Number.isFinite(radius) && Number.isFinite(z) ? "INVALID_ARGUMENT" : "NON_FINITE_VALUE", "Revolved profile coordinates must be finite and radii non-negative.", { operation: "revolveMesh" });
         }
         if (!Number.isFinite(Math.fround(radius)) || !Number.isFinite(Math.fround(z))) {
             throw new GeometryError("NON_FINITE_VALUE", "Revolved profile coordinates exceed finite Float32 mesh storage.", { operation: "revolveMesh" });

package/dist/geometry/stroke-path.js

@@ -1,21 +1,12 @@
 import { GeometryError } from "./errors.js";
-import { unionPolygonGeometry } from "./polygon-clipping.js";
-import { normalizeRegion } from "./regions.js";
+import { path2InputData } from "./paths/path-value.js";
+import { clippingRing, regionFromMultiPolygon, unionPolygonGeometry } from "./polygon-clipping.js";
 import { resolveCircularSegments } from "./resolution.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits, } from "./sampling-limits.js";
 import { resolveGeometryTolerance } from "./tolerance.js";
 const DEFAULT_MITER_LIMIT = 4;
 function fail(message) {
-    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "strokePathRegion" });
-}
-function ring(points) {
-    const result = points.map(([x, y]) => [x, y]);
-    const first = result[0];
-    const last = result.at(-1);
-    if (first !== undefined && last !== undefined && (first[0] !== last[0] || first[1] !== last[1])) {
-        result.push([...first]);
-    }
-    return result;
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "strokeRegionData" });
 }
 function ellipsePoints(center, radius, segments) {
     return Array.from({ length: segments }, (_, index) => {
@@ -23,10 +14,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 +42,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,25 +66,41 @@ 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) {
-    const closed = options.closed ?? false;
+/** @internal Bounded CCW stroke primitives shared by native sections and pure clipping. */
+export function strokePathContours(input, options, exactCircularSegments) {
+    const limits = resolveGeometrySamplingLimits(options.limits);
+    const { points: path, closed } = path2InputData(input, options.closed, limits);
     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);
-    assertSamplingCount(circularSegments, "strokePathRegion", limits.maxCircularSegments);
+    assertSamplingCount(path.length, "strokeRegionData", limits.maxPathPoints);
+    assertSamplingCount(circularSegments, "strokeRegionData", limits.maxCircularSegments);
     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 +
         joinCount * (join === "round" ? circularSegments : join === "miter" ? 4 : 3) +
         (!closed && cap === "round" ? 2 * circularSegments : 0);
-    assertSamplingCount(constructionVertices, "strokePathRegion", limits.maxProfilePoints);
+    assertSamplingCount(constructionVertices, "strokeRegionData", limits.maxProfilePoints);
     for (let index = 0; index < segmentCount; index += 1) {
         let start = normalizedPath[index];
         let end = normalizedPath[(index + 1) % normalizedPath.length];
@@ -108,42 +114,46 @@ 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) => [clippingRing(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, "strokeRegionData", resolveGeometrySamplingLimits(options.limits).maxProfilePoints);
     return result;
 }
-function regionFromMultiPolygon(value) {
-    return normalizeRegion(value.map((polygon) => ({
-        outer: polygon[0].slice(0, -1).map(([x, y]) => [x, y]),
-        holes: polygon.slice(1).map((hole) => hole.slice(0, -1).map(([x, y]) => [x, y])),
-    })));
-}
 /**
  * Converts a sampled millimetre path into the filled region covered by a centered stroke.
  *
@@ -152,29 +162,8 @@ function regionFromMultiPolygon(value) {
  * resolution. Bevels fill the outer corner triangle; miters extend the outer edges to their
  * 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);
+export function strokeRegionData(path, options) {
+    const result = strokePathMultiPolygon(path, options);
     if (result.length === 0)
         return fail("The sampled stroke path has no visible length.");
     return regionFromMultiPolygon(result);