@metamesh/modeling 0.7.0 → 0.8.0

package/dist/geometry/loft.js

@@ -3,7 +3,7 @@ import { resolveExtrusionControls, resolveExtrusionDivisions, } from "./extrusio
 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 { assertMeshAllocationWithinLimits, resolveModelingLimits } from "./model-limits.js";
 import { assertSamplingCount } from "./sampling-limits.js";
 export { triangulateLoop2 } from "./loft-triangulation.js";
 /**
@@ -23,10 +23,6 @@ export { triangulateLoop2 } from "./loft-triangulation.js";
  * ```
  */
 export function loftMesh(stations, options) {
-    return buildLoftMesh(stations, options);
-}
-/** @internal Shared pure loft with host allocation preflight. */
-export function buildLoftMesh(stations, options, allocationGuard) {
     if (options?.correspondence === undefined)
         throw new GeometryError("INVALID_ARGUMENT", "Point-loop lofts require an explicit correspondence method.", { operation: "loftMesh" });
     const limits = resolveModelingLimits(options.limits);
@@ -45,7 +41,7 @@ export function buildLoftMesh(stations, options, allocationGuard) {
         ...station,
         profile: pointLoftProfile(station.profile),
     }));
-    return simpleLoftMesh(prepareLoftGeometry(profiles, options, limits, false), limits, allocationGuard);
+    return simpleLoftMesh(prepareLoftGeometry(profiles, options, limits, false), limits);
 }
 /**
  * Linearly extrudes one simple profile along +Z with robust ear-clipped caps.

package/dist/geometry/mechanical/standards.js

@@ -44,11 +44,10 @@ export const METRIC_FASTENER_STANDARDS = Object.freeze({
 });
 /** Returns the immutable standards record for one supported metric size. */
 export function getMetricFastenerStandard(size) {
-    const value = METRIC_FASTENER_STANDARDS[size];
-    if (value === undefined) {
+    if (!Object.hasOwn(METRIC_FASTENER_STANDARDS, size)) {
         throw new GeometryError("INVALID_ARGUMENT", `Unsupported metric fastener size: ${size}.`);
     }
-    return value;
+    return METRIC_FASTENER_STANDARDS[size];
 }
 /** Returns one recommended metric clearance-hole diameter in millimetres. */
 export function getMetricClearanceHole(size, fit = "normal") {

package/dist/geometry/mechanical/threads.js

@@ -36,11 +36,10 @@ const validateFitPolicy = (policy) => {
 export function resolvePrintableThreadFitPolicy(fit = "normal") {
     if (typeof fit !== "string")
         return validateFitPolicy(fit);
-    const policy = PRINTABLE_THREAD_FIT_POLICIES[fit];
-    if (policy === undefined) {
+    if (!Object.hasOwn(PRINTABLE_THREAD_FIT_POLICIES, fit)) {
         throw new GeometryError("INVALID_ARGUMENT", `Unsupported printable thread fit: ${fit}.`);
     }
-    return policy;
+    return PRINTABLE_THREAD_FIT_POLICIES[fit];
 }
 /**
  * Applies role-specific radial compensation while preserving thread depth.

package/dist/geometry/mesh-centroid.js

@@ -0,0 +1,36 @@
+import { GeometryError } from "./errors.js";
+import { analyzeTriangleMesh } from "./mesh.js";
+/**
+ * Computes the uniform-density volume centroid of an oriented closed solid, including cavity shells.
+ * Coordinates are millimetres. Indexed closure and positive aggregate volume are required; callers
+ * may use validateSolidMesh first when geometric intersections and shell orientation are untrusted.
+ * Fresh mutable input is inspected on every call, and buffers are never changed.
+ *
+ * @param mesh - Consistently oriented closed mesh with positive enclosed volume.
+ * @returns A fresh immutable XYZ volume centroid.
+ */
+export function computeTriangleMeshCentroid(mesh) {
+    const facts = analyzeTriangleMesh(mesh, { requireClosed: true });
+    if (!(facts.signedVolume > 0))
+        throw new GeometryError("INVALID_TOPOLOGY", "A volume centroid requires positive oriented volume.", { operation: "computeTriangleMeshCentroid" });
+    const origin = facts.bounds.min;
+    const totals = [0, 0, 0], corrections = [0, 0, 0];
+    for (let offset = 0; offset < mesh.indices.length; offset += 3) {
+        const a = mesh.indices[offset] * 3, b = mesh.indices[offset + 1] * 3, c = mesh.indices[offset + 2] * 3;
+        const ax = mesh.positions[a] - origin[0], ay = mesh.positions[a + 1] - origin[1], az = mesh.positions[a + 2] - origin[2];
+        const bx = mesh.positions[b] - origin[0], by = mesh.positions[b + 1] - origin[1], bz = mesh.positions[b + 2] - origin[2];
+        const cx = mesh.positions[c] - origin[0], cy = mesh.positions[c + 1] - origin[1], cz = mesh.positions[c + 2] - origin[2];
+        const volume = (ax * (by * cz - bz * cy) + ay * (bz * cx - bx * cz) + az * (bx * cy - by * cx)) / 6;
+        const coordinates = [(ax + bx + cx) / 4, (ay + by + cy) / 4, (az + bz + cz) / 4];
+        for (let axis = 0; axis < 3; axis++) {
+            const value = volume * coordinates[axis], next = totals[axis] + value;
+            corrections[axis] +=
+                Math.abs(totals[axis]) >= Math.abs(value)
+                    ? totals[axis] - next + value
+                    : value - next + totals[axis];
+            totals[axis] = next;
+        }
+    }
+    const coordinate = (axis) => origin[axis] + (totals[axis] + corrections[axis]) / facts.signedVolume;
+    return Object.freeze([coordinate(0), coordinate(1), coordinate(2)]);
+}

package/dist/geometry/mesh-solid-intersections.js

@@ -0,0 +1,123 @@
+const subtract = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const cross = (a, b) => [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0],
+];
+const distance = (a, b) => Math.hypot(...subtract(a, b));
+const normal = (triangle) => {
+    const value = cross(subtract(triangle[1], triangle[0]), subtract(triangle[2], triangle[0]));
+    const length = Math.hypot(...value);
+    return [value[0] / length, value[1] / length, value[2] / length];
+};
+/** @internal Reuses the same double-precision normal for repeated contact tests. */
+export function prepareSolidTriangle(points) {
+    return { points, normal: normal(points) };
+}
+const project = (point, axis) => axis === 0 ? [point[1], point[2]] : axis === 1 ? [point[0], point[2]] : [point[0], point[1]];
+const turn = (a, b, p) => (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);
+const dominantAxis = (value) => {
+    let axis = 0;
+    for (let index = 1; index < 3; index++)
+        if (Math.abs(value[index]) > Math.abs(value[axis]))
+            axis = index;
+    return axis;
+};
+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) => {
+        const b = points[(index + 1) % 3];
+        return sign * turn(a, b, p) >= -epsilon * Math.hypot(b[0] - a[0], b[1] - a[1]);
+    });
+}
+function onSharedBoundary(point, shared, epsilon) {
+    if (shared.some((vertex) => distance(point, vertex) <= epsilon))
+        return true;
+    if (shared.length !== 2)
+        return false;
+    const a = shared[0], b = shared[1], edge = subtract(b, a), delta = subtract(point, a);
+    const length = Math.hypot(...edge), along = dot(delta, edge) / length;
+    return (along >= -epsilon &&
+        along <= length + epsilon &&
+        Math.hypot(...cross(delta, edge)) / length <= epsilon);
+}
+function coplanarIntersection(first, second, direction, shared, epsilon) {
+    const axis = dominantAxis(direction), clip = second.map((point) => project(point, axis));
+    const sign = Math.sign(turn(clip[0], clip[1], clip[2]));
+    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;
+            if (in0)
+                next.push(start);
+            if (in0 !== in1) {
+                const fraction = Math.max(0, Math.min(1, d0 / (d0 - d1)));
+                next.push([
+                    start[0] + (end[0] - start[0]) * fraction,
+                    start[1] + (end[1] - start[1]) * fraction,
+                    start[2] + (end[2] - start[2]) * fraction,
+                ]);
+            }
+        }
+        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));
+}
+/** @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])));
+    const separated = (values) => values.every((value) => value > epsilon) || values.every((value) => value < -epsilon);
+    if (separated(distances0) || separated(distances1))
+        return false;
+    if (distances0.every((value) => Math.abs(value) <= epsilon) &&
+        distances1.every((value) => Math.abs(value) <= epsilon))
+        return coplanarIntersection(first, second, n0, shared, epsilon);
+    const points = [];
+    const collect = (source, target, values, n) => {
+        for (let index = 0; index < 3; index++) {
+            const a = source[index], b = source[(index + 1) % 3];
+            const d0 = values[index], d1 = values[(index + 1) % 3];
+            if (Math.abs(d0) <= epsilon && inside(a, target, n, epsilon))
+                points.push(a);
+            if ((d0 < 0 && d1 > 0) || (d0 > 0 && d1 < 0)) {
+                const fraction = d0 / (d0 - d1);
+                const point = [
+                    a[0] + (b[0] - a[0]) * fraction,
+                    a[1] + (b[1] - a[1]) * fraction,
+                    a[2] + (b[2] - a[2]) * fraction,
+                ];
+                if (inside(point, target, n, epsilon))
+                    points.push(point);
+            }
+        }
+    };
+    collect(first, second, distances0, n1);
+    collect(second, first, distances1, n0);
+    return points.some((point) => !onSharedBoundary(point, shared, epsilon));
+}
+/** @internal Signed solid angle at a point separated from a closed triangle shell. */
+export function triangleSolidAngle(point, triangle) {
+    const a = subtract(triangle[0], point), b = subtract(triangle[1], point), c = subtract(triangle[2], point);
+    const la = Math.hypot(...a), lb = Math.hypot(...b), lc = Math.hypot(...c);
+    return (2 *
+        Math.atan2(dot(a, cross(b, c)), la * lb * lc + dot(a, b) * lc + dot(b, c) * la + dot(c, a) * lb));
+}

