@driftengine/assets 4.6.1 → 4.7.1

package/dist/blendData.js

@@ -0,0 +1,366 @@
+/**
+ * Reading a `.blend`'s structs by field name, and following its pointers between blocks.
+ *
+ * `blendFile.ts` says where every block is and what every struct looks like; this is what turns
+ * those two tables into `mesh.int('totvert')` and `object.deref('data')`. Every accessor names a
+ * field rather than an offset, so a field that moved between Blender releases is found where the
+ * file says it is, and a field that does not exist in this file answers `has` false rather than
+ * reading whatever sits at an offset some other release used.
+ *
+ * **A missing field is a question, not an error.** Most of the reading above this module is
+ * "the new name if this file has it, the old one otherwise", so `has` is cheap and every typed
+ * accessor throws only when asked for a field the struct does not carry — which is a reader bug,
+ * and is said with the struct's name and the Blender version beside it.
+ */
+import { DrftError } from '@driftengine/drft';
+import { readBlendBlocks, readBlendHeader, readDna } from './blendFile.js';
+/** A parsed file: its blocks, its catalogue, and the maps from an address to a block. */
+export class BlendData {
+    header;
+    bytes;
+    view;
+    blocks;
+    structs;
+    byType = new Map();
+    /**
+     * Which datablock each block's data belongs to: the most recent block that is not `DATA`.
+     *
+     * **Addresses are only unique inside one datablock, and 5.0 relies on it.** Blender's own reader
+     * keeps one map for datablocks and a second, per datablock, for the data blocks that follow it,
+     * and 5.0 writes placeholder addresses that repeat between datablocks: measured on a 5.0 file,
+     * one address named eight different meshes' attribute arrays. A file-wide map answered every
+     * mesh with the last mesh's positions.
+     */
+    owner;
+    ids = new Map();
+    scoped = new Map();
+    sorted = new Map();
+    /** Before 5.0 every address was a real one, so a data pointer may be resolved file-wide. */
+    fileWide;
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        this.header = readBlendHeader(bytes);
+        this.blocks = readBlendBlocks(bytes, this.header);
+        const dna = this.blocks.find((block) => block.code === 'DNA1');
+        if (dna === undefined)
+            throw new DrftError('blend: the file carries no DNA1 catalogue');
+        this.structs = readDna(bytes, dna, this.header);
+        for (const struct of this.structs)
+            this.byType.set(struct.type, struct);
+        this.owner = new Int32Array(this.blocks.length);
+        this.fileWide = this.header.version < 500 ? new Map() : null;
+        let scope = -1;
+        this.blocks.forEach((block, i) => {
+            if (block.code !== 'DATA') {
+                scope = i;
+                if (block.address !== 0n)
+                    this.ids.set(block.address, i);
+            }
+            else if (block.address !== 0n) {
+                let map = this.scoped.get(scope);
+                if (map === undefined)
+                    this.scoped.set(scope, (map = new Map()));
+                map.set(block.address, i);
+                let list = this.sorted.get(scope);
+                if (list === undefined)
+                    this.sorted.set(scope, (list = []));
+                list.push(i);
+            }
+            this.owner[i] = block.code === 'DATA' ? scope : i;
+            if (this.fileWide !== null && block.address !== 0n)
+                this.fileWide.set(block.address, i);
+        });
+        for (const list of this.sorted.values()) {
+            list.sort((a, b) => {
+                const x = this.blocks[a].address;
+                const y = this.blocks[b].address;
+                return x < y ? -1 : x > y ? 1 : 0;
+            });
+        }
+    }
+    /** The catalogue entry for a struct type, or undefined where this file's Blender had none. */
+    struct(type) {
+        return this.byType.get(type);
+    }
+    /** The datablock a block's data belongs to, which is what scopes every pointer inside it. */
+    scopeOf(block) {
+        return this.owner[block] ?? -1;
+    }
+    /**
+     * The block an address falls in, and how far into it, as seen from inside datablock `scope`.
+     *
+     * The datablock's own data first, then the datablocks themselves, which is the order Blender's
+     * reader resolves in. Null for an address nothing holds.
+     */
+    find(address, scope) {
+        if (address === 0n)
+            return null;
+        const own = this.scoped.get(scope)?.get(address) ?? this.ids.get(address);
+        if (own !== undefined)
+            return { block: own, offset: 0 };
+        const list = this.sorted.get(scope);
+        if (list !== undefined) {
+            let lo = 0;
+            let hi = list.length - 1;
+            while (lo <= hi) {
+                const mid = (lo + hi) >> 1;
+                const index = list[mid];
+                const block = this.blocks[index];
+                if (block.address > address)
+                    hi = mid - 1;
+                else if (block.address + BigInt(block.length) <= address)
+                    lo = mid + 1;
+                else
+                    return { block: index, offset: Number(address - block.address) };
+            }
+        }
+        const anywhere = this.fileWide?.get(address);
+        return anywhere === undefined ? null : { block: anywhere, offset: 0 };
+    }
+    /** Every datablock of a two-letter code — `OB`, `ME`, `MA` — as views of their own struct. */
+    idsOf(code) {
+        const out = [];
+        this.blocks.forEach((block, i) => {
+            if (block.code !== code)
+                return;
+            const struct = this.structs[block.sdna];
+            if (struct !== undefined)
+                out.push(new BlendStruct(this, struct, block.offset, i));
+        });
+        return out;
+    }
+    /** A view of the struct at an address, typed by the block that holds it or by `type`. */
+    at(address, scope, type) {
+        const found = this.find(address, scope);
+        if (found === null)
+            return null;
+        const block = this.blocks[found.block];
+        const struct = type === undefined ? this.structs[block.sdna] : this.byType.get(type);
+        if (struct === undefined)
+            return null;
+        return new BlendStruct(this, struct, block.offset + found.offset, this.scopeOf(found.block));
+    }
+    /**
+     * The structs of an array a pointer names, indexed *inside* its block.
+     *
+     * **Never by adding to the address.** From 5.0 an address is a placeholder rather than a
+     * location, so `base + 24` is not the second element and can be exactly the address of some
+     * unrelated block.
+     */
+    array(address, scope, type, count) {
+        const found = this.find(address, scope);
+        const struct = this.byType.get(type);
+        if (found === null || struct === undefined)
+            return [];
+        const block = this.blocks[found.block];
+        const start = block.offset + found.offset;
+        const room = Math.floor((block.offset + block.length - start) / struct.size);
+        const n = Math.min(count ?? room, room);
+        const owner = this.scopeOf(found.block);
+        const out = [];
+        for (let i = 0; i < n; i++)
+            out.push(new BlendStruct(this, struct, start + i * struct.size, owner));
+        return out;
+    }
+    /** The raw bytes a pointer names, through the end of its block. */
+    raw(address, scope) {
+        const found = this.find(address, scope);
+        if (found === null)
+            return null;
+        const block = this.blocks[found.block];
+        return this.bytes.subarray(block.offset + found.offset, block.offset + block.length);
+    }
+    /** A zero-terminated string a `char *` names. */
+    text(address, scope) {
+        const raw = this.raw(address, scope);
+        if (raw === null)
+            return '';
+        const stop = raw.indexOf(0);
+        return new TextDecoder().decode(stop < 0 ? raw : raw.subarray(0, stop));
+    }
+    /** The block a pointer names, for its count and its catalogue type. */
+    blockOf(address, scope) {
+        const found = this.find(address, scope);
+        return found === null ? null : (this.blocks[found.block] ?? null);
+    }
+    pointer(at) {
+        const le = this.header.littleEndian;
+        return this.header.pointerSize === 8
+            ? this.view.getBigUint64(at, le)
+            : BigInt(this.view.getUint32(at, le));
+    }
+}
+/** One struct in the file, read by field name. */
+export class BlendStruct {
+    file;
+    struct;
+    offset;
+    scope;
+    constructor(file, struct, offset, 
+    /** The datablock this struct's data belongs to, which every pointer in it is resolved inside. */
+    scope) {
+        this.file = file;
+        this.struct = struct;
+        this.offset = offset;
+        this.scope = scope;
+    }
+    get type() {
+        return this.struct.type;
+    }
+    has(name) {
+        return this.struct.fields.has(name);
+    }
+    field(name) {
+        const field = this.struct.fields.get(name);
+        if (field === undefined) {
+            throw new DrftError(`blend: ${this.struct.type} has no field "${name}" in a file from Blender ` +
+                `${this.file.header.version}, which is a reader bug rather than a bad file`);
+        }
+        return field;
+    }
+    /** An integer field of any width, signed as its type is. */
+    int(name, index = 0) {
+        const field = this.field(name);
+        return readInt(this.file, field.type, this.offset + field.offset + index * elementSize(field));
+    }
+    float(name, index = 0) {
+        const field = this.field(name);
+        const at = this.offset + field.offset + index * elementSize(field);
+        const le = this.file.header.littleEndian;
+        return field.type === 'double'
+            ? this.file.view.getFloat64(at, le)
+            : this.file.view.getFloat32(at, le);
+    }
+    /** Every element of a float array field, flattened: `co[3]` is three, `mat[4][4]` sixteen. */
+    floats(name) {
+        const field = this.field(name);
+        const count = field.dims.reduce((n, d) => n * d, 1);
+        const out = [];
+        for (let i = 0; i < count; i++)
+            out.push(this.float(name, i));
+        return out;
+    }
+    ints(name) {
+        const field = this.field(name);
+        const count = field.dims.reduce((n, d) => n * d, 1);
+        const out = [];
+        for (let i = 0; i < count; i++)
+            out.push(this.int(name, i));
+        return out;
+    }
+    /** A `char[]` field as text, up to its first zero. */
+    string(name) {
+        const field = this.field(name);
+        const start = this.offset + field.offset;
+        const bytes = this.file.bytes.subarray(start, start + field.size);
+        const stop = bytes.indexOf(0);
+        return new TextDecoder().decode(stop < 0 ? bytes : bytes.subarray(0, stop));
+    }
+    /** An ID's name without its two-letter code: `OBCube` is `Cube`. */
+    idName() {
+        return this.sub('id').string('name').slice(2);
+    }
+    ptr(name, index = 0) {
+        const field = this.field(name);
+        if (!field.pointer)
+            throw new DrftError(`blend: ${this.struct.type}.${name} is not a pointer`);
+        return this.file.pointer(this.offset + field.offset + index * this.file.header.pointerSize);
+    }
+    /** Follow a pointer field, typed by the block it lands in or by `type` where that is known. */
+    deref(name, type) {
+        return this.file.at(this.ptr(name), this.scope, type);
+    }
+    /** An array a pointer field names, `count` long or as long as its block. */
+    array(name, type, count) {
+        return this.file.array(this.ptr(name), this.scope, type, count);
+    }
+    /** The bytes a pointer field names, through the end of their block. */
+    raw(name) {
+        return this.file.raw(this.ptr(name), this.scope);
+    }
+    /** The block a pointer field names. */
+    blockOf(name) {
+        return this.file.blockOf(this.ptr(name), this.scope);
+    }
+    /** A `char *` field's text. */
+    text(name) {
+        return this.file.text(this.ptr(name), this.scope);
+    }
+    /** An embedded struct field, viewed in place. */
+    sub(name) {
+        const field = this.field(name);
+        const struct = this.file.struct(field.type);
+        if (struct === undefined)
+            throw new DrftError(`blend: no struct ${field.type} in the catalogue`);
+        return new BlendStruct(this.file, struct, this.offset + field.offset, this.scope);
+    }
+    /** The links of a `ListBase` field, following `next` until it runs out. */
+    list(name, type) {
+        const base = this.sub(name);
+        const out = [];
+        const seen = new Set();
+        let address = base.ptr('first');
+        while (address !== 0n && !seen.has(address)) {
+            seen.add(address);
+            const link = this.file.at(address, this.scope, type);
+            if (link === null)
+                break;
+            out.push(link);
+            /* `next` is the first pointer of every link, including those that embed it in a header
+               struct of their own, as every modifier and constraint does. */
+            address = this.file.pointer(link.offset);
+        }
+        return out;
+    }
+    /** An array of pointers that a pointer-to-pointer field names: `Mesh.mat`, `Object.mat`. */
+    pointers(name, count) {
+        const raw = this.file.find(this.ptr(name), this.scope);
+        if (raw === null)
+            return [];
+        const out = [];
+        const base = this.file.blocks[raw.block].offset + raw.offset;
+        for (let i = 0; i < count; i++)
+            out.push(this.file.pointer(base + i * this.file.header.pointerSize));
+        return out;
+    }
+}
+function elementSize(field) {
+    const count = field.dims.reduce((n, d) => n * d, 1);
+    return field.size / count;
+}
+function readInt(file, type, at) {
+    const le = file.header.littleEndian;
+    const view = file.view;
+    switch (type) {
+        case 'char':
+        case 'uchar':
+        case 'uint8_t':
+        case 'bool':
+            return view.getUint8(at);
+        case 'int8_t':
+            return view.getInt8(at);
+        case 'short':
+        case 'int16_t':
+            return view.getInt16(at, le);
+        case 'ushort':
+        case 'uint16_t':
+            return view.getUint16(at, le);
+        case 'int':
+        case 'int32_t':
+            return view.getInt32(at, le);
+        case 'uint':
+        case 'uint32_t':
+            return view.getUint32(at, le);
+        case 'int64_t':
+        case 'long':
+            return Number(view.getBigInt64(at, le));
+        case 'uint64_t':
+        case 'ulong':
+            return Number(view.getBigUint64(at, le));
+        case 'float':
+            return view.getFloat32(at, le);
+        default:
+            throw new DrftError(`blend: no integer reading for a field of type ${type}`);
+    }
+}

