@forgeax/engine-fbx 0.0.0-dev.8d955ade1c79

package/scripts/test-wasm.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// test-wasm.mjs — quick smoke test for the compiled fbx-wasm module.
+// Runs in Node.js (not the browser) using the compiled .mjs + .wasm.
+//
+// Usage: node scripts/test-wasm.mjs <path-to-fbx>
+//   e.g.: node scripts/test-wasm.mjs ../../forgeax-engine-assets/vendor/fbx-test/cube.fbx
+
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkgDir = resolve(__dirname, '..');
+
+// Emscripten builds with ENVIRONMENT=web, but we can make it work in Node
+// by providing a locateFile that resolves the .wasm correctly.
+const wasmPath = resolve(pkgDir, 'pkg', 'fbx-wasm.wasm');
+const wasmBinary = readFileSync(wasmPath);
+
+// Dynamic import of the Emscripten module (Windows needs file:// URLs)
+import { pathToFileURL } from 'node:url';
+const modulePath = pathToFileURL(resolve(pkgDir, 'pkg', 'fbx-wasm.mjs')).href;
+const createModule = (await import(modulePath)).default;
+
+const mod = await createModule({
+  wasmBinary,
+});
+
+// Read the FBX file
+const fbxPath = process.argv[2];
+if (!fbxPath) {
+  console.error('Usage: node scripts/test-wasm.mjs <path-to-fbx>');
+  process.exit(1);
+}
+
+const fbxBytes = readFileSync(resolve(fbxPath));
+console.log(`Parsing: ${fbxPath} (${fbxBytes.length} bytes)`);
+
+const ptr = mod._malloc(fbxBytes.length);
+mod.HEAPU8.set(fbxBytes, ptr);
+mod._parseFbxWasm(ptr, fbxBytes.length);
+mod._free(ptr);
+
+const resultPtr = mod._getResultPtr();
+const resultLen = mod._getResultLen();
+
+if (!resultPtr || !resultLen) {
+  console.error('WASM returned empty result');
+  mod._freeResult();
+  process.exit(1);
+}
+
+const json = mod.UTF8ToString(resultPtr, resultLen);
+mod._freeResult();
+
+const parsed = JSON.parse(json);
+
+if (parsed.error) {
+  console.error('Parse error:', parsed.error);
+  process.exit(1);
+}
+
+console.log('\n=== FBX Parse Result ===');
+console.log(`Meshes:     ${parsed.meshes?.length ?? 0}`);
+console.log(`Nodes:      ${parsed.nodes?.length ?? 0}`);
+console.log(`Materials:  ${parsed.materials?.length ?? 0}`);
+console.log(`Skeletons:  ${parsed.skeletons?.length ?? 0}`);
+console.log(`Skins:      ${parsed.skins?.length ?? 0}`);
+console.log(`Clips:      ${parsed.clips?.length ?? 0}`);
+
+if (parsed.meshes?.length > 0) {
+  const m = parsed.meshes[0];
+  console.log(`\nFirst mesh: "${m.name ?? '(unnamed)'}"`);
+  console.log(`  vertices: ${m.vertices.length / 3} positions`);
+  console.log(`  indices:  ${m.indices?.length ?? 0}`);
+  console.log(`  polygons: ${m.polygonCount}`);
+  console.log(`  attrs:    ${Object.keys(m.attributes).join(', ')}`);
+}
+
+if (parsed.skeletons?.length > 0) {
+  const s = parsed.skeletons[0];
+  console.log(`\nSkeleton: ${s.jointCount} joints`);
+  console.log(`  jointPaths: ${s.jointPaths.slice(0, 5).join(', ')}${s.jointCount > 5 ? '...' : ''}`);
+}
+
+if (parsed.clips?.length > 0) {
+  const c = parsed.clips[0];
+  console.log(`\nFirst clip: "${c.name ?? '(unnamed)'}" (${c.duration.toFixed(3)}s, ${c.channels.length} channels)`);
+}
+
+console.log('\n✅ WASM FBX parsing test passed!');

package/src/__tests__/blendshape-import.integration.test.ts

