@metamesh/modeling 0.11.0 → 0.13.0

package/dist/engine/session-graph.js

@@ -1,6 +1,6 @@
 import { GeometryError } from "../geometry/errors.js";
 import { GenerationError, } from "../model/generation.js";
-import { captureGenerationValue, compareGenerationValues, generationDataEntries, } from "./immutable-generation-data.js";
+import { captureGenerationDependencies, captureGenerationValue, compareGenerationValues, generationDataEntries, } from "./immutable-generation-data.js";
 import { createModelDependencies } from "./model-dependencies.js";
 import { assertSynchronousScopeResult } from "./native/ownership.js";
 function reusableEntry(node) {
@@ -11,17 +11,13 @@ function reusableEntry(node) {
     return undefined;
 }
 const parameterKeys = Symbol("parameter-keys");
-const emptyBindings = Object.freeze({});
+const emptyInputs = Object.freeze([]);
 const isArray = (value) => Array.isArray(value);
 const canonicalId = (id) => typeof id === "string" && id.length <= 64 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id);
 function invalid(message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "generate" });
 }
-const sameBindings = (left, right) => {
-    const keys = Object.keys(left);
-    return (keys.length === Object.keys(right).length &&
-        keys.every((key) => Object.hasOwn(right, key) && Object.is(left[key], right[key])));
-};
+const sameInputs = (left, right) => left.length === right.length && left.every((value, index) => Object.is(value, right[index]));
 function evaluateComputed(callback) {
     const result = callback();
     assertSynchronousScopeResult(result, () => new GeometryError("INVALID_ARGUMENT", "Computed callbacks must be synchronous.", {
@@ -46,16 +42,18 @@ class ComputationRevision {
     parameterSnapshot;
     committed;
     readerIds;
+    validatedInputs;
     assertActive;
     assertNoFailedAssertion;
     nodes = new Map();
     keySignature;
     stack = [];
-    constructor(options, parameterSnapshot, committed, readerIds, assertActive, assertNoFailedAssertion) {
+    constructor(options, parameterSnapshot, committed, readerIds, validatedInputs, assertActive, assertNoFailedAssertion) {
         this.options = options;
         this.parameterSnapshot = parameterSnapshot;
         this.committed = committed;
         this.readerIds = readerIds;
+        this.validatedInputs = validatedInputs;
         this.assertActive = assertActive;
         this.assertNoFailedAssertion = assertNoFailedAssertion;
         // Structural reads share one unambiguous signature, even when parameter names contain NUL.
@@ -77,27 +75,22 @@ class ComputationRevision {
         this.nodes.clear();
         this.committed = new Map();
     }
-    register(id, bindingsOrCallback, callback) {
+    register(id, callback, dependencies = emptyInputs) {
         if (!canonicalId(id) || this.nodes.has(id))
             invalid("Computed IDs must be unique canonical lowercase identifiers of at most 64 characters.");
         if (this.nodes.size >= 100_000)
             throw new GeometryError("COMPLEXITY_LIMIT", "Too many declared computations.", {
                 operation: "computed",
             });
-        const bindings = typeof bindingsOrCallback === "function"
-            ? emptyBindings
-            : Object.freeze(Object.fromEntries(generationDataEntries(bindingsOrCallback)));
+        if (typeof callback !== "function" || !Array.isArray(dependencies))
+            invalid("Use computed(id, callback, dependencies?) with an optional dependency array.");
+        const inputs = dependencies === emptyInputs
+            ? emptyInputs
+            : captureGenerationDependencies(dependencies, (value) => this.readerIds.has(value), this.validatedInputs);
         const previous = this.committed.get(id);
-        let boundInputs;
-        if (previous !== undefined && sameBindings(previous.bindings, bindings))
-            boundInputs = previous.boundInputs;
-        else
-            boundInputs = captureGenerationValue(bindings, (value) => this.readerIds.has(value));
-        const invoke = typeof bindingsOrCallback === "function" ? bindingsOrCallback : () => callback(boundInputs);
         this.nodes.set(id, {
-            callback: invoke,
-            bindings,
-            boundInputs,
+            callback,
+            inputs,
             previous,
             state: { kind: "pending" },
         });
@@ -162,7 +155,7 @@ class ComputationRevision {
         }
     }
     canReuse(node, previous) {
-        if (this.options.cache === false || node.boundInputs !== previous.boundInputs)
+        if (this.options.cache === false || !sameInputs(node.inputs, previous.inputs))
             return false;
         for (const [key, value] of previous.parameters) {
             const current = key === parameterKeys ? this.keySignature : Reflect.get(this.parameterSnapshot, key);
@@ -191,6 +184,18 @@ class ComputationRevision {
         evaluation.parameters.clear();
         evaluation.dependencies.clear();
         evaluation.cacheable = true;
+        // Declared readers depend on their output, not just their stable callable identity.
+        for (const input of node.inputs) {
+            const dependency = typeof input === "function" ? this.readerIds.get(input) : undefined;
+            if (dependency !== undefined) {
+                try {
+                    this.read(dependency);
+                }
+                catch {
+                    // Failed reads already prevent reuse; the callback owns propagation or fallback.
+                }
+            }
+        }
         const result = evaluateComputed(node.callback);
         this.assertNoFailedAssertion();
         const previous = node.previous;
@@ -198,14 +203,13 @@ class ComputationRevision {
         if (reusable && previous !== undefined) {
             const comparison = compareGenerationValues(previous.value, result);
             if (comparison === "different")
-                invalid(`Cache verification for '${id}' found a changed result without a tracked dependency. Bind changing local values explicitly.`);
+                invalid(`Cache verification for '${id}' found a changed result without a tracked dependency. Add changing outer values to the dependency array.`);
             if (comparison === "unsupported")
                 invalid(`Cache verification for '${id}' cannot compare this result within its bounded data/recipe probe. Use cache: false for a full output equivalence check.`);
             value = previous.value;
         }
         return Object.freeze({
-            bindings: node.bindings,
-            boundInputs: node.boundInputs,
+            inputs: node.inputs,
             parameters: evaluation.parameters,
             dependencies: evaluation.dependencies,
             value,
@@ -221,11 +225,12 @@ export function createGenerationGraph(options, maxParts) {
     let committed = new Map();
     const readers = new Map();
     const readerIds = new WeakMap();
+    const validatedInputs = new WeakSet();
     let activeRead;
     let previousInput = {};
     let previousParameterSnapshot = {};
     // Build stable readers outside registration's lexical scope so they cannot retain a revision's
-    // callback, captured locals, or copied bindings after that revision closes.
+    // callback, captured locals, or dependency inputs after that revision closes.
     const createReader = (id) => (() => {
         if (activeRead === undefined)
             return invalid("Computed readers can only be used during their active model session revision.");
@@ -251,7 +256,7 @@ export function createGenerationGraph(options, maxParts) {
                 if (assertionFailure !== undefined)
                     throw assertionFailure;
             };
-            const computations = new ComputationRevision(options, parameterSnapshot, committed, readerIds, assertActive, assertNoFailedAssertion);
+            const computations = new ComputationRevision(options, parameterSnapshot, committed, readerIds, validatedInputs, assertActive, assertNoFailedAssertion);
             const params = new Proxy(parameterSnapshot, {
                 get: (target, key) => {
                     assertActive();
@@ -300,11 +305,11 @@ export function createGenerationGraph(options, maxParts) {
                 },
             });
             activeRead = computations.read;
-            const computed = ((id, bindingsOrCallback, callback) => {
+            const computed = ((id, callback, dependencies) => {
                 assertActive();
                 if (!declaring || computations.evaluating)
                     invalid("Declare computations only in the outer generation callback.");
-                computations.register(id, bindingsOrCallback, callback);
+                computations.register(id, callback, dependencies);
                 let reader = readers.get(id);
                 if (reader === undefined) {
                     reader = createReader(id);
@@ -379,18 +384,20 @@ export function createGenerationGraph(options, maxParts) {
                     // Catching an assertion does not turn its revision into a successful snapshot.
                     assertNoFailedAssertion();
                     declaring = false;
-                    if (!isArray(output) || output.length === 0)
+                    const parts = isArray(output) ? output : [output];
+                    if (parts.length === 0)
                         invalid("Generation must return at least one declared part.");
-                    if (output.length > maxParts)
+                    if (parts.length > maxParts)
                         throw new GeometryError("COMPLEXITY_LIMIT", `Output exceeds ${maxParts} parts.`, {
                             operation: "generate",
                         });
                     const returnedIds = new Set();
-                    for (const descriptor of output) {
+                    for (const descriptor of parts) {
                         if (!declaredParts.has(descriptor) || returnedIds.has(descriptor.id))
                             invalid("Return each declared output part at most once.");
                         returnedIds.add(descriptor.id);
                     }
+                    return parts;
                 },
                 dependencies(output) {
                     return createModelDependencies(output, modelParameters, new Map([...computations.nodes].map(([id, node]) => [id, reusableEntry(node)])), readerIds);
@@ -403,7 +410,7 @@ export function createGenerationGraph(options, maxParts) {
                     for (const node of computations.nodes.values()) {
                         const entry = reusableEntry(node);
                         if (entry !== undefined)
-                            retained.push(entry.value, entry.bindings, entry.boundInputs, ...entry.parameters.values());
+                            retained.push(entry.value, entry.inputs, ...entry.parameters.values());
                     }
                     return [...retained, parameterSnapshot, inputValues];
                 },

package/dist/engine/session.js

@@ -110,8 +110,7 @@ class SessionRevision {
     generate(revision, deferred, native, mode) {
         const { program, services, caches } = this.session;
         const startedAt = performance.now();
-        const output = program.generate({ ...revision.context, services });
-        revision.finish(output);
+        const output = revision.finish(program.generate({ ...revision.context, services }));
         if (mode === "validate")
             return { kind: "validation", diagnostics: Object.freeze([...revision.diagnostics]) };
         const captured = caches.snapshots.capture({

package/dist/geometry/bounds.js

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

package/dist/geometry/cylinder.js

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

package/dist/geometry/edge-finishing.js

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

package/dist/geometry/heightfield.js

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

package/dist/geometry/index.js

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/geometry/math/vector3.js

@@ -13,7 +13,11 @@ export const add3 = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
  * subtract3([4, 5, 6], [1, 2, 3]); // [3, 3, 3]
  * ```
  */
-export const subtract3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+export const subtract3 = (a, b) => [
+    a[0] - b[0],
+    a[1] - b[1],
+    a[2] - b[2],
+];
 /**
  * Multiplies a vector by a dimensionless scalar.
  * @example

package/dist/geometry/mechanical/gears.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../errors.js";
-import { signedAreaLoop2 } from "../regions.js";
+import { signedContourArea } from "../regions.js";
 import { resolveCircularSegments, resolveGeometryResolution, } from "../resolution.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
 const DEFAULT_PRESSURE_ANGLE_DEGREES = 20;
@@ -398,7 +398,7 @@ const sampleResolvedCylindricalGearOutline = (dimensions, options, operation) =>
         }
     }
     points.pop();
-    if (!(signedAreaLoop2(points) > 0)) {
+    if (!(signedContourArea(points) > 0)) {
         throw new GeometryError("INVALID_TOPOLOGY", "The sampled gear outline must be counter-clockwise.", {
             operation,
         });

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

@@ -1,6 +1,6 @@
 /** Closed ridge and complete-solid mesh construction from resolved thread plans. */
-import { triangulateLoop2 } from "../loft.js";
-import { joinTriangleMeshes, measureTriangleMesh, reverseTriangleMesh, validateTriangleMesh, } from "../mesh.js";
+import { triangulateContour } from "../loft/loft.js";
+import { joinTriangleMeshes, measureTriangleMesh, reverseTriangleMesh, validateTriangleMesh, } from "../mesh/mesh.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits } from "../model-limits.js";
 import { resolveHelicalThreadMeshOptions, resolveHelicalThreadSolidMeshPreflight, } from "./thread-mesh-plan.js";
 import { buildThreadSurfaceColumn, stitchThreadSurfaceColumns } from "./thread-surface.js";
@@ -45,7 +45,7 @@ const buildThreadRidgeComponent = (options) => {
             const c = (column + 1) * size + next, d = (column + 1) * size + point;
             indices.push(a, b, c, a, c, d);
         }
-    const capTriangles = triangulateLoop2([...section].reverse());
+    const capTriangles = triangulateContour([...section].reverse());
     const cap = (column, top) => {
         for (let offset = 0; offset < capTriangles.length; offset += 3) {
             const a = column * size + (size - 1 - capTriangles[offset]);