@forgeax/engine-render 0.1.20 → 0.1.23

package/src/render-system.ts

@@ -19,12 +19,14 @@
 import { numMipLevels, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import type { World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
+import { mat4 } from '@forgeax/engine-math';
 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 { err, ok, type Result, RhiError } from '@forgeax/engine-rhi';
 import {
   derive,
+  deriveTextureLayout,
   type Handle,
   type MaterialAsset,
   type MaterialTextureValue,
@@ -32,8 +34,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,12 +65,22 @@ 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,
+  GpuDrivenProductionInspection,
+  LodOcclusionInspection,
+  LodOcclusionInspectionRow,
+  LodOcclusionWorldInspection,
   MotionBlurInspection,
+  ReflectionProbeInspection,
   RenderSceneInspection,
+  SsrDependenciesInspection,
   TemporalTargetInspection,
   TransmissionInspection,
 } from './inspection-types';
@@ -80,11 +98,18 @@ 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 { ReflectionProbeRecordOwner } from './reflection/record-owner';
+import {
+  OcclusionRenderRuntime,
+  type OcclusionRuntimeCandidate,
+} from './scene/visibility/occlusion-runtime';
+import { primitiveKey, viewKey } from './scene/visibility/types';
 import { inspectVolumetricFog } from './volume/inspection';
 
 export type { RenderSceneInspection } from './inspection-types';
 
 import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
+import { createCubeCaptureScheduler } from './capture/scheduler';
 import type { EnvironmentInspection } from './environment/inspection';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
@@ -92,22 +117,27 @@ import {
   GPU_BUFFER_USAGE_UNIFORM,
   GPU_BUFFER_USAGE_VERTEX,
 } from './gpu-usage';
+import { resetHdrpBuffers } from './hdrp-buffers';
 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,10 +150,18 @@ import type {
   GraphTargetCaptureRequest,
   RenderFrameState,
 } from './record/frame-snapshot';
-import { getTextureIdentity } from './record/frame-snapshot';
+import { getTextureIdentity, worldEntityKey } 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 { computeProjectionMatrix, computeViewMatrix } from './record/helpers';
 import { applyParamSnapshotToUbo, residentTextureView } from './record/main-pass-material';
 import type { RenderSystemInternals } from './record/render-context';
+import type { CubeCaptureGraphState } from './record/typed-frame-graph';
 import {
   type RenderFeatureGraphCandidate,
   resetRenderFeatureGraphState,
@@ -137,10 +175,18 @@ 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 { inspectLodOcclusion } from './scene/visibility/inspection';
 import { resolveSsaoParameters } from './ssao-config';
+import { projectSsrDependencies, resolveSsrAdmissionGeneration } from './ssr/admission';
 import {
   getTransparentSortConfig,
   TRANSPARENT_SORT_MODE_DISTANCE,
@@ -148,6 +194,7 @@ 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';
@@ -163,6 +210,136 @@ import {
   inspectTransmissionFromAdmission,
 } from './transmission/inspection';
 
+interface LodInspectionQuerySummary {
+  readonly used: number;
+  readonly capacity: number;
+}
+
+function createLodWorldInspections(
+  worlds: readonly World[],
+  renderables: readonly RenderableSnapshot[],
+  submittedRenderables: readonly RenderableSnapshot[],
+  camera: CameraSnapshot,
+  frameId: number,
+  worldKeys: readonly number[],
+  slots: ReadonlyMap<number, { readonly slot: number; readonly generation: number }>,
+  query: LodInspectionQuerySummary,
+  fallback: LodOcclusionInspection['fallback'],
+  degradation: LodOcclusionInspection['degradation'],
+): readonly LodOcclusionWorldInspection[] {
+  // The CPU projection knows which renderables belong to each World, but it
+  // does not receive the GPU selector/query counters split by World from the
+  // same submit. Keep these rows available for diagnostics while explicitly
+  // marking their attribution unavailable; producers must not promote them
+  // to World-reorder evidence by inferring facts from array order.
+  const attribution = Object.freeze({
+    status: 'unavailable' as const,
+    reason: 'projection-only' as const,
+  });
+  const submitted = new Set(submittedRenderables);
+  const sampleLimit = 64;
+  const accumulators = worlds.map(() => ({
+    allCount: 0,
+    allVisible: 0,
+    allSamples: [] as RenderableSnapshot[],
+    lodCount: 0,
+    lodVisible: 0,
+    lodSamples: [] as RenderableSnapshot[],
+  }));
+  // Keep this projection bounded: the old implementation filtered the full
+  // 100k renderable list twice per World on every frame and retained another
+  // Set-backed traversal just to derive the six counters below. One pass is
+  // enough because the inspection only needs counts, the first row identity,
+  // and at most 64 detached samples.
+  for (const renderable of renderables) {
+    const accumulator = accumulators[renderable.worldId];
+    if (accumulator === undefined) continue;
+    const visible = submitted.has(renderable);
+    accumulator.allCount += 1;
+    if (visible) accumulator.allVisible += 1;
+    if (accumulator.allSamples.length < sampleLimit) accumulator.allSamples.push(renderable);
+    if ((renderable.lods?.length ?? 0) > 0) {
+      accumulator.lodCount += 1;
+      if (visible) accumulator.lodVisible += 1;
+      if (accumulator.lodSamples.length < sampleLimit) accumulator.lodSamples.push(renderable);
+    }
+  }
+  const result: LodOcclusionWorldInspection[] = [];
+  for (let worldId = 0; worldId < worlds.length; worldId += 1) {
+    const world = worlds[worldId];
+    if (world === undefined) continue;
+    const accumulator = accumulators[worldId];
+    if (accumulator === undefined || accumulator.allCount === 0) {
+      result.push(
+        Object.freeze({ attachmentId: world.identity, rows: Object.freeze([]), attribution }),
+      );
+      continue;
+    }
+    const usesLod = accumulator.lodCount > 0;
+    const candidateCount = usesLod ? accumulator.lodCount : accumulator.allCount;
+    const visible = usesLod ? accumulator.lodVisible : accumulator.allVisible;
+    const samples = usesLod ? accumulator.lodSamples : accumulator.allSamples;
+    const first = samples[0];
+    const slot =
+      first === undefined
+        ? undefined
+        : slots.get(worldEntityKey(worldKeys[first.worldId] ?? first.worldId, first.entityKey));
+    const row: LodOcclusionInspectionRow = {
+      root: {
+        guid: first === undefined ? 'none' : `asset-handle:${first.assetHandle}`,
+        sourceKey: `render-world:${world.identity}`,
+      },
+      view: {
+        attachmentId: world.identity,
+        cameraEntity: world === worlds[camera.worldId ?? 0] ? (camera.entityKey ?? 0) : 0,
+        viewRole: 'main',
+        viewGeneration: camera.historyVersion ?? 0,
+      },
+      slot: { primitiveSlot: slot?.slot ?? 0, slotGeneration: slot?.generation ?? 0 },
+      generation: frameId,
+      count: { candidates: candidateCount, visible, occluded: candidateCount - visible },
+      lodHistogram: [{ level: 0, count: candidateCount }],
+      queryLatencyUs: { median: 0, p95: 0, last: 0 },
+      pagePressure: query,
+      fallback,
+      degradation,
+      samples: samples.map((candidate, index) => ({
+        primitiveSlot:
+          slots.get(
+            worldEntityKey(worldKeys[candidate.worldId] ?? candidate.worldId, candidate.entityKey),
+          )?.slot ?? index,
+        level: 0,
+        visible: submitted.has(candidate),
+      })),
+    };
+    result.push(
+      Object.freeze({
+        attachmentId: world.identity,
+        rows: Object.freeze([row]),
+        attribution,
+      }),
+    );
+  }
+  return Object.freeze(
+    result.sort((left, right) => left.attachmentId.localeCompare(right.attachmentId)),
+  );
+}
+
+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,
@@ -232,7 +409,7 @@ function sortTransparentDispatch(
     const camPos = camera.position;
 
     // Squared camera distance per entry (negated → ascending = back-to-front).
-    // D-3: world position = translation column of Transform.world (m[12,13,14]).
+    // D-3: world position = translation column of GlobalTransform.world (m[12,13,14]).
     const negDistSq = (entry: DispatchEntry): number => {
       const tx = renderables[entry.renderableIndex]?.transform;
       if (tx === undefined) return 0;
@@ -338,6 +515,8 @@ export interface RenderSystem {
   observeCurrentFrame(
     options: FrameObservationOptions,
   ): Promise<Result<FrameObservation, ObservationUnavailableError>>;
+  /** Resolve the renderer-owned GPU LOD counters for the last accepted submit. */
+  observeLodOcclusion(): Promise<void>;
   /** Internal same-frame graph target access for backend diagnostics. */
   getCurrentGraphTarget(name: string): CurrentGraphTarget | undefined;
   /** Internal test capture copied into the draw's command submission. */
@@ -354,13 +533,29 @@ export interface RenderSystem {
   readonly visibilityStats: { explicitlyHidden: number };
   /** Persistent scene maintenance evidence from the ordinary single-World path. */
   readonly renderScene: RenderSceneInspection;
+  readonly reflectionProbes: ReflectionProbeInspection;
+  /** Live producer/RHI/temporal receipts projected through SSR admission. */
+  readonly ssrDependencies: SsrDependenciesInspection;
+  /** Producer completion fence included in the public FrameReceipt. */
+  readonly reflectionFallbackCompletion: Promise<void> | undefined;
+  /** True while a progressive CubeCamera candidate still owns unfinished faces. */
+  isCubeCapturePending(target: RenderTarget): boolean;
   readonly environment: EnvironmentInspection;
   readonly temporal: TemporalInspection;
   readonly bloom: BloomInspection;
   readonly motionBlurInspection: MotionBlurInspection | undefined;
   readonly temporalTargetInspection: TemporalTargetInspection | undefined;
+  readonly lodOcclusionInspection: LodOcclusionInspection | undefined;
+  /** Bounded GPU-driven counters without materializing the persistent scene table. */
+  readonly gpuDrivenInspection: GpuDrivenProductionInspection;
   /** 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. */
@@ -492,6 +687,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.
  *
@@ -763,6 +1127,41 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   let preparedWorlds: readonly World[] = [];
   let latestCamera: CameraSnapshot | undefined;
   const pointsLinesOwner = new StandardPointsLinesOwner(internals);
+  const reflectionProbeOwner = new ReflectionProbeRecordOwner(internals);
+  let ssrFormatReceipt: import('@forgeax/engine-rhi').RhiTextureFormatCapabilityReceipt | undefined;
+  let ssrFormatProbeGeneration = -1;
+  let ssrFormatProbe: Promise<void> | undefined;
+  let ssrFallbackGeneration: number | undefined;
+  const ensureSsrFormatProbe = (): void => {
+    if (internals.ssrIdentity === undefined) return;
+    const generation = internals.deviceScope.generation;
+    if (
+      ssrFormatReceipt?.deviceGeneration === generation ||
+      ssrFormatProbeGeneration === generation ||
+      ssrFormatProbe !== undefined ||
+      typeof internals.device.probeTextureFormatCapability !== 'function'
+    ) {
+      return;
+    }
+    ssrFormatProbeGeneration = generation;
+    const device = internals.device;
+    ssrFormatProbe = device
+      .probeTextureFormatCapability()
+      .then((result) => {
+        if (internals.device !== device || internals.deviceScope.generation !== generation) return;
+        ssrFormatReceipt = result.ok ? result.value : undefined;
+      })
+      .catch(() => {
+        if (internals.device === device && internals.deviceScope.generation === generation) {
+          ssrFormatReceipt = undefined;
+        }
+      })
+      .finally(() => {
+        ssrFormatProbe = undefined;
+      });
+  };
+  const cubeCaptureScheduler = createCubeCaptureScheduler({ maxFacesPerFrame: 1 });
+  const cubeCaptureState: CubeCaptureGraphState = { work: [] };
   const persistentRenderScene = new PersistentRenderScene({
     getDevice: () => internals.device,
     onGpuError: (error) => internals.errorRegistry.fire(error),
@@ -908,6 +1307,23 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         ),
     } satisfies import('./pipeline-builder').PipelineBuilderShaderModuleFactory);
   let gpuDrivenProduction = new GpuDrivenProduction(internals.device, gpuDrivenShaderFactory);
+  let occlusionRuntime: OcclusionRenderRuntime | undefined = new OcclusionRenderRuntime(
+    internals.device,
+    persistentRenderScene.visibilityFacetStore(),
+    gpuDrivenShaderFactory,
+    persistentRenderScene.visibilityBudgetValue(),
+  );
+  const ensureOcclusionRuntime = (): OcclusionRenderRuntime => {
+    if (occlusionRuntime === undefined) {
+      occlusionRuntime = new OcclusionRenderRuntime(
+        internals.device,
+        persistentRenderScene.visibilityFacetStore(),
+        gpuDrivenShaderFactory,
+        persistentRenderScene.visibilityBudgetValue(),
+      );
+    }
+    return occlusionRuntime;
+  };
   const featureGpuWork: RenderFeatureGpuWorkOwner = createRenderFeatureGpuWorkOwner({
     getDevice: () => internals.device,
     getShaderModuleFactory: () =>
@@ -955,15 +1371,18 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   // raw (material-handle-based, cross-world collision semantically correct).
   const frameState: RenderFrameState = {
     frameNumber: 0,
+    reflectionFallbackDemand: false,
     graphGeneration: 0,
     successfulTemporalFrameIndex: 0,
     lastSuccessfulBloom: 'off',
     temporalFrameTransaction: createTemporalFrameTransaction({ deviceEpoch: 0 }),
     temporalFrameInput: undefined,
+    reflectionFallbackReadback: undefined,
     directionalShadowCache: null,
     directionalShadowCacheRecorded: false,
     compiledFrameGraph: null,
     compiledFrameGraphTopologyKey: null,
+    compiledFrameGraphGeneration: 0,
     volumetricFogPreviousGraph: null,
     volumetricFogPreviousGraphKey: null,
     volumetricFogCandidateGraph: null,
@@ -980,6 +1399,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     volumetricFogHistorySignature: null,
     retiredCompiledFrameGraphs: new Set(),
     currentFrameObservationSource: undefined,
+    reflectionFallbackObservationSource: undefined,
     lastSuccessfulCameraAntialias: undefined,
     temporalGpuState: undefined,
     activeTemporalGpuState: undefined,
@@ -991,16 +1411,19 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     currentDirectionalShadowView: null,
     currentSpotShadowView: null,
     instanceBuffers: new Map(),
+    probeBlendBuffers: new Map(),
+    probeBlendRecordBufferCapacity: 0,
     morphBuffers: new Map(),
     hdrpClusterBinScratch: createClusterBinScratch(),
     hdrpClusterGridScratch: null,
     hdrpLightIndexListScratch: null,
-    hdrpClusterMembershipBindGroup: null,
+    hdrpClusterMembership: null,
+    standardLightingGraphSignature: '',
+    standardLightingInspection: undefined,
+    pointShadowInspection: undefined,
     transientInstanceBuffers: [],
     warnedZeroLightStandard: false,
     warnedMultiLightDirectional: false,
-    warnedMultiLightPoint: false,
-    warnedMultiLightSpot: false,
     // feat-20260630-equirect-kind-internalized-ibl-declarative-skyligh M3 / w19:
     // once-warn latches for >1 Skylight / >1 SkyboxBackground (names winner).
     warnedMultiSkylight: false,
@@ -1051,10 +1474,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
@@ -1073,6 +1493,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;
@@ -1133,66 +1556,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);
     }
-    for (const [id, buffer] of postProcessParamsBuffers) {
-      if (declarations.has(id)) continue;
-      internals.device.destroyBuffer(buffer);
-      postProcessParamsBuffers.delete(id);
+    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();
     }
   };
-  // feat-20260609 M4 / T-10-a: post-process pipeline cache (id|colorFormat -> RhiRenderPipeline).
+  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 (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;
@@ -1202,6 +1683,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,
@@ -1217,6 +1706,134 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   const dispatchCounts: { unlit: number } = {
     unlit: 0,
   };
+  let lastLodOcclusionInspection: LodOcclusionInspection | undefined;
+  // The GPU selector returns stable numeric World keys with its same-submit
+  // counters. Keep the attachment join from that submit, rather than using
+  // the current worlds[] position when the asynchronous readback completes.
+  let lastLodWorldAttachments: ReadonlyMap<number, string> = new Map();
+  let occlusionCandidateCache:
+    | {
+        readonly renderables: readonly RenderableSnapshot[];
+        readonly camera: CameraSnapshot;
+        readonly cameraWorldIdentity: string;
+        readonly candidates: readonly OcclusionRuntimeCandidate[];
+      }
+    | undefined;
+  let lodCandidateCountCache:
+    | { readonly renderables: readonly RenderableSnapshot[]; readonly count: number }
+    | undefined;
+  let lodInspectionRenderablesCache:
+    | {
+        readonly submissionRenderables: readonly RenderableSnapshot[];
+        readonly lodCandidateCount: number;
+        readonly values: readonly RenderableSnapshot[];
+      }
+    | undefined;
+  let orderedDispatchCache:
+    | {
+        readonly source: readonly DispatchEntry[];
+        readonly world: World;
+        readonly camera: readonly CameraSnapshot[];
+        readonly renderables: readonly RenderableSnapshot[];
+        readonly value: readonly DispatchEntry[];
+      }
+    | undefined;
+  const applyLodSelectionTelemetry = (
+    selection:
+      | {
+          readonly candidateCount: number;
+          readonly visible: number;
+          readonly occluded: number;
+          readonly lodHistogram: readonly { readonly level: number; readonly count: number }[];
+          readonly worldSelections?: readonly {
+            readonly worldKey: number;
+            readonly primitiveSlot: number;
+            readonly slotGeneration: number;
+            readonly candidateCount: number;
+            readonly visible: number;
+            readonly occluded: number;
+            readonly lodHistogram: readonly { readonly level: number; readonly count: number }[];
+          }[];
+        }
+      | undefined,
+  ): void => {
+    if (selection === undefined || lastLodOcclusionInspection === undefined) return;
+    const inspection = lastLodOcclusionInspection;
+    // The GPU readback histogram is the selector fact, while final submitted
+    // counts are owned by the persistent visibility projection. Keeping the
+    // projection count here excludes ordinary non-LOD geometry (for example a
+    // benchmark occluder) from the LOD workload without inventing a second
+    // visibility owner or mixing CPU/GPU admission decisions.
+    let worlds = inspection.worlds;
+    const worldSelections = selection.worldSelections;
+    if (worldSelections !== undefined && worldSelections.length > 0) {
+      const selectionsByAttachment = new Map<string, (typeof worldSelections)[number][]>();
+      let attributionValid = true;
+      for (const selected of worldSelections) {
+        const attachmentId = lastLodWorldAttachments.get(selected.worldKey);
+        if (attachmentId === undefined) {
+          attributionValid = false;
+          break;
+        }
+        const rows = selectionsByAttachment.get(attachmentId);
+        if (rows === undefined) selectionsByAttachment.set(attachmentId, [selected]);
+        else rows.push(selected);
+      }
+      if (attributionValid) {
+        const nextWorlds = worlds.map((world) => {
+          const selected = selectionsByAttachment.get(world.attachmentId);
+          const baseRow = world.rows[0];
+          if (selected === undefined || baseRow === undefined) {
+            if (world.rows.length > 0) attributionValid = false;
+            return world;
+          }
+          const candidateCount = selected.reduce((sum, row) => sum + row.candidateCount, 0);
+          if (candidateCount !== baseRow.count.candidates) {
+            attributionValid = false;
+            return world;
+          }
+          return Object.freeze({
+            ...world,
+            attribution: Object.freeze({
+              status: 'same-submit' as const,
+              submit: inspection.submit,
+            }),
+            rows: Object.freeze(
+              selected.map((row) => ({
+                ...baseRow,
+                slot: {
+                  primitiveSlot: row.primitiveSlot,
+                  slotGeneration: row.slotGeneration,
+                },
+                count: {
+                  candidates: row.candidateCount,
+                  visible: row.visible,
+                  occluded: row.occluded,
+                },
+                lodHistogram: row.lodHistogram,
+              })),
+            ),
+          });
+        });
+        if (attributionValid) worlds = Object.freeze(nextWorlds);
+      }
+    }
+    lastLodOcclusionInspection = inspectLodOcclusion({
+      ...inspection,
+      count: {
+        ...lastLodOcclusionInspection.count,
+        candidates: selection.candidateCount,
+        visible: selection.visible,
+        occluded: selection.occluded,
+      },
+      lodHistogram: selection.lodHistogram,
+      // Per-primitive samples are intentionally omitted until the GPU readback
+      // carries stable primitive identities; the histogram is the authoritative
+      // producer fact and is copied from the same GPU cull counters.
+      samples: [],
+      worlds,
+    });
+  };
   // feat-20260531-per-frame-bind-group-cache M1 / w4: per-frame
   // createBindGroup counter scaffolding. Reset on every draw([world], { cameraOwner: 0, resourceOwner: 0 }) entry,
   // bumped on cache-miss in render-system-record.ts (M2-M4 bump points).
@@ -1376,7 +1993,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),
     });
   };
@@ -1387,8 +2004,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,
@@ -1412,6 +2027,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);
@@ -1580,6 +2196,47 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         gpuDriven: gpuDrivenProduction.inspect(),
       };
     },
+    get gpuDrivenInspection(): GpuDrivenProductionInspection {
+      return gpuDrivenProduction.inspect();
+    },
+    get reflectionProbes(): ReflectionProbeInspection {
+      return reflectionProbeOwner.inspect();
+    },
+    get ssrDependencies(): SsrDependenciesInspection {
+      ensureSsrFormatProbe();
+      const owner = reflectionProbeOwner.inspect();
+      const nextGeneration = owner.reflectionFallback.projectionGeneration;
+      const reset = resolveSsrAdmissionGeneration(ssrFallbackGeneration, nextGeneration);
+      if (reset.changed) {
+        frameState.temporalFrameTransaction.reset('signature-change');
+        frameState.temporalFrame = undefined;
+        frameState.temporalFrameInput = undefined;
+        frameState.lastSuccessfulTemporalView = undefined;
+        frameState.successfulTemporalFrameIndex = 0;
+        frameState.pendingTemporalCommit = { kind: 'none' };
+      }
+      ssrFallbackGeneration = reset.generation;
+      const temporal =
+        frameState.lastSuccessfulTemporalView === undefined
+          ? undefined
+          : ({
+              successfulSubmit: true,
+              generation: frameState.lastSuccessfulTemporalView.input.deviceGeneration,
+            } as const);
+      return projectSsrDependencies({
+        requested: frameState.reflectionFallbackDemand === true,
+        identity: internals.ssrIdentity,
+        reflectionFallback: owner.reflectionFallback,
+        format: ssrFormatReceipt,
+        temporal,
+      });
+    },
+    get reflectionFallbackCompletion(): Promise<void> | undefined {
+      return frameState.reflectionFallbackCompletion;
+    },
+    isCubeCapturePending(target: RenderTarget): boolean {
+      return cubeCaptureScheduler.inspect(target).candidateGeneration !== undefined;
+    },
     get environment(): EnvironmentInspection {
       return environmentLifecycle.inspect();
     },
@@ -1646,6 +2303,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         }),
       });
     },
