@forgeax/engine-render 0.1.21 → 0.1.24

package/src/render-system.ts

@@ -16,21 +16,21 @@
 // .invert` (charter proposition 5: no math reinvention; render-system.test.ts
 // asserts `/@forgeax\/engine-math/` shows up in render-system.ts source).
 
-import { numMipLevels, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
+import {
+  type MipmapEncoderWork,
+  numMipLevels,
+  resolveAssetHandle,
+} from '@forgeax/engine-assets-runtime';
 import 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 {
-  BindGroup,
   BindGroupEntry,
   BindGroupLayout,
   Buffer,
   RenderPipeline,
-  Sampler,
-  Texture,
-  TextureFormat,
-  TextureView,
+  RhiDevice,
 } from '@forgeax/engine-rhi';
 import { err, ok, type Result, RhiError } from '@forgeax/engine-rhi';
 import {
@@ -39,7 +39,6 @@ import {
   type Handle,
   type MaterialAsset,
   type MaterialTextureValue,
-  type MeshAsset,
   type RenderPipelineAsset,
   RenderQueue,
   type SamplerAsset,
@@ -52,14 +51,16 @@ import {
   projectDirectionalShadowInspectionSource,
 } from './assembly/directional-shadow-inspection';
 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,
-  PointsLinesMaterialUnsupportedError,
   type RenderError,
   TransmissionCapabilityMissingError,
 } from './errors/render';
 import {
+  type RenderFeatureHost,
   type RenderFeaturePreparedGraphicsResolverInput,
   runRenderFeatureFrame,
   settlePreparedGraphicsCompletion,
@@ -82,60 +83,40 @@ import { GpuDrivenProduction } from './gpu-driven/production-raster';
 import type {
   BloomInspection,
   DirectionalShadowInspection,
+  GpuDrivenProductionInspection,
+  LodOcclusionInspection,
+  LodOcclusionInspectionRow,
+  LodOcclusionWorldInspection,
   MotionBlurInspection,
   ReflectionProbeInspection,
-  ReflectionProbeSelectionInspection,
   RenderSceneInspection,
+  SsrDependenciesInspection,
   TemporalTargetInspection,
   TransmissionInspection,
 } from './inspection-types';
-import { admitPointsLines } from './points-lines/admission';
-import { PointsLinesExpansionCache } from './points-lines/expansion-cache';
+import { buildOcclusionProxyVertices } from './occlusion-proxy';
+import type { PointsLinesRetainedSnapshot } from './points-lines/snapshot';
+import { StandardPointsLinesOwner } from './points-lines/standard-owner';
 import {
-  inspectPointsLines,
-  type PointsLinesInspection,
-  type PointsLinesSourceError,
-} from './points-lines/inspection';
+  createRenderSystemRecovery,
+  materialSamplerHandles,
+  materialTextureHandles,
+} from './recovery/render-system-candidate';
+import { ReflectionProbeRecordOwner } from './reflection/record-owner';
 import {
-  createPointsLinesLanePreparationAdapter,
-  type PointsLinesLanePreparationAdapter,
-} from './points-lines/prepare';
-import { createPointsLinesLaneAdapter, type PointsLinesBackend } from './points-lines/record';
-import type { PointsLinesRetainedSnapshot } from './points-lines/snapshot';
-import type { PointsLinesRecordOwner, PointsLinesRecordSubmission } from './record/render-context';
+  OcclusionRenderRuntime,
+  type OcclusionRuntimeCandidate,
+} from './scene/visibility/occlusion-runtime';
+import { primitiveKey, viewKey } from './scene/visibility/types';
 import { inspectVolumetricFog } from './volume/inspection';
 
 export type { RenderSceneInspection } from './inspection-types';
 
-import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
-import { mat4, vec3 } from '@forgeax/engine-math';
-import { buildCubeCameraFaceViews } from './capture/cube-views';
 import { createCubeCaptureScheduler } from './capture/scheduler';
-import {
-  createFaceUniformsBuffer,
-  createPrefilterUniformsBuffer,
-  writeAllFaceUniforms,
-  writeAllPrefilterUniforms,
-} from './device/gpu-residency';
+import type { GpuResidencyCache } from './device/gpu-residency';
 import type { EnvironmentInspection } from './environment/inspection';
-import {
-  GPU_TEXTURE_USAGE_COPY_SRC,
-  GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING,
-} from './gpu-texture-usage';
-import {
-  GPU_BUFFER_USAGE_COPY_DST,
-  GPU_BUFFER_USAGE_INDEX,
-  GPU_BUFFER_USAGE_UNIFORM,
-  GPU_BUFFER_USAGE_VERTEX,
-} from './gpu-usage';
+import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM } from './gpu-usage';
 import { resetHdrpBuffers } from './hdrp-buffers';
-import {
-  CUBEMAP_FACE_VERTICES,
-  createIblPipelines,
-  getOrCreateIblCache,
-  PREFILTER_MIP_LEVELS,
-  PREFILTER_SIZE,
-} from './ibl/IblPipelineCache';
 import { assembleMaterialWithSkylightEntries } from './ibl/skylight-bind-group';
 import { disposeInstanceBuffers, disposeTransientInstanceBuffers } from './instance-buffer-cache';
 import {
@@ -168,7 +149,7 @@ import type {
   GraphTargetCaptureRequest,
   RenderFrameState,
 } from './record/frame-snapshot';
-import { getTextureIdentity } from './record/frame-snapshot';
+import { getTextureIdentity, worldEntityKey } from './record/frame-snapshot';
 import type { GpuPassTimingReason } from './record/gpu-pass-timing/errors';
 import type {
   GpuPassTimingCapture,
@@ -177,27 +158,14 @@ import type {
 } from './record/gpu-pass-timing/session';
 import type { GpuTimingCapture } from './record/gpu-timing';
 import { applyParamSnapshotToUbo, residentTextureView } from './record/main-pass-material';
-import type { ReflectionProbeRecordState, RenderSystemInternals } from './record/render-context';
-import type { CubeCaptureGraphState, ReflectionProbeGraphWork } from './record/typed-frame-graph';
+import type { RecoveryPipelineReadiness } from './record/recovery-pipeline';
+import type { PipelineState, RenderSystemInternals } from './record/render-context';
+import type { CubeCaptureGraphState } from './record/typed-frame-graph';
 import {
   type RenderFeatureGraphCandidate,
   resetRenderFeatureGraphState,
   settleVolumetricFogGraphCandidate,
 } from './record/typed-frame-graph';
-import { REFLECTION_PROBE_VIEW_SLOT_BASE, VIEW_UNIFORM_SLOT_STRIDE } from './record/view-ubo';
-import {
-  advanceProbeFilter,
-  commitProbeFilterStep,
-  createProbeFilterState,
-  type ProbeFilterState,
-} from './reflection/filter';
-import { buildReflectionProbeTable } from './reflection/gpu-table';
-import {
-  admitReflectionProbe,
-  DEFAULT_REFLECTION_PROBE_LIMITS,
-  type ReflectionProbeFact,
-  type ReflectionProbeSelectionResult,
-} from './reflection/projection';
 import {
   type CameraSnapshot,
   type DrawOwnerOptions,
@@ -214,8 +182,10 @@ import type {
   RenderableSnapshot,
 } from './render-system-extract';
 import { extractFrames } from './render-system-extract';
-import { PersistentRenderScene } from './scene/render-scene';
+import { type PersistentGpuDrivenCandidate, 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,
@@ -239,6 +209,149 @@ import {
   inspectTransmissionFromAdmission,
 } from './transmission/inspection';
 
+function canonicalizeWorldComposition(
+  worlds: readonly World[],
+  owners: Pick<DrawOwnerOptions, 'cameraOwner' | 'resourceOwner'>,
+  leases: readonly RenderReadLease[] | undefined,
+): {
+  readonly worlds: readonly World[];
+  readonly owners: Pick<DrawOwnerOptions, 'cameraOwner' | 'resourceOwner'>;
+  readonly leases: readonly RenderReadLease[] | 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),
+          ),
+  };
+}
+
+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)),
+  );
+}
+
 type TimingSessionHost = RenderSystemInternals & {
   gpuPassTimingSession?: GpuPassTimingSession | undefined;
   gpuPassTimingCapture?: GpuPassTimingCapture | undefined;
@@ -275,6 +388,128 @@ export {
   selectSwapChainFormat,
 } from './record/render-context';
 
+export type RendererProducerRootKind =
+  | 'backend-surface'
+  | 'shader-material-pipeline'
+  | 'mesh-texture-sampler'
+  | 'render-scene'
+  | 'gpu-driven'
+  | 'feature'
+  | 'external-source'
+  | 'render-graph'
+  | 'target-history'
+  | 'observation-lease';
+
+export interface RendererProducerRoot {
+  readonly kind: RendererProducerRootKind;
+  readonly owner: string;
+  readonly candidateScope: 'device-scope';
+  readonly visibility: 'visible-workset' | 'non-visible-lazy';
+  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',
+    owner: 'backend-surface-owner',
+    candidateScope: 'device-scope',
+    visibility: 'visible-workset',
+    disabledWork: 'zero',
+  },
+  {
+    kind: 'shader-material-pipeline',
+    owner: 'shader-material-pipeline-owner',
+    candidateScope: 'device-scope',
+    visibility: 'visible-workset',
+    disabledWork: 'zero',
+  },
+  {
+    kind: 'mesh-texture-sampler',
+    owner: 'gpu-residency',
+    candidateScope: 'device-scope',
+    visibility: 'visible-workset',
+    disabledWork: 'lazy',
+  },
+  {
+    kind: 'render-scene',
+    owner: 'persistent-render-scene',
+    candidateScope: 'device-scope',
+    visibility: 'visible-workset',
+    disabledWork: 'zero',
+  },
+  {
+    kind: 'gpu-driven',
+    owner: 'gpu-driven-production',
+    candidateScope: 'device-scope',
+    visibility: 'visible-workset',
+    disabledWork: 'zero',
+  },
+  {
+    kind: 'feature',
+    owner: 'render-feature-host',
+    candidateScope: 'device-scope',
+    visibility: 'visible-workset',
+    disabledWork: 'lazy',
+  },
+  {
+    kind: 'external-source',
+    owner: 'external-source-owner',
+    candidateScope: 'device-scope',
+    visibility: 'non-visible-lazy',
+    disabledWork: 'zero',
+  },
+  {
+    kind: 'render-graph',
+    owner: 'typed-frame-graph',
+    candidateScope: 'device-scope',
+    visibility: 'visible-workset',
+    disabledWork: 'zero',
+  },
+  {
+    kind: 'target-history',
+    owner: 'temporal-target-owner',
+    candidateScope: 'device-scope',
+    visibility: 'visible-workset',
+    disabledWork: 'zero',
+  },
+  {
+    kind: 'observation-lease',
+    owner: 'render-observation-owner',
+    candidateScope: 'device-scope',
+    visibility: 'non-visible-lazy',
+    disabledWork: 'zero',
+  },
+]);
+
+export function createRendererProducerRootMatrix(): readonly RendererProducerRoot[] {
+  return PRODUCER_ROOT_MATRIX;
+}
+
+/**
+ * Production-owned recovery facts. These values are projections of the live
+ * RenderSystem owners; they are not a test ledger or a second graph model.
+ */
+export interface RecoveryProductionEvidence {
+  readonly producerRoots: readonly RendererProducerRoot[];
+  readonly graph: {
+    readonly ready: boolean;
+    readonly generation: number;
+    readonly passCount: number;
+    readonly resourceCount: number;
+  };
+  readonly residency: { readonly meshResidencyEpoch: number };
+  readonly submissions: {
+    readonly count: number;
+    readonly lastGeneration: number | undefined;
+  };
+}
+
 /**
  * Unified transparent-queue sub-sort covering all four
  * {@link TransparentSortConfig} modes. Reorders the
@@ -323,7 +558,7 @@ function sortTransparentDispatch(
     const camPos = camera.position;
 
     // Squared camera distance per entry (negated → ascending = back-to-front).
-    // D-3: world position = translation column of Transform.world (m[12,13,14]).
+    // 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;
@@ -422,6 +657,19 @@ export interface RenderSystem {
     renderReadLeases?: readonly RenderReadLease[],
     timingCapture?: GpuTimingCapture,
   ): boolean;
+  /** Prepare a detached graph candidate without entering the frame record path. */
+  prepareRecoveryGraphCandidate(
+    runtime: RecoveryGraphCandidateRuntime,
+  ): RecoveryGraphCandidatePreparation;
+  /** Finish and submit detached candidate setup, never a frame receipt. */
+  submitCandidateSetup(
+    candidate: RecoveryGraphCandidate,
+    isValid: () => boolean,
+  ): Result<RecoveryGraphSetupSubmission, RhiError>;
+  /** Publish a detached graph candidate at the generation publication boundary. */
+  publishRecoveryGraphCandidate(candidate: RecoveryGraphCandidate): void;
+  /** Discard a detached graph candidate that did not reach publication. */
+  discardRecoveryGraphCandidate(candidate: RecoveryGraphCandidate): void;
   /** Release renderer-owned persistent state for one detached World. */
   detachScene(world: World): void;
   /** Release the profiler catalog contribution owned by this RenderSystem. */
