@forgeax/engine-render 0.1.28 → 0.1.30

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

@@ -25,10 +25,19 @@ import { executeRendererFrameTransaction } from '../assembly/renderer-frame-tran
 import { type RenderError, RenderFeatureStageFailedError } from '../errors/render';
 import {
   getRenderFeaturePlanExecutionProjection,
+  hasSubmissionSensitiveFeatures,
   type RenderFeaturePlanExecution,
 } from '../features/host';
-import { type RenderFeaturePlannedFrame, renderFeaturePlanSignature } from '../features/plan';
-import { projectRenderFeaturePlans as projectPlanExecutions } from '../features/render-graph-contribution';
+import {
+  type RenderFeaturePlannedFrame,
+  renderFeaturePlanSignature,
+  renderFeaturePlanSignatureEvidenceMatches,
+} from '../features/plan';
+import {
+  createRenderFeatureProjectionState,
+  projectRenderFeaturePlans as projectPlanExecutions,
+  projectRenderFeatureShadows,
+} from '../features/render-graph-contribution';
 import type {
   RenderFeatureGraphBindingsResolution,
   RenderFeatureGraphTargetResolver,
@@ -46,13 +55,29 @@ import {
   GPU_TEXTURE_USAGE_COPY_DST,
   GPU_TEXTURE_USAGE_COPY_SRC,
   GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
+  GPU_TEXTURE_USAGE_STORAGE_BINDING,
   GPU_TEXTURE_USAGE_TEXTURE_BINDING,
 } from '../gpu-texture-usage';
+import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM } from '../gpu-usage';
+import { createStandardSurfaceLightingBindGroup } from '../hdrp-buffers';
+import type { RenderFeatureGraphInspection } from '../inspection-types';
+import type { RenderExtent } from '../pipeline/render-extent';
 import {
   type StandardTopologyInputValue,
   standardLightingTopologySignature,
 } from '../pipeline/standard-lighting/topology';
+import {
+  importAutoExposureGraphResources,
+  retireAutoExposureGpuResources,
+} from '../pipeline/standard-output/auto-exposure/gpu';
+import { commitAutoExposureSubmission } from '../pipeline/standard-output/auto-exposure/state';
+import { retireStandardLutGpuResources } from '../pipeline/standard-output/lut-gpu';
+import {
+  commitStandardLutCandidate,
+  resetStandardLutState,
+} from '../pipeline/standard-output/lut-state';
 import { resolveVolumetricFogProfile, STANDARD_PIPELINE_ID } from '../pipeline/standard-profile';