+    get lodOcclusionInspection(): LodOcclusionInspection | undefined {
+      return lastLodOcclusionInspection;
+    },
     get bloom(): BloomInspection {
       const pipelineState = internals.getPipelineState();
       const resources = pipelineState?.perPassResources;
@@ -1672,6 +2332,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();
     },
@@ -1741,20 +2444,27 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             worlds,
             { cameraOwner, resourceOwner },
             internals.assets.catalogEpoch,
-            () =>
+            (renderables) =>
               extractFrames(
                 worlds,
                 { cameraOwner, resourceOwner },
                 internals.assets,
                 internals.getPipelineState(),
                 persistentRenderScene.materialSnapshotCacheStore(),
-                { cull: 'none' },
+                {
+                  cull: 'none',
+                  renderables,
+                  ...(internals.getMaterialShaderArtifact === undefined
+                    ? {}
+                    : { getMaterialShaderArtifact: internals.getMaterialShaderArtifact }),
+                },
               ),
             renderReadLeases,
           );
         });
         const {
           cameras,
+          cubeCameras,
           lights,
           environment,
           environmentReady,
@@ -1765,18 +2475,296 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           skylightCount,
           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],
+          frameState.frameNumber,
+          skylight,
+        );
         latestCamera = cameras[0];
+        persistentRenderScene.updateVisibilityFacet(worlds, latestCamera, renderables);
+        let occlusionProjection:
+          | import('./scene/visibility/occlusion-runtime').OcclusionFrameProjection
+          | undefined;
+        let occlusionFallback: LodOcclusionInspection['fallback'] = { active: false };
+        const worldKeys = persistentRenderScene.visibilityWorldKeysFor(worlds);
+        const slotByEntity = persistentRenderScene.compositionSlotByStableEntity();
+        if (latestCamera !== undefined) {
+          const camera = latestCamera;
+          const cameraWorld = worlds[camera.worldId ?? cameraOwner];
+          const view = viewKey({
+            attachmentId: cameraWorld?.identity ?? 'missing-camera-world',
+            cameraEntity: camera.entityKey ?? 0,
+            viewRole: 'main',
+            viewGeneration: camera.historyVersion ?? 0,
+          });
+          const cachedCandidates = occlusionCandidateCache;
+          const candidates =
+            cachedCandidates?.renderables === renderables &&
+            cachedCandidates.camera === camera &&
+            cachedCandidates.cameraWorldIdentity === (cameraWorld?.identity ?? '')
+              ? cachedCandidates.candidates
+              : renderables.flatMap((renderable) => {
+                  const world = worlds[renderable.worldId];
+                  const aabb = renderable.localAabb;
+                  // Occlusion is a LOD transport concern. A plain mesh has no
+                  // lower-detail range to select, so keep it on the ordinary CPU
+                  // visibility path and do not allocate query resources for it.
+                  if (
+                    world === undefined ||
+                    cameraWorld === undefined ||
+                    aabb === undefined ||
+                    aabb.length < 6 ||
+                    renderable.lods === undefined ||
+                    renderable.lods.length === 0
+                  )
+                    return [];
+                  const slot = slotByEntity.get(
+                    worldEntityKey(
+                      worldKeys[renderable.worldId] ?? renderable.worldId,
+                      renderable.entityKey,
+                    ),
+                  );
+                  if (slot === undefined) return [];
+                  const primitive = primitiveKey({
+                    attachmentId: cameraWorld.identity,
+                    worldGeneration: worldKeys[renderable.worldId] ?? renderable.worldId,
+                    primitiveSlot: slot.slot,
+                    slotGeneration: slot.generation,
+                  });
+                  return [
+                    {
+                      view,
+                      primitive,
+                      epoch: 0,
+                      bounds: {
+                        min: [aabb[0] ?? 0, aabb[1] ?? 0, aabb[2] ?? 0] as [number, number, number],
+                        max: [aabb[3] ?? 0, aabb[4] ?? 0, aabb[5] ?? 0] as [number, number, number],
+                      },
+                      candidate: { level: 0, confidence: 1 },
+                      deviceGeneration: internals.deviceScope.generation,
+                      proxyVertices: buildOcclusionProxyVertices(
+                        aabb,
+                        renderable.transform.world,
+                        camera,
+                      ),
+                    },
+                  ];
+                });
+          occlusionCandidateCache = {
+            renderables,
+            camera,
+            cameraWorldIdentity: cameraWorld?.identity ?? '',
+            candidates,
+          };
+          occlusionProjection = runProfiledRenderPhase(profileSession, 'occlusion-prepare', () =>
+            ensureOcclusionRuntime().prepareBatch(candidates, camera.antialias === 'msaa' ? 4 : 1),
+          );
+          const queryPool = ensureOcclusionRuntime().inspect();
+          const queryUnavailable = ensureOcclusionRuntime().prepareUnavailable;
+          const queryCapacityFallback =
+            candidates.length > 0 && queryUnavailable && queryPool.availablePages === 0;
+          occlusionFallback = queryCapacityFallback
+            ? {
+                active: true as const,
+                reason: 'page-exhausted' as const,
+                error: {
+                  code: 'visibility-query-capacity-exhausted',
+                  expected: 'one available occlusion-query page for the LOD candidate batch',
+                  hint: 'retry the LOD query after an in-flight page completes',
+                  detail: {
+                    availablePages: queryPool.availablePages,
+                    pageCount: queryPool.pageCount,
+                    pageIndexLimit: queryPool.pageIndexLimit,
+                  },
+                },
+              }
+            : ({ active: false } as const);
+        }
+        // Query transport is best-effort and must fail open. A candidate that
+        // was hidden by an earlier completion becomes visible again when this
+        // device/frame cannot reserve a fresh query page; the next successful
+        // submission can rebuild confidence from a real result.
+        if (
+          occlusionProjection === undefined &&
+          latestCamera !== undefined &&
+          ensureOcclusionRuntime().prepareUnavailable
+        ) {
+          const cameraWorld = worlds[latestCamera.worldId ?? cameraOwner];
+          if (cameraWorld !== undefined) {
+            const fallbackView = viewKey({
+              attachmentId: cameraWorld.identity,
+              cameraEntity: latestCamera.entityKey ?? 0,
+              viewRole: 'main',
+              viewGeneration: latestCamera.historyVersion ?? 0,
+            });
+            for (const renderable of renderables) {
+              if ((renderable.lods?.length ?? 0) === 0) continue;
+              const world = worlds[renderable.worldId];
+              if (world === undefined) continue;
+              const slot = slotByEntity.get(
+                worldEntityKey(
+                  worldKeys[renderable.worldId] ?? renderable.worldId,
+                  renderable.entityKey,
+                ),
+              );
+              if (slot === undefined) continue;
+              persistentRenderScene.visibilityFacetStore().applyConfidence(
+                fallbackView,
+                primitiveKey({
+                  attachmentId: cameraWorld.identity,
+                  worldGeneration: worldKeys[renderable.worldId] ?? renderable.worldId,
+                  primitiveSlot: slot.slot,
+                  slotGeneration: slot.generation,
+                }),
+                { type: 'failure', submissionGeneration: frameState.frameNumber },
+              );
+            }
+          }
+        }
+        const visibilityProjection = persistentRenderScene.projectVisibility(
+          worlds,
+          latestCamera,
+          renderables,
+          dispatch,
+        );
+        const submissionRenderables = visibilityProjection.renderables;
+        const submissionDispatch = visibilityProjection.dispatch;
+        const inspectionCamera = latestCamera;
+        let lodCandidateCountForFrame = 0;
+        if (inspectionCamera !== undefined) {
+          const firstRenderable = renderables[0];
+          const lodCandidateCount =
+            lodCandidateCountCache?.renderables === renderables
+              ? lodCandidateCountCache.count
+              : (() => {
+                  const count = renderables.reduce(
+                    (total, renderable) => total + ((renderable.lods?.length ?? 0) > 0 ? 1 : 0),
+                    0,
+                  );
+                  lodCandidateCountCache = { renderables, count };
+                  return count;
+                })();
+          lodCandidateCountForFrame = lodCandidateCount;
+          const inspectionRenderables =
+            lodInspectionRenderablesCache?.submissionRenderables === submissionRenderables &&
+            lodInspectionRenderablesCache.lodCandidateCount === lodCandidateCount
+              ? lodInspectionRenderablesCache.values
+              : (() => {
+                  const values =
+                    lodCandidateCount > 0
+                      ? submissionRenderables.filter(
+                          (renderable) => (renderable.lods?.length ?? 0) > 0,
+                        )
+                      : submissionRenderables;
+                  lodInspectionRenderablesCache = {
+                    submissionRenderables,
+                    lodCandidateCount,
+                    values,
+                  };
+                  return values;
+                })();
+          const candidateCount =
+            lodCandidateCount > 0 ? lodCandidateCount : renderables.length + frustumStats.culled;
+          const inspectionQuery = ensureOcclusionRuntime().inspect();
+          const inspectionBudget = persistentRenderScene.visibilityBudgetValue();
+          const inspectionWorlds = createLodWorldInspections(
+            worlds,
+            renderables,
+            submissionRenderables,
+            inspectionCamera,
+            frameState.frameNumber,
+            worldKeys,
+            slotByEntity,
+            {
+              used:
+                inspectionQuery.pageCount * inspectionQuery.pageIndexLimit -
+                inspectionQuery.availablePages * inspectionQuery.pageIndexLimit,
+              capacity: inspectionQuery.pageCount * inspectionQuery.pageIndexLimit,
+            },
+            occlusionFallback,
+            ensureOcclusionRuntime().prepareUnavailable
+              ? { active: true, reason: 'query-unavailable' as const }
+              : { active: false },
+          );
+          const attachmentByWorldKey = new Map<number, string>();
+          for (let worldId = 0; worldId < worlds.length; worldId += 1) {
+            const world = worlds[worldId];
+            if (world === undefined) continue;
+            const worldKey = worldKeys[worldId] ?? worldId;
+            if (attachmentByWorldKey.has(worldKey)) {
+              attachmentByWorldKey.clear();
+              break;
+            }
+            attachmentByWorldKey.set(worldKey, world.identity);
+          }
+          lastLodWorldAttachments = attachmentByWorldKey;
+          lastLodOcclusionInspection = inspectLodOcclusion({
+            root: {
+              guid:
+                firstRenderable === undefined
+                  ? 'none'
+                  : `asset-handle:${firstRenderable.assetHandle}`,
+              sourceKey: `render-frame:${frameState.frameNumber}`,
+            },
+            view: {
+              attachmentId: worlds[inspectionCamera.worldId ?? cameraOwner]?.identity ?? 'none',
+              cameraEntity: inspectionCamera.entityKey ?? 0,
+              viewRole: 'main',
+              viewGeneration: inspectionCamera.historyVersion ?? 0,
+            },
+            slot: {
+              primitiveSlot: 0,
+              slotGeneration: persistentRenderScene.inspect().topology.revision,
+            },
+            generation: frameState.frameNumber,
+            count: {
+              candidates: candidateCount,
+              visible: inspectionRenderables.length,
+              occluded: visibilityProjection.suppressed,
+            },
+            lodHistogram: [{ level: 0, count: inspectionRenderables.length }],
+            queryLatencyUs: { median: 0, p95: 0, last: 0 },
+            pagePressure: { used: 0, capacity: 3 * 4096 },
+            fallback: occlusionFallback,
+            degradation: ensureOcclusionRuntime().prepareUnavailable
+              ? { active: true, reason: 'query-unavailable' as const }
+              : { active: false },
+            samples: inspectionRenderables.slice(0, 64).map((_, index) => ({
+              primitiveSlot: index,
+              level: 0,
+              visible: true,
+            })),
+            submit: {
+              frameId: frameState.frameNumber,
+              build: resolveInspectionBuild(internals),
+              deviceGeneration: internals.deviceScope.generation,
+            },
+            budget: inspectionBudget,
+            worlds: inspectionWorlds,
+          });
+        } else {
+          lastLodOcclusionInspection = undefined;
+          lastLodWorldAttachments = new Map();
+        }
         const temporalDemanded =
           cameras[0]?.antialias === 'taa' || (cameras[0]?.motionBlur?.shutterAngle ?? 0) > 0;
         if (temporalDemanded) {
-          persistentRenderScene.prepareTemporalFrame(renderables);
+          persistentRenderScene.prepareTemporalFrame(submissionRenderables);
         }
         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.
