@forgeax/engine-fbx 0.1.2

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,200 @@
+import { ImporterRegistry, type RunImportMeta, runImport } from '@forgeax/engine-import';
+import type { ImportErrorDetail } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { deriveFbxSourceKeys, fbxImporter, sourceKeyForFbxOutput } from '../fbx-importer.js';
+
+const FBX_SOURCE = 'apps/hello/format-tier1/fixtures/multi-target-morph.fbx';
+const FBX_GUID = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
+const FBX_SOURCE_URL = new URL(`../../../../${FBX_SOURCE}`, import.meta.url);
+
+async function readFbxFixture(): Promise<Uint8Array> {
+  const nodeFs = (await import('node:' + 'fs/promises')) as unknown as {
+    readonly readFile: (path: URL) => Promise<Uint8Array>;
+  };
+  return new Uint8Array(await nodeFs.readFile(FBX_SOURCE_URL));
+}
+
+function fbxMeta(): RunImportMeta {
+  return {
+    importer: 'fbx',
+    source: FBX_SOURCE,
+    subAssets: [
+      {
+        guid: FBX_GUID,
+        sourceIndex: 0,
+        sourceKey: 'fbx:mesh:MorphTriangle',
+        kind: 'mesh',
+      },
+    ],
+  };
+}
+
+describe('public FBX importer source-read recovery', () => {
+  it('preserves refusal and retries on the same registry and Meta/GUID', async () => {
+    const sourceBytes = await readFbxFixture();
+    const registry = new ImporterRegistry();
+    registry.register(fbxImporter);
+    const reads = { count: 0 };
+    let refuseImporterRead = true;
+    const fs = {
+      readSource: async () => {
+        reads.count += 1;
+        if (refuseImporterRead && reads.count === 2) {
+          return {
+            ok: false as const,
+            error: new Error('transient source read refusal: repairable'),
+          };
+        }
+        return { ok: true as const, value: sourceBytes };
+      },
+    };
+
+    const refused = await runImport(fbxMeta(), registry, fs);
+    expect(refused).toMatchObject({
+      ok: false,
+      error: {
+        code: 'source-read-failed',
+        detail: {
+          source: FBX_SOURCE,
+          reason: 'transient source read refusal: repairable',
+        },
+      },
+    });
+    expect(refused).not.toHaveProperty('value.pack');
+    expect(reads.count).toBe(2);
+
+    refuseImporterRead = false;
+    const repaired = await runImport(fbxMeta(), registry, fs);
+    const repeated = await runImport(fbxMeta(), registry, fs);
+    expect(repaired.ok).toBe(true);
+    expect(repeated.ok).toBe(true);
+    if (
+      !repaired.ok ||
+      'skipped' in repaired.value ||
+      !repeated.ok ||
+      'skipped' in repeated.value
+    ) {
+      throw new Error('repaired FBX import must publish a product');
+    }
+    expect(repaired.value.pack.assets).toHaveLength(1);
+    expect(repaired.value.pack.assets[0]).toMatchObject({
+      guid: FBX_GUID,
+      sourceKey: 'fbx:mesh:MorphTriangle',
+      kind: 'mesh',
+    });
+    expect(repeated.value.pack).toEqual(repaired.value.pack);
+    expect(reads.count).toBe(6);
+    expect(registry.registeredImporters()).toEqual(['fbx']);
+  });
+});
+
+describe('public FBX importer malformed-source recovery', () => {
+  it('returns one bounded source diagnostic, then retries deterministically on repaired bytes', async () => {
+    const sourceBytes = await readFbxFixture();
+    const meta = fbxMeta();
+    const registry = new ImporterRegistry();
+    registry.register(fbxImporter);
+    const reads = { count: 0 };
+    let bytes: Uint8Array<ArrayBufferLike> = new TextEncoder().encode(
+      'readable but malformed FBX source',
+    );
+    const fs = {
+      readSource: async (path: string) => {
+        reads.count += 1;
+        expect(path).toBe(FBX_SOURCE);
+        return { ok: true as const, value: bytes };
+      },
+    };
+
+    const refused = await runImport(meta, registry, fs);
+    expect(refused.ok).toBe(false);
+    expect(refused).not.toHaveProperty('value');
+    if (refused.ok) throw new Error('malformed FBX must be refused');
+    const diagnostics = (
+      refused.error.detail as Extract<
+        ImportErrorDetail,
+        { readonly diagnostics: readonly unknown[] }
+      >
+    ).diagnostics;
+    expect(refused.error.code).toBe('source-validation-failed');
+    expect(refused.error).not.toHaveProperty('value');
+    expect(refused.error).not.toHaveProperty('pack');
+    expect(refused.error).not.toHaveProperty('cookProducts');
+    expect(diagnostics).toHaveLength(1);
+    expect(refused.error).toMatchObject({
+      expected: 'a readable FBX source that ufbx can parse',
+      detail: {
+        diagnostics: [
+          {
+            code: 'fbx-source-parse-failed',
+            severity: 'error',
+            sourcePath: FBX_SOURCE,
+            sourceRange: { start: 0, end: 0, line: 1, column: 1 },
+            rule: 'fbx-source-parse',
+            expected: 'a readable FBX source that ufbx can parse',
+            actual: 'fbx-wasm: Unrecognized file format',
+          },
+        ],
+      },
+    });
+    expect(diagnostics[0]?.actual.length).toBeLessThanOrEqual(256);
+    expect(reads.count).toBe(2);
+
+    bytes = sourceBytes;
+    const repaired = await runImport(meta, registry, fs);
+    const repeated = await runImport(meta, registry, fs);
+    expect(repaired.ok).toBe(true);
+    expect(repeated.ok).toBe(true);
+    if (
+      !repaired.ok ||
+      'skipped' in repaired.value ||
+      !repeated.ok ||
+      'skipped' in repeated.value
+    ) {
+      throw new Error('repaired FBX import must publish a product');
+    }
+    expect(repaired.value.pack).toEqual(repeated.value.pack);
+    expect(repaired.value.pack.assets).toHaveLength(1);
+    expect(repaired.value.pack.assets[0]).toMatchObject({
+      guid: FBX_GUID,
+      sourceKey: 'fbx:mesh:MorphTriangle',
+      kind: 'mesh',
+    });
+    expect(reads.count).toBe(6);
+    expect(registry.registeredImporters()).toEqual(['fbx']);
+  });
+});
+
+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,167 @@
+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.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);
+  });
+});