+import { type ProbeBackgroundResources, recordProbeBackground } from '../reflection/background';
 import type { CameraSnapshot } from '../render-contract';
 import type {
   RenderPipelineFeatureTarget,
@@ -61,7 +86,7 @@ import type {
 } from '../render-pipeline';
 import type { ExtractedLights, ExtractedVolumetricFog } from '../render-system-extract';
 import { SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS } from '../shadow-atlas';
-import type { SsrAdmissionResult } from '../ssr/admission';
+import type { SsrAdmissionResult, SsrSpatialAdmission } from '../ssr/admission';
 import type { RenderTarget } from '../targets/contracts';
 import type { RenderTargetPhysical } from '../targets/physical';
 import {
@@ -71,15 +96,22 @@ import {
   hasPendingTemporalGpuSubmit,
   retireTemporalGpuState,
   retireTemporalGpuStateAfterFence,
+  TEMPORAL_HISTORY_FORMATS,
   temporalReadIndex,
   temporalWriteIndex,
 } from '../temporal/gpu';
 import { isSceneDataTarget } from '../temporal/scene-data';
+import { createTargetCoverageAttachment } from '../temporal/target-coverage-attachment';
 import type { TransmissionDemand } from '../transmission/projection';
 import { hasVolumetricFogCapability } from '../volume/capability';
 import { deriveVolumetricFogExtent, deriveVolumetricFogResolvedExtent } from '../volume/resources';
 import { buildPerFrameBindGroups } from './frame-lighting';
-import { getTextureIdentity, type RenderFrameState } from './frame-snapshot';
+import {
+  type GraphTargetPassReplayPrefixReceipt,
+  type GraphTargetPassReplayReceipt,
+  getTextureIdentity,
+  type RenderFrameState,
+} from './frame-snapshot';
 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';
@@ -198,13 +230,14 @@ export function commitReflectionFallbackGraph(
 function importTemporalHistoryTarget(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
   label: string,
-  kind: 'color' | 'temporal',
+  kind: 'color' | 'temporal' | 'stability',
   role: 'read' | 'write',
 ): import('../render-pipeline').RenderPipelineTarget {
+  const format = TEMPORAL_HISTORY_FORMATS[kind];
   const texture = graph.importTexture(
     label,
     {
-      format: 'rgba16float',
+      format,
       size: 'surface',
       usage:
         GPU_TEXTURE_USAGE_COPY_SRC |
@@ -222,7 +255,7 @@ function importTemporalHistoryTarget(
         frame.targetH,
       );
       const index = role === 'read' ? temporalReadIndex(state) : temporalWriteIndex(state);
-      return (kind === 'color' ? state.color[index] : state.temporal[index]).texture;
+      return state[kind][index].texture;
     },
   );
   if (!texture.ok) throw texture.error;
@@ -239,11 +272,11 @@ function importTemporalHistoryTarget(
         frame.targetH,
       );
       const index = role === 'read' ? temporalReadIndex(state) : temporalWriteIndex(state);
-      return (kind === 'color' ? state.color[index] : state.temporal[index]).view;
+      return state[kind][index].view;
     },
   );
   if (!view.ok) throw view.error;
-  return { texture: texture.value, view: view.value, format: 'rgba16float', sampleCount: 1 };
+  return { texture: texture.value, view: view.value, format, sampleCount: 1 };
 }
 
 function importTemporalHistoryTargets(
@@ -253,6 +286,18 @@ function importTemporalHistoryTargets(
 > {
   return {
     currentColor: importTemporalHistoryTarget(graph, 'taa-history-current-color', 'color', 'write'),
+    currentStability: importTemporalHistoryTarget(
+      graph,
+      'taa-history-current-stability',
+      'stability',
+      'write',
+    ),
+    previousStability: importTemporalHistoryTarget(
+      graph,
+      'taa-history-previous-stability',
+      'stability',
+      'read',
+    ),
     previousColor: importTemporalHistoryTarget(
       graph,
       'taa-history-previous-color',
@@ -274,6 +319,110 @@ function importTemporalHistoryTargets(
   };
 }
 
+function importSsrHistoryTarget(
+  graph: RenderGraphBuilder<RenderPipelineFrame>,
+  label: string,
+  role: 'read' | 'write',
+  surface = false,
+): import('../render-pipeline').RenderPipelineTarget {
+  const texture = graph.importTexture(
+    label,
+    {
+      format: surface ? 'rgba8unorm' : 'rgba16float',
+      size: 'half-surface',
+      usage:
+        GPU_TEXTURE_USAGE_COPY_SRC |
+        GPU_TEXTURE_USAGE_COPY_DST |
+        GPU_TEXTURE_USAGE_RENDER_ATTACHMENT |
+        GPU_TEXTURE_USAGE_STORAGE_BINDING |
+        GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+      domain: 'linear-hdr',
+    },
+    (frame) => {
+      const internal = frame as import('./render-context')._InternalRenderPipelineContext;
+      const owner = internal.frameState.ssrHistoryOwner;
+      const candidate = internal.frameState.ssrHistoryCandidate;
+      if (owner === undefined || candidate === undefined) {
+        throw new RhiError({
+          code: 'rhi-not-available',
+          expected: 'SSR history candidate to be staged before graph execution',
+          hint: 'begin the SSR history candidate before executing the admitted graph',
+        });
+      }
+      const slot =
+        role === 'read'
+          ? (candidate.readSlot ?? (candidate.writeSlot === 0 ? 1 : 0))
+          : candidate.writeSlot;
+      return surface
+        ? owner.resources.slots[slot].surfaceTexture
+        : owner.resources.slots[slot].texture;
+    },
+  );
+  if (!texture.ok) throw texture.error;
+  const view = graph.importView(
+    texture.value,
+    { label: `${label}.view`, dimension: '2d' },
+    (frame) => {
+      const internal = frame as import('./render-context')._InternalRenderPipelineContext;
+      const owner = internal.frameState.ssrHistoryOwner;
+      const candidate = internal.frameState.ssrHistoryCandidate;
+      if (owner === undefined || candidate === undefined) {
+        throw new RhiError({
+          code: 'rhi-not-available',
+          expected: 'SSR history candidate to be staged before graph execution',
+          hint: 'begin the SSR history candidate before executing the admitted graph',
+        });
+      }
+      const slot =
+        role === 'read'
+          ? (candidate.readSlot ?? (candidate.writeSlot === 0 ? 1 : 0))
+          : candidate.writeSlot;
+      return surface ? owner.resources.slots[slot].surfaceView : owner.resources.slots[slot].view;
+    },
+  );
+  if (!view.ok) throw view.error;
+  return {
+    texture: texture.value,
+    view: view.value,
+    format: surface ? 'rgba8unorm' : 'rgba16float',
+    sampleCount: 1,
+    domain: 'linear-hdr',
+  };
+}
+
+function importSsrHistoryTargets(
+  graph: RenderGraphBuilder<RenderPipelineFrame>,
+): NonNullable<
+  import('../render-pipeline').RenderPipelineBuildContext<RenderPipelineFrame>['ssrHistory']
+> {
+  return {
+    previous: importSsrHistoryTarget(graph, 'ssr-history-previous', 'read'),
+    output: importSsrHistoryTarget(graph, 'ssr-history-output', 'write'),
+    previousSurface: importSsrHistoryTarget(graph, 'ssr-history-previous-surface', 'read', true),
+    outputSurface: importSsrHistoryTarget(graph, 'ssr-history-output-surface', 'write', true),
+    params: (() => {
+      const imported = graph.importBuffer(
+        'ssr-history-params',
+        { size: 32, usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST },
+        (frame) => {
+          const internal = frame as import('./render-context')._InternalRenderPipelineContext;
+          const owner = internal.frameState.ssrHistoryOwner;
+          if (owner === undefined) {
+            throw new RhiError({
+              code: 'rhi-not-available',
+              expected: 'SSR history owner to be staged before graph execution',
+              hint: 'create the renderer-owned SSR history before executing the admitted graph',
+            });
+          }
+          return owner.resources.paramsBuffer;
+        },
+      );
+      if (!imported.ok) throw imported.error;
+      return imported.value;
+    })(),
+  };
+}
+
 export function shouldUseTemporalFrameTransaction(
   antialias: CameraSnapshot['antialias'],
   temporalDemand = false,
@@ -345,6 +494,7 @@ export interface ReflectionProbeFilterGraphState {
 }
 
 export interface ReflectionProbeGraphWork {
+  readonly background?: ProbeBackgroundResources;
   readonly probeIndex: number;
   readonly rawTexture: Texture;
   readonly rawCubeView: TextureView;
@@ -538,7 +688,6 @@ function addCubeCaptureGraphPasses(
         const captureResolveView = captureResolve?.ok ? captureResolve.value : null;
         const captureContext = {
           ...internal,
-          gpuDrivenEntityKeys: new Set<number>(),
           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
@@ -571,6 +720,7 @@ function addCubeCaptureGraphPasses(
 export function addReflectionProbeGraphPasses(
   builder: RenderGraphBuilder<RenderPipelineFrame>,
   state: ReflectionProbeGraphState,
+  environmentCube?: import('../environment/ibl').GraphEnvironment,
 ): Result<readonly import('@forgeax/engine-render-graph').GraphAccess[], RenderGraphError> {
   const accesses: import('@forgeax/engine-render-graph').GraphAccess[] = [];
   for (const work of state.work) {
@@ -656,6 +806,11 @@ export function addReflectionProbeGraphPasses(
       if (!depth.ok) return depth;
       const added = builder.addRasterPass(`reflection-probe.${work.probeIndex}.capture.${face}`, {
         accesses: [
+          ...(environmentCube === undefined
+            ? []
+            : [environmentCube.sky, environmentCube.irradiance, environmentCube.prefilter].map(
+                (resource) => ({ resource, usage: 'sampled-read' as const }),
+              )),
           { resource: view.value, usage: 'color-attachment' },
           { resource: depth.value, usage: 'depth-stencil-write' },
         ],
@@ -683,9 +838,35 @@ export function addReflectionProbeGraphPasses(
           if (!captureColor.ok || !captureDepth.ok) return;
           if (work.faceCamera === undefined || work.viewBindGroupDynamicOffset === undefined)
             return;
+          recordProbeBackground(
+            work.background,
+            internal,
+            work.faceCamera,
+            pass,
+            environmentCube === undefined
+              ? undefined
+              : resources.textureView(environmentCube.sky).unwrap(),
+          );
+          const captureContext = {
+            ...internal,
+            ...(environmentCube === undefined
+              ? {}
+              : {
+                  environmentIbl: {
+                    irradiance: resources.textureView(environmentCube.irradiance).unwrap(),
+                    prefilter: resources.textureView(environmentCube.prefilter).unwrap(),
+                  },
+                }),
+          };
+          delete captureContext.reflectionProbes;
+          delete captureContext.hdrpSsaoBlurredView;
+          delete captureContext.gpuDrivenDrawKeys;
+          delete captureContext.gpuDrivenStandardPbrFrameResources;
           encodeMainPass(
             {
-              ...internal,
+              ...captureContext,
+              dispatch: internal.captureDispatch ?? internal.dispatch,
+              foldDispatchPlan: null,
               camera: work.faceCamera,
               viewBindGroupDynamicOffset: work.viewBindGroupDynamicOffset,
               geometryColorView: captureColor.value,
@@ -787,6 +968,57 @@ export interface RenderFeatureGraphRuntimeState {
   >;
 }
 
+/** The exact fields that define one validated feature-plan collection. */
+export interface RenderFeaturePlanRevisionEntry {
+  readonly featureIdentity: string;
+  readonly generation: number;
+  readonly signature: string;
+  readonly order: number;
+}
+
+/** Compact graph-owner state for a completely validated feature-plan set. */
+export interface RenderFeaturePlanRevisionState {
+  readonly revision: number;
+  readonly entries: readonly RenderFeaturePlanRevisionEntry[];
+}
+
+/**
+ * Advance the plan revision only when the complete canonical plan collection
+ * changes. Equality is an exact field comparison; the canonical signatures
+ * have already been recomputed by validation before this helper is called.
+ */
+export function updateRenderFeaturePlanRevision(
+  previous: RenderFeaturePlanRevisionState,
+  plans: readonly RenderFeaturePlannedFrame[],
+  executions: readonly RenderFeaturePlanExecution[],
+): RenderFeaturePlanRevisionState {
+  if (
+    plans.length === previous.entries.length &&
+    plans.every((planned, index) => {
+      const prior = previous.entries[index];
+      return (
+        prior !== undefined &&
+        prior.featureIdentity === planned.featureIdentity &&
+        prior.generation === planned.generation &&
+        prior.signature === planned.signature &&
+        prior.order === (executions[index]?.order ?? -1)
+      );
+    })
+  ) {
+    return previous;
+  }
+  const entries = plans.map((planned, index) => ({
+    featureIdentity: planned.featureIdentity,
+    generation: planned.generation,
+    signature: planned.signature,
+    order: executions[index]?.order ?? -1,
+  }));
+  return {
+    revision: previous.revision + 1,
+    entries: Object.freeze(entries),
+  };
+}
+
 /** A frame-local graph candidate that is committed only after compilation. */
 export interface RenderFeatureGraphCandidate {
   readonly plans: readonly RenderFeaturePlannedFrame[];
@@ -795,16 +1027,22 @@ export interface RenderFeatureGraphCandidate {
     import('../fullscreen-post-process-pass').PostProcessShaderEntry
   >;
   /**
-   * Physical prepared resources are imported into the compiled graph. A new
-   * prepared batch therefore needs a new graph even when the declarative plan
-   * signature is unchanged; otherwise queue retirement can destroy the buffer
-   * still referenced by the memoized graph.
+   * Physical transient graphics resources are imported into the compiled
+   * graph. Their lease therefore needs a new graph even when the declarative
+   * plan signature is unchanged; otherwise queue retirement could destroy a
+   * buffer still referenced by the memoized graph. Retired GPU-work leases are
+   * kept in the completion batch but are not imported by this candidate and do
+   * not require a graph revision on their own.
    */
   readonly preparedResourceKey?: string;
   /** Release candidate-owned prepared resources when graph promotion fails. */
   readonly onRejected?: () => void;
   /** Publish candidate-owned runtime declarations only after graph promotion. */
   readonly onAccepted?: () => void;
+  /** Consume producer frame state only after the command buffer is submitted. */
+  readonly onSubmitted?: () => void;
+  /** Discard producer frame state after graph execution/submission aborts. */
+  readonly onAborted?: () => void;
   /** Discard candidate-only resources when a base graph is kept as fallback. */
   readonly onAbandoned?: () => void;
 }
@@ -812,6 +1050,139 @@ export interface RenderFeatureGraphCandidate {
 const featureGraphStates = new WeakMap<RenderSystemInternals, RenderFeatureGraphRuntimeState>();
 const graphDeviceGenerations = new WeakMap<object, number>();
 
+interface MutableRenderFeatureGraphInspection {
+  planRevisionState: RenderFeaturePlanRevisionState;
+  signatureValidationCalls: number;
+  signatureValidationBytes: number;
+  signatureValidationChars: number;
+  signatureValidationCpuMs: number;
+  signatureValidationCacheHits: number;
+  signatureValidationCacheMisses: number;
+  ensureCalls: number;
+  reuseHits: number;
+  rebuildAttempts: number;
+  compileAttempts: number;
+  compileSuccesses: number;
+  compileFailures: number;
+  validationFailures: number;
+  buildFailures: number;
+  compileCpuMs: number;
+  candidatesWithPreparedBatches: number;
+  preparedKeyChanges: number;
+  accepted: number;
+  rejected: number;
+  abandoned: number;
+  lastPlanSignature: string;
+  lastTopologyKey: string | undefined;
+  lastPreparedResourceKey: string | undefined;
+  preparedKeyObserved: boolean;
+}
+
+const featureGraphInspections = new WeakMap<
+  RenderSystemInternals,
+  MutableRenderFeatureGraphInspection
+>();
+
+function mutableFeatureGraphInspection(
+  internals: RenderSystemInternals,
+): MutableRenderFeatureGraphInspection {
+  const existing = featureGraphInspections.get(internals);
+  if (existing !== undefined) return existing;
+  const created: MutableRenderFeatureGraphInspection = {
+    planRevisionState: { revision: 0, entries: [] },
+    signatureValidationCalls: 0,
+    signatureValidationBytes: 0,
+    signatureValidationChars: 0,
+    signatureValidationCpuMs: 0,
+    signatureValidationCacheHits: 0,
+    signatureValidationCacheMisses: 0,
+    ensureCalls: 0,
+    reuseHits: 0,
+    rebuildAttempts: 0,
+    compileAttempts: 0,
+    compileSuccesses: 0,
+    compileFailures: 0,
+    validationFailures: 0,
+    buildFailures: 0,
+    compileCpuMs: 0,
+    candidatesWithPreparedBatches: 0,
+    preparedKeyChanges: 0,
+    accepted: 0,
+    rejected: 0,
+    abandoned: 0,
+    lastPlanSignature: '',
+    lastTopologyKey: undefined,
+    lastPreparedResourceKey: undefined,
+    preparedKeyObserved: false,
+  };
+  featureGraphInspections.set(internals, created);
+  return created;
+}
+
+export function getRenderFeatureGraphInspection(
+  internals: RenderSystemInternals,
+): RenderFeatureGraphInspection {
+  const metrics = mutableFeatureGraphInspection(internals);
+  return Object.freeze({
+    planRevision: metrics.planRevisionState.revision,
+    signatureValidationCalls: metrics.signatureValidationCalls,
+    signatureValidationBytes: metrics.signatureValidationBytes,
+    signatureValidationChars: metrics.signatureValidationChars,
+    signatureValidationCpuMs: metrics.signatureValidationCpuMs,
+    signatureValidationCacheHits: metrics.signatureValidationCacheHits,
+    signatureValidationCacheMisses: metrics.signatureValidationCacheMisses,
+    ensureCalls: metrics.ensureCalls,
+    reuseHits: metrics.reuseHits,
+    rebuildAttempts: metrics.rebuildAttempts,
+    compileAttempts: metrics.compileAttempts,
+    compileSuccesses: metrics.compileSuccesses,
+    compileFailures: metrics.compileFailures,
+    validationFailures: metrics.validationFailures,
+    buildFailures: metrics.buildFailures,
+    compileCpuMs: metrics.compileCpuMs,
+    candidatesWithPreparedBatches: metrics.candidatesWithPreparedBatches,
+    preparedKeyChanges: metrics.preparedKeyChanges,
+    accepted: metrics.accepted,
+    rejected: metrics.rejected,
+    abandoned: metrics.abandoned,
+    last: Object.freeze({
+      planSignature: metrics.lastPlanSignature,
+      topologyKey: metrics.lastTopologyKey,
+      preparedResourceKey: metrics.lastPreparedResourceKey,
+    }),
+  });
+}
+
+export function recordRenderFeatureCandidate(
+  internals: RenderSystemInternals,
+  candidate: RenderFeatureGraphCandidate,
+): void {
+  const metrics = mutableFeatureGraphInspection(internals);
+  if (
+    metrics.preparedKeyObserved &&
+    metrics.lastPreparedResourceKey !== candidate.preparedResourceKey
+  ) {
+    metrics.preparedKeyChanges += 1;
+  }
+  metrics.preparedKeyObserved = true;
+  metrics.lastPreparedResourceKey = candidate.preparedResourceKey;
+  if (candidate.preparedResourceKey !== undefined) {
+    metrics.candidatesWithPreparedBatches += 1;
+  }
+}
+
+function recordRenderFeatureCandidateEvent(
+  internals: RenderSystemInternals,
+  candidate: RenderFeatureGraphCandidate,
+  event: 'accepted' | 'rejected' | 'abandoned',
+): void {
+  const metrics = mutableFeatureGraphInspection(internals);
+  metrics[event] += 1;
+  if (event === 'accepted') candidate.onAccepted?.();
+  else if (event === 'rejected') candidate.onRejected?.();
+  else candidate.onAbandoned?.();
+}
+
 interface TimingInstrumentationState {
   readonly instrumentation: RenderGraphPassInstrumentation<RenderPipelineFrame>;
   setCapture(capture: GpuPassTimingCapture | undefined): void;
@@ -830,6 +1201,11 @@ type CompiledGraphTargetAccess = CompiledRenderGraph<RenderPipelineFrame> & {
   readonly getColorTargetTexture: (name: string) => Texture | undefined;
 };
 
+type ResolvedDepthPassExecution =
+  import('@forgeax/engine-render-graph').RenderGraphPassExecution & {
+    readonly resolvedDepthStencilAttachmentView?: TextureView;
+  };
+
 export function getRenderFeatureGraphState(
   internals: RenderSystemInternals,
 ): RenderFeatureGraphRuntimeState {
@@ -899,15 +1275,46 @@ export function resolvePostProcessChainAdmission(
 
 function validateRenderFeaturePlans(
   plans: readonly RenderFeaturePlannedFrame[],
+  metrics?: MutableRenderFeatureGraphInspection,
 ): Result<readonly RenderFeaturePlanExecution[], RenderError> {
   const identities = new Set<string>();
   const projected: RenderFeaturePlanExecution[] = [];
   let previousOrder = -1;
   for (const [order, planned] of plans.entries()) {
     const execution = getRenderFeaturePlanExecutionProjection(planned);
+    const signatureMetrics =
+      metrics === undefined ? undefined : { calls: 0, typedArrayBytes: 0, outputChars: 0 };
+    const started =
+      metrics === undefined
+        ? 0
+        : typeof performance === 'undefined'
+          ? Date.now()
+          : performance.now();
+    // The host records detached structural evidence, but graph admission must
+    // check it again so a mutation between the two synchronous stages cannot
+    // smuggle a stale plan into the compiled graph. Only candidates without
+    // evidence fall back to the canonical serializer.
+    const signatureCacheHit = renderFeaturePlanSignatureEvidenceMatches(
+      planned.plan,
+      planned.signature,
+    );
+    if (metrics !== undefined) {
+      if (signatureCacheHit) metrics.signatureValidationCacheHits += 1;
+      else metrics.signatureValidationCacheMisses += 1;
+    }
+    const recomputedSignature = signatureCacheHit
+      ? planned.signature
+      : renderFeaturePlanSignature(planned.plan, signatureMetrics);
+    if (metrics !== undefined) {
+      const now = typeof performance === 'undefined' ? Date.now() : performance.now();
+      metrics.signatureValidationCalls += signatureMetrics?.calls ?? 0;
+      metrics.signatureValidationBytes += signatureMetrics?.typedArrayBytes ?? 0;
+      metrics.signatureValidationChars += signatureMetrics?.outputChars ?? 0;
+      metrics.signatureValidationCpuMs += now - started;
+    }
     if (
       identities.has(planned.featureIdentity) ||
-      planned.signature !== renderFeaturePlanSignature(planned.plan) ||
+      planned.signature !== recomputedSignature ||
       execution === undefined ||
       execution.featureIdentity !== planned.featureIdentity ||
       execution.order <= previousOrder
@@ -930,7 +1337,7 @@ function commitFeatureCandidate(
   // Publish renderer-owned declarations only after their device resources have
   // been admitted.  If the acceptance hook throws, the previously accepted
   // graph/state pair remains visible to the caller.
-  candidate.onAccepted?.();
+  recordRenderFeatureCandidateEvent(internals, candidate, 'accepted');
   const state = getRenderFeatureGraphState(internals);
   state.plans = candidate.plans;
   state.fullscreenEffects = candidate.fullscreenEffects;
@@ -948,10 +1355,13 @@ function topologyOf(
   shadowMapSize: number | undefined,
   gpuDriven: PreparedGpuDrivenFrame | undefined,
   featureGraphCandidate: RenderFeatureGraphCandidate | undefined,
+  featurePlanRevision: number,
   cubeCaptureState: CubeCaptureGraphState | undefined,
   transmissionDemand: TransmissionDemand | undefined,
   volumetricFog: ExtractedVolumetricFog | undefined,
   standardLighting: StandardTopologyInputValue | undefined,
+  ssr: SsrSpatialAdmission | undefined,
+  renderExtent: RenderExtent | undefined,
 ): Result<RenderPipelineTopology, RhiError> {
   const cascadeCount = Math.max(1, Math.min(4, Math.round(lights.cascadeCount ?? 1))) as
     | 1
@@ -1007,12 +1417,16 @@ function topologyOf(
           : volumetricFog?.lightKind === undefined
             ? lights.directional
             : undefined;
+  const preparedLut =
+    frameState.pendingStandardLutGpuResources ?? frameState.standardLutGpuResources;
   return ok({
     pipelineId: STANDARD_PIPELINE_ID,
     standardProfile: internals.standardProfile,
     config,
     clearOnly,
     reflectionFallback: { enabled: frameState.reflectionFallbackDemand === true },
+    ssr,
+    ...(renderExtent === undefined ? {} : { extent: renderExtent }),
     surface: {
       width,
       height,
@@ -1025,6 +1439,27 @@ function topologyOf(
       antialias: camera.antialias,
       bloom: camera.bloom,
     },
+    atmosphere: !clearOnly && frameState.environmentFrame?.source.kind === 'atmosphere',
+    output: {
+      autoExposure:
+        !clearOnly &&
+        camera.output?.exposure.kind === 'auto' &&
+        (frameState.pendingAutoExposureGpuResources ?? frameState.autoExposureGpuResources) !==
+          undefined,
+      whiteBalance:
+        !clearOnly &&
+        camera.output !== undefined &&
+        (camera.output.temperature !== 6504 || camera.output.tint !== 0),
+      temperature: camera.output?.temperature ?? 6504,
+      tint: camera.output?.tint ?? 0,
+      colorLut:
+        !clearOnly &&
+        (camera.output?.colorLutStrength ?? 0) > 0 &&
+        (frameState.pendingStandardLutGpuResources ?? frameState.standardLutGpuResources) !==
+          undefined,
+      colorLutStrength: camera.output?.colorLutStrength ?? 0,
+      ...(preparedLut === undefined ? {} : { lutSourceKey: preparedLut.sourceKey }),
+    },
     temporal: {
       taa: camera.antialias === 'taa',
       motionBlur: isMotionBlurTemporalDemand(camera.motionBlur),
@@ -1092,9 +1527,7 @@ function topologyOf(
       maxColorAttachments: internals.device.caps.maxColorAttachments,
     },
     featureTopologySignature: JSON.stringify({
-      plans: renderFeatureGraphPlanSignature(
-        featureGraphCandidate?.plans ?? getRenderFeatureGraphState(internals).plans,
-      ),
+      planRevision: featurePlanRevision,
       fullscreenEffects: featurePostEffectDeclarations,
       preparedResourceKey: featureGraphCandidate?.preparedResourceKey ?? '',
       cubeCaptureSlots: cubeCaptureState?.work.length ?? 0,
@@ -1263,7 +1696,9 @@ function resolveTargetBindings(
       frame.runtime as RenderSystemInternals,
       frame.frameState,
       frame.pipelineState,
-      frame.validated.length > 0,
+      // This callback is reached only for an actual feature draw. A scene
+      // containing only particles still needs the pipeline's View/light ABI.
+      true,
       frame.bindGroupCounts,
       {
         directionalShadow: frame.frameState.currentDirectionalShadowView ?? undefined,
@@ -1350,23 +1785,42 @@ export function ensureCompiledFrameGraph(
   volumeTopologyCandidate = false,
   standardLighting?: StandardTopologyInputValue,
   onRecoveryError?: (error: unknown) => void,
+  ssr?: SsrSpatialAdmission,
+  renderExtent?: RenderExtent,
 ): CompiledRenderGraph<RenderPipelineFrame> | null {
+  const featureMetrics = mutableFeatureGraphInspection(internals);
+  featureMetrics.ensureCalls += 1;
   const requestedStandardLightingSignature = standardLightingTopologySignature(standardLighting);
   const lastKnownGood = (): CompiledRenderGraph<RenderPipelineFrame> | null =>
     frameState.compiledFrameGraph !== null &&
+    !hasSubmissionSensitiveFeatures(getRenderFeatureGraphState(internals).plans) &&
     frameState.standardLightingGraphSignature === requestedStandardLightingSignature
       ? frameState.compiledFrameGraph
       : null;
   const surfaceWidth = Math.max(1, width);
   const surfaceHeight = Math.max(1, height);
   const featurePlans = featureGraphCandidate?.plans ?? getRenderFeatureGraphState(internals).plans;
-  const projectedFeaturePlans = validateRenderFeaturePlans(featurePlans);
+  const projectedFeaturePlans = validateRenderFeaturePlans(featurePlans, featureMetrics);
   if (!projectedFeaturePlans.ok) {
+    featureMetrics.validationFailures += 1;
     onRecoveryError?.(projectedFeaturePlans.error);
     reportRenderFeatureGraphError(internals, projectedFeaturePlans.error);
-    featureGraphCandidate?.onRejected?.();
+    if (featureGraphCandidate !== undefined) {
+      recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
+    }
     return volumeTopologyCandidate ? null : lastKnownGood();
   }
+  const nextPlanRevision = updateRenderFeaturePlanRevision(
+    featureMetrics.planRevisionState,
+    featurePlans,
+    projectedFeaturePlans.value,
+  );
+  if (nextPlanRevision !== featureMetrics.planRevisionState) {
+    featureMetrics.lastPlanSignature = nextPlanRevision.entries
+      .map((entry) => `${entry.featureIdentity}:${entry.signature}`)
+      .join('|');
+    featureMetrics.planRevisionState = nextPlanRevision;
+  }
   const topologyResult = topologyOf(
     internals,
     frameState,
@@ -1379,15 +1833,21 @@ export function ensureCompiledFrameGraph(
     shadowMapSize,
     gpuDriven,
     featureGraphCandidate,
+    featureMetrics.planRevisionState.revision,
     cubeCaptureState,
     transmissionDemand,
     volumetricFog,
     standardLighting,
+    ssr,
+    renderExtent,
   );
   if (!topologyResult.ok) {
+    featureMetrics.buildFailures += 1;
     onRecoveryError?.(topologyResult.error);
     internals.errorRegistry.fire(topologyResult.error);
-    featureGraphCandidate?.onRejected?.();
+    if (featureGraphCandidate !== undefined) {
+      recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
+    }
     return volumeTopologyCandidate ? null : lastKnownGood();
   }
   const requestedPostEffects = topologyResult.value.config?.postEffects ?? [];
@@ -1416,7 +1876,7 @@ export function ensureCompiledFrameGraph(
         getPipeline(
           identity,
           built.bindGroupLayout,
-          topologyResult.value.surface.storageFormat as GPUTextureFormat,
+          [topologyResult.value.surface.storageFormat as GPUTextureFormat],
           entry,
         ) !== null
       );
@@ -1427,7 +1887,9 @@ export function ensureCompiledFrameGraph(
     // Do not publish a candidate whose fullscreen chain is only partially
     // ready. Keep the accepted graph (including its prior post-effect chain)
     // and retry the same feature candidate on the next frame.
-    featureGraphCandidate?.onRejected?.();
+    if (featureGraphCandidate !== undefined) {
+      recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
+    }
     return acceptedLkg;
   }
   const topology = postProcessAdmission.pending
@@ -1441,6 +1903,12 @@ export function ensureCompiledFrameGraph(
     : topologyResult.value;
   const key = JSON.stringify({
     topology,
+    // 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
+    // that receipt without forcing every unobserved frame onto the split
+    // output path.
+    observationCaptureDomains: [...(internals.observationCaptureDomains ?? [])].sort(),
     // GPU-driven residency can become available after the first record pass
     // (custom mesh handles are resolved into the per-frame projection).  The
     // topology signature alone is intentionally stable across that lifecycle,
@@ -1461,11 +1929,13 @@ export function ensureCompiledFrameGraph(
     ]),
   });
   if (frameState.compiledFrameGraph !== null && frameState.compiledFrameGraphTopologyKey === key) {
+    featureMetrics.reuseHits += 1;
+    featureMetrics.lastTopologyKey = key;
     frameState.standardLightingGraphSignature = requestedStandardLightingSignature;
     if (featureGraphCandidate !== undefined && !postProcessAdmission.pending) {
       commitFeatureCandidate(internals, featureGraphCandidate);
     } else if (featureGraphCandidate !== undefined) {
-      featureGraphCandidate.onAbandoned?.();
+      recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'abandoned');
     }
     // A candidate flag only describes a possible topology replacement. When
     // the derived key is unchanged there is no replacement to stage: reuse the
@@ -1474,17 +1944,120 @@ export function ensureCompiledFrameGraph(
     return frameState.compiledFrameGraph;
   }
 
+  featureMetrics.rebuildAttempts += 1;
+  featureMetrics.lastTopologyKey = key;
+  const discardPendingStandardOutput = (): void => {
+    if (frameState.pendingAutoExposureGpuResources !== undefined) {
+      retireAutoExposureGpuResources(frameState.pendingAutoExposureGpuResources);
+      frameState.pendingAutoExposureGpuResources = undefined;
+    }
+    if (frameState.pendingStandardLutGpuResources !== undefined) {
+      retireStandardLutGpuResources(frameState.pendingStandardLutGpuResources);
+      frameState.pendingStandardLutGpuResources = undefined;
+    }
+  };
   const builder = new RenderGraphBuilder<RenderPipelineFrame>();
+  const autoExposureResources =
+    topology.output?.autoExposure === true ? importAutoExposureGraphResources(builder) : undefined;
+  if (autoExposureResources !== undefined && !autoExposureResources.ok) {
+    internals.errorRegistry.fire(autoExposureResources.error);
+    featureGraphCandidate?.onRejected?.();
+    discardPendingStandardOutput();
+    return lastKnownGood();
+  }
+  const lutResources =
+    topology.output?.colorLut === true
+      ? (() => {
+          const prepared =
+            frameState.pendingStandardLutGpuResources ?? frameState.standardLutGpuResources;
+          if (prepared === undefined) return undefined;
+          const texture = builder.importTexture(
+            'standard-color-lut-source',
+            {
+              format: 'rgba16float',
+              size: {
+                width: prepared.size,
+                height: prepared.size,
+                depthOrArrayLayers: prepared.size,
+              },
+              dimension: '3d',
+              usage: GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+            },
+            (frame) =>
+              (
+                (frame as _InternalRenderPipelineContext).frameState
+                  .pendingStandardLutGpuResources ??
+                (frame as _InternalRenderPipelineContext).frameState.standardLutGpuResources
+              )?.texture ?? prepared.texture,
+          );
+          if (!texture.ok) return texture;
+          const view = builder.importView(
+            texture.value,
+            { label: 'standard-color-lut-source.view', dimension: '3d' },
+            (frame) =>
+              (
+                (frame as _InternalRenderPipelineContext).frameState
+                  .pendingStandardLutGpuResources ??
+                (frame as _InternalRenderPipelineContext).frameState.standardLutGpuResources
+              )?.view ?? prepared.view,
+          );
+          if (!view.ok) return view;
+          return ok({ texture: texture.value, view: view.value, prepared });
+        })()
+      : undefined;
+  if (lutResources !== undefined && !lutResources.ok) {
+    internals.errorRegistry.fire(lutResources.error);
+    featureGraphCandidate?.onRejected?.();
+    discardPendingStandardOutput();
+    return lastKnownGood();
+  }
   const taaHistory = camera.antialias === 'taa' ? importTemporalHistoryTargets(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();
+  }
+  const ssrHistory = ssr?.status === 'admitted' ? importSsrHistoryTargets(builder) : undefined;
   let projectedFeatures = false;
+  const featureProjection = createRenderFeatureProjectionState();
+  let featureShadows:
+    | ReturnType<typeof projectRenderFeatureShadows<RenderPipelineFrame>>
+    | undefined;
   let projectedGpuDriven = false;
   const built = frameState.activePipeline.build(
     {
       graph: builder,
+      observationCaptureDomains: internals.observationCaptureDomains,
+      ...(autoExposureResources?.ok === true
+        ? { standardOutput: { autoExposure: autoExposureResources.value } }
+        : {}),
+      ...(lutResources?.ok === true
+        ? {
+            standardOutput: {
+              ...(autoExposureResources?.ok === true
+                ? { autoExposure: autoExposureResources.value }
+                : {}),
+              colorLut: {
+                view: lutResources.value.view,
+                sampler: lutResources.value.prepared.sampler,
+                strength: lutResources.value.prepared.strength,
+                bindGroupLayout: lutResources.value.prepared.bindGroupLayout,
+                bindGroup: lutResources.value.prepared.bindGroup,
+              },
+            },
+          }
+        : {}),
       ...(standardLighting === undefined ? {} : { standardLighting }),
       capabilities: { rgba16floatRenderable: internals.device.caps.rgba16floatRenderable },
       ...(occlusion === undefined ? {} : { occlusion }),
       ...(taaHistory === undefined ? {} : { taaHistory }),
+      ...(targetCoverage?.ok === true ? { targetCoverage: targetCoverage.value } : {}),
+      ...(ssrHistory === undefined ? {} : { ssrHistory }),
       encodeTransmissionMip: ({ pass, resources, source }) => {
         const sourceView = resources.textureView(source);
         if (!sourceView.ok) throw sourceView.error;
@@ -1494,24 +2067,69 @@ export function ensureCompiledFrameGraph(
       projectGpuDriven: (target) => {
         if (projectedGpuDriven || gpuDriven === undefined) return ok(undefined);
         projectedGpuDriven = true;
-        return gpuDriven.project(builder, target.format, target.sampleCount);
+        return gpuDriven.project(
+          builder,
+          target.format,
+          target.sampleCount,
+          target.additionalColorFormats,
+        );
       },
-      contributeFeatures: (targets, semanticTargets = [], namedTargets = {}) => {
+      ...(gpuDriven?.projectShadow === undefined
+        ? {}
+        : {
+            projectGpuDrivenShadow: (identity) =>
+              gpuDriven.projectShadow?.(builder, identity) ?? ok(undefined),
+          }),
+      contributeShadowFeatures: () =>
+        (featureShadows ??= projectRenderFeatureShadows(
+          builder,
+          projectedFeaturePlans.value,
+          featureProjection,
+        )),
+      contributeFeatures: (
+        targets,
+        semanticTargets = [],
+        namedTargets = {},
+        standardSurfaceAccesses = [],
+      ) => {
         if (projectedFeatures) return ok(undefined);
         projectedFeatures = true;
         if (projectedFeaturePlans.value.length === 0) return ok(undefined);
         const resolveTarget = targetResolver(targets, semanticTargets, namedTargets);
         const projected = projectPlanExecutions(builder, projectedFeaturePlans.value, {
+          state: featureProjection,
           resolveTarget,
+          standardSurfaceAccesses,
           resolveBindings: (input) => resolveTargetBindings(input, featurePostProcessEntries),
+          resolveStandardLighting: (frame, pipeline) => {
+            const context = frame as import('./render-context')._InternalRenderPipelineContext;
+            if (context.standardLighting?.kind !== 'clustered') return undefined;
+            const layout = (
+              pipeline as RenderPipeline & {
+                getBindGroupLayout?: (index: number) => BindGroupLayout;
+              }
+            ).getBindGroupLayout?.(2);
+            if (layout === undefined) return undefined;
+            return (
+              createStandardSurfaceLightingBindGroup(
+                context.runtime,
+                layout,
+                context.standardLighting.prepared.layout.grid,
+                context.hdrpSsaoBlurredView === undefined
+                  ? { enabled: false }
+                  : { enabled: true, ssaoBlurredView: context.hdrpSsaoBlurredView },
+              ) ?? undefined
+            );
+          },
           reportError: (error) => reportRenderFeatureGraphError(internals, error),
         });
         return projected.ok ? ok(undefined) : projected;
       },
-      contributeCubeCaptures: () => {
+      contributeCubeCaptures: (environmentCube) => {
         const reflectionProbes = addReflectionProbeGraphPasses(
           builder,
           cubeCaptureState?.reflectionProbes ?? { work: [] },
+          environmentCube,
         );
         if (!reflectionProbes.ok) return reflectionProbes;
         return cubeCaptureState === undefined
@@ -1524,19 +2142,33 @@ export function ensureCompiledFrameGraph(
     topology,
   );
   if (!built.ok) {
+    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();
   }
+  featureMetrics.compileAttempts += 1;
+  const compileStarted = typeof performance === 'undefined' ? Date.now() : performance.now();
   const compiled = builder.compile({
     device: internals.device,
     surfaceSize: { width: surfaceWidth, height: surfaceHeight },
   });
+  featureMetrics.compileCpuMs +=
+    (typeof performance === 'undefined' ? Date.now() : performance.now()) - compileStarted;
   if (!compiled.ok) {
+    featureMetrics.compileFailures += 1;
     onRecoveryError?.(compiled.error);
     internals.errorRegistry.fire(compiled.error);
     featureGraphCandidate?.onRejected?.();
+    discardPendingStandardOutput();
+    if (featureGraphCandidate !== undefined) {
+      recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'rejected');
+    }
     return lastKnownGood();
   }
   const previous = frameState.compiledFrameGraph;
@@ -1551,21 +2183,31 @@ export function ensureCompiledFrameGraph(
   frameState.compiledFrameGraphGeneration += 1;
   const compiledTargets = compiled.value as CompiledGraphTargetAccess;
   frameState.graphGeneration += 1;
+  featureMetrics.compileSuccesses += 1;
   frameState.perFrameGraph = {
     getColorTargetDescriptor: (name) => compiledTargets.getColorTargetDescriptor(name),
     getColorTargetView: (name) => compiledTargets.getColorTargetView(name),
     getColorTargetTexture: (name) => compiledTargets.getColorTargetTexture(name),
     graphGeneration: frameState.graphGeneration,
   };
+  // View buffer replacement is safe to retire once the compiled graph owns
+  // the new imports. Shadow cache publication remains submit-transactional
+  // and is committed only by executeCompiledFrameGraph's onSubmitted hook.
+  if (gpuDriven?._commitGpuResourceReplacement !== undefined) {
+    gpuDriven._commitGpuResourceReplacement();
+  } else {
+    // Synthetic/internal prepared projections predating the split own no
+    // shadow cache; retain their original graph-promotion callback.
+    gpuDriven?._commitResourceReplacement();
+  }
   const deviceGeneration = internals.deviceScope?.generation;
   if (deviceGeneration !== undefined) {
     graphDeviceGenerations.set(compiled.value, deviceGeneration);
   }
-  gpuDriven?._commitResourceReplacement();
   if (featureGraphCandidate !== undefined && !postProcessAdmission.pending) {
     commitFeatureCandidate(internals, featureGraphCandidate);
   } else if (featureGraphCandidate !== undefined) {
-    featureGraphCandidate.onAbandoned?.();
+    recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'abandoned');
   }
   if (!volumeTopologyCandidate && previous !== null) retire(frameState, previous);
   return compiled.value;
@@ -1577,15 +2219,21 @@ export function executeCompiledFrameGraph(
   frame: RenderPipelineFrame,
   encoder: RhiCommandEncoder,
   runPass?: import('@forgeax/engine-render-graph').RenderGraphPassRunner,
-  frameHooks?: {
-    readonly afterGraphExecute?: () => Result<void, RhiError>;
-    readonly onSubmitted?: () => void;
-    readonly onAborted?: () => void;
-  },
+  frameHooks?:
+    | {
+        readonly afterGraphExecute?: () => Result<void, RhiError>;
+        readonly onSubmitted?: () => void;
+        readonly onAborted?: () => void;
+      }
+    // Keep the pre-submit-hook shape accepted for internal callers that have
+    // not yet migrated to the typed frame hooks object.
+    | (() => void),
   readbackFaces?: readonly number[],
   onSubmitted?: (completed: Promise<unknown>) => void,
   timingCapture?: GpuTimingCapture,
 ): boolean {
+  const legacySubmitCommit = typeof frameHooks === 'function' ? frameHooks : undefined;
+  const resolvedFrameHooks = typeof frameHooks === 'function' ? undefined : frameHooks;
   const graph = frameState.compiledFrameGraph;
   const rejectTemporalFrame = (): void => {
     if (frameState.temporalFrameInput === undefined) return;
@@ -1594,6 +2242,8 @@ export function executeCompiledFrameGraph(
   };
   if (graph === null) {
     timingCapture?.discard();
+    frameState.pendingAutoExposureState = undefined;
+    frameState.pendingStandardLutState = undefined;
     settleVolumetricFogGraphCandidate(frameState, false);
     rejectTemporalFrame();
     return false;
@@ -1664,14 +2314,327 @@ export function executeCompiledFrameGraph(
   const transaction = executeRendererFrameTransaction<PreparedCommand>({
     build: () => ({ ok: true, value: { command: undefined as never } }),
     execute: () => {
-      const executed = graph.execute(frame, runPass, graphInstrumentation);
-      timingInstrumentationState?.setCapture(undefined);
-      if (!executed.ok) {
-        passTimingCapture?.abort({ code: executed.error.code });
-        internals.errorRegistry.fire(executed.error);
-        return { ok: false, stage: 'execute' };
+      const graphCapture = frameState.graphTargetCapture;
+      const replayPassNames = graphCapture?.replayPassNames;
+      const unsupportedCaptureKind =
+        graphCapture !== undefined &&
+        graphCapture.kind !== undefined &&
+        graphCapture.kind !== 'target-copy' &&
+        graphCapture.kind !== 'pass-replay';
+      if (unsupportedCaptureKind || replayPassNames !== undefined) {
+        if (graphCapture === undefined) {
+          return { ok: false, stage: 'execute' };
+        }
+        const passNames = graph.inspect().passes.map((pass) => pass.name);
+        const passNameCounts = new Map<string, number>();
+        for (const passName of passNames) {
+          passNameCounts.set(passName, (passNameCounts.get(passName) ?? 0) + 1);
+        }
+        const passNameSet = new Set(passNames);
+        const selectedReplayPassNames = replayPassNames ?? [];
+        const requestedPassNames = new Set(selectedReplayPassNames);
+        const passReplayCapture = graphCapture.kind === 'pass-replay' ? graphCapture : undefined;
+        const onPassEncoded = passReplayCapture?.onPassEncoded;
+        const onPrefixEncoded = passReplayCapture?.onPrefixEncoded;
+        const depthAttachmentPassName = passReplayCapture?.depthAttachmentPassName;
+        const observeAfterPassName = passReplayCapture?.observeAfterPassName;
+        let replayValidationFailed = false;
+        const duplicatePassName = selectedReplayPassNames.find(
+          (passName, index) => selectedReplayPassNames.indexOf(passName) !== index,
+        );
+        const invalidPassName = selectedReplayPassNames.find(
+          (passName) => !passNameSet.has(passName),
+        );
+        const nonUniquePassName = selectedReplayPassNames.find(
+          (passName) => passNameCounts.get(passName) !== 1,
+        );
+        const replayFailure = (reason: string): void => {
+          replayValidationFailed = true;
+          internals.errorRegistry.fire(
+            new RhiError({
+              code: 'webgpu-runtime-error',
+              expected:
+                'the requested graph target replay pass selection is valid and executes once',
+              hint: 'inspect replayPassNames against the compiled graph pass roster',
+              detail: {
+                error: {
+                  code: 'graph-target-capture-failed',
+                  message: JSON.stringify({
+                    target: graphCapture.kind === 'pass-replay' ? undefined : graphCapture.name,
+                    replayPassNames,
+                    availablePassNames: passNames,
+                    reason,
+                  }),
+                },
+              },
+            }),
+          );
+        };
+        if (unsupportedCaptureKind) {
+          replayFailure('capture-kind-unknown');
+          return { ok: false, stage: 'execute' };
+        }
+        if (replayPassNames === undefined) {
+          replayFailure('replay-pass-selection-missing');
+          return { ok: false, stage: 'execute' };
+        }
+        if (replayPassNames.length === 0) {
+          replayFailure('replay-pass-selection-empty');
+          return { ok: false, stage: 'execute' };
+        }
+        if (duplicatePassName !== undefined) {
+          replayFailure(`replay-pass-selection-duplicate:${duplicatePassName}`);
+          return { ok: false, stage: 'execute' };
+        }
+        if (invalidPassName !== undefined) {
+          replayFailure(`replay-pass-selection-unknown:${invalidPassName}`);
+          return { ok: false, stage: 'execute' };
+        }
+        if (nonUniquePassName !== undefined) {
+          replayFailure(`replay-pass-selection-non-unique:${nonUniquePassName}`);
+          return { ok: false, stage: 'execute' };
+        }
+
+        if (onPrefixEncoded !== undefined) {
+          if (onPassEncoded !== undefined) {
+            replayFailure('pass-replay-prefix-callback-conflict');
+            return { ok: false, stage: 'execute' };
+          }
+          if (depthAttachmentPassName === undefined) {
+            replayFailure('pass-replay-depth-attachment-name-missing');
+            return { ok: false, stage: 'execute' };
+          }
+          if (observeAfterPassName === undefined) {
+            replayFailure('pass-replay-observe-boundary-name-missing');
+            return { ok: false, stage: 'execute' };
+          }
+          const firstNonPrefixPass = selectedReplayPassNames.find(
+            (passName, index) => passName !== passNames[index],
+          );
+          if (
+            firstNonPrefixPass !== undefined ||
+            selectedReplayPassNames.length > passNames.length
+          ) {
+            replayFailure('pass-replay-selection-not-prefix');
+            return { ok: false, stage: 'execute' };
+          }
+          if (selectedReplayPassNames.at(-1) !== observeAfterPassName) {
+            replayFailure('pass-replay-observe-boundary-not-last');
+            return { ok: false, stage: 'execute' };
+          }
+          const anchorIndex = selectedReplayPassNames.indexOf(depthAttachmentPassName);
+          if (anchorIndex < 0 || anchorIndex > selectedReplayPassNames.length - 1) {
+            replayFailure('pass-replay-depth-attachment-not-in-prefix');
+            return { ok: false, stage: 'execute' };
+          }
+        }
+
+        let replayTarget:
+          | {
+              readonly name: string;
+              readonly view: TextureView;
+              readonly texture: Texture;
+              readonly textureIdentity: number;
+              readonly graphGeneration: number;
+            }
+          | undefined;
+        if (onPassEncoded !== undefined || onPrefixEncoded !== undefined) {
+          const targetName = passReplayCapture?.targetName;
+          const graphAccess = frameState.perFrameGraph;
+          const targetView =
+            targetName === undefined ? undefined : graphAccess?.getColorTargetView(targetName);
+          const targetTexture =
+            targetName === undefined ? undefined : graphAccess?.getColorTargetTexture(targetName);
+          const targetDescriptor =
+            targetName === undefined
+              ? undefined
+              : graphAccess?.getColorTargetDescriptor(targetName);
+          if (targetName === undefined) {
+            replayFailure('pass-replay-target-name-missing');
+            return { ok: false, stage: 'execute' };
+          }
+          if (graphAccess === undefined || graphAccess === null) {
+            replayFailure(`pass-replay-target-missing:${targetName}`);
+            return { ok: false, stage: 'execute' };
+          }
+          if (targetView === undefined || targetTexture === undefined) {
+            replayFailure(`pass-replay-target-missing:${targetName}`);
+            return { ok: false, stage: 'execute' };
+          }
+          if (targetDescriptor !== undefined && targetDescriptor.texture !== targetTexture) {
+            replayFailure(`pass-replay-target-identity-mismatch:${targetName}`);
+            return { ok: false, stage: 'execute' };
+          }
+          replayTarget = {
+            name: targetName,
+            view: targetView,
+            texture: targetTexture,
+            textureIdentity: getTextureIdentity(targetTexture),
+            graphGeneration: graphAccess.graphGeneration,
+          };
+        }
+
+        const executed = graph.execute(frame, runPass, graphInstrumentation);
+        if (!executed.ok) {
+          passTimingCapture?.abort({ code: executed.error.code });
+          internals.errorRegistry.fire(executed.error);
+          return { ok: false, stage: 'execute' };
+        }
+        const replayedPassNames = new Set<string>();
+        let prefixCallbackCount = 0;
+        let depthAnchorReceipt:
+          | {
+              readonly pass: { name: string; executionIndex: number };
+              readonly view: TextureView;
+            }
+          | undefined;
+        const replayRunPass: import('@forgeax/engine-render-graph').RenderGraphPassRunner = (
+          pass,
+          encode,
+        ) => {
+          if (!requestedPassNames.has(pass.name)) return;
+          if (replayedPassNames.has(pass.name)) {
+            replayFailure(`replay-pass-selection-multiple-hit:${pass.name}`);
+            return;
+          }
+          replayedPassNames.add(pass.name);
+          const depthView = (pass as ResolvedDepthPassExecution).resolvedDepthStencilAttachmentView;
+          if (onPrefixEncoded !== undefined) {
+            if (pass.name === depthAttachmentPassName) {
+              if (depthView === undefined) {
+                replayFailure(`pass-replay-depth-attachment-missing:${pass.name}`);
+                return;
+              }
+              const target = replayTarget;
+              if (target === undefined || depthView !== target.view) {
+                replayFailure(`pass-replay-attachment-target-mismatch:${pass.name}`);
+                return;
+              }
+              if (depthAnchorReceipt !== undefined) {
+                replayFailure(`pass-replay-depth-attachment-multiple-hit:${pass.name}`);
+                return;
+              }
+              depthAnchorReceipt = {
+                pass: { name: pass.name, executionIndex: pass.executionIndex },
+                view: depthView,
+              };
+            }
+            let encoded = false;
+            const encodePrefix = () => {
+              if (encoded) {
+                replayFailure(`pass-replay-encode-multiple-hit:${pass.name}`);
+                return;
+              }
+              encode();
+              encoded = true;
+              if (replayValidationFailed || pass.name !== observeAfterPassName) return;
+              const target = replayTarget;
+              const anchor = depthAnchorReceipt;
+              if (target === undefined || anchor === undefined) {
+                replayFailure('pass-replay-depth-attachment-anchor-missing-at-boundary');
+                return;
+              }
+              const receipt: GraphTargetPassReplayPrefixReceipt = {
+                passName: pass.name,
+                executionIndex: pass.executionIndex,
+                resolvedDepthStencilAttachmentView: anchor.view,
+                graphGeneration: target.graphGeneration,
+                targetName: target.name,
+                targetView: target.view,
+                targetTexture: target.texture,
+                targetTextureIdentity: target.textureIdentity,
+                replayPassNames: [...selectedReplayPassNames],
+                depthAttachmentPassName: anchor.pass.name,
+                observeAfterPassName: pass.name,
+                depthAttachmentExecutionIndex: anchor.pass.executionIndex,
+              };
+              try {
+                onPrefixEncoded(receipt);
+                prefixCallbackCount += 1;
+              } catch (cause) {
+                replayFailure(
+                  `pass-replay-prefix-callback-threw:${pass.name}:${cause instanceof Error ? cause.message : String(cause)}`,
+                );
+              }
+            };
+            if (runPass === undefined) encodePrefix();
+            else runPass(pass, encodePrefix);
+            if (!encoded && !replayValidationFailed) {
+              replayFailure(`pass-replay-encode-not-called:${pass.name}`);
+            }
+            return;
+          }
+          if (onPassEncoded === undefined) {
+            if (runPass === undefined) encode();
+            else runPass(pass, encode);
+            return;
+          }
+          const target = replayTarget;
+          if (target === undefined || depthView === undefined) {
+            replayFailure(`pass-replay-depth-attachment-missing:${pass.name}`);
+            return;
+          }
+          if (depthView !== target.view) {
+            replayFailure(`pass-replay-attachment-target-mismatch:${pass.name}`);
+            return;
+          }
+          let encoded = false;
+          const encodeAndObserve = () => {
+            if (encoded) {
+              replayFailure(`pass-replay-encode-multiple-hit:${pass.name}`);
+              return;
+            }
+            encode();
+            encoded = true;
+            if (replayValidationFailed) return;
+            const receipt: GraphTargetPassReplayReceipt = {
+              passName: pass.name,
+              executionIndex: pass.executionIndex,
+              resolvedDepthStencilAttachmentView: depthView,
+              graphGeneration: target.graphGeneration,
+              targetName: target.name,
+              targetView: target.view,
+              targetTexture: target.texture,
+              targetTextureIdentity: target.textureIdentity,
+            };
+            try {
+              onPassEncoded(receipt);
+            } catch (cause) {
+              replayFailure(
+                `pass-replay-callback-threw:${pass.name}:${cause instanceof Error ? cause.message : String(cause)}`,
+              );
+            }
+          };
+          if (runPass === undefined) encodeAndObserve();
+          else runPass(pass, encodeAndObserve);
+          if (!encoded && !replayValidationFailed) {
+            replayFailure(`pass-replay-encode-not-called:${pass.name}`);
+          }
+        };
+        const replayed = graph.execute(frame, replayRunPass);
+        if (!replayed.ok) {
+          internals.errorRegistry.fire(replayed.error);
+          return { ok: false, stage: 'execute' };
+        }
+        if (replayValidationFailed) return { ok: false, stage: 'execute' };
+        if (replayedPassNames.size !== requestedPassNames.size) {
+          replayFailure('replay-pass-selection-zero-hit');
+          return { ok: false, stage: 'execute' };
+        }
+        if (onPrefixEncoded !== undefined && prefixCallbackCount !== 1) {
+          replayFailure('pass-replay-prefix-callback-count-invalid');
+          return { ok: false, stage: 'execute' };
+        }
+      } else {
+        const executed = graph.execute(frame, runPass, graphInstrumentation);
+        if (!executed.ok) {
+          passTimingCapture?.abort({ code: executed.error.code });
+          internals.errorRegistry.fire(executed.error);
+          return { ok: false, stage: 'execute' };
+        }
       }
-      const afterGraphExecute = frameHooks?.afterGraphExecute;
+      timingInstrumentationState?.setCapture(undefined);
+      const afterGraphExecute = resolvedFrameHooks?.afterGraphExecute;
       if (afterGraphExecute !== undefined) {
         const recorded = afterGraphExecute();
         if (!recorded.ok) {
@@ -1684,7 +2647,7 @@ export function executeCompiledFrameGraph(
     finish: () => {
       const graphCapture = frameState.graphTargetCapture;
       frameState.graphTargetCapture = undefined;
-      if (graphCapture !== undefined) {
+      if (graphCapture !== undefined && graphCapture.kind !== 'pass-replay') {
         const graphAccess = frameState.perFrameGraph;
         const graphTexture = graphAccess?.getColorTargetTexture(graphCapture.name);
         const descriptor = graphAccess?.getColorTargetDescriptor(graphCapture.name);
@@ -1903,7 +2866,8 @@ export function executeCompiledFrameGraph(
           },
         }),
     commit: () => {
-      frameHooks?.onSubmitted?.();
+      resolvedFrameHooks?.onSubmitted?.();
+      legacySubmitCommit?.();
       if (frameState.temporalFrameInput !== undefined) {
         const temporal = frameState.temporalFrameTransaction.commit({ accepted: true });
         if (temporal.ok) {
@@ -1931,6 +2895,46 @@ export function executeCompiledFrameGraph(
           ?.perPassResources.commitBloomFrameReceipts?.(frameState.bloomFrameReceipts);
         frameState.bloomFrameReceipts = undefined;
       }
+      const pendingAuto = frameState.pendingAutoExposureGpuResources;
+      if (pendingAuto !== undefined) {
+        const previousAuto = frameState.autoExposureGpuResources;
+        frameState.autoExposureGpuResources = pendingAuto;
+        frameState.pendingAutoExposureGpuResources = undefined;
+        if (previousAuto !== undefined && previousAuto !== pendingAuto) {
+          internals.device.queue
+            .onSubmittedWorkDone()
+            .then(() => retireAutoExposureGpuResources(previousAuto))
+            .catch(() => undefined);
+        }
+      }
+      const pendingAutoState = frameState.pendingAutoExposureState;
+      if (pendingAutoState !== undefined) {
+        frameState.autoExposureState = commitAutoExposureSubmission(
+          pendingAutoState.state,
+          pendingAutoState,
+        );
+        frameState.pendingAutoExposureState = undefined;
+      }
+      const pendingLut = frameState.pendingStandardLutGpuResources;
+      if (pendingLut !== undefined) {
+        const previousLut = frameState.standardLutGpuResources;
+        frameState.standardLutGpuResources = pendingLut;
+        frameState.pendingStandardLutGpuResources = undefined;
+        if (previousLut !== undefined && previousLut !== pendingLut) {
+          retireStandardLutGpuResources(previousLut);
+        }
+      }
+      const pendingLutState = frameState.pendingStandardLutState;
+      if (pendingLutState !== undefined) {
+        frameState.standardLutState =
+          pendingLutState.remove || pendingLutState.candidate === undefined
+            ? resetStandardLutState(pendingLutState.state, 'resource-removed', {
+                targetGeneration: pendingLutState.targetGeneration,
+                deviceEpoch: pendingLutState.deviceEpoch,
+              })
+            : commitStandardLutCandidate(pendingLutState.state, pendingLutState.candidate);
+        frameState.pendingStandardLutState = undefined;
+      }
       const stagedGpuState = frameState.temporalGpuState;
       if (stagedGpuState !== undefined) {
         if (commitTemporalGpuSubmit(stagedGpuState)) {
@@ -1993,15 +2997,28 @@ export function executeCompiledFrameGraph(
         frameState.environmentLifecycle?.publish(frameState.environmentGeneration);
         frameState.environmentGeneration = undefined;
       }
+      frameState.pendingAtmospherePublish?.();
+      frameState.pendingAtmospherePublish = undefined;
       onSubmitted?.(internals.device.queue.onSubmittedWorkDone());
     },
     abort: (failure) => {
-      frameHooks?.onAborted?.();
+      frameState.pendingAtmospherePublish = undefined;
+      resolvedFrameHooks?.onAborted?.();
       passTimingCapture?.abort({ code: failure.stage });
       timingHost.gpuPassTimingCapture = undefined;
       timingHost.gpuPassTimingSubmittedWork = undefined;
       timingCapture?.discard();
       frameState.bloomFrameReceipts = undefined;
+      frameState.pendingAutoExposureState = undefined;
+      frameState.pendingStandardLutState = undefined;
+      if (frameState.pendingAutoExposureGpuResources !== undefined) {
+        retireAutoExposureGpuResources(frameState.pendingAutoExposureGpuResources);
+        frameState.pendingAutoExposureGpuResources = undefined;
+      }
+      if (frameState.pendingStandardLutGpuResources !== undefined) {
+        retireStandardLutGpuResources(frameState.pendingStandardLutGpuResources);
+        frameState.pendingStandardLutGpuResources = undefined;
+      }
       if (frameState.environmentGeneration !== undefined) {
         frameState.environmentLifecycle?.recordStageFailure(
           failure.stage,