@@ -1805,15 +2793,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;
@@ -1879,14 +2873,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,
@@ -1900,6 +2903,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;
@@ -1911,9 +2937,31 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         // world that owns skylight / skybox / singleton render state, w5 / D-3).
         // Only the Transparent segment is reordered; queue ordering between
         // segments (sortDispatchByQueue, stable) is preserved.
-        const orderedDispatch = runProfiledRenderPhase(profileSession, 'sort', () =>
-          sortTransparentDispatch(dispatch, resourceWorld, cameras, renderables),
-        );
+        const orderedDispatch = runProfiledRenderPhase(profileSession, 'sort', () => {
+          const cached = orderedDispatchCache;
+          if (
+            cached?.source === submissionDispatch &&
+            cached.world === resourceWorld &&
+            cached.camera === cameras &&
+            cached.renderables === submissionRenderables
+          ) {
+            return cached.value;
+          }
+          const value = sortTransparentDispatch(
+            [...submissionDispatch],
+            resourceWorld,
+            cameras,
+            submissionRenderables,
+          );
+          orderedDispatchCache = {
+            source: submissionDispatch,
+            world: resourceWorld,
+            camera: cameras,
+            renderables: submissionRenderables,
+            value,
+          };
+          return value;
+        });
 
         // M3 / w26: single dispatch list replaces old three-bucket model.
         // Pass dispatch to recordFrame — the record stage iterates dispatch
