@forgeax/engine-render 0.1.2

package/src/__tests__/persistent-render-scene.unit.test.ts

@@ -0,0 +1,1311 @@
+import { Disabled, defineComponent, type EntityHandle, World } from '@forgeax/engine-ecs';
+import { vec3 } from '@forgeax/engine-math';
+import { RhiNullCommandEncoder, RhiNullDevice, RhiNullQueue } from '@forgeax/engine-rhi-null';
+import { ChildOf, MorphWeights, propagateTransforms, Transform } from '@forgeax/engine-scene';
+import { toShared } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import {
+  Camera,
+  Instances,
+  MeshFilter,
+  MeshRenderer,
+  PointLight,
+  PostProcessParams,
+} from '../components';
+import { PersistentRenderScene } from '../persistent-render-scene';
+import type {
+  CameraSnapshot,
+  DispatchEntry,
+  ExtractedFrame,
+  GpuDrivenDrawSnapshot,
+  MaterialSnapshot,
+  RenderableSnapshot,
+} from '../render-system-extract';
+import {
+  extractCameraSnapshots,
+  refreshExtractedFrameCameras,
+  refreshExtractedFrameLights,
+} from '../render-system-extract';
+import { temporalViewId } from '../temporal-view';
+
+const material = {} as MaterialSnapshot;
+const GameplayState = defineComponent('PersistentRenderSceneGameplayStateTest', {
+  value: { type: 'f32', default: 0 },
+});
+
+function renderable(
+  entityKey: number,
+  world: Float32Array,
+  materialSnapshot: MaterialSnapshot = material,
+): RenderableSnapshot {
+  return {
+    assetHandle: 1,
+    transform: { world: new Float32Array(world) },
+    material: materialSnapshot,
+    materials: [materialSnapshot],
+    materialBindingSources: ['engine-default'],
+    worldId: 0,
+    entityKey,
+  };
+}
+
+function frame(...snapshots: RenderableSnapshot[]): ExtractedFrame {
+  return {
+    cameras: [],
+    lights: {
+      directional: undefined,
+      directionalCount: 0,
+      point: [],
+      spot: [],
+      lightViewProj: undefined,
+      splitPlanes: undefined,
+      cascadeCount: undefined,
+      cascadeBlend: undefined,
+      shadowMapSize: undefined,
+      depthBias: undefined,
+      normalBias: undefined,
+      pcfKernelSize: undefined,
+      pointShadow: [],
+      directionalCsmConfig: undefined,
+      directionalCsmDirection: undefined,
+    },
+    renderables: snapshots,
+    dispatch: [],
+    environment: { kind: 'none', worldId: 0, skylightCount: 0, skyboxCount: 0 },
+    frustumStats: { culled: 0, total: 0 },
+    visibilityStats: { explicitlyHidden: 0 },
+    postProcessParams: new Map(),
+    visibilitySnapshots: [],
+    featureVisibilitySnapshots: [],
+    hiddenEntityReports: [],
+  };
+}
+
+function csmCamera(world: Float32Array): CameraSnapshot {
+  return {
+    worldId: 0,
+    entityKey: 0,
+    world,
+    position: vec3.create(world[12] ?? 0, world[13] ?? 0, world[14] ?? 0),
+    fov: Math.PI / 3,
+    aspect: 1,
+    near: 0.1,
+    far: 100,
+    projection: 'perspective',
+    orthoLeft: -1,
+    orthoRight: 1,
+    orthoBottom: -1,
+    orthoTop: 1,
+    tonemap: 'none',
+    exposure: 1,
+    whitePoint: 1,
+    antialias: 'none',
+    historyVersion: 0,
+    bloom: 'off',
+    bloomThreshold: 1,
+    bloomIntensity: 0,
+    bloomBlurRadius: 1,
+    clearColor: [0, 0, 0, 1],
+  };
+}
+
+function csmCandidateFrame(
+  candidate: RenderableSnapshot,
+  cameraWorld: Float32Array,
+): ExtractedFrame {
+  const base = frame(candidate);
+  const shadowDispatch = [
+    {
+      entityIndex: candidate.entityKey,
+      materialHandle: 0,
+      renderableIndex: 0,
+      passIndex: 0,
+      queue: 2000,
+      layer: 0,
+      tags: { LightMode: 'ShadowCaster' },
+      renderState: undefined,
+      defines: undefined,
+      vertexEntry: 'vs_main',
+      fragmentEntry: undefined,
+      materialShaderId: 'forgeax::default-shadow-caster',
+      paramSnapshot: {},
+    },
+  ] satisfies DispatchEntry[];
+  return {
+    ...base,
+    cameras: [csmCamera(cameraWorld)],
+    dispatch: shadowDispatch,
+    candidateRenderables: [candidate],
+    candidateDispatch: shadowDispatch,
+    lights: {
+      ...base.lights,
+      directionalCount: 1,
+      cascadeCount: 2,
+      cascadeBlend: 0.25,
+      shadowMapSize: 512,
+      directionalCsmConfig: {
+        cascadeCount: 2,
+        splitLambda: 0.5,
+        cascadeBlend: 0.25,
+        mapSize: 512,
+        shadowDistance: 40,
+        pcfKernelSize: 3,
+      },
+      directionalCsmDirection: vec3.create(0.4, -0.8, 0.2),
+    },
+  };
+}
+
+function compositionFrame(
+  entries: readonly { readonly entity: EntityHandle; readonly worldId: number }[],
+): ExtractedFrame {
+  const first = entries[0];
+  if (first === undefined) throw new Error('compositionFrame requires at least one renderable');
+  const result = frame(renderable(first.entity, new Float32Array(16)));
+  return {
+    ...result,
+    renderables: entries.map(({ entity, worldId }) => ({
+      ...renderable(entity, new Float32Array(16)),
+      worldId,
+    })),
+  };
+}
+
+describe('PersistentRenderScene', () => {
+  it('does no World traversal on no-change and drains one transform delta without rebuilding', () => {
+    const world = new World();
+    const entity = world.spawn({ component: Transform, data: { pos: [1, 0, 0] } }).unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame(renderable(entity, world.get(entity, Transform).unwrap().world));
+    };
+
+    const initial = persistent.extract(world, 0, build);
+    const unchanged = persistent.extract(world, 0, build);
+    expect(unchanged).toBe(initial);
+    expect(builds).toBe(1);
+
+    world.set(entity, Transform, { pos: [9, 0, 0] }).unwrap();
+    propagateTransforms(world).unwrap();
+    const updated = persistent.extract(world, 0, build);
+
+    expect(builds).toBe(1);
+    expect(updated.renderables[0]?.transform.world[12]).toBe(9);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 1,
+      noChangeFrames: 1,
+      deltaFrames: 1,
+      transformUpdates: 1,
+      projectionRecords: 1,
+    });
+  });
+
+  it('retains submitted temporal authority for an unchanged non-rigid projection', () => {
+    const world = new World();
+    const entity = world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: MorphWeights, data: { weights: new Float32Array([0]) } },
+      )
+      .unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame({
+        ...renderable(entity, world.get(entity, Transform).unwrap().world),
+        morphWeights: new Float32Array(world.get(entity, MorphWeights).unwrap().weights),
+      });
+    };
+
+    const initial = persistent.extract(world, 0, build);
+    const projection = persistent.temporalProjection([world]);
+    expect(projection).toBeDefined();
+    if (projection === undefined) return;
+    projection.commitSubmission(projection.captureSubmission(initial.renderables));
+
+    const unchanged = persistent.extract(world, 0, build);
+    const temporal = projection.withTemporal(
+      unchanged.renderables[0] as RenderableSnapshot,
+    ).temporal;
+
+    expect(unchanged).toBe(initial);
+    expect(builds).toBe(1);
+    expect(temporal).toMatchObject({
+      previousSource: 'last-submitted',
+      previousEpoch: 1,
+      reactive: false,
+      reactiveReasons: [],
+    });
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 1,
+      noChangeFrames: 1,
+      projectionRecords: 1,
+    });
+  });
+
+  it('admits a component-added renderable through one entity extraction and topology patch', () => {
+    const world = new World();
+    const first = world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: MeshFilter, data: { assetHandle: toShared<'MeshAsset'>(0) } },
+        { component: MeshRenderer, data: {} },
+      )
+      .unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    const gpuDraw = {
+      submeshIndex: 0,
+      passIndex: 0,
+      queue: 2000,
+      kind: 'indexed' as const,
+      first: 0,
+      count: 36,
+      baseVertex: 0,
+      materialSlot: 0,
+      topology: 'triangle-list',
+      pipelineClass: 'opaque-pbr',
+      materialResourceClass: 'plain',
+    } satisfies GpuDrivenDrawSnapshot;
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame({
+        ...renderable(first, world.get(first, Transform).unwrap().world),
+        gpuDrivenDraws: [gpuDraw],
+      });
+    };
+
+    persistent.extract(world, 0, build);
+    const second = world
+      .spawn(
+        { component: Transform, data: { pos: [2, 0, 0] } },
+        { component: MeshFilter, data: { assetHandle: toShared<'MeshAsset'>(0) } },
+        { component: MeshRenderer, data: {} },
+      )
+      .unwrap();
+    propagateTransforms(world).unwrap();
+    const shadowDispatch = {
+      entityIndex: second,
+      materialHandle: 0,
+      renderableIndex: 0,
+      passIndex: 0,
+      queue: 2000,
+      layer: 0,
+      tags: { LightMode: 'ShadowCaster' },
+      renderState: undefined,
+      defines: undefined,
+      vertexEntry: 'vs_main',
+      fragmentEntry: undefined,
+      materialShaderId: 'forgeax::default-shadow-caster',
+      paramSnapshot: {},
+    } satisfies DispatchEntry;
+    const updated = persistent.extract(
+      world,
+      0,
+      build,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      (entity) =>
+        entity === second
+          ? {
+              snapshot: {
+                ...renderable(second, world.get(second, Transform).unwrap().world),
+                gpuDrivenDraws: [gpuDraw],
+              },
+              candidateDispatch: [shadowDispatch],
+            }
+          : undefined,
+    );
+
+    expect(builds).toBe(1);
+    expect(updated.candidateRenderables?.map((candidate) => candidate.entityKey)).toEqual([
+      first,
+      second,
+    ]);
+    expect(updated.candidateDispatch?.map((entry) => entry.entityIndex)).toEqual([second]);
+    expect(updated.candidateDispatch?.[0]?.renderableIndex).toBe(1);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 1,
+      deltaFrames: 1,
+      projectionRecords: 2,
+    });
+    expect(persistent.inspect().topology.patches).toBeGreaterThan(0);
+  });
+
+  it('patches ordinary topology in a multi-World composition without a full rebuild', () => {
+    const firstWorld = new World();
+    const secondWorld = new World();
+    const first = firstWorld.spawn({ component: Transform, data: {} }).unwrap();
+    const second = secondWorld.spawn({ component: Transform, data: {} }).unwrap();
+    propagateTransforms(firstWorld).unwrap();
+    propagateTransforms(secondWorld).unwrap();
+    const persistent = new PersistentRenderScene();
+    const gpuDraw = {
+      submeshIndex: 0,
+      passIndex: 0,
+      queue: 2000,
+      kind: 'indexed' as const,
+      first: 0,
+      count: 36,
+      baseVertex: 0,
+      materialSlot: 0,
+      topology: 'triangle-list',
+      pipelineClass: 'opaque-pbr',
+      materialResourceClass: 'plain',
+    } satisfies GpuDrivenDrawSnapshot;
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return {
+        ...compositionFrame([{ entity: first, worldId: 0 }]),
+        renderables: [
+          {
+            ...renderable(first, firstWorld.get(first, Transform).unwrap().world),
+            worldId: 0,
+            gpuDrivenDraws: [gpuDraw],
+          },
+        ],
+      };
+    };
+    const refresh = (
+      world: World,
+      worldId: number,
+      entity: EntityHandle,
+      _current: ExtractedFrame,
+    ) =>
+      world === secondWorld && entity === second
+        ? {
+            snapshot: {
+              ...renderable(second, world.get(second, Transform).unwrap().world),
+              worldId,
+              gpuDrivenDraws: [gpuDraw],
+            },
+            candidateDispatch: [
+              {
+                entityIndex: second,
+                materialHandle: 0,
+                renderableIndex: 0,
+                passIndex: 0,
+                queue: 2000,
+                layer: 0,
+                tags: { LightMode: 'ShadowCaster' },
+                renderState: undefined,
+                defines: undefined,
+                vertexEntry: 'vs_main',
+                fragmentEntry: undefined,
+                materialShaderId: 'forgeax::default-shadow-caster',
+                paramSnapshot: {},
+              } satisfies DispatchEntry,
+            ],
+          }
+        : undefined;
+
+    persistent.extractComposition(
+      [firstWorld, secondWorld],
+      { cameraOwner: 0, resourceOwner: 0 },
+      0,
+      build,
+      refresh,
+    );
+    secondWorld
+      .addComponent(second, {
+        component: MeshFilter,
+        data: { assetHandle: toShared<'MeshAsset'>(0) },
+      })
+      .unwrap();
+    secondWorld.addComponent(second, { component: MeshRenderer, data: {} }).unwrap();
+    propagateTransforms(secondWorld).unwrap();
+
+    const updated = persistent.extractComposition(
+      [firstWorld, secondWorld],
+      { cameraOwner: 0, resourceOwner: 0 },
+      0,
+      build,
+      refresh,
+    );
+
+    expect(builds).toBe(1);
+    expect(updated.candidateRenderables?.map((candidate) => candidate.entityKey)).toEqual([
+      first,
+      second,
+    ]);
+    expect(updated.candidateDispatch?.map((entry) => entry.entityIndex)).toEqual([second]);
+    expect(updated.candidateDispatch?.[0]?.renderableIndex).toBe(1);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 1,
+      deltaFrames: 1,
+      topologyEntitiesReconciled: 1,
+      singleEntityExtractions: 1,
+      projectionRecords: 2,
+    });
+    expect(persistent.inspect().topology.patches).toBeGreaterThan(0);
+  });
+
+  it('rebuilds on an asset epoch change', () => {
+    const world = new World();
+    const entity = world.spawn({ component: Transform, data: {} }).unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame(renderable(entity, world.get(entity, Transform).unwrap().world));
+    };
+
+    persistent.extract(world, 0, build);
+    persistent.extract(world, 1, build);
+
+    expect(builds).toBe(2);
+    expect(persistent.inspect().lastResyncReason).toBe('asset-catalog-changed');
+  });
+
+  it('refreshes camera state and CSM inputs without rebuilding the render projection', () => {
+    const world = new World();
+    const rendered = world.spawn({ component: Transform, data: {} }).unwrap();
+    const camera = world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 5] } },
+        { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
+      )
+      .unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame(renderable(rendered, world.get(rendered, Transform).unwrap().world));
+    };
+    const refresh = (current: ExtractedFrame) => refreshExtractedFrameCameras(world, current);
+
+    persistent.extract(world, 0, build, undefined, refresh);
+    world.set(camera, Transform, { pos: [3, 0, 5] }).unwrap();
+    propagateTransforms(world).unwrap();
+    const moved = persistent.extract(world, 0, build, undefined, refresh);
+
+    expect(builds).toBe(1);
+    expect(moved.cameras[0]?.world[12]).toBe(3);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 1,
+      cameraUpdates: 1,
+      deltaFrames: 1,
+      projectionRecords: 1,
+    });
+  });
+
+  it('changes camera view identity after a World attachment generation is replaced', () => {
+    const world = new World();
+    world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
+      )
+      .unwrap();
+    const persistent = new PersistentRenderScene();
+    const build = () => ({ ...frame(), cameras: extractCameraSnapshots(world) });
+
+    const first = persistent.extract(world, 0, build).cameras[0];
+    persistent.detach(world);
+    const second = persistent.extract(world, 0, build).cameras[0];
+
+    expect(first).toBeDefined();
+    expect(second).toBeDefined();
+    expect(first?.entityKey).toBe(second?.entityKey);
+    expect(first?.worldId).not.toBe(second?.worldId);
+    expect(temporalViewId(first?.worldId ?? -1, first?.entityKey ?? -1)).not.toBe(
+      temporalViewId(second?.worldId ?? -1, second?.entityKey ?? -1),
+    );
+  });
+
+  it('refreshes post-process resource data without rebuilding the render domain', () => {
+    const world = new World();
+    const rendered = world.spawn({ component: Transform, data: {} }).unwrap();
+    const paramsEntity = world
+      .spawn({
+        component: PostProcessParams,
+        data: { shader: 'test::motion-blur', data: new Uint8Array([1, 2, 3, 4]) },
+      })
+      .unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return {
+        ...frame(renderable(rendered, world.get(rendered, Transform).unwrap().world)),
+        postProcessParams: new Map([
+          ['test::motion-blur', world.get(paramsEntity, PostProcessParams).unwrap().data],
+        ]),
+      };
+    };
+    const refresh = (current: ExtractedFrame) => ({
+      ...current,
+      postProcessParams: new Map([
+        ['test::motion-blur', world.get(paramsEntity, PostProcessParams).unwrap().data],
+      ]),
+    });
+
+    persistent.extract(world, 0, build, undefined, undefined, undefined, refresh);
+    world
+      .set(paramsEntity, PostProcessParams, {
+        data: new Uint8Array([5, 6, 7, 8]),
+      })
+      .unwrap();
+    const updated = persistent.extract(world, 0, build, undefined, undefined, undefined, refresh);
+
+    expect(builds).toBe(1);
+    expect([...(updated.postProcessParams.get('test::motion-blur') ?? [])]).toEqual([5, 6, 7, 8]);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 1,
+      deltaFrames: 1,
+      resourceUpdates: 1,
+      projectionRecords: 1,
+    });
+  });
+
+  it('refreshes light resources without rebuilding the render domain', () => {
+    const world = new World();
+    const rendered = world.spawn({ component: Transform, data: {} }).unwrap();
+    const light = world
+      .spawn(
+        { component: Transform, data: { pos: [1, 2, 3] } },
+        { component: PointLight, data: { intensity: 2, range: 8 } },
+      )
+      .unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame(renderable(rendered, world.get(rendered, Transform).unwrap().world));
+    };
+    const refresh = (current: ExtractedFrame) => refreshExtractedFrameLights(world, current);
+
+    persistent.extract(world, 0, build, undefined, undefined, undefined, undefined, refresh);
+    world.set(light, PointLight, { intensity: 6 }).unwrap();
+    const updated = persistent.extract(
+      world,
+      0,
+      build,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      refresh,
+    );
+
+    expect(builds).toBe(1);
+    expect(updated.lights.point[0]?.intensity).toBe(6);
+    expect(updated.lights.point[0]?.position).toEqual(vec3.create(1, 2, 3));
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 1,
+      deltaFrames: 1,
+      resourceUpdates: 1,
+      projectionRecords: 1,
+    });
+  });
+
+  it('publishes camera-refresh CSM matrices from the same candidate-aware plan', () => {
+    const world = new World();
+    const caster = world.spawn({ component: Transform, data: { pos: [0, 20, -8] } }).unwrap();
+    const camera = world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 5] } },
+        { component: Camera, data: { fov: Math.PI / 3, aspect: 1, near: 0.1, far: 100 } },
+      )
+      .unwrap();
+    propagateTransforms(world).unwrap();
+
+    const casterWorld = new Float32Array(world.get(caster, Transform).unwrap().world);
+    const casterSnapshot: RenderableSnapshot = {
+      ...renderable(caster, casterWorld),
+      localAabb: new Float32Array([-1, -1, -1, 1, 1, 1]),
+      candidateIndex: 0,
+    };
+    const cameraWorld = () => new Float32Array(world.get(camera, Transform).unwrap().world);
+    const build = () => csmCandidateFrame(casterSnapshot, cameraWorld());
+    const refresh = (current: ExtractedFrame) => refreshExtractedFrameCameras(world, current);
+    const persistent = new PersistentRenderScene();
+
+    persistent.extract(world, 0, build, undefined, refresh);
+    world.set(camera, Transform, { pos: [1, 0, 5] }).unwrap();
+    propagateTransforms(world).unwrap();
+    const moved = persistent.extract(world, 0, build, undefined, refresh);
+    const plan = moved.lights.directionalCsm;
+    expect(plan).toBeDefined();
+    expect(plan?.cascades[0]?.casterRenderableIndices).toContain(0);
+    expect(moved.lights.lightViewProj).toBeDefined();
+    if (plan === undefined || moved.lights.lightViewProj === undefined) return;
+
+    for (let index = 0; index < plan.cascades.length; index += 1) {
+      expect(Array.from(plan.cascades[index]?.lightViewProj ?? [])).toEqual(
+        Array.from(moved.lights.lightViewProj[index] ?? []),
+      );
+    }
+    expect(Array.from(plan.splitPlanes)).toEqual(Array.from(moved.lights.splitPlanes ?? []));
+    expect(moved.lights.cascadeCount).toBe(plan.cascadeCount);
+    expect(moved.lights.cascadeBlend).toBe(plan.cascadeBlend);
+    expect(moved.lights.shadowMapSize).toBe(plan.shadowMapSize);
+    expect(moved.lights.lightViewProj).toBe(plan.lightViewProj);
+    expect(moved.lights.splitPlanes).toBe(plan.splitPlanes);
+    expect(moved.lights.cascades).toBe(plan.cascades);
+  });
+
+  it('reuses the dispatch membership owner across camera-only persistent culls', () => {
+    const world = new World();
+    const caster = world.spawn({ component: Transform, data: { pos: [0, 20, -8] } }).unwrap();
+    const camera = world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 5] } },
+        { component: Camera, data: { fov: Math.PI / 3, aspect: 1, near: 0.1, far: 100 } },
+      )
+      .unwrap();
+    propagateTransforms(world).unwrap();
+
+    const casterSnapshot: RenderableSnapshot = {
+      ...renderable(caster, new Float32Array(world.get(caster, Transform).unwrap().world)),
+      localAabb: new Float32Array([-1, -1, -1, 1, 1, 1]),
+      candidateIndex: 0,
+    };
+    const build = () =>
+      csmCandidateFrame(
+        casterSnapshot,
+        new Float32Array(world.get(camera, Transform).unwrap().world),
+      );
+    const refresh = (current: ExtractedFrame) => refreshExtractedFrameCameras(world, current);
+    const persistent = new PersistentRenderScene();
+
+    const initial = persistent.extract(world, 0, build, undefined, refresh);
+    expect(initial.candidateDispatchMembership).toBeDefined();
+    const candidateDispatch = initial.candidateDispatch;
+    const candidateDispatchMembership = initial.candidateDispatchMembership;
+    const candidateDomain = initial.candidateDomain;
+
+    expect(initial.candidateRenderables).toBe(candidateDomain?.renderables);
+    expect(candidateDispatch).toBe(candidateDomain?.dispatch);
+
+    world.set(camera, Transform, { pos: [1, 0, 5] }).unwrap();
+    propagateTransforms(world).unwrap();
+    const moved = persistent.extract(world, 0, build, undefined, refresh);
+
+    expect(moved.candidateDispatch).toBe(candidateDispatch);
+    expect(moved.candidateDispatchMembership).toBe(candidateDispatchMembership);
+    expect(moved.candidateDomain).toBe(candidateDomain);
+    expect(moved.candidateRenderables).toBe(candidateDomain?.renderables);
+    expect(moved.candidateDispatchMembership?.shadowCasterCandidateIndices.has(0)).toBe(true);
+  });
+
+  it('remaps candidate-domain identity when attaching a nonzero World render id', () => {
+    const identity = new Float32Array(16);
+    identity[0] = 1;
+    identity[5] = 1;
+    identity[10] = 1;
+    identity[15] = 1;
+    const persistent = new PersistentRenderScene();
+
+    persistent.extract(new World(), 0, () => csmCandidateFrame(renderable(1, identity), identity));
+
+    const secondWorld = new World();
+    const attached = persistent.extract(secondWorld, 0, () =>
+      csmCandidateFrame(renderable(2, identity), identity),
+    );
+
+    expect(attached.candidateDomain?.renderables[0]?.worldId).toBe(1);
+    expect(attached.candidateDomain?.indexByIdentity.get('1:2')).toBe(0);
+    expect(
+      attached.lights.directionalCsm?.cascades.some((cascade) =>
+        Array.from(cascade.casterRenderableIndices).includes(0),
+      ),
+    ).toBe(true);
+  });
+
+  it('rebases candidate identity, dispatch, and CSM membership after delta removal', () => {
+    const world = new World();
+    const first = world.spawn({ component: Transform, data: { pos: [0, 0, -5] } }).unwrap();
+    const second = world.spawn({ component: Transform, data: { pos: [2, 0, -6] } }).unwrap();
+    const third = world.spawn({ component: Transform, data: { pos: [-2, 0, -7] } }).unwrap();
+    const camera = world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 5] } },
+        { component: Camera, data: { fov: Math.PI / 3, aspect: 1, near: 0.1, far: 100 } },
+      )
+      .unwrap();
+    propagateTransforms(world).unwrap();
+
+    const entities = [first, second, third] as const;
+    const build = () => {
+      const base = frame();
+      const candidates = entities.map((entity, candidateIndex) => ({
+        ...renderable(entity, world.get(entity, Transform).unwrap().world),
+        localAabb: new Float32Array([-1, -1, -1, 1, 1, 1]),
+        candidateIndex,
+      }));
+      const candidateDispatch = candidates.map(
+        (candidate, renderableIndex) =>
+          ({
+            entityIndex: candidate.entityKey,
+            materialHandle: 0,
+            renderableIndex,
+            passIndex: 0,
+            queue: 2000,
+            layer: 0,
+            tags: { LightMode: 'ShadowCaster' },
+            renderState: undefined,
+            defines: undefined,
+            vertexEntry: 'vs_main',
+            fragmentEntry: undefined,
+            materialShaderId: 'forgeax::default-shadow-caster',
+            paramSnapshot: {},
+          }) satisfies DispatchEntry,
+      );
+      return {
+        ...base,
+        cameras: [csmCamera(new Float32Array(world.get(camera, Transform).unwrap().world))],
+        renderables: candidates,
+        dispatch: candidateDispatch,
+        candidateRenderables: candidates,
+        candidateDispatch,
+        lights: {
+          ...base.lights,
+          directionalCount: 1,
+          cascadeCount: 2,
+          cascadeBlend: 0.25,
+          shadowMapSize: 512,
+          directionalCsmConfig: {
+            cascadeCount: 2,
+            splitLambda: 0.5,
+            cascadeBlend: 0.25,
+            mapSize: 512,
+            shadowDistance: 40,
+            pcfKernelSize: 3,
+          },
+          directionalCsmDirection: vec3.create(0.4, -0.8, 0.2),
+        },
+      };
+    };
+
+    const persistent = new PersistentRenderScene();
+    persistent.extract(world, 0, build);
+    world.despawn(first).unwrap();
+    const projected = persistent.extract(world, 0, build);
+
+    expect(projected.candidateRenderables?.map((candidate) => candidate.entityKey)).toEqual([
+      second,
+      third,
+    ]);
+    expect(projected.candidateRenderables?.map((candidate) => candidate.candidateIndex)).toEqual([
+      0, 1,
+    ]);
+    expect(projected.candidateDispatch?.map((entry) => entry.entityIndex)).toEqual([second, third]);
+    expect(projected.candidateDispatch?.map((entry) => entry.renderableIndex)).toEqual([0, 1]);
+    expect(projected.renderables.map((candidate) => candidate.entityKey)).not.toContain(first);
+
+    const casterIndices = new Set(
+      projected.lights.directionalCsm?.cascades.flatMap((cascade) => [
+        ...cascade.casterRenderableIndices,
+      ]),
+    );
+    expect(casterIndices).toEqual(new Set([0, 1]));
+    expect(casterIndices).not.toContain(2);
+  });
+
+  it('skips CPU camera culling only while production coverage matches', () => {
+    const world = new World();
+    const rendered = world.spawn({ component: Transform, data: { pos: [100, 0, 0] } }).unwrap();
+    const camera = world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 5] } },
+        { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
+      )
+      .unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    const build = () =>
+      frame({
+        ...renderable(rendered, world.get(rendered, Transform).unwrap().world),
+        localAabb: new Float32Array([-0.5, -0.5, -0.5, 0.5, 0.5, 0.5]),
+        gpuDrivenDraws: [
+          {
+            submeshIndex: 0,
+            passIndex: 0,
+            queue: 2000,
+            kind: 'indexed',
+            first: 0,
+            count: 36,
+            baseVertex: 0,
+            materialSlot: 0,
+            topology: 'triangle-list',
+            pipelineClass: 'opaque-pbr',
+            materialResourceClass: 'plain',
+          },
+        ],
+      });
+    const refresh = (current: ExtractedFrame) => refreshExtractedFrameCameras(world, current);
+
+    persistent.extract(world, 0, build, undefined, refresh, '0:urp');
+    expect(persistent.inspect().topology.ineligible).toBe(0);
+
+    world.set(camera, Transform, { pos: [1, 0, 5] }).unwrap();
+    propagateTransforms(world).unwrap();
+    const fallback = persistent.extract(world, 0, build, undefined, refresh, '0:urp');
+    expect(fallback).toMatchObject({ frustumStats: { culled: 1, total: 1 } });
+    expect(fallback.renderables).toHaveLength(0);
+
+    persistent.setGpuDrivenCoverage(world, '0:urp', true);
+    world.set(camera, Transform, { pos: [2, 0, 5] }).unwrap();
+    propagateTransforms(world).unwrap();
+    const owned = persistent.extract(world, 0, build, undefined, refresh, '0:urp');
+    expect(owned.renderables).toHaveLength(1);
+
+    world.set(camera, Transform, { pos: [3, 0, 5] }).unwrap();
+    propagateTransforms(world).unwrap();
+    const invalidated = persistent.extract(world, 0, build, undefined, refresh, '1:urp');
+    expect(invalidated).toMatchObject({ frustumStats: { culled: 1, total: 1 } });
+    expect(invalidated.renderables).toHaveLength(0);
+  });
+
+  it('refreshes only renderables that reference an explicitly changed shared payload', () => {
+    const world = new World();
+    const entity = world.spawn({ component: Transform, data: {} }).unwrap();
+    const handle = world.allocSharedRef<'MaterialAsset', { value: number }>('MaterialAsset', {
+      value: 1,
+    });
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    const initialMaterial = {
+      baseColor: new Float32Array([1, 0, 0]),
+      metallic: 0,
+      roughness: 1,
+      materialHandle: Number(handle),
+    } as MaterialSnapshot;
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame(
+        renderable(entity, world.get(entity, Transform).unwrap().world, initialMaterial),
+      );
+    };
+
+    persistent.extract(world, 0, build);
+    const resolved = world.sharedRefs.resolve<'MaterialAsset', { value: number }>(handle).unwrap();
+    resolved.value = 2;
+    world.sharedRefs.markChanged(handle).unwrap();
+    const updated = persistent.extract(world, 0, build, (snapshot) => {
+      const nextMaterial = {
+        ...snapshot.material,
+        baseColor: new Float32Array([0, 1, 0]),
+      } as MaterialSnapshot;
+      return { ...snapshot, material: nextMaterial, materials: [nextMaterial] };
+    });
+
+    expect(builds).toBe(1);
+    expect(updated.renderables[0]?.material.baseColor[1]).toBe(1);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 1,
+      deltaFrames: 1,
+      materialUpdates: 1,
+    });
+  });
+
+  it('refreshes an ordinary instance range without rebuilding the World projection', () => {
+    const first = new Float32Array(16);
+    first[0] = 1;
+    first[5] = 1;
+    first[10] = 1;
+    first[15] = 1;
+    const second = new Float32Array(first);
+    second[12] = 2;
+    const world = new World();
+    const entity = world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: Instances, data: { transforms: first } },
+      )
+      .unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame({
+        ...renderable(entity, world.get(entity, Transform).unwrap().world),
+        instances: {
+          transforms: new Float32Array(world.get(entity, Instances).unwrap().transforms),
+          instanceCount: 1,
+          cacheKey: entity,
+          archVersion: 1,
+        },
+      });
+    };
+
+    persistent.extract(world, 0, build);
+    world.set(entity, Instances, { transforms: new Float32Array([...first, ...second]) }).unwrap();
+    const updated = persistent.extract(world, 0, build);
+
+    expect(builds).toBe(1);
+    expect(updated.renderables[0]?.instances?.instanceCount).toBe(2);
+    expect(updated.renderables[0]?.instances?.transforms[28]).toBe(2);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 1,
+      deltaFrames: 1,
+      instanceUpdates: 1,
+    });
+  });
+
+  it('ignores unrelated gameplay component changes', () => {
+    const world = new World();
+    const entity = world
+      .spawn({ component: Transform, data: {} }, { component: GameplayState, data: { value: 1 } })
+      .unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame(renderable(entity, world.get(entity, Transform).unwrap().world));
+    };
+
+    const initial = persistent.extract(world, 0, build);
+    world.set(entity, GameplayState, { value: 2 }).unwrap();
+    const unchanged = persistent.extract(world, 0, build);
+
+    expect(unchanged).toBe(initial);
+    expect(builds).toBe(1);
+    expect(persistent.inspect()).toMatchObject({
+      noChangeFrames: 1,
+      deltaFrames: 0,
+      worldEntitiesScanned: 0,
+    });
+  });
+
+  it('rebuilds the persistent candidate when Disabled is added', () => {
+    const world = new World();
+    const entity = world.spawn({ component: Transform, data: {} }).unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return world.hasComponent(entity, Disabled)
+        ? frame()
+        : frame(renderable(entity, world.get(entity, Transform).unwrap().world));
+    };
+
+    const active = persistent.extract(world, 0, build);
+    world.addComponent(entity, { component: Disabled, data: {} }).unwrap();
+    const disabled = persistent.extract(world, 0, build);
+
+    expect(active.renderables).toHaveLength(1);
+    expect(disabled.renderables).toHaveLength(0);
+    expect(builds).toBe(2);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 2,
+      lastResyncReason: 'unsupported-change',
+      projectionRecords: 0,
+    });
+  });
+
+  it('rebuilds the persistent candidate when Disabled is removed', () => {
+    const world = new World();
+    const entity = world
+      .spawn({ component: Transform, data: {} }, { component: Disabled, data: {} })
+      .unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return world.hasComponent(entity, Disabled)
+        ? frame()
+        : frame(renderable(entity, world.get(entity, Transform).unwrap().world));
+    };
+
+    const disabled = persistent.extract(world, 0, build);
+    world.removeComponent(entity, Disabled).unwrap();
+    const restored = persistent.extract(world, 0, build);
+
+    expect(disabled.renderables).toHaveLength(0);
+    expect(restored.renderables).toHaveLength(1);
+    expect(builds).toBe(2);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 2,
+      lastResyncReason: 'unsupported-change',
+      projectionRecords: 1,
+    });
+  });
+
+  it('shares Disabled structural invalidation with the single-World composition path', () => {
+    const world = new World();
+    const entity = world.spawn({ component: Transform, data: {} }).unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return world.hasComponent(entity, Disabled)
+        ? frame()
+        : frame(renderable(entity, world.get(entity, Transform).unwrap().world));
+    };
+    const owner = { cameraOwner: 0, resourceOwner: 0 };
+
+    const active = persistent.extractComposition([world], owner, 0, build);
+    world.addComponent(entity, { component: Disabled, data: {} }).unwrap();
+    const disabled = persistent.extractComposition([world], owner, 0, build);
+    world.removeComponent(entity, Disabled).unwrap();
+    const restored = persistent.extractComposition([world], owner, 0, build);
+
+    expect(active.renderables).toHaveLength(1);
+    expect(disabled.renderables).toHaveLength(0);
+    expect(restored.renderables).toHaveLength(1);
+    expect(builds).toBe(3);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 3,
+      lastResyncReason: 'attach',
+      projectionRecords: 1,
+    });
+  });
+
+  it('projects entity deletion without a full extract rebuild', () => {
+    const world = new World();
+    const first = world.spawn({ component: Transform, data: {} }).unwrap();
+    const second = world.spawn({ component: Transform, data: { pos: [1, 0, 0] } }).unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = (): ExtractedFrame => {
+      builds += 1;
+      const initial = frame(renderable(first, world.get(first, Transform).unwrap().world));
+      return {
+        ...initial,
+        renderables: [
+          initial.renderables[0] as RenderableSnapshot,
+          renderable(second, world.get(second, Transform).unwrap().world),
+        ],
+      };
+    };
+
+    persistent.extract(world, 0, build);
+    world.despawn(second).unwrap();
+    const projected = persistent.extract(world, 0, build);
+
+    expect(builds).toBe(1);
+    expect(projected.renderables.map((snapshot) => snapshot.entityKey)).toEqual([first]);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 1,
+      deltaFrames: 1,
+      projectionRecords: 1,
+    });
+  });
+
+  it('does not rebuild when a stale derived transform is followed by entity removal', () => {
+    const world = new World();
+    const first = world.spawn({ component: Transform, data: {} }).unwrap();
+    const removed = world.spawn({ component: Transform, data: { pos: [1, 0, 0] } }).unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = (): ExtractedFrame => {
+      builds += 1;
+      const snapshots = [renderable(first, world.get(first, Transform).unwrap().world)];
+      if (world.hasComponent(removed, Transform)) {
+        snapshots.push(renderable(removed, world.get(removed, Transform).unwrap().world));
+      }
+      return frame(...snapshots);
+    };
+
+    persistent.extract(world, 0, build);
+    world.set(removed, Transform, { pos: [2, 0, 0] }).unwrap();
+    propagateTransforms(world).unwrap();
+    world.despawn(removed).unwrap();
+    const projected = persistent.extract(world, 0, build);
+
+    expect(builds).toBe(1);
+    expect(projected.renderables.map((snapshot) => snapshot.entityKey)).toEqual([first]);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 1,
+      deltaFrames: 1,
+      projectionRecords: 1,
+    });
+  });
+
+  it('ignores transform changes on entities outside the render projection', () => {
+    const world = new World();
+    const rendered = world.spawn({ component: Transform, data: {} }).unwrap();
+    const gameplayOnly = world.spawn({ component: Transform, data: {} }).unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame(renderable(rendered, world.get(rendered, Transform).unwrap().world));
+    };
+
+    const initial = persistent.extract(world, 0, build);
+    world.set(gameplayOnly, Transform, { pos: [5, 0, 0] }).unwrap();
+    propagateTransforms(world).unwrap();
+    const unchanged = persistent.extract(world, 0, build);
+
+    expect(unchanged).toBe(initial);
+    expect(builds).toBe(1);
+  });
+
+  it('reconciles hierarchy faults and same-process repair even when propagation reports an error', () => {
+    const world = new World();
+    const parent = world.spawn({ component: Transform, data: { pos: [4, 0, 0] } }).unwrap();
+    const child = world
+      .spawn(
+        { component: Transform, data: { pos: [1, 0, 0] } },
+        { component: ChildOf, data: { parent } },
+      )
+      .unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame(renderable(child, world.get(child, Transform).unwrap().world));
+    };
+
+    persistent.extract(world, 0, build);
+    expect(world.get(child, Transform).unwrap().world[12]).toBe(5);
+
+    world.set(child, ChildOf, { parent: 0xfffffffe as EntityHandle }).unwrap();
+    expect(propagateTransforms(world).ok).toBe(false);
+    const fault = persistent.extract(world, 0, build);
+    expect(fault.renderables[0]?.transform.world[12]).toBe(1);
+
+    world.set(child, ChildOf, { parent }).unwrap();
+    propagateTransforms(world).unwrap();
+    const repaired = persistent.extract(world, 0, build);
+    expect(repaired.renderables[0]?.transform.world[12]).toBe(5);
+    expect(builds).toBe(3);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 3,
+      lastResyncReason: 'unsupported-change',
+    });
+  });
+
+  it('rebuilds lost GPU tables from the retained CPU projection without traversing World', () => {
+    const world = new World();
+    const entity = world.spawn({ component: Transform, data: {} }).unwrap();
+    propagateTransforms(world).unwrap();
+    let device = new RhiNullDevice(
+      new RhiNullQueue(),
+      (bookkeeper, ownedDevice) => new RhiNullCommandEncoder(bookkeeper, ownedDevice),
+    );
+    const persistent = new PersistentRenderScene({ getDevice: () => device });
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame(renderable(entity, world.get(entity, Transform).unwrap().world));
+    };
+
+    persistent.extract(world, 0, build);
+    expect(persistent.inspect().gpu).toMatchObject({ status: 'resident', fullRebuilds: 1 });
+
+    persistent.resetGpuForRecover();
+    device = new RhiNullDevice(
+      new RhiNullQueue(),
+      (bookkeeper, ownedDevice) => new RhiNullCommandEncoder(bookkeeper, ownedDevice),
+    );
+    persistent.extract(world, 0, build);
+
+    expect(builds).toBe(1);
+    expect(persistent.inspect()).toMatchObject({
+      fullRebuilds: 1,
+      noChangeFrames: 1,
+      projectionRecords: 1,
+      gpu: { status: 'resident', fullRebuilds: 1 },
+    });
+  });
+
+  it('releases CPU and GPU state when a World detaches', () => {
+    const world = new World();
+    const entity = world.spawn({ component: Transform, data: {} }).unwrap();
+    propagateTransforms(world).unwrap();
+    const device = new RhiNullDevice(
+      new RhiNullQueue(),
+      (bookkeeper, ownedDevice) => new RhiNullCommandEncoder(bookkeeper, ownedDevice),
+    );
+    const persistent = new PersistentRenderScene({ getDevice: () => device });
+    let builds = 0;
+    const build = () => {
+      builds += 1;
+      return frame(renderable(entity, world.get(entity, Transform).unwrap().world));
+    };
+
+    persistent.extract(world, 0, build);
+    persistent.detach(world);
+
+    expect(persistent.inspect()).toMatchObject({
+      projectionRecords: 0,
+      gpu: { status: 'inactive' },
+    });
+    persistent.extract(world, 0, build);
+    expect(builds).toBe(2);
+  });
+
+  it('keeps renderer-local WorldRenderId stable when composition order changes', () => {
+    const firstWorld = new World();
+    const secondWorld = new World();
+    const firstEntity = firstWorld.spawn({ component: Transform, data: {} }).unwrap();
+    const secondEntity = secondWorld.spawn({ component: Transform, data: {} }).unwrap();
+    propagateTransforms(firstWorld).unwrap();
+    propagateTransforms(secondWorld).unwrap();
+    const persistent = new PersistentRenderScene();
+
+    const initial = persistent.extractComposition(
+      [firstWorld, secondWorld],
+      { cameraOwner: 0, resourceOwner: 0 },
+      0,
+      () =>
+        compositionFrame([
+          { entity: firstEntity, worldId: 0 },
+          { entity: secondEntity, worldId: 1 },
+        ]),
+    );
+    const firstWorldId = initial.renderables[0]?.worldId;
+    const secondWorldId = initial.renderables[1]?.worldId;
+
+    const reordered = persistent.extractComposition(
+      [secondWorld, firstWorld],
+      { cameraOwner: 0, resourceOwner: 0 },
+      0,
+      () =>
+        compositionFrame([
+          { entity: secondEntity, worldId: 0 },
+          { entity: firstEntity, worldId: 1 },
+        ]),
+    );
+
+    expect(firstWorldId).toBeDefined();
+    expect(secondWorldId).toBeDefined();
+    expect(firstWorldId).not.toBe(secondWorldId);
+    expect(reordered.renderables[0]?.worldId).toBe(secondWorldId);
+    expect(reordered.renderables[1]?.worldId).toBe(firstWorldId);
+  });
+
+  it('retires WorldRenderId when a World detaches before the same object reattaches', () => {
+    const world = new World();
+    const entity = world.spawn({ component: Transform, data: {} }).unwrap();
+    propagateTransforms(world).unwrap();
+    const persistent = new PersistentRenderScene();
+    const build = () => frame(renderable(entity, world.get(entity, Transform).unwrap().world));
+
+    const initialWorldId = persistent.extract(world, 0, build).renderables[0]?.worldId;
+    persistent.detach(world);
+    const reattachedWorldId = persistent.extract(world, 0, build).renderables[0]?.worldId;
+
+    expect(initialWorldId).toBeDefined();
+    expect(reattachedWorldId).toBeDefined();
+    expect(reattachedWorldId).not.toBe(initialWorldId);
+  });
+});