@forgeax/engine-render 0.1.19 → 0.1.21

package/src/render-system.ts

@@ -21,10 +21,21 @@ import type { World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
 import type { RecorderSession } from '@forgeax/engine-profiler';
 import type { CompiledRenderGraphInfo } from '@forgeax/engine-render-graph';
-import type { BindGroupEntry, BindGroupLayout, Buffer, RenderPipeline } from '@forgeax/engine-rhi';
+import type {
+  BindGroup,
+  BindGroupEntry,
+  BindGroupLayout,
+  Buffer,
+  RenderPipeline,
+  Sampler,
+  Texture,
+  TextureFormat,
+  TextureView,
+} from '@forgeax/engine-rhi';
 import { err, ok, type Result, RhiError } from '@forgeax/engine-rhi';
 import {
   derive,
+  deriveTextureLayout,
   type Handle,
   type MaterialAsset,
   type MaterialTextureValue,
@@ -32,8 +43,14 @@ import {
   type RenderPipelineAsset,
   RenderQueue,
   type SamplerAsset,
+  type TextureAsset,
   toShared,
 } from '@forgeax/engine-types';
+import {
+  type DirectionalShadowInspectionSource,
+  directionalShadowProfileFromQuality,
+  projectDirectionalShadowInspectionSource,
+} from './assembly/directional-shadow-inspection';
 import { createClusterBinScratch } from './cluster-binner';
 import { EnvironmentLifecycle } from './environment/lifecycle';
 import {
@@ -57,11 +74,17 @@ import {
   DEPTH_MIN_PARAMS_BYTE_SIZE,
   entryHasDepthRead,
   type PostProcessShaderEntry,
+  postProcessShaderEntrySignature,
+  postProcessShaderModuleLabel,
+  postProcessShaderPipelineLabel,
 } from './fullscreen-post-process-pass';
 import { GpuDrivenProduction } from './gpu-driven/production-raster';
 import type {
   BloomInspection,
+  DirectionalShadowInspection,
   MotionBlurInspection,
+  ReflectionProbeInspection,
+  ReflectionProbeSelectionInspection,
   RenderSceneInspection,
   TemporalTargetInspection,
   TransmissionInspection,
@@ -80,33 +103,59 @@ import {
 import { createPointsLinesLaneAdapter, type PointsLinesBackend } from './points-lines/record';
 import type { PointsLinesRetainedSnapshot } from './points-lines/snapshot';
 import type { PointsLinesRecordOwner, PointsLinesRecordSubmission } from './record/render-context';
+import { inspectVolumetricFog } from './volume/inspection';
 
 export type { RenderSceneInspection } from './inspection-types';
 
 import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
+import { mat4, vec3 } from '@forgeax/engine-math';
+import { buildCubeCameraFaceViews } from './capture/cube-views';
+import { createCubeCaptureScheduler } from './capture/scheduler';
+import {
+  createFaceUniformsBuffer,
+  createPrefilterUniformsBuffer,
+  writeAllFaceUniforms,
+  writeAllPrefilterUniforms,
+} from './device/gpu-residency';
 import type { EnvironmentInspection } from './environment/inspection';
+import {
+  GPU_TEXTURE_USAGE_COPY_SRC,
+  GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING,
+} from './gpu-texture-usage';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_INDEX,
   GPU_BUFFER_USAGE_UNIFORM,
   GPU_BUFFER_USAGE_VERTEX,
 } from './gpu-usage';
+import { resetHdrpBuffers } from './hdrp-buffers';
+import {
+  CUBEMAP_FACE_VERTICES,
+  createIblPipelines,
+  getOrCreateIblCache,
+  PREFILTER_MIP_LEVELS,
+  PREFILTER_SIZE,
+} from './ibl/IblPipelineCache';
 import { assembleMaterialWithSkylightEntries } from './ibl/skylight-bind-group';
 import { disposeInstanceBuffers, disposeTransientInstanceBuffers } from './instance-buffer-cache';
-import type { MeshMaterialBindingObservation } from './mesh-material-bindings';
-import { validateClusterGrid } from './pipeline/standard-pipeline';
 import {
-  DEFAULT_CLUSTER_GRID,
-  DEFAULT_STANDARD_PROFILE,
-  resolveStandardLane,
-} from './pipeline/standard-profile';
+  type MeshMaterialBindingObservation,
+  type MeshMaterialBindingPreparationFailure,
+  type MeshMaterialBindingResidency,
+  projectMeshMaterialBindingObservation,
+} from './mesh-material-bindings';
+import type { StandardLightingInspection } from './pipeline/standard-lighting/inspection';
+import { validateClusterGrid } from './pipeline/standard-pipeline';
+import { DEFAULT_CLUSTER_GRID } from './pipeline/standard-profile';
 import { PipelineSpecError } from './pipeline-spec';
+import type { PointShadowInspection } from './point-shadow-inspection';
 import { PostProcessError } from './post-process-errors';
 import {
   createPreparedGraphicsResolver,
   type PreparedGraphicsResolver,
 } from './prepare/prepared-graphics-resolver';
 import {
+  type CubeCaptureFrameInput,
   type FrameObservation,
   type FrameObservationOptions,
   observeCurrentFrame,
@@ -120,12 +169,35 @@ import type {
   RenderFrameState,
 } from './record/frame-snapshot';
 import { getTextureIdentity } from './record/frame-snapshot';
+import type { GpuPassTimingReason } from './record/gpu-pass-timing/errors';
+import type {
+  GpuPassTimingCapture,
+  GpuPassTimingFrameIdentity,
+  GpuPassTimingSession,
+} from './record/gpu-pass-timing/session';
+import type { GpuTimingCapture } from './record/gpu-timing';
 import { applyParamSnapshotToUbo, residentTextureView } from './record/main-pass-material';
-import type { RenderSystemInternals } from './record/render-context';
+import type { ReflectionProbeRecordState, RenderSystemInternals } from './record/render-context';
+import type { CubeCaptureGraphState, ReflectionProbeGraphWork } from './record/typed-frame-graph';
 import {
   type RenderFeatureGraphCandidate,
   resetRenderFeatureGraphState,
+  settleVolumetricFogGraphCandidate,
 } from './record/typed-frame-graph';
+import { REFLECTION_PROBE_VIEW_SLOT_BASE, VIEW_UNIFORM_SLOT_STRIDE } from './record/view-ubo';
+import {
+  advanceProbeFilter,
+  commitProbeFilterStep,
+  createProbeFilterState,
+  type ProbeFilterState,
+} from './reflection/filter';
+import { buildReflectionProbeTable } from './reflection/gpu-table';
+import {
+  admitReflectionProbe,
+  DEFAULT_REFLECTION_PROBE_LIMITS,
+  type ReflectionProbeFact,
+  type ReflectionProbeSelectionResult,
+} from './reflection/projection';
 import {
   type CameraSnapshot,
   type DrawOwnerOptions,
@@ -134,7 +206,13 @@ import {
   type RenderPhaseSkipReason,
   type RenderRecordPhase,
 } from './render-contract';
-import type { DispatchEntry, ExtractedFrame, RenderableSnapshot } from './render-system-extract';
+import type {
+  DispatchEntry,
+  ExtractedFrame,
+  ExtractedLights,
+  MaterialSnapshot,
+  RenderableSnapshot,
+} from './render-system-extract';
 import { extractFrames } from './render-system-extract';
 import { PersistentRenderScene } from './scene/render-scene';
 import { resolveSsaoParameters } from './ssao-config';
@@ -145,6 +223,8 @@ import {
   TRANSPARENT_SORT_MODE_LAYER_YZ,
   TRANSPARENT_SORT_MODE_LAYER_Z,
 } from './systems/transparent-sort-config';
+import type { RenderTarget } from './targets/contracts';
+import { createTemporalFrameTransaction, type TemporalFrame } from './temporal/frame';
 import { retireTemporalGpuState } from './temporal/gpu';
 import { inspectTemporal, type TemporalInspection } from './temporal/inspection';
 import {
@@ -159,6 +239,21 @@ import {
   inspectTransmissionFromAdmission,
 } from './transmission/inspection';
 
+type TimingSessionHost = RenderSystemInternals & {
+  gpuPassTimingSession?: GpuPassTimingSession | undefined;
+  gpuPassTimingCapture?: GpuPassTimingCapture | undefined;
+  gpuPassTimingFrameIdentity?: GpuPassTimingFrameIdentity | undefined;
+  gpuPassTimingBeginReason?: GpuPassTimingReason | undefined;
+};
+
+/** Attach the Render-owned timing session without widening the public renderer surface. */
+export function attachGpuPassTimingSession(
+  internals: object,
+  session: GpuPassTimingSession | undefined,
+): void {
+  (internals as TimingSessionHost).gpuPassTimingSession = session;
+}
+
 export type {
   _InternalRenderPipelineContext,
   _StandardForwardSceneView,
@@ -325,6 +420,7 @@ export interface RenderSystem {
     worlds: readonly World[],
     opts: DrawOwnerOptions,
     renderReadLeases?: readonly RenderReadLease[],
+    timingCapture?: GpuTimingCapture,
   ): boolean;
   /** Release renderer-owned persistent state for one detached World. */
   detachScene(world: World): void;
@@ -349,6 +445,9 @@ export interface RenderSystem {
   readonly visibilityStats: { explicitlyHidden: number };
   /** Persistent scene maintenance evidence from the ordinary single-World path. */
   readonly renderScene: RenderSceneInspection;
+  readonly reflectionProbes: ReflectionProbeInspection;
+  /** True while a progressive CubeCamera candidate still owns unfinished faces. */
+  isCubeCapturePending(target: RenderTarget): boolean;
   readonly environment: EnvironmentInspection;
   readonly temporal: TemporalInspection;
   readonly bloom: BloomInspection;
@@ -356,6 +455,12 @@ export interface RenderSystem {
   readonly temporalTargetInspection: TemporalTargetInspection | undefined;
   /** Last completed transmission candidate facts, detached from GPU handles. */
   readonly transmission: TransmissionInspection | undefined;
+  /** Single production projection of Directional author/extract/record facts. */
+  readonly directionalShadow: DirectionalShadowInspection;
+  /** Last prepared Standard transport facts, detached from GPU handles. */
+  readonly standardLightingInspection: StandardLightingInspection | undefined;
+  /** Last submitted point-shadow atlas budget facts, detached from GPU handles. */
+  readonly pointShadowInspection: PointShadowInspection | undefined;
   /** Retained Points/Lines authoring facts from the single scene projection. */
   readonly pointsLinesSnapshots: readonly PointsLinesRetainedSnapshot[];
   /** Current mesh-slot provenance and active diagnostics from the last frame. */
@@ -392,6 +497,10 @@ export interface RenderSystem {
     readonly createBindGroup: number;
     readonly keys: readonly string[];
   };
+  /** Latest accepted-submit temporal POD; absent until the first accepted frame. */
+  readonly temporalFrame: TemporalFrame | undefined;
+  /** Current renderer-owned volumetric fog inspection snapshot. */
+  readonly volumetricFog: import('./volume/inspection').VolumetricFogInspection;
   /** Configure the sole Standard graph owner before the first frame. */
   configureStandard(config: RenderPipelineAsset['config']): void;
   /** Register one engine-owned post-process shader used by the Standard lane. */
@@ -483,6 +592,175 @@ type PointsLinesGpuResources = {
 };
 type PointsLinesPreparationAdapter = PointsLinesLanePreparationAdapter<PointsLinesGpuResources>;
 
+function preparationFailureFrom(error: unknown): MeshMaterialBindingPreparationFailure | undefined {
+  if (typeof error !== 'object' || error === null) return undefined;
+  const value = error as {
+    readonly code?: unknown;
+    readonly expected?: unknown;
+    readonly hint?: unknown;
+    readonly detail?: unknown;
+  };
+  if (
+    typeof value.code !== 'string' ||
+    typeof value.expected !== 'string' ||
+    typeof value.hint !== 'string'
+  ) {
+    return undefined;
+  }
+  const detail =
+    typeof value.detail === 'object' && value.detail !== null
+      ? { ...(value.detail as Record<string, unknown>) }
+      : undefined;
+  return {
+    code: value.code,
+    expected: value.expected,
+    hint: value.hint,
+    ...(detail === undefined ? {} : { detail }),
+  };
+}
+
+function materialTextureHandles(
+  material: MaterialSnapshot,
+): readonly Handle<'TextureAsset', 'shared'>[] {
+  const handles = new Map<number, Handle<'TextureAsset', 'shared'>>();
+  const add = (handle: Handle<'TextureAsset', 'shared'> | undefined): void => {
+    if (handle !== undefined) handles.set(Number(handle), handle);
+  };
+  for (const handle of material.textureHandles?.values() ?? []) add(handle);
+  add(material.baseColorTexture);
+  add(material.metallicRoughnessTexture);
+  add(material.normalTexture);
+  add(material.emissiveTexture);
+  add(material.occlusionTexture);
+  return [...handles.values()];
+}
+
+function materialSamplerHandles(
+  material: MaterialSnapshot,
+): readonly Handle<'SamplerAsset', 'shared'>[] {
+  const handles = new Map<number, Handle<'SamplerAsset', 'shared'>>();
+  for (const handle of material.samplerHandles?.values() ?? []) {
+    handles.set(Number(handle), handle);
+  }
+  return [...handles.values()];
+}
+
+/**
+ * Project the producer-owned material and GPU store state into the one
+ * renderer observation surface. This is intentionally recomputed from the
+ * current frame's detached material snapshots; no readiness map is retained
+ * by RenderSystem. A producer failure with an already resident resource is
+ * reported as last-known-good, preserving recovery context without copying
+ * the producer's lifecycle state.
+ */
+function observeMaterialResidency(
+  world: World | undefined,
+  material: MaterialSnapshot,
+  internals: RenderSystemInternals,
+): MeshMaterialBindingResidency {
+  const textures: Array<{ readonly handle: number; readonly mipLevelCount: number }> = [];
+  const samplers: Array<{ readonly handle: number; readonly resident: boolean }> = [];
+  let pending = false;
+  let resident = false;
+  let failure: MeshMaterialBindingPreparationFailure | undefined;
+  const keepFailure = (error: unknown): void => {
+    if (failure === undefined) failure = preparationFailureFrom(error);
+  };
+
+  if (world === undefined) {
+    pending = true;
+  } else {
+    const materialHandle = material.materialHandle;
+    if (materialHandle !== undefined && materialHandle !== 0) {
+      const materialResult = resolveAssetHandle<MaterialAsset>(
+        world,
+        toShared<'MaterialAsset'>(materialHandle),
+      );
+      if (!materialResult.ok) {
+        keepFailure(materialResult.error);
+      } else {
+        const guid = internals.assets.guidOf(materialResult.value);
+        if (guid !== undefined) {
+          const readiness = internals.assets.getMaterialReadiness(guid);
+          if (readiness?.status === 'Error') keepFailure(readiness.error);
+          const load = internals.assets.loadState.get(guid);
+          if (load?.status === 'provisional') pending = true;
+        }
+      }
+    }
+
+    for (const handle of materialTextureHandles(material)) {
+      const existing = internals.gpuStore.getTextureGpuView(handle, world);
+      const pod = resolveAssetHandle<TextureAsset>(world, handle);
+      if (!pod.ok) {
+        keepFailure(pod.error);
+        continue;
+      }
+      let view = existing;
+      if (view === undefined) {
+        const prepared = internals.gpuStore.ensureResident(handle, pod.value, world);
+        if (!prepared.ok) keepFailure(prepared.error);
+        view = internals.gpuStore.getTextureGpuView(handle, world);
+      }
+      if (view === undefined) {
+        pending = failure === undefined;
+        continue;
+      }
+      const textureLayout = deriveTextureLayout({
+        shape: pod.value.shape,
+        format: pod.value.format,
+        mips: pod.value.mips,
+      });
+      if (!textureLayout.ok) {
+        keepFailure(textureLayout.error);
+        continue;
+      }
+      resident = true;
+      textures.push({
+        handle: Number(handle),
+        mipLevelCount: Math.max(1, textureLayout.value.levels.length),
+      });
+    }
+
+    for (const handle of materialSamplerHandles(material)) {
+      const pod = resolveAssetHandle<SamplerAsset>(world, handle);
+      if (!pod.ok) {
+        keepFailure(pod.error);
+        samplers.push({ handle: Number(handle), resident: false });
+        continue;
+      }
+      const prepared = internals.gpuStore.ensureSamplerResident(handle, pod.value, world);
+      if (!prepared.ok) {
+        keepFailure(prepared.error);
+        samplers.push({ handle: Number(handle), resident: false });
+      } else {
+        resident = true;
+        samplers.push({ handle: Number(handle), resident: true });
+      }
+    }
+    // Video views are supplied by the dynamic host store at record time. They
+    // are not static TextureAsset residents, so this bounded projection stays
+    // pending until a dynamic observation contract exists rather than guessing
+    // from the VideoAsset GUID.
+    if ((material.videoTextureFields?.size ?? 0) > 0) pending = true;
+  }
+
+  const readiness =
+    failure === undefined
+      ? pending
+        ? 'pending'
+        : 'ready'
+      : resident
+        ? 'last-known-good'
+        : 'failed';
+  return {
+    readiness,
+    samplers,
+    textures,
+    ...(failure === undefined ? {} : { preparationFailure: failure }),
+  };
+}
+
 /**
  * The Standard renderer's single Points/Lines prepare owner.
  *
@@ -744,6 +1022,551 @@ class StandardPointsLinesOwner implements PointsLinesRecordOwner {
   }
 }
 
+type ProbeCubeSet = {
+  readonly texture: Texture;
+  readonly cubeView: TextureView;
+  readonly faceViews: readonly TextureView[];
+  readonly mipViews: readonly (readonly TextureView[])[];
+  readonly depthTexture: Texture;
+  readonly depthView: TextureView;
+  readonly size: number;
+};
+
+type ProbeGpuResource = {
+  fact: ReflectionProbeFact;
+  index: number;
+  filter: ProbeFilterState;
+  rawFaceCursor: number;
+  readonly raw: ProbeCubeSet;
+  active: ProbeCubeSet | undefined;
+  candidate: ProbeCubeSet;
+  spare: ProbeCubeSet | undefined;
+  readonly sampler: Sampler;
+  readonly uniformBuffer: Buffer;
+  readonly filterGroup1: BindGroup;
+  pending?: {
+    readonly rawCaptureFace: number | undefined;
+    readonly step: ReturnType<typeof advanceProbeFilter>;
+  };
+};
+
+type ProbeSharedResources = {
+  readonly faceUniforms: Buffer;
+  readonly prefilterUniforms: Buffer;
+  readonly vertexBuffer: Buffer;
+  readonly sampler: Sampler;
+  readonly filterPipeline: RenderPipeline;
+  readonly cubeGroup1Bgl: BindGroupLayout;
+  readonly prefilterGroup0Bgl: BindGroupLayout;
+};
+
+/** Renderer-owned raw capture and incremental PMREM/LKG promotion owner. */
+class ReflectionProbeRecordOwner {
+  private readonly resources = new Map<string, ProbeGpuResource>();
+  private shared: ProbeSharedResources | undefined;
+  private pipelineWarmup: Promise<void> | undefined;
+  private pipelineWarmupFailure: string | undefined;
+  private pipelineWarmupAttempts = 0;
+  private lastFactCount = 0;
+  private lastAcceptedCount = 0;
+  private lastScheduledRawFaces = 0;
+  private lastScheduledFilteredSteps = 0;
+  private lastSelection: ReflectionProbeSelectionInspection = { kind: 'skylight' };
+  private readonly outputFormat: TextureFormat;
+
+  constructor(private readonly internals: RenderSystemInternals) {
+    this.outputFormat = internals.device.caps.rgba16floatRenderable ? 'rgba16float' : 'rgba8unorm';
+  }
+
+  inspect(): ReflectionProbeInspection {
+    let rawFacesCaptured = 0;
+    let filteredStepsCompleted = 0;
+    const filteredMipLevels = new Set<number>();
+    let activeCount = 0;
+    for (const resource of this.resources.values()) {
+      rawFacesCaptured += resource.rawFaceCursor;
+      filteredStepsCompleted += resource.filter.cursor;
+      const completedMipCount = Math.min(
+        PREFILTER_MIP_LEVELS,
+        Math.floor(resource.filter.cursor / resource.filter.faceCount),
+      );
+      for (let mip = 0; mip < completedMipCount; mip += 1) filteredMipLevels.add(mip);
+      if (resource.active !== undefined) activeCount += 1;
+    }
+    return {
+      selection: this.lastSelection,
+      factCount: this.lastFactCount,
+      acceptedCount: this.lastAcceptedCount,
+      activeCount,
+      rawFacesCaptured,
+      filteredStepsCompleted,
+      filteredMipLevels: [...filteredMipLevels].sort((a, b) => a - b),
+      scheduledRawFaces: this.lastScheduledRawFaces,
+      scheduledFilteredSteps: this.lastScheduledFilteredSteps,
+      pipelineReady: this.shared !== undefined,
+      pipelineWarmupAttempts: this.pipelineWarmupAttempts,
+      ...(this.pipelineWarmupFailure === undefined
+        ? {}
+        : { pipelineWarmupFailure: this.pipelineWarmupFailure }),
+    };
+  }
+
+  private ensurePipelineWarmup(): void {
+    if (this.shared !== undefined || this.pipelineWarmup !== undefined) return;
+    const factory = this.internals.shaderModuleFactory;
+    if (factory === undefined) return;
+    const attempt = this.pipelineWarmupAttempts + 1;
+    this.pipelineWarmupAttempts = attempt;
+    this.pipelineWarmup = createIblPipelines(
+      this.internals.deviceScope,
+      this.internals.device,
+      (device, descriptor) => {
+        const labeled = {
+          ...descriptor,
+          label: `${descriptor.label ?? 'ibl'}-reflection-probe-${attempt}`,
+        };
+        return this.internals.createShaderModule === undefined
+          ? Promise.resolve(factory.createShaderModule(labeled))
+          : this.internals.createShaderModule(device, labeled);
+      },
+      this.outputFormat,
+    ).then((result) => {
+      if (!result.ok) {
+        this.pipelineWarmupFailure = `${result.error.code}: ${result.error.hint}`;
+        console.warn('[forgeax] ReflectionProbe IBL warmup retry', this.pipelineWarmupFailure);
+        this.pipelineWarmup = undefined;
+        return;
+      }
+      this.shared = this.createSharedResources(result.value.prefilterPipeline);
+      if (this.shared === undefined) {
+        this.pipelineWarmupFailure = 'renderer-owned IBL resources could not be allocated';
+        console.warn('[forgeax] ReflectionProbe IBL resource allocation retry');
+        this.pipelineWarmup = undefined;
+      }
+    });
+  }
+
+  prepare(
+    facts: readonly ReflectionProbeFact[],
+    selections: ReadonlyMap<string, ReflectionProbeSelectionResult>,
+    displayCamera: CameraSnapshot | undefined,
+  ): ReflectionProbeRecordState {
+    this.lastFactCount = facts.length;
+    this.lastScheduledRawFaces = 0;
+    this.lastScheduledFilteredSteps = 0;
+    const selectedProbe = [...selections.values()]
+      .filter(
+        (selection): selection is Extract<ReflectionProbeSelectionResult, { kind: 'probe' }> =>
+          selection.kind === 'probe',
+      )
+      .sort((a, b) => a.worldId - b.worldId || a.entityKey - b.entityKey)[0];
+    this.lastSelection =
+      selectedProbe === undefined
+        ? { kind: 'skylight' }
+        : { kind: 'probe', worldId: selectedProbe.worldId, entityKey: selectedProbe.entityKey };
+    if (facts.length > 0) this.ensurePipelineWarmup();
+    void this.pipelineWarmup;
+    const ordered = facts
+      .slice()
+      .sort((a, b) => a.worldId - b.worldId || a.entityKey - b.entityKey);
+    let acceptedCount = 0;
+    let acceptedBytes = 0;
+    const accepted = new Map<string, ProbeGpuResource>();
+    for (const fact of ordered) {
+      const admission = admitReflectionProbe(
+        fact,
+        { acceptedCount, acceptedBytes },
+        DEFAULT_REFLECTION_PROBE_LIMITS,
+      );
+      if (!admission.ok) continue;
+      const key = `${fact.worldId}:${fact.entityKey}`;
+      const resource = this.resourceFor(key, fact, acceptedCount);
+      if (resource === undefined) continue;
+      acceptedCount += 1;
+      acceptedBytes = admission.acceptedBytes;
+      accepted.set(key, resource);
+    }
+    for (const [key, resource] of this.resources) {
+      if (!accepted.has(key)) {
+        this.destroyProbeResource(resource);
+        this.resources.delete(key);
+      } else resource.index = [...accepted.keys()].indexOf(key);
+    }
+    const rows = [...accepted.values()]
+      .map((resource) => {
+        const active = resource.active;
+        if (active === undefined) return undefined;
+        return {
+          primitiveKey: `${resource.fact.worldId}:${resource.fact.entityKey}`,
+          index: resource.index,
+          worldId: resource.fact.worldId,
+          entityKey: resource.fact.entityKey,
+          center: resource.fact.center,
+          halfExtents: resource.fact.halfExtents,
+          intensity: resource.fact.intensity,
+          generation: resource.filter.activeGeneration,
+          filteredView: active.cubeView,
+          sampler: resource.sampler,
+          uniformBuffer: resource.uniformBuffer,
+        };
+      })
+      .filter((row): row is NonNullable<typeof row> => row !== undefined);
+    const table = buildReflectionProbeTable(rows);
+    const work: ReflectionProbeGraphWork[] = [];
+    for (const resource of accepted.values()) {
+      const rawCaptureFace =
+        resource.rawFaceCursor < resource.raw.faceViews.length ? resource.rawFaceCursor : undefined;
+      const step =
+        resource.rawFaceCursor >= resource.raw.faceViews.length
+          ? advanceProbeFilter(resource.filter)
+          : undefined;
+      if (this.shared === undefined) continue;
+      if (rawCaptureFace === undefined && step === undefined) continue;
+      const filterGroup0 =
+        step === undefined
+          ? undefined
+          : this.internals.device.createBindGroup({
+              label: `reflection-probe-${resource.index}-pmrem-${step.mipLevel}-${step.faceIndex}`,
+              layout: this.shared.prefilterGroup0Bgl,
+              entries: [
+                {
+                  binding: 0,
+                  resource: {
+                    kind: 'buffer',
+                    value: {
+                      buffer: this.shared.faceUniforms,
+                      offset: step.faceIndex * 256,
+                      size: 64,
+                    },
+                  },
+                },
+                {
+                  binding: 1,
+                  resource: {
+                    kind: 'buffer',
+                    value: {
+                      buffer: this.shared.prefilterUniforms,
+                      offset: (step.mipLevel * 6 + step.faceIndex) * 256,
+                      size: 16,
+                    },
+                  },
+                },
+              ],
+            });
+      if (filterGroup0 !== undefined && !filterGroup0.ok) continue;
+      if (resource.pending !== undefined) continue;
+      resource.pending = { rawCaptureFace, step };
+      if (rawCaptureFace !== undefined) this.lastScheduledRawFaces += 1;
+      if (step !== undefined) this.lastScheduledFilteredSteps += 1;
+      const face =
+        rawCaptureFace === undefined
+          ? undefined
+          : buildCubeCameraFaceViews({
+              position: resource.fact.center,
+              near: 0.1,
+              far: 100,
+            })[rawCaptureFace];
+      const faceCamera =
+        face === undefined || displayCamera === undefined
+          ? undefined
+          : {
+              ...displayCamera,
+              position: vec3.create(
+                resource.fact.center[0] ?? 0,
+                resource.fact.center[1] ?? 0,
+                resource.fact.center[2] ?? 0,
+              ),
+              world: mat4.invert(mat4.create(), face.view),
+              fov: Math.PI / 2,
+              aspect: 1,
+              near: face.near,
+              far: face.far,
+              projection: 'perspective' as const,
+            };
+      work.push({
+        probeIndex: resource.index,
+        rawTexture: resource.raw.texture,
+        rawCubeView: resource.raw.cubeView,
+        rawFaceViews: resource.raw.faceViews,
+        rawDepthTexture: resource.raw.depthTexture,
+        filteredTexture: resource.candidate.texture,
+        filteredCubeView: resource.candidate.cubeView,
+        filteredFaceViewsByMip: resource.candidate.mipViews,
+        outputFormat: this.outputFormat,
+        sampler: resource.sampler,
+        filterPipeline: this.shared.filterPipeline,
+        filterGroup0: filterGroup0?.value,
+        filterGroup1: resource.filterGroup1,
+        cubeVertexBuffer: this.shared.vertexBuffer,
+        rawCaptureFace,
+        rawDepthView: resource.raw.depthView,
+        rawSize: resource.raw.size,
+        ...(faceCamera === undefined ? {} : { faceCamera }),
+        ...(rawCaptureFace === undefined
+          ? {}
+          : {
+              viewBindGroupDynamicOffset:
+                (REFLECTION_PROBE_VIEW_SLOT_BASE + resource.index) * VIEW_UNIFORM_SLOT_STRIDE,
+            }),
+        filteredSize: resource.candidate.size,
+        step,
+      });
+    }
+    return {
+      table,
+      selections,
+      graph: { work },
+      completeSubmission: (submitted, completed) => this.completeSubmission(submitted, completed),
+    };
+  }
+
+  private completeSubmission(submitted: boolean, completed?: Promise<unknown>): void {
+    if (completed !== undefined) {
+      void completed.then(
+        () => this.completeSubmission(submitted),
+        () => this.completeSubmission(false),
+      );
+      return;
+    }
+    for (const resource of this.resources.values()) {
+      const pending = resource.pending;
+      delete resource.pending;
+      if (!submitted || pending === undefined) continue;
+      if (pending.rawCaptureFace !== undefined) {
+        resource.rawFaceCursor = Math.min(
+          resource.rawFaceCursor + 1,
+          resource.raw.faceViews.length,
+        );
+        continue;
+      }
+      if (pending.step === undefined) continue;
+      resource.filter = commitProbeFilterStep(resource.filter, true);
+      if (resource.filter.cursor >= resource.filter.faceCount * resource.filter.mipCount) {
+        const previous = resource.active;
+        resource.active = resource.candidate;
+        resource.candidate = resource.spare ?? previous ?? resource.candidate;
+        resource.spare = undefined;
+      }
+    }
+  }
+
+  dispose(): void {
+    for (const resource of this.resources.values()) {
+      this.destroyProbeResource(resource);
+    }
+    this.resources.clear();
+    if (this.shared !== undefined) {
+      this.internals.device.destroyBuffer(this.shared.faceUniforms);
+      this.internals.device.destroyBuffer(this.shared.prefilterUniforms);
+      this.internals.device.destroyBuffer(this.shared.vertexBuffer);
+    }
+    this.shared = undefined;
+    this.pipelineWarmup = undefined;
+  }
+
+  private destroyProbeResource(resource: ProbeGpuResource): void {
+    const sets = new Set<ProbeCubeSet>([resource.raw, resource.candidate]);
+    if (resource.active !== undefined) sets.add(resource.active);
+    if (resource.spare !== undefined) sets.add(resource.spare);
+    for (const set of sets) this.destroyCubeSet(set);
+    this.internals.device.destroyBuffer(resource.uniformBuffer);
+  }
+
+  private destroyCubeSet(set: ProbeCubeSet): void {
+    this.internals.device.destroyTexture(set.texture);
+    this.internals.device.destroyTexture(set.depthTexture);
+  }
+
+  private resourceFor(
+    key: string,
+    fact: ReflectionProbeFact,
+    index: number,
+  ): ProbeGpuResource | undefined {
+    const existing = this.resources.get(key);
+    if (existing !== undefined) {
+      if (existing.fact.revision !== fact.revision) {
+        existing.fact = fact;
+        existing.filter = createProbeFilterState({
+          probeIndex: index,
+          mipCount: PREFILTER_MIP_LEVELS,
+          activeGeneration: existing.filter.activeGeneration,
+        });
+        existing.rawFaceCursor = 0;
+      } else {
+        existing.fact = fact;
+        existing.index = index;
+      }
+      return existing;
+    }
+    if (this.shared === undefined) return undefined;
+    const raw = this.createCubeSet(`reflection-probe-${index}-raw`, fact.resolution);
+    const candidate = this.createCubeSet(`reflection-probe-${index}-candidate`, fact.resolution);
+    const spare = this.createCubeSet(`reflection-probe-${index}-spare`, fact.resolution);
+    if (raw === undefined || candidate === undefined || spare === undefined) return undefined;
+    const uniformBuffer = this.internals.device.createBuffer({
+      label: `reflection-probe-${index}-uniforms`,
+      size: 32,
+      usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+      mappedAtCreation: false,
+    });
+    if (!uniformBuffer.ok) return undefined;
+    const payload = new Float32Array([
+      -Math.max(0, fact.intensity),
+      fact.center[0],
+      fact.center[1],
+      fact.center[2],
+      fact.halfExtents[0],
+      fact.halfExtents[1],
+      fact.halfExtents[2],
+      0,
+    ]);
+    const written = this.internals.device.queue.writeBuffer(uniformBuffer.value, 0, payload);
+    if (!written.ok) return undefined;
+    const filterGroup1 = this.internals.device.createBindGroup({
+      label: `reflection-probe-${index}-filter-input`,
+      layout: this.shared.cubeGroup1Bgl,
+      entries: [
+        { binding: 0, resource: { kind: 'textureView', value: raw.cubeView } },
+        { binding: 1, resource: { kind: 'sampler', value: this.shared.sampler } },
+      ],
+    });
+    if (!filterGroup1.ok) return undefined;
+    const resource: ProbeGpuResource = {
+      fact,
+      index,
+      filter: createProbeFilterState({ probeIndex: index, mipCount: PREFILTER_MIP_LEVELS }),
+      rawFaceCursor: 0,
+      raw,
+      active: undefined,
+      candidate,
+      spare,
+      sampler: this.shared.sampler,
+      uniformBuffer: uniformBuffer.value,
+      filterGroup1: filterGroup1.value,
+    };
+    this.resources.set(key, resource);
+    return resource;
+  }
+
+  private createSharedResources(filterPipeline: RenderPipeline): ProbeSharedResources | undefined {
+    const faceUniforms = createFaceUniformsBuffer(this.internals.device);
+    const prefilterUniforms = createPrefilterUniformsBuffer(this.internals.device);
+    if (!faceUniforms.ok || !prefilterUniforms.ok) return undefined;
+    if (!writeAllFaceUniforms(this.internals.device, faceUniforms.value).ok) return undefined;
+    if (!writeAllPrefilterUniforms(this.internals.device, prefilterUniforms.value).ok)
+      return undefined;
+    const vertexBuffer = this.internals.device.createBuffer({
+      label: 'reflection-probe-capture-cube-vertices',
+      size: CUBEMAP_FACE_VERTICES.byteLength,
+      usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST,
+      mappedAtCreation: false,
+    });
+    if (!vertexBuffer.ok) return undefined;
+    const vertexWrite = this.internals.device.queue.writeBuffer(
+      vertexBuffer.value,
+      0,
+      CUBEMAP_FACE_VERTICES,
+    );
+    if (!vertexWrite.ok) return undefined;
+    const sampler = this.internals.device.createSampler({
+      label: 'reflection-probe-pmrem-sampler',
+      magFilter: 'linear',
+      minFilter: 'linear',
+      mipmapFilter: 'linear',
+      addressModeU: 'clamp-to-edge',
+      addressModeV: 'clamp-to-edge',
+      addressModeW: 'clamp-to-edge',
+    });
+    const cache = getOrCreateIblCache(this.internals.deviceScope);
+    if (
+      !sampler.ok ||
+      cache.cubeGroup1Bgl === undefined ||
+      cache.prefilterGroup0Bgl === undefined
+    ) {
+      return undefined;
+    }
+    return {
+      faceUniforms: faceUniforms.value,
+      prefilterUniforms: prefilterUniforms.value,
+      vertexBuffer: vertexBuffer.value,
+      sampler: sampler.value,
+      filterPipeline,
+      cubeGroup1Bgl: cache.cubeGroup1Bgl,
+      prefilterGroup0Bgl: cache.prefilterGroup0Bgl,
+    };
+  }
+
+  private createCubeSet(label: string, requestedSize: number): ProbeCubeSet | undefined {
+    const size = Math.min(Math.max(1, Math.floor(requestedSize)), PREFILTER_SIZE);
+    const mipCount = Math.min(PREFILTER_MIP_LEVELS, Math.floor(Math.log2(size)) + 1);
+    const texture = this.internals.device.createTexture({
+      label,
+      size: { width: size, height: size, depthOrArrayLayers: 6 },
+      mipLevelCount: mipCount,
+      sampleCount: 1,
+      dimension: '2d',
+      format: this.outputFormat,
+      usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING | GPU_TEXTURE_USAGE_COPY_SRC,
+      viewFormats: [],
+      textureBindingViewDimension: undefined,
+    });
+    if (!texture.ok) return undefined;
+    const cubeView = this.internals.device.createTextureView(texture.value, {
+      label: `${label}-cube`,
+      dimension: 'cube',
+      baseMipLevel: 0,
+      mipLevelCount: mipCount,
+      arrayLayerCount: 6,
+    });
+    if (!cubeView.ok) return undefined;
+    const faceViews: TextureView[] = [];
+    const mipViews: TextureView[][] = [];
+    for (let mip = 0; mip < mipCount; mip += 1) {
+      const faces: TextureView[] = [];
+      for (let face = 0; face < 6; face += 1) {
+        const view = this.internals.device.createTextureView(texture.value, {
+          label: `${label}-mip${mip}-face${face}`,
+          dimension: '2d',
+          baseMipLevel: mip,
+          mipLevelCount: 1,
+          baseArrayLayer: face,
+          arrayLayerCount: 1,
+        });
+        if (!view.ok) return undefined;
+        if (mip === 0) faceViews.push(view.value);
+        faces.push(view.value);
+      }
+      mipViews.push(faces);
+    }
+    const depthTexture = this.internals.device.createTexture({
+      label: `${label}-depth`,
+      size: { width: size, height: size, depthOrArrayLayers: 1 },
+      mipLevelCount: 1,
+      sampleCount: 1,
+      dimension: '2d',
+      format: 'depth24plus-stencil8',
+      usage: 0x10,
+      viewFormats: [],
+      textureBindingViewDimension: undefined,
+    });
+    if (!depthTexture.ok) return undefined;
+    const depthView = this.internals.device.createTextureView(depthTexture.value, {
+      label: `${label}-depth-view`,
+      dimension: '2d',
+    });
+    if (!depthView.ok) return undefined;
+    return {
+      texture: texture.value,
+      cubeView: cubeView.value,
+      faceViews,
+      mipViews,
+      depthTexture: depthTexture.value,
+      depthView: depthView.value,
+      size,
+    };
+  }
+}
+
 export function createRenderSystem(internals: RenderSystemInternals): RenderSystem {
   const phaseCatalogRegistration = internals.profiler?.registerPhaseCatalog(
     'render',
@@ -754,6 +1577,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   let preparedWorlds: readonly World[] = [];
   let latestCamera: CameraSnapshot | undefined;
   const pointsLinesOwner = new StandardPointsLinesOwner(internals);
+  const reflectionProbeOwner = new ReflectionProbeRecordOwner(internals);
+  const cubeCaptureScheduler = createCubeCaptureScheduler({ maxFacesPerFrame: 1 });
+  const cubeCaptureState: CubeCaptureGraphState = { work: [] };
   const persistentRenderScene = new PersistentRenderScene({
     getDevice: () => internals.device,
     onGpuError: (error) => internals.errorRegistry.fire(error),
@@ -949,10 +1775,27 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     graphGeneration: 0,
     successfulTemporalFrameIndex: 0,
     lastSuccessfulBloom: 'off',
+    temporalFrameTransaction: createTemporalFrameTransaction({ deviceEpoch: 0 }),
+    temporalFrameInput: undefined,
     directionalShadowCache: null,
     directionalShadowCacheRecorded: false,
     compiledFrameGraph: null,
     compiledFrameGraphTopologyKey: null,
+    compiledFrameGraphGeneration: 0,
+    volumetricFogPreviousGraph: null,
+    volumetricFogPreviousGraphKey: null,
+    volumetricFogCandidateGraph: null,
+    volumetricFogParamsBuffers: [null, null],
+    volumetricFogParamsPendingSlot: null,
+    volumetricFogParamsAcceptedSlot: null,
+    volumetricFogAcceptedParams: undefined,
+    volumetricFogPendingParams: undefined,
+    volumetricFogInspection: inspectVolumetricFog({ authored: false, capability: 'available' }),
+    volumetricFogAccepted: undefined,
+    volumetricFogAcceptedContext: undefined,
+    volumetricFogHistoryGraph: null,
+    volumetricFogHistorySlot: null,
+    volumetricFogHistorySignature: null,
     retiredCompiledFrameGraphs: new Set(),
     currentFrameObservationSource: undefined,
     lastSuccessfulCameraAntialias: undefined,
@@ -970,7 +1813,10 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     hdrpClusterBinScratch: createClusterBinScratch(),
     hdrpClusterGridScratch: null,
     hdrpLightIndexListScratch: null,
-    hdrpClusterMembershipBindGroup: null,
+    hdrpClusterMembership: null,
+    standardLightingGraphSignature: '',
+    standardLightingInspection: undefined,
+    pointShadowInspection: undefined,
     transientInstanceBuffers: [],
     warnedZeroLightStandard: false,
     warnedMultiLightDirectional: false,
@@ -1026,10 +1872,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     // (its topology is frame-invariant). Standard configuration overwrites this with the
     // resolved asset config on every swap so the active graph reads its current config.
     installedPipelineConfig: undefined,
-    // feat-20260608-cluster-lighting M2 / w10 + M5 / w20: HDRP active flag + once-per-frame
-    // warn dedup set for hdrp-light-budget-exceeded / hdrp-index-list-overflow.
-    isHdrpActive: false,
-    hdrpOncePerFrameFired: new Set(),
+    standardOncePerFrameFired: new Set(),
     // feat-20260612-point-light-shadows-urp-hdrp M3 / T-M3-2 (plan-strategy §D-1):
     // cube_array shadow atlas + per-frame snapshot list. Atlas is null until the
     // first frame whose extracted lights.pointShadow is non-empty (zero-shadow
@@ -1048,6 +1891,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     spotShadowSnapshots: [],
   };
   let directFrameId = 0;
+  let lastDirectionalShadowLights: ExtractedLights | undefined;
+  let lastDirectionalShadowCandidate: 'accepted' | 'failed' = 'failed';
+  let lastDirectionalShadowError: DirectionalShadowInspectionSource['error'];
 
   function beginProfilePhase(session: RecorderSession | undefined, phase: RenderPhase): boolean {
     if (session === undefined) return false;
@@ -1108,66 +1954,124 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   let activeFeaturePostProcessEntries: ReadonlyMap<string, PostProcessShaderEntry> = new Map();
   const lookupPostProcess = (id: string): PostProcessShaderEntry | undefined =>
     builtinPostProcessEntries.get(id) ?? activeFeaturePostProcessEntries.get(id);
+  const invalidatePostProcessModule = (id: string): void => {
+    const entry = lookupPostProcess(id);
+    if (entry !== undefined) {
+      internals.invalidateShaderModule?.(postProcessShaderModuleLabel(id, entry.source));
+    }
+  };
   // feat-20260621 M-A2 / w8: expose the eager-created per-id params UBO through
   // the narrow runtime surface so dispatchFullscreenPass can writeBuffer the
   // per-frame snapshot + bind it at group(1) binding(2).
   const getPostProcessParamsBuffer = (id: string): Buffer | undefined =>
     postProcessParamsBuffers.get(id);
-  const ensurePostProcessParamsResources = (
+  interface PostProcessParamsCandidate {
+    readonly buffers: ReadonlyMap<string, Buffer>;
+    readonly created: readonly Buffer[];
+  }
+  const postProcessParamsByteSize = (entry: PostProcessShaderEntry): number =>
+    entry.params?.byteSize ?? (entryHasDepthRead(entry) ? DEPTH_MIN_PARAMS_BYTE_SIZE : 0);
+  const destroyPostProcessParams = (buffers: readonly Buffer[]): void => {
+    for (const buffer of buffers) {
+      const destroyed = internals.device.destroyBuffer(buffer);
+      if (!destroyed.ok) internals.errorRegistry.fire(destroyed.error);
+    }
+  };
+  const preparePostProcessParamsResources = (
     featureEntries: ReadonlyMap<string, PostProcessShaderEntry>,
-  ): void => {
+  ): Result<PostProcessParamsCandidate, RhiError> => {
     const declarations = new Map<string, PostProcessShaderEntry>([
       ...builtinPostProcessEntries.entries(),
       ...featureEntries.entries(),
     ]);
+    const next = new Map<string, Buffer>();
+    const allocated: Buffer[] = [];
+    const discardCreated = (): void => destroyPostProcessParams(allocated);
     for (const [id, entry] of declarations) {
       if (id === 'forgeax.taa-resolve') continue;
-      const byteSize =
-        entry.params?.byteSize ?? (entryHasDepthRead(entry) ? DEPTH_MIN_PARAMS_BYTE_SIZE : 0);
-      if (byteSize === 0 || postProcessParamsBuffers.has(id)) continue;
+      const byteSize = postProcessParamsByteSize(entry);
+      if (byteSize === 0) continue;
+      const existing = postProcessParamsBuffers.get(id);
+      const accepted = lookupPostProcess(id);
+      if (
+        existing !== undefined &&
+        accepted !== undefined &&
+        postProcessShaderEntrySignature(accepted) === postProcessShaderEntrySignature(entry)
+      ) {
+        next.set(id, existing);
+        continue;
+      }
       const created = internals.device.createBuffer({
         label: `post-process-params-${id}`,
         size: byteSize,
         usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
         mappedAtCreation: false,
       });
-      if (!created.ok) throw created.error;
+      if (!created.ok) {
+        discardCreated();
+        return err(created.error);
+      }
       const buffer = created.value;
+      allocated.push(buffer);
       if (entry.params !== undefined) {
         const written = internals.device.queue.writeBuffer(buffer, 0, entry.params.defaultValue);
         if (!written.ok) {
-          internals.device.destroyBuffer(buffer);
-          throw written.error;
+          discardCreated();
+          return err(written.error);
         }
       }
-      postProcessParamsBuffers.set(id, buffer);
+      next.set(id, buffer);
+    }
+    return ok({ buffers: next, created: Object.freeze([...allocated]) });
+  };
+  const discardPostProcessParamsCandidate = (candidate: PostProcessParamsCandidate): void => {
+    destroyPostProcessParams(candidate.created);
+  };
+  const retirePostProcessParams = (buffers: readonly Buffer[]): void => {
+    if (buffers.length === 0) return;
+    const release = (): void => destroyPostProcessParams(buffers);
+    try {
+      void internals.device.queue.onSubmittedWorkDone().then(release, release);
+    } catch {
+      release();
     }
-    for (const [id, buffer] of postProcessParamsBuffers) {
-      if (declarations.has(id)) continue;
-      internals.device.destroyBuffer(buffer);
-      postProcessParamsBuffers.delete(id);
+  };
+  const acceptPostProcessParamsCandidate = (candidate: PostProcessParamsCandidate): void => {
+    const previous = [...postProcessParamsBuffers.values()];
+    const next = new Set(candidate.buffers.values());
+    postProcessParamsBuffers.clear();
+    for (const [id, buffer] of candidate.buffers) {
+      postProcessParamsBuffers.set(id, buffer);
     }
+    retirePostProcessParams(previous.filter((buffer) => !next.has(buffer)));
   };
-  // feat-20260609 M4 / T-10-a: post-process pipeline cache (id|colorFormat -> RhiRenderPipeline).
+  // feat-20260609 M4 / T-10-a: post-process pipeline cache (declaration|colorFormat -> RhiRenderPipeline).
   // Solves CONCERN-1: dispatcher previously passed `pipeline=null` to
   // built.createHandle because per-frame execute closures cannot await async
   // shader compile. The cache here delegates the actual build to
   // `internals.buildPostProcessPipeline` (sync wrapper over the shared shader
-  // adapter; 1-frame warmup), then memoizes by `id|colorFormat`.
+  // adapter; 1-frame warmup), then memoizes by declaration identity + format.
   const postProcessPipelineCache = new Map<string, RenderPipeline>();
   const getPostProcessPipeline = (
     id: string,
     bgl: BindGroupLayout,
     colorFormat: GPUTextureFormat,
+    entryOverride?: PostProcessShaderEntry,
   ): RenderPipeline | null => {
-    const key = `${id}|${colorFormat}`;
+    const entry = entryOverride ?? lookupPostProcess(id);
+    if (entry === undefined) return null;
+    const signature = postProcessShaderEntrySignature(entry);
+    const key = `${id}|${colorFormat}|${signature}`;
     const cached = postProcessPipelineCache.get(key);
     if (cached !== undefined) return cached;
-    const entry = lookupPostProcess(id);
-    if (entry === undefined) return null;
     const factory = internals.buildPostProcessPipeline;
     if (factory === undefined) return null;
-    const built = factory(entry, bgl, colorFormat, `post-process-${id}`);
+    const built = factory(
+      entry,
+      bgl,
+      colorFormat,
+      postProcessShaderPipelineLabel(id, entry.source),
+    );
     if (built === null) return null;
     postProcessPipelineCache.set(key, built);
     return built;
@@ -1177,6 +2081,14 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       if (key.startsWith(`${id}|`)) postProcessPipelineCache.delete(key);
     }
   };
+  const clearPostProcessPipelineEntry = (id: string, entry: PostProcessShaderEntry): void => {
+    const suffix = `|${postProcessShaderEntrySignature(entry)}`;
+    for (const key of postProcessPipelineCache.keys()) {
+      if (key.startsWith(`${id}|`) && key.endsWith(suffix)) {
+        postProcessPipelineCache.delete(key);
+      }
+    }
+  };
   Object.assign(internals, {
     lookupPostProcess,
     getPostProcessParamsBuffer,
@@ -1351,7 +2263,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     if (buffer === undefined) return group;
     return ok({
       handle: group.value,
-      dynamicOffsets: [0],
+      dynamicOffsets: [0, 0],
       release: () => internals.device.destroyBuffer(buffer),
     });
   };
@@ -1362,8 +2274,6 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   const preparedResolverFactory = (
     input: RenderFeaturePreparedGraphicsResolverInput,
   ): PreparedGraphicsResolver => {
-    activeFeaturePostProcessEntries = input.fullscreenEffects;
-    ensurePostProcessParamsResources(input.fullscreenEffects);
     return createPreparedGraphicsResolver({
       device: internals.device,
       featureIdentity: input.featureIdentity,
@@ -1387,6 +2297,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             descriptor.shader,
             fullscreen.bindGroupLayout,
             descriptor.colorFormats[0] as GPUTextureFormat,
+            postProcessEntry,
           );
           if (pipeline !== null && pipeline !== undefined) {
             preparedPipelineIds.set(pipeline as object, descriptor.shader);
@@ -1555,6 +2466,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         gpuDriven: gpuDrivenProduction.inspect(),
       };
     },
+    get reflectionProbes(): ReflectionProbeInspection {
+      return reflectionProbeOwner.inspect();
+    },
+    isCubeCapturePending(target: RenderTarget): boolean {
+      return cubeCaptureScheduler.inspect(target).candidateGeneration !== undefined;
+    },
     get environment(): EnvironmentInspection {
       return environmentLifecycle.inspect();
     },
@@ -1647,6 +2564,49 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     get transmission(): TransmissionInspection | undefined {
       return lastTransmissionInspection;
     },
+    get directionalShadow(): DirectionalShadowInspection {
+      const lights = lastDirectionalShadowLights;
+      const pipelineState = internals.getPipelineState();
+      const graph = frameState.compiledFrameGraph?.inspect();
+      const requested = directionalShadowProfileFromQuality(lights?.directionalShadowQuality);
+      const mapSize = pipelineState?.perPassResources.shadowMapSize ?? 0;
+      const cascadeCount = lights?.cascadeCount ?? 0;
+      const shadowReady = frameState.currentDirectionalShadowView !== null;
+      const atlasBytes =
+        shadowReady && mapSize > 0 && cascadeCount > 0
+          ? mapSize * mapSize * Math.ceil(Math.sqrt(cascadeCount)) ** 2 * 4
+          : 0;
+      return projectDirectionalShadowInspectionSource({
+        requested,
+        candidate: lastDirectionalShadowCandidate,
+        ...(frameState.directionalShadowCache === null
+          ? {}
+          : {
+              lastKnownGood: directionalShadowProfileFromQuality(
+                frameState.directionalShadowCache.directionalShadowQuality,
+              ),
+            }),
+        cascadeCount,
+        mapSize,
+        atlasBytes,
+        writerPasses:
+          graph?.passes.filter((pass) => pass.name.startsWith('shadowCascade')).length ?? 0,
+        shadowAngularRadius: lights?.directionalCsmConfig?.shadowAngularRadius,
+        maxPenumbraTexels: lights?.directionalCsmConfig?.maxPenumbraTexels,
+        deviceGeneration: internals.deviceScope.generation,
+        graphGeneration: frameState.perFrameGraph?.graphGeneration ?? frameState.graphGeneration,
+        shadowReady,
+        ...(lastDirectionalShadowError === undefined ? {} : { error: lastDirectionalShadowError }),
+      });
+    },
+    get standardLightingInspection(): StandardLightingInspection | undefined {
+      const inspection = frameState.standardLightingInspection;
+      return inspection === undefined ? undefined : Object.freeze({ ...inspection });
+    },
+    get pointShadowInspection(): PointShadowInspection | undefined {
+      const inspection = frameState.pointShadowInspection;
+      return inspection === undefined ? undefined : Object.freeze({ ...inspection });
+    },
     get pointsLinesSnapshots(): readonly PointsLinesRetainedSnapshot[] {
       return persistentRenderScene.pointsLinesSnapshots();
     },
@@ -1657,6 +2617,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       worlds: readonly World[],
       opts: DrawOwnerOptions,
       renderReadLeases?: readonly RenderReadLease[],
+      timingCapture?: GpuTimingCapture,
     ): boolean {
       preparedWorlds = worlds;
       const profileSession = internals.profiler?.activeSession();
@@ -1729,9 +2690,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         });
         const {
           cameras,
+          cubeCameras,
           lights,
           environment,
           environmentReady,
+          volumetricFog,
           renderables,
           dispatch,
           skylight,
@@ -1739,10 +2702,19 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           skybox,
           skyboxCount,
           fog,
+          fogFailure,
           frustumStats,
           visibilityStats,
           postProcessParams,
         } = frame;
+        lastDirectionalShadowLights = lights;
+        lastDirectionalShadowCandidate = 'failed';
+        lastDirectionalShadowError = lights.directionalShadowError;
+        const reflectionProbeRecord = reflectionProbeOwner.prepare(
+          frame.reflectionProbes ?? [],
+          persistentRenderScene.reflectionProbeProjection().selected,
+          cameras[0],
+        );
         latestCamera = cameras[0];
         const temporalDemanded =
           cameras[0]?.antialias === 'taa' || (cameras[0]?.motionBlur?.shutterAngle ?? 0) > 0;
@@ -1750,6 +2722,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           persistentRenderScene.prepareTemporalFrame(renderables);
         }
         environmentLifecycle.bindScope(internals.deviceScope);
+        if (fogFailure !== undefined) {
+          environmentLifecycle.recordSelectionFailure(fogFailure);
+        }
         if (!environmentReady || environment === undefined) {
           frameState.pendingTemporalCommit = { kind: 'none' };
           // A world with no camera still has a valid clear-only render path.
@@ -1778,15 +2753,21 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         }
         if (lastMeshMaterialBindingFrame !== frame) {
           lastMeshMaterialBindingFrame = frame;
-          lastMeshMaterialBindings = renderables.map((renderable) => ({
-            worldId: renderable.worldId,
-            entityKey: renderable.entityKey,
-            bindings: renderable.materials.map((material, slotIndex) => ({
-              handle: material.materialHandle ?? 0,
-              source: renderable.materialBindingSources[slotIndex] ?? 'engine-default',
-            })),
-            diagnostics: renderable.materialBindingDiagnostics ?? [],
-          }));
+          lastMeshMaterialBindings = renderables.map((renderable) => {
+            const materialWorld = preparedWorlds[renderable.worldId];
+            return projectMeshMaterialBindingObservation({
+              worldId: renderable.worldId,
+              entityKey: renderable.entityKey,
+              bindings: renderable.materials.map((material, slotIndex) => ({
+                handle: material.materialHandle ?? 0,
+                source: renderable.materialBindingSources[slotIndex] ?? 'engine-default',
+              })),
+              diagnostics: renderable.materialBindingDiagnostics ?? [],
+              residency: renderable.materials.map((material) =>
+                observeMaterialResidency(materialWorld, material, internals),
+              ),
+            });
+          });
         }
 
         bindGroupCounts.createBindGroup = 0;
@@ -1852,14 +2833,23 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             createPreparedGraphicsResolver: preparedResolverFactory,
             gpuWork: featureGpuWork,
           });
-          activeFeaturePostProcessEntries = featureFrame.fullscreenEffects;
-          ensurePostProcessParamsResources(featureFrame.fullscreenEffects);
           lastVisibilityStats.explicitlyHidden = featureFrame.hiddenEntityReports.length;
           for (const featureError of featureFrame.errors) {
             if (!isPendingRenderFeaturePreparation(featureError)) {
               internals.errorRegistry.fire(featureError);
             }
           }
+          const postProcessParamsCandidate = preparePostProcessParamsResources(
+            featureFrame.fullscreenEffects,
+          );
+          if (!postProcessParamsCandidate.ok) {
+            internals.errorRegistry.fire(postProcessParamsCandidate.error);
+            for (const batch of featureFrame.preparedResourceBatches) {
+              const released = batch.release();
+              if (!released.ok) internals.errorRegistry.fire(released.error);
+            }
+            return [];
+          }
           featureGraphCandidate = {
             plans: featureFrame.plans,
             fullscreenEffects: featureFrame.fullscreenEffects,
@@ -1873,6 +2863,29 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                   internals.errorRegistry.fire(released.error);
                 }
               }
+              discardPostProcessParamsCandidate(postProcessParamsCandidate.value);
+            },
+            onAbandoned: () => {
+              discardPostProcessParamsCandidate(postProcessParamsCandidate.value);
+            },
+            onAccepted: () => {
+              for (const [id, previous] of activeFeaturePostProcessEntries) {
+                const next = featureFrame.fullscreenEffects.get(id);
+                if (next === undefined) {
+                  clearPostProcessPipelineCache(id);
+                  invalidatePostProcessModule(id);
+                } else if (
+                  postProcessShaderEntrySignature(previous) !==
+                  postProcessShaderEntrySignature(next)
+                ) {
+                  clearPostProcessPipelineEntry(id, previous);
+                  if (previous.source !== next.source) {
+                    invalidatePostProcessModule(id);
+                  }
+                }
+              }
+              acceptPostProcessParamsCandidate(postProcessParamsCandidate.value);
+              activeFeaturePostProcessEntries = featureFrame.fullscreenEffects;
             },
           };
           return featureFrame.preparedResourceBatches;
@@ -1949,20 +2962,50 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             {
               owner: gpuDrivenProduction,
               scene: persistentRenderScene.compositionGpuDrivenState(),
-              onCoverage: (ownsAll) => {
-                const key = `${internals.gpuStore.meshResidencyEpoch}:${frameState.isHdrpActive ? 'hdrp' : 'urp'}`;
+              onCoverage: (ownsAll, clusteredLighting) => {
+                const key = `${internals.gpuStore.meshResidencyEpoch}:${clusteredLighting ? 'clustered' : 'standard'}`;
                 persistentRenderScene.setCompositionGpuDrivenCoverage(key, ownsAll);
               },
             },
             renderReadLeases,
             featureGraphCandidate,
             pointsLinesOwner,
+            {
+              snapshots: cubeCameras,
+              scheduler: cubeCaptureScheduler,
+              state: cubeCaptureState,
+              reflectionProbes: reflectionProbeRecord,
+            } satisfies CubeCaptureFrameInput,
             environment?.environmentSignature ?? '',
             environment?.fogSignature ?? '',
             environmentReady && environment !== undefined,
             persistentRenderScene.transmissionTopologyDemand(),
+            volumetricFog,
+            timingCapture,
           ),
         );
+        const directionalQuality = lights.directionalShadowQuality;
+        const directionalShadowReady =
+          directionalQuality === undefined ||
+          (frameState.currentDirectionalShadowView !== null &&
+            (lights.lightViewProj?.length ?? 0) > 0 &&
+            (internals.getPipelineState()?.perPassResources.shadowMapSize ?? 0) > 0);
+        if (submitted && directionalShadowReady) {
+          lastDirectionalShadowCandidate = 'accepted';
+        } else if (directionalQuality !== undefined) {
+          lastDirectionalShadowError = {
+            code: 'directional-shadow-candidate-failed',
+            expected:
+              'the extracted Directional CSM candidate has a valid graph target and fitted matrices',
+            hint: 'inspect the retained LKG and retry after the graph or resource owner recovers',
+            detail: {
+              submitted,
+              hasShadowView: frameState.currentDirectionalShadowView !== null,
+              matrixCount: lights.lightViewProj?.length ?? 0,
+              shadowMapSize: internals.getPipelineState()?.perPassResources.shadowMapSize ?? 0,
+            },
+          };
+        }
         if (submitted) {
           const temporalCommit = persistentRenderScene.commitTemporalFrame();
           if (!temporalCommit.ok) {
@@ -2061,6 +3104,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       frameState.graphTargetCapture = request;
     },
     bindGroupCounts: bindGroupCounts,
+    get temporalFrame(): TemporalFrame | undefined {
+      const accepted = frameState.temporalFrame;
+      if (accepted === undefined) return undefined;
+      return {
+        ...accepted,
+        currentViewProjection: new Float32Array(accepted.currentViewProjection),
+        previousViewProjection:
+          accepted.previousViewProjection === undefined
+            ? undefined
+            : new Float32Array(accepted.previousViewProjection),
+        jitter: [accepted.jitter[0], accepted.jitter[1]],
+        viewport: { ...accepted.viewport },
+      };
+    },
     frustumStats: lastFrustumStats,
     visibilityStats: lastVisibilityStats,
     get meshMaterialBindings(): readonly MeshMaterialBindingObservation[] {
@@ -2075,15 +3132,16 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     get perFrameGraphInfo(): CompiledRenderGraphInfo | undefined {
       return frameState.compiledFrameGraph?.inspect();
     },
+    get volumetricFog(): import('./volume/inspection').VolumetricFogInspection {
+      return frameState.volumetricFogInspection;
+    },
     configureStandard(config: RenderPipelineAsset['config']): void {
       const profileConfig = internals.standardProfile;
       const resolvedConfig =
         profileConfig === undefined
           ? config
           : {
-              ...(profileConfig.lighting === 'clustered'
-                ? { clusterGrid: DEFAULT_CLUSTER_GRID }
-                : {}),
+              clusterGrid: DEFAULT_CLUSTER_GRID,
               ...(profileConfig.ssao ? { ssao: { enabled: true } } : {}),
               ...config,
             };
@@ -2108,16 +3166,6 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // is a rare boot/swap event, never a per-frame cost.
       installEpoch += 1;
       frameState.installedPipelineHandle = installEpoch;
-      // The installed profile may request clustered lighting, but the actual
-      // graph lane is capability-gated.  On WebGL2 (including WebKit's wgpu
-      // fallback) the forward lane is selected when compute/storage buffers
-      // are unavailable; keep the frame bindings on that same lane instead of
-      // advertising HDRP's clustered bind-group layout to URP pipelines.
-      frameState.isHdrpActive =
-        resolveStandardLane(internals.standardProfile ?? DEFAULT_STANDARD_PROFILE, {
-          compute: internals.device.caps.compute,
-          storageBuffer: internals.device.caps.storageBuffer,
-        }) === 'clustered';
       frameState.installedPipelineConfig = resolvedConfig;
     },
     registerBuiltinPostProcess(id: string, entry: PostProcessShaderEntry): () => void {
@@ -2161,6 +3209,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         }
         builtinPostProcessEntries.set(id, entry);
         if (paramsBuffer !== undefined) postProcessParamsBuffers.set(id, paramsBuffer);
+        const moduleLabel = postProcessShaderModuleLabel(id, entry.source);
         return () => {
           if (builtinPostProcessEntries.get(id) === entry) {
             builtinPostProcessEntries.delete(id);
@@ -2170,9 +3219,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             internals.device.destroyBuffer(current);
             postProcessParamsBuffers.delete(id);
           }
-          for (const key of postProcessPipelineCache.keys()) {
-            if (key.startsWith(`${id}|`)) postProcessPipelineCache.delete(key);
-          }
+          clearPostProcessPipelineCache(id);
+          internals.invalidateShaderModule?.(moduleLabel);
         };
       } catch (cause) {
         if (paramsBuffer !== undefined) internals.device.destroyBuffer(paramsBuffer);
@@ -2180,16 +3228,24 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       }
     },
     disposeFrameState(): void {
+      (internals as TimingSessionHost).gpuPassTimingSession?.dispose();
+      (internals as TimingSessionHost).gpuPassTimingSession = undefined;
+      (internals as TimingSessionHost).gpuPassTimingCapture = undefined;
+      (internals as TimingSessionHost).gpuPassTimingSubmittedWork = undefined;
+      (internals as TimingSessionHost).gpuPassTimingFrameIdentity = undefined;
+      (internals as TimingSessionHost).gpuPassTimingBeginReason = undefined;
       persistentRenderScene.dispose();
       gpuDrivenProduction.dispose();
       disposeFeatureGpuWork();
+      reflectionProbeOwner.dispose();
       // Bloom generations are renderer-owned rather than graph-owned. Drain
       // candidate, active, and fence-retiring bundles before the rest of the
       // frame state is torn down; the owner callback is idempotent so the
       // outer Renderer.dispose cascade can safely call this once only.
       internals.getPipelineState()?.perPassResources.drainBloomResources?.();
       internals.clearPostProcessPipelineCache?.('forgeax.taa-resolve');
-      internals.invalidateShaderModule?.('post-process-forgeax.taa-resolve-module');
+      invalidatePostProcessModule('forgeax.taa-resolve');
+      resetHdrpBuffers(internals);
       // Retire graph-owned resources and dispose instance-buffer caches.
       // Both calls are idempotent + tolerate per-handle errors silently;
       // the Renderer.dispose() cascade owns the surrounding try/catch
@@ -2214,9 +3270,30 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         retireTemporalGpuState(retiring);
       }
       frameState.retiringTemporalGpuStates.clear();
+      settleVolumetricFogGraphCandidate(frameState, false);
+      for (const buffer of frameState.volumetricFogParamsBuffers) {
+        if (buffer === null) continue;
+        const destroyed = internals.device.destroyBuffer(buffer);
+        if (!destroyed.ok) internals.errorRegistry.fire(destroyed.error);
+      }
+      frameState.volumetricFogParamsBuffers = [null, null];
+      frameState.volumetricFogParamsPendingSlot = null;
+      frameState.volumetricFogParamsAcceptedSlot = null;
+      frameState.volumetricFogAcceptedParams = undefined;
+      frameState.volumetricFogPendingParams = undefined;
+      frameState.volumetricFogAccepted = undefined;
+      frameState.volumetricFogAcceptedContext = undefined;
+      frameState.volumetricFogHistoryGraph = null;
+      frameState.volumetricFogHistorySlot = null;
+      frameState.volumetricFogHistorySignature = null;
+      frameState.hdrpClusterMembership = null;
       const compiled = frameState.compiledFrameGraph;
       frameState.compiledFrameGraph = null;
       frameState.compiledFrameGraphTopologyKey = null;
+      frameState.perFrameGraph = null;
+      frameState.standardLightingGraphSignature = '';
+      frameState.standardLightingInspection = undefined;
+      frameState.pointShadowInspection = undefined;
       if (compiled !== null) compiled.retire().catch(() => undefined);
       for (const retired of frameState.retiredCompiledFrameGraphs) {
         retired.retire().catch(() => undefined);
@@ -2251,6 +3328,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       lastTransmissionKey = '';
       transmissionCapabilityGeneration = -1;
       transmissionCapability = undefined;
+      // The replacement device cannot consume buffers minted by the lost
+      // device.  Drop the shared Standard Cluster bundle before the next
+      // frame asks for a new generation; resetHdrpBuffers fences the bundle
+      // using its own device/queue instead of the replacement runtime device.
+      resetHdrpBuffers(internals);
       // Keep the persistent material demand observable across device loss.
       // The physical resource has already been fenced by markDeviceLost(); the
       // detached inspection now exposes the rebuild-required lifecycle until a
@@ -2260,6 +3342,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       gpuDrivenProduction.dispose();
       gpuDrivenProduction = new GpuDrivenProduction(internals.device, gpuDrivenShaderFactory);
       disposeFeatureGpuWork();
+      reflectionProbeOwner.dispose();
       // A recovered device cannot retain handles from the lost device. The
       // Bloom owner abandons candidates and retires every committed generation
       // before the new PipelineState is rebuilt.
@@ -2269,9 +3352,33 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // must be discarded, not merely marked for destruction: their opaque
       // handles cannot be used on the fresh device and the next draw must
       // lazily build a new graph from the preserved ECS / asset POD caches.
+      settleVolumetricFogGraphCandidate(frameState, false);
       frameState.compiledFrameGraph?.retire().catch(() => undefined);
       frameState.compiledFrameGraph = null;
       frameState.compiledFrameGraphTopologyKey = null;
+      frameState.volumetricFogPreviousGraph = null;
+      frameState.volumetricFogPreviousGraphKey = null;
+      frameState.volumetricFogCandidateGraph = null;
+      frameState.volumetricFogAccepted = undefined;
+      frameState.volumetricFogAcceptedContext = undefined;
+      frameState.volumetricFogHistoryGraph = null;
+      frameState.volumetricFogHistorySlot = null;
+      frameState.volumetricFogHistorySignature = null;
+      // The old device owns these transient params buffers. Discard their
+      // handles without calling destroy() on the lost device; the next frame
+      // must allocate fresh buffers on the replacement device.
+      frameState.volumetricFogParamsBuffers = [null, null];
+      frameState.volumetricFogParamsPendingSlot = null;
+      frameState.volumetricFogParamsAcceptedSlot = null;
+      frameState.volumetricFogAcceptedParams = undefined;
+      frameState.volumetricFogPendingParams = undefined;
+      // Do not expose graph-owned texture/descriptor accessors from the lost
+      // device while recovery is between generations. Inspection and capture
+      // must remain detached until the replacement graph is accepted.
+      frameState.perFrameGraph = null;
+      frameState.standardLightingGraphSignature = '';
+      frameState.standardLightingInspection = undefined;
+      frameState.pointShadowInspection = undefined;
       frameState.directionalShadowCache = null;
       frameState.directionalShadowCacheRecorded = false;
       frameState.currentFrameObservationSource = undefined;
@@ -2290,6 +3397,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         retireTemporalGpuState(retiring);
       }
       frameState.retiringTemporalGpuStates.clear();
+      frameState.hdrpClusterMembership = null;
       for (const retired of frameState.retiredCompiledFrameGraphs) {
         retired.retire().catch(() => undefined);
       }