@forgeax/engine-render 0.1.32 → 0.1.34

package/src/__tests__/temporal-history-lifecycle.unit.test.ts

@@ -31,6 +31,11 @@ describe('TAA history lifecycle', () => {
         'r8unorm',
       ]);
       expect(state).toHaveProperty('stability');
+      expect(state).toHaveProperty('cloudRadiance');
+      expect(state).toHaveProperty('cloudTransmittance');
+      expect(state).toHaveProperty('cloudDepth');
+      expect(state.cloudHistoryEnabled).toBe(false);
+      expect(state.cloudRadiance).toBeUndefined();
       const view = createTemporalView({ antialias: 'taa', width: 8, height: 8 });
       const inspection = inspectTemporal(view, undefined, { active: state });
       expect(inspection.historyBytes).toBe(34 * 8 * 8);
@@ -39,6 +44,33 @@ describe('TAA history lifecycle', () => {
       retireTemporalGpuState(state);
     }
   });
+  it('allocates the cloud MRT only for a cloud-enabled candidate', async () => {
+    const device = (await new RhiNullAdapter().requestDevice()).unwrap();
+    const textures = vi.spyOn(device, 'createTexture');
+    const state = getTemporalGpuState(
+      {} as RenderFrameState,
+      device,
+      DeviceScope.create(23, 'cloud-history-test'),
+      8,
+      8,
+      true,
+    );
+    try {
+      expect(state.cloudHistoryEnabled).toBe(true);
+      expect(state.cloudRadiance).toBeDefined();
+      expect(textures).toHaveBeenCalledTimes(12);
+      expect(textures.mock.calls.slice(6).map(([desc]) => desc.label)).toEqual([
+        'cloud-history-radiance-a',
+        'cloud-history-radiance-b',
+        'cloud-history-transmittance-a',
+        'cloud-history-transmittance-b',
+        'cloud-history-depth-a',
+        'cloud-history-depth-b',
+      ]);
+    } finally {
+      retireTemporalGpuState(state);
+    }
+  });
   it('filters subpixel color reconstruction without filtering temporal metadata', async () => {
     const device = (await new RhiNullAdapter().requestDevice()).unwrap();
     const samplers = vi.spyOn(device, 'createSampler');

package/src/__tests__/temporal-performance.integration.test.ts

@@ -210,7 +210,7 @@ describe('temporal motion blur performance evidence', () => {
     const evidence = createCorrectnessEvidence(
       {
         backend: 'webgpu',
-        framesObserved: 300,
+        framesObserved: 60,
         temporal: { status: 'stable', historyValid: true, historyAttempt: 'committed', epoch: 300 },
         temporalTarget: {
           identity: 'standard-scene-temporal',
@@ -441,7 +441,7 @@ describe('temporal motion blur performance evidence', () => {
     const assembled = assemblePerformanceAdmissionEvidence(
       {
         backend: 'webgpu',
-        framesObserved: 300,
+        framesObserved: 60,
         errors: [],
         drawErrors: [],
         resolution: { width: 1920, height: 1080 },
@@ -543,7 +543,7 @@ describe('temporal motion blur performance evidence', () => {
       assemblePerformanceAdmissionEvidence(
         {
           backend: 'webgpu',
-          framesObserved: 300,
+          framesObserved: 60,
           errors: [],
           drawErrors: [],
           resolution: { width: 1920, height: 1080 },

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__/visibility-instances.integration.test.ts

@@ -6,23 +6,17 @@ import { Instances } from '../components/instances';
 import { MeshFilter } from '../components/mesh-filter';
 import { MeshRenderer } from '../components/mesh-renderer';
 import { Visibility, VisibilityStateValue } from '../components/visibility';
-import { InstanceCollectionStore } from '../instances';
 import { extractFrames } from '../render-system-extract';
 
 const IDENTITY = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 
-function spawnInstance(
-  world: World,
-  instanceCollections: InstanceCollectionStore,
-  state: keyof typeof VisibilityStateValue,
-) {
-  const collectionId = instanceCollections.create({ transforms: IDENTITY }).unwrap().collectionId;
+function spawnInstance(world: World, state: keyof typeof VisibilityStateValue) {
   return world
     .spawn(
       { component: Transform, data: {} },
       { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: {} },
-      { component: Instances, data: { collectionId } },
+      { component: Instances, data: { transforms: new Float32Array(IDENTITY) } },
       { component: Visibility, data: { state: VisibilityStateValue[state] } },
     )
     .unwrap();
@@ -31,12 +25,9 @@ function spawnInstance(
 describe('visibility instance producer gate', () => {
   it('gates an explicit Instances owner before producing a renderable', () => {
     const world = new World();
-    const instanceCollections = new InstanceCollectionStore();
-    const entity = spawnInstance(world, instanceCollections, 'hidden');
+    const entity = spawnInstance(world, 'hidden');
 
-    const frame = extractFrames([world], 0, undefined, undefined, undefined, {
-      instanceCollections,
-    });
+    const frame = extractFrames([world], 0);
 
     expect(frame.renderables.some((item) => item.entityKey === entity)).toBe(false);
     expect(frame.dispatch.some((item) => item.entityIndex === 0)).toBe(false);
@@ -44,13 +35,10 @@ describe('visibility instance producer gate', () => {
 
   it('keeps visible members of a mixed batch independent from hidden members', () => {
     const world = new World();
-    const instanceCollections = new InstanceCollectionStore();
-    spawnInstance(world, instanceCollections, 'hidden');
-    const visible = spawnInstance(world, instanceCollections, 'visible');
+    spawnInstance(world, 'hidden');
+    const visible = spawnInstance(world, 'visible');
 
-    const frame = extractFrames([world], 0, undefined, undefined, undefined, {
-      instanceCollections,
-    });
+    const frame = extractFrames([world], 0);
 
     expect(frame.renderables.map((item) => item.entityKey)).toEqual([visible]);
     expect(frame.dispatch.length).toBe(2);

package/src/__tests__/visibility-producer-matrix.integration.test.ts

@@ -11,7 +11,6 @@ import { SpriteInstances } from '../components/sprite-instances';
 import { TileLayer } from '../components/tile-layer';
 import { Tilemap } from '../components/tilemap';
 import { Visibility, VisibilityStateValue } from '../components/visibility';
-import { InstanceCollectionStore } from '../instances';
 import { extractFrames } from '../render-system-extract';
 import { classifySceneDataCoverage } from '../temporal/coverage';
 import { tilemapChunkExtractSystem } from '../tilemap-chunk-extract-system';
@@ -20,7 +19,7 @@ const IDENTITY = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
 
 type ProducerCase = {
   readonly name: string;
-  readonly setup: (world: World, instanceCollections: InstanceCollectionStore) => EntityHandle;
+  readonly setup: (world: World) => EntityHandle;
 };
 
 function staticMesh(world: World): EntityHandle {
@@ -61,33 +60,25 @@ function spriteMesh(world: World): EntityHandle {
     .unwrap();
 }
 
-function autoFoldInstances(
-  world: World,
-  instanceCollections: InstanceCollectionStore,
-): EntityHandle {
-  const collectionId = instanceCollections.create({ transforms: IDENTITY }).unwrap().collectionId;
+function autoFoldInstances(world: World): EntityHandle {
   return world
     .spawn(
       { component: Transform, data: {} },
       { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: {} },
-      { component: Instances, data: { collectionId } },
+      { component: Instances, data: { transforms: IDENTITY } },
       { component: Visibility, data: { state: VisibilityStateValue.hidden } },
     )
     .unwrap();
 }
 
-function explicitInstances(
-  world: World,
-  instanceCollections: InstanceCollectionStore,
-): EntityHandle {
-  const collectionId = instanceCollections.create({ transforms: IDENTITY }).unwrap().collectionId;
+function explicitInstances(world: World): EntityHandle {
   return world
     .spawn(
       { component: Transform, data: {} },
       { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: {} },
-      { component: Instances, data: { collectionId } },
+      { component: Instances, data: { transforms: IDENTITY } },
       { component: Visibility, data: { state: VisibilityStateValue.hidden } },
     )
     .unwrap();
@@ -141,20 +132,18 @@ describe('visibility built-in producer matrix', () => {
 
   it.each(PRODUCERS)('$name is hidden, visible, then restorable', ({ setup }) => {
     const world = new World();
-    const instanceCollections = new InstanceCollectionStore();
-    const entity = setup(world, instanceCollections);
+    const entity = setup(world);
 
-    const options = { instanceCollections };
-    const hidden = extractFrames([world], 0, undefined, undefined, undefined, options);
+    const hidden = extractFrames([world], 0);
     expect(hidden.renderables).toHaveLength(0);
     expect(hidden.dispatch).toHaveLength(0);
 
     world.set(entity, Visibility, { state: VisibilityStateValue.visible }).unwrap();
-    const visible = extractFrames([world], 0, undefined, undefined, undefined, options);
+    const visible = extractFrames([world], 0);
     expect(visible.visibilitySnapshots[0]?.get(entity)?.effective).toBe('visible');
 
     world.set(entity, Visibility, { state: VisibilityStateValue.hidden }).unwrap();
-    const restored = extractFrames([world], 0, undefined, undefined, undefined, options);
+    const restored = extractFrames([world], 0);
     expect(restored.renderables).toHaveLength(0);
     expect(restored.dispatch).toHaveLength(0);
   });

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

@@ -35,14 +35,18 @@ describe('volumetric optics CPU oracle', () => {
   it('does not apply density twice to single-scatter radiance', () => {
     expect(integrateShader).not.toContain('phase * sample.g * sample.r * (1.0 - transmittance)');
     expect(integrateShader).toContain(
-      'let local_scatter = radiance * volume_params.albedo.xyz * phase *',
+      'source += radiance * volume_params.albedo.xyz * phase * VOLUME_LIGHT_PHASE_SCALE * sigma;',
+    );
+    expect(integrateShader).toContain(
+      'let local_scatter = source * (1.0 - local_transmittance) / max(extinction, EPSILON) +',
     );
-    expect(integrateShader).toContain('VOLUME_LIGHT_PHASE_SCALE * (1.0 - local_transmittance) +');
   });
 
   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,146 @@ describe('volumetric fog budget and recovery contract', () => {
     );
   });
 
+  it.each([
+    1, 2,
+  ])('uses the canonical World clock for %i owners and bounds real history reuse', async (ownerCount) => {
+    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();
+    for (let owner = 0; owner < ownerCount; owner++)
+      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 === VOLUMETRIC_FOG_PARAMS_BYTES,
+        )
+        .at(-1);
+      expect(paramsWrite).toBeDefined();
+      if (paramsWrite === undefined) return { history: -1, worldTime: -1, delta: -1 };
+      const params = new Float32Array(paramsWrite.bytes.buffer, paramsWrite.bytes.byteOffset);
+      expect(params[3]).toBe(ownerCount);
+      for (let owner = 0; owner < ownerCount; owner++) {
+        expect(params[(owner + 1) * 36 + 32]).toBeCloseTo(world.getResource(Time).elapsed, 5);
+      }
+      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);
@@ -395,7 +569,7 @@ describe('volumetric fog budget and recovery contract', () => {
     expect(resolved?.extent).toEqual({ width: 960, height: 540, depthOrArrayLayers: 1 });
   });
 
-  it('keeps one real Renderer volume generation through 20 resizes, 3 recoveries, and 300 frames', async () => {
+  it('keeps one real Renderer volume generation through 20 resizes, 3 recoveries, and 60 frames', async () => {
     const adapter = new RecoverableNullAdapter();
     const backend = {
       ...nullRhi,
@@ -602,7 +776,7 @@ describe('volumetric fog budget and recovery contract', () => {
       readonly totalBytes: number;
       readonly physicalResourceCount: number;
     }> = [];
-    for (let frame = 0; frame < 300; frame += 1) {
+    for (let frame = 0; frame < 60; frame += 1) {
       const inspection = await draw();
       const facts = inspection?.volumetricFog?.resourceFacts;
       expect(facts).toBeDefined();

package/src/__tests__/volumetric-fog-errors.unit.test.ts

@@ -1,6 +1,7 @@
 import type { EntityHandle } from '@forgeax/engine-ecs';
 import { describe, expect, it } from 'vitest';
 import { type VolumetricFogAuthoring, validateVolumetricFog } from '../volume/component';
+import { extractVolumetricFog } from '../volume/extract';
 
 const base: VolumetricFogAuthoring = {
   light: 1 as EntityHandle,
@@ -32,12 +33,12 @@ describe('VolumetricFog structured error contract', () => {
     }
   });
 
-  it('keeps owner conflict as a closed error instead of creating a second volume', () => {
-    const result = validateVolumetricFog({ ...base, ownerCount: 2 });
+  it('keeps volume budget overflow as a closed error', () => {
+    const result = extractVolumetricFog(Array.from({ length: 9 }, () => base));
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error.code).toBe('volume-owner-conflict');
-      expect(result.error.detail).toMatchObject({ ownerCount: 2 });
+      expect(result.error.detail).toMatchObject({ ownerCount: 9 });
     }
   });