dsh-cad 0.2.0

package/lib/convert/dcprt.js

@@ -0,0 +1,38 @@
+import { encodeF32B64, encodeU32B64 } from '../b64.js';
+import { runModelOp } from '../modeling/client.js';
+import { isDcPrtDocument } from '../feature_script/dc_prt.js';
+/** Convert a .dcprt buffer to indexed CadMeshes by replaying its features. */
+export async function parseDcprt(buffer, fallbackName, timeoutMs = 180_000) {
+    let doc;
+    try {
+        doc = JSON.parse(buffer.toString('utf8'));
+    }
+    catch (error) {
+        throw new Error(`the DCPRT file is not valid JSON: ${error.message}`);
+    }
+    if (!isDcPrtDocument(doc)) {
+        throw new Error('not a DCPRT part document (missing dcprt header or features)');
+    }
+    await runModelOp({ kind: 'reset' }, timeoutMs);
+    for (const [index, feature] of doc.features.entries()) {
+        try {
+            await runModelOp(feature, timeoutMs);
+        }
+        catch (error) {
+            throw new Error(`DCPRT replay failed at feature ${index} (${feature.kind}): ${error.message}`);
+        }
+    }
+    const tessellated = await runModelOp({ kind: 'tessellate_all' }, timeoutMs);
+    if (tessellated.meshes === undefined || tessellated.meshes.length === 0) {
+        throw new Error('the DCPRT document replays to no bodies');
+    }
+    const names = new Map(doc.bodies.map((body) => [body.bodyId, body.name]));
+    return tessellated.meshes.map((mesh, index) => ({
+        name: names.get(mesh.bodyId) ?? mesh.name ?? `${fallbackName} #${index + 1}`,
+        positions: encodeF32B64(mesh.positions),
+        normals: mesh.normals === undefined ? undefined : encodeF32B64(mesh.normals),
+        indices: encodeU32B64(mesh.indices),
+        vertexCount: mesh.positions.length / 3,
+        triangleCount: mesh.indices.length / 3,
+    }));
+}

package/lib/convert/detect.js

@@ -0,0 +1,22 @@
+const EXTENSION_TO_FORMAT = {
+    stl: 'stl',
+    obj: 'obj',
+    step: 'step',
+    stp: 'step',
+    iges: 'iges',
+    igs: 'iges',
+    brep: 'brep',
+    dxf: 'dxf',
+    svg: 'svg',
+    dcprt: 'dcprt',
+};
+export function detectFormat(fileName) {
+    const dot = fileName.lastIndexOf('.');
+    if (dot < 0)
+        return null;
+    const extension = fileName.slice(dot + 1).toLowerCase();
+    return EXTENSION_TO_FORMAT[extension] ?? null;
+}
+export function is3DFormat(format) {
+    return format === 'stl' || format === 'obj' || format === 'step' || format === 'iges' || format === 'brep' || format === 'dcprt';
+}

package/lib/convert/dxf.js

