@metamesh/modeling 0.12.0 → 0.13.0

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]);

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

@@ -1,6 +1,6 @@
 /** Periodic thread profiles and axial/radial fit compensation. */
 import { GeometryError } from "../errors.js";
-import { triangulateLoop2 } from "../loft.js";
+import { triangulateContour } from "../loft/loft.js";
 import { resolveGeometryTolerance } from "../tolerance.js";
 const BUTTRESS_DEFAULT_DEPTH_RATIO = 0.66271;
 const BUTTRESS_CREST_FLAT_RATIO = 0.16316;
@@ -207,7 +207,7 @@ export const createThreadRidgeSection = (points, minimum, linearTolerance, opera
     // closing the ridge section retraces its minor-envelope edge, creating overlapping cap faces and
     // zero-area triangles. Keep exactly the connected tooth plus its two root transition points.
     const section = points.slice(firstRaised - 1, lastRaised + 2);
-    triangulateLoop2([...section].reverse());
+    triangulateContour([...section].reverse());
     return section;
 };
 const standardProfile = (kind, pitch, depth, root, crest, leftRun, rightRun) => {

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

@@ -124,7 +124,7 @@ export const buildThreadSurfaceColumn = (profile, resolved, options, angle, maxi
     };
     const candidates = [];
     let order = 0;
-    const add = (z, kind = "regular", profileRadial, endFactor, surfaceRadius, profileOrdinal, atLeadTip = false) => {
+    const add = (z, { kind = "regular", profileRadial, endFactor, surfaceRadius, profileOrdinal, atLeadTip = false, } = {}) => {
         if (z < -resolved.tolerance.linear || z > resolved.length + resolved.tolerance.linear)
             return;
         candidates.push({
@@ -182,7 +182,12 @@ export const buildThreadSurfaceColumn = (profile, resolved, options, angle, maxi
             // redundant in this sparse mesher and would reintroduce dense, near-collinear triangles.
             for (const [profileIndex, [profileAxial, profileRadial],] of resolved.surfaceSection.entries()) {
                 const profileRadius = majorRadius + profileRadial;
-                add(center + profileAxial * scale.width, "profile", undefined, undefined, leadInEnvelopeRadius + (profileRadius - leadInEnvelopeRadius) * scale.height, period * resolved.surfaceSection.length + profileIndex, atBottomTip || atTopTip);
+                add(center + profileAxial * scale.width, {
+                    kind: "profile",
+                    surfaceRadius: leadInEnvelopeRadius + (profileRadius - leadInEnvelopeRadius) * scale.height,
+                    profileOrdinal: period * resolved.surfaceSection.length + profileIndex,
+                    atLeadTip: atBottomTip || atTopTip,
+                });
             }
         }
     }
@@ -191,7 +196,11 @@ export const buildThreadSurfaceColumn = (profile, resolved, options, angle, maxi
             const firstPeriod = Math.ceil((activeMinimum - phaseShift - profileAxial - resolved.tolerance.linear) / profile.pitch);
             const lastPeriod = Math.floor((activeMaximum - phaseShift - profileAxial + resolved.tolerance.linear) / profile.pitch);
             for (let period = firstPeriod; period <= lastPeriod; period += 1) {
-                add(phaseShift + profileAxial + period * profile.pitch, "profile", profileRadial, undefined, undefined, period * resolved.surfaceSection.length + profileIndex);
+                add(phaseShift + profileAxial + period * profile.pitch, {
+                    kind: "profile",
+                    profileRadial,
+                    profileOrdinal: period * resolved.surfaceSection.length + profileIndex,
+                });
             }
         }
     }
@@ -199,14 +208,14 @@ export const buildThreadSurfaceColumn = (profile, resolved, options, angle, maxi
         !usesScaledLeadIn &&
         resolved.bottomBoundary > resolved.tolerance.linear &&
         resolved.bottomBoundary < resolved.length - resolved.tolerance.linear) {
-        add(resolved.bottomBoundary, "forced-bottom", undefined, 0);
+        add(resolved.bottomBoundary, { kind: "forced-bottom", endFactor: 0 });
     }
     const upperThreadBoundary = resolved.topBoundary;
     if (resolved.top === "blunt" &&
         !usesScaledLeadIn &&
         upperThreadBoundary > resolved.tolerance.linear &&
         upperThreadBoundary < resolved.length - resolved.tolerance.linear) {
-        add(upperThreadBoundary, "forced-top", undefined, 0);
+        add(upperThreadBoundary, { kind: "forced-top", endFactor: 0 });
     }
     candidates.sort((left, right) => left.z - right.z || left.order - right.order);
     const normalized = [];

package/dist/geometry/{mesh-centroid.js → mesh/mesh-centroid.js}

@@ -1,4 +1,4 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
 import { analyzeTriangleMesh } from "./mesh.js";
 /**
  * Computes the uniform-density volume centroid of an oriented closed solid, including cavity shells.

package/dist/geometry/{mesh-planar.js → mesh/mesh-planar.js}

@@ -1,4 +1,4 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
 import { buildTriangleMeshQualityAnalysis, } from "./mesh-quality.js";
 const DEFAULT_MAXIMUM_FLIP_ATTEMPTS = 1_000_000;
 const DEFAULT_MAXIMUM_PATCH_TRIANGLE_COUNT = 50_000;

package/dist/geometry/{mesh-quality.js → mesh/mesh-quality.js}

@@ -1,5 +1,5 @@
-import { GeometryError } from "./errors.js";
-import { resolveGeometryTolerance, } from "./tolerance.js";
+import { GeometryError } from "../errors.js";
+import { resolveGeometryTolerance, } from "../tolerance.js";
 const DEFAULT_MAXIMUM_TRIANGLE_COUNT = 200_000;
 const FLOAT32_EPSILON = 2 ** -23;
 const MINIMUM_PLANAR_ANGULAR_TOLERANCE = 1e-5;

package/dist/geometry/{mesh-signature.js → mesh/mesh-signature.js}

@@ -1,5 +1,5 @@
-import { GeometryError } from "./errors.js";
-import { analyzeTriangleMesh, validateTriangleMesh, } from "./mesh.js";
+import { GeometryError } from "../errors.js";
+import { analyzeTriangleMesh, validateTriangleMesh } from "./mesh.js";
 const DEFAULT_POSITION_TOLERANCE = 1e-5;
 const DEFAULT_VOLUME_TOLERANCE = 1e-4;
 const DEFAULT_MAXIMUM_TRIANGLE_COUNT = 200_000;

package/dist/geometry/{mesh-solid.js → mesh/mesh-solid.js}

@@ -1,8 +1,8 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
+import { resolveGeometryTolerance } from "../tolerance.js";
 import { IndexedMeshEdgeTable } from "./mesh-edge-table.js";
 import { prepareSolidTriangle, trianglesIntersectBeyondSharedBoundary, triangleSolidAngle, } from "./mesh-solid-intersections.js";
 import { analyzeTriangleMesh } from "./mesh.js";
-import { resolveGeometryTolerance } from "./tolerance.js";
 const MAXIMUM_TRIANGLES = 200_000;
 const MAXIMUM_TESTS = 2_000_000;
 /**

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

@@ -1,8 +1,8 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
+import { writeMeshVertex } from "../numeric.js";
+import { resolveGeometryTolerance } from "../tolerance.js";
+import { transformDeterminant3, validateTransform3 } from "../transform3.js";
 import { IndexedMeshEdgeTable } from "./mesh-edge-table.js";
-import { writeMeshVertex } from "./numeric.js";
-import { resolveGeometryTolerance } from "./tolerance.js";
-import { transformDeterminant3, validateTransform3 } from "./transform3.js";
 function inspectTriangleMesh(mesh, options = {}, mode = "validate", topology = false) {
     // Snapshot meshes can expose owned-copy accessors. Read each buffer once before traversal.
     const source = { positions: mesh.positions, indices: mesh.indices };
@@ -161,10 +161,9 @@ export function analyzeTriangleMesh(mesh, options = {}) {
 /**
  * Validates mesh buffers, indices, triangle area, and optionally closed topology.
  *
- * Closed validation requires each edge to occur exactly twice with opposite
- * directions, rejecting boundary and non-manifold edges. Validation does not
- * mutate or copy the mesh. This establishes edge connectivity, not the absence
- * of geometric self-intersections between faces.
+ * Closed validation requires exactly two oppositely directed uses per edge, rejecting boundary
+ * and non-manifold edges. It establishes edge connectivity without detecting geometric
+ * self-intersections between faces. The mesh is neither mutated nor copied.
  *
  * @param mesh - Mesh to inspect.
  * @param options - Empty-mesh, topology, and tolerance policy.

package/dist/geometry/paths/frames.js

@@ -88,11 +88,10 @@ const signedAngleAround = (from, to, axis) => Math.atan2(dot3(axis, cross3(from,
 /**
  * Builds rotation-minimizing frames for a non-duplicated closed path.
  *
- * Centered cyclic tangents are parallel-transported around the loop. The seam
- * holonomy is measured by transporting the last normal back to the first
- * tangent, then its residual rotation is distributed uniformly over all path
- * intervals. This avoids a single visible seam or an accumulated frame flip.
- * The maxPathPoints ceiling (default100000) bounds path points and frames.
+ * Centered cyclic tangents are parallel-transported around the loop. Transporting the last
+ * normal back to the first tangent measures seam holonomy; distributing that residual rotation
+ * uniformly over all path intervals avoids a visible seam or accumulated frame flip.
+ * The maxPathPoints ceiling (default 100000) bounds path points and frames.
  */
 export const computeClosedParallelTransportFrames = (path, initialNormal, limits = {}) => {
     if (path.length < 3) {

package/dist/geometry/patterns/options.js

@@ -0,0 +1 @@
+export {};

package/dist/{engine/pattern-placements.js → geometry/patterns/placements.js}

@@ -1,8 +1,8 @@
-import { GeometryError } from "../geometry/errors.js";
-import { cross3, dot3, scale3 } from "../geometry/math/vector3.js";
-import { distributeAlongPath } from "../geometry/paths/planar.js";
-import { normalizeSweepPath } from "../geometry/sweeps/validation.js";
-import { composeTransform3, frameTransform3, IDENTITY_TRANSFORM3, rotationTransform3, translationTransform3, } from "../geometry/transform3.js";
+import { GeometryError } from "../errors.js";
+import { cross3, dot3, scale3 } from "../math/vector3.js";
+import { distributeAlongPath } from "../paths/planar.js";
+import { normalizeSweepPath } from "../sweeps/validation.js";
+import { composeTransform3, frameTransform3, IDENTITY_TRANSFORM3, rotationTransform3, translationTransform3, } from "../transform3.js";
 const fail = (operation, message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation });
 };
@@ -24,7 +24,7 @@ const finite = (value, operation) => {
     return value;
 };
 const vector = (value, operation) => {
-    if (!Array.isArray(value) || value.length !== 3 || !value.every(Number.isFinite))
+    if (!Array.isArray(value) || value.length !== 3 || !Array.from(value).every(Number.isFinite))
         fail(operation, "Pattern vectors require three finite coordinates.");
     return value;
 };
@@ -111,16 +111,30 @@ export function gridPatternPlan(options) {
         fail(operation, "Grid count and spacing require matching XY or XYZ tuples.");
     if (options.center !== undefined && typeof options.center !== "boolean")
         fail(operation, "Grid center must be a boolean.");
-    const counts = [options.count[0], options.count[1], options.count[2] ?? 1];
+    const counts = [options.count[0], options.count[1], dimensions === 3 ? options.count[2] : 1];
     counts.forEach((count) => patternCount(count, operation));
     const count = patternCount(counts[0] * counts[1] * counts[2], operation);
-    const spacing = [options.spacing[0], options.spacing[1], options.spacing[2] ?? 0];
+    const spacing = [
+        options.spacing[0],
+        options.spacing[1],
+        dimensions === 3 ? options.spacing[2] : 0,
+    ];
     const extent = spacing.map((distance, axis) => {
         finite(distance, operation);
         if (counts[axis] > 1 && distance === 0)
             fail(operation, "Repeated grid axes require nonzero spacing.");
         return finite(distance * (counts[axis] - 1), operation);
     });
+    if (options.frame !== undefined) {
+        optionsObject(options.frame, operation);
+        for (const coordinates of [
+            options.frame.origin,
+            options.frame.xAxis,
+            options.frame.yAxis,
+            options.frame.zAxis,
+        ])
+            vector(coordinates, operation);
+    }
     const frame = options.frame === undefined ? IDENTITY_TRANSFORM3 : frameTransform3(options.frame);
     return {
         count,

package/dist/geometry/patterns.js

@@ -0,0 +1,25 @@
+import { gridPatternPlan, linearPatternPlan, pathPatternPlan, radialPatternPlan, } from "./patterns/placements.js";
+import { resolveGeometrySamplingLimits } from "./sampling-limits.js";
+function transforms(plan) {
+    return Object.freeze(Array.from({ length: plan.count }, (_, index) => Object.freeze(plan.transformAt(index))));
+}
+/** Equal linear placements in millimetres, including the original at the origin. */
+export function linearPatternTransforms(options) {
+    return transforms(linearPatternPlan(options));
+}
+/** Rotations about an explicit axis; angles use degrees and the first placement is identity. */
+export function radialPatternTransforms(options) {
+    return transforms(radialPatternPlan(options));
+}
+/** XY or XYZ grid placements in millimetres, in X-fastest order. */
+export function gridPatternTransforms(options) {
+    return transforms(gridPatternPlan(options));
+}
+/**
+ * Equal physical arc-length placements along a sampled XYZ path. Tangent orientation maps +Z
+ * onto the local path tangent; fixed orientation only translates. Closed paths omit a repeated seam.
+ * Explicit sampling ceilings bound both input points and output placements.
+ */
+export function pathPatternTransforms(path, options, limits) {
+    return transforms(pathPatternPlan(path, options, resolveGeometrySamplingLimits(limits)));
+}

package/dist/geometry/primitive-resolvers.js

@@ -112,17 +112,17 @@ export function resolveBoxPrimitive(options) {
         if (selections.length === 0 || selections.length > 12)
             throw new GeometryError("INVALID_ARGUMENT", "Box treatments require a nonempty map of nominal edges or groups.", { operation });
         const cuts = [];
+        const selectedEdges = new Set();
         for (const [selection, selected] of selections) {
             const setbacks = edgeTreatmentSetbacks(selected, operation, Math.PI / 2, options.limits);
-            if (setbacks.some((value) => value <= 0))
-                throw new GeometryError("INVALID_ARGUMENT", "Box treatments require positive setbacks.", {
-                    operation,
-                });
             for (const edge of expandBoxEdges(selection)) {
-                if (cuts.some((cut) => cut.edge === edge))
+                if (selectedEdges.has(edge))
                     throw new GeometryError("INVALID_ARGUMENT", "Box edge selections must not overlap.", {
                         operation,
                     });
+                selectedEdges.add(edge);
+                if (setbacks[0] === 0 && setbacks[1] === 0)
+                    continue;
                 const [first, second] = edge.split("-"), a = boxFaceAxes[first][0], b = boxFaceAxes[second][0];
                 if (setbacks[0] >= dimensions[b] || setbacks[1] >= dimensions[a])
                     throw new GeometryError("INVALID_ARGUMENT", "Box edge setbacks must fit their adjoining dimensions.", { operation });
@@ -134,6 +134,8 @@ export function resolveBoxPrimitive(options) {
                 });
             }
         }
+        if (cuts.length === 0)
+            return base;
         for (const cut of cuts) {
             const [first, second] = cut.edge.split("-"), [a, sa] = boxFaceAxes[first], [b, sb] = boxFaceAxes[second];
             for (const other of cuts) {
@@ -167,10 +169,8 @@ export function resolveBoxPrimitive(options) {
         };
     }
     const setbacks = edgeTreatmentSetbacks(treatment, operation, Math.PI / 2, options.limits);
-    if (setbacks.some((value) => value <= 0))
-        throw new GeometryError("INVALID_ARGUMENT", "Box treatments require positive setbacks.", {
-            operation,
-        });
+    if (setbacks[0] === 0 && setbacks[1] === 0)
+        return base;
     const distance = setbacks[0];
     assertPositivePrimitive(distance, "edge treatment size", operation);
     const inner = [

package/dist/geometry/profiles/contour.js

@@ -1,6 +1,6 @@
 import { sampleCurve2 } from "../curves/sampling.js";
 import { GeometryError } from "../errors.js";
-import { normalizeLoop2 } from "../regions.js";
+import { normalizeContour } from "../regions.js";
 import { resolveGeometrySamplingLimits } from "../sampling-limits.js";
 import { requireProfileVertexCount } from "./validation.js";
 const OPERATION = "sampleContour";
@@ -12,7 +12,7 @@ function invalid(message) {
  * Physical scaling precedes adaptive curve sampling; the final end must repeat start exactly.
  * Shared anchors and the closing seam are emitted once. Winding normalization may change the
  * starting vertex. The sampled loop is checked for self-intersection and degeneracy by
- * `normalizeLoop2`; this is a single contour without holes. No editor modes or normalized
+ * `normalizeContour`; this is a single contour without holes. No editor modes or normalized
  * coordinate range are required. No native engine, SDK, or ambient resolution is used.
  *
  * @param curve - Closed contour in millimetres unless positive scales convert its coordinates.
@@ -98,5 +98,5 @@ export function sampleContour(curve, options = {}) {
             output.push(sampled[pointIndex]);
         start = end;
     }
-    return normalizeLoop2(output, true);
+    return normalizeContour(output, true);
 }

package/dist/geometry/profiles/matched.js

@@ -1,7 +1,7 @@
 import { planarCubicControl } from "../curves/evaluation.js";
 import { resolveLineSegmentCount, resolveUniformCubicSegments } from "../curves/sampling.js";
 import { GeometryError } from "../errors.js";
-import { normalizeRegion2, signedAreaLoop2 } from "../regions.js";
+import { normalizeRegion, signedContourArea } from "../regions.js";
 import { resolveArcSegments, resolveGeometryResolution } from "../resolution.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits } from "../sampling-limits.js";
 import { createProfileSpanSampler } from "./span-sampling.js";
@@ -167,7 +167,7 @@ export function matchProfiles(profiles, options = {}) {
                         spans.push(span.id);
                     }
                 });
-                const area = signedAreaLoop2(points);
+                const area = signedContourArea(points);
                 if (!(contourIndex === 0 ? area > 0 : area < 0))
                     fail("Outer contours must be CCW and holes CW; matching never reorders winding.");
                 return Object.freeze({
@@ -183,7 +183,7 @@ export function matchProfiles(profiles, options = {}) {
             });
         });
         // This validates intersections and containment, without changing logical slots or topology.
-        normalizeRegion2(components.map((component) => ({
+        normalizeRegion(components.map((component) => ({
             outer: component.outer.points,
             holes: component.holes.map((hole) => hole.points),
         })));