@forgeax/engine-render 0.1.32 → 0.1.34

package/src/render-system.ts

@@ -1,45 +1,28 @@
 import { projectCaptureScene } from './capture/scene-projection';
 import type { RenderSceneBounds } from './scene/render-scene-types';
-// @forgeax/engine-runtime - RenderSystem main entry (D-S2 three-stage Extract ->
-// Prepare -> Record + 4-tier error fan-out).
-//
-// Engine-internal phase: NOT registered to World schedule (AC-09);
-// `Renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 })` invokes once per frame. See `Renderer` JSDoc in
-// `./render-contract.ts` for the public error/frame contract and AGENTS.md
-// "ECS render bridge" section for the AI-user-facing contract.
-//
-// Stage carve-out (review round 1 finding #3 - 505 line cap fallback):
-//   - render-system.ts          (this file)             types + orchestration
-//   - render-system-extract.ts  Extract ECS query phase + snapshot helpers
-//   - render-system-record.ts   Prepare + Record GPU phase + matrix helpers
-//
 // @forgeax/engine-math is referenced through render-system-record.ts which builds
 // view/proj matrices and worldFromLocal via `mat4.compose / .multiply /
 // .invert` (charter proposition 5: no math reinvention; render-system.test.ts
 // asserts `/@forgeax\/engine-math/` shows up in render-system.ts source).
 