@@ -1941,13 +2989,16 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 // The same runner is also called by geometry/material helpers;
                 // invoking those wrappers would turn a pass probe into the
                 // high-overhead per-draw `nested` probe.
-                if (
-                  profileSession.detail === 'passes' &&
-                  (!phase.startsWith('record/graph-execute/') ||
-                    (phase.slice('record/graph-execute/'.length).includes('/') &&
-                      !phase.endsWith('/geometry-loop')))
-                ) {
-                  return action();
+                if (profileSession.detail === 'passes') {
+                  const isOcclusionOwner =
+                    phase === 'record/occlusion-query-submit' ||
+                    phase === 'record/occlusion-global-advance';
+                  const isGraphOwner =
+                    phase === 'record/graph-execute' ||
+                    (phase.startsWith('record/graph-execute/') &&
+                      (!phase.slice('record/graph-execute/'.length).includes('/') ||
+                        phase.endsWith('/geometry-loop')));
+                  if (!isOcclusionOwner && !isGraphOwner) return action();
                 }
                 return runProfiledRenderPhase(profileSession, phase, action);
               };
@@ -1960,7 +3011,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             resourceWorld,
             cameras,
             lights,
-            renderables,
+            [...submissionRenderables],
             orderedDispatch,
             frameState,
             dispatchCounts,
