@metamesh/modeling 0.14.0 → 0.16.0

package/dist/geometry/polygon-clipping.js

@@ -1,7 +1,24 @@
 import * as clippingModule from "polygon-clipping";
+import { normalizeRegion } from "./regions.js";
 const moduleWithDefault = clippingModule;
 /** @internal Normalizes polygon-clipping's CommonJS and bundled ESM module shapes. */
 export const polygonClipping = moduleWithDefault.default ?? clippingModule;
+/** @internal Copies an open contour into polygon-clipping's explicitly closed ring format. */
+export function clippingRing(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;
+}
+/** @internal Converts closed clipping rings into canonical regions with implicit seams. */
+export 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])),
+    })));
+}
 const CLIPPING_COORDINATE_GRID = 1e9;
 const snapCoordinate = (value) => Math.round(value * CLIPPING_COORDINATE_GRID) / CLIPPING_COORDINATE_GRID;
 /** Canonicalizes shared endpoints below model tolerance before they enter the sweep-line kernel. */

package/dist/geometry/profiles/contour.js

@@ -9,6 +9,7 @@ function invalid(message) {
 }
 /**
  * Samples 2–32 connected line/cubic segments into a simple, nonzero-area, immutable CCW XY loop.
+ *
  * Physical scaling precedes adaptive curve sampling; the final end must repeat start exactly.
  * Shared anchors and the closing seam are emitted once. Winding normalization may change the
  * starting vertex. The sampled loop is checked for self-intersection and degeneracy by
@@ -16,7 +17,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 +39,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 +67,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 +91,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
@@ -64,6 +64,7 @@ const contours = (component) => [
 ];
 /**
  * Explicitly matches identified component/contour/span topology across a family.
+ *
  * Every paired span uses the maximum physical subdivision count requested by any member.
  * Cubics share a checked uniform parameter grid, including grids selected by exact paired requests.
  * Input order and winding are preserved. Collapsed spans retain repeated logical slots, which
@@ -132,7 +133,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,14 +72,18 @@ 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,
     }) / 4);
 }
 /**
- * Creates an immutable CCW rectangle loop. Round radius zero is square; tangent saturated endpoints occur once.
+ * Creates an immutable sampled CCW rectangle boundary. Round radius zero is square; tangent saturated endpoints occur once.
+ *
+ * Use [rectangle](/docs/reference/model/rectangle) for a filled Section.
+ *
+ * @see {@link rectangleProfile} for identified edge/corner spans used by matchProfiles.
  *
  * @example Rounded rectangle outline
  * ```ts
@@ -148,6 +152,11 @@ export function rectangleContour(options) {
 /**
  * Creates an identified rectangle whose edge/corner spans survive zero and saturated round radii. Outer winding is CCW.
  *
+ * Use [rectangle](/docs/reference/model/rectangle) for a filled Section.
+ *
+ * @see {@link matchProfiles} to sample a family with shared landmark correspondence.
+ * @see {@link rectangleContour} for sampled boundary coordinates.
+ *
  * @example Retain rectangle landmarks
  * ```ts
  * rectangleProfile({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
@@ -194,7 +203,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 +239,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

@@ -23,6 +23,7 @@ function distanceToChord(point, start, end) {
 }
 /**
  * Samples 1–31 line/cubic segments into a deeply immutable open [radius,height] polyline.
+ *
  * Anchors must progress strictly upward; nonnegative-radius cubic controls must have ordered
  * heights between their endpoints. Cubics use de Casteljau subdivision with a conservative
  * control-hull chord-error bound. Lines also obey the optional physical edge-length ceiling.
@@ -30,7 +31,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 +49,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 +73,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 +110,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++) {
@@ -138,6 +139,7 @@ export function sampleSideProfile(curve, options = {}) {
 }
 /**
  * Closes an open, strictly upward [radius, height] side outline to the radius-zero axis.
+ *
  * Adds horizontal bottom/top edges at the endpoint heights, retaining axis endpoints once.
  * Returns a counterclockwise filled-boundary contour without a repeated seam vertex.
  * Radii must be nonnegative; the result must enclose nonzero area without touching itself.

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,18 +41,18 @@ 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, sizing) => {
@@ -66,7 +66,7 @@ const requiredFullCircleSegments = (radius, resolution, sizing) => {
         : 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);
+    return Math.max(resolution.minSegments, chordSegments, lengthSegments);
 };
 const assertRadius = (radius, operation) => {
     if (!Number.isFinite(radius) || radius <= 0) {
@@ -107,11 +107,11 @@ export function resolveCircularSegments(radius, policy = {}, limits = {}) {
     if (resolution.circularSegments !== undefined)
         return resolution.circularSegments;
     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.`, {
+    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,
             },
@@ -142,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.
@@ -176,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)
@@ -187,10 +187,10 @@ 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;
@@ -199,18 +199,18 @@ export function resolveAlignedCircularSegments(radius, options) {
         ...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,
             },
@@ -225,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
@@ -237,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) => {
@@ -76,8 +67,9 @@ function deduplicatePath(path, closed, width) {
     return Object.freeze(points);
 }
 /** @internal Bounded CCW stroke primitives shared by native sections and pure clipping. */
