@forgeax/engine-render 0.1.19 → 0.1.21

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

@@ -3,12 +3,18 @@ import {
   type CompiledRenderGraph,
   type GraphResourceResolver,
   RenderGraphBuilder,
+  RenderGraphError,
+  type RenderGraphPassInstrumentation,
+  type RenderGraphPassInstrumentationScope,
 } from '@forgeax/engine-render-graph';
 import type {
+  BindGroup,
   BindGroupLayout,
+  Buffer,
   CommandBuffer,
   RenderPipeline,
   RhiCommandEncoder,
+  Sampler,
   Texture,
   TextureFormat,
   TextureView,
@@ -28,10 +34,13 @@ import type {
   RenderFeatureGraphTargetResolver,
 } from '../features/render-graph-raster';
 import { isRenderFeatureTargetHandle } from '../features/targets';
+import type { PostProcessShaderEntry } from '../fullscreen-post-process-pass';
 import {
   buildFullscreenPostProcessPass,
   createFullscreenBindGroup,
   isTemporalFullscreenBinding,
+  postProcessShaderEntrySignature,
+  postProcessShaderModuleLabel,
 } from '../fullscreen-post-process-pass';
 import type { PreparedGpuDrivenFrame } from '../gpu-driven/production-raster';
 import {
@@ -40,14 +49,21 @@ import {
   GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
   GPU_TEXTURE_USAGE_TEXTURE_BINDING,
 } from '../gpu-texture-usage';
-import { STANDARD_PIPELINE_ID } from '../pipeline/standard-profile';
+import {
+  type StandardTopologyInputValue,
+  standardLightingTopologySignature,
+} from '../pipeline/standard-lighting/topology';
+import { resolveVolumetricFogProfile, STANDARD_PIPELINE_ID } from '../pipeline/standard-profile';
 import type { CameraSnapshot } from '../render-contract';
 import type {
   RenderPipelineFeatureTarget,
   RenderPipelineFrame,
   RenderPipelineTopology,
 } from '../render-pipeline';
-import type { ExtractedLights } from '../render-system-extract';
+import type { ExtractedLights, ExtractedVolumetricFog } from '../render-system-extract';
+import { SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS } from '../shadow-atlas';
+import type { RenderTarget } from '../targets/contracts';
+import type { RenderTargetPhysical } from '../targets/physical';
 import {
   abortTemporalGpuSubmit,
   commitTemporalGpuSubmit,
@@ -60,9 +76,19 @@ import {
 } from '../temporal/gpu';
 import { isSceneDataTarget } from '../temporal/scene-data';
 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 { PipelineState, RenderSystemInternals } from './render-context';
+import type { GpuPassTimingPassIdentity } from './gpu-pass-timing/contract.js';
+import type { GpuPassTimingCapture, GpuPassTimingSession } from './gpu-pass-timing/session.js';
+import type { GpuTimingCapture, VolumeTimingTimestampWrites } from './gpu-timing';
+import { encodeMainPass } from './main-pass';
+import type {
+  _InternalRenderPipelineContext,
+  PipelineState,
+  RenderSystemInternals,
+} from './render-context';
 import { resolveSurfaceFormatPair, resolveSurfaceProfile } from './render-context';
 
 export interface TemporalGraphCapabilities {
@@ -203,6 +229,465 @@ export function createTemporalGraphRoster(input: {
   };
 }
 
+export interface CubeCaptureGraphWork {
+  readonly target: RenderTarget;
+  readonly faceIndex: number;
+  readonly physical: RenderTargetPhysical;
+  readonly faceCamera: import('../render-contract').CameraSnapshot;
+  readonly viewBindGroupDynamicOffset: number;
+}
+
+export interface CubeCaptureGraphState {
+  work: readonly CubeCaptureGraphWork[];
+  reflectionProbes?: ReflectionProbeGraphState;
+}
+
+export interface ReflectionProbeFilterGraphWork {
+  readonly probeIndex: number;
+  readonly faceIndex: number;
+  readonly mipLevel: number;
+}
+
+export interface ReflectionProbeFilterGraphState {
+  readonly work: readonly ReflectionProbeFilterGraphWork[];
+  readonly maxStepsPerFrame: number;
+}
+
+export interface ReflectionProbeGraphWork {
+  readonly probeIndex: number;
+  readonly rawTexture: Texture;
+  readonly rawCubeView: TextureView;
+  readonly rawFaceViews: readonly TextureView[];
+  readonly rawDepthTexture: Texture;
+  readonly rawCaptureFace: number | undefined;
+  readonly rawDepthView: TextureView;
+  readonly rawSize: number;
+  readonly faceCamera?: import('../render-contract').CameraSnapshot;
+  readonly viewBindGroupDynamicOffset?: number;
+  readonly filteredTexture: Texture;
+  readonly filteredCubeView: TextureView;
+  readonly filteredFaceViewsByMip: readonly (readonly TextureView[])[];
+  readonly outputFormat: TextureFormat;
+  readonly sampler: Sampler;
+  readonly filterPipeline: RenderPipeline;
+  readonly filterGroup0: BindGroup | undefined;
+  readonly filterGroup1: BindGroup;
+  readonly cubeVertexBuffer: Buffer;
+  readonly filteredSize: number;
+  readonly step: ReflectionProbeFilterGraphWork | undefined;
+}
+
+export interface ReflectionProbeGraphState {
+  readonly work: readonly ReflectionProbeGraphWork[];
+}
+
+export function boundedReflectionProbeFilterWork(
+  state: ReflectionProbeFilterGraphState,
+): readonly ReflectionProbeFilterGraphWork[] {
+  return state.work.slice(0, Math.max(0, state.maxStepsPerFrame));
+}
+
+function renderTargetMipCount(work: CubeCaptureGraphWork): number {
+  const { descriptor } = work.physical;
+  return descriptor.mipLevels === 1
+    ? 1
+    : Math.floor(Math.log2(Math.max(descriptor.width, descriptor.height))) + 1;
+}
+
+function addCubeCaptureGraphPasses(
+  builder: RenderGraphBuilder<RenderPipelineFrame>,
+  state: CubeCaptureGraphState,
+): Result<void, RenderGraphError> {
+  for (let index = 0; index < state.work.length; index += 1) {
+    const slot = index;
+    const initial = state.work[slot];
+    if (initial === undefined) continue;
+    const current = (): CubeCaptureGraphWork => state.work[slot] ?? initial;
+    const texture = builder.importTexture(
+      `cube-capture.${slot}.texture`,
+      {
+        format: initial.physical.descriptor.format,
+        size: {
+          width: initial.physical.descriptor.width,
+          height: initial.physical.descriptor.height,
+          depthOrArrayLayers: initial.physical.descriptor.sampleCount === 4 ? 1 : 6,
+        },
+        mipLevelCount:
+          initial.physical.descriptor.sampleCount === 4 ? 1 : renderTargetMipCount(initial),
+        sampleCount: initial.physical.descriptor.sampleCount,
+        dimension: '2d',
+        usage: 0x10 | 0x04 | 0x01,
+      },
+      () => current().physical.colorTextures[current().faceIndex] ?? initial.physical.texture,
+    );
+    if (!texture.ok) return texture;
+    const color = builder.importView(
+      texture.value,
+      {
+        label: `cube-capture.${slot}.color`,
+        dimension: '2d',
+        baseMipLevel: 0,
+        mipLevelCount: 1,
+        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
+        arrayLayerCount: 1,
+      },
+      () =>
+        current().physical.faceViews[current().faceIndex] ??
+        initial.physical.faceViews[initial.faceIndex] ??
+        initial.physical.view,
+    );
+    if (!color.ok) return color;
+    const depthTexture = builder.importTexture(
+      `cube-capture.${slot}.depth-texture`,
+      {
+        format: 'depth24plus-stencil8',
+        size: {
+          width: initial.physical.descriptor.width,
+          height: initial.physical.descriptor.height,
+          depthOrArrayLayers: initial.physical.descriptor.sampleCount === 4 ? 1 : 6,
+        },
+        mipLevelCount: 1,
+        sampleCount: initial.physical.descriptor.sampleCount,
+        dimension: '2d',
+        usage: 0x10,
+      },
+      () => current().physical.depthTextures[current().faceIndex] as Texture,
+    );
+    if (!depthTexture.ok) return depthTexture;
+    const depth = builder.importView(
+      depthTexture.value,
+      {
+        label: `cube-capture.${slot}.depth`,
+        dimension: '2d',
+        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
+        arrayLayerCount: 1,
+      },
+      () => current().physical.depthViews[current().faceIndex] as TextureView,
+    );
+    if (!depth.ok) return depth;
+    const resolveTexture =
+      initial.physical.descriptor.sampleCount === 4
+        ? builder.importTexture(
+            `cube-capture.${slot}.resolve-texture`,
+            {
+              format: initial.physical.descriptor.format,
+              size: {
+                width: initial.physical.descriptor.width,
+                height: initial.physical.descriptor.height,
+                depthOrArrayLayers: 6,
+              },
+              mipLevelCount: renderTargetMipCount(initial),
+              sampleCount: 1,
+              dimension: '2d',
+              usage: 0x10 | 0x04 | 0x01,
+            },
+            () =>
+              current().physical.resolveTexture ??
+              initial.physical.resolveTexture ??
+              initial.physical.texture,
+          )
+        : undefined;
+    if (resolveTexture !== undefined && !resolveTexture.ok) return resolveTexture;
+    const resolve =
+      resolveTexture === undefined
+        ? undefined
+        : builder.importView(
+            resolveTexture.value,
+            {
+              label: `cube-capture.${slot}.resolve`,
+              dimension: '2d',
+              baseMipLevel: 0,
+              mipLevelCount: 1,
+              baseArrayLayer: initial.faceIndex,
+              arrayLayerCount: 1,
+            },
+            () =>
+              current().physical.resolveFaceViews[current().faceIndex] ??
+              initial.physical.resolveFaceViews[initial.faceIndex] ??
+              initial.physical.resolveView,
+          );
+    if (resolve !== undefined && !resolve.ok) return resolve;
+    const added = builder.addRasterPass(`cube-capture-face.${slot}`, {
+      accesses: [
+        { resource: color.value, usage: 'color-attachment' },
+        { resource: depth.value, usage: 'depth-stencil-write' },
+        ...(resolve === undefined
+          ? []
+          : [{ resource: resolve.value, usage: 'color-attachment' as const }]),
+      ],
+      colorAttachments: [
+        {
+          view: color.value,
+          ...(resolve === undefined ? {} : { resolveTarget: resolve.value }),
+          loadOp: 'clear',
+          storeOp: 'store',
+          clearValue: () => {
+            return { r: 0, g: 0, b: 0, a: 1 };
+          },
+        },
+      ],
+      depthStencilAttachment: {
+        view: depth.value,
+        depthClearValue: 1,
+        depthLoadOp: 'clear',
+        depthStoreOp: 'store',
+        stencilClearValue: 0,
+        stencilLoadOp: 'clear',
+        stencilStoreOp: 'store',
+      },
+      encode: ({ pass, frame, resources }) => {
+        const internal = frame as _InternalRenderPipelineContext;
+        const captureColor = resources.textureView(color.value);
+        if (!captureColor.ok) return;
+        const captureDepth = resources.textureView(depth.value);
+        if (!captureDepth.ok) return;
+        const captureResolve =
+          resolve === undefined ? undefined : resources.textureView(resolve.value);
+        if (resolve !== undefined && (captureResolve === undefined || !captureResolve.ok)) return;
+        const captureResolveView = captureResolve?.ok ? captureResolve.value : null;
+        const captureContext = {
+          ...internal,
+          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
+          // cube target is rendered by a compatible forward pipeline.
+          tonemapActive: false,
+          skyboxActive: false,
+          transparentColorFormat: initial.physical.descriptor.format as GPUTextureFormat,
+          msaaActive: initial.physical.descriptor.sampleCount === 4,
+          viewBindGroupDynamicOffset: current().viewBindGroupDynamicOffset,
+          geometryColorView: captureColor.value,
+          geometryDepthView: captureDepth.value,
+          geometryColorResolveView: captureResolveView,
+          splitLdrSprite: false,
+          ldrSpritePassView: null,
+        };
+        encodeMainPass(captureContext, pass, undefined, {
+          colorViews: [captureColor.value],
+          colorFormats: [initial.physical.descriptor.format as GPUTextureFormat],
+          depthView: captureDepth.value,
+          passKind: 'forward',
+          clearColor: [0, 0, 0, 1],
+        });
+      },
+    });
+    if (!added.ok) return added;
+  }
+  return ok(undefined);
+}
+
+export function addReflectionProbeGraphPasses(
+  builder: RenderGraphBuilder<RenderPipelineFrame>,
+  state: ReflectionProbeGraphState,
+): Result<readonly import('@forgeax/engine-render-graph').GraphAccess[], RenderGraphError> {
+  const accesses: import('@forgeax/engine-render-graph').GraphAccess[] = [];
+  for (const work of state.work) {
+    const raw = builder.importTexture(
+      `reflection-probe.${work.probeIndex}.raw`,
+      {
+        format: work.outputFormat,
+        size: { width: work.rawSize, height: work.rawSize, depthOrArrayLayers: 6 },
+        mipLevelCount: 1,
+        sampleCount: 1,
+        dimension: '2d',
+        usage: 0x10 | 0x04 | 0x01,
+      },
+      () => work.rawTexture,
+    );
+    if (!raw.ok) return raw;
+    const rawCube = builder.importView(
+      raw.value,
+      {
+        label: `reflection-probe.${work.probeIndex}.raw-cube`,
+        dimension: 'cube',
+        arrayLayerCount: 6,
+      },
+      () => work.rawCubeView,
+    );
+    if (!rawCube.ok) return rawCube;
+    const filtered = builder.importTexture(
+      `reflection-probe.${work.probeIndex}.filtered`,
+      {
+        format: work.outputFormat,
+        size: { width: work.filteredSize, height: work.filteredSize, depthOrArrayLayers: 6 },
+        mipLevelCount: work.filteredFaceViewsByMip.length,
+        sampleCount: 1,
+        dimension: '2d',
+        usage: 0x10 | 0x04 | 0x01,
+      },
+      () => work.filteredTexture,
+    );
+    if (!filtered.ok) return filtered;
+    const filteredCube = builder.importView(
+      filtered.value,
+      {
+        label: `reflection-probe.${work.probeIndex}.filtered-cube`,
+        dimension: 'cube',
+        baseMipLevel: 0,
+        mipLevelCount: work.filteredFaceViewsByMip.length,
+        arrayLayerCount: 6,
+      },
+      () => work.filteredCubeView,
+    );
+    if (!filteredCube.ok) return filteredCube;
+    if (work.rawCaptureFace !== undefined) {
+      const face = work.rawCaptureFace;
+      const view = builder.importView(
+        raw.value,
+        {
+          label: `reflection-probe.${work.probeIndex}.capture-face-${face}`,
+          dimension: '2d',
+          baseArrayLayer: face,
+          arrayLayerCount: 1,
+        },
+        () => work.rawFaceViews[face] as TextureView,
+      );
+      if (!view.ok) return view;
+      const depthTexture = builder.importTexture(
+        `reflection-probe.${work.probeIndex}.capture-depth`,
+        {
+          format: 'depth24plus-stencil8',
+          size: { width: work.rawSize, height: work.rawSize, depthOrArrayLayers: 1 },
+          mipLevelCount: 1,
+          sampleCount: 1,
+          dimension: '2d',
+          usage: 0x10,
+        },
+        () => work.rawDepthTexture,
+      );
+      if (!depthTexture.ok) return depthTexture;
+      const depth = builder.importView(
+        depthTexture.value,
+        { label: `reflection-probe.${work.probeIndex}.capture-depth-view`, dimension: '2d' },
+        () => work.rawDepthView,
+      );
+      if (!depth.ok) return depth;
+      const added = builder.addRasterPass(`reflection-probe.${work.probeIndex}.capture.${face}`, {
+        accesses: [
+          { resource: view.value, usage: 'color-attachment' },
+          { resource: depth.value, usage: 'depth-stencil-write' },
+        ],
+        colorAttachments: [
+          {
+            view: view.value,
+            loadOp: 'clear',
+            storeOp: 'store',
+            clearValue: { r: 0, g: 0, b: 0, a: 1 },
+          },
+        ],
+        depthStencilAttachment: {
+          view: depth.value,
+          depthClearValue: 1,
+          depthLoadOp: 'clear',
+          depthStoreOp: 'store',
+          stencilClearValue: 0,
+          stencilLoadOp: 'clear',
+          stencilStoreOp: 'store',
+        },
+        encode: ({ pass, frame, resources }) => {
+          const internal = frame as _InternalRenderPipelineContext;
+          const captureColor = resources.textureView(view.value);
+          const captureDepth = resources.textureView(depth.value);
+          if (!captureColor.ok || !captureDepth.ok) return;
+          if (work.faceCamera === undefined || work.viewBindGroupDynamicOffset === undefined)
+            return;
+          encodeMainPass(
+            {
+              ...internal,
+              camera: work.faceCamera,
+              viewBindGroupDynamicOffset: work.viewBindGroupDynamicOffset,
+              geometryColorView: captureColor.value,
+              geometryDepthView: captureDepth.value,
+              geometryColorResolveView: null,
+              transparentColorFormat: work.outputFormat as GPUTextureFormat,
+              msaaActive: false,
+              splitLdrSprite: false,
+              ldrSpritePassView: null,
+            },
+            pass,
+            undefined,
+            {
+              colorViews: [captureColor.value],
+              colorFormats: [work.outputFormat as GPUTextureFormat],
+              depthView: captureDepth.value,
+              passKind: 'forward',
+              clearColor: [0, 0, 0, 1],
+            },
+          );
+        },
+      });
+      if (!added.ok) return added;
+    }
+    const step = work.step;
+    if (step !== undefined) {
+      const mipViews = work.filteredFaceViewsByMip[step.mipLevel];
+      const outputView = mipViews?.[step.faceIndex];
+      if (outputView === undefined) {
+        return err(
+          new RenderGraphError({
+            code: 'resource-resolution-failed',
+            expected: 'every scheduled probe mip has a filtered face view',
+            hint: 'rebuild the renderer-owned probe output before compiling the Standard graph',
+            detail: {
+              resourceLabel: `reflection-probe.${work.probeIndex}.filtered`,
+              passName: 'pmrem',
+            },
+          }),
+        );
+      }
+      const output = builder.importView(
+        filtered.value,
+        {
+          label: `reflection-probe.${work.probeIndex}.filtered-mip${step.mipLevel}-face${step.faceIndex}`,
+          dimension: '2d',
+          baseMipLevel: step.mipLevel,
+          mipLevelCount: 1,
+          baseArrayLayer: step.faceIndex,
+          arrayLayerCount: 1,
+        },
+        () => outputView,
+      );
+      if (!output.ok) return output;
+      const added = builder.addRasterPass(
+        `reflection-probe.${work.probeIndex}.pmrem.${step.mipLevel}.${step.faceIndex}`,
+        {
+          accesses: [
+            { resource: rawCube.value, usage: 'sampled-read' },
+            { resource: output.value, usage: 'color-attachment' },
+          ],
+          colorAttachments: [
+            {
+              view: output.value,
+              loadOp: 'clear',
+              storeOp: 'store',
+              clearValue: { r: 0, g: 0, b: 0, a: 1 },
+            },
+          ],
+          encode: ({ pass }) => {
+            if (work.filterGroup0 === undefined) return;
+            pass.setPipeline(work.filterPipeline);
+            pass.setBindGroup(0, work.filterGroup0);
+            pass.setBindGroup(1, work.filterGroup1);
+            pass.setVertexBuffer(0, work.cubeVertexBuffer);
+            pass.draw(6, 1, step.faceIndex * 6, 0);
+          },
+        },
+      );
+      if (!added.ok) return added;
+    }
+    accesses.push({ resource: filteredCube.value, usage: 'sampled-read' });
+  }
+  return ok(accesses);
+}
+
+export {
+  projectRenderTargetGraph,
+  type RenderTargetGraphInput,
+  type RenderTargetGraphProjection,
+  type RenderTargetGraphSubresource,
+} from '../targets/graph-projection';
+
 export interface RenderFeatureGraphRuntimeState {
   plans: readonly RenderFeaturePlannedFrame[];
   fullscreenEffects: ReadonlyMap<
@@ -227,10 +712,34 @@ export interface RenderFeatureGraphCandidate {
   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;
+  /** Discard candidate-only resources when a base graph is kept as fallback. */
+  readonly onAbandoned?: () => void;
 }
 
 const featureGraphStates = new WeakMap<RenderSystemInternals, RenderFeatureGraphRuntimeState>();
 
+interface TimingInstrumentationState {
+  readonly instrumentation: RenderGraphPassInstrumentation<RenderPipelineFrame>;
+  setCapture(capture: GpuPassTimingCapture | undefined): void;
+}
+
+const timingInstrumentationStates = new WeakMap<
+  RenderSystemInternals,
+  TimingInstrumentationState
+>();
+
+interface VolumeTimingInstrumentationState {
+  readonly instrumentation: RenderGraphPassInstrumentation<RenderPipelineFrame>;
+  setCapture(capture: GpuTimingCapture | undefined): void;
+}
+
+const volumeTimingInstrumentationStates = new WeakMap<
+  RenderSystemInternals,
+  VolumeTimingInstrumentationState
+>();
+
 type CompiledGraphTargetAccess = CompiledRenderGraph<RenderPipelineFrame> & {
   readonly getColorTargetDescriptor: (
     name: string,
@@ -281,6 +790,31 @@ export function renderFeatureGraphPlanSignature(
   );
 }
 
+/**
+ * Admit fullscreen post-processes as one chain, never as independent passes.
+ * A pass whose shader module is still compiling cannot clear a graph target and
+ * leave the remainder of the chain sampling an undefined intermediate. The
+ * renderer therefore keeps the base output-transform graph until every
+ * requested effect is ready, then admits the complete ordered chain together.
+ */
+export function resolvePostProcessChainAdmission(
+  effects: readonly string[],
+  isReady: (identity: string) => boolean,
+): { readonly admitted: readonly string[]; readonly pending: boolean } {
+  // Probe every declaration even after the first miss.  A single frame may
+  // introduce several effects; evaluating all of them lets the shared cache
+  // start every independent compile together instead of serialising warmup on
+  // array order.
+  let ready = true;
+  for (const identity of effects) {
+    if (!isReady(identity)) ready = false;
+  }
+  return {
+    admitted: ready ? effects : [],
+    pending: !ready,
+  };
+}
+
 function validateRenderFeaturePlans(
   plans: readonly RenderFeaturePlannedFrame[],
 ): Result<readonly RenderFeaturePlanExecution[], RenderError> {
@@ -311,6 +845,10 @@ function commitFeatureCandidate(
   internals: RenderSystemInternals,
   candidate: RenderFeatureGraphCandidate,
 ): void {
+  // 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?.();
   const state = getRenderFeatureGraphState(internals);
   state.plans = candidate.plans;
   state.fullscreenEffects = candidate.fullscreenEffects;
@@ -328,7 +866,10 @@ function topologyOf(
   shadowMapSize: number | undefined,
   gpuDriven: PreparedGpuDrivenFrame | undefined,
   featureGraphCandidate: RenderFeatureGraphCandidate | undefined,
+  cubeCaptureState: CubeCaptureGraphState | undefined,
   transmissionDemand: TransmissionDemand | undefined,
+  volumetricFog: ExtractedVolumetricFog | undefined,
+  standardLighting: StandardTopologyInputValue | undefined,
 ): Result<RenderPipelineTopology, RhiError> {
   const cascadeCount = Math.max(1, Math.min(4, Math.round(lights.cascadeCount ?? 1))) as
     | 1
@@ -353,6 +894,10 @@ function topologyOf(
     ...(featureGraphCandidate?.fullscreenEffects ??
       getRenderFeatureGraphState(internals).fullscreenEffects),
   ].map(([id]) => id);
+  const featurePostEffectDeclarations = [
+    ...(featureGraphCandidate?.fullscreenEffects ??
+      getRenderFeatureGraphState(internals).fullscreenEffects),
+  ].map(([id, entry]) => [id, postProcessShaderEntrySignature(entry)] as const);
   const config =
     featurePostEffects.length === 0
       ? frameState.installedPipelineConfig
@@ -365,6 +910,21 @@ function topologyOf(
             ]),
           ],
         };
+  const volumeCapability = hasVolumetricFogCapability(
+    internals.device.caps,
+    internals.volumetricFogShaders,
+  );
+  const selectedVolumeLight =
+    volumetricFog?.lightKind === 'spot'
+      ? lights.spot.find((light) => light.entity === volumetricFog.lightEntity)
+      : volumetricFog?.lightKind === 'point'
+        ? lights.point.find((light) => light.entity === volumetricFog.lightEntity)
+        : volumetricFog?.lightKind === 'directional' &&
+            lights.directional?.entity === volumetricFog.lightEntity
+          ? lights.directional
+          : volumetricFog?.lightKind === undefined
+            ? lights.directional
+            : undefined;
   return ok({
     pipelineId: STANDARD_PIPELINE_ID,
     standardProfile: internals.standardProfile,
@@ -387,10 +947,13 @@ function topologyOf(
       motionBlur: isMotionBlurTemporalDemand(camera.motionBlur),
     },
     shadow: {
-      mapSize: shadowMapSize ?? 1024,
-      cascadeCount,
-      pointCount: Math.min(4, lights.pointShadow.length),
-      pointFaceSize: lights.pointShadow[0]?.mapSize ?? 512,
+      directional:
+        shadowMapSize === undefined || lights.cascadeCount === undefined
+          ? 'disabled'
+          : { mapSize: shadowMapSize, cascadeCount },
+      spotMapSize: shadowMapSize ?? 1024,
+      pointCount: Math.min(SHADOW_ATLAS_DEFAULT_LAYERS, lights.pointShadow.length),
+      pointFaceSize: lights.pointShadow[0]?.mapSize ?? SHADOW_ATLAS_DEFAULT_FACE_SIZE,
       spotCount: Math.min(
         4,
         lights.spot.filter(
@@ -398,6 +961,47 @@ function topologyOf(
         ).length,
       ),
     },
+    volumetricFog:
+      volumetricFog?.status === 'available' &&
+      volumetricFog.densityAsset?.shape.viewDimension === '3d' &&
+      camera.tonemap !== 'none' &&
+      selectedVolumeLight !== undefined &&
+      volumeCapability
+        ? (() => {
+            const volumeProfile = resolveVolumetricFogProfile(internals.standardProfile ?? {});
+            return {
+              enabled: true,
+              format: volumetricFog.densityAsset.format,
+              extent: {
+                width: volumetricFog.densityAsset.shape.extent.width,
+                height: volumetricFog.densityAsset.shape.extent.height,
+                depth: volumetricFog.densityAsset.shape.extent.depth,
+              },
+              froxelExtent: deriveVolumetricFogExtent(
+                { width, height },
+                volumeProfile.depth,
+                volumeProfile.tileSize,
+              ),
+              resolvedExtent: deriveVolumetricFogResolvedExtent(
+                { width, height },
+                volumeProfile.tileSize,
+              ),
+              lightKind: volumetricFog.lightKind,
+              lightEntity: volumetricFog.lightEntity,
+              pointLightEntity: volumetricFog.pointLightEntity,
+              spotLightEntity: volumetricFog.spotLightEntity,
+              ...(volumetricFog.projector === undefined
+                ? {}
+                : {
+                    projector: {
+                      guid: volumetricFog.projector.guid,
+                      generation: volumetricFog.projector.generation,
+                      revision: volumetricFog.projector.revision,
+                    },
+                  }),
+            };
+          })()
+        : { enabled: false },
     lane: {
       compute: internals.device.caps.compute,
       storageBuffer: internals.device.caps.storageBuffer,
@@ -408,10 +1012,12 @@ function topologyOf(
       plans: renderFeatureGraphPlanSignature(
         featureGraphCandidate?.plans ?? getRenderFeatureGraphState(internals).plans,
       ),
-      fullscreenEffects: featurePostEffects,
+      fullscreenEffects: featurePostEffectDeclarations,
       preparedResourceKey: featureGraphCandidate?.preparedResourceKey ?? '',
+      cubeCaptureSlots: cubeCaptureState?.work.length ?? 0,
     }),
     gpuDrivenTopologySignature: gpuDriven?.topologySignature ?? '',
+    standardLightingTopologySignature: standardLightingTopologySignature(standardLighting),
     transmissionDemand: transmissionDemand ?? {
       activeCount: 0,
       needsRoughMips: false,
@@ -467,14 +1073,17 @@ function targetResolver(
   };
 }
 
-function resolveTargetBindings(input: {
-  readonly frame: RenderPipelineFrame;
-  readonly binding: import('../prepare/prepared-graphics-resolver').PreparedGraphicsResolvedResource & {
-    readonly kind: 'bindings';
-  };
-  readonly resources: GraphResourceResolver;
-  readonly resolveTarget: RenderFeatureGraphTargetResolver;
-}): RenderFeatureGraphBindingsResolution | undefined {
+function resolveTargetBindings(
+  input: {
+    readonly frame: RenderPipelineFrame;
+    readonly binding: import('../prepare/prepared-graphics-resolver').PreparedGraphicsResolvedResource & {
+      readonly kind: 'bindings';
+    };
+    readonly resources: GraphResourceResolver;
+    readonly resolveTarget: RenderFeatureGraphTargetResolver;
+  },
+  featurePostProcessEntries?: ReadonlyMap<string, PostProcessShaderEntry>,
+): RenderFeatureGraphBindingsResolution | undefined {
   const frame = input.frame as import('./render-context')._InternalRenderPipelineContext;
   const descriptor = input.binding.descriptor;
   const pipeline = input.binding.pipeline as
@@ -486,7 +1095,8 @@ function resolveTargetBindings(input: {
   if (descriptor?.values.fullscreen === true && isTemporalFullscreenBinding(descriptor.values)) {
     const shader = descriptor.values.shader;
     if (typeof shader !== 'string') return undefined;
-    const entry = frame.runtime.lookupPostProcess?.(shader);
+    const entry =
+      featurePostProcessEntries?.get(shader) ?? frame.runtime.lookupPostProcess?.(shader);
     if (entry === undefined) return undefined;
     const fullscreen = buildFullscreenPostProcessPass(
       { device: frame.runtime.device, errorRegistry: frame.runtime.errorRegistry },
@@ -576,8 +1186,10 @@ function resolveTargetBindings(input: {
         directionalShadow: frame.frameState.currentDirectionalShadowView ?? undefined,
         spotShadow: frame.frameState.currentSpotShadowView ?? undefined,
       },
+      true,
+      frame.standardLighting,
     ).viewBindGroup;
-    return viewBindGroup === null ? undefined : { handle: viewBindGroup, dynamicOffsets: [0] };
+    return viewBindGroup === null ? undefined : { handle: viewBindGroup, dynamicOffsets: [0, 0] };
   }
   const target = input.resolveTarget(sceneDepth);
   if (target === undefined) return undefined;
@@ -610,6 +1222,32 @@ function retire(
     .catch(() => undefined);
 }
 
+/**
+ * Settle a volume topology candidate after the command buffer outcome is
+ * known. A graph that failed to encode, finish, or submit must never become
+ * the next frame's accepted graph: retire it and restore the prior graph (or
+ * leave the renderer without a graph when this was the first attempt).
+ */
+export function settleVolumetricFogGraphCandidate(
+  frameState: RenderFrameState,
+  submitted: boolean,
+): void {
+  const candidate = frameState.volumetricFogCandidateGraph ?? null;
+  if (candidate === null) return;
+  const previous = frameState.volumetricFogPreviousGraph ?? null;
+  const previousKey = frameState.volumetricFogPreviousGraphKey ?? null;
+  if (submitted) {
+    if (previous !== null && previous !== candidate) retire(frameState, previous);
+  } else {
+    if (candidate !== previous) retire(frameState, candidate);
+    frameState.compiledFrameGraph = previous;
+    frameState.compiledFrameGraphTopologyKey = previousKey;
+  }
+  frameState.volumetricFogPreviousGraph = null;
+  frameState.volumetricFogPreviousGraphKey = null;
+  frameState.volumetricFogCandidateGraph = null;
+}
+
 export function ensureCompiledFrameGraph(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
@@ -621,9 +1259,19 @@ export function ensureCompiledFrameGraph(
   shadowMapSize: number | undefined,
   gpuDriven?: PreparedGpuDrivenFrame,
   featureGraphCandidate?: RenderFeatureGraphCandidate,
+  cubeCaptureState?: CubeCaptureGraphState,
   clearOnly = false,
   transmissionDemand?: TransmissionDemand,
+  volumetricFog?: ExtractedVolumetricFog,
+  volumeTopologyCandidate = false,
+  standardLighting?: StandardTopologyInputValue,
 ): CompiledRenderGraph<RenderPipelineFrame> | null {
+  const requestedStandardLightingSignature = standardLightingTopologySignature(standardLighting);
+  const lastKnownGood = (): CompiledRenderGraph<RenderPipelineFrame> | null =>
+    frameState.compiledFrameGraph !== null &&
+    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;
@@ -631,7 +1279,7 @@ export function ensureCompiledFrameGraph(
   if (!projectedFeaturePlans.ok) {
     reportRenderFeatureGraphError(internals, projectedFeaturePlans.error);
     featureGraphCandidate?.onRejected?.();
-    return frameState.compiledFrameGraph;
+    return volumeTopologyCandidate ? null : lastKnownGood();
   }
   const topologyResult = topologyOf(
     internals,
@@ -645,19 +1293,86 @@ export function ensureCompiledFrameGraph(
     shadowMapSize,
     gpuDriven,
     featureGraphCandidate,
+    cubeCaptureState,
     transmissionDemand,
+    volumetricFog,
+    standardLighting,
   );
   if (!topologyResult.ok) {
     internals.errorRegistry.fire(topologyResult.error);
     featureGraphCandidate?.onRejected?.();
-    return frameState.compiledFrameGraph;
+    return volumeTopologyCandidate ? null : lastKnownGood();
+  }
+  const requestedPostEffects = topologyResult.value.config?.postEffects ?? [];
+  const featurePostProcessEntries =
+    featureGraphCandidate?.fullscreenEffects ??
+    getRenderFeatureGraphState(internals).fullscreenEffects;
+  const postProcessAdmission = resolvePostProcessChainAdmission(
+    requestedPostEffects,
+    (identity) => {
+      const entry =
+        featurePostProcessEntries.get(identity) ?? internals.lookupPostProcess?.(identity);
+      // Preserve the existing missing-entry failure contract. The graph will
+      // report post-process-not-found during record instead of silently
+      // removing an authored id from the topology.
+      if (entry === undefined) return true;
+      const buildPipeline = internals.buildPostProcessPipeline;
+      const getPipeline = internals.getPostProcessPipeline;
+      if (buildPipeline === undefined || getPipeline === undefined) return true;
+      const built = buildFullscreenPostProcessPass(
+        { device: internals.device, errorRegistry: internals.errorRegistry },
+        entry,
+        camera.antialias === 'msaa' && topologyResult.value.lane.multisample,
+      );
+      if (built === null) return false;
+      return (
+        getPipeline(
+          identity,
+          built.bindGroupLayout,
+          topologyResult.value.surface.storageFormat as GPUTextureFormat,
+          entry,
+        ) !== null
+      );
+    },
+  );
+  const acceptedLkg = lastKnownGood();
+  if (postProcessAdmission.pending && acceptedLkg !== null) {
+    // 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?.();
+    return acceptedLkg;
   }
-  const topology = topologyResult.value;
-  const key = JSON.stringify(topology);
+  const topology = postProcessAdmission.pending
+    ? {
+        ...topologyResult.value,
+        config: {
+          ...(topologyResult.value.config ?? {}),
+          postEffects: [],
+        },
+      }
+    : topologyResult.value;
+  const key = JSON.stringify({
+    topology,
+    cubeCaptureSlots: cubeCaptureState?.work.length ?? 0,
+    reflectionProbeSlots: cubeCaptureState?.reflectionProbes?.work.map((work) => [
+      work.probeIndex,
+      work.rawCaptureFace ?? -1,
+      work.step?.faceIndex ?? -1,
+      work.step?.mipLevel ?? -1,
+    ]),
+  });
   if (frameState.compiledFrameGraph !== null && frameState.compiledFrameGraphTopologyKey === key) {
-    if (featureGraphCandidate !== undefined) {
+    frameState.standardLightingGraphSignature = requestedStandardLightingSignature;
+    if (featureGraphCandidate !== undefined && !postProcessAdmission.pending) {
       commitFeatureCandidate(internals, featureGraphCandidate);
+    } else if (featureGraphCandidate !== undefined) {
+      featureGraphCandidate.onAbandoned?.();
     }
+    // A candidate flag only describes a possible topology replacement. When
+    // the derived key is unchanged there is no replacement to stage: reuse the
+    // accepted graph so dynamic volume history/imported views can advance and
+    // a queue-submit failure can still publish the LKG diagnostic.
     return frameState.compiledFrameGraph;
   }
 
@@ -668,6 +1383,7 @@ export function ensureCompiledFrameGraph(
   const built = frameState.activePipeline.build(
     {
       graph: builder,
+      ...(standardLighting === undefined ? {} : { standardLighting }),
       capabilities: { rgba16floatRenderable: internals.device.caps.rgba16floatRenderable },
       ...(taaHistory === undefined ? {} : { taaHistory }),
       encodeTransmissionMip: ({ pass, resources, source }) => {
@@ -688,11 +1404,21 @@ export function ensureCompiledFrameGraph(
         const resolveTarget = targetResolver(targets, semanticTargets, namedTargets);
         const projected = projectPlanExecutions(builder, projectedFeaturePlans.value, {
           resolveTarget,
-          resolveBindings: resolveTargetBindings,
+          resolveBindings: (input) => resolveTargetBindings(input, featurePostProcessEntries),
           reportError: (error) => reportRenderFeatureGraphError(internals, error),
         });
         return projected.ok ? ok(undefined) : projected;
       },
+      contributeCubeCaptures: () => {
+        const reflectionProbes = addReflectionProbeGraphPasses(
+          builder,
+          cubeCaptureState?.reflectionProbes ?? { work: [] },
+        );
+        if (!reflectionProbes.ok) return reflectionProbes;
+        return cubeCaptureState === undefined
+          ? ok(undefined)
+          : addCubeCaptureGraphPasses(builder, cubeCaptureState);
+      },
       hasFeature: (identity) =>
         projectedFeaturePlans.value.some((execution) => execution.featureIdentity === identity),
     },
@@ -701,7 +1427,7 @@ export function ensureCompiledFrameGraph(
   if (!built.ok) {
     internals.errorRegistry.fire(built.error);
     featureGraphCandidate?.onRejected?.();
-    return frameState.compiledFrameGraph;
+    return volumeTopologyCandidate ? null : lastKnownGood();
   }
   const compiled = builder.compile({
     device: internals.device,
@@ -710,11 +1436,18 @@ export function ensureCompiledFrameGraph(
   if (!compiled.ok) {
     internals.errorRegistry.fire(compiled.error);
     featureGraphCandidate?.onRejected?.();
-    return frameState.compiledFrameGraph;
+    return lastKnownGood();
   }
   const previous = frameState.compiledFrameGraph;
+  if (volumeTopologyCandidate) {
+    frameState.volumetricFogPreviousGraph = previous;
+    frameState.volumetricFogPreviousGraphKey = frameState.compiledFrameGraphTopologyKey;
+    frameState.volumetricFogCandidateGraph = compiled.value;
+  }
   frameState.compiledFrameGraph = compiled.value;
   frameState.compiledFrameGraphTopologyKey = key;
+  frameState.standardLightingGraphSignature = requestedStandardLightingSignature;
+  frameState.compiledFrameGraphGeneration += 1;
   const compiledTargets = compiled.value as CompiledGraphTargetAccess;
   frameState.graphGeneration += 1;
   frameState.perFrameGraph = {
@@ -724,10 +1457,12 @@ export function ensureCompiledFrameGraph(
     graphGeneration: frameState.graphGeneration,
   };
   gpuDriven?._commitResourceReplacement();
-  if (featureGraphCandidate !== undefined) {
+  if (featureGraphCandidate !== undefined && !postProcessAdmission.pending) {
     commitFeatureCandidate(internals, featureGraphCandidate);
+  } else if (featureGraphCandidate !== undefined) {
+    featureGraphCandidate.onAbandoned?.();
   }
-  if (previous !== null) retire(frameState, previous);
+  if (!volumeTopologyCandidate && previous !== null) retire(frameState, previous);
   return compiled.value;
 }
 
@@ -737,16 +1472,69 @@ export function executeCompiledFrameGraph(
   frame: RenderPipelineFrame,
   encoder: RhiCommandEncoder,
   runPass?: import('@forgeax/engine-render-graph').RenderGraphPassRunner,
+  readbackFaces?: readonly number[],
+  onSubmitted?: (completed: Promise<unknown>) => void,
+  timingCapture?: GpuTimingCapture,
 ): boolean {
   const graph = frameState.compiledFrameGraph;
-  if (graph === null) return false;
+  const invalidatePostProcessModule = (id: string): void => {
+    const entry = internals.lookupPostProcess?.(id);
+    if (entry !== undefined) {
+      internals.invalidateShaderModule?.(postProcessShaderModuleLabel(id, entry.source));
+    }
+  };
+  const rejectTemporalFrame = (): void => {
+    if (frameState.temporalFrameInput === undefined) return;
+    frameState.temporalFrameTransaction.commit({ accepted: false });
+    frameState.temporalFrameInput = undefined;
+  };
+  if (graph === null) {
+    timingCapture?.discard();
+    settleVolumetricFogGraphCandidate(frameState, false);
+    rejectTemporalFrame();
+    return false;
+  }
+  const timingHost = internals as RenderSystemInternals & {
+    gpuPassTimingSession?: GpuPassTimingSession | undefined;
+    gpuPassTimingCapture?: GpuPassTimingCapture | undefined;
+    gpuPassTimingSubmittedWork?: Promise<void> | undefined;
+    gpuPassTimingFrameIdentity?:
+      | import('./gpu-pass-timing/session.js').GpuPassTimingFrameIdentity
+      | undefined;
+    gpuPassTimingBeginReason?:
+      | import('./gpu-pass-timing/errors.js').GpuPassTimingReason
+      | undefined;
+  };
+  timingHost.gpuPassTimingCapture = undefined;
+  timingHost.gpuPassTimingSubmittedWork = undefined;
+  timingHost.gpuPassTimingBeginReason = undefined;
+  const timingIdentity = timingHost.gpuPassTimingFrameIdentity;
+  const passTimingResult =
+    timingIdentity === undefined
+      ? undefined
+      : timingHost.gpuPassTimingSession?.beginFrame({
+          ...timingIdentity,
+          graphGeneration: frameState.compiledFrameGraphGeneration,
+        });
+  const capture = passTimingResult?.ok === true ? passTimingResult.value : undefined;
+  if (passTimingResult?.ok === false) timingHost.gpuPassTimingBeginReason = passTimingResult.error;
+  const passTimingCapture = capture;
+  timingHost.gpuPassTimingCapture = passTimingCapture;
+  const timingInstrumentationState =
+    passTimingCapture !== undefined
+      ? getTimingInstrumentationState(internals, passTimingCapture)
+      : timingCapture === undefined
+        ? undefined
+        : getVolumeTimingInstrumentationState(internals, timingCapture);
   type PreparedCommand = { readonly command: CommandBuffer };
   let preparedCommand: PreparedCommand = { command: undefined as never };
   const transaction = executeRendererFrameTransaction<PreparedCommand>({
     build: () => ({ ok: true, value: { command: undefined as never } }),
     execute: () => {
-      const executed = graph.execute(frame, runPass);
+      const executed = graph.execute(frame, runPass, timingInstrumentationState?.instrumentation);
+      timingInstrumentationState?.setCapture(undefined);
       if (!executed.ok) {
+        passTimingCapture?.abort({ code: executed.error.code });
         internals.errorRegistry.fire(executed.error);
         return { ok: false, stage: 'execute' };
       }
@@ -876,6 +1664,7 @@ export function executeCompiledFrameGraph(
           );
         }
       }
+      internals.encodeRenderTargetReadbacks?.(encoder, readbackFaces);
       const stagedGpuState = frameState.temporalGpuState;
       if (stagedGpuState !== undefined && !hasPendingTemporalGpuSubmit(stagedGpuState)) {
         internals.errorRegistry.fire(
@@ -887,8 +1676,19 @@ export function executeCompiledFrameGraph(
         );
         return { ok: false, stage: 'finish' };
       }
+      if (passTimingCapture !== undefined) {
+        const tail = passTimingCapture.encodeTail(encoder);
+        if (!tail.ok) passTimingCapture.abort({ code: tail.error.code });
+      }
+      const resolved = timingCapture?.resolve(encoder);
+      if (resolved !== undefined && !resolved.ok) {
+        timingCapture?.discard();
+        return { ok: false, stage: 'finish' };
+      }
       const finished = encoder.finish();
       if (!finished.ok) {
+        passTimingCapture?.abort({ code: finished.error.code });
+        timingCapture?.discard();
         internals.errorRegistry.fire(finished.error);
         return { ok: false, stage: 'finish' };
       }
@@ -898,12 +1698,20 @@ export function executeCompiledFrameGraph(
     submit: () => {
       const submitted = internals.device.queue.submit([preparedCommand.command]);
       if (!submitted.ok) {
+        passTimingCapture?.abort({ code: submitted.error.code });
+        timingCapture?.discard();
         internals.errorRegistry.fire(submitted.error);
         return { ok: false, stage: 'submit' };
       }
+      timingCapture?.markSubmitted();
       return { ok: true, value: undefined };
     },
     commit: () => {
+      if (passTimingCapture !== undefined) {
+        const completion = internals.device.queue.onSubmittedWorkDone();
+        timingHost.gpuPassTimingSubmittedWork = completion;
+        passTimingCapture.markSubmitted(completion);
+      }
       if (frameState.bloomFrameReceipts !== undefined) {
         internals
           .getPipelineState()
@@ -917,7 +1725,7 @@ export function executeCompiledFrameGraph(
           frameState.activeTemporalGpuState = stagedGpuState;
           if (previousGpuState !== undefined && previousGpuState !== stagedGpuState) {
             internals.clearPostProcessPipelineCache?.('forgeax.taa-resolve');
-            internals.invalidateShaderModule?.('post-process-forgeax.taa-resolve-module');
+            invalidatePostProcessModule('forgeax.taa-resolve');
             retireTemporalGpuStateAfterFence(
               previousGpuState,
               internals.device.queue,
@@ -947,7 +1755,7 @@ export function executeCompiledFrameGraph(
       }
       if (stagedTemporalCommit.kind === 'off') {
         internals.clearPostProcessPipelineCache?.('forgeax.taa-resolve');
-        internals.invalidateShaderModule?.('post-process-forgeax.taa-resolve-module');
+        invalidatePostProcessModule('forgeax.taa-resolve');
         const activeGpuState = frameState.activeTemporalGpuState;
         if (activeGpuState !== undefined) {
           retireTemporalGpuStateAfterFence(
@@ -972,8 +1780,13 @@ export function executeCompiledFrameGraph(
         frameState.environmentLifecycle?.publish(frameState.environmentGeneration);
         frameState.environmentGeneration = undefined;
       }
+      onSubmitted?.(internals.device.queue.onSubmittedWorkDone());
     },
     abort: (failure) => {
+      passTimingCapture?.abort({ code: failure.stage });
+      timingHost.gpuPassTimingCapture = undefined;
+      timingHost.gpuPassTimingSubmittedWork = undefined;
+      timingCapture?.discard();
       frameState.bloomFrameReceipts = undefined;
       if (frameState.environmentGeneration !== undefined) {
         frameState.environmentLifecycle?.recordStageFailure(
@@ -996,5 +1809,176 @@ export function executeCompiledFrameGraph(
       }
     },
   });
+  settleVolumetricFogGraphCandidate(frameState, transaction.ok);
+  if (!transaction.ok) rejectTemporalFrame();
   return transaction.ok;
 }
+
+function getTimingInstrumentationState(
+  internals: RenderSystemInternals,
+  capture: GpuPassTimingCapture,
+): TimingInstrumentationState {
+  const existing = timingInstrumentationStates.get(internals);
+  if (existing !== undefined) {
+    existing.setCapture(capture);
+    return existing;
+  }
+  type TimestampWrites = NonNullable<ReturnType<GpuPassTimingCapture['timestampWrites']>>;
+  const activeIdentity: {
+    passName: string;
+    passKind: GpuPassTimingPassIdentity['passKind'];
+    executionIndex: number;
+  } = {
+    passName: '',
+    passKind: 'raster',
+    executionIndex: 0,
+  };
+  let activeWrites: TimestampWrites | undefined;
+  let activeCapture: GpuPassTimingCapture | undefined = capture;
+  const rasterScope: RenderGraphPassInstrumentationScope = {
+    renderPassDescriptor: (descriptor) => {
+      const capture = activeCapture;
+      const identity = activeIdentity;
+      const writes = activeWrites;
+      if (capture === undefined || identity === undefined || writes === undefined) {
+        return descriptor;
+      }
+      if (descriptor.timestampWrites !== undefined) {
+        capture.markOwnerConflict(identity);
+        return descriptor;
+      }
+      (descriptor as { timestampWrites?: TimestampWrites }).timestampWrites = writes;
+      return descriptor;
+    },
+  };
+  const computeScope: RenderGraphPassInstrumentationScope = {
+    computePassDescriptor: (descriptor) => {
+      const capture = activeCapture;
+      const identity = activeIdentity;
+      const writes = activeWrites;
+      if (capture === undefined || identity === undefined || writes === undefined) {
+        return descriptor;
+      }
+      if (descriptor.timestampWrites !== undefined) {
+        capture.markOwnerConflict(identity);
+        return descriptor;
+      }
+      (descriptor as { timestampWrites?: TimestampWrites }).timestampWrites = writes;
+      return descriptor;
+    },
+  };
+  const copyScope: RenderGraphPassInstrumentationScope = {
+    beforeCopy: (encoder) => {
+      const capture = activeCapture;
+      const identity = activeIdentity;
+      if (capture === undefined || identity === undefined) return;
+      capture.copyBoundaryBefore(identity, encoder);
+    },
+    afterCopy: (encoder) => {
+      const capture = activeCapture;
+      const identity = activeIdentity;
+      if (capture === undefined || identity === undefined) return;
+      capture.copyBoundaryAfter(identity, encoder);
+    },
+  };
+  const instrumentation: RenderGraphPassInstrumentation<RenderPipelineFrame> = {
+    begin: (pass) => {
+      const capture = activeCapture;
+      if (capture === undefined) return undefined;
+      activeIdentity.passName = pass.name;
+      activeIdentity.passKind = pass.kind;
+      activeIdentity.executionIndex = pass.executionIndex;
+      activeWrites = capture.recordPass(activeIdentity);
+      if (activeWrites === undefined) return undefined;
+      switch (pass.kind) {
+        case 'raster':
+          return rasterScope;
+        case 'compute':
+          return computeScope;
+        case 'copy':
+          return copyScope;
+      }
+    },
+  };
+  const state: TimingInstrumentationState = {
+    instrumentation,
+    setCapture: (capture) => {
+      activeCapture = capture;
+      if (capture === undefined) {
+        activeWrites = undefined;
+      }
+    },
+  };
+  timingInstrumentationStates.set(internals, state);
+  return state;
+}
+
+function getVolumeTimingInstrumentationState(
+  internals: RenderSystemInternals,
+  capture: GpuTimingCapture,
+): VolumeTimingInstrumentationState {
+  const existing = volumeTimingInstrumentationStates.get(internals);
+  if (existing !== undefined) {
+    existing.setCapture(capture);
+    return existing;
+  }
+  let activeCapture: GpuTimingCapture | undefined = capture;
+  let activePassName: string | undefined;
+  let activeWrites: VolumeTimingTimestampWrites | undefined;
+  const rasterScope: RenderGraphPassInstrumentationScope = {
+    renderPassDescriptor: (descriptor) => {
+      const currentCapture = activeCapture;
+      const passName = activePassName;
+      const writes = activeWrites;
+      if (currentCapture === undefined || passName === undefined || writes === undefined) {
+        return descriptor;
+      }
+      if (descriptor.timestampWrites !== undefined) {
+        currentCapture.skipPass(passName);
+        activeWrites = undefined;
+        return descriptor;
+      }
+      return { ...descriptor, timestampWrites: writes };
+    },
+  };
+  const computeScope: RenderGraphPassInstrumentationScope = {
+    computePassDescriptor: (descriptor) => {
+      const currentCapture = activeCapture;
+      const passName = activePassName;
+      const writes = activeWrites;
+      if (currentCapture === undefined || passName === undefined || writes === undefined) {
+        return descriptor;
+      }
+      if (descriptor.timestampWrites !== undefined) {
+        currentCapture.skipPass(passName);
+        activeWrites = undefined;
+        return descriptor;
+      }
+      return { ...descriptor, timestampWrites: writes };
+    },
+  };
+  const instrumentation: RenderGraphPassInstrumentation<RenderPipelineFrame> = {
+    begin: (pass) => {
+      const currentCapture = activeCapture;
+      if (currentCapture === undefined) return undefined;
+      activePassName = pass.name;
+      activeWrites = currentCapture.recordPass(pass.name);
+      if (activeWrites === undefined) return undefined;
+      if (pass.kind === 'raster') return rasterScope;
+      if (pass.kind === 'compute') return computeScope;
+      currentCapture.skipPass(pass.name);
+      activeWrites = undefined;
+      return undefined;
+    },
+  };
+  const state: VolumeTimingInstrumentationState = {
+    instrumentation,
+    setCapture: (nextCapture) => {
+      activeCapture = nextCapture;
+      activePassName = undefined;
+      activeWrites = undefined;
+    },
+  };
+  volumeTimingInstrumentationStates.set(internals, state);
+  return state;
+}