@@ -0,0 +1,124 @@
+/**
+ * DXF → CadDrawing2D conversion via dxf-parser. Maps the entity subset the
+ * viewport renders; unknown entity types are counted, not failed.
+ *
+ * dxf-parser ships as CJS with `module.exports = class`; load it through
+ * createRequire to sidestep ESM-interop typing friction.
+ */
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const DxfParser = require('dxf-parser');
+/** DXF AutoCAD color index → 0xRRGGBB (subset). 0 = ByBlock/ByLayer. */ const ACI_COLORS = {
+    1: 0xff0000, 2: 0xffff00, 3: 0x00ff00, 4: 0x00ffff, 5: 0x0000ff, 6: 0xff00ff,
+    7: 0xffffff, 8: 0x808080, 9: 0xc0c0c0,
+    30: 0xff5f00, 40: 0xff8700, 50: 0xffaf00, 60: 0xffd700, 90: 0xaf8700,
+};
+function aciColor(colorIndex) {
+    if (colorIndex === undefined || colorIndex === 0)
+        return undefined;
+    return ACI_COLORS[colorIndex];
+}
+function bulgedPolylinePoints(vertices) {
+    // Bulge arcs are approximated by the chord polyline; exact arc tessellation
+    // is deferred work. Straight segments pass through unchanged.
+    const points = [];
+    for (const vertex of vertices)
+        points.push(vertex.x, vertex.y);
+    return points;
+}
+/** Convert DXF text into a 2D drawing. */
+export function parseDXF(text) {
+    const dxf = new DxfParser().parseSync(text) ?? { entities: [] };
+    const entities = [];
+    const layers = new Set();
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    const track = (x, y) => {
+        if (!Number.isFinite(x) || !Number.isFinite(y))
+            return;
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+    };
+    for (const entity of dxf.entities ?? []) {
+        const layer = typeof entity.layer === 'string' && entity.layer !== '' ? entity.layer : undefined;
+        if (layer !== undefined)
+            layers.add(layer);
+        const color = aciColor(entity.colorIndex);
+        switch (entity.type) {
+            case 'LINE': {
+                // dxf-parser exposes LINE endpoints as a two-entry vertices array.
+                const line = entity;
+                const from = line.vertices?.[0];
+                const to = line.vertices?.[1];
+                if (from === undefined || to === undefined)
+                    break;
+                entities.push({ type: 'line', x1: from.x, y1: from.y, x2: to.x, y2: to.y, layer, color });
+                track(from.x, from.y);
+                track(to.x, to.y);
+                break;
+            }
+            case 'CIRCLE': {
+                const circle = entity;
+                entities.push({ type: 'circle', cx: circle.center.x, cy: circle.center.y, r: circle.radius, layer, color });
+                track(circle.center.x - circle.radius, circle.center.y - circle.radius);
+                track(circle.center.x + circle.radius, circle.center.y + circle.radius);
+                break;
+            }
+            case 'ARC': {
+                const arc = entity;
+                entities.push({
+                    type: 'arc', cx: arc.center.x, cy: arc.center.y, r: arc.radius,
+                    startAngle: arc.startAngle, endAngle: arc.endAngle, layer, color,
+                });
+                track(arc.center.x - arc.radius, arc.center.y - arc.radius);
+                track(arc.center.x + arc.radius, arc.center.y + arc.radius);
+                break;
+            }
+            case 'LWPOLYLINE':
+            case 'POLYLINE': {
+                const polyline = entity;
+                const points = bulgedPolylinePoints(polyline.vertices ?? []);
+                if (points.length >= 4) {
+                    entities.push({ type: 'polyline', points, closed: polyline.shape === true, layer, color });
+                    for (let i = 0; i < points.length; i += 2)
+                        track(points[i], points[i + 1]);
+                }
+                break;
+            }
+            case 'TEXT':
+            case 'MTEXT': {
+                const textEntity = entity;
+                const anchor = textEntity.startPoint ?? textEntity.position;
+                const content = textEntity.text;
+                if (anchor !== undefined && content !== undefined && content !== '') {
+                    entities.push({
+                        type: 'text', x: anchor.x, y: anchor.y, text: content,
+                        height: textEntity.textHeight ?? 1, rotation: textEntity.rotation ?? 0, layer, color,
+                    });
+                    track(anchor.x, anchor.y);
+                }
+                break;
+            }
+            default:
+                // Unknown entity kinds are skipped; the count still reflects them.
+                break;
+        }
+    }
+    if (!Number.isFinite(minX)) {
+        minX = 0;
+        minY = 0;
+        maxX = 0;
+        maxY = 0;
+    }
+    return {
+        kind: '2d',
+        format: 'dxf',
+        entities,
+        bounds: { min: { x: minX, y: minY }, max: { x: maxX, y: maxY } },
+        layers: [...layers],
+    };
+}

package/lib/convert/index.js