@@ -429,6 +677,8 @@ export interface RenderSystem {
   observeCurrentFrame(
     options: FrameObservationOptions,
   ): Promise<Result<FrameObservation, ObservationUnavailableError>>;
+  /** Resolve the renderer-owned GPU LOD counters for the last accepted submit. */
+  observeLodOcclusion(): Promise<void>;
   /** Internal same-frame graph target access for backend diagnostics. */
   getCurrentGraphTarget(name: string): CurrentGraphTarget | undefined;
   /** Internal test capture copied into the draw's command submission. */
@@ -446,6 +696,10 @@ export interface RenderSystem {
   /** Persistent scene maintenance evidence from the ordinary single-World path. */
   readonly renderScene: RenderSceneInspection;
   readonly reflectionProbes: ReflectionProbeInspection;
+  /** Live producer/RHI/temporal receipts projected through SSR admission. */
+  readonly ssrDependencies: SsrDependenciesInspection;
+  /** 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;
@@ -453,6 +707,9 @@ export interface RenderSystem {
   readonly bloom: BloomInspection;
   readonly motionBlurInspection: MotionBlurInspection | undefined;
   readonly temporalTargetInspection: TemporalTargetInspection | undefined;
+  readonly lodOcclusionInspection: LodOcclusionInspection | undefined;
+  /** Bounded GPU-driven counters without materializing the persistent scene table. */
+  readonly gpuDrivenInspection: GpuDrivenProductionInspection;
   /** Last completed transmission candidate facts, detached from GPU handles. */
   readonly transmission: TransmissionInspection | undefined;
   /** Single production projection of Directional author/extract/record facts. */
@@ -465,6 +722,8 @@ export interface RenderSystem {
   readonly pointsLinesSnapshots: readonly PointsLinesRetainedSnapshot[];
   /** Current mesh-slot provenance and active diagnostics from the last frame. */
   readonly meshMaterialBindings: readonly MeshMaterialBindingObservation[];
+  /** Final-submit IBL binding-chain receipt for the last diagnostic frame. */
+  readonly iblBinding: import('./mesh-material-bindings').IblBindingInspection | undefined;
   /**
    * feat-20260531-bloom-first-declarative-render-graph-pass M4 fix-up w19:
    * per-frame render-graph pass names in declaration order. Empty array
@@ -478,6 +737,8 @@ export interface RenderSystem {
   readonly lastSuccessfulCameraAntialias: CameraSnapshot['antialias'] | undefined;
   /** Detached compiled-graph facts used by the renderer inspection owner. */
   readonly perFrameGraphInfo: CompiledRenderGraphInfo | undefined;
+  /** Production-owner recovery facts used by Renderer.inspect(). */
+  readonly recoveryEvidence: RecoveryProductionEvidence;
   /**
    * feat-20260531-per-frame-bind-group-cache M1 / w4: per-frame
    * createBindGroup counter. Reset to 0 on every `draw([world], { cameraOwner: 0, resourceOwner: 0 })` entry,
@@ -505,6 +766,8 @@ export interface RenderSystem {
   configureStandard(config: RenderPipelineAsset['config']): void;
   /** Register one engine-owned post-process shader used by the Standard lane. */
   registerBuiltinPostProcess(id: string, entry: PostProcessShaderEntry): () => void;
+  /** Resolve one active built-in post-process declaration for a detached candidate. */
+  readonly lookupPostProcess: (id: string) => PostProcessShaderEntry | undefined;
   /**
    * feat-20260612-rhi-destroy-renderer-dispose-gpu-lifecycle / M5 / w21:
    * release the per-RenderSystem frame-state GPU bookkeeping during
@@ -528,9 +791,19 @@ export interface RenderSystem {
    *      handles and are rebuilt after the replacement device is live.
    * Idempotent and graph-optional (no-op when nothing has compiled yet).
    */
-  resetForRecover(): void;
+  resetForRecover(retiringPipelineState?: PipelineState, replacementDevice?: RhiDevice): void;
+  /** Build post-process parameter buffers without mutating the active bundle. */
+  prepareRecoveryPostProcessResources(
+    device: RhiDevice,
+  ): Result<RecoveryPostProcessResources, RhiError>;
+  /** Publish a previously prepared post-process bundle at the recovery boundary. */
+  publishRecoveryPostProcessResources(candidate: RecoveryPostProcessResources): void;
+  /** Release a candidate bundle that was never published. */
+  discardRecoveryPostProcessResources(candidate: RecoveryPostProcessResources): void;
   /** Recreate post-process GPU parameter resources after a device rebuild. */
   restorePostProcessResources(): void;
+  /** Build candidate roots from explicit candidate-owned device state. */
+  prepareRecoveryRoots(runtime: RecoveryRootRuntime): RecoveryRootBundle;
 }
 
 function isStructuredRendererError(error: unknown): error is RhiError | RenderError {
@@ -586,11 +859,12 @@ function makePreparedPipelinePendingError(): RhiError {
   });
 }
 
-type PointsLinesGpuResources = {
-  readonly vertexBuffer: Buffer;
-  readonly indexBuffer: Buffer;
-};
-type PointsLinesPreparationAdapter = PointsLinesLanePreparationAdapter<PointsLinesGpuResources>;
+/** 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;
@@ -619,30 +893,56 @@ function preparationFailureFrom(error: unknown): MeshMaterialBindingPreparationF
   };
 }
 
-function materialTextureHandles(
-  material: MaterialSnapshot,
-): readonly Handle<'TextureAsset', 'shared'>[] {
-  const handles = new Map<number, Handle<'TextureAsset', 'shared'>>();
-  const add = (handle: Handle<'TextureAsset', 'shared'> | undefined): void => {
-    if (handle !== undefined) handles.set(Number(handle), handle);
-  };
-  for (const handle of material.textureHandles?.values() ?? []) add(handle);
-  add(material.baseColorTexture);
-  add(material.metallicRoughnessTexture);
-  add(material.normalTexture);
-  add(material.emissiveTexture);
-  add(material.occlusionTexture);
-  return [...handles.values()];
+/** Candidate-only device/runtime inputs used by the recovery prepare seam. */
+export interface RecoveryGraphCandidateRuntime {
+  readonly internals: RenderSystemInternals;
+  readonly pipelineState: PipelineState;
 }
 
-function materialSamplerHandles(
-  material: MaterialSnapshot,
-): readonly Handle<'SamplerAsset', 'shared'>[] {
-  const handles = new Map<number, Handle<'SamplerAsset', 'shared'>>();
-  for (const handle of material.samplerHandles?.values() ?? []) {
-    handles.set(Number(handle), handle);
-  }
-  return [...handles.values()];
+/** 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;
 }
 
 /**
@@ -761,812 +1061,6 @@ function observeMaterialResidency(
   };
 }
 
-/**
- * The Standard renderer's single Points/Lines prepare owner.
- *
- * The retained snapshot is the identity boundary; this owner only resolves
- * the source assets, runs admission, and publishes the existing preparation
- * and record contracts to the main geometry loop. The expansion cache is
- * shared across lanes and this owner keeps the one prepared vertex/index
- * resource pair for each retained identity.
- */
-class StandardPointsLinesOwner implements PointsLinesRecordOwner {
-  private readonly cache = new PointsLinesExpansionCache();
-  private readonly preparations = new Map<string, PointsLinesPreparationAdapter>();
-  private readonly active = new Map<string, PointsLinesInspection>();
-  private readonly layoutProjection = deriveVertexLayoutProjection({
-    position: new Float32Array(0),
-    normal: new Float32Array(0),
-    uv: new Float32Array(0),
-    tangent: new Float32Array(0),
-  });
-
-  constructor(private readonly internals: RenderSystemInternals) {}
-
-  beginFrame(): void {
-    this.active.clear();
-  }
-
-  prepare(
-    entry: import('./record/frame-snapshot').ValidatedRenderable,
-    clustered: boolean,
-  ): PointsLinesRecordSubmission | undefined {
-    const snapshot = entry.source.pointsLines;
-    if (snapshot === undefined || snapshot.component === undefined || entry.world === undefined) {
-      return undefined;
-    }
-    const key = `${snapshot.worldId}:${snapshot.entityKey}`;
-    const topology = snapshot.component === 'Points' ? 'point-list' : 'line-list';
-    const backend = this.backend();
-    const lane = backend === 'wgpu-webgl2' ? 'cpu-webgl2' : clustered ? 'clustered' : 'direct';
-    const meshResult = resolveAssetHandle<MeshAsset>(
-      entry.world,
-      toShared<'MeshAsset'>(entry.source.assetHandle),
-    );
-    const materialResult = resolveAssetHandle<MaterialAsset>(
-      entry.world,
-      toShared<'MaterialAsset'>(snapshot.materialHandle),
-    );
-    if (!meshResult.ok || !materialResult.ok) {
-      this.publishRefusal(
-        snapshot,
-        new PointsLinesMaterialUnsupportedError({
-          entity: snapshot.entityKey,
-          material: 'unresolved',
-          pass: 'forward',
-          module: 'asset-resolution',
-          reason: 'source MeshAsset or MaterialAsset could not be resolved',
-        }),
-      );
-      return undefined;
-    }
-    const admission = admitPointsLines({
-      entity: snapshot.entityKey,
-      mesh: meshResult.value,
-      material: materialResult.value,
-      ...(snapshot.style?.kind === 'points'
-        ? {
-            points: {
-              sizePx: snapshot.style.sizePx,
-              shape: snapshot.style.shape === 'circle' ? 1 : 0,
-            },
-          }
-        : { lines: { widthPx: snapshot.style?.widthPx ?? 1 } }),
-    });
-    if (!admission.ok) {
-      this.publishRefusal(snapshot, admission.error);
-      return undefined;
-    }
-    const geometryKey = this.cache.getOrCreate(snapshot, meshResult.value).key;
-    const prepKey = `${geometryKey}:${lane}:${backend}`;
-    let preparation = this.preparations.get(prepKey);
-    if (preparation === undefined) {
-      preparation = createPointsLinesLanePreparationAdapter(lane, backend, {
-        cache: this.cache,
-        adapter: {
-          create: (geometry) => {
-            const vertex = this.internals.device.createBuffer({
-              label: `points-lines-vertices:${geometryKey}`,
-              size: Math.max(4, geometry.vertices.byteLength),
-              usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST,
-              mappedAtCreation: false,
-            });
-            if (!vertex.ok) return err(vertex.error);
-            const index = this.internals.device.createBuffer({
-              label: `points-lines-indices:${geometryKey}`,
-              size: Math.max(4, geometry.indices.byteLength),
-              usage: GPU_BUFFER_USAGE_INDEX | GPU_BUFFER_USAGE_COPY_DST,
-              mappedAtCreation: false,
-            });
-            if (!index.ok) {
-              this.internals.device.destroyBuffer(vertex.value);
-              return err(index.error);
-            }
-            return ok({ vertexBuffer: vertex.value, indexBuffer: index.value });
-          },
-          upload: (resource, geometry) => {
-            if (geometry.vertices.byteLength > 0) {
-              const vertexWrite = this.internals.device.queue.writeBuffer(
-                resource.vertexBuffer,
-                0,
-                geometry.vertices,
-              );
-              if (!vertexWrite.ok) return err(vertexWrite.error);
-            }
-            if (geometry.indices.byteLength > 0) {
-              const indexWrite = this.internals.device.queue.writeBuffer(
-                resource.indexBuffer,
-                0,
-                geometry.indices,
-              );
-              if (!indexWrite.ok) return err(indexWrite.error);
-            }
-            return ok(geometry.derivedBytes);
-          },
-          validate: (_resource, geometry) =>
-            geometry.expandedVertexCount > 0 && geometry.expandedIndexCount > 0
-              ? ok(undefined)
-              : err(new Error('Points/Lines expansion contains no drawable triangles')),
-          destroy: (resource) => {
-            this.internals.device.destroyBuffer(resource.vertexBuffer);
-            this.internals.device.destroyBuffer(resource.indexBuffer);
-          },
-        },
-      });
-      this.preparations.set(prepKey, preparation);
-    }
-    const prepared = preparation.prepare(snapshot, meshResult.value);
-    if (!prepared.ok) {
-      const lkg = preparation.lastKnownGood();
-      if (lkg !== undefined) {
-        const lkgPlan = createPointsLinesLaneAdapter(lane, backend).createRecordPlan(
-          lkg.snapshot,
-          lkg.geometry,
-        );
-        const state = preparation.inspect();
-        this.active.set(
-          key,
-          inspectPointsLines({
-            snapshot,
-            topology,
-            lane,
-            pointCount: lkg.geometry.pointCount,
-            segmentCount: lkg.geometry.segmentCount,
-            sourceBytes: lkg.geometry.sourceBytes,
-            derivedBytes: lkg.geometry.derivedBytes,
-            cache: { hit: true, rebuilds: state.rebuilds, evictions: 0 },
-            drawCount: lkgPlan.drawCount,
-            uploadBytes: 0,
-            lastKnownGood: true,
-            refusal: {
-              code: prepared.error.code,
-              expected: prepared.error.expected,
-              hint: prepared.error.hint,
-              detail: prepared.error.detail,
-              generation: prepared.error.detail.generation,
-              lastKnownGood: true,
-            },
-          }),
-        );
-        return {
-          plan: lkgPlan,
-          vertexBuffer: lkg.resource.vertexBuffer,
-          indexBuffer: lkg.resource.indexBuffer,
-          layoutProjection: this.layoutProjection,
-        };
-      }
-      this.publishRefusal(snapshot, prepared.error);
-      return undefined;
-    }
-    const plan = createPointsLinesLaneAdapter(lane, backend).createRecordPlan(
-      snapshot,
-      prepared.value.geometry,
-    );
-    const state = preparation.inspect();
-    this.active.set(
-      key,
-      inspectPointsLines({
-        snapshot,
-        topology,
-        lane,
-        pointCount: prepared.value.geometry.pointCount,
-        segmentCount: prepared.value.geometry.segmentCount,
-        sourceBytes: prepared.value.geometry.sourceBytes,
-        derivedBytes: prepared.value.geometry.derivedBytes,
-        cache: {
-          hit: prepared.value.uploadedBytes === 0,
-          rebuilds: state.rebuilds,
-          evictions: 0,
-        },
-        drawCount: plan.drawCount,
-        uploadBytes: prepared.value.uploadedBytes,
-        lastKnownGood: prepared.value.lastKnownGood,
-      }),
-    );
-    return {
-      plan,
-      vertexBuffer: prepared.value.resource.vertexBuffer,
-      indexBuffer: prepared.value.resource.indexBuffer,
-      layoutProjection: this.layoutProjection,
-    };
-  }
-
-  resetForDeviceLoss(): void {
-    for (const preparation of this.preparations.values()) preparation.resetForDeviceLoss();
-    this.active.clear();
-  }
-
-  inspections(): readonly PointsLinesInspection[] {
-    return [...this.active.values()];
-  }
-
-  private backend(): PointsLinesBackend {
-    switch (this.internals.device.caps.backendKind) {
-      case 'wgpu-webgl2':
-        return 'wgpu-webgl2';
-      case 'null':
-        return 'null';
-      default:
-        return 'webgpu';
-    }
-  }
-
-  private publishRefusal(
-    snapshot: PointsLinesRetainedSnapshot,
-    error: PointsLinesSourceError,
-  ): void {
-    this.active.set(
-      `${snapshot.worldId}:${snapshot.entityKey}`,
-      inspectPointsLines({
-        snapshot,
-        topology: snapshot.component === 'Points' ? 'point-list' : 'line-list',
-        lane: 'refused',
-        pointCount: 0,
-        segmentCount: 0,
-        sourceBytes: 0,
-        derivedBytes: 0,
-        cache: { hit: false, rebuilds: 0, evictions: 0 },
-        drawCount: 0,
-        uploadBytes: 0,
-        lastKnownGood: false,
-        refusal: {
-          code: error.code,
-          expected: error.expected,
-          hint: error.hint,
-          detail: error.detail,
-          generation: snapshot.meshGeneration,
-          lastKnownGood: false,
-        },
-      }),
-    );
-  }
-}
-
-type ProbeCubeSet = {
-  readonly texture: Texture;
-  readonly cubeView: TextureView;
-  readonly faceViews: readonly TextureView[];
-  readonly mipViews: readonly (readonly TextureView[])[];
-  readonly depthTexture: Texture;
-  readonly depthView: TextureView;
-  readonly size: number;
-};
-
-type ProbeGpuResource = {
-  fact: ReflectionProbeFact;
-  index: number;
-  filter: ProbeFilterState;
-  rawFaceCursor: number;
-  readonly raw: ProbeCubeSet;
-  active: ProbeCubeSet | undefined;
-  candidate: ProbeCubeSet;
-  spare: ProbeCubeSet | undefined;
-  readonly sampler: Sampler;
-  readonly uniformBuffer: Buffer;
-  readonly filterGroup1: BindGroup;
-  pending?: {
-    readonly rawCaptureFace: number | undefined;
-    readonly step: ReturnType<typeof advanceProbeFilter>;
-  };
-};
-
-type ProbeSharedResources = {
-  readonly faceUniforms: Buffer;
-  readonly prefilterUniforms: Buffer;
-  readonly vertexBuffer: Buffer;
-  readonly sampler: Sampler;
-  readonly filterPipeline: RenderPipeline;
-  readonly cubeGroup1Bgl: BindGroupLayout;
-  readonly prefilterGroup0Bgl: BindGroupLayout;
-};
-
-/** Renderer-owned raw capture and incremental PMREM/LKG promotion owner. */
-class ReflectionProbeRecordOwner {
-  private readonly resources = new Map<string, ProbeGpuResource>();
-  private shared: ProbeSharedResources | undefined;
-  private pipelineWarmup: Promise<void> | undefined;
-  private pipelineWarmupFailure: string | undefined;
-  private pipelineWarmupAttempts = 0;
-  private lastFactCount = 0;
-  private lastAcceptedCount = 0;
-  private lastScheduledRawFaces = 0;
-  private lastScheduledFilteredSteps = 0;
-  private lastSelection: ReflectionProbeSelectionInspection = { kind: 'skylight' };
-  private readonly outputFormat: TextureFormat;
-
-  constructor(private readonly internals: RenderSystemInternals) {
-    this.outputFormat = internals.device.caps.rgba16floatRenderable ? 'rgba16float' : 'rgba8unorm';
-  }
-
-  inspect(): ReflectionProbeInspection {
-    let rawFacesCaptured = 0;
-    let filteredStepsCompleted = 0;
-    const filteredMipLevels = new Set<number>();
-    let activeCount = 0;
-    for (const resource of this.resources.values()) {
-      rawFacesCaptured += resource.rawFaceCursor;
-      filteredStepsCompleted += resource.filter.cursor;
-      const completedMipCount = Math.min(
-        PREFILTER_MIP_LEVELS,
-        Math.floor(resource.filter.cursor / resource.filter.faceCount),
-      );
-      for (let mip = 0; mip < completedMipCount; mip += 1) filteredMipLevels.add(mip);
-      if (resource.active !== undefined) activeCount += 1;
-    }
-    return {
-      selection: this.lastSelection,
-      factCount: this.lastFactCount,
-      acceptedCount: this.lastAcceptedCount,
-      activeCount,
-      rawFacesCaptured,
-      filteredStepsCompleted,
-      filteredMipLevels: [...filteredMipLevels].sort((a, b) => a - b),
-      scheduledRawFaces: this.lastScheduledRawFaces,
-      scheduledFilteredSteps: this.lastScheduledFilteredSteps,
-      pipelineReady: this.shared !== undefined,
-      pipelineWarmupAttempts: this.pipelineWarmupAttempts,
-      ...(this.pipelineWarmupFailure === undefined
-        ? {}
-        : { pipelineWarmupFailure: this.pipelineWarmupFailure }),
-    };
-  }
-
-  private ensurePipelineWarmup(): void {
-    if (this.shared !== undefined || this.pipelineWarmup !== undefined) return;
-    const factory = this.internals.shaderModuleFactory;
-    if (factory === undefined) return;
-    const attempt = this.pipelineWarmupAttempts + 1;
-    this.pipelineWarmupAttempts = attempt;
-    this.pipelineWarmup = createIblPipelines(
-      this.internals.deviceScope,
-      this.internals.device,
-      (device, descriptor) => {
-        const labeled = {
-          ...descriptor,
-          label: `${descriptor.label ?? 'ibl'}-reflection-probe-${attempt}`,
-        };
-        return this.internals.createShaderModule === undefined
-          ? Promise.resolve(factory.createShaderModule(labeled))
-          : this.internals.createShaderModule(device, labeled);
-      },
-      this.outputFormat,
-    ).then((result) => {
-      if (!result.ok) {
-        this.pipelineWarmupFailure = `${result.error.code}: ${result.error.hint}`;
-        console.warn('[forgeax] ReflectionProbe IBL warmup retry', this.pipelineWarmupFailure);
-        this.pipelineWarmup = undefined;
-        return;
-      }
-      this.shared = this.createSharedResources(result.value.prefilterPipeline);
-      if (this.shared === undefined) {
-        this.pipelineWarmupFailure = 'renderer-owned IBL resources could not be allocated';
-        console.warn('[forgeax] ReflectionProbe IBL resource allocation retry');
-        this.pipelineWarmup = undefined;
-      }
-    });
-  }
-
-  prepare(
-    facts: readonly ReflectionProbeFact[],
-    selections: ReadonlyMap<string, ReflectionProbeSelectionResult>,
-    displayCamera: CameraSnapshot | undefined,
-  ): ReflectionProbeRecordState {
-    this.lastFactCount = facts.length;
-    this.lastScheduledRawFaces = 0;
-    this.lastScheduledFilteredSteps = 0;
-    const selectedProbe = [...selections.values()]
-      .filter(
-        (selection): selection is Extract<ReflectionProbeSelectionResult, { kind: 'probe' }> =>
-          selection.kind === 'probe',
-      )
-      .sort((a, b) => a.worldId - b.worldId || a.entityKey - b.entityKey)[0];
-    this.lastSelection =
-      selectedProbe === undefined
-        ? { kind: 'skylight' }
-        : { kind: 'probe', worldId: selectedProbe.worldId, entityKey: selectedProbe.entityKey };
-    if (facts.length > 0) this.ensurePipelineWarmup();
-    void this.pipelineWarmup;
-    const ordered = facts
-      .slice()
-      .sort((a, b) => a.worldId - b.worldId || a.entityKey - b.entityKey);
-    let acceptedCount = 0;
-    let acceptedBytes = 0;
-    const accepted = new Map<string, ProbeGpuResource>();
-    for (const fact of ordered) {
-      const admission = admitReflectionProbe(
-        fact,
-        { acceptedCount, acceptedBytes },
-        DEFAULT_REFLECTION_PROBE_LIMITS,
-      );
-      if (!admission.ok) continue;
-      const key = `${fact.worldId}:${fact.entityKey}`;
-      const resource = this.resourceFor(key, fact, acceptedCount);
-      if (resource === undefined) continue;
-      acceptedCount += 1;
-      acceptedBytes = admission.acceptedBytes;
-      accepted.set(key, resource);
-    }
-    for (const [key, resource] of this.resources) {
-      if (!accepted.has(key)) {
-        this.destroyProbeResource(resource);
-        this.resources.delete(key);
-      } else resource.index = [...accepted.keys()].indexOf(key);
-    }
-    const rows = [...accepted.values()]
-      .map((resource) => {
-        const active = resource.active;
-        if (active === undefined) return undefined;
-        return {
-          primitiveKey: `${resource.fact.worldId}:${resource.fact.entityKey}`,
-          index: resource.index,
-          worldId: resource.fact.worldId,
-          entityKey: resource.fact.entityKey,
-          center: resource.fact.center,
-          halfExtents: resource.fact.halfExtents,
-          intensity: resource.fact.intensity,
-          generation: resource.filter.activeGeneration,
-          filteredView: active.cubeView,
-          sampler: resource.sampler,
-          uniformBuffer: resource.uniformBuffer,
-        };
-      })
-      .filter((row): row is NonNullable<typeof row> => row !== undefined);
-    const table = buildReflectionProbeTable(rows);
-    const work: ReflectionProbeGraphWork[] = [];
-    for (const resource of accepted.values()) {
-      const rawCaptureFace =
-        resource.rawFaceCursor < resource.raw.faceViews.length ? resource.rawFaceCursor : undefined;
-      const step =
-        resource.rawFaceCursor >= resource.raw.faceViews.length
-          ? advanceProbeFilter(resource.filter)
-          : undefined;
-      if (this.shared === undefined) continue;
-      if (rawCaptureFace === undefined && step === undefined) continue;
-      const filterGroup0 =
-        step === undefined
-          ? undefined
-          : this.internals.device.createBindGroup({
-              label: `reflection-probe-${resource.index}-pmrem-${step.mipLevel}-${step.faceIndex}`,
-              layout: this.shared.prefilterGroup0Bgl,
-              entries: [
-                {
-                  binding: 0,
-                  resource: {
-                    kind: 'buffer',
-                    value: {
-                      buffer: this.shared.faceUniforms,
-                      offset: step.faceIndex * 256,
-                      size: 64,
-                    },
-                  },
-                },
-                {
-                  binding: 1,
-                  resource: {
-                    kind: 'buffer',
-                    value: {
-                      buffer: this.shared.prefilterUniforms,
-                      offset: (step.mipLevel * 6 + step.faceIndex) * 256,
-                      size: 16,
-                    },
-                  },
-                },
-              ],
-            });
-      if (filterGroup0 !== undefined && !filterGroup0.ok) continue;
-      if (resource.pending !== undefined) continue;
-      resource.pending = { rawCaptureFace, step };
-      if (rawCaptureFace !== undefined) this.lastScheduledRawFaces += 1;
-      if (step !== undefined) this.lastScheduledFilteredSteps += 1;
-      const face =
-        rawCaptureFace === undefined
-          ? undefined
-          : buildCubeCameraFaceViews({
-              position: resource.fact.center,
-              near: 0.1,
-              far: 100,
-            })[rawCaptureFace];
-      const faceCamera =
-        face === undefined || displayCamera === undefined
-          ? undefined
-          : {
-              ...displayCamera,
-              position: vec3.create(
-                resource.fact.center[0] ?? 0,
-                resource.fact.center[1] ?? 0,
-                resource.fact.center[2] ?? 0,
-              ),
-              world: mat4.invert(mat4.create(), face.view),
-              fov: Math.PI / 2,
-              aspect: 1,
-              near: face.near,
-              far: face.far,
-              projection: 'perspective' as const,
-            };
-      work.push({
-        probeIndex: resource.index,
-        rawTexture: resource.raw.texture,
-        rawCubeView: resource.raw.cubeView,
-        rawFaceViews: resource.raw.faceViews,
-        rawDepthTexture: resource.raw.depthTexture,
-        filteredTexture: resource.candidate.texture,
-        filteredCubeView: resource.candidate.cubeView,
-        filteredFaceViewsByMip: resource.candidate.mipViews,
-        outputFormat: this.outputFormat,
-        sampler: resource.sampler,
-        filterPipeline: this.shared.filterPipeline,
-        filterGroup0: filterGroup0?.value,
-        filterGroup1: resource.filterGroup1,
-        cubeVertexBuffer: this.shared.vertexBuffer,
-        rawCaptureFace,
-        rawDepthView: resource.raw.depthView,
-        rawSize: resource.raw.size,
-        ...(faceCamera === undefined ? {} : { faceCamera }),
-        ...(rawCaptureFace === undefined
-          ? {}
-          : {
-              viewBindGroupDynamicOffset:
-                (REFLECTION_PROBE_VIEW_SLOT_BASE + resource.index) * VIEW_UNIFORM_SLOT_STRIDE,
-            }),
-        filteredSize: resource.candidate.size,
-        step,
-      });
-    }
-    return {
-      table,
-      selections,
-      graph: { work },
-      completeSubmission: (submitted, completed) => this.completeSubmission(submitted, completed),
-    };
-  }
-
-  private completeSubmission(submitted: boolean, completed?: Promise<unknown>): void {
-    if (completed !== undefined) {
-      void completed.then(
-        () => this.completeSubmission(submitted),
-        () => this.completeSubmission(false),
-      );
-      return;
-    }
-    for (const resource of this.resources.values()) {
-      const pending = resource.pending;
-      delete resource.pending;
-      if (!submitted || pending === undefined) continue;
-      if (pending.rawCaptureFace !== undefined) {
-        resource.rawFaceCursor = Math.min(
-          resource.rawFaceCursor + 1,
-          resource.raw.faceViews.length,
-        );
-        continue;
-      }
-      if (pending.step === undefined) continue;
-      resource.filter = commitProbeFilterStep(resource.filter, true);
-      if (resource.filter.cursor >= resource.filter.faceCount * resource.filter.mipCount) {
-        const previous = resource.active;
-        resource.active = resource.candidate;
-        resource.candidate = resource.spare ?? previous ?? resource.candidate;
-        resource.spare = undefined;
-      }
-    }
-  }
-
-  dispose(): void {
-    for (const resource of this.resources.values()) {
-      this.destroyProbeResource(resource);
-    }
-    this.resources.clear();
-    if (this.shared !== undefined) {
-      this.internals.device.destroyBuffer(this.shared.faceUniforms);
-      this.internals.device.destroyBuffer(this.shared.prefilterUniforms);
-      this.internals.device.destroyBuffer(this.shared.vertexBuffer);
-    }
-    this.shared = undefined;
-    this.pipelineWarmup = undefined;
-  }
-
-  private destroyProbeResource(resource: ProbeGpuResource): void {
-    const sets = new Set<ProbeCubeSet>([resource.raw, resource.candidate]);
-    if (resource.active !== undefined) sets.add(resource.active);
-    if (resource.spare !== undefined) sets.add(resource.spare);
-    for (const set of sets) this.destroyCubeSet(set);
-    this.internals.device.destroyBuffer(resource.uniformBuffer);
-  }
-
-  private destroyCubeSet(set: ProbeCubeSet): void {
-    this.internals.device.destroyTexture(set.texture);
-    this.internals.device.destroyTexture(set.depthTexture);
-  }
-
-  private resourceFor(
-    key: string,
-    fact: ReflectionProbeFact,
-    index: number,
-  ): ProbeGpuResource | undefined {
-    const existing = this.resources.get(key);
-    if (existing !== undefined) {
-      if (existing.fact.revision !== fact.revision) {
-        existing.fact = fact;
-        existing.filter = createProbeFilterState({
-          probeIndex: index,
-          mipCount: PREFILTER_MIP_LEVELS,
-          activeGeneration: existing.filter.activeGeneration,
-        });
-        existing.rawFaceCursor = 0;
-      } else {
-        existing.fact = fact;
-        existing.index = index;
-      }
-      return existing;
-    }
-    if (this.shared === undefined) return undefined;
-    const raw = this.createCubeSet(`reflection-probe-${index}-raw`, fact.resolution);
-    const candidate = this.createCubeSet(`reflection-probe-${index}-candidate`, fact.resolution);
-    const spare = this.createCubeSet(`reflection-probe-${index}-spare`, fact.resolution);
-    if (raw === undefined || candidate === undefined || spare === undefined) return undefined;
-    const uniformBuffer = this.internals.device.createBuffer({
-      label: `reflection-probe-${index}-uniforms`,
-      size: 32,
-      usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-      mappedAtCreation: false,
-    });
-    if (!uniformBuffer.ok) return undefined;
-    const payload = new Float32Array([
-      -Math.max(0, fact.intensity),
-      fact.center[0],
-      fact.center[1],
-      fact.center[2],
-      fact.halfExtents[0],
-      fact.halfExtents[1],
-      fact.halfExtents[2],
-      0,
-    ]);
-    const written = this.internals.device.queue.writeBuffer(uniformBuffer.value, 0, payload);
-    if (!written.ok) return undefined;
-    const filterGroup1 = this.internals.device.createBindGroup({
-      label: `reflection-probe-${index}-filter-input`,
-      layout: this.shared.cubeGroup1Bgl,
-      entries: [
-        { binding: 0, resource: { kind: 'textureView', value: raw.cubeView } },
-        { binding: 1, resource: { kind: 'sampler', value: this.shared.sampler } },
-      ],
-    });
-    if (!filterGroup1.ok) return undefined;
-    const resource: ProbeGpuResource = {
-      fact,
-      index,
-      filter: createProbeFilterState({ probeIndex: index, mipCount: PREFILTER_MIP_LEVELS }),
-      rawFaceCursor: 0,
-      raw,
-      active: undefined,
-      candidate,
-      spare,
-      sampler: this.shared.sampler,
-      uniformBuffer: uniformBuffer.value,
-      filterGroup1: filterGroup1.value,
-    };
-    this.resources.set(key, resource);
-    return resource;
-  }
-
-  private createSharedResources(filterPipeline: RenderPipeline): ProbeSharedResources | undefined {
-    const faceUniforms = createFaceUniformsBuffer(this.internals.device);
-    const prefilterUniforms = createPrefilterUniformsBuffer(this.internals.device);
-    if (!faceUniforms.ok || !prefilterUniforms.ok) return undefined;
-    if (!writeAllFaceUniforms(this.internals.device, faceUniforms.value).ok) return undefined;
-    if (!writeAllPrefilterUniforms(this.internals.device, prefilterUniforms.value).ok)
-      return undefined;
-    const vertexBuffer = this.internals.device.createBuffer({
-      label: 'reflection-probe-capture-cube-vertices',
-      size: CUBEMAP_FACE_VERTICES.byteLength,
-      usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST,
-      mappedAtCreation: false,
-    });
-    if (!vertexBuffer.ok) return undefined;
-    const vertexWrite = this.internals.device.queue.writeBuffer(
-      vertexBuffer.value,
-      0,
-      CUBEMAP_FACE_VERTICES,
-    );
-    if (!vertexWrite.ok) return undefined;
-    const sampler = this.internals.device.createSampler({
-      label: 'reflection-probe-pmrem-sampler',
-      magFilter: 'linear',
-      minFilter: 'linear',
-      mipmapFilter: 'linear',
-      addressModeU: 'clamp-to-edge',
-      addressModeV: 'clamp-to-edge',
-      addressModeW: 'clamp-to-edge',
-    });
-    const cache = getOrCreateIblCache(this.internals.deviceScope);
-    if (
-      !sampler.ok ||
-      cache.cubeGroup1Bgl === undefined ||
-      cache.prefilterGroup0Bgl === undefined
-    ) {
-      return undefined;
-    }
-    return {
-      faceUniforms: faceUniforms.value,
-      prefilterUniforms: prefilterUniforms.value,
-      vertexBuffer: vertexBuffer.value,
-      sampler: sampler.value,
-      filterPipeline,
-      cubeGroup1Bgl: cache.cubeGroup1Bgl,
-      prefilterGroup0Bgl: cache.prefilterGroup0Bgl,
-    };
-  }
-
-  private createCubeSet(label: string, requestedSize: number): ProbeCubeSet | undefined {
-    const size = Math.min(Math.max(1, Math.floor(requestedSize)), PREFILTER_SIZE);
-    const mipCount = Math.min(PREFILTER_MIP_LEVELS, Math.floor(Math.log2(size)) + 1);
-    const texture = this.internals.device.createTexture({
-      label,
-      size: { width: size, height: size, depthOrArrayLayers: 6 },
-      mipLevelCount: mipCount,
-      sampleCount: 1,
-      dimension: '2d',
-      format: this.outputFormat,
-      usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING | GPU_TEXTURE_USAGE_COPY_SRC,
-      viewFormats: [],
-      textureBindingViewDimension: undefined,
-    });
-    if (!texture.ok) return undefined;
-    const cubeView = this.internals.device.createTextureView(texture.value, {
-      label: `${label}-cube`,
-      dimension: 'cube',
-      baseMipLevel: 0,
-      mipLevelCount: mipCount,
-      arrayLayerCount: 6,
-    });
-    if (!cubeView.ok) return undefined;
-    const faceViews: TextureView[] = [];
-    const mipViews: TextureView[][] = [];
-    for (let mip = 0; mip < mipCount; mip += 1) {
-      const faces: TextureView[] = [];
-      for (let face = 0; face < 6; face += 1) {
-        const view = this.internals.device.createTextureView(texture.value, {
-          label: `${label}-mip${mip}-face${face}`,
-          dimension: '2d',
-          baseMipLevel: mip,
-          mipLevelCount: 1,
-          baseArrayLayer: face,
-          arrayLayerCount: 1,
-        });
-        if (!view.ok) return undefined;
-        if (mip === 0) faceViews.push(view.value);
-        faces.push(view.value);
-      }
-      mipViews.push(faces);
-    }
-    const depthTexture = this.internals.device.createTexture({
-      label: `${label}-depth`,
-      size: { width: size, height: size, depthOrArrayLayers: 1 },
-      mipLevelCount: 1,
-      sampleCount: 1,
-      dimension: '2d',
-      format: 'depth24plus-stencil8',
-      usage: 0x10,
-      viewFormats: [],
-      textureBindingViewDimension: undefined,
-    });
-    if (!depthTexture.ok) return undefined;
-    const depthView = this.internals.device.createTextureView(depthTexture.value, {
-      label: `${label}-depth-view`,
-      dimension: '2d',
-    });
-    if (!depthView.ok) return undefined;
-    return {
-      texture: texture.value,
-      cubeView: cubeView.value,
-      faceViews,
-      mipViews,
-      depthTexture: depthTexture.value,
-      depthView: depthView.value,
-      size,
-    };
-  }
-}
-
 export function createRenderSystem(internals: RenderSystemInternals): RenderSystem {
   const phaseCatalogRegistration = internals.profiler?.registerPhaseCatalog(
     'render',
@@ -1578,6 +1072,38 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   let latestCamera: CameraSnapshot | undefined;
   const pointsLinesOwner = new StandardPointsLinesOwner(internals);
   const reflectionProbeOwner = new ReflectionProbeRecordOwner(internals);
+  let ssrFormatReceipt: import('@forgeax/engine-rhi').RhiTextureFormatCapabilityReceipt | undefined;
+  let ssrFormatProbeGeneration = -1;
+  let ssrFormatProbe: Promise<void> | undefined;
+  let ssrFallbackGeneration: number | undefined;
+  const ensureSsrFormatProbe = (): void => {
+    if (internals.ssrIdentity === undefined) return;
+    const generation = internals.deviceScope.generation;
+    if (
+      ssrFormatReceipt?.deviceGeneration === generation ||
+      ssrFormatProbeGeneration === generation ||
+      ssrFormatProbe !== undefined ||
+      typeof internals.device.probeTextureFormatCapability !== 'function'
+    ) {
+      return;
+    }
+    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: [] };
   const persistentRenderScene = new PersistentRenderScene({
@@ -1587,7 +1113,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       internals.gpuStore.invalidateMesh(handle, preparedWorlds[worldId] ?? worldId);
     },
   });
-  const environmentLifecycle = new EnvironmentLifecycle(internals.deviceScope);
+  let environmentLifecycle = new EnvironmentLifecycle(internals.deviceScope);
   const transmissionAdmission = new TransmissionCandidateAdmission();
   let lastTransmissionInspection: TransmissionInspection | undefined;
   let lastTransmissionKey = '';
@@ -1712,8 +1238,13 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         });
     lastTransmissionKey = key;
   };
