@forgeax/engine-render 0.1.21 → 0.1.23

package/src/record/frame.ts

@@ -29,11 +29,12 @@ import {
   type ObservationUnavailableReason,
   RendererOperationError,
 } from '../errors/render';
-import type { FogFrame } from '../extract/environment';
 import type { GpuDrivenProduction, PreparedGpuDrivenFrame } from '../gpu-driven/production-raster';
 import { GpuBuffer } from '../gpu-resource';
+import { GPU_TEXTURE_USAGE_COPY_SRC } from '../gpu-texture-usage';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
+  GPU_BUFFER_USAGE_MAP_READ,
   GPU_BUFFER_USAGE_UNIFORM,
   GPU_BUFFER_USAGE_VERTEX,
 } from '../gpu-usage';
@@ -58,6 +59,7 @@ import type {
   SkylightSnapshot,
 } from '../render-system-extract';
 import type { PersistentGpuDrivenState } from '../scene/render-scene';
+import type { OcclusionFrameProjection } from '../scene/visibility/occlusion-runtime';
 import { SHADOW_ATLAS_DEFAULT_LAYERS } from '../shadow-atlas';
 import {
   getTransparentSortConfig,
@@ -75,6 +77,7 @@ import {
   warnZeroLightStandard,
   writeHdrpClusterAndSsaoBuffers,
   writeShadowParamsBuffer,
+  writeSpotModifierTextures,
 } from './frame-lighting';
 import {
   type BindGroupCounts,
@@ -82,9 +85,12 @@ import {
   type DirectionalShadowWorldState,
   type DispatchCounts,
   type FrameObservationSource,
+  getTextureIdentity,
   makeZeroCameraFallbackSnapshot,
+  type ReflectionFallbackReadbackRequest,
   type RenderFrameState,
   type ValidatedRenderable,
+  validateGraphTargetCaptureReadback,
   worldEntityKey,
 } from './frame-snapshot';
 // feat-20260622-chunk-gpu-instancing-sprite-tilemap M1 / w4 (D-1 record-stage
@@ -246,6 +252,75 @@ import {
   writeViewUbo,
 } from './view-ubo';
 
+/**
+ * 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.
+ */
+function gpuDrivenMeshesForFrame(
+  internals: RenderSystemInternals,
+  pipelineState: PipelineState,
+  worlds: readonly World[],
+  scene: PersistentGpuDrivenState | undefined,
+): ReadonlyMap<number, MeshGpuHandles> {
+  const meshes = new Map(pipelineState.meshes);
+  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);
+    let gpu = internals.gpuStore.getMeshGpuHandles(sharedHandle, world);
+    if (gpu === undefined && !meshes.has(assetHandle)) {
+      const asset = resolveAssetHandle<MeshAsset>(world, sharedHandle);
+      if (asset.ok) {
+        const lodMeshes = slot.snapshot.lods?.map((lod) =>
+          internals.assets.lookup<MeshAsset>(lod.mesh),
+        );
+        const resolvedLodMeshes =
+          lodMeshes?.every((lod): lod is MeshAsset => lod?.kind === 'mesh') === true
+            ? lodMeshes
+            : undefined;
+        const resident = internals.gpuStore.ensureResident(
+          sharedHandle,
+          asset.value,
+          world,
+          resolvedLodMeshes,
+        );
+        if (resident.ok) gpu = resident.value;
+      }
+    }
+    if (gpu !== undefined) meshes.set(assetHandle, gpu);
+  }
+  const value = meshes;
+  gpuDrivenMeshCache.set(scene.scene, {
+    meshResidencyEpoch: internals.gpuStore.meshResidencyEpoch,
+    pipelineMeshes: pipelineState.meshes,
+    value,
+  });
+  return value;
+}
+
+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.
@@ -388,6 +463,135 @@ function runRecordProfilePhase<T>(
   return runner === undefined ? action() : runner(phase, action);
 }
 