@@ -0,0 +1,90 @@
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { ImporterRegistry, type RunImportMeta, runImport } from '@forgeax/engine-import';
+import type { MeshAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { fbxImporter } from '../fbx-importer.js';
+import { initFbxWasm, parseFbx } from '../index.js';
+
+const MESH_GUID = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
+const sourceUrl = new URL(
+  '../../../../apps/hello/format-tier1/fixtures/multi-target-morph.fbx',
+  import.meta.url,
+);
+
+async function readFixture(url: URL): Promise<Uint8Array> {
+  const nodeFs = (await import('node:' + 'fs/promises')) as unknown as {
+    readonly readFile: (path: URL) => Promise<Uint8Array>;
+  };
+  return new Uint8Array(await nodeFs.readFile(url));
+}
+
+function meta(): RunImportMeta {
+  return {
+    importer: 'fbx',
+    source: 'apps/hello/format-tier1/fixtures/multi-target-morph.fbx',
+    subAssets: [
+      { guid: MESH_GUID, sourceIndex: 0, sourceKey: 'fbx:mesh:MorphTriangle', kind: 'mesh' },
+    ],
+  };
+}
+
+describe('real FBX BlendShape import through ufbx WASM', () => {
+  it('keeps source target order, authored weights, and target lengths', async () => {
+    const bytes = await readFixture(sourceUrl);
+    await initFbxWasm();
+    const raw = JSON.parse(parseFbx(bytes)) as {
+      readonly meshes: readonly {
+        readonly morphTargets?: readonly { readonly position?: readonly number[] }[];
+        readonly morphWeights?: readonly number[];
+      }[];
+    };
+    expect(raw.meshes).toHaveLength(1);
+    expect(raw.meshes[0]?.morphTargets).toHaveLength(2);
+    expect(raw.meshes[0]?.morphTargets?.[0]?.position).toEqual([0, 0, 0, 0.25, 0, 0, 0, 0.5, 0]);
+    expect(raw.meshes[0]?.morphTargets?.[1]?.position).toEqual([0, 0, -0.25, 0, 0, 0, 0, 0, 0]);
+    expect(raw.meshes[0]?.morphWeights).toEqual([0.25, 0.5]);
+
+    const registry = new ImporterRegistry();
+    registry.register(fbxImporter);
+    const fs = { readSource: async () => ({ ok: true as const, value: bytes }) };
+    const result = await runImport(meta(), registry, fs);
+    expect(result.ok).toBe(true);
+    if (!result.ok || 'skipped' in result.value) throw new Error('expected FBX DDC pack');
+    const entry = result.value.pack.assets.find((asset) => asset.guid === MESH_GUID);
+    expect(entry?.kind).toBe('mesh');
+    const payload = entry?.payload as {
+      readonly vertices: readonly number[];
+      readonly morphTargets?: readonly { readonly position?: readonly number[] }[];
+      readonly morphWeights?: readonly number[];
+    };
+    expect(payload.morphTargets).toHaveLength(2);
+    expect(payload.morphTargets?.map((target) => target.position?.length)).toEqual([9, 9]);
+    expect(payload.morphWeights).toEqual([0.25, 0.5]);
+    expect(payload.vertices.length).toBe(3 * 12);
+
+    const runtime = new AssetRegistry({} as never);
+    const parsedMesh = runtime.parseAssetPayload('mesh', entry?.payload ?? {});
+    expect(parsedMesh).toMatchObject({ kind: 'mesh' });
+    expect(runtime.catalog(MESH_GUID, parsedMesh as never).ok).toBe(true);
+    const loaded = await runtime.loadByGuid<MeshAsset>(runtime.parseGuid(MESH_GUID));
+    expect(loaded.ok).toBe(true);
+    if (!loaded.ok) return;
+    expect(loaded.value.kind).toBe('mesh');
+    expect(Array.from(loaded.value.morphWeights ?? [])).toEqual([0.25, 0.5]);
+    expect(loaded.value.morphTargets).toHaveLength(2);
+  });
+
+  it('records that this real fixture has no imported animation clip', async () => {
+    const bytes = await readFixture(sourceUrl);
+    await initFbxWasm();
+    const registry = new ImporterRegistry();
+    registry.register(fbxImporter);
+    const fs = { readSource: async () => ({ ok: true as const, value: bytes }) };
+    const result = await runImport(meta(), registry, fs);
+    expect(result.ok).toBe(true);
+    if (!result.ok || 'skipped' in result.value) return;
+    expect(
+      result.value.pack.assets.filter((asset) => asset.kind === 'animation-clip'),
+    ).toHaveLength(0);
+  });
+});

package/src/__tests__/blendshape-import.unit.test.ts

@@ -0,0 +1,83 @@
+import type { MeshPod } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { parseAnimationClips } from '../parse-animation-clip.js';
+import { type FbxRawMesh, parseMesh } from '../parse-mesh.js';
+import { buildMeshAsset } from '../to-asset-pack.js';
+
+type MorphRawMesh = FbxRawMesh & {
+  readonly morphTargets?: readonly {
+    readonly position?: number[];
+    readonly normal?: number[];
+    readonly tangent?: number[];
+  }[];
+  readonly morphWeights?: number[];
+};
+
+function rawMesh(overrides: Partial<MorphRawMesh> = {}): MorphRawMesh {
+  return {
+    vertices: [0, 0, 0, 1, 0, 0],
+    indices: [0, 1],
+    attributes: {},
+    polygonCount: 1,
+    sourceIndex: 0,
+    materialIndex: -1,
+    ...overrides,
+  };
+}
+
+describe('FBX BlendShape morph projection', () => {
+  it('keeps target-major deltas and authored weights through MeshAsset', () => {
+    const pod = parseMesh(
+      rawMesh({
+        morphTargets: [{ position: [0, 0, 0, 0.25, 0, 0] }],
+        morphWeights: [0.5],
+      }),
+      0,
+    ) as MeshPod & {
+      readonly morphTargets?: readonly { readonly position?: Float32Array }[];
+      readonly morphWeights?: Float32Array;
+    };
+    const asset = buildMeshAsset(pod, 'fbx-morph-guid');
+    const mesh = asset.payload as {
+      morphTargets?: readonly { readonly position?: Float32Array }[];
+      morphWeights?: Float32Array;
+    };
+    expect(mesh.morphTargets?.[0]?.position?.[3]).toBeCloseTo(0.25);
+    expect(Array.from(mesh.morphWeights ?? [])).toEqual([0.5]);
+  });
+
+  it('fails before asset promotion when a source exceeds the eight-target limit', () => {
+    expect(() =>
+      parseMesh(
+        rawMesh({
+          morphTargets: Array.from({ length: 9 }, () => ({ position: [0, 0, 0, 0, 0, 0] })),
+        }),
+        0,
+      ),
+    ).toThrow('fbx-morph-invalid');
+  });
+
+  it('preserves per-element FBX morph weight channels during resampling', () => {
+    const [clip] = parseAnimationClips(
+      {
+        clips: [
+          {
+            duration: 1,
+            channels: [
+              {
+                targetNode: 'Root',
+                property: 'weights',
+                weightCount: 4,
+                keyTimes: [0, 1],
+                keyValues: [0, 0, 0, 0, 1, 2, 3, 4],
+              },
+            ],
+          },
+        ],
+      },
+      1,
+    );
+    expect(clip?.channels[0]?.property).toBe('weights');
+    expect(Array.from(clip?.channels[0]?.sampler.output ?? [])).toEqual([0, 0, 0, 0, 1, 2, 3, 4]);
+  });
+});

package/src/__tests__/fbx-importer.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { deriveFbxSourceKeys, sourceKeyForFbxOutput } from '../fbx-importer.js';
+
+describe('fbx importer contract migration fixture', () => {
+  it('requires the generic ImportProduct shape', () => {
+    expect('ImportProduct').toBe('ImportProduct');
+  });
+
+  it('requires multi-asset output to keep local artifact ownership', () => {
+    expect('asset-local artifacts').toContain('artifacts');
+    expect('package-global artifacts').not.toContain('asset-local artifacts');
+  });
+});
+
+describe('FBX producer sourceKey', () => {
+  it('is stable across source relocation and output reorder', () => {
+    const first = deriveFbxSourceKeys([
+      { kind: 'mesh', name: 'Body' },
+      { kind: 'scene', name: 'Root' },
+    ]);
+    const reordered = deriveFbxSourceKeys([
+      { kind: 'scene', name: 'Root' },
+      { kind: 'mesh', name: 'Body' },
+    ]);
+    expect(first).toEqual({ ok: true, keys: ['fbx:mesh:Body', 'fbx:scene:Root'] });
+    expect(reordered).toEqual({ ok: true, keys: ['fbx:scene:Root', 'fbx:mesh:Body'] });
+    expect(sourceKeyForFbxOutput({ kind: 'mesh', name: 'Body' })).toBe('fbx:mesh:Body');
+  });
+
+  it('rejects duplicate anonymous output kinds instead of using array position', () => {
+    expect(deriveFbxSourceKeys([{ kind: 'mesh' }, { kind: 'mesh' }])).toEqual({
+      ok: false,
+      code: 'ambiguous-source-key',
+    });
+  });
+});

package/src/__tests__/fbx-local-artifacts.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest';
+import { buildMeshAsset } from '../to-asset-pack.js';
+
+const GUID_A = '019e2cc6-0c86-79da-aa76-b0984c86d45c';
+const GUID_B = '019e2cc6-0c86-79da-aa76-b0984c86d45d';
+
+function mesh(guid: string) {
+  return buildMeshAsset(
+    {
+      sourceIndex: guid === GUID_A ? 0 : 1,
+      vertices: new Float32Array([0, 0, 0]),
+      indices: new Uint16Array([0]),
+      attributes: {},
+      submeshes: [],
+    },
+    guid,
+  );
+}
+
+describe('FBX asset-local artifacts', () => {
+  it('allows two assets to own the same local key without sharing refs or bytes', () => {
+    const first = mesh(GUID_A) as unknown as Record<string, unknown>;
+    const second = mesh(GUID_B) as unknown as Record<string, unknown>;
+    const firstBody = (first.artifacts as Record<string, Record<string, unknown>>).body;
+    const secondBody = (second.artifacts as Record<string, Record<string, unknown>>).body;
+    expect(firstBody).toBeDefined();
+    expect(secondBody).toBeDefined();
+    if (firstBody === undefined || secondBody === undefined) return;
+
+    expect(first.refs).toEqual([]);
+    expect(second.refs).toEqual([]);
+    expect(firstBody.mediaType).toBe('application/x-forgeax-mesh');
+    expect(secondBody.mediaType).toBe('application/x-forgeax-mesh');
+    expect(firstBody.bytes).toBeInstanceOf(Uint8Array);
+    expect(secondBody.bytes).toBeInstanceOf(Uint8Array);
+    expect(firstBody).not.toHaveProperty('path');
+    expect(firstBody).not.toHaveProperty('integrity');
+  });
+});

package/src/__tests__/index.test.ts

@@ -0,0 +1,168 @@
+import type { ImportedAsset, MeshAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import type { FbxRawMesh } from '../parse-mesh.js';
+import { parseMesh } from '../parse-mesh.js';
+import { buildMeshAsset } from '../to-asset-pack.js';
+
+describe('@forgeax/engine-fbx', () => {
+  it('exports initFbxWasm', async () => {
+    const mod = await import('../index.js');
+    expect(typeof mod.initFbxWasm).toBe('function');
+  });
+
+  it('exports parseFbx', async () => {
+    const mod = await import('../index.js');
+    expect(typeof mod.parseFbx).toBe('function');
+  });
+
+  it('exports parseFbxToObject', async () => {
+    const mod = await import('../index.js');
+    expect(typeof mod.parseFbxToObject).toBe('function');
+  });
+
+  it('exports isFbxWasmReady', async () => {
+    const mod = await import('../index.js');
+    expect(typeof mod.isFbxWasmReady).toBe('function');
+  });
+
+  it('isFbxWasmReady returns false before init', async () => {
+    const mod = await import('../index.js');
+    expect(mod.isFbxWasmReady()).toBe(false);
+  });
+
+  it('parseFbx throws before init', async () => {
+    const mod = await import('../index.js');
+    expect(() => mod.parseFbx(new Uint8Array(0))).toThrow('WASM not initialized');
+  });
+});
+
+describe('@forgeax/engine-fbx barrel', () => {
+  it('exports fbxImporter with key "fbx"', async () => {
+    const mod = await import('../index.js');
+    expect(mod.fbxImporter.key).toBe('fbx');
+    expect(typeof mod.fbxImporter.import).toBe('function');
+  });
+
+  it('exports the parse-*.ts bridge layer + toAssetPack', async () => {
+    const mod = await import('../index.js');
+    expect(typeof mod.parseMesh).toBe('function');
+    expect(typeof mod.parseScene).toBe('function');
+    expect(typeof mod.parseMaterial).toBe('function');
+    expect(typeof mod.parseSkeleton).toBe('function');
+    expect(typeof mod.parseSkin).toBe('function');
+    expect(typeof mod.parseAnimationClips).toBe('function');
+    expect(typeof mod.parseTextures).toBe('function');
+    expect(typeof mod.resolveFbxTexturePath).toBe('function');
+    expect(typeof mod.toAssetPack).toBe('function');
+    expect(typeof mod.fbxErr).toBe('function');
+  });
+});
+
+// ── M6: buildMeshAsset aabb — GREEN (M7 make-green) ─────────────────
+
+/** Extract MeshAsset payload from an ImportedAsset (guards kind='mesh'). */
+function meshFromAsset(asset: ImportedAsset): MeshAsset {
+  if (asset.kind !== 'mesh') throw new TypeError(`expected mesh, got ${asset.kind}`);
+  return asset.payload as MeshAsset;
+}
+
+/** Build a mock FbxRawMesh with no indices (per-vertex attributes only). */
+function mockRawMesh(vertices: number[], attributes?: Record<string, number[]>): FbxRawMesh {
+  return {
+    name: 'AabbTestMesh',
+    vertices,
+    attributes: attributes ?? {},
+    polygonCount: Math.max(0, Math.floor(vertices.length / 9)),
+    sourceIndex: 0,
+    materialIndex: -1,
+  };
+}
+
+describe('buildMeshAsset aabb (GREEN)', () => {
+  it('m6-1a: normal quad — aabb matches position min/max', () => {
+    const vertices = [0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0];
+    const raw = mockRawMesh(vertices);
+    const pod = parseMesh(raw, 0);
+    const asset = buildMeshAsset(pod, 'guid-quad');
+    const mesh = meshFromAsset(asset);
+
+    // aabb should be Float32Array(6) = [minX, minY, minZ, maxX, maxY, maxZ]
+    // from vertices pod: minX=0, minY=0, minZ=0, maxX=1, maxY=1, maxZ=0
+    const aabb = mesh.aabb;
+    expect(aabb, 'aabb must be defined').toBeDefined();
+    expect(aabb).toBeInstanceOf(Float32Array);
+    expect(aabb?.length).toBe(6);
+
+    // Normal quad: vertices [(0,0,0),(1,0,0),(0,1,0),(1,1,0)]
+    // biome and tsc strict guards: use ?. and as number for Float32Array index access
+    expect(aabb?.[0] as number, 'minX').toBe(0);
+    expect(aabb?.[1] as number, 'minY').toBe(0);
+    expect(aabb?.[2] as number, 'minZ').toBe(0);
+    expect(aabb?.[3] as number, 'maxX').toBe(1);
+    expect(aabb?.[4] as number, 'maxY').toBe(1);
+    expect(aabb?.[5] as number, 'maxZ').toBe(0);
+  });
+
+  it('m6-1b: single point — min == max for all axes', () => {
+    const vertices = [5, 5, 5];
+    const raw = mockRawMesh(vertices);
+    const pod = parseMesh(raw, 0);
+    const asset = buildMeshAsset(pod, 'guid-point');
+    const mesh = meshFromAsset(asset);
+
+    const aabb = mesh.aabb;
+    expect(aabb, 'aabb must be defined').toBeDefined();
+    expect(aabb?.length).toBe(6);
+
+    expect(aabb?.[0] as number, 'minX').toBe(5);
+    expect(aabb?.[1] as number, 'minY').toBe(5);
+    expect(aabb?.[2] as number, 'minZ').toBe(5);
+    expect(aabb?.[3] as number, 'maxX').toBe(5);
+    expect(aabb?.[4] as number, 'maxY').toBe(5);
+    expect(aabb?.[5] as number, 'maxZ').toBe(5);
+  });
+
+  it('m6-1c: empty vertices — inverted-empty box, no NaN', () => {
+    const vertices: number[] = [];
+    const raw = mockRawMesh(vertices);
+    const pod = parseMesh(raw, 0);
+    const asset = buildMeshAsset(pod, 'guid-empty');
+    const mesh = meshFromAsset(asset);
+
+    const aabb = mesh.aabb;
+    expect(aabb, 'aabb must be defined for empty mesh').toBeDefined();
+    expect(aabb?.length).toBe(6);
+
+    // Inverted-empty box convention: min.x > max.x (from box3.fromPositions
+    // when positions.length < 3). This signals "no volume" to pick.ts which
+    // skips the entity (AC-07).
+    expect(aabb?.[0] as number, 'minX').toBeGreaterThan(aabb?.[3] as number);
+    // No NaN anywhere
+    for (let i = 0; i < 6; i++) {
+      expect(Number.isNaN(aabb?.[i] ?? 0), `aabb[${i}] must not be NaN`).toBe(false);
+    }
+  });
+
+  it('m6-1d: degenerate plane (Y=0) — one axis min==max, still pickable', () => {
+    const vertices = [0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1];
+    const raw = mockRawMesh(vertices);
+    const pod = parseMesh(raw, 0);
+    const asset = buildMeshAsset(pod, 'guid-plane');
+    const mesh = meshFromAsset(asset);
+
+    const aabb = mesh.aabb;
+    expect(aabb, 'aabb must be defined').toBeDefined();
+    expect(aabb?.length).toBe(6);
+
+    // Degenerate in Y (all Y=0) => minY == maxY == 0
+    expect(aabb?.[0] as number, 'minX').toBe(0);
+    expect(aabb?.[1] as number, 'minY').toBe(0);
+    expect(aabb?.[2] as number, 'minZ').toBe(0);
+    expect(aabb?.[3] as number, 'maxX').toBe(1);
+    expect(aabb?.[4] as number, 'maxY').toBe(0);
+    expect(aabb?.[5] as number, 'maxZ').toBe(1);
+
+    // Verify degenerate condition: Y axis has zero thickness
+    expect(aabb?.[1] as number).toBe(aabb?.[4] as number);
+  });
+});

package/src/__tests__/mesh-material-slots.unit.test.ts

@@ -0,0 +1,125 @@
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import type { MeshAsset, MeshPod } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { buildMeshAsset } from '../to-asset-pack';
+
+describe('FBX mesh material slots', () => {
+  it('projects repeated material indices through one stable slot table', () => {
+    const pod: MeshPod = {
+      name: 'MultiMaterial',
+      vertices: new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]),
+      indices: new Uint16Array([0, 1, 2]),
+      attributes: {},
+      sourceIndex: 0,
+      submeshes: [0, 1, 0].map((materialIndex) => ({
+        indexOffset: 0,
+        indexCount: 3,
+        vertexCount: 3,
+        topology: 'triangle-list' as const,
+        materialIndex,
+      })),
+    };
+    const asset = buildMeshAsset(pod, '019d0000-0000-7000-8000-000000000010', undefined, {
+      guidByIndex: new Map([
+        [0, '019d0000-0000-7000-8000-000000000011'],
+        [1, '019d0000-0000-7000-8000-000000000012'],
+      ]),
+      nameByIndex: new Map([
+        [0, 'Body'],
+        [1, 'Trim'],
+      ]),
+    });
+    if (asset.kind !== 'mesh') throw new Error('expected mesh');
+    const mesh = asset.payload as MeshAsset;
+
+    expect(mesh.submeshes.map((submesh) => submesh.materialSlot)).toEqual([0, 1, 0]);
+    expect(mesh.materialSlots.map((slot) => slot.slotName)).toEqual(['Body', 'Trim']);
+    expect(asset.refs.map((ref) => ref.guid)).toEqual([
+      '019d0000-0000-7000-8000-000000000011',
+      '019d0000-0000-7000-8000-000000000012',
+    ]);
+  });
+
+  it('keeps old indices across source reorder and appends a newly discovered slot', () => {
+    const pod: MeshPod = {
+      name: 'Reimported',
+      vertices: new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]),
+      indices: new Uint16Array([0, 1, 2]),
+      attributes: {},
+      sourceIndex: 0,
+      submeshes: [0, 1].map((materialIndex) => ({
+        indexOffset: 0,
+        indexCount: 3,
+        vertexCount: 3,
+        topology: 'triangle-list' as const,
+        materialIndex,
+      })),
+    };
+    const asset = buildMeshAsset(pod, '019d0000-0000-7000-8000-000000000020', undefined, {
+      guidByIndex: new Map([
+        [0, '019d0000-0000-7000-8000-000000000021'],
+        [1, '019d0000-0000-7000-8000-000000000022'],
+      ]),
+      nameByIndex: new Map([
+        [0, 'Accent'],
+        [1, 'Body'],
+      ]),
+      sourceKeyByIndex: new Map([
+        [0, 'fbx:material:Accent'],
+        [1, 'fbx:material:Body'],
+      ]),
+      previousMaterialSlots: [
+        { slotName: 'Body', sourceKey: 'fbx:material:Body' },
+        { slotName: 'Trim', sourceKey: 'fbx:material:Trim', defaultMaterialGuid: 'old-trim' },
+      ],
+      materialSlotDefaultOverrides: {
+        'fbx:material:Trim': '019d0000-0000-7000-8000-000000000099',
+      },
+    });
+    if (asset.kind !== 'mesh') throw new Error('expected mesh');
+    const mesh = asset.payload as MeshAsset;
+
+    expect(mesh.submeshes.map((submesh) => submesh.materialSlot)).toEqual([2, 0]);
+    expect(mesh.materialSlots.map((slot) => slot.slotName)).toEqual(['Body', 'Trim', 'Accent']);
+    expect(mesh.materialSlots[1]?.defaultMaterial).toBeUndefined();
+    expect(asset.refs.map((ref) => ref.guid)).not.toContain('019d0000-0000-7000-8000-000000000099');
+  });
+
+  it('cooks the authored default while retaining stable producer topology', () => {
+    const sourceGuid = '019d0000-0000-7000-8000-000000000031';
+    const authoredGuid = '019d0000-0000-7000-8000-000000000032';
+    const pod: MeshPod = {
+      name: 'Editable',
+      vertices: new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]),
+      indices: new Uint16Array([0, 1, 2]),
+      attributes: {},
+      sourceIndex: 0,
+      submeshes: [
+        {
+          indexOffset: 0,
+          indexCount: 3,
+          vertexCount: 3,
+          topology: 'triangle-list',
+          materialIndex: 0,
+        },
+      ],
+    };
+    const asset = buildMeshAsset(pod, '019d0000-0000-7000-8000-000000000030', undefined, {
+      guidByIndex: new Map([[0, sourceGuid]]),
+      nameByIndex: new Map([[0, 'Body']]),
+      sourceKeyByIndex: new Map([[0, 'fbx:material:Body']]),
+      previousMaterialSlots: [
+        {
+          slotName: 'Body',
+          sourceKey: 'fbx:material:Body',
+          defaultMaterialGuid: sourceGuid,
+        },
+      ],
+      materialSlotDefaultOverrides: { 'fbx:material:Body': authoredGuid },
+    });
+    if (asset.kind !== 'mesh') throw new Error('expected mesh');
+    const mesh = asset.payload as MeshAsset;
+
+    expect(AssetGuid.format(mesh.materialSlots[0]?.defaultMaterial as never)).toBe(authoredGuid);
+  });
+});