@forgeax/engine-render 0.1.33 → 0.1.35

package/src/scene/render-scene.ts

@@ -1,29 +1,17 @@
-import type { EntityHandle, Query, World } from '@forgeax/engine-ecs';
-import { componentId } from '@forgeax/engine-ecs/internal';
-import type { RenderReadLease, RenderReadVersion } from '@forgeax/engine-ecs/projection';
+import { RuntimeMaterialValue, RuntimeMeshVertices } from '@forgeax/engine-assets-runtime';
+import type { EntityHandle, World } from '@forgeax/engine-ecs';
+import type {
+  RenderReadLease,
+  RenderReadVersion,
+  StateProjection,
+  StateProjectionBatch,
+} from '@forgeax/engine-ecs/projection';
 import { box3, frustum, mat4 } from '@forgeax/engine-math';
 import { type RhiDevice, RhiError } from '@forgeax/engine-rhi';
-import {
-  ChildOf,
-  collectSubtree,
-  GlobalTransform,
-  MorphWeights,
-  Transform,
-} from '@forgeax/engine-scene';
+import { ChildOf, Children, GlobalTransform, MorphWeights } from '@forgeax/engine-scene';
 import { Skin } from '@forgeax/engine-skinning';
 import { err, ok, type Result } from '@forgeax/engine-types';
-import {
-  Instances,
-  Layer,
-  Lines,
-  MeshFilter,
-  MeshRenderer,
-  Points,
-  SortKey,
-  SpriteInstances,
-  SpriteRegionOverride,
-  Visibility,
-} from '../components';
+import { Instances, Lines, Points, SpriteInstances, Visibility } from '../components';
 import type { DeviceScope, LifecycleResourceSpec } from '../device/device-scope';
 import { gpuDrivenShadowDrawKey } from '../extract/gpu-driven';
 import { motionBlurTemporalDemand } from '../features/motion-blur/motion-blur-params';
@@ -37,10 +25,12 @@ import type {
   GpuDrivenStructureMetrics,
   PersistentRenderSceneInspection,
 } from '../inspection-types';
-import type { InstanceCollectionStore } from '../instances';
+import type { InstanceProjectionStore } from '../instances';
 import { fingerprintNumericArray, InstanceBoundsCache } from '../instances-derived-bounds';
 import type { PointsLinesInspection } from '../points-lines/inspection';
 import type { PointsLinesRetainedSnapshot } from '../points-lines/snapshot';