@@ -1970,20 +3021,28 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             skybox,
             skyboxCount,
             postProcessParams,
-            fog,
             worlds,
             recordProfilePhase,
             {
               owner: gpuDrivenProduction,
               scene: persistentRenderScene.compositionGpuDrivenState(),
-              onCoverage: (ownsAll) => {
-                const key = `${internals.gpuStore.meshResidencyEpoch}:${frameState.isHdrpActive ? 'hdrp' : 'urp'}`;
-                persistentRenderScene.setCompositionGpuDrivenCoverage(key, ownsAll);
+              onSceneDemand: (sceneRowsRequired) => {
+                persistentRenderScene.setCompositionGpuSceneDemand(sceneRowsRequired);
               },
+              activeEntityKeys: visibilityProjection.activeEntityKeys,
+              activeEntityRevision: visibilityProjection.activeEntityRevision,
+              telemetryCandidateCount: lodCandidateCountForFrame,
+              ...(occlusionProjection === undefined ? {} : { occlusion: occlusionProjection }),
             },
             renderReadLeases,
             featureGraphCandidate,
             pointsLinesOwner,
+            {
+              snapshots: cubeCameras,
+              scheduler: cubeCaptureScheduler,
+              state: cubeCaptureState,
+              reflectionProbes: reflectionProbeRecord,
+            } satisfies CubeCaptureFrameInput,
             environment?.environmentSignature ?? '',
             environment?.fogSignature ?? '',
             environmentReady && environment !== undefined,
@@ -1992,7 +3051,50 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             timingCapture,
           ),
         );
