@forgeax/engine-runtime 0.1.4 → 0.1.6

package/src/__tests__/scene-mount-wrapper-roundtrip.test.ts

@@ -0,0 +1,202 @@
+// scene-mount-wrapper-roundtrip.test.ts — regression for the editor "Add to
+// Scene" ghost-node accretion bug.
+//
+// The editor's whole-GLB Add-to-Scene (spawnGlbSceneAsMount) produces a scene
+// pack shaped like:
+//     entities: [ ..., { localId: W, Name:"bed.glb", Transform, Children:[M] } ]
+//     mounts:   [ { localId: M, source: <bedGUID>, memberCount: N, parent: W } ]
+// i.e. an OWNED wrapper entity whose child is a nested mount. This is the exact
+// on-disk shape after the first add+save.
+//
+// On RELOAD, world.instantiateScene re-materialises the mount as a plain "mount
+// entity" (no Name, no SceneInstance — just Transform/ChildOf/Children) sitting
+// BETWEEN the wrapper and the child SceneInstance root. On the NEXT collect that
+// plain mount entity carries no SceneInstance, so rootsToSceneAsset emitted it
+// as an OWNED (nameless) entity + a fresh mount — one extra ghost node per
+// save→reload cycle. This test asserts collect is a FIXED POINT across two
+// reload cycles.
+
+import type { Asset } from '@forgeax/engine-assets-runtime';
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { World } from '@forgeax/engine-ecs';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import { Children, Name, Transform } from '@forgeax/engine-scene';
+import type { Handle, SceneAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { rootsToSceneAsset, serializeSceneAssetToPack } from '../collect-scene-asset';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+import { registerSceneComponents } from './helpers/register-scene-components';
+
+const G_CHILD = '11111111-1111-4111-8111-111111111111';
+const G_TOP = '22222222-2222-4222-8222-222222222222';
+
+function mkReg(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
+}
+function pg(s: string): AssetGuid {
+  const r = AssetGuid.parse(s);
+  if (!r.ok) throw new Error(`bad GUID: ${s}`);
+  return r.value;
+}
+function cat(reg: AssetRegistry, g: string, p: SceneAsset): void {
+  reg.catalog(pg(g), p as Asset);
+}
+function rs(w: World, a: SceneAsset): Handle<'SceneAsset', 'shared'> {
+  registerSceneComponents(w, [Name]);
+  return w.allocSharedRef('SceneAsset', a);
+}
+function accessParse(reg: AssetRegistry) {
+  const internal = reg as unknown as {
+    parseAssetPayload(kind: string, payload: Record<string, unknown>, refs?: string[]): unknown;
+  };
+  return (payload: Record<string, unknown>, refs?: readonly string[]): SceneAsset =>
+    internal.parseAssetPayload('scene', payload, refs as string[] | undefined) as SceneAsset;
+}
+function unpack(pack: Record<string, unknown>): {
+  payload: Record<string, unknown>;
+  refs: readonly string[] | undefined;
+} {
+  const a = (pack.assets as Record<string, unknown>[])[0] as Record<string, unknown>;
+  return { payload: a.payload as Record<string, unknown>, refs: a.refs as string[] | undefined };
+}
+
+describe('editor Add-to-Scene wrapper+mount round-trip (ghost accretion regression)', () => {
+  it('collect is a fixed point across reload cycles (no nameless ghost accretes)', () => {
+    const reg = mkReg();
+    const w = new World();
+
+    // Child scene = the "bed": one owned mesh entity.
+    const child: SceneAsset = {
+      kind: 'scene',
+      entities: [
+        {
+          localId: 0 as never,
+          components: { Name: { value: 'bed-mesh' }, Transform: { pos: [0, 0, 0] } },
+        },
+      ],
+    };
+    cat(reg, G_CHILD, child);
+
+    // Plain top scene with ONE owned entity (like spin-cube's Ground). The
+    // editor adds the mount live below via a wrapper (no mounts[] on disk yet).
+    const top: SceneAsset = {
+      kind: 'scene',
+      entities: [
+        {
+          localId: 0 as never,
+          components: { Name: { value: 'Ground' }, Transform: { pos: [0, 0, 0] } },
+        },
+      ],
+    };
+    cat(reg, G_TOP, top);
+
+    const parse = accessParse(reg);
+
+    const runCycle = (roots: number[]): { owned: number; mounts: number; pack: SceneAsset } => {
+      const c = rootsToSceneAsset(reg, w, roots as never);
+      if (!c.ok) throw new Error(`collect failed: ${JSON.stringify(c.error)}`);
+      return {
+        owned: c.value.entities.length,
+        mounts: (c.value.mounts ?? []).length,
+        pack: c.value,
+      };
+    };
+
+    // The editor's owned top-level roots after a reload = the named entities the
+    // session tracks (store.ts _e2h owned-set: the scene asset's entities[], not
+    // mount internals). Mirror that here by taking the NAMED entities reachable
+    // from the scene (Ground + the bed.glb wrapper), excluding the nameless
+    // mount carrier — exactly what the editor collects via entRootHandles.
+    const namedTopEntities = (syntheticRoot: number): number[] => {
+      const wr = w as unknown as {
+        get(
+          e: number,
+          c: unknown,
+        ): {
+          ok: boolean;
+          value?: { entities?: ArrayLike<number>; value?: string; parent?: number };
+        };
+      };
+      // BFS from the synthetic root over Children; keep NAMED entities whose
+      // parent is not itself a named-tracked entity (i.e. top-level owned roots).
+      const named: number[] = [];
+      const queue = [syntheticRoot];
+      const seen = new Set<number>([syntheticRoot]);
+      while (queue.length) {
+        const cur = queue.shift() as number;
+        const ch = wr.get(cur, Children);
+        if (ch.ok && ch.value?.entities) {
+          for (const k of Array.from(ch.value.entities)) {
+            if (seen.has(k)) continue;
+            seen.add(k);
+            queue.push(k);
+            if (wr.get(k, Name).ok) named.push(k);
+          }
+        }
+      }
+      return named;
+    };
+
+    // Instantiate the top scene.
+    const i0 = reg.instantiate(rs(w, top), w);
+    expect(i0.ok).toBe(true);
+    if (!i0.ok) return;
+
+    // ── Editor "Add to Scene": spawn a NAMED wrapper parented under the top
+    //    scene, then mount the child scene UNDER the wrapper (instantiate with
+    //    parent=wrapper). Mirrors spawnGlbSceneAsMount +
+    //    instantiateSceneRefUnderWorld. ──
+    const wrapperRes = w.spawn(
+      { component: Name, data: { value: 'bed.glb' } },
+      { component: Transform, data: { pos: [0, 0, 0] } },
+    );
+    expect(wrapperRes.ok).toBe(true);
+    if (!wrapperRes.ok) return;
+    const mountRes = reg.instantiate(rs(w, child), w, wrapperRes.value);
+    expect(mountRes.ok).toBe(true);
+    if (!mountRes.ok) return;
+
+    // Cycle 1: collect from the owned roots (Ground + wrapper).
+    // Ground is a child of the synthetic root; the wrapper is a free root we
+    // just spawned. Collect from both (the editor's entRootHandles set).
+    const groundRoots = namedTopEntities(i0.value as unknown as number);
+    const c1 = runCycle([...groundRoots, wrapperRes.value as unknown as number]);
+
+    // Cycle 2: serialize → parse → reload → collect.
+    const s1 = serializeSceneAssetToPack(c1.pack, w.components.entries(), G_TOP);
+    expect(s1.ok).toBe(true);
+    if (!s1.ok) return;
+    const u1 = unpack(s1.value);
+    const p1 = parse(u1.payload, u1.refs);
+    cat(reg, G_TOP, p1);
+    const i1 = reg.instantiate(rs(w, p1), w);
+    expect(i1.ok).toBe(true);
+    if (!i1.ok) return;
+    const c2 = runCycle(namedTopEntities(i1.value as unknown as number));
+
+    // Cycle 3: reload + collect once more (the ghost-accretion point).
+    const s2 = serializeSceneAssetToPack(c2.pack, w.components.entries(), G_TOP);
+    expect(s2.ok).toBe(true);
+    if (!s2.ok) return;
+    const u2 = unpack(s2.value);
+    const p2 = parse(u2.payload, u2.refs);
+    cat(reg, G_TOP, p2);
+    const i2 = reg.instantiate(rs(w, p2), w);
+    expect(i2.ok).toBe(true);
+    if (!i2.ok) return;
+    const c3 = runCycle(namedTopEntities(i2.value as unknown as number));
+
+    // ACCEPTANCE: owned + mount counts are a FIXED POINT across reloads (before
+    // the fix this grew unboundedly: owned 2 → 3 → 5, one nameless ghost per
+    // cycle). Ground + bed.glb wrapper = 2 owned; the bed = 1 mount.
+    expect({ owned: c1.owned, mounts: c1.mounts }).toEqual({ owned: 2, mounts: 1 });
+    expect({ owned: c2.owned, mounts: c2.mounts }).toEqual({ owned: 2, mounts: 1 });
+    expect({ owned: c3.owned, mounts: c3.mounts }).toEqual({ owned: 2, mounts: 1 });
+
+    // No owned entity is nameless (the ghost signature).
+    for (const e of c3.pack.entities) {
+      const comps = e.components as Record<string, Record<string, unknown>>;
+      expect(comps.Name, `owned entity localId ${e.localId} must have a Name`).toBeDefined();
+    }
+  });
+});

package/src/__tests__/scene-sugar-instantiate.test.ts

@@ -0,0 +1,324 @@
+import * as SceneOwner from '@forgeax/engine-scene';
+// scene-sugar-instantiate.test - engine.assets.instantiate sugar wrapper
+// runtime equivalence (feat-20260514-scene-as-world-blueprint w30; M3 rewrite
+// from old SceneInstanceId returns to new Entity returns).
+//
+// Coverage:
+//   (a) sugar entry runs the same pipeline as the main entry: a 2-node
+//       SceneAsset goes through `engine.assets.instantiate(handle, world)`
+//       and yields the same Entity root / mapping / overrides as the
+//       direct `SceneOwner.worldInstantiateScene(world, handle)` call (AC-03 +
+//       requirements §IN-3 sugar contract).
+//   (b) `parent?` passthrough: passing a parent through the sugar wrapper
+//       attaches `ChildOf { parent }` to the root nodes byte-for-byte the
+//       same way the main entry does.
+//   (c) error passthrough: when the underlying SceneAssetResolver returns
+//       Err, the sugar surface returns the same Err verbatim — no wrap, no
+//       rename, no message rewrite (research §error-model + plan-strategy
+//       §3.3 closed-union transparency).
+
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { defineComponent, type EntityHandle, World } from '@forgeax/engine-ecs';
+import { SceneInstance } from '@forgeax/engine-render';
+import { ChildOf } from '@forgeax/engine-scene';
+import type { Handle, LocalEntityId, SceneAsset, SceneEntity } from '@forgeax/engine-types';
+import { toShared } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+import { registerRuntimeComponents } from './helpers/register-runtime-components';
+
+function localId(n: number): LocalEntityId {
+  return n as LocalEntityId;
+}
+
+function buildScene(): SceneAsset {
+  const Transform = defineComponent('Transform', { pos: 'array<f32, 3>' });
+  void Transform;
+  const nodes: SceneEntity[] = [
+    { localId: localId(0), components: { Transform: { pos: [1, 0, 0] } } },
+    { localId: localId(1), components: { Transform: { pos: [2, 0, 0] } } },
+  ];
+  return { kind: 'scene', entities: nodes };
+}
+
+function registerSceneAsset(world: World, asset: SceneAsset): Handle<'SceneAsset', 'shared'> {
+  return world.allocSharedRef('SceneAsset', asset);
+}
+
+describe('w30 - engine.assets.instantiate sugar wrapper equivalence (AC-03)', () => {
+  it('(a) sugar entry produces the same Entity root / mapping shape as the main entry', () => {
+    defineComponent('Transform', { pos: 'array<f32, 3>' });
+    const reg = new AssetRegistry(makeMockShaderRegistry());
+    const asset = buildScene();
+    // Direct path baseline.
+    const worldA = new World();
+    registerRuntimeComponents(worldA);
+    const handleA = registerSceneAsset(worldA, asset);
+    const directRes = SceneOwner.worldInstantiateScene(worldA, handleA);
+    expect(directRes.ok).toBe(true);
+    if (!directRes.ok) return;
+    const directRoot = directRes.value.root;
+    const directInst = worldA.get(directRoot, SceneInstance);
+    expect(directInst.ok).toBe(true);
+    if (!directInst.ok) return;
+    const directState = SceneOwner.worldGetSceneInstanceState(worldA, directRoot);
+    expect(directState.ok).toBe(true);
+    if (!directState.ok) return;
+    // Sugar path.
+    const worldB = new World();
+    registerRuntimeComponents(worldB);
+    const handleB = registerSceneAsset(worldB, asset);
+    const sugarRes = reg.instantiate<SceneAsset>(handleB, worldB);
+    expect(sugarRes.ok).toBe(true);
+    if (!sugarRes.ok) return;
+    const sugarRoot: EntityHandle = sugarRes.value;
+    const sugarInst = worldB.get(sugarRoot, SceneInstance);
+    expect(sugarInst.ok).toBe(true);
+    if (!sugarInst.ok) return;
+    const sugarState = SceneOwner.worldGetSceneInstanceState(worldB, sugarRoot);
+    expect(sugarState.ok).toBe(true);
+    if (!sugarState.ok) return;
+    // Mapping length parity (2 nodes -> 2 slots).
+    expect(sugarInst.value.mapping.length).toBe(directInst.value.mapping.length);
+    expect(sugarState.value.overrides.size).toBe(directState.value.overrides.size);
+    expect(sugarState.value.overrides.size).toBe(0);
+  });
+
+  it('(b) parent? passthrough attaches ChildOf via the sugar entry', () => {
+    const Transform = defineComponent('Transform', { pos: 'array<f32, 3>' });
+    const reg = new AssetRegistry(makeMockShaderRegistry());
+    const asset = buildScene();
+    const world = new World();
+    registerRuntimeComponents(world);
+    const handle = registerSceneAsset(world, asset);
+    const parentSpawn = world.spawn({
+      component: Transform,
+      data: { pos: [0, 0, 0] },
+    });
+    expect(parentSpawn.ok).toBe(true);
+    if (!parentSpawn.ok) return;
+    const parentEntity: EntityHandle = parentSpawn.value;
+    const sugarRes = reg.instantiate<SceneAsset>(handle, world, parentEntity);
+    expect(sugarRes.ok).toBe(true);
+    if (!sugarRes.ok) return;
+    const sugarRoot: EntityHandle = sugarRes.value;
+    const sugarState = SceneOwner.worldGetSceneInstanceState(world, sugarRoot);
+    expect(sugarState.ok).toBe(true);
+    if (!sugarState.ok) return;
+    // The synthetic root now carries a ChildOf component pointing at the
+    // caller-supplied parent entity (root entities are children of the
+    // synthetic root, not of the caller-supplied parent directly).
+    const childOf = world.get(sugarRoot, ChildOf);
+    expect(childOf.ok).toBe(true);
+    if (!childOf.ok) return;
+    expect(childOf.value.parent).toBe(parentEntity);
+  });
+
+  it('(c) error passthrough: invalid handle -> sugar returns Err verbatim', () => {
+    const reg = new AssetRegistry(makeMockShaderRegistry());
+    const world = new World();
+    registerRuntimeComponents(world);
+    // Use a handle that is not a managed ref -> instantiateScene returns Err.
+    const bogusHandle = toShared<'SceneAsset'>(9999);
+    const r = reg.instantiate<SceneAsset>(bogusHandle, world);
+    expect(r.ok).toBe(false);
+    if (r.ok) return;
+    expect(typeof r.error).toBe('object');
+  });
+});
+
+// ── M5 post-instantiate component injection (w13) ──
+// feat-20260528-scene-asset-guid-refs-and-post-instantiate M5 / w13 TDD red.
+//
+// Coverage:
+//   (d) AC-09: rootEntities() + addComponent -> hasComponent=true (query-after pattern);
+//       canonical post-instantiate workflow for attaching custom components to
+//       the top-level nodes of a prefab instance without a per-instance
+//       instantiate(overrides) API.
+//   (e) AC-10: mapping[localId] + addComponent -> hasComponent=true;
+//       verifies that an AI user can reach any specific node by its Scene-authored
+//       localId and attach a component after instantiation.
+//   (f) rootEntities() snapshot stays stable after addComponent -- the returned
+//       array is a snapshot at call time, not a live view (SceneInstance contract).
+
+function buildPostScene(): SceneAsset {
+  const nodes: SceneEntity[] = [
+    { localId: localId(0), components: { Transform: { pos: [0, 0, 0] } } },
+    { localId: localId(1), components: { Transform: { pos: [1, 0, 0] }, ChildOf: { parent: 0 } } },
+  ];
+  return { kind: 'scene', entities: nodes };
+}
+
+// A lightweight component for post-instantiate injection testing.
+const Enemy = defineComponent('Enemy', { speed: 'f32', hp: 'u32' });
+
+// A second component so we can test per-localId injection independently.
+const Waypoint = defineComponent('Waypoint', { index: 'u32' });
+
+function postInstantiateEntity(entity: EntityHandle | number | undefined): EntityHandle {
+  if (typeof entity === 'number') return entity as EntityHandle;
+  throw new Error('rootEntities returned non-Entity entry');
+}
+
+describe('M5 post-instantiate component injection (w13 / AC-09 + AC-10)', () => {
+  it('(d) AC-09: rootEntities() + world.addComponent -> hasComponent is true', () => {
+    defineComponent('Transform', { pos: 'array<f32, 3>' });
+    const reg = new AssetRegistry(makeMockShaderRegistry());
+    const asset = buildPostScene();
+    const world = new World();
+    registerRuntimeComponents(world, [Enemy, Waypoint]);
+    const handle = registerSceneAsset(world, asset);
+    const r = reg.instantiate<SceneAsset>(handle, world);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    const root: EntityHandle = r.value;
+    const state = SceneOwner.worldGetSceneInstanceState(world, root);
+    expect(state.ok).toBe(true);
+    if (!state.ok) return;
+    const roots = state.value.rootEntities;
+    expect(roots.length).toBe(1);
+    const rootEntity = postInstantiateEntity(roots[0]);
+    // Attach Enemy component via the query-after pattern.
+    const addRes = world.addComponent(rootEntity, {
+      component: Enemy,
+      data: { speed: 4.5, hp: 2 },
+    });
+    expect(addRes.ok).toBe(true);
+    if (!addRes.ok) return;
+    const enemyCheck = world.get(rootEntity, Enemy);
+    expect(enemyCheck.ok).toBe(true);
+    if (!enemyCheck.ok) return;
+    expect(enemyCheck.value.speed).toBe(4.5);
+    expect(enemyCheck.value.hp).toBe(2);
+  });
+
+  it('(e) AC-10: mapping[localId] + world.addComponent -> hasComponent is true', () => {
+    defineComponent('Transform', { pos: 'array<f32, 3>' });
+    const reg = new AssetRegistry(makeMockShaderRegistry());
+    const asset = buildPostScene();
+    const world = new World();
+    registerRuntimeComponents(world, [Enemy, Waypoint]);
+    const handle = registerSceneAsset(world, asset);
+    const r = reg.instantiate<SceneAsset>(handle, world);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    const root: EntityHandle = r.value;
+    const inst = world.get(root, SceneInstance);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+    // Reach node 1 (child) by its localId via mapping array.
+    const mapping = inst.value.mapping;
+    const childEntity = mapping[1] as unknown as EntityHandle | undefined;
+    expect(childEntity).toBeDefined();
+    if (childEntity === undefined) return;
+    const addRes = world.addComponent(childEntity, {
+      component: Waypoint,
+      data: { index: 3 },
+    });
+    expect(addRes.ok).toBe(true);
+    if (!addRes.ok) return;
+    const wpCheck = world.get(childEntity, Waypoint);
+    expect(wpCheck.ok).toBe(true);
+    if (!wpCheck.ok) return;
+    expect(wpCheck.value.index).toBe(3);
+  });
+
+  it('(d-ii) AC-09: addComponent on a second root entity (multi-root scene)', () => {
+    // Two root nodes, each gets a different component via query-after.
+    defineComponent('Transform', { pos: 'array<f32, 3>' });
+    const multiRoot: SceneEntity[] = [
+      { localId: localId(0), components: { Transform: { pos: [0, 0, 0] } } },
+      { localId: localId(1), components: { Transform: { pos: [10, 0, 0] } } },
+    ];
+    const reg = new AssetRegistry(makeMockShaderRegistry());
+    const world = new World();
+    registerRuntimeComponents(world, [Enemy, Waypoint]);
+    const asset: SceneAsset = { kind: 'scene', entities: multiRoot };
+    const handle = registerSceneAsset(world, asset);
+    const r = reg.instantiate<SceneAsset>(handle, world);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    const root: EntityHandle = r.value;
+    const state = SceneOwner.worldGetSceneInstanceState(world, root);
+    expect(state.ok).toBe(true);
+    if (!state.ok) return;
+    const roots = state.value.rootEntities;
+    expect(roots.length).toBe(2);
+    // Attach Enemy to root 0, Waypoint to root 1.
+    const e0 = postInstantiateEntity(roots[0]);
+    const e1 = postInstantiateEntity(roots[1]);
+    const add0 = world.addComponent(e0, {
+      component: Enemy,
+      data: { speed: 3, hp: 1 },
+    });
+    expect(add0.ok).toBe(true);
+    expect(world.get(e0, Enemy).ok).toBe(true);
+    const add1 = world.addComponent(e1, {
+      component: Waypoint,
+      data: { index: 7 },
+    });
+    expect(add1.ok).toBe(true);
+    expect(world.get(e1, Waypoint).ok).toBe(true);
+  });
+
+  it('rootEntities snapshot is stable (not a live view)', () => {
+    defineComponent('Transform', { pos: 'array<f32, 3>' });
+    const reg = new AssetRegistry(makeMockShaderRegistry());
+    const world = new World();
+    registerRuntimeComponents(world, [Enemy, Waypoint]);
+    const singleRoot: SceneEntity[] = [
+      { localId: localId(0), components: { Transform: { pos: [0, 0, 0] } } },
+    ];
+    const asset: SceneAsset = { kind: 'scene', entities: singleRoot };
+    const handle = registerSceneAsset(world, asset);
+    const r = reg.instantiate<SceneAsset>(handle, world);
+    if (!r.ok) throw new Error(`instantiate failed: ${JSON.stringify(r.error)}`);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    const root: EntityHandle = r.value;
+    const state = SceneOwner.worldGetSceneInstanceState(world, root);
+    expect(state.ok).toBe(true);
+    if (!state.ok) return;
+    const roots1 = state.value.rootEntities;
+    // Add a component to the root entity and re-query.
+    const e = postInstantiateEntity(roots1[0]);
+    const addRes = world.addComponent(e, {
+      component: Enemy,
+      data: { speed: 1, hp: 10 },
+    });
+    expect(addRes.ok).toBe(true);
+    const state2 = SceneOwner.worldGetSceneInstanceState(world, root);
+    expect(state2.ok).toBe(true);
+    if (!state2.ok) return;
+    const roots2 = state2.value.rootEntities;
+    expect(roots1).toEqual(roots2);
+  });
+
+  it('mapping identity: mapping[localId] returns the same Entity across calls', () => {
+    defineComponent('Transform', { pos: 'array<f32, 3>' });
+    const reg = new AssetRegistry(makeMockShaderRegistry());
+    const world = new World();
+    registerRuntimeComponents(world);
+    const asset = buildPostScene();
+    const handle = registerSceneAsset(world, asset);
+    const r = reg.instantiate<SceneAsset>(handle, world);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    const root: EntityHandle = r.value;
+    const inst = world.get(root, SceneInstance);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+    const mapping1 = inst.value.mapping;
+    const inst2 = world.get(root, SceneInstance);
+    expect(inst2.ok).toBe(true);
+    if (!inst2.ok) return;
+    const mapping2 = inst2.value.mapping;
+    for (const lid of [0, 1]) {
+      const e1 = mapping1[lid];
+      const e2 = mapping2[lid];
+      expect(e1).toBeDefined();
+      expect(e2).toBeDefined();
+      expect(e1).toBe(e2);
+    }
+  });
+});