@@ -0,0 +1,70 @@
+import { parseSTL } from './stl.js';
+import { parseOBJ } from './obj.js';
+import { parseDXF } from './dxf.js';
+import { parseSVG } from './svg.js';
+import { parseOcct } from './step.js';
+import { parseDcprt } from './dcprt.js';
+function meshBounds(meshes) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let maxZ = -Infinity;
+    // Decode each mesh's base64 positions once and scan the xyz triplets.
+    for (const mesh of meshes) {
+        const positions = Buffer.from(mesh.positions, 'base64');
+        for (let offset = 0; offset + 12 <= positions.length; offset += 12) {
+            const x = positions.readFloatLE(offset);
+            const y = positions.readFloatLE(offset + 4);
+            const z = positions.readFloatLE(offset + 8);
+            if (x < minX)
+                minX = x;
+            if (y < minY)
+                minY = y;
+            if (z < minZ)
+                minZ = z;
+            if (x > maxX)
+                maxX = x;
+            if (y > maxY)
+                maxY = y;
+            if (z > maxZ)
+                maxZ = z;
+        }
+    }
+    return { min: { x: minX, y: minY, z: minZ }, max: { x: maxX, y: maxY, z: maxZ } };
+}
+/** Scan a set of CadMeshes for their axis-aligned bounds. */
+export function computeMeshBounds(meshes) {
+    return meshBounds(meshes);
+}
+/** Convert a supported CAD file buffer into a renderable scene. */
+export async function convert(buffer, format, fileName) {
+    const stem = fileName.replace(/\.[^.]+$/, '');
+    switch (format) {
+        case 'stl': {
+            const meshes = [parseSTL(buffer, stem)];
+            return { kind: '3d', format, meshes, bounds: meshBounds(meshes), units: 'unitless' };
+        }
+        case 'obj': {
+            const meshes = parseOBJ(buffer.toString('utf8'), stem);
+            if (meshes.length === 0)
+                throw new Error('the OBJ file contains no faces');
+            return { kind: '3d', format, meshes, bounds: meshBounds(meshes), units: 'unitless' };
+        }
+        case 'step':
+        case 'iges':
+        case 'brep': {
+            const meshes = await parseOcct(buffer, format, stem);
+            return { kind: '3d', format, meshes, bounds: meshBounds(meshes), units: 'mm' };
+        }
+        case 'dcprt': {
+            const meshes = await parseDcprt(buffer, stem);
+            return { kind: '3d', format, meshes, bounds: meshBounds(meshes), units: 'mm' };
+        }
+        case 'dxf':
+            return parseDXF(buffer.toString('utf8'));
+        case 'svg':
+            return parseSVG(buffer.toString('utf8'));
+    }
+}

package/lib/convert/obj.js

