@forgeax/engine-rhi-debug 0.1.28 → 0.1.30

package/src/__tests__/recorder-session.integration.test.ts

@@ -1,9 +1,64 @@
 import { createShaderModule, rhi } from '@forgeax/engine-rhi-null';
+import { ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { attachRecorder, openReplay } from '../index';
 import { decodeTape } from '../protocol/codec';
 
 describe('RecorderSession real RHI consumer', () => {
+  it('preserves synchronous shader creation and replays pipeline-derived layouts', async () => {
+    const source = '@compute @workgroup_size(1) fn main() {}';
+    const rawDevice = (await (await rhi.requestAdapter()).unwrap().requestDevice()).unwrap();
+    const module = (await createShaderModule(rawDevice, { code: source })).unwrap();
+    let receivedDevice: unknown;
+    const attachment = attachRecorder({
+      rhi,
+      createShaderModule,
+      createShaderModuleImmediate: (device) => {
+        receivedDevice = device;
+        return ok(module);
+      },
+    }).unwrap();
+    const device = (
+      await (await attachment.backend.rhi.requestAdapter()).unwrap().requestDevice()
+    ).unwrap();
+    const factory = attachment.backend.createShaderModuleImmediate;
+    expect(factory).toBeTypeOf('function');
+    expect(
+      (attachment.backend.rhi as unknown as { createShaderModuleImmediate: unknown })
+        .createShaderModuleImmediate,
+    ).toBe(factory);
+    const shader = factory?.(device, { code: source });
+    expect(shader?.ok).toBe(true);
+    expect(receivedDevice).not.toBe(device);
+    if (!shader?.ok) throw new Error('synchronous shader factory unavailable');
+    const pipeline = device
+      .createComputePipeline({
+        layout: 'auto',
+        compute: { module: shader.value, entryPoint: 'main' },
+      })
+      .unwrap();
+    const layout = (
+      pipeline as typeof pipeline & import('@forgeax/engine-rhi').RhiComputePipelineOps
+    ).getBindGroupLayout(0);
+    const bindings = device.createBindGroup({ layout, entries: [] }).unwrap();
+    const capture = attachment.captureFrame();
+    (await attachment.frameBoundary()).unwrap();
+    const encoder = device.createCommandEncoder({}).unwrap();
+    const pass = encoder.beginComputePass({});
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, bindings);
+    pass.dispatchWorkgroups(1);
+    pass.end();
+    device.queue.submit([encoder.finish().unwrap()]).unwrap();
+    (await attachment.frameBoundary()).unwrap();
+    const tape = decodeTape((await capture).unwrap().bytes).unwrap();
+    expect(tape.bootstrap.some((item) => item.create.kind === 'getBindGroupLayout')).toBe(true);
+    const replayDevice = (await (await rhi.requestAdapter()).unwrap().requestDevice()).unwrap();
+    const replay = await openReplay(tape, { device: replayDevice, createShaderModule });
+    expect(replay.ok).toBe(true);
+    await attachment.dispose();
+  });
+
   it('captures one steady frame into a strict v7 artifact', async () => {
     const attached = attachRecorder({ rhi, createShaderModule });
     expect(attached.ok).toBe(true);

package/src/__tests__/recorder-session.unit.test.ts

@@ -1,4 +1,5 @@
-import type { RhiInstance } from '@forgeax/engine-rhi';
+import type { RhiInstance, ShaderModule } from '@forgeax/engine-rhi';
+import { ok } from '@forgeax/engine-types';
 import { describe, expect, it, vi } from 'vitest';
 import { attachRecorder, type RecordableBackend } from '../recorder/session';
 
@@ -48,6 +49,22 @@ describe('RecorderSession contract', () => {
     ).toBe(attached.value.backend.createShaderModule);
   });
 
+  it('preserves the optional immediate shader factory on both backend seams', () => {
+    const createShaderModuleImmediate = vi.fn(() => ok({} as ShaderModule));
+    const attached = attachRecorder({ ...backend(), createShaderModuleImmediate });
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+
+    expect(attached.value.backend.createShaderModuleImmediate).toBeDefined();
+    expect(
+      (
+        attached.value.backend.rhi as unknown as {
+          createShaderModuleImmediate?: unknown;
+        }
+      ).createShaderModuleImmediate,
+    ).toBe(attached.value.backend.createShaderModuleImmediate);
+  });
+
   it('resolves an abort as one terminal structured result', async () => {
     const attached = attachRecorder(backend());
     expect(attached.ok).toBe(true);

package/src/__tests__/replay-session.dawn.test.ts

@@ -153,7 +153,122 @@ function triangleTape(): Tape {
   };
 }
 
+function msaaTriangleTape(): Tape {
+  const tape = triangleTape();
+  const bootstrapResources = tape.bootstrap.map((resource) => {
+    if (resource.handleId === 'texture:rt') {
+      const desc = resource.create.desc as Record<string, unknown>;
+      return bootstrap('texture:msaa', 'texture', {
+        ...resource.create,
+        handleId: 'texture:msaa',
+        desc: { ...desc, sampleCount: 4, usage: 0x10 },
+      });
+    }
+    if (resource.handleId === 'texture-view:rt') {
+      return bootstrap('texture-view:msaa', 'texture-view', {
+        ...resource.create,
+        sourceHandleId: 'texture:msaa',
+        resultHandleId: 'texture-view:msaa',
+      });
+    }
+    if (resource.handleId === 'pipeline:triangle') {
+      const desc = resource.create.desc as Record<string, unknown>;
+      return bootstrap('pipeline:triangle', 'pipeline', {
+        ...resource.create,
+        desc: { ...desc, multisample: { count: 4 } },
+      });
+    }
+    return resource;
+  });
+  bootstrapResources.push(
+    bootstrap('texture:resolve', 'texture', {
+      kind: 'createTexture',
+      handleId: 'texture:resolve',
+      desc: {
+        size: { width: WIDTH, height: HEIGHT, depthOrArrayLayers: 1 },
+        format: 'rgba8unorm',
+        dimension: '2d',
+        mipLevelCount: 1,
+        sampleCount: 1,
+        usage: 0x11,
+      },
+    }),
+    bootstrap('texture-view:resolve', 'texture-view', {
+      kind: 'createTextureView',
+      sourceHandleId: 'texture:resolve',
+      resultHandleId: 'texture-view:resolve',
+      desc: {},
+    }),
+  );
+
+  const events = tape.events.map((event) => {
+    if (event.kind === 'beginRenderPass') {
+      return {
+        ...event,
+        desc: {
+          ...event.desc,
+          colorAttachments: [
+            {
+              view: null,
+              clearValue: { r: 0, g: 0, b: 0, a: 1 },
+              loadOp: 'clear',
+              storeOp: 'store',
+            },
+          ],
+        },
+        colorAttachmentViewHandleIds: ['texture-view:msaa'],
+        colorAttachmentResolveTargetHandleIds: ['texture-view:resolve'],
+      };
+    }
+    return event;
+  }) as Tape['events'];
+
+  return {
+    ...tape,
+    header: { ...tape.header, blobCount: 0 },
+    bootstrap: bootstrapResources,
+    events,
+    blobs: [],
+  };
+}
+
 describe.skipIf(SKIP_DAWN)('ReplaySession Dawn contract', () => {
+  it.each([
+    0x84, 0x184, 0x06,
+  ])('restores captured buffer bytes without COPY_DST (usage %i)', async (usage) => {
+    const pack = await loadDawn();
+    const expected = new Uint8Array([17, 31, 63, 127, 5, 9, 13, 21]);
+    const tape: Tape = {
+      header: { formatVersion: 7, rhiCaps: {}, eventCount: 0, blobCount: 1 },
+      bootstrap: [
+        bootstrap(
+          'buffer:seed',
+          'buffer',
+          {
+            kind: 'createBuffer',
+            handleId: 'buffer:seed',
+            desc: { size: expected.length, usage },
+          },
+          [{ hash: 'seed', byteOffset: 0, byteLength: expected.length }],
+        ),
+      ],
+      events: [],
+      blobs: [{ hash: 'seed', bytes: expected, compression: 'none' }],
+    };
+    const replay = (
+      await openReplay(tape, {
+        device: await freshDevice(pack),
+        createShaderModule: pack.createShaderModule,
+      })
+    ).unwrap();
+    try {
+      expect((await replay.readResource('buffer:seed')).unwrap().bytes).toEqual(expected);
+      expect(tape.bootstrap[0]?.create.desc).toEqual({ size: expected.length, usage });
+    } finally {
+      (await replay.dispose()).unwrap();
+    }
+  });
+
   it('replays a triangle and returns attachment bytes through inspectWork', async () => {
     const pack = await loadDawn();
     const tape = triangleTape();
@@ -175,6 +290,19 @@ describe.skipIf(SKIP_DAWN)('ReplaySession Dawn contract', () => {
     expect(baseline.value.attachment?.provenance.selectedWorkIndex).toBe(0);
     expect(baseline.value.attachment?.provenance.subresource).toBeNull();
 
+    const selected = await first.value.readResourceAtWork('texture-view:rt', 0);
+    expect(
+      selected.ok,
+      selected.ok ? undefined : `${selected.error.code}: ${JSON.stringify(selected.error.detail)}`,
+    ).toBe(true);
+    if (!selected.ok) throw new Error(selected.error.hint);
+    expect(selected.value.provenance.selectedWorkIndex).toBe(0);
+    expect(selected.value.bytes).toEqual(baseline.value.attachment?.bytes);
+    const bootstrap = await first.value.readResource('texture-view:rt');
+    if (!bootstrap.ok) throw new Error(bootstrap.error.hint);
+    expect(bootstrap.value.provenance.selectedWorkIndex).toBeUndefined();
+    expect(selected.value.bytes).not.toEqual(bootstrap.value.bytes);
+
     const second = await openReplay(tape, {
       device: await freshDevice(pack),
       createShaderModule: pack.createShaderModule,
@@ -189,6 +317,49 @@ describe.skipIf(SKIP_DAWN)('ReplaySession Dawn contract', () => {
     expect((await second.value.dispose()).ok).toBe(true);
   }, 60_000);
 
+  it('resolves an MSAA attachment for pixels and rejects direct MSAA readback', async () => {
+    const pack = await loadDawn();
+    const replayResult = await openReplay(msaaTriangleTape(), {
+      device: await freshDevice(pack),
+      createShaderModule: pack.createShaderModule,
+    });
+    expect(replayResult.ok).toBe(true);
+    if (!replayResult.ok) throw new Error(replayResult.error.hint);
+
+    try {
+      const first = await replayResult.value.inspectWork(0, ['pixels']);
+      expect(
+        first.ok,
+        first.ok ? undefined : `${first.error.code}: ${JSON.stringify(first.error.detail)}`,
+      ).toBe(true);
+      if (!first.ok) throw new Error(first.error.hint);
+      const attachment = first.value.attachment;
+      expect(attachment?.provenance.resourceId).toBe('texture-view:resolve');
+      expect(attachment?.provenance.selectedWorkIndex).toBe(0);
+      expect(attachment?.provenance.subresource).toBeNull();
+      const centerOffset = (Math.floor(HEIGHT / 2) * WIDTH + Math.floor(WIDTH / 2)) * 4;
+      expect(attachment?.bytes.slice(centerOffset, centerOffset + 4)).toEqual(
+        new Uint8Array([255, 0, 0, 255]),
+      );
+
+      const repeated = await replayResult.value.inspectWork(0, ['pixels']);
+      expect(repeated.ok).toBe(true);
+      if (!repeated.ok) throw new Error(repeated.error.hint);
+      expect(repeated.value.attachment?.bytes).toEqual(attachment?.bytes);
+      expect(repeated.value.attachment?.provenance.resourceId).toBe('texture-view:resolve');
+      expect(repeated.value.attachment?.provenance.selectedWorkIndex).toBe(0);
+      expect(repeated.value.attachment?.provenance.subresource).toBeNull();
+
+      const directMsaa = await replayResult.value.readResource('texture:msaa');
+      expect(directMsaa.ok).toBe(false);
+      if (directMsaa.ok) throw new Error('MSAA texture readback unexpectedly succeeded');
+      expect(directMsaa.error.code).toBe('readback-unsupported');
+      expect(directMsaa.error.detail).toMatchObject({ resourceId: 'texture:msaa' });
+    } finally {
+      expect((await replayResult.value.dispose()).ok).toBe(true);
+    }
+  }, 60_000);
+
   it('reports the first shader factory failure on a real Dawn device', async () => {
     const pack = await loadDawn();
     const device = await freshDevice(pack);

package/src/__tests__/replay-session.test-d.ts

@@ -14,6 +14,7 @@ const backend: ReplayBackend = {
 
 expectTypeOf(backend.createShaderModule).toBeFunction();
 expectTypeOf(session.inspectWork(0)).resolves.toHaveProperty('ok');
+expectTypeOf(session.readResourceAtWork('texture:out', 0)).resolves.toHaveProperty('ok');
 expectTypeOf(session.dispose()).resolves.toHaveProperty('ok');
 expectTypeOf<WorkInspection['pipeline']>().not.toBeNever();
 expectTypeOf<WorkInspection['bindings']>().toMatchTypeOf<readonly unknown[] | undefined>();

package/src/__tests__/rhi-debug-fresh-replay.dawn.test.ts

@@ -12,6 +12,7 @@ import {
 } from '../recorder';
 import { assembleTape } from '../recorder/assemble';
 import { openReplay, type ReplayBackend } from '../replay/session';
+import { runQuerySetReplayFixture } from './query-set-replay-fixture';
 
 interface DawnPack {
   readonly rhi: RhiInstance;
@@ -175,4 +176,64 @@ describe.skipIf(SKIP_DAWN)('RHI debug v7 fresh-device evidence', () => {
     expect(normalizedPixelDelta(baseline, replayPixels)).toBeLessThanOrEqual(0.01);
     expect((await session.value.dispose()).ok).toBe(true);
   }, 60_000);
+
+  it('captures and replays an occlusion QuerySet with an eight-byte readback', async () => {
+    const pack = await loadDawn();
+    const recorder = wrap(pack.rhi);
+    const recordingShaderModule = wrapCreateShaderModule(pack.createShaderModule, recorder);
+    const adapter = await recorder.requestAdapter();
+    expect(adapter.ok).toBe(true);
+    if (!adapter.ok) throw new Error(`QuerySet Dawn adapter failed: ${adapter.error.code}`);
+    const deviceResult = await adapter.value.requestDevice();
+    expect(deviceResult.ok).toBe(true);
+    if (!deviceResult.ok)
+      throw new Error(`QuerySet Dawn device failed: ${deviceResult.error.code}`);
+    const armed = recorder.arm(1);
+    expect(armed.ok).toBe(true);
+    if (!armed.ok) throw new Error(armed.error.hint);
+    const evidence = await runQuerySetReplayFixture({
+      runner: 'dawn',
+      device: deviceResult.value,
+      createShaderModule: recordingShaderModule,
+      replayCreateShaderModule: pack.createShaderModule,
+      finishCapture: async () => {
+        recorder.onFrameEnd();
+        const assembled = assembleTape(recorder);
+        if (!assembled.ok) throw new Error(assembled.error.hint);
+        return assembled.value;
+      },
+      createFreshDevice: async () => {
+        const freshAdapter = await pack.rhi.requestAdapter();
+        if (!freshAdapter.ok) throw new Error(freshAdapter.error.hint);
+        const freshDevice = await freshAdapter.value.requestDevice();
+        if (!freshDevice.ok) throw new Error(freshDevice.error.hint);
+        return freshDevice.value;
+      },
+    });
+    expect(evidence, JSON.stringify(evidence.errorReceipts)).toMatchObject({
+      status: 'available',
+      tapeFormatVersion: 7,
+      resolveDestinationOffset: 256,
+      originalQueryValues: expect.arrayContaining([expect.any(String), '0']),
+      originalResultHalfWords: [15360, 0, 0, 15360, 0, 0, 0, 15360],
+      freshQueryValues: ['1', '0'],
+      errorReceipts: [],
+      deviceLost: null,
+    });
+    expect(evidence.originalQueryValues[0]).not.toBe('0');
+    expect(evidence.originalColorBytes.some((byte) => byte > 0)).toBe(true);
+    expect(evidence.eventKinds).toEqual(
+      expect.arrayContaining([
+        'createQuerySet',
+        'beginRenderPass',
+        'beginOcclusionQuery',
+        'endOcclusionQuery',
+        'resolveQuerySet',
+        'submit',
+        'destroyQuerySet',
+      ]),
+    );
+    expect(evidence.querySetHandleId).toBeDefined();
+    expect(evidence.resolveDestinationHandleId).toBeDefined();
+  }, 60_000);
 });

package/src/__tests__/timestamp-query-capture.dawn.test.ts

@@ -0,0 +1,61 @@
+import { rhi } from '@forgeax/engine-rhi-webgpu';
+import { describe, expect, it } from 'vitest';
+import { decodeTape } from '../protocol/codec';
+import { validateTape } from '../protocol/validation';
+import { wrap } from '../recorder';
+import { assembleTape } from '../recorder/assemble';
+
+describe('timestamp query capture ownership', () => {
+  it.each([
+    'render',
+    'compute',
+    'empty-compute',
+  ] as const)('retains a pre-capture QuerySet for %s passes', async (kind) => {
+    const recorded = wrap(rhi);
+    const adapter = (await recorded.requestAdapter()).unwrap();
+    const device = (
+      await adapter.requestDevice({ requiredFeatures: ['timestamp-query'] })
+    ).unwrap();
+    const querySet = device.createQuerySet({ type: 'timestamp', count: 2 }).unwrap();
+    const target = device
+      .createTexture({ size: { width: 4, height: 4 }, format: 'rgba8unorm', usage: 0x10 })
+      .unwrap();
+    const view = device.createTextureView(target, {}).unwrap();
+    try {
+      recorded.arm(1);
+      const encoder = device.createCommandEncoder().unwrap();
+      const timestampWrites = { querySet, beginningOfPassWriteIndex: 0, endOfPassWriteIndex: 1 };
+      if (kind === 'render')
+        encoder
+          .beginRenderPass({
+            colorAttachments: [{ view, loadOp: 'clear', storeOp: 'store' }],
+            timestampWrites,
+          })
+          .end();
+      else if (kind === 'compute') encoder.beginComputePass({ timestampWrites }).end();
+      else encoder.encodeEmptyComputePass({ timestampWrites });
+      device.queue.submit([encoder.finish().unwrap()]).unwrap();
+      await device.queue.onSubmittedWorkDone();
+      recorded.onFrameEnd();
+      const tape = recorded.getTape();
+      if (tape === undefined || !('events' in tape)) throw new Error('Missing captured tape');
+      const pass = tape.events.find(
+        (event) => event.kind === 'beginRenderPass' || event.kind === 'beginComputePass',
+      );
+      expect(pass).toHaveProperty('timestampQuerySetHandleId');
+      if (pass?.kind !== 'beginRenderPass' && pass?.kind !== 'beginComputePass')
+        throw new Error('Missing pass');
+      expect(pass.desc?.timestampWrites).toEqual({
+        beginningOfPassWriteIndex: 0,
+        endOfPassWriteIndex: 1,
+      });
+      const encoded = assembleTape(recorded).unwrap().bytes;
+      const decoded = decodeTape(encoded).unwrap();
+      expect(decoded.bootstrap.some((row) => row.kind === 'query-set')).toBe(true);
+      expect(validateTape(decoded).ok).toBe(true);
+    } finally {
+      device.destroyQuerySet(querySet).unwrap();
+      device.destroyTexture(target).unwrap();
+    }
+  });
+});

package/src/index.ts

@@ -66,6 +66,7 @@ export {
   attachRecorder,
   type CaptureFrameOptions,
   type CreateShaderModuleFn,
+  type CreateShaderModuleImmediateFn,
   type EncodedTape,
   type RecordableBackend,
   type RecorderAttachment,

package/src/protocol/event-semantics.ts

@@ -14,11 +14,14 @@ export const eventKinds = [
   'frameMark',
   'createBuffer',
   'createTexture',
+  'createQuerySet',
   'destroyBuffer',
   'destroyTexture',
+  'destroyQuerySet',
   'createTextureView',
   'createSampler',
   'createBindGroupLayout',
+  'getBindGroupLayout',
   'createBindGroup',
   'createPipelineLayout',
   'createRenderPipeline',
@@ -30,12 +33,15 @@ export const eventKinds = [
   'copyExternalImageToTexture',
   'submit',
   'beginRenderPass',
+  'beginOcclusionQuery',
+  'endOcclusionQuery',
   'beginComputePass',
   'copyBufferToBuffer',
   'copyBufferToTexture',
   'copyTextureToBuffer',
   'copyTextureToTexture',
   'clearBuffer',
+  'resolveQuerySet',
   'pushDebugGroup',
   'popDebugGroup',
   'insertDebugMarker',
@@ -86,6 +92,8 @@ export function resourceKindForEvent(kind: EventKind): ResourceKind | undefined
       return 'buffer';
     case 'createTexture':
       return 'texture';
+    case 'createQuerySet':
+      return 'query-set';
     case 'createTextureView':
       return 'texture-view';
     case 'createSampler':
@@ -97,6 +105,7 @@ export function resourceKindForEvent(kind: EventKind): ResourceKind | undefined
       return 'pipeline';
     case 'createBindGroup':
     case 'createBindGroupLayout':
+    case 'getBindGroupLayout':
     case 'createPipelineLayout':
       return 'binding';
     case 'createCommandEncoder':
@@ -114,7 +123,9 @@ function semanticsFor(kind: EventKind): EventSemantics {
     read: (event) => referencedHandles(event),
     written: (event) => writtenHandles(event),
     destroyed: (event) =>
-      event.kind === 'destroyBuffer' || event.kind === 'destroyTexture'
+      event.kind === 'destroyBuffer' ||
+      event.kind === 'destroyTexture' ||
+      event.kind === 'destroyQuerySet'
         ? stringField(event, 'handleId')
         : [],
   };
@@ -122,7 +133,12 @@ function semanticsFor(kind: EventKind): EventSemantics {
 
 function categoryFor(kind: EventKind): EventCategory {
   if (isWorkEvent(kind)) return 'work';
-  if (kind.startsWith('create') || kind.startsWith('destroy') || kind === 'initialData')
+  if (
+    kind.startsWith('create') ||
+    kind.startsWith('destroy') ||
+    kind === 'initialData' ||
+    kind === 'getBindGroupLayout'
+  )
     return 'resource';
   if (kind.includes('Pass')) return 'pass';
   if (kind.startsWith('copy') || kind === 'clearBuffer' || kind.startsWith('write')) return 'copy';
@@ -153,6 +169,9 @@ function referencedHandles(event: RhiCallEvent): readonly string[] {
     'resourceHandleIds',
     'bindGroupHandleId',
     'pipelineHandleId',
+    'querySetHandleId',
+    'occlusionQuerySetHandleId',
+    'timestampQuerySetHandleId',
     'indexBufferHandleId',
     'vertexBufferHandleId',
   ];

package/src/protocol/types.ts

@@ -11,6 +11,7 @@ export type TapeBlobCompression = 'none' | 'gzip';
 export type ResourceKind =
   | 'buffer'
   | 'texture'
+  | 'query-set'
   | 'texture-view'
   | 'sampler'
   | 'shader-module'

package/src/protocol/validation.ts

@@ -93,6 +93,7 @@ function isResourceKind(value: string): value is ResourceKind {
   return [
     'buffer',
     'texture',
+    'query-set',
     'texture-view',
     'sampler',
     'shader-module',
@@ -112,8 +113,10 @@ function eventResources(event: RhiCallEvent): EventResources {
   switch (event.kind) {
     case 'createBuffer':
     case 'createTexture':
+    case 'createQuerySet':
     case 'createSampler':
     case 'createBindGroupLayout':
+    case 'getBindGroupLayout':
     case 'createBindGroup':
     case 'createPipelineLayout':
     case 'createRenderPipeline':
@@ -123,6 +126,7 @@ function eventResources(event: RhiCallEvent): EventResources {
         created: [event.handleId],
         reads: handleRefs(event, [
           'layoutHandleId',
+          'pipelineHandleId',
           'vertexShaderModuleHandleId',
           'fragmentShaderModuleHandleId',
           'computeShaderModuleHandleId',
@@ -135,6 +139,7 @@ function eventResources(event: RhiCallEvent): EventResources {
       return { created: [event.cmdHandleId], reads: [], destroyed: [] };
     case 'destroyBuffer':
     case 'destroyTexture':
+    case 'destroyQuerySet':
       return { created: [], reads: [event.handleId], destroyed: [event.handleId] };
     case 'writeBuffer':
     case 'writeTexture':
@@ -156,6 +161,37 @@ function eventResources(event: RhiCallEvent): EventResources {
         ]),
         destroyed: [],
       };
+    case 'resolveQuerySet':
+      return {
+        created: [],
+        reads: handleRefs(event, ['cmdHandleId', 'querySetHandleId', 'destinationHandleId']),
+        destroyed: [],
+      };
+    case 'beginRenderPass':
+      return {
+        created: [event.passHandleId],
+        reads: handleRefs(event, [
+          'cmdHandleId',
+          'occlusionQuerySetHandleId',
+          'timestampQuerySetHandleId',
+          'colorAttachmentViewHandleIds',
+          'colorAttachmentResolveTargetHandleIds',
+          'depthStencilViewHandleId',
+        ]),
+        destroyed: [],
+      };
+    case 'beginComputePass':
+      return {
+        created: [event.passHandleId],
+        reads: handleRefs(event, ['cmdHandleId', 'timestampQuerySetHandleId']),
+        destroyed: [],
+      };
+    case 'endRenderPass':
+    case 'endComputePass':
+      return { created: [], reads: [event.passHandleId], destroyed: [event.passHandleId] };
+    case 'beginOcclusionQuery':
+    case 'endOcclusionQuery':
+      return { created: [], reads: handleRefs(event, ['passHandleId']), destroyed: [] };
     default:
       return { created: [], reads: [], destroyed: [] };
   }

package/src/recorder/assemble.ts

@@ -161,7 +161,11 @@ function createdHandleId(event: RhiCallEvent): HandleId | undefined {
   if (event.kind === 'beginRenderPass' || event.kind === 'beginComputePass') {
     return event.passHandleId;
   }
-  if (event.kind.startsWith('create') && 'handleId' in event) return event.handleId;
+  if (
+    (event.kind.startsWith('create') || event.kind === 'getBindGroupLayout') &&
+    'handleId' in event
+  )
+    return event.handleId;
   return undefined;
 }
 
@@ -171,6 +175,8 @@ function resourceKind(event: RhiCallEvent): BootstrapResource['kind'] | undefine
       return 'buffer';
     case 'createTexture':
       return 'texture';
+    case 'createQuerySet':
+      return 'query-set';
     case 'createTextureView':
       return 'texture-view';
     case 'createSampler':
@@ -182,6 +188,7 @@ function resourceKind(event: RhiCallEvent): BootstrapResource['kind'] | undefine
       return 'pipeline';
     case 'createBindGroup':
     case 'createBindGroupLayout':
+    case 'getBindGroupLayout':
     case 'createPipelineLayout':
       return 'binding';
     case 'createCommandEncoder':