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

package/src/__tests__/collect-scene-mount-collapse.test.ts

@@ -0,0 +1,391 @@
+import * as SceneOwner from '@forgeax/engine-scene';
+// collect-scene-mount-collapse.test.ts — M2 mount-collapse tests
+// (feat-20260703-collect-nested-sceneinstance-to-mount-roundtrip).
+//
+// M1T7 AUDIT (feat-20260707-engine-world-clone-transient-for-editor-ssot):
+//   Classification: (c) unaffected — Children used only for runtime hierarchy
+//   wiring (w.get, w.addComponent), never for collect output assertions.
+//   SceneInstance absence assertions at lines 87-89 / 137-140 check that
+//   SceneInstance is absent from output — already true with old hardcoded skip
+//   and preserved by the new transient check. No test modification required.
+
+import type { Asset } from '@forgeax/engine-assets-runtime';
+import { AssetRegistry, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
+import { defineComponent, type EntityHandle, World } from '@forgeax/engine-ecs';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import { SceneInstance } from '@forgeax/engine-render';
+import { ChildOf, Children } from '@forgeax/engine-scene';
+import type { Handle, SceneAsset } from '@forgeax/engine-types';
+import { err, ok } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { rootsToSceneAsset } from '../collect-scene-asset';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+import { registerSceneComponents } from './helpers/register-scene-components';
+
+function mkReg() {
+  return new AssetRegistry(makeMockShaderRegistry());
+}
+function pg(s: string): AssetGuid {
+  const r = AssetGuid.parse(s);
+  if (!r.ok) throw new Error(`bad GUID`);
+  return r.value;
+}
+function soi(reg: AssetRegistry, p: SceneAsset, g: string) {
+  (reg as unknown as { _originIndex: WeakMap<SceneAsset, string> })._originIndex.set(p, g);
+}
+function rs(w: World, a: SceneAsset) {
+  registerSceneComponents(w);
+  return w.allocSharedRef('SceneAsset', a);
+}
+function wr(w: World, ph: Handle<'SceneAsset', 'shared'>, ch: Handle<'SceneAsset', 'shared'>) {
+  SceneOwner.worldSetSceneAssetResolver(w, (_s, pH) =>
+    (pH as unknown as number) === (ph as unknown as number)
+      ? ok(ch)
+      : err({ code: 'asset-not-found' }),
+  );
+}
+function rcoAll(reg: AssetRegistry, w: World, root: EntityHandle) {
+  for (const e of w.iterDescendants(root)) {
+    if (!w.get(e, SceneInstance).ok) continue;
+    const s = SceneOwner.worldGetSceneAssetForInstance(w, e);
+    if (!s.ok) continue;
+    const c = resolveAssetHandle<SceneAsset>(w, s.value as unknown as Handle<string, 'shared'>);
+    if (!c.ok) continue;
+    soi(reg, c.value as SceneAsset, G1);
+    soi(reg, c.value as SceneAsset, G2);
+  }
+}
+
+const G1 = 'cbe42beb-8975-5096-b3a1-3dda4cb4c077';
+const G2 = 'f6af7007-158f-4d92-9e47-93bf2f213e1f';
+
+// ── m2-t1: Form 2 — root itself is SceneInstance ──
+describe('m2-t1 — Form 2: root itself is SceneInstance', () => {
+  it('whole tree collapses: root stripped, child mount excludes members', () => {
+    const reg = mkReg();
+    const w = new World();
+    const child: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+    };
+    reg.catalog(pg(G1), child as Asset);
+
+    const parent: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: 0 as never, components: { Transform: { pos: [10, 0, 0] } } }],
+      mounts: [{ localId: 1 as never, source: 0, memberFirst: 2 as never, memberCount: 1 }],
+    };
+    const ch = rs(w, child);
+    const ph = rs(w, parent);
+    wr(w, ph, ch);
+
+    const inst = SceneOwner.worldInstantiateScene(w, ph);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+    rcoAll(reg, w, inst.value.root);
+
+    const res = rootsToSceneAsset(reg, w, [inst.value.root]);
+    expect(res.ok).toBe(true);
+    if (!res.ok) return;
+
+    // Root is SceneInstance → root's own entities are owned.
+    // Child's member entities are excluded.
+    const s = res.value;
+    expect(s.entities.length).toBeGreaterThanOrEqual(1); // parent's own entity
+    for (const e of s.entities) {
+      expect(
+        (e.components as Record<string, Record<string, unknown>>).SceneInstance,
+      ).toBeUndefined();
+    }
+    // Child anchor produces a mount.
+    expect(s.mounts).toBeDefined();
+    expect(s.mounts?.length).toBe(1);
+    expect(s.mounts?.[0]?.source).toBe(G1);
+  });
+});
+
+// ── m2-t2: Form 1 — deep anchor ──
+describe('m2-t2 — Form 1: deep anchor with ChildOf parent', () => {
+  it('anchor subtree collapses, ancestors preserved as owned', () => {
+    const reg = mkReg();
+    const w = new World();
+    const child: SceneAsset = {
+      kind: 'scene',
+      entities: [
+        { localId: 0 as never, components: { Transform: { pos: [1, 0, 0] } } },
+        { localId: 1 as never, components: { Transform: { pos: [2, 0, 0] } } },
+      ],
+    };
+    reg.catalog(pg(G1), child as Asset);
+    const ch = rs(w, child);
+
+    const outerRes = w.spawn({ component: ChildOf, data: { parent: 0 as EntityHandle } });
+    expect(outerRes.ok).toBe(true);
+    if (!outerRes.ok) return;
+    const outerE = outerRes.value;
+
+    const ci = SceneOwner.worldInstantiateScene(w, ch, outerE);
+    expect(ci.ok).toBe(true);
+    if (!ci.ok) return;
+    rcoAll(reg, w, ci.value.root);
+
+    // Wire Children on outer root so collectSubtree discovers anchor.
+    const ec = w.get(outerE, Children as never);
+    if (!ec.ok)
+      w.addComponent(outerE, { component: Children, data: { entities: [ci.value.root] } } as never);
+
+    const res = rootsToSceneAsset(reg, w, [outerE]);
+    expect(res.ok).toBe(true);
+    if (!res.ok) return;
+
+    // Outer root is NOT SceneInstance → no mount for it.
+    // Child anchor produces a mount; its member entities excluded from owned.
+    expect(res.value.mounts).toBeDefined();
+    expect(res.value.mounts?.length).toBe(1);
+    expect(res.value.mounts?.[0]?.source).toBe(G1);
+    for (const e of res.value.entities) {
+      expect(
+        (e.components as Record<string, Record<string, unknown>>).SceneInstance,
+      ).toBeUndefined();
+    }
+  });
+});
+
+// ── m2-t3: AC-03 window invariants ──
+describe('m2-t3 — AC-03 window invariants', () => {
+  it('mount window covers full totalSlots', () => {
+    const reg = mkReg();
+    const w = new World();
+    const ca: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+    };
+    reg.catalog(pg(G1), ca as Asset);
+    const ch = rs(w, ca);
+
+    const pa: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+      mounts: [{ localId: 1 as never, source: 0, memberFirst: 2 as never, memberCount: 1 }],
+    };
+    const ph = rs(w, pa);
+    wr(w, ph, ch);
+    const inst = SceneOwner.worldInstantiateScene(w, ph);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+    rcoAll(reg, w, inst.value.root);
+
+    const res = rootsToSceneAsset(reg, w, [inst.value.root]);
+    expect(res.ok).toBe(true);
+    if (!res.ok) return;
+    expect(res.value.mounts?.[0]?.memberCount).toBe(1);
+  });
+
+  it('sparse localId does not shrink window', () => {
+    const reg = mkReg();
+    const w = new World();
+    const ca: SceneAsset = {
+      kind: 'scene',
+      entities: [
+        { localId: 0 as never, components: { Transform: { pos: [1, 0, 0] } } },
+        { localId: 1 as never, components: { Transform: { pos: [2, 0, 0] } } },
+      ],
+    };
+    reg.catalog(pg(G1), ca as Asset);
+    const ch = rs(w, ca);
+
+    const pa: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+      mounts: [{ localId: 1 as never, source: 0, memberFirst: 2 as never, memberCount: 2 }],
+    };
+    const ph = rs(w, pa);
+    wr(w, ph, ch);
+    const inst = SceneOwner.worldInstantiateScene(w, ph);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+    rcoAll(reg, w, inst.value.root);
+
+    // Despawn one member to create sparse mapping.
+    // Member slots start at memberFirst=2 (mount entity is at mapping[1]).
+    // Despawning the mount entity would cascade-kill the child synthetic root
+    // (ChildOf.linkedSpawn=true), erasing the anchor entirely.
+    const si = w.get(inst.value.root, SceneInstance);
+    if (si.ok && si.value.mapping[2] !== undefined) w.despawn(si.value.mapping[2] as EntityHandle);
+
+    const res = rootsToSceneAsset(reg, w, [inst.value.root]);
+    expect(res.ok).toBe(true);
+    if (!res.ok) return;
+    expect(res.value.mounts?.[0]?.memberCount).toBe(2); // totalSlots, not live count
+  });
+
+  it('multiple child mounts have non-overlapping windows', () => {
+    const reg = mkReg();
+    const w = new World();
+    const cA: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+    };
+    const cB: SceneAsset = {
+      kind: 'scene',
+      entities: [
+        { localId: 0 as never, components: { Transform: {} } },
+        { localId: 1 as never, components: { Transform: {} } },
+      ],
+    };
+    reg.catalog(pg(G1), cA as Asset);
+    reg.catalog(pg(G2), cB as Asset);
+    const hA = rs(w, cA);
+    const hB = rs(w, cB);
+
+    const pa: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+      mounts: [
+        { localId: 1 as never, source: 0, memberFirst: 3 as never, memberCount: 1 },
+        { localId: 2 as never, source: 1, memberFirst: 4 as never, memberCount: 2 },
+      ],
+    };
+    const ph = rs(w, pa);
+    SceneOwner.worldSetSceneAssetResolver(w, (sIdx, pH) =>
+      (pH as unknown as number) !== (ph as unknown as number)
+        ? err({ code: 'asset-not-found' })
+        : sIdx === 0
+          ? ok(hA)
+          : ok(hB),
+    );
+
+    const inst = SceneOwner.worldInstantiateScene(w, ph);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+    for (const e of w.iterDescendants(inst.value.root)) {
+      if (!w.get(e, SceneInstance).ok) continue;
+      const s = SceneOwner.worldGetSceneAssetForInstance(w, e);
+      if (!s.ok) continue;
+      const c = resolveAssetHandle<SceneAsset>(w, s.value as unknown as Handle<string, 'shared'>);
+      if (!c.ok) continue;
+      soi(reg, c.value as SceneAsset, c.value.entities.length === 1 ? G1 : G2);
+    }
+
+    const res = rootsToSceneAsset(reg, w, [inst.value.root]);
+    expect(res.ok).toBe(true);
+    if (!res.ok) return;
+
+    const ms = res.value.mounts ?? [];
+    expect(ms.length).toBe(2);
+    const W = ms
+      .map((m) => ({ f: m.memberFirst as number, c: m.memberCount }))
+      .sort((a, b) => a.f - b.f);
+    for (let i = 0; i < W.length - 1; i++) {
+      const cur = W[i];
+      const next = W[i + 1];
+      if (!cur || !next) throw new Error('window index out of range');
+      expect(cur.f + cur.c).toBeLessThanOrEqual(next.f);
+    }
+    const owned = new Set(res.value.entities.map((e) => e.localId as unknown as number));
+    for (const w of W)
+      for (let lid = w.f; lid < w.f + w.c; lid++) expect(owned.has(lid)).toBe(false);
+  });
+});
+
+// ── m2-t4: Graft preservation ──
+describe('m2-t4 — graft preservation', () => {
+  it('graft entity under a member survives as owned', () => {
+    const reg = mkReg();
+    const w = new World();
+    const ca: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+    };
+    reg.catalog(pg(G1), ca as Asset);
+    const ch = rs(w, ca);
+
+    const pa: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+      mounts: [{ localId: 1 as never, source: 0, memberFirst: 2 as never, memberCount: 1 }],
+    };
+    const ph = rs(w, pa);
+    wr(w, ph, ch);
+    const inst = SceneOwner.worldInstantiateScene(w, ph);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+    const root = inst.value.root;
+    rcoAll(reg, w, root);
+
+    const si = w.get(root, SceneInstance);
+    if (!si.ok) return;
+    const member = si.value.mapping[0];
+    if (member === undefined) return;
+
+    // Graft a prop entity under the member.
+    const prop = w.spawn({ component: ChildOf, data: { parent: member as EntityHandle } });
+    expect(prop.ok).toBe(true);
+    if (!prop.ok) return;
+    w.addComponent(
+      member as EntityHandle,
+      { component: Children, data: { entities: [prop.value] } } as never,
+    );
+
+    const res = rootsToSceneAsset(reg, w, [root]);
+    expect(res.ok).toBe(true);
+    if (!res.ok) return;
+
+    // Prop should survive as owned entity (not eaten by mount).
+    let propFound = false;
+    for (const e of res.value.entities) {
+      if ((e.components as Record<string, Record<string, unknown>>).ChildOf) {
+        propFound = true;
+        break;
+      }
+    }
+    expect(propFound).toBe(true);
+  });
+
+  it('unmappable cross-window entity ref fails fast', () => {
+    const reg = mkReg();
+    const w = new World();
+    const ca: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+    };
+    reg.catalog(pg(G1), ca as Asset);
+    const ch = rs(w, ca);
+
+    const pa: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+      mounts: [{ localId: 1 as never, source: 0, memberFirst: 2 as never, memberCount: 1 }],
+    };
+    const ph = rs(w, pa);
+    wr(w, ph, ch);
+    const inst = SceneOwner.worldInstantiateScene(w, ph);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+    const root = inst.value.root;
+    rcoAll(reg, w, root);
+
+    const si = w.get(root, SceneInstance);
+    if (!si.ok) return;
+    const member = si.value.mapping[0];
+    if (member === undefined) return;
+
+    // Graft with ChildOf.parent pointing outside closure.
+    // Spawn `outside` without ChildOf — no parent linkage, so it stays
+    // unreachable from the root subtree and _rlid(graft.parent) fails.
+    const outside = w.spawn();
+    expect(outside.ok).toBe(true);
+    if (!outside.ok) return;
+
+    const CrossWindowRef = defineComponent('CrossWindowRef', { target: 'entity' });
+    registerSceneComponents(w, [CrossWindowRef]);
+    const graft = w.spawn(
+      { component: ChildOf, data: { parent: member as EntityHandle } },
+      { component: CrossWindowRef, data: { target: outside.value } },
+    );
+    expect(graft.ok).toBe(true);
+    if (!graft.ok) return;
+    const res = rootsToSceneAsset(reg, w, [root]);
+    expect(res.ok).toBe(false); // fail-fast
+  });
+});