+import type { PreparedRenderPublication } from '../publication/receiver';
+import type { RenderResourceScope } from '../publication/resource-scope';
 import { worldEntityKey } from '../record/frame-snapshot';
 import {
   type ReflectionProbeFact,
@@ -62,7 +52,11 @@ import {
   type TransmissionDemand,
   type TransmissionDemandOperation,
 } from '../transmission/projection';
-import { ProbeBlendSceneProjection, type ProbeSceneObjectInput } from './probe-blend';
+import {
+  type ProbeBlendBufferProjection,
+  ProbeBlendSceneProjection,
+  type ProbeSceneObjectInput,
+} from './probe-blend';
 import type {
   RenderSceneApplyResult,
   RenderSceneBounds,
@@ -72,6 +66,13 @@ import type {
   RenderSceneResyncReason,
   RenderSceneSlot,
 } from './render-scene-types';
+import {
+  createGlobalTransformChangeQuery,
+  createRenderSourceState,
+  type GlobalTransformChangeQuery,
+  isRenderableMember,
+  RENDERABLE_SOURCE_COMPONENTS,
+} from './render-source';
 import { buildShadowFrusta } from './shadow-visibility';
 import { createVisibilityBudget, type VisibilityBudget } from './visibility/budget';
 import {
@@ -114,8 +115,6 @@ interface WorldTransformSpan {
   readonly worlds: Readonly<Float32Array>;
 }
 
-type GlobalTransformChangeQuery = Query<readonly [typeof GlobalTransform]>;
-
 function sameInstanceIdentitySet(
   current: Uint32Array | undefined,
   previous: Uint32Array | undefined,
@@ -402,16 +401,33 @@ export class RenderScene {
       return this.emptyResult();
     }
 
-    for (const operation of operations) {
+    // Prepare every potentially fallible payload copy before mutating retained
+    // columns. The commit loop below only uses owned POD and borrowed numeric spans.
+    const preparedOperations = operations.map((operation): RenderSceneOperation => {
+      if (operation.kind === 'remove') return operation;
       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');
       }
-    }
+      return {
+        ...operation,
+        ...(operation.snapshot === undefined ? {} : { snapshot: ownSnapshot(operation.snapshot) }),
+        ...(operation.instances === undefined
+          ? {}
+          : {
+              instances: {
+                ...operation.instances,
+                transforms: new Float32Array(operation.instances.transforms),
+                ...(operation.instances.generations === undefined
+                  ? {}
+                  : { generations: new Uint32Array(operation.instances.generations) }),
+              },
+            }),
+      };
+    });
     this.deltaFrames += 1;
     this.renderableScans = operations.length;
     const pendingByWorld = new Map<number, Map<number, PendingIdentity>>();
@@ -453,7 +469,7 @@ export class RenderScene {
         }
       }
     };
-    for (const operation of operations) {
+    for (const operation of preparedOperations) {
       const pending = pendingFor(operation.worldId, operation.entityKey);
       if (operation.kind === 'remove') {
         pending.current = undefined;
@@ -462,7 +478,7 @@ export class RenderScene {
       }
       if (operation.snapshot !== undefined) {
         const previousMaterials = pending.current?.materials;
-        const next = ownSnapshot(operation.snapshot);
+        const next = operation.snapshot;
         pending.current =
           previousMaterials !== undefined &&
           previousMaterials.length === next.materials.length &&
@@ -478,13 +494,7 @@ export class RenderScene {
       if (operation.instances !== undefined) {
         pending.current = {
           ...pending.current,
-          instances: {
-            ...operation.instances,
-            transforms: new Float32Array(operation.instances.transforms),
-            ...(operation.instances.generations === undefined
-              ? {}
-              : { generations: new Uint32Array(operation.instances.generations) }),
-          },
+          instances: operation.instances,
         };
         pending.instanceChanged = true;
       }
@@ -753,6 +763,11 @@ export class RenderScene {
     return this.slotSnapshot;
   }
 
+  /** Cheap owner revision for retained derived projections. */
+  revisionValue(): number {
+    return this.revision;
+  }
+
   slot(worldId: number, entityKey: number): RenderSceneSlot | undefined {
     return this.lookup(worldId, entityKey);
   }
@@ -1047,10 +1062,10 @@ export class RenderScene {
 export interface PersistentRenderSceneOptions {
   readonly getDevice?: (() => RhiDevice) | undefined;
   readonly onGpuError?: ((error: RhiError) => void) | undefined;
-  readonly onSharedRefMutation?: ((worldId: number, handle: number) => void) | undefined;
+  readonly onRuntimeAssetChange?: ((worldId: number, handle: number) => void) | undefined;
   readonly configuredQueryBudget?: number | undefined;
-  /** Producer-owned instance collections consumed by the same source update flow. */
-  readonly instanceCollections?: InstanceCollectionStore | undefined;
+  /** Instance projection accepted by the same World source update flow. */
+  readonly instanceCollections?: InstanceProjectionStore | undefined;
 }
 
 export interface PersistentGpuDrivenState {
@@ -1059,7 +1074,11 @@ export interface PersistentGpuDrivenState {
   readonly slots: readonly RenderSceneSlot[];
   /** Stable renderer-local World keys aligned with RenderSceneSlot.worldId. */
   readonly worldKeys?: readonly number[];
+  /** Public World identities aligned with RenderSceneSlot.worldId. */
+  readonly worldIdentities?: readonly string[];
   readonly structureMetrics?: GpuDrivenStructureMetrics;
+  /** Stable retained ProbeBlend upload projection from the Scene owner. */
+  readonly probeBlend?: ProbeBlendBufferProjection;
 }
 
 export interface CpuDirectViewInput {
@@ -1127,7 +1146,7 @@ type PersistentGpuSceneInspection = PersistentRenderSceneInspection['gpu'];
 
 interface PersistentCompositionEntry {
   readonly token: object;
-  readonly worlds: readonly World[];
+  readonly worlds: readonly RenderResourceScope[];
   readonly projection: RenderScene;
   readonly topology: BatchTopology;
   readonly transmissionDemand: PersistentTransmissionDemandProjection;
@@ -1137,7 +1156,11 @@ interface PersistentCompositionEntry {
   readonly readVersions: RenderReadVersion[];
   readonly leaseIdentities: readonly string[];
   readonly transformQueries: readonly GlobalTransformChangeQuery[];
-  readonly renderChangeQueries: readonly ReadonlyMap<number, Query>[];
+  readonly sourceStates: readonly {
+    projection: StateProjection;
+    entities: Map<number, EntityHandle>;
+    contentHandles: Map<number, readonly number[]>;
+  }[];
   readonly dispatchBySlot: Map<number, readonly DispatchEntry[]>;
   dispatchRevision: number;
   dispatchCache: { readonly revision: number; readonly value: DispatchEntry[] } | undefined;
@@ -1147,81 +1170,18 @@ interface PersistentCompositionEntry {
   /** Slots retained for recovery but excluded from direct and indirect submission. */
   readonly unavailableSlots: Set<number>;
   catalogEpoch: number;
-  instanceEpoch: number;
   readonly probeProjection: ProbeBlendSceneProjection;
+  probeObjects:
+    | {
+        readonly revision: number;
+        readonly value: readonly ProbeSceneObjectInput[];
+        readonly surfaceValue: readonly ProbeSceneObjectInput[];
+      }
+    | undefined;
   temporalDemanded: boolean;
   gpuDrivenSceneRequired: boolean;
 }
 
-// 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,
-  MeshFilter,
-  MeshRenderer,
-  Instances,
-  SpriteInstances,
-  SpriteRegionOverride,
-  Skin,
-  Layer,
-  Visibility,
-  MorphWeights,
-  Points,
-  Lines,
-  SortKey,
-] as const;
-const RENDERABLE_SOURCE_COMPONENT_IDS = new Set(
-  RENDERABLE_SOURCE_COMPONENTS.map((component) => componentId(component)),
-);
-const VISIBILITY_DEPENDENCY_COMPONENT_IDS = new Set([
-  componentId(ChildOf),
-  componentId(Visibility),
-]);
-const STRUCTURAL_MEMBERSHIP_SCAN_COMPONENT_IDS = new Set([
-  componentId(ChildOf),
-  componentId(Layer),
-  componentId(Visibility),
-  componentId(SpriteRegionOverride),
-  componentId(SortKey),
-]);
-
-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 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;
-    // The initial full extraction has already consumed this change evidence.
-    // Keep the query compiled so subsequent frames iterate only rows whose
-    // component version changed.
-    for (const _span of query.spans().unwrap()) {
-      // Establish the observation baseline.
-    }
-    queries.set(componentId(component), query);
-  }
-  return queries;
-}
-
-function collectRenderableEntities(world: World): ReadonlySet<number> {
-  const result = new Set<number>();
-  const query = world.query({ read: [MeshRenderer], with: [Transform, MeshFilter] }).unwrap();
-  for (const row of query) result.add(row.entity as number);
-  return result;
-}
-
 function sourceMembershipChanged(world: World, slot: RenderSceneSlot): boolean {
   const entity = slot.entityKey as EntityHandle;
   const snapshot = slot.snapshot;
@@ -1576,7 +1536,7 @@ export class PersistentRenderScene {
     return this.visibilityBudget;
   }
 
-  private visibilityWorldKey(world: World | undefined, fallback: number): number {
+  private visibilityWorldKey(world: RenderResourceScope | undefined, fallback: number): number {
     if (world === undefined) return fallback;
     const existing = this.visibilityWorldKeys.get(world.identity);
     if (existing !== undefined) return existing;
@@ -1586,12 +1546,12 @@ export class PersistentRenderScene {
     return key;
   }
 
-  private worldKeyAt(worlds: readonly World[], worldId: number): number {
+  private worldKeyAt(worlds: readonly RenderResourceScope[], 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[] {
+  visibilityWorldKeysFor(worlds: readonly RenderResourceScope[]): readonly number[] {
     return worlds.map((world, worldId) => this.visibilityWorldKey(world, worldId));
   }
 
@@ -1600,6 +1560,10 @@ export class PersistentRenderScene {
     return this.composition?.projection.slotsSnapshot() ?? [];
   }
 
+  compositionSlot(worldId: number, entityKey: number): RenderSceneSlot | undefined {
+    return this.composition?.projection.slot(worldId, entityKey);
+  }
+
   shadowCasterProjection(): PersistentShadowCasterProjection | undefined {
     return this.shadowProjection;
   }
@@ -1610,7 +1574,7 @@ export class PersistentRenderScene {
   }
 
   private stableEntityKey(
-    worlds: readonly World[],
+    worlds: readonly RenderResourceScope[],
     renderable: Pick<RenderableSnapshot, 'worldId' | 'entityKey'>,
   ): number {
     return worldEntityKey(this.worldKeyAt(worlds, renderable.worldId), renderable.entityKey);
@@ -1618,7 +1582,7 @@ export class PersistentRenderScene {
 
   /** Feed the facet from extracted renderables using persistent slot identity. */
   updateVisibilityFacet(
-    worlds: readonly World[],
+    worlds: readonly RenderResourceScope[],
     camera: CameraSnapshot | undefined,
     renderables: readonly RenderableSnapshot[],
   ): void {
@@ -1678,7 +1642,7 @@ export class PersistentRenderScene {
    * visible through `decideVisibility`.
    */
   projectVisibility(
-    worlds: readonly World[],
+    worlds: readonly RenderResourceScope[],
     camera: CameraSnapshot | undefined,
     renderables: readonly RenderableSnapshot[],
     dispatch: readonly DispatchEntry[],
@@ -1852,6 +1816,77 @@ export class PersistentRenderScene {
     return this.reflectionProbes.snapshot();
   }
 
+  consumePublication(input: PreparedRenderPublication): ExtractedFrame {
+    const { resources, packet, frame } = input;
+    let entry = this.composition;
+    if (entry === undefined || packet.baseline) {
+      this.invalidate();
+      const projection = new RenderScene();
+      entry = {
+        token: {},
+        worlds: [resources],
+        projection,
+        topology: new BatchTopology(),
+        transmissionDemand: new PersistentTransmissionDemandProjection(),
+        hiddenEntityReports: [],
+        worldKeys: this.visibilityWorldKeysFor([resources]),
+        readVersions: [],
+        leaseIdentities: [],
+        transformQueries: [],
+        sourceStates: [],
+        dispatchBySlot: new Map(),
+        dispatchRevision: 0,
+        dispatchCache: undefined,
+        skinConsumersByJoint: new Map(),
+        pendingRenderableEntitiesByWorld: [],
+        unavailableSlots: new Set(),
+        catalogEpoch: 0,
+        probeProjection: new ProbeBlendSceneProjection(),
+        probeObjects: undefined,
+        temporalDemanded: false,
+        gpuDrivenSceneRequired: true,
+      };
+      this.composition = entry;
+      this.fullRebuilds++;
+      this.lastResyncReason = 'attach';
+    }
+    this.worldEntitiesScanned = 0;
+    this.sceneTableUploadBytes = 0;
+    const removedDemand: TransmissionDemandOperation[] = [];
+    for (const operation of input.operations) {
+      if (operation.kind !== 'remove' && operation.snapshot === undefined) continue;
+      const previous = entry.projection.slot(0, operation.entityKey);
+      for (let index = 0; index < (previous?.snapshot.materials.length ?? 0); index++)
+        removedDemand.push({ kind: 'remove', key: `0:${operation.entityKey}:${index}` });
+    }
+    const delta = entry.projection.apply(input.operations);
+    for (const removed of delta.removedSlots) {
+      entry.dispatchBySlot.delete(removed.slot);
+      this.stableSlotByEntity.delete(worldEntityKey(entry.worldKeys[0] ?? 0, removed.entityKey));
+    }
+    for (const recreated of delta.recreatedSlots) entry.dispatchBySlot.delete(recreated.slot);
+    for (const [slot, dispatch] of dispatchEntriesBySlot(frame, entry.projection))
+      entry.dispatchBySlot.set(slot, dispatch);
+    if (frame.renderables.length || packet.removed.length) {
+      entry.dispatchRevision++;
+      entry.dispatchCache = undefined;
+      this.visibilityFacets.clear();
+      this.invalidateActiveEntityRevision();
+    }
+    for (const slot of [...delta.createdSlots, ...delta.updatedSlots, ...delta.recreatedSlots])
+      this.stableSlotByEntity.set(worldEntityKey(entry.worldKeys[0] ?? 0, slot.entityKey), slot);
+    entry.transmissionDemand.apply([
+      ...removedDemand,
+      ...transmissionDemandOperations(frame.renderables),
+    ]);
+    entry.topology.apply(delta);
+    this.syncGpuOwner(entry.token, entry.projection, delta);
+    if (input.operations.length) this.deltaFrames++;
+    else this.noChangeFrames++;
+    this.transformUpdates += delta.updated;
+    return this.deriveFramePlan(entry, frame);
+  }
+
   extractComposition(
     worlds: readonly World[],
     owner: { readonly cameraOwner: number; readonly resourceOwner: number },
@@ -1865,7 +1900,7 @@ export class PersistentRenderScene {
     const sameWorldSet =
       entry !== undefined &&
       entry.worlds.length === worlds.length &&
-      entry.worlds.every((world) => worlds.includes(world));
+      entry.worlds.every((world) => worlds.some((local) => local === world));
     const worldOrderChanged =
       entry !== undefined &&
       sameWorldSet &&
@@ -1899,7 +1934,6 @@ export class PersistentRenderScene {
         preserveVisibilityOnReorder,
       );
     }
-    let requiresSourceRefresh = false;
     const changedEntitiesByWorld = worlds.map(
       (_, worldId) => new Set(entry.pendingRenderableEntitiesByWorld[worldId] ?? []),
     );
@@ -1912,171 +1946,144 @@ export class PersistentRenderScene {
         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 currentRenderableEntitiesByWorld: readonly (ReadonlySet<number> | undefined)[] | undefined;
+    const sourceBatches: StateProjectionBatch[] = [];
     const removedSlots: RenderSceneSlot[] = [];
-    for (let worldId = 0; worldId < worlds.length; worldId += 1) {
+    const transformSpans: WorldTransformSpan[] = [];
+    for (let worldId = 0; worldId < worlds.length; worldId++) {
       const world = worlds[worldId];
-      if (world === undefined) continue;
-      const lease = leases?.[worldId];
-      if (lease === undefined || entry.leaseIdentities[worldId] !== lease.worldIdentity) {
-        requiresSourceRefresh = true;
-        break;
-      }
+      const source = entry.sourceStates[worldId];
+      const lease = leases[worldId];
       const version = entry.readVersions[worldId];
-      if (version === undefined) {
-        requiresSourceRefresh = true;
-        break;
-      }
-      let read: ReturnType<RenderReadLease['readChanges']>;
-      try {
-        read = lease.readChanges(version);
-      } catch {
-        requiresSourceRefresh = true;
-        break;
-      }
-      if (read.status === 'rebuild') {
-        structureChangedWorlds.add(worldId);
+      if (
+        world === undefined ||
+        source === undefined ||
+        lease === undefined ||
+        version === undefined
+      )
+        continue;
+      const read = lease.readChanges(version);
+      nextReadVersions[worldId] = read.version;
+      const changed = changedEntitiesByWorld[worldId];
+      const content = contentChangedByWorld[worldId];
+      if (changed === undefined || content === undefined) continue;
+      if (version.structureEpoch !== read.version.structureEpoch) {
+        this.visibilityFacets.clear();
+        this.invalidateActiveEntityRevision();
       }
-      const changes = read.world;
-      const shared = read.sharedRefs;
-      if (shared.records.length > 0) {
-        for (const record of shared.records) {
-          this.options.onSharedRefMutation?.(worldId, record.handle);
-          const changed = changedEntitiesByWorld[worldId];
-          const content = contentChangedByWorld[worldId];
-          if (changed !== undefined && content !== undefined) {
-            entry.projection.addSharedRefConsumers(worldId, record.handle, content);
-            for (const entity of content) changed.add(entity);
+      const batch = source.projection.read();
+      sourceBatches.push(batch);
+      this.worldEntitiesScanned += batch.scannedRows;
+      const dependencyVisited = new Set<number>();
+      const runtimeAssets = new Set<number>();
+      const runtimeContentChanged =
+        batch.membershipChanged ||
+        batch.changedComponents.includes(RuntimeMaterialValue) ||
+        batch.changedComponents.includes(RuntimeMeshVertices);
+      const contentComponents = RENDERABLE_SOURCE_COMPONENTS.filter(
+        (component) => component !== Instances && batch.changedComponents.includes(component),
+      );
+      const instancesChanged = batch.changedComponents.includes(Instances);
+      const reconcileIdentities =
+        batch.membershipChanged ||
+        runtimeContentChanged ||
+        contentComponents.length > 0 ||
+        instancesChanged;
+      for (const index of reconcileIdentities ? batch.indices : []) {
+        const previous = source.entities.get(index);
+        const current = source.projection.entity(index);
+        if (runtimeContentChanged) {
+          const runtimeHandles = new Set(source.contentHandles.get(index));
+          if (current !== undefined) {
+            const material = world.hasComponent(current, RuntimeMaterialValue)
+              ? world.get(current, RuntimeMaterialValue)
+              : undefined;
+            const mesh = world.hasComponent(current, RuntimeMeshVertices)
+              ? world.get(current, RuntimeMeshVertices)
+              : undefined;
+            if (material?.ok) runtimeHandles.add(Number(material.value.asset));
+            if (mesh?.ok) runtimeHandles.add(Number(mesh.value.asset));
           }
+          for (const handle of runtimeHandles) runtimeAssets.add(handle);
         }
-      }
-      for (const changedComponentId of changes.changedComponentIds) {
-        if (read.status === 'rebuild') {
-          structuralComponentIdsByWorld[worldId]?.add(changedComponentId);
-        }
-        if (!RENDERABLE_SOURCE_COMPONENT_IDS.has(changedComponentId)) continue;
-        const changed = changedEntitiesByWorld[worldId];
-        if (changed === undefined) continue;
-        const otherChanged = contentChangedByWorld[worldId];
-        const query = entry.renderChangeQueries[worldId]?.get(changedComponentId);
-        if (query !== undefined) {
-          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 (previous !== undefined) {
+          const slot = entry.projection.slot(worldId, previous);
+          if (
+            batch.membershipChanged &&
+            slot !== undefined &&
+            (current !== previous || !isRenderableMember(world, previous))
+          ) {
+            removedSlots.push(slot);
+            changed.add(previous);
           }
-        }
-      }
-      if (requiresSourceRefresh) break;
-      nextReadVersions[worldId] = read.version;
-    }
-    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)) ??
+          for (const consumer of entry.skinConsumersByJoint.get(skinJointKey(worldId, previous)) ??
             []) {
-            changedEntitiesByWorld[worldId]?.add(consumer);
-            contentChangedByWorld[worldId]?.add(consumer);
+            changed.add(consumer);
+            content.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, worldId) =>
-        structureChangedWorlds.has(worldId) ? collectRenderableEntities(world) : undefined,
-      );
-      currentRenderableEntitiesByWorld = currentByWorld;
-      for (let worldId = 0; worldId < currentByWorld.length; worldId += 1) {
-        const world = worlds[worldId];
-        const current = currentByWorld[worldId];
-        if (world === undefined || current === undefined) continue;
-        const changed = changedEntitiesByWorld[worldId];
-        if (changed !== undefined && structureChangedWorlds.has(worldId)) {
-          // A joint can disappear without leaving a row in the joint's
-          // GlobalTransform change query. Wake every dependent renderable so
-          // the next partial extraction validates the dangling reference and
-          // either republishes or retires its palette data.
-          for (const [jointKey, consumers] of entry.skinConsumersByJoint) {
-            const separator = jointKey.indexOf(':');
-            const indexedWorldId = Number(jointKey.slice(0, separator));
-            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);
-              contentChangedByWorld[worldId]?.add(consumer);
+        if (current === undefined) continue;
+        const existing = entry.projection.slot(worldId, current);
+        const membershipChanged =
+          batch.membershipChanged &&
+          (existing === undefined || sourceMembershipChanged(world, existing));
+        let contentChanged = membershipChanged;
+        for (const component of contentComponents) {
+          if (source.projection.changed(current, component)) contentChanged = true;
+        }
+        if (
+          (contentChanged || (instancesChanged && source.projection.changed(current, Instances))) &&
+          isRenderableMember(world, current)
+        ) {
+          changed.add(current);
+          if (contentChanged) content.add(current);
+        }
+        if (
+          version.structureEpoch !== read.version.structureEpoch ||
+          source.projection.changed(current, ChildOf) ||
+          source.projection.changed(current, Visibility)
+        ) {
+          if (!dependencyVisited.has(current)) {
+            const pending = [current];
+            while (pending.length > 0) {
+              const dependent = pending.pop();
+              if (dependent === undefined || dependencyVisited.has(dependent)) continue;
+              dependencyVisited.add(dependent);
+              const children = world.hasComponent(dependent, Children)
+                ? world.get(dependent, Children)
+                : undefined;
+              if (children?.ok)
+                for (const child of children.value.entities) pending.push(child as EntityHandle);
+              if (!isRenderableMember(world, dependent)) continue;
+              changed.add(dependent);
+              content.add(dependent);
             }
           }
-          for (const entity of current) {
-            if (entry.projection.slot(worldId, entity) === undefined) changed.add(entity);
-          }
-          const structuralComponentIds = structuralComponentIdsByWorld[worldId];
-          const scanAllMembership =
-            structuralComponentIds !== undefined &&
-            [...structuralComponentIds].some((id) =>
-              STRUCTURAL_MEMBERSHIP_SCAN_COMPONENT_IDS.has(id),
-            );
-          for (const slot of entry.projection.slotsSnapshot()) {
-            if (slot.worldId !== worldId || !current.has(slot.entityKey)) continue;
-            const membershipChanged = sourceMembershipChanged(world, slot);
-            if (scanAllMembership || membershipChanged) {
-              changed.add(slot.entityKey);
-              contentChangedByWorld[worldId]?.add(slot.entityKey);
+        }
+      }
+      for (const handle of runtimeAssets) {
+        this.options.onRuntimeAssetChange?.(worldId, handle);
+        entry.projection.addSharedRefConsumers(worldId, handle, content);
+      }
+      for (const entity of content) changed.add(entity);
+      const query = entry.transformQueries[worldId];
+      if (query !== undefined) {
+        for (const span of query.spans().unwrap()) {
+          const matrices = span.get(GlobalTransform).world;
+          if (!(matrices instanceof Float32Array))
+            throw new Error('GlobalTransform projection must expose a numeric column.');
+          transformSpans.push({ worldId, entities: span.entities, worlds: matrices });
+          if (entry.skinConsumersByJoint.size > 0) {
+            for (const entity of span.entities) {
+              for (const consumer of entry.skinConsumersByJoint.get(
+                skinJointKey(worldId, entity),
+              ) ?? []) {
+                changed.add(consumer);
+                content.add(consumer);
+              }
             }
           }
         }
-        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;
       }
     }
 
@@ -2089,6 +2096,8 @@ export class PersistentRenderScene {
       for (const entityKey of changedEntitiesByWorld[worldId] ?? []) pending.add(entityKey);
     }
 
+    const resourceFrame = buildCandidateFrame('none');
+    for (const batch of sourceBatches) batch.validate();
     let changedDelta: RenderSceneApplyResult | undefined;
     const hasChangedEntities = changedEntitiesByWorld.some((entities) => entities.size > 0);
     if (hasChangedEntities || removedSlots.length > 0 || transformSpans.length > 0) {
@@ -2103,9 +2112,6 @@ export class PersistentRenderScene {
       }
       for (const slot of removedSlots) {
         operations.push({ kind: 'remove', worldId: slot.worldId, entityKey: slot.entityKey });
-        if (slot.snapshot.skinJointEntities !== undefined) {
-          removeSkinConsumer(entry.skinConsumersByJoint, slot.snapshot);
-        }
         for (
           let materialIndex = 0;
           materialIndex < slot.snapshot.materials.length;
@@ -2162,7 +2168,23 @@ export class PersistentRenderScene {
         });
         publishedEntitiesByWorld[snapshot.worldId]?.add(snapshot.entityKey);
       }
+      for (const batch of sourceBatches) batch.validate();
       changedDelta = entry.projection.apply(operations, transformSpans);
+      for (const slot of changedDelta.removedSlots) {
+        const world = worlds[slot.worldId];
+        if (world !== undefined) this.options.instanceCollections?.release(world, slot.entityKey);
+      }
+      for (const snapshot of partial?.renderables ?? []) {
+        const world = worlds[snapshot.worldId];
+        if (world === undefined) continue;
+        if (snapshot.instances === undefined)
+          this.options.instanceCollections?.release(world, snapshot.entityKey);
+        else
+          this.options.instanceCollections?.accept(world, snapshot.entityKey, snapshot.instances);
+      }
+      for (const slot of removedSlots)
+        if (slot.snapshot.skinJointEntities !== undefined)
+          removeSkinConsumer(entry.skinConsumersByJoint, slot.snapshot);
       const publishedSkinKeys = new Set<string>();
       for (const snapshot of partial?.renderables ?? []) {
         publishedSkinKeys.add(`${snapshot.worldId}:${snapshot.entityKey}`);
@@ -2198,7 +2220,7 @@ export class PersistentRenderScene {
             return (
               worldId !== undefined &&
               !changedEntitiesByWorld[worldId]?.has(report.entity) &&
-              currentRenderableEntitiesByWorld?.[worldId]?.has(report.entity) !== false
+              isRenderableMember(report.world, report.entity)
             );
           }),
           ...(partial?.hiddenEntityReports ?? []),
@@ -2227,8 +2249,9 @@ export class PersistentRenderScene {
             continue;
           }
           if (slot === undefined) {
-            const current = currentRenderableEntitiesByWorld?.[worldId];
-            if (current !== undefined && !current.has(entityKey)) pending?.delete(entityKey);
+            const world = worlds[worldId];
+            if (world !== undefined && !isRenderableMember(world, entityKey))
+              pending?.delete(entityKey);
             continue;
           }
           // The producer did not publish this requested identity. Keep the
@@ -2279,9 +2302,43 @@ export class PersistentRenderScene {
       this.noChangeFrames += 1;
       this.syncGpuOwner(entry.token, entry.projection);
     }
-    const result = this.deriveFramePlan(entry, buildCandidateFrame);
+    const result = this.deriveFramePlan(entry, resourceFrame);
+    for (let worldId = 0; worldId < sourceBatches.length; worldId++) {
+      const batch = sourceBatches[worldId];
+      const source = entry.sourceStates[worldId];
+      if (batch === undefined || source === undefined) continue;
+      batch.accept();
+      if (
+        !batch.membershipChanged &&
+        !batch.changedComponents.includes(RuntimeMaterialValue) &&
+        !batch.changedComponents.includes(RuntimeMeshVertices)
+      )
+        continue;
+      for (const index of batch.indices) {
+        const entity = source.projection.entity(index);
+        if (entity === undefined) {
+          source.entities.delete(index);
+          source.contentHandles.delete(index);
+        } else {
+          source.entities.set(index, entity);
+          const handles: number[] = [];
+          const world = worlds[worldId];
+          if (world !== undefined) {
+            const material = world.hasComponent(entity, RuntimeMaterialValue)
+              ? world.get(entity, RuntimeMaterialValue)
+              : undefined;
+            const mesh = world.hasComponent(entity, RuntimeMeshVertices)
+              ? world.get(entity, RuntimeMeshVertices)
+              : undefined;
+            if (material?.ok) handles.push(Number(material.value.asset));
+            if (mesh?.ok) handles.push(Number(mesh.value.asset));
+          }
+          if (handles.length === 0) source.contentHandles.delete(index);
+          else source.contentHandles.set(index, handles);
+        }
+      }
+    }
     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;
@@ -2328,11 +2385,13 @@ export class PersistentRenderScene {
       this.stableSlotByEntity.clear();
     }
     if (this.gpuOwner !== world && this.gpuOwner !== detachedComposition?.token) return;
-    this.retireGpuScene(this.gpuScene);
-    this.gpuScene = undefined;
+    // The GPU Scene is renderer-owned. A frame graph recorded for the current
+    // device may retain its table bindings after a World detaches, while the
+    // next attached composition can rebuild the same tables in place. Keep
+    // that single scene resident until device replacement or renderer
+    // disposal; retiring it here lets a reused graph submit destroyed buffers.
     this.gpuOwner = undefined;
-    this.gpuDevice = undefined;
-    this.gpuStatus = 'inactive';
+    this.gpuStatus = this.gpuScene === undefined ? 'inactive' : 'resident';
   }
 
   /** Drop only device-owned tables; the CPU projection remains the recovery authority. */
@@ -2398,6 +2457,9 @@ export class PersistentRenderScene {
       scene,
       plan: composition.topology.plan(),
       slots,
+      worldKeys: composition.worldKeys,
+      worldIdentities: composition.worlds.map((world) => world.identity),
+      probeBlend: composition.probeProjection.recordBufferProjection(),
     });
     let published = false;
     let released = false;
@@ -2569,11 +2631,13 @@ export class PersistentRenderScene {
       plan: entry.topology.plan(),
       slots: entry.projection.slotsSnapshot(),
       worldKeys: entry.worldKeys,
+      worldIdentities: entry.worlds.map((world) => world.identity),
       structureMetrics: {
         worldEntitiesScanned: this.worldEntitiesScanned,
         sceneTableUploadBytes: this.sceneTableUploadBytes,
         paletteUploadBytes: 0,
       },
+      probeBlend: entry.probeProjection.recordBufferProjection(),
     };
   }
 
@@ -2647,7 +2711,12 @@ export class PersistentRenderScene {
     preserveVisibilityOnReorder = false,
   ): ExtractedFrame {
     const previousEntry = this.composition;
-    const candidateFrame = buildCandidateFrame('full');
+    const sourceStates = worlds.map((world) => createRenderSourceState(world));
+    const candidateFrame = buildCandidateFrame({
+      kind: 'partial',
+      entitiesByWorld: sourceStates.map((source) => new Set(source.entities.values())),
+    });
+    for (const source of sourceStates) source.batch.validate();
     this.temporalCapture = undefined;
     this.worldEntitiesScanned = candidateFrame.renderables.length;
     const worldKeys = this.visibilityWorldKeysFor(worlds);
@@ -2675,38 +2744,18 @@ export class PersistentRenderScene {
         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 stableCandidateFrame = candidateFrame;
+    const renderables = candidateFrame.renderables;
     const projection = previousEntry?.projection ?? new RenderScene();
     if (previousEntry !== undefined) {
-      projection.remapWorlds(previousEntry.worlds.map((world) => worlds.indexOf(world)));
+      projection.remapWorlds(
+        previousEntry.worlds.map((world) =>
+          (worlds as readonly RenderResourceScope[]).indexOf(world),
+        ),
+      );
     }
     const desired = new Set(
-      sortedRenderables.map((snapshot) => identityKey(snapshot.worldId, snapshot.entityKey)),
+      renderables.map((snapshot) => identityKey(snapshot.worldId, snapshot.entityKey)),
     );
     const operations: RenderSceneOperation[] = [];
     for (const slot of projection.slotsSnapshot()) {
@@ -2714,7 +2763,7 @@ export class PersistentRenderScene {
         operations.push({ kind: 'remove', worldId: slot.worldId, entityKey: slot.entityKey });
       }
     }
-    for (const snapshot of sortedRenderables) {
+    for (const snapshot of renderables) {
       operations.push({
         kind: 'update',
         worldId: snapshot.worldId,
@@ -2723,6 +2772,22 @@ export class PersistentRenderScene {
       });
     }
     const delta = projection.apply(operations);
+    for (const snapshot of renderables) {
+      const world = worlds[snapshot.worldId];
+      if (world !== undefined && snapshot.instances !== undefined)
+        this.options.instanceCollections?.accept(world, snapshot.entityKey, snapshot.instances);
+    }
+    this.options.instanceCollections?.retain(
+      new Set(
+        projection
+          .slotsSnapshot()
+          .flatMap((slot) =>
+            slot.snapshot.instances?.collectionId === undefined
+              ? []
+              : [slot.snapshot.instances.collectionId],
+          ),
+      ),
+    );
     this.stableSlotByEntity.clear();
     for (const slot of projection.slotsSnapshot()) {
       const stableWorld = worldKeys[slot.worldId] ?? slot.worldId;
@@ -2757,10 +2822,7 @@ export class PersistentRenderScene {
         leases === undefined || leases.length !== worlds.length
           ? []
           : worlds.map(createGlobalTransformChangeQuery),
-      renderChangeQueries:
-        leases === undefined || leases.length !== worlds.length
-          ? []
-          : worlds.map(createRenderChangeQueries),
+      sourceStates,
       dispatchBySlot: dispatchEntriesBySlot(stableCandidateFrame, projection),
       dispatchRevision: 0,
       dispatchCache: undefined,
@@ -2768,8 +2830,8 @@ export class PersistentRenderScene {
       pendingRenderableEntitiesByWorld: worlds.map(() => new Set<number>()),
       unavailableSlots: new Set<number>(),
       catalogEpoch,
-      instanceEpoch: this.options.instanceCollections?.epoch ?? 0,
       probeProjection: new ProbeBlendSceneProjection(),
+      probeObjects: undefined,
       temporalDemanded: frameDemandsTemporal(candidateFrame),
       gpuDrivenSceneRequired: true,
     };
@@ -2804,6 +2866,7 @@ export class PersistentRenderScene {
         ? projection.cullingWorldBounds(snapshot)
         : projection.cullingWorldBoundsAt(slot);
     });
+    for (const source of sourceStates) source.batch.accept();
     this.frameEpoch += 1;
     this.visibilityFacetFrame = undefined;
     this.visibilityProjectionCache = undefined;
@@ -2826,9 +2889,8 @@ export class PersistentRenderScene {
    */
   private deriveFramePlan(
     entry: PersistentCompositionEntry,
-    buildCandidateFrame: (request: PersistentRenderCandidateRequest) => ExtractedFrame,
+    resourceFrame: ExtractedFrame,
   ): ExtractedFrame {
-    const resourceFrame = buildCandidateFrame('none');
     const cachedDispatch = entry.dispatchCache;
     const dispatch =
       cachedDispatch?.revision === entry.dispatchRevision
@@ -2840,7 +2902,10 @@ export class PersistentRenderScene {
     const candidateFrame: ExtractedFrame = {
       ...resourceFrame,
       hiddenEntityReports: entry.hiddenEntityReports,
-      visibilityStats: { explicitlyHidden: entry.hiddenEntityReports.length },
+      visibilityStats:
+        entry.sourceStates.length === 0
+          ? resourceFrame.visibilityStats
+          : { explicitlyHidden: entry.hiddenEntityReports.length },
       dispatch,
     };
     entry.temporalDemanded = frameDemandsTemporal(candidateFrame);
@@ -2938,27 +3003,41 @@ export class PersistentRenderScene {
             ] 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 revision = entry.projection.revisionValue();
+    if (entry.probeObjects?.revision !== revision) {
+      const slots = entry.projection.slotsSnapshot();
+      const value = Object.freeze(
+        slots.map((slot) =>
+          Object.freeze({
+            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,
+            ] as const,
+          }),
+        ),
+      );
+      entry.probeObjects = {
+        revision,
+        value,
+        surfaceValue: Object.freeze(
+          value.filter((_object, index) =>
+            slots[index]?.snapshot.materials.some(
+              (material) => material.surfaceModel === 'single-layer-medium',
+            ),
+          ),
+        ),
+      };
     }
-    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,
-      ],
-    }));
+    const surfaceOnly = probes.length === 0;
     entry.probeProjection.apply({
-      objects,
+      objects: surfaceOnly ? entry.probeObjects.surfaceValue : entry.probeObjects.value,
       probes,
       sky,
+      worldRevision: revision,
+      ...(surfaceOnly ? { retainSkyResidualRecords: true } : {}),
     });
   }