@metamesh/modeling 0.12.0 → 0.14.0

package/dist/engine/transform-operations.js

@@ -1,6 +1,9 @@
 import { attachTransform } from "../geometry/anchors.js";
+import { vector2Data, vector3Data, } from "../geometry/math/vector-value.js";
 import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
-import { eulerTransform3, scaleTransform3, translationTransform3 } from "../geometry/transform3.js";
+import { transform2, transform3, } from "../geometry/transform-chain.js";
+import { readTransformMatrix } from "../geometry/transform-matrix.js";
+import { eulerTransform3, scaleTransform3, translationTransform3, validateTransform3, } from "../geometry/transform3.js";
 import * as kernel from "./native/index.js";
 import { transformPrimitiveSectionProfile } from "./primitive-profiles.js";
 /** Internal host-bound transform operations. */
@@ -30,25 +33,24 @@ export function createTransformOperations(environment) {
             ? result
             : environment.rememberPrimitiveProfile(result, transformPrimitiveSectionProfile(profile, matrix));
     };
-    const translate = ((value, offset) => {
+    const translate = ((value, supplied) => {
         const native = resolveHandle(value);
+        const offset = native.kind === "section"
+            ? vector2Data(supplied)
+            : vector3Data(supplied);
         validateCoordinates(offset, native.kind === "section" ? 2 : 3, "translate");
         return native.kind === "section"
-            ? preserveProfile(value, ownSection(native.value.translate(offset)), [
-                1,
-                0,
-                offset[0],
-                0,
-                1,
-                offset[1],
-                0,
-                0,
-                1,
-            ])
+            ? preserveProfile(value, ownSection(native.value.translate(offset)), [1, 0, offset[0], 0, 1, offset[1], 0, 0, 1])
             : environment.preserveAnchors(value, wrapSolid(kernel.translate(scope, native.value, offset)), translationTransform3(offset));
     });
-    const rotate = ((value, degrees) => {
+    const rotate = ((value, supplied, options) => {
         const native = resolveHandle(value);
+        const degrees = typeof supplied === "number" ? supplied : vector3Data(supplied);
+        if (options !== undefined) {
+            return native.kind === "section"
+                ? transform(value, transform2().rotate(degrees, options))
+                : transform(value, transform3().rotate(degrees, options));
+        }
         if (native.kind === "section") {
             if (typeof degrees !== "number")
                 return throwGeometryError("INVALID_ARGUMENT", "rotate", "Section rotation requires a scalar angle.");
@@ -71,13 +73,26 @@ export function createTransformOperations(environment) {
         validateCoordinates(degrees, 3, "rotate");
         return environment.preserveAnchors(value, wrapSolid(kernel.rotate(scope, native.value, degrees)), eulerTransform3(degrees));
     });
-    const scale = ((value, factors) => {
+    const scale = ((value, supplied, options) => {
         const native = resolveHandle(value);
-        const values = typeof factors === "number" ? [factors] : factors;
+        const factors = typeof supplied === "number"
+            ? supplied
+            : native.kind === "section"
+                ? vector2Data(supplied)
+                : vector3Data(supplied);
+        if (options !== undefined) {
+            return native.kind === "section"
+                ? transform(value, transform2().scale(factors, options))
+                : transform(value, transform3().scale(factors, options));
+        }
         if (typeof factors !== "number")
             validateCoordinates(factors, native.kind === "section" ? 2 : 3, "scale");
-        if (!values.every(Number.isFinite) || values.some((factor) => factor === 0))
-            throwGeometryError("SINGULAR_TRANSFORM", "scale", "Scale factors must be finite and nonzero.");
+        const scaleMatrix = scaleTransform3(typeof factors === "number"
+            ? [factors, factors, native.kind === "section" ? 1 : factors]
+            : native.kind === "section"
+                ? [factors[0], factors[1], 1]
+                : factors);
+        validateTransform3(scaleMatrix);
         return native.kind === "section"
             ? preserveProfile(value, ownSection(native.value.scale(factors)), [
                 typeof factors === "number" ? factors : factors[0],
@@ -90,10 +105,13 @@ export function createTransformOperations(environment) {
                 0,
                 1,
             ])
-            : environment.preserveAnchors(value, wrapSolid(kernel.scale(scope, native.value, factors)), scaleTransform3(typeof factors === "number" ? [factors, factors, factors] : factors));
+            : environment.preserveAnchors(value, wrapSolid(kernel.scale(scope, native.value, factors)), scaleMatrix);
     });
-    const mirror = ((value, normal) => {
+    const mirror = ((value, supplied) => {
         const native = resolveHandle(value);
+        const normal = native.kind === "section"
+            ? vector2Data(supplied)
+            : vector3Data(supplied);
         validateCoordinates(normal, native.kind === "section" ? 2 : 3, "mirror");
         if (normal.every((coordinate) => coordinate === 0))
             throwGeometryError("INVALID_ARGUMENT", "mirror", "Mirror normal must be nonzero.");
@@ -139,18 +157,17 @@ export function createTransformOperations(environment) {
                 ]);
             })();
     });
-    const transform = ((value, matrix) => {
+    const transform = ((value, placement) => {
         const native = resolveHandle(value);
+        const matrix = native.kind === "solid"
+            ? transform3(readTransformMatrix(placement, 3)).toMatrix()
+            : transform2(readTransformMatrix(placement, 2)).toMatrix();
         if (native.kind === "solid") {
             validateCoordinates(matrix, 16, "transform");
             return environment.preserveAnchors(value, wrapSolid(kernel.transform(scope, native.value, matrix)), matrix);
         }
         validateCoordinates(matrix, 9, "transform");
         const m = matrix;
-        if (m[6] !== 0 || m[7] !== 0 || m[8] !== 1)
-            throwGeometryError("INVALID_ARGUMENT", "transform", "Section transform must be affine.");
-        if (m[0] * m[4] - m[1] * m[3] === 0)
-            throwGeometryError("SINGULAR_TRANSFORM", "transform", "Section transform must be nonsingular.");
         const columnMajor = [m[0], m[3], m[6], m[1], m[4], m[7], m[2], m[5], m[8]];
         return preserveProfile(value, ownSection(native.value.transform(columnMajor)), m);
     });

package/dist/geometry/bounds.js

@@ -0,0 +1,117 @@
+import { GeometryError } from "./errors.js";
+function fail(operation, message) {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation });
+}
+function isArray(value) {
+    return Array.isArray(value);
+}
+function vector(values, operation) {
+    if (values.some((value) => !Number.isFinite(value)))
+        fail(operation, "Bounds calculations must produce finite coordinates.");
+    const normalized = values.map((value) => (value === 0 ? 0 : value));
+    return values.length === 2
+        ? Object.freeze([normalized[0], normalized[1]])
+        : Object.freeze([normalized[0], normalized[1], normalized[2]]);
+}
+function validate(bounds, operation) {
+    if (typeof bounds !== "object" ||
+        bounds === null ||
+        !isArray(bounds.min) ||
+        !isArray(bounds.max) ||
+        (bounds.min.length !== 2 && bounds.min.length !== 3) ||
+        bounds.max.length !== bounds.min.length)
+        fail(operation, "Bounds require matching XY or XYZ minimum and maximum tuples.");
+    for (let axis = 0; axis < bounds.min.length; axis++) {
+        const minimum = bounds.min[axis], maximum = bounds.max[axis];
+        if (!Number.isFinite(minimum) || !Number.isFinite(maximum) || minimum > maximum)
+            fail(operation, "Bounds coordinates must be finite and ordered from minimum to maximum.");
+        if (!Number.isFinite(maximum - minimum))
+            fail(operation, "Bounds dimensions must be finite.");
+    }
+    return bounds.min.length;
+}
+function size(bounds) {
+    return bounds.max.map((value, axis) => value - bounds.min[axis]);
+}
+function center(bounds) {
+    return bounds.min.map((value, axis) => value / 2 + bounds.max[axis] / 2);
+}
+export function boundsFromSize(dimensions, options = {}) {
+    const operation = "boundsFromSize";
+    if (!isArray(dimensions) ||
+        (dimensions.length !== 2 && dimensions.length !== 3) ||
+        Array.from(dimensions).some((value) => !Number.isFinite(value) || value < 0))
+        fail(operation, "Bounds dimensions require two or three finite nonnegative values.");
+    if (typeof options !== "object" ||
+        options === null ||
+        isArray(options) ||
+        (options.center !== undefined && typeof options.center !== "boolean"))
+        fail(operation, "Bounds placement requires an optional boolean center value.");
+    const centered = options.center ?? true;
+    return Object.freeze({
+        min: vector(dimensions.map((value) => (centered ? -value / 2 : 0)), operation),
+        max: vector(dimensions.map((value) => (centered ? value / 2 : value)), operation),
+    });
+}
+export function boundsSize(bounds) {
+    validate(bounds, "boundsSize");
+    return vector(size(bounds), "boundsSize");
+}
+export function boundsCenter(bounds) {
+    validate(bounds, "boundsCenter");
+    return vector(center(bounds), "boundsCenter");
+}
+export function containsBounds(outer, inner) {
+    const dimension = validate(outer, "containsBounds");
+    if (validate(inner, "containsBounds") !== dimension)
+        fail("containsBounds", "Contained bounds must have the same dimension.");
+    return outer.min.every((value, axis) => inner.min[axis] >= value && inner.max[axis] <= outer.max[axis]);
+}
+export function fitBounds(source, target, options = {}) {
+    const operation = "fitBounds";
+    const dimension = validate(source, operation);
+    if (validate(target, operation) !== dimension)
+        fail(operation, "Source and target bounds must have the same dimension.");
+    if (typeof options !== "object" || options === null || isArray(options))
+        fail(operation, "Fitting options must be an object.");
+    if (options.maxScale !== undefined &&
+        (!Number.isFinite(options.maxScale) || options.maxScale <= 0))
+        fail(operation, "Maximum fitting scale must be finite and positive.");
+    const sourceSize = size(source), targetSize = size(target);
+    const ratios = sourceSize.flatMap((extent, axis) => extent === 0 ? [] : [targetSize[axis] / extent]);
+    if (ratios.length === 0)
+        fail(operation, "Fitting needs at least one positive source extent.");
+    const scale = Math.min(...ratios, options.maxScale ?? Infinity);
+    if (!Number.isFinite(scale) || scale <= 0)
+        fail(operation, "Target bounds must allow a finite positive fitting scale.");
+    const sourceCenter = center(source), targetCenter = center(target);
+    const position = vector(targetCenter.map((value, axis) => value - sourceCenter[axis] * scale), operation);
+    const bounds = Object.freeze({
+        min: vector(source.min.map((value, axis) => value * scale + position[axis]), operation),
+        max: vector(source.max.map((value, axis) => value * scale + position[axis]), operation),
+    });
+    return Object.freeze({ scale, position, bounds });
+}
+/**
+ * Returns immutable translations for a +X row of finite XYZ bounds with a nonnegative gap.
+ * Each minimum Y/Z becomes zero, and the first minimum X becomes zero. Supply bounds after
+ * any intended part rotation; translations apply to those bounds. An empty input returns [].
+ */
+export function layoutRow(bounds, options = {}) {
+    const operation = "layoutRow";
+    if (!isArray(bounds) || typeof options !== "object" || options === null || isArray(options))
+        fail(operation, "Row layout requires bounds and an options object.");
+    const gap = options.gap ?? 0;
+    if (!Number.isFinite(gap) || gap < 0)
+        fail(operation, "Row gap must be finite and nonnegative.");
+    let nextX = 0;
+    return Object.freeze(Array.from(bounds, (item) => {
+        if (validate(item, operation) !== 3)
+            fail(operation, "Row layout requires XYZ bounds.");
+        const position = vector([nextX - item.min[0], -item.min[1], -item.min[2]], operation);
+        nextX += item.max[0] - item.min[0] + gap;
+        if (!Number.isFinite(nextX))
+            fail(operation, "Row layout exceeds finite coordinates.");
+        return position;
+    }));
+}

package/dist/geometry/cylinder.js

@@ -60,11 +60,15 @@ export function resolveCylinderPrimitive(options) {
         invalid("Cylinder side dimensions must remain finite.");
     const sideX = radialChange / sideLength, sideZ = options.height / sideLength;
     const bottomAngle = Math.acos(-sideX), topAngle = Math.acos(sideX);
-    const bottom = options.ends?.bottom, top = options.ends?.top;
+    let bottom = options.ends?.bottom, top = options.ends?.top;
     const bottomSetbacks = bottom === undefined
         ? [0, 0]
         : edgeTreatmentSetbacks(bottom, "cylinder", bottomAngle, options.limits);
     const topSetbacks = top === undefined ? [0, 0] : edgeTreatmentSetbacks(top, "cylinder", topAngle, options.limits);
+    if (bottomSetbacks[0] === 0 && bottomSetbacks[1] === 0)
+        bottom = undefined;
+    if (topSetbacks[0] === 0 && topSetbacks[1] === 0)
+        top = undefined;
     if ((bottom && bottomRadius === 0) || (top && topRadius === 0))
         invalid("A zero-radius cone apex cannot receive an end treatment.");
     if ((bottom && bottomSetbacks[0] >= bottomRadius) || (top && topSetbacks[0] >= topRadius))

package/dist/geometry/edge-finishing.js

@@ -29,8 +29,8 @@ export function edgeTreatmentSetbacks(treatment, operation, angle = Math.PI / 2,
             throw new GeometryError("NON_FINITE_VALUE", "Treatment setbacks must be finite.", {
                 operation,
             });
-        if (result.some((value) => value <= 0))
-            fail(operation, "Treatment setbacks must be positive.");
+        if (result.some((value) => value < 0) || (result[0] === 0) !== (result[1] === 0))
+            fail(operation, "Treatment setbacks must be positive or both zero.");
     }
     else if (treatment.kind === "profile") {
         const points = treatment.profile;

package/dist/geometry/heightfield.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "./errors.js";
-import { validateTriangleMesh } from "./mesh.js";
+import { validateTriangleMesh } from "./mesh/mesh.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "./model-limits.js";
 import { writeMeshVertex } from "./numeric.js";
 function planHeightfield(options, limits) {

package/dist/geometry/index.js

@@ -1,6 +1,9 @@
 /** Pure geometry foundations without host initialization. @packageDocumentation */
-export { validateSolidMesh } from "./mesh-solid.js";
-export { computeTriangleMeshCentroid } from "./mesh-centroid.js";
+export { boundsFromSize, boundsSize, boundsCenter, containsBounds, fitBounds, layoutRow, } from "./bounds.js";
+export { fitTextLayout } from "./text-fitting.js";
+export { gridPatternTransforms, linearPatternTransforms, radialPatternTransforms, pathPatternTransforms, } from "./patterns.js";
+export { validateSolidMesh } from "./mesh/mesh-solid.js";
+export { computeTriangleMeshCentroid } from "./mesh/mesh-centroid.js";
 export { matchProfiles, } from "./profiles/matched.js";
 export { heightfieldMesh, preflightHeightfield, } from "./heightfield.js";
 export { preflightThreadedRodSolid as preflightThreadedRod, preflightInternalThreadCutterSolid as preflightInternalThreadCutter, preflightThreadedNutSolid as preflightThreadedNut, } from "./mechanical/thread-solids.js";
@@ -8,8 +11,11 @@ export { anchorFrame3, attachTransform, boxAnchor3, createAnchor3, cylinderAncho
 export { defaultGeometrySamplingLimits, resolveGeometrySamplingLimits, } from "./sampling-limits.js";
 export { GeometryError, isGeometryError, } from "./errors.js";
 export { resolveExtrusionDivisions, } from "./extrusion.js";
-export { extrudeMesh, loftMesh, triangulateLoop2, } from "./loft.js";
-export { add3, cross3, dot3, length3, lerp3, normalize3, projectOntoPlane3, rotateAroundAxis3, scale3, subtract3, } from "./math/vector3.js";
+export { extrudeMesh, loftMesh, triangulateContour, } from "./loft/loft.js";
+export { transform2, transform3, } from "./transform-chain.js";
+export { vector2, vector3, } from "./math/vector-value.js";
+export { add2, subtract2, scale2, dot2, cross2, length2, distance2, normalize2, lerp2, rotate2, } from "./math/vector2.js";
+export { add3, cross3, dot3, length3, distance3, lerp3, normalize3, projectOntoPlane3, scale3, subtract3, } from "./math/vector3.js";
 export { minimumCylindricalGearToothCountWithoutUndercut, resolveCylindricalGear, resolveCylindricalGearPair, resolveRackPitch, sampleCylindricalGearOutline, sampleInternalCylindricalGearSpaceOutline, sampleRackToothPath, } from "./mechanical/gears.js";
 export { measureInternalCylindricalGearPairMotion, } from "./mechanical/gear-motion.js";
 export { METRIC_FASTENER_STANDARDS, getMetricClearanceHole, getMetricFastenerStandard, } from "./mechanical/standards.js";
@@ -18,27 +24,28 @@ export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, cre
 export { preflightHelicalThreadSolidMesh, } from "./mechanical/thread-mesh-plan.js";
 export { sampleConventionalThreadHelices as sampleThreadHelices, } from "./mechanical/thread-helices.js";
 export { PRINTABLE_THREAD_FIT_POLICIES, compensateThreadDiameters, resolvePrintableThreadFitPolicy, resolveThreadCircularSegments, } from "./mechanical/threads.js";
-export { analyzeTriangleMesh, joinTriangleMeshes, measureTriangleMesh, meshBounds, reverseTriangleMesh, transformTriangleMesh, validateTriangleMesh, } from "./mesh.js";
-export { createTriangleMeshSignature, } from "./mesh-signature.js";
-export { optimizePlanarPatches, } from "./mesh-planar.js";
-export { analyzeTriangleMeshQuality, } from "./mesh-quality.js";
+export { analyzeTriangleMesh, joinTriangleMeshes, measureTriangleMesh, meshBounds, reverseTriangleMesh, transformTriangleMesh, validateTriangleMesh, } from "./mesh/mesh.js";
+export { createTriangleMeshSignature, } from "./mesh/mesh-signature.js";
+export { optimizePlanarPatches, } from "./mesh/mesh-planar.js";
+export { analyzeTriangleMeshQuality, } from "./mesh/mesh-quality.js";
 export { computeClosedParallelTransportFrames, computeParallelTransportFrames, } from "./paths/frames.js";
 export { sampleHelix } from "./paths/helix.js";
 export { cumulativePathLengths, pathLength } from "./paths/path.js";
+export { closestPointOnPath, } from "./paths/closest-point.js";
 export { distributeAlongPath, roundClosedPolylinePath, } from "./paths/planar.js";
-export { circleLoop, rectangleLoop, regularPolygonLoop, starLoop, } from "./profiles/profiles.js";
-export { sampleSideProfile, } from "./profiles/side-profile.js";
+export { circleContour, rectangleContour, regularPolygonContour, starContour, } from "./profiles/profiles.js";
+export { closeToAxis, sampleSideProfile, } from "./profiles/side-profile.js";
 export { sampleContour, } from "./profiles/contour.js";
-export { ellipseLoop } from "./profiles/shapes.js";
+export { ellipseContour } from "./profiles/shapes.js";
 export { rectangleProfile, } from "./profiles/rectangle.js";
-export { loopContainsPoint, normalizeLoop2, normalizePolygon2, normalizeRegion2, regionArea, regionBounds, signedAreaLoop2, } from "./regions.js";
+export { contourContainsPoint, normalizeContour, normalizePolygon, normalizeRegion, regionArea, regionBounds, signedContourArea, } from "./regions.js";
 export { resolveAlignedCircularSegments, resolveArcSegments, resolveCircularSegments, } from "./resolution.js";
 export { revolveMesh } from "./revolve/revolve-mesh.js";
 export { preflightSvgRegion, } from "./svg-import.js";
 export { strokePathRegion, } from "./stroke-path.js";
 export { sweepMesh } from "./sweeps/sweep-mesh.js";
 export { DEFAULT_GEOMETRY_TOLERANCE, resolveGeometryTolerance, } from "./tolerance.js";
-export { transformLoop2, transformPath2, transformPath3, transformRegion2, } from "./transform-geometry.js";
+export { transformContour, transformPath2, transformPath3, transformRegionData, } from "./transform-geometry.js";
 export { IDENTITY_TRANSFORM3, applyTransformDirection3, applyTransformPoint3, composeTransform3, eulerTransform3, frameTransform3, inverseTransform3, rotationTransform3, scaleTransform3, transformDeterminant3, translationTransform3, validateTransform3, } from "./transform3.js";
 export { sampleTextContours } from "./text-contours.js";
 export { sampleCurve2, sampleCurve3 } from "./curves/sampling.js";

package/dist/geometry/{loft-correspondence.js → loft/loft-correspondence.js}

@@ -1,6 +1,6 @@
-import { GeometryError } from "./errors.js";
-import { assertMeshAllocationWithinLimits } from "./model-limits.js";
-import { assertSamplingCount } from "./sampling-limits.js";
+import { GeometryError } from "../errors.js";
+import { assertMeshAllocationWithinLimits } from "../model-limits.js";
+import { assertSamplingCount } from "../sampling-limits.js";
 const maximumComparisons = 8_000_000;
 const fail = (message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "loft" });

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

@@ -1,10 +1,10 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
+import { normalizeContour, normalizeRegion, signedContourArea } from "../regions.js";
+import { resolveGeometryResolution } from "../resolution.js";
+import { assertSamplingCount } from "../sampling-limits.js";
+import { frameTransform3 } from "../transform3.js";
 import { alignLoftRows, assertLoftGrid, loftSubdivisions, sliceLoftRows, subdivideLoftRow, } from "./loft-correspondence.js";
 import { loftFrame, resolveLoftControls } from "./loft-options.js";
-import { normalizeLoop2, normalizeRegion2, signedAreaLoop2 } from "./regions.js";
-import { resolveGeometryResolution } from "./resolution.js";
-import { assertSamplingCount } from "./sampling-limits.js";
-import { frameTransform3 } from "./transform3.js";
 const fail = (message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "loft" });
 };
@@ -55,8 +55,8 @@ function checkedLoop(points, outer, authoritative, limits) {
     if (!Array.isArray(points))
         fail("Loft contours must be ordered point arrays.");
     assertSamplingCount(points.length, "loft", limits.maxProfilePoints);
-    normalizeLoop2(points, outer);
-    const sameWinding = signedAreaLoop2(points) > 0 === outer;
+    normalizeContour(points, outer);
+    const sameWinding = signedContourArea(points) > 0 === outer;
     if (!sameWinding && authoritative)
         fail("Identified loft contours must retain outer CCW and hole CW winding.");
     const copied = points.map((point) => [point[0], point[1]]);
@@ -106,7 +106,7 @@ export function prepareLoftGeometry(input, options, limits, authoritative, recip
     const maxLengths = input.map((_, index) => recipeSampled?.[index] === true ? undefined : resolution.maxSegmentLength);
     // Validate every original station's filled topology, including middle stations.
     // Inserted world grids may have no useful local plane and are checked by mesh topology.
-    input.forEach((station) => normalizeRegion2(station.profile.components.map((component) => ({
+    input.forEach((station) => normalizeRegion(station.profile.components.map((component) => ({
         outer: component.outer.points,
         holes: component.holes.map((hole) => hole.points),
     }))));

package/dist/geometry/{loft-options.js → loft/loft-options.js}

@@ -1,5 +1,5 @@
-import { GeometryError } from "./errors.js";
-import { frameTransform3 } from "./transform3.js";
+import { GeometryError } from "../errors.js";
+import { frameTransform3 } from "../transform3.js";
 /** @internal Resolves placement without sorting stations or interpolating their axes. */
 export function loftFrame(placement, operation = "loft") {
     if (typeof placement !== "object" ||

package/dist/geometry/{loft-simple-mesh.js → loft/loft-simple-mesh.js}

@@ -1,8 +1,8 @@
-import { GeometryError } from "./errors.js";
-import { triangulateLoop2 } from "./loft-triangulation.js";
-import { measureTriangleMesh, validateTriangleMesh } from "./mesh.js";
-import { assertMeshAllocationWithinLimits } from "./model-limits.js";
-import { writeMeshVertex } from "./numeric.js";
+import { GeometryError } from "../errors.js";
+import { measureTriangleMesh, validateTriangleMesh } from "../mesh/mesh.js";
+import { assertMeshAllocationWithinLimits } from "../model-limits.js";
+import { writeMeshVertex } from "../numeric.js";
+import { triangulateContour } from "./loft-triangulation.js";
 /** @internal Pure closed simple-contour strips, retaining repeated correspondence slots as shared physical vertices. */
 export function simpleLoftMesh(geometry, limits) {
     const count = geometry.world[0][0].length, rowCount = geometry.world.length;
@@ -68,7 +68,7 @@ export function simpleLoftMesh(geometry, limits) {
             triangle(a.slots[index], b.slots[next], b.slots[index]);
         }
     const cap = (row, top) => {
-        const contour = rows[row], triangles = triangulateLoop2(contour.points);
+        const contour = rows[row], triangles = triangulateContour(contour.points);
         for (let index = 0; index < triangles.length; index += 3)
             triangle(contour.vertices[triangles[index]], contour.vertices[triangles[index + (top ? 1 : 2)]], contour.vertices[triangles[index + (top ? 2 : 1)]]);
     };

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

@@ -1,5 +1,5 @@
-import { GeometryError } from "./errors.js";
-import { normalizeLoop2 } from "./regions.js";
+import { GeometryError } from "../errors.js";
+import { normalizeContour } from "../regions.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) => {
@@ -9,12 +9,12 @@ const pointInTriangle = (point, a, b, c, epsilon) => {
     return ab >= -epsilon && bc >= -epsilon && ca >= -epsilon;
 };
 /** Ear-clips one normalized simple CCW loop into stable local vertex indices. */
-export function triangulateLoop2(loop) {
-    const normalized = normalizeLoop2(loop, true);
+export function triangulateContour(loop) {
+    const normalized = normalizeContour(loop, true);
     const assertComparisonLimit = (requiredCount) => {
         if (requiredCount > maximumComparisons)
             throw new GeometryError("COMPLEXITY_LIMIT", "Profile cap triangulation exceeds its eight-million-comparison work limit.", {
-                operation: "triangulateLoop2",
+                operation: "triangulateContour",
                 details: { requiredCount, allowedCount: maximumComparisons },
             });
     };
@@ -59,7 +59,7 @@ export function triangulateLoop2(loop) {
             break;
         }
         if (!clipped) {
-            throw new GeometryError("INVALID_TOPOLOGY", "Profile cap triangulation could not find a valid ear.", { operation: "triangulateLoop2" });
+            throw new GeometryError("INVALID_TOPOLOGY", "Profile cap triangulation could not find a valid ear.", { operation: "triangulateContour" });
         }
     }
     triangles.push(remaining[0], remaining[1], remaining[2]);

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

@@ -1,11 +1,11 @@
-import { GeometryError } from "./errors.js";
-import { resolveExtrusionControls, resolveExtrusionDivisions, } from "./extrusion.js";
+import { GeometryError } from "../errors.js";
+import { resolveExtrusionControls, resolveExtrusionDivisions, } from "../extrusion.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits } from "../model-limits.js";
+import { assertSamplingCount } from "../sampling-limits.js";
 import { pointLoftProfile, prepareLoftGeometry } from "./loft-geometry.js";
 import {} from "./loft-options.js";
 import { simpleLoftMesh } from "./loft-simple-mesh.js";
-import { assertMeshAllocationWithinLimits, resolveModelingLimits } from "./model-limits.js";
-import { assertSamplingCount } from "./sampling-limits.js";
-export { triangulateLoop2 } from "./loft-triangulation.js";
+export { triangulateContour } from "./loft-triangulation.js";
 /**
  * Lofts simple point loops at z heights or explicit right-handed frames, in input order.
  *
@@ -17,8 +17,8 @@ export { triangulateLoop2 } from "./loft-triangulation.js";
  *
  * @example Loft with explicit point correspondence
  * ```ts
- * const bottom = rectangleLoop({ size: [20, 12] });
- * const top = rectangleLoop({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * const bottom = rectangleContour({ size: [20, 12] });
+ * const top = rectangleContour({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
  * loftMesh([{ profile: bottom, z: 0 }, { profile: top, z: 30 }], { correspondence: "reindex" });
  * ```
  */
@@ -48,7 +48,7 @@ export function loftMesh(stations, options) {
  *
  * @example Extrude point data without an engine
  * ```ts
- * const outline = rectangleLoop({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * const outline = rectangleContour({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
  * extrudeMesh(outline, { height: 8 });
  * ```
  */

package/dist/geometry/math/immutable-value.js

@@ -0,0 +1,20 @@
+// A versioned realm protocol lets separately bundled authoring values cross the host boundary.
+const immutableMath = Symbol.for("@metamesh/modeling/immutable-math/6");
+/**
+ * Brands and freezes only this constructor's prototype. Pure-annotated callers let bundlers
+ * discard unused classes without dropping initialization for classes that remain reachable.
+ */
+export function immutableMathClass(constructor) {
+    Object.defineProperty(constructor.prototype, immutableMath, { value: true });
+    Object.freeze(constructor.prototype);
+    return constructor;
+}
+/** Math values are atomic immutable inputs, rather than enumerable recipe data. */
+export function isImmutableMathValue(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return (Object.isFrozen(value) &&
+        typeof prototype === "object" &&
+        prototype !== null &&
+        Object.isFrozen(prototype) &&
+        Object.getOwnPropertyDescriptor(prototype, immutableMath)?.value === true);
+}