package/dist/geometry/mesh-solid.js

@@ -0,0 +1,284 @@
+import { GeometryError } from "./errors.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;
+/**
+ * Checks closed indexed topology, triangle intersections, and alternating nested shell orientation.
+ * Outward exterior shells and inward cavity shells are accepted. Separate shells must not touch,
+ * intersect, or overlap as material. Indexed neighbours may share their own vertex or edge.
+ *
+ * Uses bounded floating-point tests, not exact predicates or repair. Contacts within the selected
+ * tolerance reject conservatively. At most 200,000 triangles and 2,000,000 spatial/containment tests
+ * are supported; exhausting a ceiling throws COMPLEXITY_LIMIT rather than claiming validity.
+ * 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.
+ * @returns The original mesh after every requested check succeeds.
+ */
+export function validateSolidMesh(mesh, options = {}) {
+    analyzeSolidMesh(mesh, options);
+    return mesh;
+}
+function validationWork(mesh, options) {
+    if (typeof mesh !== "object" ||
+        mesh === null ||
+        !(mesh.positions instanceof Float32Array) ||
+        !(mesh.indices instanceof Uint32Array) ||
+        mesh.positions.length % 3 !== 0 ||
+        mesh.indices.length % 3 !== 0)
+        throw new GeometryError("INVALID_MESH", "Solid validation requires complete Float32 XYZ vertices and Uint32 triangle indices.", { operation: "validateSolidMesh" });
+    if (typeof options !== "object" || options === null || Array.isArray(options))
+        throw new GeometryError("INVALID_ARGUMENT", "Solid validation options must be an object.", {
+            operation: "validateSolidMesh",
+        });
+    const count = mesh.indices.length / 3;
+    const maximumTests = options.maximumTests ?? MAXIMUM_TESTS;
+    if (!Number.isSafeInteger(maximumTests) || maximumTests < 1 || maximumTests > MAXIMUM_TESTS)
+        throw new GeometryError("INVALID_ARGUMENT", "Solid validation maximumTests must be an integer from 1 through 2,000,000.", { operation: "validateSolidMesh" });
+    if (count > MAXIMUM_TRIANGLES)
+        throw new GeometryError("COMPLEXITY_LIMIT", "Solid validation exceeds its triangle ceiling.", {
+            operation: "validateSolidMesh",
+            details: { required: count, allowed: MAXIMUM_TRIANGLES },
+        });
+    if (mesh.positions.length / 3 > mesh.indices.length)
+        throw new GeometryError("INVALID_MESH", "Solid validation requires every position-buffer vertex to be referenced.", { operation: "validateSolidMesh" });
+    return { count, maximumTests };
+}
+/** @internal Fresh measurements precede one adjacency traversal for closure, fans, and shells. */
+export function analyzeSolidMesh(mesh, options = {}) {
+    const work = validationWork(mesh, options);
+    const measurements = analyzeTriangleMesh(mesh, {
+        ...(options.tolerance === undefined ? {} : { tolerance: options.tolerance }),
+    });
+    checkSolidGeometry(mesh, measurements, options, work);
+    return measurements;
+}
+/**
+ * @internal Checks the engine's privately owned snapshot using fresh closed-topology measurements.
+ * Callers must own the exact unchanged buffer ranges and use the same tolerance as their analysis.
+ * Never accepts public cached facts; public validation always analyzes mutable input afresh.
+ */
+export function validateAnalyzedSolidMesh(mesh, measurements, options = {}) {
+    checkSolidGeometry(mesh, measurements, options, validationWork(mesh, options));
+}
+function checkSolidGeometry(mesh, facts, options, { count, maximumTests }) {
+    const epsilon = resolveGeometryTolerance(Math.hypot(...facts.bounds.max.map((value, axis) => value - facts.bounds.min[axis])), options.tolerance).linear;
+    let tests = 0;
+    const spend = () => {
+        if (++tests > maximumTests)
+            throw new GeometryError("COMPLEXITY_LIMIT", "Solid validation exhausted its work ceiling.", {
+                operation: "validateSolidMesh",
+                details: { required: tests, allowed: maximumTests },
+            });
+    };
+    const vertex = (index) => [
+        mesh.positions[index * 3],
+        mesh.positions[index * 3 + 1],
+        mesh.positions[index * 3 + 2],
+    ];
+    const triangle = (index) => [
+        vertex(mesh.indices[index * 3]),
+        vertex(mesh.indices[index * 3 + 1]),
+        vertex(mesh.indices[index * 3 + 2]),
+    ];
+    // Cache only exact double-precision normals. Two reusable contact records avoid retaining
+    // per-triangle point objects or allocating new coordinates for every spatial comparison.
+    const normals = new Float64Array(mesh.indices.length);
+    const contactTriangle = () => ({
+        points: [
+            [0, 0, 0],
+            [0, 0, 0],
+            [0, 0, 0],
+        ],
+        normal: [0, 0, 0],
+    });
+    const left = contactTriangle(), right = contactTriangle();
+    const readContactTriangle = (index, target) => {
+        for (let corner = 0; corner < 3; corner++) {
+            const offset = mesh.indices[index * 3 + corner] * 3;
+            const point = target.points[corner];
+            point[0] = mesh.positions[offset];
+            point[1] = mesh.positions[offset + 1];
+            point[2] = mesh.positions[offset + 2];
+            target.normal[corner] = normals[index * 3 + corner];
+        }
+    };
+    const parents = Uint32Array.from({ length: count }, (_, index) => index);
+    const cornerParents = Uint32Array.from({ length: mesh.indices.length }, (_, index) => index);
+    const find = (links, value) => {
+        let current = value;
+        while (links[current] !== current) {
+            links[current] = links[links[current]];
+            current = links[current];
+        }
+        return current;
+    };
+    const root = (value) => find(parents, value);
+    const cornerOf = (triangle, vertex) => {
+        for (let corner = triangle * 3; corner < triangle * 3 + 3; corner++)
+            if (mesh.indices[corner] === vertex)
+                return corner;
+        throw new GeometryError("INVALID_TOPOLOGY", "Mesh edge incidence is inconsistent.", {
+            operation: "validateSolidMesh",
+        });
+    };
+    const edges = new IndexedMeshEdgeTable(mesh.indices.length, true);
+    const bounds = new Float64Array(count * 6);
+    for (let index = 0; index < count; index++) {
+        const points = triangle(index);
+        const direction = prepareSolidTriangle(points).normal;
+        for (let axis = 0; axis < 3; axis++) {
+            normals[index * 3 + axis] = direction[axis];
+            bounds[index * 6 + axis] = Math.min(points[0][axis], points[1][axis], points[2][axis]);
+            bounds[index * 6 + axis + 3] = Math.max(points[0][axis], points[1][axis], points[2][axis]);
+        }
+        for (let edge = 0; edge < 3; edge++) {
+            const a = mesh.indices[index * 3 + edge], b = mesh.indices[index * 3 + ((edge + 1) % 3)];
+            const previous = edges.touch(a, b, index);
+            if (previous >= 0) {
+                parents[root(index)] = root(previous);
+                for (const vertex of [a, b])
+                    cornerParents[find(cornerParents, cornerOf(index, vertex))] = find(cornerParents, cornerOf(previous, vertex));
+            }
+        }
+    }
+    if (!edges.isClosed())
+        throw new GeometryError("INVALID_MESH", "Closed meshes require exactly two oppositely wound faces at every edge.", { operation: "validateSolidMesh" });
+    const firstCorners = new Uint32Array(mesh.positions.length / 3).fill(0xffff_ffff);
+    for (let corner = 0; corner < mesh.indices.length; corner++) {
+        const vertex = mesh.indices[corner], link = find(cornerParents, corner);
+        if (firstCorners[vertex] === 0xffff_ffff)
+            firstCorners[vertex] = link;
+        else if (firstCorners[vertex] !== link)
+            throw new GeometryError("INVALID_TOPOLOGY", "Solid vertices require one connected closed incident triangle fan.", { operation: "validateSolidMesh", details: { vertex } });
+    }
+    if (firstCorners.includes(0xffff_ffff))
+        throw new GeometryError("INVALID_MESH", "Solid validation requires every position-buffer vertex to be referenced.", { operation: "validateSolidMesh" });
+    const order = Array.from({ length: count }, (_, index) => index);
+    const build = (start, end) => {
+        const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+        for (let index = start; index < end; index++)
+            for (let axis = 0; axis < 3; axis++) {
+                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)
+            return { start, end, min, max };
+        let axis = 0;
+        for (let index = 1; index < 3; index++)
+            if (max[index] - min[index] > max[axis] - min[axis])
+                axis = index;
+        const partition = order
+            .slice(start, end)
+            .sort((a, b) => bounds[a * 6 + axis] +
+            bounds[a * 6 + axis + 3] -
+            (bounds[b * 6 + axis] + bounds[b * 6 + axis + 3]));
+        for (let index = 0; index < partition.length; index++)
+            order[start + index] = partition[index];
+        const middle = start + Math.floor((end - start) / 2);
+        return { start, end, min, max, children: [build(start, middle), build(middle, end)] };
+    };
+    const overlaps = (a, b) => a.min.every((value, axis) => value <= b.max[axis] + epsilon && a.max[axis] + epsilon >= b.min[axis]);
+    const pair = (a, b) => {
+        spend();
+        for (let axis = 0; axis < 3; axis++)
+            if (bounds[a * 6 + axis] > bounds[b * 6 + axis + 3] + epsilon ||
+                bounds[b * 6 + axis] > bounds[a * 6 + axis + 3] + epsilon)
+                return;
+        const shared = [];
+        if (root(a) === root(b))
+            for (let index = 0; index < 3; index++) {
+                const id = mesh.indices[a * 3 + index];
+                if (id === mesh.indices[b * 3] ||
+                    id === mesh.indices[b * 3 + 1] ||
+                    id === mesh.indices[b * 3 + 2])
+                    shared.push(vertex(id));
+            }
+        readContactTriangle(a, left);
+        readContactTriangle(b, right);
+        if (trianglesIntersectBeyondSharedBoundary(left, right, shared, epsilon))
+            throw new GeometryError("SELF_INTERSECTION", "Solid triangles intersect or touch beyond their indexed boundary.", { operation: "validateSolidMesh", details: { triangleA: a, triangleB: b } });
+    };
+    const visit = (a, b) => {
+        spend();
+        if (!overlaps(a, b))
+            return;
+        if (a === b && a.children !== undefined) {
+            visit(a.children[0], a.children[0]);
+            visit(a.children[0], a.children[1]);
+            visit(a.children[1], a.children[1]);
+            return;
+        }
+        if (a.children !== undefined) {
+            visit(a.children[0], b);
+            visit(a.children[1], b);
+            return;
+        }
+        if (b.children !== undefined) {
+            visit(a, b.children[0]);
+            visit(a, b.children[1]);
+            return;
+        }
+        for (let first = a.start; first < a.end; first++)
+            for (let second = b.start; second < b.end; second++)
+                if (a !== b || first < second)
+                    pair(order[first], order[second]);
+    };
+    const tree = build(0, count);
+    visit(tree, tree);
+    const shells = new Map();
+    for (let index = 0; index < count; index++) {
+        const id = root(index), shell = shells.get(id);
+        if (shell === undefined)
+            shells.set(id, [index]);
+        else
+            shell.push(index);
+    }
+    const entries = [...shells.values()].map((triangles) => {
+        const origin = triangle(triangles[0])[0];
+        let volume = 0;
+        const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+        for (const index of triangles) {
+            const [a, b, c] = triangle(index).map((point) => point.map((value, axis) => value - origin[axis]));
+            volume +=
+                (a[0] * (b[1] * c[2] - b[2] * c[1]) +
+                    a[1] * (b[2] * c[0] - b[0] * c[2]) +
+                    a[2] * (b[0] * c[1] - b[1] * c[0])) /
+                    6;
+            for (let axis = 0; axis < 3; axis++) {
+                min[axis] = Math.min(min[axis], bounds[index * 6 + axis]);
+                max[axis] = Math.max(max[axis], bounds[index * 6 + axis + 3]);
+            }
+        }
+        return { triangles, origin, volume, min, max };
+    });
+    for (const shell of entries) {
+        let depth = 0;
+        for (const other of entries) {
+            spend();
+            if (shell === other ||
+                shell.origin.some((value, axis) => value < other.min[axis] || value > other.max[axis]))
+                continue;
+            let angle = 0;
+            for (const index of other.triangles) {
+                spend();
+                angle += triangleSolidAngle(shell.origin, triangle(index));
+            }
+            if (Math.abs(angle) > 2 * Math.PI)
+                depth++;
+        }
+        if ((depth % 2 === 0 ? shell.volume : -shell.volume) <= epsilon ** 3)
+            throw new GeometryError("INVALID_TOPOLOGY", "Solid shells require outward exteriors and inward nested cavity boundaries.", {
+                operation: "validateSolidMesh",
+                details: {
+                    triangle: shell.triangles[0],
+                    nestingDepth: depth,
+                    signedVolume: shell.volume,
+                },
+            });
+    }
+}

