@forgeax/engine-render 0.1.32 → 0.1.33

package/src/__tests__/public-surface.test-d.ts

@@ -2,6 +2,7 @@ import type {
   FrameObservationRequest,
   FrameReceipt,
   RenderError as PublicRenderError,
+  SunCardinalityError as PublicSunCardinalityError,
   ReflectionProbeInspection,
   ReflectionProbeSelectionInspection,
   RendererState,
@@ -65,6 +66,13 @@ const ssrInspection: SsrSpatialInspection = inspection.ssr;
 void ssrInspection;
 type IntentError = Extract<PublicRenderError, { readonly code: 'render-intent-invalid' }>;
 expectTypeOf<IntentError['detail']>().toEqualTypeOf<RenderIntentInvalidDetail>();
+type PublicSunCardinalityCode = Extract<PublicRenderError['code'], 'sun-cardinality'>;
+expectTypeOf<PublicSunCardinalityCode>().toEqualTypeOf<'sun-cardinality'>();
+expectTypeOf<PublicSunCardinalityError['code']>().toEqualTypeOf<'sun-cardinality'>();
+expectTypeOf<PublicSunCardinalityError['detail']>().toEqualTypeOf<{
+  readonly field: 'sun';
+  readonly value: number;
+}>();
 const backendKind: RenderInspection['capabilities']['backendKind'] =
   inspection.capabilities.backendKind;
 void backendKind;

package/src/__tests__/render-error-code-owner.test-d.ts

@@ -39,6 +39,7 @@ const expectedCodes = [
   'dynamic-resolution-invalid-parameter',
   'dynamic-resolution-requires-taa',
   'dynamic-resolution-timing-unavailable',
+  'motion-blur-invalid-params',
   'shadow-invalid-config',
   'equirect-projection-failed',
   'standard-light-budget-exceeded',
@@ -63,6 +64,7 @@ const expectedCodes = [
   'render-feature-draw-recording-failed',
   'environment-source-conflict',
   'fog-cardinality',
+  'sun-cardinality',
   'taa-caps-insufficient',
   'environment-generation-failed',
   'atmosphere-invalid-parameter',

package/src/__tests__/render-feature-error-reporting.unit.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import {
+  PENDING_RENDER_FEATURE_ERROR_REPORT_INTERVAL_FRAMES,
+  shouldReportPendingRenderFeatureError,
+} from '../features/error-reporting.js';
+
+describe('pending render-feature error reporting', () => {
+  it('reports the first failure, suppresses the hot-loop, and reopens the cooldown', () => {
+    const lastReportedFrame = new Map<string, number>();
+    expect(shouldReportPendingRenderFeatureError(lastReportedFrame, 'feature\0plan', 10)).toBe(
+      true,
+    );
+    expect(shouldReportPendingRenderFeatureError(lastReportedFrame, 'feature\0plan', 11)).toBe(
+      false,
+    );
+    expect(
+      shouldReportPendingRenderFeatureError(
+        lastReportedFrame,
+        'feature\0plan',
+        10 + PENDING_RENDER_FEATURE_ERROR_REPORT_INTERVAL_FRAMES,
+      ),
+    ).toBe(true);
+  });
+});

package/src/__tests__/render-feature-stage-fault-recovery.unit.test.ts

@@ -89,6 +89,29 @@ function frame(host: RenderFeatureHost, frameNumber: number) {
 }
 
 describe('RenderFeature stage fault recovery lifecycle', () => {
+  it('retains the original exception when a feature stage throws', () => {
+    const cause = new TypeError('feature plan exploded');
+    const host = createRenderFeatureHost(
+      [
+        {
+          identity: 'synthetic.m10.throwing',
+          extract: () => ok({ ready: true }),
+          plan: () => {
+            throw cause;
+          },
+        },
+      ],
+      caps,
+    ).unwrap();
+
+    const result = frame(host, 1);
+    expect(result.errors[0]).toMatchObject({
+      code: 'render-feature-stage-failed',
+      detail: { featureIdentity: 'synthetic.m10.throwing', cause },
+    });
+    expect(host.diagnostics()[0]?.latestError).toMatchObject({ detail: { cause } });
+  });
+
   it.each<Fault>([
     'create',
     'prepared-resource',

package/src/__tests__/render-scene-temporal-retry.unit.test.ts

@@ -130,4 +130,35 @@ describe('RenderScene temporal retry boundary', () => {
       instanceCollections.dispose();
     }
   });
+
+  it('keeps instance motion valid when stable generations reorder', () => {
+    const instanceCollections = new InstanceCollectionStore();
+    const collection = instanceCollections.create({ transforms: matrices(2, 1) }).unwrap();
+    const initialInstances = instanceCollections.snapshot(collection.collectionId).unwrap();
+    instanceCollections
+      .replace(
+        collection.collectionId,
+        matrices(2, 9),
+        new Uint32Array([
+          initialInstances.generations[1] ?? 0,
+          initialInstances.generations[0] ?? 0,
+        ]),
+      )
+      .unwrap();
+    const reorderedInstances = instanceCollections.snapshot(collection.collectionId).unwrap();
+    const scene = new RenderScene();
+    scene.setTemporalTracking(true);
+    try {
+      scene.apply([updateSnapshot(snapshot(7, 1, initialInstances))]);
+      submit(scene, 7);
+      scene.apply([updateInstances(snapshot(7, 1, reorderedInstances))]);
+
+      const temporal = scene.temporalSnapshotBySlot(0);
+      expect(temporal?.motionValid).toBe(true);
+      expect(temporal?.previousInstances?.generations).toEqual(initialInstances.generations);
+      expect(temporal?.previousInstances?.transforms).toEqual(initialInstances.transforms);
+    } finally {
+      instanceCollections.dispose();
+    }
+  });
 });

package/src/__tests__/renderer-frame-transaction.integration.test.ts

@@ -87,7 +87,8 @@ function temporalResolveFrame(
       bloom: 'off',
       bloomThreshold: 1,
       bloomIntensity: 1,
-      bloomBlurRadius: 1,
+      bloomSoftKnee: 0.5,
+      bloomScatter: 0.7,
       clearColor: [0, 0, 0, 1],
       temporal: frameState.lastSuccessfulTemporalView,
     },
@@ -1147,6 +1148,7 @@ describe('renderer successful-submit transaction', () => {
       height: 4,
       frameIndex: 6,
       historyValid: true,
+      sampleTimeSeconds: 1,
     });
     const frameState = {
       temporalGpuState: undefined,
@@ -1160,6 +1162,7 @@ describe('renderer successful-submit transaction', () => {
           height: 4,
           frameIndex: 6,
           historyValid: true,
+          sampleTimeSeconds: 1.016,
         }),
       },
       environmentGeneration,
@@ -1244,6 +1247,7 @@ describe('renderer successful-submit transaction', () => {
     expect(active.valid).toBe(true);
     expect(active.readIndex).toBe(1);
     expect(frameState.lastSuccessfulTemporalView).toBe(lastSuccessfulTemporalView);
+    expect(frameState.lastSuccessfulTemporalView.sampleTimeSeconds).toBe(1);
     expect(environmentLifecycle.inspect().activeSignature).toBe(activeEnvironment.signature);
     expect(environmentLifecycle.inspect().lkgSignature).toBe(activeEnvironment.signature);
     frameState.environmentGeneration = environmentLifecycle
@@ -1257,6 +1261,7 @@ describe('renderer successful-submit transaction', () => {
         height: 8,
         frameIndex: 7,
         historyValid: true,
+        sampleTimeSeconds: 1.016,
       }),
     };
     const retryFrame = temporalResolveFrame(device, scope, frameState, {});
@@ -1273,6 +1278,7 @@ describe('renderer successful-submit transaction', () => {
     expect(gpuCommitAfterSubmit).toEqual([1]);
     expect(frameState.activeTemporalGpuState).not.toBe(active);
     expect(frameState.successfulTemporalFrameIndex).toBe(8);
+    expect(frameState.lastSuccessfulTemporalView?.sampleTimeSeconds).toBe(1.016);
     expect(frameState.temporalGpuState).toBeUndefined();
     expect(frameState.retiringTemporalGpuStates.size).toBe(1);
     expect(publishEnvironment).toHaveBeenCalledTimes(1);

package/src/__tests__/shader-manifest-fixture.ts

@@ -43,14 +43,14 @@ const entries: readonly FixtureEntry[] = [
     bindings: '[]',
   },
   {
-    hash: 'fixture-bloom-bright',
-    wgsl: '// fixture marker: BloomBrightParams\n',
+    hash: 'fixture-bloom-downsample',
+    wgsl: '// fixture marker: BloomDownsampleParams\n',
     glsl: '',
     bindings: '[]',
   },
   {
-    hash: 'fixture-bloom-blur',
-    wgsl: '// fixture marker: BloomBlurParams\n',
+    hash: 'fixture-bloom-upsample',
+    wgsl: '// fixture marker: BloomUpsampleParams\n',
     glsl: '',
     bindings: '[]',
   },

package/src/__tests__/skinned-shadow-caster.test.ts

@@ -60,6 +60,8 @@ describe('skinned shadow caster', () => {
     expect(shader).toContain('discard;');
     expect(shader).toContain('@group(2) @binding(1)');
     expect(shader).toContain('let skinMatrix = palette[');
+    expect(shader).toContain('materialIndex = u32(meshes[meshIndex].temporal.w);');
+    expect(shader).not.toContain('bitcast<u32>(meshes[meshIndex].temporal.w)');
     expect(shader).toContain('@location(13) color : vec4<f32>');
     expect(shader).toContain('out.color = in.color;');
     expect(record).toContain('entry.source.skin.byteOffset');

package/src/__tests__/standard-lighting-write.unit.test.ts

@@ -41,7 +41,8 @@ function camera(): CameraSnapshot {
     bloom: 'off',
     bloomThreshold: 1,
     bloomIntensity: 1,
-    bloomBlurRadius: 4,
+    bloomSoftKnee: 0.5,
+    bloomScatter: 0.7,
     clearColor: [0, 0, 0, 1],
   };
 }

package/src/__tests__/standard-pipeline.dawn.test.ts

@@ -31,7 +31,7 @@ function topology(): RenderPipelineTopology {
       storageFormat: 'bgra8unorm',
       viewFormat: 'bgra8unorm-srgb',
     },
-    camera: { tonemap: 'aces-filmic', antialias: 'fxaa', bloom: 'on' },
+    camera: { tonemap: 'aces-filmic', antialias: 'fxaa', bloom: 'on', bloomIntensity: 1 },
     shadow: {
       directional: { mapSize: 64, cascadeCount: 1 },
       spotMapSize: 64,

package/src/__tests__/standard-pipeline.integration.test.ts

@@ -35,10 +35,15 @@ const dualViewProfile: SurfaceProfile = {
   hasDisplayEndpoint: true,
 };
 
+type TopologyOverrides = Omit<Partial<RenderPipelineTopology>, 'camera'> & {
+  readonly camera?: Partial<RenderPipelineTopology['camera']>;
+};
+
 function topology(
   profile: StandardProfile,
-  overrides: Partial<RenderPipelineTopology> = {},
+  overrides: TopologyOverrides = {},
 ): RenderPipelineTopology {
+  const { camera: cameraOverride, ...rest } = overrides;
   return {
     pipelineId: STANDARD_PIPELINE_ID,
     standardProfile: profile,
@@ -49,7 +54,13 @@ function topology(
       storageFormat: 'bgra8unorm',
       viewFormat: 'bgra8unorm-srgb',
     },
-    camera: { tonemap: 'aces-filmic', antialias: 'fxaa', bloom: 'on' },
+    camera: {
+      tonemap: 'aces-filmic',
+      antialias: 'fxaa',
+      bloom: 'on',
+      bloomIntensity: 1,
+      ...cameraOverride,
+    },
     shadow: {
       directional: { mapSize: 64, cascadeCount: 1 },
       spotMapSize: 64,
@@ -65,7 +76,7 @@ function topology(
     },
     featureTopologySignature: 'none',
     gpuDrivenTopologySignature: '',
-    ...overrides,
+    ...rest,
   };
 }
 
@@ -109,7 +120,7 @@ function standardLightingFor(resolvedTopology: RenderPipelineTopology) {
   return standardLighting;
 }
 
-async function build(profile: StandardProfile, overrides?: Partial<RenderPipelineTopology>) {
+async function build(profile: StandardProfile, overrides?: TopologyOverrides) {
   const graph = new RenderGraphBuilder<RenderPipelineFrame>();
   const resolvedTopology = topology(profile, overrides);
   const histogram = graph.createBuffer('standard-auto-exposure-histogram', { size: 1024 });
@@ -232,7 +243,7 @@ function importedTaaHistory(graph: RenderGraphBuilder<RenderPipelineFrame>) {
   };
 }
 
-async function buildTaa(profile: StandardProfile, overrides?: Partial<RenderPipelineTopology>) {
+async function buildTaa(profile: StandardProfile, overrides?: TopologyOverrides) {
   const graph = new RenderGraphBuilder<RenderPipelineFrame>();
   const history = importedTaaHistory(graph);
   const resolvedTopology = topology(profile, overrides);
@@ -542,9 +553,8 @@ describe('forgeax::standard graph', () => {
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const names = result.value.inspect().passes.map((pass) => pass.name);
-    expect(names).not.toContain('bloom-bright');
-    expect(names).not.toContain('bloom-blur-h');
-    expect(names).not.toContain('bloom-blur-v');
+    expect(names.some((name) => name.startsWith('bloom-downsample-'))).toBe(false);
+    expect(names.some((name) => name.startsWith('bloom-upsample-'))).toBe(false);
     expect(names).not.toContain('bloom-composite');
     expect(names).toContain('taa-resolve');
     expect(names).toContain('output-transform');

package/src/__tests__/temporal-reset-matrix.unit.test.ts

@@ -37,6 +37,16 @@ describe('TemporalView reset matrix', () => {
     expect(resolveTemporalReset(previous, next)).toBeUndefined();
   });
 
+  it('applies camera reset reasons to motion-blur-only off views', () => {
+    const previous = createTemporalView({ ...base().input, antialias: 'none' });
+    const next = createTemporalView({
+      ...previous.input,
+      antialias: 'none',
+      viewIdentity: 'secondary',
+    });
+    expect(resolveTemporalReset(previous, next)).toBe('view-switch');
+  });
+
   it('treats an explicit off commit as a first-frame boundary when TAA resumes', () => {
     const previous = base();
     const off = createTemporalView({

package/src/__tests__/temporal-view.unit.test.ts

@@ -130,7 +130,8 @@ describe('TemporalView v1', () => {
       bloom: 'disabled',
       bloomThreshold: 1,
       bloomIntensity: 0,
-      bloomBlurRadius: 0,
+      bloomSoftKnee: 0.5,
+      bloomScatter: 0.7,
       clearColor: [0, 0, 0, 1] as const,
     } as unknown as CameraSnapshot;
     const light = {

package/src/__tests__/typed-pipeline-topology.unit.test.ts

@@ -32,6 +32,10 @@ import { standardTemporalPostOrder } from '../temporal/standard-scene-data';
 
 let device: RhiDevice;
 
+type TopologyOverrides = Omit<Partial<RenderPipelineTopology>, 'camera'> & {
+  readonly camera?: Partial<RenderPipelineTopology['camera']>;
+};
+
 beforeAll(async () => {
   const adapter = await rhi.requestAdapter();
   if (!adapter.ok) throw adapter.error;
@@ -42,8 +46,9 @@ beforeAll(async () => {
 
 function topology(
   pipelineId: 'forgeax::standard',
-  overrides: Partial<RenderPipelineTopology> = {},
+  overrides: TopologyOverrides = {},
 ): RenderPipelineTopology {
+  const { camera: cameraOverride, ...rest } = overrides;
   return {
     pipelineId,
     config: undefined,
@@ -53,7 +58,13 @@ function topology(
       storageFormat: 'bgra8unorm',
       viewFormat: 'bgra8unorm-srgb',
     },
-    camera: { tonemap: 'aces-filmic', antialias: 'fxaa', bloom: 'on' },
+    camera: {
+      tonemap: 'aces-filmic',
+      antialias: 'fxaa',
+      bloom: 'on',
+      bloomIntensity: 1,
+      ...cameraOverride,
+    },
     shadow: {
       directional: { mapSize: 1024, cascadeCount: 4 },
       spotMapSize: 1024,
@@ -69,7 +80,7 @@ function topology(
     },
     featureTopologySignature: 'none',
     gpuDrivenTopologySignature: '',
-    ...overrides,
+    ...rest,
   };
 }
 
@@ -877,7 +888,12 @@ describe('typed built-in pipeline topology', () => {
 
   it('keeps zero-shutter Motion Blur free of temporal target and passes', () => {
     expect(
-      isMotionBlurTemporalDemand({ shutterAngle: 0, maxRadiusPixels: 32, sampleCount: 8 }),
+      isMotionBlurTemporalDemand({
+        shutterAngle: 0,
+        maxRadiusPixels: 32,
+        sampleCount: 8,
+        targetFps: 60,
+      }),
     ).toBe(false);
     const compiled = compile(
       standardPipeline,

package/src/__tests__/volume-optics-oracle.unit.test.ts

@@ -42,7 +42,9 @@ describe('volumetric optics CPU oracle', () => {
 
   it('converts the shared integrated-light basis once before normalized HG', () => {
     expect(integrateShader).toContain('const VOLUME_LIGHT_PHASE_SCALE : f32 = FOUR_PI;');
-    expect(integrateShader).toContain('phase *\n        VOLUME_LIGHT_PHASE_SCALE *');
+    expect(integrateShader.match(/phase\s*\*\s*VOLUME_LIGHT_PHASE_SCALE\s*\*/g) ?? []).toHaveLength(
+      1,
+    );
   });
 
   it('keeps empty density at identity transmittance', () => {

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

@@ -1,10 +1,11 @@
 import { execFileSync } from 'node:child_process';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
-import { World } from '@forgeax/engine-ecs';
+import { Time, World } from '@forgeax/engine-ecs';
 import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
 import type {
   BindGroupLayoutDescriptor,
+  Buffer,
   RenderPipelineDescriptor,
   RhiAdapter,
   RhiDevice,
@@ -33,6 +34,7 @@ import {
   deriveVolumetricFogExtent,
   deriveVolumetricFogResolvedExtent,
   inspectVolumetricFogResources,
+  VOLUMETRIC_FOG_PARAMS_BYTES,
 } from '../volume/resources';
 import { resolveVolumeTemporalReset } from '../volume/temporal';
 
@@ -62,15 +64,12 @@ class RecoverableNullDevice extends RhiNullDevice {
   private readonly resolveLost: (info: LostInfo) => void;
   private readonly lostPromise: Promise<LostInfo>;
 
-  constructor() {
+  constructor(queue: RhiNullQueue = new RhiNullQueue()) {
     let resolveLost!: (info: LostInfo) => void;
     const lostPromise = new Promise<LostInfo>((resolve) => {
       resolveLost = resolve;
     });
-    super(
-      new RhiNullQueue(),
-      (bookkeeper, device) => new RhiNullCommandEncoder(bookkeeper, device),
-    );
+    super(queue, (bookkeeper, device) => new RhiNullCommandEncoder(bookkeeper, device));
     this.resolveLost = resolveLost;
     this.lostPromise = lostPromise;
   }
@@ -104,13 +103,44 @@ class RecoverableNullAdapter implements RhiAdapter {
   readonly limits: Readonly<Record<string, number>> = {};
   readonly devices: RecoverableNullDevice[] = [];
 
+  constructor(private readonly queueFactory: () => RhiNullQueue = () => new RhiNullQueue()) {}
+
   requestDevice(): Promise<Result<RhiDevice, RhiError>> {
-    const device = new RecoverableNullDevice();
+    const device = new RecoverableNullDevice(this.queueFactory());
     this.devices.push(device);
     return Promise.resolve(ok(device));
   }
 }
 
+interface CapturedQueueWrite {
+  readonly buffer: Buffer;
+  readonly offset: number;
+  readonly bytes: Uint8Array;
+}
+
+/** Captures the real record-stage volume parameter writes without adding a
+ * second render implementation. */
+class RecordingNullQueue extends RhiNullQueue {
+  readonly writes: CapturedQueueWrite[] = [];
+
+  override writeBuffer(
+    buffer: Buffer,
+    bufferOffset: number,
+    data: ArrayBufferView | ArrayBuffer,
+    dataOffset?: number,
+    size?: number,
+  ) {
+    const source =
+      data instanceof ArrayBuffer
+        ? new Uint8Array(data)
+        : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    const start = dataOffset ?? 0;
+    const end = size === undefined ? source.byteLength : start + size;
+    this.writes.push({ buffer, offset: bufferOffset, bytes: source.slice(start, end) });
+    return super.writeBuffer(buffer, bufferOffset, data, dataOffset, size);
+  }
+}
+
 function surfaceCanvas(width = 1920, height = 1080): HTMLCanvasElement {
   return { width, height, getContext: () => null } as unknown as HTMLCanvasElement;
 }
@@ -336,11 +366,11 @@ describe('volumetric fog budget and recovery contract', () => {
           label: 'volume-params',
           kind: 'buffer',
           origin: 'imported',
-          descriptor: { kind: 'buffer', size: 128 },
+          descriptor: { kind: 'buffer', size: VOLUMETRIC_FOG_PARAMS_BYTES },
           firstUse: 0,
           lastUse: 3,
           derivedUsage: 64,
-          byteSize: 128,
+          byteSize: VOLUMETRIC_FOG_PARAMS_BYTES,
         },
       ],
     } as const;
@@ -349,21 +379,25 @@ describe('volumetric fog budget and recovery contract', () => {
     expect(facts.sampleCount).toBe(960 * 540 * 64);
     expect(facts.resolvedPixelCount).toBe(960 * 540);
     expect(facts.currentBytes).toBe(960 * 540 * 8);
-    expect(facts.bufferBytes).toBe(128);
+    expect(facts.bufferBytes).toBe(VOLUMETRIC_FOG_PARAMS_BYTES);
     expect(facts.liveResourceCount).toBe(5);
     expect(facts.historyBytes).toBe(960 * 540 * 8 * 2);
     expect(facts.physicalResourceCount).toBe(5);
-    expect(facts.totalBytes).toBe(960 * 540 * 16 * 4 + 960 * 540 * 8 * 3 + 128);
+    expect(facts.totalBytes).toBe(
+      960 * 540 * 16 * 4 + 960 * 540 * 8 * 3 + VOLUMETRIC_FOG_PARAMS_BYTES,
+    );
     expect(facts.totalBytes).toBe(
       facts.currentBytes + facts.historyBytes + facts.scratchBytes + facts.bufferBytes,
     );
     expect(facts.totalBytes).toBeLessThanOrEqual(MAX_MEMORY_BYTES);
 
     const doubleBuffered = inspectVolumetricFogResources(graph, { parameterBufferCount: 2 });
-    expect(doubleBuffered.bufferBytes).toBe(256);
+    expect(doubleBuffered.bufferBytes).toBe(VOLUMETRIC_FOG_PARAMS_BYTES * 2);
     expect(doubleBuffered.liveResourceCount).toBe(6);
     expect(doubleBuffered.physicalResourceCount).toBe(6);
-    expect(doubleBuffered.totalBytes).toBe(960 * 540 * 16 * 4 + 960 * 540 * 8 * 3 + 256);
+    expect(doubleBuffered.totalBytes).toBe(
+      960 * 540 * 16 * 4 + 960 * 540 * 8 * 3 + VOLUMETRIC_FOG_PARAMS_BYTES * 2,
+    );
     expect(doubleBuffered.totalBytes).toBe(
       doubleBuffered.currentBytes +
         doubleBuffered.historyBytes +
@@ -372,6 +406,136 @@ describe('volumetric fog budget and recovery contract', () => {
     );
   });
 
+  it('uses the canonical World clock to bound real volume history reuse', async () => {
+    const queue = new RecordingNullQueue();
+    const adapter = new RecoverableNullAdapter(() => queue);
+    const backend = {
+      ...nullRhi,
+      requestAdapter: async () => ok(adapter),
+    };
+    const created = await constructRendererHost(
+      surfaceCanvas(640, 360),
+      { rhi: backend },
+      { shaderManifestUrl: VOLUME_MANIFEST },
+    );
+    expect(created.ok).toBe(true);
+    if (!created.ok) return;
+    const { renderer } = created.value;
+    const world = new World();
+    const density = world.allocSharedRef('TextureAsset', densityAsset());
+    world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 3] } },
+        {
+          component: Camera,
+          data: {
+            ...perspective({ fov: Math.PI / 4, aspect: 16 / 9 }),
+            tonemap: TONEMAP_ACES_FILMIC,
+          },
+        },
+      )
+      .unwrap();
+    const sun = world
+      .spawn({
+        component: DirectionalLight,
+        data: { direction: [-0.4, -0.8, -0.3], castShadow: true },
+      })
+      .unwrap();
+    world
+      .spawn({
+        component: VolumetricFog,
+        data: {
+          light: sun,
+          density,
+          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();
+
+    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;
+    const drawAndRead = async (): Promise<{
+      readonly history: number;
+      readonly worldTime: number;
+      readonly delta: number;
+    }> => {
+      queue.writes.length = 0;
+      const frame = renderer.draw(request);
+      expect(frame.ok).toBe(true);
+      if (!frame.ok) return { history: -1, worldTime: -1, delta: -1 };
+      expect((await frame.value.completed).ok).toBe(true);
+      const paramsWrite = queue.writes
+        .filter((write) => write.offset === 0 && write.bytes.byteLength === 144)
+        .at(-1);
+      expect(paramsWrite).toBeDefined();
+      if (paramsWrite === undefined) return { history: -1, worldTime: -1, delta: -1 };
+      const historyWrite = queue.writes
+        .filter(
+          (write) =>
+            write.buffer === paramsWrite.buffer &&
+            write.offset === 31 * Float32Array.BYTES_PER_ELEMENT &&
+            write.bytes.byteLength === 3 * Float32Array.BYTES_PER_ELEMENT,
+        )
+        .at(-1);
+      expect(historyWrite).toBeDefined();
+      if (historyWrite === undefined) return { history: -1, worldTime: -1, delta: -1 };
+      return {
+        history: new Float32Array(
+          historyWrite.bytes.buffer,
+          historyWrite.bytes.byteOffset,
+          1,
+        )[0] as number,
+        worldTime: new Float32Array(
+          historyWrite.bytes.buffer,
+          historyWrite.bytes.byteOffset,
+          3,
+        )[1] as number,
+        delta: new Float32Array(
+          historyWrite.bytes.buffer,
+          historyWrite.bytes.byteOffset,
+          3,
+        )[2] as number,
+      };
+    };
+
+    world.update(1 / 60).unwrap();
+    const firstTime = world.getResource(Time).elapsed;
+    const first = await drawAndRead();
+    expect(first.worldTime).toBeCloseTo(firstTime, 5);
+    expect(first.history).toBe(0);
+
+    const stable = await drawAndRead();
+    expect(world.getResource(Time).elapsed).toBe(firstTime);
+    expect(stable.worldTime).toBeCloseTo(firstTime, 5);
+    expect(stable.history).toBe(1);
+
+    world.update(1 / 60).unwrap();
+    const movedTime = world.getResource(Time).elapsed;
+    const moved = await drawAndRead();
+    expect(moved.worldTime).toBeCloseTo(movedTime, 5);
+    expect(moved.worldTime).toBeGreaterThan(first.worldTime);
+    expect(moved.history).toBe(1);
+    expect(moved.delta).toBeCloseTo(1 / 60, 6);
+    expect(stable.delta).toBe(0);
+    for (let index = 0; index < 12; index += 1) world.update(1 / 60).unwrap();
+    const jumped = await drawAndRead();
+    expect(jumped.history).toBe(0);
+    expect(jumped.delta).toBeGreaterThan(0.1);
+    await renderer.dispose();
+  }, 30_000);
+
   it('derives a same-XY resolve descriptor when the packed raw extent is supplied alone', async () => {
     const adapter = await nullRhi.requestAdapter();
     expect(adapter.ok).toBe(true);