@forgeax/engine-render 0.1.33 → 0.1.35

package/src/render-system.ts

@@ -1,38 +1,23 @@
 import { projectCaptureScene } from './capture/scene-projection';
+import { renderMaterialContext } from './extract/material-context';
+import { RenderPublicationError } from './publication/contract';
+import { preparePublicationGeometry } from './publication/prepare-geometry';
+import type { PreparedRenderPublication } from './publication/receiver';
+import { type RenderResourceScope, renderTime } from './publication/resource-scope';
 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 { Time, type World } from '@forgeax/engine-ecs';
+import { numMipLevels } from '@forgeax/engine-assets-runtime';
+import 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 Handle, type RenderPipelineAsset, toShared } from '@forgeax/engine-types';
 import {
   type DirectionalShadowInspectionSource,
   directionalShadowProfileFromQuality,
@@ -40,7 +25,9 @@ import {
 } 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,
@@ -49,6 +36,7 @@ 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,
@@ -83,6 +71,7 @@ import {
   postProcessShaderPipelineLabel,
 } from './fullscreen-post-process-pass';
 import type {
+  BarrelDistortionInspection,
   BloomInspection,
   DepthOfFieldInspection,
   DirectionalShadowInspection,
@@ -125,11 +114,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';
 
@@ -169,9 +154,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';
@@ -181,11 +167,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';
@@ -198,6 +182,10 @@ import {
   createPreparedGraphicsResolver,
   type PreparedGraphicsResolver,
 } from './prepare/prepared-graphics-resolver';
+import {
+  inspectBarrelDistortionState,
+  resetBarrelDistortionGraphState,
+} from './record/barrel-distortion-frame';
 import {
   type CubeCaptureFrameInput,
   type FrameObservation,
@@ -213,6 +201,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,
@@ -230,34 +219,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,
@@ -266,6 +260,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';
@@ -283,73 +279,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;
@@ -386,102 +315,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
@@ -520,6 +358,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. */
@@ -528,6 +368,7 @@ export interface RenderSystem {
     opts: DrawOwnerOptions,
     renderReadLeases?: readonly RenderReadLease[],
     timingCapture?: GpuTimingCapture,
+    publication?: PreparedRenderPublication,
   ): boolean;
   /**
    * Return the asset binding consumed by the last successful record pass.
@@ -535,6 +376,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(
@@ -568,8 +414,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[];
   /**
@@ -588,6 +432,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;
@@ -630,8 +476,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. */
@@ -751,149 +603,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',
@@ -901,7 +610,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   );
   let releaseProfilerCatalog =
     phaseCatalogRegistration?.ok === true ? phaseCatalogRegistration.value : undefined;
-  let preparedWorlds: readonly World[] = [];
+  let preparedWorlds: readonly RenderResourceScope[] = [];
   const resolveFeatureNoise = createFeatureNoiseResolver({
     scope: internals.deviceScope,
     getDevice: () => internals.device,
@@ -909,6 +618,7 @@ 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;
@@ -929,7 +639,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     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,
@@ -957,7 +667,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,
@@ -1105,6 +815,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,
@@ -1176,6 +889,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,
@@ -1203,6 +917,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,
@@ -1221,6 +942,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     currentFrameObservationSource: undefined,
     reflectionFallbackObservationSource: undefined,
     lastSuccessfulCameraAntialias: undefined,
+    lastSuccessfulBarrelDistortion: undefined,
+    barrelDistortionGraphResolution: 'accepted',
     temporalGpuState: undefined,
     autoExposureGpuResources: undefined,
     pendingAutoExposureGpuResources: undefined,
@@ -1326,7 +1049,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   // 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, number>();
+  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.
@@ -1532,7 +1255,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
@@ -1622,6 +1345,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> => {
@@ -1775,7 +1503,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   let orderedDispatchCache:
     | {
         readonly source: readonly DispatchEntry[];
-        readonly world: World;
+        readonly world: RenderResourceScope;
         readonly camera: readonly CameraSnapshot[];
         readonly renderables: readonly RenderableSnapshot[];
         readonly value: readonly DispatchEntry[];
@@ -1901,11 +1629,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   };
   let lastMeshMaterialBindings: readonly MeshMaterialBindingObservation[] = [];
   let lastMeshMaterialBindingRenderables: readonly RenderableSnapshot[] | undefined;
+  let lastPresentation: FramePresentation = 'pending';
   const createPreparedResolverFactory =
     (
       runtime: RenderSystemInternals,
       gpuWork: RenderFeatureGpuWorkOwner,
-      worlds: readonly World[],
+      worlds: readonly RenderResourceScope[],
       caches: PreparedResolverCaches,
     ) =>
     (input: RenderFeaturePreparedGraphicsResolverInput): PreparedGraphicsResolver => {
@@ -2064,6 +1793,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
@@ -2201,10 +1941,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?.();
@@ -2217,9 +1959,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 {
@@ -2274,6 +2018,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;
     },
@@ -2457,14 +2204,21 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       opts: DrawOwnerOptions,
       renderReadLeases?: readonly RenderReadLease[],
       timingCapture?: GpuTimingCapture,
+      publication?: PreparedRenderPublication,
     ): boolean {
       const composition = canonicalizeWorldComposition(worlds, opts, renderReadLeases);
-      const compositionWorlds = composition.worlds;
+      const sourceWorlds = composition.worlds;
+      const compositionWorlds: readonly RenderResourceScope[] =
+        publication === undefined ? sourceWorlds : [publication.resources];
       const compositionLeases = composition.leases;
       preparedWorlds = compositionWorlds;
       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.
@@ -2495,21 +2249,45 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           // so a hot-swap cannot reuse passes compiled for the retired pipeline.
           resetRenderFeatureGraphState(internals);
           lastBuiltPipelineHandle = frameState.installedPipelineHandle;
-          persistentRenderScene.invalidate();
+          if (publication === undefined) persistentRenderScene.invalidate();
         }
         dispatchCounts.unlit = 0;
 
-        const resourceWorld = compositionWorlds[resourceOwner] as World;
+        const resourceWorld = compositionWorlds[resourceOwner] as RenderResourceScope;
         let frame: ReturnType<PersistentRenderScene['extractComposition']>;
         try {
           frame = runProfiledRenderPhase(profileSession, 'extract', () => {
+            if (publication !== undefined) {
+              for (const handle of [
+                ...publication.packet.invalidatedAssets,
+                ...publication.packet.retiredAssets,
+              ]) {
+                internals.gpuStore.invalidateMesh(handle, publication.resources);
+                internals.gpuStore.evictTexture(
+                  handle as Handle<'TextureAsset', 'shared'>,
+                  publication.resources,
+                );
+              }
+              return persistentRenderScene.consumePublication(
+                preparePublicationGeometry(
+                  publication,
+                  persistentRenderScene,
+                  internals.getPipelineState()?.skinPaletteAllocator,
+                  internals.assets,
+                  instanceCollections,
+                  internals.device.caps.storageBuffer
+                    ? internals.getMaterialShaderArtifact
+                    : undefined,
+                ),
+              );
+            }
             return persistentRenderScene.extractComposition(
-              compositionWorlds,
+              sourceWorlds,
               { cameraOwner, resourceOwner },
               internals.assets.catalogEpoch,
               (renderables) =>
                 extractFrames(
-                  compositionWorlds,
+                  sourceWorlds,
                   {
                     cameraOwner,
                     resourceOwner,
@@ -2519,25 +2297,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                   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,
-                          },
-                        }),
+                    ...renderMaterialContext(internals.device.caps),
                     cull: 'none',
                     retainHidden: true,
                     renderables,
@@ -2563,11 +2323,13 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         lastMotionBlurInvalidParams = undefined;
         const {
           cameras: extractedCameras,
+          auxiliaryCameras,
           cubeCameras,
           lights,
           environment,
           environmentReady,
           volumetricFog,
+          cloudLayer,
           renderables,
           dispatch,
           shadowCasterEntityKeys: extractedShadowCasterEntityKeys,
@@ -2587,7 +2349,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           frameState,
           internals,
           cameras[0],
-          compositionWorlds[cameraOwner] as World,
+          compositionWorlds[cameraOwner] as RenderResourceScope,
         );
         if (!preparedOutput.ok) {
           internals.errorRegistry.fire(preparedOutput.error);
@@ -2796,6 +2558,17 @@ 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
@@ -2991,6 +2764,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'
@@ -3041,11 +2825,12 @@ 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;
+          const delta = renderTime(compositionWorlds[cameraOwner] as RenderResourceScope).delta;
           motionBlurDelta = Number.isFinite(delta) ? Math.max(0, delta) : 0;
         } catch {
           motionBlurDelta = 0;
@@ -3087,17 +2872,39 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 .skylightResources;
         let featureGraphCandidate: RenderFeatureGraphCandidate | undefined;
         const preparedResourceBatches = runProfiledRenderPhase(profileSession, 'features', () => {
+          if (
+            publication?.packet.features.some(
+              (row) =>
+                !internals.featureHost?.features.some(
+                  (feature) => feature.identity === row.identity,
+                ),
+            )
+          )
+            throw new RenderPublicationError({
+              reason: 'shape',
+              subject: 'published feature has no receiver implementation',
+            });
           if (internals.featureHost === undefined) return [];
           const featureFrame = runRenderFeatureFrame(internals.featureHost, {
-            worlds: compositionWorlds,
+            worlds: sourceWorlds,
+            ...(publication === undefined
+              ? {}
+              : {
+                  publishedFeatures: publication.packet.features,
+                  ...(publication.onFeatureSourceSubmitted === undefined
+                    ? {}
+                    : { onFeatureSourceSubmitted: publication.onFeatureSourceSubmitted }),
+                }),
             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 }),
@@ -3147,6 +2954,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           featureGraphCandidate = {
             plans: featureFrame.plans,
             fullscreenEffects: featureFrame.fullscreenEffects,
+            postProcessIdentities: featureFrame.postProcessIdentities,
             ...(featureFrame.requiresPreparedResourceKey
               ? { preparedResourceKey: `frame-${frameState.frameNumber}` }
               : {}),
@@ -3281,18 +3089,50 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           frameState.standardLutState.resident !== null ||
           frameState.pendingStandardLutState !== undefined;
         if (hasLiveFeatureState) {
-          const cameraWorld = compositionWorlds[cameraOwner] as World;
-          const deltaTime = cameraWorld.getResource(Time).delta;
+          const cameraWorld = compositionWorlds[cameraOwner] as RenderResourceScope;
+          const deltaTime = renderTime(cameraWorld).delta;
           stageLiveFeatureState(
             cameras[0],
             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)
+          (auxiliaryCameras.length > 0 ||
+            cubeCameras.length > 0 ||
+            reflectionProbeRecord.graph.work.some((work) => work.rawCaptureFace !== undefined))
             ? projectCaptureScene(shadowCasterProjection, submissionRenderables, orderedDispatch)
             : undefined;
+        // Track actual draws so a clear/submit cannot claim visible geometry was presented.
+        const presentedRenderableKeys = new Set<number>();
+        const presentedSubmeshKeys = new Set<string>();
+        const consumeDynamicGeometry = dynamicGeometryFrames.onRenderableDraw(sourceWorlds);
+        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,
@@ -3325,12 +3165,24 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 deviceGeneration: internals.deviceScope.generation,
               },
               ...(occlusionProjection === undefined ? {} : { occlusion: occlusionProjection }),
+              frameTime: (() => {
+                const elapsed = renderTime(
+                  compositionWorlds[cameraOwner] as RenderResourceScope,
+                ).elapsed;
+                return Number.isFinite(elapsed) ? elapsed : 0;
+              })(),
+              deviceGeneration: internals.deviceScope.generation,
+              ...(surfaceDynamicInputFrame === undefined
+                ? {}
+                : { surfaceDynamicInput: surfaceDynamicInputFrame }),
+              ...(opts.geometryLane === undefined ? {} : { geometryLane: opts.geometryLane }),
             },
             compositionLeases,
             featureGraphCandidate,
             pointsLinesOwner,
             {
               snapshots: cubeCameras,
+              auxiliaryCameras,
               scheduler: cubeCaptureScheduler,
               state: cubeCaptureState,
               reflectionProbes: reflectionProbeRecord,
@@ -3351,13 +3203,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();
@@ -3381,6 +3236,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) {
@@ -3398,6 +3358,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           };
         }
         if (submitted) {
+          lastPresentation = framePresentation;
           recoveryOwner.setLastSuccessfulFrameSeed({
             frame,
             worlds: compositionWorlds,
@@ -3405,6 +3366,21 @@ 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 = renderTime(
+                compositionWorlds[cameraOwner] as RenderResourceScope,
+              ).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;
@@ -3418,13 +3394,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();
@@ -3521,6 +3496,8 @@ 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;
@@ -3557,6 +3534,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       )
         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 &&
@@ -3621,9 +3612,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);
     },
@@ -3650,7 +3650,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;
@@ -3729,7 +3733,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);
@@ -3778,6 +3782,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;
@@ -3789,6 +3798,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) {
@@ -3816,6 +3828,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;
@@ -3849,9 +3862,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
@@ -3871,6 +3885,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) {
@@ -3909,6 +3924,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
@@ -3949,9 +3965,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;
@@ -3963,6 +3982,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;
@@ -3989,6 +4009,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;
@@ -4011,7 +4034,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();
@@ -4020,6 +4043,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;
@@ -4070,14 +4094,3 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
 export function resolveInspectionBuild(internals: Pick<RenderSystemInternals, 'build'>): string {
   return internals.build ?? 'render-system';
 }
-
-// @forgeax/engine-render - built-in record context extension.
-//
-// The public RenderPipelineContext is canonical in render-contract.ts. This
-// owner adds only concrete assembly state for built-in record closures.
-
-/**
- * Package-private extension consumed by the built-in record closures only.
- * Custom pipeline authors see the leaf RenderPipelineContext contract and
- * never this surface.
- */