@metamesh/modeling 0.14.0 → 0.15.0

package/dist/geometry/paths/resampling.js

@@ -9,7 +9,7 @@ const distance = (a, b) => {
         curveFailure("NON_FINITE_VALUE", "Curve extent exceeds finite arithmetic.");
     return value;
 };
-function resamplePolyline(path, dimensions, options, createWriter) {
+function resamplePolyline(path, dimensions, options, createWriter, includeTangents = true) {
     const maximum = resolveSamplingBudget(options);
     if (options.closed !== undefined && typeof options.closed !== "boolean")
         curveFailure("INVALID_ARGUMENT", "closed must be a boolean.");
@@ -91,10 +91,12 @@ function resamplePolyline(path, dimensions, options, createWriter) {
             point[2] = z(a) + (z(b) - z(a)) * t;
         }
         validateCurvePoint3(point);
-        tangent[0] = b[0] - a[0];
-        tangent[1] = b[1] - a[1];
-        tangent[2] = z(b) - z(a);
-        normalizeCurveDirection(tangent, tangent);
+        if (includeTangents) {
+            tangent[0] = b[0] - a[0];
+            tangent[1] = b[1] - a[1];
+            tangent[2] = z(b) - z(a);
+            normalizeCurveDirection(tangent, tangent);
+        }
         writer.append(point, tangent);
     }
     return writer.finish();
@@ -123,3 +125,23 @@ export function resamplePolyline3(path, options = {}) {
 export function resamplePolyline2(path, options = {}) {
     return resamplePolyline(path, 2, options, createPlanarSampleWriter);
 }
+/** Internal points-only writer; Path2 owns these mutable coordinates and freezes public interchange. */
+export function resamplePath2Data(path, options) {
+    const points = [];
+    return resamplePolyline(path, 2, options, () => ({
+        append: (point) => {
+            points.push([point[0], point[1]]);
+        },
+        finish: () => points,
+    }), false);
+}
+/** Internal points-only writer; avoids calculating and allocating tangents discarded by Path3. */
+export function resamplePath3Data(path, options) {
+    const points = [];
+    return resamplePolyline(path, 3, options, () => ({
+        append: (point) => {
+            points.push([point[0], point[1], point[2]]);
+        },
+        finish: () => points,
+    }), false);
+}

package/dist/geometry/patterns/placements.js

@@ -1,7 +1,9 @@
 import { GeometryError } from "../errors.js";
+import { vector3Data } from "../math/vector-value.js";
 import { cross3, dot3, scale3 } from "../math/vector3.js";
+import { path2InputData, path3InputData, } from "../paths/path-value.js";
 import { distributeAlongPath } from "../paths/planar.js";
-import { normalizeSweepPath } from "../sweeps/validation.js";
+import { restrictTransform3 } from "../transform2.js";
 import { composeTransform3, frameTransform3, IDENTITY_TRANSFORM3, rotationTransform3, translationTransform3, } from "../transform3.js";
 const fail = (operation, message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation });
@@ -23,13 +25,35 @@ const finite = (value, operation) => {
         });
     return value;
 };
