@forgeax/engine-render 0.1.27 → 0.1.29

package/src/__tests__/gpu-driven-view-gpu-evidence.ts

@@ -44,6 +44,15 @@ function snapshot(entityKey: number, x: number): RenderableSnapshot {
   };
 }
 
+function updateSnapshot(value: RenderableSnapshot) {
+  return {
+    kind: 'update' as const,
+    worldId: value.worldId,
+    entityKey: value.entityKey,
+    snapshot: value,
+  };
+}
+
 export interface GpuDrivenViewGpuEvidence {
   readonly visibleInstance: number;
   readonly indexCount: number;
@@ -90,12 +99,17 @@ export async function runGpuDrivenViewLifecycleEvidence(
   for (let frame = 0; frame < frames; frame += 1) {
     const targetCount = frame < 4 ? 2 ** frame : frame % 2 === 0 ? 1 : 8;
     const operations: Array<
-      | { readonly kind: 'create'; readonly snapshot: RenderableSnapshot }
+      | {
+          readonly kind: 'update';
+          readonly worldId: number;
+          readonly entityKey: number;
+          readonly snapshot: RenderableSnapshot;
+        }
       | { readonly kind: 'remove'; readonly worldId: number; readonly entityKey: number }
     > = [];
     while (activeCount < targetCount) {
       activeCount += 1;
-      operations.push({ kind: 'create', snapshot: snapshot(activeCount, activeCount * 0.05) });
+      operations.push(updateSnapshot(snapshot(activeCount, activeCount * 0.05)));
     }
     while (activeCount > targetCount) {
       operations.push({ kind: 'remove', worldId: 0, entityKey: activeCount });
@@ -140,6 +154,9 @@ export async function runGpuDrivenViewLifecycleEvidence(
 export async function runGpuDrivenViewGpuEvidence(): Promise<GpuDrivenViewGpuEvidence> {
   const adapter = (await rhi.requestAdapter()).unwrap();
   const device = (await adapter.requestDevice()).unwrap();
+  const rawDevice = _internal_getRawDevice(device);
+  if (rawDevice === undefined) throw new Error('GPU-driven evidence raw device unavailable');
+  rawDevice.pushErrorScope('validation');
   const shader = (
     await rhi.createShaderModule(device, {
       code: GPU_DRIVEN_VIEW_WGSL,
@@ -168,19 +185,16 @@ export async function runGpuDrivenViewGpuEvidence(): Promise<GpuDrivenViewGpuEvi
     ],
   };
   const delta = projection.apply([
-    {
-      kind: 'create',
-      snapshot: {
-        ...instancedWithLod,
-        instances: {
-          transforms: new Float32Array([...visibleInstance, ...culledInstance]),
-          instanceCount: 2,
-          cacheKey: 1,
-          archVersion: 1,
-        },
+    updateSnapshot({
+      ...instancedWithLod,
+      instances: {
+        transforms: new Float32Array([...visibleInstance, ...culledInstance]),
+        instanceCount: 2,
+        cacheKey: 1,
+        archVersion: 1,
       },
-    },
-    { kind: 'create', snapshot: snapshot(2, 10) },
+    }),
+    updateSnapshot(snapshot(2, 10)),
   ]);
   const sceneAvailability = GpuScene.create(device, 2).unwrap();
   if (sceneAvailability.status !== 'available') throw new Error('GPU Scene unavailable');
@@ -248,16 +262,54 @@ export async function runGpuDrivenViewGpuEvidence(): Promise<GpuDrivenViewGpuEvi
     64,
   );
   device.queue.submit([encoder.finish().unwrap()]).unwrap();
-  await device.queue.onSubmittedWorkDone();
 
-  // Exercise the real GPU telemetry readback before any mapped range is
-  // unmapped.  This is intentionally on the same submit as the visible and
-  // indirect readbacks so a detached DataView cannot be hidden by a mock or a
-  // separate inspection path.
-  const lodSelection = await view.readLodSelection();
+  // Start observing immediately, then submit the cached graph again before
+  // the first mapAsync settles. The second copy must be skipped while the
+  // readback is pending; compute/raster work remains submit-able.
+  const pendingLodSelection = view.readLodSelection();
+  if (view.readLodSelection() !== pendingLodSelection) {
+    throw new Error('GPU-driven LOD telemetry did not coalesce concurrent observers');
+  }
+  const overlappingEncoder = device
+    .createCommandEncoder({ label: 'gpu-driven-evidence-overlap' })
+    .unwrap();
+  compiled.execute({ encoder: overlappingEncoder }).unwrap();
+  device.queue.submit([overlappingEncoder.finish().unwrap()]).unwrap();
+  const lodSelection = await pendingLodSelection;
   if (lodSelection === undefined || lodSelection.batches.length !== lodSelection.batchCount) {
     throw new Error('GPU-driven LOD selection readback unavailable or incomplete');
   }
+  await device.queue.onSubmittedWorkDone();
+
+  // After unmap, a later cached-graph submission must restore telemetry
+  // observation rather than leaving the latch permanently consumed.
+  const recoveryProjection = mat4.identity(mat4.create());
+  recoveryProjection[12] = 10;
+  view
+    .update(
+      topology.plan(),
+      sceneAvailability.scene,
+      frustum.fromViewProjection(frustum.create(), recoveryProjection),
+    )
+    .unwrap();
+  const recoveryEncoder = device
+    .createCommandEncoder({ label: 'gpu-driven-evidence-recovery' })
+    .unwrap();
+  compiled.execute({ encoder: recoveryEncoder }).unwrap();
+  device.queue.submit([recoveryEncoder.finish().unwrap()]).unwrap();
+  await device.queue.onSubmittedWorkDone();
+  const recoveredLodSelection = await view.readLodSelection();
+  if (
+    recoveredLodSelection === undefined ||
+    recoveredLodSelection === lodSelection ||
+    recoveredLodSelection.visible === lodSelection.visible
+  ) {
+    throw new Error('GPU-driven LOD telemetry did not recover after a skipped copy');
+  }
+  const validationError = await rawDevice.popErrorScope();
+  if (validationError !== null) {
+    throw new Error(`GPU-driven telemetry overlap validation failed: ${validationError.message}`);
+  }
 
   const visibleMap = (await visibleReadback.mapAsync(GPU_MAP_MODE_READ)).unwrap();
   const visibleValue = new DataView(visibleMap.getMappedRange().unwrap()).getUint32(0, true);

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

@@ -53,11 +53,26 @@ function snapshot(entityKey: number): RenderableSnapshot {
   };
 }
 
+function updateSnapshot(value: RenderableSnapshot) {
+  return {
+    kind: 'update' as const,
+    worldId: value.worldId,
+    entityKey: value.entityKey,
+    snapshot: value,
+  };
+}
+
 function preparedFrame(view: GpuDrivenView): PreparedGpuDrivenFrame {
   return {
     topologySignature: `view-generation:${view.inspect().resourceGeneration}`,
-    entityKeys: new Set(),
-    ownsAllRenderables: true,
+    ownsAllDrawItems: true,
+    standardPbrFrameResources: {
+      materialBindGroups: [],
+      materialSlotIndicesByEntity: new Map(),
+      instancesBindGroup: {} as never,
+      materialStride: 0,
+      sceneMaterialBuffer: {} as never,
+    },
     _commitResourceReplacement: () => view._commitResourceReplacement(),
     project: (graph) => {
       const projected = view.addPasses(graph);
@@ -126,8 +141,14 @@ describe('GpuDrivenView graph projection', () => {
     if (first === null) return;
     const prepared: PreparedGpuDrivenFrame = {
       topologySignature: 'stable-gpu-driven-test',
-      entityKeys: new Set(),
-      ownsAllRenderables: true,
+      ownsAllDrawItems: true,
+      standardPbrFrameResources: {
+        materialBindGroups: [],
+        materialSlotIndicesByEntity: new Map(),
+        instancesBindGroup: {} as never,
+        materialStride: 0,
+        sceneMaterialBuffer: {} as never,
+      },
       _commitResourceReplacement: () => undefined,
       project: (graph) => {
         const pass = graph.addComputePass('gpu-driven-test', {
@@ -153,7 +174,7 @@ describe('GpuDrivenView graph projection', () => {
     const device = (await adapter.requestDevice()).unwrap();
     const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
     const projection = new RenderScene();
-    const delta = projection.apply([{ kind: 'create', snapshot: snapshot(1) }]);
+    const delta = projection.apply([updateSnapshot(snapshot(1))]);
     const sceneAvailability = GpuScene.create(device, 1).unwrap();
     expect(sceneAvailability.status).toBe('available');
     if (sceneAvailability.status !== 'available') return;
@@ -240,7 +261,7 @@ describe('GpuDrivenView graph projection', () => {
     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 firstDelta = projection.apply([updateSnapshot(snapshot(1))]);
     const sceneAvailability = GpuScene.create(device, 2).unwrap();
     expect(sceneAvailability.status).toBe('available');
     if (sceneAvailability.status !== 'available') return;
@@ -351,7 +372,7 @@ describe('GpuDrivenView graph projection', () => {
     delete (device as unknown as { caps?: unknown }).caps;
     delete (device as unknown as { surfaceViewFormats?: unknown }).surfaceViewFormats;
 
-    const secondDelta = projection.apply([{ kind: 'create', snapshot: snapshot(2) }]);
+    const secondDelta = projection.apply([updateSnapshot(snapshot(2))]);
     sceneAvailability.scene.sync(secondDelta).unwrap();
     topology.rebuild(projection.slotsSnapshot());
     view.update(topology.plan(), sceneAvailability.scene, planes).unwrap();
@@ -389,7 +410,7 @@ describe('GpuDrivenView graph projection', () => {
     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 firstDelta = projection.apply([updateSnapshot(snapshot(1))]);
     const sceneAvailability = GpuScene.create(device, 2).unwrap();
     expect(sceneAvailability.status).toBe('available');
     if (sceneAvailability.status !== 'available') return;
@@ -406,7 +427,7 @@ describe('GpuDrivenView graph projection', () => {
     expect(firstVisible).toBeDefined();
     if (firstVisible === undefined) return;
 
-    const secondDelta = projection.apply([{ kind: 'create', snapshot: snapshot(2) }]);
+    const secondDelta = projection.apply([updateSnapshot(snapshot(2))]);
     sceneAvailability.scene.sync(secondDelta).unwrap();
     topology.rebuild(projection.slotsSnapshot());
     view.update(topology.plan(), sceneAvailability.scene, planes).unwrap();

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

@@ -1,6 +1,7 @@
 import { frustum, mat4 } from '@forgeax/engine-math';
 import { describe, expect, it } from 'vitest';
 import { BatchTopology } from '../gpu-driven/batch-topology';
+import { GPU_DRIVEN_VIEW_WGSL } from '../gpu-driven/view-gpu';
 import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
 import { RenderScene } from '../scene/render-scene';
 import { classifyGpuDrivenView } from './gpu-driven-view-reference';
@@ -38,13 +39,22 @@ function snapshot(entityKey: number, x: number, resourceClass = 'plain'): Render
   };
 }
 
+function updateSnapshot(value: RenderableSnapshot) {
+  return {
+    kind: 'update' as const,
+    worldId: value.worldId,
+    entityKey: value.entityKey,
+    snapshot: value,
+  };
+}
+
 describe('GPU-driven batch topology and CPU oracle', () => {
   it('isolates LOD candidates so one indirect range cannot serve different meshes', () => {
     const projection = new RenderScene();
     const lods = [{ mesh: '00000000-0000-7000-8000-000000000001' as never, screenCoverage: 0.5 }];
     projection.apply([
-      { kind: 'create', snapshot: { ...snapshot(1, 0), lods } },
-      { kind: 'create', snapshot: { ...snapshot(2, 4), lods } },
+      updateSnapshot({ ...snapshot(1, 0), lods }),
+      updateSnapshot({ ...snapshot(2, 4), lods }),
     ]);
     const topology = new BatchTopology();
     topology.rebuild(projection.slotsSnapshot());
@@ -54,7 +64,7 @@ describe('GPU-driven batch topology and CPU oracle', () => {
 
     const transformOnly = projection.apply([
       {
-        kind: 'update-transform',
+        kind: 'update',
         worldId: 0,
         entityKey: 1,
         world: snapshot(1, 0.25).transform.world,
@@ -64,22 +74,19 @@ describe('GPU-driven batch topology and CPU oracle', () => {
 
     const instancedProjection = new RenderScene();
     instancedProjection.apply([
-      {
-        kind: 'create',
-        snapshot: {
-          ...snapshot(3, 0),
-          lods,
-          instances: {
-            transforms: new Float32Array([
-              ...mat4.identity(mat4.create()),
-              ...mat4.identity(mat4.create()),
-            ]),
-            instanceCount: 2,
-            cacheKey: 3,
-            archVersion: 1,
-          },
+      updateSnapshot({
+        ...snapshot(3, 0),
+        lods,
+        instances: {
+          transforms: new Float32Array([
+            ...mat4.identity(mat4.create()),
+            ...mat4.identity(mat4.create()),
+          ]),
+          instanceCount: 2,
+          cacheKey: 3,
+          archVersion: 1,
         },
-      },
+      }),
     ]);
     const instancedTopology = new BatchTopology();
     instancedTopology.rebuild(instancedProjection.slotsSnapshot());
@@ -89,12 +96,25 @@ describe('GPU-driven batch topology and CPU oracle', () => {
     );
   });
 
+  it('projects compact visible items into batch-local mesh and material indices', () => {
+    expect(GPU_DRIVEN_VIEW_WGSL).toMatch(
+      /vec2<u32>\(\s*candidate\.submitAdmission >> 1u,\s*materialOrPalette,/,
+    );
+    expect(GPU_DRIVEN_VIEW_WGSL).toContain('(candidate.submitAdmission & 1u)');
+    expect(GPU_DRIVEN_VIEW_WGSL).toContain('instance.customDataStart');
+    expect(GPU_DRIVEN_VIEW_WGSL).toContain('(candidate.materialSlot & 0x80000000u)');
+    expect(GPU_DRIVEN_VIEW_WGSL).toContain('visibleIndices[candidate.visibleBase + localVisible]');
+    expect(GPU_DRIVEN_VIEW_WGSL).toContain('overflowIndex(candidate.batchIndex)');
+    expect(GPU_DRIVEN_VIEW_WGSL).toContain('visibleCount = 0u');
+    expect(GPU_DRIVEN_VIEW_WGSL).toContain('indirectArgs[args + 4u] = 0u');
+  });
+
   it('patches topology only when compatibility membership changes', () => {
     const projection = new RenderScene();
     projection.apply([
-      { kind: 'create', snapshot: snapshot(1, 0) },
-      { kind: 'create', snapshot: snapshot(2, 0.5) },
-      { kind: 'create', snapshot: snapshot(3, 0, 'textured') },
+      updateSnapshot(snapshot(1, 0)),
+      updateSnapshot(snapshot(2, 0.5)),
+      updateSnapshot(snapshot(3, 0, 'textured')),
     ]);
     const topology = new BatchTopology();
     topology.rebuild(projection.slotsSnapshot());
@@ -103,7 +123,7 @@ describe('GPU-driven batch topology and CPU oracle', () => {
 
     const transformOnly = projection.apply([
       {
-        kind: 'update-transform',
+        kind: 'update',
         worldId: 0,
         entityKey: 1,
         world: snapshot(1, 0.25).transform.world,
@@ -120,10 +140,7 @@ describe('GPU-driven batch topology and CPU oracle', () => {
 
   it('compacts visible primitive indices and writes portable indexed indirect args', () => {
     const projection = new RenderScene();
-    projection.apply([
-      { kind: 'create', snapshot: snapshot(1, 0) },
-      { kind: 'create', snapshot: snapshot(2, 10) },
-    ]);
+    projection.apply([updateSnapshot(snapshot(1, 0)), updateSnapshot(snapshot(2, 10))]);
     const topology = new BatchTopology();
     topology.rebuild(projection.slotsSnapshot());
     const planes = frustum.fromViewProjection(frustum.create(), mat4.identity(mat4.create()));
@@ -152,16 +169,13 @@ describe('GPU-driven batch topology and CPU oracle', () => {
     expect(first).toBeDefined();
     if (first === undefined) return;
     projection.apply([
-      {
-        kind: 'create',
-        snapshot: {
-          ...source,
-          gpuDrivenDraws: [
-            { ...first, kind: 'non-indexed', first: 0, count: 3 },
-            { ...first, kind: 'non-indexed', first: 3, count: 6 },
-          ],
-        },
-      },
+      updateSnapshot({
+        ...source,
+        gpuDrivenDraws: [
+          { ...first, kind: 'non-indexed', first: 0, count: 3 },
+          { ...first, kind: 'non-indexed', first: 3, count: 6 },
+        ],
+      }),
     ]);
     const topology = new BatchTopology();
     topology.rebuild(projection.slotsSnapshot());
@@ -180,6 +194,105 @@ describe('GPU-driven batch topology and CPU oracle', () => {
     expect(secondArgs.getUint32(12, true)).toBe(0);
   });
 
+  it('retains source draw identity when an earlier compact draw is ineligible', () => {
+    const source = snapshot(1, 0);
+    const first = source.gpuDrivenDraws?.[0];
+    expect(first).toBeDefined();
+    if (first === undefined) return;
+    const projection = new RenderScene();
+    projection.apply([
+      updateSnapshot({
+        ...source,
+        gpuDrivenDraws: [
+          {
+            ...first,
+            drawItemIndex: 10,
+            prepared: {
+              identity: { material: 'custom', geometry: 'triangle', deformation: 'rigid' },
+            } as never,
+          },
+          { ...first, drawItemIndex: 20, first: 9, count: 12 },
+        ],
+      }),
+    ]);
+    const topology = new BatchTopology();
+    topology.rebuild(projection.slotsSnapshot());
+    const candidates = topology.plan().batches.flatMap((batch) => batch.candidates);
+    expect(candidates).toHaveLength(1);
+    expect(candidates[0]?.drawItemIndex).toBe(20);
+    expect(topology.plan().batches[0]?.key).toMatchObject({ first: 9, count: 12 });
+  });
+
+  it('patches a same-key eligibility swap using the retained draw identity', () => {
+    const source = snapshot(1, 0);
+    const first = source.gpuDrivenDraws?.[0];
+    expect(first).toBeDefined();
+    if (first === undefined) return;
+    const ineligible = {
+      ...first,
+      drawItemIndex: 10,
+      prepared: {
+        identity: { material: 'custom', geometry: 'triangle', deformation: 'rigid' },
+      } as never,
+    };
+    const eligible = { ...first, drawItemIndex: 20, first: 9, count: 12 };
+    const eligibleAt10 = { ...eligible, drawItemIndex: 10 };
+    const ineligibleAt20 = { ...ineligible, drawItemIndex: 20 };
+    const projection = new RenderScene();
+    projection.apply([updateSnapshot({ ...source, gpuDrivenDraws: [ineligible, eligible] })]);
+    const topology = new BatchTopology();
+    topology.rebuild(projection.slotsSnapshot());
+    const swapped = projection.apply([
+      updateSnapshot({ ...source, gpuDrivenDraws: [eligibleAt10, ineligibleAt20] }),
+    ]);
+    expect(topology.apply(swapped)).toBe(true);
+    expect(topology.inspect().patches).toBe(1);
+    expect(topology.plan().batches.flatMap((batch) => batch.candidates)[0]?.drawItemIndex).toBe(10);
+  });
+
+  it('keeps prepared material and range identity after reversing submesh order', () => {
+    const source = snapshot(1, 0);
+    const first = source.gpuDrivenDraws?.[0];
+    expect(first).toBeDefined();
+    if (first === undefined) return;
+    const materialA = { ...material, materialHandle: 11 } as MaterialSnapshot;
+    const materialB = { ...material, materialHandle: 12 } as MaterialSnapshot;
+    const orderedDraws = [
+      { ...first, drawItemIndex: 4, materialSlot: 0, first: 0, count: 3 },
+      { ...first, drawItemIndex: 9, materialSlot: 1, first: 3, count: 6 },
+    ];
+    const [orderedFirst, orderedSecond] = orderedDraws;
+    if (orderedFirst === undefined || orderedSecond === undefined) return;
+    const ordered = {
+      ...source,
+      materials: [materialA, materialB],
+      material: materialA,
+      gpuDrivenDraws: orderedDraws,
+    };
+    const reversed = {
+      ...ordered,
+      gpuDrivenDraws: [orderedSecond, orderedFirst],
+    };
+    const orderedTopology = new BatchTopology();
+    const reversedTopology = new BatchTopology();
+    const orderedScene = new RenderScene();
+    const reversedScene = new RenderScene();
+    orderedScene.apply([updateSnapshot(ordered)]);
+    reversedScene.apply([updateSnapshot(reversed)]);
+    orderedTopology.rebuild(orderedScene.slotsSnapshot());
+    reversedTopology.rebuild(reversedScene.slotsSnapshot());
+    const describe = (topology: BatchTopology) =>
+      topology
+        .plan()
+        .batches.map((batch) => [
+          batch.key.materialSlot,
+          batch.key.first,
+          batch.key.count,
+          batch.candidates[0]?.drawItemIndex,
+        ]);
+    expect(describe(reversedTopology).sort()).toEqual(describe(orderedTopology).sort());
+  });
+
   it('culls ordinary instance-local transforms and emits instance identities', () => {
     const source = snapshot(1, 0);
     const identity = mat4.identity(mat4.create());
@@ -187,18 +300,15 @@ describe('GPU-driven batch topology and CPU oracle', () => {
     outside[12] = 10;
     const projection = new RenderScene();
     projection.apply([
-      {
-        kind: 'create',
-        snapshot: {
-          ...source,
-          instances: {
-            transforms: new Float32Array([...identity, ...outside]),
-            instanceCount: 2,
-            cacheKey: 1,
-            archVersion: 1,
-          },
+      updateSnapshot({
+        ...source,
+        instances: {
+          transforms: new Float32Array([...identity, ...outside]),
+          instanceCount: 2,
+          cacheKey: 1,
+          archVersion: 1,
         },
-      },
+      }),
     ]);
     const topology = new BatchTopology();
     topology.rebuild(projection.slotsSnapshot());
@@ -215,10 +325,7 @@ describe('GPU-driven batch topology and CPU oracle', () => {
 
   it('reports overflow instead of silently accepting a truncated batch', () => {
     const projection = new RenderScene();
-    projection.apply([
-      { kind: 'create', snapshot: snapshot(1, 0) },
-      { kind: 'create', snapshot: snapshot(2, 0.5) },
-    ]);
+    projection.apply([updateSnapshot(snapshot(1, 0)), updateSnapshot(snapshot(2, 0.5))]);
     const topology = new BatchTopology();
     topology.rebuild(projection.slotsSnapshot());
     const plan = topology.plan();
@@ -239,7 +346,7 @@ describe('GPU-driven batch topology and CPU oracle', () => {
     const projection = new RenderScene();
     const { localAabb: _localAabb, ...withoutBounds } = snapshot(1, 0);
     const topology = new BatchTopology();
-    topology.rebuild(projection.apply([{ kind: 'create', snapshot: withoutBounds }]).createdSlots);
+    topology.rebuild(projection.apply([updateSnapshot(withoutBounds)]).createdSlots);
     expect(topology.inspect().ineligible).toBe(1);
 
     const removed = projection.apply([{ kind: 'remove', worldId: 0, entityKey: 1 }]);

package/src/__tests__/gpu-pass-timing.browser.test.ts

@@ -4,7 +4,12 @@ import { runBrowserGpuPassTiming } from './gpu-pass-timing-browser-runner.js';
 const browserReady = typeof navigator !== 'undefined' && navigator.gpu !== undefined;
 
 describe.skipIf(!browserReady)('GPU pass timing Browser dev-server runner', () => {
-  it('keeps receipt facts and unsupported timing structured without stopping draw', async () => {
+  // The first live lavapipe renderer pair can exceed Vitest's 15s default while
+  // the shader manifest and timestamp-query path are cold; keep this bound
+  // local to the real WebGPU owner instead of weakening the global timeout.
+  it('keeps receipt facts and unsupported timing structured without stopping draw', {
+    timeout: 30_000,
+  }, async () => {
     const result = await runBrowserGpuPassTiming();
     expect(result.frames).toBe(3);
     if (result.supported) {

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

@@ -121,4 +121,46 @@ describe('GpuResidencyCache mesh stride', () => {
     if (packedIndices === undefined) return;
     expect(new Uint16Array(packedIndices.buffer)).toEqual(new Uint16Array([0, 1, 2, 0, 2, 1]));
   });
+
+  it('refuses a payload whose bytes do not match the projected stride', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap();
+    const store = new GpuResidencyCache();
+    store.configureGpuDevice(
+      device,
+      undefined,
+      () => {
+        throw new Error('cubemap registration is not part of this test');
+      },
+      device.caps,
+    );
+    const mesh: MeshAsset = {
+      kind: 'mesh',
+      vertices: new Float32Array(49),
+      attributes: {
+        position: new Float32Array(9),
+        normal: new Float32Array(9),
+        uv: new Float32Array(6),
+        tangent: new Float32Array(12),
+      },
+      submeshes: [
+        {
+          indexOffset: 0,
+          indexCount: 0,
+          vertexCount: 3,
+          topology: 'triangle-list',
+          materialSlot: 0,
+        },
+      ],
+      materialSlots: [{ slotName: 'default' }],
+    };
+    const world = new World();
+    const handle = world.allocSharedRef('MeshAsset', mesh);
+
+    const resident = store.ensureResident(handle, mesh);
+
+    expect(resident.ok).toBe(false);
+    if (!resident.ok) expect(resident.error.code).toBe('asset-not-registered');
+    expect(store.getMeshGpuHandles(handle)).toBeUndefined();
+  });
 });

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

@@ -76,7 +76,12 @@ fn fs(input: VertexOutput) -> @location(0) vec4<f32> {
 }
 `;
 
-const material = { materialHandle: 1 } as MaterialSnapshot;
+const material = {
+  baseColor: new Float32Array([1, 1, 1]),
+  metallic: 0,
+  roughness: 1,
+  materialHandle: 1,
+} as MaterialSnapshot;
 
 function snapshot(entityKey: number, translationX: number): RenderableSnapshot {
   const world = new Float32Array(16);
@@ -97,6 +102,15 @@ function snapshot(entityKey: number, translationX: number): RenderableSnapshot {
   };
 }
 
+function updateSnapshot(value: RenderableSnapshot) {
+  return {
+    kind: 'update' as const,
+    worldId: value.worldId,
+    entityKey: value.entityKey,
+    snapshot: value,
+  };
+}
+
 function bufferBinding(buffer: Buffer) {
   return { kind: 'buffer' as const, value: { buffer } };
 }
@@ -119,10 +133,10 @@ export async function runGpuSceneGraph(): Promise<GpuSceneGraphEvidence> {
   scene
     .sync(
       projection.apply([
-        { kind: 'create', snapshot: snapshot(10, -3) },
-        { kind: 'create', snapshot: snapshot(11, -0.5) },
-        { kind: 'create', snapshot: snapshot(12, 0.5) },
-        { kind: 'create', snapshot: snapshot(13, 3) },
+        updateSnapshot(snapshot(10, -3)),
+        updateSnapshot(snapshot(11, -0.5)),
+        updateSnapshot(snapshot(12, 0.5)),
+        updateSnapshot(snapshot(13, 3)),
       ]),
     )
     .unwrap();