@forgeax/engine-render 0.1.7 → 0.1.20

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

@@ -0,0 +1,655 @@
+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 { RenderGraphBuilder } from '@forgeax/engine-render-graph';
+import type {
+  BindGroupLayoutDescriptor,
+  RenderPipelineDescriptor,
+  RhiAdapter,
+  RhiDevice,
+  RhiError,
+  SamplerDescriptor,
+} from '@forgeax/engine-rhi';
+import {
+  rhi as nullRhi,
+  RhiNullCommandEncoder,
+  RhiNullDevice,
+  RhiNullQueue,
+} from '@forgeax/engine-rhi-null';
+import { Transform } from '@forgeax/engine-scene';
+import { ok, type Result, type TextureAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { Camera, perspective, TONEMAP_ACES_FILMIC } from '../components/camera';
+import { DirectionalLight } from '../components/directional-light';
+import { constructRendererHost } from '../construct-renderer';
+import { resolveVolumetricFogProfile } from '../pipeline/standard-profile';
+import type { RenderPipelineFrame } from '../render-pipeline';
+import { VolumetricFog } from '../volume/component';
+import { inspectVolumetricFog } from '../volume/inspection';
+import { recoverVolumetricFog, stageVolumetricFog } from '../volume/recovery';
+import {
+  createVolumetricFogResources,
+  deriveVolumetricFogExtent,
+  deriveVolumetricFogResolvedExtent,
+  inspectVolumetricFogResources,
+} from '../volume/resources';
+import { resolveVolumeTemporalReset } from '../volume/temporal';
+
+const MAX_MEMORY_BYTES = 48 * 1024 * 1024;
+
+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-temporal', wgsl: 'fn volume_temporal() {}', glsl: '', bindings: '' },
+      { hash: 'volume-integrate', wgsl: 'fn volume_integrate() {}', glsl: '', bindings: '' },
+      { hash: 'volume-composite', wgsl: 'fn volume_fs() {}', glsl: '', bindings: '' },
+    ],
+  }),
+)}`;
+
+type LostInfo = { readonly reason: 'destroyed' | 'unknown'; readonly message: string };
+
+/** A null-device that can drive the real Renderer lost -> recover lifecycle. */
+class RecoverableNullDevice extends RhiNullDevice {
+  readonly renderPipelineDescriptors: RenderPipelineDescriptor[] = [];
+  readonly bindGroupLayoutDescriptors: BindGroupLayoutDescriptor[] = [];
+  readonly samplerDescriptors: SamplerDescriptor[] = [];
+  private readonly resolveLost: (info: LostInfo) => void;
+  private readonly lostPromise: Promise<LostInfo>;
+
+  constructor() {
+    let resolveLost!: (info: LostInfo) => void;
+    const lostPromise = new Promise<LostInfo>((resolve) => {
+      resolveLost = resolve;
+    });
+    super(
+      new RhiNullQueue(),
+      (bookkeeper, device) => new RhiNullCommandEncoder(bookkeeper, device),
+    );
+    this.resolveLost = resolveLost;
+    this.lostPromise = lostPromise;
+  }
+
+  override get lost(): Promise<LostInfo> {
+    return this.lostPromise;
+  }
+
+  override createRenderPipeline(descriptor: RenderPipelineDescriptor) {
+    this.renderPipelineDescriptors.push(descriptor);
+    return super.createRenderPipeline(descriptor);
+  }
+
+  override createBindGroupLayout(descriptor: BindGroupLayoutDescriptor) {
+    this.bindGroupLayoutDescriptors.push(descriptor);
+    return super.createBindGroupLayout(descriptor);
+  }
+
+  override createSampler(descriptor?: SamplerDescriptor) {
+    this.samplerDescriptors.push(descriptor ?? {});
+    return super.createSampler(descriptor);
+  }
+
+  lose(): void {
+    this.resolveLost({ reason: 'unknown', message: 'AC-22 lifecycle recovery probe' });
+  }
+}
+
+class RecoverableNullAdapter implements RhiAdapter {
+  readonly features: ReadonlySet<GPUFeatureName> = new Set();
+  readonly limits: Readonly<Record<string, number>> = {};
+  readonly devices: RecoverableNullDevice[] = [];
+
+  requestDevice(): Promise<Result<RhiDevice, RhiError>> {
+    const device = new RecoverableNullDevice();
+    this.devices.push(device);
+    return Promise.resolve(ok(device));
+  }
+}
+
+function surfaceCanvas(width = 1920, height = 1080): HTMLCanvasElement {
+  return { width, height, getContext: () => null } as unknown as HTMLCanvasElement;
+}
+
+function densityAsset(): 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),
+  };
+}
+
+interface LedgerSnapshot {
+  readonly liveTextures: number;
+  readonly liveBuffers: number;
+  readonly liveHandles: number;
+}
+
+function snapshotLedger(device: RecoverableNullDevice): LedgerSnapshot {
+  const live = device.bookkeeper.allRecords().filter((record) => !record.destroyed);
+  return {
+    liveTextures: live.filter((record) => record.kind === 'Texture').length,
+    liveBuffers: live.filter((record) => record.kind === 'Buffer').length,
+    liveHandles: live.length,
+  };
+}
+
+async function persistAc22Receipt(receipt: unknown): Promise<void> {
+  const target = process.env.FORGEAX_AC22_RECEIPT;
+  if (target === undefined) return;
+  await mkdir(dirname(target), { recursive: true });
+  await writeFile(target, `${JSON.stringify(receipt, null, 2)}\n`);
+}
+
+describe('volumetric fog budget and recovery contract', () => {
+  it('keeps one active generation and bounded resources through 20 resizes', () => {
+    let signature = {
+      cameraRevision: 1,
+      fogRevision: 1,
+      lightRevision: 1,
+      densityGeneration: 4,
+      width: 320,
+      height: 180,
+    };
+    let resets = 0;
+    for (let index = 0; index < 20; index += 1) {
+      const next = { ...signature, width: 320 + index + 1, height: 180 + index + 1 };
+      const reset = resolveVolumeTemporalReset(signature, next);
+      expect(reset).toEqual({ reset: true, reason: 'resize' });
+      signature = next;
+      resets += 1;
+    }
+    const inspection = inspectVolumetricFog({
+      authored: true,
+      capability: 'available',
+      recovery: {
+        guid: '019f0000-0000-7000-8000-0000000003f1',
+        generation: signature.densityGeneration,
+        deviceEpoch: 0,
+        status: 'accepted',
+      },
+      acceptedDigest: 'sha256:volume',
+      format: 'r8unorm',
+      passCount: 1,
+      sampleCount: 1,
+      memoryBytes: 320 * 180 * 4,
+    });
+    expect(resets).toBe(20);
+    expect(inspection.generation).toBe(4);
+    expect(inspection.memoryBytes).toBeLessThanOrEqual(MAX_MEMORY_BYTES);
+    expect(inspection.passCount).toBe(1);
+    expect(inspection.sampleCount).toBe(1);
+  });
+
+  it('records three recovery transitions without zeroing unavailable timing evidence', () => {
+    const initial = {
+      guid: '019f0000-0000-7000-8000-0000000003f1',
+      generation: 4,
+      deviceEpoch: 0,
+      status: 'accepted' as const,
+    };
+    const candidate = stageVolumetricFog(initial, { generation: 5, digest: 'sha256:candidate' });
+    const lost = recoverVolumetricFog(candidate, { kind: 'device-lost', deviceEpoch: 1 });
+    const degraded = recoverVolumetricFog(lost, { kind: 'submit-failed' });
+    const stale = recoverVolumetricFog(degraded, { kind: 'accepted', generation: 5 });
+    const inspection = inspectVolumetricFog({
+      authored: true,
+      capability: 'available',
+      degraded: true,
+      recovery: stale,
+      acceptedDigest: 'sha256:accepted',
+      passCount: 1,
+      sampleCount: 1,
+      memoryBytes: 1024,
+    });
+    expect(stale.candidateFailure).toBe('stale-generation');
+    expect(inspection.resourceStage).toBe('lkg');
+    expect(inspection.memoryBytes).toBeGreaterThan(0);
+    expect(Number.isFinite(inspection.memoryBytes)).toBe(true);
+  });
+
+  it('derives high-profile bytes and samples from compiled descriptors', () => {
+    expect(
+      resolveVolumetricFogProfile({ volumetricFog: { quality: 'low', depth: 48, tileSize: 16 } }),
+    ).toEqual({
+      quality: 'low',
+      depth: 48,
+      tileSize: 16,
+    });
+    expect(deriveVolumetricFogExtent({ width: 1920, height: 1080 }, 48, 16)).toEqual({
+      width: 240,
+      height: 135,
+      depth: 48,
+    });
+    expect(deriveVolumetricFogExtent({ width: 1920, height: 1080 })).toEqual({
+      width: 960,
+      height: 540,
+      depth: 64,
+    });
+    expect(deriveVolumetricFogResolvedExtent({ width: 1920, height: 1080 }, 4)).toEqual({
+      width: 480,
+      height: 270,
+      depth: 1,
+    });
+    expect(deriveVolumetricFogResolvedExtent({ width: 1920, height: 1080 }, 16)).toEqual({
+      width: 240,
+      height: 135,
+      depth: 1,
+    });
+    const extent = { width: 960, height: 540, depthOrArrayLayers: 16 };
+    const graph = {
+      generation: 17,
+      passes: [],
+      resources: [
+        {
+          label: 'volume-froxel',
+          kind: 'texture',
+          origin: 'created',
+          descriptor: {
+            kind: 'texture',
+            format: 'rgba8unorm',
+            size: extent,
+            width: extent.width,
+            height: extent.height,
+            depthOrArrayLayers: extent.depthOrArrayLayers,
+            mipLevelCount: 1,
+            sampleCount: 1,
+          },
+          firstUse: 0,
+          lastUse: 1,
+          derivedUsage: 8,
+          format: 'rgba8unorm',
+          extent,
+          byteSize: 960 * 540 * 16 * 4,
+        },
+        {
+          label: 'volume-resolved-current',
+          kind: 'texture',
+          origin: 'created',
+          descriptor: {
+            kind: 'texture',
+            format: 'rgba16float',
+            size: { width: 960, height: 540, depthOrArrayLayers: 1 },
+            width: 960,
+            height: 540,
+            depthOrArrayLayers: 1,
+            mipLevelCount: 1,
+            sampleCount: 1,
+          },
+          firstUse: 1,
+          lastUse: 2,
+          derivedUsage: 8,
+          format: 'rgba16float',
+          extent: { width: 960, height: 540, depthOrArrayLayers: 1 },
+          byteSize: 960 * 540 * 8,
+        },
+        {
+          label: 'volume-history',
+          kind: 'texture',
+          origin: 'created',
+          descriptor: {
+            kind: 'texture',
+            format: 'rgba16float',
+            size: { width: 960, height: 540, depthOrArrayLayers: 1 },
+            width: 960,
+            height: 540,
+            depthOrArrayLayers: 1,
+            mipLevelCount: 1,
+            sampleCount: 1,
+          },
+          firstUse: 1,
+          lastUse: 3,
+          derivedUsage: 8,
+          format: 'rgba16float',
+          extent: { width: 960, height: 540, depthOrArrayLayers: 1 },
+          byteSize: 960 * 540 * 8,
+        },
+        {
+          label: 'volume-temporal',
+          kind: 'texture',
+          origin: 'created',
+          descriptor: {
+            kind: 'texture',
+            format: 'rgba16float',
+            size: { width: 960, height: 540, depthOrArrayLayers: 1 },
+            width: 960,
+            height: 540,
+            depthOrArrayLayers: 1,
+            mipLevelCount: 1,
+            sampleCount: 1,
+          },
+          firstUse: 1,
+          lastUse: 3,
+          derivedUsage: 8,
+          format: 'rgba16float',
+          extent: { width: 960, height: 540, depthOrArrayLayers: 1 },
+          byteSize: 960 * 540 * 8,
+        },
+        {
+          label: 'volume-params',
+          kind: 'buffer',
+          origin: 'imported',
+          descriptor: { kind: 'buffer', size: 128 },
+          firstUse: 0,
+          lastUse: 3,
+          derivedUsage: 64,
+          byteSize: 128,
+        },
+      ],
+    } as const;
+    const facts = inspectVolumetricFogResources(graph);
+    expect(facts.generation).toBe(17);
+    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.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(
+      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.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(
+      doubleBuffered.currentBytes +
+        doubleBuffered.historyBytes +
+        doubleBuffered.scratchBytes +
+        doubleBuffered.bufferBytes,
+    );
+  });
+
+  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);
+    if (!adapter.ok) return;
+    const createdDevice = await adapter.value.requestDevice();
+    expect(createdDevice.ok).toBe(true);
+    if (!createdDevice.ok) return;
+    const graph = new RenderGraphBuilder<RenderPipelineFrame>();
+    const resources = createVolumetricFogResources(graph, { width: 960, height: 540, depth: 64 });
+    expect(resources.ok).toBe(true);
+    if (!resources.ok) return;
+    const compiled = graph.compile({
+      device: createdDevice.value,
+      surfaceSize: { width: 1920, height: 1080 },
+    });
+    expect(compiled.ok).toBe(true);
+    if (!compiled.ok) return;
+    const resolved = compiled.value
+      .inspect()
+      .resources.find((resource) => resource.label === 'volume-resolved-current');
+    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 () => {
+    const adapter = new RecoverableNullAdapter();
+    const backend = {
+      ...nullRhi,
+      requestAdapter: async () => ok(adapter),
+    };
+    const canvas = surfaceCanvas();
+    const created = await constructRendererHost(
+      canvas,
+      { 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 directionalLight = world
+      .spawn({
+        component: DirectionalLight,
+        data: { direction: [-0.4, -0.8, -0.3], castShadow: true },
+      })
+      .unwrap();
+    world
+      .spawn({
+        component: VolumetricFog,
+        data: {
+          light: directionalLight,
+          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();
+    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;
+    const draw = async () => {
+      const frame = renderer.draw(request);
+      expect(frame.ok).toBe(true);
+      if (!frame.ok) return undefined;
+      expect((await frame.value.completed).ok).toBe(true);
+      return renderer.inspect();
+    };
+
+    const initial = await draw();
+    expect(initial?.volumetricFog).toMatchObject({
+      status: 'available',
+      resourceStage: 'accepted',
+      passCount: 4,
+    });
+    const initialFacts = initial?.volumetricFog?.resourceFacts;
+    expect(initialFacts).toBeDefined();
+    if (initialFacts === undefined) return;
+    const warmup = await draw();
+    expect(warmup?.volumetricFog).toMatchObject({ status: 'available', passCount: 4 });
+    const warmedFacts = warmup?.volumetricFog?.resourceFacts;
+    expect(warmedFacts).toBeDefined();
+    if (warmedFacts === undefined) return;
+    const compositeDescriptors = adapter.devices[0]?.renderPipelineDescriptors.filter(
+      (descriptor) => descriptor.label === 'volume_composite',
+    );
+    expect(compositeDescriptors?.length).toBeGreaterThan(0);
+    expect(
+      compositeDescriptors?.every(
+        (descriptor) => descriptor.fragment?.targets[0]?.format === 'rgba16float',
+      ),
+    ).toBe(true);
+    expect(
+      adapter.devices[0]?.bindGroupLayoutDescriptors.find(
+        (descriptor) => descriptor.label === 'volume_composite.bind-group-layout',
+      )?.entries,
+    ).toEqual([
+      {
+        binding: 0,
+        visibility: 3,
+        texture: { sampleType: 'float', viewDimension: '2d' },
+      },
+      { binding: 1, visibility: 3, sampler: { type: 'filtering' } },
+      { binding: 2, visibility: 3, texture: { sampleType: 'depth', viewDimension: '2d' } },
+      { binding: 3, visibility: 3, buffer: { type: 'uniform' } },
+    ]);
+    expect(
+      adapter.devices[0]?.samplerDescriptors.find(
+        (descriptor) => descriptor.label === 'volume_composite.sampler',
+      ),
+    ).toMatchObject({ minFilter: 'linear', magFilter: 'linear' });
+    expect(
+      adapter.devices[0]?.samplerDescriptors.find(
+        (descriptor) => descriptor.label === 'volume_inject.density-sampler',
+      ),
+    ).toBeUndefined();
+    const initialLedger = snapshotLedger(adapter.devices[0] as RecoverableNullDevice);
+    expect(initialFacts.totalBytes).toBeLessThanOrEqual(MAX_MEMORY_BYTES);
+    expect(initialFacts.liveResourceCount).toBe(5);
+    expect(initialFacts.physicalResourceCount).toBe(5);
+    expect(warmedFacts.liveResourceCount).toBe(6);
+    expect(warmedFacts.physicalResourceCount).toBe(6);
+    expect(snapshotLedger(adapter.devices[0] as RecoverableNullDevice).liveTextures).toBe(
+      initialLedger.liveTextures,
+    );
+    expect(snapshotLedger(adapter.devices[0] as RecoverableNullDevice).liveBuffers).toBe(
+      initialLedger.liveBuffers,
+    );
+    const resizeFacts: Array<{
+      readonly deviceGeneration: number;
+      readonly volumeGeneration: number | undefined;
+      readonly graphGeneration: number;
+      readonly liveResourceCount: number;
+      readonly totalBytes: number;
+      readonly physicalResourceCount: number;
+    }> = [];
+    for (let index = 0; index < 20; index += 1) {
+      canvas.width = 1921 + index;
+      canvas.height = 1081 + index;
+      const inspection = await draw();
+      const facts = inspection?.volumetricFog?.resourceFacts;
+      expect(facts).toBeDefined();
+      if (facts === undefined || inspection === undefined) return;
+      resizeFacts.push({
+        deviceGeneration: inspection.frame.deviceGeneration,
+        volumeGeneration: inspection.volumetricFog?.generation,
+        graphGeneration: facts.generation,
+        liveResourceCount: facts.liveResourceCount,
+        totalBytes: facts.totalBytes,
+        physicalResourceCount: facts.physicalResourceCount,
+      });
+      expect(inspection.volumetricFog).toMatchObject({ status: 'available', passCount: 4 });
+      expect(facts.liveResourceCount).toBe(6);
+      expect(facts.physicalResourceCount).toBe(6);
+      expect(facts.totalBytes).toBeLessThanOrEqual(MAX_MEMORY_BYTES);
+      const ledger = snapshotLedger(adapter.devices[0] as RecoverableNullDevice);
+      expect(ledger.liveTextures).toBe(initialLedger.liveTextures);
+      expect(ledger.liveBuffers).toBe(initialLedger.liveBuffers);
+    }
+
+    const recoveryGenerations: number[] = [];
+    const recoveryLedgers: LedgerSnapshot[] = [];
+    for (let index = 0; index < 3; index += 1) {
+      const device = adapter.devices.at(-1);
+      expect(device).toBeDefined();
+      if (device === undefined) return;
+      device.lose();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      expect(renderer.state()).toBe('device-lost');
+      expect(renderer.draw(request).ok).toBe(false);
+      const recovered = await renderer.recover();
+      expect(recovered.ok).toBe(true);
+      expect(renderer.state()).toBe('alive');
+      const firstAfterRecovery = await draw();
+      expect(firstAfterRecovery?.volumetricFog).toMatchObject({
+        status: 'available',
+        passCount: 4,
+      });
+      const firstFacts = firstAfterRecovery?.volumetricFog?.resourceFacts;
+      expect(firstFacts).toBeDefined();
+      if (firstFacts === undefined || firstAfterRecovery === undefined) return;
+      expect(firstFacts.liveResourceCount).toBe(5);
+      expect(firstFacts.physicalResourceCount).toBe(5);
+      expect(firstFacts.totalBytes).toBeLessThanOrEqual(MAX_MEMORY_BYTES);
+      const inspection = await draw();
+      expect(inspection?.volumetricFog).toMatchObject({ status: 'available', passCount: 4 });
+      const facts = inspection?.volumetricFog?.resourceFacts;
+      expect(facts).toBeDefined();
+      if (facts === undefined || inspection === undefined) return;
+      recoveryGenerations.push(inspection.frame.deviceGeneration);
+      expect(facts.liveResourceCount).toBe(6);
+      expect(facts.physicalResourceCount).toBe(6);
+      expect(facts.totalBytes).toBeLessThanOrEqual(MAX_MEMORY_BYTES);
+      recoveryLedgers.push(snapshotLedger(adapter.devices.at(-1) as RecoverableNullDevice));
+    }
+    expect(adapter.devices).toHaveLength(4);
+    expect(new Set(recoveryGenerations).size).toBe(3);
+    expect(recoveryGenerations[2]).toBeGreaterThan(recoveryGenerations[0] ?? -1);
+
+    const steadyFacts: Array<{
+      readonly deviceGeneration: number;
+      readonly volumeGeneration: number | undefined;
+      readonly graphGeneration: number;
+      readonly liveResourceCount: number;
+      readonly totalBytes: number;
+      readonly physicalResourceCount: number;
+    }> = [];
+    for (let frame = 0; frame < 300; frame += 1) {
+      const inspection = await draw();
+      const facts = inspection?.volumetricFog?.resourceFacts;
+      expect(facts).toBeDefined();
+      if (facts === undefined || inspection === undefined) return;
+      steadyFacts.push({
+        deviceGeneration: inspection.frame.deviceGeneration,
+        volumeGeneration: inspection.volumetricFog?.generation,
+        graphGeneration: facts.generation,
+        liveResourceCount: facts.liveResourceCount,
+        totalBytes: facts.totalBytes,
+        physicalResourceCount: facts.physicalResourceCount,
+      });
+    }
+    const steadyBaseline = steadyFacts[0];
+    expect(steadyBaseline).toBeDefined();
+    if (steadyBaseline === undefined) return;
+    for (const facts of steadyFacts) expect(facts).toEqual(steadyBaseline);
+    expect(new Set(resizeFacts.map((facts) => facts.liveResourceCount)).size).toBe(1);
+    expect(new Set(resizeFacts.map((facts) => facts.physicalResourceCount)).size).toBe(1);
+    expect(new Set(resizeFacts.map((facts) => facts.deviceGeneration)).size).toBe(1);
+    expect(new Set(resizeFacts.map((facts) => facts.volumeGeneration)).size).toBe(1);
+    expect(new Set(resizeFacts.map((facts) => facts.graphGeneration)).size).toBe(20);
+    expect(steadyBaseline.liveResourceCount).toBe(6);
+    expect(steadyBaseline.physicalResourceCount).toBe(6);
+    expect(steadyBaseline.totalBytes).toBeLessThanOrEqual(MAX_MEMORY_BYTES);
+    const steadyLedger = snapshotLedger(adapter.devices.at(-1) as RecoverableNullDevice);
+    expect(steadyLedger.liveTextures).toBeGreaterThan(0);
+    expect(steadyLedger.liveBuffers).toBeGreaterThan(0);
+    for (const ledger of recoveryLedgers) {
+      expect(ledger.liveTextures).toBe(steadyLedger.liveTextures);
+      expect(ledger.liveBuffers).toBe(steadyLedger.liveBuffers);
+    }
+    await persistAc22Receipt({
+      schemaVersion: '1',
+      head: execFileSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8' }).trim(),
+      runnerClass: 'null-structural',
+      source: 'renderer.inspect+RhiNull.bookkeeper',
+      resizeCount: resizeFacts.length,
+      resizeFacts,
+      recoveryCount: recoveryGenerations.length,
+      recoveryGenerations,
+      steadyFrameCount: steadyFacts.length,
+      steadyFirst: steadyFacts[0],
+      steadyLast: steadyFacts.at(-1),
+      resourceBudgetBytes: MAX_MEMORY_BYTES,
+      activeLedger: steadyLedger,
+    });
+    await renderer.dispose();
+  });
+});