@metamesh/modeling 0.7.0 → 0.8.0

package/dist/engine/finalization.js

@@ -1,6 +1,8 @@
 import { GeometryError } from "../geometry/errors.js";
 import { optimizePlanarPatches } from "../geometry/mesh-planar.js";
-import { analyzeTriangleMesh } from "../geometry/mesh.js";
+import { validateAnalyzedSolidMesh } from "../geometry/mesh-solid.js";
+import { analyzeTriangleMesh, } from "../geometry/mesh.js";
+import { MeshViewCache } from "./mesh-view-cache.js";
 import { copiedMeshViews, copiedUint32Array } from "./native/copied-views.js";
 const isArray = (value) => Array.isArray(value);
 function finalPartTotals(parts) {
@@ -26,6 +28,12 @@ function fitsLimits(totals, limits) {
 }
 /** Finalizes one complete build under the selected limits, preserving usable originals when optional cleanup fails. */
 export function finalizeModel(execution, output, limits, options, startedAt, builtAt) {
+    if (options.meshValidation !== undefined &&
+        options.meshValidation !== "topology" &&
+        options.meshValidation !== "solid")
+        throw new GeometryError("INVALID_ARGUMENT", "Unsupported mesh validation mode.", {
+            operation: "finalize",
+        });
     const descriptors = execution.isSolid(output) ? [{ id: "model", solid: output }] : output;
     if (!isArray(descriptors) || descriptors.length === 0)
         throw new GeometryError("INVALID_ARGUMENT", "Build must return a solid or at least one named part.", { operation: "finalize" });
@@ -36,6 +44,7 @@ export function finalizeModel(execution, output, limits, options, startedAt, bui
     const ids = new Set();
     const backingBuffers = new Set();
     const meshCopies = new Map();
+    const directMeasurements = new MeshViewCache();
     const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
     let vertices = 0, triangles = 0, bytes = 0;
     let parts = descriptors.map((descriptor) => {
@@ -76,10 +85,12 @@ export function finalizeModel(execution, output, limits, options, startedAt, bui
             throw new GeometryError("COMPLEXITY_LIMIT", "Aggregate output exceeds the execution limits.", { operation: "finalize" });
         // Direct meshes are copied before analysis so later caller mutation cannot invalidate facts.
         const mesh = descriptor.mesh === undefined ? source : copiedMeshViews(source, meshCopies);
-        const measurements = nativeAnalysis?.measurements ??
-            analyzeTriangleMesh(mesh, { requireClosed: true, includeTopology: true });
-        if (descriptor.mesh !== undefined)
+        let measurements = nativeAnalysis?.measurements ?? directMeasurements.get(mesh);
+        if (measurements === undefined) {
+            measurements = analyzeTriangleMesh(mesh, { requireClosed: true, includeTopology: true });
             execution.validateMesh(mesh);
+            directMeasurements.set(mesh, measurements);
+        }
         if (!(measurements.signedVolume > 0))
             throw new GeometryError("INVALID_TOPOLOGY", "Manufacturing parts must enclose positive oriented volume.", { operation: "finalize" });
         for (let axis = 0; axis < 3; axis += 1) {
@@ -95,20 +106,9 @@ export function finalizeModel(execution, output, limits, options, startedAt, bui
     });
     const originalParts = parts;
     if (options.meshTopologyMode === "optimized" && triangles <= 200_000) {
-        const candidates = new Map();
+        const candidates = new MeshViewCache();
         parts = parts.map((part) => {
-            let indexBuffers = candidates.get(part.positions.buffer);
-            if (indexBuffers === undefined) {
-                indexBuffers = new Map();
-                candidates.set(part.positions.buffer, indexBuffers);
-            }
-            let views = indexBuffers.get(part.indices.buffer);
-            if (views === undefined) {
-                views = new Map();
-                indexBuffers.set(part.indices.buffer, views);
-            }
-            const key = `${part.positions.byteOffset}:${part.positions.length}:${part.indices.byteOffset}:${part.indices.length}`;
-            const cached = views.get(key);
+            const cached = candidates.get(part);
             if (cached !== undefined)
                 return Object.freeze({ ...part, ...cached });
             let selected = {
@@ -134,7 +134,7 @@ export function finalizeModel(execution, output, limits, options, startedAt, bui
             catch {
                 // Optional optimization preserves the usable original on unsupported geometry.
             }
-            views.set(key, selected);
+            candidates.set(part, selected);
             return Object.freeze({ ...part, ...selected });
         });
     }
@@ -148,6 +148,15 @@ export function finalizeModel(execution, output, limits, options, startedAt, bui
         throw new GeometryError("COMPLEXITY_LIMIT", "Selected output exceeds the execution limits.", {
             operation: "finalize",
         });
+    if (options.meshValidation === "solid") {
+        const checked = new MeshViewCache();
+        for (const part of parts) {
+            if (checked.get(part) !== undefined)
+                continue;
+            validateAnalyzedSolidMesh(part, part.measurements);
+            checked.set(part, true);
+        }
+    }
     const finalizedAt = performance.now();
     return Object.freeze({
         parts: Object.freeze(parts),

package/dist/engine/inspection-operations.js

@@ -1,26 +1,21 @@
 import { ownScopedManifoldValue } from "./native/context.js";
 import { copiedMeshViews } from "./native/copied-views.js";
+import { measureSolidDistance } from "./native/distance.js";
+import { assertNativeSolidStatus } from "./native/status.js";
 /** Internal host-bound inspection operations. */
 export function createInspectionOperations(environment) {
-    const { scope, throwGeometryError, nativeSolid, nativeSection, ownSolid, validateFiniteNumber, requirePositiveNumber, validateCoordinates, analyzedMeshFor, } = environment;
+    const { scope, throwGeometryError, nativeSolid, resolveHandle, ownSolid, ownSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, analyzedMeshFor, solidInspectionFor, sectionInspectionFor, } = environment;
     const operations = {
         toTriangleMesh: (value) => copiedMeshViews(analyzedMeshFor(value).mesh, new Map()),
-        inspectSection: (handle) => {
-            const native = nativeSection(handle), bounds = native.bounds();
-            const parts = native.decompose().map((part) => ownScopedManifoldValue(scope, part));
-            return {
-                ...bounds,
-                area: native.area(),
-                contours: native.toPolygons().length,
-                parts: parts.length,
-                vertices: native.numVert(),
-            };
-        },
-        inspectSolid: (handle) => {
-            const native = nativeSolid(handle), bounds = native.boundingBox();
-            const parts = native.decompose().map((part) => ownScopedManifoldValue(scope, part));
-            return { ...bounds, parts: parts.length, volume: native.volume() };
+        inspectSection: sectionInspectionFor,
+        inspectSolid: solidInspectionFor,
+        isEmpty: (handle) => {
+            const native = resolveHandle(handle);
+            if (native.kind === "solid")
+                assertNativeSolidStatus(native.value, "isEmpty");
+            return native.value.isEmpty();
         },
+        distance: (handle, other) => measureSolidDistance(nativeSolid(handle), nativeSolid(other)),
         rayCast: (handle, origin, endpoint) => {
             validateCoordinates(origin, 3, "rayCast");
             validateCoordinates(endpoint, 3, "rayCast");
@@ -36,12 +31,21 @@ export function createInspectionOperations(environment) {
                 normal: Object.freeze([...hit.normal]),
             })));
         },
-        components: (handle) => nativeSolid(handle).decompose().map(ownSolid),
-        simplify: (handle, tolerance) => {
-            const native = nativeSolid(handle);
-            const original = ownScopedManifoldValue(scope, native.asOriginal());
-            return ownSolid(original.simplify(requirePositiveNumber(tolerance, "simplify")));
-        },
+        components: ((handle) => {
+            const native = resolveHandle(handle);
+            if (native.kind === "section")
+                return Object.freeze(native.value.isEmpty() ? [] : native.value.decompose().map(ownSection));
+            assertNativeSolidStatus(native.value, "components");
+            return Object.freeze(native.value.decompose().map(ownSolid));
+        }),
+        simplify: ((handle, tolerance) => {
+            const native = resolveHandle(handle);
+            const distance = requirePositiveNumber(tolerance, "simplify");
+            if (native.kind === "section")
+                return ownSection(native.value.simplify(distance));
+            const original = ownScopedManifoldValue(scope, native.value.asOriginal());
+            return ownSolid(original.simplify(distance));
+        }),
         setTolerance: (handle, tolerance) => {
             if (validateFiniteNumber(tolerance, "setTolerance") < 0)
                 throwGeometryError("INVALID_ARGUMENT", "setTolerance", "Tolerance must be nonnegative millimetres.");

package/dist/engine/loft-operations.js

@@ -143,7 +143,7 @@ export function createLoftOperation(environment, solidFromMesh) {
         const geometry = prepareLoftGeometry(input, selected, selected.limits, authoritative, recipeSampled);
         if (geometry.stations.every((station) => station.profile.components.length === 1 &&
             station.profile.components[0].holes.length === 0))
-            return solidFromMesh(simpleLoftMesh(geometry, selected.limits, environment.assertMeshAllocation));
+            return solidFromMesh(simpleLoftMesh(geometry, selected.limits));
         const mesh = buildProfileLoftMesh(environment.module, geometry.stations, selected.limits, false, 0, (station, contour, slot) => geometry.world[station][contour][slot]);
         if (measureTriangleMesh(mesh).signedVolume < 0)
             for (let index = 0; index < mesh.indices.length; index += 3) {

package/dist/engine/mechanical-operations.js

@@ -2,15 +2,12 @@ import * as kernel from "./native/index.js";
 /** Internal host-bound mechanical operations. */
 export function createMechanicalOperations(environment) {
     const { resolution } = environment;
-    const { scope, assertActive, wrapSolid, assertMeshAllocation, withResolutionDefaults } = environment;
+    const { scope, assertActive, wrapSolid, withResolutionDefaults } = environment;
     const nutOptions = (value) => ({
         ...withResolutionDefaults(value),
         bodyResolution: { ...resolution, ...value.bodyResolution },
     });
-    const threadBudget = (preflight, operation) => {
-        const vertices = (preflight.estimatedRows + 2) * preflight.circularSegments;
-        assertMeshAllocation(vertices, preflight.estimatedTriangles, (vertices + preflight.estimatedTriangles) * 12, operation);
-    };
+    // Explicit preflight preserves the stable error operation names exposed by these constructors.
     const operations = {
         threadRidge: (value) => {
             assertActive();
@@ -19,19 +16,19 @@ export function createMechanicalOperations(environment) {
         threadedRod: (value) => {
             assertActive();
             const resolved = withResolutionDefaults(value);
-            threadBudget(kernel.preflightThreadedRod(resolved), "threadedRod");
+            kernel.preflightThreadedRod(resolved);
             return wrapSolid(kernel.threadedRod(scope, resolved));
         },
         internalThreadCutter: (value) => {
             assertActive();
             const resolved = withResolutionDefaults(value);
-            threadBudget(kernel.preflightInternalThreadCutter(resolved), "internalThreadCutter");
+            kernel.preflightInternalThreadCutter(resolved);
             return wrapSolid(kernel.internalThreadCutter(scope, resolved));
         },
         threadedNut: (value) => {
             assertActive();
             const resolved = nutOptions(value);
-            threadBudget(kernel.preflightThreadedNut(resolved).thread, "threadedNut");
+            kernel.preflightThreadedNut(resolved);
             return wrapSolid(kernel.threadedNut(scope, resolved));
         },
         preflightThreadedRod: (value) => {

package/dist/engine/mesh-view-cache.js

@@ -0,0 +1,23 @@
+/** @internal Operation-local facts for identical privately owned mesh buffer ranges. */
+export class MeshViewCache {
+    positions = new Map();
+    key(mesh) {
+        return `${mesh.positions.byteOffset}:${mesh.positions.length}:${mesh.indices.byteOffset}:${mesh.indices.length}`;
+    }
+    get(mesh) {
+        return this.positions.get(mesh.positions.buffer)?.get(mesh.indices.buffer)?.get(this.key(mesh));
+    }
+    set(mesh, value) {
+        let indices = this.positions.get(mesh.positions.buffer);
+        if (indices === undefined) {
+            indices = new Map();
+            this.positions.set(mesh.positions.buffer, indices);
+        }
+        let ranges = indices.get(mesh.indices.buffer);
+        if (ranges === undefined) {
+            ranges = new Map();
+            indices.set(mesh.indices.buffer, ranges);
+        }
+        ranges.set(this.key(mesh), value);
+    }
+}

package/dist/engine/native/adapter.js

@@ -1,4 +1,5 @@
 import { validateTriangleMesh } from "../../geometry/mesh.js";
+import { assertNativeSolidStatus } from "./status.js";
 /**
  * Constructs a live Manifold solid from a copied indexed triangle mesh.
  *
@@ -12,9 +13,6 @@ export const triangleMeshToManifold = (module, mesh, scope) => {
         triVerts: mesh.indices,
     });
     const manifold = scope.own(new module.Manifold(manifoldMesh));
-    const status = manifold.status();
-    if (status !== "NoError") {
-        throw new Error(`Manifold rejected generated mesh: ${status}.`);
-    }
+    assertNativeSolidStatus(manifold, "solidFromMesh");
     return manifold;
 };

package/dist/engine/native/distance.js

@@ -0,0 +1,42 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { assertNativeSolidStatus } from "./status.js";
+/** Internal minimum separation query; never exposes the kernel's capped search result. */
+export function measureSolidDistance(left, right) {
+    assertNativeSolidStatus(left, "distance");
+    assertNativeSolidStatus(right, "distance");
+    if (left.isEmpty() || right.isEmpty())
+        throw new GeometryError("DEGENERATE_GEOMETRY", "Distance requires nonempty solids.", {
+            operation: "distance",
+        });
+    const a = left.boundingBox(), b = right.boundingBox();
+    const axes = [0, 1, 2];
+    const lower = Math.hypot(...axes.map((i) => Math.max(0, a.min[i] - b.max[i], b.min[i] - a.max[i])));
+    const upper = Math.hypot(...axes.map((i) => Math.max(Math.abs(a.min[i] - b.max[i]), Math.abs(a.max[i] - b.min[i]))));
+    const diagonal = Math.max(Math.hypot(...axes.map((i) => a.max[i] - a.min[i])), Math.hypot(...axes.map((i) => b.max[i] - b.min[i])));
+    const scale = Math.max(upper, ...[...a.min, ...a.max, ...b.min, ...b.max].map(Math.abs));
+    const padding = Math.max(Math.sqrt(Number.MIN_VALUE) * 2, scale * Number.EPSILON * 8);
+    const maximum = upper + padding;
+    if (!Number.isFinite(maximum * maximum) || maximum <= 0)
+        throw new GeometryError("NON_FINITE_VALUE", "Distance exceeds the kernel's numeric range.", {
+            operation: "distance",
+        });
+    // A modest extent-based seed avoids many tiny searches for very unequal shapes.
+    // A full bounding-box diagonal would make the kernel visit unnecessary triangle pairs.
+    let radius = Math.min(maximum, Math.max(lower + padding, diagonal / 32, padding));
+    for (;;) {
+        const value = left.minGap(right, radius);
+        // The kernel takes sqrt(radius²) when capped; that can round below radius.
+        const capSlack = Math.max(Math.sqrt(Number.MIN_VALUE), radius * Number.EPSILON * 4);
+        if (!Number.isFinite(value) || value < 0 || value > radius + capSlack)
+            throw new GeometryError("NON_FINITE_VALUE", "The kernel returned an invalid distance.", {
+                operation: "distance",
+            });
+        if (value < radius - capSlack)
+            return value;
+        if (radius === maximum)
+            throw new GeometryError("INVALID_MESH", "The kernel could not resolve the minimum distance.", {
+                operation: "distance",
+            });
+        radius = Math.min(maximum, radius * 2);
+    }
+}

package/dist/engine/native/status.js

@@ -0,0 +1,16 @@
+import { GeometryError } from "../../geometry/errors.js";
+/** Checks an already required native evaluation without exposing upstream status types publicly. */
+export function assertNativeSolidStatus(native, operation) {
+    const status = native.status();
+    if (status === "NoError")
+        return;
+    const code = status === "NonFiniteVertex"
+        ? "NON_FINITE_VALUE"
+        : status === "ResultTooLarge"
+            ? "COMPLEXITY_LIMIT"
+            : "INVALID_TOPOLOGY";
+    throw new GeometryError(code, `The geometry kernel rejected the solid: ${status}.`, {
+        operation,
+        details: { nativeStatus: status },
+    });
+}

package/dist/engine/operation-environment.js

@@ -3,7 +3,8 @@ import { resolveCircularPrimitiveSegments } from "../geometry/primitive-resoluti
 /** Applies explicit resolution inheritance once for this bound context. */
 export function createOperationEnvironment(owner, resolution) {
     const withResolutionDefaults = (value) => {
-        const limits = resolveModelingLimits(value.limits, owner.limits);
+        const overrides = value.limits;
+        const limits = overrides === undefined ? owner.limits : resolveModelingLimits(overrides, owner.limits);
         return {
             ...value,
             resolution: {

package/dist/engine/section-operations.js

@@ -5,7 +5,7 @@ import { sampleTextContours } from "../geometry/text-contours.js";
 import * as kernel from "./native/index.js";
 /** Internal host-bound section operations. */
 export function createSectionOperations(environment, transforms) {
-    const { module, limits, scope, assertActive, throwGeometryError, nativeSolid, nativeSection, wrapSection, ownSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, assertOperandCount, withResolutionDefaults, resolveCircularSegments, } = environment;
+    const { module, limits, scope, assertActive, throwGeometryError, nativeSolid, nativeSection, wrapSection, ownSection, validateFiniteNumber, validateCoordinates, assertOperandCount, withResolutionDefaults, resolveCircularSegments, } = environment;
     const { translate } = transforms.operations;
     const fromContours = (contours, value = {}) => {
         assertActive();
@@ -51,8 +51,8 @@ export function createSectionOperations(environment, transforms) {
             const join = value.join ?? "round";
             if (!["round", "miter", "square"].includes(join))
                 throwGeometryError("INVALID_ARGUMENT", "offset", "Unsupported offset join.");
-            if (value.miterLimit !== undefined)
-                requirePositiveNumber(value.miterLimit, "offset");
+            if (value.miterLimit !== undefined && validateFiniteNumber(value.miterLimit, "offset") < 2)
+                throwGeometryError("INVALID_ARGUMENT", "offset", "miterLimit must be at least two.");
             return ownSection(native.offset(distance, join === "round" ? "Round" : join === "miter" ? "Miter" : "Square", value.miterLimit, resolveCircularSegments(Math.max(Math.abs(distance), 0.001), {
                 ...(value.circularSegments === undefined ? {} : { segments: value.circularSegments }),
                 ...(value.resolution === undefined ? {} : { resolution: value.resolution }),

package/dist/geometry/heightfield.js

@@ -1,50 +1,91 @@
 import { GeometryError } from "./errors.js";
 import { validateTriangleMesh } from "./mesh.js";
-import { defaultModelingLimits } from "./model-limits.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "./model-limits.js";
 import { writeMeshVertex } from "./numeric.js";
-const isArray = (value) => Array.isArray(value);
-/** Checks regular-grid dimensions and bounds allocation before evaluating any height samples. */
-export function preflightHeightfield(options, limits = {}) {
+function planHeightfield(options, limits) {
     const operation = "preflightHeightfield";
     if (typeof options !== "object" ||
         options === null ||
-        !isArray(options.size) ||
-        options.size.length !== 2 ||
-        !options.size.every((value) => Number.isFinite(value) && value > 0) ||
-        !isArray(options.segments) ||
-        options.segments.length !== 2 ||
-        !options.segments.every((value) => Number.isSafeInteger(value) && value > 0) ||
         typeof options.height !== "function" ||
         !Number.isFinite(options.baseZ ?? 0) ||
-        (options.origin !== undefined &&
-            (!isArray(options.origin) ||
-                options.origin.length !== 2 ||
-                !options.origin.every(Number.isFinite)))) {
-        throw new GeometryError("INVALID_ARGUMENT", "Heightfields need a finite positive footprint, integer intervals, finite base, and a height callback.", { operation });
+        (options.triangulation !== undefined &&
+            !["fixed", "min-edge", "center-error"].includes(options.triangulation))) {
+        throw new GeometryError("INVALID_ARGUMENT", "Heightfields need a finite base, height callback, and supported triangulation policy.", { operation });
+    }
+    let x, y;
+    let xAt, yAt;
+    if (options.coordinates !== undefined) {
+        const coordinates = options.coordinates;
+        if (typeof coordinates !== "object" ||
+            coordinates === null ||
+            !Array.isArray(coordinates.x) ||
+            !Array.isArray(coordinates.y) ||
+            coordinates.x.length < 2 ||
+            coordinates.y.length < 2 ||
+            options.size !== undefined ||
+            options.segments !== undefined ||
+            options.origin !== undefined) {
+            throw new GeometryError("INVALID_ARGUMENT", "Explicit heightfield coordinates need two or more samples per axis and cannot include size, segments, or origin.", { operation });
+        }
+        x = coordinates.x.length - 1;
+        y = coordinates.y.length - 1;
+        xAt = (index) => coordinates.x[index];
+        yAt = (index) => coordinates.y[index];
+    }
+    else {
+        if (!Array.isArray(options.size) ||
+            options.size.length !== 2 ||
+            !options.size.every((value) => Number.isFinite(value) && value > 0) ||
+            !Array.isArray(options.segments) ||
+            options.segments.length !== 2 ||
+            !options.segments.every((value) => Number.isSafeInteger(value) && value > 0) ||
+            (options.origin !== undefined &&
+                (!Array.isArray(options.origin) ||
+                    options.origin.length !== 2 ||
+                    !options.origin.every(Number.isFinite)))) {
+            throw new GeometryError("INVALID_ARGUMENT", "Uniform heightfields need a finite positive footprint, integer intervals, and finite origin.", { operation });
+        }
+        [x, y] = options.segments;
+        const [width, depth] = options.size;
+        const [originX, originY] = options.origin ?? [-width / 2, -depth / 2];
+        xAt = (index) => originX + (width * index) / x;
+        yAt = (index) => originY + (depth * index) / y;
     }
-    const [x, y] = options.segments;
     const sampleCount = (x + 1) * (y + 1);
     const perimeter = 2 * (x + y);
     const vertexCount = sampleCount + perimeter + 1;
     const triangleCount = 2 * x * y + 3 * perimeter;
     const byteCount = 12 * (vertexCount + triangleCount);
-    const policy = { ...defaultModelingLimits, ...limits };
-    if (![policy.maxVertices, policy.maxTriangles, policy.maxBytes].every((value) => Number.isSafeInteger(value) && value > 0))
-        throw new GeometryError("INVALID_ARGUMENT", "Heightfield ceilings must be positive safe integers.", { operation });
-    if (!Number.isSafeInteger(byteCount) ||
-        vertexCount > 0xffff_ffff ||
-        triangleCount * 3 > 0xffff_ffff ||
-        vertexCount > policy.maxVertices ||
-        triangleCount > policy.maxTriangles ||
-        byteCount > policy.maxBytes) {
-        throw new GeometryError("COMPLEXITY_LIMIT", "Heightfield grid exceeds the configured output limits or numeric index ceiling.", { operation });
+    assertMeshAllocationWithinLimits(vertexCount, triangleCount, byteCount, operation, resolveModelingLimits(limits));
+    for (const [axis, count, at] of [
+        ["x", x, xAt],
+        ["y", y, yAt],
+    ]) {
+        let previous = -Infinity;
+        for (let index = 0; index <= count; index += 1) {
+            const coordinate = Math.fround(at(index));
+            if (!Number.isFinite(coordinate) || !(coordinate > previous))
+                throw new GeometryError("INVALID_ARGUMENT", "Heightfield axes must be finite, strictly increasing, and distinct in Float32 storage.", { operation, details: { axis, index } });
+            previous = coordinate;
+        }
     }
-    return Object.freeze({ sampleCount, vertexCount, triangleCount, byteCount });
+    return {
+        x,
+        y,
+        xAt,
+        yAt,
+        facts: Object.freeze({ sampleCount, vertexCount, triangleCount, byteCount }),
+    };
+}
+/** Checks grid dimensions, coordinate precision, and allocation bounds before evaluating heights. */
+export function preflightHeightfield(options, limits = {}) {
+    return planHeightfield(options, limits).facts;
 }
 /**
- * Builds a closed indexed solid from a regularly sampled top, matched boundary walls, and flat base.
- * Heights are evaluated once per grid point after allocation preflight. Physical XY sizes and all
- * output coordinates must fit Float32 storage. Shared wall vertices prevent cracks at the base.
+ * Builds a closed indexed mesh from a rectilinear top, matched boundary walls, and flat base.
+ * Heights run once per grid point after preflight; center-error adds one evaluation per cell.
+ * Top winding is +Z, the base is -Z, and sides face outward. Coordinates and heights must fit
+ * Float32 storage. Explicit axes are captured before sampling; shared wall vertices prevent cracks.
  *
  * @example Sample a closed wavy mesh
  * ```ts
@@ -55,11 +96,13 @@ export function preflightHeightfield(options, limits = {}) {
  * ```
  */
 export function heightfieldMesh(options, limits = {}) {
-    const facts = preflightHeightfield(options, limits);
+    const plan = planHeightfield(options, limits);
+    const { facts, x: nx, y: ny } = plan;
     const operation = "heightfieldMesh";
-    const [nx, ny] = options.segments;
-    const [width, depth] = options.size;
-    const [originX, originY] = options.origin ?? [-width / 2, -depth / 2];
+    const xs = Array.from({ length: nx + 1 }, (_, index) => plan.xAt(index));
+    const ys = Array.from({ length: ny + 1 }, (_, index) => plan.yAt(index));
+    const triangulation = options.triangulation ?? "fixed";
+    const heightAt = options.height;
     const baseZ = Math.fround(options.baseZ ?? 0);
     if (!Number.isFinite(baseZ))
         throw new GeometryError("NON_FINITE_VALUE", "Heightfield base must fit Float32 storage.", {
@@ -68,13 +111,16 @@ export function heightfieldMesh(options, limits = {}) {
     const positions = new Float32Array(facts.vertexCount * 3);
     const indices = new Uint32Array(facts.triangleCount * 3);
     const grid = (x, y) => y * (nx + 1) + x;
+    const sampleHeight = (point) => {
+        const height = Math.fround(heightAt(point));
+        if (!Number.isFinite(height) || !(height > baseZ))
+            throw new GeometryError("INVALID_ARGUMENT", "Every finite Float32 height must be strictly above the Float32 base.", { operation, details: { x: point[0], y: point[1] } });
+        return height;
+    };
     for (let y = 0; y <= ny; y += 1) {
         for (let x = 0; x <= nx; x += 1) {
-            const point = [originX + (width * x) / nx, originY + (depth * y) / ny];
-            const height = Math.fround(options.height(point));
-            if (!Number.isFinite(height) || !(height > baseZ)) {
-                throw new GeometryError("INVALID_ARGUMENT", "Every finite Float32 height must be strictly above the Float32 base.", { operation, details: { x, y } });
-            }
+            const point = [xs[x], ys[y]];
+            const height = sampleHeight(point);
             writeMeshVertex(positions, grid(x, y) * 3, [point[0], point[1], height], operation);
         }
     }
@@ -87,8 +133,21 @@ export function heightfieldMesh(options, limits = {}) {
     for (let y = 0; y < ny; y += 1) {
         for (let x = 0; x < nx; x += 1) {
             const a = grid(x, y), b = grid(x + 1, y), c = grid(x + 1, y + 1), d = grid(x, y + 1);
-            triangle(a, b, c);
-            triangle(a, c, d);
+            const za = positions[a * 3 + 2], zb = positions[b * 3 + 2], zc = positions[c * 3 + 2], zd = positions[d * 3 + 2];
+            // Rectangular XY cells have equal XY diagonal lengths, so only Z differs.
+            let alternate = triangulation === "min-edge" && Math.abs(zb - zd) < Math.abs(za - zc);
+            if (triangulation === "center-error") {
+                const centre = sampleHeight([(xs[x] + xs[x + 1]) / 2, (ys[y] + ys[y + 1]) / 2]);
+                alternate = Math.abs((zb + zd) / 2 - centre) < Math.abs((za + zc) / 2 - centre);
+            }
+            if (alternate) {
+                triangle(a, b, d);
+                triangle(b, c, d);
+            }
+            else {
+                triangle(a, b, c);
+                triangle(a, c, d);
+            }
         }
     }
     const boundary = [];
@@ -102,7 +161,7 @@ export function heightfieldMesh(options, limits = {}) {
         boundary.push(grid(0, y));
     const baseStart = facts.sampleCount;
     const baseCenter = facts.vertexCount - 1;
-    writeMeshVertex(positions, baseCenter * 3, [originX + width / 2, originY + depth / 2, baseZ], operation);
+    writeMeshVertex(positions, baseCenter * 3, [(xs[0] + xs[nx]) / 2, (ys[0] + ys[ny]) / 2, baseZ], operation);
     for (let offset = 0; offset < boundary.length; offset += 1) {
         const top = boundary[offset];
         writeMeshVertex(positions, (baseStart + offset) * 3, [positions[top * 3], positions[top * 3 + 1], baseZ], operation);

package/dist/geometry/index.js

@@ -1,4 +1,6 @@
 /** Pure geometry foundations without host initialization. @packageDocumentation */
+export { validateSolidMesh } from "./mesh-solid.js";
+export { computeTriangleMeshCentroid } from "./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";

package/dist/geometry/loft-simple-mesh.js

@@ -1,15 +1,14 @@
 import { GeometryError } from "./errors.js";
 import { triangulateLoop2 } from "./loft-triangulation.js";
 import { measureTriangleMesh, validateTriangleMesh } from "./mesh.js";
-import { assertMeshAllocationWithinLimits, } from "./model-limits.js";
+import { assertMeshAllocationWithinLimits } from "./model-limits.js";
 import { writeMeshVertex } from "./numeric.js";
 /** @internal Pure closed simple-contour strips, retaining repeated correspondence slots as shared physical vertices. */
-export function simpleLoftMesh(geometry, limits, allocationGuard) {
+export function simpleLoftMesh(geometry, limits) {
     const count = geometry.world[0][0].length, rowCount = geometry.world.length;
     const maximumVertices = count * rowCount, maximumTriangles = 2 * count * (rowCount - 1) + 2 * (count - 2);
     const bytes = 12 * (maximumVertices + maximumTriangles);
     assertMeshAllocationWithinLimits(maximumVertices, maximumTriangles, bytes, "loftMesh", limits);
-    allocationGuard?.(maximumVertices, maximumTriangles, bytes, "loftMesh");
     const positions = new Float32Array(maximumVertices * 3), indices = new Uint32Array(maximumTriangles * 3);
     let vertexCount = 0, cursor = 0;
     const rows = geometry.world.map((contours, row) => {

package/dist/geometry/loft-triangulation.js

@@ -11,6 +11,16 @@ const pointInTriangle = (point, a, b, c, epsilon) => {
 /** Ear-clips one normalized simple CCW loop into stable local vertex indices. */
 export function triangulateLoop2(loop) {
     const normalized = normalizeLoop2(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",
+                details: { requiredCount, allowedCount: maximumComparisons },
+            });
+    };
+    // Every accepted ear scans all remaining vertices plus its outer-loop comparison.
+    // Reject impossible workloads before clipping; unsuccessful ears still spend the live budget.
+    assertComparisonLimit(((normalized.length - 3) * (normalized.length + 6)) / 2);
     // Subdividing a straight edge introduces roundoff-sized turns. Treat them consistently
     // in both ear convexity and containment so they cannot consume a false ear or block the cap.
     let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
@@ -25,24 +35,17 @@ export function triangulateLoop2(loop) {
     const remaining = normalized.map((_, index) => index);
     const triangles = [];
     let comparisons = 0;
-    const consume = () => {
-        if (++comparisons > maximumComparisons)
-            throw new GeometryError("COMPLEXITY_LIMIT", "Profile cap triangulation exceeds its eight-million-comparison work limit.", {
-                operation: "triangulateLoop2",
-                details: { requiredCount: comparisons, allowedCount: maximumComparisons },
-            });
-    };
     while (remaining.length > 3) {
         let clipped = false;
         for (let offset = 0; offset < remaining.length; offset += 1) {
-            consume();
+            assertComparisonLimit(++comparisons);
             const previous = remaining[(offset - 1 + remaining.length) % remaining.length];
             const current = remaining[offset];
             const next = remaining[(offset + 1) % remaining.length];
             if (cross(normalized[previous], normalized[current], normalized[next]) <= epsilon)
                 continue;
             if (remaining.some((candidate) => {
-                consume();
+                assertComparisonLimit(++comparisons);
                 return (candidate !== previous &&
                     candidate !== current &&
                     candidate !== next &&