@metamesh/modeling 0.17.0 → 0.18.0

package/dist/engine/{session-snapshot.js → session/snapshot-cache.js}

@@ -1,26 +1,22 @@
-import { GeometryError } from "../geometry/errors.js";
-import { vector3Data } from "../geometry/math/vector-value.js";
-import { isImmutableBuffer } from "../model/immutable-buffer.js";
-import { createGeometryFinalizer, rememberSnapshotPart, } from "./finalization.js";
-import { createModelSummary } from "./model-summary.js";
-import { placeFinalizedGeometry } from "./placement.js";
+import { GeometryError } from "../../geometry/errors.js";
+import { isImmutableBuffer, ownImmutableBuffer } from "../../geometry/immutable-buffer.js";
+import { transform3 } from "../../geometry/transform-value.js";
+import { validateRigidTransform3 } from "../../geometry/transform3.js";
+import { createGeometryFinalizer } from "../finalization.js";
+import { requireModelPart } from "../model-parts.js";
+import { createModelSummary } from "../model-summary.js";
+import { placeFinalizedGeometry } from "../placement.js";
 let nextSession = 0;
 function invalid(message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "generate" });
 }
-const vector = (value) => {
-    const result = value === undefined ? [0, 0, 0] : vector3Data(value);
-    if (!result.every(Number.isFinite))
-        invalid("Part placement requires three finite coordinates.");
-    return Object.freeze([...result]);
-};
 /** Only fixed buffer fields can establish immutable mesh identity across revisions. */
 function isImmutableMesh(value) {
     return (Object.isFrozen(value) &&
         isImmutableBuffer(Object.getOwnPropertyDescriptor(value, "positions")?.value) &&
         isImmutableBuffer(Object.getOwnPropertyDescriptor(value, "indices")?.value));
 }
