@forgeax/engine-rhi-webgpu 0.1.21 → 0.1.23

package/dist/internal/__tests__/timestamp-query.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=timestamp-query.unit.test.d.ts.map

package/dist/internal/__tests__/timestamp-query.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp-query.unit.test.d.ts","sourceRoot":"","sources":["../../../src/internal/__tests__/timestamp-query.unit.test.ts"],"names":[],"mappings":""}

package/dist/internal/r32float-capability.d.ts

@@ -0,0 +1,6 @@
+import { type Result, RhiError, type RhiTextureFormatCapabilityReceipt } from '@forgeax/engine-rhi';
+type RawDevice = GPUDevice;
+/** Execute the complete real-device r32float profile without exposing raw handles. */
+export declare function probeR32FloatCapability(rawDevice: RawDevice, deviceGeneration: number): Promise<Result<RhiTextureFormatCapabilityReceipt, RhiError>>;
+export {};
+//# sourceMappingURL=r32float-capability.d.ts.map

package/dist/internal/r32float-capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r32float-capability.d.ts","sourceRoot":"","sources":["../../src/internal/r32float-capability.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,MAAM,EACX,QAAQ,EACR,KAAK,iCAAiC,EAGvC,MAAM,qBAAqB,CAAC;AAS7B,KAAK,SAAS,GAAG,SAAS,CAAC;AAE3B,sFAAsF;AACtF,wBAAsB,uBAAuB,CAC3C,SAAS,EAAE,SAAS,EACpB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,CAAC,iCAAiC,EAAE,QAAQ,CAAC,CAAC,CA+H9D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-rhi-webgpu",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "private": false,
   "type": "module",
   "license": "Apache-2.0",