package/dist/blendFile.d.ts

@@ -0,0 +1,69 @@
+/**
+ * A `.blend` file's container: its header, its blocks, and the catalogue of structures the file
+ * carries to describe its own layout.
+ *
+ * **The catalogue is what makes this readable at all.** Every `.blend` ends with a `DNA1` block
+ * listing each C struct the writing Blender knew — its fields, their types, their sizes — so a
+ * reader learns the layout *from the file* rather than hard-coding one Blender release. A mesh
+ * written by 2.79 and one written by 5.2 differ in nearly every struct, and both are read by the
+ * same code because neither is assumed.
+ *
+ * **Three container shapes are read, and anything else is refused by name.** The twelve-byte
+ * header every release before 5.0 wrote, with four- or eight-byte pointers and either byte order,
+ * and the seventeen-byte header 5.0 introduced, whose block headers carry 64-bit lengths. A file
+ * compressed with gzip (before 3.0) or zstd (3.0 on) is reported as such, and `readBlendFile`
+ * takes the decompressed bytes: decompressing is the host's capability, not this module's.
+ *
+ * What this gives up: a block whose pointer is not the start of a block is found by search, which
+ * is a binary search over every block. That is the cost of not assuming how Blender allocates.
+ */
+/** What the first bytes say, before any block is read. */
+export interface BlendHeader {
+    readonly pointerSize: 4 | 8;
+    readonly littleEndian: boolean;
+    /** The writing Blender's version, as the header spells it: 279, 405, 500. */
+    readonly version: number;
+    /** Bytes of header before the first block. */
+    readonly headerSize: number;
+    /** Bytes in each block header: 20, 24, or 32 for the 64-bit form 5.0 writes. */
+    readonly blockHeaderSize: number;
+}
+/** One block: a run of `count` structs of catalogue type `sdna`, at `offset` in the file. */
+export interface BlendBlock {
+    readonly code: string;
+    readonly sdna: number;
+    /** The address the struct had in the writing process, which every pointer to it names. */
+    readonly address: bigint;
+    readonly length: number;
+    readonly count: number;
+    readonly offset: number;
+}
+/** One field of a catalogued struct, with its offset already summed. */
+export interface DnaField {
+    /** The bare name: `*next` and `co[3]` are `next` and `co`. */
+    readonly name: string;
+    readonly type: string;
+    readonly offset: number;
+    readonly size: number;
+    readonly pointer: boolean;
+    /** Array dimensions, outermost first; empty for a scalar. */
+    readonly dims: readonly number[];
+}
+export interface DnaStruct {
+    readonly index: number;
+    readonly type: string;
+    readonly size: number;
+    readonly fields: ReadonlyMap<string, DnaField>;
+}
+/** Which compression, if any, a file's first bytes declare. */
+export type BlendCompression = 'gzip' | 'zstd' | null;
+/** The compression a `.blend` was saved with, by its magic, or null for a plain file. */
+export declare function blendCompression(bytes: Uint8Array): BlendCompression;
+/** Whether these bytes are an uncompressed `.blend`. */
+export declare function isBlend(bytes: Uint8Array): boolean;
+/** Parse the header, refusing any shape this module has not been taught. */
+export declare function readBlendHeader(bytes: Uint8Array): BlendHeader;
+/** Walk every block header up to `ENDB`. */
+export declare function readBlendBlocks(bytes: Uint8Array, header: BlendHeader): BlendBlock[];
+/** Parse the `DNA1` block into structs with every field's offset summed. */
+export declare function readDna(bytes: Uint8Array, block: BlendBlock, header: BlendHeader): DnaStruct[];