+  // GPU-driven production uses the validated adapter for normal frames. The
+  // assembly-supplied closure resolves its device-bound adapter at call time,
+  // so recovery candidate preparation still follows candidateShaderState
+  // rather than retaining a lost-generation module.
   const gpuDrivenShaderFactory =
     internals.shaderModuleFactory ??
+    internals.immediateShaderModuleFactory ??
     ({
       createShaderModule: () =>
         err(
@@ -1724,35 +1255,54 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           }),
         ),
     } satisfies import('./pipeline-builder').PipelineBuilderShaderModuleFactory);
-  let gpuDrivenProduction = new GpuDrivenProduction(internals.device, gpuDrivenShaderFactory);
-  const featureGpuWork: RenderFeatureGpuWorkOwner = createRenderFeatureGpuWorkOwner({
-    getDevice: () => internals.device,
-    getShaderModuleFactory: () =>
-      internals.shaderModuleFactory ??
-      ({
-        createShaderModule: () =>
-          err(
-            new RhiError({
-              code: 'rhi-not-available',
-              expected: 'the renderer backend exposes shader module creation',
-              hint: 'construct the renderer through the backend pack before activating GPU features',
-            }),
-          ),
-      } satisfies import('./pipeline-builder').PipelineBuilderShaderModuleFactory),
-    getImmediateShaderModuleFactory: () =>
-      internals.immediateShaderModuleFactory ??
-      internals.shaderModuleFactory ??
-      ({
-        createShaderModule: () =>
-          err(
-            new RhiError({
-              code: 'rhi-not-available',
-              expected: 'the renderer backend exposes shader module creation',
-              hint: 'construct the renderer through the backend pack before activating GPU features',
-            }),
-          ),
-      } satisfies import('./pipeline-builder').PipelineBuilderShaderModuleFactory),
-  });
+  let gpuDrivenProduction = GpuDrivenProduction.forDevice(internals.device, gpuDrivenShaderFactory);
+  let occlusionRuntime: OcclusionRenderRuntime | undefined = new OcclusionRenderRuntime(
+    internals.device,
+    persistentRenderScene.visibilityFacetStore(),
+    gpuDrivenShaderFactory,
+    persistentRenderScene.visibilityBudgetValue(),
+  );
+  const ensureOcclusionRuntime = (): OcclusionRenderRuntime => {
+    if (occlusionRuntime === undefined) {
+      occlusionRuntime = new OcclusionRenderRuntime(
+        internals.device,
+        persistentRenderScene.visibilityFacetStore(),
+        gpuDrivenShaderFactory,
+        persistentRenderScene.visibilityBudgetValue(),
+      );
+    }
+    return occlusionRuntime;
+  };
+  const createFeatureGpuWorkOwner = (runtime: RenderSystemInternals): RenderFeatureGpuWorkOwner =>
+    createRenderFeatureGpuWorkOwner({
+      getDevice: () => runtime.device,
+      getShaderModuleFactory: () =>
+        runtime.shaderModuleFactory ??
+        ({
+          createShaderModule: () =>
+            err(
+              new RhiError({
+                code: 'rhi-not-available',
+                expected: 'the renderer backend exposes shader module creation',
+                hint: 'construct the renderer through the backend pack before activating GPU features',
+              }),
+            ),
+        } satisfies import('./pipeline-builder').PipelineBuilderShaderModuleFactory),
+      getImmediateShaderModuleFactory: () =>
+        runtime.immediateShaderModuleFactory ??
+        runtime.shaderModuleFactory ??
+        ({
+          createShaderModule: () =>
+            err(
+              new RhiError({
+                code: 'rhi-not-available',
+                expected: 'the renderer backend exposes shader module creation',
+                hint: 'construct the renderer through the backend pack before activating GPU features',
+              }),
+            ),
+        } satisfies import('./pipeline-builder').PipelineBuilderShaderModuleFactory),
+    });
+  let featureGpuWork = createFeatureGpuWorkOwner(internals);
   const disposeFeatureGpuWork = (): void => {
     const disposed = featureGpuWork.dispose();
     if (!disposed.ok) internals.errorRegistry.fire(disposed.error);
@@ -1772,11 +1322,13 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   // raw (material-handle-based, cross-world collision semantically correct).
   const frameState: RenderFrameState = {
     frameNumber: 0,
+    reflectionFallbackDemand: false,
     graphGeneration: 0,
     successfulTemporalFrameIndex: 0,
     lastSuccessfulBloom: 'off',
     temporalFrameTransaction: createTemporalFrameTransaction({ deviceEpoch: 0 }),
     temporalFrameInput: undefined,
+    reflectionFallbackReadback: undefined,
     directionalShadowCache: null,
     directionalShadowCacheRecorded: false,
     compiledFrameGraph: null,
@@ -1798,6 +1350,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     volumetricFogHistorySignature: null,
     retiredCompiledFrameGraphs: new Set(),
     currentFrameObservationSource: undefined,
+    reflectionFallbackObservationSource: undefined,
     lastSuccessfulCameraAntialias: undefined,
     temporalGpuState: undefined,
     activeTemporalGpuState: undefined,
@@ -1809,6 +1362,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     currentDirectionalShadowView: null,
     currentSpotShadowView: null,
     instanceBuffers: new Map(),
+    probeBlendBuffers: new Map(),
+    probeBlendRecordBufferCapacity: 0,
     morphBuffers: new Map(),
     hdrpClusterBinScratch: createClusterBinScratch(),
     hdrpClusterGridScratch: null,
@@ -1820,8 +1375,6 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     transientInstanceBuffers: [],
     warnedZeroLightStandard: false,
     warnedMultiLightDirectional: false,
-    warnedMultiLightPoint: false,
-    warnedMultiLightSpot: false,
     // feat-20260630-equirect-kind-internalized-ibl-declarative-skyligh M3 / w19:
     // once-warn latches for >1 Skylight / >1 SkyboxBackground (names winner).
     warnedMultiSkylight: false,
@@ -1891,6 +1444,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     spotShadowSnapshots: [],
   };
   let directFrameId = 0;
+  let submittedFrameCount = 0;
+  let lastSubmittedGeneration: number | undefined;
   let lastDirectionalShadowLights: ExtractedLights | undefined;
   let lastDirectionalShadowCandidate: 'accepted' | 'failed' = 'failed';
   let lastDirectionalShadowError: DirectionalShadowInspectionSource['error'];
@@ -1949,7 +1504,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   // D-3 / D-8: per-shader params UBO resource table (id -> GPU Buffer).
   // Eager-created at register time when entry.params is present (byteSize >= 16,
   // defaultValue.length === byteSize); reused frame-to-frame via queue.writeBuffer.
-  const postProcessParamsBuffers = new Map<string, Buffer>();
+  let postProcessParamsBuffers = new Map<string, Buffer>();
+  let postProcessParamsDevice = internals.device;
   const builtinPostProcessEntries = new Map<string, PostProcessShaderEntry>();
   let activeFeaturePostProcessEntries: ReadonlyMap<string, PostProcessShaderEntry> = new Map();
   const lookupPostProcess = (id: string): PostProcessShaderEntry | undefined =>
@@ -1965,6 +1521,76 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   // per-frame snapshot + bind it at group(1) binding(2).
   const getPostProcessParamsBuffer = (id: string): Buffer | undefined =>
     postProcessParamsBuffers.get(id);
+  const postProcessDeclarations = (): readonly (readonly [string, PostProcessShaderEntry])[] => [
+    ...builtinPostProcessEntries.entries(),
+    ...activeFeaturePostProcessEntries.entries(),
+  ];
+  const disposePostProcessResources = (resources: RecoveryPostProcessResources): void => {
+    for (const buffer of resources.paramsBuffers.values()) {
+      const destroyed = resources.device.destroyBuffer(buffer);
+      if (!destroyed.ok) internals.errorRegistry.fire(destroyed.error);
+    }
+  };
+  const prepareRecoveryPostProcessResources = (
+    device: RhiDevice,
+  ): Result<RecoveryPostProcessResources, RhiError> => {
+    const paramsBuffers = new Map<string, Buffer>();
+    try {
+      for (const [id, entry] of postProcessDeclarations()) {
+        if (id === 'forgeax.taa-resolve') continue;
+        let buffer: Buffer | undefined;
+        if (entry.params !== undefined) {
+          const created = device.createBuffer({
+            label: `post-process-params-${id}`,
+            size: entry.params.byteSize,
+            usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+            mappedAtCreation: false,
+          });
+          if (!created.ok) throw created.error;
+          buffer = created.value;
+          paramsBuffers.set(id, buffer);
+          const written = device.queue.writeBuffer(buffer, 0, entry.params.defaultValue);
+          if (!written.ok) throw written.error;
+        } else if (entryHasDepthRead(entry)) {
+          const created = device.createBuffer({
+            label: `post-process-params-${id}`,
+            size: DEPTH_MIN_PARAMS_BYTE_SIZE,
+            usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+            mappedAtCreation: false,
+          });
+          if (!created.ok) throw created.error;
+          buffer = created.value;
+        }
+        if (buffer !== undefined) paramsBuffers.set(id, buffer);
+      }
+    } catch (cause) {
+      disposePostProcessResources({ device, paramsBuffers });
+      if (cause instanceof RhiError) return err(cause);
+      return err(
+        new RhiError({
+          code: 'webgpu-runtime-error',
+          expected: 'post-process recovery resources are created on the candidate device',
+          hint: cause instanceof Error ? cause.message : String(cause),
+        }),
+      );
+    }
+    return ok({ device, paramsBuffers });
+  };
+  const publishRecoveryPostProcessResources = (candidate: RecoveryPostProcessResources): void => {
+    if (candidate.paramsBuffers === postProcessParamsBuffers) return;
+    const previous = { device: postProcessParamsDevice, paramsBuffers: postProcessParamsBuffers };
+    postProcessParamsDevice = candidate.device;
+    postProcessParamsBuffers = candidate.paramsBuffers;
+    disposePostProcessResources(previous);
+  };
+  const discardRecoveryPostProcessResources = (candidate: RecoveryPostProcessResources): void => {
+    if (candidate.paramsBuffers === postProcessParamsBuffers) {
+      postProcessParamsBuffers = new Map();
+      disposePostProcessResources(candidate);
+      return;
+    }
+    disposePostProcessResources(candidate);
+  };
   interface PostProcessParamsCandidate {
     readonly buffers: ReadonlyMap<string, Buffer>;
     readonly created: readonly Buffer[];
@@ -2064,6 +1690,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     const key = `${id}|${colorFormat}|${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(
@@ -2104,6 +1731,134 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   const dispatchCounts: { unlit: number } = {
     unlit: 0,
   };
+  let lastLodOcclusionInspection: LodOcclusionInspection | undefined;
+  // The GPU selector returns stable numeric World keys with its same-submit
+  // counters. Keep the attachment join from that submit, rather than using
+  // the current worlds[] position when the asynchronous readback completes.
+  let lastLodWorldAttachments: ReadonlyMap<number, string> = new Map();
+  let occlusionCandidateCache:
+    | {
+        readonly renderables: readonly RenderableSnapshot[];
+        readonly camera: CameraSnapshot;
+        readonly cameraWorldIdentity: string;
+        readonly candidates: readonly OcclusionRuntimeCandidate[];
+      }
+    | undefined;
+  let lodCandidateCountCache:
+    | { readonly renderables: readonly RenderableSnapshot[]; readonly count: number }
+    | undefined;
+  let lodInspectionRenderablesCache:
+    | {
+        readonly submissionRenderables: readonly RenderableSnapshot[];
+        readonly lodCandidateCount: number;
+        readonly values: readonly RenderableSnapshot[];
+      }
+    | undefined;
+  let orderedDispatchCache:
+    | {
+        readonly source: readonly DispatchEntry[];
+        readonly world: World;
+        readonly camera: readonly CameraSnapshot[];
+        readonly renderables: readonly RenderableSnapshot[];
+        readonly value: readonly DispatchEntry[];
+      }
+    | undefined;
+  const applyLodSelectionTelemetry = (
+    selection:
+      | {
+          readonly candidateCount: number;
+          readonly visible: number;
+          readonly occluded: number;
+          readonly lodHistogram: readonly { readonly level: number; readonly count: number }[];
+          readonly worldSelections?: readonly {
+            readonly worldKey: number;
+            readonly primitiveSlot: number;
+            readonly slotGeneration: number;
+            readonly candidateCount: number;
+            readonly visible: number;
+            readonly occluded: number;
+            readonly lodHistogram: readonly { readonly level: number; readonly count: number }[];
+          }[];
+        }
+      | undefined,
+  ): void => {
+    if (selection === undefined || lastLodOcclusionInspection === undefined) return;
+    const inspection = lastLodOcclusionInspection;
+    // The GPU readback histogram is the selector fact, while final submitted
+    // counts are owned by the persistent visibility projection. Keeping the
+    // projection count here excludes ordinary non-LOD geometry (for example a
+    // benchmark occluder) from the LOD workload without inventing a second
+    // visibility owner or mixing CPU/GPU admission decisions.
+    let worlds = inspection.worlds;
+    const worldSelections = selection.worldSelections;
+    if (worldSelections !== undefined && worldSelections.length > 0) {
+      const selectionsByAttachment = new Map<string, (typeof worldSelections)[number][]>();
+      let attributionValid = true;
+      for (const selected of worldSelections) {
+        const attachmentId = lastLodWorldAttachments.get(selected.worldKey);
+        if (attachmentId === undefined) {
+          attributionValid = false;
+          break;
+        }
+        const rows = selectionsByAttachment.get(attachmentId);
+        if (rows === undefined) selectionsByAttachment.set(attachmentId, [selected]);
+        else rows.push(selected);
+      }
+      if (attributionValid) {
+        const nextWorlds = worlds.map((world) => {
+          const selected = selectionsByAttachment.get(world.attachmentId);
+          const baseRow = world.rows[0];
+          if (selected === undefined || baseRow === undefined) {
+            if (world.rows.length > 0) attributionValid = false;
+            return world;
+          }
+          const candidateCount = selected.reduce((sum, row) => sum + row.candidateCount, 0);
+          if (candidateCount !== baseRow.count.candidates) {
+            attributionValid = false;
+            return world;
+          }
+          return Object.freeze({
+            ...world,
+            attribution: Object.freeze({
+              status: 'same-submit' as const,
+              submit: inspection.submit,
+            }),
+            rows: Object.freeze(
+              selected.map((row) => ({
+                ...baseRow,
+                slot: {
+                  primitiveSlot: row.primitiveSlot,
+                  slotGeneration: row.slotGeneration,
+                },
+                count: {
+                  candidates: row.candidateCount,
+                  visible: row.visible,
+                  occluded: row.occluded,
+                },
+                lodHistogram: row.lodHistogram,
+              })),
+            ),
+          });
+        });
+        if (attributionValid) worlds = Object.freeze(nextWorlds);
+      }
+    }
+    lastLodOcclusionInspection = inspectLodOcclusion({
+      ...inspection,
+      count: {
+        ...lastLodOcclusionInspection.count,
+        candidates: selection.candidateCount,
+        visible: selection.visible,
+        occluded: selection.occluded,
+      },
+      lodHistogram: selection.lodHistogram,
+      // Per-primitive samples are intentionally omitted until the GPU readback
+      // carries stable primitive identities; the histogram is the authoritative
+      // producer fact and is copied from the same GPU cull counters.
+      samples: [],
+      worlds,
+    });
+  };
   // feat-20260531-per-frame-bind-group-cache M1 / w4: per-frame
   // createBindGroup counter scaffolding. Reset on every draw([world], { cameraOwner: 0, resourceOwner: 0 }) entry,
   // bumped on cache-miss in render-system-record.ts (M2-M4 bump points).
@@ -2112,44 +1867,60 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     createBindGroup: 0,
     keys: [],
   };
-  const preparedPipelineIds = new WeakMap<object, string>();
-  const preparedMaterialPipelineShaders = new WeakMap<object, string>();
-  const preparedGroup0Pipelines = new WeakSet<object>();
-  const preparedViewOnlyPipelines = new WeakSet<object>();
-  const preparedRenderMaterialPipelines = new WeakSet<object>();
-  const preparedAssetHandles = new WeakMap<World, Map<string, number>>();
+  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 = preparedAssetHandles.get(world);
+    let handles = caches.preparedAssetHandles.get(world);
     if (handles === undefined) {
       handles = new Map();
-      preparedAssetHandles.set(world, handles);
+      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 = internals.assets.lookup(guid);
+    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 = preparedWorlds[worldIndex];
-    const material = internals.assets.lookup(materialGuid) as MaterialAsset | undefined;
-    const pipelineState = internals.getPipelineState();
+    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 = internals.getParamSchema?.(materialShaderId) ?? [];
+    const schema = runtime.getParamSchema?.(materialShaderId) ?? [];
     const values = material.values ?? {};
     const derived = derive(schema);
     const fields = [...derived.textureFieldNames];
@@ -2162,7 +1933,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         schema,
         values as Readonly<Record<string, number | readonly number[]>>,
       );
-      const created = internals.device.createBuffer({
+      const created = runtime.device.createBuffer({
         label: `prepared-material:${materialGuid}`,
         size: payload.byteLength,
         usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
@@ -2170,9 +1941,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       if (!created.ok) return created;
       buffer = created.value;
       payloadByteLength = payload.byteLength;
-      const written = internals.device.queue.writeBuffer(buffer, 0, payload);
+      const written = runtime.device.queue.writeBuffer(buffer, 0, payload);
       if (!written.ok) {
-        internals.device.destroyBuffer(buffer);
+        runtime.device.destroyBuffer(buffer);
         return written;
       }
     }
@@ -2189,20 +1960,32 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           : undefined;
       let sampler = pipelineState.defaultSampler;
       if (textureValue?.sampler !== undefined) {
-        const handle = preparedHandle(world, String(textureValue.sampler), 'SamplerAsset');
+        const handle = preparedHandle(
+          runtime,
+          caches,
+          world,
+          String(textureValue.sampler),
+          'SamplerAsset',
+        );
         if (handle !== undefined) {
           const asset = resolveAssetHandle<SamplerAsset>(world, handle);
           if (asset.ok) {
-            const resident = internals.gpuStore.ensureSamplerResident(handle, asset.value, world);
+            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(world, String(textureValue.texture), 'TextureAsset');
+        const handle = preparedHandle(
+          runtime,
+          caches,
+          world,
+          String(textureValue.texture),
+          'TextureAsset',
+        );
         if (handle !== undefined) {
-          view = residentTextureView(world, internals.gpuStore, internals, handle) ?? view;
+          view = residentTextureView(world, runtime.gpuStore, runtime, handle) ?? view;
         }
       }
       textureResources.push({ sampler, view });
@@ -2238,12 +2021,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         textureIndex += 1;
         continue;
       }
-      if (buffer !== undefined) internals.device.destroyBuffer(buffer);
+      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) internals.device.destroyBuffer(buffer);
+      if (buffer !== undefined) runtime.device.destroyBuffer(buffer);
       return err(new Error('prepared material skylight fallback is unavailable'));
     }
     const completeEntries = assembleMaterialWithSkylightEntries(entries, {
@@ -2255,206 +2038,261 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       brdfLutSampler: fallback.sampler,
       intensityBuffer: fallback.intensityBuffer,
     });
-    const group = internals.device.createBindGroup({ layout, entries: completeEntries });
+    const group = runtime.device.createBindGroup({ layout, entries: completeEntries });
     if (!group.ok) {
-      if (buffer !== undefined) internals.device.destroyBuffer(buffer);
+      if (buffer !== undefined) runtime.device.destroyBuffer(buffer);
       return group;
     }
     if (buffer === undefined) return group;
     return ok({
       handle: group.value,
       dynamicOffsets: [0, 0],
-      release: () => internals.device.destroyBuffer(buffer),
+      release: () => runtime.device.destroyBuffer(buffer),
     });
   };
   const lastFrustumStats: { culled: number; total: number } = { culled: 0, total: 0 };
   const lastVisibilityStats: { explicitlyHidden: number } = { explicitlyHidden: 0 };
   let lastMeshMaterialBindings: readonly MeshMaterialBindingObservation[] = [];
   let lastMeshMaterialBindingFrame: ExtractedFrame | undefined;
-  const preparedResolverFactory = (
-    input: RenderFeaturePreparedGraphicsResolverInput,
-  ): PreparedGraphicsResolver => {
-    return createPreparedGraphicsResolver({
-      device: internals.device,
-      featureIdentity: input.featureIdentity,
-      generation: input.generation,
-      capabilityAvailable: true,
-      featureOrder: input.order,
-      lookup: input.lookup,
-      resolveGpuBuffer: (reference) =>
-        featureGpuWork.resolveBuffer(input.featureIdentity, reference),
-      resolvePipeline: (descriptor) => {
-        const postProcessEntry =
-          input.fullscreenEffects.get(descriptor.shader) ??
-          builtinPostProcessEntries.get(descriptor.shader);
-        if (postProcessEntry !== undefined) {
-          const fullscreen = buildFullscreenPostProcessPass(
-            { device: internals.device, errorRegistry: internals.errorRegistry },
-            postProcessEntry,
-          );
-          if (fullscreen === null) return err(new Error('prepared post-process layout failed'));
-          const pipeline = internals.getPostProcessPipeline?.(
+  const createPreparedResolverFactory =
+    (
+      runtime: RenderSystemInternals,
+      gpuWork: RenderFeatureGpuWorkOwner,
+      worlds: readonly World[],
+      caches: PreparedResolverCaches,
+    ) =>
+    (input: RenderFeaturePreparedGraphicsResolverInput): PreparedGraphicsResolver => {
+      const {
+        preparedPipelineIds,
+        preparedMaterialPipelineShaders,
+        preparedGroup0Pipelines,
+        preparedViewOnlyPipelines,
+        preparedRenderMaterialPipelines,
+      } = caches;
+      return createPreparedGraphicsResolver({
+        device: runtime.device,
+        featureIdentity: input.featureIdentity,
+        generation: input.generation,
+        capabilityAvailable: true,
+        featureOrder: input.order,
+        lookup: input.lookup,
+        resolveGpuBuffer: (reference) => gpuWork.resolveBuffer(input.featureIdentity, reference),
+        resolvePipeline: (descriptor) => {
+          const postProcessEntry =
+            input.fullscreenEffects.get(descriptor.shader) ??
+            builtinPostProcessEntries.get(descriptor.shader);
+          if (postProcessEntry !== undefined) {
+            const fullscreen = buildFullscreenPostProcessPass(
+              { device: runtime.device, errorRegistry: runtime.errorRegistry },
+              postProcessEntry,
+            );
+            if (fullscreen === null) return err(new Error('prepared post-process layout failed'));
+            const pipeline = runtime.getPostProcessPipeline?.(
+              descriptor.shader,
+              fullscreen.bindGroupLayout,
+              descriptor.colorFormats[0] as GPUTextureFormat,
+              postProcessEntry,
+            );
+            if (pipeline !== null && pipeline !== undefined) {
+              preparedPipelineIds.set(pipeline as object, descriptor.shader);
+              if (runtime.getMaterialShaderBindingContract?.(descriptor.shader) === 'group-0') {
+                preparedGroup0Pipelines.add(pipeline as object);
+              }
+            }
+            return pipeline === null || pipeline === undefined
+              ? err(makePreparedPipelinePendingError())
+              : ok(pipeline);
+          }
+          const preparedPipeline = runtime.getMaterialShaderPipeline?.(
             descriptor.shader,
-            fullscreen.bindGroupLayout,
+            descriptor.colorFormats[0] === 'rgba16float',
+            descriptor.renderState,
+            descriptor.topology,
+            descriptor.indexFormat,
+            undefined,
+            'forward',
+            undefined,
+            descriptor.sampleCount ?? 1,
+            // Prepared graphics own their declared attachment format. Passing
+            // it through keeps the PSO compatible with feature-target views
+            // (the ordinary material path intentionally defaults to the
+            // swap-chain view format).
             descriptor.colorFormats[0] as GPUTextureFormat,
-            postProcessEntry,
+            undefined,
+            descriptor.depthFormat === undefined
+              ? null
+              : (descriptor.depthFormat as GPUTextureFormat),
+            descriptor.vertexLayout,
+            undefined,
+            input.shaderModuleMode,
           );
-          if (pipeline !== null && pipeline !== undefined) {
-            preparedPipelineIds.set(pipeline as object, descriptor.shader);
-            if (internals.getMaterialShaderBindingContract?.(descriptor.shader) === 'group-0') {
+          // 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
+          // retryable next-frame prepare into an invalid GPU command buffer.
+          const pipeline = preparedPipeline ?? null;
+          if (pipeline !== null) {
+            preparedMaterialPipelineShaders.set(pipeline as object, descriptor.shader);
+            const bindingContract = runtime.getMaterialShaderBindingContract?.(descriptor.shader);
+            if (bindingContract === 'group-0') {
               preparedGroup0Pipelines.add(pipeline as object);
+            } else if (bindingContract === 'view-only') {
+              preparedViewOnlyPipelines.add(pipeline as object);
+            } else {
+              preparedRenderMaterialPipelines.add(pipeline as object);
             }
           }
-          return pipeline === null || pipeline === undefined
-            ? err(makePreparedPipelinePendingError())
-            : ok(pipeline);
-        }
-        const preparedPipeline = internals.getMaterialShaderPipeline?.(
-          descriptor.shader,
-          descriptor.colorFormats[0] === 'rgba16float',
-          descriptor.renderState,
-          descriptor.topology,
-          descriptor.indexFormat,
-          undefined,
-          'forward',
-          undefined,
-          descriptor.sampleCount ?? 1,
-          // Prepared graphics own their declared attachment format. Passing
-          // it through keeps the PSO compatible with feature-target views
-          // (the ordinary material path intentionally defaults to the
-          // swap-chain view format).
-          descriptor.colorFormats[0] as GPUTextureFormat,
-          undefined,
-          descriptor.depthFormat === undefined
-            ? null
-            : (descriptor.depthFormat as GPUTextureFormat),
-          descriptor.vertexLayout,
-          undefined,
-          input.shaderModuleMode,
-        );
-        // 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
-        // retryable next-frame prepare into an invalid GPU command buffer.
-        const pipeline = preparedPipeline ?? null;
-        if (pipeline !== null) {
-          preparedMaterialPipelineShaders.set(pipeline as object, descriptor.shader);
-          const bindingContract = internals.getMaterialShaderBindingContract?.(descriptor.shader);
-          if (bindingContract === 'group-0') {
-            preparedGroup0Pipelines.add(pipeline as object);
-          } else if (bindingContract === 'view-only') {
-            preparedViewOnlyPipelines.add(pipeline as object);
-          } else {
-            preparedRenderMaterialPipelines.add(pipeline as object);
+          return pipeline === null ? err(makePreparedPipelinePendingError()) : ok(pipeline);
+        },
+        resolveBindings: (descriptor, pipeline) => {
+          const materialShaderId = preparedMaterialPipelineShaders.get(pipeline as object);
+          const bindingContract =
+            materialShaderId === undefined
+              ? undefined
+              : runtime.getMaterialShaderBindingContract?.(materialShaderId);
+          if (bindingContract === 'group-0-resource') {
+            return descriptor.values.sceneDepth === undefined
+              ? err(new Error('prepared group-0 resource pipeline requires a scene target'))
+              : ok(undefined);
           }
-        }
-        return pipeline === null ? err(makePreparedPipelinePendingError()) : ok(pipeline);
-      },
-      resolveBindings: (descriptor, pipeline) => {
-        const materialShaderId = preparedMaterialPipelineShaders.get(pipeline as object);
-        const bindingContract =
-          materialShaderId === undefined
-            ? undefined
-            : internals.getMaterialShaderBindingContract?.(materialShaderId);
-        if (bindingContract === 'group-0-resource') {
-          return descriptor.values.sceneDepth === undefined
-            ? err(new Error('prepared group-0 resource pipeline requires a scene target'))
-            : ok(undefined);
-        }
-        if (bindingContract === 'view-and-scene-depth') {
-          return ok(undefined);
-        }
-        if (preparedGroup0Pipelines.has(pipeline as object)) {
+          if (bindingContract === 'view-and-scene-depth') {
+            return ok(undefined);
+          }
+          if (preparedGroup0Pipelines.has(pipeline as object)) {
+            const layout =
+              (materialShaderId === undefined
+                ? undefined
+                : runtime.getMaterialBindGroupLayout?.(materialShaderId)) ??
+              (
+                pipeline as RenderPipeline & {
+                  getBindGroupLayout?: (index: number) => BindGroupLayout;
+                }
+              ).getBindGroupLayout?.(0);
+            return layout === undefined
+              ? err(new Error('prepared group-0 pipeline bind group layout is unavailable'))
+              : runtime.device.createBindGroup({ layout, entries: [] });
+          }
+          if (
+            preparedViewOnlyPipelines.has(pipeline as object) ||
+            (preparedRenderMaterialPipelines.has(pipeline as object) &&
+              descriptor.values.group === 0) ||
+            pipeline === runtime.getPipelineState()?.unlitPipeline
+          ) {
+            return ok(undefined);
+          }
+          const group = descriptor.values.group;
           const layout =
-            (materialShaderId === undefined
-              ? undefined
-              : internals.getMaterialBindGroupLayout?.(materialShaderId)) ??
+            (materialShaderId !== undefined
+              ? (runtime.getMaterialBindGroupLayout?.(materialShaderId) ??
+                (group === 0 ? runtime.getPipelineState()?.materialBindGroupLayout : undefined))
+              : undefined) ??
             (
               pipeline as RenderPipeline & {
                 getBindGroupLayout?: (index: number) => BindGroupLayout;
               }
-            ).getBindGroupLayout?.(0);
-          return layout === undefined
-            ? err(new Error('prepared group-0 pipeline bind group layout is unavailable'))
-            : internals.device.createBindGroup({ layout, entries: [] });
-        }
-        if (
-          preparedViewOnlyPipelines.has(pipeline as object) ||
-          (preparedRenderMaterialPipelines.has(pipeline as object) &&
-            descriptor.values.group === 0) ||
-          pipeline === internals.getPipelineState()?.unlitPipeline
-        ) {
-          return ok(undefined);
-        }
-        const group = descriptor.values.group;
-        const layout =
-          (materialShaderId !== undefined
-            ? (internals.getMaterialBindGroupLayout?.(materialShaderId) ??
-              (group === 0 ? internals.getPipelineState()?.materialBindGroupLayout : undefined))
-            : undefined) ??
-          (
-            pipeline as RenderPipeline & {
-              getBindGroupLayout?: (index: number) => BindGroupLayout;
-            }
-          ).getBindGroupLayout?.(group === 1 ? 1 : 0);
-        const material = descriptor.values.material;
-        if (
-          group === 1 &&
-          layout !== undefined &&
-          materialShaderId !== undefined &&
-          typeof material === 'object' &&
-          material !== null &&
-          'world' in material &&
-          'guid' in material &&
-          typeof material.world === 'number' &&
-          typeof material.guid === 'string'
-        ) {
-          return preparedMaterialBindings(materialShaderId, material.world, material.guid, layout);
-        }
-        return layout === undefined
-          ? err(new Error('prepared pipeline bind group layout is unavailable'))
-          : internals.device.createBindGroup({
+            ).getBindGroupLayout?.(group === 1 ? 1 : 0);
+          const material = descriptor.values.material;
+          if (
+            group === 1 &&
+            layout !== undefined &&
+            materialShaderId !== undefined &&
+            typeof material === 'object' &&
+            material !== null &&
+            'world' in material &&
+            'guid' in material &&
+            typeof material.world === 'number' &&
+            typeof material.guid === 'string'
+          ) {
+            return preparedMaterialBindings(
+              runtime,
+              caches,
+              worlds,
+              materialShaderId,
+              material.world,
+              material.guid,
               layout,
-              entries:
-                group === 1 && preparedPipelineIds.has(pipeline as object)
-                  ? [
-                      {
-                        binding: 0,
-                        resource: {
-                          kind: 'textureView',
-                          value: internals.getPipelineState()?.fallbackTextureView as never,
+            );
+          }
+          return layout === undefined
+            ? err(new Error('prepared pipeline bind group layout is unavailable'))
+            : runtime.device.createBindGroup({
+                layout,
+                entries:
+                  group === 1 && preparedPipelineIds.has(pipeline as object)
+                    ? [
+                        {
+                          binding: 0,
+                          resource: {
+                            kind: 'textureView',
+                            value: runtime.getPipelineState()?.fallbackTextureView as never,
+                          },
                         },
-                      },
-                      {
-                        binding: 1,
-                        resource: {
-                          kind: 'sampler',
-                          value: internals.getPipelineState()?.defaultSampler as never,
+                        {
+                          binding: 1,
+                          resource: {
+                            kind: 'sampler',
+                            value: runtime.getPipelineState()?.defaultSampler as never,
+                          },
                         },
-                      },
-                      ...(internals.getPostProcessParamsBuffer?.(
-                        preparedPipelineIds.get(pipeline as object) ?? '',
-                      ) === undefined
-                        ? []
-                        : [
-                            {
-                              binding: 2,
-                              resource: {
-                                kind: 'buffer' as const,
-                                value: {
-                                  buffer: internals.getPostProcessParamsBuffer?.(
-                                    preparedPipelineIds.get(pipeline as object) ?? '',
-                                  ) as never,
+                        ...(runtime.getPostProcessParamsBuffer?.(
+                          preparedPipelineIds.get(pipeline as object) ?? '',
+                        ) === undefined
+                          ? []
+                          : [
+                              {
+                                binding: 2,
+                                resource: {
+                                  kind: 'buffer' as const,
+                                  value: {
+                                    buffer: runtime.getPostProcessParamsBuffer?.(
+                                      preparedPipelineIds.get(pipeline as object) ?? '',
+                                    ) as never,
+                                  },
                                 },
                               },
-                            },
-                          ]),
-                    ]
-                  : [],
-            });
-      },
-    });
-  };
+                            ]),
+                      ]
+                    : [],
+              });
+        },
+      });
+    };
+  const preparedResolverFactory = (
+    input: RenderFeaturePreparedGraphicsResolverInput,
+  ): PreparedGraphicsResolver =>
+    createPreparedResolverFactory(
+      internals,
+      featureGpuWork,
+      preparedWorlds,
+      activePreparedResolverCaches,
+    )(input);
+  const recoveryOwner = createRenderSystemRecovery({
+    frameState,
+    internals,
+    getEnvironmentLifecycle: () => environmentLifecycle,
+    getGpuDrivenProduction: () => gpuDrivenProduction,
+    setGpuDrivenProduction: (production) => {
+      gpuDrivenProduction = production;
+    },
+    disposeFeatureGpuWork,
+    setFeatureGpuWork: (owner) => {
+      featureGpuWork = owner;
+    },
+    getActiveFeaturePostProcessEntries: () => activeFeaturePostProcessEntries,
+    setActiveFeaturePostProcessEntries: (entries) => {
+      activeFeaturePostProcessEntries = entries;
+    },
+    postProcessPipelineCache,
+    clearPostProcessPipelineCache,
+    clearPostProcessPipelineEntry,
+    invalidatePostProcessModule,
+    persistentRenderScene,
+    gpuDrivenShaderFactory,
+    createFeatureGpuWorkOwner,
+    pointsLinesOwner,
+    createPreparedResolverFactory,
+    createPreparedResolverCaches,
+  });
   return {
     releaseProfilerCatalog(): void {
       releaseProfilerCatalog?.();
@@ -2466,9 +2304,44 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         gpuDriven: gpuDrivenProduction.inspect(),
       };
     },
+    get gpuDrivenInspection(): GpuDrivenProductionInspection {
+      return gpuDrivenProduction.inspect();
+    },
     get reflectionProbes(): ReflectionProbeInspection {
       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,
+      });
+    },
+    get reflectionFallbackCompletion(): Promise<void> | undefined {
+      return frameState.reflectionFallbackCompletion;
+    },
     isCubeCapturePending(target: RenderTarget): boolean {
       return cubeCaptureScheduler.inspect(target).candidateGeneration !== undefined;
     },
@@ -2538,6 +2411,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         }),
       });
     },
+    get lodOcclusionInspection(): LodOcclusionInspection | undefined {
+      return lastLodOcclusionInspection;
+    },
     get bloom(): BloomInspection {
       const pipelineState = internals.getPipelineState();
       const resources = pipelineState?.perPassResources;
@@ -2619,7 +2495,10 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       renderReadLeases?: readonly RenderReadLease[],
       timingCapture?: GpuTimingCapture,
     ): boolean {
-      preparedWorlds = worlds;
+      const composition = canonicalizeWorldComposition(worlds, opts, renderReadLeases);
+      const compositionWorlds = composition.worlds;
+      const compositionLeases = composition.leases;
+      preparedWorlds = compositionWorlds;
       const profileSession = internals.profiler?.activeSession();
       let ownsProfileFrame = false;
       let submitted = false;
@@ -2635,7 +2514,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 } = opts;
+        const { cameraOwner, resourceOwner } = 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.
@@ -2670,22 +2549,28 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         // 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 = worlds[resourceOwner] as World;
+        const resourceWorld = compositionWorlds[resourceOwner] as World;
         const frame = runProfiledRenderPhase(profileSession, 'extract', () => {
           return persistentRenderScene.extractComposition(
-            worlds,
+            compositionWorlds,
             { cameraOwner, resourceOwner },
             internals.assets.catalogEpoch,
-            () =>
+            (renderables) =>
               extractFrames(
-                worlds,
+                compositionWorlds,
                 { cameraOwner, resourceOwner },
                 internals.assets,
                 internals.getPipelineState(),
                 persistentRenderScene.materialSnapshotCacheStore(),
-                { cull: 'none' },
+                {
+                  cull: 'none',
+                  renderables,
+                  ...(internals.getMaterialShaderArtifact === undefined
+                    ? {}
+                    : { getMaterialShaderArtifact: internals.getMaterialShaderArtifact }),
+                },
               ),
-            renderReadLeases,
+            compositionLeases,
           );
         });
         const {
@@ -2701,7 +2586,6 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           skylightCount,
           skybox,
           skyboxCount,
-          fog,
           fogFailure,
           frustumStats,
           visibilityStats,
@@ -2714,12 +2598,280 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           frame.reflectionProbes ?? [],
           persistentRenderScene.reflectionProbeProjection().selected,
           cameras[0],
+          frameState.frameNumber,
+          skylight,
         );
         latestCamera = cameras[0];
+        persistentRenderScene.updateVisibilityFacet(compositionWorlds, latestCamera, renderables);
+        let occlusionProjection:
+          | import('./scene/visibility/occlusion-runtime').OcclusionFrameProjection
+          | undefined;
+        let occlusionFallback: LodOcclusionInspection['fallback'] = { active: false };
+        const worldKeys = persistentRenderScene.visibilityWorldKeysFor(compositionWorlds);
+        const slotByEntity = persistentRenderScene.compositionSlotByStableEntity();
+        if (latestCamera !== undefined) {
+          const camera = latestCamera;
+          const cameraWorld = compositionWorlds[camera.worldId ?? cameraOwner];
+          const view = viewKey({
+            attachmentId: cameraWorld?.identity ?? 'missing-camera-world',
+            cameraEntity: camera.entityKey ?? 0,
+            viewRole: 'main',
+            viewGeneration: camera.historyVersion ?? 0,
+          });
+          const cachedCandidates = occlusionCandidateCache;
+          const candidates =
+            cachedCandidates?.renderables === renderables &&
+            cachedCandidates.camera === camera &&
+            cachedCandidates.cameraWorldIdentity === (cameraWorld?.identity ?? '')
+              ? cachedCandidates.candidates
+              : renderables.flatMap((renderable) => {
+                  const world = compositionWorlds[renderable.worldId];
+                  const aabb = renderable.localAabb;
+                  // Occlusion is a LOD transport concern. A plain mesh has no
+                  // lower-detail range to select, so keep it on the ordinary CPU
+                  // visibility path and do not allocate query resources for it.
+                  if (
+                    world === undefined ||
+                    cameraWorld === undefined ||
+                    aabb === undefined ||
+                    aabb.length < 6 ||
+                    renderable.lods === undefined ||
+                    renderable.lods.length === 0
+                  )
+                    return [];
+                  const slot = slotByEntity.get(
+                    worldEntityKey(
+                      worldKeys[renderable.worldId] ?? renderable.worldId,
+                      renderable.entityKey,
+                    ),
+                  );
+                  if (slot === undefined) return [];
+                  const primitive = primitiveKey({
+                    attachmentId: cameraWorld.identity,
+                    worldGeneration: worldKeys[renderable.worldId] ?? renderable.worldId,
+                    primitiveSlot: slot.slot,
+                    slotGeneration: slot.generation,
+                  });
+                  return [
+                    {
+                      view,
+                      primitive,
+                      epoch: 0,
+                      bounds: {
+                        min: [aabb[0] ?? 0, aabb[1] ?? 0, aabb[2] ?? 0] as [number, number, number],
+                        max: [aabb[3] ?? 0, aabb[4] ?? 0, aabb[5] ?? 0] as [number, number, number],
+                      },
+                      candidate: { level: 0, confidence: 1 },
+                      deviceGeneration: internals.deviceScope.generation,
+                      proxyVertices: buildOcclusionProxyVertices(
+                        aabb,
+                        renderable.transform.world,
+                        camera,
+                      ),
+                    },
+                  ];
+                });
+          occlusionCandidateCache = {
+            renderables,
+            camera,
+            cameraWorldIdentity: cameraWorld?.identity ?? '',
+            candidates,
+          };
+          occlusionProjection = runProfiledRenderPhase(profileSession, 'occlusion-prepare', () =>
+            ensureOcclusionRuntime().prepareBatch(candidates, camera.antialias === 'msaa' ? 4 : 1),
+          );
+          const queryPool = ensureOcclusionRuntime().inspect();
+          const queryUnavailable = ensureOcclusionRuntime().prepareUnavailable;
+          const queryCapacityFallback =
+            candidates.length > 0 && queryUnavailable && queryPool.availablePages === 0;
+          occlusionFallback = queryCapacityFallback
+            ? {
+                active: true as const,
+                reason: 'page-exhausted' as const,
+                error: {
+                  code: 'visibility-query-capacity-exhausted',
+                  expected: 'one available occlusion-query page for the LOD candidate batch',
+                  hint: 'retry the LOD query after an in-flight page completes',
+                  detail: {
+                    availablePages: queryPool.availablePages,
+                    pageCount: queryPool.pageCount,
+                    pageIndexLimit: queryPool.pageIndexLimit,
+                  },
+                },
+              }
+            : ({ active: false } as const);
+        }
+        // Query transport is best-effort and must fail open. A candidate that
+        // was hidden by an earlier completion becomes visible again when this
+        // device/frame cannot reserve a fresh query page; the next successful
+        // submission can rebuild confidence from a real result.
+        if (
+          occlusionProjection === undefined &&
+          latestCamera !== undefined &&
+          ensureOcclusionRuntime().prepareUnavailable
+        ) {
+          const cameraWorld = compositionWorlds[latestCamera.worldId ?? cameraOwner];
+          if (cameraWorld !== undefined) {
+            const fallbackView = viewKey({
+              attachmentId: cameraWorld.identity,
+              cameraEntity: latestCamera.entityKey ?? 0,
+              viewRole: 'main',
+              viewGeneration: latestCamera.historyVersion ?? 0,
+            });
+            for (const renderable of renderables) {
+              if ((renderable.lods?.length ?? 0) === 0) continue;
+              const world = compositionWorlds[renderable.worldId];
+              if (world === undefined) continue;
+              const slot = slotByEntity.get(
+                worldEntityKey(
+                  worldKeys[renderable.worldId] ?? renderable.worldId,
+                  renderable.entityKey,
+                ),
+              );
+              if (slot === undefined) continue;
+              persistentRenderScene.visibilityFacetStore().applyConfidence(
+                fallbackView,
+                primitiveKey({
+                  attachmentId: cameraWorld.identity,
+                  worldGeneration: worldKeys[renderable.worldId] ?? renderable.worldId,
+                  primitiveSlot: slot.slot,
+                  slotGeneration: slot.generation,
+                }),
+                { type: 'failure', submissionGeneration: frameState.frameNumber },
+              );
+            }
+          }
+        }
+        const visibilityProjection = persistentRenderScene.projectVisibility(
+          compositionWorlds,
+          latestCamera,
+          renderables,
+          dispatch,
+        );
+        const submissionRenderables = visibilityProjection.renderables;
+        const submissionDispatch = visibilityProjection.dispatch;
+        const inspectionCamera = latestCamera;
+        let lodCandidateCountForFrame = 0;
+        if (inspectionCamera !== undefined) {
+          const firstRenderable = renderables[0];
+          const lodCandidateCount =
+            lodCandidateCountCache?.renderables === renderables
+              ? lodCandidateCountCache.count
+              : (() => {
+                  const count = renderables.reduce(
+                    (total, renderable) => total + ((renderable.lods?.length ?? 0) > 0 ? 1 : 0),
+                    0,
+                  );
+                  lodCandidateCountCache = { renderables, count };
+                  return count;
+                })();
+          lodCandidateCountForFrame = lodCandidateCount;
+          const inspectionRenderables =
+            lodInspectionRenderablesCache?.submissionRenderables === submissionRenderables &&
+            lodInspectionRenderablesCache.lodCandidateCount === lodCandidateCount
+              ? lodInspectionRenderablesCache.values
+              : (() => {
+                  const values =
+                    lodCandidateCount > 0
+                      ? submissionRenderables.filter(
+                          (renderable) => (renderable.lods?.length ?? 0) > 0,
+                        )
+                      : submissionRenderables;
+                  lodInspectionRenderablesCache = {
+                    submissionRenderables,
+                    lodCandidateCount,
+                    values,
+                  };
+                  return values;
+                })();
+          const candidateCount =
+            lodCandidateCount > 0 ? lodCandidateCount : renderables.length + frustumStats.culled;
+          const inspectionQuery = ensureOcclusionRuntime().inspect();
+          const inspectionBudget = persistentRenderScene.visibilityBudgetValue();
+          const inspectionWorlds = createLodWorldInspections(
+            compositionWorlds,
+            renderables,
+            submissionRenderables,
+            inspectionCamera,
+            frameState.frameNumber,
+            worldKeys,
+            slotByEntity,
+            {
+              used:
+                inspectionQuery.pageCount * inspectionQuery.pageIndexLimit -
+                inspectionQuery.availablePages * inspectionQuery.pageIndexLimit,
+              capacity: inspectionQuery.pageCount * inspectionQuery.pageIndexLimit,
+            },
+            occlusionFallback,
+            ensureOcclusionRuntime().prepareUnavailable
+              ? { active: true, reason: 'query-unavailable' as const }
+              : { active: false },
+          );
+          const attachmentByWorldKey = new Map<number, string>();
+          for (let worldId = 0; worldId < compositionWorlds.length; worldId += 1) {
+            const world = compositionWorlds[worldId];
+            if (world === undefined) continue;
+            const worldKey = worldKeys[worldId] ?? worldId;
+            if (attachmentByWorldKey.has(worldKey)) {
+              attachmentByWorldKey.clear();
+              break;
+            }
+            attachmentByWorldKey.set(worldKey, world.identity);
+          }
+          lastLodWorldAttachments = attachmentByWorldKey;
+          lastLodOcclusionInspection = inspectLodOcclusion({
+            root: {
+              guid:
+                firstRenderable === undefined
+                  ? 'none'
+                  : `asset-handle:${firstRenderable.assetHandle}`,
+              sourceKey: `render-frame:${frameState.frameNumber}`,
+            },
+            view: {
+              attachmentId:
+                compositionWorlds[inspectionCamera.worldId ?? cameraOwner]?.identity ?? 'none',
+              cameraEntity: inspectionCamera.entityKey ?? 0,
+              viewRole: 'main',
+              viewGeneration: inspectionCamera.historyVersion ?? 0,
+            },
+            slot: {
+              primitiveSlot: 0,
+              slotGeneration: persistentRenderScene.inspect().topology.revision,
+            },
+            generation: frameState.frameNumber,
+            count: {
+              candidates: candidateCount,
+              visible: inspectionRenderables.length,
+              occluded: visibilityProjection.suppressed,
+            },
+            lodHistogram: [{ level: 0, count: inspectionRenderables.length }],
+            queryLatencyUs: { median: 0, p95: 0, last: 0 },
+            pagePressure: { used: 0, capacity: 3 * 4096 },
+            fallback: occlusionFallback,
+            degradation: ensureOcclusionRuntime().prepareUnavailable
+              ? { active: true, reason: 'query-unavailable' as const }
+              : { active: false },
+            samples: inspectionRenderables.slice(0, 64).map((_, index) => ({
+              primitiveSlot: index,
+              level: 0,
+              visible: true,
+            })),
+            submit: {
+              frameId: frameState.frameNumber,
+              build: resolveInspectionBuild(internals),
+              deviceGeneration: internals.deviceScope.generation,
+            },
+            budget: inspectionBudget,
+            worlds: inspectionWorlds,
+          });
+        } else {
+          lastLodOcclusionInspection = undefined;
+          lastLodWorldAttachments = new Map();
+        }
         const temporalDemanded =
           cameras[0]?.antialias === 'taa' || (cameras[0]?.motionBlur?.shutterAngle ?? 0) > 0;
         if (temporalDemanded) {
-          persistentRenderScene.prepareTemporalFrame(renderables);
+          persistentRenderScene.prepareTemporalFrame(submissionRenderables);
         }
         environmentLifecycle.bindScope(internals.deviceScope);
         if (fogFailure !== undefined) {
@@ -2819,7 +2971,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         const preparedResourceBatches = runProfiledRenderPhase(profileSession, 'features', () => {
           if (internals.featureHost === undefined) return [];
           const featureFrame = runRenderFeatureFrame(internals.featureHost, {
-            worlds,
+            worlds: compositionWorlds,
             owner: resourceOwner,
             frameNumber: frameState.frameNumber,
             visibilitySnapshots: frame.featureVisibilitySnapshots,
@@ -2897,9 +3049,31 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         // world that owns skylight / skybox / singleton render state, w5 / D-3).
         // Only the Transparent segment is reordered; queue ordering between
         // segments (sortDispatchByQueue, stable) is preserved.
-        const orderedDispatch = runProfiledRenderPhase(profileSession, 'sort', () =>
-          sortTransparentDispatch(dispatch, resourceWorld, cameras, renderables),
-        );
+        const orderedDispatch = runProfiledRenderPhase(profileSession, 'sort', () => {
+          const cached = orderedDispatchCache;
+          if (
+            cached?.source === submissionDispatch &&
+            cached.world === resourceWorld &&
+            cached.camera === cameras &&
+            cached.renderables === submissionRenderables
+          ) {
+            return cached.value;
+          }
+          const value = sortTransparentDispatch(
+            [...submissionDispatch],
+            resourceWorld,
+            cameras,
+            submissionRenderables,
+          );
+          orderedDispatchCache = {
+            source: submissionDispatch,
+            world: resourceWorld,
+            camera: cameras,
+            renderables: submissionRenderables,
+            value,
+          };
+          return value;
+        });
 
         // M3 / w26: single dispatch list replaces old three-bucket model.
         // Pass dispatch to recordFrame — the record stage iterates dispatch
@@ -2927,13 +3101,16 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 // The same runner is also called by geometry/material helpers;
                 // invoking those wrappers would turn a pass probe into the
                 // high-overhead per-draw `nested` probe.
-                if (
-                  profileSession.detail === 'passes' &&
-                  (!phase.startsWith('record/graph-execute/') ||
-                    (phase.slice('record/graph-execute/'.length).includes('/') &&
-                      !phase.endsWith('/geometry-loop')))
-                ) {
-                  return action();
+                if (profileSession.detail === 'passes') {
+                  const isOcclusionOwner =
+                    phase === 'record/occlusion-query-submit' ||
+                    phase === 'record/occlusion-global-advance';
+                  const isGraphOwner =
+                    phase === 'record/graph-execute' ||
+                    (phase.startsWith('record/graph-execute/') &&
+                      (!phase.slice('record/graph-execute/'.length).includes('/') ||
+                        phase.endsWith('/geometry-loop')));
+                  if (!isOcclusionOwner && !isGraphOwner) return action();
                 }
                 return runProfiledRenderPhase(profileSession, phase, action);
               };
@@ -2946,7 +3123,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             resourceWorld,
             cameras,
             lights,
-            renderables,
+            [...submissionRenderables],
             orderedDispatch,
             frameState,
             dispatchCounts,
@@ -2956,18 +3133,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             skybox,
             skyboxCount,
             postProcessParams,
-            fog,
-            worlds,
+            compositionWorlds,
             recordProfilePhase,
             {
               owner: gpuDrivenProduction,
               scene: persistentRenderScene.compositionGpuDrivenState(),
-              onCoverage: (ownsAll, clusteredLighting) => {
-                const key = `${internals.gpuStore.meshResidencyEpoch}:${clusteredLighting ? 'clustered' : 'standard'}`;
-                persistentRenderScene.setCompositionGpuDrivenCoverage(key, ownsAll);
+              onSceneDemand: (sceneRowsRequired) => {
+                persistentRenderScene.setCompositionGpuSceneDemand(sceneRowsRequired);
               },
+              activeEntityKeys: visibilityProjection.activeEntityKeys,
+              activeEntityRevision: visibilityProjection.activeEntityRevision,
+              telemetryCandidateCount: lodCandidateCountForFrame,
+              ...(occlusionProjection === undefined ? {} : { occlusion: occlusionProjection }),
             },
-            renderReadLeases,
+            compositionLeases,
             featureGraphCandidate,
             pointsLinesOwner,
             {
@@ -2984,6 +3163,30 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             timingCapture,
           ),
         );
+        if (submitted) {
+          try {
+            internals.recoveryColdWorkGuard?.finish();
+          } catch (cause) {
+            submitted = false;
+            throw cause;
+          }
+        }
+        if (submitted && lastLodOcclusionInspection !== undefined) {
+          const query = ensureOcclusionRuntime().inspect();
+          lastLodOcclusionInspection = {
+            ...lastLodOcclusionInspection,
+            pagePressure: {
+              used:
+                query.pageCount * query.pageIndexLimit -
+                query.availablePages * query.pageIndexLimit,
+              capacity: query.pageCount * query.pageIndexLimit,
+            },
+            fallback: occlusionFallback,
+            degradation: ensureOcclusionRuntime().prepareUnavailable
+              ? { active: true, reason: 'query-unavailable' as const }
+              : { active: false },
+          };
+        }
         const directionalQuality = lights.directionalShadowQuality;
         const directionalShadowReady =
           directionalQuality === undefined ||
@@ -3007,6 +3210,21 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           };
         }
         if (submitted) {
+          recoveryOwner.setLastSuccessfulFrameSeed({
+            frame,
+            worlds: compositionWorlds,
+            cameraOwner: composition.owners.cameraOwner,
+            resourceOwner: composition.owners.resourceOwner,
+            width: Math.max(1, internals.canvas.width),
+            height: Math.max(1, internals.canvas.height),
+          });
+          submittedFrameCount += 1;
+          lastSubmittedGeneration = internals.deviceScope?.generation;
+          if (occlusionProjection === undefined) {
+            runProfiledRenderPhase(profileSession, 'record/occlusion-global-advance', () =>
+              ensureOcclusionRuntime().advanceSuccessfulSubmit(frameState.frameNumber),
+            );
+          }
           const temporalCommit = persistentRenderScene.commitTemporalFrame();
           if (!temporalCommit.ok) {
             internals.errorRegistry.fire(temporalCommit.error);
@@ -3085,6 +3303,21 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       const currentFrameId = frameState.frameNumber - 1;
       return observeCurrentFrame(options, frameState.currentFrameObservationSource, currentFrameId);
     },
+    async observeLodOcclusion(): Promise<void> {
+      await ensureOcclusionRuntime().waitForCompletions();
+      applyLodSelectionTelemetry(await gpuDrivenProduction.readLodSelection());
+      if (lastLodOcclusionInspection !== undefined) {
+        const queryLatency = ensureOcclusionRuntime().inspectQueryLatency();
+        lastLodOcclusionInspection = inspectLodOcclusion({
+          ...lastLodOcclusionInspection,
+          queryLatencyUs: {
+            median: queryLatency.median,
+            p95: queryLatency.p95,
+            last: queryLatency.last,
+          },
+        });
+      }
+    },
     getCurrentGraphTarget(name: string) {
       const graph = frameState.perFrameGraph;
       if (graph === undefined || graph === null) return undefined;
@@ -3123,6 +3356,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     get meshMaterialBindings(): readonly MeshMaterialBindingObservation[] {
       return lastMeshMaterialBindings;
     },
+    get iblBinding(): import('./mesh-material-bindings').IblBindingInspection | undefined {
+      return frameState.iblBindingInspection;
+    },
     get perFramePassNames(): readonly string[] {
       return frameState.compiledFrameGraph?.inspect().passes.map((pass) => pass.name) ?? [];
     },
@@ -3132,6 +3368,25 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     get perFrameGraphInfo(): CompiledRenderGraphInfo | undefined {
       return frameState.compiledFrameGraph?.inspect();
     },
+    get recoveryEvidence(): RecoveryProductionEvidence {
+      const graph = frameState.compiledFrameGraph?.inspect();
+      return Object.freeze({
+        producerRoots: createRendererProducerRootMatrix(),
+        graph: Object.freeze({
+          ready: graph !== undefined,
+          generation: frameState.graphGeneration,
+          passCount: graph?.passes.length ?? 0,
+          resourceCount: graph?.resources.length ?? 0,
+        }),
+        residency: Object.freeze({
+          meshResidencyEpoch: internals.gpuStore.meshResidencyEpoch,
+        }),
+        submissions: Object.freeze({
+          count: submittedFrameCount,
+          lastGeneration: lastSubmittedGeneration,
+        }),
+      });
+    },
     get volumetricFog(): import('./volume/inspection').VolumetricFogInspection {
       return frameState.volumetricFogInspection;
     },
@@ -3227,6 +3482,11 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         throw cause;
       }
     },
+    lookupPostProcess,
+    prepareRecoveryGraphCandidate: recoveryOwner.prepareRecoveryGraphCandidate,
+    submitCandidateSetup: recoveryOwner.submitCandidateSetup,
+    publishRecoveryGraphCandidate: recoveryOwner.publishRecoveryGraphCandidate,
+    discardRecoveryGraphCandidate: recoveryOwner.discardRecoveryGraphCandidate,
     disposeFrameState(): void {
       (internals as TimingSessionHost).gpuPassTimingSession?.dispose();
       (internals as TimingSessionHost).gpuPassTimingSession = undefined;
@@ -3234,8 +3494,10 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       (internals as TimingSessionHost).gpuPassTimingSubmittedWork = undefined;
       (internals as TimingSessionHost).gpuPassTimingFrameIdentity = undefined;
       (internals as TimingSessionHost).gpuPassTimingBeginReason = undefined;
+      pointsLinesOwner.dispose();
       persistentRenderScene.dispose();
       gpuDrivenProduction.dispose();
+      occlusionRuntime?.dispose();
       disposeFeatureGpuWork();
       reflectionProbeOwner.dispose();
       // Bloom generations are renderer-owned rather than graph-owned. Drain
@@ -3304,6 +3566,15 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // dispose error strategy).
       disposeInstanceBuffers(frameState.instanceBuffers, internals.errorRegistry);
       disposeTransientInstanceBuffers(frameState.transientInstanceBuffers, internals.errorRegistry);
+      if (frameState.probeBlendRecordBuffer !== undefined) {
+        if (!frameState.probeBlendRecordBuffer.isDestroyed) {
+          const result = frameState.probeBlendRecordBuffer.destroy();
+          if (!result.ok) internals.errorRegistry.fire(result.error);
+        }
+        delete frameState.probeBlendRecordBuffer;
+      }
+      frameState.probeBlendRecordBufferCapacity = 0;
+      frameState.probeBlendBuffers.clear();
       if (frameState.morphBuffers !== undefined) {
         for (const entry of frameState.morphBuffers.values()) {
           if (!entry.buffer.isDestroyed) {
@@ -3323,7 +3594,18 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         frameState.pointShadowAtlas = null;
       }
     },
-    resetForRecover(): void {
+    resetForRecover(retiringPipelineState?: PipelineState, replacementDevice?: RhiDevice): void {
+      frameState.lastSuccessfulTemporalView = undefined;
+      frameState.successfulTemporalFrameIndex = 0;
+      frameState.pendingTemporalCommit = { kind: 'none' };
+      // The active expansion buffers belong to the lost generation. Abandon
+      // 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;
+      ssrFallbackGeneration = undefined;
       transmissionAdmission.markDeviceLost();
       lastTransmissionKey = '';
       transmissionCapabilityGeneration = -1;
@@ -3340,13 +3622,28 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       updateTransmissionInspection(lastTransmissionAntialias, false);
       persistentRenderScene.resetGpuForRecover();
       gpuDrivenProduction.dispose();
-      gpuDrivenProduction = new GpuDrivenProduction(internals.device, gpuDrivenShaderFactory);
+      // 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(
+        replacementDevice ?? internals.device,
+        gpuDrivenShaderFactory,
+      );
+      occlusionRuntime?.dispose();
+      // The replacement device is installed by the host after this hook. Do
+      // not recreate device-bound query resources against the lost device;
+      // the first post-recovery frame lazily binds the current device.
+      occlusionRuntime = undefined;
       disposeFeatureGpuWork();
+      featureGpuWork = createFeatureGpuWorkOwner(internals);
       reflectionProbeOwner.dispose();
       // 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.
-      internals.getPipelineState()?.perPassResources.drainBloomResources?.();
+      (
+        retiringPipelineState ?? internals.getPipelineState()
+      )?.perPassResources.drainBloomResources?.();
       // feat-20260622-s5 M3 / B-2 / w18: recover() rebuild drops device-bound
       // state minted by the lost device. The active graph and per-entity caches
       // must be discarded, not merely marked for destruction: their opaque
@@ -3383,6 +3680,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       frameState.directionalShadowCacheRecorded = false;
       frameState.currentFrameObservationSource = undefined;
       frameState.lastSuccessfulCameraAntialias = undefined;
+      frameState.temporalFrameTransaction.reset('device-recovery');
+      frameState.temporalFrame = undefined;
+      frameState.temporalFrameInput = undefined;
+      frameState.lastSuccessfulTemporalView = undefined;
+      frameState.successfulTemporalFrameIndex = 0;
+      frameState.pendingTemporalCommit = { kind: 'none' };
       frameState.currentDirectionalShadowView = null;
       frameState.currentSpotShadowView = null;
       if (frameState.temporalGpuState !== undefined) {
@@ -3403,6 +3706,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       }
       frameState.retiredCompiledFrameGraphs.clear();
       frameState.instanceBuffers.clear();
+      delete frameState.probeBlendRecordBuffer;
+      frameState.probeBlendRecordBufferCapacity = 0;
+      frameState.probeBlendBuffers.clear();
       frameState.morphBuffers?.clear();
       frameState.transientInstanceBuffers = [];
       frameState.pointShadowAtlas = null;
@@ -3423,53 +3729,152 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // the lost device, so recovery must invalidate this cache alongside the
       // feature-host declarations and UBOs below.
       postProcessPipelineCache.clear();
-      // Logical declarations stay live in the feature host while a replacement
-      // device is being requested.
-      postProcessParamsBuffers.clear();
+      // Logical declarations and the active params bundle stay live until the
+      // candidate post-process bundle crosses the publication boundary.
       resetRenderFeatureGraphState(internals);
     },
+    prepareRecoveryPostProcessResources(device: RhiDevice) {
+      return prepareRecoveryPostProcessResources(device);
+    },
+    publishRecoveryPostProcessResources(candidate: RecoveryPostProcessResources): void {
+      publishRecoveryPostProcessResources(candidate);
+    },
+    discardRecoveryPostProcessResources(candidate: RecoveryPostProcessResources): void {
+      discardRecoveryPostProcessResources(candidate);
+    },
     restorePostProcessResources(): void {
-      const declarations = [
-        ...builtinPostProcessEntries.entries(),
-        ...activeFeaturePostProcessEntries.entries(),
-      ];
-      for (const [id, entry] of declarations) {
-        if (id === 'forgeax.taa-resolve') continue;
-        let buffer: Buffer | undefined;
-        if (entry.params !== undefined) {
-          const created = internals.device.createBuffer({
-            label: `post-process-params-${id}`,
-            size: entry.params.byteSize,
-            usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-            mappedAtCreation: false,
-          });
-          if (!created.ok) throw created.error;
-          buffer = created.value;
-          const written = internals.device.queue.writeBuffer(buffer, 0, entry.params.defaultValue);
-          if (!written.ok) {
-            internals.device.destroyBuffer(buffer);
-            throw written.error;
-          }
-        } else if (entryHasDepthRead(entry)) {
-          const created = internals.device.createBuffer({
-            label: `post-process-params-${id}`,
-            size: DEPTH_MIN_PARAMS_BYTE_SIZE,
-            usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-            mappedAtCreation: false,
+      const prepared = prepareRecoveryPostProcessResources(internals.device);
+      if (!prepared.ok) throw prepared.error;
+      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 (!created.ok) throw created.error;
-          buffer = created.value;
         }
-        if (buffer !== undefined && lookupPostProcess(id) === entry) {
-          postProcessParamsBuffers.set(id, buffer);
-        } else if (buffer !== undefined) {
-          internals.device.destroyBuffer(buffer);
+        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();
+        },
+      };
     },
   };
 }
 
+/** Resolve the build identity used by every inspection submit. */
+export function resolveInspectionBuild(internals: Pick<RenderSystemInternals, 'build'>): string {
+  return internals.build ?? 'render-system';
+}
+
 // @forgeax/engine-render - built-in record context extension.
 //
 // The public RenderPipelineContext is canonical in render-contract.ts. This