@@ -0,0 +1,106 @@
+import { encodeF32B64, encodeU32B64 } from '../b64.js';
+function parseObj(text) {
+    const model = { positions: [], normals: [], groups: [{ name: '', faces: [] }] };
+    let currentGroup = model.groups[0];
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (line === '' || line.startsWith('#'))
+            continue;
+        const space = line.indexOf(' ');
+        if (space < 0)
+            continue;
+        const keyword = line.slice(0, space);
+        const rest = line.slice(space + 1).trim();
+        if (keyword === 'v') {
+            const parts = rest.split(/\s+/);
+            model.positions.push(Number(parts[0]), Number(parts[1]), Number(parts[2]));
+        }
+        else if (keyword === 'vn') {
+            const parts = rest.split(/\s+/);
+            model.normals.push(Number(parts[0]), Number(parts[1]), Number(parts[2]));
+        }
+        else if (keyword === 'o' || keyword === 'g') {
+            const name = rest.split(/\s+/)[0] ?? '';
+            currentGroup = { name, faces: [] };
+            model.groups.push(currentGroup);
+        }
+        else if (keyword === 'f') {
+            const vertices = [];
+            const normalVertices = [];
+            for (const token of rest.split(/\s+/)) {
+                if (token === '')
+                    continue;
+                // Forms: v, v/vt, v//vn, v/vt/vn
+                const segments = token.split('/');
+                const vertexIndex = Number(segments[0]);
+                if (!Number.isFinite(vertexIndex) || vertexIndex === 0)
+                    continue;
+                // OBJ indices are 1-based; negatives count back from the end.
+                const resolved = vertexIndex > 0 ? vertexIndex - 1 : model.positions.length / 3 + vertexIndex;
+                vertices.push(resolved);
+                const normalToken = segments[2];
+                if (normalToken !== undefined && normalToken !== '') {
+                    const normalIndex = Number(normalToken);
+                    const resolvedNormal = normalIndex > 0 ? normalIndex - 1 : model.normals.length / 3 + normalIndex;
+                    normalVertices.push(resolvedNormal);
+                }
+            }
+            if (vertices.length >= 3)
+                currentGroup.faces.push({ vertices, normalVertices });
+        }
+    }
+    return model;
+}
+/** Fan-triangulate one face loop. */
+function fanTriangles(loop) {
+    const triangles = [];
+    for (let i = 1; i < loop.length - 1; i++) {
+        triangles.push([loop[0], loop[i], loop[i + 1]]);
+    }
+    return triangles;
+}
+/** Convert OBJ text into CadMeshes (one per non-empty group). */
+export function parseOBJ(text, fallbackName) {
+    const model = parseObj(text);
+    const meshes = [];
+    for (const group of model.groups) {
+        if (group.faces.length === 0)
+            continue;
+        const positions = [];
+        const normals = [];
+        const indices = [];
+        const vertexMap = new Map();
+        const hasNormals = group.faces.some((face) => face.normalVertices.length === face.vertices.length);
+        for (const face of group.faces) {
+            const faceNormals = face.normalVertices.length === face.vertices.length ? face.normalVertices : null;
+            for (const [a, b, c] of fanTriangles(face.vertices)) {
+                for (const vertexIndex of [a, b, c]) {
+                    const px = model.positions[vertexIndex * 3] ?? 0;
+                    const py = model.positions[vertexIndex * 3 + 1] ?? 0;
+                    const pz = model.positions[vertexIndex * 3 + 2] ?? 0;
+                    const normalIndex = faceNormals?.[vertexIndex];
+                    const key = normalIndex === undefined ? `${vertexIndex}` : `${vertexIndex}/${normalIndex}`;
+                    let index = vertexMap.get(key);
+                    if (index === undefined) {
+                        index = positions.length / 3;
+                        vertexMap.set(key, index);
+                        positions.push(px, py, pz);
+                        if (hasNormals) {
+                            normals.push(normalIndex === undefined ? 0 : model.normals[normalIndex * 3] ?? 0, normalIndex === undefined ? 0 : model.normals[normalIndex * 3 + 1] ?? 0, normalIndex === undefined ? 0 : model.normals[normalIndex * 3 + 2] ?? 0);
+                        }
+                    }
+                    indices.push(index);
+                }
+            }
+        }
+        meshes.push({
+            name: group.name === '' ? fallbackName : group.name,
+            positions: encodeF32B64(Float32Array.from(positions)),
+            normals: hasNormals ? encodeF32B64(Float32Array.from(normals)) : undefined,
+            indices: encodeU32B64(Uint32Array.from(indices)),
+            vertexCount: positions.length / 3,
+            triangleCount: indices.length / 3,
+        });
+    }
+    return meshes;
+}

package/lib/convert/png.js

