@ludic-labs/assembly 0.0.0-stage → 0.4.0

package/dist/diagnostics.d.ts

@@ -0,0 +1,5 @@
+import type { Diagnostic } from "./types.js";
+export declare class AssetCompileError extends Error {
+    readonly diagnostics: Diagnostic[];
+    constructor(diagnostics: Diagnostic[]);
+}

package/dist/diagnostics.js

@@ -0,0 +1,8 @@
+export class AssetCompileError extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+        super(diagnostics.map((d) => `${d.code} ${d.path}: ${d.message}`).join("\n"));
+        this.diagnostics = diagnostics;
+        this.name = "AssetCompileError";
+    }
+}

package/dist/export.d.ts

@@ -0,0 +1,54 @@
+import type { Bounds, CompiledAsset, Vec3 } from "./types.js";
+/** Version of the GLB layout and metadata written by `exportGLB`. */
+export declare const GLB_EXPORT_VERSION = 1;
+/** One compiled asset placed in an exported scene, e.g. a posed character and the chair it sits on. */
+export interface SceneItem {
+    asset: CompiledAsset;
+    /** sRGB `#rrggbb` accent for tintable materials. */
+    tint?: string;
+    /** Translation in the asset frame. */
+    offset?: Vec3;
+    /** Node name. Defaults to `asset`, or `asset/<n>` when the scene has several items. */
+    name?: string;
+}
+export type Scene = CompiledAsset | SceneItem | readonly SceneItem[];
+export interface GLBOptions {
+    /** Name of the scene and its root node (default `ludic-assembly`). */
+    name?: string;
+}
+export interface SceneView {
+    /** Square image size in pixels, 64–2048 (default 1024). */
+    size?: number;
+    /** Camera yaw and pitch in radians, as in `createPreview` (default: the preview's front-right view). */
+    yaw?: number;
+    pitch?: number;
+    /** Supersampling per axis, 1–4 (default 2). */
+    samples?: number;
+    /** World bounds to frame instead of the scene geometry, e.g. a close-up. */
+    fit?: Bounds;
+    /** Transparent margin on each side in pixels (default size / 22.5, rounded). */
+    padding?: number;
+}
+export interface SceneImage {
+    width: number;
+    height: number;
+    /** Straight (unpremultiplied) RGBA bytes, row-major from the top-left; the background is transparent. */
+    color: Uint8Array;
+}
+/**
+ * Experimental. Serialize a static scene as binary glTF 2.0 (GLB). The same scene always produces the
+ * same bytes: no timestamps or library versions are written.
+ *
+ * Each instance becomes a node and mesh named by its stable ID, with one material per asset material.
+ * Vertex colors are stored untinted in `COLOR_0`; a tintable material carries the tint as its
+ * `baseColorFactor`, which glTF multiplies with the vertex color. Geometry keeps the asset frame
+ * (+X right, +Y up, −Z front). A root node turns it 180° about +Y so the asset faces glTF's +Z front.
+ * Positions, normals and colors are stored as 32-bit floats. Units are recorded in `asset.extras` and
+ * never converted. Joints and clips are not exported: pass `poseAsset(…)` to export one frame.
+ */
+export declare function exportGLB(scene: Scene, options?: GLBOptions): Uint8Array;
+/**
+ * Experimental. Bake a square, transparent image of a scene with the CPU rasterizer used by previews,
+ * framed to its geometry or to `fit`. Pixel bytes are deterministic; image encoding belongs to the caller.
+ */
+export declare function bakeScene(scene: Scene, view?: SceneView): SceneImage;

package/dist/export.js