package/src/__tests__/collect-subtree.unit.test.ts

@@ -0,0 +1,75 @@
+// M1 test — collectSubtree shared visited de-duplication (AC-03, AC-16).
+//
+// Verifies the extracted collectSubtree shared util:
+//   (a) single root with 3-tier descendants — visited.size equals total closure
+//   (b) roots=[A, A_child] with shared external visited — no error, no duplicates
+//   (c) no visited argument — util creates its own Set internally
+//
+// TDD phase "red": collect-subtree.ts does not exist yet.
+
+import { type EntityHandle, World } from '@forgeax/engine-ecs';
+import { ChildOf, collectSubtree, Name } from '@forgeax/engine-scene';
+import { describe, expect, it } from 'vitest';
+
+// Build a chain of N entities linked by Children.
+// Returns the array of entity raw IDs from root down.
+function buildChain(world: World, depth: number): number[] {
+  const ids: number[] = [];
+  let parent: EntityHandle | undefined;
+  for (let i = 0; i < depth; i++) {
+    const res =
+      parent === undefined
+        ? world.spawn({ component: Name, data: { value: `e${i}` } })
+        : world.spawn(
+            { component: Name, data: { value: `e${i}` } },
+            { component: ChildOf, data: { parent } },
+          );
+    if (!res.ok) throw new Error(`spawn failed: ${i}`);
+    ids.push(res.value as number);
+    parent = res.value;
+  }
+  return ids;
+}
+
+describe('collectSubtree — AC-03 shared visited', () => {
+  it('single root with 3-tier descendants yields visited.size = total closure', () => {
+    const world = new World();
+    const chain = buildChain(world, 4); // 4 entities: e0 -> e1 -> e2 -> e3
+    const visited = collectSubtree(world, chain[0] as EntityHandle);
+    expect(visited.size).toBe(4);
+    expect(visited.has(chain[0] as number)).toBe(true);
+    expect(visited.has(chain[1] as number)).toBe(true);
+    expect(visited.has(chain[2] as number)).toBe(true);
+    expect(visited.has(chain[3] as number)).toBe(true);
+  });
+
+  it('roots=[A, A_child] with shared visited — no error and no duplicates', () => {
+    const world = new World();
+    const chain = buildChain(world, 4); // e0 -> e1 -> e2 -> e3
+    const sharedVisited = new Set<number>();
+    const visited1 = collectSubtree(world, chain[0] as EntityHandle, sharedVisited);
+    const visited2 = collectSubtree(world, chain[1] as EntityHandle, sharedVisited);
+    // Both calls use the same sharedVisited; no duplicates
+    expect(sharedVisited.size).toBe(4);
+    expect(visited1).toBe(sharedVisited);
+    expect(visited2).toBe(sharedVisited);
+  });
+
+  it('no visited argument — creates a new Set internally', () => {
+    const world = new World();
+    const chain = buildChain(world, 3);
+    const visited = collectSubtree(world, chain[0] as EntityHandle);
+    expect(visited).toBeInstanceOf(Set);
+    expect(visited.size).toBe(3);
+  });
+
+  it('leaf entity (no Children) returns set containing only itself', () => {
+    const world = new World();
+    const res = world.spawn({ component: Name, data: { value: 'leaf' } });
+    expect(res.ok).toBe(true);
+    const e = res.ok ? res.value : 0;
+    const visited = collectSubtree(world, e as EntityHandle);
+    expect(visited.size).toBe(1);
+    expect(visited.has(e as number)).toBe(true);
+  });
+});

