@metamesh/modeling 0.14.0 → 0.16.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/bounds-value.js

@@ -0,0 +1,93 @@
+import { boundsCenter, boundsSize, containsBounds, validateBounds } from "./bounds.js";
+import { GeometryError } from "./errors.js";
+import { immutableMathClass } from "./math/immutable-value.js";
+import { vector2, vector3 } from "./math/vector-value.js";
+function fail(dimension, message) {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: `bounds${dimension}` });
+}
+function snapshot(input, dimension) {
+    if (typeof input !== "object" || input === null)
+        fail(dimension, "Bounds require minimum and maximum coordinate tuples.");
+    const { min, max } = input;
+    if (!Array.isArray(min) ||
+        !Array.isArray(max) ||
+        min.length !== dimension ||
+        max.length !== dimension)
+        fail(dimension, `Bounds require matching ${dimension}D minimum and maximum tuples.`);
+    const minimum = min, maximum = max;
+    const copy = (source) => Object.freeze(Array.from({ length: dimension }, (_, axis) => {
+        const value = source[axis];
+        return value === 0 ? 0 : value;
+    }));
+    const data = Object.freeze({ min: copy(minimum), max: copy(maximum) });
+    validateBounds(data, `bounds${dimension}`);
+    return data;
+}
+const PlanarBounds = /* @__PURE__ */ immutableMathClass(class PlanarBounds {
+    #data;
+    min;
+    max;
+    constructor(data) {
+        this.#data = data;
+        this.min = data.min;
+        this.max = data.max;
+        Object.freeze(this);
+    }
+    size() {
+        return vector2(boundsSize(this));
+    }
+    center() {
+        return vector2(boundsCenter(this));
+    }
+    containsBounds(other) {
+        return containsBounds(this, other);
+    }
+    toData() {
+        return this.#data;
+    }
+});
+const SpatialBounds = /* @__PURE__ */ immutableMathClass(class SpatialBounds {
+    #data;
+    min;
+    max;
+    constructor(data) {
+        this.#data = data;
+        this.min = data.min;
+        this.max = data.max;
+        Object.freeze(this);
+    }
+    size() {
+        return vector3(boundsSize(this));
+    }
+    center() {
+        return vector3(boundsCenter(this));
+    }
+    containsBounds(other) {
+        return containsBounds(this, other);
+    }
+    toData() {
+        return this.#data;
+    }
+});
+/**
+ * Snapshots finite ordered XY bounds in millimetres as an immutable fluent value.
+ *
+ * Zero extents are valid. Invalid dimensions, nonfinite coordinates, reversed bounds and
+ * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
+ * Compiled Generator packages passing these values to host recipes or computed data require
+ * runtime 8.0.0 or newer in major 8.
+ */
+export function bounds2(input) {
+    return new PlanarBounds(snapshot(input, 2));
+}
+/**
+ * Snapshots finite ordered XYZ bounds in millimetres as an immutable fluent value.
+ *
+ * Zero extents are valid. Invalid dimensions, nonfinite coordinates, reversed bounds and
+ * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
+ * Compiled Generator packages passing these values to host recipes or computed data require
+ * runtime 8.0.0 or newer in major 8.
+ */
+export function bounds3(input) {
+    return new SpatialBounds(snapshot(input, 3));
+}

package/dist/geometry/bounds.js

@@ -13,7 +13,8 @@ function vector(values, operation) {
         ? Object.freeze([normalized[0], normalized[1]])
         : Object.freeze([normalized[0], normalized[1], normalized[2]]);
 }