+        if (submitted && lastLodOcclusionInspection !== undefined) {
+          const query = ensureOcclusionRuntime().inspect();
+          lastLodOcclusionInspection = {
+            ...lastLodOcclusionInspection,
+            pagePressure: {
+              used:
+                query.pageCount * query.pageIndexLimit -
+                query.availablePages * query.pageIndexLimit,
+              capacity: query.pageCount * query.pageIndexLimit,
+            },
+            fallback: occlusionFallback,
+            degradation: ensureOcclusionRuntime().prepareUnavailable
+              ? { active: true, reason: 'query-unavailable' as const }
+              : { active: false },
+          };
+        }
+        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) {
+          if (occlusionProjection === undefined) {
+            runProfiledRenderPhase(profileSession, 'record/occlusion-global-advance', () =>
+              ensureOcclusionRuntime().advanceSuccessfulSubmit(frameState.frameNumber),
+            );
+          }
           const temporalCommit = persistentRenderScene.commitTemporalFrame();
           if (!temporalCommit.ok) {
             internals.errorRegistry.fire(temporalCommit.error);
@@ -2071,6 +3173,21 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       const currentFrameId = frameState.frameNumber - 1;
       return observeCurrentFrame(options, frameState.currentFrameObservationSource, currentFrameId);
     },
+    async observeLodOcclusion(): Promise<void> {
+      await ensureOcclusionRuntime().waitForCompletions();
+      applyLodSelectionTelemetry(await gpuDrivenProduction.readLodSelection());
+      if (lastLodOcclusionInspection !== undefined) {
+        const queryLatency = ensureOcclusionRuntime().inspectQueryLatency();
+        lastLodOcclusionInspection = inspectLodOcclusion({
+          ...lastLodOcclusionInspection,
+          queryLatencyUs: {
+            median: queryLatency.median,
+            p95: queryLatency.p95,
+            last: queryLatency.last,
+          },
+        });
+      }
+    },
     getCurrentGraphTarget(name: string) {
       const graph = frameState.perFrameGraph;
       if (graph === undefined || graph === null) return undefined;
@@ -2127,9 +3244,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         profileConfig === undefined
           ? config
           : {
-              ...(profileConfig.lighting === 'clustered'
-                ? { clusterGrid: DEFAULT_CLUSTER_GRID }
-                : {}),
+              clusterGrid: DEFAULT_CLUSTER_GRID,
               ...(profileConfig.ssao ? { ssao: { enabled: true } } : {}),
               ...config,
             };
@@ -2154,16 +3269,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 {
@@ -2207,6 +3312,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);
@@ -2216,9 +3322,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);
@@ -2226,16 +3331,25 @@ 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();
+      occlusionRuntime?.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
@@ -2276,9 +3390,14 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       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);
@@ -2289,6 +3408,15 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // dispose error strategy).
       disposeInstanceBuffers(frameState.instanceBuffers, internals.errorRegistry);
       disposeTransientInstanceBuffers(frameState.transientInstanceBuffers, internals.errorRegistry);
