@forgeax/engine-render 0.1.33 → 0.1.35

package/src/recovery/render-system-candidate.ts

@@ -9,9 +9,11 @@ import {
   type Result,
   RhiError,
 } from '@forgeax/engine-rhi';
+import type { MaterialShaderArtifact } from '@forgeax/engine-shader';
 import type { Handle, MeshAsset, SamplerAsset, TextureAsset } from '@forgeax/engine-types';
 import { toShared } from '@forgeax/engine-types';
 import { standardBloomAdmitted } from '../bloom-admission';
+import { cloudShadowResolutionForQuality } from '../cloud/parameters';
 import { createClusterBinScratch } from '../cluster-binner';
 import type { EnvironmentLifecycle } from '../environment/lifecycle';
 import {
@@ -29,8 +31,12 @@ import {
   type PostProcessShaderEntry,
   postProcessShaderEntrySignature,
 } from '../fullscreen-post-process-pass';
-import { collectGpuDrivenMaterialArtifacts } from '../gpu-driven/material-artifacts';
+import {
+  collectGpuDrivenMaterialArtifacts,
+  requiresProbeBlendRecord,
+} from '../gpu-driven/material-artifacts';
 import { GpuDrivenProduction } from '../gpu-driven/production-raster';
+import { disposeInstanceBufferChunks, disposeInstanceBuffers } from '../instance-buffer-cache';
 import { inspectStandardLighting } from '../pipeline/standard-lighting/inspection';
 import { retireAutoExposureGpuResources } from '../pipeline/standard-output/auto-exposure/gpu';
 import {
@@ -38,12 +44,16 @@ import {
   resetStandardOutputForDeviceLoss,
 } from '../pipeline/standard-output/resources';
 import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
+import { standardTopologyVariantSet } from '../pipeline-spec';
 import { inspectPointShadow } from '../point-shadow-inspection';
 import type { PreparedGraphicsResolver } from '../prepare/prepared-graphics-resolver';
+import type { RenderResourceScope } from '../publication/resource-scope';
 import { gpuDrivenMeshesForFrame, validateRenderables } from '../record/frame';
 import { prepareFrameLighting } from '../record/frame-lighting';
 import type { RenderFrameState, ValidatedRenderable } from '../record/frame-snapshot';
+import { resolveGeometryInstanceBuffer } from '../record/main-pass-geometry';
 import { computeSplitLdrSprite } from '../record/main-pass-sprite-draws';
+import { ensureProbeBlendRecordBuffer } from '../record/probe-blend-buffer';
 import {
   prepareRecoveryPipelineReadiness,
   type RecoveryPipelineReadiness,
@@ -53,6 +63,8 @@ import {
   ensureCompiledFrameGraph,
   getRenderFeatureGraphState,
   type RenderFeatureGraphCandidate,
+  retire as retireCompiledGraph,
+  shareRenderGraphGenerationAllocationOwner,
 } from '../record/typed-frame-graph';
 import { STANDARD_OUTPUT_TRANSFORM_FEATURE_ID } from '../render-contract';
 import type {
@@ -62,6 +74,7 @@ import type {
 } from '../render-system-extract';
 import type { PersistentGpuDrivenCandidate, PersistentRenderScene } from '../scene/render-scene';
 import { SHADOW_ATLAS_DEFAULT_LAYERS } from '../shadow-atlas';
+import { ReadonlyDynamicInputPage, type SurfaceDynamicInputFrame } from '../surface/dynamic-input';
 import { createTemporalFrameTransaction } from '../temporal/frame';
 import {
   getTemporalBindGroupResources,
@@ -83,16 +96,24 @@ export interface PreparedResolverCaches {
   readonly preparedGroup0Pipelines: WeakSet<object>;
   readonly preparedViewOnlyPipelines: WeakSet<object>;
   readonly preparedRenderMaterialPipelines: WeakSet<object>;
-  readonly preparedAssetHandles: WeakMap<World, Map<string, number>>;
+  readonly preparedAssetHandles: WeakMap<RenderResourceScope, Map<string, number>>;
 }
 
 export interface RecoveryFrameSeed {
   readonly frame: ExtractedFrame;
-  readonly worlds: readonly World[];
+  readonly worlds: readonly RenderResourceScope[];
   readonly cameraOwner: number;
   readonly resourceOwner: number;
   readonly width: number;
   readonly height: number;
+  /** Last submitted Surface page is reused while the replacement device warms. */
+  readonly surfaceDynamicInput?: SurfaceDynamicInputFrame;
+  /** Last submitted RenderResourceScope/App time snapshot for the Surface frame ABI. */
+  readonly frameTime?: number;
+  /** Exact forward artifacts accepted by the submitted frame. */
+  readonly materialArtifacts?: ReadonlyMap<string, MaterialShaderArtifact>;
+  /** Exact ShadowCaster artifacts accepted by the submitted frame. */
+  readonly shadowMaterialArtifacts?: ReadonlyMap<string, MaterialShaderArtifact>;
 }
 
 export interface RenderSystemRecoveryDependencies {
@@ -124,7 +145,7 @@ export interface RenderSystemRecoveryDependencies {
   readonly createPreparedResolverFactory: (
     runtime: RenderSystemInternals,
     gpuWork: RenderFeatureGpuWorkOwner,
-    worlds: readonly World[],
+    worlds: readonly RenderResourceScope[],
     caches: PreparedResolverCaches,
   ) => (input: RenderFeaturePreparedGraphicsResolverInput) => PreparedGraphicsResolver;
   readonly createPreparedResolverCaches: () => PreparedResolverCaches;
@@ -209,13 +230,18 @@ export function createRenderSystemRecovery(
   } = deps;
 
   // This is a detached CPU projection, retained only after queue submission.
-  // It is not a World/lease cache and it never carries target or scheduler state.
+  // It is not a RenderResourceScope/lease cache and it never carries target or scheduler state.
   let lastSuccessfulFrameSeed: RecoveryFrameSeed | undefined;
 
   const createRecoveryCandidateFrameState = (): RenderFrameState => {
-    const { probeBlendRecordBuffer: discardedProbeBlendRecordBuffer, ...baseFrameState } =
-      frameState;
+    const {
+      probeBlendRecordBuffer: discardedProbeBlendRecordBuffer,
+      instanceCollections: discardedInstanceInspection,
+      ...baseFrameState
+    } = frameState;
     void discardedProbeBlendRecordBuffer;
+    // Candidate uploads must not publish residency into the active inspection.
+    void discardedInstanceInspection;
     return {
       ...baseFrameState,
       successfulTemporalFrameIndex: 0,
@@ -256,15 +282,18 @@ export function createRenderSystemRecovery(
       retiredCompiledFrameGraphs: new Set(),
       currentFrameObservationSource: undefined,
       lastSuccessfulCameraAntialias: undefined,
+      lastSuccessfulBarrelDistortion: undefined,
       temporalGpuState: undefined,
       activeTemporalGpuState: undefined,
       retiringTemporalGpuStates: new Set(),
+      cloudHistoryActive: false,
       lastSuccessfulTemporalView: undefined,
       pendingTemporalCommit: { kind: 'none' },
       environmentGeneration: undefined,
       currentDirectionalShadowView: null,
       currentSpotShadowView: null,
       instanceBuffers: new Map(),
+      instanceBufferChunks: new Map(),
       morphBuffers: new Map(),
       hdrpClusterBinScratch: createClusterBinScratch(),
       hdrpClusterGridScratch: null,
@@ -299,6 +328,18 @@ export function createRenderSystemRecovery(
       candidate.recoveryReadiness.assertPreparedCache();
     }
     const previousFeatureHost = internals.featureHost;
+    // The candidate graph proves topology and pipeline readiness before the
+    // publication boundary, but its imported display view was acquired before
+    // the shared canvas context was reconfigured for the replacement device.
+    // Retire that frame-bound graph and preserve the prepared owners/caches;
+    // the first recovered frame recompiles the same topology against the
+    // newly configured context instead of submitting a view from the lost
+    // device generation.
+    const candidateDisplayGraph = candidate.frameState.compiledFrameGraph;
+    candidate.frameState.compiledFrameGraph = null;
+    candidate.frameState.compiledFrameGraphTopologyKey = null;
+    candidate.frameState.perFrameGraph = null;
+    candidateDisplayGraph?.retire().catch(() => undefined);
     // The caller enters this method only after the active generation swap and
     // after resetForRecover() has shed every lost-device owner. Replace the
     // whole device-bound frame projection so no stale cache/map/temporal view
@@ -366,10 +407,13 @@ export function createRenderSystemRecovery(
     // A successful clear-only draw can have no display camera. There is no
     // frame graph to rehydrate in that case, but the device generation is
     // still recoverable; the next camera-bearing draw will build its graph
-    // from the current World composition.
+    // from the current RenderResourceScope composition.
     if (camera === undefined) return { kind: 'no-seed' };
 
     const candidateFrameState = createRecoveryCandidateFrameState();
+    // Candidate graph generations are one renderer-owned allocation stream;
+    // publication changes their role, not their accounting owner.
+    shareRenderGraphGenerationAllocationOwner(frameState, candidateFrameState);
     resetStandardOutputForDeviceLoss(candidateFrameState, runtime.internals.deviceScope.generation);
     Object.assign(candidateFrameState, {
       temporalFrame: undefined,
@@ -382,6 +426,7 @@ export function createRenderSystemRecovery(
     let candidateFeatureHost: RenderFeatureHost | undefined;
     let candidateFeatureGpuWork: RenderFeatureGpuWorkOwner | undefined;
     let candidatePointsLines: RecoveryPointsLinesCandidate | undefined;
+    let candidateSurfacePage: ReadonlyDynamicInputPage | undefined;
     let candidateFeatureGraph: RenderFeatureGraphCandidate = {
       plans: Object.freeze([]),
       fullscreenEffects: new Map(),
@@ -401,12 +446,11 @@ export function createRenderSystemRecovery(
       if (pendingOutput !== undefined) retireAutoExposureGpuResources(pendingOutput);
       candidateFrameState.pendingAutoExposureGpuResources = undefined;
       for (const work of setupWorks) work.discard();
-      setupWorks.length = 0;
       const graph = candidateFrameState.compiledFrameGraph;
       candidateFrameState.compiledFrameGraph = null;
       candidateFrameState.perFrameGraph = null;
       try {
-        graph?.retire().catch(() => undefined);
+        if (graph !== null) retireCompiledGraph(candidateFrameState, graph);
       } catch {
         // Candidate cleanup continues through every independent owner.
       }
@@ -430,10 +474,21 @@ export function createRenderSystemRecovery(
       candidateGpuDrivenScene = undefined;
       candidatePointsLines?.release();
       candidatePointsLines = undefined;
+      candidateSurfacePage?.release();
+      candidateSurfacePage = undefined;
+      disposeInstanceBuffers(candidateFrameState.instanceBuffers, runtime.internals.errorRegistry);
+      if (candidateFrameState.instanceBufferChunks !== undefined) {
+        disposeInstanceBufferChunks(
+          candidateFrameState.instanceBufferChunks,
+          runtime.internals.errorRegistry,
+        );
+      }
       candidateGpuStore.destroyAll();
     };
     const markPublished = (): void => {
       candidatePointsLines?.publish();
+      candidateSurfacePage?.release();
+      candidateSurfacePage = undefined;
       candidatePublished = true;
     };
     const failed = (
@@ -449,7 +504,7 @@ export function createRenderSystemRecovery(
         candidateFrameState,
         runtime.internals,
         camera,
-        seed.worlds[seed.cameraOwner] as World,
+        seed.worlds[seed.cameraOwner] as RenderResourceScope,
       );
       if (!output.ok) return failed('candidate Standard output preparation failed', output.error);
       const gpuScene = persistentRenderScene.prepareRecoveryGpuDrivenCandidate(
@@ -457,11 +512,101 @@ export function createRenderSystemRecovery(
       );
       if (!gpuScene.ok) return failed('candidate GPU scene preparation failed', gpuScene.error);
       candidateGpuDrivenScene = gpuScene.value;
+      candidateValidated = validateRenderables(
+        runtime.internals,
+        seed.worlds[seed.cameraOwner] as RenderResourceScope,
+        seed.worlds,
+        runtime.pipelineState,
+        candidateFrameState,
+        seed.frame.renderables,
+        seed.frame.dispatch,
+      );
+      if (candidateValidated.length !== seed.frame.renderables.length) {
+        return failed('candidate validation did not retain every LKG-visible renderable');
+      }
+      const lighting = prepareFrameLighting(
+        runtime.internals,
+        candidateFrameState,
+        seed.frame.lights,
+        camera,
+        runtime.pipelineState,
+      );
+      if (!lighting.ok) return failed('candidate lighting preparation failed');
+      let recoverySurfaceDynamicInput = seed.surfaceDynamicInput;
+      if (
+        recoverySurfaceDynamicInput !== undefined &&
+        recoverySurfaceDynamicInput.page.deviceGeneration !==
+          runtime.internals.deviceScope.generation
+      ) {
+        const source = recoverySurfaceDynamicInput;
+        const created = ReadonlyDynamicInputPage.create({
+          sourceId: source.page.sourceId,
+          pageId: source.page.pageId,
+          schema: source.page.schema,
+        });
+        if (!created.ok) {
+          return failed('candidate Surface recovery page creation failed', created.error);
+        }
+        candidateSurfacePage = created.value;
+        // Preserve CPU-authored parameters before preparing the replacement GPU page.
+        candidateSurfacePage.bytes.set(source.page.bytes);
+        const reconfigured = candidateSurfacePage.reconfigureDevice(
+          runtime.internals.deviceScope.generation,
+        );
+        if (!reconfigured.ok) {
+          return failed('candidate Surface recovery page generation failed', reconfigured.error);
+        }
+        const ranges = (source.ranges ?? []).map((range) => {
+          const reserved = candidateSurfacePage?.reserveRange({
+            domain: range.domain,
+            recordStart: range.recordStart,
+            recordCount: range.recordCount,
+            instanceIndex: range.instanceIndex,
+            member: range.member,
+          });
+          if (reserved === undefined || !reserved.ok) {
+            throw reserved?.error ?? new Error('candidate Surface recovery range unavailable');
+          }
+          return reserved.value;
+        });
+        recoverySurfaceDynamicInput = {
+          page: candidateSurfacePage,
+          ranges,
+          projectionRevision: source.projectionRevision + 1,
+          frameTime: source.frameTime,
+        };
+      }
       if (candidateGpuDrivenScene.state !== undefined) {
         candidateGpuDrivenProduction = GpuDrivenProduction.forDevice(
           runtime.internals.device,
           gpuDrivenShaderFactory,
         );
+        const clustered = lighting.value.standard?.kind === 'clustered';
+        const standardVariantSet = standardTopologyVariantSet(
+          lighting.value.standard,
+          runtime.internals.device.caps.storageBuffer,
+          false,
+        );
+        const standardPbrArtifact = runtime.internals.getMaterialShaderArtifact?.(
+          'forgeax::default-standard-pbr',
+          {
+            vertexColorAvailable: false,
+            deformation: 'rigid',
+            pass: 'forward',
+            address: 'scene-index',
+            variantSet: standardVariantSet,
+          },
+        );
+        const standardPbrSkinArtifact = runtime.internals.getMaterialShaderArtifact?.(
+          'forgeax::pbr-skin',
+          {
+            vertexColorAvailable: false,
+            deformation: 'skin',
+            pass: 'forward',
+            address: 'scene-index',
+            variantSet: standardVariantSet,
+          },
+        );
         const shadowProjection = persistentRenderScene.shadowCasterProjection();
         // The retained scene owns prepared draw receipts. The extraction seed
         // precedes GPU admission and must not stand in for that projection.
@@ -482,20 +627,45 @@ export function createRenderSystemRecovery(
             },
             renderableIndex,
           }));
-        const { materialArtifacts, shadowMaterialArtifacts, firstArtifact, firstSkinArtifact } =
-          collectGpuDrivenMaterialArtifacts({
-            rows: artifactRows(seed.frame.renderables),
-            shadowRows: artifactRows(shadowProjection?.renderables ?? []),
-            dispatch: seed.frame.dispatch,
-            shadowDispatch: shadowProjection?.dispatch ?? seed.frame.dispatch,
-            resolve: runtime.internals.getMaterialShaderArtifact,
-            clustered:
-              seed.frame.lights.point.length +
-                seed.frame.lights.spot.length +
-                seed.frame.lights.rect.length >
-                0 || candidateFrameState.installedPipelineConfig?.ssao?.enabled === true,
-            reflectionFallback: candidateFrameState.reflectionFallbackDemand === true,
-          });
+        const collectedArtifacts = collectGpuDrivenMaterialArtifacts({
+          rows: artifactRows(seed.frame.renderables),
+          shadowRows: artifactRows(shadowProjection?.renderables ?? []),
+          dispatch: seed.frame.dispatch,
+          shadowDispatch: shadowProjection?.dispatch ?? seed.frame.dispatch,
+          resolve: runtime.internals.getMaterialShaderArtifact,
+          clustered:
+            seed.frame.lights.point.length +
+              seed.frame.lights.spot.length +
+              seed.frame.lights.rect.length >
+              0 || candidateFrameState.installedPipelineConfig?.ssao?.enabled === true,
+          reflectionFallback: candidateFrameState.reflectionFallbackDemand === true,
+        });
+        const materialArtifacts =
+          collectedArtifacts.materialArtifacts.size > 0
+            ? collectedArtifacts.materialArtifacts
+            : (seed.materialArtifacts ?? new Map());
+        const shadowMaterialArtifacts =
+          collectedArtifacts.shadowMaterialArtifacts.size > 0
+            ? collectedArtifacts.shadowMaterialArtifacts
+            : (seed.shadowMaterialArtifacts ?? new Map());
+        const firstMaterialArtifact = materialArtifacts.values().next().value as
+          | MaterialShaderArtifact
+          | undefined;
+        const firstSkinArtifact = [...materialArtifacts.values()].find(
+          (artifact) => artifact.receipt?.skinPaletteAddress !== undefined,
+        );
+        const firstArtifact = firstMaterialArtifact ?? standardPbrArtifact;
+        const materialSkinArtifact = firstSkinArtifact ?? standardPbrSkinArtifact;
+        const probeBlendRequested = [...materialArtifacts.values()].some((artifact) =>
+          requiresProbeBlendRecord(artifact),
+        );
+        const probeBlendRecordBuffer = probeBlendRequested
+          ? ensureProbeBlendRecordBuffer(
+              runtime.internals.device,
+              candidateFrameState,
+              candidateGpuDrivenScene.state.probeBlend,
+            )
+          : undefined;
         const prepared = candidateGpuDrivenProduction.prepare({
           scene: candidateGpuDrivenScene.state,
           camera,
@@ -507,11 +677,21 @@ export function createRenderSystemRecovery(
           ),
           viewBindGroupLayout: runtime.pipelineState.viewBindGroupLayout,
           meshResidencyEpoch: runtime.internals.gpuStore.meshResidencyEpoch,
-
+          hdrp:
+            clustered &&
+            ((lighting.value.standard?.prepared.local.length ?? 0) > 0 ||
+              candidateFrameState.installedPipelineConfig?.ssao?.enabled === true),
+          clustered,
           ...(firstArtifact === undefined ? {} : { materialArtifact: firstArtifact }),
-          ...(firstSkinArtifact === undefined ? {} : { materialSkinArtifact: firstSkinArtifact }),
+          ...(materialSkinArtifact === undefined ? {} : { materialSkinArtifact }),
           ...(materialArtifacts.size === 0 ? {} : { materialArtifacts }),
           ...(shadowMaterialArtifacts.size === 0 ? {} : { shadowMaterialArtifacts }),
+          ...(probeBlendRecordBuffer === undefined ? {} : { probeBlendRecordBuffer }),
+          ...(seed.frameTime === undefined ? {} : { frameTime: seed.frameTime }),
+          ...(recoverySurfaceDynamicInput === undefined
+            ? {}
+            : { surfaceDynamicInput: recoverySurfaceDynamicInput }),
+          deviceGeneration: runtime.internals.deviceScope.generation,
           materialPipelineState: runtime.pipelineState,
           ...(runtime.internals.getMaterialShaderPipelineEntry === undefined
             ? {}
@@ -520,6 +700,25 @@ export function createRenderSystemRecovery(
         if (!prepared.ok) return failed('candidate GPU-driven preparation failed', prepared.error);
         preparedGpuDriven = prepared.value;
       }
+      // A fully GPU-owned frame recovers through GPU Scene above. Only mixed
+      // or direct frames need the legacy instance-buffer closure as well.
+      if (!preparedGpuDriven?.ownsAllDrawItems || !preparedGpuDriven.ownsAllShadowCasters) {
+        for (const entry of candidateValidated) {
+          if (entry.source.instances === undefined) continue;
+          const prepared = resolveGeometryInstanceBuffer(
+            {
+              runtime: runtime.internals,
+              pipelineState: runtime.pipelineState,
+              frameState: candidateFrameState,
+              bindGroupCounts: { createBindGroup: 0, keys: [] },
+            },
+            entry,
+            [],
+            false,
+          );
+          if (prepared === null) return failed('candidate instance preparation failed');
+        }
+      }
       candidateFeatureHost = runtime.internals.featureHost;
       if (candidateFeatureHost !== undefined && candidateFeatureHost.size > 0) {
         candidateFeatureGpuWork = createFeatureGpuWorkOwner(runtime.internals);
@@ -529,11 +728,13 @@ export function createRenderSystemRecovery(
           colorAttachmentFormat: runtime.pipelineState.colorAttachmentFormat,
           storageBuffer: runtime.internals.device.caps.storageBuffer,
           multisample: runtime.internals.device.caps.backendKind !== 'wgpu-webgl2',
+          cloudHistory: seed.frame.cloudLayer !== undefined,
         });
         const featureFrame = runRenderFeatureFrame(candidateFeatureHost, {
-          worlds: seed.worlds,
+          worlds: seed.worlds.filter((world): world is World => !('resolveAsset' in world)),
           owner: seed.resourceOwner,
           frameNumber: candidateFrameState.frameNumber,
+          selectedCamera: camera,
           frameSize: {
             width: runtime.internals.canvas.width,
             height: runtime.internals.canvas.height,
@@ -557,7 +758,7 @@ export function createRenderSystemRecovery(
           gpuWork: candidateFeatureGpuWork,
         });
         if (featureFrame.errors.length > 0) {
-          return failed('candidate render-feature preparation failed');
+          return failed('candidate render-feature preparation failed', featureFrame.errors[0]);
         }
         const featurePreparationIncomplete = featureFrame.plans.some((planned) => {
           const execution = getRenderFeaturePlanExecutionProjection(planned);
@@ -586,6 +787,7 @@ export function createRenderSystemRecovery(
         candidateFeatureGraph = {
           plans: featureFrame.plans,
           fullscreenEffects: featureFrame.fullscreenEffects,
+          postProcessIdentities: featureFrame.postProcessIdentities,
           ...(batches.length === 0
             ? {}
             : { preparedResourceKey: `recovery-${runtime.internals.deviceScope.generation}` }),
@@ -678,26 +880,6 @@ export function createRenderSystemRecovery(
           }
         }
       }
-      candidateValidated = validateRenderables(
-        runtime.internals,
-        resourceWorld,
-        seed.worlds,
-        runtime.pipelineState,
-        candidateFrameState,
-        seed.frame.renderables,
-        seed.frame.dispatch,
-      );
-      if (candidateValidated.length !== seed.frame.renderables.length) {
-        return failed('candidate validation did not retain every LKG-visible renderable');
-      }
-      const lighting = prepareFrameLighting(
-        runtime.internals,
-        candidateFrameState,
-        seed.frame.lights,
-        camera,
-        runtime.pipelineState,
-      );
-      if (!lighting.ok) return failed('candidate lighting preparation failed');
       candidatePointsLines = pointsLinesOwner.prepareRecoveryCandidate(
         candidateValidated,
         lighting.value.standard?.kind === 'clustered',
@@ -723,7 +905,11 @@ export function createRenderSystemRecovery(
       });
       const candidatePostProcessIds = new Set<string>([
         ...(candidateFrameState.installedPipelineConfig?.postEffects ?? []),
-        ...candidateFeatureGraph.fullscreenEffects.keys(),
+        // Required identities include effects disabled for this frame. Warm only
+        // published entries, using their public identity rather than graph aliases.
+        ...(candidateFeatureGraph.postProcessIdentities ?? []).filter((id) =>
+          candidateFeatureGraph.fullscreenEffects.has(id),
+        ),
       ]);
       const configuredPostEffects = candidateFrameState.installedPipelineConfig?.postEffects ?? [];
       const postProcessPipeline = runtime.internals.getPostProcessPipeline;
@@ -855,6 +1041,13 @@ export function createRenderSystemRecovery(
         (error) => {
           recoveryGraphFailure ??= error;
         },
+        undefined,
+        undefined,
+        false,
+        false,
+        seed.frame.cloudLayer === undefined
+          ? undefined
+          : cloudShadowResolutionForQuality(seed.frame.cloudLayer.params.quality),
       );
       if (graph === null) return failed('candidate frame graph compilation failed');
       if (recoveryReadiness === undefined)

package/src/reflection/record-owner.ts

@@ -397,9 +397,13 @@ export class ReflectionProbeRecordOwner {
     this.lastFactCount = facts.length;
     this.lastScheduledRawFaces = 0;
     this.lastScheduledFilteredSteps = 0;
-    const firstSelection = selections.values().next().value as
-      | ReflectionProbeSelectionResult
-      | undefined;
+    // The fallback MRT has one representative readback, so choose a stable
+    // non-neutral probe consumer when the scene contains one. Renderable map
+    // order is not a source-selection contract: the first entry is commonly
+    // an outside panel while the local probe consumer appears later.
+    const firstSelection =
+      [...selections.values()].find((selection) => selection.kind === 'probe') ??
+      (selections.values().next().value as ReflectionProbeSelectionResult | undefined);
     this.lastSelection =
       firstSelection?.kind === 'probe'
         ? {