-function validate(bounds, operation) {
+/** Internal shared validation for tuple algorithms and immutable bounds snapshots. */
+export function validateBounds(bounds, operation) {
     if (typeof bounds !== "object" ||
         bounds === null ||
         !isArray(bounds.min) ||
@@ -54,23 +55,23 @@ export function boundsFromSize(dimensions, options = {}) {
     });
 }
 export function boundsSize(bounds) {
-    validate(bounds, "boundsSize");
+    validateBounds(bounds, "boundsSize");
     return vector(size(bounds), "boundsSize");
 }
 export function boundsCenter(bounds) {
-    validate(bounds, "boundsCenter");
+    validateBounds(bounds, "boundsCenter");
     return vector(center(bounds), "boundsCenter");
 }
 export function containsBounds(outer, inner) {
-    const dimension = validate(outer, "containsBounds");
-    if (validate(inner, "containsBounds") !== dimension)
+    const dimension = validateBounds(outer, "containsBounds");
+    if (validateBounds(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)
+    const dimension = validateBounds(source, operation);
+    if (validateBounds(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.");
@@ -94,6 +95,7 @@ export function fitBounds(source, target, options = {}) {
 }
 /**
  * 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 [].
  */
@@ -106,7 +108,7 @@ export function layoutRow(bounds, options = {}) {
         fail(operation, "Row gap must be finite and nonnegative.");
     let nextX = 0;
     return Object.freeze(Array.from(bounds, (item) => {
-        if (validate(item, operation) !== 3)
+        if (validateBounds(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;

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 }];
@@ -237,11 +237,10 @@ export function sampleCurve3(curve, options = {}) {
     return sampleCurve(curve, options, createSpatialSampleWriter);
 }
 /** Samples a planar curve with the same guarantees and policy as spatial sampling.
- * @remarks Private spatial scratch math is shared, while only final planar vectors are copied and
- * frozen. At stationary tangents, outgoing secants are preferred and endpoints use a backward fallback.
+ * @remarks Returned planar points and tangents are copied and 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/errors.js

@@ -50,6 +50,7 @@ export class GeometryError extends Error {
 }
 /**
  * Recognizes structured geometry errors from separately bundled Modeling copies in the same realm.
+ *
  * Ordinary errors and unmarked code-shaped objects are rejected. The marker is execution-local and
  * does not survive structured cloning; worker protocols carry their own serialized error envelope.
  */

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/heightfield.js

@@ -77,16 +77,27 @@ function planHeightfield(options, limits) {
         facts: Object.freeze({ sampleCount, vertexCount, triangleCount, byteCount }),
     };
 }
-/** Checks grid dimensions, coordinate precision, and allocation bounds before evaluating heights. */
+/**
+ * Checks grid options, Float32 axis precision, and output limits; returns exact mesh buffer counts.
+ *
+ * This pure operation needs no engine and neither evaluates `height` nor allocates mesh buffers.
+ * Successful preflight leaves height values, Float32 base storage, and generated mesh validity to
+ * construction. `byteCount` covers position and index buffers, not total working memory.
+ *
+ * @see {@link heightfieldMesh}
+ */
 export function preflightHeightfield(options, limits = {}) {
     return planHeightfield(options, limits).facts;
 }
 /**
  * Builds a closed indexed mesh from a rectilinear top, matched boundary walls, and flat base.
+ *
  * Heights run once per grid point after preflight; center-error adds one evaluation per cell.
  * Top winding is +Z, the base is -Z, and sides face outward. Coordinates and heights must fit
  * Float32 storage. Explicit axes are captured before sampling; shared wall vertices prevent cracks.
  *
+ * @see {@link preflightHeightfield}
+ *
  * @example Sample a closed wavy mesh
  * ```ts
  * heightfieldMesh({

package/dist/geometry/index.js

@@ -1,4 +1,5 @@
 /** Pure geometry foundations without host initialization. @packageDocumentation */
+export { bounds2, bounds3, } from "./bounds-value.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";
@@ -7,31 +8,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 { transform2, transform3, } from "./transform-chain.js";
+export { transform2, transform3, } from "./transform-value.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 { closestPointOnPath, } from "./paths/closest-point.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";
@@ -42,11 +42,12 @@ 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, transformRegionData, } 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";
 export { resamplePolyline2, resamplePolyline3, } from "./paths/resampling.js";
+export { resolveKnuckleHinge, } from "./mechanical/knuckle-hinge.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)