package/dist/blendFile.js

@@ -0,0 +1,182 @@
+/**
+ * A `.blend` file's container: its header, its blocks, and the catalogue of structures the file
+ * carries to describe its own layout.
+ *
+ * **The catalogue is what makes this readable at all.** Every `.blend` ends with a `DNA1` block
+ * listing each C struct the writing Blender knew — its fields, their types, their sizes — so a
+ * reader learns the layout *from the file* rather than hard-coding one Blender release. A mesh
+ * written by 2.79 and one written by 5.2 differ in nearly every struct, and both are read by the
+ * same code because neither is assumed.
+ *
+ * **Three container shapes are read, and anything else is refused by name.** The twelve-byte
+ * header every release before 5.0 wrote, with four- or eight-byte pointers and either byte order,
+ * and the seventeen-byte header 5.0 introduced, whose block headers carry 64-bit lengths. A file
+ * compressed with gzip (before 3.0) or zstd (3.0 on) is reported as such, and `readBlendFile`
+ * takes the decompressed bytes: decompressing is the host's capability, not this module's.
+ *
+ * What this gives up: a block whose pointer is not the start of a block is found by search, which
+ * is a binary search over every block. That is the cost of not assuming how Blender allocates.
+ */
+import { DrftError } from '@driftengine/drft';
+/** The compression a `.blend` was saved with, by its magic, or null for a plain file. */
+export function blendCompression(bytes) {
+    if (bytes.length >= 2 && bytes[0] === 0x1f && bytes[1] === 0x8b)
+        return 'gzip';
+    if (bytes.length >= 4 && bytes[0] === 0x28 && bytes[1] === 0xb5 && bytes[2] === 0x2f) {
+        return bytes[3] === 0xfd ? 'zstd' : null;
+    }
+    return null;
+}
+/** Whether these bytes are an uncompressed `.blend`. */
+export function isBlend(bytes) {
+    const magic = 'BLENDER';
+    if (bytes.length < 12)
+        return false;
+    for (let i = 0; i < magic.length; i++)
+        if (bytes[i] !== magic.charCodeAt(i))
+            return false;
+    return true;
+}
+const ascii = (bytes, at, length) => String.fromCharCode(...bytes.subarray(at, at + length));
+/** Parse the header, refusing any shape this module has not been taught. */
+export function readBlendHeader(bytes) {
+    if (!isBlend(bytes)) {
+        const packed = blendCompression(bytes);
+        throw new DrftError(packed === null
+            ? 'blend: not a .blend file (no BLENDER magic)'
+            : `blend: this file is ${packed}-compressed and must be decompressed before it is read`);
+    }
+    const seventh = String.fromCharCode(bytes[7] ?? 0);
+    if (seventh === '-' || seventh === '_') {
+        const endian = String.fromCharCode(bytes[8] ?? 0);
+        if (endian !== 'v' && endian !== 'V')
+            throw new DrftError(`blend: byte order "${endian}"`);
+        const pointerSize = seventh === '-' ? 8 : 4;
+        return {
+            pointerSize,
+            littleEndian: endian === 'v',
+            version: Number(ascii(bytes, 9, 3)),
+            headerSize: 12,
+            blockHeaderSize: pointerSize === 8 ? 24 : 20,
+        };
+    }
+    /* 5.0 on: `BLENDER` + header size + `-` + file format version + byte order + four digits. */
+    const headerSize = Number(ascii(bytes, 7, 2));
+    const format = Number(ascii(bytes, 10, 2));
+    const endian = String.fromCharCode(bytes[12] ?? 0);
+    if (headerSize !== 17 ||
+        bytes[9] !== 0x2d ||
+        format !== 1 ||
+        (endian !== 'v' && endian !== 'V')) {
+        throw new DrftError(`blend: header "${ascii(bytes, 0, 17)}" is a container layout this reader does not know`);
+    }
+    return {
+        pointerSize: 8,
+        littleEndian: endian === 'v',
+        version: Number(ascii(bytes, 13, 4)),
+        headerSize,
+        blockHeaderSize: 32,
+    };
+}
+/** Walk every block header up to `ENDB`. */
+export function readBlendBlocks(bytes, header) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const le = header.littleEndian;
+    const blocks = [];
+    let at = header.headerSize;
+    while (at + header.blockHeaderSize <= bytes.length) {
+        const code = ascii(bytes, at, 4).replace(/\0+$/, '');
+        let length;
+        let address;
+        let sdna;
+        let count;
+        if (header.blockHeaderSize === 32) {
+            sdna = view.getInt32(at + 4, le);
+            address = view.getBigUint64(at + 8, le);
+            length = Number(view.getBigInt64(at + 16, le));
+            count = Number(view.getBigInt64(at + 24, le));
+        }
+        else {
+            length = view.getInt32(at + 4, le);
+            address =
+                header.pointerSize === 8
+                    ? view.getBigUint64(at + 8, le)
+                    : BigInt(view.getUint32(at + 8, le));
+            const rest = at + 8 + header.pointerSize;
+            sdna = view.getInt32(rest, le);
+            count = view.getInt32(rest + 4, le);
+        }
+        if (code === 'ENDB')
+            return blocks;
+        const offset = at + header.blockHeaderSize;
+        if (length < 0 || offset + length > bytes.length) {
+            throw new DrftError(`blend: block "${code}" at ${at} runs past the end of the file`);
+        }
+        blocks.push({ code, sdna, address, length, count, offset });
+        at = offset + length;
+    }
+    throw new DrftError('blend: the file ends before its ENDB block, so it was not saved completely');
+}
+/** Parse the `DNA1` block into structs with every field's offset summed. */
+export function readDna(bytes, block, header) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const le = header.littleEndian;
+    let at = block.offset;
+    const end = block.offset + block.length;
+    const expect = (tag) => {
+        at = block.offset + Math.ceil((at - block.offset) / 4) * 4;
+        if (ascii(bytes, at, 4) !== tag)
+            throw new DrftError(`blend: DNA1 has no ${tag} section`);
+        at += 4;
+    };
+    const strings = () => {
+        const count = view.getInt32(at, le);
+        at += 4;
+        const out = [];
+        for (let i = 0; i < count; i++) {
+            const stop = bytes.indexOf(0, at);
+            if (stop < 0 || stop >= end)
+                throw new DrftError('blend: DNA1 string table is truncated');
+            out.push(ascii(bytes, at, stop - at));
+            at = stop + 1;
+        }
+        return out;
+    };
+    expect('SDNA');
+    expect('NAME');
+    const names = strings();
+    expect('TYPE');
+    const types = strings();
+    expect('TLEN');
+    const lengths = [];
+    for (let i = 0; i < types.length; i++)
+        lengths.push(view.getInt16(at + i * 2, le));
+    at += types.length * 2;
+    expect('STRC');
+    const count = view.getInt32(at, le);
+    at += 4;
+    const structs = [];
+    for (let s = 0; s < count; s++) {
+        const typeIndex = view.getInt16(at, le);
+        const fieldCount = view.getInt16(at + 2, le);
+        at += 4;
+        const fields = new Map();
+        let offset = 0;
+        for (let f = 0; f < fieldCount; f++) {
+            const typeOf = view.getInt16(at, le);
+            const type = types[typeOf] ?? '';
+            const raw = names[view.getInt16(at + 2, le)] ?? '';
+            at += 4;
+            const pointer = raw.startsWith('*') || raw.startsWith('(*');
+            const dims = [...raw.matchAll(/\[(\d+)\]/g)].map((m) => Number(m[1]));
+            const element = pointer ? header.pointerSize : (lengths[typeOf] ?? 0);
+            const size = dims.reduce((n, d) => n * d, element);
+            const name = raw.replace(/^[(*]+/, '').replace(/[)[].*$/, '');
+            fields.set(name, { name, type, offset, size, pointer, dims });
+            offset += size;
+        }
+        const type = types[typeIndex] ?? '';
+        structs.push({ index: s, type, size: lengths[typeIndex] ?? offset, fields });
+    }
+    return structs;
+}