+      if (frameState.probeBlendRecordBuffer !== undefined) {
+        if (!frameState.probeBlendRecordBuffer.isDestroyed) {
+          const result = frameState.probeBlendRecordBuffer.destroy();
+          if (!result.ok) internals.errorRegistry.fire(result.error);
+        }
+        delete frameState.probeBlendRecordBuffer;
+      }
+      frameState.probeBlendRecordBufferCapacity = 0;
+      frameState.probeBlendBuffers.clear();
       if (frameState.morphBuffers !== undefined) {
         for (const entry of frameState.morphBuffers.values()) {
           if (!entry.buffer.isDestroyed) {
@@ -2309,10 +3437,19 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       }
     },
     resetForRecover(): void {
+      ssrFormatReceipt = undefined;
+      ssrFormatProbeGeneration = -1;
+      ssrFormatProbe = undefined;
+      ssrFallbackGeneration = undefined;
       transmissionAdmission.markDeviceLost();
       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
@@ -2321,7 +3458,13 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       persistentRenderScene.resetGpuForRecover();
       gpuDrivenProduction.dispose();
       gpuDrivenProduction = new GpuDrivenProduction(internals.device, gpuDrivenShaderFactory);
+      occlusionRuntime?.dispose();
+      // The replacement device is installed by the host after this hook. Do
+      // not recreate device-bound query resources against the lost device;
+      // the first post-recovery frame lazily binds the current device.
+      occlusionRuntime = undefined;
       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.
@@ -2351,10 +3494,23 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       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;
       frameState.lastSuccessfulCameraAntialias = undefined;
+      frameState.temporalFrameTransaction.reset('device-recovery');
+      frameState.temporalFrame = undefined;
+      frameState.temporalFrameInput = undefined;
+      frameState.lastSuccessfulTemporalView = undefined;
+      frameState.successfulTemporalFrameIndex = 0;
+      frameState.pendingTemporalCommit = { kind: 'none' };
       frameState.currentDirectionalShadowView = null;
       frameState.currentSpotShadowView = null;
       if (frameState.temporalGpuState !== undefined) {
@@ -2369,11 +3525,15 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         retireTemporalGpuState(retiring);
       }
       frameState.retiringTemporalGpuStates.clear();
+      frameState.hdrpClusterMembership = null;
       for (const retired of frameState.retiredCompiledFrameGraphs) {
         retired.retire().catch(() => undefined);
       }
       frameState.retiredCompiledFrameGraphs.clear();
       frameState.instanceBuffers.clear();
+      delete frameState.probeBlendRecordBuffer;
+      frameState.probeBlendRecordBufferCapacity = 0;
+      frameState.probeBlendBuffers.clear();
       frameState.morphBuffers?.clear();
       frameState.transientInstanceBuffers = [];
       frameState.pointShadowAtlas = null;
@@ -2441,6 +3601,71 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   };
 }
 
