@metamesh/modeling 0.13.0 → 0.15.0

package/dist/geometry/anchors.js

@@ -1,4 +1,6 @@
 import { GeometryError } from "./errors.js";
+import { vector3Data } from "./math/vector-value.js";
+import { cross3, dot3 } from "./math/vector3.js";
 import { resolveGeometryTolerance } from "./tolerance.js";
 import { composeTransform3, frameTransform3, inverseTransform3 } from "./transform3.js";
 const boxFaces = {
@@ -71,7 +73,7 @@ export function boxAnchor3(options) {
             return origin[axis] + (direction[axis] * size[axis]) / 2;
         return (origin[axis] + (direction[axis] > 0 ? size[axis] : direction[axis] < 0 ? 0 : size[axis] / 2));
     };
-    return createAnchor3([coordinate(0), coordinate(1), coordinate(2)], direction, up);
+    return anchor3([coordinate(0), coordinate(1), coordinate(2)], direction, up);
 }
 /** Creates a cap-center or radial-side anchor using cylinder()'s construction origin.
  * @remarks Both centered and noncentered cylinders extend along +Z. Side angle uses degrees;
@@ -82,12 +84,12 @@ export function cylinderAnchor3(options) {
     assertAnchorOptions(options, operation);
     const origin = primitiveAnchorOrigin(options, operation);
     const { radius, height, face } = options;
-    const angleDegrees = options.angleDegrees === undefined ? 0 : options.angleDegrees;
+    const angle = options.angle === undefined ? 0 : options.angle;
     if (!Number.isFinite(radius) || radius <= 0 || !Number.isFinite(height) || height <= 0)
         throw new GeometryError("INVALID_ARGUMENT", "Cylinder anchor dimensions must be positive.", {
             operation,
         });
-    if (!Number.isFinite(angleDegrees))
+    if (!Number.isFinite(angle))
         throw new GeometryError("NON_FINITE_VALUE", "Cylinder anchor angle must be finite.", {
             operation,
         });
@@ -95,19 +97,13 @@ export function cylinderAnchor3(options) {
         throw new GeometryError("INVALID_ARGUMENT", "Unsupported cylinder anchor face.", { operation });
     const center = options.center ?? true;
     if (face === "top")
-        return createAnchor3([origin[0], origin[1], origin[2] + (center ? height / 2 : height)], [0, 0, 1], [0, 1, 0]);
+        return anchor3([origin[0], origin[1], origin[2] + (center ? height / 2 : height)], [0, 0, 1], [0, 1, 0]);
     if (face === "bottom")
-        return createAnchor3([origin[0], origin[1], origin[2] - (center ? height / 2 : 0)], [0, 0, -1], [0, 1, 0]);
-    const angle = angleDegrees * (Math.PI / 180);
-    const cosine = Math.cos(angle), sine = Math.sin(angle);
-    return createAnchor3([origin[0] + radius * cosine, origin[1] + radius * sine, origin[2] + (center ? 0 : height / 2)], [cosine, sine, 0], [0, 0, 1]);
+        return anchor3([origin[0], origin[1], origin[2] - (center ? height / 2 : 0)], [0, 0, -1], [0, 1, 0]);
+    const angleRadians = angle * (Math.PI / 180);
+    const cosine = Math.cos(angleRadians), sine = Math.sin(angleRadians);
+    return anchor3([origin[0] + radius * cosine, origin[1] + radius * sine, origin[2] + (center ? 0 : height / 2)], [cosine, sine, 0], [0, 0, 1]);
 }
-const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-const cross = (a, b) => [
-    a[1] * b[2] - a[2] * b[1],
-    a[2] * b[0] - a[0] * b[2],
-    a[0] * b[1] - a[1] * b[0],
-];
 const normalized = (vector, label, tolerance) => {
     if (!vector.every(Number.isFinite)) {
         throw new GeometryError("NON_FINITE_VALUE", `${label} coordinates must be finite.`);
@@ -134,34 +130,44 @@ const normalized = (vector, label, tolerance) => {
  * @returns A frozen anchor with unit, orthogonal direction and up vectors.
  * @throws {@link GeometryError} For non-finite or degenerate inputs.
  */
