@forgeax/engine-rhi-webgpu 0.1.21 → 0.1.24

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.24",
   "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.24",
+    "@forgeax/engine-types": "0.1.24",
     "@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);
+    });
+  });
 }
 
 {
@@ -499,6 +563,77 @@ import { createMockGpu, type MockCapture, makeShaderError } from './__mocks__/gp
   }
 
   describe('MVP-1.1 runtime — verbatim pass-through of the 5 descriptors', () => {
+    afterEach(() => vi.unstubAllGlobals());
+
+    it('normalizes omitted dynamic Dawn limits from the adapter without mutating the descriptor', async () => {
+      const gpu = createMockGpu();
+      const descriptor: GPUDeviceDescriptor = { label: 'dynamic-limit-probe' };
+      const r = await requestDevice({ gpu, deviceDescriptor: descriptor });
+      expect(r.ok).toBe(true);
+      expect(descriptor).toEqual({ label: 'dynamic-limit-probe' });
+
+      const ev = lastOf(gpu.__captured, 'requestDevice');
+      expect(ev.options).toMatchObject({
+        label: 'dynamic-limit-probe',
+        requiredLimits: {
+          maxDynamicUniformBuffersPerPipelineLayout: 8,
+          maxDynamicStorageBuffersPerPipelineLayout: 4,
+        },
+      });
+    });
+
+    it('preserves explicit dynamic limits while filling only the omitted adapter-backed limit', async () => {
+      const gpu = createMockGpu();
+      const requiredLimits = { maxDynamicUniformBuffersPerPipelineLayout: 2 };
+      const r = await requestDevice({ gpu, deviceDescriptor: { requiredLimits } });
+      expect(r.ok).toBe(true);
+
+      const ev = lastOf(gpu.__captured, 'requestDevice');
+      expect(ev.options?.requiredLimits).toEqual({
+        maxDynamicUniformBuffersPerPipelineLayout: 2,
+        maxDynamicStorageBuffersPerPipelineLayout: 4,
+      });
+      expect(requiredLimits).toEqual({ maxDynamicUniformBuffersPerPipelineLayout: 2 });
+    });
+
+    it('clamps oversized dynamic limits to the adapter without mutating the descriptor', async () => {
+      const gpu = createMockGpu();
+      const requiredLimits = {
+        maxDynamicUniformBuffersPerPipelineLayout: 1_000_000,
+        maxDynamicStorageBuffersPerPipelineLayout: 1_000_000,
+      };
+      const r = await requestDevice({ gpu, deviceDescriptor: { requiredLimits } });
+      expect(r.ok).toBe(true);
+
+      const ev = lastOf(gpu.__captured, 'requestDevice');
+      expect(ev.options?.requiredLimits).toEqual({
+        maxDynamicUniformBuffersPerPipelineLayout: 8,
+        maxDynamicStorageBuffersPerPipelineLayout: 4,
+      });
+      expect(requiredLimits).toEqual({
+        maxDynamicUniformBuffersPerPipelineLayout: 1_000_000,
+        maxDynamicStorageBuffersPerPipelineLayout: 1_000_000,
+      });
+    });
+
+    it('applies the same normalization on the public adapter two-step path', async () => {
+      const gpu = createMockGpu();
+      vi.stubGlobal('navigator', { gpu });
+      const adapterResult = await requestAdapter();
+      expect(adapterResult.ok).toBe(true);
+      if (!adapterResult.ok) return;
+
+      const deviceResult = await adapterResult.value.requestDevice({
+        requiredLimits: { maxDynamicStorageBuffersPerPipelineLayout: 1 },
+      });
+      expect(deviceResult.ok).toBe(true);
+      const ev = lastOf(gpu.__captured, 'requestDevice');
+      expect(ev.options?.requiredLimits).toEqual({
+        maxDynamicUniformBuffersPerPipelineLayout: 8,
+        maxDynamicStorageBuffersPerPipelineLayout: 1,
+      });
+    });
+
     it('BufferDescriptor passes through size / usage / label / mappedAtCreation', async () => {
       const gpu = createMockGpu();
       const r = await requestDevice({ gpu });

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,12 +1503,32 @@ 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,
+    // The raw backend owns the only real loss-injection seam. Keep this
+    // Promise as a transparent observation boundary; a test provider must
+    // operate on the backend before this shim and must never be added to the
+    // public RHI surface.
     lost: rawDevice.lost as unknown as Promise<{
       readonly reason: 'destroyed' | 'unknown';
       readonly message: string;

package/src/index.ts

@@ -76,12 +76,51 @@ export interface GpuLike {
   requestAdapter(options?: GPURequestAdapterOptions | undefined): Promise<GpuAdapterLike | null>;
 }
 
-/** The `GPUAdapter` subset accepted at the provider seam — only the `requestDevice` entry is consumed. */
+/** The `GPUAdapter` subset accepted at the provider seam — capability limits plus `requestDevice`. */
 export interface GpuAdapterLike {
+  readonly limits?: GPUSupportedLimits | undefined;
   // forgeax-async-whitelist: dom-native — spec `GPUAdapter.requestDevice()` raw entry
   requestDevice(descriptor?: GPUDeviceDescriptor | undefined): Promise<GpuDeviceLike>;
 }
 
+const DYNAMIC_DEVICE_LIMIT_KEYS = [
+  'maxDynamicUniformBuffersPerPipelineLayout',
+  'maxDynamicStorageBuffersPerPipelineLayout',
+] as const;
+const SYNTHETIC_DAWN_DYNAMIC_LIMIT_DEFAULT = 1_000_000;
+
+/**
+ * Keep browser-native Dawn from synthesizing the 1,000,000 dynamic-buffer
+ * defaults or clamping Dawn's synthetic 1,000,000 request. The adapter's
+ * reported values are the only safe values for omitted/defaulted limits: they
+ * are finite, supported by this adapter, and do not mutate the caller's
+ * descriptor.
+ */
+function normalizeDeviceDescriptor(
+  adapter: { readonly limits?: GPUSupportedLimits | undefined },
+  descriptor?: GPUDeviceDescriptor | undefined,
+): GPUDeviceDescriptor | undefined {
+  const adapterLimits = adapter.limits;
+  if (adapterLimits === undefined || adapterLimits === null) return descriptor;
+
+  const requiredLimits = { ...(descriptor?.requiredLimits ?? {}) };
+  let changed = false;
+  for (const key of DYNAMIC_DEVICE_LIMIT_KEYS) {
+    const value = adapterLimits[key];
+    if (!Number.isFinite(value) || value < 1) continue;
+    const requested = requiredLimits[key];
+    if (
+      requested !== undefined &&
+      (requested <= value || requested !== SYNTHETIC_DAWN_DYNAMIC_LIMIT_DEFAULT)
+    ) {
+      continue;
+    }
+    requiredLimits[key] = value;
+    changed = true;
+  }
+  return changed ? { ...(descriptor ?? {}), requiredLimits } : descriptor;
+}
+
 /**
  * The `GPUDevice` subset accepted at the provider seam — exactly the fields the
  * shim actually touches (the 5 descriptor `createX` calls + features / limits /
@@ -196,7 +235,9 @@ export async function requestDevice(
 
   let rawDevice: GpuDeviceLike;
   try {
-    rawDevice = await adapter.requestDevice(opts.deviceDescriptor);
+    rawDevice = await adapter.requestDevice(
+      normalizeDeviceDescriptor(adapter, opts.deviceDescriptor),
+    );
   } catch (e) {
     return classifyRequestDeviceError(e);
   }
@@ -393,7 +434,7 @@ function makeRhiAdapter(rawAdapter: {
       let rawDevice: GpuDeviceLike;
       try {
         rawDevice = (await rawAdapter.requestDevice(
-          opts as GPUDeviceDescriptor | undefined,
+          normalizeDeviceDescriptor(rawAdapter, opts as GPUDeviceDescriptor | undefined),
         )) as GpuDeviceLike;
       } catch (e) {
         return classifyRequestDeviceError(e);