package/dist/blendGeometry.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A `.blend` mesh as triangle primitives, one per material slot, in glTF's conventions.
+ *
+ * **The same conversion serves every route out of a `.blend`.** `blendGltf.ts` writes these into a
+ * glTF document for `readModel`, and a bake that keeps a world's instancing calls this once per
+ * distinct mesh rather than once per object. So what a corner becomes — its position turned Y up,
+ * its UV flipped to glTF's origin, its colour linear — is decided here and nowhere else.
+ *
+ * **Vertices are shared where every attribute agrees exactly**, which is how Blender's exporter
+ * builds them, found by walking the exported copies of each source vertex rather than by hashing,
+ * so a fifty-million-corner city costs a scan rather than fifty million string keys.
+ *
+ * **Faces are triangulated as Blender does it**: a quad split from its first corner, an ngon by ear
+ * clipping in its own plane. Blender clips ears in a different order, so an ngon's diagonals can
+ * differ from Blender's; on a planar face that changes no pixel, on a bent one it changes the bend.
+ */
+import type { BlendMeshData } from './blendMesh.ts';
+/** What a material slot asks of the geometry that wears it. */
+export interface SlotNeeds {
+    /** Which colour attribute to carry as `COLOR_0`: a name, `''` for the render one, or null. */
+    readonly vertexColor: string | null;
+    /** Which UV map to carry as `TEXCOORD_0`, by name, or null for the render map. */
+    readonly uvMap: string | null;
+    /** A 3x3 affine transform applied to that map in Blender's UV space, or null. */
+    readonly uvTransform: readonly number[] | null;
+}
+export interface BlendPrimitive {
+    /** The material slot, or -1 where the object has none. */
+    readonly slot: number;
+    readonly positions: Float32Array;
+    readonly normals: Float32Array;
+    readonly uvs: Float32Array | null;
+    readonly colors: Float32Array | null;
+    readonly indices: Uint32Array;
+    /** The source vertex each exported vertex came from, for shape keys and weights. */
+    readonly sourceVertex: Int32Array;
+    /** The source corner each exported vertex first came from, for per-corner shape normals. */
+    readonly sourceCorner: Int32Array;
+}
+/** Blender Z up to glTF Y up: (x, y, z) becomes (x, z, -y). */
+export declare function toYUp(out: Float32Array, at: number, x: number, y: number, z: number): void;
+/** Triangles of one face, as corner indices, appended to `out`. */
+export declare function triangulateFace(mesh: BlendMeshData, face: number, normal: readonly number[], out: number[]): void;
+/** Split a mesh into one primitive per material slot it uses. */
+export declare function meshPrimitives(mesh: BlendMeshData, normals: Float32Array, slots: number, needs: (slot: number) => SlotNeeds): BlendPrimitive[];