@@ -22,8 +22,8 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@forgeax/engine-rhi": "0.1.21",
-    "@forgeax/engine-types": "0.1.21",
+    "@forgeax/engine-rhi": "0.1.23",
+    "@forgeax/engine-types": "0.1.23",
     "@webgpu/types": "^0.1.71"
   },
   "forgeax": {

package/src/__tests__/dawn-real-gpu.dawn.test.ts

@@ -1276,6 +1276,20 @@ describe('w3 dawn-real-gpu timestamp admission path', () => {
     if (!deviceResult.ok) return;
     const device = deviceResult.value;
 
+    const { createShaderModule } = await import('../index');
+    const shaderResult = await createShaderModule(device, {
+      code: '@compute @workgroup_size(1) fn timestamp_probe() {}',
+    });
+    expect(shaderResult.ok).toBe(true);
+    if (!shaderResult.ok) return;
+    const pipelineResult = device.createComputePipeline({
+      label: 'w3-timestamp-compute-pipeline',
+      layout: 'auto',
+      compute: { module: shaderResult.value, entryPoint: 'timestamp_probe' },
+    });
+    expect(pipelineResult.ok).toBe(true);
+    if (!pipelineResult.ok) return;
+
     const querySetResult = device.createQuerySet({ type: 'timestamp', count: 2 });
     expect(querySetResult.ok).toBe(true);
     if (!querySetResult.ok) return;
@@ -1310,6 +1324,8 @@ describe('w3 dawn-real-gpu timestamp admission path', () => {
           endOfPassWriteIndex: 1,
         },
       });
+      pass.setPipeline(pipelineResult.value);
+      pass.dispatchWorkgroups(1);
       pass.end();
     } catch (error) {
       const refusal = error as { code?: string; expected?: string; hint?: string };
@@ -1381,6 +1397,158 @@ describe('w3 dawn-real-gpu timestamp admission path', () => {
     expect(end).toBeGreaterThan(begin);
     mappedResult.value.unmap();
   });
+
+  it('runs render-pass timestampWrites -> resolve -> submit -> readback or records a structured refusal', async () => {
+    const selector = 'standard' as const;
+    const source = 'packages/rhi-webgpu/src/__tests__/dawn-real-gpu.dawn.test.ts';
+    const adapterResult = await rhi.requestAdapter();
+    expect(adapterResult.ok).toBe(true);
+    if (!adapterResult.ok) return;
+
+    if (!adapterResult.value.features.has('timestamp-query')) {
+      reportTimestampEvidence({
+        carrier: 'dawn-node',
+        selector,
+        source,
+        acceptedGpu: 0,
+        refusalCode: 'timestamp-query-unsupported',
+        expected: "adapter.features.has('timestamp-query')",
+        hint: 'request a real Dawn device with the timestamp-query feature enabled',
+      });
+      return;
+    }
+
+    const deviceResult = await adapterResult.value.requestDevice({
+      requiredFeatures: ['timestamp-query'],
+    });
+    expect(deviceResult.ok).toBe(true);
+    if (!deviceResult.ok) return;
+    const device = deviceResult.value;
+
+    const querySetResult = device.createQuerySet({ type: 'timestamp', count: 2 });
+    expect(querySetResult.ok).toBe(true);
+    if (!querySetResult.ok) return;
+
+    const targetResult = device.createTexture({
+      label: 'w3-timestamp-raster-target',
+      size: { width: 1, height: 1, depthOrArrayLayers: 1 },
+      format: 'rgba8unorm',
+      usage: GPUTextureUsage.RENDER_ATTACHMENT,
+    });
+    expect(targetResult.ok).toBe(true);
+    if (!targetResult.ok) return;
+    const viewResult = device.createTextureView(targetResult.value, {});
+    expect(viewResult.ok).toBe(true);
+    if (!viewResult.ok) return;
+
+    const resolveResult = device.createBuffer({
+      label: 'w3-timestamp-raster-resolve',
+      size: 256,
+      usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,
+    });
+    expect(resolveResult.ok).toBe(true);
+    if (!resolveResult.ok) return;
+
+    const readbackResult = device.createBuffer({
+      label: 'w3-timestamp-raster-readback',
+      size: 256,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
+    expect(readbackResult.ok).toBe(true);
+    if (!readbackResult.ok) return;
+
+    const encoderResult = device.createCommandEncoder({ label: 'w3-timestamp-raster-encoder' });
+    expect(encoderResult.ok).toBe(true);
+    if (!encoderResult.ok) return;
+    const encoder = encoderResult.value;
+
+    try {
+      const pass = encoder.beginRenderPass({
+        label: 'timestamp-raster',
+        colorAttachments: [
+          {
+            view: viewResult.value,
+            loadOp: 'clear',
+            storeOp: 'store',
+          },
+        ],
+        timestampWrites: {
+          querySet: querySetResult.value,
+          beginningOfPassWriteIndex: 0,
+          endOfPassWriteIndex: 1,
+        },
+      });
+      pass.end();
+    } catch (error) {
+      const refusal = error as { code?: string; expected?: string; hint?: string };
+      reportTimestampEvidence({
+        carrier: 'dawn-node',
+        selector,
+        source,
+        acceptedGpu: 0,
+        refusalCode: 'timestamp-write-unavailable',
+        expected:
+          refusal.expected ??
+          'GPURenderPassDescriptor.timestampWrites to be accepted by the real render pass',
+        hint: refusal.hint ?? String(error),
+      });
+      expect(refusal.code).toBe('webgpu-runtime-error');
+      return;
+    }
+
+    const resolveQueriesResult = encoder.resolveQuerySet(
+      querySetResult.value,
+      0,
+      2,
+      resolveResult.value,
+      0,
+    );
+    expect(resolveQueriesResult.ok).toBe(true);
+    if (!resolveQueriesResult.ok) return;
+    encoder.copyBufferToBuffer(resolveResult.value, 0, readbackResult.value, 0, 16);
+
+    const finishResult = encoder.finish();
+    expect(finishResult.ok).toBe(true);
+    if (!finishResult.ok) return;
+    const submitResult = device.queue.submit([finishResult.value]);
+    expect(submitResult.ok).toBe(true);
+    if (!submitResult.ok) return;
+    await device.queue.onSubmittedWorkDone();
+
+    const mappedResult = await readbackResult.value.mapAsync(GPUMapMode.READ);
+    expect(mappedResult.ok).toBe(true);
+    if (!mappedResult.ok) return;
+    const rangeResult = mappedResult.value.getMappedRange(0, 16);
+    expect(rangeResult.ok).toBe(true);
+    if (!rangeResult.ok) return;
+    const ticks = new BigUint64Array(rangeResult.value);
+    const begin = ticks[0];
+    const end = ticks[1];
+    if (begin === undefined || end === undefined || end <= begin) {
+      reportTimestampEvidence({
+        carrier: 'dawn-node',
+        selector,
+        source,
+        acceptedGpu: 0,
+        refusalCode: 'timestamp-write-unavailable',
+        expected: 'end > begin',
+        hint: 'timestamp readback did not produce a positive GPU interval for a render pass',
+        observed: { begin: begin?.toString() ?? null, end: end?.toString() ?? null },
+      });
+      mappedResult.value.unmap();
+      return;
+    }
+
+    reportTimestampEvidence({
+      carrier: 'dawn-node',
+      selector,
+      source,
+      acceptedGpu: 1,
+      ticks: { begin: begin.toString(), end: end.toString() },
+    });
+    expect(end).toBeGreaterThan(begin);
+    mappedResult.value.unmap();
+  });
 });
 
 describe('w36 (M5) - dawn-real-gpu RhiQueue.writeTexture real-path', () => {

package/src/__tests__/r32float-capability-generation.integration.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { rhi } from '../index';
+
+const hasGpu = globalThis.navigator?.gpu !== undefined;
+
+describe.skipIf(!hasGpu)('WebGPU r32float probe generation budget', () => {
+  it('reuses one receipt within a generation and probes a replacement', async () => {
+    const adapterResult = await rhi.requestAdapter();
+    expect(adapterResult.ok).toBe(true);
+    if (!adapterResult.ok) return;
+    const firstDeviceResult = await adapterResult.value.requestDevice();
+    expect(firstDeviceResult.ok).toBe(true);
+    if (!firstDeviceResult.ok) return;
+
+    const first = firstDeviceResult.value;
+    const firstProbe = first.probeTextureFormatCapability();
+    expect(first.probeTextureFormatCapability()).toBe(firstProbe);
+    const firstReceipt = await firstProbe;
+    expect(firstReceipt.ok).toBe(true);
+    if (!firstReceipt.ok) return;
+    expect(firstReceipt.value.probeExecutions).toBe(1);
+
+    const replacementAdapterResult = await rhi.requestAdapter();
+    expect(replacementAdapterResult.ok).toBe(true);
+    if (!replacementAdapterResult.ok) return;
+    const replacementResult = await replacementAdapterResult.value.requestDevice();
+    expect(replacementResult.ok).toBe(true);
+    if (!replacementResult.ok) return;
+    const replacementReceipt = await replacementResult.value.probeTextureFormatCapability();
+    expect(replacementReceipt.ok).toBe(true);
+    if (!replacementReceipt.ok) return;
+    expect(replacementReceipt.value.deviceGeneration).not.toBe(firstReceipt.value.deviceGeneration);
+    expect(replacementReceipt.value.probeExecutions).toBe(1);
+  });
+});

package/src/__tests__/r32float-format-capability.browser.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { rhi } from '../index';
+
+describe('WebGPU r32float format profile', () => {
+  it('executes every profile stage and returns readback evidence', async () => {
+    const adapterResult = await rhi.requestAdapter();
+    expect(adapterResult.ok).toBe(true);
+    if (!adapterResult.ok) return;
+    const deviceResult = await adapterResult.value.requestDevice();
+    expect(deviceResult.ok).toBe(true);
+    if (!deviceResult.ok) return;
+
+    const receiptResult = await deviceResult.value.probeTextureFormatCapability();
+    expect(receiptResult.ok).toBe(true);
+    if (!receiptResult.ok) return;
+    expect(receiptResult.value.profile).toBe('r32float-mip-sampled-storage');
+    expect(receiptResult.value.verdict).toBe('admitted');
+    expect(receiptResult.value.evidence).toBe('real');
+    expect(receiptResult.value.stages).toHaveLength(8);
+    expect(receiptResult.value.readback?.byteLength).toBeGreaterThan(0);
+  });
+});

package/src/__tests__/r32float-format-capability.dawn.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { rhi } from '../index';
+
+describe('Dawn r32float format profile', () => {
+  it('executes the independent full chain through completion and readback', async () => {
+    const adapterResult = await rhi.requestAdapter();
+    expect(adapterResult.ok).toBe(true);
+    if (!adapterResult.ok) return;
+    const deviceResult = await adapterResult.value.requestDevice();
+    expect(deviceResult.ok).toBe(true);
+    if (!deviceResult.ok) return;
+
+    const receiptResult = await deviceResult.value.probeTextureFormatCapability();
+    expect(receiptResult.ok).toBe(true);
+    if (!receiptResult.ok) return;
+    expect(receiptResult.value.profile).toBe('r32float-mip-sampled-storage');
+    expect(receiptResult.value.verdict).toBe('admitted');
+    expect(receiptResult.value.evidence).toBe('real');
+    expect(receiptResult.value.stages.map((stage) => stage.stage)).toEqual([
+      'texture-create',
+      'mip-view',
+      'sampled-storage-bind-group',
+      'pipeline-bind',
+      'finish',
+      'submit',
+      'completion',
+      'readback',
+    ]);
+    expect(receiptResult.value.readback?.values.length).toBeGreaterThan(0);
+  });
+});

package/src/__tests__/rhi-webgpu.unit.test.ts

@@ -452,6 +452,70 @@ import { createMockGpu, type MockCapture, makeShaderError } from './__mocks__/gp
       expect(device.destroyBuffer(readbackResult.value).ok).toBe(true);
     });
   });
