@metamesh/modeling 0.18.0 → 0.20.0

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

@@ -1,10 +1,11 @@
 import { GeometryError } from "../errors.js";
 import { immutableMeshView } from "../immutable-buffer.js";
-import { writeMeshVertex } from "../numeric.js";
 import { resolveGeometryTolerance } from "../tolerance.js";
-import { readTransformMatrix } from "../transform-matrix.js";
-import { transformDeterminant3, validateTransform3 } from "../transform3.js";
-import { IndexedMeshEdgeTable } from "./mesh-edge-table.js";
+import { transformDeterminant3, validateTransform3 } from "../transforms/affine3.js";
+import { readTransformMatrix } from "../transforms/matrix-input.js";
+import { IndexedMeshEdgeTable } from "./edge-table.js";
+import { reverseOwnedTriangleWinding } from "./winding.js";
+import { writeMeshVertex } from "./write-vertex.js";
 function inspectTriangleMesh(mesh, options = {}, mode = "validate", topology = false) {
     // Normalize immutable storage and read raw input accessors once before traversal.
     const source = immutableMeshView(mesh);
@@ -77,6 +78,7 @@ function inspectTriangleMesh(mesh, options = {}, mode = "validate", topology = f
     };
     // Keep the two hot-loop accumulators independent and local: no mutable numeric objects escape.
     let surfaceArea = 0, areaCorrection = 0, signedVolume = 0, volumeCorrection = 0;
+    // A local tetrahedron origin limits cancellation when the mesh has a large world offset.
     const originX = source.positions[0] ?? 0, originY = source.positions[1] ?? 0, originZ = source.positions[2] ?? 0;
     for (let offset = 0; offset < source.indices.length; offset += 3) {
         const a = source.indices[offset], b = source.indices[offset + 1], c = source.indices[offset + 2];
@@ -157,7 +159,7 @@ export function analyzeTriangleMesh(mesh, options = {}) {
  * 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 mesh - Raw or captured indexed buffers with complete finite XYZ vertices.
  * @param options - Empty-mesh, topology, and tolerance policy.
  * @returns The original mesh after successful validation.
  * @throws `GeometryError` When any requested invariant fails.
@@ -222,11 +224,7 @@ export function reverseTriangleMesh(mesh) {
     const source = immutableMeshView(mesh);
     validateTriangleMesh(source);
     const indices = new Uint32Array(source.indices);
-    for (let offset = 0; offset < indices.length; offset += 3) {
-        const second = indices[offset + 1];
-        indices[offset + 1] = indices[offset + 2];
-        indices[offset + 2] = second;
-    }
+    reverseOwnedTriangleWinding(indices);
     return { indices, positions: new Float32Array(source.positions) };
 }
 /**
@@ -236,7 +234,7 @@ export function reverseTriangleMesh(mesh) {
  * automatically reverses every triangle. Singular transforms are rejected.
  *
  * @param mesh - Mesh to transform without mutation.
- * @param placement - Immutable spatial placement or canonical row-major affine matrix.
+ * @param placement - Frame, fluent transform, or row-major affine matrix.
  * @returns A mesh with fresh transformed positions and copied or reversed indices.
  */
 export function transformTriangleMesh(mesh, placement) {
@@ -256,12 +254,7 @@ export function transformTriangleMesh(mesh, placement) {
         ], "transformTriangleMesh");
     }
     const indices = new Uint32Array(source.indices);
-    if (transformDeterminant3(transform) < 0) {
-        for (let offset = 0; offset < indices.length; offset += 3) {
-            const second = indices[offset + 1];
-            indices[offset + 1] = indices[offset + 2];
-            indices[offset + 2] = second;
-        }
-    }
+    if (transformDeterminant3(transform) < 0)
+        reverseOwnedTriangleWinding(indices);
     return validateTriangleMesh({ indices, positions });
 }

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

@@ -1,6 +1,7 @@
 import { GeometryError } from "../errors.js";
 import { immutableMeshView, isImmutableBuffer } from "../immutable-buffer.js";
-import { buildTriangleMeshQualityAnalysis, } from "./mesh-quality.js";
+import { buildTriangleMeshQualityAnalysis, } from "./quality.js";
+import { triangleQuality } from "./triangle-quality.js";
 const DEFAULT_MAXIMUM_FLIP_ATTEMPTS = 1_000_000;
 const DEFAULT_MAXIMUM_PATCH_TRIANGLE_COUNT = 50_000;
 const DEFAULT_MAXIMUM_PROCESSED_TRIANGLE_COUNT = 200_000;
@@ -17,6 +18,8 @@ const pointAt = (positions, vertex) => [
     positions[vertex * 3 + 1],
     positions[vertex * 3 + 2],
 ];
+// Keep these kernels local to isolate V8's array-type feedback from other modeling operations.
+// Shared helpers see more array representations, which can slow hot loops even when inlined.
 const subtract = (left, right) => [
     left[0] - right[0],
     left[1] - right[1],
@@ -70,22 +73,9 @@ const pairQuality = (positions, first, second) => {
     let maximumAspectRatio = 0;
     for (const triangle of [first, second]) {
         const points = triangle.map((vertex) => pointAt(positions, vertex));
-        const edgeVectors = [
-            subtract(points[1], points[0]),
-            subtract(points[2], points[1]),
-            subtract(points[0], points[2]),
-        ];
-        const edgeSquaredLengths = edgeVectors.map(squaredLength);
-        const doubleArea = Math.sqrt(squaredLength(cross(edgeVectors[0], subtract(points[2], points[0]))));
-        maximumAspectRatio = Math.max(maximumAspectRatio, doubleArea === 0
-            ? Number.POSITIVE_INFINITY
-            : (Math.sqrt(3) * Math.max(...edgeSquaredLengths)) / (2 * doubleArea));
-        for (let corner = 0; corner < 3; corner += 1) {
-            const origin = points[corner];
-            const incoming = subtract(points[(corner + 1) % 3], origin);
-            const outgoing = subtract(points[(corner + 2) % 3], origin);
-            angles.push(Math.atan2(Math.sqrt(squaredLength(cross(incoming, outgoing))), dot(incoming, outgoing)));
-        }
+        const quality = triangleQuality(points[0], points[1], points[2], "squared");
+        maximumAspectRatio = Math.max(maximumAspectRatio, quality.aspectRatio);
+        angles.push(...quality.angles);
     }
     angles.sort((left, right) => left - right);
     return { angles, maximumAspectRatio };
@@ -170,7 +160,7 @@ const fallbackReasonForCandidate = (before, after, boundaryEdgeKeys) => {
  * original raw mesh object. Immutable inputs produce owned raw output buffers, including unchanged
  * results. Malformed buffers and the configured analysis complexity limit throw.
  *
- * @param mesh - Closed, consistently wound indexed triangle mesh in arbitrary consistent units.
+ * @param mesh - Closed, consistently wound mesh in consistent units.
  * @param options - Patch eligibility, numeric tolerance, and deterministic work bounds.
  * @returns Optimized connectivity and before/after diagnostics, or an unchanged safe fallback.
  */

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

@@ -1,6 +1,7 @@
 import { GeometryError } from "../errors.js";
 import { immutableMeshView } from "../immutable-buffer.js";
 import { resolveGeometryTolerance, } from "../tolerance.js";
+import { triangleQuality } from "./triangle-quality.js";
 const DEFAULT_MAXIMUM_TRIANGLE_COUNT = 200_000;
 const FLOAT32_EPSILON = 2 ** -23;
 const MINIMUM_PLANAR_ANGULAR_TOLERANCE = 1e-5;
@@ -10,18 +11,9 @@ const pointAt = (positions, vertex) => [
     positions[vertex * 3 + 1],
     positions[vertex * 3 + 2],
 ];
-const subtract = (left, right) => [
-    left[0] - right[0],
-    left[1] - right[1],
-    left[2] - right[2],
-];
+// Keep these kernels local to isolate V8's array-type feedback from other modeling operations.
+// Shared helpers see more array representations, which can slow hot loops even when inlined.
 const dot = (left, right) => left[0] * right[0] + left[1] * right[1] + left[2] * right[2];
-const cross = (left, right) => [
-    left[1] * right[2] - left[2] * right[1],
-    left[2] * right[0] - left[0] * right[2],
-    left[0] * right[1] - left[1] * right[0],
-];
-const length = (vector) => Math.hypot(vector[0], vector[1], vector[2]);
 const maximumUint32 = (values) => {
     let maximum = 0;
     for (const value of values)
@@ -80,46 +72,22 @@ const meshBoundsAndExtent = (positions) => {
         extent: Math.max(maximum[0] - minimum[0], maximum[1] - minimum[1], maximum[2] - minimum[2]),
     };
 };
-const triangleAngles = (first, second, third) => {
-    const firstSecond = subtract(second, first);
-    const firstThird = subtract(third, first);
-    const secondThird = subtract(third, second);
-    const lengthFirstSecond = length(firstSecond);
-    const lengthFirstThird = length(firstThird);
-    const lengthSecondThird = length(secondThird);
-    if (lengthFirstSecond === 0 || lengthFirstThird === 0 || lengthSecondThird === 0) {
-        return [0, 0, 0];
-    }
-    const thirdFirst = subtract(first, third);
-    const secondFirst = [-firstSecond[0], -firstSecond[1], -firstSecond[2]];
-    const thirdSecond = [-secondThird[0], -secondThird[1], -secondThird[2]];
-    return [
-        Math.atan2(length(cross(firstSecond, firstThird)), dot(firstSecond, firstThird)),
-        Math.atan2(length(cross(secondThird, secondFirst)), dot(secondThird, secondFirst)),
-        Math.atan2(length(cross(thirdFirst, thirdSecond)), dot(thirdFirst, thirdSecond)),
-    ];
-};
 const faceAnalysis = (positions, vertices, index) => {
     const first = pointAt(positions, vertices[0]);
     const second = pointAt(positions, vertices[1]);
     const third = pointAt(positions, vertices[2]);
-    const firstSecond = subtract(second, first);
-    const firstThird = subtract(third, first);
-    const secondThird = subtract(third, second);
-    const product = cross(firstSecond, firstThird);
-    const doubleArea = length(product);
+    const quality = triangleQuality(first, second, third, "hypot");
+    const { doubleArea } = quality;
     const area = doubleArea / 2;
-    const longestEdge = Math.max(length(firstSecond), length(firstThird), length(secondThird));
     const normal = doubleArea === 0
         ? undefined
-        : [product[0] / doubleArea, product[1] / doubleArea, product[2] / doubleArea];
-    const angles = triangleAngles(first, second, third);
+        : [quality.crossX / doubleArea, quality.crossY / doubleArea, quality.crossZ / doubleArea];
     return {
         area,
-        aspectRatio: area === 0 ? Number.POSITIVE_INFINITY : (Math.sqrt(3) * longestEdge ** 2) / (4 * area),
+        aspectRatio: quality.aspectRatio,
         doubleArea,
         index,
-        minimumAngleRadians: Math.min(...angles),
+        minimumAngleRadians: Math.min(...quality.angles),
         normal,
         planeOffset: normal === undefined ? undefined : dot(normal, first),
         vertices,
@@ -234,7 +202,7 @@ const buildPatchAnalysis = (faces, edges, faceIndices, id) => {
         },
     };
 };
-/** @internal */
+/** @internal Builds fresh bounded geometry and topology facts without mutating source buffers. */
 export function buildTriangleMeshQualityAnalysis(mesh, options = {}) {
     const source = immutableMeshView(mesh);
     const maxTriangles = positiveInteger(options.maxTriangles ?? DEFAULT_MAXIMUM_TRIANGLE_COUNT, "Maximum analyzed triangle count");
@@ -389,7 +357,7 @@ export function buildTriangleMeshQualityAnalysis(mesh, options = {}) {
  * Degenerate triangles are reported rather than rejected, while malformed buffers, non-finite
  * positions, missing vertex references, and the configured complexity limit throw.
  *
- * @param mesh - Indexed triangle mesh in arbitrary consistent model units.
+ * @param mesh - Indexed triangle mesh in consistent units.
  * @param options - Scale-aware tolerance and analysis budget.
  * @returns A deterministic report without mutating or copying the mesh.
  */

package/dist/geometry/mesh/render-buffers.js

@@ -0,0 +1,220 @@
+import { GeometryError } from "../errors.js";
+import { immutableMeshView } from "../immutable-buffer.js";
+import { validateTriangleMesh } from "./operations.js";
+const MAX_NORMAL_COMPARISONS = 50_000_000;
+// Float32 integer coordinates share low zero bits. Mix high bits before masking a table slot.
+function mixHash(value) {
+    value = Math.imul(value ^ (value >>> 16), 0x7feb352d);
+    value = Math.imul(value ^ (value >>> 15), 0x846ca68b);
+    return value ^ (value >>> 16);
+}
+function tableCapacity(count) {
+    let capacity = 16;
+    while (capacity < count * 2)
+        capacity *= 2;
+    if (capacity > 0x8000_0000)
+        throw new GeometryError("COMPLEXITY_LIMIT", "Render mesh exceeds hash table capacity.");
+    return capacity;
+}
+/**
+ * Builds crease-aware render buffers without moving or merging distinct positions.
+ * Face normals are averaged only at exactly coincident positions within the crease angle.
+ * Returns owned buffers; every triangle retains its coordinates, order and winding.
+ * Pathological vertex fans exceeding 50 million normal comparisons reject with a complexity error.
+ *
+ * @param input - Indexed mesh to copy; source buffers remain unchanged.
+ *
+ * @example
+ * ```ts
+ * import * as mesh from "@metamesh/modeling/geometry/mesh";
+ * const surface = mesh.heightfield({ size: [10, 10], segments: [2, 2], height: () => 0 });
+ * const rendered = mesh.render(surface);
+ * // rendered.positions and rendered.normals can be passed to a renderer or GLB writer.
+ * ```
+ */
+export function renderMesh(input, options = {}) {
+    const angle = options.creaseAngle ?? 20;
+    if (!Number.isFinite(angle) || angle < 0 || angle > 180)
+        throw new GeometryError("INVALID_ARGUMENT", "Crease angle must be from 0 through 180 degrees.", {
+            operation: "renderMesh",
+        });
+    const mesh = immutableMeshView(input);
+    validateTriangleMesh(mesh);
+    return renderValidatedMesh(mesh, angle);
+}
+/**
+ * @internal Renders exact privately captured buffer ranges already validated with the default
+ * mesh tolerance. The buffers must remain unchanged, and angle must be validated in [0, 180].
+ */
+export function renderValidatedMesh({ positions, indices }, angle) {
+    const vertexCount = positions.length / 3;
+    const cornerCount = indices.length;
+    const faceCount = cornerCount / 3;
+    const positionBits = new Uint32Array(positions.buffer, positions.byteOffset, positions.length);
+    const faceNormals = new Float64Array(cornerCount);
+    for (let face = 0; face < faceCount; face += 1) {
+        const offset = face * 3;
+        const a = indices[offset] * 3;
+        const b = indices[offset + 1] * 3;
+        const c = indices[offset + 2] * 3;
+        const ux = positions[b] - positions[a];
+        const uy = positions[b + 1] - positions[a + 1];
+        const uz = positions[b + 2] - positions[a + 2];
+        const vx = positions[c] - positions[a];
+        const vy = positions[c + 1] - positions[a + 1];
+        const vz = positions[c + 2] - positions[a + 2];
+        const nx = uy * vz - uz * vy;
+        const ny = uz * vx - ux * vz;
+        const nz = ux * vy - uy * vx;
+        const inverseLength = 1 / Math.hypot(nx, ny, nz);
+        faceNormals[offset] = nx * inverseLength;
+        faceNormals[offset + 1] = ny * inverseLength;
+        faceNormals[offset + 2] = nz * inverseLength;
+    }
+    // Position identity is exact. In particular, no tolerance can collapse a thin physical gap.
+    const positionIds = new Uint32Array(vertexCount);
+    const representatives = new Uint32Array(vertexCount);
+    const positionTable = new Uint32Array(tableCapacity(vertexCount));
+    const positionMask = positionTable.length - 1;
+    let uniquePositions = 0;
+    const positionHash = (offset) => Math.imul(positions[offset] === 0 ? 0 : positionBits[offset], 73_856_093) ^
+        Math.imul(positions[offset + 1] === 0 ? 0 : positionBits[offset + 1], 19_349_663) ^
+        Math.imul(positions[offset + 2] === 0 ? 0 : positionBits[offset + 2], 83_492_791);
+    for (let vertex = 0; vertex < vertexCount; vertex += 1) {
+        const offset = vertex * 3;
+        let slot = mixHash(positionHash(offset)) & positionMask;
+        while (positionTable[slot] !== 0) {
+            const id = positionTable[slot] - 1;
+            const other = representatives[id] * 3;
+            if (positions[offset] === positions[other] &&
+                positions[offset + 1] === positions[other + 1] &&
+                positions[offset + 2] === positions[other + 2])
+                break;
+            slot = (slot + 1) & positionMask;
+        }
+        if (positionTable[slot] === 0) {
+            representatives[uniquePositions] = vertex;
+            positionTable[slot] = ++uniquePositions;
+        }
+        positionIds[vertex] = positionTable[slot] - 1;
+    }
+    const bucketOffsets = new Uint32Array(uniquePositions + 1);
+    for (const vertex of indices)
+        bucketOffsets[positionIds[vertex] + 1] += 1;
+    let comparisons = 0;
+    for (let id = 0; id < uniquePositions; id += 1) {
+        const count = bucketOffsets[id + 1];
+        comparisons += count * count;
+        if (angle !== 0 && comparisons > MAX_NORMAL_COMPARISONS)
+            throw new GeometryError("COMPLEXITY_LIMIT", "Render mesh exceeds the normal comparison work limit.", { operation: "renderMesh", details: { maxNormalComparisons: MAX_NORMAL_COMPARISONS } });
+        bucketOffsets[id + 1] = count + bucketOffsets[id];
+    }
+    const bucketFaces = new Uint32Array(cornerCount);
+    const cursors = bucketOffsets.slice(0, uniquePositions);
+    for (let corner = 0; corner < cornerCount; corner += 1) {
+        const id = positionIds[indices[corner]];
+        bucketFaces[cursors[id]] = Math.floor(corner / 3);
+        cursors[id] += 1;
+    }
+    let capacity = Math.min(cornerCount, Math.max(16, vertexCount));
+    let renderPositions = new Float32Array(capacity * 3);
+    let renderNormals = new Float32Array(capacity * 3);
+    let renderPositionBits = new Uint32Array(renderPositions.buffer);
+    let renderNormalBits = new Uint32Array(renderNormals.buffer);
+    let renderTable = new Uint32Array(tableCapacity(capacity));
+    let renderMask = renderTable.length - 1;
+    const renderedIndices = new Uint32Array(cornerCount);
+    const candidateNormal = new Float32Array(3);
+    const normalBits = new Uint32Array(candidateNormal.buffer);
+    let renderedCount = 0;
+    const creaseDot = Math.cos((angle * Math.PI) / 180);
+    const renderHash = (offset) => {
+        return (Math.imul(renderPositions[offset] === 0 ? 0 : renderPositionBits[offset], 73_856_093) ^
+            Math.imul(renderPositions[offset + 1] === 0 ? 0 : renderPositionBits[offset + 1], 19_349_663) ^
+            Math.imul(renderPositions[offset + 2] === 0 ? 0 : renderPositionBits[offset + 2], 83_492_791) ^
+            Math.imul(renderNormals[offset] === 0 ? 0 : renderNormalBits[offset], 49_979_687) ^
+            Math.imul(renderNormals[offset + 1] === 0 ? 0 : renderNormalBits[offset + 1], 67_867_967) ^
+            Math.imul(renderNormals[offset + 2] === 0 ? 0 : renderNormalBits[offset + 2], 86_028_121));
+    };
+    for (let corner = 0; corner < cornerCount; corner += 1) {
+        const faceOffset = Math.floor(corner / 3) * 3;
+        const nx = faceNormals[faceOffset];
+        const ny = faceNormals[faceOffset + 1];
+        const nz = faceNormals[faceOffset + 2];
+        const positionOffset = indices[corner] * 3;
+        let sumX = nx, sumY = ny, sumZ = nz;
+        if (angle !== 0) {
+            sumX = 0;
+            sumY = 0;
+            sumZ = 0;
+            const id = positionIds[indices[corner]];
+            for (let k = bucketOffsets[id]; k < bucketOffsets[id + 1]; k += 1) {
+                const other = bucketFaces[k] * 3;
+                const ox = faceNormals[other];
+                const oy = faceNormals[other + 1];
+                const oz = faceNormals[other + 2];
+                if (other === faceOffset || nx * ox + ny * oy + nz * oz >= creaseDot) {
+                    sumX += ox;
+                    sumY += oy;
+                    sumZ += oz;
+                }
+            }
+        }
+        const length = Math.hypot(sumX, sumY, sumZ);
+        candidateNormal[0] = length > 1e-12 ? sumX / length : nx;
+        candidateNormal[1] = length > 1e-12 ? sumY / length : ny;
+        candidateNormal[2] = length > 1e-12 ? sumZ / length : nz;
+        const hash = positionHash(positionOffset) ^
+            Math.imul(candidateNormal[0] === 0 ? 0 : normalBits[0], 49_979_687) ^
+            Math.imul(candidateNormal[1] === 0 ? 0 : normalBits[1], 67_867_967) ^
+            Math.imul(candidateNormal[2] === 0 ? 0 : normalBits[2], 86_028_121);
+        let slot = mixHash(hash) & renderMask;
+        while (renderTable[slot] !== 0) {
+            const offset = (renderTable[slot] - 1) * 3;
+            if (renderPositions[offset] === positions[positionOffset] &&
+                renderPositions[offset + 1] === positions[positionOffset + 1] &&
+                renderPositions[offset + 2] === positions[positionOffset + 2] &&
+                renderNormals[offset] === candidateNormal[0] &&
+                renderNormals[offset + 1] === candidateNormal[1] &&
+                renderNormals[offset + 2] === candidateNormal[2])
+                break;
+            slot = (slot + 1) & renderMask;
+        }
+        if (renderTable[slot] === 0) {
+            if (renderedCount === capacity) {
+                capacity = Math.min(cornerCount, capacity * 2);
+                const grownPositions = new Float32Array(capacity * 3);
+                const grownNormals = new Float32Array(capacity * 3);
+                grownPositions.set(renderPositions);
+                grownNormals.set(renderNormals);
+                renderPositions = grownPositions;
+                renderNormals = grownNormals;
+                renderPositionBits = new Uint32Array(renderPositions.buffer);
+                renderNormalBits = new Uint32Array(renderNormals.buffer);
+                renderTable = new Uint32Array(tableCapacity(capacity));
+                renderMask = renderTable.length - 1;
+                for (let index = 0; index < renderedCount; index += 1) {
+                    let target = mixHash(renderHash(index * 3)) & renderMask;
+                    while (renderTable[target] !== 0)
+                        target = (target + 1) & renderMask;
+                    renderTable[target] = index + 1;
+                }
+                slot = mixHash(hash) & renderMask;
+                while (renderTable[slot] !== 0)
+                    slot = (slot + 1) & renderMask;
+            }
+            const offset = renderedCount * 3;
+            renderPositions[offset] = positions[positionOffset];
+            renderPositions[offset + 1] = positions[positionOffset + 1];
+            renderPositions[offset + 2] = positions[positionOffset + 2];
+            renderNormals.set(candidateNormal, offset);
+            renderTable[slot] = ++renderedCount;
+        }
+        renderedIndices[corner] = renderTable[slot] - 1;
+    }
+    return {
+        positions: renderPositions.slice(0, renderedCount * 3),
+        normals: renderNormals.slice(0, renderedCount * 3),
+        indices: renderedIndices,
+    };
+}

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

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

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

@@ -1,3 +1,5 @@
+// Keep these kernels local to isolate V8's array-type feedback from other modeling operations.
+// Shared helpers see more array representations, which can slow hot loops even when inlined.
 const subtract = (a, b) => [
     a[0] - b[0],
     a[1] - b[1],
@@ -28,13 +30,26 @@ const dominantAxis = (value) => {
             axis = index;
     return axis;
 };
+/** Returns the actual nearby segment point; offset half-planes overexpand acute corners. */
+function nearbySegmentPoint(point, a, b, epsilon) {
+    const dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
+    const lengthSquared = dx * dx + dy * dy + dz * dz;
+    const fraction = lengthSquared === 0
+        ? 0
+        : Math.max(0, Math.min(1, ((point[0] - a[0]) * dx + (point[1] - a[1]) * dy + (point[2] - a[2]) * dz) /
+            lengthSquared));
+    const x = a[0] + fraction * dx, y = a[1] + fraction * dy, z = a[2] + fraction * dz;
+    return Math.hypot(point[0] - x, point[1] - y, point[2] - z) <= epsilon ? [x, y, z] : undefined;
+}
 function inside(point, triangle, direction, epsilon) {
     const axis = dominantAxis(direction), p = project(point, axis), points = triangle.map((vertex) => project(vertex, axis));
     const sign = Math.sign(turn(points[0], points[1], points[2]));
-    return points.every((a, index) => {
+    if (points.every((a, index) => {
         const b = points[(index + 1) % 3];
-        return sign * turn(a, b, p) >= -epsilon * Math.hypot(b[0] - a[0], b[1] - a[1]);
-    });
+        return sign * turn(a, b, p) >= 0;
+    }))
+        return true;
+    return triangle.some((a, index) => nearbySegmentPoint(point, a, triangle[(index + 1) % 3], epsilon) !== undefined);
 }
 function onSharedBoundary(point, shared, epsilon) {
     if (shared.some((vertex) => distance(point, vertex) <= epsilon))
@@ -53,13 +68,12 @@ function coplanarIntersection(first, second, direction, shared, epsilon) {
     let polygon = [...first];
     for (let edge = 0; edge < 3 && polygon.length > 0; edge++) {
         const a = clip[edge], b = clip[(edge + 1) % 3];
-        const tolerance = epsilon * Math.hypot(b[0] - a[0], b[1] - a[1]);
         const signed = (point) => sign * turn(a, b, project(point, axis));
         const next = [];
         for (let index = 0; index < polygon.length; index++) {
             const start = polygon[index], end = polygon[(index + 1) % polygon.length];
             const d0 = signed(start), d1 = signed(end);
-            const in0 = d0 >= -tolerance, in1 = d1 >= -tolerance;
+            const in0 = d0 >= 0, in1 = d1 >= 0;
             if (in0)
                 next.push(start);
             if (in0 !== in1) {
@@ -73,22 +87,36 @@ function coplanarIntersection(first, second, direction, shared, epsilon) {
         }
         polygon = next;
     }
-    if (polygon.length === 0)
-        return false;
-    const origin = project(polygon[0], axis);
-    let area = 0;
-    for (let index = 1; index + 1 < polygon.length; index++)
-        area += turn(origin, project(polygon[index], axis), project(polygon[index + 1], axis));
-    const scale = Math.max(...first.map((point, index) => distance(point, first[(index + 1) % 3])));
-    if (Math.abs(area) > epsilon * scale)
-        return true;
-    return polygon.some((point) => !onSharedBoundary(point, shared, epsilon));
+    if (polygon.length > 0) {
+        const origin = project(polygon[0], axis);
+        let area = 0;
+        for (let index = 1; index + 1 < polygon.length; index++)
+            area += turn(origin, project(polygon[index], axis), project(polygon[index + 1], axis));
+        const scale = Math.max(...first.map((point, index) => distance(point, first[(index + 1) % 3])));
+        if (Math.abs(area) > epsilon * scale)
+            return true;
+        if (polygon.some((point) => !onSharedBoundary(point, shared, epsilon)))
+            return true;
+    }
+    // A distance tolerance rounds a triangle's corners. Clipping against independently offset
+    // support lines instead creates long miters and can report contact many epsilons away.
+    const nearbyContact = (source, target) => source.some((point) => target.some((a, index) => {
+        const closest = nearbySegmentPoint(point, a, target[(index + 1) % 3], epsilon);
+        return (closest !== undefined &&
+            (!onSharedBoundary(point, shared, epsilon) || !onSharedBoundary(closest, shared, epsilon)));
+    }));
+    return nearbyContact(first, second) || nearbyContact(second, first);
 }
 /** @internal Detects contact beyond a permitted indexed vertex or edge, without welding. */
 export function trianglesIntersectBeyondSharedBoundary(firstGeometry, secondGeometry, shared, epsilon) {
     const first = firstGeometry.points, second = secondGeometry.points, n0 = firstGeometry.normal, n1 = secondGeometry.normal;
-    const distances0 = first.map((point) => dot(n1, subtract(point, second[0])));
-    const distances1 = second.map((point) => dot(n0, subtract(point, first[0])));
+    // Indexed shared vertices lie exactly on both planes. Dot-product cancellation must not
+    // turn that known zero into a false crossing along a nearly coplanar edge.
+    const planeDistance = (point, n, origin) => shared.some((vertex) => vertex.every((value, axis) => value === point[axis]))
+        ? 0
+        : dot(n, subtract(point, origin));
+    const distances0 = first.map((point) => planeDistance(point, n1, second[0]));
+    const distances1 = second.map((point) => planeDistance(point, n0, first[0]));
     const separated = (values) => values.every((value) => value > epsilon) || values.every((value) => value < -epsilon);
     if (separated(distances0) || separated(distances1))
         return false;

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

@@ -1,9 +1,9 @@
 import { GeometryError } from "../errors.js";
 import { immutableMeshView } from "../immutable-buffer.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 { IndexedMeshEdgeTable } from "./edge-table.js";
+import { analyzeTriangleMesh, } from "./operations.js";
+import { prepareSolidTriangle, trianglesIntersectBeyondSharedBoundary, triangleSolidAngle, } from "./solid-intersections.js";
 const MAXIMUM_TRIANGLES = 200_000;
 const MAXIMUM_TESTS = 2_000_000;
 /**
@@ -18,7 +18,7 @@ const MAXIMUM_TESTS = 2_000_000;
  * Input buffers are freshly inspected and never modified; units are millimetres.
  *
  * @param mesh - Closed triangle mesh to inspect.
- * @param options - Optional lower work ceiling and numeric comparison policy.
+ * @param options - Lower work limit and tolerance for numeric comparisons.
  * @returns The original mesh after every requested check succeeds.
  */
 export function validateSolidMesh(mesh, options = {}) {
@@ -172,7 +172,8 @@ function checkSolidGeometry(mesh, facts, options, { count, maxTests }) {
                 min[axis] = Math.min(min[axis], bounds[order[index] * 6 + axis]);
                 max[axis] = Math.max(max[axis], bounds[order[index] * 6 + axis + 3]);
             }
-        if (end - start <= 8)
+        // Small leaves avoid an 8x8 cross-product of false candidates on thin sampled surfaces.
+        if (end - start <= 4)
             return { start, end, min, max };
         let axis = 0;
         for (let index = 1; index < 3; index++)
@@ -219,7 +220,10 @@ function checkSolidGeometry(mesh, facts, options, { count, maxTests }) {
             visit(a.children[1], a.children[1]);
             return;
         }
-        if (a.children !== undefined) {
+        // Narrow both sides of a candidate pair instead of descending one entire subtree
+        // against a broad node on the other side of the thin sampled surface.
+        if (a.children !== undefined &&
+            (b.children === undefined || a.end - a.start >= b.end - b.start)) {
             visit(a.children[0], b);
             visit(a.children[1], b);
             return;

package/dist/geometry/mesh/triangle-quality.js

@@ -0,0 +1,42 @@
+const magnitude = (x, y, z, calculation) => calculation === "hypot" ? Math.hypot(x, y, z) : Math.sqrt(x * x + y * y + z * z);
+const cornerAngle = (ux, uy, uz, vx, vy, vz, calculation) => Math.atan2(magnitude(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx, calculation), ux * vx + uy * vy + uz * vz);
+/** @internal Shape measurements using the caller's selected length arithmetic and tolerances. */
+export function triangleQuality(first, second, third, calculation) {
+    const abx = second[0] - first[0], aby = second[1] - first[1], abz = second[2] - first[2];
+    const acx = third[0] - first[0], acy = third[1] - first[1], acz = third[2] - first[2];
+    const bcx = third[0] - second[0], bcy = third[1] - second[1], bcz = third[2] - second[2];
+    const cax = first[0] - third[0], cay = first[1] - third[1], caz = first[2] - third[2];
+    const crossX = aby * acz - abz * acy, crossY = abz * acx - abx * acz, crossZ = abx * acy - aby * acx;
+    const doubleArea = magnitude(crossX, crossY, crossZ, calculation);
+    let longestEdgeSquared;
+    let collapsed = false;
+    if (calculation === "hypot") {
+        const ab = Math.hypot(abx, aby, abz), ac = Math.hypot(acx, acy, acz), bc = Math.hypot(bcx, bcy, bcz);
+        longestEdgeSquared = Math.max(ab, ac, bc) ** 2;
+        collapsed = ab === 0 || ac === 0 || bc === 0;
+    }
+    else {
+        longestEdgeSquared = Math.max(abx * abx + aby * aby + abz * abz, bcx * bcx + bcy * bcy + bcz * bcz, cax * cax + cay * cay + caz * caz);
+    }
+    // Quality reporting negates these edges; flip comparison subtracts them directly.
+    // Preserve both evaluation paths, including signed zero, for deterministic quality ordering.
+    const bax = calculation === "hypot" ? -abx : first[0] - second[0], bay = calculation === "hypot" ? -aby : first[1] - second[1], baz = calculation === "hypot" ? -abz : first[2] - second[2];
+    const cbx = calculation === "hypot" ? -bcx : second[0] - third[0], cby = calculation === "hypot" ? -bcy : second[1] - third[1], cbz = calculation === "hypot" ? -bcz : second[2] - third[2];
+    const angles = collapsed
+        ? [0, 0, 0]
+        : [
+            Math.atan2(doubleArea, abx * acx + aby * acy + abz * acz),
+            cornerAngle(bcx, bcy, bcz, bax, bay, baz, calculation),
+            cornerAngle(cax, cay, caz, cbx, cby, cbz, calculation),
+        ];
+    return {
+        angles,
+        aspectRatio: doubleArea === 0
+            ? Number.POSITIVE_INFINITY
+            : (Math.sqrt(3) * longestEdgeSquared) / (2 * doubleArea),
+        crossX,
+        crossY,
+        crossZ,
+        doubleArea,
+    };
+}

package/dist/geometry/mesh/winding.js

@@ -0,0 +1,11 @@
+/**
+ * @internal Reverses validated, exclusively owned triangle indices in place.
+ * Global reversal preserves areas and closed topology; caller-owned public meshes need copies.
+ */
+export function reverseOwnedTriangleWinding(indices) {
+    for (let offset = 0; offset < indices.length; offset += 3) {
+        const second = indices[offset + 1];
+        indices[offset + 1] = indices[offset + 2];
+        indices[offset + 2] = second;
+    }
+}

package/dist/geometry/{numeric.js → mesh/write-vertex.js}

@@ -1,4 +1,4 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
 /** @internal Writes one finite, representable manufacturing vertex before checking mesh topology. */
 export function writeMeshVertex(positions, offset, point, operation) {
     for (let axis = 0; axis < 3; axis += 1) {