@metamesh/modeling 0.12.0 → 0.14.0

package/dist/geometry/paths/frames.js

@@ -1,4 +1,4 @@
-import { cross3, dot3, length3, normalize3, projectOntoPlane3, rotateAroundAxis3, scale3, subtract3, } from "../math/vector3.js";
+import { cross3, dot3, length3, normalize3, projectOntoPlane3, rotateAroundAxis3Radians, scale3, subtract3, } from "../math/vector3.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
 const tangentAt = (path, index) => {
     if (index === 0) {
@@ -32,7 +32,7 @@ const transportNormal = (normal, previousTangent, tangent) => {
     if (sine > 1e-10) {
         const axis = scale3(rotationAxis, 1 / sine);
         const cosine = Math.max(-1, Math.min(1, dot3(previousTangent, tangent)));
-        transported = rotateAroundAxis3(normal, axis, Math.atan2(sine, cosine));
+        transported = rotateAroundAxis3Radians(normal, axis, Math.atan2(sine, cosine));
     }
     return normalize3(projectOntoPlane3(transported, tangent));
 };
@@ -88,11 +88,10 @@ const signedAngleAround = (from, to, axis) => Math.atan2(dot3(axis, cross3(from,
 /**
  * Builds rotation-minimizing frames for a non-duplicated closed path.
  *
- * Centered cyclic tangents are parallel-transported around the loop. The seam
- * holonomy is measured by transporting the last normal back to the first
- * tangent, then its residual rotation is distributed uniformly over all path
- * intervals. This avoids a single visible seam or an accumulated frame flip.
- * The maxPathPoints ceiling (default100000) bounds path points and frames.
+ * Centered cyclic tangents are parallel-transported around the loop. Transporting the last
+ * normal back to the first tangent measures seam holonomy; distributing that residual rotation
+ * uniformly over all path intervals avoids a visible seam or accumulated frame flip.
+ * The maxPathPoints ceiling (default 100000) bounds path points and frames.
  */
 export const computeClosedParallelTransportFrames = (path, initialNormal, limits = {}) => {
     if (path.length < 3) {
@@ -108,7 +107,7 @@ export const computeClosedParallelTransportFrames = (path, initialNormal, limits
     const seamCorrection = signedAngleAround(seamNormal, transportedNormals[0], tangents[0]);
     return tangents.map((tangent, index) => {
         const correction = (seamCorrection * index) / path.length;
-        const normal = normalize3(projectOntoPlane3(rotateAroundAxis3(transportedNormals[index], tangent, correction), tangent));
+        const normal = normalize3(projectOntoPlane3(rotateAroundAxis3Radians(transportedNormals[index], tangent, correction), tangent));
         return {
             tangent,
             normal,

package/dist/geometry/patterns/options.js

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

package/dist/{engine/pattern-placements.js → geometry/patterns/placements.js}

@@ -1,8 +1,8 @@
-import { GeometryError } from "../geometry/errors.js";
-import { cross3, dot3, scale3 } from "../geometry/math/vector3.js";
-import { distributeAlongPath } from "../geometry/paths/planar.js";
-import { normalizeSweepPath } from "../geometry/sweeps/validation.js";
-import { composeTransform3, frameTransform3, IDENTITY_TRANSFORM3, rotationTransform3, translationTransform3, } from "../geometry/transform3.js";
+import { GeometryError } from "../errors.js";
+import { cross3, dot3, scale3 } from "../math/vector3.js";
+import { distributeAlongPath } from "../paths/planar.js";
+import { normalizeSweepPath } from "../sweeps/validation.js";
+import { composeTransform3, frameTransform3, IDENTITY_TRANSFORM3, rotationTransform3, translationTransform3, } from "../transform3.js";
 const fail = (operation, message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation });
 };
@@ -24,7 +24,7 @@ const finite = (value, operation) => {
     return value;
 };
 const vector = (value, operation) => {
-    if (!Array.isArray(value) || value.length !== 3 || !value.every(Number.isFinite))
+    if (!Array.isArray(value) || value.length !== 3 || !Array.from(value).every(Number.isFinite))
         fail(operation, "Pattern vectors require three finite coordinates.");
     return value;
 };
@@ -111,16 +111,30 @@ 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 counts = [options.count[0], options.count[1], options.count[2] ?? 1];
+    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);
-    const spacing = [options.spacing[0], options.spacing[1], options.spacing[2] ?? 0];
+    const spacing = [
+        options.spacing[0],
+        options.spacing[1],
+        dimensions === 3 ? options.spacing[2] : 0,
+    ];
     const extent = spacing.map((distance, axis) => {
         finite(distance, operation);
         if (counts[axis] > 1 && distance === 0)
             fail(operation, "Repeated grid axes require nonzero spacing.");
         return finite(distance * (counts[axis] - 1), operation);
     });
+    if (options.frame !== undefined) {
+        optionsObject(options.frame, operation);
+        for (const coordinates of [
+            options.frame.origin,
+            options.frame.xAxis,
+            options.frame.yAxis,
+            options.frame.zAxis,
+        ])
+            vector(coordinates, operation);
+    }
     const frame = options.frame === undefined ? IDENTITY_TRANSFORM3 : frameTransform3(options.frame);
     return {
         count,

package/dist/geometry/patterns.js

@@ -0,0 +1,25 @@
+import { gridPatternPlan, linearPatternPlan, pathPatternPlan, radialPatternPlan, } from "./patterns/placements.js";
+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. */
+export function linearPatternTransforms(options) {
+    return transforms(linearPatternPlan(options));
+}
+/** Rotations about an explicit axis; angles use degrees and the first placement is identity. */
+export function radialPatternTransforms(options) {
+    return transforms(radialPatternPlan(options));
+}
+/** XY or XYZ grid placements in millimetres, in X-fastest order. */
+export function gridPatternTransforms(options) {
+    return transforms(gridPatternPlan(options));
+}
+/**
+ * Equal physical arc-length placements along a sampled XYZ path. Tangent orientation maps +Z
+ * onto the local path tangent; fixed orientation only translates. Closed paths omit a repeated seam.
+ * Explicit sampling ceilings bound both input points and output placements.
+ */
+export function pathPatternTransforms(path, options, limits) {
+    return transforms(pathPatternPlan(path, options, resolveGeometrySamplingLimits(limits)));
+}

package/dist/geometry/primitive-resolution.js

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

package/dist/geometry/primitive-resolvers.js

@@ -112,17 +112,17 @@ export function resolveBoxPrimitive(options) {
         if (selections.length === 0 || selections.length > 12)
             throw new GeometryError("INVALID_ARGUMENT", "Box treatments require a nonempty map of nominal edges or groups.", { operation });
         const cuts = [];
+        const selectedEdges = new Set();
         for (const [selection, selected] of selections) {
             const setbacks = edgeTreatmentSetbacks(selected, operation, Math.PI / 2, options.limits);
-            if (setbacks.some((value) => value <= 0))
-                throw new GeometryError("INVALID_ARGUMENT", "Box treatments require positive setbacks.", {
-                    operation,
-                });
             for (const edge of expandBoxEdges(selection)) {
-                if (cuts.some((cut) => cut.edge === edge))
+                if (selectedEdges.has(edge))
                     throw new GeometryError("INVALID_ARGUMENT", "Box edge selections must not overlap.", {
                         operation,
                     });
+                selectedEdges.add(edge);
+                if (setbacks[0] === 0 && setbacks[1] === 0)
+                    continue;
                 const [first, second] = edge.split("-"), a = boxFaceAxes[first][0], b = boxFaceAxes[second][0];
                 if (setbacks[0] >= dimensions[b] || setbacks[1] >= dimensions[a])
                     throw new GeometryError("INVALID_ARGUMENT", "Box edge setbacks must fit their adjoining dimensions.", { operation });
@@ -134,6 +134,8 @@ export function resolveBoxPrimitive(options) {
                 });
             }
         }
+        if (cuts.length === 0)
+            return base;
         for (const cut of cuts) {
             const [first, second] = cut.edge.split("-"), [a, sa] = boxFaceAxes[first], [b, sb] = boxFaceAxes[second];
             for (const other of cuts) {
@@ -167,10 +169,8 @@ export function resolveBoxPrimitive(options) {
         };
     }
     const setbacks = edgeTreatmentSetbacks(treatment, operation, Math.PI / 2, options.limits);
-    if (setbacks.some((value) => value <= 0))
-        throw new GeometryError("INVALID_ARGUMENT", "Box treatments require positive setbacks.", {
-            operation,
-        });
+    if (setbacks[0] === 0 && setbacks[1] === 0)
+        return base;
     const distance = setbacks[0];
     assertPositivePrimitive(distance, "edge treatment size", operation);
     const inner = [

package/dist/geometry/profiles/contour.js

@@ -1,6 +1,6 @@
 import { sampleCurve2 } from "../curves/sampling.js";
 import { GeometryError } from "../errors.js";
-import { normalizeLoop2 } from "../regions.js";
+import { normalizeContour } from "../regions.js";
 import { resolveGeometrySamplingLimits } from "../sampling-limits.js";
 import { requireProfileVertexCount } from "./validation.js";
 const OPERATION = "sampleContour";
@@ -12,7 +12,7 @@ function invalid(message) {
  * 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
- * `normalizeLoop2`; this is a single contour without holes. No editor modes or normalized
+ * `normalizeContour`; this is a single contour without holes. No editor modes or normalized
  * 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.
@@ -98,5 +98,5 @@ export function sampleContour(curve, options = {}) {
             output.push(sampled[pointIndex]);
         start = end;
     }
-    return normalizeLoop2(output, true);
+    return normalizeContour(output, true);
 }

package/dist/geometry/profiles/matched.js

@@ -1,7 +1,7 @@
 import { planarCubicControl } from "../curves/evaluation.js";
 import { resolveLineSegmentCount, resolveUniformCubicSegments } from "../curves/sampling.js";
 import { GeometryError } from "../errors.js";
-import { normalizeRegion2, signedAreaLoop2 } from "../regions.js";
+import { normalizeRegion, signedContourArea } from "../regions.js";
 import { resolveArcSegments, resolveGeometryResolution } from "../resolution.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits } from "../sampling-limits.js";
 import { createProfileSpanSampler } from "./span-sampling.js";
@@ -167,7 +167,7 @@ export function matchProfiles(profiles, options = {}) {
                         spans.push(span.id);
                     }
                 });
-                const area = signedAreaLoop2(points);
+                const area = signedContourArea(points);
                 if (!(contourIndex === 0 ? area > 0 : area < 0))
                     fail("Outer contours must be CCW and holes CW; matching never reorders winding.");
                 return Object.freeze({
@@ -183,7 +183,7 @@ export function matchProfiles(profiles, options = {}) {
             });
         });
         // This validates intersections and containment, without changing logical slots or topology.
-        normalizeRegion2(components.map((component) => ({
+        normalizeRegion(components.map((component) => ({
             outer: component.outer.points,
             holes: component.holes.map((hole) => hole.points),
         })));

package/dist/geometry/profiles/profiles.js

@@ -2,17 +2,17 @@ import { GeometryError } from "../errors.js";
 import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
 import { assertPrimitiveOptions } from "../primitive-resolvers.js";
 import { requireFiniteProfileValues, requireProfileVertexCount } from "./validation.js";
-export { rectangleLoop } from "./rectangle.js";
+export { rectangleContour } from "./rectangle.js";
 /**
  * Creates an immutable centered CCW circle with +X seam and vertex or face radial sizing.
  *
  * @example Explicit circular point data
  * ```ts
- * circleLoop({ diameter: 20, segments: 32 });
+ * circleContour({ diameter: 20, segments: 32 });
  * ```
  */
-export const circleLoop = (options) => {
-    const operation = "circleLoop";
+export const circleContour = (options) => {
+    const operation = "circleContour";
     assertPrimitiveOptions(options, operation);
     if ((options.radius === undefined) === (options.diameter === undefined)) {
         throw new GeometryError("INVALID_ARGUMENT", "Specify exactly one radius or diameter.", {
@@ -44,11 +44,11 @@ export const circleLoop = (options) => {
  *
  * @example Hexagon sized to its faces
  * ```ts
- * regularPolygonLoop({ radius: 10, sides: 6, sizing: "face" });
+ * regularPolygonContour({ radius: 10, sides: 6, sizing: "face" });
  * ```
  */
-export const regularPolygonLoop = (options) => {
-    const operation = "regularPolygonLoop";
+export const regularPolygonContour = (options) => {
+    const operation = "regularPolygonContour";
     const { radius, sides, rotationDegrees = 0, sizing = "vertex" } = options;
     requireFiniteProfileValues([radius, rotationDegrees], operation);
     if (!(radius > 0)) {
@@ -72,11 +72,11 @@ export const regularPolygonLoop = (options) => {
  *
  * @example Five-point outline
  * ```ts
- * starLoop(12, 5, 6);
+ * starContour(12, 5, 6);
  * ```
  */
-export const starLoop = (outerRadius, points, innerRadius = outerRadius / 2, limits = {}) => {
-    const operation = "starLoop";
+export const starContour = (outerRadius, points, innerRadius = outerRadius / 2, limits = {}) => {
+    const operation = "starContour";
     requireFiniteProfileValues([outerRadius, innerRadius], operation);
     if (!(outerRadius > 0) || !(innerRadius > 0) || innerRadius >= outerRadius) {
         throw new GeometryError("INVALID_ARGUMENT", "Star radii must be positive, with the inner radius smaller than the outer.", { operation });

package/dist/geometry/profiles/rectangle.js

@@ -65,7 +65,7 @@ export function rectangleCornerSegments(corner, limits) {
     const selected = resolveModelingLimits(limits);
     const exact = corner.segments ?? corner.resolution?.circularSegments;
     if (exact !== undefined && Number.isSafeInteger(exact) && exact >= 3)
-        assertSamplingCount(exact, "rectangleLoop", selected.maxCircularSegments);
+        assertSamplingCount(exact, "rectangleContour", selected.maxCircularSegments);
     if (corner.radius === 0 &&
         corner.segments === undefined &&
         corner.resolution?.circularSegments === undefined)
@@ -83,11 +83,11 @@ export function rectangleCornerSegments(corner, limits) {
  *
  * @example Rounded rectangle outline
  * ```ts
- * rectangleLoop({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * rectangleContour({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
  * ```
  */
-export function rectangleLoop(options) {
-    const { width, height, corners, limits } = resolveRectangle(options, "rectangleLoop");
+export function rectangleContour(options) {
+    const { width, height, corners, limits } = resolveRectangle(options, "rectangleContour");
     const counts = corners.map((corner) => {
         if (corner.kind === "square")
             return 1;
@@ -95,9 +95,9 @@ export function rectangleLoop(options) {
             const intervals = rectangleCornerSegments(corner, limits);
             return corner.radius > 0 ? intervals + 1 : 1;
         }
-        return edgeTreatmentPointCount(corner, "rectangleLoop", { limits });
+        return edgeTreatmentPointCount(corner, "rectangleContour", { limits });
     });
-    requireProfileVertexCount(counts.reduce((sum, count) => sum + count, 0), 3, "rectangleLoop", limits);
+    requireProfileVertexCount(counts.reduce((sum, count) => sum + count, 0), 3, "rectangleContour", limits);
     const x = width / 2, y = height / 2;
     const vertices = [
         [x, y],
@@ -131,7 +131,7 @@ export function rectangleLoop(options) {
         }
         const samples = corner.kind === "square"
             ? [[0, 0]]
-            : sampleEdgeTreatment(corner, "rectangleLoop", { limits });
+            : sampleEdgeTreatment(corner, "rectangleContour", { limits });
         for (const [a, b] of samples)
             points.push([
                 vertices[index][0] + incoming[index][0] * a + outgoing[index][0] * b,

package/dist/geometry/profiles/shapes.js

@@ -7,33 +7,33 @@ import { requireFiniteProfileValues, requireProfileVertexCount } from "./validat
  *
  * @example Ellipse by full dimensions
  * ```ts
- * ellipseLoop({ size: [30, 20] });
+ * ellipseContour({ size: [30, 20] });
  * ```
  */
-export function ellipseLoop(options) {
-    assertPrimitiveOptions(options, "ellipseLoop");
+export function ellipseContour(options) {
+    assertPrimitiveOptions(options, "ellipseContour");
     if ((options.radius === undefined) === (options.size === undefined)) {
         throw new GeometryError("INVALID_ARGUMENT", "Specify exactly one radius or size tuple.", {
-            operation: "ellipseLoop",
+            operation: "ellipseContour",
         });
     }
     const dimensions = options.radius ?? options.size;
     if (!Array.isArray(dimensions) || dimensions.length !== 2) {
         throw new GeometryError("INVALID_ARGUMENT", "Ellipse dimensions must be an exact XY tuple.", {
-            operation: "ellipseLoop",
+            operation: "ellipseContour",
         });
     }
     const factor = options.radius === undefined ? 0.5 : 1;
     const radiusX = dimensions[0] * factor;
     const radiusY = dimensions[1] * factor;
-    requireFiniteProfileValues([radiusX, radiusY], "ellipseLoop");
+    requireFiniteProfileValues([radiusX, radiusY], "ellipseContour");
     if (![radiusX, radiusY].every((value) => Number.isFinite(value) && value > 0)) {
         throw new GeometryError("INVALID_ARGUMENT", "Ellipse radii must be finite and positive.", {
-            operation: "ellipseLoop",
+            operation: "ellipseContour",
         });
     }
-    const segments = resolveCircularPrimitiveSegments(Math.max(radiusX, radiusY), options, "ellipseLoop");
-    requireProfileVertexCount(segments, 3, "ellipseLoop", options.limits);
+    const segments = resolveCircularPrimitiveSegments(Math.max(radiusX, radiusY), options, "ellipseContour");
+    requireProfileVertexCount(segments, 3, "ellipseContour", options.limits);
     return Object.freeze(Array.from({ length: segments }, (_, index) => {
         const angle = (index * Math.PI * 2) / segments;
         return Object.freeze([radiusX * Math.cos(angle), radiusY * Math.sin(angle)]);

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

@@ -1,4 +1,5 @@
 import { GeometryError } from "../errors.js";
+import { normalizeContour } from "../regions.js";
 import { resolveGeometryResolution } from "../resolution.js";
 import { resolveGeometrySamplingLimits } from "../sampling-limits.js";
 import { requireProfileVertexCount } from "./validation.js";
@@ -135,3 +136,39 @@ export function sampleSideProfile(curve, options = {}) {
     }
     return Object.freeze(output);
 }
+/**
+ * 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.
+ * This is a solid-body closure, not a hollow-wall or mounting-bore construction.
+ */
+export function closeToAxis(side, limits) {
+    const operation = "closeToAxis";
+    const arrayShape = Array.isArray(side);
+    if (!arrayShape || side.length < 2)
+        throw new GeometryError("INVALID_ARGUMENT", "A side outline needs at least two points.", {
+            operation,
+        });
+    requireProfileVertexCount(side.length, 2, operation, limits);
+    for (let index = 0; index < side.length; index++) {
+        const point = side[index];
+        const pointShape = Array.isArray(point) && point.length === 2;
+        if (!pointShape ||
+            !point.every(Number.isFinite) ||
+            point[0] < 0 ||
+            (index > 0 && point[1] <= side[index - 1][1]))
+            throw new GeometryError("INVALID_ARGUMENT", "Side points require finite nonnegative radii and strictly increasing heights.", { operation });
+    }
+    const first = side[0];
+    const last = side.at(-1);
+    requireProfileVertexCount(side.length + Number(first[0] !== 0) + Number(last[0] !== 0), 3, operation, limits);
+    const contour = [];
+    if (first[0] !== 0)
+        contour.push([0, first[1]]);
+    for (const point of side)
+        contour.push(point);
+    if (last[0] !== 0)
+        contour.push([0, last[1]]);
+    return normalizeContour(contour, true);
+}

package/dist/geometry/regions.js

@@ -28,7 +28,7 @@ const coordinateScale = (loop) => {
     return Math.max(maxX - minX, maxY - minY);
 };
 /** Returns the signed area of a non-duplicated loop; positive means CCW. */
-export function signedAreaLoop2(loop) {
+export function signedContourArea(loop) {
     if (loop.length === 0)
         return 0;
     const origin = loop[0];
@@ -48,7 +48,7 @@ export function signedAreaLoop2(loop) {
     return (twiceArea + correction) / 2;
 }
 /** Returns true when a point lies inside or on the boundary of a loop. */
-export function loopContainsPoint(loop, point) {
+export function contourContainsPoint(loop, point) {
     let inside = false;
     for (let index = 0, previous = loop.length - 1; index < loop.length; previous = index++) {
         const a = loop[index];
@@ -128,7 +128,7 @@ const boundedSegments = (loop, epsilon) => loop.map((a, index) => {
 const consumeIntersectionCandidate = (budget) => {
     budget.candidates += 1;
     if (budget.candidates > MAX_INTERSECTION_CANDIDATES) {
-        throw new GeometryError("COMPLEXITY_LIMIT", "Region validation exceeds the 2000000 intersection-candidate work limit.", { operation: "normalizeRegion2", details: { maximumCandidates: MAX_INTERSECTION_CANDIDATES } });
+        throw new GeometryError("COMPLEXITY_LIMIT", "Region validation exceeds the 2000000 intersection-candidate work limit.", { operation: "normalizeRegion", details: { maximumCandidates: MAX_INTERSECTION_CANDIDATES } });
     }
 };
 const boundedIntersections = (segments, epsilon, budget, sameLoop) => {
@@ -170,7 +170,7 @@ const loopsIntersect = (a, b, epsilon, budget) => a === b ||
  * result must be simple and have non-zero area. Previously validated immutable results may be
  * returned unchanged when their winding and tolerance policy match.
  */
-export function normalizeLoop2(input, counterClockwise, tolerance = {}) {
+export function normalizeContour(input, counterClockwise, tolerance = {}) {
     return normalizeLoopWithBudget(input, counterClockwise, tolerance, { candidates: 0 });
 }
 const normalizeLoopWithBudget = (input, counterClockwise, tolerance, budget) => {
@@ -199,7 +199,7 @@ const normalizeLoopWithBudget = (input, counterClockwise, tolerance, budget) =>
     if (boundedIntersections(boundedSegments(cleaned, resolved.linear), resolved.linear, budget, true)) {
         throw new GeometryError("SELF_INTERSECTION", "A loop must not self-intersect.");
     }
-    const area = signedAreaLoop2(cleaned);
+    const area = signedContourArea(cleaned);
     if (!Number.isFinite(area)) {
         throw new GeometryError("NON_FINITE_VALUE", "Loop area must be finite.");
     }
@@ -223,7 +223,7 @@ const normalizeLoopWithBudget = (input, counterClockwise, tolerance, budget) =>
  * within its exterior and boundaries may not intersect. Previously validated immutable results
  * may be returned unchanged under the same tolerance policy.
  */
-export function normalizePolygon2(polygon, tolerance = {}) {
+export function normalizePolygon(polygon, tolerance = {}) {
     return normalizePolygonWithBudget(polygon, tolerance, { candidates: 0 });
 }
 const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
@@ -236,7 +236,7 @@ const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
     const epsilon = resolveGeometryTolerance(scale, policy).linear;
     for (let index = 0; index < holes.length; index += 1) {
         const hole = holes[index];
-        if (!loopContainsPoint(outer, hole[0]) || loopsIntersect(outer, hole, epsilon, budget)) {
+        if (!contourContainsPoint(outer, hole[0]) || loopsIntersect(outer, hole, epsilon, budget)) {
             throw new GeometryError("INVALID_TOPOLOGY", "Every hole must lie inside its exterior.");
         }
     }
@@ -254,8 +254,8 @@ const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
             if (!boundsOverlap(previous, current, 2 * epsilon))
                 continue;
             if (loopsIntersect(previous.loop, current.loop, epsilon, budget) ||
-                loopContainsPoint(previous.loop, current.loop[0]) ||
-                loopContainsPoint(current.loop, previous.loop[0])) {
+                contourContainsPoint(previous.loop, current.loop[0]) ||
+                contourContainsPoint(current.loop, previous.loop[0])) {
                 throw new GeometryError("INVALID_TOPOLOGY", "Polygon holes must be disjoint.");
             }
         }
@@ -273,7 +273,7 @@ const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
  * Validates a disjoint explicit region and returns immutable normalized data.
  * Previously validated immutable results may be returned unchanged under the same tolerance policy.
  */
-export function normalizeRegion2(region, tolerance = {}) {
+export function normalizeRegion(region, tolerance = {}) {
     const policy = resolveGeometryTolerance(1, tolerance);
     if (samePolicy(normalizedRegions.get(region), policy))
         return region;
@@ -284,8 +284,8 @@ export function normalizeRegion2(region, tolerance = {}) {
     }
     const budget = { candidates: 0 };
     const polygons = region.map((polygon) => normalizePolygonWithBudget(polygon, policy, budget));
-    const containsFilledPoint = (polygon, point) => loopContainsPoint(polygon.outer, point) &&
-        !polygon.holes.some((hole) => loopContainsPoint(hole, point));
+    const containsFilledPoint = (polygon, point) => contourContainsPoint(polygon.outer, point) &&
+        !polygon.holes.some((hole) => contourContainsPoint(hole, point));
     // Broad phase preserves exact contact semantics while avoiding pairwise loop
     // walks for separated polygons (for example many disconnected QR modules).
     const bounded = polygons
@@ -336,7 +336,7 @@ export function normalizeRegion2(region, tolerance = {}) {
  * Returns the total filled area of a normalized region in square millimetres.
  *
  * Each polygon contributes its outer-loop area minus the areas of its holes. An empty region has
- * zero area. Call {@link normalizeRegion2} first when input winding or topology is not already
+ * zero area. Call {@link normalizeRegion} first when input winding or topology is not already
  * canonical.
  *
  * @param region - Normalized disjoint polygons with CCW outers and clockwise holes.
@@ -344,8 +344,8 @@ export function normalizeRegion2(region, tolerance = {}) {
  */
 export function regionArea(region) {
     return region.reduce((total, polygon) => total +
-        Math.abs(signedAreaLoop2(polygon.outer)) -
-        polygon.holes.reduce((holeTotal, hole) => holeTotal + Math.abs(signedAreaLoop2(hole)), 0), 0);
+        Math.abs(signedContourArea(polygon.outer)) -
+        polygon.holes.reduce((holeTotal, hole) => holeTotal + Math.abs(signedContourArea(hole)), 0), 0);
 }
 /** Returns finite axis-aligned bounds for a non-empty region. */
 export function regionBounds(region) {

package/dist/geometry/resolution.js

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

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

@@ -1,10 +1,10 @@
 import { GeometryError } from "../errors.js";
-import { triangulateLoop2 } from "../loft.js";
-import { validateTriangleMesh } from "../mesh.js";
+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 { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
-import { normalizeLoop2 } from "../regions.js";
+import { normalizeContour } from "../regions.js";
 import { assertSamplingCount } from "../sampling-limits.js";
 const AXIS_EPSILON = 1e-10;
 /**
@@ -52,7 +52,7 @@ export const revolveMesh = (profile, options = {}) => {
         }
         maximumRadius = Math.max(maximumRadius, radius);
     }
-    profile = normalizeLoop2(profile, true);
+    profile = normalizeContour(profile, true);
     const circularSegments = resolveCircularPrimitiveSegments(maximumRadius, options, "revolveMesh");
     const closed = degrees === 360;
     const segments = closed
@@ -117,7 +117,7 @@ export const revolveMesh = (profile, options = {}) => {
         }
     }
     if (!closed) {
-        const cap = triangulateLoop2(profile);
+        const cap = triangulateContour(profile);
         const at = (profileIndex, station) => vertexIndices[profileIndex][profile[profileIndex][0] <= AXIS_EPSILON ? 0 : station];
         for (let offset = 0; offset < cap.length; offset += 3) {
             const a = cap[offset], b = cap[offset + 1], c = cap[offset + 2];