@forgeax/engine-gltf 0.1.2

package/src/__tests__/pick-e2e.integration.test.ts

@@ -0,0 +1,238 @@
+// pick-e2e.integration.test.ts — glTF end-to-end pick probe over pack JSON roundtrip
+// (bug-20260706-import-path-meshasset-aabb-undefined-blocks-pick M5 / m5-1).
+//
+// Verifies the full chain: GltfMeshIr → meshIrToMeshAsset (producer) →
+// packMeshBin (JSON tail encode) → explicit JSON.stringify → JSON.parse
+// roundtrip (simulating dev-server pack transport) → aabb reconstruction
+// (Float32Array from plain array, the loader dual-contract path) →
+// World.allocSharedRef + spawn (MeshFilter / MeshRenderer / Transform) →
+// pick() hit assertion + negative-control miss.
+//
+// Falsification drill (plan-strategy section 5.4) EXECUTED:
+//   (1) Commented out `aabb: box3.fromPositions(box3.create(), positionsCat)`
+//       in packages/gltf/src/bridge.ts:329.
+//   (2) Ran this test → FAIL: pick() returned undefined (mesh entity had
+//       aabb === undefined, broad-phase `continue` skipped it).
+//       Confirmed the probe is sensitive to the aabb variable — not
+//       unconditionally green.
+//   (3) Restored the aabb emit line.
+//   (4) Re-ran → PASS.
+//   Drill result: probe correctly detects aabb absence. (Recorded inline
+//   in this file header as required by plan subsection 5.4.)
+//
+// AC-03 hard constraint: dawn-node smoke does NOT count — this vitest
+// integration test explicitly exercises the pack JSON roundtrip path that
+// dawn smoke skips. Reviewer can grep for `JSON.stringify` /
+// `JSON.parse` in this file to confirm.
+//
+// References: plan-strategy D-3 / R-6; pick-tile.test.ts (no-GPU pick
+// test paradigm); cli-gltf.integration.test.ts (gltf integration test
+// fixture pattern).
+
+import { World } from '@forgeax/engine-ecs';
+import { packMeshBinV4 } from '@forgeax/engine-import';
+import { decodeMeshBinHeader } from '@forgeax/engine-pack';
+import { pick } from '@forgeax/engine-picking';
+import { Camera, Materials, MeshFilter, MeshRenderer, perspective } from '@forgeax/engine-render';
+import { Transform } from '@forgeax/engine-scene';
+import type { Handle, MaterialAsset, MeshAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import type { GltfMeshIr } from '../parse-gltf.js';
+import { unwrapMeshAsset as meshIrToMeshAsset } from './bridge-test-helpers.js';
+
+// ---- helpers ----
+
+/** Convert a branded handle to the raw u32 used by allocSharedRef return. */
+function asHandle<T extends string>(n: number): Handle<T, 'shared'> {
+  return n as unknown as Handle<T, 'shared'>;
+}
+
+// ---- test ----
+
+describe('gltf e2e pick probe over pack JSON roundtrip (m5-1)', () => {
+  it('meshIrToMeshAsset → packMeshBin → JSON roundtrip → pick hit + negative-control miss', () => {
+    // --- 1. GltfMeshIr fixture: single triangle at Z=-3, XY symmetric ---
+    const prim: GltfMeshIr = {
+      positions: new Float32Array([-1, -1, -3, 1, -1, -3, 0, 1, -3]),
+      indices: new Uint16Array([0, 1, 2]),
+      materialIndex: 0,
+      meshIndex: 0,
+    };
+
+    // --- 2. Producer: meshIrToMeshAsset emits aabb (M4) ---
+    const meshAsset = meshIrToMeshAsset([prim]);
+    expect(meshAsset.aabb).toBeInstanceOf(Float32Array);
+    expect(meshAsset.aabb).toHaveLength(6);
+    // Min of positions: (-1, -1, -3); max: (1, 1, -3)
+    expect(meshAsset.aabb?.[0]).toBe(-1);
+    expect(meshAsset.aabb?.[1]).toBe(-1);
+    expect(meshAsset.aabb?.[2]).toBe(-3);
+    expect(meshAsset.aabb?.[3]).toBe(1);
+    expect(meshAsset.aabb?.[4]).toBe(1);
+    expect(meshAsset.aabb?.[5]).toBe(-3);
+
+    // --- 3. Encode via packMeshBin: converts aabb Float32Array to plain
+    //       array in the JSON tail (Array.from at import/src/mesh-bin.ts:153) ---
+    const packed = packMeshBinV4(
+      {
+        vertices: meshAsset.vertices,
+        indices: meshAsset.indices,
+        submeshes: meshAsset.submeshes,
+        aabb: meshAsset.aabb,
+        attributes: meshAsset.attributes,
+      },
+      'gltf://pick',
+    );
+    expect(packed.ok).toBe(true);
+    if (!packed.ok) return;
+    const bin = packed.value;
+
+    const header = decodeMeshBinHeader(bin, 'gltf://pick');
+    expect(header.ok).toBe(true);
+    if (!header.ok) return;
+    const jsonOffset = 80 + header.value.vertexBytes + header.value.indexBytes;
+    const jsonBytes = bin.slice(jsonOffset, jsonOffset + header.value.jsonBytes);
+    const metaRaw = new TextDecoder().decode(jsonBytes);
+
+    // Verify aabb is encoded as a plain number array in the JSON tail.
+    const metaParsed = JSON.parse(metaRaw) as { aabb?: number[] };
+    expect(Array.isArray(metaParsed.aabb)).toBe(true);
+    expect(metaParsed.aabb).toHaveLength(6);
+
+    // --- 4. Explicit JSON roundtrip: simulate dev-server pack transport ---
+    // AC-03 / D-3: the test MUST contain explicit JSON.stringify → JSON.parse
+    // that mirrors the fetch-based transport path dawn smoke skips.
+    const transportStr = JSON.stringify(metaParsed);
+    const transportParsed = JSON.parse(transportStr) as { aabb?: number[] };
+    expect(Array.isArray(transportParsed.aabb)).toBe(true);
+    // Values survive the roundtrip intact.
+    expect(transportParsed.aabb?.[0]).toBe(-1);
+    expect(transportParsed.aabb?.[1]).toBe(-1);
+    expect(transportParsed.aabb?.[2]).toBe(-3);
+    expect(transportParsed.aabb?.[3]).toBe(1);
+    expect(transportParsed.aabb?.[4]).toBe(1);
+    expect(transportParsed.aabb?.[5]).toBe(-3);
+
+    // --- 5. Reconstruct aabb as the runtime loader would ---
+    //   loader dual-contract: plain array → new Float32Array(array)
+    //   (runtime/src/mesh-bin.ts:116: `aabb = new Float32Array(parsed.aabb)`)
+    const roundtrippedAabb = new Float32Array(transportParsed.aabb as number[]);
+    expect(roundtrippedAabb).toHaveLength(6);
+    expect(roundtrippedAabb[0]).toBe(-1);
+    expect(roundtrippedAabb[5]).toBe(-3);
+
+    // --- 6. World setup ---
+    const world = new World();
+
+    // Material for MeshRenderer (any visible material; pick only needs
+    // the MeshFilter + MeshRenderer presence on the archetype).
+    const unlitMat = Materials.unlit([1, 1, 1, 1]) as unknown as MaterialAsset;
+    const unlitHandle = asHandle<'MaterialAsset'>(world.allocSharedRef('MaterialAsset', unlitMat));
+
+    // Reconstruct the MeshAsset payload with the roundtripped aabb and
+    // original typed arrays. Use a cast since exactOptionalPropertyTypes
+    // forbids spreading optional fields that resolve to undefined.
+    const meshPayload = {
+      kind: 'mesh' as const,
+      vertices: meshAsset.vertices,
+      ...(meshAsset.indices !== undefined ? { indices: meshAsset.indices } : {}),
+      submeshes: meshAsset.submeshes,
+      aabb: roundtrippedAabb,
+      attributes: meshAsset.attributes,
+    } as MeshAsset;
+
+    const meshHandle = asHandle<'MeshAsset'>(world.allocSharedRef('MeshAsset', meshPayload));
+
+    // Mesh entity at origin. Identity Transform → identity world mat4.
+    const meshEntity = world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: MeshFilter, data: { assetHandle: meshHandle } },
+        { component: MeshRenderer, data: { materials: [unlitHandle] } },
+      )
+      .unwrap();
+
+    // Camera entity at origin, looking down -Z (perspective).
+    // Identity Transform → identity world mat4 → view = identity.
+    const cameraEntity = world
+      .spawn(
+        { component: Transform, data: {} },
+        {
+          component: Camera,
+          data: perspective({ fov: Math.PI / 4, aspect: 1 }),
+        },
+      )
+      .unwrap();
+
+    // --- 7. pick hit: screen center (50, 50) on 100x100 → ndc (0, 0) → ray
+    //       straight down -Z → enters AABB at z=-3 → hit ---
+    const hit = pick(world, cameraEntity, 50, 50, 100, 100);
+    expect(hit).toBeDefined();
+    if (hit) {
+      expect(hit.entity).toBe(meshEntity);
+      // The entry point should be near the AABB front face at z=-3.
+      expect(Math.abs((hit.point[2] as number) - -3)).toBeLessThan(0.1);
+    }
+
+    // --- 8. Negative control: pick bottom-right corner (100, 100) on
+    //       100x100 → ndc (1, -1) → ray at Z=-3 lands at (x≈1.24, y≈-1.24)
+    //       which is outside the AABB x-range [-1, 1] → miss ---
+    const miss = pick(world, cameraEntity, 100, 100, 100, 100);
+    expect(miss).toBeUndefined();
+  });
+
+  it('mesh without aabb: pick() returns undefined (falsification witness)', () => {
+    // Create a MeshAsset payload that explicitly omits aabb, verifying
+    // that pick() skips it at the broad-phase check (pick.ts:184).
+    // This is a secondary in-code falsification — it repeats the
+    // comment-out-drill semantics without modifying M4 production code.
+    const world = new World();
+
+    const unlitMat = Materials.unlit([1, 1, 1, 1]) as unknown as MaterialAsset;
+    const unlitHandle = asHandle<'MaterialAsset'>(world.allocSharedRef('MaterialAsset', unlitMat));
+
+    const noAabbMesh = {
+      kind: 'mesh' as const,
+      vertices: new Float32Array([-1, -1, -3, 1, -1, -3, 0, 1, -3]),
+      indices: new Uint16Array([0, 1, 2]),
+      submeshes: [
+        {
+          indexOffset: 0,
+          indexCount: 3,
+          vertexCount: 3,
+          topology: 'triangle-list' as const,
+          materialSlot: 0,
+        },
+      ],
+      materialSlots: [{ slotName: 'Default' }],
+      attributes: {},
+    } satisfies MeshAsset;
+
+    const noAabbHandle = asHandle<'MeshAsset'>(world.allocSharedRef('MeshAsset', noAabbMesh));
+
+    world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: MeshFilter, data: { assetHandle: noAabbHandle } },
+        {
+          component: MeshRenderer,
+          data: { materials: [unlitHandle] },
+        },
+      )
+      .unwrap();
+
+    const cameraEntity = world
+      .spawn(
+        { component: Transform, data: {} },
+        {
+          component: Camera,
+          data: perspective({ fov: Math.PI / 4, aspect: 1 }),
+        },
+      )
+      .unwrap();
+
+    // Same center ray that would hit if aabb were present.
+    const miss = pick(world, cameraEntity, 50, 50, 100, 100);
+    expect(miss).toBeUndefined();
+  });
+});

