@forgeax/engine-rhi-webgpu 0.1.20 → 0.1.23

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/dist/internal/timestamp-query.d.ts

@@ -7,9 +7,4 @@ export declare function resolveTimestampQueries(args: {
     rawDestination: GPUBuffer;
     destinationOffset: number;
 }): Result<void, RhiError>;
-export declare function writeTimestamp(args: {
-    rawEncoder: GPUCommandEncoder;
-    rawQuerySet: GPUQuerySet;
-    queryIndex: number;
-}): void;
 //# sourceMappingURL=timestamp-query.d.ts.map

package/dist/internal/timestamp-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timestamp-query.d.ts","sourceRoot":"","sources":["../../src/internal/timestamp-query.ts"],"names":[],"mappings":"AAEA,OAAO,EAAW,KAAK,MAAM,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAErE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,UAAU,EAAE,iBAAiB,CAAC;IAC9B,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,SAAS,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,GAAG,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAoBzB;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACnC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,IAAI,CAqBP"}
+{"version":3,"file":"timestamp-query.d.ts","sourceRoot":"","sources":["../../src/internal/timestamp-query.ts"],"names":[],"mappings":"AAEA,OAAO,EAAW,KAAK,MAAM,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAErE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,UAAU,EAAE,iBAAiB,CAAC;IAC9B,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,SAAS,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,GAAG,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAoBzB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-rhi-webgpu",
-  "version": "0.1.20",
+  "version": "0.1.23",
   "private": false,
   "type": "module",
   "license": "Apache-2.0",
@@ -22,8 +22,8 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@forgeax/engine-rhi": "0.1.20",
-    "@forgeax/engine-types": "0.1.20",
+    "@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

@@ -1219,9 +1219,8 @@ describe('w36 (M5) - dawn-real-gpu RhiQueue.onSubmittedWorkDone returns Promise<
 // ---------------------------------------------------------------------------
 //
 // research §2.4 + dawn ComputePassDescriptor timestampWrites reference:
-// the real compute pass owns the beginning/end timestamp writes. The legacy
-// command-encoder writeTimestamp path is not used because current Dawn rejects
-// it even when timestamp-query is advertised.
+// the real compute pass owns the beginning/end timestamp writes. Command-
+// encoder timestamp markers are intentionally absent from the RHI surface.
 describe('w38 (M5 / K-3) - dawn-real-gpu compute-pass timestampWrites gate', () => {
   it('reports timestamp-query refusal without treating a capability-disabled path as success', async () => {
     const device = await requestRhiDevice();
@@ -1277,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;
@@ -1311,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 };
@@ -1382,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

@@ -219,6 +219,74 @@ import { createMockGpu, type MockCapture, makeShaderError } from './__mocks__/gp
     });
   });
 
+  describe('encodeEmptyComputePass', () => {
+    it('forwards one mirrored descriptor to one raw pass and ends that pass once', 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');
+      const rawDescriptors: GPUComputePassDescriptor[] = [];
+      let beginCalls = 0;
+      let endCalls = 0;
+      const originalCreateCommandEncoder = raw.createCommandEncoder.bind(raw);
+      raw.createCommandEncoder = (descriptor) => {
+        const encoder = originalCreateCommandEncoder(descriptor);
+        const originalBeginComputePass = encoder.beginComputePass.bind(encoder);
+        encoder.beginComputePass = (passDescriptor) => {
+          beginCalls += 1;
+          if (passDescriptor !== undefined) rawDescriptors.push(passDescriptor);
+          const pass = originalBeginComputePass(passDescriptor);
+          const originalEnd = pass.end.bind(pass);
+          pass.end = () => {
+            endCalls += 1;
+            originalEnd();
+          };
+          return pass;
+        };
+        return encoder;
+      };
+
+      const device = makeRhiDevice(raw as unknown as GPUDevice).device;
+      const querySetResult = device.createQuerySet({ type: 'timestamp', count: 2 });
+      if (!querySetResult.ok) throw new Error('mock createQuerySet failed');
+      const descriptor = {
+        timestampWrites: {
+          querySet: querySetResult.value,
+          beginningOfPassWriteIndex: 0,
+        },
+      };
+      const encoderResult = device.createCommandEncoder();
+      if (!encoderResult.ok) throw new Error('mock createCommandEncoder failed');
+
+      encoderResult.value.encodeEmptyComputePass(descriptor);
+
+      expect(beginCalls).toBe(1);
+      expect(endCalls).toBe(1);
+      expect(rawDescriptors).toHaveLength(1);
+      expect(rawDescriptors[0]?.timestampWrites?.querySet).toBe(querySetResult.value);
+      expect(rawDescriptors[0]?.timestampWrites?.beginningOfPassWriteIndex).toBe(0);
+    });
+
+    it('keeps the finished-encoder failure channel', async () => {
+      const gpu = createMockGpu();
+      const r = await requestDevice({ gpu });
+      if (!r.ok) throw new Error('mock requestDevice should not fail');
+      const encoderResult = r.value.createCommandEncoder();
+      if (!encoderResult.ok) throw new Error('mock createCommandEncoder failed');
+      expect(encoderResult.value.finish().ok).toBe(true);
+
+      expect(() =>
+        encoderResult.value.encodeEmptyComputePass({
+          timestampWrites: {
+            querySet: {} as never,
+            endOfPassWriteIndex: 1,
+          },
+        }),
+      ).toThrowError(expect.objectContaining({ code: 'command-encoder-finished' }));
+    });
+  });
+
   // w24 - resolveQuerySet placeholder retirement red phase. Asserts:
   //   (a) destinationOffset % 256 != 0 -> webgpu-runtime-error with .expected
   //       literal 'destinationOffset % 256 == 0 (spec normative)'.
