@metamesh/modeling 0.0.0-stage → 0.6.0

package/dist/geometry/mesh-quality.js

@@ -0,0 +1,396 @@
+import { GeometryError } from "./errors.js";
+import { resolveGeometryTolerance, } from "./tolerance.js";
+const DEFAULT_MAXIMUM_TRIANGLE_COUNT = 200_000;
+const FLOAT32_EPSILON = 2 ** -23;
+const MINIMUM_PLANAR_ANGULAR_TOLERANCE = 1e-5;
+const edgeKey = (first, second) => first < second ? `${first}:${second}` : `${second}:${first}`;
+const pointAt = (positions, vertex) => [
+    positions[vertex * 3],
+    positions[vertex * 3 + 1],
+    positions[vertex * 3 + 2],
+];
+const subtract = (left, right) => [
+    left[0] - right[0],
+    left[1] - right[1],
+    left[2] - right[2],
+];
+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)
+        maximum = Math.max(maximum, value);
+    return maximum;
+};
+const maximumIterable = (values) => {
+    let maximum = 0;
+    for (const value of values)
+        maximum = Math.max(maximum, value);
+    return maximum;
+};
+const positiveInteger = (value, label) => {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new GeometryError("INVALID_ARGUMENT", `${label} must be a positive safe integer.`);
+    }
+    return value;
+};
+const structurallyValidateMesh = (mesh, maximumTriangleCount) => {
+    if (!(mesh.positions instanceof Float32Array) || !(mesh.indices instanceof Uint32Array)) {
+        throw new GeometryError("INVALID_MESH", "Triangle meshes require Float32Array positions and Uint32Array indices.");
+    }
+    if (mesh.positions.length === 0 || mesh.positions.length % 3 !== 0) {
+        throw new GeometryError("INVALID_MESH", "Mesh positions must contain complete XYZ vertices.");
+    }
+    if (mesh.indices.length === 0 || mesh.indices.length % 3 !== 0) {
+        throw new GeometryError("INVALID_MESH", "Mesh indices must contain complete triangles.");
+    }
+    const triangleCount = mesh.indices.length / 3;
+    if (triangleCount > maximumTriangleCount) {
+        throw new GeometryError("COMPLEXITY_LIMIT", `Mesh quality analysis is limited to ${maximumTriangleCount} triangles.`);
+    }
+    for (let index = 0; index < mesh.positions.length; index += 1) {
+        if (!Number.isFinite(mesh.positions[index])) {
+            throw new GeometryError("NON_FINITE_VALUE", `Mesh position ${index} must be finite.`);
+        }
+    }
+    const vertexCount = mesh.positions.length / 3;
+    for (let index = 0; index < mesh.indices.length; index += 1) {
+        if (mesh.indices[index] >= vertexCount) {
+            throw new GeometryError("INVALID_MESH", `Triangle ${Math.floor(index / 3)} references a missing vertex.`);
+        }
+    }
+};
+const meshBoundsAndExtent = (positions) => {
+    const minimum = [Infinity, Infinity, Infinity];
+    const maximum = [-Infinity, -Infinity, -Infinity];
+    for (let offset = 0; offset < positions.length; offset += 3) {
+        for (let axis = 0; axis < 3; axis += 1) {
+            minimum[axis] = Math.min(minimum[axis], positions[offset + axis]);
+            maximum[axis] = Math.max(maximum[axis], positions[offset + axis]);
+        }
+    }
+    return {
+        bounds: { min: minimum, max: maximum },
+        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 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);
+    return {
+        area,
+        aspectRatio: area === 0 ? Number.POSITIVE_INFINITY : (Math.sqrt(3) * longestEdge ** 2) / (4 * area),
+        doubleArea,
+        index,
+        minimumAngleRadians: Math.min(...angles),
+        normal,
+        planeOffset: normal === undefined ? undefined : dot(normal, first),
+        vertices,
+    };
+};
+const facesAreCoplanar = (reference, candidate, positions, angularTolerance, linearTolerance) => {
+    if (reference.normal === undefined ||
+        reference.planeOffset === undefined ||
+        candidate.normal === undefined ||
+        dot(reference.normal, candidate.normal) < Math.cos(angularTolerance)) {
+        return false;
+    }
+    return candidate.vertices.every((vertex) => Math.abs(dot(reference.normal, pointAt(positions, vertex)) - reference.planeOffset) <=
+        linearTolerance);
+};
+const countBoundaryLoops = (boundaryEdges) => {
+    if (boundaryEdges.length === 0)
+        return 0;
+    const neighbours = new Map();
+    for (const edge of boundaryEdges) {
+        const first = neighbours.get(edge.first) ?? new Set();
+        const second = neighbours.get(edge.second) ?? new Set();
+        first.add(edge.second);
+        second.add(edge.first);
+        neighbours.set(edge.first, first);
+        neighbours.set(edge.second, second);
+    }
+    const visited = new Set();
+    let components = 0;
+    for (const start of neighbours.keys()) {
+        if (visited.has(start))
+            continue;
+        components += 1;
+        const pending = [start];
+        visited.add(start);
+        while (pending.length > 0) {
+            const vertex = pending.pop();
+            for (const neighbour of neighbours.get(vertex) ?? []) {
+                if (visited.has(neighbour))
+                    continue;
+                visited.add(neighbour);
+                pending.push(neighbour);
+            }
+        }
+    }
+    return components;
+};
+const buildPatchAnalysis = (faces, edges, faceIndices, id) => {
+    const faceSet = new Set(faceIndices);
+    const patchEdgeKeys = new Set();
+    const vertices = new Set();
+    const neighbours = new Map();
+    const incidence = new Map();
+    const boundaryEdges = [];
+    let internalEdgeCount = 0;
+    let surfaceArea = 0;
+    let minimumAngleRadians = Number.POSITIVE_INFINITY;
+    let maximumAspectRatio = 0;
+    for (const faceIndex of faceIndices) {
+        const face = faces[faceIndex];
+        surfaceArea += face.area;
+        minimumAngleRadians = Math.min(minimumAngleRadians, face.minimumAngleRadians);
+        maximumAspectRatio = Math.max(maximumAspectRatio, face.aspectRatio);
+        for (const vertex of face.vertices) {
+            vertices.add(vertex);
+            incidence.set(vertex, (incidence.get(vertex) ?? 0) + 1);
+        }
+        for (let localEdge = 0; localEdge < 3; localEdge += 1) {
+            patchEdgeKeys.add(edgeKey(face.vertices[localEdge], face.vertices[(localEdge + 1) % 3]));
+        }
+    }
+    for (const key of patchEdgeKeys) {
+        const edge = edges.get(key);
+        const patchUseCount = edge.uses.reduce((count, use) => count + (faceSet.has(use.face) ? 1 : 0), 0);
+        if (patchUseCount === 1)
+            boundaryEdges.push(edge);
+        else if (patchUseCount === 2)
+            internalEdgeCount += 1;
+        if (patchUseCount > 0) {
+            const first = neighbours.get(edge.first) ?? new Set();
+            const second = neighbours.get(edge.second) ?? new Set();
+            first.add(edge.second);
+            second.add(edge.first);
+            neighbours.set(edge.first, first);
+            neighbours.set(edge.second, second);
+        }
+    }
+    const maximumVertexTriangleIncidence = maximumIterable(incidence.values());
+    const firstFace = faces[faceIndices[0]];
+    return {
+        boundaryEdgeKeys: new Set(boundaryEdges.map(({ key }) => key)),
+        faceIndices,
+        report: {
+            boundaryEdgeCount: boundaryEdges.length,
+            boundaryLoopCount: countBoundaryLoops(boundaryEdges),
+            fanRatio: maximumVertexTriangleIncidence / faceIndices.length,
+            firstTriangleIndex: faceIndices[0],
+            id,
+            internalEdgeCount,
+            maximumTriangleAspectRatio: maximumAspectRatio,
+            maximumVertexTriangleIncidence,
+            maximumVertexValence: maximumIterable((function* () {
+                for (const neighbourSet of neighbours.values())
+                    yield neighbourSet.size;
+            })()),
+            minimumTriangleAngleDegrees: (minimumAngleRadians * 180) / Math.PI,
+            normal: firstFace.normal,
+            planeOffset: firstFace.planeOffset,
+            surfaceArea,
+            triangleCount: faceIndices.length,
+            vertexCount: vertices.size,
+        },
+    };
+};
+/** @internal */
+export function buildTriangleMeshQualityAnalysis(mesh, options = {}) {
+    const maximumTriangleCount = positiveInteger(options.maximumTriangleCount ?? DEFAULT_MAXIMUM_TRIANGLE_COUNT, "Maximum analyzed triangle count");
+    structurallyValidateMesh(mesh, maximumTriangleCount);
+    const { bounds, extent } = meshBoundsAndExtent(mesh.positions);
+    const tolerance = resolveGeometryTolerance(extent, options.tolerance);
+    const planarLinearTolerance = Math.max(tolerance.linear, Math.max(extent, 1) * FLOAT32_EPSILON * 8);
+    const planarAngularTolerance = Math.max(tolerance.angular, MINIMUM_PLANAR_ANGULAR_TOLERANCE);
+    const vertexCount = mesh.positions.length / 3;
+    const triangleCount = mesh.indices.length / 3;
+    const neighbourSets = Array.from({ length: vertexCount }, () => new Set());
+    const vertexTriangleIncidence = new Uint32Array(vertexCount);
+    const mutableEdges = new Map();
+    const faces = [];
+    const duplicateFaces = new Map();
+    let surfaceArea = 0;
+    let signedVolume = 0;
+    let nearZeroAreaTriangleCount = 0;
+    let minimumTriangleAngleRadians = Number.POSITIVE_INFINITY;
+    let maximumTriangleAspectRatio = 0;
+    for (let offset = 0; offset < mesh.indices.length; offset += 3) {
+        const vertices = [
+            mesh.indices[offset],
+            mesh.indices[offset + 1],
+            mesh.indices[offset + 2],
+        ];
+        const face = faceAnalysis(mesh.positions, vertices, offset / 3);
+        faces.push(face);
+        surfaceArea += face.area;
+        minimumTriangleAngleRadians = Math.min(minimumTriangleAngleRadians, face.minimumAngleRadians);
+        maximumTriangleAspectRatio = Math.max(maximumTriangleAspectRatio, face.aspectRatio);
+        if (new Set(vertices).size !== 3 ||
+            face.doubleArea <= tolerance.area ||
+            face.normal === undefined) {
+            nearZeroAreaTriangleCount += 1;
+        }
+        const first = pointAt(mesh.positions, vertices[0]);
+        const second = pointAt(mesh.positions, vertices[1]);
+        const third = pointAt(mesh.positions, vertices[2]);
+        signedVolume +=
+            (first[0] * (second[1] * third[2] - second[2] * third[1]) +
+                first[1] * (second[2] * third[0] - second[0] * third[2]) +
+                first[2] * (second[0] * third[1] - second[1] * third[0])) /
+                6;
+        const duplicateKey = [...vertices].sort((left, right) => left - right).join(":");
+        duplicateFaces.set(duplicateKey, (duplicateFaces.get(duplicateKey) ?? 0) + 1);
+        for (const vertex of vertices)
+            vertexTriangleIncidence[vertex] += 1;
+        for (let localEdge = 0; localEdge < 3; localEdge += 1) {
+            const start = vertices[localEdge];
+            const end = vertices[(localEdge + 1) % 3];
+            neighbourSets[start].add(end);
+            neighbourSets[end].add(start);
+            const key = edgeKey(start, end);
+            const edge = mutableEdges.get(key) ??
+                {
+                    first: Math.min(start, end),
+                    key,
+                    second: Math.max(start, end),
+                    uses: [],
+                };
+            edge.uses.push({ end, face: offset / 3, start });
+            mutableEdges.set(key, edge);
+        }
+    }
+    const edges = new Map(mutableEdges);
+    const adjacency = Array.from({ length: triangleCount }, () => []);
+    for (const edge of edges.values()) {
+        if (edge.uses.length !== 2)
+            continue;
+        const first = edge.uses[0].face;
+        const second = edge.uses[1].face;
+        if (facesAreCoplanar(faces[first], faces[second], mesh.positions, planarAngularTolerance, planarLinearTolerance)) {
+            adjacency[first].push(second);
+            adjacency[second].push(first);
+        }
+    }
+    const patchByFace = new Int32Array(triangleCount).fill(-1);
+    const patches = [];
+    for (let seed = 0; seed < triangleCount; seed += 1) {
+        if (patchByFace[seed] !== -1 || faces[seed].normal === undefined)
+            continue;
+        const id = patches.length;
+        const pending = [seed];
+        const faceIndices = [];
+        patchByFace[seed] = id;
+        while (pending.length > 0) {
+            const faceIndex = pending.pop();
+            faceIndices.push(faceIndex);
+            for (const candidate of adjacency[faceIndex]) {
+                if (patchByFace[candidate] !== -1)
+                    continue;
+                if (!facesAreCoplanar(faces[seed], faces[candidate], mesh.positions, planarAngularTolerance, planarLinearTolerance)) {
+                    continue;
+                }
+                patchByFace[candidate] = id;
+                pending.push(candidate);
+            }
+        }
+        faceIndices.sort((left, right) => left - right);
+        patches.push(buildPatchAnalysis(faces, edges, faceIndices, id));
+    }
+    const duplicateTriangleCount = [...duplicateFaces.values()].reduce((count, occurrences) => count + Math.max(0, occurrences - 1), 0);
+    const openEdgeCount = [...edges.values()].filter(({ uses }) => uses.length === 1).length;
+    const nonManifoldEdgeCount = [...edges.values()].filter(({ uses }) => uses.length > 2).length;
+    const inconsistentWindingEdgeCount = [...edges.values()].filter(({ uses }) => {
+        if (uses.length !== 2)
+            return false;
+        return (uses[0].start < uses[0].end ? 1 : -1) === (uses[1].start < uses[1].end ? 1 : -1);
+    }).length;
+    const vertexValence = Uint32Array.from(neighbourSets, ({ size }) => size);
+    const report = {
+        duplicateTriangleCount,
+        inconsistentWindingEdgeCount,
+        isClosedOrientedManifold: nearZeroAreaTriangleCount === 0 &&
+            duplicateTriangleCount === 0 &&
+            openEdgeCount === 0 &&
+            nonManifoldEdgeCount === 0 &&
+            inconsistentWindingEdgeCount === 0,
+        maximumTriangleAspectRatio,
+        maximumVertexTriangleIncidence: maximumUint32(vertexTriangleIncidence),
+        maximumVertexValence: maximumUint32(vertexValence),
+        minimumTriangleAngleDegrees: (minimumTriangleAngleRadians * 180) / Math.PI,
+        nearZeroAreaTriangleCount,
+        nonManifoldEdgeCount,
+        openEdgeCount,
+        planarPatches: patches.map(({ report }) => report),
+        signedVolume,
+        surfaceArea,
+        triangleCount,
+        vertexCount,
+    };
+    return {
+        bounds,
+        edges,
+        extent,
+        faces,
+        patches,
+        patchByFace,
+        planarAngularTolerance,
+        planarLinearTolerance,
+        report,
+        tolerance,
+        vertexTriangleIncidence,
+        vertexValence,
+    };
+}
+/**
+ * Measures triangle shape, edge topology, vertex concentration, and connected planar patches.
+ *
+ * Positions are never welded: valence and manifold status describe the supplied indexed topology.
+ * 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 options - Scale-aware tolerance and analysis budget.
+ * @returns A deterministic report without mutating or copying the mesh.
+ */
+export function analyzeTriangleMeshQuality(mesh, options = {}) {
+    return buildTriangleMeshQualityAnalysis(mesh, options).report;
+}

