@metamesh/modeling 0.19.0 → 0.20.0

package/dist/geometry/profiles/primitives/ellipse.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../../errors.js";
 import { vector2Data } from "../../math/vector-value.js";
-import { resolveCircularPrimitiveSegments } from "../../primitive-resolution.js";
-import { assertPrimitiveOptions } from "../../primitive-resolvers.js";
+import { assertPrimitiveOptions } from "../../primitives/resolvers.js";
+import { resolveCircularPrimitiveSegments } from "../../primitives/sampling.js";
 import { requireFiniteProfileValues, requireProfileVertexCount } from "../validation.js";
 /**
  * Creates an immutable centered CCW ellipse with +X seam within the selected sampling ceiling.

package/dist/geometry/profiles/primitives/rectangle.js

@@ -1,10 +1,10 @@
-import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../../edge-finishing.js";
 import { GeometryError } from "../../errors.js";
+import { resolveModelingLimits } from "../../limits.js";
 import { vector2Data } from "../../math/vector-value.js";
-import { resolveModelingLimits } from "../../model-limits.js";
-import { assertPrimitiveOptions } from "../../primitive-resolvers.js";
-import { resolveAlignedCircularSegments } from "../../resolution.js";
-import { assertSamplingCount } from "../../sampling-limits.js";
+import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../../primitives/edges.js";
+import { assertPrimitiveOptions } from "../../primitives/resolvers.js";
+import { assertSamplingCount } from "../../sampling/limits.js";
+import { resolveAlignedCircularSegments } from "../../sampling/resolution.js";
 import { requireFiniteProfileValues, requireProfileVertexCount } from "../validation.js";
 const fail = (operation, message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation });
@@ -56,8 +56,8 @@ export function resolveRectangle(options, operation) {
         }
     return { width, height, corners, setbacks, limits };
 }
-/** @internal Resolves one quarter arc under the same exact and physical convention as native rectangles. */
-export function rectangleCornerSegments(corner, limits) {
+// Pure contours and identified profiles use the same quarter-arc sampling as native rectangles.
+function rectangleCornerSegments(corner, limits) {
     if (corner.kind !== "round")
         return 1;
     const selected = resolveModelingLimits(limits);
@@ -156,7 +156,7 @@ export function rectangleContour(options) {
  *
  * Use [rectangle](/docs/reference/model/rectangle) for a filled Section.
  *
- * @see {@link matchProfiles} to sample a family with shared landmark correspondence.
+ * @see [matchProfiles](/docs/reference/geometry/matchProfiles) to sample a family with shared landmark correspondence.
  * @see {@link rectangleContour} for sampled boundary coordinates.
  *
  * @example Retain rectangle landmarks

package/dist/geometry/profiles/primitives/star.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../../errors.js";
-import { assertPrimitiveOptions } from "../../primitive-resolvers.js";
+import { assertPrimitiveOptions } from "../../primitives/resolvers.js";
 import { requireFiniteProfileValues, requireProfileVertexCount } from "../validation.js";
 /**
  * Creates an immutable centered CCW alternating-radius star within the selected profile sampling ceiling.

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

@@ -1,7 +1,7 @@
 import { GeometryError } from "../errors.js";
-import { normalizeContour } from "../regions.js";
-import { resolveGeometryResolution } from "../resolution.js";
-import { resolveGeometrySamplingLimits } from "../sampling-limits.js";
+import { normalizeContour } from "../regions/operations.js";
+import { resolveGeometrySamplingLimits } from "../sampling/limits.js";
+import { resolveGeometryResolution } from "../sampling/resolution.js";
 import { requireProfileVertexCount } from "./validation.js";
 const OPERATION = "sampleSideProfile";
 const MAX_SEGMENTS = 31;
@@ -30,8 +30,8 @@ function distanceToChord(point, start, end) {
  * Neither normalized coordinates nor editor metadata are required. Endpoints are retained once;
  * 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 min(4096, maxProfilePoints).
+ * @param curve - Open outline in millimetres, or coordinates converted by the selected scales.
+ * @param options - Coordinate scales, physical sampling, and vertex limits.
  * @returns Frozen open polyline in millimetres, ordered from lowest to highest anchor.
  * @throws {@link GeometryError} for invalid coordinates, order, scale, or exceeded subdivision budget.
  *
@@ -144,6 +144,9 @@ export function sampleSideProfile(curve, options = {}) {
  * 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.
+ *
+ * @param side - [radius, height] points in millimetres, with increasing heights.
+ * @param limits - Point limits, including any added axis endpoints.
  */
 export function closeToAxis(side, limits) {
     const operation = "closeToAxis";

package/dist/geometry/profiles/validation.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../errors.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling/limits.js";
 /** @internal Validates finite dimensions shared by the pure profile factories. */
 export function requireFiniteProfileValues(values, operation) {
     if (!values.every(Number.isFinite)) {

package/dist/geometry/{polygon-clipping.js → regions/clipping.js}

@@ -1,5 +1,5 @@
 import * as clippingModule from "polygon-clipping";
-import { normalizeRegion } from "./regions.js";
+import { normalizeRegion } from "./operations.js";
 const moduleWithDefault = clippingModule;
 /** @internal Normalizes polygon-clipping's CommonJS and bundled ESM module shapes. */
 export const polygonClipping = moduleWithDefault.default ?? clippingModule;

package/dist/geometry/{convex-offset.js → regions/convex-offset.js}

@@ -1,4 +1,4 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
 /** @internal Parallel-edge offsets shared by convex extrusion rims and pocket entries. */
 export function convexContourOffsets(points, operation) {
     const fail = (message) => {

package/dist/geometry/{region-offset.js → regions/offset.js}

@@ -1,9 +1,11 @@
-import { GeometryError } from "./errors.js";
-import { resolveModelingLimits } from "./model-limits.js";
-import { normalizeRegionWithWork, signedContourArea } from "./regions.js";
-import { assertSamplingCount } from "./sampling-limits.js";
-import { resolveGeometryTolerance } from "./tolerance.js";
+import { GeometryError } from "../errors.js";
+import { resolveModelingLimits } from "../limits.js";
+import { assertSamplingCount } from "../sampling/limits.js";
+import { resolveGeometryTolerance } from "../tolerance.js";
+import { normalizeRegionWithWork, signedContourArea } from "./operations.js";
 const maximumWork = 2_000_000;
+// Keep these kernels local to isolate V8's array-type feedback from other modeling operations.
+// Shared helpers see more array representations, which can slow hot loops even when inlined.
 const cross = (a, b) => a[0] * b[1] - a[1] * b[0];
 const dot = (a, b) => a[0] * b[0] + a[1] * b[1];
 const difference = (a, b) => [a[0] - b[0], a[1] - b[1]];

package/dist/geometry/{regions.js → regions/operations.js}

@@ -1,5 +1,5 @@
-import { GeometryError } from "./errors.js";
-import { resolveGeometryTolerance } from "./tolerance.js";
+import { GeometryError } from "../errors.js";
+import { resolveGeometryTolerance } from "../tolerance.js";
 // Only our deeply frozen, canonical outputs enter these registries. Object.isFrozen alone
 // cannot establish validation provenance, and caller-owned inputs must never be cached.
 const normalizedLoops = new WeakMap();
@@ -27,10 +27,15 @@ const coordinateScale = (loop) => {
     }
     return Math.max(maxX - minX, maxY - minY);
 };
-/** Returns the signed area of a non-duplicated loop; positive means CCW. */
+/**
+ * Returns the signed area of a non-duplicated loop; positive means CCW.
+ *
+ * @param loop - XY loop in millimetres, with implicit closure; not validated.
+ */
 export function signedContourArea(loop) {
     if (loop.length === 0)
         return 0;
+    // Shift to a local origin and compensate the sum to retain small areas at large coordinates.
     const origin = loop[0];
     let twiceArea = 0, correction = 0;
     for (let index = 0; index < loop.length; index += 1) {
@@ -47,7 +52,12 @@ export function signedContourArea(loop) {
     }
     return (twiceArea + correction) / 2;
 }
-/** Returns true when a point lies inside or on the boundary of a loop. */
+/**
+ * Returns true when a point lies inside or on the boundary of a loop.
+ *
+ * @param loop - Simple XY loop with either winding.
+ * @param point - Query in the loop's coordinate system.
+ */
 export function contourContainsPoint(loop, point) {
     let inside = false;
     for (let index = 0, previous = loop.length - 1; index < loop.length; previous = index++) {
@@ -167,8 +177,11 @@ const loopsIntersect = (a, b, epsilon, budget) => a === b ||
  *
  * Adjacent duplicates and a repeated seam point are removed. Coordinates must
  * be finite, the effective loop must contain at least three points, and the
- * result must be simple and have non-zero area. Previously validated immutable results may be
+ * result must be simple and have nonzero area. Previously validated immutable results may be
  * returned unchanged when their winding and tolerance policy match.
+ *
+ * @param input - XY loop in millimetres; caller data is preserved.
+ * @param counterClockwise - true for an exterior, false for a hole.
  */
 export function normalizeContour(input, counterClockwise, tolerance = {}) {
     return normalizeLoopWithBudget(input, counterClockwise, tolerance, { candidates: 0 });
@@ -222,6 +235,8 @@ const normalizeLoopWithBudget = (input, counterClockwise, tolerance, budget) =>
  * Exteriors become CCW and holes clockwise. Every hole must lie strictly
  * within its exterior and boundaries may not intersect. Previously validated immutable results
  * may be returned unchanged under the same tolerance policy.
+ *
+ * @param polygon - Millimetre exterior and holes; boundaries must be disjoint.
  */
 export function normalizePolygon(polygon, tolerance = {}) {
     return normalizePolygonWithBudget(polygon, tolerance, { candidates: 0 });
@@ -272,6 +287,8 @@ 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.
+ *
+ * @param region - Disjoint millimetre polygons; empty input is valid.
  */
 export function normalizeRegion(region, tolerance = {}) {
     return normalizeRegionWithWork(region, tolerance).region;
@@ -298,30 +315,46 @@ function normalizeRegionWithBudget(region, tolerance, budget) {
         !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
-        .map((polygon) => {
-        let minX = Infinity;
-        let minY = Infinity;
-        let maxX = -Infinity;
-        let maxY = -Infinity;
-        for (const [x, y] of polygon.outer) {
-            minX = Math.min(minX, x);
-            minY = Math.min(minY, y);
-            maxX = Math.max(maxX, x);
-            maxY = Math.max(maxY, y);
-        }
-        return { polygon, minX, minY, maxX, maxY };
-    })
+    let bounded = polygons
+        .map((polygon) => ({ polygon, ...loopBounds(polygon.outer) }))
         .sort((a, b) => a.minX - b.minX);
+    const projectedCandidates = (ordered, minimum, maximum) => {
+        if (ordered.every((bounds, index) => index === 0 || ordered[index - 1][maximum] < bounds[minimum]))
+            return 0;
+        const ends = ordered.map((bounds) => bounds[maximum]).sort((a, b) => a - b);
+        let expired = 0;
+        let candidates = 0;
+        for (let index = 0; index < ordered.length; index++) {
+            while (ends[expired] < ordered[index][minimum])
+                expired++;
+            candidates += index - expired;
+        }
+        return candidates;
+    };
+    const horizontalCandidates = projectedCandidates(bounded, "minX", "maxX");
+    let minimum = "minX";
+    // Compare actual interval overlap: tall disjoint columns still belong on the X sweep.
+    // Ties retain X, and an already disjoint X projection needs no second sort.
+    if (horizontalCandidates > 0) {
+        const vertical = [...bounded].sort((a, b) => a.minY - b.minY);
+        if (projectedCandidates(vertical, "minY", "maxY") < horizontalCandidates) {
+            bounded = vertical;
+            minimum = "minY";
+        }
+    }
+    const maximum = minimum === "minY" ? "maxY" : "maxX";
+    const otherMinimum = minimum === "minY" ? "minX" : "minY";
+    const otherMaximum = minimum === "minY" ? "maxX" : "maxY";
     const active = [];
     for (const current of bounded) {
         let retained = 0;
         for (const candidate of active) {
-            if (candidate.maxX < current.minX)
+            if (candidate[maximum] < current[minimum])
                 continue;
             active[retained++] = candidate;
             consumeIntersectionCandidate(budget);
-            if (candidate.maxY < current.minY || current.maxY < candidate.minY)
+            if (candidate[otherMaximum] < current[otherMinimum] ||
+                current[otherMaximum] < candidate[otherMinimum])
                 continue;
             const a = current.polygon.outer;
             const b = candidate.polygon.outer;
@@ -357,7 +390,11 @@ export function regionArea(region) {
         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. */
+/**
+ * Returns finite axis-aligned bounds for a nonempty region.
+ *
+ * @param region - Nonempty region with finite millimetre exterior coordinates.
+ */
 export function regionBounds(region) {
     if (region.length === 0) {
         throw new GeometryError("DEGENERATE_GEOMETRY", "An empty region has no bounds.");

package/dist/geometry/{stroke-path.js → regions/stroke.js}

@@ -1,9 +1,9 @@
-import { GeometryError } from "./errors.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";
+import { GeometryError } from "../errors.js";
+import { path2InputData } from "../paths/value.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling/limits.js";
+import { resolveArcSegments, resolveCircularSegments, } from "../sampling/resolution.js";
+import { resolveGeometryTolerance } from "../tolerance.js";
+import { clippingRing, regionFromMultiPolygon, unionPolygonGeometry } from "./clipping.js";
 const DEFAULT_MITER_LIMIT = 4;
 function fail(message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "strokeRegionData" });
@@ -14,6 +14,7 @@ function ellipsePoints(center, radius, segments) {
         return [center[0] + Math.cos(angle) * radius, center[1] + Math.sin(angle) * radius];
     });
 }
+/** Builds an outer corner with an interior overlap; offset edges and miter tips stay fixed. */
 function cornerContour(previous, point, next, halfWidth, join) {
     const incomingLength = Math.hypot(point[0] - previous[0], point[1] - previous[1]);
     const outgoingLength = Math.hypot(next[0] - point[0], next[1] - point[1]);
@@ -31,7 +32,15 @@ function cornerContour(previous, point, next, halfWidth, join) {
     const side = turn > 0 ? -1 : 1;
     const before = [-incoming[1] * halfWidth * side, incoming[0] * halfWidth * side];
     const after = [-outgoing[1] * halfWidth * side, outgoing[0] * halfWidth * side];
-    const points = [point, [point[0] + before[0], point[1] + before[1]]];
+    // A vertex on both segment end edges can leave seams when clipping rounds intersections.
+    // Keep the anchor inside both rectangles instead; the half-width and segment-length bounds
+    // ensure the extra corner coverage stays within existing strips, even on short segments.
+    const overlap = Math.min(1, incomingLength / halfWidth, outgoingLength / halfWidth) / 2;
+    const anchor = [
+        point[0] - (before[0] + after[0]) * overlap,
+        point[1] - (before[1] + after[1]) * overlap,
+    ];
+    const points = [anchor, [point[0] + before[0], point[1] + before[1]]];
     const denominator = 1 + incoming[0] * outgoing[0] + incoming[1] * outgoing[1];
     // The outer offset-line intersection has radius halfWidth / cos(turnAngle / 2).
     // Apply SVG's miter ratio before division so sharp reversals cannot create an unbounded tip.
@@ -97,10 +106,15 @@ export function strokePathContours(input, options, exactCircularSegments) {
     const contours = [];
     const segmentCount = closed ? normalizedPath.length : normalizedPath.length - 1;
     const joinCount = closed ? normalizedPath.length : Math.max(0, normalizedPath.length - 2);
+    const capIntervals = !closed && cap === "round" ? resolveArcSegments(half, 180, { circularSegments }, limits) : 0;
     const constructionVertices = segmentCount * 4 +
         joinCount * (join === "round" ? circularSegments : join === "miter" ? 4 : 3) +
-        (!closed && cap === "round" ? 2 * circularSegments : 0);
+        (capIntervals > 0 ? 2 * (capIntervals - 1) : 0);
     assertSamplingCount(constructionVertices, "strokeRegionData", limits.maxProfilePoints);
+    const capArc = Array.from({ length: Math.max(0, capIntervals - 1) }, (_, index) => {
+        const angle = ((index + 1) * Math.PI) / capIntervals;
+        return [Math.cos(angle), Math.sin(angle)];
+    });
     for (let index = 0; index < segmentCount; index += 1) {
         let start = normalizedPath[index];
         let end = normalizedPath[(index + 1) % normalizedPath.length];
@@ -114,16 +128,28 @@ export function strokePathContours(input, options, exactCircularSegments) {
             }
         }
         const normal = [-tangent[1] * half, tangent[0] * half];
-        contours.push([
+        const contour = [
             [start[0] - normal[0], start[1] - normal[1]],
             [end[0] - normal[0], end[1] - normal[1]],
-            [end[0] + normal[0], end[1] + normal[1]],
-            [start[0] + normal[0], start[1] + normal[1]],
-        ]);
+        ];
+        // Insert only arc interiors into the end segments. Their existing +/-normal vertices
+        // are exact cap endpoints, so clipping never has to join a nearly tangent disk edge.
+        if (index === segmentCount - 1)
+            for (const [c, s] of capArc)
+                contour.push([
+                    end[0] - normal[0] * c + normal[1] * s,
+                    end[1] - normal[1] * c - normal[0] * s,
+                ]);
+        contour.push([end[0] + normal[0], end[1] + normal[1]], [start[0] + normal[0], start[1] + normal[1]]);
+        if (index === 0)
+            for (const [c, s] of capArc)
+                contour.push([
+                    start[0] + normal[0] * c - normal[1] * s,
+                    start[1] + normal[1] * c + normal[0] * s,
+                ]);
+        contours.push(contour);
     }
-    const disk = join === "round" || (!closed && cap === "round")
-        ? ellipsePoints([0, 0], half, circularSegments)
-        : [];
+    const disk = join === "round" ? ellipsePoints([0, 0], half, circularSegments) : [];
     const circleAt = ([x, y]) => disk.map(([u, v]) => [x + u, y + v]);
     if (join === "round") {
         const joinPoints = closed ? normalizedPath : normalizedPath.slice(1, -1);
@@ -139,9 +165,6 @@ export function strokePathContours(input, options, exactCircularSegments) {
                 contours.push(corner);
         }
     }
-    if (!closed && cap === "round") {
-        contours.push(circleAt(normalizedPath[0]), circleAt(normalizedPath.at(-1)));
-    }
     return contours;
 }
 /** @internal Polygon-clipping representation shared with the bounded SVG importer. */
@@ -159,8 +182,11 @@ export function strokePathMultiPolygon(path, options, circularSegments) {
  *
  * Closed paths omit a duplicated seam point. Zero-length sampled segments are ignored, while the
  * effective path must still contain visible length. Round caps and joins use deterministic physical
- * 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.
+ * resolution. Caps are tangent-aligned semicircles with `ceil(circularSegments / 2)` intervals,
+ * following {@link resolveArcSegments}. 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.
+ *
+ * @param path - Sampled XY path in millimetres; path values supply closure.
  */
 export function strokeRegionData(path, options) {
     const result = strokePathMultiPolygon(path, options);

package/dist/geometry/{loft/loft-triangulation.js → regions/triangulation.js}

@@ -1,5 +1,5 @@
 import { GeometryError } from "../errors.js";
-import { normalizeContour } from "../regions.js";
+import { normalizeContour } from "./operations.js";
 const maximumComparisons = 8_000_000;
 const cross = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
 const pointInTriangle = (point, a, b, c, epsilon) => {
@@ -8,7 +8,37 @@ const pointInTriangle = (point, a, b, c, epsilon) => {
     const ca = cross(c, a, point);
     return ab >= -epsilon && bc >= -epsilon && ca >= -epsilon;
 };
-/** Ear-clips one normalized simple CCW loop into stable local vertex indices. */
+const convexCap = (loop, epsilon) => {
+    const count = loop.length;
+    if (!loop.every((point, index) => cross(loop[(index - 1 + count) % count], point, loop[(index + 1) % count]) > epsilon))
+        return undefined;
+    const anchor = loop[count - 1];
+    for (let current = 0; current < count - 3; current++) {
+        const next = loop[current + 1];
+        // A convex chain's closest vertices to this diagonal are its two neighboring endpoints.
+        // Keep the ordinary ear path when tolerance could classify either neighbor inside the ear.
+        if (cross(anchor, loop[current], next) <= epsilon ||
+            cross(next, anchor, loop[current + 2]) >= -epsilon ||
+            cross(next, anchor, loop[count - 2]) >= -epsilon)
+            return undefined;
+    }
+    const triangles = new Uint32Array((count - 2) * 3);
+    let offset = 0;
+    for (let current = 0; current < count - 3; current++) {
+        triangles[offset++] = count - 1;
+        triangles[offset++] = current;
+        triangles[offset++] = current + 1;
+    }
+    triangles[offset++] = count - 3;
+    triangles[offset++] = count - 2;
+    triangles[offset] = count - 1;
+    return triangles;
+};
+/**
+ * Triangulates one simple loop into indices of its normalized CCW vertex order.
+ *
+ * @param loop - Boundary to normalize; indices address its cleaned CCW order.
+ */
 export function triangulateContour(loop) {
     const normalized = normalizeContour(loop, true);
     const assertComparisonLimit = (requiredCount) => {
@@ -32,6 +62,9 @@ export function triangulateContour(loop) {
     }
     const extent = Math.max(maxX - minX, maxY - minY);
     const epsilon = extent * extent * Number.EPSILON * 32;
+    const convex = convexCap(normalized, epsilon);
+    if (convex !== undefined)
+        return convex;
     const remaining = normalized.map((_, index) => index);
     const triangles = [];
     let comparisons = 0;

package/dist/geometry/revolve/{revolve-mesh.js → mesh.js}

@@ -1,12 +1,12 @@
 import { GeometryError } from "../errors.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 { path2InputData } from "../paths/path-value.js";
-import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
-import { normalizeContour } from "../regions.js";
-import { assertSamplingCount } from "../sampling-limits.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../limits.js";
+import { validateTriangleMesh } from "../mesh/operations.js";
+import { writeMeshVertex } from "../mesh/write-vertex.js";
+import { path2InputData } from "../paths/value.js";
+import { resolveCircularPrimitiveSegments } from "../primitives/sampling.js";
+import { normalizeContour } from "../regions/operations.js";
+import { triangulateContour } from "../regions/triangulation.js";
+import { assertSamplingCount } from "../sampling/limits.js";
 const AXIS_EPSILON = 1e-10;
 /**
  * Revolves a non-duplicated closed `[radius, z]` profile around +Z.
@@ -19,8 +19,7 @@ const AXIS_EPSILON = 1e-10;
  * 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 `{}`.
+ * @param input - Closed `[radius, Z]` profile in millimetres; radii must be non-negative.
  * @returns A closed indexed triangle mesh revolved counter-clockwise around +Z.
  *
  * @example Partial revolution with end caps

package/dist/geometry/{circular-sampling.js → sampling/circular.js}

@@ -1,6 +1,6 @@
-import { GeometryError } from "./errors.js";
-import { resolveCircularPrimitiveSegments } from "./primitive-resolution.js";
-import { assertPrimitiveOptions } from "./primitive-resolvers.js";
+import { GeometryError } from "../errors.js";
+import { assertPrimitiveOptions } from "../primitives/resolvers.js";
+import { resolveCircularPrimitiveSegments } from "../primitives/sampling.js";
 function fail(message, nonfinite = false) {
     throw new GeometryError(nonfinite ? "NON_FINITE_VALUE" : "INVALID_ARGUMENT", message, {
         operation: "resolveCircularSampling",

package/dist/geometry/{sampling-limits.js → sampling/limits.js}

@@ -1,4 +1,4 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
 /** Conservative defaults; trusted callers can supply larger explicit ceilings. */
 export const defaultGeometrySamplingLimits = Object.freeze({
     maxPathPoints: 100_000,
@@ -6,7 +6,11 @@ export const defaultGeometrySamplingLimits = Object.freeze({
     maxSweepProfilePoints: 4_096,
     maxCircularSegments: 512,
 });
-/** Resolves finite positive safe-integer allocation ceilings without ambient state. */
+/**
+ * Resolves finite positive safe-integer allocation ceilings without ambient state.
+ *
+ * @param overrides - Trusted overrides that may raise defaults; omitted fields keep them.
+ */
 export function resolveGeometrySamplingLimits(overrides = {}) {
     if (typeof overrides !== "object" || overrides === null || Array.isArray(overrides))
         throw new GeometryError("INVALID_ARGUMENT", "Sampling limits must be an object.", {

package/dist/geometry/{resolution.js → sampling/resolution.js}

@@ -1,5 +1,5 @@
-import { GeometryError } from "./errors.js";
-import { resolveGeometrySamplingLimits } from "./sampling-limits.js";
+import { GeometryError } from "../errors.js";
+import { resolveGeometrySamplingLimits } from "./limits.js";
 const DEFAULT_MAX_CHORD_ERROR = 0.05;
 const DEFAULT_MINIMUM_SEGMENTS = 16;
 const invalid = (message, details) => {
@@ -10,13 +10,12 @@ const invalid = (message, details) => {
 };
 /** @internal Resolves operation policy over explicit allocation ceilings and defaults. */
 export function resolveGeometryResolution(policy = {}, limits = {}) {
-    const merged = policy;
-    const circularSegments = merged.circularSegments;
+    const circularSegments = policy.circularSegments;
     const allowedMaximum = resolveGeometrySamplingLimits(limits).maxCircularSegments;
-    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;
+    const minSegments = policy.minSegments ?? Math.min(DEFAULT_MINIMUM_SEGMENTS, allowedMaximum);
+    const maxSegments = policy.maxSegments ?? allowedMaximum;
+    const maxChordError = policy.maxChordError ?? DEFAULT_MAX_CHORD_ERROR;
+    const maxSegmentLength = policy.maxSegmentLength;
     if (!Number.isSafeInteger(minSegments) || minSegments < 3) {
         invalid("minSegments must be an integer of at least three.", { minSegments });
     }
@@ -85,7 +84,8 @@ const assertRadius = (radius, operation) => {
  * `COMPLEXITY_LIMIT` rather than silently reducing quality.
  *
  * @param radius - Circle radius in millimetres.
- * @param policy - Optional operation-level policy under explicit sampling ceilings.
+ * @param policy - Optional operation-level policy under explicit sampling limits.
+ * @param limits - Full-circle segment limits; omitted fields use defaults.
  * @returns Full-circle segment count.
  * @throws {@link GeometryError} when radius or policy is invalid, or the requested tolerance
  * exceeds the configured segment safety limit.
@@ -139,7 +139,7 @@ const checkedLeastCommonMultiple = (left, right, operation) => {
 /**
  * Resolves a deterministic full-circle count aligned to reusable topology factors.
  *
- * `alignTo` must be non-empty and contain only positive safe integers. Its checked least common
+ * `alignTo` must be nonempty 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 `minSegments`. Adaptive counts are rounded upward and fail with
@@ -221,12 +221,13 @@ export function resolveAlignedCircularSegments(radius, options) {
 /**
  * Resolves the number of segments needed for a circular arc.
  *
- * Full-circle limits and exact circular counts are scaled to the requested angular span, matching
- * the reusable BOSL2-style convention while retaining at least one segment.
+ * Full-circle limits and exact circular counts are scaled to the requested angular span,
+ * retaining at least one segment.
  *
  * @param radius - Arc radius in millimetres.
- * @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.
+ * @param angle - Nonzero signed sweep angle no greater than 360 degrees in magnitude.
+ * @param policy - Explicit physical sampling policy; omitted fields use package defaults.
+ * @param limits - Full-circle segment limit, applied before scaling to the arc.
  * @returns Segment count for the requested arc span.
  * @throws {@link GeometryError} when radius, angle, or resolution policy is invalid, or the
  * corresponding full-circle tolerance exceeds the configured safety limit.

package/dist/geometry/svg/fill.js

@@ -1,6 +1,6 @@
-import { clippingRing, polygonClipping, regionFromMultiPolygon, unionPolygonGeometry, xorPolygonGeometry, } from "../polygon-clipping.js";
-import { signedContourArea } from "../regions.js";
-import { assertSamplingCount } from "../sampling-limits.js";
+import { clippingRing, polygonClipping, regionFromMultiPolygon, unionPolygonGeometry, xorPolygonGeometry, } from "../regions/clipping.js";
+import { signedContourArea } from "../regions/operations.js";
+import { assertSamplingCount } from "../sampling/limits.js";
 /** Private clipping stage with the selected execution's immutable allocation ceiling. */
 export function createBoundedSvgClipping(maxVertices) {
     function ringVertexCount(value) {
@@ -53,6 +53,7 @@ export function createBoundedSvgClipping(maxVertices) {
         const tolerance = Math.max(1, summedArea) * 1e-9;
         return Math.abs(summedArea - multiPolygonArea(union)) > tolerance;
     }
+    // Each polygon set stores one bit of coverage count. XOR adds bits; intersections carry.
     function addCoverageBits(left, right) {
         const output = [];
         let carry = [];