@@ -0,0 +1,114 @@
+/**
+ * Minimal PNG decoder for the image-profile pipeline: 8-bit non-interlaced
+ * grayscale / grayscale+alpha / RGB / RGBA, decoding to a luma map. Zero
+ * dependencies (node:zlib); unsupported variants fail with explicit errors.
+ */
+import { inflateSync } from 'node:zlib';
+const SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const COLOR_CHANNELS = { 0: 1, 4: 2, 2: 3, 6: 4 };
+/** Decode a PNG buffer to a luma image. */
+export function decodePng(buffer) {
+    if (buffer.length < 8 || !buffer.subarray(0, 8).equals(SIGNATURE)) {
+        throw new Error('not a PNG file (bad signature)');
+    }
+    let offset = 8;
+    let width = 0;
+    let height = 0;
+    let bitDepth = 0;
+    let colorType = -1;
+    const idat = [];
+    let seenIhdr = false;
+    while (offset + 8 <= buffer.length) {
+        const length = buffer.readUInt32BE(offset);
+        const type = buffer.toString('ascii', offset + 4, offset + 8);
+        const data = buffer.subarray(offset + 8, offset + 8 + length);
+        if (type === 'IHDR') {
+            width = data.readUInt32BE(0);
+            height = data.readUInt32BE(4);
+            bitDepth = data[8];
+            colorType = data[9];
+            const compression = data[10];
+            const filterMethod = data[11];
+            const interlace = data[12];
+            if (bitDepth !== 8)
+                throw new Error(`unsupported PNG bit depth ${bitDepth} (only 8-bit)`);
+            if (!(colorType in COLOR_CHANNELS))
+                throw new Error(`unsupported PNG color type ${colorType}`);
+            if (compression !== 0 || filterMethod !== 0)
+                throw new Error('unsupported PNG compression/filter method');
+            if (interlace !== 0)
+                throw new Error('interlaced PNG is not supported');
+            seenIhdr = true;
+        }
+        else if (type === 'IDAT') {
+            idat.push(data);
+        }
+        else if (type === 'IEND') {
+            break;
+        }
+        offset += 12 + length;
+    }
+    if (!seenIhdr || width === 0 || height === 0)
+        throw new Error('the PNG has no usable IHDR chunk');
+    const channels = COLOR_CHANNELS[colorType];
+    const bytesPerPixel = channels;
+    const stride = width * bytesPerPixel;
+    const raw = inflateSync(Buffer.concat(idat));
+    if (raw.length < (stride + 1) * height)
+        throw new Error('the PNG pixel data is truncated');
+    const pixels = unfilter(raw, width, height, bytesPerPixel);
+    return { width, height, gray: toLuma(pixels, width, height, channels) };
+}
+function paeth(a, b, c) {
+    const p = a + b - c;
+    const pa = Math.abs(p - a);
+    const pb = Math.abs(p - b);
+    const pc = Math.abs(p - c);
+    if (pa <= pb && pa <= pc)
+        return a;
+    if (pb <= pc)
+        return b;
+    return c;
+}
+function unfilter(raw, width, height, bytesPerPixel) {
+    const stride = width * bytesPerPixel;
+    const out = new Uint8Array(stride * height);
+    let input = 0;
+    for (let y = 0; y < height; y++) {
+        const filter = raw[input++];
+        const row = y * stride;
+        const prior = row - stride;
+        for (let x = 0; x < stride; x++) {
+            const value = raw[input++];
+            const left = x >= bytesPerPixel ? out[row + x - bytesPerPixel] : 0;
+            const up = y > 0 ? out[prior + x] : 0;
+            const upLeft = y > 0 && x >= bytesPerPixel ? out[prior + x - bytesPerPixel] : 0;
+            let result = value;
+            if (filter === 1)
+                result = value + left;
+            else if (filter === 2)
+                result = value + up;
+            else if (filter === 3)
+                result = value + ((left + up) >> 1);
+            else if (filter === 4)
+                result = value + paeth(left, up, upLeft);
+            else if (filter !== 0)
+                throw new Error(`unknown PNG row filter ${filter}`);
+            out[row + x] = result & 0xff;
+        }
+    }
+    return out;
+}
+function toLuma(pixels, width, height, channels) {
+    const gray = new Uint8Array(width * height);
+    for (let i = 0; i < gray.length; i++) {
+        const o = i * channels;
+        if (channels === 1)
+            gray[i] = pixels[o];
+        else if (channels === 2)
+            gray[i] = pixels[o];
+        else
+            gray[i] = Math.round(0.299 * pixels[o] + 0.587 * pixels[o + 1] + 0.114 * pixels[o + 2]);
+    }
+    return gray;
+}

package/lib/convert/step-worker.mjs