@@ -0,0 +1,272 @@
+import { requireValue } from "./required.js";
+import { appendMesh, emptyMesh, meshForAsset } from "./mesh.js";
+import { linear } from "./compat.js";
+import { bakeMesh } from "./bake.js";
+import { cross, dot, normalize } from "./math.js";
+/** Version of the GLB layout and metadata written by `exportGLB`. */
+export const GLB_EXPORT_VERSION = 1;
+const DEFAULT_YAW = Math.atan2(24, -26), DEFAULT_PITCH = Math.atan2(28, Math.hypot(24, 26));
+const hex = /^#[0-9a-fA-F]{6}$/;
+const ARRAY_BUFFER = 34962, ELEMENT_ARRAY_BUFFER = 34963, FLOAT = 5126, UNSIGNED_SHORT = 5123, UNSIGNED_INT = 5125;
+function items(scene) {
+    const list = Array.isArray(scene)
+        ? scene
+        : "layers" in scene
+            ? [{ asset: scene }]
+            : [scene];
+    if (!list.length)
+        throw new RangeError("Export requires at least one asset");
+    for (const item of list) {
+        if (!item || typeof item !== "object" || !item.asset || typeof item.asset.layers !== "object")
+            throw new TypeError("Export items require a compiled asset");
+        if (item.tint !== undefined && !hex.test(item.tint))
+            throw new RangeError("Tint must be #rrggbb");
+        if (item.offset !== undefined &&
+            (!Array.isArray(item.offset) || item.offset.length !== 3 || !item.offset.every(Number.isFinite)))
+            throw new RangeError("Offsets must be three finite numbers");
+    }
+    if (new Set(list.map((item) => item.asset.units)).size > 1)
+        throw new RangeError("Exported assets must share units; units are never converted");
+    return [...list];
+}
+/** Named meshes of one asset: an instance each, or a layer each for meshes without instances. */
+function pieces(asset) {
+    const list = asset.instances.length
+        ? asset.instances.map((i) => ({ name: i.id, material: i.material, mesh: i.mesh }))
+        : Object.entries(asset.layers).map(([material, mesh]) => ({ name: material, material, mesh }));
+    return list.filter((piece) => piece.mesh.indices.length > 0);
+}
+/** Linear-space accent, rounded so that last-digit differences between engines cannot reach the file. */
+const baseColor = (tint) => [
+    ...[1, 3, 5].map((i) => Math.round(linear(parseInt(tint.slice(i, i + 2), 16)) * 1e6) / 1e6),
+    1,
+];
+/**
+ * Experimental. Serialize a static scene as binary glTF 2.0 (GLB). The same scene always produces the
+ * same bytes: no timestamps or library versions are written.
+ *
+ * Each instance becomes a node and mesh named by its stable ID, with one material per asset material.
+ * Vertex colors are stored untinted in `COLOR_0`; a tintable material carries the tint as its
+ * `baseColorFactor`, which glTF multiplies with the vertex color. Geometry keeps the asset frame
+ * (+X right, +Y up, −Z front). A root node turns it 180° about +Y so the asset faces glTF's +Z front.
+ * Positions, normals and colors are stored as 32-bit floats. Units are recorded in `asset.extras` and
+ * never converted. Joints and clips are not exported: pass `poseAsset(…)` to export one frame.
+ */
+export function exportGLB(scene, options = {}) {
+    const list = items(scene), name = options.name ?? "ludic-assembly";
+    if (typeof name !== "string")
+        throw new TypeError("Export name must be a string");
+    const chunks = [];
+    let byteLength = 0;
+    const bufferViews = [], accessors = [], meshes = [], materials = [], nodes = [{ name, rotation: [0, 1, 0, 0], children: [] }];
+    const view = (bytes, target) => {
+        chunks.push(bytes);
+        bufferViews.push({ buffer: 0, byteOffset: byteLength, byteLength: bytes.byteLength, target });
+        byteLength += bytes.byteLength;
+        const pad = (4 - (byteLength % 4)) % 4;
+        if (pad) {
+            chunks.push(new Uint8Array(pad));
+            byteLength += pad;
+        }
+        return bufferViews.length - 1;
+    };
+    const floats = (values, withBounds) => {
+        const data = new Float32Array(values.length), bytes = new Uint8Array(values.length * 4), dv = new DataView(bytes.buffer);
+        for (let i = 0; i < values.length; i++) {
+            if (!Number.isFinite(values[i]))
+                throw new RangeError("Export requires finite geometry");
+            data[i] = requireValue(values[i]);
+            dv.setFloat32(i * 4, requireValue(values[i]), true);
+        }
+        const accessor = {
+            bufferView: view(bytes, ARRAY_BUFFER),
+            componentType: FLOAT,
+            count: data.length / 3,
+            type: "VEC3",
+        };
+        if (withBounds) {
+            const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+            for (let i = 0; i < data.length; i++) {
+                min[i % 3] = Math.min(requireValue(min[i % 3]), requireValue(data[i]));
+                max[i % 3] = Math.max(requireValue(max[i % 3]), requireValue(data[i]));
+            }
+            accessor.min = min;
+            accessor.max = max;
+        }
+        accessors.push(accessor);
+        return accessors.length - 1;
+    };
+    let primitives = 0;
+    for (const [index, item] of list.entries()) {
+        const asset = item.asset, itemName = item.name ?? (list.length > 1 ? `asset/${index}` : "asset"), materialIndex = new Map(), children = [];
+        const extras = { schema: asset.schema, sourceHash: asset.sourceHash };
+        if (asset.identity)
+            extras.identity = asset.identity;
+        if (asset.slots)
+            extras.slots = asset.slots;
+        if (asset.pose)
+            extras.pose = asset.pose;
+        if (item.tint)
+            extras.tint = item.tint.toLowerCase();
+        const node = { name: itemName };
+        if (item.offset?.some((v) => v !== 0))
+            node.translation = [...item.offset];
+        node.children = children;
+        node.extras = extras;
+        nodes.push(node);
+        requireValue(nodes[0]).children.push(nodes.length - 1);
+        for (const piece of pieces(asset)) {
+            const { positions, normals, colors, indices } = piece.mesh, count = positions.length / 3;
+            if (!Number.isInteger(count) ||
+                normals.length !== positions.length ||
+                colors.length !== positions.length ||
+                indices.length % 3 ||
+                indices.some((i) => !Number.isInteger(i) || i < 0 || i >= count))
+                throw new RangeError(`Mesh ${piece.name} has inconsistent attributes`);
+            if (!materialIndex.has(piece.material)) {
+                const tintable = asset.materials[piece.material]?.tintable === true;
+                materials.push({
+                    name: list.length > 1 ? `${itemName}/${piece.material}` : piece.material,
+                    pbrMetallicRoughness: {
+                        baseColorFactor: tintable && item.tint ? baseColor(item.tint) : [1, 1, 1, 1],
+                        metallicFactor: 0,
+                        roughnessFactor: 1,
+                    },
+                    extras: { tintable },
+                });
+                materialIndex.set(piece.material, materials.length - 1);
+            }
+            const position = floats(positions, true), normal = floats(normals, false), color = floats(colors, false);
+            // The largest index value of a component type is reserved (glTF 2.0, 3.7.2.1).
+            const wide = count > 65535, width = wide ? 4 : 2, bytes = new Uint8Array(indices.length * width), dv = new DataView(bytes.buffer);
+            for (let i = 0; i < indices.length; i++)
+                if (wide)
+                    dv.setUint32(i * 4, requireValue(indices[i]), true);
+                else
+                    dv.setUint16(i * 2, requireValue(indices[i]), true);
+            accessors.push({
+                bufferView: view(bytes, ELEMENT_ARRAY_BUFFER),
+                componentType: wide ? UNSIGNED_INT : UNSIGNED_SHORT,
+                count: indices.length,
+                type: "SCALAR",
+            });
+            meshes.push({
+                name: piece.name,
+                primitives: [
+                    {
+                        attributes: { POSITION: position, NORMAL: normal, COLOR_0: color },
+                        indices: accessors.length - 1,
+                        material: materialIndex.get(piece.material),
+                    },
+                ],
+            });
+            // Some importers sanitize names (three.js drops "/"); extras keep the exact stable ID.
+            nodes.push({ name: piece.name, mesh: meshes.length - 1, extras: { id: piece.name } });
+            children.push(nodes.length - 1);
+            primitives++;
+        }
+    }
+    if (!primitives)
+        throw new RangeError("Export requires nonempty geometry");
+    const json = {
+        asset: {
+            version: "2.0",
+            generator: "Ludic Assembly",
+            extras: {
+                export: GLB_EXPORT_VERSION,
+                units: requireValue(list[0]).asset.units,
+                frame: "+X right, +Y up, -Z front",
+            },
+        },
+        scene: 0,
+        scenes: [{ name, nodes: [0] }],
+        nodes,
+        meshes,
+        materials,
+        accessors,
+        bufferViews,
+        buffers: [{ byteLength }],
+    };
+    const text = new TextEncoder().encode(JSON.stringify(json)), jsonLength = Math.ceil(text.length / 4) * 4, total = 12 + 8 + jsonLength + 8 + byteLength, out = new Uint8Array(total), dv = new DataView(out.buffer);
+    dv.setUint32(0, 0x46546c67, true);
+    dv.setUint32(4, 2, true);
+    dv.setUint32(8, total, true);
+    dv.setUint32(12, jsonLength, true);
+    dv.setUint32(16, 0x4e4f534a, true);
+    out.set(text, 20);
+    out.fill(0x20, 20 + text.length, 20 + jsonLength);
+    let at = 20 + jsonLength;
+    dv.setUint32(at, byteLength, true);
+    dv.setUint32(at + 4, 0x004e4942, true);
+    at += 8;
+    for (const chunk of chunks) {
+        out.set(chunk, at);
+        at += chunk.byteLength;
+    }
+    return out;
+}
+/**
+ * Experimental. Bake a square, transparent image of a scene with the CPU rasterizer used by previews,
+ * framed to its geometry or to `fit`. Pixel bytes are deterministic; image encoding belongs to the caller.
+ */
+export function bakeScene(scene, view = {}) {
+    const list = items(scene), size = view.size ?? 1024, samples = view.samples ?? 2, padding = view.padding ?? Math.round(size / 22.5), yaw = view.yaw ?? DEFAULT_YAW, pitch = view.pitch ?? DEFAULT_PITCH;
+    if (!Number.isInteger(size) || size < 64 || size > 2048)
+        throw new RangeError("Scene images are 64–2048 pixels");
+    if (!Number.isInteger(samples) || samples < 1 || samples > 4)
+        throw new RangeError("Samples must be an integer 1–4");
+    if (!Number.isInteger(padding) || padding < 0 || padding * 2 >= size)
+        throw new RangeError("Padding must leave room for the image");
+    if (!Number.isFinite(yaw) || !Number.isFinite(pitch))
+        throw new RangeError("Camera must be finite");
+    const mesh = emptyMesh();
+    for (const item of list)
+        appendMesh(mesh, meshForAsset(item.asset, item.tint), item.offset ?? [0, 0, 0]);
+    if (!mesh.indices.length)
+        throw new RangeError("Export requires nonempty geometry");
+    const back = [Math.sin(yaw) * Math.cos(pitch), Math.sin(pitch), Math.cos(yaw) * Math.cos(pitch)], right = normalize(cross([0, 1, 0], back)), basis = { back, right, up: cross(back, right) };
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    const extend = (p) => {
+        const x = dot(p, right), y = dot(p, basis.up);
+        minX = Math.min(minX, x);
+        maxX = Math.max(maxX, x);
+        minY = Math.min(minY, y);
+        maxY = Math.max(maxY, y);
+    };
+    const fit = view.fit;
+    if (fit) {
+        if (![...fit.min, ...fit.max].every(Number.isFinite))
+            throw new RangeError("Fit bounds must be finite");
+        for (const x of [fit.min[0], fit.max[0]])
+            for (const y of [fit.min[1], fit.max[1]])
+                for (const z of [fit.min[2], fit.max[2]])
+                    extend([x, y, z]);
+    }
+    else
+        for (let i = 0; i < mesh.positions.length; i += 3)
+            extend(mesh.positions.slice(i, i + 3));
+    const extent = Math.max(maxX - minX, maxY - minY);
+    if (!Number.isFinite(extent) || extent <= 0)
+        throw new RangeError("Scene requires nonempty bounds");
+    const ppu = (size - padding * 2) / extent, viewport = fit
+        ? {
+            left: -Math.round((size - (maxX - minX) * ppu) / 2 - minX * ppu),
+            top: Math.round((size - (maxY - minY) * ppu) / 2 + maxY * ppu),
+            width: size,
+            height: size,
+        }
+        : null, frame = bakeMesh(mesh, ppu, samples, basis, viewport), ox = viewport ? Math.round(frame.left * ppu) - viewport.left : Math.floor((size - frame.width) / 2), oy = viewport ? viewport.top - Math.round(frame.top * ppu) : Math.floor((size - frame.height) / 2), color = new Uint8Array(size * size * 4);
+    for (let y = 0; y < frame.height; y++) {
+        const py = oy + y;
+        if (py < 0 || py >= size)
+            continue;
+        for (let x = 0; x < frame.width; x++) {
+            const px = ox + x;
+            if (px < 0 || px >= size)
+                continue;
+            const from = (x + y * frame.width) * 4;
+            color.set(frame.color.subarray(from, from + 4), (px + py * size) * 4);
+        }
+    }
+    return { width: size, height: size, color };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type * from "./types.js";
+export { SCHEMA, SCHEMA_V2, SCHEMA_V3, MAX_ARRAY_COUNT, ANCHORS, AXES, AssetCompileError, compileAsset, validateAsset, } from "./compiler.js";
+export { appendMesh, emptyMesh, meshBounds, validateMesh, canonicalJSON, sourceHash, meshForAsset, } from "./mesh.js";
+export { MOTION_SCHEMA, CONTACT_TOLERANCE, SLIP_TOLERANCE, VERIFICATION_SAMPLES, MEASURED_CODES, compileMotion, checkMotion, validateMotion, samplePose, poseAsset, posedMesh, seatOn, } from "./motion.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { SCHEMA, SCHEMA_V2, SCHEMA_V3, MAX_ARRAY_COUNT, ANCHORS, AXES, AssetCompileError, compileAsset, validateAsset, } from "./compiler.js";
+export { appendMesh, emptyMesh, meshBounds, validateMesh, canonicalJSON, sourceHash, meshForAsset, } from "./mesh.js";
+export { MOTION_SCHEMA, CONTACT_TOLERANCE, SLIP_TOLERANCE, VERIFICATION_SAMPLES, MEASURED_CODES, compileMotion, checkMotion, validateMotion, samplePose, poseAsset, posedMesh, seatOn, } from "./motion.js";

package/dist/legacy.d.ts

@@ -0,0 +1,36 @@
+import type { Axis, CompiledAsset, MeshData, Vec3 } from "./types.js";
+/** How one legacy per-vertex joint ID maps onto a schema 0.2 joint. */
+export interface LegacyJointMapping {
+    id: string;
+    /**
+     * Map two legacy IDs onto one sided joint `<id>/left` and `<id>/right` (right axes mirrored, as in
+     * schema 0.2). Both entries must declare the same parent, pivot kind and DOFs.
+     */
+    side?: "left" | "right";
+    parent?: string;
+    /**
+     * `height` places the hinge line at Y = `mesh.rigPivots[height]`, Z = 0 (the legacy convention);
+     * X is the joint's vertex bounds center. `position` gives the left or unsided pivot explicitly.
+     */
+    pivot: {
+        height: 0 | 1;
+    } | {
+        position: Vec3;
+    };
+    dofs: {
+        name: string;
+        axis: Axis;
+        limits: [number, number];
+    }[];
+}
+export interface LegacyRig {
+    units?: "meters" | "tiles";
+    /** Every legacy joint ID present in the mesh must be listed; null keeps its vertices static. */
+    joints: Record<number, LegacyJointMapping | null>;
+}
+/**
+ * Wrap a compatibility mesh that carries per-vertex `joints` (and optionally `rigPivots`) as a rigged
+ * schema 0.2 compilation, so motion sets, sampling, posing, previews and bakes apply to it.
+ * The host owns the mapping: what each legacy joint ID and pivot height means is host knowledge.
+ */
+export declare function fromLegacyRig(mesh: MeshData, rig: LegacyRig): CompiledAsset;

package/dist/legacy.js

@@ -0,0 +1,180 @@
+import { requireValue } from "./required.js";
+import { AssetCompileError } from "./diagnostics.js";
+import { appendMesh, emptyMesh, meshBounds, sourceHash } from "./mesh.js";
+const AXES = {
+    "+x": [1, 0, 0],
+    "-x": [-1, 0, 0],
+    "+y": [0, 1, 0],
+    "-y": [0, -1, 0],
+    "+z": [0, 0, 1],
+    "-z": [0, 0, -1],
+};
+/**
+ * Wrap a compatibility mesh that carries per-vertex `joints` (and optionally `rigPivots`) as a rigged
+ * schema 0.2 compilation, so motion sets, sampling, posing, previews and bakes apply to it.
+ * The host owns the mapping: what each legacy joint ID and pivot height means is host knowledge.
+ */
+export function fromLegacyRig(mesh, rig) {
+    const fail = (code, path, message, extra = {}) => {
+        throw new AssetCompileError([{ code, path, message, ...extra }]);
+    };
+    if (!mesh.joints || mesh.joints.length !== mesh.positions.length / 3)
+        fail("UNRIGGED_ASSET", "/joints", "The mesh needs one legacy joint ID per vertex.");
+    const mapped = Object.keys(rig.joints).map(Number), declared = new Map(), refs = new Map();
+    for (const key of mapped) {
+        const m = rig.joints[key];
+        if (!m)
+            continue;
+        const path = `/joints/${key}`, ref = m.side ? `${m.id}/${m.side}` : m.id;
+        if (!/^[A-Za-z][A-Za-z0-9_-]{0,79}$/.test(m.id))
+            fail("SCHEMA_ERROR", `${path}/id`, "Invalid joint ID.");
+        if (m.id === "static" || [...refs.values()].includes(ref))
+            fail("DUPLICATE_NAME", `${path}/id`, "Each joint and side is mapped once; static is reserved.");
+        if (!m.dofs.length || m.dofs.length > 3)
+            fail("SCHEMA_ERROR", `${path}/dofs`, "Expected 1–3 DOFs.");
+        m.dofs.forEach((d, i) => {
+            if (!Object.hasOwn(AXES, d.axis))
+                fail("UNKNOWN_AXIS", `${path}/dofs/${i}/axis`, "Choose a signed axis.", {
+                    received: d.axis,
+                    expected: Object.keys(AXES),
+                });
+            const [lo, hi] = d.limits;
+            if (!(lo < hi) || lo > 0 || hi < 0 || lo < -360 || hi > 360)
+                fail("JOINT_LIMIT", `${path}/dofs/${i}/limits`, "Limits must contain the rest value 0.", {
+                    received: d.limits,
+                });
+        });
+        if ("height" in m.pivot && !mesh.rigPivots)
+            fail("SCHEMA_ERROR", `${path}/pivot`, "Height pivots need mesh.rigPivots.");
+        const other = declared.get(m.id);
+        if (other) {
+            const shape = (x) => JSON.stringify([x.parent, "height" in x.pivot ? "height" : "position", x.dofs, !!x.side]);
+            if (!m.side || !other.side || shape(other) !== shape(m))
+                fail("SCHEMA_ERROR", path, "Two legacy IDs share a joint only as its left and right sides, with the same parent, pivot kind and DOFs.");
+        }
+        else
+            declared.set(m.id, m);
+        refs.set(key, ref);
+    }
+    for (const [id, m] of declared) {
+        if (m.side && ![...refs.values()].includes(`${id}/${m.side === "left" ? "right" : "left"}`))
+            fail("SCHEMA_ERROR", "/joints", `Sided joint ${id} needs both a left and a right legacy ID.`);
+        if (m.parent !== undefined && !declared.has(m.parent))
+            fail("UNKNOWN_JOINT", "/joints", "Unknown parent joint.", {
+                received: m.parent,
+                expected: [...declared.keys()].sort(),
+            });
+    }
+    // Group triangles by legacy joint ID, preserving triangle order.
+    const groups = new Map();
+    for (let t = 0; t < mesh.indices.length; t += 3) {
+        const legacy = requireValue(requireValue(mesh.joints)[requireValue(mesh.indices[t])]);
+        if (!Object.hasOwn(rig.joints, legacy))
+            fail("UNKNOWN_JOINT", "/joints", `Legacy joint ID ${legacy} is present in the mesh but not mapped.`, {
+                received: legacy,
+                expected: mapped.map(String),
+            });
+        const id = refs.get(legacy) ?? "static";
+        if (!groups.has(id))
+            groups.set(id, { legacy, triangles: [] });
+        requireValue(groups.get(id)).triangles.push(t);
+    }
+    const instances = [];
+    for (const [id, group] of [...groups].sort(([a], [b]) => (a < b ? -1 : 1))) {
+        const out = { positions: [], normals: [], colors: [], indices: [] }, remap = new Map();
+        for (const t of group.triangles)
+            for (const index of mesh.indices.slice(t, t + 3)) {
+                if (!remap.has(index)) {
+                    remap.set(index, remap.size);
+                    out.positions.push(...mesh.positions.slice(index * 3, index * 3 + 3));
+                    out.normals.push(...mesh.normals.slice(index * 3, index * 3 + 3));
+                    out.colors.push(...mesh.colors.slice(index * 3, index * 3 + 3));
+                }
+                out.indices.push(requireValue(remap.get(index)));
+            }
+        const bounds = meshBounds(out), c = bounds.min.map((v, i) => (v + requireValue(bounds.max[i])) / 2);
+        instances.push({
+            id,
+            part: requireValue(id.split("/")[0]),
+            material: "legacy",
+            translation: [0, 0, 0],
+            bounds,
+            anchors: {
+                center: c,
+                "top-center": [c[0], bounds.max[1], c[2]],
+                "bottom-center": [c[0], bounds.min[1], c[2]],
+                "left-center": [bounds.min[0], c[1], c[2]],
+                "right-center": [bounds.max[0], c[1], c[2]],
+                "front-center": [c[0], c[1], bounds.min[2]],
+                "back-center": [c[0], c[1], bounds.max[2]],
+            },
+            mesh: out,
+            joint: id === "static" ? null : id,
+        });
+    }
+    const compiled = new Map(), stack = new Set();
+    const build = (ref) => {
+        if (compiled.has(ref))
+            return requireValue(compiled.get(ref));
+        if (stack.has(ref))
+            return fail("DEPENDENCY_CYCLE", "/joints", "Cyclic joint hierarchy.", { received: ref });
+        stack.add(ref);
+        const [base, side] = ref.split("/"), m = requireValue(declared.get(base));
+        let parent = null;
+        if (m.parent !== undefined) {
+            parent = requireValue(declared.get(m.parent)).side ? `${m.parent}/${side ?? "left"}` : m.parent;
+            build(parent);
+        }
+        const b = instances.find((i) => i.id === ref)?.bounds;
+        let pivot;
+        if ("position" in m.pivot) {
+            const [x, y, z] = m.pivot.position;
+            pivot = [side === "right" && x !== 0 ? -x : x, y, z];
+        }
+        else
+            pivot = [b ? (b.min[0] + b.max[0]) / 2 : 0, requireValue(mesh.rigPivots)[m.pivot.height], 0];
+        stack.delete(ref);
+        const joint = {
+            id: ref,
+            joint: base,
+            ...(side ? { side } : {}),
+            parent,
+            pivot,
+            dofs: m.dofs.map((d) => {
+                const a = AXES[d.axis];
+                return {
+                    name: d.name,
+                    axis: side === "right" ? [a[0], a[1] === 0 ? 0 : -a[1], a[2] === 0 ? 0 : -a[2]] : [...a],
+                    limits: [d.limits[0], d.limits[1]],
+                };
+            }),
+        };
+        compiled.set(ref, joint);
+        return joint;
+    };
+    for (const ref of [...new Set(refs.values())].sort())
+        build(ref);
+    const depth = (j) => j.parent === null ? 0 : 1 + depth(requireValue(compiled.get(j.parent)));
+    const joints = [...compiled.values()].sort((a, b) => depth(a) - depth(b) || (a.id < b.id ? -1 : 1)), index = new Map(joints.map((j, i) => [j.id, i]));
+    const layer = emptyMesh();
+    for (const instance of instances) {
+        instance.mesh.joints = new Array(instance.mesh.positions.length / 3).fill(instance.joint ? (index.get(instance.joint) ?? -1) : -1);
+        appendMesh(layer, instance.mesh);
+    }
+    return {
+        schema: "asset-assembly/0.2",
+        units: rig.units ?? "tiles",
+        sourceHash: sourceHash({ legacyRig: rig, mesh }),
+        layers: { legacy: layer },
+        materials: { legacy: { color: "#ffffff" } },
+        instances,
+        bounds: meshBounds(layer),
+        groundPivot: [0, 0, 0],
+        triangles: layer.indices.length / 3,
+        skeleton: { joints },
+        identity: null,
+        slots: {},
+        states: {},
+        alternates: [],
+    };
+}

package/dist/math.d.ts

@@ -0,0 +1,16 @@
+import type { Transform, Vec3 } from "./types.js";
+export declare const add: (a: Vec3, b: Vec3) => Vec3;
+export declare const sub: (a: Vec3, b: Vec3) => Vec3;
+export declare const scale: (a: Vec3, n: number) => Vec3;
+export declare const dot: (a: Vec3, b: Vec3) => number;
+export declare const cross: (a: Vec3, b: Vec3) => Vec3;
+export declare const normalize: (a: Vec3) => Vec3;
+/** Fixed output precision shared by declarative geometry and sampled transforms. */
+export declare const quantize: (v: number) => number;
+export declare const IDENTITY: Transform;
+/** Right-handed rotation about a unit axis by degrees (Rodrigues). */
+export declare function rotation(axis: Vec3, degrees: number): Transform;
+export declare function compose(a: Transform, b: Transform): Transform;
+export declare const translation: (v: Vec3) => Transform;
+export declare const applyPoint: (m: Transform, p: Vec3) => Vec3;
+export declare const applyVector: (m: Transform, p: Vec3) => Vec3;

package/dist/math.js

@@ -0,0 +1,62 @@
+import { requireValue } from "./required.js";
+export const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+export const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+export const scale = (a, n) => [a[0] * n, a[1] * n, a[2] * n];
+export const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+export const cross = (a, b) => [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0],
+];
+export const normalize = (a) => scale(a, 1 / Math.max(1e-12, Math.hypot(...a)));
+/** Fixed output precision shared by declarative geometry and sampled transforms. */
+export const quantize = (v) => {
+    const q = Math.round(v * 1e12) / 1e12;
+    return q === 0 ? 0 : q;
+};
+export const IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0];
+/** Right-handed rotation about a unit axis by degrees (Rodrigues). */
+export function rotation(axis, degrees) {
+    const r = (degrees * Math.PI) / 180, c = Math.cos(r), s = Math.sin(r), t = 1 - c, [x, y, z] = axis;
+    return [
+        c + x * x * t,
+        x * y * t - z * s,
+        x * z * t + y * s,
+        0,
+        y * x * t + z * s,
+        c + y * y * t,
+        y * z * t - x * s,
+        0,
+        z * x * t - y * s,
+        z * y * t + x * s,
+        c + z * z * t,
+        0,
+    ];
+}
+export function compose(a, b) {
+    const out = new Array(12);
+    for (let row = 0; row < 3; row++) {
+        for (let col = 0; col < 3; col++)
+            out[row * 4 + col] =
+                requireValue(a[row * 4]) * requireValue(b[col]) +
+                    requireValue(a[row * 4 + 1]) * requireValue(b[4 + col]) +
+                    requireValue(a[row * 4 + 2]) * requireValue(b[8 + col]);
+        out[row * 4 + 3] =
+            requireValue(a[row * 4]) * requireValue(b[3]) +
+                requireValue(a[row * 4 + 1]) * requireValue(b[7]) +
+                requireValue(a[row * 4 + 2]) * requireValue(b[11]) +
+                requireValue(a[row * 4 + 3]);
+    }
+    return out;
+}
+export const translation = (v) => [1, 0, 0, v[0], 0, 1, 0, v[1], 0, 0, 1, v[2]];
+export const applyPoint = (m, p) => [
+    requireValue(m[0]) * p[0] + requireValue(m[1]) * p[1] + requireValue(m[2]) * p[2] + requireValue(m[3]),
+    requireValue(m[4]) * p[0] + requireValue(m[5]) * p[1] + requireValue(m[6]) * p[2] + requireValue(m[7]),
+    requireValue(m[8]) * p[0] + requireValue(m[9]) * p[1] + requireValue(m[10]) * p[2] + requireValue(m[11]),
+];
+export const applyVector = (m, p) => [
+    requireValue(m[0]) * p[0] + requireValue(m[1]) * p[1] + requireValue(m[2]) * p[2],
+    requireValue(m[4]) * p[0] + requireValue(m[5]) * p[1] + requireValue(m[6]) * p[2],
+    requireValue(m[8]) * p[0] + requireValue(m[9]) * p[1] + requireValue(m[10]) * p[2],
+];

package/dist/mesh.d.ts

@@ -0,0 +1,11 @@
+import type { Bounds, CompiledAsset, MeshData, Vec3 } from "./types.js";
+export declare function meshForAsset(asset: CompiledAsset, tint?: string): MeshData;
+export declare const emptyMesh: () => MeshData;
+export declare function appendMesh(target: MeshData, source: MeshData, offset?: Vec3): MeshData;
+export declare function meshBounds(mesh: MeshData): Bounds;
+/** Remove collapsed bevel bands without changing legacy MeshBuilder output. */
+export declare function removeDegenerateTriangles(mesh: MeshData): MeshData;
+export declare function validateMesh(mesh: MeshData): string[];
+export declare function canonicalJSON(value: unknown): string;
+/** Portable SHA-256 over canonical JSON. No Node, browser or asynchronous crypto dependency. */
+export declare function sourceHash(value: unknown): string;