package/src/__tests__/public-surface.unit.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, test } from 'vitest';
+import * as publicSurface from '../index';
+
+describe('gltf public surface', () => {
+  test('keeps parser/importer front doors without a version mirror', () => {
+    expect(typeof publicSurface.parseGltf).toBe('function');
+    expect(typeof publicSurface.gltfImporter).toBe('object');
+    expect('GLTF_PACKAGE_VERSION' in publicSurface).toBe(false);
+  });
+});

package/src/__tests__/source-key-producer.integration.test.ts

@@ -0,0 +1,163 @@
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { validateProducerOutputs } from '@forgeax/engine-pack';
+import { scan } from '@forgeax/engine-pack/scanner';
+import { describe, expect, it } from 'vitest';
+import { runCliGltf } from '../cli-gltf.js';
+import type { GltfDoc } from '../parse-gltf.js';
+import { toAssetPack } from '../parse-gltf.js';
+import { serializeMetaJson } from '../serialize-meta.js';
+
+function duplicateNamedMeshDoc(): GltfDoc {
+  return {
+    meshes: [
+      { name: 'Hero', positions: new Float32Array(), materialIndex: null, meshIndex: 0 },
+      { name: 'Hero', positions: new Float32Array(), materialIndex: null, meshIndex: 1 },
+    ],
+    materials: [],
+    nodes: [],
+    scenes: [],
+    textures: undefined,
+    images: undefined,
+    samplers: undefined,
+    skeletons: [],
+    animationClips: [],
+    defaultSceneIndex: 0,
+    diagnostics: { nodeNames: [], unsupportedExtensions: [], matrixTrsCoexistNodes: [] },
+  };
+}
+
+function uniqueNamedMeshDoc(): GltfDoc {
+  const doc = duplicateNamedMeshDoc();
+  return {
+    ...doc,
+    meshes: doc.meshes.map((mesh, index) => ({ ...mesh, name: `Hero${index}` })),
+  };
+}
+
+function duplicateNamedMaterialDoc(): GltfDoc {
+  const material = {
+    name: 'Window',
+    baseColorFactor: [1, 1, 1, 1] as const,
+    metallicFactor: 0,
+    roughnessFactor: 1,
+  };
+  return {
+    ...duplicateNamedMeshDoc(),
+    meshes: [],
+    materials: [material, material],
+  };
+}
+
+function duplicateNamedMeshGltfJson(): Record<string, unknown> {
+  const positions = new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]);
+  const bufferUri = `data:application/octet-stream;base64,${Buffer.from(positions.buffer).toString('base64')}`;
+  return {
+    asset: { version: '2.0' },
+    scene: 0,
+    scenes: [{ name: 'Scene', nodes: [0, 1] }],
+    nodes: [
+      { name: 'A', mesh: 0 },
+      { name: 'B', mesh: 1 },
+    ],
+    meshes: [
+      { name: 'Hero', primitives: [{ attributes: { POSITION: 0 } }] },
+      { name: 'Hero', primitives: [{ attributes: { POSITION: 0 } }] },
+    ],
+    accessors: [{ bufferView: 0, componentType: 5126, count: 3, type: 'VEC3' }],
+    bufferViews: [{ buffer: 0, byteOffset: 0, byteLength: positions.byteLength }],
+    buffers: [{ byteLength: positions.byteLength, uri: bufferUri }],
+  };
+}
+
+describe('glTF producer source-key boundary', () => {
+  it('returns a structured conflict before publishing duplicate semantic names', () => {
+    const result = toAssetPack(duplicateNamedMeshDoc(), undefined, 'duplicate.gltf');
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('duplicate-source-key');
+    expect(result.error.sourceIndices).toEqual([0, 1]);
+  });
+
+  it('applies the same preflight to duplicate material names', () => {
+    const result = toAssetPack(duplicateNamedMaterialDoc(), undefined, 'duplicate.gltf');
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('duplicate-source-key');
+    expect(result.error.sourceIndices).toEqual([0, 1]);
+  });
+
+  it('publishes producer-valid output when semantic identity is unique', () => {
+    const result = toAssetPack(uniqueNamedMeshDoc(), undefined, 'unique.gltf');
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(validateProducerOutputs(result.value.subAssets).ok).toBe(true);
+  });
+
+  it('serializes a valid output that the pack scanner accepts immediately', async () => {
+    const tempDir = await mkdtemp(join(tmpdir(), 'gltf-source-key-'));
+    try {
+      const result = toAssetPack(uniqueNamedMeshDoc(), undefined, 'unique.gltf');
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+      await writeFile(join(tempDir, 'unique.gltf'), '{}', 'utf-8');
+      await writeFile(
+        join(tempDir, 'unique.gltf.meta.json'),
+        serializeMetaJson(result.value.meta),
+        'utf-8',
+      );
+
+      const scanResult = await scan([tempDir]);
+      expect(scanResult.ok).toBe(true);
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it('fails before writing and preserves the previous sidecar', async () => {
+    const tempDir = await mkdtemp(join(tmpdir(), 'gltf-cli-source-key-'));
+    try {
+      const sourcePath = join(tempDir, 'duplicate.gltf');
+      const metaPath = `${sourcePath}.meta.json`;
+      const previous = serializeMetaJson({
+        schemaVersion: 1,
+        kind: 'external-asset-package',
+        importer: 'gltf',
+        source: 'duplicate.gltf',
+        subAssets: [
+          {
+            guid: '01928000-7c00-7000-8000-000000000001',
+            sourceIndex: 0,
+            kind: 'mesh',
+            sourceKey: 'mesh:previous',
+          },
+        ],
+        importSettings: {
+          defaultSceneIndex: 0,
+          diagnostics: { nodeNames: [], unsupportedExtensions: [], matrixTrsCoexistNodes: [] },
+        },
+      });
+      await writeFile(sourcePath, JSON.stringify(duplicateNamedMeshGltfJson()), 'utf-8');
+      await writeFile(metaPath, previous, 'utf-8');
+      const stderr: string[] = [];
+
+      const code = await runCliGltf(['import', sourcePath], {
+        stdoutWrite: () => {},
+        stderrWrite: (line) => stderr.push(line),
+      });
+
+      expect(code).toBe(1);
+      expect(JSON.parse(stderr[0] as string)).toMatchObject({
+        code: 'duplicate-source-key',
+        detail: { sourceIndices: [0, 1] },
+      });
+      expect(await readFile(metaPath, 'utf-8')).toBe(previous);
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/__tests__/source-key.unit.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, expectTypeOf, it } from 'vitest';
+import { type GltfMetaJson, reimportReuseMeta } from '../reimport-reuse-meta.js';
+import {
+  deriveGltfSourceKeys,
+  type GltfSourceKeyError,
+  type GltfSourceKeyErrorCode,
+} from '../source-key.js';
+
+const META_BASE: GltfMetaJson = {
+  schemaVersion: 1,
+  kind: 'external-asset-package',
+  importer: 'gltf',
+  source: 'scene.gltf',
+  subAssets: [],
+  importSettings: {
+    defaultSceneIndex: 0,
+    diagnostics: { nodeNames: [], unsupportedExtensions: [], matrixTrsCoexistNodes: [] },
+  },
+};
+
+describe('glTF producer sourceKey', () => {
+  it('derives the public error-code alias from its error owner', () => {
+    expectTypeOf<GltfSourceKeyErrorCode>().toEqualTypeOf<GltfSourceKeyError['code']>();
+  });
+
+  it('derives stable semantic keys without using sourceIndex or locator', () => {
+    const result = deriveGltfSourceKeys([
+      { kind: 'mesh', sourceIndex: 4, name: 'Hero' },
+      { kind: 'material', sourceIndex: 0, name: 'Skin' },
+    ]);
+    expect(result).toEqual({ ok: true, keys: ['mesh:Hero', 'material:Skin'], conflicts: [] });
+  });
+
+  it('reports duplicate semantic names as a structured conflict', () => {
+    const result = deriveGltfSourceKeys([
+      { kind: 'mesh', sourceIndex: 0, name: 'Hero' },
+      { kind: 'mesh', sourceIndex: 1, name: 'Hero' },
+    ]);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error.code).toBe('duplicate-source-key');
+  });
+
+  it('uses the semantic kind for one anonymous output, never sourceIndex', () => {
+    const result = deriveGltfSourceKeys([{ kind: 'mesh', sourceIndex: 7 }]);
+    expect(result).toEqual({ ok: true, keys: ['mesh'], conflicts: [] });
+  });
+
+  it('persists an output display name in the generated sub-asset entry', () => {
+    const result = reimportReuseMeta([{ kind: 'mesh', sourceIndex: 0, name: 'Hero' }], undefined);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.subAssets[0]).toMatchObject({
+      kind: 'mesh',
+      sourceKey: 'mesh:Hero',
+      name: 'Hero',
+    });
+  });
+
+  it('rejects two anonymous outputs of one kind as ambiguous', () => {
+    const result = deriveGltfSourceKeys([
+      { kind: 'mesh', sourceIndex: 7 },
+      { kind: 'mesh', sourceIndex: 9 },
+    ]);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error.code).toBe('ambiguous-source-key');
+  });
+
+  it('preserves keyed identity when output order changes', () => {
+    const existing: GltfMetaJson = {
+      ...META_BASE,
+      subAssets: [
+        {
+          guid: '01928000-7c00-7000-8000-000000000001',
+          sourceIndex: 0,
+          kind: 'mesh',
+          sourceKey: 'mesh:Hero',
+        },
+        {
+          guid: '01928000-7c00-7000-8000-000000000002',
+          sourceIndex: 1,
+          kind: 'mesh',
+          sourceKey: 'mesh:Body',
+        },
+      ],
+    };
+    const result = reimportReuseMeta(
+      [
+        { kind: 'mesh', sourceIndex: 0, name: 'Body' },
+        { kind: 'mesh', sourceIndex: 1, name: 'Hero' },
+      ],
+      existing,
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.subAssets).toMatchObject([
+      { guid: '01928000-7c00-7000-8000-000000000002', sourceIndex: 0, sourceKey: 'mesh:Body' },
+      { guid: '01928000-7c00-7000-8000-000000000001', sourceIndex: 1, sourceKey: 'mesh:Hero' },
+    ]);
+  });
+
+  it('preserves keyed identity when a new output is inserted', () => {
+    const existing: GltfMetaJson = {
+      ...META_BASE,
+      subAssets: [
+        {
+          guid: '01928000-7c00-7000-8000-000000000004',
+          sourceIndex: 0,
+          kind: 'mesh',
+          sourceKey: 'mesh:Hero',
+        },
+        {
+          guid: '01928000-7c00-7000-8000-000000000005',
+          sourceIndex: 1,
+          kind: 'mesh',
+          sourceKey: 'mesh:Body',
+        },
+      ],
+    };
+    const result = reimportReuseMeta(
+      [
+        { kind: 'mesh', sourceIndex: 0, name: 'New' },
+        { kind: 'mesh', sourceIndex: 1, name: 'Hero' },
+        { kind: 'mesh', sourceIndex: 2, name: 'Body' },
+      ],
+      existing,
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.subAssets.slice(1)).toMatchObject([
+      { guid: '01928000-7c00-7000-8000-000000000004', sourceKey: 'mesh:Hero' },
+      { guid: '01928000-7c00-7000-8000-000000000005', sourceKey: 'mesh:Body' },
+    ]);
+  });
+
+  it('reuses an anonymous semantic kind key when its sourceIndex changes', () => {
+    const existing: GltfMetaJson = {
+      ...META_BASE,
+      subAssets: [
+        {
+          guid: '01928000-7c00-7000-8000-000000000003',
+          sourceIndex: 0,
+          kind: 'scene',
+          sourceKey: 'scene',
+        },
+      ],
+    };
+    const result = reimportReuseMeta([{ kind: 'scene', sourceIndex: 9 }], existing);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.subAssets).toEqual([
+      {
+        guid: '01928000-7c00-7000-8000-000000000003',
+        sourceIndex: 9,
+        kind: 'scene',
+        sourceKey: 'scene',
+      },
+    ]);
+  });
+});