@forgeax/engine-render 0.1.20 → 0.1.23

package/src/record/frame.ts

@@ -21,19 +21,30 @@ import {
 } from '@forgeax/engine-rhi';
 import type { MaterialRenderState, MeshAsset } from '@forgeax/engine-types';
 import { 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';
-import { ObservationUnavailableError, type ObservationUnavailableReason } from '../errors/render';
-import type { FogFrame } from '../extract/environment';
+import {
+  ObservationUnavailableError,
+  type ObservationUnavailableReason,
+  RendererOperationError,
+} from '../errors/render';
 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';
 import { disposeTransientInstanceBuffers } from '../instance-buffer-cache';
+import { inspectStandardLighting } from '../pipeline/standard-lighting/inspection';
+import { standardLightingTopologySignature } from '../pipeline/standard-lighting/topology';
+import { inspectPointShadow } from '../point-shadow-inspection';
 import type {
   CameraSnapshot,
+  CubeCameraSnapshot,
   RenderRecordPhase,
   SpotLightProjectorFrameContext,
   VolumetricFogFrameContext,
@@ -48,6 +59,8 @@ 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,
   TRANSPARENT_SORT_MODE_LAYER_Y,
@@ -63,8 +76,8 @@ import {
   resolveSkyboxActive,
   warnZeroLightStandard,
   writeHdrpClusterAndSsaoBuffers,
-  writePointSpotLightBuffers,
   writeShadowParamsBuffer,
+  writeSpotModifierTextures,
 } from './frame-lighting';
 import {
   type BindGroupCounts,
@@ -72,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
@@ -223,12 +239,87 @@ import { computeSplitLdrSprite } from './main-pass-sprite-draws';
 import { cleanPerEntityCache, ensureMeshSsboCapacity, uploadMeshSsboBatch } from './mesh-ssbo';
 import { writeShadowCasterUniforms } from './shadow-pass';
 import {
+  type CubeCaptureGraphState,
   ensureCompiledFrameGraph,
   executeCompiledFrameGraph,
   type RenderFeatureGraphCandidate,
   settleVolumetricFogGraphCandidate,
 } from './typed-frame-graph';
-import { writePointsLinesViewUbo, writeViewUbo } from './view-ubo';
+import {
+  CUBE_CAPTURE_VIEW_SLOT_BASE,
+  VIEW_UNIFORM_SLOT_STRIDE,
+  writePointsLinesViewUbo,
+  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;
@@ -301,6 +392,67 @@ export function materialSlotCountForPrefix(
 
 export type RecordProfileRunner = <T>(phase: RenderRecordPhase, action: () => T) => T;
 
+export interface CubeCaptureFrameInput {
+  readonly snapshots: readonly CubeCameraSnapshot[];
+  readonly scheduler: import('../capture/scheduler').CubeCaptureScheduler;
+  readonly state: CubeCaptureGraphState;
+  readonly reflectionProbes?: import('./render-context').ReflectionProbeRecordState;
+}
+
+function prepareCubeCapture(
+  internals: RenderSystemInternals,
+  input: CubeCaptureFrameInput | undefined,
+  displayCamera: CameraSnapshot,
+): readonly import('./typed-frame-graph').CubeCaptureGraphWork[] {
+  if (input === undefined) return [];
+  if (input.reflectionProbes === undefined) delete input.state.reflectionProbes;
+  else input.state.reflectionProbes = input.reflectionProbes.graph;
+  input.scheduler.beginFrame();
+  for (const snapshot of input.snapshots) {
+    const inspection = input.scheduler.inspect(snapshot.target);
+    if (inspection.candidateGeneration !== undefined) continue;
+    const requested = input.scheduler.request({
+      target: snapshot.target,
+      position: snapshot.position,
+      near: snapshot.near,
+      far: snapshot.far,
+      updateIntent: snapshot.updateIntent,
+      requestVersion: snapshot.requestVersion,
+      faceBudget: snapshot.faceBudget,
+    });
+    if (!requested.ok) internals.errorRegistry.fire(requested.error);
+  }
+  const work = input.scheduler.nextWork();
+  const physicalWork: import('./typed-frame-graph').CubeCaptureGraphWork[] = [];
+  for (const item of work) {
+    const physical = internals.getRenderTargetPhysical?.(item.target);
+    if (physical === undefined) continue;
+    const faceIndex = CUBE_CAMERA_FACE_ORDER.indexOf(item.face);
+    if (faceIndex < 0) continue;
+    const faceWorld = mat4.create();
+    mat4.invert(faceWorld, item.view);
+    physicalWork.push({
+      target: item.target,
+      faceIndex,
+      physical,
+      faceCamera: {
+        ...displayCamera,
+        position: vec3.create(item.position[0] ?? 0, item.position[1] ?? 0, item.position[2] ?? 0),
+        world: faceWorld,
+        fov: Math.PI / 2,
+        aspect: 1,
+        near: item.near,
+        far: item.far,
+        projection: 'perspective',
+      },
+      viewBindGroupDynamicOffset:
+        (CUBE_CAPTURE_VIEW_SLOT_BASE + physicalWork.length) * VIEW_UNIFORM_SLOT_STRIDE,
+    });
+  }
+  input.state.work = physicalWork;
+  return physicalWork;
+}
+
 const EMPTY_ENTITY_KEYS: ReadonlySet<number> = new Set<number>();
 
 function runRecordProfilePhase<T>(
@@ -311,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;
@@ -619,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] =
@@ -739,6 +1025,8 @@ function prepareSpotLightProjectorFrame(
     texture: resident.value.texture.handle,
     view: resident.value.view,
     sampler: sampler.value,
+    spotIndex: lights.spot.indexOf(source),
+    lightSlotIndex: lights.point.length + lights.spot.indexOf(source),
   };
 }
 
@@ -1023,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
@@ -1036,11 +1323,16 @@ export function recordFrame(
   gpuDriven?: {
     readonly owner: GpuDrivenProduction;
     readonly scene: PersistentGpuDrivenState | undefined;
-    readonly onCoverage: (ownsAll: 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,
   pointsLinesOwner?: import('./render-context').PointsLinesRecordOwner,
+  cubeCapture?: CubeCaptureFrameInput,
   environmentSignature = '',
   fogSignature = '',
   environmentReady = true,
@@ -1048,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,
@@ -1097,14 +1391,35 @@ export function recordFrame(
     if (!camera) return false;
     const pipelineState = internals.getPipelineState();
     if (pipelineState === null) return false;
+    if (pipelineState.device !== internals.device) {
+      internals.errorRegistry.fire(
+        new RendererOperationError('device-operation-failed', {
+          operation: 'draw',
+          cause: {
+            code: 'pipeline-device-mismatch',
+            expected: 'pipelineState.device === runtime.device',
+            hint: 'discard stale pipeline state before recording the next frame',
+            detail: {
+              expected: 'pipelineState.device === runtime.device',
+              hint: 'discard stale pipeline state before recording the next frame',
+            },
+          },
+        }),
+      );
+      return false;
+    }
     frameState.currentFrameObservationSource = undefined;
+    if (frameState.reflectionFallbackReadback !== undefined) {
+      internals.device.destroyBuffer(frameState.reflectionFallbackReadback.buffer);
+      frameState.reflectionFallbackReadback = undefined;
+    }
     frameState.currentDirectionalShadowView = null;
     frameState.currentSpotShadowView = null;
 
     // Record-stage fold operator linear scan (groups transparent-sort entries
     // into fold buckets + records the fold-eligible count metric). Extracted to
     // computeFoldBuckets (M3/w18).
-    const { foldBuckets, light } = runRecordProfilePhase(profilePhase, 'record/scene-state', () => {
+    const lightingPreparation = runRecordProfilePhase(profilePhase, 'record/scene-state', () => {
       const foldBuckets = runRecordProfilePhase(
         profilePhase,
         'record/scene-state/fold-buckets',
@@ -1113,13 +1428,13 @@ 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 { light, pointLights, spotLights, totalLightCount } = runRecordProfilePhase(
-        profilePhase,
-        'record/scene-state/lighting-prep',
-        () => prepareFrameLighting(internals, frameState, lights),
+      const lighting = runRecordProfilePhase(profilePhase, 'record/scene-state/lighting-prep', () =>
+        prepareFrameLighting(internals, frameState, lights, camera, pipelineState),
       );
+      if (!lighting.ok) return lighting;
+      const { light, totalLightCount, standard } = lighting.value;
 
       runRecordProfilePhase(profilePhase, 'record/scene-state/ambient-resolution', () => {
         // feat-20260520-skylight-ibl-cubemap M4 / t27 (AC-10 + F-4 nit):
@@ -1166,31 +1481,17 @@ export function recordFrame(
         }
       });
 
-      // feat-20260608-cluster-lighting M5 / w21 + M6 / w23: HDRP per-frame CPU
-      // cluster binning + light-data / cluster-grid / SSAO buffer uploads. Runs
-      // only when the HDRP pipeline is active and there is at least one punctual
-      // light. Extracted to a sub-function (M3/w18) so recordFrame stays a
-      // skeleton; fail-soft error semantics are preserved verbatim.
-      runRecordProfilePhase(profilePhase, 'record/scene-state/hdrp-cluster', () => {
-        writeHdrpClusterAndSsaoBuffers(
-          internals,
-          frameState,
-          camera,
-          pointLights,
-          spotLights,
-          profilePhase,
-          pipelineState.hdrpClusterMembershipPipeline !== null &&
-            internals.device.caps?.compute === true,
-          pipelineState.hdrpClusterMembershipBindGroupLayout,
-        );
-      });
-
       // Zero-light standard-material once-warn (no Skylight + 0 direct light +
       // >=1 lit material -> black). Extracted to warnZeroLightStandard (M3/w18).
       warnZeroLightStandard(frameState, renderables, skylight, totalLightCount);
 
-      return { foldBuckets, light };
+      return { ok: true as const, value: { foldBuckets, light, standard } };
     });
+    if (!lightingPreparation.ok) {
+      internals.errorRegistry.fire(lightingPreparation.error);
+      return false;
+    }
+    const { foldBuckets, light, standard } = lightingPreparation.value;
 
     // Case E (this commit): 0 renderables = legitimate scene (LO §1.1
     // hello-window minimum semantic). Mirrors the Case C softening for
@@ -1276,13 +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,
-        hdrp: frameState.isHdrpActive,
+        // 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')
@@ -1296,7 +1616,48 @@ export function recordFrame(
       lights.pointShadow.length > 0 ||
       lights.spot.some((spot) => spot.castShadow);
     const gpuOwnsAllPrimaryRaster = preparedGpuDriven?.ownsAllRenderables === true;
-    gpuDriven?.onCoverage(gpuOwnsAllPrimaryRaster && !cpuShadowCastersActive);
+    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,
+          ),
+    );
+    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(
@@ -1310,14 +1671,68 @@ export function recordFrame(
         graphShadowMapSize,
         preparedGpuDriven,
         featureGraphCandidate,
+        cubeCapture?.state,
         cameras.length === 0,
         transmissionDemand,
+        gpuDriven?.occlusion,
         graphVolumetricFog,
         volumeTopologyCandidate,
+        standard,
       ),
     );
     if (preflightGraph === null) return false;
 
+    // The compiled graph is the acceptance boundary for the prepared
+    // Standard lighting declaration. Upload the same declaration only after
+    // that graph is current; a failed candidate therefore cannot leave an old
+    // graph consuming a new buffer generation.
+    if (frameState.standardLightingGraphSignature !== standardLightingTopologySignature(standard)) {
+      internals.errorRegistry.fire(
+        new RendererOperationError('device-operation-failed', {
+          operation: 'draw',
+          cause: {
+            code: 'standard-graph-generation-mismatch',
+            expected: 'compiled graph and prepared Standard lighting share one topology signature',
+            hint: 'retry the frame after the Standard graph candidate is accepted',
+            detail: {
+              expected: standardLightingTopologySignature(standard),
+              actual: frameState.standardLightingGraphSignature,
+            },
+          },
+        }),
+      );
+      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',
+        () =>
+          writeHdrpClusterAndSsaoBuffers(
+            internals,
+            frameState,
+            camera,
+            standard.prepared,
+            standard.transport,
+            profilePhase,
+            pipelineState.hdrpClusterMembershipPipeline !== null,
+            pipelineState.hdrpClusterMembershipBindGroupLayout,
+            preparedSpotLightProjector?.lightSlotIndex,
+            pipelineState,
+          ),
+      );
+      if (!clusterWrite.ok) {
+        internals.errorRegistry.fire(clusterWrite.error);
+        return false;
+      }
+    }
+
     // Acquire the swap-chain texture + colour view + target dimensions (with
     // one reconfigure-and-retry on surface-outdated). Extracted to
     // acquireSwapChainTarget (M3/w18); returns null on unrecoverable failure
@@ -1332,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) {
@@ -1501,41 +1896,6 @@ export function recordFrame(
     const geometryColorResolveView: TextureView | null = null;
     const ldrSpriteColorView: TextureView | null = null;
 
-    // Validate renderable handles + collect render plan. Empty `renderables`
-    // input or all-unregistered handles both produce `validatedOrdered.length === 0`,
-    // which is the Case E (clear-pass-only) path.
-    //
-    // feat-20260520-2d-sprite-layer-mvp M-3 / w25 (@new-surface): per-entry
-    // `renderableIndex` tracks the position into the original renderables[]
-    // array so the bucket-aware reordering below can correlate
-    // transparent-sort output (TransparentEntry.renderableIndex) back to
-    // the validated row.
-    // bug-20260527-renderstate-pipeline-dispatch-gap D-4:
-    // build a renderableIndex -> renderState map from dispatch entries
-    // so each ValidatedRenderable carries its per-material renderState
-    // override without an O(n^2) back-scan in the draw loop.
-    const gpuOwnedEntityKeys = preparedGpuDriven?.entityKeys ?? EMPTY_ENTITY_KEYS;
-    const validated = runRecordProfilePhase(profilePhase, 'record/validation', () =>
-      gpuOwnsAllPrimaryRaster && !cpuShadowCastersActive
-        ? []
-        : validateRenderables(
-            internals,
-            world,
-            worlds,
-            pipelineState,
-            frameState,
-            renderables,
-            transparentDispatch,
-            cpuShadowCastersActive ? EMPTY_ENTITY_KEYS : gpuOwnedEntityKeys,
-          ),
-    );
-    gpuDriven?.owner.recordCpuValidation(validated, gpuOwnedEntityKeys);
-
-    // Per-frame cache clean-up: drop per-entity BG cache entries + instance
-    // buffers whose entityKey is absent from the current validated set (despawn
-    // eviction). Extracted to cleanPerFrameCaches (M3/w18).
-    cleanPerFrameCaches(internals, frameState, validated, gpuOwnedEntityKeys);
-
     // Dispatch-ordered render plan: reorder validated renderables to dispatch
     // order, run the mesh-SSBO capacity gate (graceful truncation), and build
     // the fold dispatch plan. Extracted to buildDispatchPlan (M3/w18).
@@ -1605,8 +1965,8 @@ export function recordFrame(
           light,
           lights,
           frameState.spotShadowSnapshots,
-          fog,
           temporalView,
+          preparedSpotLightProjector?.spotIndex,
         );
         if (pipelineState.pointsLinesViewBuffer !== undefined) {
           writePointsLinesViewUbo(
@@ -1623,11 +1983,6 @@ export function recordFrame(
           lights,
         );
 
-        // Per-frame full rewrite of the PointLight + SpotLight std430 storage
-        // buffers (header + first-slice cap N=4 slots). Extracted to
-        // writePointSpotLightBuffers (M3/w18).
-        writePointSpotLightBuffers(internals, pipelineState, lights);
-
         // Per-renderable entity_world upload (batched): all N mat4+normalMatrix
         // slots assembled into a single contiguous scratch buffer, then flushed
         // as one writeBuffer call. Extracted to mesh-ssbo.ts (M3/w21) so its
@@ -1676,10 +2031,38 @@ export function recordFrame(
           validated.length > 0 || preparedGpuDriven !== undefined,
           bindGroupCounts,
           undefined,
-          false,
+          true,
+          standard,
         ),
       );
 
+    for (const capture of cubeCaptureWork) {
+      writeViewUbo(
+        internals.device.queue,
+        pipelineState.viewUniformBuffer,
+        capture.faceCamera,
+        light,
+        lights,
+        frameState.spotShadowSnapshots,
+        capture.viewBindGroupDynamicOffset,
+        preparedSpotLightProjector?.spotIndex,
+      );
+    }
+    for (const probe of cubeCapture?.reflectionProbes?.graph.work ?? []) {
+      if (probe.faceCamera === undefined || probe.viewBindGroupDynamicOffset === undefined)
+        continue;
+      writeViewUbo(
+        internals.device.queue,
+        pipelineState.viewUniformBuffer,
+        probe.faceCamera,
+        light,
+        lights,
+        frameState.spotShadowSnapshots,
+        probe.viewBindGroupDynamicOffset,
+        preparedSpotLightProjector?.spotIndex,
+      );
+    }
+
     // ── feat-20260529-rendergraph-pass-abstraction M4 / w13b ───────────
     // The compiled typed graph is the sole per-frame pass owner.
     //
@@ -1711,6 +2094,7 @@ export function recordFrame(
       assets: internals.assets,
       world,
       gpuDrivenEntityKeys: gpuOwnedEntityKeys,
+      ...(gpuDrivenWorldKeys === undefined ? {} : { gpuDrivenWorldKeys }),
       store: internals.gpuStore,
       pipelineState,
       bloomResources: pipelineState.perPassResources.getBloomResources?.() ?? null,
@@ -1755,16 +2139,34 @@ export function recordFrame(
       dispatch: transparentDispatch,
       hdrpClusterBindGroup,
       hdrpClusterMembershipBindGroup,
+      ...(gpuDriven?.occlusion === undefined ? {} : { occlusion: gpuDriven.occlusion }),
+      standardLighting: standard,
       foldDispatchPlan,
       materialSlotIndices,
       materialSlots,
       materialSlotOwners,
       materialSlotCount,
+      ...(cubeCapture?.reflectionProbes === undefined
+        ? {}
+        : { reflectionProbes: cubeCapture.reflectionProbes }),
       pointsLines: pointsLinesOwner,
       materialBgAssemblyCache: frameState.materialBgAssemblyCache,
       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),
@@ -1788,9 +2190,65 @@ 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,
       ),
     );
+    if (cubeCapture !== undefined && cubeCaptureWork.length > 0) {
+      const completed = cubeCapture.scheduler.completeSubmission(submitted, completion);
+      if (!completed.ok) internals.errorRegistry.fire(completed.error);
+    }
+    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
@@ -1837,6 +2295,11 @@ export function recordFrame(
         frameState.volumetricFogAccepted = volumetricFog;
         frameState.volumetricFogAcceptedContext = preparedVolumetricFog;
       }
+      frameState.standardLightingInspection = inspectStandardLighting(standard);
+      frameState.pointShadowInspection = inspectPointShadow(
+        lights.pointShadow,
+        SHADOW_ATLAS_DEFAULT_LAYERS,
+      );
     }
     return submitted;
   } finally {
@@ -1857,9 +2320,9 @@ export function recordFrame(
       );
     }
     frameState.frameNumber += 1;
-    // feat-20260608-cluster-lighting M5 / w22: clear HDRP once-per-frame fired
+    // feat-20260608-cluster-lighting M5 / w22: clear Standard once-per-frame fired
     // set so the next frame re-fires if the condition persists.
-    frameState.hdrpOncePerFrameFired.clear();
+    frameState.standardOncePerFrameFired.clear();
   }
 }
 
@@ -1871,7 +2334,7 @@ interface DirectionalShadowCacheDecision {
 function readWorldState(lease: RenderReadLease): DirectionalShadowWorldState {
   return {
     worldIdentity: lease.worldIdentity,
-    changeCursor: lease.inspectCursor(),
+    version: lease.captureVersion(),
   };
 }
 
@@ -1893,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;
     }
   }
@@ -1927,6 +2388,20 @@ function sameLightViewProj(
   return true;
 }
 
+function sameDirectionalShadowQuality(
+  previous: DirectionalShadowQuality,
+  next: DirectionalShadowQuality,
+): boolean {
+  if (previous.kind !== next.kind) return false;
+  if (previous.kind === 'pcf' && next.kind === 'pcf') return previous.kernel === next.kernel;
+  if (previous.kind !== 'pcss' || next.kind !== 'pcss') return false;
+  return (
+    previous.preset === next.preset &&
+    previous.angularRadiusRadians === next.angularRadiusRadians &&
+    previous.maxPenumbraTexels === next.maxPenumbraTexels
+  );
+}
+
 function prepareDirectionalShadowCache(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
@@ -1946,6 +2421,7 @@ function prepareDirectionalShadowCache(
     cascadeCount === undefined ||
     cascadeCount <= 0 ||
     lightViewProj === undefined ||
+    lights.directionalShadowQuality === undefined ||
     validatedOrdered.length === 0
   ) {
     return { reuse: false, next: null };
@@ -1958,6 +2434,10 @@ function prepareDirectionalShadowCache(
     cached !== null &&
     cached.shadowMapSize === shadowMapSize &&
     cached.cascadeCount === cascadeCount &&
+    sameDirectionalShadowQuality(
+      cached.directionalShadowQuality,
+      lights.directionalShadowQuality,
+    ) &&
     cached.pipelineHandle === frameState.installedPipelineHandle &&
     cached.graphTopologyKey === frameState.compiledFrameGraphTopologyKey &&
     cached.assetCatalogEpoch === assetCatalogEpoch &&
@@ -1986,6 +2466,7 @@ function prepareDirectionalShadowCache(
       graphTopologyKey: frameState.compiledFrameGraphTopologyKey,
       shadowMapSize,
       cascadeCount,
+      directionalShadowQuality: lights.directionalShadowQuality,
       lightViewProj: lightViewProj.map((matrix) => new Float32Array(matrix)),
       meshResidencyEpoch,
     },
@@ -2018,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
@@ -2043,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
@@ -2078,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;
@@ -2264,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