@forgeax/engine-runtime 0.1.19 → 0.1.20

package/src/__tests__/shadow-fields-observable.dawn.test.ts

@@ -33,6 +33,11 @@ const WIDTH = 256;
 const HEIGHT = 256;
 const BPR = Math.ceil((WIDTH * 4) / 256) * 256;
 
+// Each falsifier performs four fresh 256x256 Dawn readbacks. Windows' Dawn
+// prebuild can exceed Vitest's 90-second bound for that sequence while still
+// completing well inside the nightly platform job's 45-minute budget.
+const SHADOW_FIELDS_FALSIFIER_TIMEOUT_MS = 300_000;
+
 const ENGINE_MANIFEST = await (async () => {
   const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
   return buildEngineShaderManifest();
@@ -582,45 +587,57 @@ describe('M6 shadow fields observability', () => {
   // (physically removing the UBO write), comment out the matching
   // `viewPayload[126|127|128] = ...` line in render-system-record.ts and re-run
   // the corresponding `varied` leg — its diff collapses to 0, matching `held`.
-  it('falsification: depthBias varied differs, held does not (signal attributable to the field)', async () => {
-    if (typeof globalThis.navigator?.gpu?.requestAdapter !== 'function') return;
-    const varied = diff(
-      await renderConfig(true, 0.0, 0.05, 3),
-      await renderConfig(true, 0.5, 0.05, 3),
-    );
-    const held = diff(
-      await renderConfig(true, 0.0, 0.05, 3),
-      await renderConfig(true, 0.0, 0.05, 3),
-    );
-    expect(varied.diff).toBeGreaterThan(0);
-    expect(held.diff).toBe(0);
-  }, 90000);
+  it(
+    'falsification: depthBias varied differs, held does not (signal attributable to the field)',
+    async () => {
+      if (typeof globalThis.navigator?.gpu?.requestAdapter !== 'function') return;
+      const varied = diff(
+        await renderConfig(true, 0.0, 0.05, 3),
+        await renderConfig(true, 0.5, 0.05, 3),
+      );
+      const held = diff(
+        await renderConfig(true, 0.0, 0.05, 3),
+        await renderConfig(true, 0.0, 0.05, 3),
+      );
+      expect(varied.diff).toBeGreaterThan(0);
+      expect(held.diff).toBe(0);
+    },
+    SHADOW_FIELDS_FALSIFIER_TIMEOUT_MS,
+  );
 
-  it('falsification: normalBias varied differs, held does not', async () => {
-    if (typeof globalThis.navigator?.gpu?.requestAdapter !== 'function') return;
-    const varied = diff(
-      await renderConfig(true, 0.005, 0.0, 3),
-      await renderConfig(true, 0.005, 0.5, 3),
-    );
-    const held = diff(
-      await renderConfig(true, 0.005, 0.0, 3),
-      await renderConfig(true, 0.005, 0.0, 3),
-    );
-    expect(varied.diff).toBeGreaterThan(0);
-    expect(held.diff).toBe(0);
-  }, 90000);
+  it(
+    'falsification: normalBias varied differs, held does not',
+    async () => {
+      if (typeof globalThis.navigator?.gpu?.requestAdapter !== 'function') return;
+      const varied = diff(
+        await renderConfig(true, 0.005, 0.0, 3),
+        await renderConfig(true, 0.005, 0.5, 3),
+      );
+      const held = diff(
+        await renderConfig(true, 0.005, 0.0, 3),
+        await renderConfig(true, 0.005, 0.0, 3),
+      );
+      expect(varied.diff).toBeGreaterThan(0);
+      expect(held.diff).toBe(0);
+    },
+    SHADOW_FIELDS_FALSIFIER_TIMEOUT_MS,
+  );
 
-  it('falsification: pcfKernelSize varied differs, held does not', async () => {
-    if (typeof globalThis.navigator?.gpu?.requestAdapter !== 'function') return;
-    const varied = diff(
-      await renderConfig(true, 0.005, 0.05, 1),
-      await renderConfig(true, 0.005, 0.05, 5),
-    );
-    const held = diff(
-      await renderConfig(true, 0.005, 0.05, 1),
-      await renderConfig(true, 0.005, 0.05, 1),
-    );
-    expect(varied.diff).toBeGreaterThan(0);
-    expect(held.diff).toBe(0);
-  }, 90000);
+  it(
+    'falsification: pcfKernelSize varied differs, held does not',
+    async () => {
+      if (typeof globalThis.navigator?.gpu?.requestAdapter !== 'function') return;
+      const varied = diff(
+        await renderConfig(true, 0.005, 0.05, 1),
+        await renderConfig(true, 0.005, 0.05, 5),
+      );
+      const held = diff(
+        await renderConfig(true, 0.005, 0.05, 1),
+        await renderConfig(true, 0.005, 0.05, 1),
+      );
+      expect(varied.diff).toBeGreaterThan(0);
+      expect(held.diff).toBe(0);
+    },
+    SHADOW_FIELDS_FALSIFIER_TIMEOUT_MS,
+  );
 });

package/src/__tests__/skinned-shadow-mixed.dawn.test.ts

@@ -312,7 +312,9 @@ async function renderMixed(castShadow: boolean): Promise<MixedCapture> {
     if (!host.ok) throw host.error;
     renderer = host.value.renderer;
     unsubscribe = renderer.subscribe((event) => {
-      if (event.kind === 'error') errors.push(event.error.code);
+      if (event.kind === 'error') {
+        errors.push(event.error.code);
+      }
     });
     const world = new World();
     spawnMixedScene(world, castShadow);

package/src/__tests__/sprite-cullmode-flip.dawn.test.ts

@@ -229,12 +229,11 @@ describe('feat-20260608 M2 m2-t5: sprite pipeline cullMode "none" lets H/V flipp
     const synth = buildSyntheticRgba();
     const synthPod = {
       kind: 'texture' as const,
-      width: synth.width,
-      height: synth.height,
+      shape: { viewDimension: '2d' as const, extent: { width: synth.width, height: synth.height } },
       format: 'rgba8unorm-srgb' as const,
       data: synth.data,
       colorSpace: 'srgb' as const,
-      mipmap: false,
+      mips: { kind: 'none' as const },
     };
     const textureHandle = worldFlip.allocSharedRef('TextureAsset', synthPod as never);
     const samplerHandle = worldFlip.allocSharedRef('SamplerAsset', {
@@ -382,12 +381,11 @@ describe('feat-20260608 M2 m2-t5: sprite pipeline cullMode "none" lets H/V flipp
     const synth = buildSyntheticRgba();
     const synthPod = {
       kind: 'texture' as const,
-      width: synth.width,
-      height: synth.height,
+      shape: { viewDimension: '2d' as const, extent: { width: synth.width, height: synth.height } },
       format: 'rgba8unorm-srgb' as const,
       data: synth.data,
       colorSpace: 'srgb' as const,
-      mipmap: false,
+      mips: { kind: 'none' as const },
     };
     const textureHandle = worldFlipBoth.allocSharedRef('TextureAsset', synthPod as never);
     const samplerHandle = worldFlipBoth.allocSharedRef('SamplerAsset', {

package/src/__tests__/sprite-lit-bgl-byte-identical.test.ts

@@ -47,7 +47,7 @@ function makeSpec(shaderId: string): PipelineSpec {
 
 describe('sprite-lit BGL byte-identical to sprite (AC-07, w4/w5 close)', () => {
   describe('pbr-view BGL (light buffers; binding 1+2)', () => {
-    it('sprite-lit vs sprite share the same 10-entry pbr-view BGL under storage-buffer caps', () => {
+    it('sprite-lit vs sprite share the same 12-entry pbr-view BGL under storage-buffer caps', () => {
       const spriteSpec = makeSpec('forgeax::sprite');
       const spriteLitSpec = makeSpec('forgeax::sprite-lit');
       const sprite = buildBindGroupLayoutDescriptor(spriteSpec, {
@@ -59,7 +59,9 @@ describe('sprite-lit BGL byte-identical to sprite (AC-07, w4/w5 close)', () => {
         caps: { storageBuffer: true },
       });
       expect(JSON.stringify(spriteLit)).toBe(JSON.stringify(sprite));
-      expect(spriteLit.entries.length).toBe(10); // binding 10 is the shared Points/Lines view UBO
+      // binding 10 is the shared Points/Lines view UBO; bindings 11/12 are the
+      // optional SpotLight projector texture and sampler on capable devices.
+      expect(spriteLit.entries.length).toBe(12);
     });
 
     it('sprite-lit vs sprite share the same 10-entry pbr-view BGL under uniform fallback caps (AC-10)', () => {

package/src/__tests__/systems.unit.test.ts

@@ -120,6 +120,7 @@ import { INSTANCE_STORAGE_STRIDE_FLOATS } from '../../../render/src/record/mesh-
 import { selectSwapChainFormat } from '../../../render/src/render-system';
 import { createSkinPaletteAllocator } from '../../../render/src/systems/skin-palette-allocator';
 import type { TransparentEntry } from '../../../render/src/systems/transparent-sort-config';
+import { createTemporalFrameTransaction } from '../../../render/src/temporal/frame';
 import { standardMaterialShaderVariants } from './helpers/standard-material-manifest';
 import { drawWithOwners } from './renderer-test-utils';
 
@@ -762,6 +763,8 @@ import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
         [],
         {
           frameNumber: 0,
+          temporalFrameTransaction: createTemporalFrameTransaction({ deviceEpoch: 0 }),
+          temporalFrameInput: undefined,
           compiledFrameGraph: null,
           compiledFrameGraphTopologyKey: null,
           retiredCompiledFrameGraphs: new Set(),
@@ -817,6 +820,8 @@ import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
         [],
         {
           frameNumber: 0,
+          temporalFrameTransaction: createTemporalFrameTransaction({ deviceEpoch: 0 }),
+          temporalFrameInput: undefined,
           compiledFrameGraph: null,
           compiledFrameGraphTopologyKey: null,
           retiredCompiledFrameGraphs: new Set(),
@@ -2081,8 +2086,10 @@ import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
       );
     });
 
-    it('imports View from forgeax_view::common', () => {
-      expect(source).toEqual(expect.stringContaining('#import forgeax_view::common::{View'));
+    it('imports View from forgeax_view::common as the sole view ABI', () => {
+      expect(source).toEqual(expect.stringContaining('#import forgeax_view::common::View'));
+      expect(source).not.toContain('FogRay');
+      expect(source).not.toContain('fogRayFromNdc');
     });
 
     it('imports fullscreen_triangle from forgeax_view::common', () => {
@@ -3450,6 +3457,8 @@ import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
         [],
         {
           frameNumber: 0,
+          temporalFrameTransaction: createTemporalFrameTransaction({ deviceEpoch: 0 }),
+          temporalFrameInput: undefined,
           compiledFrameGraph: null,
           compiledFrameGraphTopologyKey: null,
           retiredCompiledFrameGraphs: new Set(),
@@ -3569,6 +3578,8 @@ import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
         [],
         {
           frameNumber: 0,
+          temporalFrameTransaction: createTemporalFrameTransaction({ deviceEpoch: 0 }),
+          temporalFrameInput: undefined,
           compiledFrameGraph: null,
           compiledFrameGraphTopologyKey: null,
           retiredCompiledFrameGraphs: new Set(),
@@ -3642,6 +3653,8 @@ import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
         [],
         {
           frameNumber: 0,
+          temporalFrameTransaction: createTemporalFrameTransaction({ deviceEpoch: 0 }),
+          temporalFrameInput: undefined,
           compiledFrameGraph: null,
           compiledFrameGraphTopologyKey: null,
           retiredCompiledFrameGraphs: new Set(),

package/src/__tests__/texture-dimensions.browser.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'vitest';
+
+const TEXTURE_BINDING = 0x04;
+const COPY_DST = 0x08;
+const COPY_SRC = 0x01;
+const STORAGE_BINDING = 0x80;
+const MAP_READ = 0x0001;
+const COMPUTE_STAGE = 1;
+
+type ProbeResult =
+  | { readonly status: 'ready'; readonly samples: readonly (readonly number[])[] }
+  | { readonly status: 'unavailable'; readonly reason: string };
+
+async function probe(): Promise<ProbeResult> {
+  if (!('gpu' in navigator)) return { status: 'unavailable', reason: 'webgpu-unavailable' };
+  const adapter = await navigator.gpu.requestAdapter();
+  if (adapter === null) return { status: 'unavailable', reason: 'adapter-unavailable' };
+  const device = await adapter.requestDevice();
+  const texture = device.createTexture({
+    size: { width: 2, height: 2, depthOrArrayLayers: 2 },
+    dimension: '3d',
+    format: 'rgba8unorm',
+    usage: TEXTURE_BINDING | COPY_DST,
+  });
+  const arrayTexture = device.createTexture({
+    size: { width: 2, height: 2, depthOrArrayLayers: 2 },
+    dimension: '2d',
+    format: 'rgba8unorm',
+    usage: TEXTURE_BINDING | COPY_DST,
+  });
+  const samples = new Uint8Array(256 * 2 * 2);
+  for (let point = 0; point < 8; point += 1) {
+    const z = Math.floor(point / 4);
+    const y = Math.floor((point % 4) / 2);
+    const x = point % 2;
+    const offset = z * 512 + y * 256 + x * 4;
+    samples[offset] = point + 1;
+    samples[offset + 3] = 255;
+  }
+  const layout = { offset: 0, bytesPerRow: 256, rowsPerImage: 2 };
+  const extent = { width: 2, height: 2, depthOrArrayLayers: 2 };
+  device.queue.writeTexture({ texture: arrayTexture }, samples, layout, extent);
+  device.queue.writeTexture({ texture }, samples, layout, extent);
+  const output = device.createBuffer({ size: 256, usage: STORAGE_BINDING | COPY_SRC });
+  const readback = device.createBuffer({ size: 256, usage: MAP_READ | COPY_DST });
+  const module = device.createShaderModule({
+    code: `
+      @group(0) @binding(0) var array_tex: texture_2d_array<f32>;
+      @group(0) @binding(1) var volume_tex: texture_3d<f32>;
+      @group(0) @binding(2) var<storage, read_write> output: array<vec4<u32>>;
+      fn to_byte(value: f32) -> u32 {
+        return u32(round(value * 255.0));
+      }
+      @compute @workgroup_size(1)
+      fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+        let point = id.x;
+        let coord = vec3<i32>(i32(point % 2u), i32((point / 2u) % 2u), i32(point / 4u));
+        let array_value = textureLoad(array_tex, coord.xy, coord.z, 0);
+        let volume_value = textureLoad(volume_tex, coord, 0);
+        output[point] = vec4<u32>(to_byte(array_value.r), 0u, 0u, 0u);
+        output[point + 8u] = vec4<u32>(to_byte(volume_value.r), 0u, 0u, 0u);
+      }
+    `,
+  });
+  const bindGroupLayout = device.createBindGroupLayout({
+    entries: [
+      { binding: 0, visibility: COMPUTE_STAGE, texture: { viewDimension: '2d-array' } },
+      { binding: 1, visibility: COMPUTE_STAGE, texture: { viewDimension: '3d' } },
+      {
+        binding: 2,
+        visibility: COMPUTE_STAGE,
+        buffer: { type: 'storage' },
+      },
+    ],
+  });
+  const pipeline = device.createComputePipeline({
+    layout: device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] }),
+    compute: { module, entryPoint: 'main' },
+  });
+  const bindGroup = device.createBindGroup({
+    layout: bindGroupLayout,
+    entries: [
+      { binding: 0, resource: arrayTexture.createView({ dimension: '2d-array' }) },
+      { binding: 1, resource: texture.createView({ dimension: '3d' }) },
+      { binding: 2, resource: { buffer: output } },
+    ],
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(8);
+  pass.end();
+  encoder.copyBufferToBuffer(output, 0, readback, 0, 256);
+  device.queue.submit([encoder.finish()]);
+  await readback.mapAsync(MAP_READ);
+  const actual = new Uint8Array(readback.getMappedRange()).slice();
+  readback.unmap();
+  const observed = Array.from({ length: 8 }, (_, point) => [
+    actual[point * 16] ?? 0,
+    actual[(point + 8) * 16] ?? 0,
+  ]);
+  const expected = Array.from({ length: 8 }, (_, point) => point + 1);
+  if (
+    observed.some(
+      ([arraySample, volumeSample], point) =>
+        arraySample !== expected[point] || volumeSample !== expected[point],
+    )
+  ) {
+    return { status: 'unavailable', reason: 'gpu-readback-mismatch' };
+  }
+  return { status: 'ready', samples: observed };
+}
+
+describe('browser texture dimensions', () => {
+  it('returns an observable WebGPU status instead of silently accepting a bad view', async () => {
+    const result = await probe();
+    expect(['ready', 'unavailable']).toContain(result.status);
+    if (result.status === 'unavailable') expect(result.reason.length).toBeGreaterThan(0);
+    if (result.status === 'ready') {
+      expect(result.samples).toHaveLength(8);
+      expect(
+        result.samples.map(([arraySample, volumeSample]) => [arraySample, volumeSample]),
+      ).toEqual(Array.from({ length: 8 }, (_, point) => [point + 1, point + 1]));
+    }
+  });
+});

package/src/__tests__/transcode-fallback.unit.test.ts

@@ -126,7 +126,11 @@ function wireFetch(
               {
                 guid: GUID_TEX,
                 kind: 'texture',
-                payload: { width: 4, height: 4, colorSpace },
+                payload: {
+                  shape: { viewDimension: '2d', extent: { width: 4, height: 4 } },
+                  colorSpace,
+                  mips: { kind: 'none' },
+                },
                 refs: [],
                 artifacts: {
                   body: {

package/src/__tests__/volumetric-fog-record-recovery.integration.test.ts

@@ -0,0 +1,180 @@
+// @perf-budget-skip: intentional full Renderer submit-failure and LKG recovery integration gate.
+import { World } from '@forgeax/engine-ecs';
+import {
+  Camera,
+  DirectionalLight,
+  perspective,
+  TONEMAP_ACES_FILMIC,
+  VolumetricFog,
+} from '@forgeax/engine-render';
+import type { CommandBuffer, RhiQueue } from '@forgeax/engine-rhi';
+import { RhiError } from '@forgeax/engine-rhi';
+import { rhi as nullRhi, RhiNullAdapter } from '@forgeax/engine-rhi-null';
+import { Transform } from '@forgeax/engine-scene';
+import { err, type Result, type TextureAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { createRenderer } from '../createRenderer';
+
+const VOLUME_MANIFEST = `data:application/json,${encodeURIComponent(
+  JSON.stringify({
+    entries: [
+      { hash: 'pbr', wgsl: 'f_schlick', glsl: '', bindings: '' },
+      { hash: 'unlit', wgsl: 'unlit', glsl: '', bindings: '' },
+      { hash: 'tonemap', wgsl: 'struct TonemapParams {}', glsl: '', bindings: '' },
+      { hash: 'volume-inject', wgsl: 'fn volume_inject() {}', glsl: '', bindings: '' },
+      { hash: 'volume-integrate', wgsl: 'fn volume_integrate() {}', glsl: '', bindings: '' },
+      { hash: 'volume-temporal', wgsl: 'fn volume_temporal() {}', glsl: '', bindings: '' },
+      { hash: 'volume-composite', wgsl: 'fn volume_fs() {}', glsl: '', bindings: '' },
+    ],
+  }),
+)}`;
+
+function canvas(): HTMLCanvasElement {
+  return { width: 64, height: 64, getContext: () => null } as unknown as HTMLCanvasElement;
+}
+
+function density(): TextureAsset {
+  return {
+    kind: 'texture',
+    shape: { viewDimension: '3d', extent: { width: 64, height: 64, depth: 64 } },
+    format: 'r8unorm',
+    colorSpace: 'linear',
+    mips: { kind: 'none' },
+    data: new Uint8Array(64 * 64 * 64).fill(32),
+  };
+}
+
+function failingNullRhi(controller: { failNext: boolean }) {
+  const adapter = new RhiNullAdapter();
+  const requestDevice = adapter.requestDevice.bind(adapter);
+  adapter.requestDevice = async (options) => {
+    const result = await requestDevice(options);
+    if (!result.ok) return result;
+    const queue: RhiQueue = result.value.queue;
+    const submit = queue.submit.bind(queue);
+    queue.submit = (buffers: readonly CommandBuffer[]): Result<void, RhiError> => {
+      if (controller.failNext) {
+        controller.failNext = false;
+        return err(
+          new RhiError({
+            code: 'webgpu-runtime-error',
+            expected: 'queue submission to succeed',
+            hint: 'the recovery regression intentionally rejects one submit',
+          }),
+        );
+      }
+      return submit(buffers);
+    };
+    return result;
+  };
+  return {
+    ...nullRhi,
+    requestAdapter: async () => ({ ok: true, value: adapter }),
+  };
+}
+
+describe('volumetric fog record recovery projection', () => {
+  it('keeps accepted LKG inspection on a failed submit and clears it after repair', async () => {
+    const controller = { failNext: false };
+    const created = await createRenderer(
+      canvas(),
+      { rhi: failingNullRhi(controller) as never },
+      { shaderManifestUrl: VOLUME_MANIFEST },
+    );
+    expect(created.ok).toBe(true);
+    if (!created.ok) return;
+    const renderer = created.value;
+
+    const world = new World();
+    const densityHandle = world.allocSharedRef('TextureAsset', density());
+    world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 3] } },
+        {
+          component: Camera,
+          data: {
+            ...perspective({ fov: Math.PI / 4, aspect: 1 }),
+            tonemap: TONEMAP_ACES_FILMIC,
+          },
+        },
+      )
+      .unwrap();
+    const directionalLight = world
+      .spawn({
+        component: DirectionalLight,
+        data: { direction: [-0.4, -0.8, -0.3], castShadow: true },
+      })
+      .unwrap();
+    const fogEntity = world
+      .spawn({
+        component: VolumetricFog,
+        data: {
+          light: directionalLight,
+          density: densityHandle,
+          boundsMin: [-1, -1, -1],
+          boundsMax: [1, 1, 1],
+          extinction: [0.2, 0.2, 0.2],
+          albedo: [0.8, 0.8, 0.8],
+          emission: [0, 0, 0],
+          anisotropy: 0,
+          maxDistance: 50,
+        },
+      })
+      .unwrap();
+    expect(world.update(1 / 60).ok).toBe(true);
+
+    const lease = renderer.attach(world);
+    expect(lease.ok).toBe(true);
+    if (!lease.ok) return;
+    const request = {
+      leases: [lease.value],
+      camera: { lease: lease.value },
+      environment: { lease: lease.value },
+    } as const;
+
+    expect(renderer.draw(request).ok).toBe(true);
+    expect(renderer.inspect().volumetricFog).toMatchObject({
+      status: 'available',
+      resourceStage: 'accepted',
+      generation: 1,
+      passCount: 4,
+    });
+
+    controller.failNext = true;
+    expect(renderer.draw(request).ok).toBe(false);
+    expect(renderer.inspect().volumetricFog).toMatchObject({
+      status: 'degraded',
+      resourceStage: 'lkg',
+      generation: 1,
+      lkgGeneration: 1,
+      candidateGeneration: 1,
+      candidateFailure: 'submit-failed',
+      passCount: 4,
+      // The packed high profile uses a 64x64x16 physical froxel texture,
+      // representing 64 logical slices per pixel. Inspection reports the
+      // descriptor-derived allocation bytes for this recovery fixture.
+      sampleCount: 64 * 64 * 16,
+      memoryBytes: 71808,
+    });
+
+    expect(renderer.draw(request).ok).toBe(true);
+    expect(renderer.inspect().volumetricFog).toMatchObject({
+      status: 'available',
+      resourceStage: 'accepted',
+      generation: 1,
+      passCount: 4,
+      candidateFailure: undefined,
+    });
+
+    expect(world.removeComponent(fogEntity, VolumetricFog).ok).toBe(true);
+    expect(world.update(1 / 60).ok).toBe(true);
+    expect(renderer.draw(request).ok).toBe(true);
+    expect(renderer.inspect().volumetricFog).toMatchObject({
+      status: 'off',
+      passCount: 0,
+      sampleCount: 0,
+      memoryBytes: 0,
+    });
+    expect((await renderer.dispose()).ok).toBe(true);
+  });
+});

package/src/createRenderer.ts

@@ -30,6 +30,9 @@ export async function createRenderer(
           ...(options.rhi === undefined ? {} : { rhi: options.rhi }),
           ...(options.features === undefined ? {} : { features: options.features }),
           ...(options.profiler === undefined ? {} : { profiler: options.profiler }),
+          ...(options.captureGpuTimings === undefined
+            ? {}
+            : { captureGpuTimings: options.captureGpuTimings }),
           ...(options.rhiInstrumentation === undefined
             ? {}
             : { rhiInstrumentation: options.rhiInstrumentation }),