@metamesh/modeling 0.17.0 → 0.19.0

package/dist/engine/{session-snapshot.js → session/snapshot-cache.js}

@@ -1,26 +1,22 @@
-import { GeometryError } from "../geometry/errors.js";
-import { vector3Data } from "../geometry/math/vector-value.js";
-import { isImmutableBuffer } from "../model/immutable-buffer.js";
-import { createGeometryFinalizer, rememberSnapshotPart, } from "./finalization.js";
-import { createModelSummary } from "./model-summary.js";
-import { placeFinalizedGeometry } from "./placement.js";
+import { GeometryError } from "../../geometry/errors.js";
+import { isImmutableBuffer, ownImmutableBuffer } from "../../geometry/immutable-buffer.js";
+import { transform3 } from "../../geometry/transform-value.js";
+import { validateRigidTransform3 } from "../../geometry/transform3.js";
+import { createGeometryFinalizer } from "../finalization.js";
+import { requireModelPart } from "../model-parts.js";
+import { createModelSummary } from "../model-summary.js";
+import { placeFinalizedGeometry } from "../placement.js";
 let nextSession = 0;
 function invalid(message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "generate" });
 }
-const vector = (value) => {
-    const result = value === undefined ? [0, 0, 0] : vector3Data(value);
-    if (!result.every(Number.isFinite))
-        invalid("Part placement requires three finite coordinates.");
-    return Object.freeze([...result]);
-};
 /** Only fixed buffer fields can establish immutable mesh identity across revisions. */
 function isImmutableMesh(value) {
     return (Object.isFrozen(value) &&
         isImmutableBuffer(Object.getOwnPropertyDescriptor(value, "positions")?.value) &&
         isImmutableBuffer(Object.getOwnPropertyDescriptor(value, "indices")?.value));
 }