package/dist/geometry/sweeps/sweep-closed.js

@@ -7,12 +7,12 @@ import { computeSweepFrames, validateSweepOptions } from "./orientation.js";
 import { planSweepStations, refineSweepStations } from "./stations.js";
 import { assertSweepAllocation, normalizeSweepPath, normalizeSweepProfile, writeSweepVertex, } from "./validation.js";
 /** @internal Checks host allocation policy before frames or manufacturing buffers. */
-export const buildClosedSweepMesh = (profile, path, options = {}, allocationGuard) => {
+export const buildClosedSweepMesh = (profile, path, options = {}) => {
     const operation = "sweep";
     validateSweepOptions(options);
     profile = normalizeSweepProfile(profile, operation, options.limits);
     path = normalizeSweepPath(path, true, operation, options.limits);
-    assertSweepAllocation(path.length, profile.length, true, operation, allocationGuard, options.limits);
+    assertSweepAllocation(path.length, profile.length, true, operation, options.limits);
     let scales = resolveSweepScales(options.scale, path.length);
     const seamProfileOffset = options.seamProfileOffset ?? 0;
     if (!Number.isSafeInteger(seamProfileOffset)) {
@@ -44,13 +44,13 @@ export const buildClosedSweepMesh = (profile, path, options = {}, allocationGuar
     }
     if (twistRadians !== 0) {
         const plan = planSweepStations([profile], path, scales, options);
-        assertSweepAllocation(plan.stationCount, profile.length, true, operation, allocationGuard, options.limits);
+        assertSweepAllocation(plan.stationCount, profile.length, true, operation, options.limits);
     }
     let transportedFrames = computeSweepFrames(path, options);
     let twists;
     if (twistRadians !== 0) {
         const plan = planSweepStations([profile], path, scales, options, transportedFrames);
-        assertSweepAllocation(plan.stationCount, profile.length, true, operation, allocationGuard, options.limits);
+        assertSweepAllocation(plan.stationCount, profile.length, true, operation, options.limits);
         const refined = refineSweepStations(path, scales, transportedFrames, options, plan);
         path = refined.path;
         scales = refined.scales;

package/dist/geometry/sweeps/sweep-mesh.js

@@ -14,17 +14,13 @@ import { buildOpenSweepMesh } from "./sweep-open.js";
  * ```
  */
 export function sweepMesh(profile, path, options = {}) {
-    return buildSweepMesh(profile, path, options);
-}
-/** @internal Applies host ceilings before frames, caps, or manufacturing buffers. */
-export function buildSweepMesh(profile, path, options = {}, allocationGuard) {
     validateSweepOptions(options);
     if (options.closed === true) {
-        return buildClosedSweepMesh(profile, path, options, allocationGuard);
+        return buildClosedSweepMesh(profile, path, options);
     }
     if ((options.seamProfileOffset ?? 0) !== 0)
         throw new GeometryError("INVALID_ARGUMENT", "A seamProfileOffset requires a closed path.", {
             operation: "sweep",
         });
-    return buildOpenSweepMesh(profile, path, options, allocationGuard);
+    return buildOpenSweepMesh(profile, path, options);
 }

package/dist/geometry/sweeps/sweep-open.js

@@ -6,23 +6,23 @@ import { computeSweepFrames, validateSweepOptions } from "./orientation.js";
 import { planSweepStations, refineSweepStations } from "./stations.js";
 import { assertSweepAllocation, normalizeSweepPath, normalizeSweepProfile, writeSweepVertex, } from "./validation.js";
 /** @internal Checks host allocation policy before frames, caps or manufacturing buffers. */
-export const buildOpenSweepMesh = (profile, path, options = {}, allocationGuard) => {
+export const buildOpenSweepMesh = (profile, path, options = {}) => {
     const operation = "sweep";
     validateSweepOptions(options);
     profile = normalizeSweepProfile(profile, operation, options.limits);
     path = normalizeSweepPath(path, false, operation, options.limits);
-    assertSweepAllocation(path.length, profile.length, false, operation, allocationGuard, options.limits);
+    assertSweepAllocation(path.length, profile.length, false, operation, options.limits);
     let scales = resolveSweepScales(options.scale, path.length);
     const twistRadians = ((options.twistDegrees ?? 0) / 180) * Math.PI;
     if (twistRadians !== 0) {
         const plan = planSweepStations([profile], path, scales, options);
-        assertSweepAllocation(plan.stationCount, profile.length, false, operation, allocationGuard, options.limits);
+        assertSweepAllocation(plan.stationCount, profile.length, false, operation, options.limits);
     }
     let frames = computeSweepFrames(path, options);
     let twists;
     if (twistRadians !== 0) {
         const plan = planSweepStations([profile], path, scales, options, frames);
-        assertSweepAllocation(plan.stationCount, profile.length, false, operation, allocationGuard, options.limits);
+        assertSweepAllocation(plan.stationCount, profile.length, false, operation, options.limits);
         const refined = refineSweepStations(path, scales, frames, options, plan);
         path = refined.path;
         scales = refined.scales;

package/dist/geometry/sweeps/validation.js

@@ -87,11 +87,10 @@ export function normalizeSweepPath(path, closed, operation, limits = {}) {
     return Object.freeze(cleaned);
 }
 /** @internal Checks output allocation before creating frames or buffers. */
-export function assertSweepAllocation(pathCount, profileCount, closed, operation, allocationGuard, limits = {}) {
+export function assertSweepAllocation(pathCount, profileCount, closed, operation, limits = {}) {
     const vertexCount = pathCount * profileCount;
     const triangleCount = (closed ? pathCount : pathCount - 1) * profileCount * 2 + (closed ? 0 : (profileCount - 2) * 2);
     assertMeshAllocationWithinLimits(vertexCount, triangleCount, (vertexCount + triangleCount) * 12, operation, resolveModelingLimits(limits));
-    allocationGuard?.(vertexCount, triangleCount, (vertexCount + triangleCount) * 12, operation);
 }
 /** @internal Rejects coordinates that cannot be represented in manufacturing mesh buffers. */
 export function writeSweepVertex(positions, offset, point, operation) {

package/dist/model/operations.js

@@ -3,8 +3,6 @@ function operation(name) {
     const invoke = (...args) => {
         const context = currentModelContext(name);
         const method = context[name];
-        if (typeof method !== "function")
-            throw new Error(`Unknown modeling operation "${name}".`);
         return Reflect.apply(method, undefined, args);
     };
     return invoke;
@@ -23,7 +21,7 @@ export function modelingFunctions(resolution) {
 }
 /** Host-bound box operation. Valid only during a synchronous build. */
 export const box = /* @__PURE__ */ operation("box");
-/** Constructs a closed regularly sampled heightfield during the active synchronous build. */
+/** Constructs a closed rectilinear heightfield during the active synchronous build. */
 export const heightfield = /* @__PURE__ */ operation("heightfield");
 /** Returns an immutable copy with the explicit native millimetre tolerance. */
 export const setTolerance = 
@@ -42,6 +40,11 @@ export const union = /* @__PURE__ */ operation("union");
 export const subtract = /* @__PURE__ */ operation("subtract");
 /** Host-bound intersect operation. Valid only during a synchronous build. */
 export const intersect = /* @__PURE__ */ operation("intersect");
+/** Returns intersection and difference with a same-build cutter, including empty results. */
+export const split = /* @__PURE__ */ operation("split");
+/** Splits a solid into the normal-side and opposite-side halves of a world-space plane. */
+export const splitByPlane = 
+/* @__PURE__ */ operation("splitByPlane");
 /** Host-bound compose operation. Valid only during a synchronous build. */
 export const compose = /* @__PURE__ */ operation("compose");
 /** Host-bound hull operation. Valid only during a synchronous build. */
@@ -98,6 +101,10 @@ export const inspectSection =
 /** Host-bound inspectSolid operation. Valid only during a synchronous build. */
 export const inspectSolid = 
 /* @__PURE__ */ operation("inspectSolid");
+/** Tests a solid or filled section in the active build, including expected empty Boolean results. */
+export const isEmpty = /* @__PURE__ */ operation("isEmpty");
+/** Measures the minimum separation between two nonempty solids in millimetres. */
+export const distance = /* @__PURE__ */ operation("distance");
 /** Host-bound components operation. Valid only during a synchronous build. */
 export const components = /* @__PURE__ */ operation("components");
 /** Host-bound simplify operation. Valid only during a synchronous build. */