@forgeax/engine-render 0.1.28 → 0.1.29

package/src/record/frame.ts

@@ -5,7 +5,8 @@ import { uploadMaterialUniforms } from './material-uniforms';
 import { HANDLE_NINESLICE_QUAD, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import type { World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
-import { mat4, vec3 } from '@forgeax/engine-math';
+import { deriveVertexCount } from '@forgeax/engine-geometry';
+import { frustum, mat4, vec3 } from '@forgeax/engine-math';
 import {
   type CurrentFrameObservationLease,
   createCurrentFrameObservationLease,
@@ -21,7 +22,7 @@ import {
   type TextureView,
 } from '@forgeax/engine-rhi';
 import type { MaterialRenderState, MeshAsset } from '@forgeax/engine-types';
-import { handleSlot, toShared } from '@forgeax/engine-types';
+import { BUILTIN_BASE, handleSlot, toShared } from '@forgeax/engine-types';
 import { CUBE_CAMERA_FACE_ORDER } from '../components/cube-camera';
 import type { DirectionalShadowQuality } from '../components/directional-shadow-filter';
 import type { MeshGpuHandles } from '../device/gpu-residency';
@@ -30,7 +31,9 @@ import {
   type ObservationUnavailableReason,
   RendererOperationError,
 } from '../errors/render';
+import { gpuDrivenDrawKey, gpuDrivenSourceDrawItemIndex } from '../extract/gpu-driven';
 import type { GpuDrivenProduction, PreparedGpuDrivenFrame } from '../gpu-driven/production-raster';
+import type { ShadowViewIdentity } from '../gpu-driven/shadow-views';
 import { GpuBuffer } from '../gpu-resource';
 import { GPU_TEXTURE_USAGE_COPY_SRC } from '../gpu-texture-usage';
 import {
@@ -56,12 +59,22 @@ import type {
   ExtractedVolumetricFog,
   MaterialSnapshot,
   RenderableSnapshot,
+  ShadowCasterMembership,
   SkyboxSnapshot,
   SkylightSnapshot,
 } from '../render-system-extract';
-import type { PersistentGpuDrivenState } from '../scene/render-scene';
+import type {
+  PersistentGpuDrivenState,
+  PersistentShadowCasterProjection,
+} from '../scene/render-scene';
 import type { OcclusionFrameProjection } from '../scene/visibility/occlusion-runtime';
 import { SHADOW_ATLAS_DEFAULT_LAYERS } from '../shadow-atlas';
+import {
+  admitSsrSpatial,
+  type SsrDependenciesInspection,
+  type SsrSpatialAdmission,
+} from '../ssr/admission';
+import { createSsrHistoryOwner } from '../ssr/history';
 import {
   getTransparentSortConfig,
   TRANSPARENT_SORT_MODE_LAYER_Y,
@@ -123,6 +136,66 @@ export type FrameObservationReadback = (
   lease: CurrentFrameObservationLease,
 ) => Promise<Result<Uint8Array, Error>>;
 
+/**
+ * Fold World identity into the renderer-owned validation token. The GPU
+ * production owner receives only this opaque key; ECS identity and ordering
+ * stay in the record owner where the World list is authoritative.
+ */
+function residencyValidationCacheKey(world: World, worlds: readonly World[]): string {
+  return [world.identity, ...worlds.map((candidate) => candidate.identity)].join('\u001f');
+}
+
+function renderableIdentity(snapshot: Pick<RenderableSnapshot, 'worldId' | 'entityKey'>): string {
+  return `${snapshot.worldId}:${snapshot.entityKey}`;
+}
+
+/**
+ * A GPU-owned indirect draw has no CPU submit callback. Keep the same
+ * record-stage consumption proof for downstream lifecycle owners by checking
+ * the concrete draw-key projection that was actually encoded for this frame.
+ */
+function gpuDrivenRenderableConsumed(
+  entry: ValidatedRenderable,
+  drawKeys: ReadonlySet<string>,
+): boolean {
+  const draws = entry.source.gpuDrivenDraws;
+  if (draws === undefined || draws.length === 0) return false;
+  const worldEntity = worldEntityKey(entry.source.worldId, entry.source.entityKey);
+  return draws.some((draw, compactIndex) => {
+    const material = entry.source.materials[draw.materialSlot] ?? entry.source.material;
+    return drawKeys.has(
+      gpuDrivenDrawKey(
+        worldEntity,
+        material.materialHandle ?? -1,
+        gpuDrivenSourceDrawItemIndex(draw, compactIndex),
+      ),
+    );
+  });
+}
+
+/**
+ * Project one shared validation result into a cull-specific renderable index
+ * domain. The retained ShadowCaster projection is the superset; the primary
+ * camera submission reuses its resolved mesh rows without a second residency
+ * walk or a second validation authority.
+ */
+function projectValidatedRows(
+  validated: readonly ValidatedRenderable[],
+  target: readonly RenderableSnapshot[],
+): ValidatedRenderable[] {
+  const byIdentity = new Map<string, ValidatedRenderable>();
+  for (const row of validated) byIdentity.set(renderableIdentity(row.source), row);
+  const projected: ValidatedRenderable[] = [];
+  for (let index = 0; index < target.length; index += 1) {
+    const snapshot = target[index];
+    if (snapshot === undefined) continue;
+    const row = byIdentity.get(renderableIdentity(snapshot));
+    if (row === undefined) continue;
+    projected.push({ ...row, source: snapshot, renderableIndex: index });
+  }
+  return projected;
+}
+
 export interface FrameObservationOptions {
   readonly semantic: 'linear-hdr';
   readonly readback: FrameObservationReadback;
@@ -219,7 +292,8 @@ export async function observeCurrentFrame(
   });
 }
 
-import { createTemporalView, resolveTemporalReset } from '../temporal/view';
+import { acknowledgeRenderFeatureSubmission } from '../features/host';
+import { createTemporalView, resolveTemporalReset, type TemporalView } from '../temporal/view';
 import { inspectVolumetricFog } from '../volume/inspection';
 import {
   acquireSwapChainTarget,
@@ -244,6 +318,7 @@ import {
   type CubeCaptureGraphState,
   ensureCompiledFrameGraph,
   executeCompiledFrameGraph,
+  getRenderFeatureGraphState,
   type RenderFeatureGraphCandidate,
   settleVolumetricFogGraphCandidate,
 } from './typed-frame-graph';
@@ -256,35 +331,34 @@ import {
 
 /**
  * Resolve the GPU mesh view used by the optional production raster before its
- * filtering pass runs. User meshes are pull-resident during record; relying
- * only on the boot-time builtin map would make the first frame classify every
- * imported mesh as a CPU fallback and would hide its LOD ranges from the GPU
- * cull. Keep the map frame-local so the pipeline state remains the builtin
- * compatibility owner while the residency cache remains the user-mesh SSOT.
+ * filtering pass runs. The result is keyed by the retained RenderScene slot,
+ * which preserves the World namespace already used by gpuStore. User meshes
+ * are pull-resident during record; relying only on the boot-time builtin map
+ * would make the first frame classify every imported mesh as a CPU fallback
+ * and would hide its LOD ranges from the GPU cull. Builtins are the only
+ * process-static entries and may be read from PipelineState.meshes.
  */
-function gpuDrivenMeshesForFrame(
+export function gpuDrivenMeshesForFrame(
   internals: RenderSystemInternals,
   pipelineState: PipelineState,
   worlds: readonly World[],
   scene: PersistentGpuDrivenState | undefined,
 ): ReadonlyMap<number, MeshGpuHandles> {
-  const meshes = new Map(pipelineState.meshes);
+  const meshes = new Map<number, MeshGpuHandles>();
   if (scene === undefined) return meshes;
-  const cached = gpuDrivenMeshCache.get(scene.scene);
-  if (
-    cached !== undefined &&
-    cached.meshResidencyEpoch === internals.gpuStore.meshResidencyEpoch &&
-    cached.pipelineMeshes === pipelineState.meshes
-  ) {
-    return cached.value;
-  }
   for (const slot of scene.slots) {
-    const world = worlds[slot.snapshot.worldId];
-    if (world === undefined) continue;
     const assetHandle = slot.snapshot.assetHandle;
     const sharedHandle = toShared<'MeshAsset'>(assetHandle);
+    const assetSlot = handleSlot(sharedHandle);
+    if (assetSlot < BUILTIN_BASE) {
+      const gpu = pipelineState.meshes.get(assetSlot);
+      if (gpu !== undefined) meshes.set(slot.slot, gpu);
+      continue;
+    }
+    const world = worlds[slot.snapshot.worldId];
+    if (world === undefined) continue;
     let gpu = internals.gpuStore.getMeshGpuHandles(sharedHandle, world);
-    if (gpu === undefined && !meshes.has(assetHandle)) {
+    if (gpu === undefined) {
       const asset = resolveAssetHandle<MeshAsset>(world, sharedHandle);
       if (asset.ok) {
         const lodMeshes = slot.snapshot.lods?.map((lod) =>
@@ -303,26 +377,11 @@ function gpuDrivenMeshesForFrame(
         if (resident.ok) gpu = resident.value;
       }
     }
-    if (gpu !== undefined) meshes.set(assetHandle, gpu);
+    if (gpu !== undefined) meshes.set(slot.slot, gpu);
   }
-  const value = meshes;
-  gpuDrivenMeshCache.set(scene.scene, {
-    meshResidencyEpoch: internals.gpuStore.meshResidencyEpoch,
-    pipelineMeshes: pipelineState.meshes,
-    value,
-  });
-  return value;
+  return meshes;
 }
 
-const gpuDrivenMeshCache = new WeakMap<
-  object,
-  {
-    readonly meshResidencyEpoch: number;
-    readonly pipelineMeshes: ReadonlyMap<number, MeshGpuHandles>;
-    readonly value: ReadonlyMap<number, MeshGpuHandles>;
-  }
->();
-
 /**
  * A frame-local material table. Repeated snapshot objects share one UBO slot;
  * each renderable keeps only the slot index used by each authored material.
@@ -392,6 +451,34 @@ export function materialSlotCountForPrefix(
   return maxSlot + 1;
 }
 
+type MeshSsboCapacityResult = ReturnType<typeof ensureMeshSsboCapacity>;
+
+/**
+ * Resolve the actual mesh-SSBO ceiling after the shared grow contract ran.
+ * A missing grow controller is the legacy/test surface with no renderer-owned
+ * ceiling; a failed grow explicitly exposes the pre-grow capacity and must
+ * constrain every row written by this frame, including retained shadow rows.
+ */
+function meshSsboSlotCapacityAfterEnsure(
+  internals: Pick<RenderSystemInternals, 'growMeshSsbo' | 'meshSsboState'>,
+  neededSlots: number,
+  result: MeshSsboCapacityResult,
+): number {
+  if (internals.growMeshSsbo === undefined) return Number.POSITIVE_INFINITY;
+  if (!result.ok) return Math.max(0, result.degradedToSlotCount);
+  return internals.meshSsboState?.slotCount ?? neededSlots;
+}
+
+/**
+ * Keep a row sequence inside the capacity published by the mesh-SSBO owner.
+ * The caller has already reserved earlier rows (the primary view), so this
+ * helper only accepts the remaining slots for the retained shadow sequence.
+ */
+function limitRowsToMeshSsboCapacity<T>(rows: readonly T[], availableSlots: number): readonly T[] {
+  if (availableSlots === Number.POSITIVE_INFINITY) return rows;
+  return rows.slice(0, Math.max(0, Math.floor(availableSlots)));
+}
+
 export type RecordProfileRunner = <T>(phase: RenderRecordPhase, action: () => T) => T;
 
 export interface CubeCaptureFrameInput {
@@ -456,6 +543,18 @@ function prepareCubeCapture(
 }
 
 const EMPTY_ENTITY_KEYS: ReadonlySet<number> = new Set<number>();
+const EMPTY_DRAW_KEYS: ReadonlySet<string> = new Set<string>();
+
+function cacheEntityKeysFromDrawKeys(drawKeys: ReadonlySet<string>): ReadonlySet<number> {
+  const entityKeys = new Set<number>();
+  for (const key of drawKeys) {
+    const separator = key.indexOf(':');
+    if (separator <= 0) continue;
+    const entityKey = Number(key.slice(0, separator));
+    if (Number.isSafeInteger(entityKey)) entityKeys.add(entityKey);
+  }
+  return entityKeys;
+}
 
 function runRecordProfilePhase<T>(
   runner: RecordProfileRunner | undefined,
@@ -465,6 +564,14 @@ function runRecordProfilePhase<T>(
   return runner === undefined ? action() : runner(phase, action);
 }
 
+function shadowPlanes(matrix: Float32Array): Float32Array {
+  return frustum.fromViewProjection(frustum.create(), matrix as never);
+}
+
+function shadowViewToken(matrix: Float32Array): string {
+  return Array.from(matrix).join(',');
+}
+
 function halfFloatToNumber(bits: number): number {
   const sign = (bits & 0x8000) === 0 ? 1 : -1;
   const exponent = (bits >>> 10) & 0x1f;
@@ -1048,6 +1155,157 @@ function stageAcceptedVolumetricFogFrame(
   return { ...accepted, paramsBuffer };
 }
 
+function ssrRuntimeError(
+  cause: unknown,
+): RhiError | { code: string; message: string; name?: string } {
+  if (cause instanceof RhiError) return cause;
+  if (cause instanceof Error)
+    return { code: 'ssr-history-failure', message: cause.message, name: cause.name };
+  return { code: 'ssr-history-failure', message: String(cause) };
+}
+
+function reportSsrHistoryFailure(
+  internals: RenderSystemInternals,
+  stage: 'build' | 'encode' | 'finish' | 'submit',
+  cause: unknown,
+): void {
+  internals.errorRegistry.fire(
+    new RhiError({
+      code: 'webgpu-runtime-error',
+      expected: `SSR history ${stage} succeeds before queue submission`,
+      hint: 'inspect the SSR history owner failure and retry the next frame',
+      detail: { error: ssrRuntimeError(cause) },
+    }),
+  );
+}
+
+function mapSsrHistoryResetReason(
+  reason: TemporalView['resetReason'],
+): import('../ssr/history').SsrHistoryResetReason | undefined {
+  switch (reason) {
+    case 'first-frame':
+      return 'first-enable';
+    case 'resize':
+      return 'resize';
+    case 'camera-cut':
+    case 'view-switch':
+      return 'camera-cut';
+    case 'history-version':
+      return 'history-version';
+    case 'environment-change':
+    case 'fog-change':
+      return 'reflection-generation';
+    case 'device-recover':
+      return 'device-recovery';
+    case 'submit-failure':
+    case undefined:
+      return undefined;
+  }
+}
+
+function stageSsrHistoryCandidate(
+  internals: RenderSystemInternals,
+  frameState: RenderFrameState,
+  camera: CameraSnapshot,
+  width: number,
+  height: number,
+  admission: SsrSpatialAdmission,
+  temporalView: TemporalView,
+): boolean {
+  const previousAdmission = frameState.ssrSpatialAdmission;
+  frameState.ssrSpatialAdmission = admission;
+  if (admission.status !== 'admitted') {
+    if (frameState.ssrHistoryOwner !== undefined && previousAdmission?.status === 'admitted') {
+      const owner = frameState.ssrHistoryOwner;
+      owner.reset('disable');
+      owner.retireAfterFence(internals.device.queue, (cause) => {
+        reportSsrHistoryFailure(internals, 'submit', cause);
+      });
+      frameState.ssrHistoryOwner = undefined;
+    }
+    frameState.ssrHistoryCandidate = undefined;
+    frameState.ssrLastCameraEntity = camera.entityKey;
+    frameState.ssrLastHistoryVersion = camera.historyVersion;
+    return true;
+  }
+
+  let owner = frameState.ssrHistoryOwner;
+  if (owner === undefined) {
+    const created = createSsrHistoryOwner({
+      device: internals.device,
+      scope: internals.deviceScope,
+      width,
+      height,
+    });
+    if (!created.ok) {
+      reportSsrHistoryFailure(internals, 'build', created.error);
+      return false;
+    }
+    owner = created.value;
+    frameState.ssrHistoryOwner = owner;
+  } else if (owner.resources.width !== width || owner.resources.height !== height) {
+    const resized = owner.resize(width, height);
+    if (!resized.ok) {
+      reportSsrHistoryFailure(internals, 'build', resized.error);
+      return false;
+    }
+    owner.retireAfterFence(internals.device.queue, (cause) => {
+      reportSsrHistoryFailure(internals, 'submit', cause);
+    });
+  }
+
+  let resetReason: import('../ssr/history').SsrHistoryResetReason | undefined;
+  if (
+    frameState.ssrLastCameraEntity !== undefined &&
+    frameState.ssrLastCameraEntity !== camera.entityKey
+  ) {
+    resetReason = 'camera-cut';
+  } else if (
+    frameState.ssrLastHistoryVersion !== undefined &&
+    frameState.ssrLastHistoryVersion !== camera.historyVersion
+  ) {
+    resetReason = 'history-version';
+  } else {
+    resetReason = mapSsrHistoryResetReason(temporalView.resetReason);
+  }
+  if (resetReason !== undefined) owner.reset(resetReason);
+
+  const started = owner.beginFrame();
+  if (!started.ok) {
+    reportSsrHistoryFailure(internals, 'build', started.error);
+    return false;
+  }
+  const candidate = started.value;
+  const payload =
+    frameState.ssrTemporalParamsPayload?.byteLength === 32
+      ? frameState.ssrTemporalParamsPayload
+      : new Uint8Array(32);
+  payload.fill(0);
+  const values = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  values.setUint32(0, candidate.historyValid ? 1 : 0, true);
+  values.setFloat32(4, 0.9, true);
+  values.setFloat32(8, admission.config.thickness, true);
+  values.setFloat32(12, 0.5, true);
+  // Reuse the shared successful-submit snapshot; SSR owns no jitter sequence
+  // or independently advancing previous-camera state.
+  const previousJitter = frameState.lastSuccessfulTemporalView?.currentJitterUv;
+  values.setFloat32(16, temporalView.currentJitterUv?.[0] ?? 0, true);
+  values.setFloat32(20, temporalView.currentJitterUv?.[1] ?? 0, true);
+  values.setFloat32(24, previousJitter?.[0] ?? 0, true);
+  values.setFloat32(28, previousJitter?.[1] ?? 0, true);
+  const written = internals.device.queue.writeBuffer(owner.resources.paramsBuffer, 0, payload);
+  if (!written.ok) {
+    owner.abortFrame(candidate, 'encode');
+    reportSsrHistoryFailure(internals, 'encode', written.error);
+    return false;
+  }
+  frameState.ssrTemporalParamsPayload = payload;
+  frameState.ssrHistoryCandidate = candidate;
+  frameState.ssrLastCameraEntity = camera.entityKey;
+  frameState.ssrLastHistoryVersion = camera.historyVersion;
+  return true;
+}
+
 function updateVolumetricFogInspection(
   frameState: RenderFrameState,
   fog: ExtractedVolumetricFog | undefined,
@@ -1303,7 +1561,7 @@ export function recordFrame(
   world: World,
   cameras: CameraSnapshot[],
   lights: ExtractedLights,
-  renderables: RenderableSnapshot[],
+  renderables: readonly RenderableSnapshot[],
   transparentDispatch: readonly DispatchEntry[],
   frameState: RenderFrameState,
   dispatchCounts: DispatchCounts,
@@ -1339,10 +1597,18 @@ export function recordFrame(
   fogSignature = '',
   environmentReady = true,
   transmissionDemand?: TransmissionDemand,
+  shadowCasterEntityKeys: ReadonlySet<number> = EMPTY_ENTITY_KEYS,
+  shadowCasterDrawKeys: ReadonlySet<string> | undefined = undefined,
   volumetricFog?: ExtractedVolumetricFog,
   timingCapture?: GpuTimingCapture,
+  shadowCasterMembership?: readonly ShadowCasterMembership[],
+  shadowCasterProjection?: PersistentShadowCasterProjection,
+  shadowCasterWorldKeys?: readonly number[],
+  preparedLighting?: ReturnType<typeof prepareFrameLighting>,
+  ssrDependencies?: SsrDependenciesInspection,
   onRenderableDraw?: (entry: ValidatedRenderable) => void,
 ): boolean {
+  void shadowCasterEntityKeys;
   frameState.reflectionFallbackObservationSource = undefined;
   frameState.reflectionFallbackCompletion = undefined;
   // The `try / finally` wrapper advances `frameState.frameNumber` exactly
@@ -1392,6 +1658,7 @@ export function recordFrame(
     }
     const camera = activeCameras[0];
     if (!camera) return false;
+    frameState.ssrRequested = camera.screenSpaceReflection !== undefined;
     const pipelineState = internals.getPipelineState();
     if (pipelineState === null) return false;
     if (pipelineState.device !== internals.device) {
@@ -1433,8 +1700,12 @@ export function recordFrame(
       // ensure + ExtractedLights three-arm destructure (directional fallback,
       // point/spot/Rect arrays, totalLightCount). Extracted to prepareFrameLighting
       // (M3/w18) so recordFrame stays a skeleton.
-      const lighting = runRecordProfilePhase(profilePhase, 'record/scene-state/lighting-prep', () =>
-        prepareFrameLighting(internals, frameState, lights, camera, pipelineState),
+      const lighting = runRecordProfilePhase(
+        profilePhase,
+        'record/scene-state/lighting-prep',
+        () =>
+          preparedLighting ??
+          prepareFrameLighting(internals, frameState, lights, camera, pipelineState),
       );
       if (!lighting.ok) return lighting;
       const { light, totalLightCount, standard } = lighting.value;
@@ -1519,6 +1790,10 @@ export function recordFrame(
     const effectiveShadowMapSize = resolveShadowMapSize(internals, lights);
     const effectiveSpotShadowMapSize = resolveSpotShadowMapSize(internals, lights);
     const graphShadowMapSize = effectiveShadowMapSize ?? effectiveSpotShadowMapSize;
+    const hasShadowViews =
+      (effectiveShadowMapSize ?? 0) > 0 ||
+      lights.pointShadow.length > 0 ||
+      lights.spot.some((spot) => spot.castShadow);
     const volumeCapability = hasVolumetricFogCapability(
       internals.device.caps,
       internals.volumetricFogShaders,
@@ -1579,89 +1854,248 @@ export function recordFrame(
       (volumetricFog?.status === 'degraded' && acceptedFallback !== undefined);
 
     let preparedGpuDriven: PreparedGpuDrivenFrame | undefined;
-    if (gpuDriven !== undefined) {
+    const abortPreparedGpuDriven = (): void => {
+      preparedGpuDriven?._abortResourceReplacement?.();
+    };
+    const cubeCaptureWork = prepareCubeCapture(internals, cubeCapture, camera);
+    const reflectionFallbackCandidate = cubeCapture?.reflectionProbes?.fallbackDemand === true;
+    // The Standard PBR GPU raster owns one color target. Reflection fallback
+    // adds an MRT attachment, so keep this frame on the ordinary CPU producer
+    // instead of claiming rows that the one-target GPU pipeline cannot draw.
+    const frameGpuDriven = reflectionFallbackCandidate ? undefined : gpuDriven;
+
+    // Validate first so user meshes are resident in the same frame. The GPU
+    // owner consumes this producer-owned map together with the builtin mesh
+    // entries; it never resolves an asset or creates a fallback residency.
+    // Stable persistent-scene frames reuse this exact producer result. The
+    // cache is fenced by source identities plus mesh/device/pipeline/catalog
+    // generations, so recovery or any scene/resource replacement performs a
+    // fresh owner validation before a capable submission.
+    const shadowValidationActive = hasShadowViews && shadowCasterProjection !== undefined;
+    const validationRenderables = shadowValidationActive
+      ? shadowCasterProjection.renderables
+      : renderables;
+    const validationDispatch = shadowValidationActive
+      ? shadowCasterProjection.dispatch
+      : transparentDispatch;
+    const validationInput = {
+      cacheKey: residencyValidationCacheKey(world, worlds),
+      renderables: validationRenderables,
+      transparentDispatch: validationDispatch,
+      pipelineState,
+      pipelineHandle: frameState.installedPipelineHandle,
+      meshResidencyEpoch: internals.gpuStore.meshResidencyEpoch,
+      deviceGeneration: internals.deviceScope.generation,
+      assetCatalogEpoch: internals.assets.catalogEpoch,
+    } as const;
+    const cachedValidation = frameGpuDriven?.owner.reuseResidencyValidation(validationInput);
+    const validatedProjection =
+      cachedValidation ??
+      runRecordProfilePhase(profilePhase, 'record/validation', () =>
+        validateRenderables(
+          internals,
+          world,
+          worlds,
+          pipelineState,
+          frameState,
+          validationRenderables,
+          validationDispatch,
+          EMPTY_ENTITY_KEYS,
+        ),
+      );
+    if (cachedValidation === undefined) {
+      frameGpuDriven?.owner.rememberResidencyValidation(validationInput, validatedProjection);
+    }
+    // Camera culling only changes the primary index domain. When shadows are
+    // active, the retained projection is the validation superset; project the
+    // same resolved rows into the camera-visible subset without another walk.
+    const validatedShadowForResidency = shadowValidationActive ? validatedProjection : undefined;
+    const validatedForResidency = shadowValidationActive
+      ? projectValidatedRows(validatedProjection, renderables)
+      : validatedProjection;
+
+    if (frameGpuDriven !== undefined) {
+      const gpuDrivenMeshes = new Map(
+        gpuDrivenMeshesForFrame(internals, pipelineState, worlds, frameGpuDriven.scene),
+      );
+      const meshSlotByIdentity = new Map(
+        (frameGpuDriven.scene?.slots ?? []).map((slot) => [
+          worldEntityKey(slot.snapshot.worldId, slot.snapshot.entityKey),
+          slot.slot,
+        ]),
+      );
+      for (const row of [...validatedForResidency, ...(validatedShadowForResidency ?? [])]) {
+        const slot = meshSlotByIdentity.get(
+          worldEntityKey(row.source.worldId, row.source.entityKey),
+        );
+        if (slot !== undefined) gpuDrivenMeshes.set(slot, row.mesh);
+      }
       const standardPbrArtifact = internals.getMaterialShaderArtifact?.(
         'forgeax::default-standard-pbr',
       );
-      const prepared = gpuDriven.owner.prepare({
-        scene: gpuDriven.scene,
+      const standardPbrSkinArtifact = internals.getMaterialShaderArtifact?.('forgeax::pbr-skin');
+      const paletteUploadBytes = validatedForResidency.reduce(
+        (total, row) => total + (row.source.skin?.uploadBytes ?? 0),
+        0,
+      );
+      const prepared = frameGpuDriven.owner.prepare({
+        scene: frameGpuDriven.scene,
         camera,
-        meshes: gpuDrivenMeshesForFrame(internals, pipelineState, worlds, gpuDriven.scene),
+        meshBySlot: gpuDrivenMeshes,
         viewBindGroupLayout: pipelineState.viewBindGroupLayout,
         meshResidencyEpoch: internals.gpuStore.meshResidencyEpoch,
-        // The built-in Standard graph (including its clustered transport) is
-        // eligible for the GPU-driven LOD lane. The old HDRP boolean no
-        // longer exists in the unified pipeline state, so it must not be
-        // inferred from `standard.kind`.
-        hdrp: false,
-        ...(gpuDriven.activeEntityKeys === undefined
+        // GPU-driven Standard PBR currently owns the non-clustered path only.
+        // Cluster bindings also carry screen-space ambient occlusion. Admit
+        // the scene-index variant only when none of those surface inputs are
+        // required; a zero local-light count alone does not establish that.
+        hdrp:
+          standard.kind === 'clustered' &&
+          (standard.prepared.local.length > 0 ||
+            frameState.installedPipelineConfig?.ssao?.enabled === true),
+        ...(frameGpuDriven.activeEntityKeys === undefined
+          ? {}
+          : { activeEntityKeys: frameGpuDriven.activeEntityKeys }),
+        ...(frameGpuDriven.activeEntityRevision === undefined
           ? {}
-          : { activeEntityKeys: gpuDriven.activeEntityKeys }),
-        ...(gpuDriven.activeEntityRevision === undefined
+          : { activeEntityRevision: frameGpuDriven.activeEntityRevision }),
+        ...(frameGpuDriven.telemetryCandidateCount === undefined
           ? {}
-          : { activeEntityRevision: gpuDriven.activeEntityRevision }),
-        ...(gpuDriven.telemetryCandidateCount === undefined
+          : { telemetryCandidateCount: frameGpuDriven.telemetryCandidateCount }),
+        ...(frameGpuDriven.occlusion === undefined ? {} : { occlusion: frameGpuDriven.occlusion }),
+        ...(frameGpuDriven.scene?.structureMetrics === undefined
           ? {}
-          : { telemetryCandidateCount: gpuDriven.telemetryCandidateCount }),
-        ...(gpuDriven.occlusion === undefined ? {} : { occlusion: gpuDriven.occlusion }),
+          : {
+              structureMetrics: {
+                ...frameGpuDriven.scene.structureMetrics,
+                paletteUploadBytes,
+              },
+            }),
         ...(standardPbrArtifact === undefined ? {} : { standardPbrArtifact }),
+        ...(standardPbrSkinArtifact === undefined ? {} : { standardPbrSkinArtifact }),
         standardPbrPipelineState: pipelineState,
+        ...(shadowCasterDrawKeys === undefined ? {} : { shadowCasterDrawKeys }),
+        ...(shadowCasterMembership === undefined ? {} : { shadowCasterMembership }),
       });
-      if (prepared.ok) preparedGpuDriven = prepared.value;
-      else if (prepared.error.code !== 'rhi-not-available')
+      if (!prepared.ok) {
+        // A capable GPU-owned candidate with missing producer resources is a
+        // structured stop, not permission to enumerate the same draw through
+        // the CPU semantic path. Preserve the last-known-good graph and retry
+        // after the producer publishes a validated artifact.
         internals.errorRegistry.fire(prepared.error);
+        abortPreparedGpuDriven();
+        return false;
+      } else if (prepared.value !== undefined) {
+        preparedGpuDriven = prepared.value;
+        const shadowViews: Array<{
+          readonly identity: ShadowViewIdentity;
+          readonly planes: Float32Array;
+          readonly cacheToken: string;
+        }> = [];
+        for (const [index, matrix] of (lights.lightViewProj ?? []).entries()) {
+          shadowViews.push({
+            identity: { kind: 'directional', index },
+            planes: shadowPlanes(matrix),
+            cacheToken: `${shadowViewToken(matrix)}|target:${graphShadowMapSize}:${frameState.graphGeneration}`,
+          });
+        }
+        for (const [index, point] of lights.pointShadow.entries()) {
+          for (let face = 0; face < 6; face += 1) {
+            const matrix = point.shadowMatrices.subarray(face * 16, face * 16 + 16);
+            shadowViews.push({
+              identity: { kind: 'point', index, face },
+              planes: shadowPlanes(matrix),
+              cacheToken: `${shadowViewToken(matrix)}|target:${graphShadowMapSize}:${frameState.graphGeneration}`,
+            });
+          }
+        }
+        let shadowSpotIndex = 0;
+        for (const spot of lights.spot) {
+          if (spot.lightViewProj === undefined) continue;
+          shadowViews.push({
+            identity: { kind: 'spot', index: shadowSpotIndex },
+            planes: shadowPlanes(spot.lightViewProj),
+            cacheToken: `${shadowViewToken(spot.lightViewProj)}|target:${graphShadowMapSize}:${frameState.graphGeneration}`,
+          });
+          shadowSpotIndex += 1;
+        }
+        if (prepared.value.updateShadowViews !== undefined) {
+          const shadowUpdate = prepared.value.updateShadowViews(shadowViews);
+          if (!shadowUpdate.ok) {
+            internals.errorRegistry.fire(shadowUpdate.error);
+            abortPreparedGpuDriven();
+            return false;
+          }
+        }
+      }
     }
 
+    const gpuOwnedDrawKeys = preparedGpuDriven?.drawKeys ?? EMPTY_DRAW_KEYS;
     // The GPU lane owns only the primary opaque raster today. Directional,
-    // point, and spot shadow views still consume the CPU-validated draw plan.
-    const cpuShadowCastersActive =
-      (effectiveShadowMapSize ?? 0) > 0 ||
-      lights.pointShadow.length > 0 ||
-      lights.spot.some((spot) => spot.castShadow);
-    const gpuOwnsAllPrimaryRaster = preparedGpuDriven?.ownsAllRenderables === true;
-    gpuDriven?.onSceneDemand(gpuDriven.owner.requiresSceneRows());
-
-    const cubeCaptureWork = prepareCubeCapture(internals, cubeCapture, camera);
-    const reflectionFallbackCandidate = cubeCapture?.reflectionProbes?.fallbackDemand === true;
-
-    // Validate renderables before graph admission. Besides producing the draw
-    // plan, this is the owner of per-frame cache eviction; running it before a
-    // graph candidate can fail guarantees despawned instance buffers are
-    // released even when the frame cannot be submitted.
-    const gpuOwnedEntityKeys = preparedGpuDriven?.entityKeys ?? EMPTY_ENTITY_KEYS;
-    const gpuDrivenWorldKeys = gpuDriven?.scene?.worldKeys;
-    const validated = runRecordProfilePhase(profilePhase, 'record/validation', () =>
-      gpuOwnsAllPrimaryRaster && !cpuShadowCastersActive && cubeCaptureWork.length === 0
-        ? []
-        : validateRenderables(
-            internals,
-            world,
-            worlds,
-            pipelineState,
-            frameState,
-            renderables,
-            transparentDispatch,
-            cpuShadowCastersActive || cubeCaptureWork.length > 0
-              ? EMPTY_ENTITY_KEYS
-              : gpuOwnedEntityKeys,
-            gpuDrivenWorldKeys,
-          ),
+    // point, and spot shadow views consume the same CPU-validated rows; they do
+    // not require a second residency walk because the first validation already
+    // resolved every renderable used by both lanes.
+    // The GPU lane owns the actual geometry, but the main-pass material
+    // producer still needs the validated snapshot rows to build the
+    // frame-global bind-group table consumed by indirect draws. The record
+    // loop skips claimed submeshes through `gpuDrivenDrawKeys`, so retaining
+    // these rows does not issue duplicate CPU geometry. Reusing this one
+    // validation result also keeps active shadow views from repeating the
+    // residency walk.
+    const validated = validatedForResidency;
+    frameGpuDriven?.owner.recordCpuValidation(
+      validated,
+      gpuOwnedDrawKeys,
+      validationInput.cacheKey,
     );
-    gpuDriven?.owner.recordCpuValidation(validated, gpuOwnedEntityKeys, gpuDrivenWorldKeys);
-    cleanPerFrameCaches(internals, frameState, validated, gpuOwnedEntityKeys);
+    const cacheValidated =
+      validatedShadowForResidency === undefined
+        ? validated
+        : [...validated, ...validatedShadowForResidency];
+    cleanPerFrameCaches(
+      internals,
+      frameState,
+      cacheValidated,
+      cacheEntityKeysFromDrawKeys(gpuOwnedDrawKeys),
+    );
+
+    // Compile the single frame graph only after GPU preparation has projected
+    // the current frame. This keeps the graph topology and its execution
+    // closure on the same prepared GPU-owned draw set.
 
     // S_fallback is the second output of the built-in Standard PBR BRDF. A
     // graph may still carry the detached owner tickets for inspection, but
     // the MRT is admitted only when every CPU-rendered primary row in this
     // frame uses that exact output contract. Unsupported compositions remain
     // fail-closed for SSR instead of submitting a device-invalid command.
-    frameState.reflectionFallbackDemand =
-      reflectionFallbackCandidate &&
+    const sceneInputs =
       validated.length > 0 &&
       validated.every(
         (entry) => entry.source.material.materialShaderId === 'forgeax::default-standard-pbr',
       );
-
+    const ssrAdmission =
+      ssrDependencies === undefined
+        ? undefined
+        : admitSsrSpatial({
+            camera,
+            environment: {
+              lane: standard.prepared.renderPath === 'deferred' ? 'deferred' : 'forward',
+              m0: ssrDependencies.admission,
+              sceneInputs,
+              // Standard geometry produces current motion/coverage in this
+              // graph, including its first frame. Prior history is optional.
+              temporal: sceneInputs,
+              reflectionFallback: ssrDependencies.reflectionFallback !== undefined,
+              capabilities: {
+                compute: internals.device.caps.compute,
+                storageTexture: internals.device.caps.storageTexture,
+                rgba16floatRenderable: internals.device.caps.rgba16floatRenderable,
+                r32floatSampledStorage: ssrDependencies.format?.verdict === 'admitted',
+              },
+              recovery: true,
+            },
+          });
+    frameState.reflectionFallbackDemand =
+      (reflectionFallbackCandidate || ssrAdmission?.status === 'admitted') && sceneInputs;
     const preflightGraph = runRecordProfilePhase(profilePhase, 'record/render-graph', () =>
       ensureCompiledFrameGraph(
         internals,
@@ -1677,13 +2111,18 @@ export function recordFrame(
         cubeCapture?.state,
         cameras.length === 0,
         transmissionDemand,
-        gpuDriven?.occlusion,
+        frameGpuDriven?.occlusion,
         graphVolumetricFog,
         volumeTopologyCandidate,
         standard,
+        undefined,
+        ssrAdmission,
       ),
     );
-    if (preflightGraph === null) return false;
+    if (preflightGraph === null) {
+      abortPreparedGpuDriven();
+      return false;
+    }
 
     // The compiled graph is the acceptance boundary for the prepared
     // Standard lighting declaration. Upload the same declaration only after
@@ -1704,6 +2143,7 @@ export function recordFrame(
           },
         }),
       );
+      abortPreparedGpuDriven();
       return false;
     }
     if (standard.kind === 'clustered') {
@@ -1732,6 +2172,7 @@ export function recordFrame(
       );
       if (!clusterWrite.ok) {
         internals.errorRegistry.fire(clusterWrite.error);
+        abortPreparedGpuDriven();
         return false;
       }
     }
@@ -1744,7 +2185,10 @@ export function recordFrame(
     const swapTarget = runRecordProfilePhase(profilePhase, 'record/swapchain', () =>
       acquireSwapChainTarget(internals, pipelineState),
     );
-    if (swapTarget === null) return false;
+    if (swapTarget === null) {
+      abortPreparedGpuDriven();
+      return false;
+    }
     const currentTexture = swapTarget.currentTexture;
     const view = swapTarget.view;
     const targetW = swapTarget.targetW;
@@ -1802,6 +2246,23 @@ export function recordFrame(
           : { kind: 'off', view: temporalView };
     const recordCamera: CameraSnapshot =
       temporalView.mode === 'taa' ? { ...camera, temporal: temporalView } : camera;
+    if (ssrAdmission !== undefined) {
+      const historyWidth = Math.max(1, internals.canvas.width);
+      const historyHeight = Math.max(1, internals.canvas.height);
+      if (
+        !stageSsrHistoryCandidate(
+          internals,
+          frameState,
+          camera,
+          historyWidth,
+          historyHeight,
+          ssrAdmission,
+          temporalView,
+        )
+      ) {
+        return false;
+      }
+    }
     let activeVolumetricFogContext: VolumetricFogFrameContext | undefined;
     let activeVolumetricFogSignature: VolumeTemporalSignature | undefined;
     if (graphVolumetricFog?.status === 'available' && baseVolumetricFogContext !== undefined) {
@@ -1828,6 +2289,7 @@ export function recordFrame(
       );
       if (!historyFlagWritten.ok) {
         internals.errorRegistry.fire(historyFlagWritten.error);
+        abortPreparedGpuDriven();
         return false;
       }
     }
@@ -1903,9 +2365,18 @@ export function recordFrame(
     // order, run the mesh-SSBO capacity gate (graceful truncation), and build
     // the fold dispatch plan. Extracted to buildDispatchPlan (M3/w18).
     const dispatchPlan = runRecordProfilePhase(profilePhase, 'record/dispatch-plan', () =>
-      buildDispatchPlan(internals, validated, transparentDispatch, foldBuckets),
+      buildDispatchPlan(
+        internals,
+        validated,
+        transparentDispatch,
+        foldBuckets,
+        validatedShadowForResidency ?? [],
+      ),
     );
     const validatedOrdered = dispatchPlan.validatedOrdered;
+    const shadowValidatedOrdered = dispatchPlan.shadowValidatedOrdered;
+    const shadowMeshSsboBase = validatedOrdered.length;
+    const shadowDispatch = shadowCasterProjection?.dispatch;
     const foldDispatchPlan = dispatchPlan.foldDispatchPlan;
     const materialSlotIndices = dispatchPlan.materialSlotIndices;
     const materialSlots = dispatchPlan.materialSlots;
@@ -1937,12 +2408,13 @@ export function recordFrame(
       const unormViewRes = internals.device.createTextureView(currentTexture, {});
       if (!unormViewRes.ok) {
         internals.errorRegistry.fire(unormViewRes.error);
+        abortPreparedGpuDriven();
         return false;
       }
       ldrSpritePassView = unormViewRes.value;
     }
 
-    // View / mesh uniform uploads are only needed when geometry will be drawn,
+    // View / mesh uniform uploads are needed when geometry or a feature consumes View,
     // OR when a skybox is active (skybox pass reads inverseViewProj from
     // the View UBO). Skip the writeBuffer round-trips on the Case E
     // (clear-pass-only) path only when neither condition is met.
@@ -1957,7 +2429,10 @@ export function recordFrame(
     );
     if (
       validatedOrdered.length > 0 ||
+      shadowValidatedOrdered.length > 0 ||
+      getRenderFeatureGraphState(internals).plans.some(({ plan }) => plan.passes.length > 0) ||
       skyboxActive ||
+      frameState.environmentFrame?.source.kind === 'atmosphere' ||
       activeVolumetricFogContext !== undefined ||
       preparedVolumetricFog !== undefined
     ) {
@@ -2000,6 +2475,15 @@ export function recordFrame(
           validatedOrdered,
           foldDispatchPlan,
         );
+        if (shadowValidatedOrdered.length > 0) {
+          uploadMeshSsboBatch(
+            internals.device.queue,
+            pipelineState.meshStorageBuffer,
+            shadowValidatedOrdered,
+            null,
+            shadowMeshSsboBase,
+          );
+        }
       });
     }
 
@@ -2022,6 +2506,7 @@ export function recordFrame(
     const encoderResult = internals.device.createCommandEncoder({ label: 'render-system-frame' });
     if (!encoderResult.ok) {
       internals.errorRegistry.fire(encoderResult.error);
+      abortPreparedGpuDriven();
       return false;
     }
     const encoder: RhiCommandEncoder = encoderResult.value;
@@ -2100,8 +2585,6 @@ export function recordFrame(
     const passCtx: _InternalRenderPipelineContext = {
       assets: internals.assets,
       world,
-      gpuDrivenEntityKeys: gpuOwnedEntityKeys,
-      ...(gpuDrivenWorldKeys === undefined ? {} : { gpuDrivenWorldKeys }),
       store: internals.gpuStore,
       pipelineState,
       bloomResources: pipelineState.perPassResources.getBloomResources?.() ?? null,
@@ -2137,6 +2620,10 @@ export function recordFrame(
       ...(internals.volumetricFogShaders === undefined
         ? {}
         : { volumetricFogShaders: internals.volumetricFogShaders }),
+      ...(internals.ssrShaders === undefined ? {} : { ssrShaders: internals.ssrShaders }),
+      ...(internals.atmosphereShaders === undefined
+        ? {}
+        : { atmosphereShaders: internals.atmosphereShaders }),
       ...(activeVolumetricFogContext === undefined
         ? {}
         : { volumetricFog: activeVolumetricFogContext }),
@@ -2146,13 +2633,26 @@ export function recordFrame(
       dispatch: transparentDispatch,
       hdrpClusterBindGroup,
       hdrpClusterMembershipBindGroup,
-      ...(gpuDriven?.occlusion === undefined ? {} : { occlusion: gpuDriven.occlusion }),
+      ...(frameGpuDriven?.occlusion === undefined ? {} : { occlusion: frameGpuDriven.occlusion }),
       standardLighting: standard,
       foldDispatchPlan,
       materialSlotIndices,
       materialSlots,
       materialSlotOwners,
       materialSlotCount,
+      ...(preparedGpuDriven === undefined
+        ? {}
+        : {
+            gpuDrivenStandardPbrFrameResources: preparedGpuDriven.standardPbrFrameResources,
+            gpuDrivenDrawKeys: preparedGpuDriven.drawKeys,
+            gpuDrivenShadowViews: preparedGpuDriven.shadowViewPool,
+            gpuDrivenShadowBatchProjections: preparedGpuDriven.shadowBatchProjections,
+            gpuDrivenShadowDrawKeys: preparedGpuDriven.shadowDrawKeys,
+            gpuDrivenShadowDrawKeysByView: preparedGpuDriven.shadowDrawKeysByView,
+          }),
+      ...(frameGpuDriven?.scene === undefined
+        ? {}
+        : { gpuDrivenSceneMaterialBuffer: frameGpuDriven.scene.scene.materialBuffer }),
       ...(cubeCapture?.reflectionProbes === undefined
         ? {}
         : { reflectionProbes: cubeCapture.reflectionProbes }),
@@ -2160,6 +2660,12 @@ export function recordFrame(
       materialBgAssemblyCache: frameState.materialBgAssemblyCache,
       ...(onRenderableDraw === undefined ? {} : { onRenderableDraw }),
       directionalShadowCacheReuse: directionalShadowCache.reuse,
+      ...(shadowCasterMembership === undefined ? {} : { shadowCasterMembership }),
+      ...(shadowValidatedOrdered.length === 0
+        ? {}
+        : { shadowValidatedOrdered, shadowMeshSsboBase }),
+      ...(shadowDispatch === undefined ? {} : { shadowDispatch }),
+      ...(shadowCasterWorldKeys === undefined ? {} : { shadowCasterWorldKeys }),
       ...(profilePhase !== undefined ? { profilePhase } : {}),
     };
     uploadMaterialUniforms(passCtx);
@@ -2190,6 +2696,37 @@ export function recordFrame(
     frameState.temporalFrameInput = stagedTemporalFrame;
     frameState.temporalFrameTransaction.stage(stagedTemporalFrame);
     volumeSubmissionAttempted = volumeTopologyCandidate || activeVolumetricFogContext !== undefined;
+    const ssrOwner = frameState.ssrHistoryOwner;
+    const ssrCandidate = frameState.ssrHistoryCandidate;
+    const frameHooks =
+      preparedGpuDriven === undefined &&
+      frameGpuDriven?.occlusion === undefined &&
+      ssrCandidate === undefined
+        ? undefined
+        : {
+            afterGraphExecute: () =>
+              frameGpuDriven?.occlusion?.recordResolve(encoder) ?? ok(undefined),
+            onSubmitted: () => {
+              if (ssrOwner !== undefined && ssrCandidate !== undefined) {
+                const committed = ssrOwner.commitFrame(ssrCandidate);
+                if (!committed.ok) {
+                  ssrOwner.abortFrame(ssrCandidate, 'submit');
+                  reportSsrHistoryFailure(internals, 'submit', committed.error);
+                }
+                frameState.ssrHistoryCandidate = undefined;
+              }
+              preparedGpuDriven?._commitResourceReplacement();
+              frameGpuDriven?.occlusion?.commit(true, frameState.frameNumber, profilePhase);
+            },
+            onAborted: () => {
+              if (ssrOwner !== undefined && ssrCandidate !== undefined) {
+                ssrOwner.abortFrame(ssrCandidate, 'submit');
+                frameState.ssrHistoryCandidate = undefined;
+              }
+              preparedGpuDriven?._abortResourceReplacement?.();
+              frameGpuDriven?.occlusion?.commit(false, frameState.frameNumber);
+            },
+          };
     submitted = runRecordProfilePhase(profilePhase, 'record/graph-execute', () =>
       executeCompiledFrameGraph(
         internals,
@@ -2199,17 +2736,7 @@ export function recordFrame(
         profilePhase === undefined
           ? undefined
           : (pass, encode) => profilePhase(graphExecutionPhase(pass.name), encode),
-        gpuDriven === undefined
-          ? undefined
-          : {
-              afterGraphExecute: () => gpuDriven.occlusion?.recordResolve(encoder) ?? ok(undefined),
-              onSubmitted: () => {
-                gpuDriven.occlusion?.commit(true, frameState.frameNumber, profilePhase);
-              },
-              onAborted: () => {
-                gpuDriven.occlusion?.commit(false, frameState.frameNumber);
-              },
-            },
+        frameHooks,
         cubeCaptureWork.length === 0 ? undefined : cubeCaptureWork.map((work) => work.faceIndex),
         (done) => {
           completion = done;
@@ -2231,6 +2758,20 @@ export function recordFrame(
         timingCapture,
       ),
     );
+    if (submitted && preparedGpuDriven?.drawKeys !== undefined && onRenderableDraw !== undefined) {
+      for (const entry of validated) {
+        if (gpuDrivenRenderableConsumed(entry, preparedGpuDriven.drawKeys)) {
+          onRenderableDraw(entry);
+        }
+      }
+    }
+    if (submitted) {
+      // Feature plans are submission-sensitive: VFX keeps queued fixed ticks
+      // until the graph that consumed them is actually submitted. Acknowledge
+      // the exact accepted graph here so successful frames do not replay every
+      // prior tick into the next topology.
+      acknowledgeRenderFeatureSubmission(getRenderFeatureGraphState(internals).plans);
+    }
     if (cubeCapture !== undefined && cubeCaptureWork.length > 0) {
       const completed = cubeCapture.scheduler.completeSubmission(submitted, completion);
       if (!completed.ok) internals.errorRegistry.fire(completed.error);
@@ -2312,6 +2853,10 @@ export function recordFrame(
     }
     return submitted;
   } finally {
+    if (!submitted && frameState.ssrHistoryCandidate !== undefined) {
+      frameState.ssrHistoryOwner?.abortFrame(frameState.ssrHistoryCandidate, 'submit');
+      frameState.ssrHistoryCandidate = undefined;
+    }
     // Volume topology replacements are provisional until the queue submission
     // succeeds. This runs for every early-return path as well, so a swapchain,
     // encoder, or graph failure cannot leave a non-submitted candidate as the
@@ -2422,6 +2967,15 @@ function prepareDirectionalShadowCache(
 ): DirectionalShadowCacheDecision {
   const cascadeCount = lights.cascadeCount;
   const lightViewProj = lights.lightViewProj;
+  // GPU feature buffers can change without an ECS mesh mutation. Until a
+  // producer provides a stable content revision, never reuse their shadow atlas.
+  if (
+    getRenderFeatureGraphState(internals).plans.some(({ plan }) =>
+      plan.passes.some((pass) => pass.kind === 'shadow-caster'),
+    )
+  ) {
+    return { reuse: false, next: null };
+  }
   if (
     frameState.compiledFrameGraph === null ||
     frameState.compiledFrameGraphTopologyKey === null ||
@@ -2662,6 +3216,9 @@ export function validateRenderables(
   return validated;
 }
 
+// Keep the primary record-stage name explicit at its call site while sharing
+// the same owner implementation for the complete retained ShadowCaster view.
+
 function prepareMorphMesh(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
@@ -2673,9 +3230,23 @@ function prepareMorphMesh(
   if (morph === undefined || frameState.morphBuffers === undefined) return undefined;
   const targets = mesh.morphTargets;
   if (targets === undefined || targets.length !== morph.targetCount) return undefined;
-  if (base.layoutProjection.arrayStride !== 48 || base.vertexCount <= 0) return undefined;
-  const stride = mesh.vertices.length / base.vertexCount;
-  if (!Number.isInteger(stride) || stride < 3) return undefined;
+  const position = base.layoutProjection.attributes.find(
+    (attribute) => attribute.key === 'position',
+  );
+  if (
+    position === undefined ||
+    position.offset !== 0 ||
+    position.shaderLocation !== 0 ||
+    position.format !== 'float32x3' ||
+    position.byteLength !== 12
+  ) {
+    return undefined;
+  }
+  const vertexCount = deriveVertexCount(mesh.vertices, base.layoutProjection);
+  if (vertexCount === undefined || vertexCount !== base.vertexCount || vertexCount <= 0) {
+    return undefined;
+  }
+  const stride = base.layoutProjection.arrayStride / Float32Array.BYTES_PER_ELEMENT;
 
   let active = false;
   for (const weight of morph.weights) {
@@ -2753,17 +3324,19 @@ function prepareMorphMesh(
  *
  * @internal
  */
-function buildDispatchPlan(
+export function buildDispatchPlan(
   internals: RenderSystemInternals,
   validated: readonly ValidatedRenderable[],
   transparentDispatch: readonly DispatchEntry[],
   foldBuckets: readonly FoldBucket[],
+  shadowValidated: readonly ValidatedRenderable[] = [],
 ): {
   validatedOrdered: readonly ValidatedRenderable[];
+  shadowValidatedOrdered: readonly ValidatedRenderable[];
   foldDispatchPlan: FoldDispatchPlan | null;
   materialSlotIndices: readonly (readonly number[])[];
   materialSlots: readonly MaterialSnapshot[];
-  materialSlotOwners: readonly number[];
+  materialSlotOwners: readonly ValidatedRenderable[];
   materialSlotCount: number;
 } {
   // A production GPU-owned frame has no CPU validated rows by design. The
@@ -2771,9 +3344,16 @@ function buildDispatchPlan(
   // CPU plan, material table, or fold bucket is consumed in that lane. Return
   // the empty plan without walking that list so a steady 100k scene remains
   // bounded by the persistent GPU batches rather than per-entity record work.
-  if (validated.length === 0) {
+  if (validated.length === 0 && shadowValidated.length === 0) {
+    const meshSsboCapResult = ensureMeshSsboCapacity(internals, shadowValidated.length);
+    const meshSsboSlotCapacity = meshSsboSlotCapacityAfterEnsure(
+      internals,
+      shadowValidated.length,
+      meshSsboCapResult,
+    );
     return {
       validatedOrdered: [],
+      shadowValidatedOrdered: limitRowsToMeshSsboCapacity(shadowValidated, meshSsboSlotCapacity),
       foldDispatchPlan: null,
       materialSlotIndices: [],
       materialSlots: [],
@@ -2821,7 +3401,10 @@ function buildDispatchPlan(
     validatedOrdered = ordered;
   }
 
-  const materialGroups = validatedOrdered.map((entry): readonly MaterialSnapshot[] => {
+  // Shadow-only/off-camera CPU residuals consume the same material UBO as
+  // visible draws. Their preparation must not depend on main-view visibility.
+  const materialRows = [...validatedOrdered, ...shadowValidated];
+  const materialGroups = materialRows.map((entry): readonly MaterialSnapshot[] => {
     const shaderId = entry.source.material.materialShaderId;
     if (shaderId === 'forgeax::sprite' || shaderId === 'forgeax::sprite-lit') {
       return [entry.source.material];
@@ -2831,8 +3414,13 @@ function buildDispatchPlan(
   const materialSlotPlan = buildMaterialSlotPlan(materialGroups);
   let materialSlotIndices = materialSlotPlan.slotIndices;
   let materialSlots = materialSlotPlan.slots;
-  let materialSlotOwners = materialSlotPlan.slotOwners;
+  let materialSlotOwners = materialSlotPlan.slotOwners.map((index) => {
+    const owner = materialRows[index];
+    if (owner === undefined) throw new Error('material slot has no validated owner');
+    return owner;
+  });
   let materialSlotCount = materialSlots.length;
+  let materialRenderableCount = materialRows.length;
 
   // feat-20260608-mesh-ssbo-dynamic-grow-l1-lift-1024-entity-cap M3 / T-M3-04:
   // ensure the mesh-SSBO + material-UBO buffer pair is large enough to hold
@@ -2857,8 +3445,13 @@ function buildDispatchPlan(
   //
   // feat-20260624 M1' / t7: sprite-lit treated identically to sprite
   // for material-slot accounting (paramSchema mirror, t4).
-  const neededSlots = Math.max(validatedOrdered.length, materialSlotCount);
+  const neededSlots = Math.max(validatedOrdered.length + shadowValidated.length, materialSlotCount);
   const meshSsboCapResult = ensureMeshSsboCapacity(internals, neededSlots);
+  const meshSsboSlotCapacity = meshSsboSlotCapacityAfterEnsure(
+    internals,
+    neededSlots,
+    meshSsboCapResult,
+  );
   if (!meshSsboCapResult.ok) {
     // Graceful degradation: the controller reports slots, but this stage
     // consumes entities. Find a complete prefix instead of slicing at the
@@ -2867,12 +3460,17 @@ function buildDispatchPlan(
       materialSlotIndices,
       meshSsboCapResult.degradedToSlotCount,
     );
+    materialRenderableCount = degradedRenderableCount;
     materialSlotCount = materialSlotCountForPrefix(materialSlotIndices, degradedRenderableCount);
     materialSlotIndices = materialSlotIndices.slice(0, degradedRenderableCount);
     materialSlots = materialSlots.slice(0, materialSlotCount);
     materialSlotOwners = materialSlotOwners.slice(0, materialSlotCount);
     validatedOrdered = validatedOrdered.slice(0, degradedRenderableCount);
   }
+  const shadowValidatedOrdered = limitRowsToMeshSsboCapacity(
+    shadowValidated,
+    Math.min(meshSsboSlotCapacity, materialRenderableCount) - validatedOrdered.length,
+  );
 
   // feat-20260622-chunk-gpu-instancing-sprite-tilemap M1 / w4-record-swap
   // (D-1): build the fold dispatch plan once `validatedOrdered` is final
@@ -2965,6 +3563,7 @@ function buildDispatchPlan(
 
   return {
     validatedOrdered,
+    shadowValidatedOrdered,
     foldDispatchPlan,
     materialSlotIndices,
     materialSlots,
@@ -3042,13 +3641,6 @@ function cleanPerFrameCaches(
     }
   }
 
-  if (frameState.instanceResidency !== undefined) {
-    const liveCollections = new Set(validated.map((entry) => entry.source.instances?.collectionId));
-    for (const id of frameState.instanceResidency.keys()) {
-      if (!liveCollections.has(id)) frameState.instanceResidency.delete(id);
-    }
-  }
-
   // Chunk keys are `${worldEntityKey}:${chunkStart}`. Keep the key opaque to
   // the authoring API, but retain the numeric owner prefix for eviction.
   if (frameState.instanceBufferChunks !== undefined) {