-const vector = (value, operation) => {
-    if (!Array.isArray(value) || value.length !== 3 || !Array.from(value).every(Number.isFinite))
-        fail(operation, "Pattern vectors require three finite coordinates.");
-    return value;
+const coordinates = (input, operation) => {
+    const value = typeof input === "object" &&
+        input !== null &&
+        "toArray" in input &&
+        typeof input.toArray === "function"
+        ? input.toArray()
+        : input;
+    if (!Array.isArray(value) || (value.length !== 2 && value.length !== 3))
+        fail(operation, "Pattern vectors require exact XY or XYZ coordinates.");
+    const source = value;
+    const copied = source.length === 2 ? [source[0], source[1]] : [source[0], source[1], source[2]];
+    if (copied.some((coordinate) => typeof coordinate !== "number"))
+        fail(operation, "Pattern vectors require numeric coordinates.");
+    copied.forEach((coordinate) => finite(coordinate, operation));
+    return copied;
+};
+const vector = (input, operation) => {
+    const value = coordinates(input, operation);
+    if (value.length !== 3)
+        fail(operation, "Spatial pattern vectors require XYZ coordinates.");
+    return vector3Data(value);
 };
-const direction = (value, operation) => {
-    vector(value, operation);
+const lift = (value) => [value[0], value[1], value[2] ?? 0];
+const requireDimension = (actual, expected, operation) => {
+    if (actual !== expected)
+        fail(operation, "Pattern coordinates must match the shape dimension.");
+};
+const direction = (input, operation) => {
+    const value = vector(input, operation);
     const maximum = Math.max(...value.map(Math.abs));
     if (maximum === 0)
         fail(operation, "Pattern direction must be nonzero.");
@@ -77,27 +101,46 @@ export function linearPatternPlan(options) {
             fail(operation, "Length must be a nonnegative whole multiple of the signed spacing.");
         count = patternCount(Math.round(intervals) + 1, operation);
     }
-    const axis = direction(options.direction ?? [1, 0, 0], operation);
+    const input = options.direction === undefined ? undefined : coordinates(options.direction, operation);
+    const axis = direction(input === undefined ? [1, 0, 0] : lift(input), operation);
     finite(spacing * (count - 1), operation);
-    return { count, transformAt: (index) => translationTransform3(scale3(axis, spacing * index)) };
+    return {
+        count,
+        transformAt: (index, dimension = 3) => {
+            if (input !== undefined)
+                requireDimension(input.length, dimension, operation);
+            return translationTransform3(scale3(axis, spacing * index));
+        },
+    };
 }
 export function radialPatternPlan(options) {
     const operation = "radialPattern";
     optionsObject(options, operation);
     const count = patternCount(options.count, operation);
-    const axis = direction(options.axis, operation);
-    const angle = finite((options.angleDegrees / 180) * Math.PI, operation);
-    if (angle === 0)
-        fail(operation, "Pattern angleDegrees must be nonzero.");
-    finite(angle * (count - 1), operation);
-    const center = vector(options.center ?? [0, 0, 0], operation);
-    const before = translationTransform3(scale3(center, -1));
-    const after = translationTransform3(center);
+    if ("center" in options)
+        fail(operation, "Use pivot for a radial pattern's rotation reference.");
+    const hasAxis = options.axis !== undefined;
+    const axis = direction(options.axis ?? [0, 0, 1], operation);
+    const angleRadians = finite((options.angle / 180) * Math.PI, operation);
+    if (angleRadians === 0)
+        fail(operation, "Pattern angle must be nonzero.");
+    finite(angleRadians * (count - 1), operation);
+    const pivot = options.pivot === undefined ? undefined : coordinates(options.pivot, operation);
+    const before = translationTransform3(scale3(pivot === undefined ? [0, 0, 0] : lift(pivot), -1));
+    const after = translationTransform3(pivot === undefined ? [0, 0, 0] : lift(pivot));
     return {
         count,
-        transformAt: (index) => index === 0
-            ? IDENTITY_TRANSFORM3
-            : composeTransform3(after, composeTransform3(rotationTransform3(axis, { radians: angle * index }), before)),
+        transformAt: (index, dimension = 3) => {
+            if (dimension === 2 && hasAxis)
+                fail(operation, "XY radial patterns use the implicit +Z axis.");
+            if (dimension === 3 && !hasAxis)
+                fail(operation, "Spatial radial patterns require an explicit axis.");
+            if (pivot !== undefined)
+                requireDimension(pivot.length, dimension, operation);
+            return index === 0
+                ? IDENTITY_TRANSFORM3
+                : composeTransform3(after, composeTransform3(rotationTransform3(axis, { radians: angleRadians * index }), before));
+        },
     };
 }
 export function gridPatternPlan(options) {
@@ -111,6 +154,7 @@ export function gridPatternPlan(options) {
         fail(operation, "Grid count and spacing require matching XY or XYZ tuples.");
     if (options.center !== undefined && typeof options.center !== "boolean")
         fail(operation, "Grid center must be a boolean.");
+    const centered = options.center === true;
     const counts = [options.count[0], options.count[1], dimensions === 3 ? options.count[2] : 1];
     counts.forEach((count) => patternCount(count, operation));
     const count = patternCount(counts[0] * counts[1] * counts[2], operation);
@@ -138,13 +182,17 @@ export function gridPatternPlan(options) {
     const frame = options.frame === undefined ? IDENTITY_TRANSFORM3 : frameTransform3(options.frame);
     return {
         count,
-        transformAt: (index) => {
+        transformAt: (index, dimension = 3) => {
+            if (dimension === 2) {
+                requireDimension(dimensions, dimension, operation);
+                restrictTransform3(frame);
+            }
             const coordinates = [
                 index % counts[0],
                 Math.floor(index / counts[0]) % counts[1],
                 Math.floor(index / (counts[0] * counts[1])),
             ];
-            const offset = coordinates.map((value, axis) => value * spacing[axis] - (options.center === true ? extent[axis] / 2 : 0));
+            const offset = coordinates.map((value, axis) => value * spacing[axis] - (centered ? extent[axis] / 2 : 0));
             return composeTransform3(frame, translationTransform3(offset));
         },
     };
@@ -164,18 +212,43 @@ export function pathPatternPlan(input, options, limits) {
         options.orientation !== "fixed" &&
         options.orientation !== "tangent")
         fail(operation, "Path orientation must be fixed or tangent.");
-    const path = normalizeSweepPath(input, options.closed ?? false, operation, limits);
+    const tangentOrientation = options.orientation === "tangent";
+    if (typeof input !== "object" || input === null)
+        fail(operation, "Path patterns require sampled XY or XYZ coordinates.");
+    const first = Array.isArray(input) ? input[0] : undefined;
+    const suppliedDimension = Array.isArray(input)
+        ? Array.isArray(first)
+            ? first.length
+            : typeof first === "object" && first !== null && "z" in first
+                ? 3
+                : 2
+        : Reflect.get(input, "dimension");
+    if (suppliedDimension !== 2 && suppliedDimension !== 3)
+        fail(operation, "Path patterns require sampled XY or XYZ coordinates.");
+    const dimension = suppliedDimension === 2 ? 2 : 3;
+    const data = dimension === 2
+        ? path2InputData(input, options.closed, limits)
+        : path3InputData(input, options.closed, limits);
+    const path = dimension === 2 ? data.points.map(lift) : data.points;
+    // Distribution permits reversals, zero-length edges, and open paths returning to their start.
+    // Validate the traversal before factories without allocating the complete placement collection.
+    const firstPlacement = distributeAlongPath(path, 1, data.closed, limits);
     // Defer the output placement array until the operation has checked the source copy budget.
-    let placements;
+    let placements = count === 1 ? firstPlacement : undefined;
     return {
         count,
-        transformAt: (index) => {
-            placements ??= distributeAlongPath(path, count, options.closed ?? false, limits);
+        transformAt: (index, shapeDimension = 3) => {
+            requireDimension(dimension, shapeDimension, operation);
+            placements ??= distributeAlongPath(path, count, data.closed, limits);
             const placement = placements[index];
             const translation = translationTransform3(placement.position);
-            if (options.orientation !== "tangent")
+            if (!tangentOrientation)
                 return translation;
             const tangent = placement.tangent;
+            if (dimension === 2)
+                return composeTransform3(translation, rotationTransform3([0, 0, 1], {
+                    radians: Math.atan2(tangent[1], tangent[0]),
+                }));
             const cosine = Math.max(-1, Math.min(1, dot3([0, 0, 1], tangent)));
             const axis = cross3([0, 0, 1], tangent);
             const sine = Math.hypot(...axis);

package/dist/geometry/patterns.js

@@ -3,7 +3,7 @@ import { resolveGeometrySamplingLimits } from "./sampling-limits.js";
 function transforms(plan) {
     return Object.freeze(Array.from({ length: plan.count }, (_, index) => Object.freeze(plan.transformAt(index))));
 }
-/** Equal linear placements in millimetres, including the original at the origin. */
+/** Spatial XYZ matrix placements in millimetres, including the original at the origin. */
 export function linearPatternTransforms(options) {
     return transforms(linearPatternPlan(options));
 }
@@ -11,7 +11,7 @@ export function linearPatternTransforms(options) {
 export function radialPatternTransforms(options) {
     return transforms(radialPatternPlan(options));
 }
-/** XY or XYZ grid placements in millimetres, in X-fastest order. */
+/** Spatial XYZ matrices for an XY or XYZ grid, in X-fastest order. */
 export function gridPatternTransforms(options) {
     return transforms(gridPatternPlan(options));
 }

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

@@ -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,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));
 }