@forgeax/engine-runtime 0.1.4 → 0.1.6

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

@@ -8,8 +8,7 @@
 // TDD phase "red": collect-subtree.ts does not exist yet.
 
 import { type EntityHandle, World } from '@forgeax/engine-ecs';
-import { collectSubtree } from '@forgeax/engine-render/internal';
-import { ChildOf, Name } from '@forgeax/engine-scene';
+import { ChildOf, collectSubtree, Name } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
 
 // Build a chain of N entities linked by Children.

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

@@ -1,4 +1,5 @@
 import * as SceneOwner from '@forgeax/engine-scene';
+
 // feat-20260707-engine-world-clone-transient-for-editor-ssot M1 / m1t3:
 // Children-absent collect test (AC-04).
 //
@@ -11,12 +12,18 @@ import * as SceneOwner from '@forgeax/engine-scene';
 // 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';
-import { createTestSceneAssetStore } from './helpers/scene-asset-port';
+
+function makeRegistry(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
+}
 
 function localId(n: number): LocalEntityId {
   return n as LocalEntityId;
@@ -38,14 +45,16 @@ describe('m1t3 — Children absent from collect (AC-04)', () => {
 
     const world = new World();
     registerSceneComponents(world);
-    const assets = createTestSceneAssetStore();
+    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(assets.port, world, [res.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
@@ -83,10 +92,13 @@ describe('m1t3 — Children absent from collect (AC-04)', () => {
 
     const world = new World();
     registerSceneComponents(world);
-    const assets = createTestSceneAssetStore();
-    assets.add('00000000-0000-0000-0000-000000000000', leafAsset);
-    assets.add('11111111-1111-1111-1111-111111111111', midAsset);
-    assets.add('22222222-2222-2222-2222-222222222222', outerAsset);
+    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;
@@ -113,7 +125,7 @@ describe('m1t3 — Children absent from collect (AC-04)', () => {
     if (!leafInst.ok) return;
 
     // Collect from outer root.
-    const collected = rootsToSceneAsset(assets.port, world, [outerInst.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [outerInst.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
@@ -136,14 +148,16 @@ describe('m1t3 — Children absent from collect (AC-04)', () => {
 
     const world = new World();
     registerSceneComponents(world);
-    const assets = createTestSceneAssetStore();
+    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(assets.port, world, [res.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 

package/src/__tests__/collect-transient-roundtrip.test.ts

@@ -1,3 +1,5 @@
+import * as SceneOwner from '@forgeax/engine-scene';
+
 // feat-20260707-engine-world-clone-transient-for-editor-ssot M1 / m1t4:
 // AC-05 roundtrip regression test (red-first — falsification anchor).
 //
@@ -10,31 +12,33 @@
 //   (b) Each child's ChildOf.parent points back (bijective check).
 //   (c) Degenerate: zero parent-child scene round-trips correctly.
 
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import type { EntityHandle } from '@forgeax/engine-ecs';
 import { World } from '@forgeax/engine-ecs';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import { ChildOf, Children, propagateTransforms, Transform } from '@forgeax/engine-scene';
 import type { LocalEntityId, SceneAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import '@forgeax/engine-render/internal';
-import * as SceneOwner from '@forgeax/engine-scene';
-import { ChildOf, Children, propagateTransforms, Transform } from '@forgeax/engine-scene';
 import { rootsToSceneAsset } from '../collect-scene-asset';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
 import { registerSceneComponents } from './helpers/register-scene-components';
-import { createTestSceneAssetStore } from './helpers/scene-asset-port';
 
 // Read the resolved world mat4 (column-major 16 floats) from the Transform
 // world column array view.
 function worldOf(world: World, entity: EntityHandle): Float32Array {
-  const transform = world.get(entity, Transform);
-  if (!transform.ok) throw new Error('Transform.world view missing');
-  return transform.value.world;
+  return world.get(entity, Transform).unwrap().world;
+}
+
+function makeRegistry(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
 }
 
 function localId(n: number): LocalEntityId {
   return n as LocalEntityId;
 }
 
-function registerSceneAsset(world: World, asset: SceneAsset) {
-  registerSceneComponents(world);
+// biome-ignore lint/suspicious/noExplicitAny: branded Handle type mismatch
+function registerSceneAsset(world: World, asset: SceneAsset): any {
   return world.allocSharedRef('SceneAsset', asset);
 }
 
@@ -53,21 +57,28 @@ describe('m1t4 — AC-05 roundtrip regression (red-first)', () => {
     };
 
     const world = new World();
-    const assets = createTestSceneAssetStore();
+    registerSceneComponents(world);
+    const reg = makeRegistry();
+    const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
 
     // Collect from the instantiated scene.
-    const collected = rootsToSceneAsset(assets.port, world, [res.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
     // Round-trip to a fresh world.
     const world2 = new World();
     registerSceneComponents(world2);
-    const h2 = world2.allocSharedRef('SceneAsset', collected.value);
+    const reg2 = makeRegistry();
+    const sg2 = AssetGuid.parse('11111111-1111-1111-1111-111111111111');
+    if (sg2.ok) reg2.catalog(sg2.value, collected.value);
+    // biome-ignore lint/suspicious/noExplicitAny: branded Handle type mismatch
+    const h2 = world2.allocSharedRef('SceneAsset', collected.value) as any;
     const inst2 = SceneOwner.worldInstantiateScene(world2, h2);
     expect(inst2.ok).toBe(true);
     if (!inst2.ok) return;
@@ -115,27 +126,33 @@ describe('m1t4 — AC-05 roundtrip regression (red-first)', () => {
     };
 
     const world = new World();
-    const assets = createTestSceneAssetStore();
+    registerSceneComponents(world);
+    const reg = makeRegistry();
+    const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
 
-    const collected = rootsToSceneAsset(assets.port, world, [res.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
     // Round-trip through a second world.
     const world2 = new World();
     registerSceneComponents(world2);
-    const assets2 = createTestSceneAssetStore();
-    const h2 = world2.allocSharedRef('SceneAsset', collected.value);
+    const reg2 = makeRegistry();
+    const sg2 = AssetGuid.parse('11111111-1111-1111-1111-111111111111');
+    if (sg2.ok) reg2.catalog(sg2.value, collected.value);
+    // biome-ignore lint/suspicious/noExplicitAny: branded Handle type mismatch
+    const h2 = world2.allocSharedRef('SceneAsset', collected.value) as any;
     const inst2 = SceneOwner.worldInstantiateScene(world2, h2);
     expect(inst2.ok).toBe(true);
     if (!inst2.ok) return;
 
     // Second collect also works.
-    const collected2 = rootsToSceneAsset(assets2.port, world2, [inst2.value.root]);
+    const collected2 = rootsToSceneAsset(reg2, world2, [inst2.value.root]);
     expect(collected2.ok).toBe(true);
   });
 });
@@ -172,7 +189,10 @@ describe('w1 — AC-04 transient world roundtrip numeric equivalence', () => {
     };
 
     const world = new World();
-    const assets = createTestSceneAssetStore();
+    registerSceneComponents(world);
+    const reg = makeRegistry();
+    const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
@@ -182,7 +202,7 @@ describe('w1 — AC-04 transient world roundtrip numeric equivalence', () => {
     expect(propagateTransforms(world).ok).toBe(true);
     // The Transform entity is the child of the synthetic root; locate it via
     // the collect closure being 2 entities (root + our entity).
-    const collected = rootsToSceneAsset(assets.port, world, [res.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
@@ -195,7 +215,11 @@ describe('w1 — AC-04 transient world roundtrip numeric equivalence', () => {
     // Round-trip into a fresh world.
     const world2 = new World();
     registerSceneComponents(world2);
-    const h2 = world2.allocSharedRef('SceneAsset', collected.value);
+    const reg2 = makeRegistry();
+    const sg2 = AssetGuid.parse('11111111-1111-1111-1111-111111111111');
+    if (sg2.ok) reg2.catalog(sg2.value, collected.value);
+    // biome-ignore lint/suspicious/noExplicitAny: branded Handle type mismatch
+    const h2 = world2.allocSharedRef('SceneAsset', collected.value) as any;
     const inst2 = SceneOwner.worldInstantiateScene(world2, h2);
     expect(inst2.ok).toBe(true);
     if (!inst2.ok) return;