@forgeax/engine-render 0.1.28 → 0.1.30

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';
@@ -9,6 +10,7 @@ const material = {
   baseColor: new Float32Array([1, 1, 1]),
   metallic: 0,
   roughness: 1,
+  materialShaderId: 'forgeax::default-standard-pbr',
 } as MaterialSnapshot;
 
 function snapshot(entityKey: number, x: number, resourceClass = 'plain'): RenderableSnapshot {
@@ -38,13 +40,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 +65,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 +75,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 +97,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 +124,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 +141,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 +170,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 +195,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 +301,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 +326,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 +347,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-runner.ts

@@ -104,6 +104,21 @@ function drawTimingFrame(fixture: BrowserTimingFixture): {
   };
 }
 
+export async function observeBrowserGpuPassTimingDisabled() {
+  const fixture = await createBrowserTimingFixture(false);
+  try {
+    const { receipt } = drawTimingFrame(fixture);
+    const requested = await fixture.renderer.observe(receipt, { include: ['timings'] });
+    const omitted = await fixture.renderer.observe(receipt, { include: ['draws'] });
+    if (!requested.ok) throw requested.error;
+    if (!omitted.ok) throw omitted.error;
+    return { requested: requested.value, omitted: omitted.value };
+  } finally {
+    await fixture.renderer.dispose();
+    fixture.canvas.remove();
+  }
+}
+
 function adapterString(value: unknown): string | undefined {
   return typeof value === 'string' && value.length > 0 ? value : undefined;
 }

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

@@ -1,10 +1,28 @@
 import { describe, expect, it } from 'vitest';
-import { runBrowserGpuPassTiming } from './gpu-pass-timing-browser-runner.js';
+import {
+  observeBrowserGpuPassTimingDisabled,
+  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 () => {
+  it('returns the standard unavailable observation when GPU timing is disabled', async () => {
+    const { requested, omitted } = await observeBrowserGpuPassTimingDisabled();
+    expect(requested.timings).toMatchObject({
+      status: 'unavailable',
+      reason: { code: 'gpu-timing-not-enabled' },
+    });
+    expect(requested.timings).not.toHaveProperty('frame');
+    expect(omitted.timings).toBeUndefined();
+  });
+
+  // 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-scope.unit.test.ts

@@ -0,0 +1,71 @@
+import { err, ok, type RhiDevice, RhiError } from '@forgeax/engine-rhi';
+import { rhi } from '@forgeax/engine-rhi-null';
+import { expect, it, vi } from 'vitest';
+import { DeviceScope } from '../device/device-scope';
+import { GpuBuffer, GpuTexture } from '../gpu-resource';
+
+it.each([
+  'buffer',
+  'texture',
+] as const)('keeps %s ownership on failed destruction and releases it after successful retry', async (kind) => {
+  const device = (await (await rhi.requestAdapter()).unwrap().requestDevice()).unwrap();
+  const scope = DeviceScope.create(1, 'gpu-resource');
+  const method = kind === 'buffer' ? 'destroyBuffer' : 'destroyTexture';
+  const original = device[method].bind(device);
+  const spy = vi
+    .spyOn(device, method)
+    .mockReturnValueOnce(
+      err(
+        new RhiError({ code: 'webgpu-runtime-error', expected: 'injected failure', hint: 'retry' }),
+      ),
+    );
+  const resource =
+    kind === 'buffer'
+      ? new GpuBuffer(device, device.createBuffer({ size: 64, usage: 8 }).unwrap(), scope)
+      : new GpuTexture(
+          device,
+          device
+            .createTexture({
+              size: [1, 1, 1],
+              format: 'rgba8unorm',
+              usage: 4,
+              textureBindingViewDimension: '2d',
+            })
+            .unwrap(),
+          scope,
+        );
+  expect(scope.resourceDelta()).toBe(1);
+  expect(resource.destroy().ok).toBe(false);
+  expect(resource.isDestroyed).toBe(false);
+  expect(scope.resourceDelta()).toBe(1);
+  spy.mockImplementation(original as RhiDevice[typeof method]);
+  expect(resource.destroy().ok).toBe(true);
+  expect(resource.isDestroyed).toBe(true);
+  expect(scope.resourceDelta()).toBe(0);
+  scope.retire();
+  expect(spy).toHaveBeenCalledTimes(2);
+  expect(resource.destroy().ok).toBe(false);
+  expect(scope.resourceDelta()).toBe(0);
+});
+
+it('cleans remaining resources in reverse order after an earlier resource was released', async () => {
+  const device = (await (await rhi.requestAdapter()).unwrap().requestDevice()).unwrap();
+  const scope = DeviceScope.create(1, 'gpu-resource-order');
+  const resources = Array.from(
+    { length: 3 },
+    () => new GpuBuffer(device, device.createBuffer({ size: 64, usage: 8 }).unwrap(), scope),
+  );
+  const handles: unknown[] = [];
+  vi.spyOn(device, 'destroyBuffer').mockImplementation((handle) => {
+    handles.push(handle);
+    return ok(undefined);
+  });
+  const [first, second, third] = resources;
+  if (first === undefined || second === undefined || third === undefined)
+    throw new Error('missing fixture resource');
+  second.destroy().unwrap();
+  scope.retire();
+  scope.dispose();
+  expect(handles).toEqual([second.handle, third.handle, first.handle]);
+  expect(scope.resourceDelta()).toBe(0);
+});