@forgeax/engine-render 0.1.3 → 0.1.6

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

@@ -1,1311 +0,0 @@
-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);
-  });
-});