@forgeax/engine-render 0.1.28 → 0.1.29

package/src/render-system.ts

@@ -1,3 +1,4 @@
+import type { RenderSceneBounds } from './scene/render-scene-types';
 // @forgeax/engine-runtime - RenderSystem main entry (D-S2 three-stage Extract ->
 // Prepare -> Record + 4-tier error fan-out).
 //
@@ -16,31 +17,17 @@
 // .invert` (charter proposition 5: no math reinvention; render-system.test.ts
 // asserts `/@forgeax\/engine-math/` shows up in render-system.ts source).
 
-import {
-  type MipmapEncoderWork,
-  numMipLevels,
-  resolveAssetHandle,
-} from '@forgeax/engine-assets-runtime';
-import type { World } from '@forgeax/engine-ecs';
+import { numMipLevels, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
+import { Time, type World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
 import type { RecorderSession } from '@forgeax/engine-profiler';
 import type { CompiledRenderGraphInfo } from '@forgeax/engine-render-graph';
-import type {
-  BindGroupEntry,
-  BindGroupLayout,
-  Buffer,
-  RenderPipeline,
-  RhiDevice,
-} from '@forgeax/engine-rhi';
+import type { BindGroupLayout, Buffer, RenderPipeline, RhiDevice } from '@forgeax/engine-rhi';
 import { err, ok, type Result, RhiError } from '@forgeax/engine-rhi';
 import {
-  derive,
   deriveTextureLayout,
-  type Handle,
   type MaterialAsset,
-  type MaterialTextureValue,
   type RenderPipelineAsset,
-  RenderQueue,
   type SamplerAsset,
   type TextureAsset,
   toShared,
@@ -50,9 +37,8 @@ import {
   directionalShadowProfileFromQuality,
   projectDirectionalShadowInspectionSource,
 } from './assembly/directional-shadow-inspection';
+import { createGpuDrivenOwner } from './assembly/gpu-driven-owner';
 import { createClusterBinScratch } from './cluster-binner';
-import type { DeviceScope, LifecycleResourceSpec } from './device/device-scope';
-import type { EnvironmentGeneration } from './environment/generation';
 import { EnvironmentLifecycle } from './environment/lifecycle';
 import {
   type ObservationUnavailableError,
@@ -60,11 +46,11 @@ import {
   TransmissionCapabilityMissingError,
 } from './errors/render';
 import {
-  type RenderFeatureHost,
   type RenderFeaturePreparedGraphicsResolverInput,
   runRenderFeatureFrame,
   settlePreparedGraphicsCompletion,
 } from './features/host';
+import { createFeatureNoiseResolver } from './features/noise-texture';
 import {
   createRenderFeatureGpuWorkOwner,
   type RenderFeatureGpuWorkOwner,
@@ -79,22 +65,45 @@ import {
   postProcessShaderModuleLabel,
   postProcessShaderPipelineLabel,
 } from './fullscreen-post-process-pass';
-import { GpuDrivenProduction } from './gpu-driven/production-raster';
 import type {
   BloomInspection,
   DirectionalShadowInspection,
   GpuDrivenProductionInspection,
   LodOcclusionInspection,
-  LodOcclusionInspectionRow,
-  LodOcclusionWorldInspection,
+  MaterialTextureSourceInspection,
   MotionBlurInspection,
   ReflectionProbeInspection,
   RenderSceneInspection,
   SsrDependenciesInspection,
+  SsrSpatialInspection,
   TemporalTargetInspection,
   TransmissionInspection,
 } from './inspection-types';
 import { buildOcclusionProxyVertices } from './occlusion-proxy';
+import {
+  AUTO_EXPOSURE_HISTOGRAM_BYTES,
+  retireAutoExposureGpuResources,
+  writeAutoExposureParameters,
+} from './pipeline/standard-output/auto-exposure/gpu';
+import {
+  type AutoExposureInspection,
+  createAutoExposureInspection,
+} from './pipeline/standard-output/auto-exposure/inspection';
+import {
+  createAutoExposureState,
+  resetAutoExposureState,
+} from './pipeline/standard-output/auto-exposure/state';
+import {
+  createStandardLutState,
+  inspectStandardLutState,
+  prepareStandardLutCandidate,
+  resetStandardLutState,
+  type StandardLutInspection,
+} from './pipeline/standard-output/lut-state';
+import {
+  prepareStandardOutputResources,
+  resetStandardOutputForDeviceLoss,
+} from './pipeline/standard-output/resources';
 import type { PointsLinesRetainedSnapshot } from './points-lines/snapshot';
 import { StandardPointsLinesOwner } from './points-lines/standard-owner';
 import {
@@ -102,6 +111,35 @@ import {
   materialSamplerHandles,
   materialTextureHandles,
 } from './recovery/render-system-candidate';
+
+export { materialTextureHandlesForResidency } from './recovery/render-system-candidate';
+
+import {
+  createDynamicGeometryFrameBindings,
+  resetDynamicGeometryTemporalHistory,
+} from './record/dynamic-geometry-consumption';
+import type {
+  RecoveryGraphCandidate,
+  RecoveryGraphCandidatePreparation,
+  RecoveryGraphCandidateRuntime,
+  RecoveryGraphSetupSubmission,
+  RecoveryPostProcessResources,
+  RecoveryRootBundle,
+  RecoveryRootRuntime,
+} from './recovery/types';
+
+export type {
+  RecoveryGraphCandidate,
+  RecoveryGraphCandidatePreparation,
+  RecoveryGraphCandidateRuntime,
+  RecoveryGraphSetupSubmission,
+  RecoveryPointsLinesCandidate,
+  RecoveryPostProcessResources,
+  RecoveryRootBundle,
+  RecoveryRootRuntime,
+} from './recovery/types';
+
+import { prepareRenderSystemRecoveryRoots } from './recovery/render-system-roots';
 import { ReflectionProbeRecordOwner } from './reflection/record-owner';
 import {
   OcclusionRenderRuntime,
@@ -113,18 +151,18 @@ import { inspectVolumetricFog } from './volume/inspection';
 export type { RenderSceneInspection } from './inspection-types';
 
 import { createCubeCaptureScheduler } from './capture/scheduler';
-import type { GpuResidencyCache } from './device/gpu-residency';
 import type { EnvironmentInspection } from './environment/inspection';
+import { gpuDrivenShadowDrawKey } from './extract/gpu-driven';
 import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM } from './gpu-usage';
 import { resetHdrpBuffers } from './hdrp-buffers';
-import { assembleMaterialWithSkylightEntries } from './ibl/skylight-bind-group';
+import type { SkylightBindGroupResources } from './ibl/skylight-bind-group';
 import {
   disposeInstanceBufferChunks,
   disposeInstanceBuffers,
   disposeTransientInstanceBuffers,
 } from './instance-buffer-cache';
 import type { InstanceCollectionInspection } from './instances';
-import { InstanceProjectionStore } from './instances';
+import { InstanceCollectionStore } from './instances';
 import {
   type MeshMaterialBindingObservation,
   type MeshMaterialBindingPreparationFailure,
@@ -163,12 +201,18 @@ import type {
   GpuPassTimingSession,
 } from './record/gpu-pass-timing/session';
 import type { GpuTimingCapture } from './record/gpu-timing';
-import { applyParamSnapshotToUbo, residentTextureView } from './record/main-pass-material';
-import type { RecoveryPipelineReadiness } from './record/recovery-pipeline';
+import { resolveMaterialSkylight } from './record/main-pass-material';
+import {
+  createPreparedResolverCaches,
+  type PreparedResolverCaches,
+  preparedMaterialBindings,
+} from './record/prepared-material-bindings';
 import type { PipelineState, RenderSystemInternals } from './record/render-context';
 import type { CubeCaptureGraphState } from './record/typed-frame-graph';
 import {
+  getRenderFeatureGraphInspection,
   type RenderFeatureGraphCandidate,
+  recordRenderFeatureCandidate,
   resetRenderFeatureGraphState,
   settleVolumetricFogGraphCandidate,
 } from './record/typed-frame-graph';
@@ -182,27 +226,27 @@ import {
 } from './render-contract';
 import type {
   DispatchEntry,
-  ExtractedFrame,
   ExtractedLights,
   MaterialSnapshot,
   RenderableSnapshot,
+  ShadowCasterMembership,
 } from './render-system-extract';
 import { extractFrames } from './render-system-extract';
 import {
-  type PersistentGpuDrivenCandidate,
-  type PersistentRenderCandidateRequest,
-  PersistentRenderScene,
-} from './scene/render-scene';
+  canonicalizeWorldComposition,
+  createLodWorldInspections,
+} from './render-system-projections';
+import { PersistentRenderScene } from './scene/render-scene';
 import { inspectLodOcclusion } from './scene/visibility/inspection';
 import { resolveSsaoParameters } from './ssao-config';
-import { projectSsrDependencies, resolveSsrAdmissionGeneration } from './ssr/admission';
 import {
-  getTransparentSortConfig,
-  TRANSPARENT_SORT_MODE_DISTANCE,
-  TRANSPARENT_SORT_MODE_LAYER_Y,
-  TRANSPARENT_SORT_MODE_LAYER_YZ,
-  TRANSPARENT_SORT_MODE_LAYER_Z,
-} from './systems/transparent-sort-config';
+  projectSsrDependencies,
+  resolveSsrAdmissionGeneration,
+  type SsrSpatialAdmission,
+  zeroSsrAdmissionWork,
+} from './ssr/admission';
+import { projectSsrSpatialInspection } from './ssr/inspection';
+import { sortTransparentDispatch } from './systems/transparent-dispatch';
 import type { RenderTarget } from './targets/contracts';
 import { createTemporalFrameTransaction, type TemporalFrame } from './temporal/frame';
 import { retireTemporalGpuState } from './temporal/gpu';
@@ -219,147 +263,71 @@ import {
   inspectTransmissionFromAdmission,
 } from './transmission/inspection';
 
-function canonicalizeWorldComposition(
+const WORLD_ENTITY_KEY_STRIDE = 4294967296;
+
+/**
+ * Extract emits world/entity keys in the transient `worlds[]` index domain,
+ * while PersistentRenderScene owns stable renderer-local World keys for the
+ * retained GPU scene. Rebase ShadowCaster ownership at this orchestration
+ * boundary before both GPU projection and CPU residual recording consume it.
+ */
+function rebaseShadowCasterOwnership(
   worlds: readonly World[],
-  owners: Pick<DrawOwnerOptions, 'cameraOwner' | 'resourceOwner'>,
-  leases: readonly RenderReadLease[] | undefined,
+  stableWorldKeys: readonly number[],
+  entityKeys: ReadonlySet<number>,
+  drawKeys: ReadonlySet<string>,
+  membership: readonly ShadowCasterMembership[] | undefined,
 ): {
-  readonly worlds: readonly World[];
-  readonly owners: Pick<DrawOwnerOptions, 'cameraOwner' | 'resourceOwner'>;
-  readonly leases: readonly RenderReadLease[] | undefined;
+  readonly entityKeys: ReadonlySet<number>;
+  readonly drawKeys: ReadonlySet<string>;
+  readonly membership: readonly ShadowCasterMembership[] | undefined;
 } {
-  const order = worlds
-    .map((world, index) => ({ world, index }))
-    .sort((left, right) => left.world.identity.localeCompare(right.world.identity));
-  const indexByOriginal = new Map(order.map((entry, index) => [entry.index, index]));
-  return {
-    worlds: Object.freeze(order.map((entry) => entry.world)),
-    owners: {
-      cameraOwner: indexByOriginal.get(owners.cameraOwner) ?? owners.cameraOwner,
-      resourceOwner: indexByOriginal.get(owners.resourceOwner) ?? owners.resourceOwner,
-    },
-    leases:
-      leases === undefined
-        ? undefined
-        : Object.freeze(
-            order.map((entry) => leases[entry.index]).filter((lease) => lease !== undefined),
-          ),
+  const rebaseWorldEntity = (composite: number): number => {
+    const transientWorldId = Math.floor(composite / WORLD_ENTITY_KEY_STRIDE);
+    if (
+      !Number.isInteger(transientWorldId) ||
+      transientWorldId < 0 ||
+      transientWorldId >= worlds.length
+    ) {
+      return composite;
+    }
+    const entityKey = composite - transientWorldId * WORLD_ENTITY_KEY_STRIDE;
+    return worldEntityKey(stableWorldKeys[transientWorldId] ?? transientWorldId, entityKey);
   };
-}
 
-interface LodInspectionQuerySummary {
-  readonly used: number;
-  readonly capacity: number;
-}
-
-function createLodWorldInspections(
-  worlds: readonly World[],
-  renderables: readonly RenderableSnapshot[],
-  submittedRenderables: readonly RenderableSnapshot[],
-  camera: CameraSnapshot,
-  frameId: number,
-  worldKeys: readonly number[],
-  slots: ReadonlyMap<number, { readonly slot: number; readonly generation: number }>,
-  query: LodInspectionQuerySummary,
-  fallback: LodOcclusionInspection['fallback'],
-  degradation: LodOcclusionInspection['degradation'],
-): readonly LodOcclusionWorldInspection[] {
-  // The CPU projection knows which renderables belong to each World, but it
-  // does not receive the GPU selector/query counters split by World from the
-  // same submit. Keep these rows available for diagnostics while explicitly
-  // marking their attribution unavailable; producers must not promote them
-  // to World-reorder evidence by inferring facts from array order.
-  const attribution = Object.freeze({
-    status: 'unavailable' as const,
-    reason: 'projection-only' as const,
-  });
-  const submitted = new Set(submittedRenderables);
-  const sampleLimit = 64;
-  const accumulators = worlds.map(() => ({
-    allCount: 0,
-    allVisible: 0,
-    allSamples: [] as RenderableSnapshot[],
-    lodCount: 0,
-    lodVisible: 0,
-    lodSamples: [] as RenderableSnapshot[],
-  }));
-  // Keep this projection bounded: the old implementation filtered the full
-  // 100k renderable list twice per World on every frame and retained another
-  // Set-backed traversal just to derive the six counters below. One pass is
-  // enough because the inspection only needs counts, the first row identity,
-  // and at most 64 detached samples.
-  for (const renderable of renderables) {
-    const accumulator = accumulators[renderable.worldId];
-    if (accumulator === undefined) continue;
-    const visible = submitted.has(renderable);
-    accumulator.allCount += 1;
-    if (visible) accumulator.allVisible += 1;
-    if (accumulator.allSamples.length < sampleLimit) accumulator.allSamples.push(renderable);
-    if ((renderable.lods?.length ?? 0) > 0) {
-      accumulator.lodCount += 1;
-      if (visible) accumulator.lodVisible += 1;
-      if (accumulator.lodSamples.length < sampleLimit) accumulator.lodSamples.push(renderable);
-    }
-  }
-  const result: LodOcclusionWorldInspection[] = [];
-  for (let worldId = 0; worldId < worlds.length; worldId += 1) {
-    const world = worlds[worldId];
-    if (world === undefined) continue;
-    const accumulator = accumulators[worldId];
-    if (accumulator === undefined || accumulator.allCount === 0) {
-      result.push(
-        Object.freeze({ attachmentId: world.identity, rows: Object.freeze([]), attribution }),
-      );
-      continue;
-    }
-    const usesLod = accumulator.lodCount > 0;
-    const candidateCount = usesLod ? accumulator.lodCount : accumulator.allCount;
-    const visible = usesLod ? accumulator.lodVisible : accumulator.allVisible;
-    const samples = usesLod ? accumulator.lodSamples : accumulator.allSamples;
-    const first = samples[0];
-    const slot =
-      first === undefined
-        ? undefined
-        : slots.get(worldEntityKey(worldKeys[first.worldId] ?? first.worldId, first.entityKey));
-    const row: LodOcclusionInspectionRow = {
-      root: {
-        guid: first === undefined ? 'none' : `asset-handle:${first.assetHandle}`,
-        sourceKey: `render-world:${world.identity}`,
-      },
-      view: {
-        attachmentId: world.identity,
-        cameraEntity: world === worlds[camera.worldId ?? 0] ? (camera.entityKey ?? 0) : 0,
-        viewRole: 'main',
-        viewGeneration: camera.historyVersion ?? 0,
-      },
-      slot: { primitiveSlot: slot?.slot ?? 0, slotGeneration: slot?.generation ?? 0 },
-      generation: frameId,
-      count: { candidates: candidateCount, visible, occluded: candidateCount - visible },
-      lodHistogram: [{ level: 0, count: candidateCount }],
-      queryLatencyUs: { median: 0, p95: 0, last: 0 },
-      pagePressure: query,
-      fallback,
-      degradation,
-      samples: samples.map((candidate, index) => ({
-        primitiveSlot:
-          slots.get(
-            worldEntityKey(worldKeys[candidate.worldId] ?? candidate.worldId, candidate.entityKey),
-          )?.slot ?? index,
-        level: 0,
-        visible: submitted.has(candidate),
-      })),
-    };
-    result.push(
-      Object.freeze({
-        attachmentId: world.identity,
-        rows: Object.freeze([row]),
-        attribution,
-      }),
-    );
-  }
-  return Object.freeze(
-    result.sort((left, right) => left.attachmentId.localeCompare(right.attachmentId)),
-  );
+  const stableMembership =
+    membership === undefined
+      ? undefined
+      : membership.map((entry) => ({
+          ...entry,
+          worldEntity: rebaseWorldEntity(entry.worldEntity),
+        }));
+  const stableDrawKeys =
+    stableMembership === undefined
+      ? new Set(
+          [...drawKeys].map((key) => {
+            const parts = key.split(':');
+            if (parts.length !== 4) return key;
+            const transientWorldEntity = Number(parts[0]);
+            if (!Number.isFinite(transientWorldEntity)) return key;
+            return `${rebaseWorldEntity(transientWorldEntity)}:${parts[1]}:${parts[2]}:${parts[3]}`;
+          }),
+        )
+      : new Set(
+          stableMembership.map((entry) =>
+            gpuDrivenShadowDrawKey(
+              entry.worldEntity,
+              entry.materialHandle,
+              entry.drawItemIndex,
+              entry.passIndex,
+            ),
+          ),
+        );
+  return {
+    entityKeys: new Set([...entityKeys].map(rebaseWorldEntity)),
+    drawKeys: stableDrawKeys,
+    membership: stableMembership,
+  };
 }
 
 type TimingSessionHost = RenderSystemInternals & {
@@ -418,12 +386,6 @@ export interface RendererProducerRoot {
   readonly disabledWork: 'zero' | 'lazy';
 }
 
-/** Device-bound post-process resources prepared off to the side of the active renderer. */
-export interface RecoveryPostProcessResources {
-  readonly device: RhiDevice;
-  readonly paramsBuffers: Map<string, Buffer>;
-}
-
 const PRODUCER_ROOT_MATRIX: readonly RendererProducerRoot[] = Object.freeze([
   {
     kind: 'backend-surface',
@@ -520,129 +482,6 @@ export interface RecoveryProductionEvidence {
   };
 }
 
-/**
- * Unified transparent-queue sub-sort covering all four
- * {@link TransparentSortConfig} modes. Reorders the
- * `queue === RenderQueue.Transparent` segment of the dispatch list;
- * all other queue segments keep their relative order.
- *
- * | mode | primary key | secondary key | tertiary key |
- * |:--:|:--|:--|:--|
- * | 0 (LAYER_Z)   | `layer` ASC | `posZ` ASC | `materialHandle` ASC |
- * | 1 (LAYER_Y)   | `layer` ASC | `-(posY - pivotY * sizeY)` ASC | `materialHandle` ASC |
- * | 2 (LAYER_YZ)  | `layer` ASC | `(posY - pivotY * sizeY) + yzAlpha * posZ` ASC | `materialHandle` ASC |
- * | 3 (DISTANCE)  | `-(dist² from camera)` ASC (back-to-front, layer ignored) | — |
- *
- * The `materialHandle` tertiary key for modes 0/1/2 groups same-material
- * entries together whenever the primary+secondary sort values are equal
- * (e.g. tilemap tiles in the same row/layer share `posY` in LAYER_Y mode).
- * Consecutive same-material groups then collapse into fold buckets in the
- * record-stage fold operator, significantly reducing draw call count for
- * tilemap-heavy scenes.
- *
- * `posX/Y/Z` = translation column of the entity's world mat4 (indices 12/13/14).
- * `pivotY` = `RenderableSnapshot.material.paramSnapshot.pivotAndSize[1]` (default 0.5).
- * `sizeY`  = length of the Y-axis column of the world mat4 (indices 4/5/6).
- */
-function sortTransparentDispatch(
-  dispatch: DispatchEntry[],
-  world: World,
-  cameras: readonly CameraSnapshot[],
-  renderables: readonly RenderableSnapshot[],
-): DispatchEntry[] {
-  const cfg = getTransparentSortConfig(world);
-  const mode = cfg.mode;
-
-  // Indices of Transparent-queue entries within the dispatch list.
-  const transparentSlots: number[] = [];
-  for (let i = 0; i < dispatch.length; i++) {
-    if (dispatch[i]?.queue === RenderQueue.Transparent) transparentSlots.push(i);
-  }
-  if (transparentSlots.length <= 1) return dispatch;
-
-  let sortedSlotOrder: number[];
-
-  if (mode === TRANSPARENT_SORT_MODE_DISTANCE) {
-    const camera = cameras[0];
-    if (camera === undefined) return dispatch;
-    const camPos = camera.position;
-
-    // Squared camera distance per entry (negated → ascending = back-to-front).
-    // D-3: world position = translation column of GlobalTransform.world (m[12,13,14]).
-    const negDistSq = (entry: DispatchEntry): number => {
-      const tx = renderables[entry.renderableIndex]?.transform;
-      if (tx === undefined) return 0;
-      const w = tx.world;
-      const dx = (w[12] ?? 0) - (camPos[0] ?? 0);
-      const dy = (w[13] ?? 0) - (camPos[1] ?? 0);
-      const dz = (w[14] ?? 0) - (camPos[2] ?? 0);
-      return -(dx * dx + dy * dy + dz * dz);
-    };
-
-    sortedSlotOrder = transparentSlots.slice().sort((a, b) => {
-      const da = negDistSq(dispatch[a] as DispatchEntry);
-      const db = negDistSq(dispatch[b] as DispatchEntry);
-      if (da < db) return -1;
-      if (da > db) return 1;
-      return 0;
-    });
-  } else {
-    // Modes 0/1/2: primary = layer ASC, secondary = mode-formula ASC.
-    // sizeY = length of the Y-axis column (col1 = indices 4,5,6) of the
-    // world mat4; rotation-invariant and handles flipV sign correctly.
-    const sortVal = (entry: DispatchEntry): number => {
-      const tx = renderables[entry.renderableIndex]?.transform;
-      const w = tx?.world;
-      const posY = (w?.[13] ?? 0) as number;
-      const posZ = (w?.[14] ?? 0) as number;
-      if (mode === TRANSPARENT_SORT_MODE_LAYER_Z) return posZ;
-      const mat = renderables[entry.renderableIndex]?.material;
-      // feat-20260625-refactor-sprite-as-transparent-mesh M3 / w15: post
-      // SpriteFieldsSnapshot ablation, pivot lives in paramSnapshot
-      // .pivotAndSize[0..1] (UBO-aligned vec4 slot 2, plan D-6). Non-sprite
-      // materials carry paramSnapshot=undefined and fall back to 0.5.
-      const pivotAndSize = mat?.paramSnapshot?.pivotAndSize as readonly number[] | undefined;
-      const pivotY = (pivotAndSize?.[1] ?? 0.5) as number;
-      const wy4 = (w?.[4] ?? 0) as number;
-      const wy5 = (w?.[5] ?? 1) as number;
-      const wy6 = (w?.[6] ?? 0) as number;
-      const sizeY = Math.sqrt(wy4 * wy4 + wy5 * wy5 + wy6 * wy6);
-      const footY = posY - pivotY * sizeY;
-      if (mode === TRANSPARENT_SORT_MODE_LAYER_Y) return -footY;
-      if (mode === TRANSPARENT_SORT_MODE_LAYER_YZ) return footY + cfg.yzAlpha * posZ;
-      // Defensive fallback for an unknown mode that slips past setTransparentSortConfig.
-      return posZ;
-    };
-
-    sortedSlotOrder = transparentSlots.slice().sort((a, b) => {
-      const da = dispatch[a] as DispatchEntry;
-      const db = dispatch[b] as DispatchEntry;
-      const la = da.layer;
-      const lb = db.layer;
-      if (la !== lb) return la - lb;
-      const va = sortVal(da);
-      const vb = sortVal(db);
-      if (va < vb) return -1;
-      if (va > vb) return 1;
-      // Tertiary tiebreaker: group same-materialHandle entries together so
-      // fold-eligible consecutive runs form. Entries at equal (layer,
-      // sortVal) — e.g. tilemap tiles in the same row under LAYER_Y — are
-      // depth-equivalent; reordering them by material does not change the
-      // visual result but maximises fold-bucket width.
-      return da.materialHandle - db.materialHandle;
-    });
-  }
-
-  // Scatter the reordered Transparent entries back into their original slots.
-  const result = dispatch.slice();
-  for (let k = 0; k < transparentSlots.length; k++) {
-    const targetSlot = transparentSlots[k] as number;
-    const sourceSlot = sortedSlotOrder[k] as number;
-    result[targetSlot] = dispatch[sourceSlot] as DispatchEntry;
-  }
-  return result;
-}
-
 /**
  * Engine-internal Extract / Prepare / Record driver; constructed by createRenderer.
  *
@@ -660,6 +499,9 @@ function sortTransparentDispatch(
  * whose shader identity is `forgeax::default-standard-pbr`).
  */
 export interface RenderSystem {
+  bounds(world: World, entity: number): RenderSceneBounds | undefined;
+  /** Complete explicit SSR capability preparation before drawing a device generation. */
+  initializeSsr(device?: RhiDevice): Promise<void>;
   /** Returns true only when this invocation reached queue submission. */
   draw(
     worlds: readonly World[],
@@ -677,7 +519,7 @@ export interface RenderSystem {
   /** Prepare a detached graph candidate without entering the frame record path. */
   prepareRecoveryGraphCandidate(
     runtime: RecoveryGraphCandidateRuntime,
-  ): Promise<RecoveryGraphCandidatePreparation>;
+  ): RecoveryGraphCandidatePreparation;
   /** Finish and submit detached candidate setup, never a frame receipt. */
   submitCandidateSetup(
     candidate: RecoveryGraphCandidate,
@@ -703,6 +545,8 @@ export interface RenderSystem {
   readonly pipelineDispatchCounts: {
     readonly unlit: number;
   };
+  /** Renderer-owned source for explicit large instance collections. */
+  readonly instances: InstanceCollectionStore;
   /** Detached residency and upload facts for explicit instance collections. */
   readonly instanceCollectionsInspection: readonly InstanceCollectionInspection[];
   /**
@@ -717,11 +561,17 @@ export interface RenderSystem {
   readonly reflectionProbes: ReflectionProbeInspection;
   /** Live producer/RHI/temporal receipts projected through SSR admission. */
   readonly ssrDependencies: SsrDependenciesInspection;
+  /** Live SSR spatial admission and bounded graph/history projection. */
+  readonly ssr: SsrSpatialInspection;
   /** Producer completion fence included in the public FrameReceipt. */
   readonly reflectionFallbackCompletion: Promise<void> | undefined;
   /** True while a progressive CubeCamera candidate still owns unfinished faces. */
   isCubeCapturePending(target: RenderTarget): boolean;
   readonly environment: EnvironmentInspection;
+  /** Detached auto-exposure state published after a successful frame submit. */
+  readonly autoExposure: AutoExposureInspection | undefined;
+  /** Detached Standard LUT state published after a successful frame submit. */
+  readonly standardLut: StandardLutInspection;
   readonly temporal: TemporalInspection;
   readonly bloom: BloomInspection;
   readonly motionBlurInspection: MotionBlurInspection | undefined;
@@ -756,6 +606,10 @@ export interface RenderSystem {
   readonly lastSuccessfulCameraAntialias: CameraSnapshot['antialias'] | undefined;
   /** Detached compiled-graph facts used by the renderer inspection owner. */
   readonly perFrameGraphInfo: CompiledRenderGraphInfo | undefined;
+  /** Detached feature signature/compile/lifetime counters. */
+  readonly featureGraphInspection: import('./inspection-types').RenderFeatureGraphInspection;
+  /** Detached material texture-source probe counters from the last extract. */
+  readonly materialTextureSources: MaterialTextureSourceInspection;
   /** Production-owner recovery facts used by Renderer.inspect(). */
   readonly recoveryEvidence: RecoveryProductionEvidence;
   /**
@@ -878,13 +732,6 @@ function makePreparedPipelinePendingError(): RhiError {
   });
 }
 
-/** The single Points/Lines owner’s staged device-generation handoff. */
-export interface RecoveryPointsLinesCandidate {
-  createRecoveryRoot(scope: DeviceScope): LifecycleResourceSpec<unknown>;
-  publish(): void;
-  release(): void;
-}
-
 function preparationFailureFrom(error: unknown): MeshMaterialBindingPreparationFailure | undefined {
   if (typeof error !== 'object' || error === null) return undefined;
   const value = error as {
@@ -912,58 +759,6 @@ function preparationFailureFrom(error: unknown): MeshMaterialBindingPreparationF
   };
 }
 
-/** Candidate-only device/runtime inputs used by the recovery prepare seam. */
-export interface RecoveryGraphCandidateRuntime {
-  readonly internals: RenderSystemInternals;
-  readonly pipelineState: PipelineState;
-}
-
-/** Detached graph state prepared on a replacement device, before publication. */
-export interface RecoveryGraphCandidate {
-  readonly frameState: RenderFrameState;
-  readonly setupWorks: readonly MipmapEncoderWork[];
-  readonly device: RhiDevice;
-  readonly generation: number;
-  readonly gpuDrivenProduction?: GpuDrivenProduction;
-  readonly gpuDrivenScene?: PersistentGpuDrivenCandidate;
-  /** Staged CPU-expanded Points/Lines buffers owned by the same RenderSystem. */
-  readonly pointsLines?: RecoveryPointsLinesCandidate;
-  readonly featureHost?: RenderFeatureHost;
-  readonly featureGpuWork?: RenderFeatureGpuWorkOwner;
-  readonly featureGraphCandidate?: RenderFeatureGraphCandidate;
-  readonly postProcessPipelines?: ReadonlyMap<string, RenderPipeline>;
-  readonly recoveryReadiness: RecoveryPipelineReadiness;
-  /** Release all candidate roots before publication; safe to call repeatedly. */
-  readonly release: () => void;
-  /** Transfer candidate-root ownership to the published RenderSystem. */
-  readonly markPublished: () => void;
-}
-
-/** Candidate setup completion; completion is bounded by the recovery owner. */
-export interface RecoveryGraphSetupSubmission {
-  readonly completion?: PromiseLike<unknown>;
-}
-
-export type RecoveryGraphCandidatePreparation =
-  | { readonly kind: 'no-seed' }
-  | { readonly kind: 'ready'; readonly candidate: RecoveryGraphCandidate }
-  | { readonly kind: 'failed'; readonly reason: string; readonly cause?: unknown };
-
-/** Explicit candidate-owned inputs for lifecycle-root preparation. */
-export interface RecoveryRootRuntime {
-  readonly scope: DeviceScope;
-  readonly device: RhiDevice;
-  readonly gpuStore: GpuResidencyCache;
-  readonly graphCandidate?: RecoveryGraphCandidate | undefined;
-}
-
-/** Candidate roots plus the one synchronous owner switch at publication. */
-export interface RecoveryRootBundle {
-  readonly roots: readonly LifecycleResourceSpec<unknown>[];
-  publish(): void;
-  discard(): void;
-}
-
 /**
  * Project the producer-owned material and GPU store state into the one
  * renderer observation surface. This is intentionally recomputed from the
@@ -1088,42 +883,37 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   let releaseProfilerCatalog =
     phaseCatalogRegistration?.ok === true ? phaseCatalogRegistration.value : undefined;
   let preparedWorlds: readonly World[] = [];
-  let lastSubmittedDynamicGeometryBindings = new WeakMap<World, ReadonlyMap<number, number>>();
+  const resolveFeatureNoise = createFeatureNoiseResolver({
+    scope: internals.deviceScope,
+    getDevice: () => internals.device,
+    onError: (error) => internals.errorRegistry.fire(error),
+  });
+  let preparedFeatureSkylightResources: SkylightBindGroupResources | undefined;
+  const dynamicGeometryFrames = createDynamicGeometryFrameBindings();
   let latestCamera: CameraSnapshot | undefined;
   const pointsLinesOwner = new StandardPointsLinesOwner(internals);
-  const instanceCollections = new InstanceProjectionStore();
+  const instanceCollections = new InstanceCollectionStore();
   const reflectionProbeOwner = new ReflectionProbeRecordOwner(internals);
-  let ssrFormatReceipt: import('@forgeax/engine-rhi').RhiTextureFormatCapabilityReceipt | undefined;
-  let ssrFormatProbeGeneration = -1;
-  let ssrFormatProbe: Promise<void> | undefined;
+  const ssrFormatReceipts = new WeakMap<
+    RhiDevice,
+    import('@forgeax/engine-rhi').RhiTextureFormatCapabilityReceipt
+  >();
   let ssrFallbackGeneration: number | undefined;
-  const ensureSsrFormatProbe = (): void => {
-    if (internals.ssrIdentity === undefined) return;
-    const generation = internals.deviceScope.generation;
+  const ensureSsrFormatProbe = async (device = internals.device): Promise<void> => {
     if (
-      ssrFormatReceipt?.deviceGeneration === generation ||
-      ssrFormatProbeGeneration === generation ||
-      ssrFormatProbe !== undefined ||
-      typeof internals.device.probeTextureFormatCapability !== 'function'
-    ) {
+      internals.ssrIdentity === undefined ||
+      typeof device.probeTextureFormatCapability !== 'function'
+    )
       return;
+    // RHI memoizes the probe per physical device. Retain the detached candidate
+    // receipt without publishing it: inspection selects only the active device.
+    // A failed/late recovery therefore cannot overwrite the active generation.
+    try {
+      const result = await device.probeTextureFormatCapability();
+      if (result.ok) ssrFormatReceipts.set(device, result.value);
+    } catch {
+      // Missing capability remains an explicit fallback-only admission.
     }
-    ssrFormatProbeGeneration = generation;
-    const device = internals.device;
-    ssrFormatProbe = device
-      .probeTextureFormatCapability()
-      .then((result) => {
-        if (internals.device !== device || internals.deviceScope.generation !== generation) return;
-        ssrFormatReceipt = result.ok ? result.value : undefined;
-      })
-      .catch(() => {
-        if (internals.device === device && internals.deviceScope.generation === generation) {
-          ssrFormatReceipt = undefined;
-        }
-      })
-      .finally(() => {
-        ssrFormatProbe = undefined;
-      });
   };
   const cubeCaptureScheduler = createCubeCaptureScheduler({ maxFacesPerFrame: 1 });
   const cubeCaptureState: CubeCaptureGraphState = { work: [] };
@@ -1134,7 +924,6 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       internals.gpuStore.invalidateMesh(handle, preparedWorlds[worldId] ?? worldId);
     },
     instanceCollections,
-    getSkinPaletteAllocator: () => internals.getPipelineState()?.skinPaletteAllocator ?? null,
   });
   let environmentLifecycle = new EnvironmentLifecycle(internals.deviceScope);
   const transmissionAdmission = new TransmissionCandidateAdmission();
@@ -1278,7 +1067,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           }),
         ),
     } satisfies import('./pipeline-builder').PipelineBuilderShaderModuleFactory);
-  let gpuDrivenProduction = GpuDrivenProduction.forDevice(internals.device, gpuDrivenShaderFactory);
+  let gpuDrivenRecoveryCount = 0;
+  let gpuDrivenProduction = createGpuDrivenOwner(
+    internals.device,
+    gpuDrivenShaderFactory,
+    gpuDrivenRecoveryCount,
+  );
   let occlusionRuntime: OcclusionRenderRuntime | undefined = new OcclusionRenderRuntime(
     internals.device,
     persistentRenderScene.visibilityFacetStore(),
@@ -1346,6 +1140,13 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   const frameState: RenderFrameState = {
     frameNumber: 0,
     reflectionFallbackDemand: false,
+    ssrRequested: false,
+    ssrSpatialAdmission: undefined,
+    ssrHistoryOwner: undefined,
+    ssrHistoryCandidate: undefined,
+    ssrTemporalParamsPayload: new Uint8Array(32),
+    ssrLastCameraEntity: undefined,
+    ssrLastHistoryVersion: undefined,
     graphGeneration: 0,
     successfulTemporalFrameIndex: 0,
     lastSuccessfulBloom: 'off',
@@ -1376,6 +1177,14 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     reflectionFallbackObservationSource: undefined,
     lastSuccessfulCameraAntialias: undefined,
     temporalGpuState: undefined,
+    autoExposureGpuResources: undefined,
+    pendingAutoExposureGpuResources: undefined,
+    autoExposureState: undefined,
+    pendingAutoExposureState: undefined,
+    standardLutGpuResources: undefined,
+    pendingStandardLutGpuResources: undefined,
+    standardLutState: createStandardLutState({ deviceEpoch: internals.deviceScope.generation }),
+    pendingStandardLutState: undefined,
     activeTemporalGpuState: undefined,
     retiringTemporalGpuStates: new Set(),
     lastSuccessfulTemporalView: undefined,
@@ -1385,7 +1194,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     currentDirectionalShadowView: null,
     currentSpotShadowView: null,
     instanceBuffers: new Map(),
-    instanceResidency: new Map(),
+    instanceCollections,
     instanceBufferChunks: new Map(),
     probeBlendBuffers: new Map(),
     probeBlendRecordBufferCapacity: 0,
@@ -1468,6 +1277,25 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     // tiles until the first frame with a castShadow spot (AC-03).
     spotShadowSnapshots: [],
   };
+  const resolveSsrDependencies = (requested: boolean): SsrDependenciesInspection => {
+    // Explicit SSR capability preparation belongs to initialization. Inspection
+    // only projects receipts and never starts work or creates image history.
+    const owner = reflectionProbeOwner.inspect();
+    const temporal =
+      frameState.lastSuccessfulTemporalView === undefined
+        ? undefined
+        : ({
+            successfulSubmit: true,
+            generation: frameState.lastSuccessfulTemporalView.input.deviceGeneration,
+          } as const);
+    return projectSsrDependencies({
+      requested,
+      identity: internals.ssrIdentity,
+      reflectionFallback: owner.reflectionFallback,
+      format: ssrFormatReceipts.get(internals.device),
+      temporal,
+    });
+  };
   let directFrameId = 0;
   let submittedFrameCount = 0;
   let lastSubmittedGeneration: number | undefined;
@@ -1475,6 +1303,122 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   let lastDirectionalShadowCandidate: 'accepted' | 'failed' = 'failed';
   let lastDirectionalShadowError: DirectionalShadowInspectionSource['error'];
 
+  /**
+   * Stage the detached auto/LUT facts beside the GPU candidates already owned
+   * by RenderFrameState. The typed graph promotes both records only after its
+   * single finish/submit transaction succeeds; no side registry or compile
+   * callback can publish a value early.
+   */
+  function stageLiveFeatureState(camera: CameraSnapshot | undefined, deltaTime: number): void {
+    frameState.pendingAutoExposureState = undefined;
+    frameState.pendingStandardLutState = undefined;
+    const output = camera?.output;
+    if (output === undefined) return;
+
+    const publicFrameId =
+      (internals as RenderSystemInternals & { readonly observationFrameId?: number })
+        .observationFrameId ?? frameState.frameNumber;
+    const targetGeneration = Math.max(1, camera?.historyVersion ?? 0);
+    const deviceEpoch = internals.deviceScope.generation;
+
+    if (
+      output.exposure.kind === 'auto' &&
+      (frameState.pendingAutoExposureGpuResources !== undefined ||
+        frameState.autoExposureGpuResources !== undefined)
+    ) {
+      let state = frameState.autoExposureState;
+      if (state === undefined || state.fallback !== output.exposure.fallback) {
+        const created = createAutoExposureState({
+          fallback: output.exposure.fallback,
+          targetGeneration,
+          deviceEpoch,
+          frameId: publicFrameId,
+        });
+        if (!created.ok) {
+          internals.errorRegistry.fire(created.error);
+          return;
+        }
+        state = created.value;
+      } else if (state.targetGeneration !== targetGeneration || state.deviceEpoch !== deviceEpoch) {
+        state = resetAutoExposureState(state, 'camera-change', {
+          targetGeneration,
+          deviceEpoch,
+        });
+      }
+      const resources =
+        frameState.pendingAutoExposureGpuResources ?? frameState.autoExposureGpuResources;
+      if (resources !== undefined) {
+        const parameterWrite = writeAutoExposureParameters(resources, {
+          compensationEv: output.exposure.compensationEv,
+          rangeMinEv: output.exposure.rangeEv[0],
+          rangeMaxEv: output.exposure.rangeEv[1],
+          upRate: output.exposure.rates[0],
+          downRate: output.exposure.rates[1],
+          deltaTime,
+          fallback: output.exposure.fallback,
+          generation: state.targetGeneration,
+        });
+        if (!parameterWrite.ok) {
+          internals.errorRegistry.fire(parameterWrite.error as RhiError);
+          return;
+        }
+      }
+      // The GPU adapt pass owns the numeric candidate. CPU staging carries
+      // only the generation/transaction facts needed for submit publication.
+      frameState.pendingAutoExposureState = Object.freeze({
+        state,
+        generation: state.targetGeneration,
+        deviceEpoch: state.deviceEpoch,
+        frameId: publicFrameId,
+      });
+    }
+
+    let lutState = frameState.standardLutState;
+    if (lutState.targetGeneration !== targetGeneration || lutState.deviceEpoch !== deviceEpoch) {
+      lutState = resetStandardLutState(lutState, 'device-recovered', {
+        targetGeneration,
+        deviceEpoch,
+      });
+      frameState.standardLutState = lutState;
+    }
+    const wantsLut = output.colorLutStrength > 0 && output.colorLut > 0;
+    const lutResources =
+      frameState.pendingStandardLutGpuResources ?? frameState.standardLutGpuResources;
+    if (wantsLut && lutResources !== undefined) {
+      const prepared = prepareStandardLutCandidate(lutState, {
+        // sourceKey is the Catalog-owned identity returned by the same
+        // preparation that built the live LUT bind group; numeric handles do
+        // not cross the inspection boundary.
+        resident: lutResources.sourceKey,
+        sourceKey: lutResources.sourceKey,
+        generation: lutState.targetGeneration,
+        deviceEpoch: lutState.deviceEpoch,
+        frameId: publicFrameId,
+      });
+      if (prepared.ok) {
+        frameState.pendingStandardLutState = Object.freeze({
+          state: lutState,
+          candidate: prepared.value,
+          remove: false,
+          targetGeneration,
+          deviceEpoch,
+        });
+      }
+    } else if (!wantsLut && lutState.resident !== null) {
+      frameState.pendingStandardLutState = Object.freeze({
+        state: lutState,
+        remove: true,
+        targetGeneration,
+        deviceEpoch,
+      });
+    }
+  }
+
+  function discardLiveFeatureState(): void {
+    frameState.pendingAutoExposureState = undefined;
+    frameState.pendingStandardLutState = undefined;
+  }
+
   function beginProfilePhase(session: RecorderSession | undefined, phase: RenderPhase): boolean {
     if (session === undefined) return false;
     try {
@@ -1706,22 +1650,21 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   const getPostProcessPipeline = (
     id: string,
     bgl: BindGroupLayout,
-    colorFormat: GPUTextureFormat,
+    colorFormats: readonly GPUTextureFormat[],
     entryOverride?: PostProcessShaderEntry,
   ): RenderPipeline | null => {
     const entry = entryOverride ?? lookupPostProcess(id);
     if (entry === undefined) return null;
     const signature = postProcessShaderEntrySignature(entry);
-    const key = `${id}|${colorFormat}|${signature}`;
+    const key = `${id}|${colorFormats.join(',')}|${signature}`;
     const cached = postProcessPipelineCache.get(key);
     if (cached !== undefined) return cached;
-    internals.recoveryColdWorkGuard?.notePipelineColdWork();
     const factory = internals.buildPostProcessPipeline;
     if (factory === undefined) return null;
     const built = factory(
       entry,
       bgl,
-      colorFormat,
+      colorFormats,
       postProcessShaderPipelineLabel(id, entry.source),
     );
     if (built === null) return null;
@@ -1892,193 +1835,18 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     createBindGroup: 0,
     keys: [],
   };
-  type PreparedResolverCaches = {
-    readonly preparedPipelineIds: WeakMap<object, string>;
-    readonly preparedMaterialPipelineShaders: WeakMap<object, string>;
-    readonly preparedGroup0Pipelines: WeakSet<object>;
-    readonly preparedViewOnlyPipelines: WeakSet<object>;
-    readonly preparedRenderMaterialPipelines: WeakSet<object>;
-    readonly preparedAssetHandles: WeakMap<World, Map<string, number>>;
-  };
-  const createPreparedResolverCaches = (): PreparedResolverCaches => ({
-    preparedPipelineIds: new WeakMap(),
-    preparedMaterialPipelineShaders: new WeakMap(),
-    preparedGroup0Pipelines: new WeakSet(),
-    preparedViewOnlyPipelines: new WeakSet(),
-    preparedRenderMaterialPipelines: new WeakSet(),
-    preparedAssetHandles: new WeakMap(),
-  });
   const activePreparedResolverCaches = createPreparedResolverCaches();
-  const preparedHandle = <Brand extends string>(
-    runtime: RenderSystemInternals,
-    caches: PreparedResolverCaches,
-    world: World,
-    guid: string,
-    brand: Brand,
-  ): Handle<Brand, 'shared'> | undefined => {
-    let handles = caches.preparedAssetHandles.get(world);
-    if (handles === undefined) {
-      handles = new Map();
-      caches.preparedAssetHandles.set(world, handles);
-    }
-    const key = `${brand}:${guid.toLowerCase()}`;
-    const cached = handles.get(key);
-    if (cached !== undefined) return cached as Handle<Brand, 'shared'>;
-    const asset = runtime.assets.lookup(guid);
-    if (asset === undefined) return undefined;
-    const handle = world.allocSharedRef(brand, asset);
-    handles.set(key, handle as number);
-    return handle;
-  };
-  const preparedMaterialBindings = (
-    runtime: RenderSystemInternals,
-    caches: PreparedResolverCaches,
-    worlds: readonly World[],
-    materialShaderId: string,
-    worldIndex: number,
-    materialGuid: string,
-    layout: BindGroupLayout,
-  ) => {
-    const world = worlds[worldIndex];
-    const material = runtime.assets.lookup(materialGuid) as MaterialAsset | undefined;
-    const pipelineState = runtime.getPipelineState();
-    if (world === undefined || material?.kind !== 'material' || pipelineState === null) {
-      return err(new Error('prepared material asset is unavailable'));
-    }
-    const schema = runtime.getParamSchema?.(materialShaderId) ?? [];
-    const values = material.values ?? {};
-    const derived = derive(schema);
-    const fields = [...derived.textureFieldNames];
-    let buffer: Buffer | undefined;
-    let payloadByteLength = 0;
-    if (derived.uboLayout.totalBytes > 0) {
-      const payload = new Uint8Array(Math.max(16, derived.uboLayout.totalBytes));
-      applyParamSnapshotToUbo(
-        payload,
-        schema,
-        values as Readonly<Record<string, number | readonly number[]>>,
-      );
-      const created = runtime.device.createBuffer({
-        label: `prepared-material:${materialGuid}`,
-        size: payload.byteLength,
-        usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-      });
-      if (!created.ok) return created;
-      buffer = created.value;
-      payloadByteLength = payload.byteLength;
-      const written = runtime.device.queue.writeBuffer(buffer, 0, payload);
-      if (!written.ok) {
-        runtime.device.destroyBuffer(buffer);
-        return written;
-      }
-    }
-    const textureResources: Array<{
-      sampler: import('@forgeax/engine-rhi').Sampler;
-      view: import('@forgeax/engine-rhi').TextureView;
-    }> = [];
-    for (let index = 0; index < fields.length; index += 1) {
-      const field = fields[index];
-      const value = field === undefined ? undefined : values[field];
-      const textureValue =
-        typeof value === 'object' && value !== null && 'texture' in value
-          ? (value as MaterialTextureValue)
-          : undefined;
-      let sampler = pipelineState.defaultSampler;
-      if (textureValue?.sampler !== undefined) {
-        const handle = preparedHandle(
-          runtime,
-          caches,
-          world,
-          String(textureValue.sampler),
-          'SamplerAsset',
-        );
-        if (handle !== undefined) {
-          const asset = resolveAssetHandle<SamplerAsset>(world, handle);
-          if (asset.ok) {
-            const resident = runtime.gpuStore.ensureSamplerResident(handle, asset.value, world);
-            if (resident.ok) sampler = resident.value;
-          }
-        }
-      }
-      let view = pipelineState.defaultWhiteTextureView;
-      if (textureValue !== undefined) {
-        const handle = preparedHandle(
-          runtime,
-          caches,
-          world,
-          String(textureValue.texture),
-          'TextureAsset',
-        );
-        if (handle !== undefined) {
-          view = residentTextureView(world, runtime.gpuStore, runtime, handle) ?? view;
-        }
-      }
-      textureResources.push({ sampler, view });
-    }
-    const entries: BindGroupEntry[] = [];
-    let textureIndex = 0;
-    for (let index = 0; index < derived.bglEntries.length; index += 1) {
-      const expected = derived.bglEntries[index];
-      if (expected?.buffer?.type === 'uniform' && buffer !== undefined) {
-        entries.push({
-          binding: expected.binding,
-          resource: { kind: 'buffer', value: { buffer, size: payloadByteLength } },
-        });
-        continue;
-      }
-      const textureResource = textureResources[textureIndex];
-      if (
-        expected?.sampler?.type === 'filtering' &&
-        derived.bglEntries[index + 1]?.texture !== undefined &&
-        textureResource !== undefined
-      ) {
-        entries.push({
-          binding: expected.binding,
-          resource: { kind: 'sampler', value: textureResource.sampler },
-        });
-        continue;
-      }
-      if (expected?.texture !== undefined && textureResource !== undefined) {
-        entries.push({
-          binding: expected.binding,
-          resource: { kind: 'textureView', value: textureResource.view },
-        });
-        textureIndex += 1;
-        continue;
-      }
-      if (buffer !== undefined) runtime.device.destroyBuffer(buffer);
-      return err(new Error('prepared material schema contains unsupported binding kinds'));
-    }
-    const fallback = pipelineState.skylightFallback;
-    if (fallback === null) {
-      if (buffer !== undefined) runtime.device.destroyBuffer(buffer);
-      return err(new Error('prepared material skylight fallback is unavailable'));
-    }
-    const completeEntries = assembleMaterialWithSkylightEntries(entries, {
-      irradianceView: fallback.irradianceView,
-      irradianceSampler: fallback.sampler,
-      prefilterView: fallback.prefilterView,
-      prefilterSampler: fallback.sampler,
-      brdfLutView: fallback.brdfLutView,
-      brdfLutSampler: fallback.sampler,
-      intensityBuffer: fallback.intensityBuffer,
-    });
-    const group = runtime.device.createBindGroup({ layout, entries: completeEntries });
-    if (!group.ok) {
-      if (buffer !== undefined) runtime.device.destroyBuffer(buffer);
-      return group;
-    }
-    if (buffer === undefined) return group;
-    return ok({
-      handle: group.value,
-      dynamicOffsets: [0, 0],
-      release: () => runtime.device.destroyBuffer(buffer),
-    });
-  };
   const lastFrustumStats: { culled: number; total: number } = { culled: 0, total: 0 };
   const lastVisibilityStats: { explicitlyHidden: number } = { explicitlyHidden: 0 };
+  let lastMaterialTextureSources: MaterialTextureSourceInspection = {
+    sourceFieldsVisited: 0,
+    numericSharedRefProbes: 0,
+    sourceCacheHits: 0,
+    sourceCacheMisses: 0,
+    producerRoutes: Object.freeze({}),
+  };
   let lastMeshMaterialBindings: readonly MeshMaterialBindingObservation[] = [];
-  let lastMeshMaterialBindingFrame: ExtractedFrame | undefined;
+  let lastMeshMaterialBindingRenderables: readonly RenderableSnapshot[] | undefined;
   const createPreparedResolverFactory =
     (
       runtime: RenderSystemInternals,
@@ -2115,7 +1883,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             const pipeline = runtime.getPostProcessPipeline?.(
               descriptor.shader,
               fullscreen.bindGroupLayout,
-              descriptor.colorFormats[0] as GPUTextureFormat,
+              descriptor.colorFormats as readonly GPUTextureFormat[],
               postProcessEntry,
             );
             if (pipeline !== null && pipeline !== undefined) {
@@ -2128,14 +1896,26 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               ? err(makePreparedPipelinePendingError())
               : ok(pipeline);
           }
-          const preparedPipeline = runtime.getMaterialShaderPipeline?.(
+          const clusteredParticleMesh =
+            runtime.device.caps.storageBuffer &&
+            (descriptor.shader === 'forgeax::vfx-render.particles.mesh' ||
+              descriptor.shader === 'forgeax::vfx-render.particles.mesh-inputs');
+          const requestedVariantSet = clusteredParticleMesh
+            ? 'CLUSTER_FORWARD_AVAILABLE=true'
+            : undefined;
+          // A colorless prepared program is a depth-only pass. Vertex-only
+          // shadow programs must use the depth policy; resolving them as
+          // forward asks Dawn for a non-existent `fs_main` entry point.
+          const preparedPassKind =
+            descriptor.colorFormats.length === 0 ? 'shadow-caster' : 'forward';
+          const preparedPipelineEntry = runtime.getMaterialShaderPipelineEntry?.(
             descriptor.shader,
             descriptor.colorFormats[0] === 'rgba16float',
             descriptor.renderState,
             descriptor.topology,
             descriptor.indexFormat,
-            undefined,
-            'forward',
+            requestedVariantSet,
+            preparedPassKind,
             undefined,
             descriptor.sampleCount ?? 1,
             // Prepared graphics own their declared attachment format. Passing
@@ -2150,7 +1930,41 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             descriptor.vertexLayout,
             undefined,
             input.shaderModuleMode,
+            undefined,
+            undefined,
+            undefined,
+            undefined,
+            undefined,
+            descriptor.particleInputLanes,
           );
+          const preparedPipeline =
+            preparedPipelineEntry === undefined
+              ? (runtime.getMaterialShaderPipeline?.(
+                  descriptor.shader,
+                  descriptor.colorFormats[0] === 'rgba16float',
+                  descriptor.renderState,
+                  descriptor.topology,
+                  descriptor.indexFormat,
+                  requestedVariantSet,
+                  preparedPassKind,
+                  undefined,
+                  descriptor.sampleCount ?? 1,
+                  descriptor.colorFormats[0] as GPUTextureFormat,
+                  undefined,
+                  descriptor.depthFormat === undefined
+                    ? null
+                    : (descriptor.depthFormat as GPUTextureFormat),
+                  descriptor.vertexLayout,
+                  undefined,
+                  input.shaderModuleMode,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  descriptor.particleInputLanes,
+                ) ?? null)
+              : (preparedPipelineEntry?.pipeline ?? null);
           // A requested material shader is an exact pipeline contract. During
           // async shader warmup, substituting the generic unlit pipeline can
           // mismatch vertex layouts and HDR attachment formats, turning a
@@ -2167,7 +1981,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               preparedRenderMaterialPipelines.add(pipeline as object);
             }
           }
-          return pipeline === null ? err(makePreparedPipelinePendingError()) : ok(pipeline);
+          return pipeline === null
+            ? err(makePreparedPipelinePendingError())
+            : ok({
+                handle: pipeline,
+                standardLighting: preparedPipelineEntry?.group2Contract === 'cluster',
+              });
         },
         resolveBindings: (descriptor, pipeline) => {
           const materialShaderId = preparedMaterialPipelineShaders.get(pipeline as object);
@@ -2183,6 +2002,14 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           if (bindingContract === 'view-and-scene-depth') {
             return ok(undefined);
           }
+          if (
+            preparedRenderMaterialPipelines.has(pipeline as object) &&
+            descriptor.values.group === 0 &&
+            descriptor.values.sceneDepth === undefined &&
+            descriptor.values.sceneDepthBinding !== undefined
+          ) {
+            return err(new Error('prepared scene-depth pipeline requires a scene target'));
+          }
           if (preparedGroup0Pipelines.has(pipeline as object)) {
             const layout =
               (materialShaderId === undefined
@@ -2236,6 +2063,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               material.world,
               material.guid,
               layout,
+              preparedFeatureSkylightResources,
             );
           }
           return layout === undefined
@@ -2319,23 +2147,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     createPreparedResolverCaches,
   });
   return {
+    instances: instanceCollections,
+    initializeSsr: ensureSsrFormatProbe,
     get instanceCollectionsInspection(): readonly InstanceCollectionInspection[] {
-      return instanceCollections._inspections(
-        frameState.instanceResidency,
-        frameState.frameNumber - 1,
-      );
+      return instanceCollections._inspections();
     },
     releaseProfilerCatalog(): void {
       releaseProfilerCatalog?.();
       releaseProfilerCatalog = undefined;
     },
     invalidateGeometryHistory(): void {
-      frameState.temporalFrameTransaction.reset('signature-change');
-      frameState.temporalFrame = undefined;
-      frameState.temporalFrameInput = undefined;
-      frameState.lastSuccessfulTemporalView = undefined;
-      frameState.successfulTemporalFrameIndex = 0;
-      frameState.pendingTemporalCommit = { kind: 'none' };
+      resetDynamicGeometryTemporalHistory(frameState);
+    },
+    bounds(world, entity) {
+      return persistentRenderScene.bounds(world, entity);
     },
     get renderScene(): RenderSceneInspection {
       return {
@@ -2350,32 +2175,46 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       return reflectionProbeOwner.inspect();
     },
     get ssrDependencies(): SsrDependenciesInspection {
-      ensureSsrFormatProbe();
-      const owner = reflectionProbeOwner.inspect();
-      const nextGeneration = owner.reflectionFallback.projectionGeneration;
-      const reset = resolveSsrAdmissionGeneration(ssrFallbackGeneration, nextGeneration);
-      if (reset.changed) {
-        frameState.temporalFrameTransaction.reset('signature-change');
-        frameState.temporalFrame = undefined;
-        frameState.temporalFrameInput = undefined;
-        frameState.lastSuccessfulTemporalView = undefined;
-        frameState.successfulTemporalFrameIndex = 0;
-        frameState.pendingTemporalCommit = { kind: 'none' };
-      }
-      ssrFallbackGeneration = reset.generation;
-      const temporal =
-        frameState.lastSuccessfulTemporalView === undefined
-          ? undefined
-          : ({
-              successfulSubmit: true,
-              generation: frameState.lastSuccessfulTemporalView.input.deviceGeneration,
-            } as const);
-      return projectSsrDependencies({
-        requested: frameState.reflectionFallbackDemand === true,
-        identity: internals.ssrIdentity,
-        reflectionFallback: owner.reflectionFallback,
-        format: ssrFormatReceipt,
-        temporal,
+      return resolveSsrDependencies(frameState.ssrRequested === true);
+    },
+    get ssr(): SsrSpatialInspection {
+      const camera = latestCamera;
+      const lane = internals.standardProfile?.renderPath === 'deferred' ? 'deferred' : 'forward';
+      const admission: SsrSpatialAdmission =
+        frameState.ssrSpatialAdmission ??
+        Object.freeze({
+          status: camera?.screenSpaceReflection === undefined ? 'not-requested' : 'requested',
+          lane,
+          config: camera?.screenSpaceReflection,
+          viewRange: camera === undefined ? 0 : camera.far - camera.near,
+          work: zeroSsrAdmissionWork(),
+        });
+      const admitted = admission.status === 'admitted';
+      const status =
+        admitted && internals.ssrShaders === undefined
+          ? ('structural-only' as const)
+          : admission.status;
+      const graph = frameState.compiledFrameGraph?.inspect();
+      const passRoster =
+        admitted && graph !== undefined
+          ? graph.passes.filter((pass) => pass.name.startsWith('ssr-')).map((pass) => pass.name)
+          : [];
+      const history = frameState.ssrHistoryOwner?.inspect();
+      const dependencies = resolveSsrDependencies(frameState.ssrRequested === true);
+      const fallbackSource = dependencies.reflectionFallback?.source;
+      return projectSsrSpatialInspection(admission, {
+        status,
+        ...(history === undefined
+          ? {}
+          : {
+              history: {
+                state: history.state,
+                bytes: history.activeBytes + history.candidateBytes + history.retiringBytes,
+                resetCount: history.resetCount,
+              },
+            }),
+        passRoster,
+        ...(fallbackSource === undefined ? {} : { fallbackSource }),
       });
     },
     get reflectionFallbackCompletion(): Promise<void> | undefined {
@@ -2387,6 +2226,27 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     get environment(): EnvironmentInspection {
       return environmentLifecycle.inspect();
     },
+    get autoExposure(): AutoExposureInspection | undefined {
+      const camera = latestCamera;
+      const state = frameState.autoExposureState;
+      if (camera?.output?.exposure.kind !== 'auto' || state === undefined) return undefined;
+      const actual = state.acceptedEv > 0 ? state.acceptedEv : null;
+      return createAutoExposureInspection({
+        requested: camera.output.exposure,
+        actual,
+        actualState:
+          actual === null ? (state.receipt.committed ? 'gpu-resident' : 'fallback') : 'accepted',
+        fallback: state.fallback,
+        lastKnownGood: state.lastKnownGood,
+        targetGeneration: state.targetGeneration,
+        reset: state.reset,
+        cost: { histogramBytes: AUTO_EXPOSURE_HISTOGRAM_BYTES, passCount: 3, physicalPassCount: 1 },
+        receipt: state.receipt,
+      });
+    },
+    get standardLut(): StandardLutInspection {
+      return inspectStandardLutState(frameState.standardLutState);
+    },
     get temporal(): TemporalInspection {
       return inspectTemporal(frameState.lastSuccessfulTemporalView, undefined, {
         ...(frameState.activeTemporalGpuState === undefined
@@ -2526,6 +2386,14 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       return persistentRenderScene.pointsLinesSnapshots();
     },
     detachScene(world: World): void {
+      const worldId = preparedWorlds.indexOf(world);
+      const allocator = internals.getPipelineState()?.skinPaletteAllocator;
+      if (allocator !== undefined && allocator !== null) {
+        for (const slot of persistentRenderScene.compositionSlots()) {
+          if (slot.worldId === worldId && slot.snapshot.skin !== undefined)
+            allocator.releasePersistentSlice(slot.snapshot.skin.identity);
+        }
+      }
       persistentRenderScene.detach(world);
     },
     draw(
@@ -2543,8 +2411,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       let submitted = false;
       // A failed draw must never leave a previous frame eligible to publish a
       // newly accepted dynamic-geometry candidate.
-      lastSubmittedDynamicGeometryBindings = new WeakMap();
-      const frameConsumedDynamicGeometryBindings = new WeakMap<World, Map<number, number>>();
+      dynamicGeometryFrames.begin();
       if (profileSession !== undefined && opts.profileFrame === undefined) {
         try {
           ownsProfileFrame = profileSession.beginFrame(++directFrameId).ok;
@@ -2557,7 +2424,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         // cameraOwner drives the surfaced cameras + frustum
         // cull; resourceOwner drives skylight/skybox/postProcess + per-world
         // record config.
-        const { cameraOwner, resourceOwner } = composition.owners;
+        const { cameraOwner, resourceOwner, cameraEntityKey } = composition.owners;
         // Keep the compiled graph as last-known-good until the candidate topology
         // compiles. The failed candidate frame does not execute it; successful
         // replacement retires it atomically in ensureCompiledFrameGraph.
@@ -2571,37 +2438,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         }
         dispatchCounts.unlit = 0;
 
-        // feat-20260708-composited-multi-world-rendering M3 / D-2 / m3-i2:
-        // extractFrames merges per-world snapshots (renderables + lights from
-        // every world, cameras + singleton resources from the owner world),
-        // runs read-only extractFrame per world over the already-updated World,
-        // resets frame state once, and isolates
-        // per-world errors (AC-09).
-        // Single-world draw([world], { cameraOwner: 0, resourceOwner: 0 }) is the identity path
-        // (worldId=0), byte-for-byte equivalent to the pre-M3 direct
-        // extractFrame path (AC-03 regression guarantee).
-        //
-        // Entry validation (empty worlds / owner out of range) is enforced by
-        // the public renderer.draw facade (createRenderer.ts, D-5) before this
-        // internal method is reached; the owner world is guaranteed present.
-        //
-        // feat-20260709-editor-world-partition M1 / w5+w6 (D-3): per-world
-        // record configuration (transparent-sort mode, fold buckets, skybox /
-        // asset resolution) is read from the resource-owner world — the world
-        // that owns skylight / skybox / postProcessParams. w6 sources it from
-        // the dedicated resourceOwner index. The variable is named
-        // `resourceWorld` so the record-stage reads are self-describing (they
-        // are resource-owner reads, not camera reads).
         const resourceWorld = compositionWorlds[resourceOwner] as World;
         const frame = runProfiledRenderPhase(profileSession, 'extract', () => {
           return persistentRenderScene.extractComposition(
             compositionWorlds,
             { cameraOwner, resourceOwner },
             internals.assets.catalogEpoch,
-            (request: PersistentRenderCandidateRequest) =>
+            (renderables) =>
               extractFrames(
                 compositionWorlds,
-                { cameraOwner, resourceOwner },
+                {
+                  cameraOwner,
+                  resourceOwner,
+                  ...(cameraEntityKey === undefined ? {} : { cameraEntityKey }),
+                },
                 internals.assets,
                 internals.getPipelineState(),
                 persistentRenderScene.materialSnapshotCacheStore(),
@@ -2626,13 +2476,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                         },
                       }),
                   cull: 'none',
-                  renderables: request === 'none' ? 'none' : 'full',
-                  ...(request === 'none' || request === 'full'
-                    ? {}
-                    : { renderableEntitiesByWorld: request.entitiesByWorld }),
                   retainHidden: true,
+                  renderables,
                   instanceCollections,
-                  ...(internals.getMaterialShaderArtifact === undefined
+                  ...(!internals.device.caps.storageBuffer ||
+                  internals.getMaterialShaderArtifact === undefined
                     ? {}
                     : { getMaterialShaderArtifact: internals.getMaterialShaderArtifact }),
                 },
@@ -2641,7 +2489,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           );
         });
         const {
-          cameras,
+          cameras: extractedCameras,
           cubeCameras,
           lights,
           environment,
@@ -2649,6 +2497,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           volumetricFog,
           renderables,
           dispatch,
+          shadowCasterEntityKeys: extractedShadowCasterEntityKeys,
+          shadowCasterDrawKeys: extractedShadowCasterDrawKeys,
+          shadowCasterMembership: extractedShadowCasterMembership,
           skylight,
           skylightCount,
           skybox,
@@ -2658,6 +2509,28 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           visibilityStats,
           postProcessParams,
         } = frame;
+        const cameras = extractedCameras;
+        const preparedOutput = prepareStandardOutputResources(
+          frameState,
+          internals,
+          cameras[0],
+          compositionWorlds[cameraOwner] as World,
+        );
+        if (!preparedOutput.ok) {
+          internals.errorRegistry.fire(preparedOutput.error);
+          return false;
+        }
+        const stableShadowOwnership = rebaseShadowCasterOwnership(
+          compositionWorlds,
+          persistentRenderScene.visibilityWorldKeysFor(compositionWorlds),
+          extractedShadowCasterEntityKeys,
+          extractedShadowCasterDrawKeys,
+          extractedShadowCasterMembership,
+        );
+        const shadowCasterEntityKeys = stableShadowOwnership.entityKeys;
+        const shadowCasterDrawKeys = stableShadowOwnership.drawKeys;
+        const shadowCasterMembership = stableShadowOwnership.membership;
+        const shadowCasterProjection = persistentRenderScene.shadowCasterProjection();
         lastDirectionalShadowLights = lights;
         lastDirectionalShadowCandidate = 'failed';
         lastDirectionalShadowError = lights.directionalShadowError;
@@ -2669,6 +2542,26 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           skylight,
         );
         latestCamera = cameras[0];
+        frameState.ssrRequested = latestCamera?.screenSpaceReflection !== undefined;
+        // Resolve before a committed fallback change resets accumulation.
+        // Fresh spatial SSR does not require a previous temporal submission.
+        // Inspection uses the read-only projection above and never resets state.
+        const ssrDependencies = resolveSsrDependencies(frameState.ssrRequested);
+        const reset = resolveSsrAdmissionGeneration(
+          ssrFallbackGeneration,
+          ssrDependencies.reflectionFallback?.projectionGeneration,
+        );
+        if (reset.changed) {
+          frameState.temporalFrameTransaction.reset('signature-change');
+          frameState.temporalFrame = undefined;
+          frameState.temporalFrameInput = undefined;
+          frameState.lastSuccessfulTemporalView = undefined;
+          frameState.successfulTemporalFrameIndex = 0;
+          frameState.pendingTemporalCommit = { kind: 'none' };
+          frameState.ssrHistoryOwner?.reset('reflection-generation');
+          frameState.ssrHistoryCandidate = undefined;
+        }
+        ssrFallbackGeneration = reset.generation;
         persistentRenderScene.updateVisibilityFacet(compositionWorlds, latestCamera, renderables);
         let occlusionProjection:
           | import('./scene/visibility/occlusion-runtime').OcclusionFrameProjection
@@ -2940,6 +2833,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         if (temporalDemanded) {
           persistentRenderScene.prepareTemporalFrame(submissionRenderables);
         }
+        frameState.environmentFrame = environment as
+          | import('./environment/frame').SelectedEnvironmentFrame
+          | undefined;
         environmentLifecycle.bindScope(internals.deviceScope);
         if (fogFailure !== undefined) {
           environmentLifecycle.recordSelectionFailure(fogFailure);
@@ -2970,8 +2866,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           updateTransmissionInspection(transmissionAntialias, false);
           return false;
         }
-        if (lastMeshMaterialBindingFrame !== frame) {
-          lastMeshMaterialBindingFrame = frame;
+        if (lastMeshMaterialBindingRenderables !== renderables) {
+          lastMeshMaterialBindingRenderables = renderables;
           lastMeshMaterialBindings = renderables.map((renderable) => {
             const materialWorld = preparedWorlds[renderable.worldId];
             return projectMeshMaterialBindingObservation({
@@ -3024,6 +2920,15 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         lastFrustumStats.culled = frustumStats.culled;
         lastFrustumStats.total = frustumStats.total;
         lastVisibilityStats.explicitlyHidden = visibilityStats.explicitlyHidden;
+        if (frame.materialTextureSources !== undefined) {
+          lastMaterialTextureSources = Object.freeze({
+            sourceFieldsVisited: frame.materialTextureSources.sourceFieldsVisited,
+            numericSharedRefProbes: frame.materialTextureSources.numericSharedRefProbes,
+            sourceCacheHits: frame.materialTextureSources.sourceCacheHits,
+            sourceCacheMisses: frame.materialTextureSources.sourceCacheMisses,
+            producerRoutes: Object.freeze({ ...frame.materialTextureSources.producerRoutes }),
+          });
+        }
         const featureTargets =
           preparedPipelineState === null || cameras[0] === undefined
             ? []
@@ -3034,6 +2939,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 storageBuffer: internals.device.caps.storageBuffer,
                 multisample: internals.device.caps.backendKind !== 'wgpu-webgl2',
               });
+        preparedFeatureSkylightResources =
+          preparedPipelineState === null
+            ? undefined
+            : resolveMaterialSkylight(internals, preparedPipelineState, skylight, skylightCount)
+                .skylightResources;
         let featureGraphCandidate: RenderFeatureGraphCandidate | undefined;
         const preparedResourceBatches = runProfiledRenderPhase(profileSession, 'features', () => {
           if (internals.featureHost === undefined) return [];
@@ -3049,6 +2959,28 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             ...(internals.getMaterialShaderBindingContract === undefined
               ? {}
               : { materialShaderBindingContract: internals.getMaterialShaderBindingContract }),
+            ...(preparedPipelineState === null
+              ? {}
+              : {
+                  preparedDataInterfaces: {
+                    camera: {
+                      kind: 'buffer' as const,
+                      value: preparedPipelineState.viewUniformBuffer,
+                      size: 64,
+                      usage: 'uniform' as const,
+                    },
+                    'scene-depth': {
+                      kind: 'texture-view' as const,
+                      value: preparedPipelineState.shadowFallbackTextureView,
+                    },
+                    get noise() {
+                      const value = resolveFeatureNoise(frameState.frameNumber);
+                      return value === undefined
+                        ? undefined
+                        : { kind: 'texture-view' as const, value };
+                    },
+                  },
+                }),
             createPreparedGraphicsResolver: preparedResolverFactory,
             gpuWork: featureGpuWork,
           });
@@ -3072,10 +3004,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           featureGraphCandidate = {
             plans: featureFrame.plans,
             fullscreenEffects: featureFrame.fullscreenEffects,
-            ...(featureFrame.preparedResourceBatches.length === 0
-              ? {}
-              : { preparedResourceKey: `frame-${frameState.frameNumber}` }),
+            ...(featureFrame.requiresPreparedResourceKey
+              ? { preparedResourceKey: `frame-${frameState.frameNumber}` }
+              : {}),
             onRejected: () => {
+              featureFrame.onAborted();
               for (const batch of featureFrame.preparedResourceBatches) {
                 const released = batch.release();
                 if (!released.ok) {
@@ -3085,8 +3018,15 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               discardPostProcessParamsCandidate(postProcessParamsCandidate.value);
             },
             onAbandoned: () => {
+              featureFrame.onAborted();
               discardPostProcessParamsCandidate(postProcessParamsCandidate.value);
             },
+            onSubmitted: () => {
+              featureFrame.onSubmitted();
+            },
+            onAborted: () => {
+              featureFrame.onAborted();
+            },
             onAccepted: () => {
               for (const [id, previous] of activeFeaturePostProcessEntries) {
                 const next = featureFrame.fullscreenEffects.get(id);
@@ -3107,6 +3047,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               activeFeaturePostProcessEntries = featureFrame.fullscreenEffects;
             },
           };
+          recordRenderFeatureCandidate(internals, featureGraphCandidate);
           return featureFrame.preparedResourceBatches;
         });
 
@@ -3184,13 +3125,32 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         if (cameras[0]?.bloom === 'on') {
           internals.getPipelineState()?.perPassResources.ensureBloomResources?.();
         }
+        const liveOutput = cameras[0]?.output;
+        const hasLiveFeatureState =
+          liveOutput !== undefined ||
+          frameState.autoExposureGpuResources !== undefined ||
+          frameState.pendingAutoExposureGpuResources !== undefined ||
+          frameState.autoExposureState !== undefined ||
+          frameState.pendingAutoExposureState !== undefined ||
+          frameState.standardLutGpuResources !== undefined ||
+          frameState.pendingStandardLutGpuResources !== undefined ||
+          frameState.standardLutState.resident !== null ||
+          frameState.pendingStandardLutState !== undefined;
+        if (hasLiveFeatureState) {
+          const cameraWorld = compositionWorlds[cameraOwner] as World;
+          const deltaTime = cameraWorld.getResource(Time).delta;
+          stageLiveFeatureState(
+            cameras[0],
+            Number.isFinite(deltaTime) ? Math.max(0, deltaTime) : 0,
+          );
+        }
         submitted = runProfiledRenderPhase(profileSession, 'record', () =>
           recordFrame(
             internals,
             resourceWorld,
             cameras,
             lights,
-            [...submissionRenderables],
+            submissionRenderables,
             orderedDispatch,
             frameState,
             dispatchCounts,
@@ -3226,32 +3186,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             environment?.fogSignature ?? '',
             environmentReady && environment !== undefined,
             persistentRenderScene.transmissionTopologyDemand(),
+            shadowCasterEntityKeys,
+            shadowCasterDrawKeys,
             volumetricFog,
             timingCapture,
-            (entry) => {
-              const renderable = entry.source;
-              const world = compositionWorlds[renderable.worldId];
-              if (world === undefined) return;
-              let bindings = frameConsumedDynamicGeometryBindings.get(world);
-              if (bindings === undefined) {
-                bindings = new Map();
-                frameConsumedDynamicGeometryBindings.set(world, bindings);
-              }
-              bindings.set(renderable.entityKey, renderable.assetHandle);
-            },
+            shadowCasterMembership,
+            shadowCasterProjection,
+            worldKeys,
+            undefined,
+            ssrDependencies,
+            dynamicGeometryFrames.onRenderableDraw(compositionWorlds),
           ),
         );
-        if (submitted) {
-          lastSubmittedDynamicGeometryBindings = frameConsumedDynamicGeometryBindings;
-        }
-        if (submitted) {
-          try {
-            internals.recoveryColdWorkGuard?.finish();
-          } catch (cause) {
-            submitted = false;
-            throw cause;
-          }
-        }
+        dynamicGeometryFrames.commit(submitted);
+        if (!submitted) discardLiveFeatureState();
         if (submitted && lastLodOcclusionInspection !== undefined) {
           const query = ensureOcclusionRuntime().inspect();
           lastLodOcclusionInspection = {
@@ -3346,6 +3294,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           }
         }
       } catch (err) {
+        discardLiveFeatureState();
         if (!submitted) {
           internals.getPipelineState()?.perPassResources.discardBloomResources?.();
         }
@@ -3359,7 +3308,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               }
             : err instanceof RhiError
               ? err
-              : { code: 'unknown' as const, message: String(err), name: (err as Error)?.name };
+              : {
+                  code: 'unknown' as const,
+                  message: String(err),
+                  name: (err as Error)?.name,
+                };
         internals.errorRegistry.fire(
           new RhiError({
             code: 'webgpu-runtime-error',
@@ -3379,14 +3332,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       }
       return submitted;
     },
-    isDynamicGeometryConsumed(
-      world: World,
-      entity: number,
-      meshHandle: number | undefined,
-    ): boolean {
-      if (!Number.isInteger(entity) || meshHandle === undefined) return false;
-      return lastSubmittedDynamicGeometryBindings.get(world)?.get(entity) === meshHandle;
-    },
+    isDynamicGeometryConsumed: (world, entity, meshHandle) =>
+      dynamicGeometryFrames.isConsumed(world, entity, meshHandle),
     pipelineDispatchCounts: dispatchCounts,
     observeCurrentFrame(options: FrameObservationOptions) {
       const currentFrameId = frameState.frameNumber - 1;
@@ -3457,6 +3404,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     get perFrameGraphInfo(): CompiledRenderGraphInfo | undefined {
       return frameState.compiledFrameGraph?.inspect();
     },
+    get featureGraphInspection(): import('./inspection-types').RenderFeatureGraphInspection {
+      return getRenderFeatureGraphInspection(internals);
+    },
+    get materialTextureSources(): MaterialTextureSourceInspection {
+      return lastMaterialTextureSources;
+    },
     get recoveryEvidence(): RecoveryProductionEvidence {
       const graph = frameState.compiledFrameGraph?.inspect();
       return Object.freeze({
@@ -3583,6 +3536,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       (internals as TimingSessionHost).gpuPassTimingSubmittedWork = undefined;
       (internals as TimingSessionHost).gpuPassTimingFrameIdentity = undefined;
       (internals as TimingSessionHost).gpuPassTimingBeginReason = undefined;
+      internals.getPipelineState()?.skinPaletteAllocator?.dispose();
       pointsLinesOwner.dispose();
       persistentRenderScene.dispose();
       instanceCollections.dispose();
@@ -3590,6 +3544,10 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       occlusionRuntime?.dispose();
       disposeFeatureGpuWork();
       reflectionProbeOwner.dispose();
+      frameState.ssrHistoryOwner?.dispose();
+      frameState.ssrHistoryOwner = undefined;
+      frameState.ssrHistoryCandidate = undefined;
+      frameState.ssrSpatialAdmission = undefined;
       // Bloom generations are renderer-owned rather than graph-owned. Drain
       // candidate, active, and fence-retiring bundles before the rest of the
       // frame state is torn down; the owner callback is idempotent so the
@@ -3610,6 +3568,19 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       frameState.lastSuccessfulCameraAntialias = undefined;
       frameState.currentDirectionalShadowView = null;
       frameState.currentSpotShadowView = null;
+      if (frameState.pendingAutoExposureGpuResources !== undefined) {
+        retireAutoExposureGpuResources(frameState.pendingAutoExposureGpuResources);
+        frameState.pendingAutoExposureGpuResources = undefined;
+      }
+      if (frameState.autoExposureGpuResources !== undefined) {
+        retireAutoExposureGpuResources(frameState.autoExposureGpuResources);
+        frameState.autoExposureGpuResources = undefined;
+      }
+      frameState.autoExposureState = undefined;
+      frameState.pendingAutoExposureState = undefined;
+      frameState.pendingStandardLutGpuResources = undefined;
+      frameState.standardLutGpuResources = undefined;
+      frameState.pendingStandardLutState = undefined;
       if (frameState.temporalGpuState !== undefined) {
         retireTemporalGpuState(frameState.temporalGpuState);
         frameState.temporalGpuState = undefined;
@@ -3655,7 +3626,6 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // so destroy failures fire structured errors (unified per-frame +
       // dispose error strategy).
       disposeInstanceBuffers(frameState.instanceBuffers, internals.errorRegistry);
-      frameState.instanceResidency?.clear();
       if (frameState.instanceBufferChunks !== undefined) {
         disposeInstanceBufferChunks(frameState.instanceBufferChunks, internals.errorRegistry);
       }
@@ -3696,9 +3666,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // their handles without invoking destroy on a device that can no longer
       // service cleanup; the staged candidate owns the replacement buffers.
       pointsLinesOwner.abandonForDeviceLoss();
-      ssrFormatReceipt = undefined;
-      ssrFormatProbeGeneration = -1;
-      ssrFormatProbe = undefined;
+      resetStandardOutputForDeviceLoss(frameState, internals.deviceScope.generation);
+      ssrFormatReceipts.delete(internals.device);
       ssrFallbackGeneration = undefined;
       transmissionAdmission.markDeviceLost();
       lastTransmissionKey = '';
@@ -3716,13 +3685,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       updateTransmissionInspection(lastTransmissionAntialias, false);
       persistentRenderScene.resetGpuForRecover();
       gpuDrivenProduction.dispose();
-      // The active renderer still points at the lost device until the caller
-      // completes the synchronous publication boundary. Bind the replacement
-      // explicitly so the first published draw never routes through an owner
-      // recreated against the old physical device.
-      gpuDrivenProduction = GpuDrivenProduction.forDevice(
+      gpuDrivenRecoveryCount += 1;
+      gpuDrivenProduction = createGpuDrivenOwner(
         replacementDevice ?? internals.device,
         gpuDrivenShaderFactory,
+        gpuDrivenRecoveryCount,
       );
       occlusionRuntime?.dispose();
       // The replacement device is installed by the host after this hook. Do
@@ -3732,6 +3699,13 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       disposeFeatureGpuWork();
       featureGpuWork = createFeatureGpuWorkOwner(internals);
       reflectionProbeOwner.dispose();
+      frameState.ssrHistoryOwner?.dispose();
+      frameState.ssrHistoryOwner = undefined;
+      frameState.ssrHistoryCandidate = undefined;
+      frameState.ssrSpatialAdmission = undefined;
+      frameState.ssrRequested = false;
+      frameState.ssrLastCameraEntity = undefined;
+      frameState.ssrLastHistoryVersion = undefined;
       // A recovered device cannot retain handles from the lost device. The
       // Bloom owner abandons candidates and retires every committed generation
       // before the new PipelineState is rebuilt.
@@ -3801,7 +3775,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       frameState.retiredCompiledFrameGraphs.clear();
       frameState.instanceBuffers.clear();
       frameState.instanceBufferChunks?.clear();
-      frameState.instanceResidency?.clear();
+      instanceCollections._resetResidency();
       delete frameState.probeBlendRecordBuffer;
       frameState.probeBlendRecordBufferCapacity = 0;
       frameState.probeBlendBuffers.clear();
@@ -3844,124 +3818,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       publishRecoveryPostProcessResources(prepared.value);
     },
     prepareRecoveryRoots(runtime: RecoveryRootRuntime): RecoveryRootBundle {
-      // Snapshot only CPU projections/declarations here. The root create
-      // callbacks below must never close over a mutable active owner while
-      // LifecycleTransaction is awaiting candidate construction.
-      const candidateEnvironmentLifecycle = environmentLifecycle.createRecoveryCandidate(
-        runtime.scope,
-      );
-      const roots: LifecycleResourceSpec<unknown>[] = [];
-      let candidateEnvironmentGeneration: EnvironmentGeneration | undefined;
-      let environmentRootCleaned = false;
-      let published = false;
-      if (candidateEnvironmentLifecycle.hasRecoveryFrame()) {
-        const environmentRoot = candidateEnvironmentLifecycle.createRecoveryRoot(runtime.scope);
-        roots.push({
-          ...environmentRoot,
-          create: async () => {
-            const generation = (await environmentRoot.create()) as EnvironmentGeneration;
-            candidateEnvironmentGeneration = generation;
-            return generation;
-          },
-          cleanup: (value) => {
-            if (environmentRootCleaned) return;
-            environmentRootCleaned = true;
-            if (candidateEnvironmentGeneration === value) {
-              candidateEnvironmentGeneration = undefined;
-            }
-            if (published) {
-              candidateEnvironmentLifecycle.retirePublishedGeneration(
-                value as EnvironmentGeneration,
-              );
-            } else {
-              environmentRoot.cleanup(value);
-            }
-          },
-        });
-      }
-      const graphCandidate = runtime.graphCandidate;
-      if (graphCandidate !== undefined) {
-        const releaseGraphCandidate = (): void => graphCandidate.release();
-        const compiledGraph = graphCandidate.frameState.compiledFrameGraph;
-        if (compiledGraph !== null) {
-          roots.push({
-            kind: 'pipeline',
-            create: () => {
-              if (!runtime.scope.isAlive()) {
-                throw new Error('Recovery graph candidate scope is not active.');
-              }
-              if (graphCandidate.frameState.compiledFrameGraph !== compiledGraph) {
-                throw new Error('Recovery graph candidate was changed before aggregate assembly.');
-              }
-              return compiledGraph;
-            },
-            // All graph/feature/GPU-driven candidate resources share one
-            // owner. The root is a real release seam, not a marker; the
-            // candidate latch makes every root cleanup call harmless after
-            // the first one.
-            cleanup: releaseGraphCandidate,
-          });
-        }
-        if (graphCandidate.featureHost !== undefined) {
-          const featureRoot = graphCandidate.featureHost.createRecoveryRoot(runtime.scope);
-          roots.push({ ...featureRoot, cleanup: releaseGraphCandidate });
-        }
-        if (graphCandidate.featureGpuWork !== undefined) {
-          const featureWorkRoot = graphCandidate.featureGpuWork.createRecoveryRoot(runtime.scope);
-          roots.push({ ...featureWorkRoot, cleanup: releaseGraphCandidate });
-        }
-        if (graphCandidate.gpuDrivenProduction !== undefined) {
-          const productionRoot = graphCandidate.gpuDrivenProduction.createRecoveryRoot(
-            runtime.scope,
-          );
-          roots.push({ ...productionRoot, cleanup: releaseGraphCandidate });
-        }
-        if (graphCandidate.gpuDrivenScene?.state !== undefined) {
-          const sceneRoot = graphCandidate.gpuDrivenScene.createRecoveryRoot(runtime.scope);
-          roots.push({ ...sceneRoot, cleanup: releaseGraphCandidate });
-        }
-        if (graphCandidate.pointsLines !== undefined) {
-          const pointsLinesRoot = graphCandidate.pointsLines.createRecoveryRoot(runtime.scope);
-          roots.push({ ...pointsLinesRoot, cleanup: releaseGraphCandidate });
-        }
-        if (runtime.gpuStore.recoveryResourceCount() > 0) {
-          const gpuStoreRoot = runtime.gpuStore.createRecoveryRoot(runtime.scope);
-          roots.push({ ...gpuStoreRoot, cleanup: releaseGraphCandidate });
-        }
-      }
-      let discarded = false;
-      return {
-        roots: Object.freeze(roots),
-        publish: () => {
-          if (published || discarded) return;
-          if (
-            candidateEnvironmentGeneration !== undefined &&
-            !candidateEnvironmentGeneration.retired
-          ) {
-            environmentLifecycle.retireActiveForReplacement();
-            candidateEnvironmentLifecycle.publish(candidateEnvironmentGeneration);
-          }
-          published = true;
-          environmentLifecycle = candidateEnvironmentLifecycle;
-          Object.assign(frameState, { environmentLifecycle });
-        },
-        discard: () => {
-          if (published || discarded) return;
-          discarded = true;
-          if (candidateEnvironmentGeneration !== undefined) {
-            candidateEnvironmentLifecycle.discard(candidateEnvironmentGeneration);
-            candidateEnvironmentGeneration = undefined;
-          }
-          candidateEnvironmentLifecycle.discardRecoveryCandidates();
-          // The transaction can fail before it reaches any graph root (for
-          // example while the environment root is created). Keep the graph,
-          // feature, GPU-driven, and residency resources on the same real
-          // candidate owner in that case; later scope/factory cleanup is a
-          // harmless repeat through the candidate latch.
-          graphCandidate?.release();
-          runtime.scope.abandon();
-        },
-      };
+      return prepareRenderSystemRecoveryRoots(runtime, environmentLifecycle, frameState, (next) => {
+        environmentLifecycle = next;
+      });
     },
   };
 }