@forgeax/engine-rhi-webgpu 0.1.20 → 0.1.23

package/src/device.ts

@@ -14,7 +14,8 @@
 //   exposes the spec Promise without a second cache.
 //
 // w3 / w5 / w6 (feat-20260508-rhi-surface-completion, co-commit):
-// - createCommandEncoder + 12 RhiCommandEncoder methods + 3 mixin (w3)
+// - createCommandEncoder + 12 RhiCommandEncoder spec methods plus the
+//   ForgeaX encodeEmptyComputePass compound operation + 3 mixin (w3)
 // - 17 RhiRenderPassEncoder spec stable methods + 1 setBindGroup overload +
 //   3 placeholders (executeBundles / beginOcclusionQuery / endOcclusionQuery) (w5)
 // - Queue.submit / writeBuffer real implementation + bounds validation (w6)
@@ -33,6 +34,7 @@ import type {
   BindGroupLayout,
   BindGroupLayoutDescriptor,
   Buffer,
+  BufferCopyDestination,
   BufferDescriptor,
   CanvasConfiguration,
   CommandBuffer,
@@ -63,6 +65,7 @@ import type {
   Sampler,
   SamplerDescriptor,
   Texture,
+  TextureCopySource,
   TextureDescriptor,
   TextureView,
   TextureViewDescriptor,
@@ -75,7 +78,8 @@ import {
   queueWriteBufferOutOfBounds,
   renderPassNotEnded,
 } from './errors';
-import { resolveTimestampQueries, writeTimestamp } from './internal/timestamp-query';
+import { probeR32FloatCapability } from './internal/r32float-capability';
+import { resolveTimestampQueries } from './internal/timestamp-query';
 
 /**
  * Mirror forgeax `?: T | undefined` descriptor onto the spec GPUXxxDescriptor
@@ -167,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();
@@ -812,11 +822,7 @@ function mirrorRenderPipelineDescriptor(
  *   - render-pass-not-ended is detected by tracking activePass; finish()
  *     while a pass has not been end()-ed returns the structured error.
  */
-function makeCommandEncoder(
-  rawEncoder: GPUCommandEncoder,
-  caps: { readonly timestampQuery: boolean },
-  fireFeatureNotEnabled: (featureName: string, hint: string) => void,
-): RhiCommandEncoder {
+function makeCommandEncoder(rawEncoder: GPUCommandEncoder): RhiCommandEncoder {
   function mirrorComputePassDescriptor(
     desc: ComputePassDescriptor | undefined,
   ): GPUComputePassDescriptor | undefined {
@@ -890,6 +896,12 @@ function makeCommandEncoder(
       };
       return pass;
     },
+    encodeEmptyComputePass(desc: ComputePassDescriptor): void {
+      const state = ENCODER_STATE.get(enc);
+      throwIfFinished(state);
+      const rawPass = rawEncoder.beginComputePass(mirrorComputePassDescriptor(desc));
+      rawPass.end();
+    },
     copyBufferToBuffer(
       source: Buffer,
       arg2: number | Buffer,
@@ -933,19 +945,27 @@ function makeCommandEncoder(
       rawEncoder.copyBufferToTexture(rawSrc, destination, copySize);
     },
     copyTextureToBuffer(
-      source: GPUTexelCopyTextureInfo,
-      destination: GPUTexelCopyBufferInfo,
+      source: GPUTexelCopyTextureInfo | TextureCopySource,
+      destination: GPUTexelCopyBufferInfo | BufferCopyDestination,
       copySize: GPUExtent3DStrict,
     ): void {
       const state = ENCODER_STATE.get(enc);
       throwIfFinished(state);
-      const rawDst = {
-        ...destination,
+      const rawSource: GPUTexelCopyTextureInfo = {
+        texture: source.texture as unknown as GPUTexture,
+      };
+      if (source.mipLevel !== undefined) rawSource.mipLevel = source.mipLevel;
+      if (source.origin !== undefined) rawSource.origin = source.origin;
+      if (source.aspect !== undefined) rawSource.aspect = source.aspect;
+      const rawDst: GPUTexelCopyBufferInfo = {
         buffer:
           BUFFER_RAW_MAP.get(destination.buffer as unknown as Buffer) ??
           (destination.buffer as unknown as GPUBuffer),
       };
-      rawEncoder.copyTextureToBuffer(source, rawDst, copySize);
+      if (destination.offset !== undefined) rawDst.offset = destination.offset;
+      if (destination.bytesPerRow !== undefined) rawDst.bytesPerRow = destination.bytesPerRow;
+      if (destination.rowsPerImage !== undefined) rawDst.rowsPerImage = destination.rowsPerImage;
+      rawEncoder.copyTextureToBuffer(rawSource, rawDst, copySize);
     },
     copyTextureToTexture(
       source: GPUTexelCopyTextureInfo,
@@ -1045,25 +1065,6 @@ function makeCommandEncoder(
     insertDebugMarker(markerLabel: string): void {
       rawEncoder.insertDebugMarker(markerLabel);
     },
-    writeTimestamp(querySet: QuerySet, queryIndex: number): void {
-      // M5 / K-3 (research §2.4): timestamp-query feature gate. spec
-      // writeTimestamp returns void; the forgeax form keeps the void shape
-      // and fans out 'feature-not-enabled' through the engine onError
-      // channel rather than wrapping in Result. When the capability is true,
-      // a missing or throwing raw write is a structured runtime failure so a
-      // Render capture cannot publish a fabricated interval.
-      const state = ENCODER_STATE.get(enc);
-      throwIfFinished(state);
-      if (caps.timestampQuery !== true) {
-        fireFeatureNotEnabled(
-          'timestamp-query',
-          'check device.caps.timestampQuery before calling writeTimestamp',
-        );
-        return;
-      }
-      const rawQs = QUERY_SET_RAW_MAP.get(querySet) ?? (querySet as unknown as GPUQuerySet);
-      writeTimestamp({ rawEncoder, rawQuerySet: rawQs, queryIndex });
-    },
     finish(): Result<CommandBuffer, RhiError> {
       const state = ENCODER_STATE.get(enc);
       if (state === undefined) {
@@ -1502,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';
@@ -1915,29 +1932,7 @@ export function makeRhiDevice(rawDevice: GPUDevice): {
           : rawDevice.createCommandEncoder(
               mirror(desc, ENC_KEYS) as unknown as GPUCommandEncoderDescriptor,
             );
-      // M5 / w39: pass caps.timestampQuery + an onError-style fan-out so
-      // writeTimestamp can fire 'feature-not-enabled' through the engine
-      // channel when caps.timestampQuery is false (K-3: spec writeTimestamp
-      // returns void; the forgeax form keeps that shape).
-      //
-      // Round 3 fix-up F-P3-3: the forgeax RhiDevice
-      // does not expose `onError` directly (charter proposition 5: keep
-      // RHI math-free + listener-free), so the shim writes a structured
-      // diagnostic to `console.error` matching the RhiError shape. The
-      // engine layer subscribes through `Renderer.onError` and fans the
-      // same RhiError out; this keeps the unsupported capability observable
-      // for pure-RHI consumers (mock unit tests, dawn-real-gpu probes) that
-      // never instantiate a Renderer.
-      const fireFeatureNotEnabled = (featureName: string, hint: string): void => {
-        // Diagnostic channel (a) of the K-9 double-channel pattern: default
-        // console.error so AI consumers running headless / mock paths still
-        // observe the unsupported capability without subscribing to a
-        // listener. The capability-disabled entry remains non-throwing.
-        console.error(
-          `[RhiError feature-not-enabled] expected: device.features.has('${featureName}') === true; hint: ${hint}`,
-        );
-      };
-      return ok(makeCommandEncoder(rawEnc, caps, fireFeatureNotEnabled));
+      return ok(makeCommandEncoder(rawEnc));
     },
     // fix-f3: synchronous createShaderModule placeholder removed; the
     // shader-compile-failed path lives in the top-level async factory

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

@@ -1,88 +1,120 @@
-import { RhiError } from '@forgeax/engine-rhi';
 import { describe, expect, it } from 'vitest';
 import { createMockGpu } from '../../__tests__/__mocks__/gpu-device';
 import { makeRhiDevice } from '../../device';
 
-async function timestampEncoder(writeTimestamp?: (querySet: unknown, queryIndex: number) => void) {
-  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 };
-}
-
-describe('timestamp query raw write seam', () => {
-  it('forwards a callable raw writeTimestamp exactly once', async () => {
-    const calls: Array<{ querySet: unknown; queryIndex: number }> = [];
-    const { encoder, querySet } = await timestampEncoder((rawQuerySet, queryIndex) => {
-      calls.push({ querySet: rawQuerySet, queryIndex });
+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,
+      },
     });
-
-    encoder.writeTimestamp(querySet, 1);
-
-    expect(calls).toHaveLength(1);
-    expect(calls[0]?.querySet).toBeDefined();
-    expect(calls[0]?.queryIndex).toBe(1);
-  });
-
-  it('returns a structured refusal when capability-positive raw writeTimestamp is missing', async () => {
-    const { encoder, querySet } = await timestampEncoder();
-
-    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('returns a structured refusal when raw writeTimestamp throws', async () => {
-    const { encoder, querySet } = await timestampEncoder(() => {
-      throw new Error('raw timestamp failure');
+    pass.end();
+    expect(captured).toMatchObject({
+      label: 'timestamp-pass',
+      timestampWrites: {
+        beginningOfPassWriteIndex: 0,
+        endOfPassWriteIndex: 1,
+      },
     });
-
-    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');
-    }
+    expect(rawQuerySet).toBeDefined();
+    expect(captured?.timestampWrites?.querySet).toBe(rawQuerySet);
   });
 
-  it('refuses timestamp writes after encoder.finish with a lifecycle error', async () => {
-    const { encoder, querySet } = await timestampEncoder(() => {});
-    const finish = encoder.finish();
-    expect(finish.ok).toBe(true);
-
-    expect(() => encoder.writeTimestamp(querySet, 0)).toThrow(RhiError);
-    try {
-      encoder.writeTimestamp(querySet, 0);
-    } catch (error) {
-      expect(error).toMatchObject({
-        code: 'command-encoder-finished',
-        expected: 'command encoder must not be finished before recording new commands',
-      });
-    }
+  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();
   });
 });

package/src/internal/r32float-capability.ts

@@ -0,0 +1,153 @@
+import {
+  createUnavailableR32FloatReceipt,
+  err,
+  ok,
+  R32FLOAT_PROBE_STAGES,
+  type Result,
+  RhiError,
+  type RhiTextureFormatCapabilityReceipt,
+  type RhiTextureFormatProbeStage,
+  validateR32FloatReceipt,
+} from '@forgeax/engine-rhi';
+
+const TEXTURE_BINDING = 0x04;
+const STORAGE_BINDING = 0x08;
+const COPY_SRC = 0x01;
+const COPY_DST = 0x02;
+const MAP_READ = 0x0001;
+const BUFFER_COPY_DST = 0x0008;
+
+type RawDevice = GPUDevice;
+
+/** Execute the complete real-device r32float profile without exposing raw handles. */
+export async function probeR32FloatCapability(
+  rawDevice: RawDevice,
+  deviceGeneration: number,
+): Promise<Result<RhiTextureFormatCapabilityReceipt, RhiError>> {
+  let stage: RhiTextureFormatProbeStage = 'texture-create';
+  let texture: GPUTexture | undefined;
+  let readback: GPUBuffer | undefined;
+  rawDevice.pushErrorScope('validation');
+  try {
+    texture = rawDevice.createTexture({
+      size: { width: 2, height: 2, depthOrArrayLayers: 1 },
+      format: 'r32float',
+      mipLevelCount: 2,
+      usage: TEXTURE_BINDING | STORAGE_BINDING | COPY_SRC | COPY_DST,
+    });
+
+    stage = 'mip-view';
+    const sourceView = texture.createView({ baseMipLevel: 0, mipLevelCount: 1 });
+    const destinationView = texture.createView({ baseMipLevel: 1, mipLevelCount: 1 });
+
+    stage = 'sampled-storage-bind-group';
+    const layout = rawDevice.createBindGroupLayout({
+      entries: [
+        {
+          binding: 0,
+          visibility: 4,
+          texture: { sampleType: 'unfilterable-float', viewDimension: '2d' },
+        },
+        {
+          binding: 1,
+          visibility: 4,
+          storageTexture: { access: 'write-only', format: 'r32float', viewDimension: '2d' },
+        },
+      ],
+    });
+    const bindGroup = rawDevice.createBindGroup({
+      layout,
+      entries: [
+        { binding: 0, resource: sourceView },
+        { binding: 1, resource: destinationView },
+      ],
+    });
+
+    stage = 'pipeline-bind';
+    const shader = rawDevice.createShaderModule({
+      code: `
+        @group(0) @binding(0) var source: texture_2d<f32>;
+        @group(0) @binding(1) var destination: texture_storage_2d<r32float, write>;
+        @compute @workgroup_size(1) fn main() {
+          let value = textureLoad(source, vec2i(0, 0), 0).r;
+          textureStore(destination, vec2i(0, 0), vec4f(value));
+        }
+      `,
+    });
+    const pipeline = rawDevice.createComputePipeline({
+      layout: rawDevice.createPipelineLayout({ bindGroupLayouts: [layout] }),
+      compute: { module: shader, entryPoint: 'main' },
+    });
+
+    const encoder = rawDevice.createCommandEncoder({ label: 'r32float-profile' });
+    const pass = encoder.beginComputePass();
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, bindGroup);
+    pass.dispatchWorkgroups(1);
+    pass.end();
+
+    stage = 'finish';
+    readback = rawDevice.createBuffer({ size: 256, usage: MAP_READ | BUFFER_COPY_DST });
+    encoder.copyTextureToBuffer(
+      { texture, mipLevel: 1 },
+      { buffer: readback, bytesPerRow: 256, rowsPerImage: 1 },
+      { width: 1, height: 1, depthOrArrayLayers: 1 },
+    );
+    const commandBuffer = encoder.finish();
+
+    stage = 'submit';
+    rawDevice.queue.submit([commandBuffer]);
+
+    stage = 'completion';
+    await rawDevice.queue.onSubmittedWorkDone();
+    const validationError = await rawDevice.popErrorScope();
+    if (validationError !== null) {
+      throw new Error(`WebGPU validation: ${validationError.message}`);
+    }
+
+    stage = 'readback';
+    await readback.mapAsync(MAP_READ);
+    const values = Array.from(new Float32Array(readback.getMappedRange(0, 4).slice(0)));
+    readback.unmap();
+    const receipt: RhiTextureFormatCapabilityReceipt = {
+      profile: 'r32float-mip-sampled-storage',
+      verdict: 'admitted',
+      evidence: 'real',
+      deviceGeneration,
+      stages: R32FLOAT_PROBE_STAGES.map((entry) => ({
+        stage: entry,
+        verdict: 'admitted',
+        evidence: 'real',
+      })),
+      sampleType: 'unfilterable-float',
+      usages: ['texture-binding', 'storage-binding', 'copy-src'],
+      readback: { byteLength: 4, values },
+      probeExecutions: 1,
+    };
+    const validated = validateR32FloatReceipt(receipt);
+    return validated.ok ? ok(validated.value) : validated;
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    const receipt = createUnavailableR32FloatReceipt({
+      deviceGeneration,
+      failedStage: stage,
+      detail: message,
+    });
+    void receipt;
+    return err(
+      new RhiError({
+        code: 'rhi-texture-format-capability-unavailable',
+        expected: `r32float profile stage ${stage} to complete on the live WebGPU device`,
+        hint: 'retain fallback-only rendering and inspect the device validation error',
+        detail: {
+          stage,
+          deviceGeneration,
+          reason: message,
+        },
+      }),
+    );
+  } finally {
+    texture?.destroy();
+    readback?.destroy();
+  }
+}

package/src/internal/timestamp-query.ts

@@ -30,30 +30,3 @@ export function resolveTimestampQueries(args: {
     );
   }
 }
-
-export function writeTimestamp(args: {
-  rawEncoder: GPUCommandEncoder;
-  rawQuerySet: GPUQuerySet;
-  queryIndex: number;
-}): void {
-  const encoderWithTimestamp = args.rawEncoder as unknown as {
-    writeTimestamp?: (querySet: GPUQuerySet, queryIndex: number) => void;
-  };
-  if (typeof encoderWithTimestamp.writeTimestamp !== 'function') {
-    throw new RhiError({
-      code: 'webgpu-runtime-error',
-      expected: 'underlying GPUCommandEncoder.writeTimestamp to be callable',
-      hint: 'timestamp-query is advertised but the raw encoder has no writeTimestamp method',
-    });
-  }
-  try {
-    encoderWithTimestamp.writeTimestamp(args.rawQuerySet, args.queryIndex);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new RhiError({
-      code: 'webgpu-runtime-error',
-      expected: 'underlying GPUCommandEncoder.writeTimestamp to succeed',
-      hint: `writeTimestamp raised: ${message}`,
-    });
-  }
-}