@forgeax/engine-render 0.1.33 → 0.1.35

package/src/record/typed-frame-graph.ts

@@ -1,11 +1,18 @@
+import { addTargetCaptureGraphPasses, type CubeCaptureGraphState } from './target-capture-graph';
+
+export type { CubeCaptureGraphState, CubeCaptureGraphWork } from './target-capture-graph';
+
 import { encodeMipmapLevel } from '@forgeax/engine-assets-runtime';
 import {
   type CompiledRenderGraph,
   type GraphResourceResolver,
   RenderGraphBuilder,
   RenderGraphError,
+  type RenderGraphGenerationAllocationEntry,
+  type RenderGraphGenerationAllocationInspection,
   type RenderGraphPassInstrumentation,
   type RenderGraphPassInstrumentationScope,
+  type RenderGraphResourceAllocationInspection,
 } from '@forgeax/engine-render-graph';
 import type {
   BindGroup,
@@ -23,6 +30,7 @@ import { RhiError } from '@forgeax/engine-rhi';
 import { err, ok, type Result } from '@forgeax/engine-types';
 import { executeRendererFrameTransaction } from '../assembly/renderer-frame-transaction';
 import { standardBloomAdmitted } from '../bloom-admission';
+import { CLOUD_LAYER_FEATURE_IDENTITY } from '../cloud/feature';
 import { type RenderError, RenderFeatureStageFailedError } from '../errors/render';
 import { depthOfFieldTopology } from '../features/depth-of-field/depth-of-field-feature';
 import { resolveDepthOfFieldFrameParams } from '../features/depth-of-field/depth-of-field-params';
@@ -64,11 +72,7 @@ import {
 } from '../gpu-texture-usage';
 import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM } from '../gpu-usage';
 import { createStandardSurfaceLightingBindGroup } from '../hdrp-buffers';