-/** Publishes copied views while retaining the authoritative local buffers privately. */
+/** Publishes immutable views over already-owned local buffers. */
 function createResource(id, geometry, reusable) {
     return {
         geometry,
@@ -29,66 +25,44 @@ function createResource(id, geometry, reusable) {
             id,
             revision: 1,
             measurements: geometry.measurements,
-            get positions() {
-                return new Float32Array(geometry.positions);
-            },
-            get indices() {
-                return new Uint32Array(geometry.indices);
-            },
+            positions: ownImmutableBuffer(geometry.positions),
+            indices: ownImmutableBuffer(geometry.indices),
         }),
     };
 }
 /** Captures authoritative placement and appearance before consulting world-geometry reuse. */
 function capturePlacement(descriptor) {
-    const position = vector(typeof descriptor.position === "function" ? descriptor.position() : descriptor.position);
-    const rotation = vector(typeof descriptor.rotation === "function" ? descriptor.rotation() : descriptor.rotation);
+    const transform = validateRigidTransform3(transform3(descriptor.transform).toData());
     const color = descriptor.color;
     if (color !== undefined && (typeof color !== "string" || !/^#[\da-f]{6}$/i.test(color)))
         invalid("Part colors must be six-digit hex strings.");
-    return { position, rotation, ...(color === undefined ? {} : { color: color.toLowerCase() }) };
+    return { transform, ...(color === undefined ? {} : { color: color.toLowerCase() }) };
 }
-/** Snapshot accessors own their copies; export can still use the trusted private world buffers. */
+/** Captures stable immutable world geometry without duplicating owned buffers. */
 function capturePart(id, geometry, placement, worldGeometry) {
     const part = Object.freeze({
         id,
         geometry,
         ...placement,
         measurements: worldGeometry.measurements,
-        get positions() {
-            return new Float32Array(worldGeometry.positions);
-        },
-        get indices() {
-            return new Uint32Array(worldGeometry.indices);
-        },
+        positions: ownImmutableBuffer(worldGeometry.positions),
+        indices: ownImmutableBuffer(worldGeometry.indices),
     });
-    rememberSnapshotPart(part, worldGeometry);
     return part;
 }
-/** Isolates a snapshot's lifetime from the cache transaction that produced it. */
-function createSnapshot(parts, { bounds, stats }, diagnostics, dependencies, generationStartedAt) {
-    const completedStats = Object.freeze({
-        ...stats,
-        generationMs: performance.now() - generationStartedAt,
-    });
-    let ownedParts = Object.freeze(parts);
-    const requireParts = () => ownedParts ?? invalid("This model snapshot has been disposed.");
+/** Publishes finalized data independently of the cache transaction that produced it. */
+function createResult(parts, { bounds, stats }, diagnostics, dependencies, generationStartedAt) {
+    const capturedParts = Object.freeze(parts);
     return Object.freeze({
-        get parts() {
-            return requireParts();
-        },
-        get bounds() {
-            requireParts();
-            return bounds;
-        },
-        get stats() {
-            requireParts();
-            return completedStats;
-        },
+        parts: capturedParts,
+        part: (id) => requireModelPart(capturedParts, id),
+        bounds,
+        stats: Object.freeze({
+            ...stats,
+            generateMs: performance.now() - generationStartedAt,
+        }),
         diagnostics: Object.freeze([...diagnostics]),
         dependencies,
-        dispose() {
-            ownedParts = undefined;
-        },
     });
 }
 /**
@@ -109,7 +83,7 @@ export function createSnapshotCache(options, limits) {
             const summary = createModelSummary(limits);
             let finalizeGeometry;
             for (const descriptor of output) {
-                const geometry = typeof descriptor.geometry === "function" ? descriptor.geometry() : descriptor.geometry;
+                const geometry = descriptor.geometry;
                 if (typeof geometry !== "object" || geometry === null)
                     invalid("Parts require Solid recipes or indexed manufacturing meshes.");
                 let resource = options.cache === false ? undefined : resourceCache.get(geometry);
@@ -123,14 +97,10 @@ export function createSnapshotCache(options, limits) {
                 nextResources.set(geometry, resource);
                 const placement = capturePlacement(descriptor);
                 // World buffers belong to geometry and placement, independently of semantic part identity.
-                const placementKey = JSON.stringify([
-                    resource.public.id,
-                    placement.position,
-                    placement.rotation,
-                ]);
+                const placementKey = JSON.stringify([resource.public.id, placement.transform]);
                 const placed = nextPlaced.get(placementKey) ??
                     placedCache.get(placementKey) ??
-                    placeFinalizedGeometry(resource.geometry, placement.position, placement.rotation, options.meshValidation);
+                    placeFinalizedGeometry(resource.geometry, placement.transform, options.meshValidation);
                 nextPlaced.set(placementKey, placed);
                 summary.add(placed);
                 worldParts.push(capturePart(descriptor.id, resource.public, placement, placed));
@@ -141,7 +111,7 @@ export function createSnapshotCache(options, limits) {
             return {
                 // Publish only after retention, native cleanup and cache commit have succeeded.
                 get snapshot() {
-                    return (snapshot ??= createSnapshot(worldParts, model, diagnostics, dependencies, generationStartedAt));
+                    return (snapshot ??= createResult(worldParts, model, diagnostics, dependencies, generationStartedAt));
                 },
                 retainedValues: [
                     ...nextResources.keys(),

package/dist/export/3mf.js

@@ -0,0 +1,190 @@
+import { Zip, ZipDeflate } from "fflate";
+import { GeometryError } from "../geometry/errors.js";
+import { MeshViewCache } from "../geometry/mesh/mesh-view-cache.js";
+import { captureExport } from "./capture.js";
+import { collectExport, createExportWriter } from "./writer.js";
+const coreNamespace = "http://schemas.microsoft.com/3dmanufacturing/core/2015/02";
+const materialNamespace = "http://schemas.microsoft.com/3dmanufacturing/material/2015/02";
+const encoder = new TextEncoder();
+const xmlDeclaration = '<?xml version="1.0" encoding="UTF-8"?>';
+const escapeXml = (text) => text.replace(/[&<>"']/g, (value) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&apos;" })[value]);
+// Core 3MF prohibits property bindings on component wrappers. Different appearances or material
+// bindings therefore need separate mesh objects; equal bindings retain geometry reuse.
+function plan(captured) {
+    const colors = [];
+    const colorIndices = new Map();
+    const combinations = [];
+    const combinationIndices = new Map();
+    const materialIndices = new Map(captured.materials.map((material, index) => [material.id, index]));
+    const meshes = [];
+    const references = [];
+    const byGeometry = new MeshViewCache();
+    for (const part of captured.parts) {
+        const key = `${part.materialId ?? ""}:${part.color ?? ""}`;
+        let property;
+        if (part.color !== undefined) {
+            let color = colorIndices.get(part.color);
+            if (color === undefined) {
+                color = colors.length;
+                colors.push(part.color);
+                colorIndices.set(part.color, color);
+            }
+            property = { group: 2, index: color };
+            if (part.materialId !== undefined) {
+                let combination = combinationIndices.get(key);
+                if (combination === undefined) {
+                    combination = combinations.length;
+                    combinations.push({ material: materialIndices.get(part.materialId), color });
+                    combinationIndices.set(key, combination);
+                }
+                property = { group: 3, index: combination };
+            }
+        }
+        let variants = byGeometry.get(part.geometry);
+        if (variants === undefined) {
+            variants = new Map();
+            byGeometry.set(part.geometry, variants);
+        }
+        let reference = variants.get(key);
+        if (reference === undefined) {
+            reference = meshes.length + 4;
+            meshes.push({ id: reference, part, ...(property === undefined ? {} : { property }) });
+            variants.set(key, reference);
+        }
+        references.push(reference);
+    }
+    return { meshes, references, colors, combinations };
+}
+function placement(transform) {
+    // 3MF's twelve values use a row-vector 4x3 layout; our matrices multiply column vectors.
+    return [0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11].map((index) => transform[index]).join(" ");
+}
+function* modelXml(captured) {
+    const { meshes, references, colors, combinations } = plan(captured);
+    const extension = colors.length === 0 ? "" : ` xmlns:m="${materialNamespace}" requiredextensions="m"`;
+    let xml = `${xmlDeclaration}<model unit="millimeter" xml:lang="en-US" xmlns="${coreNamespace}"${extension}><metadata name="Application">MetaMesh Modeling</metadata><metadata name="Title">${escapeXml(captured.name)}</metadata><resources>`;
+    if (captured.materials.length > 0) {
+        xml += '<basematerials id="1">';
+        for (const material of captured.materials)
+            xml += `<base name="${escapeXml(material.id)}" displaycolor="${material.color.toUpperCase()}FF"/>`;
+        xml += "</basematerials>";
+    }
+    if (colors.length > 0) {
+        xml += '<m:colorgroup id="2">';
+        for (const color of colors)
+            xml += `<m:color color="${color.toUpperCase()}FF"/>`;
+        xml += "</m:colorgroup>";
+    }
+    if (combinations.length > 0) {
+        xml += '<m:multiproperties id="3" pids="1 2">';
+        for (const combination of combinations)
+            xml += `<m:multi pindices="${combination.material} ${combination.color}"/>`;
+        xml += "</m:multiproperties>";
+    }
+    for (const resource of meshes) {
+        const { geometry } = resource.part;
+        const property = resource.property === undefined
+            ? ""
+            : ` pid="${resource.property.group}" pindex="${resource.property.index}"`;
+        xml += `<object id="${resource.id}" type="model"${property}><mesh><vertices>`;
+        for (let index = 0; index < geometry.positions.length; index += 3) {
+            xml += `<vertex x="${geometry.positions[index]}" y="${geometry.positions[index + 1]}" z="${geometry.positions[index + 2]}"/>`;
+            if (xml.length >= 32_768) {
+                yield encoder.encode(xml);
+                xml = "";
+            }
+        }
+        xml += "</vertices><triangles>";
+        for (let index = 0; index < geometry.indices.length; index += 3) {
+            xml += `<triangle v1="${geometry.indices[index]}" v2="${geometry.indices[index + 1]}" v3="${geometry.indices[index + 2]}"/>`;
+            if (xml.length >= 32_768) {
+                yield encoder.encode(xml);
+                xml = "";
+            }
+        }
+        xml += "</triangles></mesh></object>";
+    }
+    const firstPartId = meshes.length + 4;
+    for (let index = 0; index < captured.parts.length; index++) {
+        const part = captured.parts[index];
+        xml += `<object id="${firstPartId + index}" name="${escapeXml(part.id)}" partnumber="${escapeXml(part.id)}" type="model"><components><component objectid="${references[index]}"/></components></object>`;
+        if (xml.length >= 32_768) {
+            yield encoder.encode(xml);
+            xml = "";
+        }
+    }
+    xml += "</resources><build>";
+    for (let index = 0; index < captured.parts.length; index++) {
+        xml += `<item objectid="${firstPartId + index}" transform="${placement(captured.parts[index].transform)}"/>`;
+        if (xml.length >= 32_768) {
+            yield encoder.encode(xml);
+            xml = "";
+        }
+    }
+    xml += "</build></model>";
+    yield encoder.encode(xml);
+}
+/**
+ * Writes 3MF with local mesh reuse, semantic parts, rigid placement, and standard color groups.
+ * Colored output requires the Materials extension. Explicit material IDs remain distinct base-material
+ * names, combined with appearance through multiproperties; display colors never select filament.
+ * Captures mutable inputs before awaiting and awaits each owned output chunk for backpressure.
+ * The host owns destination closing and cleanup of partial output after rejection.
+ */
+export async function write3mf(parts, sink, options = {}) {
+    const captured = captureExport(parts, options, "3mf");
+    const writer = createExportWriter(captured, sink, "3mf");
+    let pending = [];
+    let zippedBytes = 0, complete = false;
+    const zip = new Zip((error, data, final) => {
+        if (error !== null)
+            throw error;
+        zippedBytes += data.byteLength;
+        if (zippedBytes >= 0xffffffff)
+            throw new GeometryError("COMPLEXITY_LIMIT", "3MF ZIP output exceeds its 32-bit container limit.");
+        pending.push(data);
+        complete = final;
+    });
+    const drain = async () => {
+        const chunks = pending;
+        pending = [];
+        for (const chunk of chunks)
+            await writer.write(chunk);
+    };
+    const add = (path) => {
+        const file = new ZipDeflate(path, { level: 6 });
+        file.mtime = new Date(1980, 0, 1);
+        zip.add(file);
+        return file;
+    };
+    try {
+        add("[Content_Types].xml").push(encoder.encode(`${xmlDeclaration}<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="model" ContentType="application/vnd.ms-package.3dmanufacturing-3dmodel+xml"/></Types>`), true);
+        await drain();
+        add("_rels/.rels").push(encoder.encode(`${xmlDeclaration}<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Target="/3D/3dmodel.model" Id="model" Type="http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel"/></Relationships>`), true);
+        await drain();
+        const model = add("3D/3dmodel.model");
+        let xmlBytes = 0;
+        for (const chunk of modelXml(captured)) {
+            captured.signal?.throwIfAborted();
+            xmlBytes += chunk.byteLength;
+            if (xmlBytes >= 0xffffffff)
+                throw new GeometryError("COMPLEXITY_LIMIT", "3MF model XML exceeds its 32-bit ZIP entry limit.");
+            model.push(chunk, false);
+            await drain();
+        }
+        model.push(new Uint8Array(), true);
+        await drain();
+        zip.end();
+        await drain();
+        if (!complete)
+            throw new Error("The 3MF compressor did not complete.");
+        return writer.report();
+    }
+    finally {
+        zip.terminate();
+    }
+}
+/** Serializes selected completed meshes as an owned 3MF file without initializing an engine. */
+export async function export3mf(parts, options = {}) {
+    return collectExport((sink) => write3mf(parts, sink, options));
+}

package/dist/export/capture.js

@@ -0,0 +1,178 @@
+import { GeometryError } from "../geometry/errors.js";
+import { immutableBufferView, isImmutableBuffer } from "../geometry/immutable-buffer.js";
+import { analyzeSolidMesh } from "../geometry/mesh/mesh-solid.js";
+import { MeshViewCache } from "../geometry/mesh/mesh-view-cache.js";
+import { analyzeTriangleMesh, transformTriangleMesh, } from "../geometry/mesh/mesh.js";
+import { IDENTITY_TRANSFORM3, validateRigidTransform3 } from "../geometry/transform3.js";
+import { resolveExportLimits } from "./limits.js";
+// Array.isArray's any[] predicate must not erase the already typed public contracts below.
+const isArray = Array.isArray;
+function identifier(id) {
+    if (typeof id !== "string" || id.length > 64 || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id))
+        throw new GeometryError("INVALID_ARGUMENT", "Export IDs must be canonical identifiers of at most 64 characters.");
+}
+function colorValue(color) {
+    if (typeof color !== "string" || !/^#[\da-f]{6}$/i.test(color))
+        throw new GeometryError("INVALID_ARGUMENT", "Export colors must be six-digit hex strings.");
+    return color.toLowerCase();
+}
+/** Captures all caller-owned data before the first await. Immutable library buffers remain shared. */
+export function captureExport(parts, options, format) {
+    if (typeof options !== "object" || options === null || isArray(options))
+        throw new GeometryError("INVALID_ARGUMENT", "Export options must be an object.");
+    const limits = resolveExportLimits(options.limits);
+    const signal = options.signal;
+    signal?.throwIfAborted();
+    const name = options.name ?? "MetaMesh model";
+    if (typeof name !== "string" ||
+        name.length === 0 ||
+        name.length > 1024 ||
+        // eslint-disable-next-line no-control-regex -- XML 1.0 characters also make consistent cross-format names.
+        /[\u0000-\u0008\u000b\u000c\u000e-\u001f\ud800-\udfff\ufffe\uffff]/u.test(name))
+        throw new GeometryError("INVALID_ARGUMENT", "Export names require one through 1024 valid XML characters.");
+    const meshValidation = options.meshValidation ?? "topology";
+    if (meshValidation !== "topology" && meshValidation !== "solid")
+        throw new GeometryError("INVALID_ARGUMENT", "Unsupported mesh validation mode.");
+    if (!isArray(parts) || parts.length === 0 || parts.length > limits.maxParts)
+        throw new GeometryError("COMPLEXITY_LIMIT", `Export requires one through ${limits.maxParts} parts.`);
+    const definitions = options.materials ?? [];
+    if (!isArray(definitions) || definitions.length > limits.maxParts)
+        throw new GeometryError("COMPLEXITY_LIMIT", "Export materials exceed the part ceiling.");
+    const materials = [];
+    const byMaterial = new Map();
+    for (const definition of definitions) {
+        if (typeof definition !== "object" || definition === null)
+            throw new GeometryError("INVALID_ARGUMENT", "Export materials must declare an ID and display color.");
+        const id = definition.id;
+        identifier(id);
+        if (byMaterial.has(id))
+            throw new GeometryError("INVALID_ARGUMENT", "Export material IDs must be unique.");
+        const material = Object.freeze({ id, color: colorValue(definition.color) });
+        materials.push(material);
+        byMaterial.set(id, material);
+    }
+    const ids = new Set();
+    const viewKeys = new Map();
+    let vertices = 0, triangles = 0, bytes = 0;
+    function captureArray(source, immutable) {
+        if (!(source.buffer instanceof ArrayBuffer))
+            throw new GeometryError("INVALID_MESH", "Export requires transferable numeric buffers.");
+        const key = `${source instanceof Float32Array ? "f" : "u"}:${source.byteOffset}:${source.length}`;
+        let ranges = viewKeys.get(source.buffer);
+        const previous = ranges?.get(key);
+        if (previous !== undefined)
+            return previous;
+        bytes += source.byteLength;
+        if (bytes > limits.maxBytes)
+            throw new GeometryError("COMPLEXITY_LIMIT", "Export snapshot exceeds maxBytes.");
+        const captured = immutable ? source : source.slice();
+        if (ranges === undefined) {
+            ranges = new Map();
+            viewKeys.set(source.buffer, ranges);
+        }
+        ranges.set(key, captured);
+        return captured;
+    }
+    const geometries = new MeshViewCache();
+    const validatedGeometries = new MeshViewCache();
+    const captured = [];
+    for (const part of parts) {
+        signal?.throwIfAborted();
+        if (typeof part !== "object" || part === null)
+            throw new GeometryError("INVALID_ARGUMENT", "Export parts must be objects.");
+        const id = part.id;
+        identifier(id);
+        if (ids.has(id))
+            throw new GeometryError("INVALID_ARGUMENT", "Export part IDs must be unique canonical identifiers.");
+        ids.add(id);
+        const input = part.geometry;
+        if (typeof input !== "object" || input === null)
+            throw new GeometryError("INVALID_MESH", "Export parts require local geometry.");
+        const { positions, indices, normals } = input;
+        const localPositions = isImmutableBuffer(positions)
+            ? immutableBufferView(positions)
+            : positions;
+        const localIndices = isImmutableBuffer(indices) ? immutableBufferView(indices) : indices;
+        const localNormals = normals === undefined
+            ? undefined
+            : isImmutableBuffer(normals)
+                ? immutableBufferView(normals)
+                : normals;
+        if (!(localPositions instanceof Float32Array) ||
+            !(localIndices instanceof Uint32Array) ||
+            localPositions.length % 3 !== 0 ||
+            localIndices.length % 3 !== 0 ||
+            (localNormals !== undefined &&
+                (!(localNormals instanceof Float32Array) || localNormals.length !== localPositions.length)))
+            throw new GeometryError("INVALID_MESH", "Export geometry requires complete Float32 XYZ positions, Uint32 triangles, and matching optional normals.");
+        vertices += localPositions.length / 3;
+        triangles += localIndices.length / 3;
+        if (vertices > limits.maxVertices || triangles > limits.maxTriangles)
+            throw new GeometryError("COMPLEXITY_LIMIT", "Export snapshot exceeds its vertex or triangle limits.");
+        const mesh = {
+            positions: captureArray(localPositions, isImmutableBuffer(positions)),
+            indices: captureArray(localIndices, isImmutableBuffer(indices)),
+            ...(localNormals === undefined
+                ? {}
+                : { normals: captureArray(localNormals, isImmutableBuffer(normals)) }),
+        };
+        const variants = geometries.get(mesh) ?? [];
+        let geometry = variants.find((value) => value.normals === mesh.normals);
+        if (geometry === undefined) {
+            if (validatedGeometries.get(mesh) !== true) {
+                const facts = meshValidation === "solid"
+                    ? analyzeSolidMesh(mesh)
+                    : analyzeTriangleMesh(mesh, {
+                        requireClosed: format === "3mf",
+                        includeTopology: format === "3mf",
+                    });
+                if (format === "3mf" && !(facts.signedVolume > 0))
+                    throw new GeometryError("INVALID_TOPOLOGY", "3MF parts require positive oriented volume.");
+                validatedGeometries.set(mesh, true);
+            }
+            if (mesh.normals !== undefined)
+                for (let offset = 0; offset < mesh.normals.length; offset += 3) {
+                    const length = Math.hypot(mesh.normals[offset], mesh.normals[offset + 1], mesh.normals[offset + 2]);
+                    if (!Number.isFinite(length) || Math.abs(length - 1) > 1e-4)
+                        throw new GeometryError("INVALID_MESH", "Authored display normals must be finite unit vectors.");
+                }
+            geometry = Object.freeze(mesh);
+            variants.push(geometry);
+            geometries.set(mesh, variants);
+        }
+        const inputTransform = part.transform;
+        if (inputTransform !== undefined && (!isArray(inputTransform) || inputTransform.length !== 16))
+            throw new GeometryError("INVALID_ARGUMENT", "Export placement requires a row-major matrix of sixteen entries.");
+        const transform = inputTransform === undefined
+            ? IDENTITY_TRANSFORM3
+            : Object.freeze([...inputTransform]);
+        validateRigidTransform3(transform);
+        // Solid validation includes placed Float32 buffers: large translations can collapse local gaps.
+        if (meshValidation === "solid" &&
+            transform.some((value, index) => value !== IDENTITY_TRANSFORM3[index]))
+            analyzeSolidMesh(transformTriangleMesh(geometry, transform));
+        const materialId = part.materialId;
+        if (materialId !== undefined && !byMaterial.has(materialId))
+            throw new GeometryError("INVALID_ARGUMENT", `Unknown export material ${String(materialId)}.`);
+        const color = part.color === undefined
+            ? materialId === undefined
+                ? undefined
+                : byMaterial.get(materialId).color
+            : colorValue(part.color);
+        captured.push(Object.freeze({
+            id,
+            geometry,
+            transform,
+            ...(color === undefined ? {} : { color }),
+            ...(materialId === undefined ? {} : { materialId }),
+        }));
+    }
+    return Object.freeze({
+        parts: Object.freeze(captured),
+        materials: Object.freeze(materials),
+        name,
+        limits,
+        meshValidation,
+        ...(signal === undefined ? {} : { signal }),
+    });
+}