@forgeax/engine-render 0.1.27 → 0.1.29

package/src/scene/render-scene.ts

@@ -3,41 +3,40 @@ import { componentId } from '@forgeax/engine-ecs/internal';
 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, GlobalTransform, MorphWeights, Transform } from '@forgeax/engine-scene';
+import {
+  ChildOf,
+  collectSubtree,
+  GlobalTransform,
+  MorphWeights,
+  Transform,
+} from '@forgeax/engine-scene';
 import { Skin } from '@forgeax/engine-skinning';
 import { err, ok, type Result } from '@forgeax/engine-types';
 import {
-  Camera,
-  DirectionalLight,
   Instances,
   Layer,
-  LightProbe,
   Lines,
   MeshFilter,
   MeshRenderer,
-  MotionBlur,
-  PointLight,
-  PointLightShadow,
   Points,
-  PostProcessParams,
-  ReflectionProbe,
-  SkyboxBackground,
-  Skylight,
   SortKey,
-  SpotLight,
   SpriteInstances,
   SpriteRegionOverride,
   Visibility,
 } from '../components';
 import type { DeviceScope, LifecycleResourceSpec } from '../device/device-scope';
+import { gpuDrivenShadowDrawKey } from '../extract/gpu-driven';
 import {
   BatchTopology,
   type BatchTopologyInspection,
   type SubmissionPlan,
 } from '../gpu-driven/batch-topology';
 import { GpuScene } from '../gpu-scene';
-import type { PersistentRenderSceneInspection } from '../inspection-types';
-import type { InstanceProjectionStore } from '../instances';
+import type {
+  GpuDrivenStructureMetrics,
+  PersistentRenderSceneInspection,
+} from '../inspection-types';
+import type { InstanceCollectionStore } from '../instances';
 import { fingerprintNumericArray, InstanceBoundsCache } from '../instances-derived-bounds';
 import type { PointsLinesInspection } from '../points-lines/inspection';
 import type { PointsLinesRetainedSnapshot } from '../points-lines/snapshot';
@@ -57,13 +56,11 @@ import type {
   RenderableSnapshot,
   RenderableTemporalSnapshot,
 } from '../render-system-extract';
-import type { SkinPaletteAllocator } from '../systems/skin-palette-allocator';
 import {
   PersistentTransmissionDemandProjection,
   type TransmissionDemand,
   type TransmissionDemandOperation,
 } from '../transmission/projection';
