@forgeax/engine-render 0.1.20 → 0.1.23

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,6 +49,10 @@ import {
   GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
   GPU_TEXTURE_USAGE_TEXTURE_BINDING,
 } from '../gpu-texture-usage';
+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 {
@@ -48,6 +61,10 @@ import type {
   RenderPipelineTopology,
 } 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 { RenderTarget } from '../targets/contracts';
+import type { RenderTargetPhysical } from '../targets/physical';
 import {
   abortTemporalGpuSubmit,
   commitTemporalGpuSubmit,
@@ -64,8 +81,15 @@ 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 { GpuPassTimingPassIdentity } from './gpu-pass-timing/contract.js';
+import type { GpuPassTimingCapture, GpuPassTimingSession } from './gpu-pass-timing/session.js';
 import type { GpuTimingCapture } from './gpu-timing';
-import type { PipelineState, RenderSystemInternals } from './render-context';
+import { encodeMainPass } from './main-pass';
+import type {
+  _InternalRenderPipelineContext,
+  PipelineState,
+  RenderSystemInternals,
+} from './render-context';
 import { resolveSurfaceFormatPair, resolveSurfaceProfile } from './render-context';
 
 export interface TemporalGraphCapabilities {
@@ -81,6 +105,97 @@ export interface TemporalGraphRoster {
   readonly uploads: number;
 }
 
+export interface ReflectionFallbackGraphRoster {
+  readonly enabled: boolean;
+  readonly attachments: readonly string[];
+  readonly passes: readonly string[];
+  readonly bindings: readonly string[];
+  readonly historyCount: 0;
+  readonly temporalDemand: 0;
+}
+
+export interface ReflectionFallbackGraphCandidate {
+  readonly generation: number;
+  readonly source: 'probe' | 'skylight' | 'neutral';
+  readonly roster: ReflectionFallbackGraphRoster;
+}
+
+export interface SsrAdmissionGraphRoster {
+  readonly enabled: boolean;
+  readonly attachments: readonly string[];
+  readonly passes: readonly string[];
+  readonly bindings: readonly string[];
+  readonly historyCount: 0;
+  readonly temporalDemand: 0;
+}
+
+/**
+ * Admission is the sole switch for parent SSR graph work. A blocked result
+ * projects to an empty roster, so missing receipts cannot allocate or bind
+ * any SSR resource.
+ */
+export function createSsrAdmissionGraphRoster(
+  admission: Pick<SsrAdmissionResult, 'status'>,
+): SsrAdmissionGraphRoster {
+  if (admission.status !== 'admitted') {
+    return {
+      enabled: false,
+      attachments: [],
+      passes: [],
+      bindings: [],
+      historyCount: 0,
+      temporalDemand: 0,
+    };
+  }
+  return {
+    enabled: true,
+    attachments: ['ssr-reflection-admission'],
+    passes: ['ssr-m0-admission'],
+    bindings: ['ssr-reflection-admission'],
+    historyCount: 0,
+    temporalDemand: 0,
+  };
+}
+
+export type ReflectionFallbackGraphFailure = 'compile-failed' | 'encode-failed' | 'submit-failed';
+
+export function createReflectionFallbackGraphRoster(input: {
+  readonly fallbackDemand: boolean;
+}): ReflectionFallbackGraphRoster {
+  if (!input.fallbackDemand) {
+    return {
+      enabled: false,
+      attachments: [],
+      passes: [],
+      bindings: [],
+      historyCount: 0,
+      temporalDemand: 0,
+    };
+  }
+  return {
+    enabled: true,
+    attachments: ['reflection-fallback-linear-hdr'],
+    passes: ['standard-main'],
+    bindings: ['reflection-fallback-output'],
+    historyCount: 0,
+    temporalDemand: 0,
+  };
+}
+
+export function commitReflectionFallbackGraph(
+  candidate: ReflectionFallbackGraphCandidate,
+  result:
+    | { readonly ok: true }
+    | { readonly ok: false; readonly reason: ReflectionFallbackGraphFailure },
+): {
+  readonly visible: boolean;
+  readonly generation: number;
+  readonly source?: ReflectionFallbackGraphCandidate['source'];
+} {
+  if (!result.ok || !candidate.roster.enabled) return { visible: false, generation: 0 };
+  return { visible: true, generation: candidate.generation, source: candidate.source };
+}
+
 function importTemporalHistoryTarget(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
   label: string,
@@ -206,6 +321,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<
@@ -230,10 +804,24 @@ 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
+>();
+
 type CompiledGraphTargetAccess = CompiledRenderGraph<RenderPipelineFrame> & {
   readonly getColorTargetDescriptor: (
     name: string,
@@ -284,6 +872,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> {
@@ -314,6 +927,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;
@@ -331,8 +948,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
@@ -357,6 +976,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
@@ -389,6 +1012,7 @@ function topologyOf(
     standardProfile: internals.standardProfile,
     config,
     clearOnly,
+    reflectionFallback: { enabled: frameState.reflectionFallbackDemand === true },
     surface: {
       width,
       height,
@@ -406,10 +1030,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(
@@ -468,10 +1095,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,
@@ -527,14 +1156,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
@@ -546,7 +1178,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 },
@@ -636,8 +1269,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;
@@ -707,11 +1342,20 @@ export function ensureCompiledFrameGraph(
   shadowMapSize: number | undefined,
   gpuDriven?: PreparedGpuDrivenFrame,
   featureGraphCandidate?: RenderFeatureGraphCandidate,
+  cubeCaptureState?: CubeCaptureGraphState,
   clearOnly = false,
   transmissionDemand?: TransmissionDemand,
+  occlusion?: import('../scene/visibility/occlusion-runtime').OcclusionFrameProjection,
   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;
@@ -719,7 +1363,7 @@ export function ensureCompiledFrameGraph(
   if (!projectedFeaturePlans.ok) {
     reportRenderFeatureGraphError(internals, projectedFeaturePlans.error);
     featureGraphCandidate?.onRejected?.();
-    return volumeTopologyCandidate ? null : frameState.compiledFrameGraph;
+    return volumeTopologyCandidate ? null : lastKnownGood();
   }
   const topologyResult = topologyOf(
     internals,
@@ -733,19 +1377,92 @@ export function ensureCompiledFrameGraph(
     shadowMapSize,
     gpuDriven,
     featureGraphCandidate,
+    cubeCaptureState,
     transmissionDemand,
     volumetricFog,
+    standardLighting,
   );
   if (!topologyResult.ok) {
     internals.errorRegistry.fire(topologyResult.error);
     featureGraphCandidate?.onRejected?.();
-    return volumeTopologyCandidate ? null : 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,
+    // 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,
+    // so include the prepared projection's presence to invalidate a cached
+    // CPU-only graph when the GPU owner becomes ready, and vice versa.
+    gpuDrivenProjectionActive: gpuDriven !== undefined,
+    // Query reservations are frame-local transport state. The projection is
+    // renderer-owned and read dynamically by the compiled pass, so a page
+    // rotation must not invalidate the graph or its cached bind groups.
+    occlusionQuery:
+      occlusion === undefined ? undefined : { active: true, sampleCount: occlusion.sampleCount },
+    cubeCaptureSlots: cubeCaptureState?.work.length ?? 0,
+    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
@@ -761,7 +1478,9 @@ export function ensureCompiledFrameGraph(
   const built = frameState.activePipeline.build(
     {
       graph: builder,
+      ...(standardLighting === undefined ? {} : { standardLighting }),
       capabilities: { rgba16floatRenderable: internals.device.caps.rgba16floatRenderable },
+      ...(occlusion === undefined ? {} : { occlusion }),
       ...(taaHistory === undefined ? {} : { taaHistory }),
       encodeTransmissionMip: ({ pass, resources, source }) => {
         const sourceView = resources.textureView(source);
@@ -781,11 +1500,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),
     },
@@ -794,7 +1523,7 @@ export function ensureCompiledFrameGraph(
   if (!built.ok) {
     internals.errorRegistry.fire(built.error);
     featureGraphCandidate?.onRejected?.();
-    return volumeTopologyCandidate ? null : frameState.compiledFrameGraph;
+    return volumeTopologyCandidate ? null : lastKnownGood();
   }
   const compiled = builder.compile({
     device: internals.device,
@@ -803,7 +1532,7 @@ export function ensureCompiledFrameGraph(
   if (!compiled.ok) {
     internals.errorRegistry.fire(compiled.error);
     featureGraphCandidate?.onRejected?.();
-    return frameState.compiledFrameGraph;
+    return lastKnownGood();
   }
   const previous = frameState.compiledFrameGraph;
   if (volumeTopologyCandidate) {
@@ -813,6 +1542,8 @@ export function ensureCompiledFrameGraph(
   }
   frameState.compiledFrameGraph = compiled.value;
   frameState.compiledFrameGraphTopologyKey = key;
+  frameState.standardLightingGraphSignature = requestedStandardLightingSignature;
+  frameState.compiledFrameGraphGeneration += 1;
   const compiledTargets = compiled.value as CompiledGraphTargetAccess;
   frameState.graphGeneration += 1;
   frameState.perFrameGraph = {
@@ -822,8 +1553,10 @@ 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 (!volumeTopologyCandidate && previous !== null) retire(frameState, previous);
   return compiled.value;
@@ -835,9 +1568,22 @@ 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;
+  },
+  readbackFaces?: readonly number[],
+  onSubmitted?: (completed: Promise<unknown>) => void,
   timingCapture?: GpuTimingCapture,
 ): boolean {
   const graph = frameState.compiledFrameGraph;
+  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 });
@@ -849,31 +1595,64 @@ export function executeCompiledFrameGraph(
     rejectTemporalFrame();
     return false;
   }
-  const timedRunPass =
-    timingCapture === undefined
-      ? runPass
-      : (
-          pass: import('@forgeax/engine-render-graph').RenderGraphPassExecution,
-          encode: () => void,
-        ) => {
-          timingCapture.beforePass(pass.name, encoder);
-          try {
-            if (runPass === undefined) encode();
-            else runPass(pass, encode);
-          } finally {
-            timingCapture.afterPass(pass.name, encoder);
-          }
-        };
+  const legacyTimingInstrumentation =
+    timingCapture === undefined ? undefined : createTimingInstrumentation(timingCapture);
+  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
+        : undefined;
+  const graphInstrumentation =
+    passTimingCapture !== undefined
+      ? timingInstrumentationState?.instrumentation
+      : legacyTimingInstrumentation;
   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, timedRunPass);
+      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 afterGraphExecute = frameHooks?.afterGraphExecute;
+      if (afterGraphExecute !== undefined) {
+        const recorded = afterGraphExecute();
+        if (!recorded.ok) {
+          internals.errorRegistry.fire(recorded.error);
+          return { ok: false, stage: 'execute' };
+        }
+      }
       return { ok: true, value: undefined };
     },
     finish: () => {
@@ -1000,6 +1779,44 @@ export function executeCompiledFrameGraph(
           );
         }
       }
+      const fallbackReadback = frameState.reflectionFallbackReadback;
+      frameState.reflectionFallbackReadback = undefined;
+      if (fallbackReadback !== undefined) {
+        const graphAccess = frameState.perFrameGraph;
+        const graphTexture = graphAccess?.getColorTargetTexture(fallbackReadback.name);
+        const descriptor = graphAccess?.getColorTargetDescriptor(fallbackReadback.name);
+        const matches =
+          graphAccess !== undefined &&
+          graphAccess !== null &&
+          graphTexture !== undefined &&
+          descriptor !== undefined &&
+          descriptor.format === fallbackReadback.expected.format &&
+          descriptor.size.width === fallbackReadback.expected.width &&
+          descriptor.size.height === fallbackReadback.expected.height &&
+          descriptor.sample === 1 &&
+          (descriptor.usage & fallbackReadback.expected.usage) ===
+            fallbackReadback.expected.usage &&
+          graphAccess.graphGeneration === fallbackReadback.expected.graphGeneration &&
+          frameState.frameNumber === fallbackReadback.expected.frameId &&
+          getTextureIdentity(graphTexture) === fallbackReadback.expected.textureIdentity;
+        if (matches && graphTexture !== undefined) {
+          encoder.copyTextureToBuffer(
+            { texture: graphTexture },
+            {
+              buffer: fallbackReadback.buffer,
+              bytesPerRow: fallbackReadback.bytesPerRow,
+              rowsPerImage: fallbackReadback.height,
+            },
+            {
+              width: fallbackReadback.width,
+              height: fallbackReadback.height,
+              depthOrArrayLayers: 1,
+            },
+          );
+          fallbackReadback.encoded = true;
+        }
+      }
+      internals.encodeRenderTargetReadbacks?.(encoder, readbackFaces);
       const stagedGpuState = frameState.temporalGpuState;
       if (stagedGpuState !== undefined && !hasPendingTemporalGpuSubmit(stagedGpuState)) {
         internals.errorRegistry.fire(
@@ -1011,6 +1828,10 @@ 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();
@@ -1018,6 +1839,7 @@ export function executeCompiledFrameGraph(
       }
       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' };
@@ -1026,8 +1848,16 @@ export function executeCompiledFrameGraph(
       return { ok: true, value: undefined };
     },
     submit: () => {
+      const injectedFailure = internals.beforeSubmit?.(internals.device);
+      if (injectedFailure !== undefined) {
+        passTimingCapture?.abort({ code: injectedFailure.code });
+        timingCapture?.discard();
+        internals.errorRegistry.fire(injectedFailure);
+        return { ok: false, stage: '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' };
@@ -1036,6 +1866,28 @@ export function executeCompiledFrameGraph(
       return { ok: true, value: undefined };
     },
     commit: () => {
+      frameHooks?.onSubmitted?.();
+      if (frameState.temporalFrameInput !== undefined) {
+        const temporal = frameState.temporalFrameTransaction.commit({ accepted: true });
+        if (temporal.ok) {
+          frameState.temporalFrame = temporal.value;
+        } else {
+          internals.errorRegistry.fire(
+            new RhiError({
+              code: 'webgpu-runtime-error',
+              expected: 'the staged temporal frame to commit after queue submission',
+              hint: 'discard the temporal candidate and retry the next frame',
+              detail: { error: temporal.error },
+            }),
+          );
+        }
+        frameState.temporalFrameInput = undefined;
+      }
+      if (passTimingCapture !== undefined) {
+        const completion = internals.device.queue.onSubmittedWorkDone();
+        timingHost.gpuPassTimingSubmittedWork = completion;
+        passTimingCapture.markSubmitted(completion);
+      }
       if (frameState.bloomFrameReceipts !== undefined) {
         internals
           .getPipelineState()
@@ -1049,7 +1901,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,
@@ -1079,7 +1931,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(
@@ -1104,8 +1956,13 @@ export function executeCompiledFrameGraph(
         frameState.environmentLifecycle?.publish(frameState.environmentGeneration);
         frameState.environmentGeneration = undefined;
       }
+      onSubmitted?.(internals.device.queue.onSubmittedWorkDone());
     },
     abort: (failure) => {
+      frameHooks?.onAborted?.();
+      passTimingCapture?.abort({ code: failure.stage });
+      timingHost.gpuPassTimingCapture = undefined;
+      timingHost.gpuPassTimingSubmittedWork = undefined;
       timingCapture?.discard();
       frameState.bloomFrameReceipts = undefined;
       if (frameState.environmentGeneration !== undefined) {
@@ -1133,3 +1990,137 @@ export function executeCompiledFrameGraph(
   if (!transaction.ok) rejectTemporalFrame();
   return transaction.ok;
 }
+
+function createTimingInstrumentation(
+  capture: GpuTimingCapture,
+): RenderGraphPassInstrumentation<RenderPipelineFrame> {
+  return {
+    begin: (pass): RenderGraphPassInstrumentationScope | undefined => {
+      // WebGPU has no portable timestamp boundary for a copy pass. Do not
+      // pretend a command-encoder marker exists; frame timing remains valid
+      // when at least one raster/compute pass is present.
+      if (pass.kind === 'copy') return undefined;
+      const writes = capture.beginPass(pass.name, pass.kind, pass.executionIndex);
+      if (writes === undefined) return undefined;
+      if (pass.kind === 'raster') {
+        return {
+          renderPassDescriptor: (descriptor) => {
+            if (descriptor.timestampWrites !== undefined) {
+              capture.markOwnerConflict(pass.name);
+              return descriptor;
+            }
+            return { ...descriptor, timestampWrites: writes };
+          },
+        };
+      }
+      return {
+        computePassDescriptor: (descriptor) => {
+          if (descriptor.timestampWrites !== undefined) {
+            capture.markOwnerConflict(pass.name);
+            return descriptor;
+          }
+          return { ...descriptor, timestampWrites: writes };
+        },
+      };
+    },
+  };
+}
+
+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;
+}