-export function strokePathContours(path, options, exactCircularSegments) {
-    const closed = options.closed ?? false;
+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")
@@ -97,9 +89,8 @@ export function strokePathContours(path, options, exactCircularSegments) {
             ? 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 [];
@@ -109,7 +100,7 @@ export function strokePathContours(path, options, exactCircularSegments) {
     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];
@@ -158,17 +149,11 @@ 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 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", resolveGeometrySamplingLimits(options.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.
  *
@@ -177,7 +162,7 @@ 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) {
+export function strokeRegionData(path, options) {
     const result = strokePathMultiPolygon(path, options);
     if (result.length === 0)
         return fail("The sampled stroke path has no visible length.");

package/dist/geometry/svg/fill.js

@@ -1,16 +1,8 @@
-import { polygonClipping, unionPolygonGeometry, xorPolygonGeometry } from "../polygon-clipping.js";
-import { normalizeRegion, signedContourArea } from "../regions.js";
+import { clippingRing, polygonClipping, regionFromMultiPolygon, unionPolygonGeometry, xorPolygonGeometry, } from "../polygon-clipping.js";
+import { signedContourArea } from "../regions.js";
 import { assertSamplingCount } from "../sampling-limits.js";
 /** Private clipping stage with the selected execution's immutable allocation ceiling. */
-export function createBoundedSvgClipping(maximumVertices) {
-    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;
-    }
+export function createBoundedSvgClipping(maxVertices) {
     function ringVertexCount(value) {
         const first = value[0];
         const last = value.at(-1);
@@ -21,7 +13,7 @@ export function createBoundedSvgClipping(maximumVertices) {
         return value.reduce((total, polygon) => total + polygon.reduce((polygonTotal, path) => polygonTotal + ringVertexCount(path), 0), 0);
     }
     function assertExpandedVertexCount(vertices, stage) {
-        assertSamplingCount(vertices, "preflightSvgRegion", maximumVertices, `SVG ${stage} exceeds ${maximumVertices} expanded vertices (requires ${vertices}).`);
+        assertSamplingCount(vertices, "preflightSvgRegion", maxVertices, `SVG ${stage} exceeds ${maxVertices} expanded vertices (requires ${vertices}).`);
     }
     function boundedMultiPolygon(value, stage) {
         assertExpandedVertexCount(multiPolygonVertexCount(value), stage);
@@ -136,16 +128,16 @@ export function createBoundedSvgClipping(maximumVertices) {
             .map((subpath) => subpath.points);
         if (rings.length === 0)
             return [];
-        const polygons = rings.map((points) => [ring(points)]);
+        const polygons = rings.map((points) => [clippingRing(points)]);
         if (fillRule === "evenodd") {
             return boundedXor(polygons.map((polygon) => [polygon]), "even-odd fill output");
         }
         const positive = rings
             .filter((points) => signedContourArea(points) >= 0)
-            .map((points) => [ring(points)]);
+            .map((points) => [clippingRing(points)]);
         const negative = rings
             .filter((points) => signedContourArea(points) < 0)
-            .map((points) => [ring(points)]);
+            .map((points) => [clippingRing(points)]);
         if (positive.length === 0)
             return boundedUnion([negative], "negative fill output");
         if (negative.length === 0)
@@ -155,12 +147,6 @@ export function createBoundedSvgClipping(maximumVertices) {
         // precisely where positive and negative nonzero winding counts match.
         return differingCoverage(positive, negative);
     }
-    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])),
-        })));
-    }
     return {
         assertExpandedVertexCount,
         boundedMultiPolygon,