-/** Publishes copied views while retaining the authoritative local buffers privately. */
+/** Publishes immutable views over already-owned local buffers. */
 function createResource(id, geometry, reusable) {
     return {
         geometry,
@@ -29,66 +25,44 @@ function createResource(id, geometry, reusable) {
             id,
             revision: 1,
             measurements: geometry.measurements,
-            get positions() {
-                return new Float32Array(geometry.positions);
-            },
-            get indices() {
-                return new Uint32Array(geometry.indices);
-            },
+            positions: ownImmutableBuffer(geometry.positions),
+            indices: ownImmutableBuffer(geometry.indices),
         }),
     };
 }
 /** Captures authoritative placement and appearance before consulting world-geometry reuse. */
 function capturePlacement(descriptor) {
-    const position = vector(typeof descriptor.position === "function" ? descriptor.position() : descriptor.position);
-    const rotation = vector(typeof descriptor.rotation === "function" ? descriptor.rotation() : descriptor.rotation);
+    const transform = validateRigidTransform3(transform3(typeof descriptor.transform === "function" ? descriptor.transform() : descriptor.transform).toData());
     const color = descriptor.color;
     if (color !== undefined && (typeof color !== "string" || !/^#[\da-f]{6}$/i.test(color)))
         invalid("Part colors must be six-digit hex strings.");
-    return { position, rotation, ...(color === undefined ? {} : { color: color.toLowerCase() }) };
+    return { transform, ...(color === undefined ? {} : { color: color.toLowerCase() }) };
 }
-/** Snapshot accessors own their copies; export can still use the trusted private world buffers. */
+/** Captures stable immutable world geometry without duplicating owned buffers. */
 function capturePart(id, geometry, placement, worldGeometry) {
     const part = Object.freeze({
         id,
         geometry,
         ...placement,
         measurements: worldGeometry.measurements,
-        get positions() {
-            return new Float32Array(worldGeometry.positions);
-        },
-        get indices() {
-            return new Uint32Array(worldGeometry.indices);
-        },
+        positions: ownImmutableBuffer(worldGeometry.positions),
+        indices: ownImmutableBuffer(worldGeometry.indices),
     });
-    rememberSnapshotPart(part, worldGeometry);
     return part;
 }
-/** Isolates a snapshot's lifetime from the cache transaction that produced it. */
-function createSnapshot(parts, { bounds, stats }, diagnostics, dependencies, generationStartedAt) {
-    const completedStats = Object.freeze({
-        ...stats,
-        generationMs: performance.now() - generationStartedAt,
-    });
-    let ownedParts = Object.freeze(parts);
-    const requireParts = () => ownedParts ?? invalid("This model snapshot has been disposed.");
+/** Publishes finalized data independently of the cache transaction that produced it. */
+function createResult(parts, { bounds, stats }, diagnostics, dependencies, generationStartedAt) {
+    const capturedParts = Object.freeze(parts);
     return Object.freeze({
-        get parts() {
-            return requireParts();
-        },
-        get bounds() {
-            requireParts();
-            return bounds;
-        },
-        get stats() {
-            requireParts();
-            return completedStats;
-        },
+        parts: capturedParts,
+        part: (id) => requireModelPart(capturedParts, id),
+        bounds,
+        stats: Object.freeze({
+            ...stats,
+            generateMs: performance.now() - generationStartedAt,
+        }),
         diagnostics: Object.freeze([...diagnostics]),
         dependencies,
-        dispose() {
-            ownedParts = undefined;
-        },
     });
 }
 /**
@@ -123,14 +97,10 @@ export function createSnapshotCache(options, limits) {
                 nextResources.set(geometry, resource);
                 const placement = capturePlacement(descriptor);
                 // World buffers belong to geometry and placement, independently of semantic part identity.
-                const placementKey = JSON.stringify([
-                    resource.public.id,
-                    placement.position,
-                    placement.rotation,
-                ]);
+                const placementKey = JSON.stringify([resource.public.id, placement.transform]);
                 const placed = nextPlaced.get(placementKey) ??
                     placedCache.get(placementKey) ??
-                    placeFinalizedGeometry(resource.geometry, placement.position, placement.rotation, options.meshValidation);
+                    placeFinalizedGeometry(resource.geometry, placement.transform, options.meshValidation);
                 nextPlaced.set(placementKey, placed);
                 summary.add(placed);
                 worldParts.push(capturePart(descriptor.id, resource.public, placement, placed));
@@ -141,7 +111,7 @@ export function createSnapshotCache(options, limits) {
             return {
                 // Publish only after retention, native cleanup and cache commit have succeeded.
                 get snapshot() {
-                    return (snapshot ??= createSnapshot(worldParts, model, diagnostics, dependencies, generationStartedAt));
+                    return (snapshot ??= createResult(worldParts, model, diagnostics, dependencies, generationStartedAt));
                 },
                 retainedValues: [
                     ...nextResources.keys(),

package/dist/geometry/anchors.js

@@ -32,11 +32,7 @@ const boxFaces = {
 const primitiveAnchorOrigin = (options, operation) => {
     if (options.center !== undefined && typeof options.center !== "boolean")
         throw new GeometryError("INVALID_ARGUMENT", "center must be boolean.", { operation });
-    const origin = options.origin === undefined ? [0, 0, 0] : options.origin;
-    if (!Array.isArray(origin) || origin.length !== 3)
-        throw new GeometryError("INVALID_ARGUMENT", "origin must be an exact XYZ tuple.", {
-            operation,
-        });
+    const origin = options.origin === undefined ? [0, 0, 0] : vector3Data(options.origin);
     for (let axis = 0; axis < 3; axis++)
         if (!Number.isFinite(origin[axis]))
             throw new GeometryError("NON_FINITE_VALUE", "Anchor origin must be finite.", { operation });
@@ -54,12 +50,9 @@ export function boxAnchor3(options) {
     const operation = "boxAnchor3";
     assertAnchorOptions(options, operation);
     const origin = primitiveAnchorOrigin(options, operation);
-    if (typeof options.size !== "number" &&
-        (!Array.isArray(options.size) || options.size.length !== 3))
-        throw new GeometryError("INVALID_ARGUMENT", "Box anchor size must be a number or XYZ tuple.", {
-            operation,
-        });
-    const size = typeof options.size === "number" ? [options.size, options.size, options.size] : options.size;
+    const size = typeof options.size === "number"
+        ? [options.size, options.size, options.size]
+        : vector3Data(options.size);
     for (let axis = 0; axis < 3; axis++)
         if (!Number.isFinite(size[axis]) || size[axis] <= 0)
             throw new GeometryError("INVALID_ARGUMENT", "Box anchor dimensions must be positive.", {

package/dist/geometry/bounds-value.js

@@ -1,7 +1,7 @@
 import { boundsCenter, boundsSize, containsBounds, validateBounds } from "./bounds.js";
-import { GeometryError } from "./errors.js";
+import { GeometryError, isGeometryError } from "./errors.js";
 import { immutableMathClass } from "./math/immutable-value.js";
-import { vector2, vector3 } from "./math/vector-value.js";
+import { vector2, vector2Data, vector3, vector3Data, } from "./math/vector-value.js";
 function fail(dimension, message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: `bounds${dimension}` });
 }
@@ -9,18 +9,28 @@ function snapshot(input, dimension) {
     if (typeof input !== "object" || input === null || Array.isArray(input))
         fail(dimension, "Bounds require extrema or size.");
     const { size, center } = input;
+    const coordinates = (value) => {
+        try {
+            return dimension === 2
+                ? vector2Data(value)
+                : vector3Data(value);
+        }
+        catch (error) {
+            if (isGeometryError(error) && error.code === "INVALID_ARGUMENT")
+                fail(dimension, `Bounds require matching ${dimension}D vectors or coordinate tuples.`);
+            throw error;
+        }
+    };
     let min, max;
     // Existing immutable bounds expose size()/center(); only a size value selects construction.
     if ("size" in input && typeof size !== "function") {
         if ("min" in input || "max" in input)
             fail(dimension, "Supply size or min/max, never both.");
-        if (!Array.isArray(size) || size.length !== dimension)
-            fail(dimension, `Size requires ${dimension}D coordinates.`);
         if (center !== undefined && typeof center !== "boolean")
             fail(dimension, "center must be boolean.");
-        const coordinates = size;
+        const sizeCoordinates = coordinates(size);
         const dimensions = Array.from({ length: dimension }, (_, axis) => {
-            const value = coordinates[axis];
+            const value = sizeCoordinates[axis];
             if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
                 fail(dimension, "Size must be finite and nonnegative.");
             return value;
@@ -33,8 +43,8 @@ function snapshot(input, dimension) {
         if (center !== undefined && typeof center !== "function")
             fail(dimension, "center requires size construction.");
         const extrema = input;
-        min = extrema.min;
-        max = extrema.max;
+        min = coordinates(extrema.min);
+        max = coordinates(extrema.max);
     }
     if (!Array.isArray(min) ||
         !Array.isArray(max) ||
@@ -102,7 +112,7 @@ const SpatialBounds = /* @__PURE__ */ immutableMathClass(class SpatialBounds {
  * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
  * Size construction centers on the origin unless `center` is false. Size and extrema are exclusive.
  * Compiled Generator packages passing these values to host recipes or computed data require
- * runtime 9.0.0 or newer in major 9.
+ * runtime 10.0.0 or newer in major 10.
  */
 export function bounds2(input) {
     return new PlanarBounds(snapshot(input, 2));
@@ -114,7 +124,7 @@ export function bounds2(input) {
  * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
  * Size construction centers on the origin unless `center` is false. Size and extrema are exclusive.
  * Compiled Generator packages passing these values to host recipes or computed data require
- * runtime 9.0.0 or newer in major 9.
+ * runtime 10.0.0 or newer in major 10.
  */
 export function bounds3(input) {
     return new SpatialBounds(snapshot(input, 3));

package/dist/geometry/heightfield.js

@@ -1,4 +1,5 @@
 import { GeometryError } from "./errors.js";
+import { vector2Data } from "./math/vector-value.js";
 import { validateTriangleMesh } from "./mesh/mesh.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "./model-limits.js";
 import { writeMeshVertex } from "./numeric.js";
@@ -33,21 +34,18 @@ function planHeightfield(options, limits) {
         yAt = (index) => coordinates.y[index];
     }
     else {
-        if (!Array.isArray(options.size) ||
-            options.size.length !== 2 ||
-            !options.size.every((value) => Number.isFinite(value) && value > 0) ||
+        const size = vector2Data(options.size);
+        const origin = options.origin === undefined ? undefined : vector2Data(options.origin);
+        if (!size.every((value) => Number.isFinite(value) && value > 0) ||
             !Array.isArray(options.segments) ||
             options.segments.length !== 2 ||
             !options.segments.every((value) => Number.isSafeInteger(value) && value > 0) ||
-            (options.origin !== undefined &&
-                (!Array.isArray(options.origin) ||
-                    options.origin.length !== 2 ||
-                    !options.origin.every(Number.isFinite)))) {
+            (origin !== undefined && !origin.every(Number.isFinite))) {
             throw new GeometryError("INVALID_ARGUMENT", "Uniform heightfields need a finite positive footprint, integer intervals, and finite origin.", { operation });
         }
         [x, y] = options.segments;
-        const [width, depth] = options.size;
-        const [originX, originY] = options.origin ?? [-width / 2, -depth / 2];
+        const [width, depth] = size;
+        const [originX, originY] = origin ?? [-width / 2, -depth / 2];
         xAt = (index) => originX + (width * index) / x;
         yAt = (index) => originY + (depth * index) / y;
     }
@@ -84,7 +82,7 @@ function planHeightfield(options, limits) {
  * 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}
+ * @see `mesh.heightfield`
  */
 export function preflightHeightfield(options, limits = {}) {
     return planHeightfield(options, limits).facts;
@@ -96,11 +94,11 @@ export function preflightHeightfield(options, limits = {}) {
  * 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}
+ * @see `mesh.preflightHeightfield`
  *
  * @example Sample a closed wavy mesh
  * ```ts
- * heightfieldMesh({
+ * mesh.heightfield({
  *   size: [30, 20], segments: [24, 16],
  *   height: ([x, y]) => 3 + Math.cos(x / 5) * Math.cos(y / 5),
  * });

package/dist/{model → geometry}/immutable-buffer.js

@@ -1,6 +1,7 @@
 const constructors = { Float32Array, Float64Array, Uint32Array, Uint8Array, Int32Array };
-const protocol = Symbol.for("@metamesh/modeling/immutable-buffer/1");
+const protocol = Symbol.for("@metamesh/modeling/immutable-buffer/2");
 const storage = new WeakMap();
+const ownedBuffers = new WeakMap();
 const adopted = new WeakMap();
 /**
  * Copies numeric data once into private storage. This pure helper needs no active generation.
@@ -10,6 +11,7 @@ const adopted = new WeakMap();
  * const heights = immutableBuffer(new Float32Array([2, 4, 6]));
  * const count = heights.length;
  * const first = heights.at(0);
+ * const doubled = Array.from(heights, (height) => height * 2);
  * const editable = heights.copy();
  * editable[0] = 8; // heights still contains 2, 4, 6.
  * ```
@@ -18,8 +20,19 @@ export function immutableBuffer(source) {
     const entry = Object.entries(constructors).find(([, constructor]) => source instanceof constructor);
     if (entry === undefined)
         throw new TypeError("immutableBuffer requires a supported numeric typed array.");
-    const [kind, constructor] = entry;
+    const constructor = entry[1];
     const owned = new constructor(source);
+    return ownImmutableBuffer(owned);
+}
+/** Wraps storage whose exclusive mutable ownership has already been captured by the host. */
+export function ownImmutableBuffer(owned) {
+    const previous = ownedBuffers.get(owned);
+    if (previous !== undefined)
+        return previous;
+    const entry = Object.entries(constructors).find(([, constructor]) => owned instanceof constructor);
+    if (entry === undefined)
+        throw new TypeError("Unsupported owned numeric storage.");
+    const [kind, constructor] = entry;
     const length = owned.length;
     const result = Object.freeze({
         [protocol]: kind,
@@ -29,18 +42,20 @@ export function immutableBuffer(source) {
             return Number.isInteger(offset) && offset >= 0 && offset < length ? owned[offset] : undefined;
         },
         copy: () => new constructor(owned),
+        [Symbol.iterator]: () => owned.values(),
     });
     storage.set(result, owned);
+    ownedBuffers.set(owned, result);
     return result;
 }
 /**
  * Copies mesh buffers into immutable data; geometric validation still occurs when modeling or finalizing.
  * @example
  * ```ts
- * import { generate, immutableMesh } from "@metamesh/modeling";
- * import { heightfieldMesh } from "@metamesh/modeling/geometry";
+ * import { generate } from "@metamesh/modeling";
+ * import * as mesh from "@metamesh/modeling/geometry/mesh";
  * const model = generate(({ computed, part }) => {
- *   const surface = computed("surface", () => immutableMesh(heightfieldMesh({
+ *   const surface = computed("surface", () => mesh.immutable(mesh.heightfield({
  *     size: [10, 10], segments: [8, 8], height: () => 2,
  *   })));
  *   return [part("surface", surface)];
@@ -50,7 +65,7 @@ export function immutableBuffer(source) {
 export function immutableMesh(mesh) {
     const { positions, indices } = mesh;
     if (!(positions instanceof Float32Array) || !(indices instanceof Uint32Array))
-        throw new TypeError("immutableMesh requires Float32 positions and Uint32 indices.");
+        throw new TypeError("mesh.immutable requires Float32 positions and Uint32 indices.");
     return Object.freeze({
         positions: immutableBuffer(positions),
         indices: immutableBuffer(indices),
@@ -75,7 +90,8 @@ export function isImmutableBuffer(value) {
         Number.isSafeInteger(length) &&
         length >= 0 &&
         typeof field("at") === "function" &&
-        typeof field("copy") === "function");
+        typeof field("copy") === "function" &&
+        typeof field(Symbol.iterator) === "function");
 }
 /** Adopts separately bundled factories once, copying before trusting their storage or methods. */
 export function adoptImmutableBuffer(buffer) {
@@ -104,6 +120,11 @@ export function immutableBufferView(buffer) {
 /** Normalizes trusted modeling/finalization inputs without copying or exposing storage publicly. */
 export function immutableMeshView(mesh) {
     const { positions, indices } = mesh;
+    if (positions instanceof Float32Array &&
+        indices instanceof Uint32Array &&
+        Object.getOwnPropertyDescriptor(mesh, "positions")?.value === positions &&
+        Object.getOwnPropertyDescriptor(mesh, "indices")?.value === indices)
+        return mesh;
     return {
         positions: isImmutableBuffer(positions) ? immutableBufferView(positions) : positions,
         indices: isImmutableBuffer(indices) ? immutableBufferView(indices) : indices,

package/dist/geometry/index.js

@@ -4,16 +4,13 @@ export { boundsSize, boundsCenter, fitBounds, layoutRow, } from "./bounds.js";
 export { resolveCircularSampling, } from "./circular-sampling.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";
+export { matchProfiles, } from "./profiles/match-profiles.js";
+export { preflightThreadedRodSolid as preflightThreadedRod, preflightInternalThreadCutterSolid as preflightInternalThreadCutter, preflightThreadedNutSolid as preflightThreadedNut, } from "./mechanical/threads/solids.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 { triangulateContour, } from "./loft/loft.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";
@@ -21,34 +18,31 @@ export { add3, cross3, dot3, length3, distance3, lerp3, normalize3, projectOntoP
 export { minimumCylindricalGearToothCountWithoutUndercut, resolveCylindricalGear, resolveCylindricalGearPair, resolveRackPitch, sampleCylindricalGearOutline, sampleInternalCylindricalGearSpaceOutline, sampleRackToothPath, } from "./mechanical/gears.js";
 export { measureInternalCylindricalGearPairMotion, } from "./mechanical/gear-motion.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, 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 { compensateThreadProfileAxially, compensateThreadProfileForFaceting, threadProfile, } from "./mechanical/threads/profiles.js";
+export {} from "./mechanical/threads/mesh-plan.js";
+export { sampleConventionalThreadHelices as sampleThreadHelices, } from "./mechanical/threads/helices.js";
+export { PRINTABLE_THREAD_FIT_POLICIES, compensateThreadDiameters, resolvePrintableThreadFitPolicy, resolveThreadCircularSegments, } from "./mechanical/threads/fit.js";
 export { computeClosedParallelTransportFrames, computeParallelTransportFrames, } from "./paths/frames.js";
 export { sampleHelix } from "./paths/helix.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 { circleContour } from "./profiles/primitives/circle.js";
+export { rectangleContour } from "./profiles/primitives/rectangle.js";
+export { regularPolygonContour, } from "./profiles/primitives/regular-polygon.js";
+export { starContour } from "./profiles/primitives/star.js";
 export { closeToAxis, sampleSideProfile, } from "./profiles/side-profile.js";
 export { sampleContour, } from "./profiles/contour.js";
-export { ellipseContour } from "./profiles/shapes.js";
-export { rectangleProfile, } from "./profiles/rectangle.js";
+export { ellipseContour } from "./profiles/primitives/ellipse.js";
+export { rectangleProfile, } from "./profiles/primitives/rectangle.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 { preflightSvgRegion, } from "./svg/import.js";
 export { strokeRegionData, } from "./stroke-path.js";
-export { sweepMesh } from "./sweeps/sweep-mesh.js";
 export { DEFAULT_GEOMETRY_TOLERANCE, resolveGeometryTolerance, } from "./tolerance.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 { IDENTITY_TRANSFORM3, applyTransformDirection3, applyTransformPoint3, composeTransform3, eulerTransform3, frameTransform3, inverseTransform3, rotationTransform3, scaleTransform3, transformDeterminant3, translationTransform3, validateTransform3, validateRigidTransform3, } 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";
+export { immutableBuffer, } from "./immutable-buffer.js";

package/dist/geometry/loft/loft.js

@@ -10,7 +10,7 @@ export { triangulateContour } from "./loft-triangulation.js";
 /**
  * Lofts simple point loops at z heights or explicit right-handed frames, in input order.
  *
- * An explicit correspondence method is required. CCW-normalized loops retain their
+ * Correspondence defaults to direct. CCW-normalized loops retain their
  * seam and original vertices; unequal counts gain subdivisions or repeated fan slots.
  * Both ends use ear-clipped caps, supporting concave profiles without center fans.
  * Intermediate slices interpolate placed world vertices, never frame axes.
@@ -21,12 +21,14 @@ export { triangulateContour } from "./loft-triangulation.js";
  * ```ts
  * 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" });
+ * mesh.loft([{ profile: bottom, z: 0 }, { profile: top, z: 30 }], { correspondence: "reindex" });
  * ```
  */
-export function loftMesh(stations, options) {
-    if (options?.correspondence === undefined)
-        throw new GeometryError("INVALID_ARGUMENT", "Point-loop lofts require an explicit correspondence method.", { operation: "loftMesh" });
+export function loftMesh(stations, options = {}) {
+    if (typeof options !== "object" || options === null || Array.isArray(options))
+        throw new GeometryError("INVALID_ARGUMENT", "Loft options must be an object.", {
+            operation: "loftMesh",
+        });
     const limits = resolveModelingLimits(options.limits);
     if (!Array.isArray(stations) || stations.length < 2)
         throw new GeometryError("INVALID_ARGUMENT", "Loft requires at least two stations.", {
@@ -53,16 +55,19 @@ export function loftMesh(stations, options) {
 /**
  * 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.
+ * End treatments are unsupported and reject at runtime. Use Section.extrude for finished ends.
  *
  * @example Extrude point data without an engine
  * ```ts
  * const outline = rectangleContour({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
- * extrudeMesh(outline, { height: 8 });
+ * mesh.extrude(outline, { height: 8 });
  * ```
  */
 export function extrudeMesh(input, options) {
     const { height } = options;
     const { center, scales, twist } = resolveExtrusionControls(height, options, "extrudeMesh");
+    if ("ends" in options)
+        throw new GeometryError("INVALID_ARGUMENT", "extrudeMesh does not support end treatments. Use Section.extrude instead.", { operation: "extrudeMesh" });
     if (!Number.isFinite(height) || height <= 0) {
         throw new GeometryError("INVALID_ARGUMENT", "Extrusion height must be finite and positive.", {
             operation: "extrudeMesh",

package/dist/geometry/mechanical/index.js

@@ -5,10 +5,10 @@
  */
 export { minimumCylindricalGearToothCountWithoutUndercut, resolveCylindricalGear, resolveCylindricalGearPair, resolveRackPitch, sampleCylindricalGearOutline, sampleInternalCylindricalGearSpaceOutline, sampleRackToothPath, } from "./gears.js";
 export { measureInternalCylindricalGearPairMotion } from "./gear-motion.js";
-export { helicalThreadRidgeMesh, helicalThreadSolidMesh } from "./thread-mesh.js";
-export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, threadProfile, } from "./thread-profiles.js";
-export { preflightHelicalThreadSolidMesh } from "./thread-mesh-plan.js";
-export { sampleConventionalThreadHelices as sampleThreadHelices } from "./thread-helices.js";
-export { compensateThreadDiameters, PRINTABLE_THREAD_FIT_POLICIES, resolvePrintableThreadFitPolicy, resolveThreadCircularSegments, } from "./threads.js";
+export { threadRidgeMesh, threadSolidMesh } from "./threads/mesh.js";
+export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, threadProfile, } from "./threads/profiles.js";
+export { preflightThreadSolidMesh } from "./threads/mesh-plan.js";
+export { sampleConventionalThreadHelices as sampleThreadHelices } from "./threads/helices.js";
+export { compensateThreadDiameters, PRINTABLE_THREAD_FIT_POLICIES, resolvePrintableThreadFitPolicy, resolveThreadCircularSegments, } from "./threads/fit.js";
 export { getMetricClearanceHoleDiameter, getMetricFastenerStandard, METRIC_FASTENER_STANDARDS, } from "./standards.js";
 export { resolveKnuckleHinge, } from "./knuckle-hinge.js";

package/dist/geometry/mechanical/threads/bevel.js

@@ -0,0 +1,24 @@
+import { GeometryError } from "../../errors.js";
+/** @internal Validates and captures factory-specific automatic bevel sizes. */
+export function resolveBevel(value, automatic, defaults, operation, parameter = "bevel") {
+    if (value === undefined)
+        return Object.freeze([defaults[0], defaults[1]]);
+    const invalid = () => {
+        throw new GeometryError("INVALID_ARGUMENT", `${parameter} must be a nonnegative finite size, "auto", or a [bottom, top] pair.`, {
+            operation,
+            details: { parameter },
+        });
+    };
+    const pair = Array.isArray(value) ? value : [value, value];
+    if (pair.length !== 2)
+        invalid();
+    const size = (index) => {
+        const item = pair[index];
+        if (item === "auto")
+            return automatic[index];
+        if (typeof item !== "number" || !Number.isFinite(item) || item < 0)
+            return invalid();
+        return item;
+    };
+    return Object.freeze([size(0), size(1)]);
+}

package/dist/geometry/mechanical/{threads.js → threads/fit.js}

@@ -1,7 +1,7 @@
-import { GeometryError } from "../errors.js";
-import { resolveCircularSegments, resolveGeometryResolution, } from "../resolution.js";
-import { resolveGeometryTolerance } from "../tolerance.js";
-import { compensateThreadProfileForFaceting } from "./thread-profiles.js";
+import { GeometryError } from "../../errors.js";
+import { resolveCircularSegments, resolveGeometryResolution, } from "../../resolution.js";
+import { resolveGeometryTolerance } from "../../tolerance.js";
+import { compensateThreadProfileForFaceting } from "./profiles.js";
 const frozenFit = (maleRadialInset, femaleRadialOutset, axialBacklash) => Object.freeze({ axialBacklash, femaleRadialOutset, maleRadialInset });
 /**
  * Conservative baseline print-fit policies in millimetres.

package/dist/geometry/mechanical/{thread-helices.js → threads/helices.js}

@@ -1,7 +1,7 @@
 /** Conventional thread helix sampling, independent of surface construction. */
-import { GeometryError } from "../errors.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
-import { assertFiniteThreadNumber } from "./thread-profiles.js";
+import { GeometryError } from "../../errors.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../../sampling-limits.js";
+import { assertFiniteThreadNumber } from "./profiles.js";
 /**
  * Samples evenly phased thread helices with finite `lead = pitch * starts`.
  * All starts together respect maxPathPoints (default 100000); excessive counts fail before allocation.