@metamesh/modeling 0.18.0 → 0.19.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/session.js

@@ -2,7 +2,7 @@ import { GeometryError } from "../../geometry/errors.js";
 import { resolveModelingLimits } from "../../geometry/model-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";
@@ -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

@@ -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/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 }),
+    });
+}

package/dist/export/glb.js

@@ -0,0 +1,209 @@
+import { GeometryError } from "../geometry/errors.js";
+import { renderMesh } from "../geometry/mesh/mesh-render.js";
+import { captureExport } from "./capture.js";
+import { collectExport, createExportWriter } from "./writer.js";
+const alignedLength = (length) => Math.ceil(length / 4) * 4;
+const linearChannel = (value) => value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+function baseColor(color) {
+    return [
+        linearChannel(Number.parseInt(color.slice(1, 3), 16) / 255),
+        linearChannel(Number.parseInt(color.slice(3, 5), 16) / 255),
+        linearChannel(Number.parseInt(color.slice(5, 7), 16) / 255),
+        1,
+    ];
+}
+/**
+ * Serializes captured local meshes as uncompressed glTF 2.0 binary, in metres and Y-up.
+ * Preserves named parts, placement, shared geometry and display appearance. Authored normals take
+ * precedence over crease-aware shading; no engine, renderer or optional compression codec is loaded.
+ */
+export function exportGlb(parts, options = {}) {
+    return collectExport((sink) => writeGlb(parts, sink, options));
+}
+/**
+ * Writes owned GLB chunks with backpressure, cancellation and explicit output limits.
+ * Plans accessor and container lengths before writing, then emits bounded binary chunks.
+ * Hosts own sink completion, scheduling and recovery after a partially written failure.
+ */
+export async function writeGlb(parts, sink, options = {}) {
+    const captured = captureExport(parts, options, "glb");
+    const creaseAngle = options.creaseAngle ?? 20;
+    if (!Number.isFinite(creaseAngle) || creaseAngle < 0 || creaseAngle > 180)
+        throw new GeometryError("INVALID_ARGUMENT", "Crease angle must be from 0 through 180 degrees.", {
+            operation: "exportGlb",
+        });
+    const writer = createExportWriter(captured, sink, "glb");
+    const accessors = [];
+    const bufferViews = [];
+    const attributes = [];
+    const materials = [];
+    const meshes = [];
+    const nodes = [];
+    const geometryAccessors = new Map();
+    const materialIndices = new Map();
+    const meshIndices = new Map();
+    let binaryLength = 0;
+    let lastYield = performance.now();
+    const addAttribute = (data, componentType, type, bounds) => {
+        const byteLength = data.length * (componentType === 5123 ? 2 : 4);
+        const bufferView = bufferViews.length;
+        bufferViews.push({
+            buffer: 0,
+            byteOffset: binaryLength,
+            byteLength,
+            target: type === "SCALAR" ? 34963 : 34962,
+        });
+        binaryLength += alignedLength(byteLength);
+        if (binaryLength > captured.limits.maxOutputBytes || binaryLength >= 0x1_0000_0000)
+            throw new GeometryError("COMPLEXITY_LIMIT", "GLB binary data exceeds the output limits.", {
+                operation: "exportGlb",
+            });
+        attributes.push({ data, componentType, byteLength });
+        const accessor = accessors.length;
+        accessors.push({
+            bufferView,
+            componentType,
+            count: data.length / (type === "VEC3" ? 3 : 1),
+            type,
+            ...bounds,
+        });
+        return accessor;
+    };
+    for (const part of captured.parts) {
+        captured.signal?.throwIfAborted();
+        let geometry = geometryAccessors.get(part.geometry);
+        if (geometry === undefined) {
+            const rendered = part.geometry.normals === undefined
+                ? renderMesh(part.geometry, { creaseAngle })
+                : { ...part.geometry, normals: part.geometry.normals };
+            const min = [Infinity, Infinity, Infinity];
+            const max = [-Infinity, -Infinity, -Infinity];
+            for (let index = 0; index < rendered.positions.length; index += 3)
+                for (let axis = 0; axis < 3; axis += 1) {
+                    min[axis] = Math.min(min[axis], rendered.positions[index + axis]);
+                    max[axis] = Math.max(max[axis], rendered.positions[index + axis]);
+                }
+            const position = addAttribute(rendered.positions, 5126, "VEC3", { min, max });
+            const normal = addAttribute(rendered.normals, 5126, "VEC3");
+            let maximumIndex = 0;
+            for (const index of rendered.indices)
+                maximumIndex = Math.max(maximumIndex, index);
+            // glTF reserves the component type's largest integer for primitive restart.
+            const indices = addAttribute(rendered.indices, maximumIndex < 65_535 ? 5123 : 5125, "SCALAR");
+            geometry = { position, normal, indices };
+            geometryAccessors.set(part.geometry, geometry);
+        }
+        const color = part.color ?? "#ffffff";
+        const materialKey = `${part.materialId ?? ""}:${color.toLowerCase()}`;
+        let material = materialIndices.get(materialKey);
+        if (material === undefined) {
+            material = materials.length;
+            materials.push({
+                ...(part.materialId === undefined
+                    ? {}
+                    : { name: part.materialId, extras: { materialId: part.materialId } }),
+                pbrMetallicRoughness: {
+                    baseColorFactor: baseColor(color),
+                    metallicFactor: 0,
+                    roughnessFactor: 1,
+                },
+            });
+            materialIndices.set(materialKey, material);
+        }
+        const meshKey = `${geometry.position}:${material}`;
+        let mesh = meshIndices.get(meshKey);
+        if (mesh === undefined) {
+            mesh = meshes.length;
+            meshes.push({
+                primitives: [
+                    {
+                        attributes: { POSITION: geometry.position, NORMAL: geometry.normal },
+                        indices: geometry.indices,
+                        material,
+                    },
+                ],
+            });
+            meshIndices.set(meshKey, mesh);
+        }
+        const transform = part.transform;
+        const matrix = Array.from({ length: 16 }, (_, index) => transform[(index % 4) * 4 + Math.floor(index / 4)]);
+        nodes.push({ name: part.id, mesh, matrix });
+        if (performance.now() - lastYield >= 16) {
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            lastYield = performance.now();
+        }
+    }
+    captured.signal?.throwIfAborted();
+    const rootNode = nodes.length;
+    nodes.push({
+        name: captured.name,
+        // Column-major matrix: x'=x/1000, y'=z/1000, z'=-y/1000.
+        matrix: [0.001, 0, 0, 0, 0, 0, -0.001, 0, 0, 0.001, 0, 0, 0, 0, 0, 1],
+        children: Array.from({ length: rootNode }, (_, index) => index),
+    });
+    const json = new TextEncoder().encode(JSON.stringify({
+        asset: { version: "2.0", generator: "MetaMesh" },
+        scene: 0,
+        scenes: [{ name: captured.name, nodes: [rootNode] }],
+        nodes,
+        meshes,
+        materials,
+        accessors,
+        bufferViews,
+        buffers: [{ byteLength: binaryLength }],
+    }));
+    const paddedJsonLength = alignedLength(json.byteLength);
+    const fileLength = 12 + 8 + paddedJsonLength + 8 + binaryLength;
+    if (fileLength >= 0x1_0000_0000 || fileLength > captured.limits.maxOutputBytes)
+        throw new GeometryError("COMPLEXITY_LIMIT", "GLB container exceeds the output limits.", {
+            operation: "exportGlb",
+        });
+    const header = new Uint8Array(20);
+    const headerView = new DataView(header.buffer);
+    headerView.setUint32(0, 0x46546c67, true);
+    headerView.setUint32(4, 2, true);
+    headerView.setUint32(8, fileLength, true);
+    headerView.setUint32(12, paddedJsonLength, true);
+    headerView.setUint32(16, 0x4e4f534a, true);
+    await writer.write(header);
+    const paddedJson = new Uint8Array(paddedJsonLength).fill(0x20);
+    paddedJson.set(json);
+    for (let start = 0; start < paddedJson.length; start += 65_536)
+        await writer.write(paddedJson.slice(start, start + 65_536));
+    const binaryHeader = new Uint8Array(8);
+    const binaryHeaderView = new DataView(binaryHeader.buffer);
+    binaryHeaderView.setUint32(0, binaryLength, true);
+    binaryHeaderView.setUint32(4, 0x004e4942, true);
+    await writer.write(binaryHeader);
+    for (const attribute of attributes) {
+        const width = attribute.componentType === 5123 ? 2 : 4;
+        const elementsPerChunk = 65_536 / width;
+        for (let start = 0; start < attribute.data.length; start += elementsPerChunk) {
+            const count = Math.min(elementsPerChunk, attribute.data.length - start);
+            const chunk = new Uint8Array(count * width);
+            const view = new DataView(chunk.buffer);
+            for (let index = 0; index < count; index += 1) {
+                const value = attribute.data[start + index];
+                if (attribute.componentType === 5126)
+                    view.setFloat32(index * width, value, true);
+                else if (attribute.componentType === 5123)
+                    view.setUint16(index * width, value, true);
+                else
+                    view.setUint32(index * width, value, true);
+            }
+            await writer.write(chunk);
+        }
+        const padding = alignedLength(attribute.byteLength) - attribute.byteLength;
+        if (padding > 0)
+            await writer.write(new Uint8Array(padding));
+    }
+    const diagnostics = [];
+    const assigned = captured.parts.filter((part) => part.materialId !== undefined);
+    if (assigned.length > 0)
+        diagnostics.push({
+            code: "MATERIAL_ASSIGNMENTS_DROPPED",
+            message: "GLB preserves material identities as metadata and appearance, without print material assignment semantics.",
+            partIds: assigned.map((part) => part.id),
+        });
+    return writer.report(diagnostics);
+}

package/dist/export/index.js

@@ -0,0 +1,5 @@
+/** Runtime-independent completed-mesh export. All input coordinates are millimetres, right-handed, and Z-up. @packageDocumentation */
+export { export3mf, write3mf } from "./3mf.js";
+export { exportStl, writeStl } from "./stl.js";
+export { exportGlb, writeGlb } from "./glb.js";
+export { defaultExportLimits } from "./limits.js";