+function halfFloatToNumber(bits: number): number {
+  const sign = (bits & 0x8000) === 0 ? 1 : -1;
+  const exponent = (bits >>> 10) & 0x1f;
+  const fraction = bits & 0x03ff;
+  if (exponent === 0) return sign * 2 ** -14 * (fraction / 1024);
+  if (exponent === 0x1f) return fraction === 0 ? sign * Infinity : Number.NaN;
+  return sign * 2 ** (exponent - 15) * (1 + fraction / 1024);
+}
+
+function createReflectionFallbackReadbackRequest(
+  internals: RenderSystemInternals,
+  frameState: RenderFrameState,
+): ReflectionFallbackReadbackRequest | undefined {
+  if (!frameState.reflectionFallbackDemand || frameState.reflectionFallbackReadback !== undefined) {
+    return undefined;
+  }
+  const graph = frameState.perFrameGraph;
+  if (graph === undefined || graph === null) return undefined;
+  const descriptor = graph.getColorTargetDescriptor('reflection-fallback-linear-hdr');
+  const texture = graph.getColorTargetTexture('reflection-fallback-linear-hdr');
+  if (
+    descriptor === undefined ||
+    texture === undefined ||
+    descriptor.format !== 'rgba16float' ||
+    descriptor.sample !== 1
+  ) {
+    return undefined;
+  }
+  const bytesPerRow = Math.ceil((descriptor.size.width * 8) / 256) * 256;
+  const created = internals.device.createBuffer({
+    label: 'reflection-fallback-linear-hdr.readback',
+    size: bytesPerRow * descriptor.size.height,
+    usage: GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ,
+    mappedAtCreation: false,
+  });
+  if (!created.ok) {
+    internals.errorRegistry.fire(created.error);
+    return undefined;
+  }
+  return {
+    name: 'reflection-fallback-linear-hdr',
+    buffer: created.value,
+    bytesPerRow,
+    width: descriptor.size.width,
+    height: descriptor.size.height,
+    expected: {
+      format: descriptor.format,
+      width: descriptor.size.width,
+      height: descriptor.size.height,
+      usage: GPU_TEXTURE_USAGE_COPY_SRC,
+      graphGeneration: graph.graphGeneration,
+      frameId: frameState.frameNumber,
+      textureIdentity: getTextureIdentity(texture),
+    },
+    encoded: false,
+  };
+}
+
+async function mapReflectionFallbackReadback(
+  internals: RenderSystemInternals,
+  request: ReflectionFallbackReadbackRequest,
+  allowZero: boolean,
+): Promise<{
+  readonly linearHdr: readonly [number, number, number, number];
+  readonly hash: string;
+  readonly graphGeneration: number;
+  readonly textureIdentity: number;
+}> {
+  try {
+    if (!request.encoded) throw new Error('reflection fallback copy was not encoded');
+    const mapped = await request.buffer.mapAsync(GPU_BUFFER_USAGE_MAP_READ);
+    if (!mapped.ok) throw mapped.error;
+    const range = mapped.value.getMappedRange();
+    if (!range.ok) throw range.error;
+    const bytes = new Uint8Array(range.value.slice(0));
+    mapped.value.unmap();
+    const validation = validateGraphTargetCaptureReadback({
+      bytes,
+      expectedByteLength: request.bytesPerRow * request.height,
+      allowZero,
+    });
+    if (!validation.ok) throw new Error(validation.code);
+    let linearHdr: readonly [number, number, number, number] = [0, 0, 0, 0];
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    for (let y = 0; y < request.height; y += 1) {
+      for (let x = 0; x < request.width; x += 1) {
+        const offset = y * request.bytesPerRow + x * 8;
+        const pixel = [0, 1, 2, 3].map((channel) =>
+          halfFloatToNumber(view.getUint16(offset + channel * 2, true)),
+        ) as [number, number, number, number];
+        // The clear attachment carries alpha=1, so alpha alone is not
+        // evidence that the Standard BRDF wrote a fallback lobe. Decode the
+        // RGB channels from the mapped MRT and admit the first finite
+        // non-zero color sample only.
+        if (pixel.slice(0, 3).some((value) => Number.isFinite(value) && value !== 0)) {
+          linearHdr = pixel;
+          y = request.height;
+          break;
+        }
+      }
+    }
+    // A cleared attachment has a non-zero alpha lane, so byte-level
+    // validation alone can incorrectly admit an otherwise empty MRT.  When
+    // the selected producer is non-neutral, require an actual finite RGB
+    // sample before publishing a complete receipt; neutral rows explicitly
+    // retain the zero quartet through allowZero=true.
+    if (
+      !allowZero &&
+      !linearHdr.slice(0, 3).some((value) => Number.isFinite(value) && value !== 0)
+    ) {
+      throw new Error('capture-readback-empty');
+    }
+    const subtle = globalThis.crypto?.subtle;
+    if (subtle === undefined) throw new Error('Web Crypto SHA-256 is unavailable');
+    const digest = await subtle.digest('SHA-256', bytes);
+    const hash = Array.from(new Uint8Array(digest), (value) =>
+      value.toString(16).padStart(2, '0'),
+    ).join('');
+    return {
+      linearHdr,
+      hash: `sha256:${hash}`,
+      graphGeneration: request.expected.graphGeneration,
+      textureIdentity: request.expected.textureIdentity,
+    };
+  } finally {
+    internals.device.destroyBuffer(request.buffer);
+  }
+}
+
 const VOLUMETRIC_FOG_PASS_COUNT = 4;
 
 type VolumetricFogParamsSlot = 0 | 1;
