@forgeax/engine-render 0.1.32 → 0.1.34

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

@@ -4,8 +4,11 @@ import {
   type GraphResourceResolver,
   RenderGraphBuilder,
   RenderGraphError,
+  type RenderGraphGenerationAllocationEntry,
+  type RenderGraphGenerationAllocationInspection,
   type RenderGraphPassInstrumentation,
   type RenderGraphPassInstrumentationScope,
+  type RenderGraphResourceAllocationInspection,
 } from '@forgeax/engine-render-graph';
 import type {
   BindGroup,
@@ -22,6 +25,8 @@ import type {
 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';
@@ -30,6 +35,7 @@ import {
   hasSubmissionSensitiveFeatures,
   type RenderFeaturePlanExecution,
 } from '../features/host';
+import { motionBlurTemporalDemand } from '../features/motion-blur/motion-blur-params';
 import {
   type RenderFeaturePlannedFrame,
   renderFeaturePlanSignature,
@@ -93,11 +99,13 @@ 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,
@@ -118,6 +126,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,
@@ -321,6 +330,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,
@@ -435,7 +563,15 @@ export function shouldUseTemporalFrameTransaction(
 export function isMotionBlurTemporalDemand(
   motionBlur: CameraSnapshot['motionBlur'] | undefined,
 ): boolean {
-  return motionBlur?.shutterAngle !== undefined && motionBlur.shutterAngle > 0;
+  return (
+    motionBlur !== undefined &&
+    motionBlurTemporalDemand({
+      shutterAngle: motionBlur.shutterAngle,
+      maxRadiusPixels: motionBlur.maxRadiusPixels,
+      sampleCount: motionBlur.sampleCount,
+      targetFps: motionBlur.targetFps ?? 60,
+    })
+  );
 }
 
 /**
@@ -968,6 +1104,7 @@ export interface RenderFeatureGraphRuntimeState {
     string,
     import('../fullscreen-post-process-pass').PostProcessShaderEntry
   >;
+  postProcessIdentities: readonly string[];
 }
 
 /** The exact fields that define one validated feature-plan collection. */
@@ -1028,6 +1165,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
@@ -1051,6 +1190,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;
@@ -1216,6 +1565,7 @@ export function getRenderFeatureGraphState(
   const created: RenderFeatureGraphRuntimeState = {
     plans: [],
     fullscreenEffects: new Map(),
+    postProcessIdentities: [],
   };
   featureGraphStates.set(internals, created);
   return created;
@@ -1225,6 +1575,7 @@ export function resetRenderFeatureGraphState(internals: RenderSystemInternals):
   const state = getRenderFeatureGraphState(internals);
   state.plans = [];
   state.fullscreenEffects = new Map();
+  state.postProcessIdentities = [];
 }
 
 export function reportRenderFeatureGraphError(
@@ -1343,6 +1694,7 @@ function commitFeatureCandidate(
   const state = getRenderFeatureGraphState(internals);
   state.plans = candidate.plans;
   state.fullscreenEffects = candidate.fullscreenEffects;
+  state.postProcessIdentities = candidate.postProcessIdentities ?? [];
 }
 
 function topologyOf(
@@ -1364,6 +1716,8 @@ 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
     | 1
@@ -1384,10 +1738,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),
@@ -1430,6 +1783,7 @@ function topologyOf(
     reflectionFallback: { enabled: frameState.reflectionFallbackDemand === true },
     ssr,
     ...(renderExtent === undefined ? {} : { extent: renderExtent }),
+    analyticFog: !clearOnly && analyticFog,
     surface: {
       width,
       height,
@@ -1440,7 +1794,12 @@ function topologyOf(
     camera: {
       tonemap: camera.tonemap,
       antialias: camera.antialias,
-      bloom: camera.bloom,
+      // Bloom intensity is a frame parameter, not a graph identity. Fold
+      // only its zero/non-zero admission into the closed topology switch so
+      // 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',
@@ -1494,6 +1853,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,
@@ -1501,7 +1870,7 @@ function topologyOf(
               },
               froxelExtent: deriveVolumetricFogExtent(
                 { width, height },
-                volumeProfile.depth,
+                volumeProfile.depth * (1 + (volumetricFog.additional?.length ?? 0)),
                 volumeProfile.tileSize,
               ),
               resolvedExtent: deriveVolumetricFogResolvedExtent(
@@ -1542,6 +1911,9 @@ function topologyOf(
       activeCount: 0,
       needsRoughMips: false,
     },
+    ...((surfaceMediumActive ?? gpuDriven?.surfaceSubmission !== undefined)
+      ? { singleLayerMedium: true }
+      : {}),
   });
 }
 
@@ -1566,6 +1938,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(
@@ -1577,11 +1973,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
@@ -1601,6 +2013,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 {
@@ -1612,6 +2027,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;
@@ -1626,11 +2171,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);
@@ -1649,13 +2192,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 }],
@@ -1733,15 +2304,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);
+    });
 }
 
 /**
@@ -1818,6 +2409,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,
@@ -1839,7 +2478,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);
@@ -1857,10 +2500,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;
@@ -1872,8 +2521,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,
@@ -1904,6 +2560,8 @@ export function ensureCompiledFrameGraph(
     standardLighting,
     ssr,
     renderExtent,
+    surfaceMediumActive,
+    analyticFog,
   );
   if (!topologyResult.ok) {
     featureMetrics.buildFailures += 1;
@@ -1912,12 +2570,22 @@ 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 =
     featureGraphCandidate?.fullscreenEffects ??
     getRenderFeatureGraphState(internals).fullscreenEffects;
+  // Motion Blur's compute plan intentionally has no raster fullscreen shader
+  // declaration, but it is still a post chain consumer: Standard Post owns
+  // the named `motion-input`/`motion-output` targets and must project it after
+  // TAA. Keep the identity in this deferred set alongside declared fullscreen
+  // effects so an early forward/deferred contribution cannot resolve its
+  // scene-data target against an incomplete target map.
+  const fullscreenFeatureIds = new Set([
+    ...featurePostProcessEntries.keys(),
+    'forgeax.motion-blur',
+  ]);
   const postProcessAdmission = resolvePostProcessChainAdmission(
     requestedPostEffects,
     (identity) => {
@@ -1954,6 +2622,7 @@ export function ensureCompiledFrameGraph(
     if (featureGraphCandidate !== undefined) {
       recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
     }
+    frameState.barrelDistortionGraphResolution = 'retained';
     return acceptedLkg;
   }
   const topology = postProcessAdmission.pending
@@ -1965,8 +2634,19 @@ export function ensureCompiledFrameGraph(
         },
       }
     : topologyResult.value;
+  // Keep Bloom's positive parameter values out of the compiled identity. A
+  // crossing of zero has already changed topology.camera.bloom above; the
+  // remaining values are uploaded by the active recorder without rebuilding
+  // targets or pipelines.
+  const topologyIdentity = {
+    ...topology,
+    camera: {
+      ...topology.camera,
+      bloomIntensity: undefined,
+    },
+  };
   const key = JSON.stringify({
-    topology,
+    topology: topologyIdentity,
     // Observation domains are an explicit per-frame graph demand.  They are
     // part of the cache identity so a request made after the ordinary graph
     // was compiled can admit the matching tone/output capture boundaries on
@@ -1979,6 +2659,11 @@ 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.
@@ -1993,9 +2678,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) {
@@ -2025,9 +2712,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
@@ -2071,23 +2760,27 @@ 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;
-  let projectedFeatures = false;
   const featureProjection = createRenderFeatureProjectionState();
   let featureShadows:
     | ReturnType<typeof projectRenderFeatureShadows<RenderPipelineFrame>>
@@ -2119,8 +2812,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 }) => {
@@ -2136,6 +2831,7 @@ export function ensureCompiledFrameGraph(
           builder,
           target.format,
           target.sampleCount,
+          () => frameState.surfaceSubmissionObservation,
           target.additionalColorFormats,
         );
       },
@@ -2156,14 +2852,42 @@ export function ensureCompiledFrameGraph(
         semanticTargets = [],
         namedTargets = {},
         standardSurfaceAccesses = [],
+        featureSelectionOrPlacement,
+        passNames = [],
       ) => {
-        if (projectedFeatures) return ok(undefined);
-        projectedFeatures = true;
-        if (projectedFeaturePlans.value.length === 0) return ok(undefined);
+        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. 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
+        )
+          .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, projectedFeaturePlans.value, {
+        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) => {
@@ -2188,7 +2912,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(
@@ -2203,6 +2928,20 @@ export function ensureCompiledFrameGraph(
       },
       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,
   );
@@ -2210,12 +2949,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();
@@ -2229,13 +2967,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 ||
@@ -2263,8 +3004,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;
@@ -2296,9 +3051,8 @@ 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;
 }
 
@@ -2324,20 +3078,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,
+    getRenderFeatureGraphState(internals).plans,
+  );
   const legacyTimingInstrumentation =
     timingCapture === undefined ? undefined : createTimingInstrumentation(timingCapture);
   const timingHost = internals as RenderSystemInternals & {
@@ -2400,6 +3165,7 @@ export function executeCompiledFrameGraph(
     );
     settleVolumetricFogGraphCandidate(frameState, false);
     settleDepthOfFieldGraphCandidate(frameState, false);
+    settleBarrelDistortionGraphCandidate(frameState, false);
     return false;
   }
   const capturedGeneration = deviceScope?.generation;
@@ -2903,8 +3669,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' };
@@ -2960,6 +3726,11 @@ export function executeCompiledFrameGraph(
     commit: () => {
       resolvedFrameHooks?.onSubmitted?.();
       legacySubmitCommit?.();
+      if (motionBlurExecution === undefined) {
+        delete frameState.motionBlurExecution;
+      } else {
+        frameState.motionBlurExecution = motionBlurExecution;
+      }
       if (frameState.temporalFrameInput !== undefined) {
         const temporal = frameState.temporalFrameTransaction.commit({ accepted: true });
         if (temporal.ok) {
@@ -3053,6 +3824,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;
       }
@@ -3061,7 +3837,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.
@@ -3092,6 +3868,7 @@ export function executeCompiledFrameGraph(
       frameState.pendingAtmospherePublish?.();
       frameState.pendingAtmospherePublish = undefined;
       onSubmitted?.(internals.device.queue.onSubmittedWorkDone());
+      settleBarrelDistortionGraphCandidate(frameState, true);
       settleVolumetricFogGraphCandidate(frameState, true);
       settleDepthOfFieldGraphCandidate(frameState, true);
     },
@@ -3127,11 +3904,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);
     },
@@ -3139,6 +3918,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();