package/src/__tests__/collect-transient-children-absent.test.ts

@@ -0,0 +1,168 @@
+import * as SceneOwner from '@forgeax/engine-scene';
+
+// feat-20260707-engine-world-clone-transient-for-editor-ssot M1 / m1t3:
+// Children-absent collect test (AC-04).
+//
+// After Children is declared transient:true (and SceneInstance likewise),
+// rootsToSceneAsset on a scene with parent-child hierarchy produces SceneAsset
+// where NO entity's components record contains a 'Children' key.
+//
+// TDD red-phase: this test asserts POST-FIX behavior. Before m1t6 lands,
+// Children IS serialized (double-write bug) — the test will FAIL, confirming
+// the bug exists. After m1t6 fixes collect to skip transient components,
+// the test must PASS.
+
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { World } from '@forgeax/engine-ecs';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import type { LocalEntityId, SceneAsset, SceneEntity } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { rootsToSceneAsset } from '../collect-scene-asset';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+import { registerSceneComponents } from './helpers/register-scene-components';
+
+function makeRegistry(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
+}
+
+function localId(n: number): LocalEntityId {
+  return n as LocalEntityId;
+}
+
+function hasComp(entity: SceneEntity, name: string): boolean {
+  return (entity.components as Record<string, Record<string, unknown>>)[name] !== undefined;
+}
+
+describe('m1t3 — Children absent from collect (AC-04)', () => {
+  it('2-level hierarchy: no entity has Children in collect output', () => {
+    const asset: SceneAsset = {
+      kind: 'scene',
+      entities: [
+        { localId: localId(0), components: {} },
+        { localId: localId(1), components: {} },
+      ],
+    };
+
+    const world = new World();
+    registerSceneComponents(world);
+    const reg = makeRegistry();
+    const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
+    if (sg.ok) reg.catalog(sg.value, asset);
+    // biome-ignore lint/suspicious/noExplicitAny: branded type mismatch
+    const handle = world.allocSharedRef('SceneAsset', asset) as any;
+    const res = SceneOwner.worldInstantiateScene(world, handle);
+    expect(res.ok).toBe(true);
+    if (!res.ok) return;
+
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
+    expect(collected.ok).toBe(true);
+    if (!collected.ok) return;
+
+    // Verify: no entity in the collected scene has 'Children' component.
+    for (const ent of collected.value.entities) {
+      expect(hasComp(ent, 'Children')).toBe(false);
+    }
+
+    // Also verify no entity has 'SceneInstance'.
+    for (const ent of collected.value.entities) {
+      expect(hasComp(ent, 'SceneInstance')).toBe(false);
+    }
+  });
+
+  it('3-level hierarchy: all entities free of Children in collect output', () => {
+    // Nest 3 levels: use nested instantiateScene calls with child scene assets.
+    // Level 1: outer parent scene.
+    // Level 2: mid scene instantiated under outer parent entity.
+    // Level 3: leaf scene instantiated under mid scene entity.
+    const leafAsset: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: localId(0), components: {} }],
+    };
+    const midAsset: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: localId(0), components: {} }],
+    };
+    const outerAsset: SceneAsset = {
+      kind: 'scene',
+      entities: [
+        { localId: localId(0), components: {} },
+        { localId: localId(1), components: {} },
+      ],
+    };
+
+    const world = new World();
+    registerSceneComponents(world);
+    const reg = makeRegistry();
+    const sg0 = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
+    const sg1 = AssetGuid.parse('11111111-1111-1111-1111-111111111111');
+    const sg2 = AssetGuid.parse('22222222-2222-2222-2222-222222222222');
+    if (sg0.ok) reg.catalog(sg0.value, leafAsset);
+    if (sg1.ok) reg.catalog(sg1.value, midAsset);
+    if (sg2.ok) reg.catalog(sg2.value, outerAsset);
+
+    // biome-ignore lint/suspicious/noExplicitAny: branded type mismatch
+    const leafH = world.allocSharedRef('SceneAsset', leafAsset) as any;
+    // biome-ignore lint/suspicious/noExplicitAny: branded type mismatch
+    const midH = world.allocSharedRef('SceneAsset', midAsset) as any;
+    // biome-ignore lint/suspicious/noExplicitAny: branded type mismatch
+    const outerH = world.allocSharedRef('SceneAsset', outerAsset) as any;
+
+    // Instantiate outer scene first.
+    const outerInst = SceneOwner.worldInstantiateScene(world, outerH);
+    expect(outerInst.ok).toBe(true);
+    if (!outerInst.ok) return;
+
+    // Find entity at localId 0 under outer root — this is the anchor for mid.
+    // We use iterDescendants to find it or directly spawn ChildOf under root.
+    // Simpler: instantiate mid under outer root directly.
+    const midInst = SceneOwner.worldInstantiateScene(world, midH, outerInst.value.root);
+    expect(midInst.ok).toBe(true);
+    if (!midInst.ok) return;
+
+    // Instantiate leaf under mid root.
+    const leafInst = SceneOwner.worldInstantiateScene(world, leafH, midInst.value.root);
+    expect(leafInst.ok).toBe(true);
+    if (!leafInst.ok) return;
+
+    // Collect from outer root.
+    const collected = rootsToSceneAsset(reg, world, [outerInst.value.root]);
+    expect(collected.ok).toBe(true);
+    if (!collected.ok) return;
+
+    // Hierarchy: outer root + (2 outer children) + mid root + (1 mid child) + leaf root + (1 leaf child) >= 7 entities.
+    // But the exact count depends on mount-collapse logic — focus on the Children assertion.
+    expect(collected.value.entities.length).toBeGreaterThan(0);
+
+    // No entity has Children or SceneInstance.
+    for (const ent of collected.value.entities) {
+      expect(hasComp(ent, 'Children')).toBe(false);
+      expect(hasComp(ent, 'SceneInstance')).toBe(false);
+    }
+  });
+
+  it('degenerate: zero-hierarchy scene has no Children', () => {
+    const asset: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: localId(0), components: {} }],
+    };
+
+    const world = new World();
+    registerSceneComponents(world);
+    const reg = makeRegistry();
+    const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
+    if (sg.ok) reg.catalog(sg.value, asset);
+    // biome-ignore lint/suspicious/noExplicitAny: branded type mismatch
+    const handle = world.allocSharedRef('SceneAsset', asset) as any;
+    const res = SceneOwner.worldInstantiateScene(world, handle);
+    expect(res.ok).toBe(true);
+    if (!res.ok) return;
+
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
+    expect(collected.ok).toBe(true);
+    if (!collected.ok) return;
+
+    for (const ent of collected.value.entities) {
+      expect(hasComp(ent, 'Children')).toBe(false);
+    }
+  });
+});