-import type {
-  MotionBlurExecutionPass,
-  MotionBlurExecutionReceipt,
-  RenderFeatureGraphInspection,
-} from '../inspection-types';
+import type { RenderFeatureGraphInspection } from '../inspection-types';
 import type { RenderExtent } from '../pipeline/render-extent';
 import {
   type StandardTopologyInputValue,
@@ -95,15 +99,15 @@ import type {
 import type { ExtractedLights, ExtractedVolumetricFog } from '../render-system-extract';
 import { SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS } from '../shadow-atlas';
 import type { SsrAdmissionResult, SsrSpatialAdmission } from '../ssr/admission';
-import type { RenderTarget } from '../targets/contracts';
-import type { RenderTargetPhysical } from '../targets/physical';
 import {
   abortTemporalGpuSubmit,
+  CLOUD_HISTORY_FORMATS,
   commitTemporalGpuSubmit,
   getTemporalGpuState,
   hasPendingTemporalGpuSubmit,
   retireTemporalGpuState,
   retireTemporalGpuStateAfterFence,
+  stageTemporalGpuSubmit,
   TEMPORAL_HISTORY_FORMATS,
   temporalReadIndex,
   temporalWriteIndex,
@@ -124,6 +128,7 @@ import type { GpuPassTimingPassIdentity } from './gpu-pass-timing/contract.js';
 import type { GpuPassTimingCapture, GpuPassTimingSession } from './gpu-pass-timing/session.js';
 import type { GpuTimingCapture } from './gpu-timing';
 import { encodeMainPass } from './main-pass';
+import { deriveMotionBlurExecutionReceipt } from './motion-blur-receipt';
 import type {
   _InternalRenderPipelineContext,
   PipelineState,
@@ -327,6 +332,125 @@ function importTemporalHistoryTargets(
   };
 }
 
+type CloudHistoryKind = keyof typeof CLOUD_HISTORY_FORMATS;
+
+function cloudHistorySurface(
+  state: import('../temporal/gpu').TemporalGpuState,
+  kind: CloudHistoryKind,
+  index: 0 | 1,
+): { readonly texture: Texture; readonly view: TextureView } {
+  if (!state.cloudHistoryEnabled) {
+    throw new Error('cloud history target resolved without a cloud-enabled temporal state');
+  }
+  switch (kind) {
+    case 'radiance':
+      if (state.cloudRadiance === undefined)
+        throw new Error('cloud radiance history is unavailable');
+      return state.cloudRadiance[index];
+    case 'transmittance':
+      if (state.cloudTransmittance === undefined)
+        throw new Error('cloud transmittance history is unavailable');
+      return state.cloudTransmittance[index];
+    case 'depth':
+      if (state.cloudDepth === undefined) throw new Error('cloud depth history is unavailable');
+      return state.cloudDepth[index];
+  }
+}
+
+/** Import one renderer-owned cloud history attachment into the typed graph. */
+function importCloudHistoryTarget(
+  graph: RenderGraphBuilder<RenderPipelineFrame>,
+  label: string,
+  kind: CloudHistoryKind,
+  role: 'read' | 'write',
+): import('../render-pipeline').RenderPipelineTarget {
+  const format = CLOUD_HISTORY_FORMATS[kind];
+  const texture = graph.importTexture(
+    label,
+    {
+      format,
+      // Cloud transport/history is intentionally half-resolution. The
+      // renderer-owned temporal state allocates the same ceil(width/2) extent
+      // and the full-resolution resolve reconstructs scene colour from it.
+      size: 'half-surface',
+      usage:
+        GPU_TEXTURE_USAGE_COPY_SRC |
+        GPU_TEXTURE_USAGE_COPY_DST |
+        GPU_TEXTURE_USAGE_RENDER_ATTACHMENT |
+        GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+      domain: 'linear-hdr',
+    },
+    (frame) => {
+      const internal = frame as _InternalRenderPipelineContext;
+      const state = getTemporalGpuState(
+        internal.frameState,
+        internal.runtime.device,
+        internal.runtime.deviceScope,
+        frame.targetW,
+        frame.targetH,
+        true,
+      );
+      const index = role === 'read' ? temporalReadIndex(state) : temporalWriteIndex(state);
+      return cloudHistorySurface(state, kind, index).texture;
+    },
+  );
+  if (!texture.ok) throw texture.error;
+  const view = graph.importView(
+    texture.value,
+    { label: `${label}.view`, dimension: '2d' },
+    (frame) => {
+      const internal = frame as _InternalRenderPipelineContext;
+      const state = getTemporalGpuState(
+        internal.frameState,
+        internal.runtime.device,
+        internal.runtime.deviceScope,
+        frame.targetW,
+        frame.targetH,
+        true,
+      );
+      const index = role === 'read' ? temporalReadIndex(state) : temporalWriteIndex(state);
+      return cloudHistorySurface(state, kind, index).view;
+    },
+  );
+  if (!view.ok) throw view.error;
+  return { texture: texture.value, view: view.value, format, sampleCount: 1 };
+}
+
+function importCloudHistoryTargets(
+  graph: RenderGraphBuilder<RenderPipelineFrame>,
+): NonNullable<
+  import('../render-pipeline').RenderPipelineBuildContext<RenderPipelineFrame>['cloudHistory']
+> {
+  return {
+    currentRadiance: importCloudHistoryTarget(
+      graph,
+      'cloud-history-radiance-current',
+      'radiance',
+      'write',
+    ),
+    previousRadiance: importCloudHistoryTarget(
+      graph,
+      'cloud-history-radiance-previous',
+      'radiance',
+      'read',
+    ),
+    currentTransmittance: importCloudHistoryTarget(
+      graph,
+      'cloud-history-transmittance-current',
+      'transmittance',
+      'write',
+    ),
+    previousTransmittance: importCloudHistoryTarget(
+      graph,
+      'cloud-history-transmittance-previous',
+      'transmittance',
+      'read',
+    ),
+    currentDepth: importCloudHistoryTarget(graph, 'cloud-history-depth-current', 'depth', 'write'),
+    previousDepth: importCloudHistoryTarget(graph, 'cloud-history-depth-previous', 'depth', 'read'),
+  };
+}
+
 function importSsrHistoryTarget(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
   label: string,
@@ -485,19 +609,6 @@ export function createTemporalGraphRoster(input: {
   };
 }
 
-export interface CubeCaptureGraphWork {
-  readonly target: RenderTarget;
-  readonly faceIndex: number;
-  readonly physical: RenderTargetPhysical;
-  readonly faceCamera: import('../render-contract').CameraSnapshot;
-  readonly viewBindGroupDynamicOffset: number;
-}
-
-export interface CubeCaptureGraphState {
-  work: readonly CubeCaptureGraphWork[];
-  reflectionProbes?: ReflectionProbeGraphState;
-}
-
 export interface ReflectionProbeFilterGraphWork {
   readonly probeIndex: number;
   readonly faceIndex: number;
@@ -544,195 +655,6 @@ export function boundedReflectionProbeFilterWork(
   return state.work.slice(0, Math.max(0, state.maxStepsPerFrame));
 }
 
-function renderTargetMipCount(work: CubeCaptureGraphWork): number {
-  const { descriptor } = work.physical;
-  return descriptor.mipLevels === 1
-    ? 1
-    : Math.floor(Math.log2(Math.max(descriptor.width, descriptor.height))) + 1;
-}
-
-function addCubeCaptureGraphPasses(
-  builder: RenderGraphBuilder<RenderPipelineFrame>,
-  state: CubeCaptureGraphState,
-): Result<void, RenderGraphError> {
-  for (let index = 0; index < state.work.length; index += 1) {
-    const slot = index;
-    const initial = state.work[slot];
-    if (initial === undefined) continue;
-    const current = (): CubeCaptureGraphWork => state.work[slot] ?? initial;
-    const texture = builder.importTexture(
-      `cube-capture.${slot}.texture`,
-      {
-        format: initial.physical.descriptor.format,
-        size: {
-          width: initial.physical.descriptor.width,
-          height: initial.physical.descriptor.height,
-          depthOrArrayLayers: initial.physical.descriptor.sampleCount === 4 ? 1 : 6,
-        },
-        mipLevelCount:
-          initial.physical.descriptor.sampleCount === 4 ? 1 : renderTargetMipCount(initial),
-        sampleCount: initial.physical.descriptor.sampleCount,
-        dimension: '2d',
-        usage: 0x10 | 0x04 | 0x01,
-      },
-      () => current().physical.colorTextures[current().faceIndex] ?? initial.physical.texture,
-    );
-    if (!texture.ok) return texture;
-    const color = builder.importView(
-      texture.value,
-      {
-        label: `cube-capture.${slot}.color`,
-        dimension: '2d',
-        baseMipLevel: 0,
-        mipLevelCount: 1,
-        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
-        arrayLayerCount: 1,
-      },
-      () =>
-        current().physical.faceViews[current().faceIndex] ??
-        initial.physical.faceViews[initial.faceIndex] ??
-        initial.physical.view,
-    );
-    if (!color.ok) return color;
-    const depthTexture = builder.importTexture(
-      `cube-capture.${slot}.depth-texture`,
-      {
-        format: 'depth24plus-stencil8',
-        size: {
-          width: initial.physical.descriptor.width,
-          height: initial.physical.descriptor.height,
-          depthOrArrayLayers: initial.physical.descriptor.sampleCount === 4 ? 1 : 6,
-        },
-        mipLevelCount: 1,
-        sampleCount: initial.physical.descriptor.sampleCount,
-        dimension: '2d',
-        usage: 0x10,
-      },
-      () => current().physical.depthTextures[current().faceIndex] as Texture,
-    );
-    if (!depthTexture.ok) return depthTexture;
-    const depth = builder.importView(
-      depthTexture.value,
-      {
-        label: `cube-capture.${slot}.depth`,
-        dimension: '2d',
-        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
-        arrayLayerCount: 1,
-      },
-      () => current().physical.depthViews[current().faceIndex] as TextureView,
-    );
-    if (!depth.ok) return depth;
-    const resolveTexture =
-      initial.physical.descriptor.sampleCount === 4
-        ? builder.importTexture(
-            `cube-capture.${slot}.resolve-texture`,
-            {
-              format: initial.physical.descriptor.format,
-              size: {
-                width: initial.physical.descriptor.width,
-                height: initial.physical.descriptor.height,
-                depthOrArrayLayers: 6,
-              },
-              mipLevelCount: renderTargetMipCount(initial),
-              sampleCount: 1,
-              dimension: '2d',
-              usage: 0x10 | 0x04 | 0x01,
-            },
-            () =>
-              current().physical.resolveTexture ??
-              initial.physical.resolveTexture ??
-              initial.physical.texture,
-          )
-        : undefined;
-    if (resolveTexture !== undefined && !resolveTexture.ok) return resolveTexture;
-    const resolve =
-      resolveTexture === undefined
-        ? undefined
-        : builder.importView(
-            resolveTexture.value,
-            {
-              label: `cube-capture.${slot}.resolve`,
-              dimension: '2d',
-              baseMipLevel: 0,
-              mipLevelCount: 1,
-              baseArrayLayer: initial.faceIndex,
-              arrayLayerCount: 1,
-            },
-            () =>
-              current().physical.resolveFaceViews[current().faceIndex] ??
-              initial.physical.resolveFaceViews[initial.faceIndex] ??
-              initial.physical.resolveView,
-          );
-    if (resolve !== undefined && !resolve.ok) return resolve;
-    const added = builder.addRasterPass(`cube-capture-face.${slot}`, {
-      accesses: [
-        { resource: color.value, usage: 'color-attachment' },
-        { resource: depth.value, usage: 'depth-stencil-write' },
-        ...(resolve === undefined
-          ? []
-          : [{ resource: resolve.value, usage: 'color-attachment' as const }]),
-      ],
-      colorAttachments: [
-        {
-          view: color.value,
-          ...(resolve === undefined ? {} : { resolveTarget: resolve.value }),
-          loadOp: 'clear',
-          storeOp: 'store',
-          clearValue: () => {
-            return { r: 0, g: 0, b: 0, a: 1 };
-          },
-        },
-      ],
-      depthStencilAttachment: {
-        view: depth.value,
-        depthClearValue: 1,
-        depthLoadOp: 'clear',
-        depthStoreOp: 'store',
-        stencilClearValue: 0,
-        stencilLoadOp: 'clear',
-        stencilStoreOp: 'store',
-      },
-      encode: ({ pass, frame, resources }) => {
-        const internal = frame as _InternalRenderPipelineContext;
-        const captureColor = resources.textureView(color.value);
-        if (!captureColor.ok) return;
-        const captureDepth = resources.textureView(depth.value);
-        if (!captureDepth.ok) return;
-        const captureResolve =
-          resolve === undefined ? undefined : resources.textureView(resolve.value);
-        if (resolve !== undefined && (captureResolve === undefined || !captureResolve.ok)) return;
-        const captureResolveView = captureResolve?.ok ? captureResolve.value : null;
-        const captureContext = {
-          ...internal,
-          camera: current().faceCamera,
-          // Cube faces are raw scene captures, not display-camera HDR output.
-          // Select the PSO against the actual target attachment so an LDR
-          // cube target is rendered by a compatible forward pipeline.
-          tonemapActive: false,
-          skyboxActive: false,
-          transparentColorFormat: initial.physical.descriptor.format as GPUTextureFormat,
-          msaaActive: initial.physical.descriptor.sampleCount === 4,
-          viewBindGroupDynamicOffset: current().viewBindGroupDynamicOffset,
-          geometryColorView: captureColor.value,
-          geometryDepthView: captureDepth.value,
-          geometryColorResolveView: captureResolveView,
-          splitLdrSprite: false,
-          ldrSpritePassView: null,
-        };
-        encodeMainPass(captureContext, pass, undefined, {
-          colorViews: [captureColor.value],
-          colorFormats: [initial.physical.descriptor.format as GPUTextureFormat],
-          depthView: captureDepth.value,
-          passKind: 'forward',
-          clearColor: [0, 0, 0, 1],
-        });
-      },
-    });
-    if (!added.ok) return added;
-  }
-  return ok(undefined);
-}
-
 export function addReflectionProbeGraphPasses(
   builder: RenderGraphBuilder<RenderPipelineFrame>,
   state: ReflectionProbeGraphState,
@@ -982,6 +904,7 @@ export interface RenderFeatureGraphRuntimeState {
     string,
     import('../fullscreen-post-process-pass').PostProcessShaderEntry
   >;
+  postProcessIdentities: readonly string[];
 }
 
 /** The exact fields that define one validated feature-plan collection. */
@@ -1042,6 +965,8 @@ export interface RenderFeatureGraphCandidate {
     string,
     import('../fullscreen-post-process-pass').PostProcessShaderEntry
   >;
+  /** Public Standard post-effect identities; graph-local resources stay internal. */
+  readonly postProcessIdentities?: readonly string[];
   /**
    * Physical transient graphics resources are imported into the compiled
    * graph. Their lease therefore needs a new graph even when the declarative
@@ -1065,6 +990,216 @@ export interface RenderFeatureGraphCandidate {
 
 const featureGraphStates = new WeakMap<RenderSystemInternals, RenderFeatureGraphRuntimeState>();
 const graphDeviceGenerations = new WeakMap<object, number>();
+const graphRetirementFailures = new WeakMap<
+  RenderFrameState,
+  Set<CompiledRenderGraph<RenderPipelineFrame>>
+>();
+
+type GraphGenerationRole = 'active' | 'candidate' | 'retiring';
+type GraphGenerationStatus = 'active' | 'retiring' | 'failed' | 'retired';
+
+interface GraphGenerationAllocationRecord {
+  readonly graph: CompiledRenderGraph<RenderPipelineFrame>;
+  status: GraphGenerationStatus;
+  allocation: RenderGraphResourceAllocationInspection | undefined;
+}
+
+/**
+ * One stable allocation owner for a RenderSystem lifetime. Recovery builds a
+ * detached frame state, but that state intentionally shares this owner before
+ * it can publish a candidate into the active RenderSystem. Graph records stay
+ * here across asynchronous retirement so a successful replacement cannot
+ * erase the overlap peak before the next public inspection.
+ */
+interface GraphGenerationAllocationOwner {
+  readonly records: Map<CompiledRenderGraph<RenderPipelineFrame>, GraphGenerationAllocationRecord>;
+  peakBytes: number;
+}
+
+const graphGenerationAllocationOwners = new WeakMap<
+  RenderFrameState,
+  GraphGenerationAllocationOwner
+>();
+
+function graphGenerationAllocationOwner(
+  frameState: RenderFrameState,
+): GraphGenerationAllocationOwner {
+  const existing = graphGenerationAllocationOwners.get(frameState);
+  if (existing !== undefined) return existing;
+  const created: GraphGenerationAllocationOwner = { records: new Map(), peakBytes: 0 };
+  graphGenerationAllocationOwners.set(frameState, created);
+  return created;
+}
+
+function graphRetirementFailureSet(
+  frameState: RenderFrameState,
+): Set<CompiledRenderGraph<RenderPipelineFrame>> {
+  const existing = graphRetirementFailures.get(frameState);
+  if (existing !== undefined) return existing;
+  const created = new Set<CompiledRenderGraph<RenderPipelineFrame>>();
+  graphRetirementFailures.set(frameState, created);
+  return created;
+}
+
+/** Share the renderer-owned graph ledger with a detached recovery frame state. */
+export function shareRenderGraphGenerationAllocationOwner(
+  source: RenderFrameState,
+  target: RenderFrameState,
+): void {
+  graphGenerationAllocationOwners.set(target, graphGenerationAllocationOwner(source));
+  graphRetirementFailures.set(target, graphRetirementFailureSet(source));
+}
+
+function observeGraphGenerationAllocation(frameState: RenderFrameState): void {
+  const owner = graphGenerationAllocationOwner(frameState);
+  let simultaneousBytes = 0;
+  for (const record of owner.records.values()) {
+    if (record.status === 'retired') continue;
+    const allocation = record.graph.inspect().resourceAllocation;
+    record.allocation = allocation;
+    if (allocation !== undefined) {
+      simultaneousBytes += allocation.liveBytes + allocation.pendingRetirementBytes;
+    }
+  }
+  owner.peakBytes = Math.max(owner.peakBytes, simultaneousBytes);
+}
+
+function trackGraphGeneration(
+  frameState: RenderFrameState,
+  graph: CompiledRenderGraph<RenderPipelineFrame>,
+): void {
+  const owner = graphGenerationAllocationOwner(frameState);
+  const record = owner.records.get(graph);
+  if (record === undefined) {
+    owner.records.set(graph, { graph, status: 'active', allocation: undefined });
+  } else if (record.status === 'retired') {
+    record.status = 'active';
+  }
+  observeGraphGenerationAllocation(frameState);
+}
+
+function setGraphGenerationRetiring(
+  frameState: RenderFrameState,
+  graph: CompiledRenderGraph<RenderPipelineFrame>,
+): void {
+  const owner = graphGenerationAllocationOwner(frameState);
+  const record = owner.records.get(graph);
+  if (record === undefined) {
+    owner.records.set(graph, { graph, status: 'retiring', allocation: undefined });
+  } else if (record.status !== 'failed') {
+    record.status = 'retiring';
+  }
+}
+
+function setGraphGenerationRetirementResult(
+  frameState: RenderFrameState,
+  graph: CompiledRenderGraph<RenderPipelineFrame>,
+  succeeded: boolean,
+): void {
+  const owner = graphGenerationAllocationOwner(frameState);
+  const record = owner.records.get(graph);
+  if (record !== undefined) record.status = succeeded ? 'retired' : 'failed';
+  observeGraphGenerationAllocation(frameState);
+  // A successful graph no longer owns any handles. Keep the renderer-level
+  // peak scalar, but release the graph object from the generation map; failed
+  // and pending owners remain retained for recovery inspection.
+  if (succeeded) owner.records.delete(graph);
+}
+
+/**
+ * Project the actual RenderSystem graph-generation owners as one detached
+ * allocation receipt. The candidate and fallback graph can overlap before a
+ * submit settles; failed retirement stays visible until the frame owner is
+ * discarded instead of disappearing with the asynchronous Set entry.
+ */
+export function inspectRenderGraphGenerationAllocation(
+  frameState: RenderFrameState,
+): RenderGraphGenerationAllocationInspection {
+  const rolesByGraph = new Map<
+    CompiledRenderGraph<RenderPipelineFrame>,
+    Set<GraphGenerationRole>
+  >();
+  const add = (
+    graph: CompiledRenderGraph<RenderPipelineFrame> | null | undefined,
+    role: GraphGenerationRole,
+  ) => {
+    if (graph === null || graph === undefined) return;
+    const roles = rolesByGraph.get(graph);
+    if (roles === undefined) rolesByGraph.set(graph, new Set([role]));
+    else roles.add(role);
+  };
+  add(frameState.compiledFrameGraph, 'active');
+  add(frameState.volumetricFogCandidateGraph, 'candidate');
+  add(frameState.volumetricFogPreviousGraph, 'retiring');
+  add(frameState.depthOfFieldCandidateGraph, 'candidate');
+  add(frameState.depthOfFieldPreviousGraph, 'retiring');
+  add(frameState.barrelDistortionCandidateGraph, 'candidate');
+  add(frameState.barrelDistortionPreviousGraph, 'retiring');
+  for (const graph of frameState.retiredCompiledFrameGraphs) add(graph, 'retiring');
+  for (const graph of graphRetirementFailureSet(frameState)) add(graph, 'retiring');
+
+  const owner = graphGenerationAllocationOwner(frameState);
+  const entries: RenderGraphGenerationAllocationEntry[] = [];
+  let unavailableGenerationCount = 0;
+  for (const [graph, record] of owner.records) {
+    if (record.status === 'retired') continue;
+    const roles = rolesByGraph.get(graph) ?? new Set<GraphGenerationRole>();
+    if (record.status === 'retiring' || record.status === 'failed') roles.add('retiring');
+    if (roles.size === 0) {
+      // A candidate can be detached from the active state's role fields while
+      // it is still being prepared. Keep its owner record observable until
+      // the publication or cleanup event settles it.
+      roles.add(record.status === 'active' ? 'active' : 'retiring');
+    }
+    // Inspection is a projection of the graph's current ledger. The cached
+    // snapshot is only for event-time peak updates; using it here would make
+    // a successfully fenced graph look live after its retirement started.
+    const allocation = graph.inspect().resourceAllocation;
+    record.allocation = allocation;
+    if (allocation === undefined) {
+      unavailableGenerationCount += 1;
+      continue;
+    }
+    const retirement =
+      record.status === 'failed' ? 'failed' : roles.has('retiring') ? 'pending' : 'active';
+    entries.push({
+      generation: graph.inspect().generation,
+      roles: Object.freeze([...roles]),
+      retirement,
+      allocation,
+    });
+  }
+  entries.sort((left, right) => left.generation - right.generation);
+  const liveBytes = entries.reduce((sum, entry) => sum + entry.allocation.liveBytes, 0);
+  const pendingRetirementBytes = entries.reduce(
+    (sum, entry) => sum + entry.allocation.pendingRetirementBytes,
+    0,
+  );
+  const peakBytes = Math.max(owner.peakBytes, liveBytes + pendingRetirementBytes);
+  const failedEntries = entries.filter((entry) => entry.retirement === 'failed');
+  return Object.freeze({
+    unit: 'engine-allocation-bytes',
+    physicalResidency: 'unknown',
+    availability:
+      entries.length === 0
+        ? unavailableGenerationCount === 0
+          ? 'complete'
+          : 'unavailable'
+        : unavailableGenerationCount === 0
+          ? 'complete'
+          : 'partial',
+    unavailableGenerationCount,
+    entries: Object.freeze(entries.map((entry) => Object.freeze(entry))),
+    liveBytes,
+    pendingRetirementBytes,
+    peakBytes,
+    failedRetirementCount: failedEntries.length,
+    failedRetirementBytes: failedEntries.reduce(
+      (sum, entry) => sum + entry.allocation.liveBytes + entry.allocation.pendingRetirementBytes,
+      0,
+    ),
+  });
+}
 
 interface MutableRenderFeatureGraphInspection {
   planRevisionState: RenderFeaturePlanRevisionState;
@@ -1230,6 +1365,7 @@ export function getRenderFeatureGraphState(
   const created: RenderFeatureGraphRuntimeState = {
     plans: [],
     fullscreenEffects: new Map(),
+    postProcessIdentities: [],
   };
   featureGraphStates.set(internals, created);
   return created;
@@ -1239,6 +1375,7 @@ export function resetRenderFeatureGraphState(internals: RenderSystemInternals):
   const state = getRenderFeatureGraphState(internals);
   state.plans = [];
   state.fullscreenEffects = new Map();
+  state.postProcessIdentities = [];
 }
 
 export function reportRenderFeatureGraphError(
@@ -1357,6 +1494,7 @@ function commitFeatureCandidate(
   const state = getRenderFeatureGraphState(internals);
   state.plans = candidate.plans;
   state.fullscreenEffects = candidate.fullscreenEffects;
+  state.postProcessIdentities = candidate.postProcessIdentities ?? [];
 }
 
 function topologyOf(
@@ -1378,6 +1516,7 @@ function topologyOf(
   standardLighting: StandardTopologyInputValue | undefined,
   ssr: SsrSpatialAdmission | undefined,
   renderExtent: RenderExtent | undefined,
+  surfaceMediumActive: boolean | undefined,
   analyticFog: boolean,
 ): Result<RenderPipelineTopology, RhiError> {
   const cascadeCount = Math.max(1, Math.min(4, Math.round(lights.cascadeCount ?? 1))) as
@@ -1399,10 +1538,9 @@ function topologyOf(
     floatRenderAttachment: internals.device.caps.rgba16floatRenderable,
   });
   if (!surfaceProfile.ok) return surfaceProfile;
-  const featurePostEffects = [
-    ...(featureGraphCandidate?.fullscreenEffects ??
-      getRenderFeatureGraphState(internals).fullscreenEffects),
-  ].map(([id]) => id);
+  const featurePostEffects =
+    featureGraphCandidate?.postProcessIdentities ??
+    getRenderFeatureGraphState(internals).postProcessIdentities;
   const featurePostEffectDeclarations = [
     ...(featureGraphCandidate?.fullscreenEffects ??
       getRenderFeatureGraphState(internals).fullscreenEffects),
@@ -1461,6 +1599,7 @@ function topologyOf(
       // positive intensity changes update the recorder UBO in place.
       bloom: standardBloomAdmitted(camera) ? 'on' : 'off',
       bloomIntensity: camera.bloomIntensity,
+      barrelDistortion: !clearOnly && (camera.barrelDistortion?.strength ?? 0) > 0,
       ...(depthOfField === undefined ? {} : { depthOfField }),
     },
     atmosphere: !clearOnly && frameState.environmentFrame?.source.kind === 'atmosphere',
@@ -1514,6 +1653,16 @@ function topologyOf(
             return {
               enabled: true,
               format: volumetricFog.densityAsset.format,
+              additional: (volumetricFog.additional ?? []).flatMap((member) =>
+                member.densityAsset?.shape.viewDimension === '3d'
+                  ? [
+                      {
+                        format: member.densityAsset.format,
+                        extent: member.densityAsset.shape.extent,
+                      },
+                    ]
+                  : [],
+              ),
               extent: {
                 width: volumetricFog.densityAsset.shape.extent.width,
                 height: volumetricFog.densityAsset.shape.extent.height,
@@ -1521,7 +1670,7 @@ function topologyOf(
               },
               froxelExtent: deriveVolumetricFogExtent(
                 { width, height },
-                volumeProfile.depth,
+                volumeProfile.depth * (1 + (volumetricFog.additional?.length ?? 0)),
                 volumeProfile.tileSize,
               ),
               resolvedExtent: deriveVolumetricFogResolvedExtent(
@@ -1562,6 +1711,9 @@ function topologyOf(
       activeCount: 0,
       needsRoughMips: false,
     },
+    ...((surfaceMediumActive ?? gpuDriven?.surfaceSubmission !== undefined)
+      ? { singleLayerMedium: true }
+      : {}),
   });
 }
 
@@ -1586,6 +1738,30 @@ function targetResolver(
           ...(named.resolveTarget === undefined ? {} : { resolveTarget: named.resolveTarget }),
         };
       }
+      if (typeof resource === 'string') {
+        const target = targets.find((candidate) => candidate.name === resource);
+        if (target !== undefined) {
+          return {
+            texture: target.texture,
+            view: target.view,
+            ...(target.resolveTarget === undefined ? {} : { resolveTarget: target.resolveTarget }),
+          };
+        }
+        // Standard lanes expose the depth attachment as a semantic target
+        // without duplicating the public `depth` name on every concrete graph
+        // projection. Keep the string alias stable for feature-authored
+        // fullscreen bindings while preserving the typed target identity.
+        if (resource === 'depth') {
+          const depth = targets.find((candidate) => candidate.kind === 'scene-depth');
+          if (depth !== undefined) {
+            return {
+              texture: depth.texture,
+              view: depth.view,
+              ...(depth.resolveTarget === undefined ? {} : { resolveTarget: depth.resolveTarget }),
+            };
+          }
+        }
+      }
     }
     if (isSceneDataTarget(resource)) {
       const semantic = semanticTargets.find(
@@ -1597,11 +1773,27 @@ function targetResolver(
         : { texture: semantic.texture, view: semantic.view };
     }
     if (!isRenderFeatureTargetHandle(resource)) return undefined;
+    // A typed feature handle is an identity, not a format request. Falling
+    // back to another same-format target can silently bind scene color in
+    // place of a missing cloud history/shadow resource and turn a producer
+    // failure into plausible but incorrect pixels.
+    // Standard lanes expose scene depth as a semantic target without a
+    // duplicated public name, while feature plans use the stable `depth`
+    // handle name. Preserve that one semantic alias here as well as above for
+    // string-authored fullscreen bindings.
     const target = targets.find(
       (candidate) =>
         candidate.kind === resource.kind &&
         candidate.format === resource.format &&
-        candidate.sampleCount === resource.sampleCount,
+        candidate.sampleCount === resource.sampleCount &&
+        (resource.name === undefined ||
+          candidate.name === resource.name ||
+          (resource.kind === 'scene-color' &&
+            resource.name === 'color' &&
+            candidate.kind === 'scene-color') ||
+          (resource.kind === 'scene-depth' &&
+            resource.name === 'depth' &&
+            candidate.kind === 'scene-depth')),
     );
     return target === undefined
       ? undefined
@@ -1621,6 +1813,9 @@ function resolveTargetBindings(
     };
     readonly resources: GraphResourceResolver;
     readonly resolveTarget: RenderFeatureGraphTargetResolver;
+    readonly resolveGpuResource?: (
+      name: string,
+    ) => import('../features/prepared-gpu-work').RenderFeatureResolvedGpuBuffer | undefined;
   },
   featurePostProcessEntries?: ReadonlyMap<string, PostProcessShaderEntry>,
 ): RenderFeatureGraphBindingsResolution | undefined {
@@ -1632,6 +1827,136 @@ function resolveTargetBindings(
   const sceneDepth = descriptor?.values.sceneDepth;
   const sceneDepthBinding = descriptor?.values.sceneDepthBinding;
   if (pipeline === undefined) return undefined;
+  if (descriptor?.values.view === true) {
+    const viewBindGroup = buildPerFrameBindGroups(
+      frame.runtime as RenderSystemInternals,
+      frame.frameState,
+      frame.pipelineState,
+      true,
+      frame.bindGroupCounts,
+      {
+        directionalShadow: frame.frameState.currentDirectionalShadowView ?? undefined,
+        spotShadow: frame.frameState.currentSpotShadowView ?? undefined,
+      },
+      true,
+      frame.standardLighting,
+    ).viewBindGroup;
+    return viewBindGroup === null ? undefined : { handle: viewBindGroup, dynamicOffsets: [0, 0] };
+  }
+  // Generic fullscreen producers (for example the CloudLayer scene pass)
+  // share the renderer-owned post-process bind-group contract without opting
+  // into the temporal two-input path below. Their input/depth aliases are
+  // resolved from the active typed graph, so they cannot accidentally sample
+  // a stale surface view or manufacture a second resource owner.
+  if (descriptor?.values.fullscreen === true && !isTemporalFullscreenBinding(descriptor.values)) {
+    const shader = descriptor.values.shader;
+    if (typeof shader !== 'string') return undefined;
+    const entry =
+      featurePostProcessEntries?.get(shader) ?? frame.runtime.lookupPostProcess?.(shader);
+    if (entry === undefined) return undefined;
+    const depthFallback = descriptor.values.depthFallback === true;
+    const depthValue = descriptor.values.depth;
+    const depthTarget =
+      depthFallback || depthValue === undefined
+        ? undefined
+        : input.resolveTarget(depthValue as never);
+    const fullscreen = buildFullscreenPostProcessPass(
+      { device: frame.runtime.device, errorRegistry: frame.runtime.errorRegistry },
+      entry,
+      depthTarget?.resolveTarget !== undefined,
+    );
+    if (fullscreen === null || fullscreen.sampler === null) return undefined;
+    const inputDisabled = descriptor.values.input === false;
+    const inputTarget = inputDisabled
+      ? undefined
+      : input.resolveTarget(descriptor.values.input as never);
+    const inputView =
+      inputTarget === undefined
+        ? { ok: true as const, value: frame.pipelineState.defaultWhiteTextureView }
+        : input.resources.textureView(inputTarget.view);
+    if (!inputView.ok) return undefined;
+    const depthView = depthFallback
+      ? frame.pipelineState.shadowFallbackTextureView
+      : depthTarget === undefined
+        ? undefined
+        : (() => {
+            const depthTexture = input.resources.texture(depthTarget.texture);
+            if (!depthTexture.ok) return undefined;
+            const created = frame.runtime.device.createTextureView(depthTexture.value as Texture, {
+              aspect: 'depth-only',
+              dimension: '2d',
+            });
+            return created.ok ? created.value : undefined;
+          })();
+    if (
+      depthTarget !== undefined &&
+      (depthView === undefined || fullscreen.depthSampler === null)
+    ) {
+      return undefined;
+    }
+    const additionalViews: { readonly binding: number; readonly view: TextureView }[] = [];
+    const additionalNames = descriptor.values.additionalTextures;
+    if (Array.isArray(additionalNames)) {
+      for (const [index, value] of additionalNames.entries()) {
+        if (typeof value !== 'string') return undefined;
+        const target = input.resolveTarget(value);
+        if (target === undefined) return undefined;
+        const view = input.resources.textureView(target.view);
+        if (!view.ok) return undefined;
+        const binding = fullscreen.extraColorBindings[index];
+        if (binding === undefined) return undefined;
+        additionalViews.push({ binding, view: view.value });
+      }
+    }
+    const layout = pipeline.getBindGroupLayout?.(1);
+    if (layout === undefined) return undefined;
+    const paramsBuffer = frame.runtime.getPostProcessParamsBuffer?.(shader);
+    if (entry.params !== undefined && paramsBuffer === undefined) return undefined;
+    if (entry.params !== undefined && paramsBuffer !== undefined) {
+      const data = frame.postProcessParams.get(shader) ?? entry.params.defaultValue;
+      if (data.byteLength !== entry.params.byteSize) return undefined;
+      const written = frame.runtime.device.queue.writeBuffer(paramsBuffer, 0, data);
+      if (!written.ok) return undefined;
+    }
+    const createdBindGroup = createFullscreenBindGroup(
+      frame.runtime.device,
+      layout,
+      inputView.value,
+      fullscreen.sampler,
+      paramsBuffer,
+      depthView ?? null,
+      fullscreen.depthSampler,
+      additionalViews,
+      fullscreen.extraStorageBindings.map((binding, index) => {
+        const names = descriptor.values.storageBuffers;
+        const name = Array.isArray(names) ? names[index] : undefined;
+        if (typeof name !== 'string') throw new Error('fullscreen storage buffer name missing');
+        const buffer = input.resolveGpuResource?.(name);
+        if (buffer === undefined) throw new Error(`fullscreen storage buffer unavailable: ${name}`);
+        return { binding, buffer: buffer.buffer };
+      }),
+    );
+    if (createdBindGroup !== null) {
+      // Cloud history is a producer of the shared temporal ping-pong state even
+      // when TAA is disabled. Stage the write at encode time; execute's finish
+      // guard and submit transaction then give it the same abort/commit/fence
+      // semantics as the TAA resolve.
+      if (shader === 'cloud-layer-resolve') {
+        const state = getTemporalGpuState(
+          frame.frameState,
+          frame.runtime.device,
+          frame.runtime.deviceScope,
+          frame.targetW,
+          frame.targetH,
+          true,
+        );
+        stageTemporalGpuSubmit(state);
+        frame.frameState.temporalGpuState = state;
+      }
+      return createdBindGroup;
+    }
+    return undefined;
+  }
   if (descriptor?.values.fullscreen === true && isTemporalFullscreenBinding(descriptor.values)) {
     const shader = descriptor.values.shader;
     if (typeof shader !== 'string') return undefined;
@@ -1646,11 +1971,9 @@ function resolveTargetBindings(
     );
     if (fullscreen === null || fullscreen.sampler === null) return undefined;
     const inputTarget = input.resolveTarget(descriptor.values.input as never);
-    const temporalTarget = input.resolveTarget(descriptor.values.temporal as never);
-    if (inputTarget === undefined || temporalTarget === undefined) return undefined;
+    if (inputTarget === undefined) return undefined;
     const inputView = input.resources.textureView(inputTarget.view);
-    const temporalView = input.resources.textureView(temporalTarget.view);
-    if (!inputView.ok || !temporalView.ok) return undefined;
+    if (!inputView.ok) return undefined;
     const layout = pipeline.getBindGroupLayout?.(1);
     if (layout === undefined) return undefined;
     const depth = input.resolveTarget(descriptor.values.depth as never);
@@ -1669,13 +1992,41 @@ function resolveTargetBindings(
     if (depth !== undefined && (depthView === undefined || fullscreen.depthSampler === null)) {
       return undefined;
     }
+
+    const paramsBuffer = frame.runtime.getPostProcessParamsBuffer?.(shader);
+    if (entry.params !== undefined && paramsBuffer === undefined) return undefined;
+    if (entry.params !== undefined && paramsBuffer !== undefined) {
+      const data = frame.postProcessParams.get(shader) ?? entry.params.defaultValue;
+      if (data.byteLength !== entry.params.byteSize) return undefined;
+      const written = frame.runtime.device.queue.writeBuffer(paramsBuffer, 0, data);
+      if (!written.ok) return undefined;
+    }
+
+    if (!isTemporalFullscreenBinding(descriptor.values)) {
+      return (
+        createFullscreenBindGroup(
+          frame.runtime.device,
+          layout,
+          inputView.value,
+          fullscreen.sampler,
+          paramsBuffer,
+          depthView ?? null,
+          fullscreen.depthSampler,
+        ) ?? undefined
+      );
+    }
+
+    const temporalTarget = input.resolveTarget(descriptor.values.temporal as never);
+    if (temporalTarget === undefined) return undefined;
+    const temporalView = input.resources.textureView(temporalTarget.view);
+    if (!temporalView.ok) return undefined;
     return (
       createFullscreenBindGroup(
         frame.runtime.device,
         layout,
         inputView.value,
         fullscreen.sampler,
-        frame.runtime.getPostProcessParamsBuffer?.(shader),
+        paramsBuffer,
         depthView ?? null,
         fullscreen.depthSampler,
         [{ binding: fullscreen.extraColorBindings[0] ?? 5, view: temporalView.value }],
@@ -1753,15 +2104,35 @@ function resolveTargetBindings(
   return created.value;
 }
 
-function retire(
+export function retire(
   frameState: RenderFrameState,
   graph: CompiledRenderGraph<RenderPipelineFrame>,
 ): void {
+  if (frameState.retiredCompiledFrameGraphs.has(graph)) return;
   frameState.retiredCompiledFrameGraphs.add(graph);
-  graph
-    .retire()
-    .finally(() => frameState.retiredCompiledFrameGraphs.delete(graph))
-    .catch(() => undefined);
+  setGraphGenerationRetiring(frameState, graph);
+  const failures = graphRetirementFailureSet(frameState);
+  const retirement = graph.retire();
+  // retire() synchronously moves graph-owned resources to pending before its
+  // queue-fence await. Capture that overlap at the lifecycle event, rather
+  // than waiting for a later inspection call.
+  observeGraphGenerationAllocation(frameState);
+  retirement
+    .then((result) => {
+      if (result.ok) {
+        failures?.delete(graph);
+        setGraphGenerationRetirementResult(frameState, graph, true);
+      } else {
+        failures?.add(graph);
+        setGraphGenerationRetirementResult(frameState, graph, false);
+      }
+      frameState.retiredCompiledFrameGraphs.delete(graph);
+    })
+    .catch(() => {
+      failures?.add(graph);
+      setGraphGenerationRetirementResult(frameState, graph, false);
+      frameState.retiredCompiledFrameGraphs.delete(graph);
+    });
 }
 
 /**
@@ -1838,6 +2209,54 @@ export function settleDepthOfFieldGraphCandidate(
   frameState.depthOfFieldCandidateGraph = null;
 }
 
+/**
+ * Settle an ordinary graph replacement at the same submit barrier as the
+ * barrel mapping. Resize, camera topology, and post-process enable/disable
+ * all replace the compiled graph; a failed command must restore that graph so
+ * the retained mapping still describes the pixels that are actually shown.
+ */
+export function settleBarrelDistortionGraphCandidate(
+  frameState: RenderFrameState,
+  submitted: boolean,
+): void {
+  const candidate = frameState.barrelDistortionCandidateGraph ?? null;
+  if (candidate === null) return;
+  const previous = frameState.barrelDistortionPreviousGraph ?? null;
+  const sharedWithSpecializedOwner =
+    frameState.depthOfFieldCandidateGraph === candidate ||
+    frameState.volumetricFogCandidateGraph === candidate;
+  if (submitted) {
+    if (!sharedWithSpecializedOwner && previous !== null && previous !== candidate) {
+      retire(frameState, previous);
+    }
+  } else {
+    if (!sharedWithSpecializedOwner) {
+      if (candidate !== previous) retire(frameState, candidate);
+      frameState.compiledFrameGraph = previous;
+      frameState.compiledFrameGraphTopologyKey =
+        frameState.barrelDistortionPreviousGraphKey ?? null;
+      if (frameState.barrelDistortionPreviousPerFrameGraph === undefined) {
+        delete frameState.perFrameGraph;
+      } else {
+        frameState.perFrameGraph = frameState.barrelDistortionPreviousPerFrameGraph;
+      }
+      frameState.graphGeneration = frameState.barrelDistortionPreviousGraphGeneration ?? 0;
+      frameState.compiledFrameGraphGeneration =
+        frameState.barrelDistortionPreviousCompiledGraphGeneration ?? 0;
+      frameState.standardLightingGraphSignature =
+        frameState.barrelDistortionPreviousStandardLightingGraphSignature ?? '';
+    }
+    frameState.barrelDistortionGraphResolution = previous === null ? 'accepted' : 'retained';
+  }
+  frameState.barrelDistortionPreviousGraph = null;
+  frameState.barrelDistortionPreviousGraphKey = null;
+  frameState.barrelDistortionPreviousPerFrameGraph = undefined;
+  frameState.barrelDistortionPreviousGraphGeneration = 0;
+  frameState.barrelDistortionPreviousCompiledGraphGeneration = 0;
+  frameState.barrelDistortionPreviousStandardLightingGraphSignature = '';
+  frameState.barrelDistortionCandidateGraph = null;
+}
+
 export function ensureCompiledFrameGraph(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
@@ -1859,8 +2278,11 @@ export function ensureCompiledFrameGraph(
   onRecoveryError?: (error: unknown) => void,
   ssr?: SsrSpatialAdmission,
   renderExtent?: RenderExtent,
+  surfaceMediumActive?: boolean,
   analyticFog = false,
+  cloudShadowResolution?: number,
 ): CompiledRenderGraph<RenderPipelineFrame> | null {
+  frameState.barrelDistortionGraphResolution = 'retained';
   const featureMetrics = mutableFeatureGraphInspection(internals);
   featureMetrics.ensureCalls += 1;
   const requestedStandardLightingSignature = standardLightingTopologySignature(standardLighting);
@@ -1878,10 +2300,16 @@ export function ensureCompiledFrameGraph(
       : { ...camera, depthOfField: frameDepthOfField };
   const lastKnownGood = (): CompiledRenderGraph<RenderPipelineFrame> | null =>
     frameState.compiledFrameGraph !== null &&
+    frameState.compiledFrameGraphTopologyKey !== null &&
     !hasSubmissionSensitiveFeatures(getRenderFeatureGraphState(internals).plans) &&
     frameState.standardLightingGraphSignature === requestedStandardLightingSignature
       ? frameState.compiledFrameGraph
       : null;
+  const retainLastKnownGood = (): CompiledRenderGraph<RenderPipelineFrame> | null => {
+    const graph = lastKnownGood();
+    if (graph !== null) frameState.barrelDistortionGraphResolution = 'retained';
+    return graph;
+  };
   const surfaceWidth = Math.max(1, width);
   const surfaceHeight = Math.max(1, height);
   const featurePlans = featureGraphCandidate?.plans ?? getRenderFeatureGraphState(internals).plans;
@@ -1893,8 +2321,15 @@ export function ensureCompiledFrameGraph(
     if (featureGraphCandidate !== undefined) {
       recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
     }
-    return volumeTopologyCandidate ? null : lastKnownGood();
+    return volumeTopologyCandidate ? null : retainLastKnownGood();
   }
+  const cloudHistoryDemand = projectedFeaturePlans.value.some(
+    (execution) =>
+      execution.featureIdentity === CLOUD_LAYER_FEATURE_IDENTITY &&
+      execution.passes.some(
+        (pass) => pass.name === 'cloud-layer-transport' || pass.name === 'cloud-layer-resolve',
+      ),
+  );
   const nextPlanRevision = updateRenderFeaturePlanRevision(
     featureMetrics.planRevisionState,
     featurePlans,
@@ -1925,6 +2360,7 @@ export function ensureCompiledFrameGraph(
     standardLighting,
     ssr,
     renderExtent,
+    surfaceMediumActive,
     analyticFog,
   );
   if (!topologyResult.ok) {
@@ -1934,7 +2370,7 @@ export function ensureCompiledFrameGraph(
     if (featureGraphCandidate !== undefined) {
       recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
     }
-    return volumeTopologyCandidate ? null : lastKnownGood();
+    return volumeTopologyCandidate ? null : retainLastKnownGood();
   }
   const requestedPostEffects = topologyResult.value.config?.postEffects ?? [];
   const featurePostProcessEntries =
@@ -1986,6 +2422,7 @@ export function ensureCompiledFrameGraph(
     if (featureGraphCandidate !== undefined) {
       recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
     }
+    frameState.barrelDistortionGraphResolution = 'retained';
     return acceptedLkg;
   }
   const topology = postProcessAdmission.pending
@@ -2022,12 +2459,17 @@ export function ensureCompiledFrameGraph(
     // so include the prepared projection's presence to invalidate a cached
     // CPU-only graph when the GPU owner becomes ready, and vice versa.
     gpuDrivenProjectionActive: gpuDriven !== undefined,
+    // Cloud shadow targets are quality-derived graph resources. Include the
+    // resolved texel grid in the cache key so a quality/resize change cannot
+    // reuse a graph compiled for the previous allocation.
+    cloudShadowResolution: cloudShadowResolution ?? 0,
+    cloudHistory: cloudHistoryDemand,
     // Query reservations are frame-local transport state. The projection is
     // renderer-owned and read dynamically by the compiled pass, so a page
     // rotation must not invalidate the graph or its cached bind groups.
     occlusionQuery:
       occlusion === undefined ? undefined : { active: true, sampleCount: occlusion.sampleCount },
-    cubeCaptureSlots: cubeCaptureState?.work.length ?? 0,
+    cubeCaptureSlots: cubeCaptureState?.work.map((work) => work.physical.descriptor),
     reflectionProbeSlots: cubeCaptureState?.reflectionProbes?.work.map((work) => [
       work.probeIndex,
       work.rawCaptureFace ?? -1,
@@ -2036,9 +2478,11 @@ export function ensureCompiledFrameGraph(
     ]),
   });
   if (frameState.compiledFrameGraph !== null && frameState.compiledFrameGraphTopologyKey === key) {
+    frameState.barrelDistortionGraphResolution = 'accepted';
     featureMetrics.reuseHits += 1;
     featureMetrics.lastTopologyKey = key;
     frameState.standardLightingGraphSignature = requestedStandardLightingSignature;
+    frameState.pendingCloudHistoryActive = cloudHistoryDemand;
     if (featureGraphCandidate !== undefined && !postProcessAdmission.pending) {
       commitFeatureCandidate(internals, featureGraphCandidate);
     } else if (featureGraphCandidate !== undefined) {
@@ -2068,9 +2512,11 @@ export function ensureCompiledFrameGraph(
     topology.output?.autoExposure === true ? importAutoExposureGraphResources(builder) : undefined;
   if (autoExposureResources !== undefined && !autoExposureResources.ok) {
     internals.errorRegistry.fire(autoExposureResources.error);
-    featureGraphCandidate?.onRejected?.();
     discardPendingStandardOutput();
-    return lastKnownGood();
+    if (featureGraphCandidate !== undefined) {
+      recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
+    }
+    return retainLastKnownGood();
   }
   const lutResources =
     topology.output?.colorLut === true
@@ -2114,20 +2560,25 @@ export function ensureCompiledFrameGraph(
       : undefined;
   if (lutResources !== undefined && !lutResources.ok) {
     internals.errorRegistry.fire(lutResources.error);
-    featureGraphCandidate?.onRejected?.();
     discardPendingStandardOutput();
-    return lastKnownGood();
+    if (featureGraphCandidate !== undefined) {
+      recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
+    }
+    return retainLastKnownGood();
   }
   const taaHistory = camera.antialias === 'taa' ? importTemporalHistoryTargets(builder) : undefined;
+  const cloudHistory = cloudHistoryDemand ? importCloudHistoryTargets(builder) : undefined;
   const targetCoverage =
     camera.dynamicResolution === undefined || topology.extent === undefined
       ? undefined
       : createTargetCoverageAttachment(builder, topology.extent);
   if (targetCoverage !== undefined && !targetCoverage.ok) {
     internals.errorRegistry.fire(targetCoverage.error);
-    featureGraphCandidate?.onRejected?.();
     discardPendingStandardOutput();
-    return lastKnownGood();
+    if (featureGraphCandidate !== undefined) {
+      recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
+    }
+    return retainLastKnownGood();
   }
   const ssrHistory = ssr?.status === 'admitted' ? importSsrHistoryTargets(builder) : undefined;
   const featureProjection = createRenderFeatureProjectionState();
@@ -2161,8 +2612,10 @@ export function ensureCompiledFrameGraph(
         : {}),
       ...(standardLighting === undefined ? {} : { standardLighting }),
       capabilities: { rgba16floatRenderable: internals.device.caps.rgba16floatRenderable },
+      ...(cloudShadowResolution === undefined ? {} : { cloudShadowResolution }),
       ...(occlusion === undefined ? {} : { occlusion }),
       ...(taaHistory === undefined ? {} : { taaHistory }),
+      ...(cloudHistory === undefined ? {} : { cloudHistory }),
       ...(targetCoverage?.ok === true ? { targetCoverage: targetCoverage.value } : {}),
       ...(ssrHistory === undefined ? {} : { ssrHistory }),
       encodeTransmissionMip: ({ pass, resources, source }) => {
@@ -2178,6 +2631,7 @@ export function ensureCompiledFrameGraph(
           builder,
           target.format,
           target.sampleCount,
+          () => frameState.surfaceSubmissionObservation,
           target.additionalColorFormats,
         );
       },
@@ -2198,23 +2652,42 @@ export function ensureCompiledFrameGraph(
         semanticTargets = [],
         namedTargets = {},
         standardSurfaceAccesses = [],
+        featureSelectionOrPlacement,
+        passNames = [],
       ) => {
-        // Forward/deferred scene lanes contribute feature plans before the
+        const selection =
+          featureSelectionOrPlacement !== undefined &&
+          typeof featureSelectionOrPlacement !== 'string'
+            ? featureSelectionOrPlacement
+            : undefined;
+        const placement =
+          typeof featureSelectionOrPlacement === 'string' ? featureSelectionOrPlacement : 'post';
+        const include = selection?.include === undefined ? undefined : new Set(selection.include);
+        const exclude = selection?.exclude === undefined ? undefined : new Set(selection.exclude);
+        // Forward/deferred scene lanes contribute scene plans before the
         // Standard post chain has created its named input/output targets.
         // Fullscreen effects (Motion Blur included) must wait for that later
-        // call so their temporal input is resolved after TAA. Other feature
-        // plans can still be projected at the forward contribution point.
-        const plans =
+        // call so their temporal input is resolved after TAA. The shared
+        // projection state below deduplicates only the execution/pass that
+        // actually reached the graph; an empty early projection therefore
+        // cannot reserve the later fullscreen pass.
+        const plans = (
           Object.keys(namedTargets).length === 0
             ? projectedFeaturePlans.value.filter(
                 (execution) => !fullscreenFeatureIds.has(execution.featureIdentity),
               )
-            : projectedFeaturePlans.value;
+            : projectedFeaturePlans.value
+        )
+          .filter((execution) => (execution.placement ?? 'post') === placement)
+          .filter((execution) => include === undefined || include.has(execution.featureIdentity))
+          .filter((execution) => exclude === undefined || !exclude.has(execution.featureIdentity));
         if (plans.length === 0) return ok(undefined);
         const resolveTarget = targetResolver(targets, semanticTargets, namedTargets);
         const projected = projectPlanExecutions(builder, plans, {
           state: featureProjection,
           resolveTarget,
+          placement,
+          ...(passNames.length === 0 ? {} : { passNames: new Set(passNames) }),
           standardSurfaceAccesses,
           resolveBindings: (input) => resolveTargetBindings(input, featurePostProcessEntries),
           resolveStandardLighting: (frame, pipeline) => {
@@ -2239,7 +2712,8 @@ export function ensureCompiledFrameGraph(
           },
           reportError: (error) => reportRenderFeatureGraphError(internals, error),
         });
-        return projected.ok ? ok(undefined) : projected;
+        if (!projected.ok) return projected;
+        return ok(undefined);
       },
       contributeCubeCaptures: (environmentCube) => {
         const reflectionProbes = addReflectionProbeGraphPasses(
@@ -2250,10 +2724,24 @@ export function ensureCompiledFrameGraph(
         if (!reflectionProbes.ok) return reflectionProbes;
         return cubeCaptureState === undefined
           ? ok(undefined)
-          : addCubeCaptureGraphPasses(builder, cubeCaptureState);
+          : addTargetCaptureGraphPasses(builder, cubeCaptureState);
       },
       hasFeature: (identity) =>
         projectedFeaturePlans.value.some((execution) => execution.featureIdentity === identity),
+      hasFeatureWork: (identity, placement) =>
+        projectedFeaturePlans.value.some(
+          (execution) =>
+            execution.featureIdentity === identity &&
+            execution.passes.length > 0 &&
+            (placement === undefined || (execution.placement ?? 'post') === placement),
+        ),
+      hasFeatureRasterWork: (identity, placement) =>
+        projectedFeaturePlans.value.some(
+          (execution) =>
+            execution.featureIdentity === identity &&
+            execution.passes.some((pass) => pass.graphics !== undefined) &&
+            (placement === undefined || (execution.placement ?? 'post') === placement),
+        ),
     },
     topology,
   );
@@ -2261,12 +2749,11 @@ export function ensureCompiledFrameGraph(
     featureMetrics.buildFailures += 1;
     onRecoveryError?.(built.error);
     internals.errorRegistry.fire(built.error);
-    featureGraphCandidate?.onRejected?.();
     discardPendingStandardOutput();
     if (featureGraphCandidate !== undefined) {
       recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
     }
-    return volumeTopologyCandidate ? null : lastKnownGood();
+    return volumeTopologyCandidate ? null : retainLastKnownGood();
   }
   featureMetrics.compileAttempts += 1;
   const compileStarted = typeof performance === 'undefined' ? Date.now() : performance.now();
@@ -2280,13 +2767,16 @@ export function ensureCompiledFrameGraph(
     featureMetrics.compileFailures += 1;
     onRecoveryError?.(compiled.error);
     internals.errorRegistry.fire(compiled.error);
-    featureGraphCandidate?.onRejected?.();
     discardPendingStandardOutput();
     if (featureGraphCandidate !== undefined) {
       recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
     }
-    return lastKnownGood();
+    return retainLastKnownGood();
   }
+  // Register the generation before publishing it. The owner observes the
+  // overlap while the previous graph is still live, even if a queue fence
+  // retires that graph before the next public inspect() call.
+  trackGraphGeneration(frameState, compiled.value);
   const previous = frameState.compiledFrameGraph;
   const depthOfFieldReplacement =
     (frameState.depthOfFieldCandidateGraph === null ||
@@ -2314,8 +2804,22 @@ export function ensureCompiledFrameGraph(
     frameState.depthOfFieldPreviousStandardLightingGraphSignature =
       frameState.standardLightingGraphSignature;
     frameState.depthOfFieldCandidateGraph = compiled.value;
+  } else if (compiled.value !== previous) {
+    // Keep the complete accepted graph projection until queue submission.
+    // This covers barrel enable/disable, output resize, and camera topology
+    // changes without introducing a second resource owner.
+    frameState.barrelDistortionPreviousGraph = previous;
+    frameState.barrelDistortionPreviousGraphKey = frameState.compiledFrameGraphTopologyKey;
+    frameState.barrelDistortionPreviousPerFrameGraph = frameState.perFrameGraph;
+    frameState.barrelDistortionPreviousGraphGeneration = frameState.graphGeneration;
+    frameState.barrelDistortionPreviousCompiledGraphGeneration =
+      frameState.compiledFrameGraphGeneration;
+    frameState.barrelDistortionPreviousStandardLightingGraphSignature =
+      frameState.standardLightingGraphSignature;
+    frameState.barrelDistortionCandidateGraph = compiled.value;
   }
   frameState.compiledFrameGraph = compiled.value;
+  frameState.barrelDistortionGraphResolution = 'accepted';
   frameState.compiledFrameGraphTopologyKey = key;
   frameState.standardLightingGraphSignature = requestedStandardLightingSignature;
   frameState.compiledFrameGraphGeneration += 1;
@@ -2347,99 +2851,11 @@ export function ensureCompiledFrameGraph(
   } else if (featureGraphCandidate !== undefined) {
     recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'abandoned');
   }
-  if (!volumeTopologyCandidate && !depthOfFieldReplacement && previous !== null) {
-    retire(frameState, previous);
-  }
+  frameState.pendingCloudHistoryActive = cloudHistoryDemand;
+  // The selected candidate owner retires the previous graph only after submit.
   return compiled.value;
 }
 
-/**
- * Project one accepted Motion Blur compute execution from the same graph and
- * resolved dispatch objects used by the encoder. A plan/capability candidate
- * without both executed passes deliberately returns no receipt.
- */
-function deriveMotionBlurExecutionReceipt(
-  internals: RenderSystemInternals,
-  frameState: RenderFrameState,
-): MotionBlurExecutionReceipt | undefined {
-  const graph = frameState.compiledFrameGraph;
-  const deviceGeneration = internals.deviceScope?.generation;
-  if (graph === null || deviceGeneration === undefined) return undefined;
-  const info = graph.inspect();
-  const graphPasses = new Map(info.passes.map((pass) => [pass.name, pass]));
-  const summaryGraphPass = graphPasses.get('motion-blur-tile-summary');
-  const reconstructGraphPass = graphPasses.get('motion-blur');
-  if (summaryGraphPass?.kind !== 'compute' || reconstructGraphPass?.kind !== 'compute') {
-    return undefined;
-  }
-  const planned = getRenderFeatureGraphState(internals).plans.find(
-    (candidate) => candidate.featureIdentity === 'forgeax.motion-blur',
-  );
-  const execution =
-    planned === undefined ? undefined : getRenderFeaturePlanExecutionProjection(planned);
-  if (execution === undefined || execution.featureIdentity !== 'forgeax.motion-blur') {
-    return undefined;
-  }
-  const executionPass = (name: 'motion-blur-tile-summary' | 'motion-blur') =>
-    execution.passes.find((pass) => pass.name === name);
-  const summary = executionPass('motion-blur-tile-summary');
-  const reconstruct = executionPass('motion-blur');
-  if (
-    summary?.gpuCompute === undefined ||
-    reconstruct?.gpuCompute === undefined ||
-    summary.resolvedGpuCompute === undefined ||
-    reconstruct.resolvedGpuCompute === undefined
-  ) {
-    return undefined;
-  }
-  const directWorkgroups = (
-    pass: NonNullable<typeof summary.resolvedGpuCompute>,
-  ): readonly [number, number, number] | undefined => {
-    const dispatch = pass.dispatches[0];
-    if (dispatch === undefined || !('workgroups' in dispatch)) return undefined;
-    return dispatch.workgroups;
-  };
-  const summaryWorkgroups = directWorkgroups(summary.resolvedGpuCompute);
-  const reconstructWorkgroups = directWorkgroups(reconstruct.resolvedGpuCompute);
-  if (summaryWorkgroups === undefined || reconstructWorkgroups === undefined) return undefined;
-  const outputResource = info.resources.find(
-    (resource) =>
-      resource.label === 'motion-blurred-color' ||
-      reconstructGraphPass.accesses.some(
-        (access) => access.resource === resource.label && access.usage === 'storage-write',
-      ),
-  );
-  if (
-    outputResource?.descriptor.kind !== 'texture' ||
-    outputResource.descriptor.format !== 'rgba16float'
-  ) {
-    return undefined;
-  }
-  const summaryReceipt: MotionBlurExecutionPass = {
-    name: 'motion-blur-tile-summary',
-    kind: 'compute',
-    entryPoint: 'tile_summary',
-    workgroups: summaryWorkgroups,
-  };
-  const reconstructReceipt: MotionBlurExecutionPass = {
-    name: 'motion-blur',
-    kind: 'compute',
-    entryPoint: 'reconstruct',
-    workgroups: reconstructWorkgroups,
-  };
-  return Object.freeze({
-    frameId: frameState.frameNumber,
-    deviceGeneration,
-    // RenderGraphBuilder generations are process-global. The renderer's
-    // frame-state generation is the identity used by inspection and by the
-    // same-frame admission check below, so retain that owner-scoped value.
-    graphGeneration: frameState.graphGeneration,
-    program: 'motion-blur-compute' as const,
-    outputFormat: 'rgba16float' as const,
-    passes: [summaryReceipt, reconstructReceipt] as const,
-  });
-}
-
 export function executeCompiledFrameGraph(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
@@ -2462,21 +2878,31 @@ export function executeCompiledFrameGraph(
   const legacySubmitCommit = typeof frameHooks === 'function' ? frameHooks : undefined;
   const resolvedFrameHooks = typeof frameHooks === 'function' ? undefined : frameHooks;
   const graph = frameState.compiledFrameGraph;
+  // Recovery keeps the candidate graph for detached inspection, but clears
+  // its topology key before the replacement canvas context is published. It
+  // is evidence only until the first post-recovery draw compiles a new graph.
+  // Never let that retained graph reach record/execute or queue.submit.
+  const detachedGraph = graph !== null && frameState.compiledFrameGraphTopologyKey === null;
   const rejectTemporalFrame = (): void => {
     if (frameState.temporalFrameInput === undefined) return;
     frameState.temporalFrameTransaction.commit({ accepted: false });
     frameState.temporalFrameInput = undefined;
   };
-  if (graph === null) {
+  if (graph === null || detachedGraph) {
     timingCapture?.discard();
     frameState.pendingAutoExposureState = undefined;
     frameState.pendingStandardLutState = undefined;
+    settleBarrelDistortionGraphCandidate(frameState, false);
     settleVolumetricFogGraphCandidate(frameState, false);
     settleDepthOfFieldGraphCandidate(frameState, false);
     rejectTemporalFrame();
     return false;
   }
-  const motionBlurExecution = deriveMotionBlurExecutionReceipt(internals, frameState);
+  const motionBlurExecution = deriveMotionBlurExecutionReceipt(
+    internals,
+    frameState,
+    getRenderFeatureGraphState(internals).plans,
+  );
   const legacyTimingInstrumentation =
     timingCapture === undefined ? undefined : createTimingInstrumentation(timingCapture);
   const timingHost = internals as RenderSystemInternals & {
@@ -2539,6 +2965,7 @@ export function executeCompiledFrameGraph(
     );
     settleVolumetricFogGraphCandidate(frameState, false);
     settleDepthOfFieldGraphCandidate(frameState, false);
+    settleBarrelDistortionGraphCandidate(frameState, false);
     return false;
   }
   const capturedGeneration = deviceScope?.generation;
@@ -3042,8 +3469,8 @@ export function executeCompiledFrameGraph(
         internals.errorRegistry.fire(
           new RhiError({
             code: 'webgpu-runtime-error',
-            expected: 'TAA resolve stages a history write before submit',
-            hint: 'retry the frame after the temporal resolve pass has encoded successfully',
+            expected: 'an admitted temporal producer stages a history write before submit',
+            hint: 'retry the frame after the TAA or CloudLayer history pass has encoded successfully',
           }),
         );
         return { ok: false, stage: 'finish' };
@@ -3197,6 +3624,11 @@ export function executeCompiledFrameGraph(
         }
       }
       const stagedTemporalCommit = frameState.pendingTemporalCommit ?? { kind: 'none' as const };
+      const stagedCloudHistoryActive = frameState.pendingCloudHistoryActive;
+      if (stagedCloudHistoryActive !== undefined) {
+        frameState.cloudHistoryActive = stagedCloudHistoryActive;
+        delete frameState.pendingCloudHistoryActive;
+      }
       if (stagedTemporalCommit.kind !== 'none') {
         frameState.lastSuccessfulTemporalView = stagedTemporalCommit.view;
       }
@@ -3205,7 +3637,7 @@ export function executeCompiledFrameGraph(
       } else if (stagedTemporalCommit.kind === 'off') {
         frameState.successfulTemporalFrameIndex = 0;
       }
-      if (stagedTemporalCommit.kind === 'off') {
+      if (stagedTemporalCommit.kind === 'off' && frameState.cloudHistoryActive !== true) {
         internals.clearPostProcessPipelineCache?.('forgeax.taa-resolve');
         // Retire frame-sized resources, not the device-owned prewarmed
         // shader. The next TAA frame must not start an async cold compile.
@@ -3236,6 +3668,7 @@ export function executeCompiledFrameGraph(
       frameState.pendingAtmospherePublish?.();
       frameState.pendingAtmospherePublish = undefined;
       onSubmitted?.(internals.device.queue.onSubmittedWorkDone());
+      settleBarrelDistortionGraphCandidate(frameState, true);
       settleVolumetricFogGraphCandidate(frameState, true);
       settleDepthOfFieldGraphCandidate(frameState, true);
     },
@@ -3271,11 +3704,13 @@ export function executeCompiledFrameGraph(
         }
         frameState.temporalGpuState = undefined;
       }
+      delete frameState.pendingCloudHistoryActive;
       frameState.pendingTemporalCommit = { kind: 'none' };
       if (frameState.environmentGeneration !== undefined) {
         frameState.environmentLifecycle?.discard(frameState.environmentGeneration);
         frameState.environmentGeneration = undefined;
       }
+      settleBarrelDistortionGraphCandidate(frameState, false);
       settleVolumetricFogGraphCandidate(frameState, false);
       settleDepthOfFieldGraphCandidate(frameState, false);
     },
@@ -3283,6 +3718,7 @@ export function executeCompiledFrameGraph(
   // The callbacks above settle the normal transaction path. Keep this guard
   // for synthetic callers and any future early transaction result that does
   // not enter a callback.
+  settleBarrelDistortionGraphCandidate(frameState, transaction.ok);
   settleVolumetricFogGraphCandidate(frameState, transaction.ok);
   settleDepthOfFieldGraphCandidate(frameState, transaction.ok);
   if (!transaction.ok) rejectTemporalFrame();