package/dist/geometry/mesh-signature.js

@@ -0,0 +1,137 @@
+import { GeometryError } from "./errors.js";
+import { analyzeTriangleMesh, validateTriangleMesh, } from "./mesh.js";
+const DEFAULT_POSITION_TOLERANCE = 1e-5;
+const DEFAULT_VOLUME_TOLERANCE = 1e-4;
+const DEFAULT_MAXIMUM_TRIANGLE_COUNT = 200_000;
+const validatePositiveTolerance = (value, name) => {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new GeometryError("INVALID_TOLERANCE", `${name} must be finite and greater than zero.`, {
+            operation: "createTriangleMeshSignature",
+            details: { [name]: value },
+        });
+    }
+    return value;
+};
+const quantizedInteger = (value, tolerance, name) => {
+    const scaled = value / tolerance;
+    const quantized = scaled < 0 ? -Math.round(-scaled) : Math.round(scaled);
+    if (!Number.isSafeInteger(quantized)) {
+        throw new GeometryError("INVALID_TOLERANCE", `${name} cannot be represented safely at the requested signature tolerance.`, {
+            operation: "createTriangleMeshSignature",
+            details: { tolerance, value },
+        });
+    }
+    return Object.is(quantized, -0) ? 0 : quantized;
+};
+const quantizedScalar = (value, tolerance, name) => {
+    const rounded = quantizedInteger(value, tolerance, name) * tolerance;
+    if (rounded === 0)
+        return 0;
+    return Number(rounded.toPrecision(15));
+};
+const coordinateKey = (positions, vertex, tolerance) => {
+    const offset = vertex * 3;
+    return `${quantizedInteger(positions[offset], tolerance, "Mesh coordinate")},${quantizedInteger(positions[offset + 1], tolerance, "Mesh coordinate")},${quantizedInteger(positions[offset + 2], tolerance, "Mesh coordinate")}`;
+};
+const canonicalOrientedTriangleKey = (a, b, c) => {
+    const rotations = [`${a}|${b}|${c}`, `${b}|${c}|${a}`, `${c}|${a}|${b}`];
+    rotations.sort();
+    return rotations[0];
+};
+const hashCanonicalKeys = (header, groups) => {
+    let first = 0x811c9dc5;
+    let second = 0x9e3779b9;
+    const update = (value) => {
+        for (let index = 0; index < value.length; index += 1) {
+            const code = value.charCodeAt(index);
+            first = Math.imul(first ^ code, 0x01000193) >>> 0;
+            second = Math.imul(second ^ code, 0x01000193) >>> 0;
+        }
+        first = Math.imul(first ^ 10, 0x01000193) >>> 0;
+        second = Math.imul(second ^ 10, 0x01000193) >>> 0;
+    };
+    update(header);
+    groups.forEach((keys, groupIndex) => {
+        update(`[${groupIndex}]`);
+        for (const key of keys)
+            update(key);
+    });
+    return `fnv1a32x2:${first.toString(16).padStart(8, "0")}${second.toString(16).padStart(8, "0")}`;
+};
+/**
+ * Creates an order-independent regression signature for a manufacturing mesh.
+ *
+ * The input must be non-empty, closed, consistently wound, and have no unreferenced vertices.
+ * Vertex and triangle order do not affect the fingerprint; winding, quantized geometry, and
+ * connectivity metrics do. The fingerprint is a regression aid, not a cryptographic digest.
+ *
+ * @param mesh - Closed oriented mesh to measure without mutation.
+ * @param options - Absolute quantization and complexity limits.
+ * @returns Compact counts, bounds, volume, topology, tolerances, and canonical fingerprint.
+ * @throws {@link GeometryError} When validation, topology, tolerance, or complexity checks fail.
+ */
+export function createTriangleMeshSignature(mesh, options = {}) {
+    const maximumTriangleCount = options.maximumTriangleCount ?? DEFAULT_MAXIMUM_TRIANGLE_COUNT;
+    if (!Number.isSafeInteger(maximumTriangleCount) || maximumTriangleCount <= 0) {
+        throw new GeometryError("INVALID_ARGUMENT", "maximumTriangleCount must be a positive safe integer.", {
+            operation: "createTriangleMeshSignature",
+            details: { maximumTriangleCount },
+        });
+    }
+    if (!(mesh.positions instanceof Float32Array) || !(mesh.indices instanceof Uint32Array)) {
+        validateTriangleMesh(mesh, { requireClosed: true });
+    }
+    const triangleCount = mesh.indices.length / 3;
+    if (triangleCount > maximumTriangleCount) {
+        throw new GeometryError("COMPLEXITY_LIMIT", `Mesh signature analysis is limited to ${maximumTriangleCount} triangles; received ${triangleCount}.`, {
+            operation: "createTriangleMeshSignature",
+            details: { maximumTriangleCount, triangleCount },
+        });
+    }
+    const positionTolerance = validatePositiveTolerance(options.positionTolerance ?? DEFAULT_POSITION_TOLERANCE, "positionTolerance");
+    const volumeTolerance = validatePositiveTolerance(options.volumeTolerance ?? DEFAULT_VOLUME_TOLERANCE, "volumeTolerance");
+    const measured = analyzeTriangleMesh(mesh, { requireClosed: true, includeTopology: true });
+    const connectedComponentCount = measured.connectedComponentCount;
+    const edgeCount = measured.edgeCount;
+    const eulerCharacteristic = measured.vertexCount - edgeCount + measured.triangleCount;
+    const twiceGenus = connectedComponentCount * 2 - eulerCharacteristic;
+    if (twiceGenus < 0 || twiceGenus % 2 !== 0) {
+        throw new GeometryError("INVALID_TOPOLOGY", "Closed mesh topology does not describe orientable vertex-manifold components.", {
+            operation: "createTriangleMeshSignature",
+            details: { connectedComponentCount, edgeCount, eulerCharacteristic },
+        });
+    }
+    const coordinateKeys = Array.from({ length: measured.vertexCount }, (_, vertex) => coordinateKey(mesh.positions, vertex, positionTolerance));
+    const vertexKeys = [...coordinateKeys].sort();
+    const triangleKeys = [];
+    for (let offset = 0; offset < mesh.indices.length; offset += 3) {
+        triangleKeys.push(canonicalOrientedTriangleKey(coordinateKeys[mesh.indices[offset]], coordinateKeys[mesh.indices[offset + 1]], coordinateKeys[mesh.indices[offset + 2]]));
+    }
+    triangleKeys.sort();
+    const quantizeBounds = ({ min, max }) => Object.freeze({
+        min: Object.freeze([
+            quantizedScalar(min[0], positionTolerance, "Mesh bound"),
+            quantizedScalar(min[1], positionTolerance, "Mesh bound"),
+            quantizedScalar(min[2], positionTolerance, "Mesh bound"),
+        ]),
+        max: Object.freeze([
+            quantizedScalar(max[0], positionTolerance, "Mesh bound"),
+            quantizedScalar(max[1], positionTolerance, "Mesh bound"),
+            quantizedScalar(max[2], positionTolerance, "Mesh bound"),
+        ]),
+    });
+    const tolerances = Object.freeze({
+        position: positionTolerance,
+        signedVolume: volumeTolerance,
+    });
+    return Object.freeze({
+        bounds: quantizeBounds(measured.bounds),
+        connectedComponentCount,
+        fingerprint: hashCanonicalKeys(`${measured.vertexCount}|${measured.triangleCount}|${positionTolerance}`, [vertexKeys, triangleKeys]),
+        genus: twiceGenus / 2,
+        signedVolume: quantizedScalar(measured.signedVolume, volumeTolerance, "Signed volume"),
+        tolerances,
+        triangleCount: measured.triangleCount,
+        vertexCount: measured.vertexCount,
+    });
+}