+function buildOcclusionProxyVertices(
+  aabb: ArrayLike<number>,
+  world: ArrayLike<number>,
+  camera: import('./render-contract').CameraSnapshot,
+): Float32Array {
+  const view = computeViewMatrix(camera);
+  const projection = computeProjectionMatrix(camera);
+  const viewProjection = mat4.create();
+  mat4.multiply(viewProjection, projection, view);
+  const corners = [
+    [aabb[0] ?? 0, aabb[1] ?? 0, aabb[2] ?? 0],
+    [aabb[3] ?? 0, aabb[1] ?? 0, aabb[2] ?? 0],
+    [aabb[3] ?? 0, aabb[4] ?? 0, aabb[2] ?? 0],
+    [aabb[0] ?? 0, aabb[4] ?? 0, aabb[2] ?? 0],
+    [aabb[0] ?? 0, aabb[1] ?? 0, aabb[5] ?? 0],
+    [aabb[3] ?? 0, aabb[1] ?? 0, aabb[5] ?? 0],
+    [aabb[3] ?? 0, aabb[4] ?? 0, aabb[5] ?? 0],
+    [aabb[0] ?? 0, aabb[4] ?? 0, aabb[5] ?? 0],
+  ];
+  const triangles = [
+    0, 1, 2, 0, 2, 3, 4, 6, 5, 4, 7, 6, 0, 4, 5, 0, 5, 1, 3, 2, 6, 3, 6, 7, 0, 3, 7, 0, 7, 4, 1, 5,
+    6, 1, 6, 2,
+  ];
+  const output = new Float32Array(triangles.length * 4);
+  for (let index = 0; index < triangles.length; index += 1) {
+    const corner = corners[triangles[index] ?? 0] ?? [0, 0, 0];
+    const cx = corner[0] ?? 0;
+    const cy = corner[1] ?? 0;
+    const cz = corner[2] ?? 0;
+    const x = (world[0] ?? 0) * cx + (world[4] ?? 0) * cy + (world[8] ?? 0) * cz + (world[12] ?? 0);
+    const y = (world[1] ?? 0) * cx + (world[5] ?? 0) * cy + (world[9] ?? 0) * cz + (world[13] ?? 0);
+    const z =
+      (world[2] ?? 0) * cx + (world[6] ?? 0) * cy + (world[10] ?? 0) * cz + (world[14] ?? 0);
+    const w =
+      (world[3] ?? 0) * cx + (world[7] ?? 0) * cy + (world[11] ?? 0) * cz + (world[15] ?? 1);
+    const base = index * 4;
+    output[base] =
+      (viewProjection[0] ?? 0) * x +
+      (viewProjection[4] ?? 0) * y +
+      (viewProjection[8] ?? 0) * z +
+      (viewProjection[12] ?? 0) * w;
+    output[base + 1] =
+      (viewProjection[1] ?? 0) * x +
+      (viewProjection[5] ?? 0) * y +
+      (viewProjection[9] ?? 0) * z +
+      (viewProjection[13] ?? 0) * w;
+    output[base + 2] =
+      (viewProjection[2] ?? 0) * x +
+      (viewProjection[6] ?? 0) * y +
+      (viewProjection[10] ?? 0) * z +
+      (viewProjection[14] ?? 0) * w;
+    output[base + 3] =
+      (viewProjection[3] ?? 0) * x +
+      (viewProjection[7] ?? 0) * y +
+      (viewProjection[11] ?? 0) * z +
+      (viewProjection[15] ?? 0) * w;
+  }
+  return output;
+}
+
+/** Resolve the build identity used by every inspection submit. */
+export function resolveInspectionBuild(internals: Pick<RenderSystemInternals, 'build'>): string {
+  return internals.build ?? 'render-system';
+}
+
 // @forgeax/engine-render - built-in record context extension.
 //
 // The public RenderPipelineContext is canonical in render-contract.ts. This