@forgeax/engine-render 0.1.3 → 0.1.6

package/src/__tests__/gpu-driven-view-graph.integration.test.ts

@@ -3,12 +3,23 @@ import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
 import type { RhiCommandEncoder } from '@forgeax/engine-rhi';
 import { type RhiNullDevice, rhi } from '@forgeax/engine-rhi-null';
 import { ok } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { BatchTopology } from '../gpu-driven/batch-topology';
+import type { PreparedGpuDrivenFrame } from '../gpu-driven/production-raster';
 import { GpuDrivenView } from '../gpu-driven/view-gpu';
 import { GpuScene } from '../gpu-scene';
-import { RenderSceneProjection } from '../render-scene-projection';
-import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
+import { RhiErrorListenerRegistry } from '../lifecycle';
+import type { RenderFrameState } from '../record/frame-snapshot';
+import { makeZeroCameraFallbackSnapshot } from '../record/frame-snapshot';
+import type { PipelineState, RenderSystemInternals } from '../record/render-context';
+import { ensureCompiledFrameGraph } from '../record/typed-frame-graph';
+import type { RenderPipeline, RenderPipelineFrame } from '../render-pipeline';
+import type {
+  ExtractedLights,
+  MaterialSnapshot,
+  RenderableSnapshot,
+} from '../render-system-extract';
+import { RenderScene } from '../scene/render-scene';
 
 const material = {
   baseColor: new Float32Array([1, 1, 1]),
@@ -28,9 +39,6 @@ function snapshot(entityKey: number): RenderableSnapshot {
     entityKey,
     gpuDrivenDraws: [
       {
-        submeshIndex: 0,
-        passIndex: 0,
-        queue: 2000,
         kind: 'indexed',
         first: 0,
         count: 36,
@@ -44,17 +52,30 @@ function snapshot(entityKey: number): RenderableSnapshot {
   };
 }
 
+function preparedFrame(view: GpuDrivenView): PreparedGpuDrivenFrame {
+  return {
+    topologySignature: `view-generation:${view.inspect().resourceGeneration}`,
+    entityKeys: new Set(),
+    ownsAllRenderables: true,
+    _commitResourceReplacement: () => view._commitResourceReplacement(),
+    project: (graph) => {
+      const projected = view.addPasses(graph);
+      return projected.ok ? ok({ accesses: [], encode: () => undefined }) : projected;
+    },
+  };
+}
+
 describe('GpuDrivenView graph projection', () => {
   it('records reset, compact, and finalize in one typed graph', async () => {
     const adapter = (await rhi.requestAdapter()).unwrap();
     const device = (await adapter.requestDevice()).unwrap();
     const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
-    const projection = new RenderSceneProjection();
+    const projection = new RenderScene();
     const delta = projection.apply([{ kind: 'create', snapshot: snapshot(1) }]);
     const sceneAvailability = GpuScene.create(device, 1).unwrap();
     expect(sceneAvailability.status).toBe('available');
     if (sceneAvailability.status !== 'available') return;
-    sceneAvailability.scene.sync(projection, delta).unwrap();
+    sceneAvailability.scene.sync(delta).unwrap();
     const topology = new BatchTopology();
     topology.rebuild(projection.slotsSnapshot());
     const view = GpuDrivenView.create({
@@ -125,4 +146,145 @@ describe('GpuDrivenView graph projection', () => {
     view.dispose();
     sceneAvailability.scene.dispose();
   });
+
+  it('keeps last-known-good graph buffers alive until replacement promotion', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap();
+    const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
+    const destroyBuffer = vi.spyOn(device, 'destroyBuffer');
+    const projection = new RenderScene();
+    const firstDelta = projection.apply([{ kind: 'create', snapshot: snapshot(1) }]);
+    const sceneAvailability = GpuScene.create(device, 2).unwrap();
+    expect(sceneAvailability.status).toBe('available');
+    if (sceneAvailability.status !== 'available') return;
+    sceneAvailability.scene.sync(firstDelta).unwrap();
+    const topology = new BatchTopology();
+    topology.rebuild(projection.slotsSnapshot());
+    const view = GpuDrivenView.create({
+      device,
+      shaderModuleFactory: { createShaderModule: () => ok(shader) },
+    }).unwrap();
+    const planes = frustum.fromViewProjection(frustum.create(), mat4.identity(mat4.create()));
+    view.update(topology.plan(), sceneAvailability.scene, planes).unwrap();
+    const previousVisible = view.visibleBuffer;
+    expect(previousVisible).toBeDefined();
+    if (previousVisible === undefined) return;
+
+    let forceCompileFailure = false;
+    const activePipeline: RenderPipeline = {
+      build: ({ graph, projectGpuDriven }) => {
+        const projected = projectGpuDriven({ format: 'rgba8unorm', sampleCount: 1 });
+        if (!projected.ok) return projected;
+        if (forceCompileFailure) {
+          const dangling = graph
+            .createBuffer('forced-candidate-compile-failure', { size: 4 })
+            .unwrap();
+          graph
+            .addComputePass('forced-candidate-compile-failure', {
+              accesses: [{ resource: dangling, usage: 'storage-read' }],
+              encode: () => undefined,
+            })
+            .unwrap();
+        }
+        return ok(undefined);
+      },
+    };
+    const frameState = {
+      compiledFrameGraph: null,
+      compiledFrameGraphTopologyKey: null,
+      retiredCompiledFrameGraphs: new Set(),
+      activePipeline,
+      installedPipelineConfig: undefined,
+    } as unknown as RenderFrameState;
+    const errors: unknown[] = [];
+    const errorRegistry = new RhiErrorListenerRegistry();
+    errorRegistry.add((error) => errors.push(error));
+    const internals = { device, errorRegistry } as unknown as RenderSystemInternals;
+    const pipelineState = {
+      format: 'rgba8unorm',
+      colorAttachmentFormat: 'rgba8unorm',
+    } as unknown as PipelineState;
+    const lights = {
+      cascadeCount: undefined,
+      pointShadow: [],
+      spot: [],
+    } as unknown as ExtractedLights;
+    const compile = (prepared: PreparedGpuDrivenFrame) =>
+      ensureCompiledFrameGraph(
+        internals,
+        frameState,
+        pipelineState,
+        makeZeroCameraFallbackSnapshot(),
+        lights,
+        1,
+        1,
+        undefined,
+        prepared,
+      );
+    const compiledPrevious = compile(preparedFrame(view));
+    expect(compiledPrevious).not.toBeNull();
+    if (compiledPrevious === null) return;
+
+    const secondDelta = projection.apply([{ kind: 'create', snapshot: snapshot(2) }]);
+    sceneAvailability.scene.sync(secondDelta).unwrap();
+    topology.rebuild(projection.slotsSnapshot());
+    view.update(topology.plan(), sceneAvailability.scene, planes).unwrap();
+
+    expect(view.inspect()).toMatchObject({ candidateCount: 2, candidateCapacity: 2 });
+    forceCompileFailure = true;
+    expect(compile(preparedFrame(view))).toBe(compiledPrevious);
+    expect(errors).toHaveLength(1);
+    expect(destroyBuffer.mock.calls.some(([buffer]) => buffer === previousVisible)).toBe(false);
+    const encoder = device.createCommandEncoder({ label: 'gpu-driven-view-lkg' }).unwrap();
+    expect(compiledPrevious.execute({ encoder } as RenderPipelineFrame).ok).toBe(true);
+
+    forceCompileFailure = false;
+    const retirePrevious = vi.spyOn(compiledPrevious, 'retire');
+    const acceptedGraph = compile(preparedFrame(view));
+    expect(acceptedGraph).not.toBe(compiledPrevious);
+    expect(retirePrevious).toHaveBeenCalledOnce();
+    await device.queue.onSubmittedWorkDone();
+    await Promise.resolve();
+    expect(destroyBuffer.mock.calls.some(([buffer]) => buffer === previousVisible)).toBe(true);
+
+    view.dispose();
+    sceneAvailability.scene.dispose();
+  });
+
+  it('releases a promoted generation once when the queue fence rejects', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap();
+    const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
+    const destroyBuffer = vi.spyOn(device, 'destroyBuffer');
+    const projection = new RenderScene();
+    const firstDelta = projection.apply([{ kind: 'create', snapshot: snapshot(1) }]);
+    const sceneAvailability = GpuScene.create(device, 2).unwrap();
+    expect(sceneAvailability.status).toBe('available');
+    if (sceneAvailability.status !== 'available') return;
+    sceneAvailability.scene.sync(firstDelta).unwrap();
+    const topology = new BatchTopology();
+    topology.rebuild(projection.slotsSnapshot());
+    const view = GpuDrivenView.create({
+      device,
+      shaderModuleFactory: { createShaderModule: () => ok(shader) },
+    }).unwrap();
+    const planes = frustum.fromViewProjection(frustum.create(), mat4.identity(mat4.create()));
+    view.update(topology.plan(), sceneAvailability.scene, planes).unwrap();
+    const firstVisible = view.visibleBuffer;
+    expect(firstVisible).toBeDefined();
+    if (firstVisible === undefined) return;
+
+    const secondDelta = projection.apply([{ kind: 'create', snapshot: snapshot(2) }]);
+    sceneAvailability.scene.sync(secondDelta).unwrap();
+    topology.rebuild(projection.slotsSnapshot());
+    view.update(topology.plan(), sceneAvailability.scene, planes).unwrap();
+    vi.spyOn(device.queue, 'onSubmittedWorkDone').mockRejectedValueOnce(new Error('device lost'));
+    view._commitResourceReplacement();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(destroyBuffer.mock.calls.filter(([buffer]) => buffer === firstVisible)).toHaveLength(1);
+
+    view.dispose();
+    sceneAvailability.scene.dispose();
+  });
 });

package/src/{gpu-driven/view-reference.ts → __tests__/gpu-driven-view-reference.ts}

@@ -1,6 +1,7 @@
+/** Test-owned CPU oracle for the GPU-driven visibility protocol. */
 import { box3, frustum, mat4 } from '@forgeax/engine-math';
-import type { RenderSceneProjectionSlot } from '../render-scene-projection';
-import type { SubmissionPlan } from './batch-topology';
+import type { SubmissionPlan } from '../gpu-driven/batch-topology';
+import type { RenderSceneSlot } from '../scene/render-scene';
 
 export const INDEXED_INDIRECT_STRIDE = 20;
 
@@ -17,7 +18,7 @@ export interface GpuDrivenViewReferenceResult {
 /** CPU oracle for the storage-buffer compute protocol and WebGL2 fallback semantics. */
 export function classifyGpuDrivenView(
   plan: SubmissionPlan,
-  slots: readonly RenderSceneProjectionSlot[],
+  slots: readonly RenderSceneSlot[],
   planes: Float32Array,
   capacityByBatch?: ReadonlyMap<number, number>,
 ): GpuDrivenViewReferenceResult {

package/src/__tests__/gpu-driven-view.browser.test.ts

@@ -1,5 +1,8 @@
 import { describe, expect, it } from 'vitest';
-import { runGpuDrivenViewGpuEvidence } from './gpu-driven-view-gpu-evidence';
+import {
+  runGpuDrivenViewGpuEvidence,
+  runGpuDrivenViewLifecycleEvidence,
+} from './gpu-driven-view-gpu-evidence';
 
 const browserReady = typeof navigator !== 'undefined' && navigator.gpu !== undefined;
 
@@ -16,4 +19,12 @@ describe.skipIf(!browserReady)('GPU-driven View Browser WebGPU', () => {
       persistentTranslationX: 0,
     });
   });
+
+  it('survives 300 frames of spawn/despawn capacity crossings without stale buffers', async () => {
+    await expect(runGpuDrivenViewLifecycleEvidence()).resolves.toEqual({
+      frames: 300,
+      bufferRebuilds: 4,
+      candidateCapacity: 8,
+    });
+  }, 30_000);
 });

package/src/__tests__/gpu-driven-view.dawn.test.ts

@@ -1,5 +1,8 @@
 import { describe, expect, it } from 'vitest';
-import { runGpuDrivenViewGpuEvidence } from './gpu-driven-view-gpu-evidence';
+import {
+  runGpuDrivenViewGpuEvidence,
+  runGpuDrivenViewLifecycleEvidence,
+} from './gpu-driven-view-gpu-evidence';
 
 describe('GPU-driven View Dawn', () => {
   it('produces compact visible IDs and portable indirect args on the real GPU API', async () => {
@@ -14,4 +17,12 @@ describe('GPU-driven View Dawn', () => {
       persistentTranslationX: 0,
     });
   });
+
+  it('survives 300 frames of spawn/despawn capacity crossings without stale buffers', async () => {
+    await expect(runGpuDrivenViewLifecycleEvidence()).resolves.toEqual({
+      frames: 300,
+      bufferRebuilds: 4,
+      candidateCapacity: 8,
+    });
+  }, 30_000);
 });

package/src/__tests__/gpu-driven-view.unit.test.ts

@@ -1,11 +1,9 @@
 import { frustum, mat4 } from '@forgeax/engine-math';
 import { describe, expect, it } from 'vitest';
 import { BatchTopology } from '../gpu-driven/batch-topology';
-import { gpuDrivenRasterEligibility } from '../gpu-driven/production-raster';
-import { classifyGpuDrivenView } from '../gpu-driven/view-reference';
-import { buildCascadeLocalCacheTokens, evaluateDirectionalShadowCache } from '../record/frame';
-import { RenderSceneProjection } from '../render-scene-projection';
 import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
+import { RenderScene } from '../scene/render-scene';
+import { classifyGpuDrivenView } from './gpu-driven-view-reference';
 
 const material = {
   baseColor: new Float32Array([1, 1, 1]),
@@ -27,9 +25,6 @@ function snapshot(entityKey: number, x: number, resourceClass = 'plain'): Render
     entityKey,
     gpuDrivenDraws: [
       {
-        submeshIndex: 0,
-        passIndex: 0,
-        queue: 2000,
         kind: 'indexed',
         first: 3,
         count: 36,
@@ -45,7 +40,7 @@ function snapshot(entityKey: number, x: number, resourceClass = 'plain'): Render
 
 describe('GPU-driven batch topology and CPU oracle', () => {
   it('patches topology only when compatibility membership changes', () => {
-    const projection = new RenderSceneProjection();
+    const projection = new RenderScene();
     projection.apply([
       { kind: 'create', snapshot: snapshot(1, 0) },
       { kind: 'create', snapshot: snapshot(2, 0.5) },
@@ -74,7 +69,7 @@ describe('GPU-driven batch topology and CPU oracle', () => {
   });
 
   it('compacts visible primitive indices and writes portable indexed indirect args', () => {
-    const projection = new RenderSceneProjection();
+    const projection = new RenderScene();
     projection.apply([
       { kind: 'create', snapshot: snapshot(1, 0) },
       { kind: 'create', snapshot: snapshot(2, 10) },
@@ -101,7 +96,7 @@ describe('GPU-driven batch topology and CPU oracle', () => {
   });
 
   it('keeps multi-submesh draw items independent and writes non-indexed indirect args', () => {
-    const projection = new RenderSceneProjection();
+    const projection = new RenderScene();
     const source = snapshot(1, 0);
     const first = source.gpuDrivenDraws?.[0];
     expect(first).toBeDefined();
@@ -140,7 +135,7 @@ describe('GPU-driven batch topology and CPU oracle', () => {
     const identity = mat4.identity(mat4.create());
     const outside = mat4.identity(mat4.create());
     outside[12] = 10;
-    const projection = new RenderSceneProjection();
+    const projection = new RenderScene();
     projection.apply([
       {
         kind: 'create',
@@ -169,7 +164,7 @@ describe('GPU-driven batch topology and CPU oracle', () => {
   });
 
   it('reports overflow instead of silently accepting a truncated batch', () => {
-    const projection = new RenderSceneProjection();
+    const projection = new RenderScene();
     projection.apply([
       { kind: 'create', snapshot: snapshot(1, 0) },
       { kind: 'create', snapshot: snapshot(2, 0.5) },
@@ -190,266 +185,15 @@ describe('GPU-driven batch topology and CPU oracle', () => {
     expect(result.visibleCount).toBe(1);
   });
 
-  it('keeps pass-agnostic shadow topology while forward capability stays explicit', () => {
-    const projection = new RenderSceneProjection();
+  it('keeps the ineligible inspection bounded to current projection membership', () => {
+    const projection = new RenderScene();
     const { localAabb: _localAabb, ...withoutBounds } = snapshot(1, 0);
     const topology = new BatchTopology();
     topology.rebuild(projection.apply([{ kind: 'create', snapshot: withoutBounds }]).createdSlots);
-    expect(topology.inspect()).toMatchObject({ candidateCount: 1, ineligible: 0 });
-    const batch = topology.plan().batches[0];
-    expect(batch).toBeDefined();
-    if (batch === undefined) return;
-    expect(gpuDrivenRasterEligibility(withoutBounds, batch)).toEqual({
-      eligible: false,
-      reason: 'missing-local-bounds-capability-lane',
-    });
+    expect(topology.inspect().ineligible).toBe(1);
 
     const removed = projection.apply([{ kind: 'remove', worldId: 0, entityKey: 1 }]);
     topology.apply(removed);
-    expect(topology.inspect()).toMatchObject({ candidateCount: 0, ineligible: 0 });
-  });
-
-  it('invalidates only the cascade containing the changed scene fact', () => {
-    const cascade = (revision: number, offset: number) => ({
-      revision,
-      lightViewProj: new Float32Array([offset]),
-      clipLightBounds: new Float32Array([offset, offset + 1]),
-      casterBroadphaseWorldAabb: new Float32Array([offset, 0, 0, offset + 1, 1, 1]),
-      rasterViewport: { x: offset * 16, y: 0, w: 16, h: 16 },
-    });
-    const revisions = (transform: number) => ({
-      transform,
-      geometry: 1,
-      material: 1,
-      eligibility: 1,
-      space: 1,
-      batch: 1,
-      resource: 1,
-    });
-    const scene = (firstTransform: number, planRevision: number, useProjectionOwner = false) => {
-      const slots = [
-        { slot: 0, generation: 1, fact: { revisions: revisions(firstTransform) } },
-        { slot: 1, generation: 1, fact: { revisions: revisions(1) } },
-      ];
-      return {
-        // The projection-owner case deliberately leaves `slots` empty. If the
-        // token builder regresses to rebuilding the compatibility map, the
-        // resulting tokens differ from the owner-backed result.
-        slots: useProjectionOwner ? [] : slots,
-        ...(useProjectionOwner
-          ? { projection: { slotByIndex: (slot: number) => slots[slot] } }
-          : {}),
-        plan: {
-          revision: planRevision,
-          batches: [
-            {
-              batchId: 10,
-              generation: 1,
-              key: {
-                resourceRevision: 1,
-                materialRevision: 1,
-                pipelineClass: 'shadow',
-                materialClass: 'opaque',
-                materialResourceClass: 'plain',
-              },
-              candidates: [{ primitiveIndex: 0 }],
-            },
-            {
-              batchId: 11,
-              generation: 1,
-              key: {
-                resourceRevision: 1,
-                materialRevision: 1,
-                pipelineClass: 'shadow',
-                materialClass: 'opaque',
-                materialResourceClass: 'plain',
-              },
-              candidates: [{ primitiveIndex: 1 }],
-            },
-          ],
-        },
-      };
-    };
-    const visibility = (spatialIndexRevision: number) => ({
-      views: [
-        { kind: 'cascade', cascadeIndex: 0, stableIds: [0], spatialIndexRevision },
-        { kind: 'cascade', cascadeIndex: 1, stableIds: [1], spatialIndexRevision },
-      ],
-    });
-    const lights = {
-      cascadeCount: 2,
-      directionalCsm: { cascades: [cascade(1, 0), cascade(2, 1)] },
-    };
-    const baseline = buildCascadeLocalCacheTokens({
-      lights: lights as never,
-      visibility: visibility(7) as never,
-      scene: scene(1, 20) as never,
-      validated: [],
-    }).tokens;
-    const changed = buildCascadeLocalCacheTokens({
-      lights: lights as never,
-      visibility: visibility(8) as never,
-      scene: scene(2, 21) as never,
-      validated: [],
-    }).tokens;
-    const ownerBacked = buildCascadeLocalCacheTokens({
-      lights: lights as never,
-      visibility: visibility(7) as never,
-      scene: scene(1, 20, true) as never,
-      validated: [],
-    }).tokens;
-
-    expect(changed[0]).not.toBe(baseline[0]);
-    expect(changed[1]).toBe(baseline[1]);
-    expect(ownerBacked).toEqual(baseline);
-  });
-
-  it('does not reuse a compatibility token after an in-place slots mutation', () => {
-    const cascade = {
-      revision: 1,
-      lightViewProj: new Float32Array([0]),
-      clipLightBounds: new Float32Array([0, 1]),
-      casterBroadphaseWorldAabb: new Float32Array([0, 0, 0, 1, 1, 1]),
-      rasterViewport: { x: 0, y: 0, w: 16, h: 16 },
-    };
-    const slots = [
-      {
-        slot: 0,
-        generation: 1,
-        fact: {
-          revisions: {
-            transform: 1,
-            geometry: 1,
-            material: 1,
-            eligibility: 1,
-            space: 1,
-            batch: 1,
-            resource: 1,
-          },
-        },
-      },
-    ];
-    const input = {
-      lights: { cascadeCount: 1, directionalCsm: { cascades: [cascade] } },
-      visibility: { views: [{ kind: 'cascade', cascadeIndex: 0, stableIds: [0] }] },
-      scene: {
-        slots,
-        plan: {
-          revision: 1,
-          batches: [
-            {
-              batchId: 1,
-              generation: 1,
-              key: {
-                resourceRevision: 1,
-                materialRevision: 1,
-                pipelineClass: 'shadow',
-                materialClass: 'opaque',
-                materialResourceClass: 'plain',
-              },
-              candidates: [{ primitiveIndex: 0 }],
-            },
-          ],
-        },
-      },
-      validated: [],
-    } as never;
-    const before = buildCascadeLocalCacheTokens(input).tokens;
-    const firstSlot = slots[0];
-    expect(firstSlot).toBeDefined();
-    if (firstSlot === undefined) return;
-    firstSlot.fact.revisions.transform = 2;
-    const after = buildCascadeLocalCacheTokens(input).tokens;
-    expect(after[0]).not.toBe(before[0]);
-  });
-
-  it('normalizes visible batch token input independent of submission order', () => {
-    const cascade = {
-      revision: 1,
-      lightViewProj: new Float32Array([0]),
-      clipLightBounds: new Float32Array([0, 1]),
-      casterBroadphaseWorldAabb: new Float32Array([0, 0, 0, 1, 1, 1]),
-      rasterViewport: { x: 0, y: 0, w: 16, h: 16 },
-    };
-    const slots = [0, 1].map((slot) => ({
-      slot,
-      generation: 1,
-      fact: {
-        revisions: {
-          transform: 1,
-          geometry: 1,
-          material: 1,
-          eligibility: 1,
-          space: 1,
-          batch: 1,
-          resource: 1,
-        },
-      },
-    }));
-    const planFor = (batchOrder: readonly number[]) => ({
-      revision: 1,
-      batches: batchOrder.map((batchId) => ({
-        batchId,
-        generation: 1,
-        key: {
-          resourceRevision: 1,
-          materialRevision: 1,
-          pipelineClass: 'shadow',
-          materialClass: 'opaque',
-          materialResourceClass: 'plain',
-        },
-        candidates: [{ primitiveIndex: batchId - 10 }],
-      })),
-    });
-    const makeInput = (batchOrder: readonly number[]) =>
-      ({
-        lights: { cascadeCount: 1, directionalCsm: { cascades: [cascade] } },
-        visibility: { views: [{ kind: 'cascade', cascadeIndex: 0, stableIds: [0, 1] }] },
-        scene: { slots, plan: planFor(batchOrder) },
-        validated: [],
-      }) as never;
-    const ascending = buildCascadeLocalCacheTokens(makeInput([10, 11])).tokens;
-    const descending = buildCascadeLocalCacheTokens(makeInput([11, 10])).tokens;
-    expect(descending).toEqual(ascending);
-  });
-
-  it('requires a complete CSM hit before allowing atlas reuse', () => {
-    const common = {
-      shadowMapSize: 1024,
-      cascadeCount: 2,
-      pipelineHandle: 7,
-      graphTopologyKey: 'shadow-graph-v1',
-      assetCatalogEpoch: 3,
-      meshResidencyEpoch: 4,
-      productionSceneToken: true,
-      worldStateMatches: true,
-    };
-    const cached = {
-      worlds: [],
-      worldStateTokens: [],
-      ...common,
-      cascadeTokens: ['csm-0-a', 'csm-1-b'],
-    } as never;
-    const hit = evaluateDirectionalShadowCache({
-      cached,
-      cascadeTokens: ['csm-0-a', 'csm-1-b'],
-      ...common,
-    });
-    expect(hit).toEqual({ reuse: true, hitMask: 3, missReason: undefined });
-
-    const partial = evaluateDirectionalShadowCache({
-      cached,
-      cascadeTokens: ['csm-0-a', 'csm-1-changed'],
-      ...common,
-    });
-    expect(partial).toEqual({ reuse: false, hitMask: 1, missReason: 'cascade-token' });
-
-    const forced = evaluateDirectionalShadowCache({
-      cached,
-      cascadeTokens: ['csm-0-a', 'csm-1-b'],
-      ...common,
-      graphTopologyKey: 'shadow-graph-v2',
-    });
-    expect(forced).toEqual({ reuse: false, hitMask: 0, missReason: 'graph-topology' });
+    expect(topology.inspect().ineligible).toBe(0);
   });
 });

package/src/__tests__/gpu-resource-store-stride.unit.test.ts

@@ -3,13 +3,13 @@ import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
 import { rhi } from '@forgeax/engine-rhi-null';
 import type { MeshAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { GpuResourceStore } from '../gpu-resource-store';
+import { GpuResidencyCache } from '../device/gpu-residency';
 
-describe('GpuResourceStore mesh stride', () => {
+describe('GpuResidencyCache mesh stride', () => {
   it('keeps the canonical 18F plus UV1 stride from the complete projection', async () => {
     const adapter = (await rhi.requestAdapter()).unwrap();
     const device = (await adapter.requestDevice()).unwrap();
-    const store = new GpuResourceStore();
+    const store = new GpuResidencyCache();
     store.configureGpuDevice(
       device,
       undefined,

package/src/__tests__/gpu-scene-render-graph-gpu.ts

@@ -4,8 +4,8 @@ import { createShaderModule, rhi } from '@forgeax/engine-rhi-webgpu';
 import { GpuScene } from '../gpu-scene';
 import { GPU_SCENE_LAYOUTS, GPU_SCENE_WGSL } from '../gpu-scene-schema';
 import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_MAP_READ } from '../gpu-usage';
-import { RenderSceneProjection } from '../render-scene-projection';
 import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
+import { RenderScene } from '../scene/render-scene';
 
 const BUFFER_USAGE_STORAGE = 0x0080;
 const COMPUTE_VISIBILITY = 0x4;
@@ -115,10 +115,9 @@ export async function runGpuSceneGraph(): Promise<GpuSceneGraphEvidence> {
   const availability = GpuScene.create(device, 4).unwrap();
   if (availability.status !== 'available') throw new Error(availability.reason);
   const scene = availability.scene;
-  const projection = new RenderSceneProjection();
+  const projection = new RenderScene();
   scene
     .sync(
-      projection,
       projection.apply([
         { kind: 'create', snapshot: snapshot(10, -3) },
         { kind: 'create', snapshot: snapshot(11, -0.5) },