@forgeax/engine-render 0.1.32 → 0.1.33

package/src/render-system.ts

@@ -39,6 +39,7 @@ import {
   projectDirectionalShadowInspectionSource,
 } from './assembly/directional-shadow-inspection';
 import { createGpuDrivenOwner } from './assembly/gpu-driven-owner';
+import { standardBloomAdmitted } from './bloom-admission';
 import { createClusterBinScratch } from './cluster-binner';
 import { EnvironmentLifecycle } from './environment/lifecycle';
 import {
@@ -48,11 +49,24 @@ 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 { reportPendingRenderFeatureErrors } from './features/error-reporting';
 import {
   type RenderFeaturePreparedGraphicsResolverInput,
   runRenderFeatureFrame,
   settlePreparedGraphicsCompletion,
 } from './features/host';
+import {
+  createMotionBlurFeature,
+  type MotionBlurFeatureInput,
+} from './features/motion-blur/motion-blur-feature';
+import {
+  MotionBlurValidationError,
+  motionBlurTemporalDemand,
+} from './features/motion-blur/motion-blur-params';
+import {
+  planMotionBlurFrame,
+  projectMotionBlurInspection,
+} from './features/motion-blur/motion-blur-runtime';
 import { createFeatureNoiseResolver } from './features/noise-texture';
 import {
   createRenderFeatureGpuWorkOwner,
@@ -83,6 +97,7 @@ import type {
   TemporalTargetInspection,
   TransmissionInspection,
 } from './inspection-types';
+import { emptyBloomInspection } from './inspection-types';
 import { buildOcclusionProxyVertices } from './occlusion-proxy';
 import {
   AUTO_EXPOSURE_HISTOGRAM_BYTES,
@@ -542,7 +557,10 @@ export interface RenderSystem {
     options: FrameObservationOptions,
   ): Promise<Result<FrameObservation, ObservationUnavailableError>>;
   /** Resolve the renderer-owned GPU LOD counters for the last accepted submit. */
-  observeLodOcclusion(): Promise<void>;
+  observeLodOcclusion(receipt?: {
+    readonly frameId: number;
+    readonly deviceGeneration: number;
+  }): Promise<void>;
   /** Internal same-frame graph target access for backend diagnostics. */
   getCurrentGraphTarget(name: string): CurrentGraphTarget | undefined;
   /** Internal test capture copied into the draw's command submission. */
@@ -580,6 +598,8 @@ export interface RenderSystem {
   readonly temporal: TemporalInspection;
   readonly bloom: BloomInspection;
   readonly motionBlurInspection: MotionBlurInspection | undefined;
+  /** The last extraction validation failure, preserved for public draw(). */
+  readonly motionBlurInvalidParams: MotionBlurValidationError | undefined;
   readonly depthOfFieldInspection: DepthOfFieldInspection | undefined;
   readonly temporalTargetInspection: TemporalTargetInspection | undefined;
   readonly lodOcclusionInspection: LodOcclusionInspection | undefined;
@@ -723,13 +743,6 @@ function reportPreparedGraphicsCompletionError(
   );
 }
 
-function isPendingRenderFeaturePreparation(error: RenderError): boolean {
-  return (
-    error.code === 'render-feature-preparation-failed' &&
-    error.detail.reason.startsWith('rhi-not-available:')
-  );
-}
-
 function makePreparedPipelinePendingError(): RhiError {
   return new RhiError({
     code: 'rhi-not-available',
@@ -897,6 +910,24 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   let preparedFeatureSkylightResources: SkylightBindGroupResources | undefined;
   const dynamicGeometryFrames = createDynamicGeometryFrameBindings();
   let latestCamera: CameraSnapshot | undefined;
+  // Last public parameter failure; cleared only after a valid extraction.
+  let lastMotionBlurInvalidParams: MotionBlurValidationError | undefined;
+  // Lazily install the compute lane when a capable frame demands it.
+  let motionBlurFeatureInput: MotionBlurFeatureInput | undefined;
+  const motionBlurFeature = createMotionBlurFeature(() => motionBlurFeatureInput);
+  const ensureMotionBlurFeature = (): void => {
+    const host = internals.featureHost;
+    if (
+      host === undefined ||
+      host.features.some((feature) => feature.identity === 'forgeax.motion-blur')
+    ) {
+      return;
+    }
+    const installed = host.install(
+      motionBlurFeature as import('./features/types').RenderFeature<unknown>,
+    );
+    if (!installed.ok) internals.errorRegistry.fire(installed.error);
+  };
   const pointsLinesOwner = new StandardPointsLinesOwner(internals);
   const instanceCollections = new InstanceCollectionStore();
   const reflectionProbeOwner = new ReflectionProbeRecordOwner(internals);
@@ -1291,6 +1322,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     // tiles until the first frame with a castShadow spot (AC-03).
     spotShadowSnapshots: [],
   };
+  // A feature that is explicitly recoverable on the next frame must not
+  // publish the same transient failure on every render tick. Keep one
+  // renderer-owned cooldown per structured feature failure while retaining
+  // the original error for the first and periodic reports.
+  const pendingFeatureErrorLastReportedFrame = new Map<string, number>();
   const resolveSsrDependencies = (requested: boolean): SsrDependenciesInspection => {
     // Explicit SSR capability preparation belongs to initialization. Inspection
     // only projects receipts and never starts work or creates image history.
@@ -1752,6 +1788,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           readonly visible: number;
           readonly occluded: number;
           readonly lodHistogram: readonly { readonly level: number; readonly count: number }[];
+          readonly submit?: { readonly frameId: number; readonly deviceGeneration: number };
           readonly worldSelections?: readonly {
             readonly worldKey: number;
             readonly primitiveSlot: number;
@@ -1763,9 +1800,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           }[];
         }
       | undefined,
+    targetInspection: LodOcclusionInspection | undefined = lastLodOcclusionInspection,
+    targetWorldAttachments: ReadonlyMap<number, string> = lastLodWorldAttachments,
   ): void => {
-    if (selection === undefined || lastLodOcclusionInspection === undefined) return;
-    const inspection = lastLodOcclusionInspection;
+    if (selection === undefined || targetInspection === undefined) return;
+    const inspection = targetInspection;
     // The GPU readback histogram is the selector fact, while final submitted
     // counts are owned by the persistent visibility projection. Keeping the
     // projection count here excludes ordinary non-LOD geometry (for example a
@@ -1777,7 +1816,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       const selectionsByAttachment = new Map<string, (typeof worldSelections)[number][]>();
       let attributionValid = true;
       for (const selected of worldSelections) {
-        const attachmentId = lastLodWorldAttachments.get(selected.worldKey);
+        const attachmentId = targetWorldAttachments.get(selected.worldKey);
         if (attachmentId === undefined) {
           attributionValid = false;
           break;
@@ -1790,15 +1829,16 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         const nextWorlds = worlds.map((world) => {
           const selected = selectionsByAttachment.get(world.attachmentId);
           const baseRow = world.rows[0];
-          if (selected === undefined || baseRow === undefined) {
-            if (world.rows.length > 0) attributionValid = false;
-            return world;
-          }
-          const candidateCount = selected.reduce((sum, row) => sum + row.candidateCount, 0);
-          if (candidateCount !== baseRow.count.candidates) {
-            attributionValid = false;
-            return world;
-          }
+          // A World with only plain meshes has no LOD selection row. Keep its
+          // projection-only receipt and allow Worlds with valid LOD rows to
+          // retain same-submit attribution. Unknown selected world keys still
+          // fail closed above.
+          if (selected === undefined || baseRow === undefined) return world;
+          // The projection row is intentionally CPU-scoped and may omit
+          // selector-only candidates that remain in the full GPU plan. The
+          // same-submit GPU row owns the denominator; comparing it to the
+          // projection count would reject a valid receipt (for example 11 GPU
+          // candidates versus 10 CPU-admitted renderables).
           return Object.freeze({
             ...world,
             attribution: Object.freeze({
@@ -1828,7 +1868,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     lastLodOcclusionInspection = inspectLodOcclusion({
       ...inspection,
       count: {
-        ...lastLodOcclusionInspection.count,
+        ...inspection.count,
         candidates: selection.candidateCount,
         visible: selection.visible,
         occluded: selection.occluded,
@@ -2274,24 +2314,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       });
     },
     get motionBlurInspection(): MotionBlurInspection | undefined {
-      const camera = latestCamera;
-      if (camera?.motionBlur === undefined) return undefined;
-      const demanded = camera.motionBlur.shutterAngle > 0;
-      const unavailable = demanded && !internals.device.caps.rgba16floatRenderable;
-      const admitted =
-        frameState.activeTemporalGpuState !== undefined ||
-        frameState.temporalGpuState !== undefined;
-      return {
-        enabled: demanded,
-        status: !demanded ? 'off' : unavailable || !admitted ? 'reset' : 'active',
-        shutterAngle: camera.motionBlur.shutterAngle,
-        maxRadiusPixels: camera.motionBlur.maxRadiusPixels,
-        sampleCount: camera.motionBlur.sampleCount,
-        temporalDemand: demanded ? 'scene-data-temporal-v1' : 'none',
-        passName: 'motion-blur',
-        historyWrites: 0,
-        ...(unavailable ? { lastFailure: 'scene-data-unavailable' as const } : {}),
-      };
+      return projectMotionBlurInspection({
+        camera: latestCamera,
+        invalidParams: lastMotionBlurInvalidParams,
+        capabilities: internals.device.caps,
+        acceptedTemporal: frameState.lastSuccessfulTemporalView,
+        transaction: frameState.temporalFrameTransaction.inspect(),
+        execution: frameState.motionBlurExecution,
+        temporalFrameId: frameState.temporalFrame?.frameId,
+        deviceGeneration: internals.deviceScope.generation,
+        graphGeneration: frameState.graphGeneration,
+      });
+    },
+    get motionBlurInvalidParams(): MotionBlurValidationError | undefined {
+      return lastMotionBlurInvalidParams;
     },
     get depthOfFieldInspection(): DepthOfFieldInspection | undefined {
       const camera = latestCamera;
@@ -2354,22 +2390,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       const lifecycle = resources?.inspectBloomResources?.(
         frameState.compiledFrameGraph?.inspect(),
       );
-      return Object.freeze(
-        lifecycle ?? {
-          graphStatus: 'empty',
-          enabled: false,
-          targetCount: 0,
-          targetBytes: 0,
-          resourceCount: 0,
-          passCount: 0,
-          encodeCount: 0,
-          bindGroupCount: 0,
-          uploadCount: 0,
-          residentChildBytes: 0,
-          generation: 0,
-          state: 'off',
-        },
-      );
+      return Object.freeze(lifecycle ?? emptyBloomInspection());
     },
     get transmission(): TransmissionInspection | undefined {
       return lastTransmissionInspection;
@@ -2444,6 +2465,10 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       const profileSession = internals.profiler?.activeSession();
       let ownsProfileFrame = false;
       let submitted = false;
+      // A prior failed record/submit may have staged a temporal capture. A
+      // capture belongs only to the draw call that created it; discard it
+      // before this call can prepare or commit a new candidate.
+      persistentRenderScene.discardTemporalFrame();
       // A failed draw must never leave a previous frame eligible to publish a
       // newly accepted dynamic-geometry candidate.
       dynamicGeometryFrames.begin();
@@ -2475,55 +2500,67 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         dispatchCounts.unlit = 0;
 
         const resourceWorld = compositionWorlds[resourceOwner] as World;
-        const frame = runProfiledRenderPhase(profileSession, 'extract', () => {
-          return persistentRenderScene.extractComposition(
-            compositionWorlds,
-            { cameraOwner, resourceOwner },
-            internals.assets.catalogEpoch,
-            (renderables) =>
-              extractFrames(
-                compositionWorlds,
-                {
-                  cameraOwner,
-                  resourceOwner,
-                  ...(cameraEntityKey === undefined ? {} : { cameraEntityKey }),
-                },
-                internals.assets,
-                internals.getPipelineState(),
-                persistentRenderScene.materialSnapshotCacheStore(),
-                {
-                  ...(internals.device.caps.backendKind === 'null'
-                    ? {}
-                    : {
-                        materialContext: {
-                          backend:
-                            internals.device.caps.backendKind === 'wgpu-webgl2'
-                              ? ('webgl2' as const)
-                              : internals.device.caps.backendKind,
-                          capability: internals.device.caps.storageBuffer
-                            ? ('storage-buffer' as const)
-                            : ('uniform-fallback' as const),
-                          pipeline: 'forward' as const,
-                          geometry: 'mesh' as const,
-                          pass: 'forward' as const,
-                          profile: 'forgeax-material-wgsl-v1' as const,
-                          toolchain: 'naga-oil' as const,
-                          instrumentation: 'none' as const,
-                        },
-                      }),
-                  cull: 'none',
-                  retainHidden: true,
-                  renderables,
-                  instanceCollections,
-                  ...(!internals.device.caps.storageBuffer ||
-                  internals.getMaterialShaderArtifact === undefined
-                    ? {}
-                    : { getMaterialShaderArtifact: internals.getMaterialShaderArtifact }),
-                },
-              ),
-            compositionLeases,
-          );
-        });
+        let frame: ReturnType<PersistentRenderScene['extractComposition']>;
+        try {
+          frame = runProfiledRenderPhase(profileSession, 'extract', () => {
+            return persistentRenderScene.extractComposition(
+              compositionWorlds,
+              { cameraOwner, resourceOwner },
+              internals.assets.catalogEpoch,
+              (renderables) =>
+                extractFrames(
+                  compositionWorlds,
+                  {
+                    cameraOwner,
+                    resourceOwner,
+                    ...(cameraEntityKey === undefined ? {} : { cameraEntityKey }),
+                  },
+                  internals.assets,
+                  internals.getPipelineState(),
+                  persistentRenderScene.materialSnapshotCacheStore(),
+                  {
+                    ...(internals.device.caps.backendKind === 'null'
+                      ? {}
+                      : {
+                          materialContext: {
+                            backend:
+                              internals.device.caps.backendKind === 'wgpu-webgl2'
+                                ? ('webgl2' as const)
+                                : internals.device.caps.backendKind,
+                            capability: internals.device.caps.storageBuffer
+                              ? ('storage-buffer' as const)
+                              : ('uniform-fallback' as const),
+                            pipeline: 'forward' as const,
+                            geometry: 'mesh' as const,
+                            pass: 'forward' as const,
+                            profile: 'forgeax-material-wgsl-v1' as const,
+                            toolchain: 'naga-oil' as const,
+                            instrumentation: 'none' as const,
+                          },
+                        }),
+                    cull: 'none',
+                    retainHidden: true,
+                    renderables,
+                    instanceCollections,
+                    ...(!internals.device.caps.storageBuffer ||
+                    internals.getMaterialShaderArtifact === undefined
+                      ? {}
+                      : { getMaterialShaderArtifact: internals.getMaterialShaderArtifact }),
+                  },
+                ),
+              compositionLeases,
+            );
+          });
+        } catch (cause) {
+          if (cause instanceof MotionBlurValidationError) {
+            lastMotionBlurInvalidParams = cause;
+            latestCamera = undefined;
+            internals.errorRegistry.fire(cause);
+            return false;
+          }
+          throw cause;
+        }
+        lastMotionBlurInvalidParams = undefined;
         const {
           cameras: extractedCameras,
           cubeCameras,
@@ -2760,6 +2797,15 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         const submissionRenderables = visibilityProjection.renderables;
         const submissionDispatch = visibilityProjection.dispatch;
         const inspectionCamera = latestCamera;
+        // The public frame receipt is allocated by WebGPURenderer immediately
+        // before this draw (`observationFrameId`). RenderSystem's private
+        // frameNumber is an internal generation and also advances on failed
+        // record attempts, so it cannot be used as receipt identity. Keep the
+        // internal generation for recovery/visibility state, but bind the LOD
+        // inspection to the frame id that the caller will receive.
+        const lodSubmitFrameId =
+          (internals as RenderSystemInternals & { readonly observationFrameId?: number })
+            .observationFrameId ?? frameState.frameNumber;
         let lodCandidateCountForFrame = 0;
         if (inspectionCamera !== undefined) {
           const firstRenderable = renderables[0];
@@ -2802,7 +2848,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             renderables,
             submissionRenderables,
             inspectionCamera,
-            frameState.frameNumber,
+            lodSubmitFrameId,
             worldKeys,
             slotByEntity,
             {
@@ -2834,7 +2880,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 firstRenderable === undefined
                   ? 'none'
                   : `asset-handle:${firstRenderable.assetHandle}`,
-              sourceKey: `render-frame:${frameState.frameNumber}`,
+              sourceKey: `render-frame:${lodSubmitFrameId}`,
             },
             view: {
               attachmentId:
@@ -2847,7 +2893,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               primitiveSlot: 0,
               slotGeneration: persistentRenderScene.inspect().topology.revision,
             },
-            generation: frameState.frameNumber,
+            generation: lodSubmitFrameId,
             count: {
               candidates: candidateCount,
               visible: inspectionRenderables.length,
@@ -2866,7 +2912,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               visible: true,
             })),
             submit: {
-              frameId: frameState.frameNumber,
+              frameId: lodSubmitFrameId,
               build: resolveInspectionBuild(internals),
               deviceGeneration: internals.deviceScope.generation,
             },
@@ -2878,7 +2924,14 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           lastLodWorldAttachments = new Map();
         }
         const temporalDemanded =
-          cameras[0]?.antialias === 'taa' || (cameras[0]?.motionBlur?.shutterAngle ?? 0) > 0;
+          cameras[0]?.antialias === 'taa' ||
+          (cameras[0]?.motionBlur !== undefined &&
+            motionBlurTemporalDemand({
+              shutterAngle: cameras[0].motionBlur.shutterAngle,
+              maxRadiusPixels: cameras[0].motionBlur.maxRadiusPixels,
+              sampleCount: cameras[0].motionBlur.sampleCount,
+              targetFps: cameras[0].motionBlur.targetFps ?? 60,
+            }));
         if (temporalDemanded) {
           persistentRenderScene.prepareTemporalFrame(submissionRenderables);
         }
@@ -2989,6 +3042,44 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 storageBuffer: internals.device.caps.storageBuffer,
                 multisample: internals.device.caps.backendKind !== 'wgpu-webgl2',
               });
+        const motionBlurParams = cameras[0]?.motionBlur;
+        let motionBlurDelta = 0;
+        try {
+          const delta = (compositionWorlds[cameraOwner] as World).getResource(Time).delta;
+          motionBlurDelta = Number.isFinite(delta) ? Math.max(0, delta) : 0;
+        } catch {
+          motionBlurDelta = 0;
+        }
+        const acceptedSampleTime = frameState.lastSuccessfulTemporalView?.sampleTimeSeconds;
+        const cameraViewIdentity = `camera:${cameras[0]?.entityKey ?? 0}`;
+        const canvasWidth = Math.max(1, internals.canvas.width);
+        const canvasHeight = Math.max(1, internals.canvas.height);
+        const motionBlurPlan = planMotionBlurFrame({
+          params: motionBlurParams,
+          sampleTimeSeconds: opts.sampleTimeSeconds,
+          acceptedSampleTimeSeconds: acceptedSampleTime,
+          fallbackDeltaSeconds: motionBlurDelta,
+          acceptedTemporal: frameState.lastSuccessfulTemporalView,
+          temporalReset: opts.temporalReset === true,
+          width: canvasWidth,
+          height: canvasHeight,
+          cameraViewIdentity,
+          historyVersion: cameras[0]?.historyVersion ?? 0,
+          environmentSignature: environment?.environmentSignature ?? '',
+          fogSignature: environment?.fogSignature ?? '',
+          deviceGeneration: internals.deviceScope?.generation ?? 0,
+        });
+        const demandedMotionBlur = motionBlurPlan.demanded;
+        motionBlurFeatureInput = motionBlurPlan.featureInput;
+        if (
+          demandedMotionBlur &&
+          internals.device.caps.compute === true &&
+          internals.device.caps.storageBuffer === true &&
+          internals.device.caps.storageTexture === true &&
+          internals.device.caps.rgba16floatRenderable === true
+        ) {
+          ensureMotionBlurFeature();
+        }
         preparedFeatureSkylightResources =
           preparedPipelineState === null
             ? undefined
@@ -3001,6 +3092,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             worlds: compositionWorlds,
             owner: resourceOwner,
             frameNumber: frameState.frameNumber,
+            frameSize: { width: internals.canvas.width, height: internals.canvas.height },
             visibilitySnapshots: frame.featureVisibilitySnapshots,
             hiddenEntityReports: frame.hiddenEntityReports,
             targets: featureTargets,
@@ -3035,11 +3127,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             gpuWork: featureGpuWork,
           });
           lastVisibilityStats.explicitlyHidden = featureFrame.hiddenEntityReports.length;
-          for (const featureError of featureFrame.errors) {
-            if (!isPendingRenderFeaturePreparation(featureError)) {
-              internals.errorRegistry.fire(featureError);
-            }
-          }
+          reportPendingRenderFeatureErrors(
+            featureFrame.errors,
+            frameState.frameNumber,
+            pendingFeatureErrorLastReportedFrame,
+            internals.errorRegistry,
+          );
           const postProcessParamsCandidate = preparePostProcessParamsResources(
             featureFrame.fullscreenEffects,
           );
@@ -3172,7 +3265,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 }
                 return runProfiledRenderPhase(profileSession, phase, action);
               };
-        if (cameras[0]?.bloom === 'on') {
+        const bloomAdmitted = standardBloomAdmitted(cameras[0]);
+        if (bloomAdmitted) {
           internals.getPipelineState()?.perPassResources.ensureBloomResources?.();
         }
         const liveOutput = cameras[0]?.output;
@@ -3226,6 +3320,10 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               activeEntityKeys: visibilityProjection.activeEntityKeys,
               activeEntityRevision: visibilityProjection.activeEntityRevision,
               telemetryCandidateCount: lodCandidateCountForFrame,
+              telemetrySubmit: {
+                frameId: lodSubmitFrameId,
+                deviceGeneration: internals.deviceScope.generation,
+              },
               ...(occlusionProjection === undefined ? {} : { occlusion: occlusionProjection }),
             },
             compositionLeases,
@@ -3254,6 +3352,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             undefined,
             ssrDependencies,
             dynamicGeometryFrames.onRenderableDraw(compositionWorlds),
+            environment?.fog,
+            opts.sampleTimeSeconds,
+            opts.temporalReset === true,
           ),
         );
         dynamicGeometryFrames.commit(submitted);
@@ -3341,7 +3442,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             frameState.depthOfFieldLastSubmitFailed = true;
           }
           internals.getPipelineState()?.perPassResources.commitBloomResources?.();
-          const nextBloom = cameras[0]?.bloom ?? 'off';
+          const nextBloom = bloomAdmitted ? 'on' : 'off';
           if (frameState.lastSuccessfulBloom === 'on' && nextBloom !== 'on') {
             internals
               .getPipelineState()
@@ -3406,6 +3507,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           }),
         );
       } finally {
+        if (!submitted) persistentRenderScene.discardTemporalFrame();
         internals.recoveryColdWorkGuard?.endFrame();
         if (ownsProfileFrame) {
           try {
@@ -3424,13 +3526,46 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       const currentFrameId = frameState.frameNumber - 1;
       return observeCurrentFrame(options, frameState.currentFrameObservationSource, currentFrameId);
     },
-    async observeLodOcclusion(): Promise<void> {
+    async observeLodOcclusion(receipt?: {
+      readonly frameId: number;
+      readonly deviceGeneration: number;
+    }): Promise<void> {
+      const capturedInspection = lastLodOcclusionInspection;
+      const capturedWorldAttachments = lastLodWorldAttachments;
+      if (capturedInspection === undefined) return;
+      if (
+        receipt !== undefined &&
+        (capturedInspection.submit.frameId !== receipt.frameId ||
+          capturedInspection.submit.deviceGeneration !== receipt.deviceGeneration)
+      )
+        return;
       await ensureOcclusionRuntime().waitForCompletions();
-      applyLodSelectionTelemetry(await gpuDrivenProduction.readLodSelection());
-      if (lastLodOcclusionInspection !== undefined) {
+      if (lastLodOcclusionInspection !== capturedInspection) return;
+      const selection = await gpuDrivenProduction.readLodSelection();
+      if (lastLodOcclusionInspection !== capturedInspection || selection === undefined) return;
+      if (
+        selection.submit !== undefined &&
+        (selection.submit.frameId !== capturedInspection.submit.frameId ||
+          selection.submit.deviceGeneration !== capturedInspection.submit.deviceGeneration)
+      )
+        return;
+      if (
+        receipt !== undefined &&
+        (selection.submit === undefined ||
+          selection.submit.frameId !== receipt.frameId ||
+          selection.submit.deviceGeneration !== receipt.deviceGeneration)
+      )
+        return;
+      applyLodSelectionTelemetry(selection, capturedInspection, capturedWorldAttachments);
+      const published = lastLodOcclusionInspection;
+      if (
+        published !== undefined &&
+        published.submit.frameId === capturedInspection.submit.frameId &&
+        published.submit.deviceGeneration === capturedInspection.submit.deviceGeneration
+      ) {
         const queryLatency = ensureOcclusionRuntime().inspectQueryLatency();
         lastLodOcclusionInspection = inspectLodOcclusion({
-          ...lastLodOcclusionInspection,
+          ...published,
           queryLatencyUs: {
             median: queryLatency.median,
             p95: queryLatency.p95,