@@ -0,0 +1,61 @@
+/**
+ * occt-import-js worker: parses STEP/IGES/BREP in a worker thread so the
+ * WASM tessellation never blocks the agent's event loop. Plain JavaScript —
+ * this file is copied verbatim into lib/ by the build.
+ */
+import { createRequire } from 'node:module'
+import { parentPort } from 'node:worker_threads'
+
+const require = createRequire(import.meta.url)
+
+async function main() {
+  if (parentPort === null) return
+  const occtimportjs = require('occt-import-js')
+  const occt = await occtimportjs()
+
+  parentPort.on('message', (request) => {
+    try {
+      const bytes = new Uint8Array(request.buffer)
+      const result =
+        request.format === 'step' ? occt.ReadStepFile(bytes, null)
+        : request.format === 'iges' ? occt.ReadIgesFile(bytes, null)
+        : occt.ReadBrepFile(bytes, null)
+      if (!result.success || result.meshes === undefined || result.meshes.length === 0) {
+        parentPort.postMessage({ jobId: request.jobId, ok: false, error: `the ${request.format.toUpperCase()} file parsed but contains no tessellatable geometry` })
+        return
+      }
+      const transfers = []
+      const meshes = result.meshes.map((mesh) => {
+        const positionArray = mesh.attributes?.position?.array
+        if (positionArray === undefined || positionArray.length < 9) return null
+        const positions = Float32Array.from(positionArray)
+        const normalSource = mesh.attributes?.normal?.array
+        const normals = normalSource !== undefined && normalSource.length === positions.length ? Float32Array.from(normalSource) : null
+        const indexSource = mesh.index?.array
+        const indices = indexSource !== undefined && indexSource.length > 0
+          ? Uint32Array.from(indexSource)
+          : Uint32Array.from({ length: positions.length / 3 }, (_, i) => i)
+        transfers.push(positions.buffer, indices.buffer)
+        if (normals !== null) transfers.push(normals.buffer)
+        const color = mesh.color
+        return {
+          name: mesh.name && mesh.name !== '' ? mesh.name : 'part',
+          positions,
+          normals: normals === null ? undefined : normals,
+          indices,
+          color: color === undefined ? undefined
+            : (Math.round(color[0] * 255) << 16) | (Math.round(color[1] * 255) << 8) | Math.round(color[2] * 255),
+        }
+      }).filter((mesh) => mesh !== null)
+      if (meshes.length === 0) {
+        parentPort.postMessage({ jobId: request.jobId, ok: false, error: `the ${request.format.toUpperCase()} file contains no meshes with geometry` })
+        return
+      }
+      parentPort.postMessage({ jobId: request.jobId, ok: true, meshes }, transfers)
+    } catch (error) {
+      parentPort.postMessage({ jobId: request.jobId, ok: false, error: error instanceof Error ? error.message : String(error) })
+    }
+  })
+}
+
+void main()

package/lib/convert/step.js

@@ -0,0 +1,66 @@
+/**
+ * Main-thread wrapper around the occt-import-js worker: one lazily spawned
+ * worker, job correlation, transferable buffers, and cooperative timeouts.
+ */
+import { Worker } from 'node:worker_threads';
+import { encodeF32B64, encodeU32B64 } from '../b64.js';
+let worker = null;
+let nextJobId = 1;
+const pending = new Map();
+function ensureWorker() {
+    if (worker !== null)
+        return worker;
+    const spawned = new Worker(new URL('./step-worker.mjs', import.meta.url));
+    spawned.on('message', (response) => {
+        const job = pending.get(response.jobId);
+        if (job === undefined)
+            return;
+        pending.delete(response.jobId);
+        clearTimeout(job.timer);
+        if (response.ok)
+            job.resolve(response.meshes);
+        else
+            job.reject(new Error(response.error));
+    });
+    spawned.on('error', (error) => {
+        failAll(error instanceof Error ? error : new Error(String(error)));
+    });
+    spawned.on('exit', (code) => {
+        if (code !== 0)
+            failAll(new Error(`the geometry worker exited unexpectedly (code ${code})`));
+        worker = null;
+    });
+    worker = spawned;
+    return spawned;
+}
+function failAll(error) {
+    for (const [jobId, job] of pending) {
+        pending.delete(jobId);
+        clearTimeout(job.timer);
+        job.reject(error);
+    }
+}
+/** Convert a STEP/IGES/BREP buffer to indexed CadMeshes. */
+export async function parseOcct(buffer, format, fallbackName, timeoutMs = 120_000) {
+    const active = ensureWorker();
+    const jobId = nextJobId++;
+    const copy = new Uint8Array(buffer.byteLength);
+    copy.set(buffer);
+    const meshes = await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            pending.delete(jobId);
+            reject(new Error(`${format.toUpperCase()} conversion timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        pending.set(jobId, { resolve, reject, timer });
+        active.postMessage({ jobId, format, buffer: copy.buffer }, [copy.buffer]);
+    });
+    return meshes.map((mesh, index) => ({
+        name: mesh.name === '' || mesh.name === undefined ? `${fallbackName} #${index + 1}` : mesh.name,
+        positions: encodeF32B64(mesh.positions),
+        normals: mesh.normals === undefined ? undefined : encodeF32B64(mesh.normals),
+        indices: encodeU32B64(mesh.indices),
+        vertexCount: mesh.positions.length / 3,
+        triangleCount: mesh.indices.length / 3,
+        color: mesh.color,
+    }));
+}