-import { VolumetricFog } from '../volume/component';
 import { ProbeBlendSceneProjection, type ProbeSceneObjectInput } from './probe-blend';
 import type {
   RenderSceneApplyResult,
@@ -74,6 +71,7 @@ import type {
   RenderSceneResyncReason,
   RenderSceneSlot,
 } from './render-scene-types';
+import { buildShadowFrusta } from './shadow-visibility';
 import { createVisibilityBudget, type VisibilityBudget } from './visibility/budget';
 import {
   primitiveKey,
@@ -103,6 +101,10 @@ interface PendingIdentity {
   current: RenderableSnapshot | undefined;
   removed: boolean;
   contentChanged: boolean;
+  /** An Instances row changed during this apply batch. */
+  instanceChanged: boolean;
+  /** A retained world transform changed during this apply batch. */
+  transformChanged: boolean;
 }
 
 interface WorldTransformSpan {
@@ -137,6 +139,16 @@ export interface RenderSceneSubmissionDelta {
   readonly slots: readonly number[];
 }
 
+/**
+ * Complete ShadowCaster producer projection retained beside the camera-cull
+ * submission frame. The persistent scene owns this sequence; record consumes
+ * it for the CPU residual lane without rebuilding a second scene projection.
+ */
+export interface PersistentShadowCasterProjection {
+  readonly renderables: readonly RenderableSnapshot[];
+  readonly dispatch: readonly DispatchEntry[];
+}
+
 function identityKey(worldId: number, entityKey: number): string {
   return `${worldId}:${entityKey}`;
 }
@@ -222,13 +234,6 @@ function ownPointsLinesSnapshot(
   };
 }
 
-function withWorld(snapshot: RenderableSnapshot, world: Float32Array): RenderableSnapshot {
-  return {
-    ...snapshot,
-    transform: { ...snapshot.transform, world: new Float32Array(world) },
-  };
-}
-
 function intersects(left: RenderSceneBounds, right: RenderSceneBounds): boolean {
   return (
     left.min[0] <= right.max[0] &&
@@ -322,8 +327,8 @@ export class RenderScene {
   private readonly freeSlots: number[] = [];
   private readonly slotsByWorld = new Map<number, Map<number, number>>();
   private readonly slotsByMaterial = new Map<number, Set<number>>();
+  private readonly slotsByAsset = 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;
@@ -348,13 +353,26 @@ export class RenderScene {
     return this.orderedSlots.length;
   }
 
-  apply(operations: readonly RenderSceneOperation[]): RenderSceneApplyResult {
-    if (operations.length === 0) {
+  apply(
+    operations: readonly RenderSceneOperation[],
+    spans: readonly WorldTransformSpan[] = [],
+  ): RenderSceneApplyResult {
+    if (operations.length === 0 && spans.length === 0) {
       this.noChangeFrames += 1;
       this.renderableScans = 0;
       return this.emptyResult();
     }
 
+    for (const operation of operations) {
+      if (
+        operation.kind === 'update' &&
+        operation.snapshot !== undefined &&
+        (operation.worldId !== operation.snapshot.worldId ||
+          operation.entityKey !== operation.snapshot.entityKey)
+      ) {
+        throw new RangeError('RenderScene update identity must match its source snapshot');
+      }
+    }
     this.deltaFrames += 1;
     this.renderableScans = operations.length;
     const pendingByWorld = new Map<number, Map<number, PendingIdentity>>();
@@ -377,31 +395,75 @@ export class RenderScene {
         current: initial?.snapshot,
         removed: false,
         contentChanged: false,
+        instanceChanged: false,
+        transformChanged: false,
       };
       entities.set(entityKey, pending);
       pendingOrder.push(pending);
       return pending;
     };
 
-    for (const operation of operations) {
-      if (operation.kind === 'create') {
-        const { worldId, entityKey } = operation.snapshot;
-        const pending = pendingFor(worldId, entityKey);
-        pending.current = ownSnapshot(operation.snapshot);
-        pending.contentChanged = true;
-        continue;
+    const updateWorld = (pending: PendingIdentity, source: Float32Array, offset: number): void => {
+      const target = pending.current?.transform.world;
+      if (target === undefined) return;
+      for (let lane = 0; lane < 16; lane += 1) {
+        const value = source[offset + lane] ?? 0;
+        if (target[lane] !== value) {
+          target[lane] = value;
+          pending.transformChanged = true;
+        }
       }
+    };
+    for (const operation of operations) {
       const pending = pendingFor(operation.worldId, operation.entityKey);
       if (operation.kind === 'remove') {
         pending.current = undefined;
         pending.removed = true;
         continue;
       }
+      if (operation.snapshot !== undefined) {
+        const previousMaterials = pending.current?.materials;
+        const next = ownSnapshot(operation.snapshot);
+        pending.current =
+          previousMaterials !== undefined &&
+          previousMaterials.length === next.materials.length &&
+          previousMaterials.every((material, index) => material === next.materials[index])
+            ? { ...next, materials: previousMaterials }
+            : next;
+        pending.contentChanged = true;
+      }
       if (pending.current === undefined) {
         ignoredLateUpdates += 1;
         continue;
       }
-      pending.current = withWorld(pending.current, operation.world);
+      if (operation.instances !== undefined) {
+        pending.current = {
+          ...pending.current,
+          instances: {
+            ...operation.instances,
+            transforms: new Float32Array(operation.instances.transforms),
+          },
+        };
+        pending.instanceChanged = true;
+      }
+      if (operation.world !== undefined) {
+        updateWorld(pending, operation.world, 0);
+      }
+    }
+    // The same pending identity merges column updates with all other source
+    // edits. There is one publication and one consumer delta per entity.
+    for (const span of spans) {
+      this.renderableScans += span.entities.length;
+      for (let row = 0; row < span.entities.length; row += 1) {
+        const entity = span.entities[row];
+        if (entity === undefined) continue;
+        const pending = pendingFor(span.worldId, entity);
+        if (pending.current === undefined) {
+          ignoredLateUpdates += 1;
+          continue;
+        }
+        updateWorld(pending, span.worlds, row * 16);
+      }
     }
 
     let created = 0;
@@ -411,6 +473,7 @@ export class RenderScene {
     const createdSlots: RenderSceneSlot[] = [];
     const updatedSlots: RenderSceneSlot[] = [];
     const contentUpdatedSlots: RenderSceneSlot[] = [];
+    const instanceUpdatedSlots: RenderSceneSlot[] = [];
     const removedSlots: RenderSceneRecord[] = [];
     const recreatedSlots: RenderSceneSlot[] = [];
     for (const pending of pendingOrder) {
@@ -438,24 +501,38 @@ export class RenderScene {
         recreated += 1;
         continue;
       }
-      const updatedSlot: RenderSceneSlot = {
-        ...pending.initial,
-        snapshot: pending.current,
-      };
-      this.unindexMaterials(pending.initial);
+      if (!pending.contentChanged && !pending.instanceChanged && !pending.transformChanged)
+        continue;
+      const updatedSlot: RenderSceneSlot =
+        pending.current === pending.initial.snapshot
+          ? pending.initial
+          : { ...pending.initial, snapshot: pending.current };
+      if (pending.contentChanged) this.unindexMaterials(pending.initial);
       this.slots[pending.initial.slot] = updatedSlot;
-      this.worldBoundsBySlot[updatedSlot.slot] = undefined;
-      this.indexMaterials(updatedSlot);
-      this.dirtySinceSubmitted.add(updatedSlot.slot);
+      if (pending.current.instances === undefined && !pending.contentChanged) {
+        const cached = this.worldBoundsBySlot[updatedSlot.slot];
+        this.worldBoundsBySlot[updatedSlot.slot] =
+          worldBounds(pending.current, cached ?? undefined) ?? null;
+      } else {
+        this.worldBoundsBySlot[updatedSlot.slot] = undefined;
+      }
+      if (pending.contentChanged) this.indexMaterials(updatedSlot);
+      if (this.temporalTracking) this.dirtySinceSubmitted.add(updatedSlot.slot);
       updatedSlots.push(updatedSlot);
       if (pending.contentChanged) contentUpdatedSlots.push(updatedSlot);
+      else if (pending.instanceChanged) instanceUpdatedSlots.push(updatedSlot);
       updated += 1;
     }
 
     const changed = created + updated + removed + recreated > 0;
     if (changed) {
       this.revision += 1;
-      this.invalidateSnapshots();
+      if (
+        created + removed + recreated > 0 ||
+        pendingOrder.some((pending) => pending.current !== pending.initial?.snapshot)
+      ) {
+        this.invalidateSnapshots();
+      }
     }
     return {
       created,
@@ -466,61 +543,31 @@ export class RenderScene {
       createdSlots,
       updatedSlots,
       contentUpdatedSlots,
+      instanceUpdatedSlots,
       removedSlots,
       recreatedSlots,
       resynced: 0,
     };
   }
 
-  /** 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;
+  /** Rebind positional World indices while retaining stable slot and submission history. */
+  remapWorlds(indices: readonly number[]): void {
+    this.slotsByWorld.clear();
+    for (const slot of this.slots) {
+      if (slot === undefined) continue;
+      this.instanceBoundsCache.invalidate(slot.entityKey, slot.worldId);
+      const mapped = indices[slot.worldId];
+      const worldId = mapped === undefined || mapped < 0 ? -1 - slot.worldId : mapped;
+      const remapped = { ...slot, worldId, snapshot: { ...slot.snapshot, worldId } };
+      this.slots[slot.slot] = remapped;
+      let entities = this.slotsByWorld.get(worldId);
+      if (entities === undefined) {
+        entities = new Map<number, number>();
+        this.slotsByWorld.set(worldId, entities);
       }
+      entities.set(slot.entityKey, slot.slot);
     }
-    this.renderableScans = scanned;
-    if (updated > 0) this.revision += 1;
-    return {
-      created: 0,
-      updated,
-      removed: 0,
-      recreated: 0,
-      ignoredLateUpdates,
-      createdSlots: [],
-      updatedSlots,
-      removedSlots: [],
-      recreatedSlots: [],
-      resynced: 0,
-    };
+    this.invalidateSnapshots();
   }
 
   /** Reconcile the current identity set while retaining slots for survivors. */
@@ -545,7 +592,7 @@ export class RenderScene {
     for (const snapshot of desired.values()) {
       const existing = this.lookup(snapshot.worldId, snapshot.entityKey);
       if (existing === undefined) {
-        const created = this.allocate(snapshot);
+        const created = this.allocate(ownSnapshot(snapshot));
         this.dirtySinceSubmitted.add(created.slot);
         continue;
       }
@@ -647,7 +694,6 @@ export class RenderScene {
     }
     this.lastSubmittedVisible = new Set(capture.visible);
     this.submittedEpoch += 1;
-    this.invalidateSnapshots();
     return {
       epoch: this.submittedEpoch,
       slots: capture.slots.map((update) => update.slot),
@@ -729,6 +775,7 @@ export class RenderScene {
       fullRebuilds: this.fullRebuilds,
       resyncs: this.resyncs,
       lastResyncReason: this.lastResyncReason,
+      instanceBoundsCache: this.instanceBoundsCache.inspect(),
     };
   }
 
@@ -741,6 +788,8 @@ export class RenderScene {
       ignoredLateUpdates: 0,
       createdSlots: [],
       updatedSlots: [],
+      contentUpdatedSlots: [],
+      instanceUpdatedSlots: [],
       removedSlots: [],
       recreatedSlots: [],
       resynced: 0,
@@ -761,7 +810,7 @@ export class RenderScene {
       generation,
       worldId: snapshot.worldId,
       entityKey: snapshot.entityKey,
-      snapshot: ownSnapshot(snapshot),
+      snapshot,
     };
     let previousWorld = this.previousWorldBySlot[slot];
     if (previousWorld === undefined) {
@@ -796,7 +845,23 @@ export class RenderScene {
     this.freeSlots.push(record.slot);
   }
 
+  addSharedRefConsumers(worldId: number, handle: number, target: Set<number>): void {
+    for (const index of [this.slotsByAsset, this.slotsByMaterial]) {
+      for (const slot of index.get(handle) ?? []) {
+        const record = this.slots[slot];
+        if (record?.worldId === worldId) target.add(record.entityKey);
+      }
+    }
+  }
+
   private indexMaterials(record: RenderSceneSlot): void {
+    const asset = record.snapshot.assetHandle;
+    let assetSlots = this.slotsByAsset.get(asset);
+    if (assetSlots === undefined) {
+      assetSlots = new Set<number>();
+      this.slotsByAsset.set(asset, assetSlots);
+    }
+    assetSlots.add(record.slot);
     for (const material of record.snapshot.materials) {
       const handle = material.materialHandle ?? 0;
       let slots = this.slotsByMaterial.get(handle);
@@ -809,6 +874,10 @@ export class RenderScene {
   }
 
   private unindexMaterials(record: RenderSceneSlot): void {
+    const asset = record.snapshot.assetHandle;
+    const assetSlots = this.slotsByAsset.get(asset);
+    assetSlots?.delete(record.slot);
+    if (assetSlots?.size === 0) this.slotsByAsset.delete(asset);
     for (const material of record.snapshot.materials) {
       const handle = material.materialHandle ?? 0;
       const slots = this.slotsByMaterial.get(handle);
@@ -914,9 +983,8 @@ export interface PersistentRenderSceneOptions {
   readonly onGpuError?: ((error: RhiError) => void) | undefined;
   readonly onSharedRefMutation?: ((worldId: number, handle: number) => void) | undefined;
   readonly configuredQueryBudget?: number | undefined;
-  /** Rebuildable projection of World-owned instance matrices. */
-  readonly instanceCollections?: InstanceProjectionStore | undefined;
-  readonly getSkinPaletteAllocator?: (() => SkinPaletteAllocator | null) | undefined;
+  /** Producer-owned instance collections consumed by the same source update flow. */
+  readonly instanceCollections?: InstanceCollectionStore | undefined;
 }
 
 export interface PersistentGpuDrivenState {
@@ -925,6 +993,7 @@ export interface PersistentGpuDrivenState {
   readonly slots: readonly RenderSceneSlot[];
   /** Stable renderer-local World keys aligned with RenderSceneSlot.worldId. */
   readonly worldKeys?: readonly number[];
+  readonly structureMetrics?: GpuDrivenStructureMetrics;
 }
 
 export interface CpuDirectViewInput {
@@ -993,19 +1062,10 @@ type PersistentGpuSceneInspection = PersistentRenderSceneInspection['gpu'];
 interface PersistentCompositionEntry {
   readonly token: object;
   readonly worlds: readonly World[];
-  readonly cameraOwner: number;
-  readonly resourceOwner: number;
   readonly projection: RenderScene;
   readonly topology: BatchTopology;
   readonly transmissionDemand: PersistentTransmissionDemandProjection;
-  structure: Pick<
-    ExtractedFrame,
-    | 'dispatch'
-    | 'visibilityStats'
-    | 'visibilitySnapshots'
-    | 'featureVisibilitySnapshots'
-    | 'hiddenEntityReports'
-  >;
+  hiddenEntityReports: ExtractedFrame['hiddenEntityReports'];
   /** Stable renderer-local World keys; unlike RenderableSnapshot.worldId they survive reorder. */
   readonly worldKeys: readonly number[];
   readonly readVersions: RenderReadVersion[];
@@ -1014,53 +1074,22 @@ interface PersistentCompositionEntry {
   readonly renderChangeQueries: readonly ReadonlyMap<number, Query>[];
   readonly dispatchBySlot: Map<number, readonly DispatchEntry[]>;
   dispatchRevision: number;
-  dispatchCache:
-    | { readonly revision: number; readonly value: readonly DispatchEntry[] }
-    | undefined;
+  dispatchCache: { readonly revision: number; readonly value: DispatchEntry[] } | undefined;
   readonly skinConsumersByJoint: Map<string, Set<number>>;
   /** Renderable identities whose partial producer still needs a successful publish. */
   readonly pendingRenderableEntitiesByWorld: Set<number>[];
   /** Slots retained for recovery but excluded from direct and indirect submission. */
   readonly unavailableSlots: Set<number>;
   catalogEpoch: number;
+  instanceEpoch: number;
   readonly probeProjection: ProbeBlendSceneProjection;
   temporalDemanded: boolean;
   gpuDrivenSceneRequired: boolean;
 }
 
-const RENDER_RELEVANT_COMPONENT_IDS = new Set([
-  componentId(GlobalTransform),
-  componentId(ChildOf),
-  componentId(MeshFilter),
-  componentId(MeshRenderer),
-  componentId(Instances),
-  componentId(SpriteInstances),
-  componentId(SpriteRegionOverride),
-  componentId(Skin),
-  componentId(Layer),
-  componentId(Visibility),
-  componentId(MorphWeights),
-  componentId(Points),
-  componentId(Lines),
-  componentId(SortKey),
-  componentId(Camera),
-  componentId(MotionBlur),
-  componentId(DirectionalLight),
-  componentId(LightProbe),
-  componentId(PointLight),
-  componentId(PointLightShadow),
-  componentId(SpotLight),
-  componentId(Skylight),
-  componentId(SkyboxBackground),
-  componentId(PostProcessParams),
-  componentId(ReflectionProbe),
-  componentId(VolumetricFog),
-]);
-
-// These components can change the retained renderable source. Other relevant
-// components affect frame resources and still require a composition rebuild;
-// they must not cause a renderable-only partial extraction to silently retain
-// stale lights, cameras, or environment facts.
+// Retained geometry consumes these component changes. Camera, lighting and
+// environment facts are freshly extracted by deriveFramePlan on every draw;
+// their edits must not recreate unrelated geometry or its submission history.
 const RENDERABLE_SOURCE_COMPONENTS = [
   GlobalTransform,
   ChildOf,
@@ -1105,6 +1134,7 @@ function createGlobalTransformChangeQuery(world: World): GlobalTransformChangeQu
 function createRenderChangeQueries(world: World): ReadonlyMap<number, Query> {
   const queries = new Map<number, Query>();
   for (const component of RENDERABLE_SOURCE_COMPONENTS) {
+    if (component === GlobalTransform) continue;
     const result = world.query({ read: [component], changed: [component] });
     if (!result.ok) throw result.error;
     const query = result.value as Query;
@@ -1190,7 +1220,7 @@ function dispatchForProjection(
   dispatchBySlot: ReadonlyMap<number, readonly DispatchEntry[]>,
   projection: RenderScene,
   unavailableSlots: ReadonlySet<number>,
-): readonly DispatchEntry[] {
+): DispatchEntry[] {
   const dispatch: DispatchEntry[] = [];
   const renderables = projection.materialize();
   for (let renderableIndex = 0; renderableIndex < renderables.length; renderableIndex += 1) {
@@ -1200,7 +1230,9 @@ function dispatchForProjection(
     if (slot === undefined) continue;
     if (unavailableSlots.has(slot.slot)) continue;
     for (const entry of dispatchBySlot.get(slot.slot) ?? []) {
-      dispatch.push({ ...entry, renderableIndex });
+      dispatch.push(
+        renderableIndex === entry.renderableIndex ? entry : { ...entry, renderableIndex },
+      );
     }
   }
   return dispatch;
@@ -1212,39 +1244,29 @@ function topologyDeltaForAvailable(
   newlyUnavailable: readonly RenderSceneSlot[],
 ): RenderSceneApplyResult {
   const updatedSlots = delta.updatedSlots.filter((slot) => !unavailableSlots.has(slot.slot));
+  const unavailableUpdates = newlyUnavailable.map((slot) => ({
+    ...slot,
+    snapshot: { ...slot.snapshot, gpuDrivenDraws: [] },
+  }));
   const contentUpdatedSlots = delta.contentUpdatedSlots?.filter(
     (slot) => !unavailableSlots.has(slot.slot),
   );
+  const instanceUpdatedSlots = delta.instanceUpdatedSlots?.filter(
+    (slot) => !unavailableSlots.has(slot.slot),
+  );
+  const contentBySlot =
+    contentUpdatedSlots === undefined
+      ? undefined
+      : new Map(contentUpdatedSlots.map((slot) => [slot.slot, slot]));
+  for (const slot of unavailableUpdates) contentBySlot?.set(slot.slot, slot);
   return {
     ...delta,
-    updatedSlots: [
-      ...updatedSlots,
-      ...newlyUnavailable.map((slot) => ({
-        ...slot,
-        snapshot: { ...slot.snapshot, gpuDrivenDraws: [] },
-      })),
-    ],
-    ...(contentUpdatedSlots === undefined ? {} : { contentUpdatedSlots }),
+    updatedSlots: [...updatedSlots, ...unavailableUpdates],
+    ...(contentBySlot === undefined ? {} : { contentUpdatedSlots: [...contentBySlot.values()] }),
+    ...(instanceUpdatedSlots === undefined ? {} : { instanceUpdatedSlots }),
   };
 }
 
-function addSharedRefConsumers(
-  projection: RenderScene,
-  worldId: number,
-  handle: number,
-  target: Set<number>,
-): void {
-  for (const slot of projection.slotsSnapshot()) {
-    if (
-      slot.worldId === worldId &&
-      (slot.snapshot.assetHandle === handle ||
-        slot.snapshot.materials.some((material) => material.materialHandle === handle))
-    ) {
-      target.add(slot.entityKey);
-    }
-  }
-}
-
 function frameDemandsTemporal(frame: ExtractedFrame): boolean {
   const camera = frame.cameras[0];
   return camera?.antialias === 'taa' || (camera?.motionBlur?.shutterAngle ?? 0) > 0;
@@ -1295,6 +1317,18 @@ function cullPersistentFrame(
   ) => worldBounds(snapshot),
 ): ExtractedFrame {
   const planes = cameraFrusta(frame.cameras);
+  // Shadow casters are not constrained by the display camera. Keep the
+  // primary camera cull intact, but admit a caster that is outside every
+  // camera frustum when its bounds intersect one of the active light-space
+  // frusta. This is especially important for point-light cube faces: the
+  // caster can be behind the camera while still occluding the receiver.
+  const casterIndices = new Set(
+    frame.dispatch
+      .filter((entry) => entry.tags.LightMode === 'ShadowCaster')
+      .map((entry) => entry.renderableIndex),
+  );
+  const shadowFrusta = casterIndices.size === 0 ? [] : buildShadowFrusta(frame.lights);
+  const shadowOnly = new Set<number>();
   const visible: RenderableSnapshot[] = [];
   if (cullProjectedIndexScratch.length < candidates.length) {
     cullProjectedIndexScratch = new Int32Array(candidates.length);
@@ -1313,6 +1347,7 @@ function cullPersistentFrame(
       continue;
     }
     let isVisible = true;
+    let isShadowVisible = false;
     const candidateBounds = boundsOf(candidate, index);
     if (candidateBounds !== undefined) {
       total += 1;
@@ -1332,10 +1367,16 @@ function cullPersistentFrame(
           break;
         }
       }
+      if (!isVisible && casterIndices.has(index)) {
+        isShadowVisible = shadowFrusta.some((lightPlanes) =>
+          frustum.intersectsBox(lightPlanes, worldAabb as box3.Box3Like),
+        );
+      }
     }
     if (!isVisible) {
       culled += 1;
-      continue;
+      if (!isShadowVisible) continue;
+      shadowOnly.add(index);
     }
     projectedIndex[index] = visible.length;
     // The culling candidate is the persistent projection snapshot used for
@@ -1349,9 +1390,15 @@ function cullPersistentFrame(
   const dispatch: DispatchEntry[] = [];
   for (const entry of frame.dispatch) {
     const candidateIndex = entry.renderableIndex;
+    // Shadow-only candidates must never enter the main forward/transparent
+    // dispatch. Their ShadowCaster entries remain available to the depth
+    // passes, which consume the same validated ordered list.
+    if (shadowOnly.has(candidateIndex) && entry.tags.LightMode !== 'ShadowCaster') continue;
     const renderableIndex = projectedIndex[candidateIndex];
     if (renderableIndex === undefined || renderableIndex < 0) continue;
-    dispatch.push({ ...entry, renderableIndex });
+    dispatch.push(
+      renderableIndex === entry.renderableIndex ? entry : { ...entry, renderableIndex },
+    );
   }
   return {
     ...frame,
@@ -1391,12 +1438,15 @@ export class PersistentRenderScene {
   private readonly materialSnapshotCaches: MaterialSnapshotCachesByWorld = new WeakMap();
   private fullRebuilds = 0;
   private worldEntitiesScanned = 0;
+  private sceneTableUploadBytes = 0;
   private noChangeFrames = 0;
   private deltaFrames = 0;
   private transformUpdates = 0;
   private lastResyncReason: RenderSceneResyncReason | undefined;
   private composition: PersistentCompositionEntry | undefined;
   private gpuScene: GpuScene | undefined;
+  private readonly retiredGpuScenes = new Set<GpuScene>();
+  private shadowProjection: PersistentShadowCasterProjection | undefined;
   private gpuOwner: object | undefined;
   private gpuDevice: RhiDevice | undefined;
   private gpuStatus: 'inactive' | 'unsupported' | 'resident' | 'rebuild-pending' | 'error' =
@@ -1424,6 +1474,7 @@ export class PersistentRenderScene {
       }
     | undefined;
   private visibilityProjectionRevision = 0;
+  private projectedIndexScratch = new Int32Array(0);
   private lastActiveEntityKeys: ReadonlySet<number> | undefined;
   /** Stable renderer-world/entity lookup; rebuilt only with composition topology. */
   private readonly stableSlotByEntity = new Map<number, RenderSceneSlot>();
@@ -1473,6 +1524,10 @@ export class PersistentRenderScene {
     return this.composition?.projection.slotsSnapshot() ?? [];
   }
 
+  shadowCasterProjection(): PersistentShadowCasterProjection | undefined {
+    return this.shadowProjection;
+  }
+
   /** Stable renderer-world/entity lookup shared by query and final projection paths. */
   compositionSlotByStableEntity(): ReadonlyMap<number, RenderSceneSlot> {
     return this.stableSlotByEntity;
@@ -1517,7 +1572,7 @@ export class PersistentRenderScene {
         renderable.lods.length === 0 ||
         bounds === undefined ||
         bounds.length < 6 ||
-        [...bounds].some((value) => !Number.isFinite(value))
+        !bounds.every(Number.isFinite)
       ) {
         continue;
       }
@@ -1594,15 +1649,19 @@ export class PersistentRenderScene {
     ) {
       return cached.projection;
     }
-    const projectedIndex = new Int32Array(renderables.length);
-    projectedIndex.fill(-1);
+    if (this.projectedIndexScratch.length < renderables.length) {
+      this.projectedIndexScratch = new Int32Array(renderables.length);
+    }
+    const projectedIndex = this.projectedIndexScratch;
+    projectedIndex.fill(-1, 0, renderables.length);
     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));
+      const stableEntity = this.stableEntityKey(worlds, renderable);
+      const slot = this.stableSlotByEntity.get(stableEntity);
       let draw = true;
       if (slot !== undefined && (renderable.lods?.length ?? 0) > 0) {
         const primitive = primitiveKey({
@@ -1613,9 +1672,7 @@ export class PersistentRenderScene {
         });
         const bounds = renderable.localAabb;
         const validBounds =
-          bounds !== undefined &&
-          bounds.length >= 6 &&
-          [...bounds].every((value) => Number.isFinite(value));
+          bounds !== undefined && bounds.length >= 6 && bounds.every(Number.isFinite);
         draw = decideVisibility({
           authorVisible: renderable.authorVisible !== false,
           validBounds,
@@ -1631,13 +1688,15 @@ export class PersistentRenderScene {
       }
       projectedIndex[index] = projected.length;
       projected.push(renderable);
-      activeEntityKeys.add(this.stableEntityKey(worlds, renderable));
+      activeEntityKeys.add(stableEntity);
     }
     const projectedDispatch: DispatchEntry[] = [];
     for (const entry of dispatch) {
       const renderableIndex = projectedIndex[entry.renderableIndex];
       if (renderableIndex === undefined || renderableIndex < 0) continue;
-      projectedDispatch.push({ ...entry, renderableIndex });
+      projectedDispatch.push(
+        renderableIndex === entry.renderableIndex ? entry : { ...entry, renderableIndex },
+      );
     }
     const projection = {
       renderables: Object.freeze(projected),
@@ -1725,6 +1784,7 @@ export class PersistentRenderScene {
     leases?: readonly RenderReadLease[],
   ): ExtractedFrame {
     this.worldEntitiesScanned = 0;
+    this.sceneTableUploadBytes = 0;
     const entry = this.composition;
     const sameWorldSet =
       entry !== undefined &&
@@ -1749,15 +1809,12 @@ export class PersistentRenderScene {
       leaseSetPreserved;
     if (
       entry === undefined ||
-      entry.catalogEpoch !== catalogEpoch ||
-      entry.cameraOwner !== owner.cameraOwner ||
-      entry.resourceOwner !== owner.resourceOwner ||
       entry.worlds.length !== worlds.length ||
       entry.worlds.some((world, index) => world !== worlds[index]) ||
       leases === undefined ||
       leases.length !== worlds.length
     ) {
-      return this.rebuildComposition(
+      return this.reconcileComposition(
         worlds,
         owner,
         catalogEpoch,
@@ -1766,14 +1823,33 @@ export class PersistentRenderScene {
         preserveVisibilityOnReorder,
       );
     }
-    let requiresRebuild = false;
+    let requiresSourceRefresh = false;
     const changedEntitiesByWorld = worlds.map(
       (_, worldId) => new Set(entry.pendingRenderableEntitiesByWorld[worldId] ?? []),
     );
+    const contentChangedByWorld = worlds.map(
+      (_, worldId) => new Set(entry.pendingRenderableEntitiesByWorld[worldId] ?? []),
+    );
+    if (entry.catalogEpoch !== catalogEpoch) {
+      for (const slot of entry.projection.slotsSnapshot()) {
+        changedEntitiesByWorld[slot.worldId]?.add(slot.entityKey);
+        contentChangedByWorld[slot.worldId]?.add(slot.entityKey);
+      }
+    }
+    const instanceEpoch = this.options.instanceCollections?.epoch ?? 0;
+    if (entry.instanceEpoch !== instanceEpoch) {
+      for (const slot of entry.projection.slotsSnapshot()) {
+        const id = slot.snapshot.instances?.collectionId;
+        if (id === undefined) continue;
+        const current = this.options.instanceCollections?.inspect(id);
+        if (!current?.ok || current.value.revision !== slot.snapshot.instances?.revision) {
+          changedEntitiesByWorld[slot.worldId]?.add(slot.entityKey);
+        }
+      }
+    }
     const nextReadVersions = entry.readVersions.slice();
     const structureChangedWorlds = new Set<number>();
     const structuralComponentIdsByWorld = worlds.map(() => new Set<number>());
-    let refreshStructureFacts = false;
     let currentRenderableEntitiesByWorld: readonly (ReadonlySet<number> | undefined)[] | undefined;
     const removedSlots: RenderSceneSlot[] = [];
     for (let worldId = 0; worldId < worlds.length; worldId += 1) {
@@ -1781,24 +1857,23 @@ export class PersistentRenderScene {
       if (world === undefined) continue;
       const lease = leases?.[worldId];
       if (lease === undefined || entry.leaseIdentities[worldId] !== lease.worldIdentity) {
-        requiresRebuild = true;
+        requiresSourceRefresh = true;
         break;
       }
       const version = entry.readVersions[worldId];
       if (version === undefined) {
-        requiresRebuild = true;
+        requiresSourceRefresh = true;
         break;
       }
       let read: ReturnType<RenderReadLease['readChanges']>;
       try {
         read = lease.readChanges(version);
       } catch {
-        requiresRebuild = true;
+        requiresSourceRefresh = true;
         break;
       }
       if (read.status === 'rebuild') {
         structureChangedWorlds.add(worldId);
-        refreshStructureFacts = true;
       }
       const changes = read.world;
       const shared = read.sharedRefs;
@@ -1806,56 +1881,80 @@ export class PersistentRenderScene {
         for (const record of shared.records) {
           this.options.onSharedRefMutation?.(worldId, record.handle);
           const changed = changedEntitiesByWorld[worldId];
-          if (changed !== undefined)
-            addSharedRefConsumers(entry.projection, worldId, record.handle, changed);
+          const content = contentChangedByWorld[worldId];
+          if (changed !== undefined && content !== undefined) {
+            entry.projection.addSharedRefConsumers(worldId, record.handle, content);
+            for (const entity of content) changed.add(entity);
+          }
         }
       }
       for (const changedComponentId of changes.changedComponentIds) {
         if (read.status === 'rebuild') {
           structuralComponentIdsByWorld[worldId]?.add(changedComponentId);
         }
-        if (!RENDER_RELEVANT_COMPONENT_IDS.has(changedComponentId)) continue;
-        if (!RENDERABLE_SOURCE_COMPONENT_IDS.has(changedComponentId)) {
-          requiresRebuild = true;
-          break;
-        }
+        if (!RENDERABLE_SOURCE_COMPONENT_IDS.has(changedComponentId)) continue;
         const changed = changedEntitiesByWorld[worldId];
         if (changed === undefined) continue;
-        if (VISIBILITY_DEPENDENCY_COMPONENT_IDS.has(changedComponentId)) {
-          refreshStructureFacts = true;
-          // Visibility and parent changes affect the effective state of a
-          // subtree. The normal update path evaluates the current rows; the
-          // set is deliberately allowed to be broad, while empty work still
-          // exits naturally without a candidate loop.
-          for (const entity of collectRenderableEntities(world)) changed.add(entity);
-          continue;
-        }
-        if (changedComponentId === componentId(GlobalTransform)) {
-          const query = entry.renderChangeQueries[worldId]?.get(changedComponentId);
-          for (const row of query ?? []) {
-            const consumers = entry.skinConsumersByJoint.get(
-              skinJointKey(worldId, row.entity as number),
-            );
-            for (const consumer of consumers ?? []) changed.add(consumer);
-          }
-          continue;
-        }
+        const otherChanged = contentChangedByWorld[worldId];
         const query = entry.renderChangeQueries[worldId]?.get(changedComponentId);
         if (query !== undefined) {
-          for (const row of query) changed.add(row.entity as number);
+          for (const row of query) {
+            const entity = row.entity as number;
+            if (VISIBILITY_DEPENDENCY_COMPONENT_IDS.has(changedComponentId)) {
+              const affected = collectSubtree(world, row.entity);
+              for (const dependent of affected) {
+                if (
+                  !entry.projection.has(worldId, dependent) &&
+                  !world.hasComponent(dependent as EntityHandle, MeshRenderer)
+                )
+                  continue;
+                changed.add(dependent);
+                otherChanged?.add(dependent);
+              }
+            } else {
+              changed.add(entity);
+              if (changedComponentId !== componentId(Instances)) otherChanged?.add(entity);
+            }
+          }
         }
       }
-      if (requiresRebuild) break;
+      if (requiresSourceRefresh) break;
       nextReadVersions[worldId] = read.version;
     }
-    if (requiresRebuild) {
-      return this.rebuildComposition(worlds, owner, catalogEpoch, buildCandidateFrame, leases);
+    if (requiresSourceRefresh) {
+      return this.reconcileComposition(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)) {
+          requiresSourceRefresh = true;
+          break;
+        }
+        transformSpans.push({ worldId, entities: span.entities, worlds: changedWorlds });
+        for (const entity of span.entities) {
+          for (const consumer of entry.skinConsumersByJoint.get(skinJointKey(worldId, entity)) ??
+            []) {
+            changedEntitiesByWorld[worldId]?.add(consumer);
+            contentChangedByWorld[worldId]?.add(consumer);
+          }
+        }
+      }
+      if (requiresSourceRefresh) break;
+    }
+    if (requiresSourceRefresh) {
+      return this.reconcileComposition(worlds, owner, catalogEpoch, buildCandidateFrame, leases);
+    }
     if (structureChangedWorlds.size > 0) {
       this.visibilityFacets.clear();
       this.invalidateActiveEntityRevision();
-      const currentByWorld = worlds.map((world) => collectRenderableEntities(world));
+      const currentByWorld = worlds.map((world, worldId) =>
+        structureChangedWorlds.has(worldId) ? collectRenderableEntities(world) : undefined,
+      );
       currentRenderableEntitiesByWorld = currentByWorld;
       for (let worldId = 0; worldId < currentByWorld.length; worldId += 1) {
         const world = worlds[worldId];
@@ -1873,7 +1972,10 @@ export class PersistentRenderScene {
             if (indexedWorldId !== worldId) continue;
             const jointEntity = Number(jointKey.slice(separator + 1));
             if (world.hasComponent(jointEntity as EntityHandle, GlobalTransform)) continue;
-            for (const consumer of consumers) changed.add(consumer);
+            for (const consumer of consumers) {
+              changed.add(consumer);
+              contentChangedByWorld[worldId]?.add(consumer);
+            }
           }
           for (const entity of current) {
             if (entry.projection.slot(worldId, entity) === undefined) changed.add(entity);
@@ -1889,26 +1991,14 @@ export class PersistentRenderScene {
             const membershipChanged = sourceMembershipChanged(world, slot);
             if (scanAllMembership || membershipChanged) {
               changed.add(slot.entityKey);
-              if (
-                slot.snapshot.instances !== undefined &&
-                !world.hasComponent(slot.entityKey as EntityHandle, Instances)
-              ) {
-                this.options.instanceCollections?.release(world, slot.entityKey);
-              }
-              if (
-                slot.snapshot.skin !== undefined &&
-                !world.hasComponent(slot.entityKey as EntityHandle, Skin)
-              ) {
-                this.options
-                  .getSkinPaletteAllocator?.()
-                  ?.releaseSliceFor(`${world.identity}:${slot.entityKey}`);
-              }
+              contentChangedByWorld[worldId]?.add(slot.entityKey);
             }
           }
         }
         for (const slot of entry.projection.slotsSnapshot()) {
           if (slot.worldId !== worldId || current.has(slot.entityKey)) continue;
           removedSlots.push(slot);
+          changedEntitiesByWorld[worldId]?.add(slot.entityKey);
         }
         this.worldEntitiesScanned += current.size;
       }
@@ -1925,7 +2015,7 @@ export class PersistentRenderScene {
 
     let changedDelta: RenderSceneApplyResult | undefined;
     const hasChangedEntities = changedEntitiesByWorld.some((entities) => entities.size > 0);
-    if (hasChangedEntities || removedSlots.length > 0) {
+    if (hasChangedEntities || removedSlots.length > 0 || transformSpans.length > 0) {
       const operations: RenderSceneOperation[] = [];
       const removedDemand: TransmissionDemandOperation[] = [];
       const replacedSkinSnapshots: RenderableSnapshot[] = [];
@@ -1940,11 +2030,6 @@ export class PersistentRenderScene {
         if (slot.snapshot.skinJointEntities !== undefined) {
           removeSkinConsumer(entry.skinConsumersByJoint, slot.snapshot);
         }
-        const world = worlds[slot.worldId];
-        if (world !== undefined) this.options.instanceCollections?.release(world, slot.entityKey);
-        this.options
-          .getSkinPaletteAllocator?.()
-          ?.releaseSliceFor(`${world?.identity ?? slot.worldId}:${slot.entityKey}`);
         for (
           let materialIndex = 0;
           materialIndex < slot.snapshot.materials.length;
@@ -1969,15 +2054,39 @@ export class PersistentRenderScene {
           }
         }
       }
-      const partial = hasChangedEntities
-        ? buildCandidateFrame({ kind: 'partial', entitiesByWorld: changedEntitiesByWorld })
-        : undefined;
+      let partial: ExtractedFrame | undefined;
+      try {
+        partial = hasChangedEntities
+          ? buildCandidateFrame({ kind: 'partial', entitiesByWorld: changedEntitiesByWorld })
+          : undefined;
+      } catch (cause) {
+        // Change queries have been observed, but this publication never ran.
+        // Retain every consumed transform identity for the producer retry.
+        for (const span of transformSpans) {
+          const pending = entry.pendingRenderableEntitiesByWorld[span.worldId];
+          for (const entity of span.entities) {
+            if (entry.projection.has(span.worldId, entity)) pending?.add(entity);
+          }
+        }
+        throw cause;
+      }
       const publishedEntitiesByWorld = worlds.map(() => new Set<number>());
       for (const snapshot of partial?.renderables ?? []) {
-        operations.push({ kind: 'create', snapshot });
+        const existing = entry.projection.slot(snapshot.worldId, snapshot.entityKey);
+        const contentChanged =
+          existing === undefined ||
+          contentChangedByWorld[snapshot.worldId]?.has(snapshot.entityKey);
+        operations.push({
+          kind: 'update',
+          worldId: snapshot.worldId,
+          entityKey: snapshot.entityKey,
+          ...(contentChanged || snapshot.instances === undefined
+            ? { snapshot }
+            : { instances: snapshot.instances }),
+        });
         publishedEntitiesByWorld[snapshot.worldId]?.add(snapshot.entityKey);
       }
-      changedDelta = entry.projection.apply(operations);
+      changedDelta = entry.projection.apply(operations, transformSpans);
       const publishedSkinKeys = new Set<string>();
       for (const snapshot of partial?.renderables ?? []) {
         publishedSkinKeys.add(`${snapshot.worldId}:${snapshot.entityKey}`);
@@ -2005,17 +2114,21 @@ export class PersistentRenderScene {
       for (const removed of changedDelta.removedSlots) entry.dispatchBySlot.delete(removed.slot);
       for (const recreated of changedDelta.recreatedSlots)
         entry.dispatchBySlot.delete(recreated.slot);
+      if (partial !== undefined || removedSlots.length > 0) {
+        const worldIndices = new Map(worlds.map((world, index) => [world, index]));
+        entry.hiddenEntityReports = [
+          ...entry.hiddenEntityReports.filter((report) => {
+            const worldId = worldIndices.get(report.world);
+            return (
+              worldId !== undefined &&
+              !changedEntitiesByWorld[worldId]?.has(report.entity) &&
+              currentRenderableEntitiesByWorld?.[worldId]?.has(report.entity) !== false
+            );
+          }),
+          ...(partial?.hiddenEntityReports ?? []),
+        ];
+      }
       if (partial !== undefined) {
-        if (refreshStructureFacts) {
-          entry.structure = {
-            ...entry.structure,
-            dispatch: partial.dispatch,
-            visibilityStats: partial.visibilityStats,
-            visibilitySnapshots: partial.visibilitySnapshots,
-            featureVisibilitySnapshots: partial.featureVisibilitySnapshots,
-            hiddenEntityReports: partial.hiddenEntityReports,
-          };
-        }
         const partialDispatch = dispatchEntriesBySlot(partial, entry.projection);
         for (const [slot, dispatch] of partialDispatch) entry.dispatchBySlot.set(slot, dispatch);
         // A changed renderable which now fails producer validation still owns
@@ -2067,8 +2180,10 @@ export class PersistentRenderScene {
       for (const removed of changedDelta.removedSlots) entry.unavailableSlots.delete(removed.slot);
       for (const recreated of changedDelta.recreatedSlots)
         entry.unavailableSlots.delete(recreated.slot);
-      entry.dispatchRevision += 1;
-      entry.dispatchCache = undefined;
+      if (partial !== undefined || removedSlots.length > 0) {
+        entry.dispatchRevision += 1;
+        entry.dispatchCache = undefined;
+      }
       entry.topology.apply(
         topologyDeltaForAvailable(changedDelta, entry.unavailableSlots, newlyUnavailable),
       );
@@ -2084,41 +2199,13 @@ export class PersistentRenderScene {
       this.transformUpdates += changedDelta.updated;
     }
 
-    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;
-    }
-    if (requiresRebuild) {
-      return this.rebuildComposition(worlds, owner, catalogEpoch, buildCandidateFrame, leases);
-    }
-    if (transformSpans.length === 0 && changedDelta === undefined) {
+    if (changedDelta === undefined) {
       this.noChangeFrames += 1;
       this.syncGpuOwner(entry.token, entry.projection);
-      const result = this.deriveFramePlan(entry, buildCandidateFrame);
-      for (let worldId = 0; worldId < nextReadVersions.length; worldId += 1) {
-        const version = nextReadVersions[worldId];
-        if (version !== undefined) entry.readVersions[worldId] = version;
-      }
-      return result;
-    }
-    if (transformSpans.length > 0) {
-      const delta = entry.projection.applyTransformSpans(transformSpans);
-      entry.topology.apply(topologyDeltaForAvailable(delta, entry.unavailableSlots, []));
-      this.syncGpuOwner(entry.token, entry.projection, delta);
-      this.deltaFrames += 1;
-      this.transformUpdates += delta.updated;
     }
     const result = this.deriveFramePlan(entry, buildCandidateFrame);
+    entry.catalogEpoch = catalogEpoch;
+    entry.instanceEpoch = instanceEpoch;
     for (let worldId = 0; worldId < nextReadVersions.length; worldId += 1) {
       const version = nextReadVersions[worldId];
       if (version !== undefined) entry.readVersions[worldId] = version;
@@ -2128,6 +2215,7 @@ export class PersistentRenderScene {
 
   invalidate(): void {
     this.composition = undefined;
+    this.shadowProjection = undefined;
     this.temporalCapture = undefined;
     this.visibilityFacets.clear();
     this.invalidateActiveEntityRevision();
@@ -2150,16 +2238,9 @@ export class PersistentRenderScene {
       ? this.composition
       : undefined;
     if (detachedComposition !== undefined) {
-      for (const slot of detachedComposition.projection.slotsSnapshot()) {
-        if (detachedComposition.worlds[slot.worldId] !== world) continue;
-        this.options.instanceCollections?.release(world, slot.entityKey);
-        if (slot.snapshot.skin === undefined) continue;
-        this.options
-          .getSkinPaletteAllocator?.()
-          ?.releaseSliceFor(`${world.identity}:${slot.entityKey}`);
-      }
+      this.composition = undefined;
+      this.shadowProjection = undefined;
     }
-    if (detachedComposition !== undefined) this.composition = undefined;
     if (detachedComposition !== undefined) this.temporalCapture = undefined;
     if (detachedComposition !== undefined) {
       this.visibilityFacets.clear();
@@ -2171,7 +2252,7 @@ export class PersistentRenderScene {
       this.stableSlotByEntity.clear();
     }
     if (this.gpuOwner !== world && this.gpuOwner !== detachedComposition?.token) return;
-    this.gpuScene?.dispose();
+    this.retireGpuScene(this.gpuScene);
     this.gpuScene = undefined;
     this.gpuOwner = undefined;
     this.gpuDevice = undefined;
@@ -2181,6 +2262,7 @@ export class PersistentRenderScene {
   /** Drop only device-owned tables; the CPU projection remains the recovery authority. */
   resetGpuForRecover(): void {
     if (this.composition !== undefined) this.composition.gpuDrivenSceneRequired = true;
+    this.retireGpuScene(this.gpuScene);
     this.gpuScene = undefined;
     this.gpuOwner = undefined;
     this.gpuDevice = undefined;
@@ -2256,6 +2338,7 @@ export class PersistentRenderScene {
       publish: () => {
         if (published || released) return;
         published = true;
+        this.retireGpuScene(this.gpuScene);
         this.gpuScene = scene;
         this.gpuOwner = composition.token;
         this.gpuDevice = device;
@@ -2301,12 +2384,13 @@ export class PersistentRenderScene {
   }
 
   dispose(): void {
-    this.gpuScene?.dispose();
+    this.retireGpuScene(this.gpuScene);
     this.gpuScene = undefined;
     this.gpuOwner = undefined;
     this.gpuDevice = undefined;
     this.gpuStatus = 'inactive';
     this.composition = undefined;
+    this.shadowProjection = undefined;
     this.temporalCapture = undefined;
     this.visibilityFacets.clear();
     this.invalidateActiveEntityRevision();
@@ -2316,6 +2400,55 @@ export class PersistentRenderScene {
     this.pointsLinesInspections = [];
   }
 
+  private retireGpuScene(scene: GpuScene | undefined, device = this.gpuDevice): void {
+    if (scene === undefined) return;
+    if (device === undefined) {
+      scene.dispose();
+      return;
+    }
+    this.retiredGpuScenes.add(scene);
+    const release = (): void => {
+      if (!this.retiredGpuScenes.delete(scene)) return;
+      scene.dispose();
+    };
+    // Retirement can happen while the current frame is still being encoded
+    // (for example when a new composition token is published).  Calling
+    // onSubmittedWorkDone() synchronously at that point observes only work
+    // already queued and may resolve before the frame that still references
+    // this scene is submitted.  Defer fence acquisition to the next
+    // microtask, after the synchronous record/submit transaction has had a
+    // chance to enqueue its command buffer.
+    void Promise.resolve()
+      .then(() => {
+        try {
+          return device.queue.onSubmittedWorkDone();
+        } catch {
+          return undefined;
+        }
+      })
+      .then(release, release);
+  }
+
+  /** Read existing culling bounds; never expose cached mutable arrays. */
+  bounds(world: World, entity: number): RenderSceneBounds | undefined {
+    const entry = this.composition;
+    const worldId = entry?.worlds.indexOf(world) ?? -1;
+    if (entry === undefined || worldId < 0) return undefined;
+    const slot = entry.projection.slot(worldId, entity);
+    if (slot === undefined) return undefined;
+    const bounds = entry.projection.cullingWorldBoundsAt(slot);
+    if (bounds === undefined) return undefined;
+    for (const axis of [0, 1, 2] as const) {
+      if (
+        !Number.isFinite(bounds.min[axis]) ||
+        !Number.isFinite(bounds.max[axis]) ||
+        bounds.min[axis] > bounds.max[axis]
+      )
+        return undefined;
+    }
+    return { min: [...bounds.min], max: [...bounds.max] };
+  }
+
   inspect(): PersistentRenderSceneInspection {
     const entry = this.composition;
     const pointsLines = this.pointsLinesInspections;
@@ -2327,6 +2460,9 @@ export class PersistentRenderScene {
       transformUpdates: this.transformUpdates,
       lastResyncReason: this.lastResyncReason,
       projectionRecords: entry?.projection.inspect().records.length ?? 0,
+      ...(entry === undefined
+        ? {}
+        : { instanceBoundsCache: entry.projection.inspect().instanceBoundsCache }),
       ...(entry === undefined ? {} : { probeBlend: entry.probeProjection.inspect() }),
       topology:
         entry?.topology.inspect() ??
@@ -2353,6 +2489,11 @@ export class PersistentRenderScene {
       plan: entry.topology.plan(),
       slots: entry.projection.slotsSnapshot(),
       worldKeys: entry.worldKeys,
+      structureMetrics: {
+        worldEntitiesScanned: this.worldEntitiesScanned,
+        sceneTableUploadBytes: this.sceneTableUploadBytes,
+        paletteUploadBytes: 0,
+      },
     };
   }
 
@@ -2408,9 +2549,9 @@ export class PersistentRenderScene {
     return { status: 'inactive' };
   }
 
-  private rebuildComposition(
+  private reconcileComposition(
     worlds: readonly World[],
-    owner: { readonly cameraOwner: number; readonly resourceOwner: number },
+    _owner: { readonly cameraOwner: number; readonly resourceOwner: number },
     catalogEpoch: number,
     buildCandidateFrame: (request: PersistentRenderCandidateRequest) => ExtractedFrame,
     leases?: readonly RenderReadLease[],
@@ -2471,8 +2612,28 @@ export class PersistentRenderScene {
       renderables: sortedRenderables,
       dispatch: sortedDispatch,
     };
-    const projection = new RenderScene();
-    projection.reset(sortedRenderables);
+    const projection = previousEntry?.projection ?? new RenderScene();
+    if (previousEntry !== undefined) {
+      projection.remapWorlds(previousEntry.worlds.map((world) => worlds.indexOf(world)));
+    }
+    const desired = new Set(
+      sortedRenderables.map((snapshot) => identityKey(snapshot.worldId, snapshot.entityKey)),
+    );
+    const operations: RenderSceneOperation[] = [];
+    for (const slot of projection.slotsSnapshot()) {
+      if (!desired.has(identityKey(slot.worldId, slot.entityKey))) {
+        operations.push({ kind: 'remove', worldId: slot.worldId, entityKey: slot.entityKey });
+      }
+    }
+    for (const snapshot of sortedRenderables) {
+      operations.push({
+        kind: 'update',
+        worldId: snapshot.worldId,
+        entityKey: snapshot.entityKey,
+        snapshot,
+      });
+    }
+    const delta = projection.apply(operations);
     this.stableSlotByEntity.clear();
     for (const slot of projection.slotsSnapshot()) {
       const stableWorld = worldKeys[slot.worldId] ?? slot.worldId;
@@ -2480,28 +2641,20 @@ export class PersistentRenderScene {
     }
     const transmissionDemand = new PersistentTransmissionDemandProjection();
     transmissionDemand.apply(transmissionDemandOperations(candidateFrame.renderables));
-    const topology = new BatchTopology();
-    topology.rebuild(projection.slotsSnapshot());
+    const topology = previousEntry?.topology ?? new BatchTopology();
+    topology.apply(delta);
     const skinConsumersByJoint = new Map<string, Set<number>>();
     for (const snapshot of stableCandidateFrame.renderables) {
       if (snapshot.skinJointEntities !== undefined) addSkinConsumer(skinConsumersByJoint, snapshot);
     }
-    const token = {};
+    const token = previousEntry?.token ?? {};
     const entry: PersistentCompositionEntry = {
       token,
       worlds: [...worlds],
-      cameraOwner: owner.cameraOwner,
-      resourceOwner: owner.resourceOwner,
       projection,
       topology,
       transmissionDemand,
-      structure: {
-        dispatch: stableCandidateFrame.dispatch,
-        visibilityStats: stableCandidateFrame.visibilityStats,
-        visibilitySnapshots: stableCandidateFrame.visibilitySnapshots,
-        featureVisibilitySnapshots: stableCandidateFrame.featureVisibilitySnapshots,
-        hiddenEntityReports: stableCandidateFrame.hiddenEntityReports,
-      },
+      hiddenEntityReports: stableCandidateFrame.hiddenEntityReports,
       worldKeys,
       readVersions:
         leases === undefined || leases.length !== worlds.length
@@ -2526,6 +2679,7 @@ export class PersistentRenderScene {
       pendingRenderableEntitiesByWorld: worlds.map(() => new Set<number>()),
       unavailableSlots: new Set<number>(),
       catalogEpoch,
+      instanceEpoch: this.options.instanceCollections?.epoch ?? 0,
       probeProjection: new ProbeBlendSceneProjection(),
       temporalDemanded: frameDemandsTemporal(candidateFrame),
       gpuDrivenSceneRequired: true,
@@ -2539,8 +2693,8 @@ export class PersistentRenderScene {
     // later rebuild.
     this.projectReflectionProbes(candidateFrame.reflectionProbes ?? []);
     this.projectProbes(entry, candidateFrame);
-    this.syncGpuOwner(token, projection, undefined, true);
-    this.fullRebuilds += 1;
+    this.syncGpuOwner(token, projection, delta);
+    if (previousEntry === undefined) this.fullRebuilds += 1;
     this.lastResyncReason = 'attach';
     const materialized = projection.materialize();
     const candidates = entry.temporalDemanded
@@ -2553,16 +2707,14 @@ export class PersistentRenderScene {
       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);
-      },
-    );
+    const ownedFrame = this.projectShadowOwnership(frameWithProbes);
+    this.shadowProjection = { renderables: ownedFrame.renderables, dispatch: ownedFrame.dispatch };
+    const result = cullPersistentFrame(ownedFrame, ownedFrame.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;
@@ -2589,17 +2741,17 @@ export class PersistentRenderScene {
   ): ExtractedFrame {
     const resourceFrame = buildCandidateFrame('none');
     const cachedDispatch = entry.dispatchCache;
-    const dispatch: DispatchEntry[] = [
-      ...(cachedDispatch?.revision === entry.dispatchRevision
+    const dispatch =
+      cachedDispatch?.revision === entry.dispatchRevision
         ? cachedDispatch.value
-        : dispatchForProjection(entry.dispatchBySlot, entry.projection, entry.unavailableSlots)),
-    ];
+        : dispatchForProjection(entry.dispatchBySlot, entry.projection, entry.unavailableSlots);
     if (cachedDispatch?.revision !== entry.dispatchRevision) {
       entry.dispatchCache = { revision: entry.dispatchRevision, value: dispatch };
     }
     const candidateFrame: ExtractedFrame = {
       ...resourceFrame,
-      ...entry.structure,
+      hiddenEntityReports: entry.hiddenEntityReports,
+      visibilityStats: { explicitlyHidden: entry.hiddenEntityReports.length },
       dispatch,
     };
     entry.temporalDemanded = frameDemandsTemporal(candidateFrame);
@@ -2626,22 +2778,55 @@ export class PersistentRenderScene {
       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);
-      },
-    );
+    const ownedFrame = this.projectShadowOwnership(frameWithProbes);
+    this.shadowProjection = { renderables: ownedFrame.renderables, dispatch: ownedFrame.dispatch };
+    const result = cullPersistentFrame(ownedFrame, ownedFrame.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 projectShadowOwnership(frame: ExtractedFrame): ExtractedFrame {
+    const shadowCasterEntityKeys = new Set<number>();
+    const shadowCasterDrawKeys = new Set<string>();
+    const shadowCasterMembership: NonNullable<ExtractedFrame['shadowCasterMembership']>[number][] =
+      [];
+    for (
+      let renderableIndex = 0;
+      renderableIndex < frame.renderables.length;
+      renderableIndex += 1
+    ) {
+      const snapshot = frame.renderables[renderableIndex];
+      if (snapshot === undefined || snapshot.authorVisible === false) continue;
+      const worldEntity = worldEntityKey(snapshot.worldId, snapshot.entityKey);
+      for (const pass of snapshot.shadowCasterPasses ?? []) {
+        shadowCasterMembership.push({ ...pass, worldEntity, renderableIndex });
+        shadowCasterEntityKeys.add(worldEntity);
+        shadowCasterDrawKeys.add(
+          gpuDrivenShadowDrawKey(
+            worldEntity,
+            pass.materialHandle,
+            pass.drawItemIndex,
+            pass.passIndex,
+          ),
+        );
+      }
+    }
+    for (const draw of frame.dispatch) {
+      if (draw.tags.LightMode !== 'ShadowCaster') continue;
+      const snapshot = frame.renderables[draw.renderableIndex];
+      if (snapshot !== undefined)
+        shadowCasterEntityKeys.add(worldEntityKey(snapshot.worldId, snapshot.entityKey));
+    }
+    return { ...frame, shadowCasterEntityKeys, shadowCasterDrawKeys, shadowCasterMembership };
+  }
+
   private projectProbes(entry: PersistentCompositionEntry, frame: ExtractedFrame): void {
     const sky =
       frame.skylight === undefined
@@ -2692,14 +2877,19 @@ export class PersistentRenderScene {
     owner: object,
     projection: RenderScene,
     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
-      ? acquired.scene.rebuild(projection.slotsSnapshot())
-      : delta === undefined
+    if (acquired === undefined) {
+      this.sceneTableUploadBytes = 0;
+      return;
+    }
+    if (acquired.rebuilt) {
+      this.sceneTableUploadBytes = acquired.uploadBytes;
+      return;
+    }
+    const result =
+      delta === undefined
         ? acquired.scene.sync({
             created: 0,
             updated: 0,
@@ -2708,22 +2898,32 @@ export class PersistentRenderScene {
             ignoredLateUpdates: 0,
             createdSlots: [],
             updatedSlots: [],
+            contentUpdatedSlots: [],
+            instanceUpdatedSlots: [],
             removedSlots: [],
             recreatedSlots: [],
             resynced: 0,
           })
         : acquired.scene.sync(delta);
-    if (!result.ok) this.failGpu(result.error);
+    if (!result.ok) {
+      this.sceneTableUploadBytes = 0;
+      this.failGpu(result.error);
+      return;
+    }
+    this.sceneTableUploadBytes = result.value.bytes;
   }
 
   private acquireGpuScene(
     owner: object,
     projection: RenderScene,
-  ): { readonly scene: GpuScene; readonly rebuilt: boolean } | undefined {
+  ):
+    | { readonly scene: GpuScene; readonly rebuilt: boolean; readonly uploadBytes: number }
+    | undefined {
     const getDevice = this.options.getDevice;
     if (getDevice === undefined) return undefined;
     const device = getDevice();
     if (this.gpuDevice !== undefined && this.gpuDevice !== device) {
+      this.retireGpuScene(this.gpuScene, this.gpuDevice);
       this.gpuScene = undefined;
       this.gpuOwner = undefined;
       this.gpuStatus = 'rebuild-pending';
@@ -2731,9 +2931,23 @@ export class PersistentRenderScene {
     if (this.gpuStatus === 'error' && this.gpuDevice === device) return undefined;
     if (this.gpuStatus === 'unsupported' && this.gpuDevice === device) return undefined;
     if (this.gpuScene !== undefined && this.gpuOwner === owner) {
-      return { scene: this.gpuScene, rebuilt: false };
+      return { scene: this.gpuScene, rebuilt: false, uploadBytes: 0 };
+    }
+    if (this.gpuScene !== undefined && this.gpuDevice === device) {
+      // Composition rebuilds replace the CPU projection token, but the GPU
+      // table resource can be rebuilt in place. Keeping one scene identity
+      // avoids destroying buffers that cached frame graphs still reference
+      // and lets queue ordering preserve writes across the next submission.
+      const rebuilt = this.gpuScene.rebuild(projection.slotsSnapshot());
+      if (!rebuilt.ok) {
+        this.failGpu(rebuilt.error);
+        return undefined;
+      }
+      this.gpuOwner = owner;
+      this.gpuStatus = 'resident';
+      return { scene: this.gpuScene, rebuilt: true, uploadBytes: rebuilt.value.bytes };
     }
-    if (this.gpuScene !== undefined) this.gpuScene.dispose();
+    this.retireGpuScene(this.gpuScene);
     this.gpuScene = undefined;
     this.gpuOwner = undefined;
     this.gpuDevice = device;
@@ -2756,11 +2970,11 @@ export class PersistentRenderScene {
     this.gpuScene = scene;
     this.gpuOwner = owner;
     this.gpuStatus = 'resident';
-    return { scene, rebuilt: true };
+    return { scene, rebuilt: true, uploadBytes: rebuilt.value.bytes };
   }
 
   private failGpu(error: RhiError): void {
-    this.gpuScene?.dispose();
+    this.retireGpuScene(this.gpuScene);
     this.gpuScene = undefined;
     this.gpuOwner = undefined;
     this.gpuStatus = 'error';