@forgeax/engine-render 0.1.21 → 0.1.24

package/src/scene/render-scene.ts

@@ -1,9 +1,9 @@
-import type { EntityHandle, World } from '@forgeax/engine-ecs';
+import type { Query, World } from '@forgeax/engine-ecs';
 import { componentId } from '@forgeax/engine-ecs/internal';
-import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
+import type { RenderReadLease, RenderReadVersion } from '@forgeax/engine-ecs/projection';
 import { box3, frustum, mat4 } from '@forgeax/engine-math';
 import { type RhiDevice, RhiError } from '@forgeax/engine-rhi';
-import { ChildOf, Transform } from '@forgeax/engine-scene';
+import { ChildOf, GlobalTransform, Transform } from '@forgeax/engine-scene';
 import { Skin } from '@forgeax/engine-skinning';
 import { err, ok, type Result } from '@forgeax/engine-types';
 import {
@@ -11,8 +11,10 @@ import {
   DirectionalLight,
   Instances,
   Layer,
+  LightProbe,
   MeshFilter,
   MeshRenderer,
+  MotionBlur,
   PointLight,
   PointLightShadow,
   PostProcessParams,
@@ -24,6 +26,7 @@ import {
   SpriteRegionOverride,
   Visibility,
 } from '../components';
+import type { DeviceScope, LifecycleResourceSpec } from '../device/device-scope';
 import {
   BatchTopology,
   type BatchTopologyInspection,
@@ -34,6 +37,7 @@ import type { PersistentRenderSceneInspection } from '../inspection-types';
 import { fingerprintNumericArray, InstanceBoundsCache } from '../instances-derived-bounds';
 import type { PointsLinesInspection } from '../points-lines/inspection';
 import type { PointsLinesRetainedSnapshot } from '../points-lines/snapshot';
+import { worldEntityKey } from '../record/frame-snapshot';
 import {
   type ReflectionProbeFact,
   ReflectionProbeProjection,
@@ -55,21 +59,30 @@ import {
   type TransmissionDemandOperation,
 } from '../transmission/projection';
 import { VolumetricFog } from '../volume/component';
+import { ProbeBlendSceneProjection, type ProbeSceneObjectInput } from './probe-blend';
 import type {
   RenderSceneApplyResult,
   RenderSceneBounds,
-  RenderSceneDelta,
   RenderSceneInspection,
   RenderSceneOperation,
   RenderSceneRecord,
   RenderSceneResyncReason,
   RenderSceneSlot,
 } from './render-scene-types';
+import { createVisibilityBudget, type VisibilityBudget } from './visibility/budget';
+import {
+  primitiveKey,
+  primitiveKeyId,
+  VisibilityFacetStore,
+  viewKey,
+  viewKeyId,
+} from './visibility/facet';
+import { decideVisibility } from './visibility/occlusion-confidence';
+import type { PrimitiveKey, ViewKey, VisibilityCandidate } from './visibility/types';
 
 export type {
   RenderSceneApplyResult,
   RenderSceneBounds,
-  RenderSceneDelta,
   RenderSceneIdentity,
   RenderSceneInspection,
   RenderSceneOperation,
@@ -86,6 +99,14 @@ interface PendingIdentity {
   removed: boolean;
 }
 
+interface WorldTransformSpan {
+  readonly worldId: number;
+  readonly entities: Readonly<Uint32Array>;
+  readonly worlds: Readonly<Float32Array>;
+}
+
+type GlobalTransformChangeQuery = Query<readonly [typeof GlobalTransform]>;
+
 export interface RenderSceneSubmissionCapture {
   readonly revision: number;
   readonly slots: readonly {
@@ -200,31 +221,55 @@ function intersects(left: RenderSceneBounds, right: RenderSceneBounds): boolean
   );
 }
 
-function worldBounds(snapshot: RenderableSnapshot): RenderSceneBounds | undefined {
+function worldBounds(
+  snapshot: RenderableSnapshot,
+  target?: RenderSceneBounds,
+): RenderSceneBounds | undefined {
   const local = snapshot.localAabb;
   if (local === undefined || local.length < 6) return undefined;
   const world = snapshot.transform.world;
-  const min: [number, number, number] = [Infinity, Infinity, Infinity];
-  const max: [number, number, number] = [-Infinity, -Infinity, -Infinity];
-  for (const x of [local[0] ?? 0, local[3] ?? 0]) {
-    for (const y of [local[1] ?? 0, local[4] ?? 0]) {
-      for (const z of [local[2] ?? 0, local[5] ?? 0]) {
-        const tx =
-          (world[0] ?? 0) * x + (world[4] ?? 0) * y + (world[8] ?? 0) * z + (world[12] ?? 0);
-        const ty =
-          (world[1] ?? 0) * x + (world[5] ?? 0) * y + (world[9] ?? 0) * z + (world[13] ?? 0);
-        const tz =
-          (world[2] ?? 0) * x + (world[6] ?? 0) * y + (world[10] ?? 0) * z + (world[14] ?? 0);
-        min[0] = Math.min(min[0], tx);
-        min[1] = Math.min(min[1], ty);
-        min[2] = Math.min(min[2], tz);
-        max[0] = Math.max(max[0], tx);
-        max[1] = Math.max(max[1], ty);
-        max[2] = Math.max(max[2], tz);
-      }
-    }
-  }
-  return { min, max };
+  const min = (target?.min ?? [0, 0, 0]) as [number, number, number];
+  const max = (target?.max ?? [0, 0, 0]) as [number, number, number];
+  const centerX = ((local[0] ?? 0) + (local[3] ?? 0)) * 0.5;
+  const centerY = ((local[1] ?? 0) + (local[4] ?? 0)) * 0.5;
+  const centerZ = ((local[2] ?? 0) + (local[5] ?? 0)) * 0.5;
+  const extentX = ((local[3] ?? 0) - (local[0] ?? 0)) * 0.5;
+  const extentY = ((local[4] ?? 0) - (local[1] ?? 0)) * 0.5;
+  const extentZ = ((local[5] ?? 0) - (local[2] ?? 0)) * 0.5;
+  const worldCenterX =
+    (world[0] ?? 0) * centerX +
+    (world[4] ?? 0) * centerY +
+    (world[8] ?? 0) * centerZ +
+    (world[12] ?? 0);
+  const worldCenterY =
+    (world[1] ?? 0) * centerX +
+    (world[5] ?? 0) * centerY +
+    (world[9] ?? 0) * centerZ +
+    (world[13] ?? 0);
+  const worldCenterZ =
+    (world[2] ?? 0) * centerX +
+    (world[6] ?? 0) * centerY +
+    (world[10] ?? 0) * centerZ +
+    (world[14] ?? 0);
+  const worldExtentX =
+    Math.abs(world[0] ?? 0) * extentX +
+    Math.abs(world[4] ?? 0) * extentY +
+    Math.abs(world[8] ?? 0) * extentZ;
+  const worldExtentY =
+    Math.abs(world[1] ?? 0) * extentX +
+    Math.abs(world[5] ?? 0) * extentY +
+    Math.abs(world[9] ?? 0) * extentZ;
+  const worldExtentZ =
+    Math.abs(world[2] ?? 0) * extentX +
+    Math.abs(world[6] ?? 0) * extentY +
+    Math.abs(world[10] ?? 0) * extentZ;
+  min[0] = worldCenterX - worldExtentX;
+  min[1] = worldCenterY - worldExtentY;
+  min[2] = worldCenterZ - worldExtentZ;
+  max[0] = worldCenterX + worldExtentX;
+  max[1] = worldCenterY + worldExtentY;
+  max[2] = worldCenterZ + worldExtentZ;
+  return target ?? { min, max };
 }
 
 function boundsFromArray(bounds: ArrayLike<number>): RenderSceneBounds | undefined {
@@ -253,20 +298,23 @@ function boundsFromArray(bounds: ArrayLike<number>): RenderSceneBounds | undefin
 export class RenderScene {
   private readonly slots: Array<RenderSceneSlot | undefined> = [];
   private readonly lastSubmittedSlots: Array<RenderSceneSlot | undefined> = [];
+  private readonly previousWorldBySlot: Array<Float32Array | undefined> = [];
   private readonly generations: number[] = [];
   private readonly freeSlots: number[] = [];
   private readonly slotsByWorld = new Map<number, Map<number, number>>();
   private readonly slotsByMaterial = new Map<number, Set<number>>();
   private readonly dirtySinceSubmitted = new Set<number>();
+  private readonly transformUpdatedSlots: RenderSceneSlot[] = [];
+  private temporalTracking = false;
   private lastSubmittedVisible = new Set<string>();
   private submittedEpoch = 0;
-  // World bounds are a pure projection of each immutable snapshot. Cache the
-  // derived value by snapshot identity so repeated view queries do not redo
-  // the eight-corner transform for every view in the same frame.
-  private readonly worldBoundsCache = new WeakMap<RenderableSnapshot, RenderSceneBounds | null>();
+  // Bounds are a derived column of the stable render slot, not metadata of a
+  // transient snapshot wrapper. Undefined means dirty; null means that the
+  // retained row has no usable bounds and must be conservatively visible.
+  private readonly worldBoundsBySlot: Array<RenderSceneBounds | null | undefined> = [];
   private readonly instanceBoundsCache = new InstanceBoundsCache();
   private orderedSlots: number[] = [];
-  private materialized: readonly RenderableSnapshot[] | undefined;
+  private materialized: RenderableSnapshot[] | undefined;
   private slotSnapshot: readonly RenderSceneSlot[] | undefined;
   private revision = 0;
   private noChangeFrames = 0;
@@ -374,6 +422,7 @@ export class RenderScene {
       };
       this.unindexMaterials(pending.initial);
       this.slots[pending.initial.slot] = updatedSlot;
+      this.worldBoundsBySlot[updatedSlot.slot] = undefined;
       this.indexMaterials(updatedSlot);
       this.dirtySinceSubmitted.add(updatedSlot.slot);
       updatedSlots.push(updatedSlot);
@@ -399,19 +448,55 @@ export class RenderScene {
     };
   }
 
-  applyDelta(delta: RenderSceneDelta): RenderSceneApplyResult {
-    if (delta.overflowed || delta.resync !== undefined) {
-      const snapshots = delta.resync ?? [];
-      this.reset(snapshots);
-      this.resyncs += 1;
-      this.lastResyncReason = delta.reason ?? 'journal-overflow';
-      return {
-        ...this.emptyResult(),
-        created: snapshots.length,
-        resynced: 1,
-      };
+  /** Apply version-selected GlobalTransform columns without allocating per-entity operations. */
+  applyTransformSpans(spans: readonly WorldTransformSpan[]): RenderSceneApplyResult {
+    this.deltaFrames += 1;
+    let scanned = 0;
+    let updated = 0;
+    let ignoredLateUpdates = 0;
+    const updatedSlots = this.transformUpdatedSlots;
+    updatedSlots.length = 0;
+    for (const span of spans) {
+      scanned += span.entities.length;
+      for (let row = 0; row < span.entities.length; row += 1) {
+        const entity = span.entities[row];
+        if (entity === undefined) continue;
+        const slot = this.lookup(span.worldId, entity);
+        if (slot === undefined) {
+          ignoredLateUpdates += 1;
+          continue;
+        }
+        const target = slot.snapshot.transform.world;
+        const sourceStart = row * 16;
+        for (let index = 0; index < 16; index += 1) {
+          target[index] = span.worlds[sourceStart + index] ?? target[index] ?? 0;
+        }
+        if (slot.snapshot.instances === undefined) {
+          const cached = this.worldBoundsBySlot[slot.slot];
+          const bounds = worldBounds(slot.snapshot, cached ?? undefined);
+          this.worldBoundsBySlot[slot.slot] = bounds ?? null;
+        } else {
+          this.worldBoundsBySlot[slot.slot] = undefined;
+        }
+        if (this.temporalTracking) this.dirtySinceSubmitted.add(slot.slot);
+        updatedSlots.push(slot);
+        updated += 1;
+      }
     }
-    return this.apply(delta.operations);
+    this.renderableScans = scanned;
+    if (updated > 0) this.revision += 1;
+    return {
+      created: 0,
+      updated,
+      removed: 0,
+      recreated: 0,
+      ignoredLateUpdates,
+      createdSlots: [],
+      updatedSlots,
+      removedSlots: [],
+      recreatedSlots: [],
+      resynced: 0,
+    };
   }
 
   /** Reconcile the current identity set while retaining slots for survivors. */
@@ -446,6 +531,7 @@ export class RenderScene {
       };
       this.unindexMaterials(existing);
       this.slots[existing.slot] = updated;
+      this.worldBoundsBySlot[updated.slot] = undefined;
       this.indexMaterials(updated);
       this.dirtySinceSubmitted.add(updated.slot);
       this.orderedSlots.push(existing.slot);
@@ -460,14 +546,25 @@ export class RenderScene {
     this.reset(snapshots);
   }
 
-  materialize(): readonly RenderableSnapshot[] {
+  /** Enable previous-frame publication only while a temporal feature consumes it. */
+  setTemporalTracking(enabled: boolean): void {
+    if (enabled === this.temporalTracking) return;
+    this.temporalTracking = enabled;
+    if (!enabled) {
+      this.dirtySinceSubmitted.clear();
+      return;
+    }
+    for (const slot of this.orderedSlots) this.dirtySinceSubmitted.add(slot);
+  }
+
+  materialize(): RenderableSnapshot[] {
     if (this.materialized !== undefined) return this.materialized;
     const snapshots: RenderableSnapshot[] = [];
     for (const slot of this.orderedSlots) {
       const record = this.slots[slot];
       if (record !== undefined) snapshots.push(record.snapshot);
     }
-    this.materialized = Object.freeze(snapshots);
+    this.materialized = snapshots;
     return this.materialized;
   }
 
@@ -513,6 +610,15 @@ export class RenderScene {
     }
     for (const update of capture.slots) {
       this.lastSubmittedSlots[update.slot] = update.current;
+      const currentWorld = update.current?.snapshot.transform.world;
+      if (currentWorld !== undefined) {
+        let previousWorld = this.previousWorldBySlot[update.slot];
+        if (previousWorld === undefined) {
+          previousWorld = new Float32Array(16);
+          this.previousWorldBySlot[update.slot] = previousWorld;
+        }
+        previousWorld.set(currentWorld);
+      }
       this.dirtySinceSubmitted.delete(update.slot);
     }
     this.lastSubmittedVisible = new Set(capture.visible);
@@ -575,8 +681,7 @@ export class RenderScene {
     for (const slot of this.orderedSlots) {
       const record = this.slots[slot];
       if (record === undefined) continue;
-      const snapshot = record.snapshot;
-      const candidate = this.cullingWorldBounds(snapshot);
+      const candidate = this.cullingWorldBoundsAt(record);
       if (candidate === null || candidate === undefined) continue;
       if (intersects(candidate, bounds)) records.push(record);
     }
@@ -634,8 +739,15 @@ export class RenderScene {
       entityKey: snapshot.entityKey,
       snapshot: ownSnapshot(snapshot),
     };
+    let previousWorld = this.previousWorldBySlot[slot];
+    if (previousWorld === undefined) {
+      previousWorld = new Float32Array(16);
+      this.previousWorldBySlot[slot] = previousWorld;
+    }
+    previousWorld.set(record.snapshot.transform.world);
     this.generations[slot] = generation;
     this.slots[slot] = record;
+    this.worldBoundsBySlot[slot] = undefined;
     let entities = this.slotsByWorld.get(snapshot.worldId);
     if (entities === undefined) {
       entities = new Map<number, number>();
@@ -649,6 +761,7 @@ export class RenderScene {
 
   private release(record: RenderSceneSlot): void {
     this.slots[record.slot] = undefined;
+    this.worldBoundsBySlot[record.slot] = undefined;
     this.instanceBoundsCache.invalidate(record.entityKey, record.worldId);
     this.unindexMaterials(record);
     const entities = this.slotsByWorld.get(record.worldId);
@@ -711,12 +824,16 @@ export class RenderScene {
       reasons.includes('geometry-revision') ||
       reasons.includes('material-revision');
     const previous = seedCurrent || submitted === undefined ? slot.snapshot : submitted.snapshot;
+    const previousWorld = this.previousWorldBySlot[slot.slot];
     return {
       previousEpoch: seedCurrent ? undefined : this.submittedEpoch,
       previousSource: seedCurrent ? 'current-seed' : 'last-submitted',
       reactive: reasons.length > 0,
       reactiveReasons: reasons,
-      previousTransform: previous.transform,
+      previousTransform:
+        seedCurrent || previousWorld === undefined
+          ? previous.transform
+          : { ...previous.transform, world: previousWorld },
       previousInstances: previous.instances,
       previousSkin: previous.skin,
       previousMorphWeights: previous.morph?.weights,
@@ -734,15 +851,14 @@ export class RenderScene {
    * bounds for its independent per-instance visibility pass. Unknown or
    * empty instance facts deliberately return undefined (conservative no-cull).
    */
-  cullingWorldBounds(snapshot: RenderableSnapshot): RenderSceneBounds | undefined {
-    let candidate = this.worldBoundsCache.get(snapshot);
-    if (candidate !== undefined || this.worldBoundsCache.has(snapshot)) {
-      return candidate ?? undefined;
-    }
+  cullingWorldBoundsAt(slot: RenderSceneSlot): RenderSceneBounds | undefined {
+    let candidate = this.worldBoundsBySlot[slot.slot];
+    if (candidate !== undefined) return candidate ?? undefined;
+    const snapshot = slot.snapshot;
     if (snapshot.instances !== undefined) {
       const instanceCount = snapshot.instances.instanceCount;
       if (instanceCount === 0 || snapshot.localAabb === undefined) {
-        this.worldBoundsCache.set(snapshot, null);
+        this.worldBoundsBySlot[slot.slot] = null;
         return undefined;
       }
       const derived = this.instanceBoundsCache.get({
@@ -757,28 +873,92 @@ export class RenderScene {
       });
       candidate = boundsFromArray(derived ?? []);
     } else {
-      candidate = worldBounds(snapshot);
+      candidate = worldBounds(snapshot, candidate ?? undefined);
     }
-    this.worldBoundsCache.set(snapshot, candidate ?? null);
+    this.worldBoundsBySlot[slot.slot] = candidate ?? null;
     return candidate;
   }
-}
 
-function readTransformWorld(world: World, entity: EntityHandle): Float32Array | undefined {
-  const transform = world.get(entity, Transform);
-  return transform.ok ? new Float32Array(transform.value.world) : undefined;
+  cullingWorldBounds(snapshot: RenderableSnapshot): RenderSceneBounds | undefined {
+    const slot = this.lookup(snapshot.worldId, snapshot.entityKey);
+    return slot === undefined ? worldBounds(snapshot) : this.cullingWorldBoundsAt(slot);
+  }
 }
 
 export interface PersistentRenderSceneOptions {
   readonly getDevice?: (() => RhiDevice) | undefined;
   readonly onGpuError?: ((error: RhiError) => void) | undefined;
   readonly onSharedRefMutation?: ((worldId: number, handle: number) => void) | undefined;
+  readonly configuredQueryBudget?: number | undefined;
 }
 
 export interface PersistentGpuDrivenState {
   readonly scene: GpuScene;
   readonly plan: SubmissionPlan;
   readonly slots: readonly RenderSceneSlot[];
+  /** Stable renderer-local World keys aligned with RenderSceneSlot.worldId. */
+  readonly worldKeys?: readonly number[];
+}
+
+export interface CpuDirectViewInput {
+  readonly view: ViewKey;
+  readonly primitives: readonly PrimitiveKey[];
+}
+
+export interface CpuDirectCandidate {
+  readonly view: ViewKey;
+  readonly primitive: PrimitiveKey;
+  readonly candidate: VisibilityCandidate;
+}
+
+/**
+ * The one renderer-owned submission projection for a display view.
+ *
+ * Occlusion completion updates the facet asynchronously, so extraction must
+ * retain every query candidate while record/prepare consume this projection.
+ * Keeping the dispatch reindex here prevents CPU direct and GPU indirect
+ * lanes from rebuilding a second visibility map with different identity
+ * semantics.
+ */
+export interface PersistentVisibilityProjection {
+  readonly renderables: readonly RenderableSnapshot[];
+  readonly dispatch: readonly DispatchEntry[];
+  readonly activeEntityKeys: ReadonlySet<number>;
+  /** Monotonic owner revision for exactly this active-key projection. */
+  readonly activeEntityRevision: number;
+  readonly suppressed: number;
+}
+
+/** Project one selected candidate per view and primitive from the facet owner. */
+export function projectCpuDirectCandidates(
+  facets: VisibilityFacetStore,
+  views: readonly CpuDirectViewInput[],
+): readonly CpuDirectCandidate[] {
+  const candidates: CpuDirectCandidate[] = [];
+  for (const { view, primitives } of views) {
+    for (const primitive of primitives) {
+      const candidate = facets.getCandidate(view, primitive);
+      if (candidate !== undefined) candidates.push({ view, primitive, candidate });
+    }
+  }
+  return candidates;
+}
+
+/** Detached GPU scene prepared from the retained CPU composition. */
+export interface PersistentGpuDrivenCandidate {
+  readonly state: PersistentGpuDrivenState | undefined;
+  /** Candidate-owned scene root; never references the active GPU scene. */
+  createRecoveryRoot(scope: DeviceScope): LifecycleResourceSpec<unknown>;
+  publish(): void;
+  discard(): void;
+  /** Release the candidate scene even after it has crossed publication. */
+  release(): void;
+}
+
+export interface RenderSceneRecoveryRoot {
+  readonly generation: number;
+  readonly revision: number;
+  readonly visibleSlots: number;
 }
 
 type PersistentGpuSceneInspection = PersistentRenderSceneInspection['gpu'];
@@ -791,16 +971,29 @@ interface PersistentCompositionEntry {
   readonly projection: RenderScene;
   readonly topology: BatchTopology;
   readonly transmissionDemand: PersistentTransmissionDemandProjection;
-  readonly readCursors: number[];
+  readonly structure: Pick<
+    ExtractedFrame,
+    | 'dispatch'
+    | 'visibilityStats'
+    | 'visibilitySnapshots'
+    | 'featureVisibilitySnapshots'
+    | 'hiddenEntityReports'
+  >;
+  /** Stable renderer-local World keys; unlike RenderableSnapshot.worldId they survive reorder. */
+  readonly worldKeys: readonly number[];
+  readonly readVersions: RenderReadVersion[];
   readonly leaseIdentities: readonly string[];
+  readonly transformQueries: readonly GlobalTransformChangeQuery[];
   catalogEpoch: number;
   readonly rigidOnly: boolean;
-  gpuDrivenCoverageKey: string | undefined;
-  gpuDrivenOwnsAll: boolean;
+  readonly probeProjection: ProbeBlendSceneProjection;
+  temporalDemanded: boolean;
+  gpuDrivenSceneRequired: boolean;
 }
 
 const RENDER_RELEVANT_COMPONENT_IDS = new Set([
   componentId(Transform),
+  componentId(GlobalTransform),
   componentId(ChildOf),
   componentId(MeshFilter),
   componentId(MeshRenderer),
@@ -811,7 +1004,9 @@ const RENDER_RELEVANT_COMPONENT_IDS = new Set([
   componentId(Layer),
   componentId(Visibility),
   componentId(Camera),
+  componentId(MotionBlur),
   componentId(DirectionalLight),
+  componentId(LightProbe),
   componentId(PointLight),
   componentId(PointLightShadow),
   componentId(SpotLight),
@@ -822,12 +1017,20 @@ const RENDER_RELEVANT_COMPONENT_IDS = new Set([
   componentId(VolumetricFog),
 ]);
 
-const NON_RENDERABLE_TRANSFORM_CONSUMERS = [
-  Camera,
-  DirectionalLight,
-  PointLight,
-  SpotLight,
-] as const;
+function createGlobalTransformChangeQuery(world: World): GlobalTransformChangeQuery {
+  const result = world.query({ read: [GlobalTransform], changed: [GlobalTransform] });
+  if (!result.ok) throw result.error;
+  const query = result.value as GlobalTransformChangeQuery;
+  for (const _span of query.spans().unwrap()) {
+    // The full rebuild consumed these values; establish the observation baseline.
+  }
+  return query;
+}
+
+function frameDemandsTemporal(frame: ExtractedFrame): boolean {
+  const camera = frame.cameras[0];
+  return camera?.antialias === 'taa' || (camera?.motionBlur?.shutterAngle ?? 0) > 0;
+}
 
 function cameraFrusta(cameras: readonly CameraSnapshot[]): readonly Float32Array[] {
   const planes: Float32Array[] = [];
@@ -845,8 +1048,8 @@ function cameraFrusta(cameras: readonly CameraSnapshot[]): readonly Float32Array
         projection,
         camera.orthoLeft,
         camera.orthoRight,
-        camera.orthoBottom,
         camera.orthoTop,
+        camera.orthoBottom,
         camera.near,
         camera.far,
       );
@@ -864,15 +1067,23 @@ function cameraFrusta(cameras: readonly CameraSnapshot[]): readonly Float32Array
   return planes;
 }
 
+let cullProjectedIndexScratch = new Int32Array(0);
+
 function cullPersistentFrame(
   frame: ExtractedFrame,
   candidates: readonly RenderableSnapshot[],
-  boundsOf: (snapshot: RenderableSnapshot) => RenderSceneBounds | undefined = worldBounds,
+  boundsOf: (snapshot: RenderableSnapshot, index: number) => RenderSceneBounds | undefined = (
+    snapshot,
+  ) => worldBounds(snapshot),
 ): ExtractedFrame {
   const planes = cameraFrusta(frame.cameras);
   const visible: RenderableSnapshot[] = [];
-  const projectedIndex = new Int32Array(candidates.length);
-  projectedIndex.fill(-1);
+  if (cullProjectedIndexScratch.length < candidates.length) {
+    cullProjectedIndexScratch = new Int32Array(candidates.length);
+  }
+  const projectedIndex = cullProjectedIndexScratch;
+  projectedIndex.fill(-1, 0, candidates.length);
+  const worldAabb = box3.create();
   let total = 0;
   let culled = 0;
 
@@ -880,10 +1091,9 @@ function cullPersistentFrame(
     const candidate = candidates[index];
     if (candidate === undefined) continue;
     let isVisible = true;
-    const candidateBounds = boundsOf(candidate);
+    const candidateBounds = boundsOf(candidate, index);
     if (candidateBounds !== undefined) {
       total += 1;
-      const worldAabb = box3.create();
       worldAabb[0] = candidateBounds.min[0] ?? 0;
       worldAabb[1] = candidateBounds.min[1] ?? 0;
       worldAabb[2] = candidateBounds.min[2] ?? 0;
@@ -906,7 +1116,12 @@ function cullPersistentFrame(
       continue;
     }
     projectedIndex[index] = visible.length;
-    visible.push(candidate);
+    // The culling candidate is the persistent projection snapshot used for
+    // bounds, while `frame.renderables[index]` may carry frame-owned
+    // attachments (for example the probe blend record). Preserve that
+    // attached renderable in the output; pushing the bare candidate here
+    // silently drops the object-level Probe ABI before record selection.
+    visible.push(frame.renderables[index] ?? candidate);
   }
 
   const dispatch: DispatchEntry[] = [];
@@ -924,8 +1139,33 @@ function cullPersistentFrame(
   };
 }
 
+function attachProbeRecords(
+  frame: ExtractedFrame,
+  candidates: RenderableSnapshot[],
+  slots: readonly RenderSceneSlot[],
+  projection: ProbeBlendSceneProjection,
+): ExtractedFrame {
+  if (!projection.hasRecords()) {
+    return frame.renderables === candidates ? frame : { ...frame, renderables: candidates };
+  }
+  const objectKeys = new Map<string, number>();
+  for (const slot of slots)
+    objectKeys.set(identityKey(slot.worldId, slot.snapshot.entityKey), slot.slot);
+  const renderables = candidates.map((candidate) => {
+    const slot = objectKeys.get(identityKey(candidate.worldId, candidate.entityKey));
+    const record = slot === undefined ? undefined : projection.getRecord(slot);
+    return record === undefined ? candidate : { ...candidate, probeBlendRecord: record };
+  });
+  return { ...frame, renderables };
+}
+
 /** Persistent scene projection used by the renderer's multi-World composition path. */
 export class PersistentRenderScene {
+  private readonly visibilityBudget: VisibilityBudget;
+  private readonly visibilityFacets: VisibilityFacetStore;
+  /** World identity is the author/runtime identity; array position is only a frame routing detail. */
+  private readonly visibilityWorldKeys = new Map<string, number>();
+  private nextVisibilityWorldKey = 0;
   private readonly materialSnapshotCaches: MaterialSnapshotCachesByWorld = new WeakMap();
   private fullRebuilds = 0;
   private worldEntitiesScanned = 0;
@@ -942,28 +1182,300 @@ export class PersistentRenderScene {
   private temporalCapture:
     | { readonly projection: RenderScene; readonly capture: RenderSceneSubmissionCapture }
     | undefined;
+  /** Monotonic token for camera/dynamic frame facts consumed by visibility caches. */
+  private frameEpoch = 0;
+  private visibilityFacetFrame:
+    | {
+        readonly frameEpoch: number;
+        readonly viewId: string;
+        readonly renderables: readonly RenderableSnapshot[];
+      }
+    | undefined;
+  private visibilityProjectionCache:
+    | {
+        readonly frameEpoch: number;
+        readonly drawRevision: number;
+        readonly viewId: string;
+        readonly renderables: readonly RenderableSnapshot[];
+        readonly dispatch: readonly DispatchEntry[];
+        readonly projection: PersistentVisibilityProjection;
+      }
+    | undefined;
+  private visibilityProjectionRevision = 0;
+  private lastActiveEntityKeys: ReadonlySet<number> | undefined;
+  /** Stable renderer-world/entity lookup; rebuilt only with composition topology. */
+  private readonly stableSlotByEntity = new Map<number, RenderSceneSlot>();
   private pointsLinesInspections: readonly PointsLinesInspection[] = [];
   private readonly reflectionProbes = new ReflectionProbeProjection();
 
-  constructor(private readonly options: PersistentRenderSceneOptions = {}) {}
+  constructor(private readonly options: PersistentRenderSceneOptions = {}) {
+    this.visibilityBudget = createVisibilityBudget(options.configuredQueryBudget);
+    this.visibilityFacets = new VisibilityFacetStore(this.visibilityBudget);
+  }
 
   /** RenderScene owns the per-World material fact cache used during extraction. */
   materialSnapshotCacheStore(): MaterialSnapshotCachesByWorld {
     return this.materialSnapshotCaches;
   }
 
+  /** The sole renderer-owned ViewKey x PrimitiveKey visibility state. */
+  visibilityFacetStore(): VisibilityFacetStore {
+    return this.visibilityFacets;
+  }
+
+  visibilityBudgetValue(): VisibilityBudget {
+    return this.visibilityBudget;
+  }
+
+  private visibilityWorldKey(world: World | undefined, fallback: number): number {
+    if (world === undefined) return fallback;
+    const existing = this.visibilityWorldKeys.get(world.identity);
+    if (existing !== undefined) return existing;
+    const key = this.nextVisibilityWorldKey;
+    this.nextVisibilityWorldKey += 1;
+    this.visibilityWorldKeys.set(world.identity, key);
+    return key;
+  }
+
+  private worldKeyAt(worlds: readonly World[], worldId: number): number {
+    return this.visibilityWorldKey(worlds[worldId], worldId);
+  }
+
+  /** Stable World routing keys for the current worlds[] frame projection. */
+  visibilityWorldKeysFor(worlds: readonly World[]): readonly number[] {
+    return worlds.map((world, worldId) => this.visibilityWorldKey(world, worldId));
+  }
+
+  /** Current retained slots, available to CPU query transport as well as GPU. */
+  compositionSlots(): readonly RenderSceneSlot[] {
+    return this.composition?.projection.slotsSnapshot() ?? [];
+  }
+
+  /** Stable renderer-world/entity lookup shared by query and final projection paths. */
+  compositionSlotByStableEntity(): ReadonlyMap<number, RenderSceneSlot> {
+    return this.stableSlotByEntity;
+  }
+
+  private stableEntityKey(
+    worlds: readonly World[],
+    renderable: Pick<RenderableSnapshot, 'worldId' | 'entityKey'>,
+  ): number {
+    return worldEntityKey(this.worldKeyAt(worlds, renderable.worldId), renderable.entityKey);
+  }
+
+  /** Feed the facet from extracted renderables using persistent slot identity. */
+  updateVisibilityFacet(
+    worlds: readonly World[],
+    camera: CameraSnapshot | undefined,
+    renderables: readonly RenderableSnapshot[],
+  ): void {
+    const world = worlds[camera?.worldId ?? 0];
+    if (world === undefined || camera === undefined) return;
+    const view = viewKey({
+      attachmentId: world.identity,
+      cameraEntity: camera.entityKey ?? 0,
+      viewRole: 'main',
+      viewGeneration: camera.historyVersion ?? 0,
+    });
+    const viewId = viewKeyId(view);
+    const previous = this.visibilityFacetFrame;
+    if (
+      previous?.frameEpoch === this.frameEpoch &&
+      previous.viewId === viewId &&
+      previous.renderables === renderables
+    ) {
+      return;
+    }
+    this.visibilityFacets.activateView(view);
+    const activePrimitiveIds = new Set<string>();
+    for (const renderable of renderables) {
+      const bounds = renderable.localAabb;
+      if (
+        renderable.lods === undefined ||
+        renderable.lods.length === 0 ||
+        bounds === undefined ||
+        bounds.length < 6 ||
+        [...bounds].some((value) => !Number.isFinite(value))
+      ) {
+        continue;
+      }
+      const slot = this.stableSlotByEntity.get(this.stableEntityKey(worlds, renderable));
+      if (slot === undefined) continue;
+      const primitive = primitiveKey({
+        attachmentId: world.identity,
+        worldGeneration: this.worldKeyAt(worlds, renderable.worldId),
+        primitiveSlot: slot.slot,
+        slotGeneration: slot.generation,
+      });
+      activePrimitiveIds.add(primitiveKeyId(primitive));
+      this.visibilityFacets.setCandidate(view, primitive, { level: 0, confidence: 1 });
+    }
+    this.visibilityFacets.pruneCandidates(view, activePrimitiveIds);
+    this.visibilityFacetFrame = { frameEpoch: this.frameEpoch, viewId, renderables };
+  }
+
+  /**
+   * Project the current facet into the final primary-raster submission.
+   *
+   * Only renderables carrying authored lower-detail levels are queryable. A
+   * plain mesh therefore remains on the ordinary visibility path, while an
+   * LOD candidate with two accepted zero-sample results is suppressed until
+   * the confidence scheduler requests its bounded re-test. Unknown identity,
+   * invalid bounds, and non-queryable confidence all remain conservatively
+   * visible through `decideVisibility`.
+   */
+  projectVisibility(
+    worlds: readonly World[],
+    camera: CameraSnapshot | undefined,
+    renderables: readonly RenderableSnapshot[],
+    dispatch: readonly DispatchEntry[],
+  ): PersistentVisibilityProjection {
+    if (camera === undefined) {
+      const activeEntityKeys = new Set(
+        renderables.map((renderable) => this.stableEntityKey(worlds, renderable)),
+      );
+      return {
+        renderables,
+        dispatch,
+        activeEntityKeys,
+        activeEntityRevision: this.activeEntityRevision(activeEntityKeys),
+        suppressed: 0,
+      };
+    }
+    const cameraWorld = worlds[camera.worldId ?? 0];
+    if (cameraWorld === undefined) {
+      const activeEntityKeys = new Set(
+        renderables.map((renderable) => this.stableEntityKey(worlds, renderable)),
+      );
+      return {
+        renderables,
+        dispatch,
+        activeEntityKeys,
+        activeEntityRevision: this.activeEntityRevision(activeEntityKeys),
+        suppressed: 0,
+      };
+    }
+    const view = viewKey({
+      attachmentId: cameraWorld.identity,
+      cameraEntity: camera.entityKey ?? 0,
+      viewRole: 'main',
+      viewGeneration: camera.historyVersion ?? 0,
+    });
+    const viewId = viewKeyId(view);
+    const cached = this.visibilityProjectionCache;
+    if (
+      cached?.frameEpoch === this.frameEpoch &&
+      cached.drawRevision === this.visibilityFacets.drawRevisionValue &&
+      cached.viewId === viewId &&
+      cached.renderables === renderables &&
+      cached.dispatch === dispatch
+    ) {
+      return cached.projection;
+    }
+    const projectedIndex = new Int32Array(renderables.length);
+    projectedIndex.fill(-1);
+    const projected: RenderableSnapshot[] = [];
+    const activeEntityKeys = new Set<number>();
+    let suppressed = 0;
+    for (let index = 0; index < renderables.length; index += 1) {
+      const renderable = renderables[index];
+      if (renderable === undefined) continue;
+      const slot = this.stableSlotByEntity.get(this.stableEntityKey(worlds, renderable));
+      let draw = true;
+      if (slot !== undefined && (renderable.lods?.length ?? 0) > 0) {
+        const primitive = primitiveKey({
+          attachmentId: cameraWorld.identity,
+          worldGeneration: this.worldKeyAt(worlds, renderable.worldId),
+          primitiveSlot: slot.slot,
+          slotGeneration: slot.generation,
+        });
+        const bounds = renderable.localAabb;
+        const validBounds =
+          bounds !== undefined &&
+          bounds.length >= 6 &&
+          [...bounds].every((value) => Number.isFinite(value));
+        draw = decideVisibility({
+          authorVisible: true,
+          validBounds,
+          frustumVisible: true,
+          lodReady: true,
+          occlusion: this.visibilityFacets.getConfidence(view, primitive),
+          lane: 'gpu',
+        }).draw;
+      }
+      if (!draw) {
+        suppressed += 1;
+        continue;
+      }
+      projectedIndex[index] = projected.length;
+      projected.push(renderable);
+      activeEntityKeys.add(this.stableEntityKey(worlds, renderable));
+    }
+    const projectedDispatch: DispatchEntry[] = [];
+    for (const entry of dispatch) {
+      const renderableIndex = projectedIndex[entry.renderableIndex];
+      if (renderableIndex === undefined || renderableIndex < 0) continue;
+      projectedDispatch.push({ ...entry, renderableIndex });
+    }
+    const projection = {
+      renderables: Object.freeze(projected),
+      dispatch: Object.freeze(projectedDispatch),
+      activeEntityKeys,
+      activeEntityRevision: this.activeEntityRevision(activeEntityKeys),
+      suppressed,
+    };
+    this.visibilityProjectionCache = {
+      frameEpoch: this.frameEpoch,
+      drawRevision: this.visibilityFacets.drawRevisionValue,
+      viewId,
+      renderables,
+      dispatch,
+      projection,
+    };
+    return projection;
+  }
+
+  /**
+   * Advance the projection revision only when the active stable-entity set
+   * changes. Camera fingerprints and scene-plan identity cover view/topology
+   * changes; keeping this token set-stable preserves the GPU filtered-plan
+   * cache on ordinary no-change frames.
+   */
+  private activeEntityRevision(activeEntityKeys: ReadonlySet<number>): number {
+    const previous = this.lastActiveEntityKeys;
+    if (
+      previous === undefined ||
+      previous.size !== activeEntityKeys.size ||
+      [...previous].some((key) => !activeEntityKeys.has(key))
+    ) {
+      this.lastActiveEntityKeys = new Set(activeEntityKeys);
+      this.visibilityProjectionRevision += 1;
+    }
+    return this.visibilityProjectionRevision;
+  }
+
+  private invalidateActiveEntityRevision(): void {
+    this.lastActiveEntityKeys = undefined;
+    this.visibilityProjectionRevision += 1;
+  }
+
   /** Project probe facts and per-primitive selection into the persistent scene owner. */
   projectReflectionProbes(probes: readonly ReflectionProbeFact[]): void {
     const projection = this.composition?.projection;
     if (projection === undefined) return;
+    if (probes.length === 0) {
+      this.reflectionProbes.update([], []);
+      return;
+    }
     const primitives = projection
       .slotsSnapshot()
       .map((slot) => {
-        const resolved = worldBounds(slot.snapshot);
+        const resolved = projection.cullingWorldBoundsAt(slot);
         if (resolved === undefined || resolved === null) return undefined;
         return {
           worldId: slot.worldId,
           entityKey: slot.entityKey,
+          renderableKey: `${slot.worldId}:${slot.entityKey}`,
           center: [
             (resolved.min[0] + resolved.max[0]) / 2,
             (resolved.min[1] + resolved.max[1]) / 2,
@@ -987,11 +1499,32 @@ export class PersistentRenderScene {
     worlds: readonly World[],
     owner: { readonly cameraOwner: number; readonly resourceOwner: number },
     catalogEpoch: number,
-    buildCandidateFrame: () => ExtractedFrame,
+    buildCandidateFrame: (renderables: 'full' | 'none') => ExtractedFrame,
     leases?: readonly RenderReadLease[],
   ): ExtractedFrame {
     this.worldEntitiesScanned = 0;
     const entry = this.composition;
+    const sameWorldSet =
+      entry !== undefined &&
+      entry.worlds.length === worlds.length &&
+      entry.worlds.every((world) => worlds.includes(world));
+    const worldOrderChanged =
+      entry !== undefined &&
+      sameWorldSet &&
+      entry.worlds.some((world, index) => world !== worlds[index]);
+    const leaseSetPreserved =
+      entry !== undefined &&
+      leases !== undefined &&
+      leases.length === worlds.length &&
+      entry.leaseIdentities.length === leases.length &&
+      entry.leaseIdentities.every((identity) =>
+        leases.some((lease) => lease.worldIdentity === identity),
+      );
+    const preserveVisibilityOnReorder =
+      entry !== undefined &&
+      worldOrderChanged &&
+      entry.catalogEpoch === catalogEpoch &&
+      leaseSetPreserved;
     if (
       entry === undefined ||
       entry.catalogEpoch !== catalogEpoch ||
@@ -1002,13 +1535,19 @@ export class PersistentRenderScene {
       leases === undefined ||
       leases.length !== worlds.length
     ) {
-      return this.rebuildComposition(worlds, owner, catalogEpoch, buildCandidateFrame, leases);
+      return this.rebuildComposition(
+        worlds,
+        owner,
+        catalogEpoch,
+        buildCandidateFrame,
+        leases,
+        preserveVisibilityOnReorder,
+      );
     }
     if (!entry.rigidOnly) {
       return this.rebuildComposition(worlds, owner, catalogEpoch, buildCandidateFrame, leases);
     }
 
-    const operations: RenderSceneOperation[] = [];
     let requiresRebuild = false;
     for (let worldId = 0; worldId < worlds.length; worldId += 1) {
       const world = worlds[worldId];
@@ -1018,14 +1557,19 @@ export class PersistentRenderScene {
         requiresRebuild = true;
         break;
       }
+      const version = entry.readVersions[worldId];
+      if (version === undefined) {
+        requiresRebuild = true;
+        break;
+      }
       let read: ReturnType<RenderReadLease['readChanges']>;
       try {
-        read = lease.readChanges(entry.readCursors[worldId] ?? 0);
+        read = lease.readChanges(version);
       } catch {
         requiresRebuild = true;
         break;
       }
-      if (read.status === 'overflow') {
+      if (read.status !== 'ok') {
         requiresRebuild = true;
         break;
       }
@@ -1038,119 +1582,86 @@ export class PersistentRenderScene {
         requiresRebuild = true;
         break;
       }
-      const derivedTransforms = new Set<EntityHandle>();
-      for (const record of changes.records) {
+      for (const changedComponentId of changes.changedComponentIds) {
+        if (!RENDER_RELEVANT_COMPONENT_IDS.has(changedComponentId)) continue;
         if (
-          record.kind === 'derived-component-changed' &&
-          record.componentId === componentId(Transform)
+          changedComponentId !== componentId(Transform) &&
+          changedComponentId !== componentId(GlobalTransform)
         ) {
-          derivedTransforms.add(record.entity as EntityHandle);
-        }
-      }
-      for (const record of changes.records) {
-        if (
-          record.kind !== 'entity-removed' &&
-          record.componentId !== undefined &&
-          !RENDER_RELEVANT_COMPONENT_IDS.has(record.componentId)
-        ) {
-          continue;
-        }
-        const authoredTransform =
-          record.kind === 'component-changed' && record.componentId === componentId(Transform);
-        const derivedTransform =
-          record.kind === 'derived-component-changed' &&
-          record.componentId === componentId(Transform);
-        if (derivedTransform) continue;
-        if (authoredTransform && derivedTransforms.has(record.entity as EntityHandle)) continue;
-        if (
-          (authoredTransform || record.componentId === componentId(Transform)) &&
-          entry.projection.has(worldId, record.entity)
-        ) {
-          const worldView = readTransformWorld(world, record.entity as EntityHandle);
-          if (worldView === undefined) {
-            requiresRebuild = true;
-            break;
-          }
-          operations.push({
-            kind: 'update-transform',
-            worldId,
-            entityKey: record.entity,
-            world: new Float32Array(worldView),
-          });
-          continue;
+          requiresRebuild = true;
+          break;
         }
-        requiresRebuild = true;
-        break;
       }
-      if (!requiresRebuild) {
-        for (const entity of derivedTransforms) {
-          if (entry.projection.has(worldId, entity)) {
-            const worldView = readTransformWorld(world, entity);
-            if (worldView === undefined) {
-              requiresRebuild = true;
-              break;
-            }
-            operations.push({
-              kind: 'update-transform',
-              worldId,
-              entityKey: entity,
-              world: new Float32Array(worldView),
-            });
-            continue;
-          }
-          // Camera snapshots are rebuilt from the current candidate frame and
-          // drive culling there; moving a camera must not invalidate the
-          // retained scene projection or recreate its GPU tables.
-          if (
-            !world.hasComponent(entity, Camera) &&
-            NON_RENDERABLE_TRANSFORM_CONSUMERS.some((component) =>
-              world.hasComponent(entity, component),
-            )
-          ) {
-            requiresRebuild = true;
-            break;
-          }
+      if (requiresRebuild) break;
+      entry.readVersions[worldId] = read.version;
+    }
+    if (requiresRebuild) {
+      return this.rebuildComposition(worlds, owner, catalogEpoch, buildCandidateFrame, leases);
+    }
+    const transformSpans: WorldTransformSpan[] = [];
+    for (let worldId = 0; worldId < entry.transformQueries.length; worldId += 1) {
+      const query = entry.transformQueries[worldId];
+      if (query === undefined) continue;
+      for (const span of query.spans().unwrap()) {
+        const changedWorlds = span.get(GlobalTransform).world;
+        if (!(changedWorlds instanceof Float32Array)) {
+          requiresRebuild = true;
+          break;
         }
+        transformSpans.push({ worldId, entities: span.entities, worlds: changedWorlds });
       }
       if (requiresRebuild) break;
-      entry.readCursors[worldId] = read.cursor;
     }
     if (requiresRebuild) {
       return this.rebuildComposition(worlds, owner, catalogEpoch, buildCandidateFrame, leases);
     }
-    if (operations.length === 0) {
+    if (transformSpans.length === 0) {
       this.noChangeFrames += 1;
       this.syncGpuOwner(entry.token, entry.projection);
       return this.deriveFramePlan(entry, buildCandidateFrame);
     }
-    const delta = entry.projection.apply(operations);
+    const delta = entry.projection.applyTransformSpans(transformSpans);
     entry.topology.apply(delta);
     this.syncGpuOwner(entry.token, entry.projection, delta);
     this.deltaFrames += 1;
-    this.transformUpdates += operations.length;
+    this.transformUpdates += delta.updated;
     return this.deriveFramePlan(entry, buildCandidateFrame);
   }
 
   invalidate(): void {
     this.composition = undefined;
     this.temporalCapture = undefined;
+    this.visibilityFacets.clear();
+    this.invalidateActiveEntityRevision();
+    this.visibilityFacetFrame = undefined;
+    this.visibilityProjectionCache = undefined;
+    this.stableSlotByEntity.clear();
     this.lastResyncReason = 'explicit-invalidate';
   }
 
-  setCompositionGpuDrivenCoverage(key: string, ownsAll: boolean): void {
+  setCompositionGpuSceneDemand(sceneRowsRequired: boolean): void {
     const entry = this.composition;
     if (entry === undefined) return;
-    entry.gpuDrivenCoverageKey = key;
-    entry.gpuDrivenOwnsAll = ownsAll;
+    entry.gpuDrivenSceneRequired = sceneRowsRequired;
   }
 
   detach(world: World): void {
+    this.visibilityFacets.detachAttachment(world.identity);
     this.materialSnapshotCaches.delete(world);
     const detachedComposition = this.composition?.worlds.includes(world)
       ? this.composition
       : undefined;
     if (detachedComposition !== undefined) this.composition = undefined;
     if (detachedComposition !== undefined) this.temporalCapture = undefined;
+    if (detachedComposition !== undefined) {
+      this.visibilityFacets.clear();
+      this.invalidateActiveEntityRevision();
+    }
+    if (detachedComposition !== undefined) {
+      this.visibilityFacetFrame = undefined;
+      this.visibilityProjectionCache = undefined;
+      this.stableSlotByEntity.clear();
+    }
     if (this.gpuOwner !== world && this.gpuOwner !== detachedComposition?.token) return;
     this.gpuScene?.dispose();
     this.gpuScene = undefined;
@@ -1161,13 +1672,118 @@ export class PersistentRenderScene {
 
   /** Drop only device-owned tables; the CPU projection remains the recovery authority. */
   resetGpuForRecover(): void {
-    if (this.composition !== undefined) this.composition.gpuDrivenOwnsAll = false;
+    if (this.composition !== undefined) this.composition.gpuDrivenSceneRequired = true;
     this.gpuScene = undefined;
     this.gpuOwner = undefined;
     this.gpuDevice = undefined;
     this.gpuStatus = this.options.getDevice === undefined ? 'inactive' : 'rebuild-pending';
   }
 
+  /** Prepare a detached GPU scene without changing the active scene owner. */
+  prepareRecoveryGpuDrivenCandidate(
+    device: RhiDevice,
+  ): Result<PersistentGpuDrivenCandidate, RhiError> {
+    const composition = this.composition;
+    if (composition === undefined) {
+      return ok({
+        state: undefined,
+        createRecoveryRoot: (scope) => ({
+          kind: 'scene-table',
+          create: () => {
+            if (!scope.isAlive()) throw new Error('GPU-driven candidate scope is not active.');
+            throw new Error('GPU-driven candidate has no scene resource.');
+          },
+          cleanup: () => undefined,
+        }),
+        publish: () => undefined,
+        discard: () => undefined,
+        release: () => undefined,
+      });
+    }
+    const created = GpuScene.create(
+      device,
+      Math.max(256, composition.projection.inspect().slotCapacity),
+    );
+    if (!created.ok) return created;
+    if (created.value.status === 'unavailable') {
+      return ok({
+        state: undefined,
+        createRecoveryRoot: (scope) => ({
+          kind: 'scene-table',
+          create: () => {
+            if (!scope.isAlive()) throw new Error('GPU-driven candidate scope is not active.');
+            throw new Error('GPU-driven candidate has no scene resource.');
+          },
+          cleanup: () => undefined,
+        }),
+        publish: () => undefined,
+        discard: () => undefined,
+        release: () => undefined,
+      });
+    }
+    const scene = created.value.scene;
+    const slots = composition.projection.slotsSnapshot();
+    const rebuilt = scene.rebuild(slots);
+    if (!rebuilt.ok) {
+      scene.dispose();
+      return rebuilt;
+    }
+    const state: PersistentGpuDrivenState = Object.freeze({
+      scene,
+      plan: composition.topology.plan(),
+      slots,
+    });
+    let published = false;
+    let released = false;
+    return ok({
+      state,
+      createRecoveryRoot: (scope) => ({
+        kind: 'scene-table',
+        create: () => {
+          if (!scope.isAlive()) throw new Error('GPU-driven candidate scope is not active.');
+          return scene;
+        },
+        cleanup: () => undefined,
+      }),
+      publish: () => {
+        if (published || released) return;
+        published = true;
+        this.gpuScene = scene;
+        this.gpuOwner = composition.token;
+        this.gpuDevice = device;
+        this.gpuStatus = 'resident';
+      },
+      discard: () => {
+        if (published || released) return;
+        released = true;
+        scene.dispose();
+      },
+      release: () => {
+        if (published || released) return;
+        released = true;
+        scene.dispose();
+      },
+    });
+  }
+
+  createRecoveryRoot(scope: DeviceScope): LifecycleResourceSpec<unknown> {
+    return {
+      kind: 'scene-table',
+      create: () => {
+        const composition = this.composition;
+        if (!scope.isAlive() || composition === undefined) {
+          throw new Error('RenderScene CPU projection is not ready for recovery.');
+        }
+        return Object.freeze({
+          generation: scope.generation,
+          revision: composition.projection.inspect().revision,
+          visibleSlots: composition.projection.slotsSnapshot().length,
+        });
+      },
+      cleanup: () => undefined,
+    };
+  }
+
   setPointsLinesInspections(inspections: readonly PointsLinesInspection[]): void {
     this.pointsLinesInspections = inspections.map((inspection) => ({
       ...inspection,
@@ -1184,6 +1800,11 @@ export class PersistentRenderScene {
     this.gpuStatus = 'inactive';
     this.composition = undefined;
     this.temporalCapture = undefined;
+    this.visibilityFacets.clear();
+    this.invalidateActiveEntityRevision();
+    this.visibilityFacetFrame = undefined;
+    this.visibilityProjectionCache = undefined;
+    this.stableSlotByEntity.clear();
     this.pointsLinesInspections = [];
   }
 
@@ -1198,6 +1819,7 @@ export class PersistentRenderScene {
       transformUpdates: this.transformUpdates,
       lastResyncReason: this.lastResyncReason,
       projectionRecords: entry?.projection.inspect().records.length ?? 0,
+      ...(entry === undefined ? {} : { probeBlend: entry.probeProjection.inspect() }),
       topology:
         entry?.topology.inspect() ??
         ({
@@ -1222,12 +1844,15 @@ export class PersistentRenderScene {
       scene: this.gpuScene,
       plan: entry.topology.plan(),
       slots: entry.projection.slotsSnapshot(),
+      worldKeys: entry.worldKeys,
     };
   }
 
   /** Publish renderer-owned previous transforms after queue submission. */
   commitTemporalFrame(): Result<void, RhiError> {
-    const gpuCommit = this.gpuScene?.commitTemporalFrame();
+    // Previous transforms are consumed only by TAA and motion blur. Ordinary
+    // frames must not copy and upload the complete GPU transform table.
+    const gpuCommit = this.gpuScene?.commitTemporalFrame(this.temporalCapture !== undefined);
     if (gpuCommit !== undefined && !gpuCommit.ok) return gpuCommit;
     const temporalCapture = this.temporalCapture;
     if (temporalCapture !== undefined) {
@@ -1279,19 +1904,76 @@ export class PersistentRenderScene {
     worlds: readonly World[],
     owner: { readonly cameraOwner: number; readonly resourceOwner: number },
     catalogEpoch: number,
-    buildCandidateFrame: () => ExtractedFrame,
+    buildCandidateFrame: (renderables: 'full' | 'none') => ExtractedFrame,
     leases?: readonly RenderReadLease[],
+    preserveVisibilityOnReorder = false,
   ): ExtractedFrame {
-    const candidateFrame = buildCandidateFrame();
+    const previousEntry = this.composition;
+    const candidateFrame = buildCandidateFrame('full');
     this.temporalCapture = undefined;
     this.worldEntitiesScanned = candidateFrame.renderables.length;
+    const worldKeys = this.visibilityWorldKeysFor(worlds);
+    if (!preserveVisibilityOnReorder) {
+      this.visibilityFacets.clear();
+      this.invalidateActiveEntityRevision();
+    } else if (previousEntry !== undefined) {
+      const previousKeys = new Set(
+        previousEntry.projection
+          .slotsSnapshot()
+          .map((slot) =>
+            worldEntityKey(previousEntry.worldKeys[slot.worldId] ?? slot.worldId, slot.entityKey),
+          ),
+      );
+      const currentKeys = new Set(
+        candidateFrame.renderables.map((renderable) =>
+          worldEntityKey(worldKeys[renderable.worldId] ?? renderable.worldId, renderable.entityKey),
+        ),
+      );
+      if (
+        previousKeys.size !== currentKeys.size ||
+        [...previousKeys].some((key) => !currentKeys.has(key))
+      ) {
+        this.visibilityFacets.clear();
+        this.invalidateActiveEntityRevision();
+      }
+    }
+    // Slot allocation is renderer-owned identity. Sort by stable World identity
+    // before allocating so a worlds[] reorder does not silently change a
+    // primitive's slot/generation. Dispatch is remapped below to the sorted
+    // renderable projection and remains frame-order independent.
+    const sorted = candidateFrame.renderables
+      .map((snapshot, sourceIndex) => ({ snapshot, sourceIndex }))
+      .sort((left, right) => {
+        const leftWorld = worldKeys[left.snapshot.worldId] ?? left.snapshot.worldId;
+        const rightWorld = worldKeys[right.snapshot.worldId] ?? right.snapshot.worldId;
+        return leftWorld - rightWorld || left.snapshot.entityKey - right.snapshot.entityKey;
+      });
+    const sortedRenderables = sorted.map(({ snapshot }) => snapshot);
+    const renderableIndex = new Int32Array(candidateFrame.renderables.length);
+    for (let index = 0; index < sorted.length; index += 1) {
+      const sourceIndex = sorted[index]?.sourceIndex;
+      if (sourceIndex !== undefined) renderableIndex[sourceIndex] = index;
+    }
+    const sortedDispatch = candidateFrame.dispatch.flatMap((entry) => {
+      const index = renderableIndex[entry.renderableIndex];
+      return index === undefined ? [] : [{ ...entry, renderableIndex: index }];
+    });
+    const stableCandidateFrame = {
+      ...candidateFrame,
+      renderables: sortedRenderables,
+      dispatch: sortedDispatch,
+    };
     const projection = new RenderScene();
-    projection.reset(candidateFrame.renderables);
+    projection.reset(sortedRenderables);
+    this.stableSlotByEntity.clear();
+    for (const slot of projection.slotsSnapshot()) {
+      const stableWorld = worldKeys[slot.worldId] ?? slot.worldId;
+      this.stableSlotByEntity.set(worldEntityKey(stableWorld, slot.entityKey), slot);
+    }
     const transmissionDemand = new PersistentTransmissionDemandProjection();
     transmissionDemand.apply(transmissionDemandOperations(candidateFrame.renderables));
     const topology = new BatchTopology();
     topology.rebuild(projection.slotsSnapshot());
-    this.projectReflectionProbes(candidateFrame.reflectionProbes ?? []);
     const token = {};
     const entry: PersistentCompositionEntry = {
       token,
@@ -1301,31 +1983,69 @@ export class PersistentRenderScene {
       projection,
       topology,
       transmissionDemand,
-      readCursors:
+      structure: {
+        dispatch: stableCandidateFrame.dispatch,
+        visibilityStats: stableCandidateFrame.visibilityStats,
+        visibilitySnapshots: stableCandidateFrame.visibilitySnapshots,
+        featureVisibilitySnapshots: stableCandidateFrame.featureVisibilitySnapshots,
+        hiddenEntityReports: stableCandidateFrame.hiddenEntityReports,
+      },
+      worldKeys,
+      readVersions:
         leases === undefined || leases.length !== worlds.length
           ? []
-          : leases.map((lease) => lease.inspectCursor()),
+          : leases.map((lease) => lease.captureVersion()),
       leaseIdentities:
         leases === undefined || leases.length !== worlds.length
           ? []
           : leases.map((lease) => lease.worldIdentity),
+      transformQueries:
+        leases === undefined || leases.length !== worlds.length
+          ? []
+          : worlds.map(createGlobalTransformChangeQuery),
       catalogEpoch,
       rigidOnly: candidateFrame.renderables.every((renderable) => renderable.skin === undefined),
-      gpuDrivenCoverageKey: undefined,
-      gpuDrivenOwnsAll: false,
+      probeProjection: new ProbeBlendSceneProjection(),
+      temporalDemanded: frameDemandsTemporal(candidateFrame),
+      gpuDrivenSceneRequired: true,
     };
     this.composition = entry;
+    projection.setTemporalTracking(entry.temporalDemanded);
+    // The projection must be installed before deriving probe primitives.  On
+    // the first composition rebuild `projectReflectionProbes` otherwise sees
+    // no composition and silently drops every per-renderable selection,
+    // leaving the producer on its neutral/no-demand path until an unrelated
+    // later rebuild.
+    this.projectReflectionProbes(candidateFrame.reflectionProbes ?? []);
+    this.projectProbes(entry, candidateFrame);
     this.syncGpuOwner(token, projection, undefined, true);
     this.fullRebuilds += 1;
     this.lastResyncReason = 'attach';
-    const candidates = projection
-      .materialize()
-      .map((snapshot) => projection.withTemporal(snapshot));
-    return cullPersistentFrame(
-      { ...candidateFrame, renderables: [...candidates] },
+    const materialized = projection.materialize();
+    const candidates = entry.temporalDemanded
+      ? materialized.map((snapshot) => projection.withTemporal(snapshot))
+      : materialized;
+    const frameWithProbes = attachProbeRecords(
+      { ...stableCandidateFrame, renderables: candidates },
       candidates,
-      (snapshot) => projection.cullingWorldBounds(snapshot),
+      projection.slotsSnapshot(),
+      entry.probeProjection,
+    );
+    const slots = projection.slotsSnapshot();
+    const result = cullPersistentFrame(
+      frameWithProbes,
+      frameWithProbes.renderables,
+      (snapshot, index) => {
+        const slot = slots[index];
+        return slot === undefined
+          ? projection.cullingWorldBounds(snapshot)
+          : projection.cullingWorldBoundsAt(slot);
+      },
     );
+    this.frameEpoch += 1;
+    this.visibilityFacetFrame = undefined;
+    this.visibilityProjectionCache = undefined;
+    return result;
   }
 
   /** Internal topology fact; the renderer does not expose demand as public API. */
@@ -1340,22 +2060,89 @@ export class PersistentRenderScene {
 
   /**
    * Derive an ephemeral frame plan from persistent scene facts. The scene
-   * retains identity/topology/cursors; no prior frame object is an authority.
+   * retains identity/topology/read versions; no prior frame object is an authority.
    */
   private deriveFramePlan(
     entry: PersistentCompositionEntry,
-    buildCandidateFrame: () => ExtractedFrame,
+    buildCandidateFrame: (renderables: 'full' | 'none') => ExtractedFrame,
   ): ExtractedFrame {
-    const candidateFrame = buildCandidateFrame();
+    const resourceFrame = buildCandidateFrame('none');
+    const candidateFrame: ExtractedFrame = { ...resourceFrame, ...entry.structure };
+    entry.temporalDemanded = frameDemandsTemporal(candidateFrame);
+    entry.projection.setTemporalTracking(entry.temporalDemanded);
+    this.projectProbes(entry, candidateFrame);
     this.projectReflectionProbes(candidateFrame.reflectionProbes ?? []);
-    const candidates = entry.projection
-      .materialize()
-      .map((snapshot) => entry.projection.withTemporal(snapshot));
-    return cullPersistentFrame(
-      { ...candidateFrame, renderables: [...candidates] },
+    const materialized = entry.projection.materialize();
+    const candidates = entry.temporalDemanded
+      ? materialized.map((snapshot) => entry.projection.withTemporal(snapshot))
+      : materialized;
+    const frameWithProbes = attachProbeRecords(
+      { ...candidateFrame, renderables: candidates },
       candidates,
-      (snapshot) => entry.projection.cullingWorldBounds(snapshot),
+      entry.projection.slotsSnapshot(),
+      entry.probeProjection,
     );
+    const slots = entry.projection.slotsSnapshot();
+    const result = cullPersistentFrame(
+      frameWithProbes,
+      frameWithProbes.renderables,
+      (snapshot, index) => {
+        const slot = slots[index];
+        return slot === undefined
+          ? entry.projection.cullingWorldBounds(snapshot)
+          : entry.projection.cullingWorldBoundsAt(slot);
+      },
+    );
+    this.frameEpoch += 1;
+    this.visibilityFacetFrame = undefined;
+    this.visibilityProjectionCache = undefined;
+    return result;
+  }
+
+  private projectProbes(entry: PersistentCompositionEntry, frame: ExtractedFrame): void {
+    const sky =
+      frame.skylight === undefined
+        ? {
+            available: false,
+            irradiance: [0, 0, 0] as const,
+            fallbackReason: 'no-skylight',
+          }
+        : {
+            available: true,
+            identity: `skylight:${frame.skylight.entityHandle}`,
+            sourceKey:
+              frame.skylight.equirectHandle > 0
+                ? `equirect:${frame.skylight.equirectHandle}`
+                : `skylight:${frame.skylight.entityHandle}`,
+            irradiance: [
+              frame.skylight.color[0] * frame.skylight.intensity,
+              frame.skylight.color[1] * frame.skylight.intensity,
+              frame.skylight.color[2] * frame.skylight.intensity,
+            ] as [number, number, number],
+          };
+    const probes = frame.lightProbes ?? [];
+    // Sky is evaluated by the global environment path. With no local light
+    // probes there can be no per-object ProbeBlendRecord, regardless of how
+    // many dynamic objects moved this frame. Preserve the projection call so
+    // a transition from probes to no probes still clears retained records.
+    if (probes.length === 0) {
+      entry.probeProjection.apply({ objects: [], probes, sky });
+      return;
+    }
+    const objects: ProbeSceneObjectInput[] = entry.projection.slotsSnapshot().map((slot) => ({
+      objectKey: slot.slot,
+      generation: slot.generation,
+      position: [
+        slot.snapshot.transform.world[12] ?? 0,
+        slot.snapshot.transform.world[13] ?? 0,
+        slot.snapshot.transform.world[14] ?? 0,
+      ],
+    }));
+    entry.probeProjection.apply({
+      objects,
+      probes,
+      sky,
+    });
   }
 
   private syncGpuOwner(
@@ -1364,6 +2151,7 @@ export class PersistentRenderScene {
     delta?: RenderSceneApplyResult,
     full = false,
   ): void {
+    if (this.composition?.token === owner && !this.composition.gpuDrivenSceneRequired) return;
     const acquired = this.acquireGpuScene(owner, projection);
     if (acquired === undefined || acquired.rebuilt) return;
     const result = full