@@ -384,42 +452,13 @@ import { createMockGpu, type MockCapture, makeShaderError } from './__mocks__/gp
       expect(device.destroyBuffer(readbackResult.value).ok).toBe(true);
     });
   });
-
   // ---------------------------------------------------------------------------
-  // w38 (M5 / K-3) - RhiCommandEncoder.writeTimestamp gating + happy path.
+  // w38 (M5) - pass descriptor timestampWrites forwarding.
   // ---------------------------------------------------------------------------
-  //
-  // research §2.4: dawn TimestampOnCommandEncoder calls
-  // encoder.WriteTimestamp(querySet, queryIndex) directly on the command
-  // encoder; the entry is gated on the 'timestamp-query' device feature.
-  // The forgeax form is RhiCommandEncoder.writeTimestamp(querySet, queryIndex)
-  // with `void` return (spec literal alignment); when caps.timestampQuery is
-  // false the shim fans out 'feature-not-enabled' through the engine onError
-  // channel (no Result wrapper because the spec method returns void).
-
-  describe('w38 (M5 / K-3) - RhiCommandEncoder.writeTimestamp', () => {
-    it('writeTimestamp(querySet, queryIndex) is callable on a CommandEncoder when caps.timestampQuery is true', async () => {
-      const gpu = createMockGpu();
-      const r = await requestDevice({ gpu });
-      if (!r.ok) throw new Error('mock requestDevice should not fail');
-      const device = r.value as unknown as {
-        caps: { timestampQuery: boolean };
-        createQuerySet: (desc: { type: string; count: number; label?: string }) => {
-          ok: boolean;
-          value: unknown;
-        };
-        createCommandEncoder: (desc?: unknown) => {
-          ok: boolean;
-          value: { writeTimestamp?: (qs: unknown, idx: number) => void };
-        };
-      };
-      // Mock device defaults to timestampQuery=false; the gate test below
-      // covers that path. Here we assert the surface exists at the very least.
-      const encResult = device.createCommandEncoder({ label: 'w38-encoder' });
-      expect(encResult.ok).toBe(true);
-      expect(typeof encResult.value.writeTimestamp).toBe('function');
-    });
-
+  // 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();
@@ -476,73 +515,6 @@ import { createMockGpu, type MockCapture, makeShaderError } from './__mocks__/gp
       expect(rawQuerySet).toBeDefined();
       expect(captured?.timestampWrites?.querySet).toBe(rawQuerySet);
     });
-
-    async function timestampEncoder(
-      writeTimestamp: ((querySet: unknown, queryIndex: number) => void) | undefined,
-    ) {
-      const gpu = createMockGpu();
-      const adapter = await gpu.requestAdapter();
-      if (adapter === null) throw new Error('mock adapter should exist');
-      const raw = await adapter.requestDevice();
-      const features = raw.features as unknown as Set<GPUFeatureName>;
-      features.add('timestamp-query');
-      const originalCreateCommandEncoder = raw.createCommandEncoder.bind(raw);
-      raw.createCommandEncoder = (descriptor) => {
-        const encoder = originalCreateCommandEncoder(descriptor) as unknown as Record<
-          string,
-          unknown
-        >;
-        if (writeTimestamp !== undefined) encoder.writeTimestamp = writeTimestamp;
-        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 });
-      if (!querySet.ok) throw new Error('timestamp query set should be created');
-      const encoder = device.createCommandEncoder();
-      if (!encoder.ok) throw new Error('command encoder should be created');
-      return { encoder: encoder.value, querySet: querySet.value };
-    }
-
-    it('forwards a callable raw writeTimestamp exactly once with the raw query set and index', async () => {
-      const calls: Array<{ querySet: unknown; queryIndex: number }> = [];
-      const { encoder, querySet } = await timestampEncoder((rawQuerySet, queryIndex) => {
-        calls.push({ querySet: rawQuerySet, queryIndex });
-      });
-      encoder.writeTimestamp(querySet, 1);
-      expect(calls).toHaveLength(1);
-      expect(calls[0]?.queryIndex).toBe(1);
-      expect(calls[0]?.querySet).toBe(querySet);
-    });
-
-    it('throws structured webgpu-runtime-error when a timestamp-capable raw encoder omits writeTimestamp', async () => {
-      const { encoder, querySet } = await timestampEncoder(undefined);
-      expect(() => encoder.writeTimestamp(querySet, 0)).toThrow(RhiError);
-      try {
-        encoder.writeTimestamp(querySet, 0);
-      } catch (error) {
-        expect(error).toMatchObject({
-          code: 'webgpu-runtime-error',
-          expected: 'underlying GPUCommandEncoder.writeTimestamp to be callable',
-        });
-        expect((error as RhiError).hint).toContain('timestamp-query');
-      }
-    });
-
-    it('throws structured webgpu-runtime-error when the raw timestamp write throws', async () => {
-      const { encoder, querySet } = await timestampEncoder(() => {
-        throw new Error('raw timestamp failure');
-      });
-      expect(() => encoder.writeTimestamp(querySet, 0)).toThrow(RhiError);
-      try {
-        encoder.writeTimestamp(querySet, 0);
-      } catch (error) {
-        expect(error).toMatchObject({
-          code: 'webgpu-runtime-error',
-          expected: 'underlying GPUCommandEncoder.writeTimestamp to succeed',
-        });
-        expect((error as RhiError).hint).toContain('raw timestamp failure');
-      }
-    });
   });
 }