@metamesh/modeling 0.18.0 → 0.20.0

package/dist/engine/session/native-cache.js

@@ -22,7 +22,7 @@ function rollback(error, values, message) {
     }
     throw error;
 }
-/** Bounded evaluated computed roots. Candidates remain provisional until ordinary run cleanup succeeds. */
+/** Bounded evaluated memo roots. Candidates remain provisional until ordinary run cleanup succeeds. */
 export function createNativeGeometryCache() {
     let committed = new Map();
     const values = (entries) => new Set([...entries.values()].map((entry) => entry.native.value));

package/dist/engine/session/parameters.js

@@ -0,0 +1,78 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { captureGenerationValue, generationDataEntries, isImmutableGenerationValue, } from "../../model/immutable-generation-data.js";
+const keys = Symbol("parameter-keys");
+function immutable() {
+    throw new GeometryError("INVALID_ARGUMENT", "Parameters are immutable.", { operation: "memo" });
+}
+/** Captures supported data and reuses identities only when the entire caller graph is immutable. */
+function captureParameters(input, previous, snapshot) {
+    return Object.freeze(Object.fromEntries(Array.from(generationDataEntries(input), ([key, value]) => [
+        key,
+        Object.is(value, previous[key]) &&
+            Object.hasOwn(snapshot, key) &&
+            isImmutableGenerationValue(value)
+            ? snapshot[key]
+            : captureGenerationValue(value),
+    ])));
+}
+/**
+ * Owns committed parameter identities and creates a separate guarded snapshot for every revision.
+ * The session commits identities only after successful geometry finalization and native cleanup.
+ */
+export function createParameterSource() {
+    let previousInput = {}, previousSnapshot = {};
+    return {
+        begin(input, assertActive, record) {
+            const inputValues = input;
+            const snapshot = captureParameters(inputValues, previousInput, previousSnapshot);
+            const keySignature = JSON.stringify(Object.keys(snapshot));
+            // This proxy is never redirected to a later snapshot: aliases within memo calls remain
+            // ordinary JavaScript identities and every late read still checks its original revision.
+            const params = new Proxy(snapshot, {
+                get(target, key) {
+                    assertActive();
+                    const value = Reflect.get(target, key);
+                    if (typeof key === "string")
+                        record(key, value);
+                    return value;
+                },
+                set: immutable,
+                deleteProperty: immutable,
+                ownKeys(target) {
+                    assertActive();
+                    record(keys, keySignature);
+                    return Reflect.ownKeys(target);
+                },
+                has(target, key) {
+                    assertActive();
+                    record(keys, keySignature);
+                    return Reflect.has(target, key);
+                },
+                getOwnPropertyDescriptor(target, key) {
+                    assertActive();
+                    record(keys, keySignature);
+                    const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+                    if (typeof key === "string")
+                        record(key, descriptor?.value);
+                    return descriptor;
+                },
+            });
+            return {
+                params,
+                retainedValues: [snapshot, inputValues],
+                has: (key) => Object.hasOwn(snapshot, key),
+                // Cache validation reads the snapshot directly; using the proxy would record those
+                // internal comparisons as new model dependencies.
+                read: (key) => key === keys ? keySignature : Reflect.get(snapshot, key),
+                commit() {
+                    previousInput = { ...inputValues };
+                    previousSnapshot = snapshot;
+                },
+            };
+        },
+        clear() {
+            previousInput = {};
+            previousSnapshot = {};
+        },
+    };
+}

package/dist/engine/session/session.js

@@ -1,8 +1,8 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { resolveModelingLimits } from "../../geometry/model-limits.js";
+import { resolveModelingLimits } from "../../geometry/limits.js";
 import { bindModelContext } from "../../model/execution-binding.js";
 import { GenerationError } from "../../model/generation.js";
-import { captureGenerationValue, generationValueBytes, } from "../../model/immutable-generation-data.js";
+import { captureGenerationValue } from "../../model/immutable-generation-data.js";
 import { createDeferredContext } from "./deferred-context.js";
 import { createGenerationGraph } from "./graph.js";
 import { createNativeGeometryCache } from "./native-cache.js";
@@ -29,7 +29,7 @@ export function createSession(program, suppliedOptions, engineLimits, transactio
     // owns their fixed lifetime; copying their enumerable fields would change their semantics.
     const services = (options.services ?? Object.freeze({}));
     const caches = {
-        graph: createGenerationGraph(options, limits.maxParts),
+        graph: createGenerationGraph(options, limits),
         snapshots: createSnapshotCache(options, limits),
         geometry: createNativeGeometryCache(),
         clear() {
@@ -93,7 +93,7 @@ export function createSession(program, suppliedOptions, engineLimits, transactio
 /**
  * Owns one attempted revision, including provisional retained native allocations. Declaration and capture
  * happen inside the native transaction; commit is allowed only after that transaction cleans up.
- * Disposal invalidates readers and releases any native allocations that were not committed.
+ * Disposal invalidates contexts and releases any native allocations that were not committed.
  */
 class SessionRevision {
     session;
@@ -120,7 +120,7 @@ class SessionRevision {
     generate(revision, deferred, native, mode) {
         const { program, services, caches } = this.session;
         const startedAt = performance.now();
-        const output = revision.finish(program.generate({ ...revision.context, services }));
+        const output = revision.finish(program.generate(revision.withServices(services)));
         if (mode === "validate")
             return { kind: "validation", diagnostics: Object.freeze([...revision.diagnostics]) };
         const captured = caches.snapshots.capture({
@@ -141,10 +141,10 @@ class SessionRevision {
         const { options, limits, caches } = this.session;
         if (options.cache === false)
             return;
-        const retainedBytes = generationValueBytes([...revision.retainedValues(), ...captured.retainedValues], limits.maxBytes);
+        const retainedBytes = revision.prepareRetention(captured.retainedValues, limits.maxBytes);
         if (retainedBytes > limits.maxBytes)
             return;
-        const nativeCandidate = caches.geometry.prepare(deferred.retentionCandidates(revision.computedValues()), (shape) => {
+        const nativeCandidate = caches.geometry.prepare(deferred.retentionCandidates(revision.memoValues()), (shape) => {
             const realized = deferred.realizedShape(shape);
             if (realized !== undefined)
                 return native().captureNative(realized);

package/dist/engine/session/snapshot-cache.js

@@ -1,7 +1,7 @@
 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 { validateRigidTransform3 } from "../../geometry/transforms/affine3.js";
+import { transform3 } from "../../geometry/transforms/value.js";
 import { createGeometryFinalizer } from "../finalization.js";
 import { requireModelPart } from "../model-parts.js";
 import { createModelSummary } from "../model-summary.js";
@@ -32,7 +32,7 @@ function createResource(id, geometry, reusable) {
 }
 /** Captures authoritative placement and appearance before consulting world-geometry reuse. */
 function capturePlacement(descriptor) {
-    const transform = validateRigidTransform3(transform3(typeof descriptor.transform === "function" ? descriptor.transform() : descriptor.transform).toData());
+    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.");
@@ -83,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);

package/dist/engine/shape-anchors.js

@@ -1,6 +1,6 @@
-import { anchor3 } from "../geometry/anchors.js";
 import { GeometryError } from "../geometry/errors.js";
-import { applyInverseTranspose3, applyTransformDirection3, applyTransformPoint3, inverseLinearTransform3, } from "../geometry/transform3.js";
+import { applyInverseTranspose3, applyValidatedTransformDirection3, applyValidatedTransformPoint3, inverseLinearTransform3, validateTransform3, } from "../geometry/transforms/affine3.js";
+import { anchor3 } from "../geometry/transforms/anchors.js";
 const maximumAnchors = 128;
 function fail(operation, message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation });
@@ -15,7 +15,7 @@ function copyAnchor(anchor, operation) {
     for (const vector of [anchor.position, anchor.direction, anchor.up])
         if (!Array.isArray(vector) || vector.length !== 3 || !vector.every(Number.isFinite))
             fail(operation, "Anchor vectors must contain exactly three finite coordinates.");
-    return anchor3(anchor.position, anchor.direction, anchor.up);
+    return anchor3({ position: anchor.position, direction: anchor.direction, up: anchor.up });
 }
 function unit(vector) {
     const maximum = Math.max(...vector.map(Math.abs));
@@ -27,7 +27,11 @@ function unit(vector) {
 }
 /** Maps positions affinely, outward normals by inverse transpose, and roll tangents linearly. */
 function transformedAnchor(anchor, matrix, inverse) {
-    return anchor3(applyTransformPoint3(matrix, anchor.position), applyInverseTranspose3(inverse, anchor.direction), unit(applyTransformDirection3(matrix, anchor.up)));
+    return anchor3({
+        position: applyValidatedTransformPoint3(matrix, anchor.position),
+        direction: applyInverseTranspose3(inverse, anchor.direction),
+        up: unit(applyValidatedTransformDirection3(matrix, anchor.up)),
+    });
 }
 /** Run-owned immutable anchor metadata. Geometry operations acquire metadata only deliberately. */
 export function createShapeAnchorOwner(assertShape, aliasShape) {
@@ -75,10 +79,13 @@ export function createShapeAnchorOwner(assertShape, aliasShape) {
             if (definitions === undefined)
                 return result;
             const inverse = inverseLinearTransform3(matrix);
-            return remember(result, Object.fromEntries(Object.entries(definitions).map(([name, value]) => [
+            validateTransform3(matrix);
+            // Names and inputs already belong to this owner; transformedAnchor returns frozen values.
+            anchors.set(result, Object.freeze(Object.fromEntries(Object.entries(definitions).map(([name, value]) => [
                 name,
                 transformedAnchor(value, matrix, inverse),
-            ])));
+            ]))));
+            return result;
         },
         dispose() {
             anchors.clear();

package/dist/export/3mf.js

@@ -0,0 +1,197 @@
+import { Zip, ZipDeflate } from "fflate";
+import { GeometryError } from "../geometry/errors.js";
+import { MeshViewCache } from "../geometry/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.
+ *
+ * @param parts - Closed, outward-wound parts in output order.
+ * @param sink - Receives each chunk; return a promise to pause writing.
+ */
+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.
+ *
+ * @param parts - Closed, outward-wound parts in output order, with local geometry in millimetres.
+ */
+export async function export3mf(parts, options = {}) {
+    return collectExport((sink) => write3mf(parts, sink, options));
+}

package/dist/export/capture.js

@@ -0,0 +1,182 @@
+import { GeometryError } from "../geometry/errors.js";
+import { immutableBufferView, isImmutableBuffer } from "../geometry/immutable-buffer.js";
+import { analyzeTriangleMesh, transformTriangleMesh, } from "../geometry/mesh/operations.js";
+import { analyzeSolidMesh } from "../geometry/mesh/solid.js";
+import { MeshViewCache } from "../geometry/mesh/view-cache.js";
+import { IDENTITY_TRANSFORM3, validateRigidTransform3 } from "../geometry/transforms/affine3.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.");
+        // Typed-array methods and species are caller-overridable; constructors guarantee an owned copy.
+        const captured = immutable
+            ? source
+            : (source instanceof Float32Array
+                ? new Float32Array(source)
+                : new Uint32Array(source));
+        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,
+        ...(signal === undefined ? {} : { signal }),
+    });
+}