-export function createAnchor3(position, direction, up = [0, 1, 0], tolerance = {}) {
-    if (!position.every(Number.isFinite)) {
-        throw new GeometryError("NON_FINITE_VALUE", "Anchor position coordinates must be finite.");
-    }
-    const resolved = resolveGeometryTolerance(Math.max(1, Math.hypot(direction[0], direction[1], direction[2])), tolerance);
-    const zAxis = normalized(direction, "Anchor direction", resolved.linear);
+export function anchor3(position, direction, up = [0, 1, 0], tolerance = {}) {
+    const coordinates = (input) => {
+        const values = vector3Data(input);
+        const point = [values[0], values[1], values[2]];
+        if (!point.every(Number.isFinite))
+            throw new GeometryError("NON_FINITE_VALUE", "Anchor coordinates must be finite.", {
+                operation: "anchor3",
+            });
+        return point;
+    };
+    const point = coordinates(position);
+    const normal = coordinates(direction);
+    const roll = coordinates(up);
+    const resolved = resolveGeometryTolerance(Math.max(1, Math.hypot(normal[0], normal[1], normal[2])), tolerance);
+    const zAxis = normalized(normal, "Anchor direction", resolved.linear);
+    const rollProjection = dot3(roll, zAxis);
     const projectedUp = [
-        up[0] - zAxis[0] * dot(up, zAxis),
-        up[1] - zAxis[1] * dot(up, zAxis),
-        up[2] - zAxis[2] * dot(up, zAxis),
+        roll[0] - zAxis[0] * rollProjection,
+        roll[1] - zAxis[1] * rollProjection,
+        roll[2] - zAxis[2] * rollProjection,
     ];
     const normalizedUp = normalized(projectedUp, "Anchor up direction", resolved.linear);
     return Object.freeze({
         direction: zAxis,
-        position: Object.freeze([position[0], position[1], position[2]]),
+        position: Object.freeze(point),
         up: normalizedUp,
     });
 }
 /**
  * Converts an anchor into a right-handed frame with direction as local +Z.
  *
- * @param anchor - Anchor created by {@link createAnchor3} or equivalent valid data.
+ * @param anchor - Anchor created by {@link anchor3} or equivalent valid data.
  * @param tolerance - Optional comparison overrides.
  * @returns A normalized right-handed frame at the anchor position.
  */
 export function anchorFrame3(anchor, tolerance = {}) {
-    const normalizedAnchor = createAnchor3(anchor.position, anchor.direction, anchor.up, tolerance);
-    const xAxis = normalized(cross(normalizedAnchor.up, normalizedAnchor.direction), "Anchor X axis", 0);
+    const normalizedAnchor = anchor3(anchor.position, anchor.direction, anchor.up, tolerance);
+    const xAxis = normalized(cross3(normalizedAnchor.up, normalizedAnchor.direction), "Anchor X axis", 0);
     return Object.freeze({
         origin: normalizedAnchor.position,
         xAxis,
@@ -183,9 +189,9 @@ export function anchorFrame3(anchor, tolerance = {}) {
  * @returns A frozen affine transform for the moving object.
  * @throws {@link GeometryError} For invalid anchors or non-finite options.
  */
-export function attachTransform(source, target, options = {}) {
+export function attachmentTransform3(source, target, options = {}) {
     const gap = options.gap ?? 0;
-    const spin = options.spinRadians ?? 0;
+    const spin = options.spin ?? 0;
     if (options.alignment !== undefined &&
         options.alignment !== "opposed" &&
         options.alignment !== "same") {
@@ -195,13 +201,14 @@ export function attachTransform(source, target, options = {}) {
         throw new GeometryError("NON_FINITE_VALUE", "Attachment gap and spin must be finite.");
     }
     const sourceFrame = anchorFrame3(source, options.tolerance);
-    const targetAnchor = createAnchor3(target.position, target.direction, target.up, options.tolerance);
+    const targetAnchor = anchor3(target.position, target.direction, target.up, options.tolerance);
     const desiredDirection = (options.alignment ?? "opposed") === "opposed"
         ? [-targetAnchor.direction[0], -targetAnchor.direction[1], -targetAnchor.direction[2]]
         : targetAnchor.direction;
-    const baseFrame = anchorFrame3(createAnchor3(targetAnchor.position, desiredDirection, targetAnchor.up, options.tolerance), options.tolerance);
-    const cosine = Math.cos(spin);
-    const sine = Math.sin(spin);
+    const baseFrame = anchorFrame3(anchor3(targetAnchor.position, desiredDirection, targetAnchor.up, options.tolerance), options.tolerance);
+    const spinRadians = ((spin % 360) * Math.PI) / 180;
+    const cosine = Math.cos(spinRadians);
+    const sine = Math.sin(spinRadians);
     const spunX = [
         baseFrame.xAxis[0] * cosine + baseFrame.yAxis[0] * sine,
         baseFrame.xAxis[1] * cosine + baseFrame.yAxis[1] * sine,

package/dist/geometry/curves/sampling.js

@@ -28,10 +28,10 @@ export function createSpatialSampleWriter() {
 /** @internal Exact counts override physical resolution, but never the finite output budget. */
 export function resolveSamplingBudget(options) {
     const selected = resolveGeometrySamplingLimits(options.limits).maxPathPoints;
-    const maximum = options.maximumVertices ?? selected;
-    if (options.maximumVertices !== undefined &&
+    const maximum = options.maxVertices ?? selected;
+    if (options.maxVertices !== undefined &&
         (!Number.isSafeInteger(maximum) || maximum < 2 || maximum > selected))
-        curveFailure("INVALID_ARGUMENT", "maximumVertices must be at least two and cannot raise maxPathPoints.");
+        curveFailure("INVALID_ARGUMENT", "maxVertices must be at least two and cannot raise maxPathPoints.");
     if (options.segments !== undefined &&
         (!Number.isSafeInteger(options.segments) || options.segments < 1))
         curveFailure("INVALID_ARGUMENT", "segments must be a positive safe integer.");
@@ -76,10 +76,10 @@ function validateArc(curve) {
     validateCurvePoint3(curve.yAxis);
     if (!Number.isFinite(curve.radius) ||
         curve.radius <= 0 ||
-        !Number.isFinite(curve.sweepDegrees) ||
-        curve.sweepDegrees === 0 ||
-        Math.abs(curve.sweepDegrees) > 360 ||
-        !Number.isFinite(curve.startDegrees ?? 0))
+        !Number.isFinite(curve.sweepAngle) ||
+        curve.sweepAngle === 0 ||
+        Math.abs(curve.sweepAngle) > 360 ||
+        !Number.isFinite(curve.startAngle ?? 0))
         curveFailure("INVALID_ARGUMENT", "Arc radius must be positive and its nonzero degree sweep at most 360.");
     if (Math.abs(Math.hypot(...curve.xAxis) - 1) > 1e-10 ||
         Math.abs(Math.hypot(...curve.yAxis) - 1) > 1e-10 ||
@@ -91,17 +91,17 @@ function validateArc(curve) {
 function sampleArc(curve, options, maximum, createWriter) {
     validateArc(curve);
     const segments = options.segments ??
-        resolveArcSegments(curve.radius, curve.sweepDegrees, options.resolution, options.limits);
+        resolveArcSegments(curve.radius, curve.sweepAngle, options.resolution, options.limits);
     assertSampleVertexCount(segments + 1, maximum);
     const writer = createWriter();
     const point = [0, 0, 0];
     const tangent = [0, 0, 0];
     const firstPoint = [0, 0, 0];
-    const sign = Math.sign(curve.sweepDegrees);
+    const sign = Math.sign(curve.sweepAngle);
     for (let i = 0; i <= segments; i++) {
-        const angle = (((curve.startDegrees ?? 0) + (curve.sweepDegrees * i) / segments) * Math.PI) / 180;
+        const angle = (((curve.startAngle ?? 0) + (curve.sweepAngle * i) / segments) * Math.PI) / 180;
         const cos = Math.cos(angle), sin = Math.sin(angle);
-        if (i === segments && Math.abs(curve.sweepDegrees) === 360) {
+        if (i === segments && Math.abs(curve.sweepAngle) === 360) {
             point[0] = firstPoint[0];
             point[1] = firstPoint[1];
             point[2] = firstPoint[2];
@@ -138,8 +138,8 @@ export function cubicControlMeetsPolicy(control, policy) {
  * Every control interval must meet the physical policy, including flatter regions subdivided to
  * match curved ones. The depth-first traversal retains only one bounded stack, without output points.
  */
-export function resolveUniformCubicSegments(control, policy, maximum, minimumSegments = 1) {
-    let segments = minimumSegments;
+export function resolveUniformCubicSegments(control, policy, maximum, minSegments = 1) {
+    let segments = minSegments;
     for (let depth = 0; depth <= 32; depth += 1) {
         assertSampleVertexCount(segments, maximum);
         const pending = [{ control, intervals: segments }];
@@ -241,7 +241,7 @@ export function sampleCurve3(curve, options = {}) {
  * frozen. At stationary tangents, outgoing secants are preferred and endpoints use a backward fallback.
  * @example
  * ```ts
- * const turn = sampleCurve2({kind: "arc", center: [0,0], radius: 10, sweepDegrees: 90});
+ * const turn = sampleCurve2({kind: "arc", center: [0,0], radius: 10, sweepAngle: 90});
  * ```
  */
 export function sampleCurve2(curve, options = {}) {

package/dist/geometry/edge-finishing.js

@@ -113,7 +113,7 @@ export function edgeTreatmentPointCount(treatment, operation, options = {}) {
                 : exact;
         if (!Number.isSafeInteger(intervals) || intervals < 1)
             fail(operation, "Smooth treatment segments must be a positive safe integer.");
-        assertSamplingCount(intervals, operation, Math.min(policy?.maximumSegments ?? selected.limits.maxCircularSegments, selected.limits.maxCircularSegments));
+        assertSamplingCount(intervals, operation, Math.min(policy?.maxSegments ?? selected.limits.maxCircularSegments, selected.limits.maxCircularSegments));
     }
     assertSamplingCount(intervals + 1, operation, selected.limits.maxProfilePoints);
     return intervals + 1;

package/dist/geometry/extrusion.js

@@ -1,4 +1,5 @@
 import { GeometryError } from "./errors.js";
+import { vector2Data } from "./math/vector-value.js";
 import { assertPositivePrimitive, assertPrimitiveOptions } from "./primitive-resolvers.js";
 import { resolveGeometryResolution } from "./resolution.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits } from "./sampling-limits.js";
@@ -12,17 +13,13 @@ export function resolveExtrusionControls(height, options, operation) {
             operation,
         });
     }
-    const twistDegrees = options.twistDegrees ?? 0;
-    if (!Number.isFinite(twistDegrees)) {
-        throw new GeometryError("NON_FINITE_VALUE", "twistDegrees must be finite.", { operation });
+    const twist = options.twist ?? 0;
+    if (!Number.isFinite(twist)) {
+        throw new GeometryError("NON_FINITE_VALUE", "twist must be finite.", { operation });
     }
     const scaleTop = options.scaleTop ?? 1;
-    if (typeof scaleTop !== "number" && (!Array.isArray(scaleTop) || scaleTop.length !== 2)) {
-        throw new GeometryError("INVALID_ARGUMENT", "scaleTop must be a number or an exact XY tuple.", {
-            operation,
-        });
-    }
-    const scales = typeof scaleTop === "number" ? [scaleTop, scaleTop] : scaleTop;
+    const values = typeof scaleTop === "number" ? [scaleTop, scaleTop] : vector2Data(scaleTop);
+    const scales = [values[0], values[1]];
     if (!Number.isFinite(scales[0]) || !Number.isFinite(scales[1])) {
         throw new GeometryError("NON_FINITE_VALUE", "scaleTop values must be finite.", { operation });
     }
@@ -34,7 +31,7 @@ export function resolveExtrusionControls(height, options, operation) {
     }
     if (options.divisions !== undefined)
         assertSamplingCount(options.divisions + 2, operation, resolveGeometrySamplingLimits(options.limits).maxPathPoints);
-    return { scales, twistDegrees, center: options.center ?? false };
+    return { scales, twist, center: options.center ?? false };
 }
 /**
  * Resolves intermediate profile copies for linear extrusion from physical curve resolution.
@@ -86,7 +83,7 @@ export function resolveExtrusionDivisions(profile, height, options = {}) {
 /** @internal Shared sampling preflight over explicit contours, without rebuilding filled topology. */
 export function resolveExtrusionContourDivisions(contours, height, options) {
     const operation = "resolveExtrusionDivisions";
-    const { scales, twistDegrees } = resolveExtrusionControls(height, options, operation);
+    const { scales, twist } = resolveExtrusionControls(height, options, operation);
     const limits = resolveGeometrySamplingLimits(options.limits);
     let radius = 0, maximumEdgeLength = 0, profileCount = 0;
     for (const contour of contours) {
@@ -115,7 +112,7 @@ export function resolveExtrusionContourDivisions(contours, height, options) {
     if (options.divisions !== undefined)
         return options.divisions;
     const policy = resolveGeometryResolution(options.resolution, options.limits);
-    const angle = (Math.abs(twistDegrees) * Math.PI) / 180;
+    const angle = (Math.abs(twist) * Math.PI) / 180;
     const maximumScale = Math.max(1, Math.abs(scales[0]), Math.abs(scales[1]));
     const scaleChange = Math.max(Math.abs(scales[0] - 1), Math.abs(scales[1] - 1));
     // A linear scale multiplied by a rotation has second derivative bounded by this magnitude.
@@ -127,13 +124,13 @@ export function resolveExtrusionContourDivisions(contours, height, options) {
     b = (maximumEdgeLength * (maximumScale * angle + Math.abs(scales[0] - scales[1]))) / 4;
     const chordSegments = policy.circularSegments === undefined
         ? Math.max(1, Math.ceil((b + Math.hypot(b, 2 * Math.sqrt(a * policy.maxChordError))) /
-            (2 * policy.maxChordError)), Math.ceil((policy.minimumSegments * Math.abs(twistDegrees)) / 360))
-        : Math.max(1, Math.ceil((policy.circularSegments * Math.abs(twistDegrees)) / 360));
-    const angularCap = Math.max(1, scales[0] === scales[1] ? 0 : policy.maximumSegments, Math.ceil((policy.maximumSegments * Math.abs(twistDegrees)) / 360));
+            (2 * policy.maxChordError)), Math.ceil((policy.minSegments * Math.abs(twist)) / 360))
+        : Math.max(1, Math.ceil((policy.circularSegments * Math.abs(twist)) / 360));
+    const angularCap = Math.max(1, scales[0] === scales[1] ? 0 : policy.maxSegments, Math.ceil((policy.maxSegments * Math.abs(twist)) / 360));
     if (chordSegments > angularCap) {
         throw new GeometryError("COMPLEXITY_LIMIT", "Extrusion surface refinement exceeds the full-circle interval safety limit.", {
             operation,
-            details: { requiredSegments: chordSegments, maximumSegments: angularCap },
+            details: { requiredSegments: chordSegments, maxSegments: angularCap },
         });
     }
     const angularTravel = radius * maximumScale * angle;

package/dist/geometry/index.js

@@ -7,27 +7,30 @@ 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";
-export { anchorFrame3, attachTransform, boxAnchor3, createAnchor3, cylinderAnchor3, } from "./anchors.js";
+export { anchorFrame3, attachmentTransform3, boxAnchor3, anchor3, cylinderAnchor3, } from "./anchors.js";
 export { defaultGeometrySamplingLimits, resolveGeometrySamplingLimits, } from "./sampling-limits.js";
 export { GeometryError, isGeometryError, } from "./errors.js";
 export { resolveExtrusionDivisions, } from "./extrusion.js";
 export { extrudeMesh, loftMesh, triangulateContour, } from "./loft/loft.js";
-export { add3, cross3, dot3, length3, lerp3, normalize3, projectOntoPlane3, rotateAroundAxis3, scale3, subtract3, } from "./math/vector3.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";
-export { buildHelicalThreadRidgeMesh, buildHelicalThreadSolidMesh, } from "./mechanical/thread-mesh.js";
-export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, createThreadProfile, } from "./mechanical/thread-profiles.js";
+export { METRIC_FASTENER_STANDARDS, getMetricClearanceHoleDiameter, getMetricFastenerStandard, } from "./mechanical/standards.js";
+export { helicalThreadRidgeMesh, helicalThreadSolidMesh } from "./mechanical/thread-mesh.js";
+export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, threadProfile, } from "./mechanical/thread-profiles.js";
 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/mesh.js";
-export { createTriangleMeshSignature, } from "./mesh/mesh-signature.js";
+export { analyzeTriangleMesh, joinTriangleMeshes, meshBounds, reverseTriangleMesh, transformTriangleMesh, validateTriangleMesh, } from "./mesh/mesh.js";
+export { computeTriangleMeshSignature, } 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 { path2, path3, } from "./paths/path-value.js";
 export { distributeAlongPath, roundClosedPolylinePath, } from "./paths/planar.js";
 export { circleContour, rectangleContour, regularPolygonContour, starContour, } from "./profiles/profiles.js";
 export { closeToAxis, sampleSideProfile, } from "./profiles/side-profile.js";
@@ -38,10 +41,10 @@ export { contourContainsPoint, normalizeContour, normalizePolygon, normalizeRegi
 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 { strokeRegionData, } from "./stroke-path.js";
 export { sweepMesh } from "./sweeps/sweep-mesh.js";
 export { DEFAULT_GEOMETRY_TOLERANCE, resolveGeometryTolerance, } from "./tolerance.js";
-export { transformContour, transformPath2, transformPath3, transformRegion, } from "./transform-geometry.js";
+export { 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/loft-simple-mesh.js

@@ -1,15 +1,15 @@
 import { GeometryError } from "../errors.js";
-import { measureTriangleMesh, validateTriangleMesh } from "../mesh/mesh.js";
+import { analyzeTriangleMesh, 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;
-    const maximumVertices = count * rowCount, maximumTriangles = 2 * count * (rowCount - 1) + 2 * (count - 2);
-    const bytes = 12 * (maximumVertices + maximumTriangles);
-    assertMeshAllocationWithinLimits(maximumVertices, maximumTriangles, bytes, "loftMesh", limits);
-    const positions = new Float32Array(maximumVertices * 3), indices = new Uint32Array(maximumTriangles * 3);
+    const maxVertices = count * rowCount, maximumTriangles = 2 * count * (rowCount - 1) + 2 * (count - 2);
+    const bytes = 12 * (maxVertices + maximumTriangles);
+    assertMeshAllocationWithinLimits(maxVertices, maximumTriangles, bytes, "loftMesh", limits);
+    const positions = new Float32Array(maxVertices * 3), indices = new Uint32Array(maximumTriangles * 3);
     let vertexCount = 0, cursor = 0;
     const rows = geometry.world.map((contours, row) => {
         const points = [], vertices = [], slots = [];
@@ -78,7 +78,7 @@ export function simpleLoftMesh(geometry, limits) {
         positions: positions.slice(0, vertexCount * 3),
         indices: indices.slice(0, cursor),
     };
-    const volume = measureTriangleMesh(mesh).signedVolume;
+    const volume = analyzeTriangleMesh(mesh).signedVolume;
     if (volume === 0)
         throw new GeometryError("DEGENERATE_GEOMETRY", "Loft stations collapse to zero enclosed volume.", { operation: "loftMesh" });
     if (volume < 0)

package/dist/geometry/loft/loft.js

@@ -1,6 +1,7 @@
 import { GeometryError } from "../errors.js";
 import { resolveExtrusionControls, resolveExtrusionDivisions, } from "../extrusion.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits } from "../model-limits.js";
+import { capturePath2Input, path2InputData } from "../paths/path-value.js";
 import { assertSamplingCount } from "../sampling-limits.js";
 import { pointLoftProfile, prepareLoftGeometry } from "./loft-geometry.js";
 import {} from "./loft-options.js";
@@ -14,6 +15,7 @@ export { triangulateContour } from "./loft-triangulation.js";
  * Both ends use ear-clipped caps, supporting concave profiles without center fans.
  * Intermediate slices interpolate placed world vertices, never frame axes.
  * Transformed coordinates must fit finite Float32 mesh storage.
+ * Path2 profiles must be closed; raw point collections are interpreted as closed.
  *
  * @example Loft with explicit point correspondence
  * ```ts
@@ -30,21 +32,27 @@ export function loftMesh(stations, options) {
         throw new GeometryError("INVALID_ARGUMENT", "Loft requires at least two stations.", {
             operation: "loftMesh",
         });
-    const input = stations;
-    assertSamplingCount(input.length, "loftMesh", limits.maxPathPoints);
-    assertSamplingCount(input.reduce((sum, station) => {
-        if (!Array.isArray(station.profile))
-            throw new GeometryError("INVALID_ARGUMENT", "Pure loft profiles must be ordered point arrays.", { operation: "loftMesh" });
-        return sum + station.profile.length;
-    }, 0), "loftMesh", 1_000_000);
-    const profiles = input.map((station) => ({
-        ...station,
-        profile: pointLoftProfile(station.profile),
+    assertSamplingCount(stations.length, "loftMesh", limits.maxPathPoints);
+    const inputs = stations;
+    const input = inputs.map(({ profile, ...placement }) => ({
+        ...placement,
+        source: capturePath2Input(profile, true),
     }));
+    assertSamplingCount(input.reduce((sum, station) => sum + station.source.count, 0), "loftMesh", 1_000_000);
+    let remaining = 1_000_000;
+    const profiles = input.map(({ source, ...placement }) => {
+        const points = path2InputData(source.input, true, {
+            maxPathPoints: Math.max(1, Math.min(limits.maxProfilePoints, remaining)),
+        }).points;
+        assertSamplingCount(points.length, "loftMesh", remaining);
+        remaining -= points.length;
+        return { ...placement, profile: pointLoftProfile(points) };
+    });
     return simpleLoftMesh(prepareLoftGeometry(profiles, options, limits, false), limits);
 }
 /**
  * Linearly extrudes one simple profile along +Z with robust ear-clipped caps.
+ * Path2 profiles must be closed; raw point collections have an implicit closing edge.
  *
  * @example Extrude point data without an engine
  * ```ts
@@ -52,9 +60,9 @@ export function loftMesh(stations, options) {
  * extrudeMesh(outline, { height: 8 });
  * ```
  */
-export function extrudeMesh(profile, options) {
+export function extrudeMesh(input, options) {
     const { height } = options;
-    const { center, scales, twistDegrees } = resolveExtrusionControls(height, options, "extrudeMesh");
+    const { center, scales, twist } = resolveExtrusionControls(height, options, "extrudeMesh");
     if (!Number.isFinite(height) || height <= 0) {
         throw new GeometryError("INVALID_ARGUMENT", "Extrusion height must be finite and positive.", {
             operation: "extrudeMesh",
@@ -63,6 +71,7 @@ export function extrudeMesh(profile, options) {
     }
     const bottom = center ? -height / 2 : 0;
     const limits = resolveModelingLimits(options.limits);
+    const profile = path2InputData(input, true, { maxPathPoints: limits.maxProfilePoints }).points;
     assertSamplingCount(profile.length, "extrudeMesh", limits.maxProfilePoints);
     const divisions = resolveExtrusionDivisions(profile, height, options);
     const count = profile.length * (divisions + 2);
@@ -76,7 +85,7 @@ export function extrudeMesh(profile, options) {
     });
     const stations = Array.from({ length: divisions + 2 }, (_, index) => {
         const amount = index / (divisions + 1);
-        const angle = ((twistDegrees * Math.PI) / 180) * amount;
+        const angle = ((twist * Math.PI) / 180) * amount;
         const cosine = Math.cos(angle), sine = Math.sin(angle);
         const sx = 1 + (scales[0] - 1) * amount, sy = 1 + (scales[1] - 1) * amount;
         return {

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