@@ -696,16 +900,21 @@ function prepareVolumetricFogFrame(
   // sub-froxel jitter. The temporal resolver consumes it without growing the
   // public fog component or allocating another uniform buffer.
   params[23] = frameState.frameNumber % 1024;
+  const selectedPointIndex =
+    selectedPoint === undefined
+      ? -1
+      : lights.point.findIndex((light) => light.entity === selectedPoint.entity);
   const selectedSpotIndex =
     selectedSpot === undefined
       ? -1
       : lights.spot.findIndex((light) => light.entity === selectedSpot.entity);
+  // Cluster light_data is one point/spot/rect array. Point slots are emitted
+  // first, so volume stores the global slot rather than a per-kind array index.
+  const selectedSpotClusterIndex =
+    selectedSpotIndex < 0 ? -1 : lights.point.length + selectedSpotIndex;
   params.set(lightColor, 24);
-  params[19] =
-    selectedPoint === undefined
-      ? -1
-      : lights.point.findIndex((light) => light.entity === selectedPoint.entity);
-  params[27] = selectedSpotIndex;
+  params[19] = selectedPointIndex;
+  params[27] = selectedSpotClusterIndex;
   params[28] = fog.fog.maxDistance;
   params[29] = fog.fog.anisotropy;
   params[30] =
@@ -1102,7 +1311,6 @@ export function recordFrame(
   skybox: SkyboxSnapshot | undefined,
   skyboxCount: number,
   postProcessParams: ReadonlyMap<string, Uint8Array>,
-  fog: FogFrame | undefined,
   // feat-20260709-editor-world-partition ENGINE-fix-round2 (defect 2): the
   // full worlds[] list passed to `renderer.draw`, indexed by
   // RenderableSnapshot.worldId so the record stage resolves each renderable's
@@ -1115,7 +1323,11 @@ export function recordFrame(
   gpuDriven?: {
     readonly owner: GpuDrivenProduction;
     readonly scene: PersistentGpuDrivenState | undefined;
-    readonly onCoverage: (ownsAll: boolean, clusteredLighting: boolean) => void;
+    readonly onSceneDemand: (sceneRowsRequired: boolean) => void;
+    readonly activeEntityKeys?: ReadonlySet<number>;
+    readonly activeEntityRevision?: number;
+    readonly telemetryCandidateCount?: number;
+    readonly occlusion?: OcclusionFrameProjection;
   },
   renderReadLeases?: readonly RenderReadLease[],
   featureGraphCandidate?: RenderFeatureGraphCandidate,
@@ -1128,6 +1340,8 @@ export function recordFrame(
   volumetricFog?: ExtractedVolumetricFog,
   timingCapture?: GpuTimingCapture,
 ): boolean {
+  frameState.reflectionFallbackObservationSource = undefined;
+  frameState.reflectionFallbackCompletion = undefined;
   // The `try / finally` wrapper advances `frameState.frameNumber` exactly
   // once per `recordFrame` invocation regardless of which early-return
   // branch is taken (camera missing, cap exceeded, pipeline pending,
@@ -1195,6 +1409,10 @@ export function recordFrame(
       return false;
     }
     frameState.currentFrameObservationSource = undefined;
+    if (frameState.reflectionFallbackReadback !== undefined) {
+      internals.device.destroyBuffer(frameState.reflectionFallbackReadback.buffer);
+      frameState.reflectionFallbackReadback = undefined;
+    }
     frameState.currentDirectionalShadowView = null;
     frameState.currentSpotShadowView = null;
 
@@ -1210,7 +1428,7 @@ export function recordFrame(
 
       // Multi-light warnings + point/spot shadow-snapshot pin + point-shadow atlas
       // ensure + ExtractedLights three-arm destructure (directional fallback,
-      // point/spot arrays, totalLightCount). Extracted to prepareFrameLighting
+      // 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),
@@ -1359,12 +1577,32 @@ export function recordFrame(
 
     let preparedGpuDriven: PreparedGpuDrivenFrame | undefined;
     if (gpuDriven !== undefined) {
+      const standardPbrArtifact = internals.getMaterialShaderArtifact?.(
+        'forgeax::default-standard-pbr',
+      );
       const prepared = gpuDriven.owner.prepare({
         scene: gpuDriven.scene,
         camera,
-        meshes: pipelineState.meshes,
+        meshes: gpuDrivenMeshesForFrame(internals, pipelineState, worlds, gpuDriven.scene),
         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
+          ? {}
+          : { activeEntityKeys: gpuDriven.activeEntityKeys }),
+        ...(gpuDriven.activeEntityRevision === undefined
+          ? {}
+          : { activeEntityRevision: gpuDriven.activeEntityRevision }),
+        ...(gpuDriven.telemetryCandidateCount === undefined
+          ? {}
+          : { telemetryCandidateCount: gpuDriven.telemetryCandidateCount }),
+        ...(gpuDriven.occlusion === undefined ? {} : { occlusion: gpuDriven.occlusion }),
+        ...(standardPbrArtifact === undefined ? {} : { standardPbrArtifact }),
+        standardPbrPipelineState: pipelineState,
       });
       if (prepared.ok) preparedGpuDriven = prepared.value;
       else if (prepared.error.code !== 'rhi-not-available')
@@ -1378,18 +1616,17 @@ export function recordFrame(
       lights.pointShadow.length > 0 ||
       lights.spot.some((spot) => spot.castShadow);
     const gpuOwnsAllPrimaryRaster = preparedGpuDriven?.ownsAllRenderables === true;
-    gpuDriven?.onCoverage(
-      gpuOwnsAllPrimaryRaster && !cpuShadowCastersActive,
-      standard.kind === 'clustered',
-    );
+    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
         ? []
@@ -1404,11 +1641,24 @@ export function recordFrame(
             cpuShadowCastersActive || cubeCaptureWork.length > 0
               ? EMPTY_ENTITY_KEYS
               : gpuOwnedEntityKeys,
+            gpuDrivenWorldKeys,
           ),
     );
-    gpuDriven?.owner.recordCpuValidation(validated, gpuOwnedEntityKeys);
+    gpuDriven?.owner.recordCpuValidation(validated, gpuOwnedEntityKeys, gpuDrivenWorldKeys);
     cleanPerFrameCaches(internals, frameState, validated, gpuOwnedEntityKeys);
 
+    // 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 &&
+      validated.length > 0 &&
+      validated.every(
+        (entry) => entry.source.material.materialShaderId === 'forgeax::default-standard-pbr',
+      );
+
     const preflightGraph = runRecordProfilePhase(profilePhase, 'record/render-graph', () =>
       ensureCompiledFrameGraph(
         internals,
@@ -1424,6 +1674,7 @@ export function recordFrame(
         cubeCapture?.state,
         cameras.length === 0,
         transmissionDemand,
+        gpuDriven?.occlusion,
         graphVolumetricFog,
         volumeTopologyCandidate,
         standard,
@@ -1453,6 +1704,12 @@ export function recordFrame(
       return false;
     }
     if (standard.kind === 'clustered') {
+      // The clustered HDRP payload owns the direct-light slot upload, so it
+      // must also drive the shared Spot IES/Cookie resource upload from the
+      // authoritative extracted-light corpus. The prepared local carrier can
+      // omit the source payload on this path, leaving the shader bound to its
+      // white Cookie fallback even though the authored handle is valid.
+      writeSpotModifierTextures(internals, pipelineState, lights.spot);
       const clusterWrite = runRecordProfilePhase(
         profilePhase,
         'record/scene-state/hdrp-cluster',
@@ -1467,6 +1724,7 @@ export function recordFrame(
             pipelineState.hdrpClusterMembershipPipeline !== null,
             pipelineState.hdrpClusterMembershipBindGroupLayout,
             preparedSpotLightProjector?.lightSlotIndex,
+            pipelineState,
           ),
       );
       if (!clusterWrite.ok) {
@@ -1489,78 +1747,58 @@ export function recordFrame(
     const targetW = swapTarget.targetW;
     const targetH = swapTarget.targetH;
 
-    const temporalView =
+    const previousTemporalView = frameState.lastSuccessfulTemporalView;
+    const currentUnjitteredViewProjection = mat4.multiply(
+      mat4.create(),
+      computeProjectionMatrix(camera),
+      computeViewMatrix(camera),
+    );
+    const currentCameraPosition = [
+      camera.position[0] ?? 0,
+      camera.position[1] ?? 0,
+      camera.position[2] ?? 0,
+    ] as const;
+    const temporalCandidate = createTemporalView({
+      antialias: camera.antialias,
+      width: Math.max(1, targetW),
+      height: Math.max(1, targetH),
+      frameIndex: frameState.successfulTemporalFrameIndex ?? 0,
+      viewIdentity: `camera:${camera.entityKey ?? 0}`,
+      environmentSignature,
+      fogSignature,
+      deviceGeneration: internals.deviceScope?.generation ?? 0,
+      ...(camera.historyVersion === undefined ? {} : { historyVersion: camera.historyVersion }),
+      historyValid: false,
+      currentUnjitteredViewProjection,
+      currentCameraPosition,
+    });
+    const resetReason =
       camera.antialias === 'taa' && environmentReady
-        ? (() => {
-            const created = createTemporalView({
-              antialias: camera.antialias,
-              width: targetW,
-              height: targetH,
-              frameIndex: frameState.successfulTemporalFrameIndex ?? 0,
-              viewIdentity: `camera:${camera.entityKey ?? 0}`,
-              environmentSignature,
-              fogSignature,
-              deviceGeneration: internals.deviceScope.generation,
-              ...(camera.historyVersion === undefined
-                ? {}
-                : { historyVersion: camera.historyVersion }),
-            });
-            const previous = frameState.lastSuccessfulTemporalView;
-            const currentUnjitteredViewProjection = mat4.multiply(
-              mat4.create(),
-              computeProjectionMatrix(camera),
-              computeViewMatrix(camera),
-            );
-            const resetCandidate = createTemporalView({
-              antialias: created.input.antialias,
-              width: created.input.width,
-              height: created.input.height,
-              frameIndex: created.input.frameIndex,
-              historyVersion: created.input.historyVersion,
-              viewIdentity: created.input.viewIdentity,
-              environmentSignature,
-              fogSignature,
-              deviceGeneration: internals.deviceScope.generation,
-              cameraCut: created.input.cameraCut,
-              historyValid: false,
-              currentUnjitteredViewProjection,
-            });
-            const resetReason = resolveTemporalReset(previous, resetCandidate);
-            return createTemporalView({
-              ...resetCandidate.input,
-              frameIndex: resetReason === undefined ? resetCandidate.input.frameIndex : 0,
-              historyValid: previous !== undefined && resetReason === undefined,
-              currentUnjitteredViewProjection,
-              resetReason,
-              ...(resetReason !== undefined ||
-              previous?.currentUnjitteredViewProjection === undefined
-                ? {}
-                : {
-                    previousUnjitteredViewProjection: previous.currentUnjitteredViewProjection,
-                  }),
-            });
-          })()
+        ? resolveTemporalReset(previousTemporalView, temporalCandidate)
         : undefined;
+    const canReusePrevious = previousTemporalView !== undefined && resetReason === undefined;
+    const temporalView = createTemporalView({
+      ...temporalCandidate.input,
+      frameIndex: resetReason === undefined ? temporalCandidate.input.frameIndex : 0,
+      historyValid: camera.antialias === 'taa' && environmentReady && canReusePrevious,
+      resetReason,
+      ...(canReusePrevious && previousTemporalView.currentUnjitteredViewProjection !== undefined
+        ? {
+            previousUnjitteredViewProjection: previousTemporalView.currentUnjitteredViewProjection,
+          }
+        : {}),
+      ...(canReusePrevious && previousTemporalView.currentCameraPosition !== undefined
+        ? { previousCameraPosition: previousTemporalView.currentCameraPosition }
+        : {}),
+    });
     frameState.pendingTemporalCommit =
       cameras.length === 0 || !environmentReady || internals.deviceScope === undefined
         ? { kind: 'none' }
-        : temporalView === undefined
-          ? {
-              kind: 'off',
-              view: createTemporalView({
-                antialias: camera.antialias,
-                width: targetW,
-                height: targetH,
-                frameIndex: frameState.successfulTemporalFrameIndex ?? 0,
-                viewIdentity: `camera:${camera.entityKey ?? 0}`,
-                environmentSignature,
-                fogSignature,
-                deviceGeneration: internals.deviceScope.generation,
-              }),
-            }
-          : { kind: 'taa', view: temporalView };
+        : temporalView.mode === 'taa'
+          ? { kind: 'taa', view: temporalView }
+          : { kind: 'off', view: temporalView };
     const recordCamera: CameraSnapshot =
-      temporalView === undefined ? camera : { ...camera, temporal: temporalView };
+      temporalView.mode === 'taa' ? { ...camera, temporal: temporalView } : camera;
     let activeVolumetricFogContext: VolumetricFogFrameContext | undefined;
     let activeVolumetricFogSignature: VolumeTemporalSignature | undefined;
     if (graphVolumetricFog?.status === 'available' && baseVolumetricFogContext !== undefined) {
@@ -1727,7 +1965,6 @@ export function recordFrame(
           light,
           lights,
           frameState.spotShadowSnapshots,
-          fog,
           temporalView,
           preparedSpotLightProjector?.spotIndex,
         );
@@ -1808,7 +2045,6 @@ export function recordFrame(
         lights,
         frameState.spotShadowSnapshots,
         capture.viewBindGroupDynamicOffset,
-        undefined,
         preparedSpotLightProjector?.spotIndex,
       );
     }
@@ -1823,7 +2059,6 @@ export function recordFrame(
         lights,
         frameState.spotShadowSnapshots,
         probe.viewBindGroupDynamicOffset,
-        undefined,
         preparedSpotLightProjector?.spotIndex,
       );
     }
@@ -1859,6 +2094,7 @@ export function recordFrame(
       assets: internals.assets,
       world,
       gpuDrivenEntityKeys: gpuOwnedEntityKeys,
+      ...(gpuDrivenWorldKeys === undefined ? {} : { gpuDrivenWorldKeys }),
       store: internals.gpuStore,
       pipelineState,
       bloomResources: pipelineState.perPassResources.getBloomResources?.() ?? null,
@@ -1903,6 +2139,7 @@ export function recordFrame(
       dispatch: transparentDispatch,
       hdrpClusterBindGroup,
       hdrpClusterMembershipBindGroup,
+      ...(gpuDriven?.occlusion === undefined ? {} : { occlusion: gpuDriven.occlusion }),
       standardLighting: standard,
       foldDispatchPlan,
       materialSlotIndices,
@@ -1917,7 +2154,19 @@ export function recordFrame(
       directionalShadowCacheReuse: directionalShadowCache.reuse,
       ...(profilePhase !== undefined ? { profilePhase } : {}),
     };
+    const fallbackReadbackRequest = createReflectionFallbackReadbackRequest(internals, frameState);
+    if (fallbackReadbackRequest !== undefined) {
+      frameState.reflectionFallbackReadback = fallbackReadbackRequest;
+    }
     let completion: Promise<unknown> | undefined;
+    let fallbackReadback:
+      | Promise<{
+          readonly linearHdr: readonly [number, number, number, number];
+          readonly hash: string;
+          readonly graphGeneration: number;
+          readonly textureIdentity: number;
+        }>
+      | undefined;
     const stagedTemporalFrame = {
       frameId: frameState.frameNumber,
       currentViewProjection: new Float32Array(currentViewProjection),
@@ -1941,9 +2190,34 @@ 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);
+              },
+            },
         cubeCaptureWork.length === 0 ? undefined : cubeCaptureWork.map((work) => work.faceIndex),
         (done) => {
           completion = done;
+          if (fallbackReadbackRequest !== undefined) {
+            fallbackReadback = done.then(
+              () =>
+                mapReflectionFallbackReadback(
+                  internals,
+                  fallbackReadbackRequest,
+                  cubeCapture?.reflectionProbes?.fallbackHasNonNeutral !== true,
+                ),
+              (cause) => {
+                internals.device.destroyBuffer(fallbackReadbackRequest.buffer);
+                throw cause;
+              },
+            );
+          }
         },
         timingCapture,
       ),
@@ -1952,7 +2226,29 @@ export function recordFrame(
       const completed = cubeCapture.scheduler.completeSubmission(submitted, completion);
       if (!completed.ok) internals.errorRegistry.fire(completed.error);
     }
-    cubeCapture?.reflectionProbes?.completeSubmission(submitted, completion);
+    if (!submitted && fallbackReadbackRequest !== undefined) {
+      internals.device.destroyBuffer(fallbackReadbackRequest.buffer);
+    }
+    const reflectionFallbackCompletion = cubeCapture?.reflectionProbes?.completeSubmission(
+      submitted,
+      completion,
+      fallbackReadbackRequest === undefined || fallbackReadback === undefined
+        ? undefined
+        : {
+            format: fallbackReadbackRequest.expected.format,
+            size: {
+              width: fallbackReadbackRequest.expected.width,
+              height: fallbackReadbackRequest.expected.height,
+            },
+            frameId: fallbackReadbackRequest.expected.frameId,
+            graphGeneration: fallbackReadbackRequest.expected.graphGeneration,
+            textureIdentity: fallbackReadbackRequest.expected.textureIdentity,
+            readback: fallbackReadback,
+          },
+      frameState.reflectionFallbackDemand,
+    );
+    frameState.reflectionFallbackCompletion = reflectionFallbackCompletion;
+    frameState.reflectionFallbackObservationSource = undefined;
     if (submitted && !directionalShadowCache.reuse) {
       frameState.directionalShadowCache = frameState.directionalShadowCacheRecorded
         ? directionalShadowCache.next
@@ -2038,7 +2334,7 @@ interface DirectionalShadowCacheDecision {
 function readWorldState(lease: RenderReadLease): DirectionalShadowWorldState {
   return {
     worldIdentity: lease.worldIdentity,
-    changeCursor: lease.inspectCursor(),
+    version: lease.captureVersion(),
   };
 }
 
@@ -2060,16 +2356,14 @@ function sameWorldState(
     if (cachedState.worldIdentity !== lease.worldIdentity) return false;
     let changes: ReturnType<RenderReadLease['readChanges']>;
     try {
-      changes = lease.readChanges(cachedState.changeCursor);
+      changes = lease.readChanges(cachedState.version);
     } catch {
-      // A lease may have evicted an old cursor after another owner consumed
-      // its bounded cursor window. Treat that as stale render evidence and
-      // rebuild the atlas from the current lease rather than reaching into
-      // World for a second mutation clock.
+      // Treat malformed or foreign version evidence as stale and rebuild the
+      // atlas rather than reaching through World for a second mutation clock.
       return false;
     }
     if (changes.status !== 'ok') return false;
-    if (changes.world.records.length !== 0 || changes.sharedRefs.records.length !== 0) {
+    if (changes.world.changedComponentIds.length !== 0 || changes.sharedRefs.records.length !== 0) {
       return false;
     }
   }
@@ -2205,6 +2499,7 @@ function validateRenderables(
   renderables: readonly RenderableSnapshot[],
   transparentDispatch: readonly DispatchEntry[],
   excludedEntityKeys: ReadonlySet<number> = new Set<number>(),
+  worldKeys?: readonly number[],
 ): ValidatedRenderable[] {
   // bug-20260527-renderstate-pipeline-dispatch-gap D-4:
   // build a renderableIndex -> renderState map from dispatch entries
@@ -2230,7 +2525,8 @@ function validateRenderables(
   for (let rIdx = 0; rIdx < renderables.length; rIdx++) {
     const r = renderables[rIdx];
     if (r === undefined) continue;
-    if (excludedEntityKeys.has(worldEntityKey(r.worldId, r.entityKey))) continue;
+    if (excludedEntityKeys.has(worldEntityKey(worldKeys?.[r.worldId] ?? r.worldId, r.entityKey)))
+      continue;
     // feat-20260709-editor-world-partition ENGINE-fix-round2 (defect 2): resolve
     // this renderable's mesh against the world it was EXTRACTED from
     // (worlds[r.worldId]) — NOT the single resource-owner `world`. Builtin mesh
@@ -2265,11 +2561,17 @@ function validateRenderables(
     // frames hit the O(1) cache.
     const meshAssetHandle = toShared<'MeshAsset'>(r.assetHandle);
     let meshHandles = internals.gpuStore.getMeshGpuHandles(meshAssetHandle, renderableWorld);
+    const lodMeshes = r.lods?.map((lod) => internals.assets.lookup<MeshAsset>(lod.mesh));
+    const resolvedLodMeshes =
+      lodMeshes?.every((lod): lod is MeshAsset => lod?.kind === 'mesh') === true
+        ? lodMeshes
+        : undefined;
     if (meshHandles === undefined && r.assetHandle > handleSlot(HANDLE_NINESLICE_QUAD)) {
       const residentRes = internals.gpuStore.ensureResident(
         meshAssetHandle,
         assetRes.value,
         renderableWorld,
+        resolvedLodMeshes,
       );
       if (residentRes.ok) {
         meshHandles = residentRes.value;
@@ -2451,6 +2753,21 @@ function buildDispatchPlan(
   materialSlotOwners: readonly number[];
   materialSlotCount: number;
 } {
+  // A production GPU-owned frame has no CPU validated rows by design. The
+  // dispatch list can still contain one entry per authored entity, but no
+  // 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) {
+    return {
+      validatedOrdered: [],
+      foldDispatchPlan: null,
+      materialSlotIndices: [],
+      materialSlots: [],
+      materialSlotOwners: [],
+      materialSlotCount: 0,
+    };
+  }
   // M3 / w26: dispatch-ordered render. The dispatch list is pre-sorted
   // by queue (ascending, stable) by the extract stage per plan-strategy D-3.
   // Reorder validated renderables to follow the dispatch order, falling