+  // ---------------------------------------------------------------------------
+  // w38 (M5) - pass descriptor timestampWrites forwarding.
+  // ---------------------------------------------------------------------------
+  // Current Dawn rejects the obsolete command-encoder writeTimestamp method.
+  // Timestamp ownership therefore enters through the real render/compute pass
+  // descriptor, where the shim maps the opaque QuerySet to its raw handle.
+  describe('w38 (M5) - pass descriptor timestampWrites', () => {
+    it('maps an opaque QuerySet in compute-pass timestampWrites to the raw descriptor', async () => {
+      const gpu = createMockGpu();
+      const adapter = await gpu.requestAdapter();
+      if (adapter === null) throw new Error('mock adapter should exist');
+      const raw = await adapter.requestDevice();
+      (raw.features as unknown as Set<GPUFeatureName>).add('timestamp-query');
+      let rawQuerySet: unknown;
+      const originalCreateQuerySet = raw.createQuerySet.bind(raw);
+      raw.createQuerySet = (descriptor) => {
+        const result = originalCreateQuerySet(descriptor);
+        rawQuerySet = result;
+        return result;
+      };
+      let captured: GPUComputePassDescriptor | undefined;
+      const originalCreateCommandEncoder = raw.createCommandEncoder.bind(raw);
+      raw.createCommandEncoder = (descriptor) => {
+        const encoder = originalCreateCommandEncoder(descriptor) as unknown as Record<
+          string,
+          unknown
+        >;
+        const originalBegin = encoder.beginComputePass as (
+          passDescriptor?: GPUComputePassDescriptor,
+        ) => unknown;
+        encoder.beginComputePass = (passDescriptor?: GPUComputePassDescriptor) => {
+          captured = passDescriptor;
+          return originalBegin.call(encoder, passDescriptor);
+        };
+        return encoder as unknown as ReturnType<typeof raw.createCommandEncoder>;
+      };
+      const { device } = makeRhiDevice(raw as unknown as GPUDevice);
+      const querySet = device.createQuerySet({ type: 'timestamp', count: 2 });
+      expect(querySet.ok).toBe(true);
+      if (!querySet.ok) return;
+      const encoder = device.createCommandEncoder();
+      expect(encoder.ok).toBe(true);
+      if (!encoder.ok) return;
+      const pass = encoder.value.beginComputePass({
+        label: 'hdrp-cluster-membership',
+        timestampWrites: {
+          querySet: querySet.value,
+          beginningOfPassWriteIndex: 0,
+          endOfPassWriteIndex: 1,
+        },
+      });
+      pass.end();
+      expect(captured).toMatchObject({
+        label: 'hdrp-cluster-membership',
+        timestampWrites: {
+          querySet: querySet.value,
+          beginningOfPassWriteIndex: 0,
+          endOfPassWriteIndex: 1,
+        },
+      });
+      expect(rawQuerySet).toBeDefined();
+      expect(captured?.timestampWrites?.querySet).toBe(rawQuerySet);
+    });
+  });
 }
 
 {

package/src/device.ts

@@ -78,6 +78,7 @@ import {
   queueWriteBufferOutOfBounds,
   renderPassNotEnded,
 } from './errors';
+import { probeR32FloatCapability } from './internal/r32float-capability';
 import { resolveTimestampQueries } from './internal/timestamp-query';
 
 /**
@@ -170,6 +171,12 @@ const QUERY_SET_COUNT_LIMIT = 4096;
  * forward recording calls to the underlying GPUCommandEncoder.
  */
 const RAW_DEVICE_MAP: WeakMap<RhiDevice, GPUDevice> = new WeakMap();
+const RAW_DEVICE_GENERATION_MAP: WeakMap<GPUDevice, number> = new WeakMap();
+const R32FLOAT_PROBE_CACHE: WeakMap<
+  RhiDevice,
+  Promise<Result<import('@forgeax/engine-rhi').RhiTextureFormatCapabilityReceipt, RhiError>>
+> = new WeakMap();
+let NEXT_DEVICE_GENERATION = 1;
 const BUFFER_RAW_MAP: WeakMap<Buffer, GPUBuffer> = new WeakMap();
 const TEXTURE_VIEW_RAW_MAP: WeakMap<TextureView, GPUTextureView> = new WeakMap();
 const ENCODER_STATE: WeakMap<RhiCommandEncoder, EncoderState> = new WeakMap();
@@ -1496,11 +1503,27 @@ export function makeRhiDevice(rawDevice: GPUDevice): {
   const limits = rawDevice.limits as RhiLimits;
 
   const queue: RhiQueue = makeQueue(rawDevice.queue);
+  const deviceGeneration =
+    RAW_DEVICE_GENERATION_MAP.get(rawDevice) ??
+    (() => {
+      const generation = NEXT_DEVICE_GENERATION++;
+      RAW_DEVICE_GENERATION_MAP.set(rawDevice, generation);
+      return generation;
+    })();
 
   const device: RhiDevice = {
     caps,
     features,
     limits,
+    probeTextureFormatCapability(): Promise<
+      Result<import('@forgeax/engine-rhi').RhiTextureFormatCapabilityReceipt, RhiError>
+    > {
+      const cached = R32FLOAT_PROBE_CACHE.get(device);
+      if (cached !== undefined) return cached;
+      const probe = probeR32FloatCapability(rawDevice, deviceGeneration);
+      R32FLOAT_PROBE_CACHE.set(device, probe);
+      return probe;
+    },
     queue,
     lost: rawDevice.lost as unknown as Promise<{
       readonly reason: 'destroyed' | 'unknown';

package/src/internal/__tests__/timestamp-query.unit.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest';
+import { createMockGpu } from '../../__tests__/__mocks__/gpu-device';
+import { makeRhiDevice } from '../../device';
+
+describe('timestamp query pass descriptor forwarding', () => {
+  it('maps an opaque QuerySet in a compute-pass timestampWrites descriptor', async () => {
+    const gpu = createMockGpu();
+    const adapter = await gpu.requestAdapter();
+    if (adapter === null) throw new Error('mock adapter should exist');
+    const raw = await adapter.requestDevice();
+    (raw.features as unknown as Set<GPUFeatureName>).add('timestamp-query');
+    let rawQuerySet: unknown;
+    const originalCreateQuerySet = raw.createQuerySet.bind(raw);
+    raw.createQuerySet = (descriptor) => {
+      const result = originalCreateQuerySet(descriptor);
+      rawQuerySet = result;
+      return result;
+    };
+    let captured: GPUComputePassDescriptor | undefined;
+    const originalCreateCommandEncoder = raw.createCommandEncoder.bind(raw);
+    raw.createCommandEncoder = (descriptor) => {
+      const encoder = originalCreateCommandEncoder(descriptor) as unknown as Record<
+        string,
+        unknown
+      >;
+      const originalBegin = encoder.beginComputePass as (
+        passDescriptor?: GPUComputePassDescriptor,
+      ) => unknown;
+      encoder.beginComputePass = (passDescriptor?: GPUComputePassDescriptor) => {
+        captured = passDescriptor;
+        return originalBegin.call(encoder, passDescriptor);
+      };
+      return encoder as unknown as ReturnType<typeof raw.createCommandEncoder>;
+    };
+    const { device } = makeRhiDevice(raw as unknown as GPUDevice);
+    const querySet = device.createQuerySet({ type: 'timestamp', count: 2 });
+    expect(querySet.ok).toBe(true);
+    if (!querySet.ok) return;
+    const encoder = device.createCommandEncoder();
+    expect(encoder.ok).toBe(true);
+    if (!encoder.ok) return;
+    const pass = encoder.value.beginComputePass({
+      label: 'timestamp-pass',
+      timestampWrites: {
+        querySet: querySet.value,
+        beginningOfPassWriteIndex: 0,
+        endOfPassWriteIndex: 1,
+      },
+    });
+    pass.end();
+    expect(captured).toMatchObject({
+      label: 'timestamp-pass',
+      timestampWrites: {
+        beginningOfPassWriteIndex: 0,
+        endOfPassWriteIndex: 1,
+      },
+    });
+    expect(rawQuerySet).toBeDefined();
+    expect(captured?.timestampWrites?.querySet).toBe(rawQuerySet);
+  });
+
+  it('maps an opaque QuerySet in a render-pass timestampWrites descriptor', async () => {
+    const gpu = createMockGpu();
+    const adapter = await gpu.requestAdapter();
+    if (adapter === null) throw new Error('mock adapter should exist');
+    const raw = await adapter.requestDevice();
+    (raw.features as unknown as Set<GPUFeatureName>).add('timestamp-query');
+    let captured: GPURenderPassDescriptor | undefined;
+    const originalCreateCommandEncoder = raw.createCommandEncoder.bind(raw);
+    raw.createCommandEncoder = (descriptor) => {
+      const encoder = originalCreateCommandEncoder(descriptor) as unknown as Record<
+        string,
+        unknown
+      >;
+      const originalBegin = encoder.beginRenderPass as (
+        passDescriptor: GPURenderPassDescriptor,
+      ) => unknown;
+      encoder.beginRenderPass = (passDescriptor: GPURenderPassDescriptor) => {
+        captured = passDescriptor;
+        return originalBegin.call(encoder, passDescriptor);
+      };
+      return encoder as unknown as ReturnType<typeof raw.createCommandEncoder>;
+    };
+    const { device } = makeRhiDevice(raw as unknown as GPUDevice);
+    const querySet = device.createQuerySet({ type: 'timestamp', count: 2 });
+    expect(querySet.ok).toBe(true);
+    if (!querySet.ok) return;
+    const texture = device.createTexture({
+      size: [1, 1, 1],
+      format: 'rgba8unorm',
+      usage: 0x10,
+    });
+    expect(texture.ok).toBe(true);
+    if (!texture.ok) return;
+    const view = device.createTextureView(texture.value, {});
+    expect(view.ok).toBe(true);
+    if (!view.ok) return;
+    const encoder = device.createCommandEncoder();
+    expect(encoder.ok).toBe(true);
+    if (!encoder.ok) return;
+    const pass = encoder.value.beginRenderPass({
+      label: 'timestamp-raster',
+      colorAttachments: [{ view: view.value, loadOp: 'clear', storeOp: 'store' }],
+      timestampWrites: {
+        querySet: querySet.value,
+        beginningOfPassWriteIndex: 0,
+        endOfPassWriteIndex: 1,
+      },
+    });
+    pass.end();
+    expect(captured).toMatchObject({
+      label: 'timestamp-raster',
+      timestampWrites: {
+        beginningOfPassWriteIndex: 0,
+        endOfPassWriteIndex: 1,
+      },
+    });
+    expect(captured?.timestampWrites?.querySet).toBeDefined();
+  });
+});