@metamesh/modeling 0.11.0 → 0.13.0

package/dist/geometry/mechanical/thread-profiles.js

@@ -1,6 +1,6 @@
 /** Periodic thread profiles and axial/radial fit compensation. */
 import { GeometryError } from "../errors.js";
-import { triangulateLoop2 } from "../loft.js";
+import { triangulateContour } from "../loft/loft.js";
 import { resolveGeometryTolerance } from "../tolerance.js";
 const BUTTRESS_DEFAULT_DEPTH_RATIO = 0.66271;
 const BUTTRESS_CREST_FLAT_RATIO = 0.16316;
@@ -207,7 +207,7 @@ export const createThreadRidgeSection = (points, minimum, linearTolerance, opera
     // closing the ridge section retraces its minor-envelope edge, creating overlapping cap faces and
     // zero-area triangles. Keep exactly the connected tooth plus its two root transition points.
     const section = points.slice(firstRaised - 1, lastRaised + 2);
-    triangulateLoop2([...section].reverse());
+    triangulateContour([...section].reverse());
     return section;
 };
 const standardProfile = (kind, pitch, depth, root, crest, leftRun, rightRun) => {

package/dist/geometry/mechanical/thread-surface.js

@@ -124,7 +124,7 @@ export const buildThreadSurfaceColumn = (profile, resolved, options, angle, maxi
     };
     const candidates = [];
     let order = 0;
-    const add = (z, kind = "regular", profileRadial, endFactor, surfaceRadius, profileOrdinal, atLeadTip = false) => {
+    const add = (z, { kind = "regular", profileRadial, endFactor, surfaceRadius, profileOrdinal, atLeadTip = false, } = {}) => {
         if (z < -resolved.tolerance.linear || z > resolved.length + resolved.tolerance.linear)
             return;
         candidates.push({
@@ -182,7 +182,12 @@ export const buildThreadSurfaceColumn = (profile, resolved, options, angle, maxi
             // redundant in this sparse mesher and would reintroduce dense, near-collinear triangles.
             for (const [profileIndex, [profileAxial, profileRadial],] of resolved.surfaceSection.entries()) {
                 const profileRadius = majorRadius + profileRadial;
-                add(center + profileAxial * scale.width, "profile", undefined, undefined, leadInEnvelopeRadius + (profileRadius - leadInEnvelopeRadius) * scale.height, period * resolved.surfaceSection.length + profileIndex, atBottomTip || atTopTip);
+                add(center + profileAxial * scale.width, {
+                    kind: "profile",
+                    surfaceRadius: leadInEnvelopeRadius + (profileRadius - leadInEnvelopeRadius) * scale.height,
+                    profileOrdinal: period * resolved.surfaceSection.length + profileIndex,
+                    atLeadTip: atBottomTip || atTopTip,
+                });
             }
         }
     }
@@ -191,7 +196,11 @@ export const buildThreadSurfaceColumn = (profile, resolved, options, angle, maxi
             const firstPeriod = Math.ceil((activeMinimum - phaseShift - profileAxial - resolved.tolerance.linear) / profile.pitch);
             const lastPeriod = Math.floor((activeMaximum - phaseShift - profileAxial + resolved.tolerance.linear) / profile.pitch);
             for (let period = firstPeriod; period <= lastPeriod; period += 1) {
-                add(phaseShift + profileAxial + period * profile.pitch, "profile", profileRadial, undefined, undefined, period * resolved.surfaceSection.length + profileIndex);
+                add(phaseShift + profileAxial + period * profile.pitch, {
+                    kind: "profile",
+                    profileRadial,
+                    profileOrdinal: period * resolved.surfaceSection.length + profileIndex,
+                });
             }
         }
     }
@@ -199,14 +208,14 @@ export const buildThreadSurfaceColumn = (profile, resolved, options, angle, maxi
         !usesScaledLeadIn &&
         resolved.bottomBoundary > resolved.tolerance.linear &&
         resolved.bottomBoundary < resolved.length - resolved.tolerance.linear) {
-        add(resolved.bottomBoundary, "forced-bottom", undefined, 0);
+        add(resolved.bottomBoundary, { kind: "forced-bottom", endFactor: 0 });
     }
     const upperThreadBoundary = resolved.topBoundary;
     if (resolved.top === "blunt" &&
         !usesScaledLeadIn &&
         upperThreadBoundary > resolved.tolerance.linear &&
         upperThreadBoundary < resolved.length - resolved.tolerance.linear) {
-        add(upperThreadBoundary, "forced-top", undefined, 0);
+        add(upperThreadBoundary, { kind: "forced-top", endFactor: 0 });
     }
     candidates.sort((left, right) => left.z - right.z || left.order - right.order);
     const normalized = [];

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

@@ -1,4 +1,4 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
 import { analyzeTriangleMesh } from "./mesh.js";
 /**
  * Computes the uniform-density volume centroid of an oriented closed solid, including cavity shells.

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

@@ -1,4 +1,4 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
 import { buildTriangleMeshQualityAnalysis, } from "./mesh-quality.js";
 const DEFAULT_MAXIMUM_FLIP_ATTEMPTS = 1_000_000;
 const DEFAULT_MAXIMUM_PATCH_TRIANGLE_COUNT = 50_000;

package/dist/geometry/{mesh-quality.js → mesh/mesh-quality.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";
 const DEFAULT_MAXIMUM_TRIANGLE_COUNT = 200_000;
 const FLOAT32_EPSILON = 2 ** -23;
 const MINIMUM_PLANAR_ANGULAR_TOLERANCE = 1e-5;

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

@@ -1,5 +1,5 @@
-import { GeometryError } from "./errors.js";
-import { analyzeTriangleMesh, validateTriangleMesh, } from "./mesh.js";
+import { GeometryError } from "../errors.js";
+import { analyzeTriangleMesh, validateTriangleMesh } from "./mesh.js";
 const DEFAULT_POSITION_TOLERANCE = 1e-5;
 const DEFAULT_VOLUME_TOLERANCE = 1e-4;
 const DEFAULT_MAXIMUM_TRIANGLE_COUNT = 200_000;

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

@@ -1,8 +1,8 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
+import { resolveGeometryTolerance } from "../tolerance.js";
 import { IndexedMeshEdgeTable } from "./mesh-edge-table.js";
 import { prepareSolidTriangle, trianglesIntersectBeyondSharedBoundary, triangleSolidAngle, } from "./mesh-solid-intersections.js";
 import { analyzeTriangleMesh } from "./mesh.js";
-import { resolveGeometryTolerance } from "./tolerance.js";
 const MAXIMUM_TRIANGLES = 200_000;
 const MAXIMUM_TESTS = 2_000_000;
 /**

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

@@ -1,8 +1,8 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
+import { writeMeshVertex } from "../numeric.js";
+import { resolveGeometryTolerance } from "../tolerance.js";
+import { transformDeterminant3, validateTransform3 } from "../transform3.js";
 import { IndexedMeshEdgeTable } from "./mesh-edge-table.js";
-import { writeMeshVertex } from "./numeric.js";
-import { resolveGeometryTolerance } from "./tolerance.js";
-import { transformDeterminant3, validateTransform3 } from "./transform3.js";
 function inspectTriangleMesh(mesh, options = {}, mode = "validate", topology = false) {
     // Snapshot meshes can expose owned-copy accessors. Read each buffer once before traversal.
     const source = { positions: mesh.positions, indices: mesh.indices };
@@ -161,10 +161,9 @@ export function analyzeTriangleMesh(mesh, options = {}) {
 /**
  * Validates mesh buffers, indices, triangle area, and optionally closed topology.
  *
- * Closed validation requires each edge to occur exactly twice with opposite
- * directions, rejecting boundary and non-manifold edges. Validation does not
- * mutate or copy the mesh. This establishes edge connectivity, not the absence
- * of geometric self-intersections between faces.
+ * Closed validation requires exactly two oppositely directed uses per edge, rejecting boundary
+ * and non-manifold edges. It establishes edge connectivity without detecting geometric
+ * self-intersections between faces. The mesh is neither mutated nor copied.
  *
  * @param mesh - Mesh to inspect.
  * @param options - Empty-mesh, topology, and tolerance policy.

package/dist/geometry/paths/frames.js

@@ -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) {

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-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);
+}