-import { numMipLevels, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
+import { numMipLevels } from '@forgeax/engine-assets-runtime';
 import { Time, type World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
 import type { RecorderSession } from '@forgeax/engine-profiler';
 import type { CompiledRenderGraphInfo } from '@forgeax/engine-render-graph';
 import type { BindGroupLayout, Buffer, RenderPipeline, RhiDevice } from '@forgeax/engine-rhi';
 import { err, ok, type Result, RhiError } from '@forgeax/engine-rhi';
-import {
-  deriveTextureLayout,
-  type MaterialAsset,
-  type RenderPipelineAsset,
-  type SamplerAsset,
-  type TextureAsset,
-  toShared,
-} from '@forgeax/engine-types';
+import { type RenderPipelineAsset, toShared } from '@forgeax/engine-types';
 import {
   type DirectionalShadowInspectionSource,
   directionalShadowProfileFromQuality,
   projectDirectionalShadowInspectionSource,
 } from './assembly/directional-shadow-inspection';
 import { createGpuDrivenOwner } from './assembly/gpu-driven-owner';
+import { standardBloomAdmitted } from './bloom-admission';
+import { createCloudFeatureFrameContext, createCloudFeatureView } from './cloud/frame-context';
 import { createClusterBinScratch } from './cluster-binner';
+import type { DynamicGeometryRecordStageLane } from './dynamic-geometry';
 import { EnvironmentLifecycle } from './environment/lifecycle';
 import {
   type ObservationUnavailableError,
@@ -48,11 +31,25 @@ import {
 } from './errors/render';
 import { projectDepthOfFieldInspection } from './features/depth-of-field/depth-of-field-inspection';
 import { resolveDepthOfFieldFrameParams } from './features/depth-of-field/depth-of-field-params';
+import type { PendingRenderFeatureErrorReport } from './features/error-reporting';
+import { reportPendingRenderFeatureErrors } from './features/error-reporting';
 import {
   type RenderFeaturePreparedGraphicsResolverInput,
   runRenderFeatureFrame,
   settlePreparedGraphicsCompletion,
 } from './features/host';
+import {
+  createMotionBlurFeature,
+  type MotionBlurFeatureInput,
+} from './features/motion-blur/motion-blur-feature';
+import {
+  MotionBlurValidationError,
+  motionBlurTemporalDemand,
+} from './features/motion-blur/motion-blur-params';
+import {
+  planMotionBlurFrame,
+  projectMotionBlurInspection,
+} from './features/motion-blur/motion-blur-runtime';
 import { createFeatureNoiseResolver } from './features/noise-texture';
 import {
   createRenderFeatureGpuWorkOwner,
@@ -69,6 +66,7 @@ import {
   postProcessShaderPipelineLabel,
 } from './fullscreen-post-process-pass';
 import type {
+  BarrelDistortionInspection,
   BloomInspection,
   DepthOfFieldInspection,
   DirectionalShadowInspection,
@@ -83,6 +81,7 @@ import type {
   TemporalTargetInspection,
   TransmissionInspection,
 } from './inspection-types';
+import { emptyBloomInspection } from './inspection-types';
 import { buildOcclusionProxyVertices } from './occlusion-proxy';
 import {
   AUTO_EXPOSURE_HISTOGRAM_BYTES,
@@ -110,11 +109,7 @@ import {
 } from './pipeline/standard-output/resources';
 import type { PointsLinesRetainedSnapshot } from './points-lines/snapshot';
 import { StandardPointsLinesOwner } from './points-lines/standard-owner';
-import {
-  createRenderSystemRecovery,
-  materialSamplerHandles,
-  materialTextureHandles,
-} from './recovery/render-system-candidate';
+import { createRenderSystemRecovery } from './recovery/render-system-candidate';
 
 export { materialTextureHandlesForResidency } from './recovery/render-system-candidate';
 
@@ -154,9 +149,10 @@ import { inspectVolumetricFog } from './volume/inspection';
 
 export type { RenderSceneInspection } from './inspection-types';
 
+import type { BarrelDistortionMapping } from './barrel-distortion';
 import { createCubeCaptureScheduler } from './capture/scheduler';
 import type { EnvironmentInspection } from './environment/inspection';
-import { gpuDrivenShadowDrawKey } from './extract/gpu-driven';
+import { rebaseShadowCasterOwnership } from './gpu-driven/shadow-ownership';
 import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM } from './gpu-usage';
 import { resetHdrpBuffers } from './hdrp-buffers';
 import type { SkylightBindGroupResources } from './ibl/skylight-bind-group';
@@ -166,11 +162,9 @@ import {
   disposeTransientInstanceBuffers,
 } from './instance-buffer-cache';
 import type { InstanceCollectionInspection } from './instances';
-import { InstanceCollectionStore } from './instances';
+import { InstanceProjectionStore } from './instances';
 import {
   type MeshMaterialBindingObservation,
-  type MeshMaterialBindingPreparationFailure,
-  type MeshMaterialBindingResidency,
   projectMeshMaterialBindingObservation,
 } from './mesh-material-bindings';
 import type { StandardLightingInspection } from './pipeline/standard-lighting/inspection';
@@ -183,6 +177,10 @@ import {
   createPreparedGraphicsResolver,
   type PreparedGraphicsResolver,
 } from './prepare/prepared-graphics-resolver';
+import {
+  inspectBarrelDistortionState,
+  resetBarrelDistortionGraphState,
+} from './record/barrel-distortion-frame';
 import {
   type CubeCaptureFrameInput,
   type FrameObservation,
@@ -198,6 +196,7 @@ import type {
   RenderFrameState,
 } from './record/frame-snapshot';
 import { getTextureIdentity, worldEntityKey } from './record/frame-snapshot';
+import type { RenderableDrawReceipt } from './record/gpu-draw-receipts';
 import type { GpuPassTimingReason } from './record/gpu-pass-timing/errors';
 import type {
   GpuPassTimingCapture,
@@ -215,34 +214,39 @@ import type { PipelineState, RenderSystemInternals } from './record/render-conte
 import type { CubeCaptureGraphState } from './record/typed-frame-graph';
 import {
   getRenderFeatureGraphInspection,
+  inspectRenderGraphGenerationAllocation,
   type RenderFeatureGraphCandidate,
   recordRenderFeatureCandidate,
   resetRenderFeatureGraphState,
+  retire as retireCompiledGraph,
+  settleBarrelDistortionGraphCandidate,
   settleDepthOfFieldGraphCandidate,
   settleVolumetricFogGraphCandidate,
 } from './record/typed-frame-graph';
 import {
   type CameraSnapshot,
   type DrawOwnerOptions,
+  type FramePresentation,
   RENDER_PHASE_CATALOG,
   type RenderPhase,
   type RenderPhaseSkipReason,
   type RenderRecordPhase,
 } from './render-contract';
-import type {
-  DispatchEntry,
-  ExtractedLights,
-  MaterialSnapshot,
-  RenderableSnapshot,
-  ShadowCasterMembership,
-} from './render-system-extract';
+import type { DispatchEntry, ExtractedLights, RenderableSnapshot } from './render-system-extract';
 import { extractFrames } from './render-system-extract';
+import { projectFramePresentation } from './render-system-presentation';
+import {
+  createRendererProducerRootMatrix,
+  type RendererProducerRoot,
+} from './render-system-producer-roots';
 import {
   canonicalizeWorldComposition,
   createLodWorldInspections,
 } from './render-system-projections';
+import { observeMaterialResidency } from './render-system-residency';
 import { PersistentRenderScene } from './scene/render-scene';
 import { inspectLodOcclusion } from './scene/visibility/inspection';
+import { resetSsaoResources } from './ssao-buffers';
 import { resolveSsaoParameters } from './ssao-config';
 import {
   projectSsrDependencies,
@@ -251,6 +255,8 @@ import {
   zeroSsrAdmissionWork,
 } from './ssr/admission';
 import { projectSsrSpatialInspection } from './ssr/inspection';
+import type { SurfaceDynamicInputFrame } from './surface/dynamic-input';
+import { SurfaceSubmissionObservationOwner } from './surface/submission-observation';
 import { sortTransparentDispatch } from './systems/transparent-dispatch';
 import type { RenderTarget } from './targets/contracts';
 import { createTemporalFrameTransaction, type TemporalFrame } from './temporal/frame';
@@ -268,73 +274,6 @@ import {
   inspectTransmissionFromAdmission,
 } from './transmission/inspection';
 
-const WORLD_ENTITY_KEY_STRIDE = 4294967296;
-
-/**
- * Extract emits world/entity keys in the transient `worlds[]` index domain,
- * while PersistentRenderScene owns stable renderer-local World keys for the
- * retained GPU scene. Rebase ShadowCaster ownership at this orchestration
- * boundary before both GPU projection and CPU residual recording consume it.
- */
-function rebaseShadowCasterOwnership(
-  worlds: readonly World[],
-  stableWorldKeys: readonly number[],
-  entityKeys: ReadonlySet<number>,
-  drawKeys: ReadonlySet<string>,
-  membership: readonly ShadowCasterMembership[] | undefined,
-): {
-  readonly entityKeys: ReadonlySet<number>;
-  readonly drawKeys: ReadonlySet<string>;
-  readonly membership: readonly ShadowCasterMembership[] | undefined;
-} {
-  const rebaseWorldEntity = (composite: number): number => {
-    const transientWorldId = Math.floor(composite / WORLD_ENTITY_KEY_STRIDE);
-    if (
-      !Number.isInteger(transientWorldId) ||
-      transientWorldId < 0 ||
-      transientWorldId >= worlds.length
-    ) {
-      return composite;
-    }
-    const entityKey = composite - transientWorldId * WORLD_ENTITY_KEY_STRIDE;
-    return worldEntityKey(stableWorldKeys[transientWorldId] ?? transientWorldId, entityKey);
-  };
-
-  const stableMembership =
-    membership === undefined
-      ? undefined
-      : membership.map((entry) => ({
-          ...entry,
-          worldEntity: rebaseWorldEntity(entry.worldEntity),
-        }));
-  const stableDrawKeys =
-    stableMembership === undefined
-      ? new Set(
-          [...drawKeys].map((key) => {
-            const parts = key.split(':');
-            if (parts.length !== 4) return key;
-            const transientWorldEntity = Number(parts[0]);
-            if (!Number.isFinite(transientWorldEntity)) return key;
-            return `${rebaseWorldEntity(transientWorldEntity)}:${parts[1]}:${parts[2]}:${parts[3]}`;
-          }),
-        )
-      : new Set(
-          stableMembership.map((entry) =>
-            gpuDrivenShadowDrawKey(
-              entry.worldEntity,
-              entry.materialHandle,
-              entry.drawItemIndex,
-              entry.passIndex,
-            ),
-          ),
-        );
-  return {
-    entityKeys: new Set([...entityKeys].map(rebaseWorldEntity)),
-    drawKeys: stableDrawKeys,
-    membership: stableMembership,
-  };
-}
-
 type TimingSessionHost = RenderSystemInternals & {
   gpuPassTimingSession?: GpuPassTimingSession | undefined;
   gpuPassTimingCapture?: GpuPassTimingCapture | undefined;
@@ -371,102 +310,11 @@ export {
   selectSwapChainFormat,
 } from './record/render-context';
 
-export type RendererProducerRootKind =
-  | 'backend-surface'
-  | 'shader-material-pipeline'
-  | 'mesh-texture-sampler'
-  | 'render-scene'
-  | 'gpu-driven'
-  | 'feature'
-  | 'external-source'
-  | 'render-graph'
-  | 'target-history'
-  | 'observation-lease';
-
-export interface RendererProducerRoot {
-  readonly kind: RendererProducerRootKind;
-  readonly owner: string;
-  readonly candidateScope: 'device-scope';
-  readonly visibility: 'visible-workset' | 'non-visible-lazy';
-  readonly disabledWork: 'zero' | 'lazy';
-}
-
-const PRODUCER_ROOT_MATRIX: readonly RendererProducerRoot[] = Object.freeze([
-  {
-    kind: 'backend-surface',
-    owner: 'backend-surface-owner',
-    candidateScope: 'device-scope',
-    visibility: 'visible-workset',
-    disabledWork: 'zero',
-  },
-  {
-    kind: 'shader-material-pipeline',
-    owner: 'shader-material-pipeline-owner',
-    candidateScope: 'device-scope',
-    visibility: 'visible-workset',
-    disabledWork: 'zero',
-  },
-  {
-    kind: 'mesh-texture-sampler',
-    owner: 'gpu-residency',
-    candidateScope: 'device-scope',
-    visibility: 'visible-workset',
-    disabledWork: 'lazy',
-  },
-  {
-    kind: 'render-scene',
-    owner: 'persistent-render-scene',
-    candidateScope: 'device-scope',
-    visibility: 'visible-workset',
-    disabledWork: 'zero',
-  },
-  {
-    kind: 'gpu-driven',
-    owner: 'gpu-driven-production',
-    candidateScope: 'device-scope',
-    visibility: 'visible-workset',
-    disabledWork: 'zero',
-  },
-  {
-    kind: 'feature',
-    owner: 'render-feature-host',
-    candidateScope: 'device-scope',
-    visibility: 'visible-workset',
-    disabledWork: 'lazy',
-  },
-  {
-    kind: 'external-source',
-    owner: 'external-source-owner',
-    candidateScope: 'device-scope',
-    visibility: 'non-visible-lazy',
-    disabledWork: 'zero',
-  },
-  {
-    kind: 'render-graph',
-    owner: 'typed-frame-graph',
-    candidateScope: 'device-scope',
-    visibility: 'visible-workset',
-    disabledWork: 'zero',
-  },
-  {
-    kind: 'target-history',
-    owner: 'temporal-target-owner',
-    candidateScope: 'device-scope',
-    visibility: 'visible-workset',
-    disabledWork: 'zero',
-  },
-  {
-    kind: 'observation-lease',
-    owner: 'render-observation-owner',
-    candidateScope: 'device-scope',
-    visibility: 'non-visible-lazy',
-    disabledWork: 'zero',
-  },
-]);
-
-export function createRendererProducerRootMatrix(): readonly RendererProducerRoot[] {
-  return PRODUCER_ROOT_MATRIX;
-}
+export type {
+  RendererProducerRoot,
+  RendererProducerRootKind,
+} from './render-system-producer-roots';
+export { createRendererProducerRootMatrix } from './render-system-producer-roots';
 
 /**
  * Production-owned recovery facts. These values are projections of the live
@@ -505,6 +353,8 @@ export interface RecoveryProductionEvidence {
  */
 export interface RenderSystem {
   bounds(world: World, entity: number): RenderSceneBounds | undefined;
+  /** Publish one renderer-owned read-only Surface dynamic page for the next frame. */
+  setSurfaceDynamicInput(frame: SurfaceDynamicInputFrame | undefined): void;
   /** Complete explicit SSR capability preparation before drawing a device generation. */
   initializeSsr(device?: RhiDevice): Promise<void>;
   /** Returns true only when this invocation reached queue submission. */
@@ -520,6 +370,11 @@ export interface RenderSystem {
    * barrier; ECS component presence alone is not a draw receipt.
    */
   isDynamicGeometryConsumed(world: World, entity: number, meshHandle: number | undefined): boolean;
+  dynamicGeometryRecordStageLane(
+    world: World,
+    entity: number,
+    meshHandle: number | undefined,
+  ): DynamicGeometryRecordStageLane | undefined;
   invalidateGeometryHistory(): void;
   /** Prepare a detached graph candidate without entering the frame record path. */
   prepareRecoveryGraphCandidate(
@@ -542,7 +397,10 @@ export interface RenderSystem {
     options: FrameObservationOptions,
   ): Promise<Result<FrameObservation, ObservationUnavailableError>>;
   /** Resolve the renderer-owned GPU LOD counters for the last accepted submit. */
-  observeLodOcclusion(): Promise<void>;
+  observeLodOcclusion(receipt?: {
+    readonly frameId: number;
+    readonly deviceGeneration: number;
+  }): Promise<void>;
   /** Internal same-frame graph target access for backend diagnostics. */
   getCurrentGraphTarget(name: string): CurrentGraphTarget | undefined;
   /** Internal test capture copied into the draw's command submission. */
@@ -550,8 +408,6 @@ export interface RenderSystem {
   readonly pipelineDispatchCounts: {
     readonly unlit: number;
   };
-  /** Renderer-owned source for explicit large instance collections. */
-  readonly instances: InstanceCollectionStore;
   /** Detached residency and upload facts for explicit instance collections. */
   readonly instanceCollectionsInspection: readonly InstanceCollectionInspection[];
   /**
@@ -570,6 +426,8 @@ export interface RenderSystem {
   readonly ssr: SsrSpatialInspection;
   /** Producer completion fence included in the public FrameReceipt. */
   readonly reflectionFallbackCompletion: Promise<void> | undefined;
+  /** Presentation readiness derived from the producer facts used by draw(). */
+  readonly presentation: FramePresentation;
   /** True while a progressive CubeCamera candidate still owns unfinished faces. */
   isCubeCapturePending(target: RenderTarget): boolean;
   readonly environment: EnvironmentInspection;
@@ -580,6 +438,8 @@ export interface RenderSystem {
   readonly temporal: TemporalInspection;
   readonly bloom: BloomInspection;
   readonly motionBlurInspection: MotionBlurInspection | undefined;
+  /** The last extraction validation failure, preserved for public draw(). */
+  readonly motionBlurInvalidParams: MotionBlurValidationError | undefined;
   readonly depthOfFieldInspection: DepthOfFieldInspection | undefined;
   readonly temporalTargetInspection: TemporalTargetInspection | undefined;
   readonly lodOcclusionInspection: LodOcclusionInspection | undefined;
@@ -610,8 +470,14 @@ export interface RenderSystem {
   readonly perFramePassNames: readonly string[];
   /** Camera antialias mode for the last successfully submitted frame. */
   readonly lastSuccessfulCameraAntialias: CameraSnapshot['antialias'] | undefined;
+  /** Effective output mapping for the last successfully submitted camera. */
+  readonly lastSuccessfulBarrelDistortion: BarrelDistortionMapping | undefined;
+  /** Detached accepted/LKG projection for Renderer.inspect(). */
+  readonly barrelDistortionInspection: BarrelDistortionInspection;
   /** Detached compiled-graph facts used by the renderer inspection owner. */
   readonly perFrameGraphInfo: CompiledRenderGraphInfo | undefined;
+  /** Detached allocation facts across active, candidate, and retiring graphs. */
+  readonly renderGraphGenerationAllocation: import('@forgeax/engine-render-graph').RenderGraphGenerationAllocationInspection;
   /** Detached feature signature/compile/lifetime counters. */
   readonly featureGraphInspection: import('./inspection-types').RenderFeatureGraphInspection;
   /** Detached material texture-source probe counters from the last extract. */
@@ -723,13 +589,6 @@ function reportPreparedGraphicsCompletionError(
   );
 }
 
-function isPendingRenderFeaturePreparation(error: RenderError): boolean {
-  return (
-    error.code === 'render-feature-preparation-failed' &&
-    error.detail.reason.startsWith('rhi-not-available:')
-  );
-}
-
 function makePreparedPipelinePendingError(): RhiError {
   return new RhiError({
     code: 'rhi-not-available',
@@ -738,149 +597,6 @@ function makePreparedPipelinePendingError(): RhiError {
   });
 }
 
-function preparationFailureFrom(error: unknown): MeshMaterialBindingPreparationFailure | undefined {
-  if (typeof error !== 'object' || error === null) return undefined;
-  const value = error as {
-    readonly code?: unknown;
-    readonly expected?: unknown;
-    readonly hint?: unknown;
-    readonly detail?: unknown;
-  };
-  if (
-    typeof value.code !== 'string' ||
-    typeof value.expected !== 'string' ||
-    typeof value.hint !== 'string'
-  ) {
-    return undefined;
-  }
-  const detail =
-    typeof value.detail === 'object' && value.detail !== null
-      ? { ...(value.detail as Record<string, unknown>) }
-      : undefined;
-  return {
-    code: value.code,
-    expected: value.expected,
-    hint: value.hint,
-    ...(detail === undefined ? {} : { detail }),
-  };
-}
-
-/**
- * Project the producer-owned material and GPU store state into the one
- * renderer observation surface. This is intentionally recomputed from the
- * current frame's detached material snapshots; no readiness map is retained
- * by RenderSystem. A producer failure with an already resident resource is
- * reported as last-known-good, preserving recovery context without copying
- * the producer's lifecycle state.
- */
-function observeMaterialResidency(
-  world: World | undefined,
-  material: MaterialSnapshot,
-  internals: RenderSystemInternals,
-): MeshMaterialBindingResidency {
-  const textures: Array<{ readonly handle: number; readonly mipLevelCount: number }> = [];
-  const samplers: Array<{ readonly handle: number; readonly resident: boolean }> = [];
-  let pending = false;
-  let resident = false;
-  let failure: MeshMaterialBindingPreparationFailure | undefined;
-  const keepFailure = (error: unknown): void => {
-    if (failure === undefined) failure = preparationFailureFrom(error);
-  };
-
-  if (world === undefined) {
-    pending = true;
-  } else {
-    const materialHandle = material.materialHandle;
-    if (materialHandle !== undefined && materialHandle !== 0) {
-      const materialResult = resolveAssetHandle<MaterialAsset>(
-        world,
-        toShared<'MaterialAsset'>(materialHandle),
-      );
-      if (!materialResult.ok) {
-        keepFailure(materialResult.error);
-      } else {
-        const guid = internals.assets.guidOf(materialResult.value);
-        if (guid !== undefined) {
-          const readiness = internals.assets.getMaterialReadiness(guid);
-          if (readiness?.status === 'Error') keepFailure(readiness.error);
-          const load = internals.assets.loadState.get(guid);
-          if (load?.status === 'provisional') pending = true;
-        }
-      }
-    }
-
-    for (const handle of materialTextureHandles(material)) {
-      const existing = internals.gpuStore.getTextureGpuView(handle, world);
-      const pod = resolveAssetHandle<TextureAsset>(world, handle);
-      if (!pod.ok) {
-        keepFailure(pod.error);
-        continue;
-      }
-      let view = existing;
-      if (view === undefined) {
-        const prepared = internals.gpuStore.ensureResident(handle, pod.value, world);
-        if (!prepared.ok) keepFailure(prepared.error);
-        view = internals.gpuStore.getTextureGpuView(handle, world);
-      }
-      if (view === undefined) {
-        pending = failure === undefined;
-        continue;
-      }
-      const textureLayout = deriveTextureLayout({
-        shape: pod.value.shape,
-        format: pod.value.format,
-        mips: pod.value.mips,
-      });
-      if (!textureLayout.ok) {
-        keepFailure(textureLayout.error);
-        continue;
-      }
-      resident = true;
-      textures.push({
-        handle: Number(handle),
-        mipLevelCount: Math.max(1, textureLayout.value.levels.length),
-      });
-    }
-
-    for (const handle of materialSamplerHandles(material)) {
-      const pod = resolveAssetHandle<SamplerAsset>(world, handle);
-      if (!pod.ok) {
-        keepFailure(pod.error);
-        samplers.push({ handle: Number(handle), resident: false });
-        continue;
-      }
-      const prepared = internals.gpuStore.ensureSamplerResident(handle, pod.value, world);
-      if (!prepared.ok) {
-        keepFailure(prepared.error);
-        samplers.push({ handle: Number(handle), resident: false });
-      } else {
-        resident = true;
-        samplers.push({ handle: Number(handle), resident: true });
-      }
-    }
-    // Video views are supplied by the dynamic host store at record time. They
-    // are not static TextureAsset residents, so this bounded projection stays
-    // pending until a dynamic observation contract exists rather than guessing
-    // from the VideoAsset GUID.
-    if ((material.videoTextureFields?.size ?? 0) > 0) pending = true;
-  }
-
-  const readiness =
-    failure === undefined
-      ? pending
-        ? 'pending'
-        : 'ready'
-      : resident
-        ? 'last-known-good'
-        : 'failed';
-  return {
-    readiness,
-    samplers,
-    textures,
-    ...(failure === undefined ? {} : { preparationFailure: failure }),
-  };
-}
-
 export function createRenderSystem(internals: RenderSystemInternals): RenderSystem {
   const phaseCatalogRegistration = internals.profiler?.registerPhaseCatalog(
     'render',
@@ -896,9 +612,28 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   });
   let preparedFeatureSkylightResources: SkylightBindGroupResources | undefined;
   const dynamicGeometryFrames = createDynamicGeometryFrameBindings();
+  let surfaceDynamicInputFrame: SurfaceDynamicInputFrame | undefined;
   let latestCamera: CameraSnapshot | undefined;
+  // Last public parameter failure; cleared only after a valid extraction.
+  let lastMotionBlurInvalidParams: MotionBlurValidationError | undefined;
+  // Lazily install the compute lane when a capable frame demands it.
+  let motionBlurFeatureInput: MotionBlurFeatureInput | undefined;
+  const motionBlurFeature = createMotionBlurFeature(() => motionBlurFeatureInput);
+  const ensureMotionBlurFeature = (): void => {
+    const host = internals.featureHost;
+    if (
+      host === undefined ||
+      host.features.some((feature) => feature.identity === 'forgeax.motion-blur')
+    ) {
+      return;
+    }
+    const installed = host.install(
+      motionBlurFeature as import('./features/types').RenderFeature<unknown>,
+    );
+    if (!installed.ok) internals.errorRegistry.fire(installed.error);
+  };
   const pointsLinesOwner = new StandardPointsLinesOwner(internals);
-  const instanceCollections = new InstanceCollectionStore();
+  const instanceCollections = new InstanceProjectionStore();
   const reflectionProbeOwner = new ReflectionProbeRecordOwner(internals);
   const ssrFormatReceipts = new WeakMap<
     RhiDevice,
@@ -926,7 +661,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   const persistentRenderScene = new PersistentRenderScene({
     getDevice: () => internals.device,
     onGpuError: (error) => internals.errorRegistry.fire(error),
-    onSharedRefMutation: (worldId, handle) => {
+    onRuntimeAssetChange: (worldId, handle) => {
       internals.gpuStore.invalidateMesh(handle, preparedWorlds[worldId] ?? worldId);
     },
     instanceCollections,
@@ -1074,6 +809,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         ),
     } satisfies import('./pipeline-builder').PipelineBuilderShaderModuleFactory);
   let gpuDrivenRecoveryCount = 0;
+  const surfaceSubmissionObservation = new SurfaceSubmissionObservationOwner(
+    () => internals.deviceScope.generation,
+  );
   let gpuDrivenProduction = createGpuDrivenOwner(
     internals.device,
     gpuDrivenShaderFactory,
@@ -1145,6 +883,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   // raw (material-handle-based, cross-world collision semantically correct).
   const frameState: RenderFrameState = {
     frameNumber: 0,
+    surfaceSubmissionObservation: undefined,
     reflectionFallbackDemand: false,
     ssrRequested: false,
     ssrSpatialAdmission: undefined,
@@ -1172,6 +911,13 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     depthOfFieldCandidateGraph: null,
     depthOfFieldAccepted: undefined,
     depthOfFieldLastSubmitFailed: false,
+    barrelDistortionPreviousGraph: null,
+    barrelDistortionPreviousGraphKey: null,
+    barrelDistortionPreviousPerFrameGraph: undefined,
+    barrelDistortionPreviousGraphGeneration: 0,
+    barrelDistortionPreviousCompiledGraphGeneration: 0,
+    barrelDistortionPreviousStandardLightingGraphSignature: '',
+    barrelDistortionCandidateGraph: null,
     volumetricFogPreviousGraph: null,
     volumetricFogPreviousGraphKey: null,
     volumetricFogCandidateGraph: null,
@@ -1190,6 +936,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     currentFrameObservationSource: undefined,
     reflectionFallbackObservationSource: undefined,
     lastSuccessfulCameraAntialias: undefined,
+    lastSuccessfulBarrelDistortion: undefined,
+    barrelDistortionGraphResolution: 'accepted',
     temporalGpuState: undefined,
     autoExposureGpuResources: undefined,
     pendingAutoExposureGpuResources: undefined,
@@ -1291,6 +1039,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     // tiles until the first frame with a castShadow spot (AC-03).
     spotShadowSnapshots: [],
   };
+  // A feature that is explicitly recoverable on the next frame must not
+  // publish the same transient failure on every render tick. Keep one
+  // renderer-owned cooldown per structured feature failure while retaining
+  // the original error for the first and periodic reports.
+  const pendingFeatureErrorLastReportedFrame = new Map<string, PendingRenderFeatureErrorReport>();
   const resolveSsrDependencies = (requested: boolean): SsrDependenciesInspection => {
     // Explicit SSR capability preparation belongs to initialization. Inspection
     // only projects receipts and never starts work or creates image history.
@@ -1496,7 +1249,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   const invalidatePostProcessModule = (id: string): void => {
     const entry = lookupPostProcess(id);
     if (entry !== undefined) {
-      internals.invalidateShaderModule?.(postProcessShaderModuleLabel(id, entry.source));
+      internals.invalidateShaderModule?.(postProcessShaderModuleLabel(entry.source));
     }
   };
   // feat-20260621 M-A2 / w8: expose the eager-created per-id params UBO through
@@ -1586,6 +1339,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       if (!destroyed.ok) internals.errorRegistry.fire(destroyed.error);
     }
   };
+  const disposeActivePostProcessResources = (): void => {
+    const resources = { device: postProcessParamsDevice, paramsBuffers: postProcessParamsBuffers };
+    postProcessParamsBuffers = new Map();
+    disposePostProcessResources(resources);
+  };
   const preparePostProcessParamsResources = (
     featureEntries: ReadonlyMap<string, PostProcessShaderEntry>,
   ): Result<PostProcessParamsCandidate, RhiError> => {
@@ -1752,6 +1510,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           readonly visible: number;
           readonly occluded: number;
           readonly lodHistogram: readonly { readonly level: number; readonly count: number }[];
+          readonly submit?: { readonly frameId: number; readonly deviceGeneration: number };
           readonly worldSelections?: readonly {
             readonly worldKey: number;
             readonly primitiveSlot: number;
@@ -1763,9 +1522,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           }[];
         }
       | undefined,
+    targetInspection: LodOcclusionInspection | undefined = lastLodOcclusionInspection,
+    targetWorldAttachments: ReadonlyMap<number, string> = lastLodWorldAttachments,
   ): void => {
-    if (selection === undefined || lastLodOcclusionInspection === undefined) return;
-    const inspection = lastLodOcclusionInspection;
+    if (selection === undefined || targetInspection === undefined) return;
+    const inspection = targetInspection;
     // The GPU readback histogram is the selector fact, while final submitted
     // counts are owned by the persistent visibility projection. Keeping the
     // projection count here excludes ordinary non-LOD geometry (for example a
@@ -1777,7 +1538,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       const selectionsByAttachment = new Map<string, (typeof worldSelections)[number][]>();
       let attributionValid = true;
       for (const selected of worldSelections) {
-        const attachmentId = lastLodWorldAttachments.get(selected.worldKey);
+        const attachmentId = targetWorldAttachments.get(selected.worldKey);
         if (attachmentId === undefined) {
           attributionValid = false;
           break;
@@ -1790,15 +1551,16 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         const nextWorlds = worlds.map((world) => {
           const selected = selectionsByAttachment.get(world.attachmentId);
           const baseRow = world.rows[0];
-          if (selected === undefined || baseRow === undefined) {
-            if (world.rows.length > 0) attributionValid = false;
-            return world;
-          }
-          const candidateCount = selected.reduce((sum, row) => sum + row.candidateCount, 0);
-          if (candidateCount !== baseRow.count.candidates) {
-            attributionValid = false;
-            return world;
-          }
+          // A World with only plain meshes has no LOD selection row. Keep its
+          // projection-only receipt and allow Worlds with valid LOD rows to
+          // retain same-submit attribution. Unknown selected world keys still
+          // fail closed above.
+          if (selected === undefined || baseRow === undefined) return world;
+          // The projection row is intentionally CPU-scoped and may omit
+          // selector-only candidates that remain in the full GPU plan. The
+          // same-submit GPU row owns the denominator; comparing it to the
+          // projection count would reject a valid receipt (for example 11 GPU
+          // candidates versus 10 CPU-admitted renderables).
           return Object.freeze({
             ...world,
             attribution: Object.freeze({
@@ -1828,7 +1590,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     lastLodOcclusionInspection = inspectLodOcclusion({
       ...inspection,
       count: {
-        ...lastLodOcclusionInspection.count,
+        ...inspection.count,
         candidates: selection.candidateCount,
         visible: selection.visible,
         occluded: selection.occluded,
@@ -1861,6 +1623,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   };
   let lastMeshMaterialBindings: readonly MeshMaterialBindingObservation[] = [];
   let lastMeshMaterialBindingRenderables: readonly RenderableSnapshot[] | undefined;
+  let lastPresentation: FramePresentation = 'pending';
   const createPreparedResolverFactory =
     (
       runtime: RenderSystemInternals,
@@ -2024,6 +1787,17 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           ) {
             return err(new Error('prepared scene-depth pipeline requires a scene target'));
           }
+          // The typed graph composes fullscreen feature bindings from its
+          // current graph views and post-process parameter snapshot at encode
+          // time. Do not manufacture a fallback bind group here: during
+          // registration/recovery its params buffer can still be absent, and
+          // a two-entry fallback cannot satisfy a params-aware layout.
+          if (
+            preparedPipelineIds.has(pipeline as object) &&
+            descriptor.values.fullscreen === true
+          ) {
+            return ok(undefined);
+          }
           if (preparedGroup0Pipelines.has(pipeline as object)) {
             const layout =
               (materialShaderId === undefined
@@ -2161,10 +1935,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     createPreparedResolverCaches,
   });
   return {
-    instances: instanceCollections,
+    setSurfaceDynamicInput(frame: SurfaceDynamicInputFrame | undefined): void {
+      surfaceDynamicInputFrame = frame;
+    },
     initializeSsr: ensureSsrFormatProbe,
     get instanceCollectionsInspection(): readonly InstanceCollectionInspection[] {
-      return instanceCollections._inspections();
+      return instanceCollections._inspections(frameState.frameNumber - 1);
     },
     releaseProfilerCatalog(): void {
       releaseProfilerCatalog?.();
@@ -2177,9 +1953,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       return persistentRenderScene.bounds(world, entity);
     },
     get renderScene(): RenderSceneInspection {
+      const submission = surfaceSubmissionObservation.inspect();
       return {
         ...persistentRenderScene.inspect(),
         gpuDriven: gpuDrivenProduction.inspect(),
+        ...(submission === undefined ? {} : { submission }),
       };
     },
     get gpuDrivenInspection(): GpuDrivenProductionInspection {
@@ -2234,6 +2012,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     get reflectionFallbackCompletion(): Promise<void> | undefined {
       return frameState.reflectionFallbackCompletion;
     },
+    get presentation(): FramePresentation {
+      return lastPresentation;
+    },
     isCubeCapturePending(target: RenderTarget): boolean {
       return cubeCaptureScheduler.inspect(target).candidateGeneration !== undefined;
     },
@@ -2274,24 +2055,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       });
     },
     get motionBlurInspection(): MotionBlurInspection | undefined {
-      const camera = latestCamera;
-      if (camera?.motionBlur === undefined) return undefined;
-      const demanded = camera.motionBlur.shutterAngle > 0;
-      const unavailable = demanded && !internals.device.caps.rgba16floatRenderable;
-      const admitted =
-        frameState.activeTemporalGpuState !== undefined ||
-        frameState.temporalGpuState !== undefined;
-      return {
-        enabled: demanded,
-        status: !demanded ? 'off' : unavailable || !admitted ? 'reset' : 'active',
-        shutterAngle: camera.motionBlur.shutterAngle,
-        maxRadiusPixels: camera.motionBlur.maxRadiusPixels,
-        sampleCount: camera.motionBlur.sampleCount,
-        temporalDemand: demanded ? 'scene-data-temporal-v1' : 'none',
-        passName: 'motion-blur',
-        historyWrites: 0,
-        ...(unavailable ? { lastFailure: 'scene-data-unavailable' as const } : {}),
-      };
+      return projectMotionBlurInspection({
+        camera: latestCamera,
+        invalidParams: lastMotionBlurInvalidParams,
+        capabilities: internals.device.caps,
+        acceptedTemporal: frameState.lastSuccessfulTemporalView,
+        transaction: frameState.temporalFrameTransaction.inspect(),
+        execution: frameState.motionBlurExecution,
+        temporalFrameId: frameState.temporalFrame?.frameId,
+        deviceGeneration: internals.deviceScope.generation,
+        graphGeneration: frameState.graphGeneration,
+      });
+    },
+    get motionBlurInvalidParams(): MotionBlurValidationError | undefined {
+      return lastMotionBlurInvalidParams;
     },
     get depthOfFieldInspection(): DepthOfFieldInspection | undefined {
       const camera = latestCamera;
@@ -2354,22 +2131,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       const lifecycle = resources?.inspectBloomResources?.(
         frameState.compiledFrameGraph?.inspect(),
       );
-      return Object.freeze(
-        lifecycle ?? {
-          graphStatus: 'empty',
-          enabled: false,
-          targetCount: 0,
-          targetBytes: 0,
-          resourceCount: 0,
-          passCount: 0,
-          encodeCount: 0,
-          bindGroupCount: 0,
-          uploadCount: 0,
-          residentChildBytes: 0,
-          generation: 0,
-          state: 'off',
-        },
-      );
+      return Object.freeze(lifecycle ?? emptyBloomInspection());
     },
     get transmission(): TransmissionInspection | undefined {
       return lastTransmissionInspection;
@@ -2444,6 +2206,14 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       const profileSession = internals.profiler?.activeSession();
       let ownsProfileFrame = false;
       let submitted = false;
+      // A failed draw cannot publish a startup completion fact. Reset the
+      // projection before extraction so a later receipt never reuses an old
+      // scene's readiness.
+      lastPresentation = 'pending';
+      // A prior failed record/submit may have staged a temporal capture. A
+      // capture belongs only to the draw call that created it; discard it
+      // before this call can prepare or commit a new candidate.
+      persistentRenderScene.discardTemporalFrame();
       // A failed draw must never leave a previous frame eligible to publish a
       // newly accepted dynamic-geometry candidate.
       dynamicGeometryFrames.begin();
@@ -2475,55 +2245,67 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         dispatchCounts.unlit = 0;
 
         const resourceWorld = compositionWorlds[resourceOwner] as World;
-        const frame = runProfiledRenderPhase(profileSession, 'extract', () => {
-          return persistentRenderScene.extractComposition(
-            compositionWorlds,
-            { cameraOwner, resourceOwner },
-            internals.assets.catalogEpoch,
-            (renderables) =>
-              extractFrames(
-                compositionWorlds,
-                {
-                  cameraOwner,
-                  resourceOwner,
-                  ...(cameraEntityKey === undefined ? {} : { cameraEntityKey }),
-                },
-                internals.assets,
-                internals.getPipelineState(),
-                persistentRenderScene.materialSnapshotCacheStore(),
-                {
-                  ...(internals.device.caps.backendKind === 'null'
-                    ? {}
-                    : {
-                        materialContext: {
-                          backend:
-                            internals.device.caps.backendKind === 'wgpu-webgl2'
-                              ? ('webgl2' as const)
-                              : internals.device.caps.backendKind,
-                          capability: internals.device.caps.storageBuffer
-                            ? ('storage-buffer' as const)
-                            : ('uniform-fallback' as const),
-                          pipeline: 'forward' as const,
-                          geometry: 'mesh' as const,
-                          pass: 'forward' as const,
-                          profile: 'forgeax-material-wgsl-v1' as const,
-                          toolchain: 'naga-oil' as const,
-                          instrumentation: 'none' as const,
-                        },
-                      }),
-                  cull: 'none',
-                  retainHidden: true,
-                  renderables,
-                  instanceCollections,
-                  ...(!internals.device.caps.storageBuffer ||
-                  internals.getMaterialShaderArtifact === undefined
-                    ? {}
-                    : { getMaterialShaderArtifact: internals.getMaterialShaderArtifact }),
-                },
-              ),
-            compositionLeases,
-          );
-        });
+        let frame: ReturnType<PersistentRenderScene['extractComposition']>;
+        try {
+          frame = runProfiledRenderPhase(profileSession, 'extract', () => {
+            return persistentRenderScene.extractComposition(
+              compositionWorlds,
+              { cameraOwner, resourceOwner },
+              internals.assets.catalogEpoch,
+              (renderables) =>
+                extractFrames(
+                  compositionWorlds,
+                  {
+                    cameraOwner,
+                    resourceOwner,
+                    ...(cameraEntityKey === undefined ? {} : { cameraEntityKey }),
+                  },
+                  internals.assets,
+                  internals.getPipelineState(),
+                  persistentRenderScene.materialSnapshotCacheStore(),
+                  {
+                    ...(internals.device.caps.backendKind === 'null'
+                      ? {}
+                      : {
+                          materialContext: {
+                            backend:
+                              internals.device.caps.backendKind === 'wgpu-webgl2'
+                                ? ('webgl2' as const)
+                                : internals.device.caps.backendKind,
+                            capability: internals.device.caps.storageBuffer
+                              ? ('storage-buffer' as const)
+                              : ('uniform-fallback' as const),
+                            pipeline: 'forward' as const,
+                            geometry: 'mesh' as const,
+                            pass: 'forward' as const,
+                            profile: 'forgeax-material-wgsl-v1' as const,
+                            toolchain: 'naga-oil' as const,
+                            instrumentation: 'none' as const,
+                          },
+                        }),
+                    cull: 'none',
+                    retainHidden: true,
+                    renderables,
+                    instanceCollections,
+                    ...(!internals.device.caps.storageBuffer ||
+                    internals.getMaterialShaderArtifact === undefined
+                      ? {}
+                      : { getMaterialShaderArtifact: internals.getMaterialShaderArtifact }),
+                  },
+                ),
+              compositionLeases,
+            );
+          });
+        } catch (cause) {
+          if (cause instanceof MotionBlurValidationError) {
+            lastMotionBlurInvalidParams = cause;
+            latestCamera = undefined;
+            internals.errorRegistry.fire(cause);
+            return false;
+          }
+          throw cause;
+        }
+        lastMotionBlurInvalidParams = undefined;
         const {
           cameras: extractedCameras,
           cubeCameras,
@@ -2531,6 +2313,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           environment,
           environmentReady,
           volumetricFog,
+          cloudLayer,
           renderables,
           dispatch,
           shadowCasterEntityKeys: extractedShadowCasterEntityKeys,
@@ -2759,7 +2542,27 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         );
         const submissionRenderables = visibilityProjection.renderables;
         const submissionDispatch = visibilityProjection.dispatch;
+        const presentationProjection = projectFramePresentation({
+          hasCamera: cameras.length > 0,
+          environmentReady,
+          hasEnvironment: environment !== undefined,
+          submissionRenderables,
+          submissionDispatch,
+          preparedWorlds,
+          internals,
+        });
+        const presentationRenderables = presentationProjection.renderables;
+        let framePresentation = presentationProjection.presentation;
         const inspectionCamera = latestCamera;
+        // The public frame receipt is allocated by WebGPURenderer immediately
+        // before this draw (`observationFrameId`). RenderSystem's private
+        // frameNumber is an internal generation and also advances on failed
+        // record attempts, so it cannot be used as receipt identity. Keep the
+        // internal generation for recovery/visibility state, but bind the LOD
+        // inspection to the frame id that the caller will receive.
+        const lodSubmitFrameId =
+          (internals as RenderSystemInternals & { readonly observationFrameId?: number })
+            .observationFrameId ?? frameState.frameNumber;
         let lodCandidateCountForFrame = 0;
         if (inspectionCamera !== undefined) {
           const firstRenderable = renderables[0];
@@ -2802,7 +2605,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             renderables,
             submissionRenderables,
             inspectionCamera,
-            frameState.frameNumber,
+            lodSubmitFrameId,
             worldKeys,
             slotByEntity,
             {
@@ -2834,7 +2637,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 firstRenderable === undefined
                   ? 'none'
                   : `asset-handle:${firstRenderable.assetHandle}`,
-              sourceKey: `render-frame:${frameState.frameNumber}`,
+              sourceKey: `render-frame:${lodSubmitFrameId}`,
             },
             view: {
               attachmentId:
@@ -2847,7 +2650,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               primitiveSlot: 0,
               slotGeneration: persistentRenderScene.inspect().topology.revision,
             },
-            generation: frameState.frameNumber,
+            generation: lodSubmitFrameId,
             count: {
               candidates: candidateCount,
               visible: inspectionRenderables.length,
@@ -2866,7 +2669,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               visible: true,
             })),
             submit: {
-              frameId: frameState.frameNumber,
+              frameId: lodSubmitFrameId,
               build: resolveInspectionBuild(internals),
               deviceGeneration: internals.deviceScope.generation,
             },
@@ -2878,7 +2681,14 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           lastLodWorldAttachments = new Map();
         }
         const temporalDemanded =
-          cameras[0]?.antialias === 'taa' || (cameras[0]?.motionBlur?.shutterAngle ?? 0) > 0;
+          cameras[0]?.antialias === 'taa' ||
+          (cameras[0]?.motionBlur !== undefined &&
+            motionBlurTemporalDemand({
+              shutterAngle: cameras[0].motionBlur.shutterAngle,
+              maxRadiusPixels: cameras[0].motionBlur.maxRadiusPixels,
+              sampleCount: cameras[0].motionBlur.sampleCount,
+              targetFps: cameras[0].motionBlur.targetFps ?? 60,
+            }));
         if (temporalDemanded) {
           persistentRenderScene.prepareTemporalFrame(submissionRenderables);
         }
@@ -2938,6 +2748,17 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         bindGroupCounts.createBindGroup = 0;
         bindGroupCounts.keys = [];
         const preparedPipelineState = internals.getPipelineState();
+        const featureView = createCloudFeatureView(
+          cameras[0],
+          compositionWorlds,
+          cameraOwner,
+          internals.canvas.width,
+          internals.canvas.height,
+          internals.deviceScope.generation,
+          frameState.lastSuccessfulTemporalView === undefined,
+          lastSubmittedGeneration !== undefined &&
+            lastSubmittedGeneration !== internals.deviceScope.generation,
+        );
         const bindGroupSkipReason: RenderPhaseSkipReason | undefined =
           internals.featureHost === undefined
             ? 'feature-host-unavailable'
@@ -2988,7 +2809,46 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 colorAttachmentFormat: preparedPipelineState.colorAttachmentFormat,
                 storageBuffer: internals.device.caps.storageBuffer,
                 multisample: internals.device.caps.backendKind !== 'wgpu-webgl2',
+                cloudHistory: cloudLayer !== undefined,
               });
+        const motionBlurParams = cameras[0]?.motionBlur;
+        let motionBlurDelta = 0;
+        try {
+          const delta = (compositionWorlds[cameraOwner] as World).getResource(Time).delta;
+          motionBlurDelta = Number.isFinite(delta) ? Math.max(0, delta) : 0;
+        } catch {
+          motionBlurDelta = 0;
+        }
+        const acceptedSampleTime = frameState.lastSuccessfulTemporalView?.sampleTimeSeconds;
+        const cameraViewIdentity = `camera:${cameras[0]?.entityKey ?? 0}`;
+        const canvasWidth = Math.max(1, internals.canvas.width);
+        const canvasHeight = Math.max(1, internals.canvas.height);
+        const motionBlurPlan = planMotionBlurFrame({
+          params: motionBlurParams,
+          sampleTimeSeconds: opts.sampleTimeSeconds,
+          acceptedSampleTimeSeconds: acceptedSampleTime,
+          fallbackDeltaSeconds: motionBlurDelta,
+          acceptedTemporal: frameState.lastSuccessfulTemporalView,
+          temporalReset: opts.temporalReset === true,
+          width: canvasWidth,
+          height: canvasHeight,
+          cameraViewIdentity,
+          historyVersion: cameras[0]?.historyVersion ?? 0,
+          environmentSignature: environment?.environmentSignature ?? '',
+          fogSignature: environment?.fogSignature ?? '',
+          deviceGeneration: internals.deviceScope?.generation ?? 0,
+        });
+        const demandedMotionBlur = motionBlurPlan.demanded;
+        motionBlurFeatureInput = motionBlurPlan.featureInput;
+        if (
+          demandedMotionBlur &&
+          internals.device.caps.compute === true &&
+          internals.device.caps.storageBuffer === true &&
+          internals.device.caps.storageTexture === true &&
+          internals.device.caps.rgba16floatRenderable === true
+        ) {
+          ensureMotionBlurFeature();
+        }
         preparedFeatureSkylightResources =
           preparedPipelineState === null
             ? undefined
@@ -3001,11 +2861,14 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             worlds: compositionWorlds,
             owner: resourceOwner,
             frameNumber: frameState.frameNumber,
+            ...(cameras[0] === undefined ? {} : { selectedCamera: cameras[0] }),
+            frameSize: { width: internals.canvas.width, height: internals.canvas.height },
             visibilitySnapshots: frame.featureVisibilitySnapshots,
             hiddenEntityReports: frame.hiddenEntityReports,
             targets: featureTargets,
             generation: internals.featureHost?.preparedGeneration ?? 0,
             caps: internals.device.caps,
+            frame: createCloudFeatureFrameContext(cloudLayer, featureView),
             ...(internals.getMaterialShaderBindingContract === undefined
               ? {}
               : { materialShaderBindingContract: internals.getMaterialShaderBindingContract }),
@@ -3035,11 +2898,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             gpuWork: featureGpuWork,
           });
           lastVisibilityStats.explicitlyHidden = featureFrame.hiddenEntityReports.length;
-          for (const featureError of featureFrame.errors) {
-            if (!isPendingRenderFeaturePreparation(featureError)) {
-              internals.errorRegistry.fire(featureError);
-            }
-          }
+          reportPendingRenderFeatureErrors(
+            featureFrame.errors,
+            frameState.frameNumber,
+            pendingFeatureErrorLastReportedFrame,
+            internals.errorRegistry,
+          );
           const postProcessParamsCandidate = preparePostProcessParamsResources(
             featureFrame.fullscreenEffects,
           );
@@ -3054,6 +2918,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           featureGraphCandidate = {
             plans: featureFrame.plans,
             fullscreenEffects: featureFrame.fullscreenEffects,
+            postProcessIdentities: featureFrame.postProcessIdentities,
             ...(featureFrame.requiresPreparedResourceKey
               ? { preparedResourceKey: `frame-${frameState.frameNumber}` }
               : {}),
@@ -3172,7 +3037,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 }
                 return runProfiledRenderPhase(profileSession, phase, action);
               };
-        if (cameras[0]?.bloom === 'on') {
+        const bloomAdmitted = standardBloomAdmitted(cameras[0]);
+        if (bloomAdmitted) {
           internals.getPipelineState()?.perPassResources.ensureBloomResources?.();
         }
         const liveOutput = cameras[0]?.output;
@@ -3194,11 +3060,44 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             Number.isFinite(deltaTime) ? Math.max(0, deltaTime) : 0,
           );
         }
+        const surfaceSubmissionCandidate = surfaceSubmissionObservation.begin({
+          frameId:
+            (internals as RenderSystemInternals & { readonly observationFrameId?: number })
+              .observationFrameId ?? frameState.frameNumber,
+          requestedLane: opts.geometryLane === 'direct' ? 'direct' : 'gpu-driven',
+          deviceGeneration: internals.deviceScope.generation,
+          resourceGeneration: gpuDrivenProduction.inspect().resourceGeneration,
+        });
+        frameState.surfaceSubmissionObservation = surfaceSubmissionCandidate;
         const probeCaptureScene =
           shadowCasterProjection !== undefined &&
           reflectionProbeRecord.graph.work.some((work) => work.rawCaptureFace !== undefined)
             ? projectCaptureScene(shadowCasterProjection, submissionRenderables, orderedDispatch)
             : undefined;
+        // This is a transient projection of the record owner's actual visible
+        // draws. It lets the presentation fact distinguish a clear/submit
+        // from a frame where geometry or its pipeline was skipped, without
+        // retaining a second readiness registry or per-asset counter.
+        const presentedRenderableKeys = new Set<number>();
+        const presentedSubmeshKeys = new Set<string>();
+        const consumeDynamicGeometry = dynamicGeometryFrames.onRenderableDraw(compositionWorlds);
+        const markPresentedRenderable = (
+          entry: Parameters<typeof consumeDynamicGeometry>[0],
+          submeshIndex?: number,
+          receipt?: RenderableDrawReceipt,
+        ): void => {
+          const entityKey = worldEntityKey(
+            worldKeys[entry.source.worldId] ?? entry.source.worldId,
+            entry.source.entityKey,
+          );
+          if (receipt?.ready !== false) {
+            presentedRenderableKeys.add(entityKey);
+          }
+          if (submeshIndex !== undefined && receipt?.ready !== false) {
+            presentedSubmeshKeys.add(`${entityKey}:${submeshIndex}`);
+          }
+          consumeDynamicGeometry(entry, receipt?.lane ?? 'cpu');
+        };
         submitted = runProfiledRenderPhase(profileSession, 'record', () =>
           recordFrame(
             internals,
@@ -3226,7 +3125,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               activeEntityKeys: visibilityProjection.activeEntityKeys,
               activeEntityRevision: visibilityProjection.activeEntityRevision,
               telemetryCandidateCount: lodCandidateCountForFrame,
+              telemetrySubmit: {
+                frameId: lodSubmitFrameId,
+                deviceGeneration: internals.deviceScope.generation,
+              },
               ...(occlusionProjection === undefined ? {} : { occlusion: occlusionProjection }),
+              frameTime: (() => {
+                const elapsed = (compositionWorlds[cameraOwner] as World).getResource(Time).elapsed;
+                return Number.isFinite(elapsed) ? elapsed : 0;
+              })(),
+              deviceGeneration: internals.deviceScope.generation,
+              ...(surfaceDynamicInputFrame === undefined
+                ? {}
+                : { surfaceDynamicInput: surfaceDynamicInputFrame }),
+              ...(opts.geometryLane === undefined ? {} : { geometryLane: opts.geometryLane }),
             },
             compositionLeases,
             featureGraphCandidate,
@@ -3253,10 +3165,16 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             worldKeys,
             undefined,
             ssrDependencies,
-            dynamicGeometryFrames.onRenderableDraw(compositionWorlds),
+            markPresentedRenderable,
+            environment?.fog,
+            opts.sampleTimeSeconds,
+            opts.temporalReset === true,
+            frame.cloudLayer,
           ),
         );
         dynamicGeometryFrames.commit(submitted);
+        if (!submitted) surfaceSubmissionCandidate.abort();
+        frameState.surfaceSubmissionObservation = undefined;
         if (!submitted) discardLiveFeatureState();
         if (submitted && lastLodOcclusionInspection !== undefined) {
           const query = ensureOcclusionRuntime().inspect();
@@ -3280,6 +3198,111 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           (frameState.currentDirectionalShadowView !== null &&
             (lights.lightViewProj?.length ?? 0) > 0 &&
             (internals.getPipelineState()?.perPassResources.shadowMapSize ?? 0) > 0);
+
+        // A successful queue submit is necessary but not sufficient for the
+        // startup presentation fact. Reuse the same visible snapshots and
+        // producer-owned GPU stores consumed by record so missing geometry,
+        // material bindings, dynamic video frames, or requested shadow work
+        // cannot dismiss the loading screen behind a clear/fallback pass.
+        if (submitted && framePresentation === 'ready' && cameras.length > 0) {
+          const pipelineState = internals.getPipelineState();
+          const visibleRenderableKeys = new Set(
+            presentationRenderables.map((renderable) =>
+              worldEntityKey(
+                worldKeys[renderable.worldId] ?? renderable.worldId,
+                renderable.entityKey,
+              ),
+            ),
+          );
+          if (
+            pipelineState === null ||
+            frameState.compiledFrameGraph === null ||
+            [...visibleRenderableKeys].some((key) => !presentedRenderableKeys.has(key))
+          ) {
+            framePresentation = 'pending';
+          }
+          for (const renderable of presentationRenderables) {
+            if (framePresentation === 'pending') break;
+            const renderableWorld = preparedWorlds[renderable.worldId];
+            const meshHandles =
+              renderableWorld === undefined
+                ? undefined
+                : (internals.gpuStore.getMeshGpuHandles(
+                    toShared<'MeshAsset'>(renderable.assetHandle),
+                    renderableWorld,
+                  ) ?? pipelineState?.meshes.get(renderable.assetHandle));
+            if (meshHandles === undefined) {
+              framePresentation = 'pending';
+              break;
+            }
+            const entityKey = worldEntityKey(
+              worldKeys[renderable.worldId] ?? renderable.worldId,
+              renderable.entityKey,
+            );
+            const gpuClaimedSubmeshes = new Set<number>();
+            for (const [compactIndex, draw] of (renderable.gpuDrivenDraws ?? []).entries()) {
+              const submeshIndex = draw.drawItemIndex ?? compactIndex;
+              if (presentedSubmeshKeys.has(`${entityKey}:${submeshIndex}`)) {
+                gpuClaimedSubmeshes.add(submeshIndex);
+              }
+            }
+            if (renderable.pointsLines === undefined) {
+              for (const [submeshIndex] of meshHandles.submeshes.entries()) {
+                if (gpuClaimedSubmeshes.has(submeshIndex)) continue;
+                if (!presentedSubmeshKeys.has(`${entityKey}:${submeshIndex}`)) {
+                  framePresentation = 'pending';
+                  break;
+                }
+              }
+            }
+            if (framePresentation === 'pending') break;
+            for (const material of renderable.materials) {
+              const residency = observeMaterialResidency(renderableWorld, material, internals);
+              if (residency.readiness === 'pending' || residency.readiness === 'failed') {
+                framePresentation = 'pending';
+                break;
+              }
+              for (const clip of material.videoTextureFields?.values() ?? []) {
+                if (internals.dynamicTextureStore?.getView(clip) === undefined) {
+                  framePresentation = 'pending';
+                  break;
+                }
+              }
+              if (framePresentation === 'pending') break;
+            }
+            if (framePresentation === 'pending') break;
+          }
+          if (
+            framePresentation === 'ready' &&
+            directionalQuality !== undefined &&
+            (!directionalShadowReady ||
+              (shadowCasterDrawKeys.size > 0 &&
+                !frameState.directionalShadowCacheRecorded &&
+                frameState.directionalShadowCache === null))
+          ) {
+            framePresentation = 'pending';
+          }
+          if (
+            framePresentation === 'ready' &&
+            lights.pointShadow.some(
+              (shadow) =>
+                shadow.shadowAtlasLayer >= 0 &&
+                (shadow.shadowMatrices.length < 96 ||
+                  [...shadow.shadowMatrices].some((value) => !Number.isFinite(value))),
+            )
+          ) {
+            framePresentation = 'pending';
+          }
+          if (
+            framePresentation === 'ready' &&
+            lights.spot.some(
+              (spot) =>
+                spot.castShadow && (spot.lightViewProj === undefined || spot.shadowAtlasTile < 0),
+            )
+          ) {
+            framePresentation = 'pending';
+          }
+        }
         if (submitted && directionalShadowReady) {
           lastDirectionalShadowCandidate = 'accepted';
         } else if (directionalQuality !== undefined) {
@@ -3297,6 +3320,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           };
         }
         if (submitted) {
+          lastPresentation = framePresentation;
           recoveryOwner.setLastSuccessfulFrameSeed({
             frame,
             worlds: compositionWorlds,
@@ -3304,6 +3328,19 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             resourceOwner: composition.owners.resourceOwner,
             width: Math.max(1, internals.canvas.width),
             height: Math.max(1, internals.canvas.height),
+            frameTime: (() => {
+              const elapsed = (compositionWorlds[cameraOwner] as World).getResource(Time).elapsed;
+              return Number.isFinite(elapsed) ? elapsed : 0;
+            })(),
+            ...(surfaceDynamicInputFrame === undefined
+              ? {}
+              : { surfaceDynamicInput: surfaceDynamicInputFrame }),
+            ...(frameState.recoveryMaterialArtifacts === undefined
+              ? {}
+              : { materialArtifacts: frameState.recoveryMaterialArtifacts }),
+            ...(frameState.recoveryShadowMaterialArtifacts === undefined
+              ? {}
+              : { shadowMaterialArtifacts: frameState.recoveryShadowMaterialArtifacts }),
           });
           submittedFrameCount += 1;
           lastSubmittedGeneration = internals.deviceScope?.generation;
@@ -3317,13 +3354,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             internals.errorRegistry.fire(temporalCommit.error);
           }
           frameState.lastSuccessfulCameraAntialias = cameras[0]?.antialias;
-          const submittedCamera = cameras[0];
           const submittedDepthOfField =
-            submittedCamera === undefined
+            cameras[0] === undefined
               ? undefined
               : resolveDepthOfFieldFrameParams(
-                  submittedCamera.depthOfField,
-                  submittedCamera.depthOfFieldError,
+                  cameras[0].depthOfField,
+                  cameras[0].depthOfFieldError,
                   frameState.depthOfFieldAccepted?.params,
                 );
           const submittedDepthOfFieldGraph = frameState.compiledFrameGraph?.inspect();
@@ -3341,7 +3377,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             frameState.depthOfFieldLastSubmitFailed = true;
           }
           internals.getPipelineState()?.perPassResources.commitBloomResources?.();
-          const nextBloom = cameras[0]?.bloom ?? 'off';
+          const nextBloom = bloomAdmitted ? 'on' : 'off';
           if (frameState.lastSuccessfulBloom === 'on' && nextBloom !== 'on') {
             internals
               .getPipelineState()
@@ -3406,6 +3442,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           }),
         );
       } finally {
+        if (!submitted) persistentRenderScene.discardTemporalFrame();
         internals.recoveryColdWorkGuard?.endFrame();
         if (ownsProfileFrame) {
           try {
@@ -3419,18 +3456,67 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     },
     isDynamicGeometryConsumed: (world, entity, meshHandle) =>
       dynamicGeometryFrames.isConsumed(world, entity, meshHandle),
+    dynamicGeometryRecordStageLane: (world, entity, meshHandle) =>
+      dynamicGeometryFrames.recordStageLane(world, entity, meshHandle),
     pipelineDispatchCounts: dispatchCounts,
     observeCurrentFrame(options: FrameObservationOptions) {
       const currentFrameId = frameState.frameNumber - 1;
       return observeCurrentFrame(options, frameState.currentFrameObservationSource, currentFrameId);
     },
-    async observeLodOcclusion(): Promise<void> {
+    async observeLodOcclusion(receipt?: {
+      readonly frameId: number;
+      readonly deviceGeneration: number;
+    }): Promise<void> {
+      const capturedInspection = lastLodOcclusionInspection;
+      const capturedWorldAttachments = lastLodWorldAttachments;
+      if (capturedInspection === undefined) return;
+      if (
+        receipt !== undefined &&
+        (capturedInspection.submit.frameId !== receipt.frameId ||
+          capturedInspection.submit.deviceGeneration !== receipt.deviceGeneration)
+      )
+        return;
       await ensureOcclusionRuntime().waitForCompletions();
-      applyLodSelectionTelemetry(await gpuDrivenProduction.readLodSelection());
-      if (lastLodOcclusionInspection !== undefined) {
+      if (lastLodOcclusionInspection !== capturedInspection) return;
+      const selection = await gpuDrivenProduction.readLodSelection();
+      if (lastLodOcclusionInspection !== capturedInspection || selection === undefined) return;
+      if (
+        selection.submit !== undefined &&
+        (selection.submit.frameId !== capturedInspection.submit.frameId ||
+          selection.submit.deviceGeneration !== capturedInspection.submit.deviceGeneration)
+      )
+        return;
+      if (
+        receipt !== undefined &&
+        (selection.submit === undefined ||
+          selection.submit.frameId !== receipt.frameId ||
+          selection.submit.deviceGeneration !== receipt.deviceGeneration)
+      )
+        return;
+      applyLodSelectionTelemetry(selection, capturedInspection, capturedWorldAttachments);
+      if (
+        selection.surfaceReadback !== undefined &&
+        selection.surfaceActualMemberIds !== undefined &&
+        selection.surfaceIndirectParameters !== undefined
+      ) {
+        surfaceSubmissionObservation.publishGpuMembers(
+          {
+            recording: selection.surfaceReadback,
+            memberIds: selection.surfaceActualMemberIds,
+            indirectParameters: selection.surfaceIndirectParameters,
+          },
+          receipt ?? capturedInspection.submit,
+        );
+      }
+      const published = lastLodOcclusionInspection;
+      if (
+        published !== undefined &&
+        published.submit.frameId === capturedInspection.submit.frameId &&
+        published.submit.deviceGeneration === capturedInspection.submit.deviceGeneration
+      ) {
         const queryLatency = ensureOcclusionRuntime().inspectQueryLatency();
         lastLodOcclusionInspection = inspectLodOcclusion({
-          ...lastLodOcclusionInspection,
+          ...published,
           queryLatencyUs: {
             median: queryLatency.median,
             p95: queryLatency.p95,
@@ -3486,9 +3572,18 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     get lastSuccessfulCameraAntialias(): CameraSnapshot['antialias'] | undefined {
       return frameState.lastSuccessfulCameraAntialias;
     },
+    get lastSuccessfulBarrelDistortion(): BarrelDistortionMapping | undefined {
+      return frameState.lastSuccessfulBarrelDistortion;
+    },
+    get barrelDistortionInspection(): BarrelDistortionInspection {
+      return inspectBarrelDistortionState(frameState, internals.deviceScope?.generation ?? 0);
+    },
     get perFrameGraphInfo(): CompiledRenderGraphInfo | undefined {
       return frameState.compiledFrameGraph?.inspect();
     },
+    get renderGraphGenerationAllocation() {
+      return inspectRenderGraphGenerationAllocation(frameState);
+    },
     get featureGraphInspection(): import('./inspection-types').RenderFeatureGraphInspection {
       return getRenderFeatureGraphInspection(internals);
     },
@@ -3515,7 +3610,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       });
     },
     get volumetricFog(): import('./volume/inspection').VolumetricFogInspection {
-      return frameState.volumetricFogInspection;
+      const accepted = frameState.volumetricFogAccepted;
+      return {
+        ...frameState.volumetricFogInspection,
+        ownerCount: accepted === undefined ? 0 : 1 + (accepted.additional?.length ?? 0),
+      };
     },
     configureStandard(config: RenderPipelineAsset['config']): void {
       const profileConfig = internals.standardProfile;
@@ -3594,7 +3693,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         }
         builtinPostProcessEntries.set(id, entry);
         if (paramsBuffer !== undefined) postProcessParamsBuffers.set(id, paramsBuffer);
-        const moduleLabel = postProcessShaderModuleLabel(id, entry.source);
+        const moduleLabel = postProcessShaderModuleLabel(entry.source);
         return () => {
           if (builtinPostProcessEntries.get(id) === entry) {
             builtinPostProcessEntries.delete(id);
@@ -3643,6 +3742,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       internals.getPipelineState()?.perPassResources.drainBloomResources?.();
       internals.clearPostProcessPipelineCache?.('forgeax.taa-resolve');
       invalidatePostProcessModule('forgeax.taa-resolve');
+      // Post-process parameter UBOs are renderer-owned persistent resources,
+      // rather than graph-owned transient state. Clear the active table before
+      // the feature host is retired so the renderer remains the sole owner.
+      disposeActivePostProcessResources();
+      resetSsaoResources(internals);
       resetHdrpBuffers(internals);
       // Retire graph-owned resources and dispose instance-buffer caches.
       // Both calls are idempotent + tolerate per-handle errors silently;
@@ -3654,6 +3758,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       frameState.directionalShadowCacheRecorded = false;
       frameState.currentFrameObservationSource = undefined;
       frameState.lastSuccessfulCameraAntialias = undefined;
+      frameState.lastSuccessfulBarrelDistortion = undefined;
+      frameState.cloudHistoryActive = false;
+      delete frameState.pendingCloudHistoryActive;
       frameState.currentDirectionalShadowView = null;
       frameState.currentSpotShadowView = null;
       if (frameState.pendingAutoExposureGpuResources !== undefined) {
@@ -3681,6 +3788,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         retireTemporalGpuState(retiring);
       }
       frameState.retiringTemporalGpuStates.clear();
+      settleBarrelDistortionGraphCandidate(frameState, false);
       settleVolumetricFogGraphCandidate(frameState, false);
       for (const buffer of frameState.volumetricFogParamsBuffers) {
         if (buffer === null) continue;
@@ -3714,9 +3822,10 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       frameState.depthOfFieldCandidateGraph = null;
       frameState.depthOfFieldAccepted = undefined;
       frameState.depthOfFieldLastSubmitFailed = false;
-      if (compiled !== null) compiled.retire().catch(() => undefined);
+      resetBarrelDistortionGraphState(frameState);
+      if (compiled !== null) retireCompiledGraph(frameState, compiled);
       for (const retired of frameState.retiredCompiledFrameGraphs) {
-        retired.retire().catch(() => undefined);
+        retireCompiledGraph(frameState, retired);
       }
       frameState.retiredCompiledFrameGraphs.clear();
       // feat-20260619 M4 (D-6): pass errorRegistry to disposeInstanceBuffers
@@ -3736,6 +3845,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       }
       frameState.probeBlendRecordBufferCapacity = 0;
       frameState.probeBlendBuffers.clear();
+      delete frameState.probeBlendRecordProjection;
       if (frameState.morphBuffers !== undefined) {
         for (const entry of frameState.morphBuffers.values()) {
           if (!entry.buffer.isDestroyed) {
@@ -3774,6 +3884,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // device.  Drop the shared Standard Cluster bundle before the next
       // frame asks for a new generation; resetHdrpBuffers fences the bundle
       // using its own device/queue instead of the replacement runtime device.
+      resetSsaoResources(internals);
       resetHdrpBuffers(internals);
       // Keep the persistent material demand observable across device loss.
       // The physical resource has already been fenced by markDeviceLost(); the
@@ -3814,9 +3925,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // must be discarded, not merely marked for destruction: their opaque
       // handles cannot be used on the fresh device and the next draw must
       // lazily build a new graph from the preserved ECS / asset POD caches.
+      settleBarrelDistortionGraphCandidate(frameState, false);
       settleVolumetricFogGraphCandidate(frameState, false);
       settleDepthOfFieldGraphCandidate(frameState, false);
-      frameState.compiledFrameGraph?.retire().catch(() => undefined);
+      if (frameState.compiledFrameGraph !== null) {
+        retireCompiledGraph(frameState, frameState.compiledFrameGraph);
+      }
       frameState.compiledFrameGraph = null;
       frameState.compiledFrameGraphTopologyKey = null;
       frameState.volumetricFogPreviousGraph = null;
@@ -3828,6 +3942,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       frameState.depthOfFieldPreviousGraphGeneration = 0;
       frameState.depthOfFieldPreviousStandardLightingGraphSignature = '';
       frameState.depthOfFieldCandidateGraph = null;
+      resetBarrelDistortionGraphState(frameState);
       frameState.volumetricFogAccepted = undefined;
       frameState.volumetricFogAcceptedContext = undefined;
       frameState.volumetricFogHistoryGraph = null;
@@ -3854,6 +3969,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       frameState.directionalShadowCacheRecorded = false;
       frameState.currentFrameObservationSource = undefined;
       frameState.lastSuccessfulCameraAntialias = undefined;
+      frameState.lastSuccessfulBarrelDistortion = undefined;
+      frameState.cloudHistoryActive = false;
+      delete frameState.pendingCloudHistoryActive;
       frameState.temporalFrameTransaction.reset('device-recovery');
       frameState.temporalFrame = undefined;
       frameState.temporalFrameInput = undefined;
@@ -3876,7 +3994,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       frameState.retiringTemporalGpuStates.clear();
       frameState.hdrpClusterMembership = null;
       for (const retired of frameState.retiredCompiledFrameGraphs) {
-        retired.retire().catch(() => undefined);
+        retireCompiledGraph(frameState, retired);
       }
       frameState.retiredCompiledFrameGraphs.clear();
       frameState.instanceBuffers.clear();
@@ -3885,6 +4003,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       delete frameState.probeBlendRecordBuffer;
       frameState.probeBlendRecordBufferCapacity = 0;
       frameState.probeBlendBuffers.clear();
+      delete frameState.probeBlendRecordProjection;
       frameState.morphBuffers?.clear();
       frameState.transientInstanceBuffers = [];
       frameState.pointShadowAtlas = null;