@forgeax/engine-render 0.1.34 → 0.1.36

package/src/render-system-residency.ts

@@ -1,5 +1,4 @@
 import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
-import type { World } from '@forgeax/engine-ecs';
 import {
   deriveTextureLayout,
   type MaterialAsset,
@@ -11,6 +10,7 @@ import type {
   MeshMaterialBindingPreparationFailure,
   MeshMaterialBindingResidency,
 } from './mesh-material-bindings';
+import type { RenderResourceScope } from './publication/resource-scope';
 import type { RenderSystemInternals } from './record/render-context';
 import { materialSamplerHandles, materialTextureHandles } from './recovery/render-system-candidate';
 import type { MaterialSnapshot } from './render-system-extract';
@@ -49,7 +49,7 @@ function preparationFailureFrom(error: unknown): MeshMaterialBindingPreparationF
  * already resident resource remains last-known-good.
  */
 export function observeMaterialResidency(
-  world: World | undefined,
+  world: RenderResourceScope | undefined,
   material: MaterialSnapshot,
   internals: RenderSystemInternals,
 ): MeshMaterialBindingResidency {

package/src/render-system.ts

@@ -1,4 +1,9 @@
 import { projectCaptureScene } from './capture/scene-projection';
+import { renderMaterialContext } from './extract/material-context';
+import { RenderPublicationError } from './publication/contract';
+import { preparePublicationGeometry } from './publication/prepare-geometry';
+import type { PreparedRenderPublication } from './publication/receiver';
+import { type RenderResourceScope, renderTime } from './publication/resource-scope';
 import type { RenderSceneBounds } from './scene/render-scene-types';
 // @forgeax/engine-math is referenced through render-system-record.ts which builds
 // view/proj matrices and worldFromLocal via `mat4.compose / .multiply /
@@ -6,13 +11,13 @@ import type { RenderSceneBounds } from './scene/render-scene-types';
 // asserts `/@forgeax\/engine-math/` shows up in render-system.ts source).
 
 import { numMipLevels } from '@forgeax/engine-assets-runtime';
-import { Time, type World } from '@forgeax/engine-ecs';
+import type { World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
 import type { RecorderSession } from '@forgeax/engine-profiler';
 import type { CompiledRenderGraphInfo } from '@forgeax/engine-render-graph';
 import type { BindGroupLayout, Buffer, RenderPipeline, RhiDevice } from '@forgeax/engine-rhi';
 import { err, ok, type Result, RhiError } from '@forgeax/engine-rhi';
-import { type RenderPipelineAsset, toShared } from '@forgeax/engine-types';
+import { type Handle, type RenderPipelineAsset, toShared } from '@forgeax/engine-types';
 import {
   type DirectionalShadowInspectionSource,
   directionalShadowProfileFromQuality,
@@ -363,6 +368,7 @@ export interface RenderSystem {
     opts: DrawOwnerOptions,
     renderReadLeases?: readonly RenderReadLease[],
     timingCapture?: GpuTimingCapture,
+    publication?: PreparedRenderPublication,
   ): boolean;
   /**
    * Return the asset binding consumed by the last successful record pass.
@@ -604,7 +610,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   );
   let releaseProfilerCatalog =
     phaseCatalogRegistration?.ok === true ? phaseCatalogRegistration.value : undefined;
-  let preparedWorlds: readonly World[] = [];
+  let preparedWorlds: readonly RenderResourceScope[] = [];
   const resolveFeatureNoise = createFeatureNoiseResolver({
     scope: internals.deviceScope,
     getDevice: () => internals.device,
@@ -1497,7 +1503,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   let orderedDispatchCache:
     | {
         readonly source: readonly DispatchEntry[];
-        readonly world: World;
+        readonly world: RenderResourceScope;
         readonly camera: readonly CameraSnapshot[];
         readonly renderables: readonly RenderableSnapshot[];
         readonly value: readonly DispatchEntry[];
@@ -1628,7 +1634,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     (
       runtime: RenderSystemInternals,
       gpuWork: RenderFeatureGpuWorkOwner,
-      worlds: readonly World[],
+      worlds: readonly RenderResourceScope[],
       caches: PreparedResolverCaches,
     ) =>
     (input: RenderFeaturePreparedGraphicsResolverInput): PreparedGraphicsResolver => {
@@ -1845,7 +1851,6 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           ) {
             return preparedMaterialBindings(
               runtime,
-              caches,
               worlds,
               materialShaderId,
               material.world,
@@ -2198,9 +2203,12 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       opts: DrawOwnerOptions,
       renderReadLeases?: readonly RenderReadLease[],
       timingCapture?: GpuTimingCapture,
+      publication?: PreparedRenderPublication,
     ): boolean {
       const composition = canonicalizeWorldComposition(worlds, opts, renderReadLeases);
-      const compositionWorlds = composition.worlds;
+      const sourceWorlds = composition.worlds;
+      const compositionWorlds: readonly RenderResourceScope[] =
+        publication === undefined ? sourceWorlds : [publication.resources];
       const compositionLeases = composition.leases;
       preparedWorlds = compositionWorlds;
       const profileSession = internals.profiler?.activeSession();
@@ -2240,21 +2248,45 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           // so a hot-swap cannot reuse passes compiled for the retired pipeline.
           resetRenderFeatureGraphState(internals);
           lastBuiltPipelineHandle = frameState.installedPipelineHandle;
-          persistentRenderScene.invalidate();
+          if (publication === undefined) persistentRenderScene.invalidate();
         }
         dispatchCounts.unlit = 0;
 
-        const resourceWorld = compositionWorlds[resourceOwner] as World;
+        const resourceWorld = compositionWorlds[resourceOwner] as RenderResourceScope;
         let frame: ReturnType<PersistentRenderScene['extractComposition']>;
         try {
           frame = runProfiledRenderPhase(profileSession, 'extract', () => {
+            if (publication !== undefined) {
+              for (const handle of [
+                ...publication.packet.invalidatedAssets,
+                ...publication.packet.retiredAssets,
+              ]) {
+                internals.gpuStore.invalidateMesh(handle, publication.resources);
+                internals.gpuStore.evictTexture(
+                  handle as Handle<'TextureAsset', 'shared'>,
+                  publication.resources,
+                );
+              }
+              return persistentRenderScene.consumePublication(
+                preparePublicationGeometry(
+                  publication,
+                  persistentRenderScene,
+                  internals.getPipelineState()?.skinPaletteAllocator,
+                  internals.assets,
+                  instanceCollections,
+                  internals.device.caps.storageBuffer
+                    ? internals.getMaterialShaderArtifact
+                    : undefined,
+                ),
+              );
+            }
             return persistentRenderScene.extractComposition(
-              compositionWorlds,
+              sourceWorlds,
               { cameraOwner, resourceOwner },
               internals.assets.catalogEpoch,
               (renderables) =>
                 extractFrames(
-                  compositionWorlds,
+                  sourceWorlds,
                   {
                     cameraOwner,
                     resourceOwner,
@@ -2264,25 +2296,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                   internals.getPipelineState(),
                   persistentRenderScene.materialSnapshotCacheStore(),
                   {
-                    ...(internals.device.caps.backendKind === 'null'
-                      ? {}
-                      : {
-                          materialContext: {
-                            backend:
-                              internals.device.caps.backendKind === 'wgpu-webgl2'
-                                ? ('webgl2' as const)
-                                : internals.device.caps.backendKind,
-                            capability: internals.device.caps.storageBuffer
-                              ? ('storage-buffer' as const)
-                              : ('uniform-fallback' as const),
-                            pipeline: 'forward' as const,
-                            geometry: 'mesh' as const,
-                            pass: 'forward' as const,
-                            profile: 'forgeax-material-wgsl-v1' as const,
-                            toolchain: 'naga-oil' as const,
-                            instrumentation: 'none' as const,
-                          },
-                        }),
+                    ...renderMaterialContext(internals.device.caps),
                     cull: 'none',
                     retainHidden: true,
                     renderables,
@@ -2308,6 +2322,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         lastMotionBlurInvalidParams = undefined;
         const {
           cameras: extractedCameras,
+          auxiliaryCameras,
           cubeCameras,
           lights,
           environment,
@@ -2333,7 +2348,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           frameState,
           internals,
           cameras[0],
-          compositionWorlds[cameraOwner] as World,
+          compositionWorlds[cameraOwner] as RenderResourceScope,
         );
         if (!preparedOutput.ok) {
           internals.errorRegistry.fire(preparedOutput.error);
@@ -2814,7 +2829,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         const motionBlurParams = cameras[0]?.motionBlur;
         let motionBlurDelta = 0;
         try {
-          const delta = (compositionWorlds[cameraOwner] as World).getResource(Time).delta;
+          const delta = renderTime(compositionWorlds[cameraOwner] as RenderResourceScope).delta;
           motionBlurDelta = Number.isFinite(delta) ? Math.max(0, delta) : 0;
         } catch {
           motionBlurDelta = 0;
@@ -2856,9 +2871,29 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 .skylightResources;
         let featureGraphCandidate: RenderFeatureGraphCandidate | undefined;
         const preparedResourceBatches = runProfiledRenderPhase(profileSession, 'features', () => {
+          if (
+            publication?.packet.features.some(
+              (row) =>
+                !internals.featureHost?.features.some(
+                  (feature) => feature.identity === row.identity,
+                ),
+            )
+          )
+            throw new RenderPublicationError({
+              reason: 'shape',
+              subject: 'published feature has no receiver implementation',
+            });
           if (internals.featureHost === undefined) return [];
           const featureFrame = runRenderFeatureFrame(internals.featureHost, {
-            worlds: compositionWorlds,
+            worlds: sourceWorlds,
+            ...(publication === undefined
+              ? {}
+              : {
+                  publishedFeatures: publication.packet.features,
+                  ...(publication.onFeatureSourceSubmitted === undefined
+                    ? {}
+                    : { onFeatureSourceSubmitted: publication.onFeatureSourceSubmitted }),
+                }),
             owner: resourceOwner,
             frameNumber: frameState.frameNumber,
             ...(cameras[0] === undefined ? {} : { selectedCamera: cameras[0] }),
@@ -3053,8 +3088,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           frameState.standardLutState.resident !== null ||
           frameState.pendingStandardLutState !== undefined;
         if (hasLiveFeatureState) {
-          const cameraWorld = compositionWorlds[cameraOwner] as World;
-          const deltaTime = cameraWorld.getResource(Time).delta;
+          const cameraWorld = compositionWorlds[cameraOwner] as RenderResourceScope;
+          const deltaTime = renderTime(cameraWorld).delta;
           stageLiveFeatureState(
             cameras[0],
             Number.isFinite(deltaTime) ? Math.max(0, deltaTime) : 0,
@@ -3071,16 +3106,15 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         frameState.surfaceSubmissionObservation = surfaceSubmissionCandidate;
         const probeCaptureScene =
           shadowCasterProjection !== undefined &&
-          reflectionProbeRecord.graph.work.some((work) => work.rawCaptureFace !== undefined)
+          (auxiliaryCameras.length > 0 ||
+            cubeCameras.length > 0 ||
+            reflectionProbeRecord.graph.work.some((work) => work.rawCaptureFace !== undefined))
             ? projectCaptureScene(shadowCasterProjection, submissionRenderables, orderedDispatch)
             : undefined;
-        // This is a transient projection of the record owner's actual visible
-        // draws. It lets the presentation fact distinguish a clear/submit
-        // from a frame where geometry or its pipeline was skipped, without
-        // retaining a second readiness registry or per-asset counter.
+        // Track actual draws so a clear/submit cannot claim visible geometry was presented.
         const presentedRenderableKeys = new Set<number>();
         const presentedSubmeshKeys = new Set<string>();
-        const consumeDynamicGeometry = dynamicGeometryFrames.onRenderableDraw(compositionWorlds);
+        const consumeDynamicGeometry = dynamicGeometryFrames.onRenderableDraw(sourceWorlds);
         const markPresentedRenderable = (
           entry: Parameters<typeof consumeDynamicGeometry>[0],
           submeshIndex?: number,
@@ -3131,7 +3165,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
               },
               ...(occlusionProjection === undefined ? {} : { occlusion: occlusionProjection }),
               frameTime: (() => {
-                const elapsed = (compositionWorlds[cameraOwner] as World).getResource(Time).elapsed;
+                const elapsed = renderTime(
+                  compositionWorlds[cameraOwner] as RenderResourceScope,
+                ).elapsed;
                 return Number.isFinite(elapsed) ? elapsed : 0;
               })(),
               deviceGeneration: internals.deviceScope.generation,
@@ -3145,6 +3181,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             pointsLinesOwner,
             {
               snapshots: cubeCameras,
+              auxiliaryCameras,
               scheduler: cubeCaptureScheduler,
               state: cubeCaptureState,
               reflectionProbes: reflectionProbeRecord,
@@ -3329,7 +3366,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             width: Math.max(1, internals.canvas.width),
             height: Math.max(1, internals.canvas.height),
             frameTime: (() => {
-              const elapsed = (compositionWorlds[cameraOwner] as World).getResource(Time).elapsed;
+              const elapsed = renderTime(
+                compositionWorlds[cameraOwner] as RenderResourceScope,
+              ).elapsed;
               return Number.isFinite(elapsed) ? elapsed : 0;
             })(),
             ...(surfaceDynamicInputFrame === undefined
@@ -4054,14 +4093,3 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
 export function resolveInspectionBuild(internals: Pick<RenderSystemInternals, 'build'>): string {
   return internals.build ?? 'render-system';
 }
-
-// @forgeax/engine-render - built-in record context extension.
-//
-// The public RenderPipelineContext is canonical in render-contract.ts. This
-// owner adds only concrete assembly state for built-in record closures.
-
-/**
- * Package-private extension consumed by the built-in record closures only.
- * Custom pipeline authors see the leaf RenderPipelineContext contract and
- * never this surface.
- */

package/src/scene/render-scene.ts

@@ -1,29 +1,17 @@
 import { RuntimeMaterialValue, RuntimeMeshVertices } from '@forgeax/engine-assets-runtime';
-import type { EntityHandle, Query, World } from '@forgeax/engine-ecs';
-import {
-  createStateProjection,
-  type RenderReadLease,
-  type RenderReadVersion,
-  type StateProjection,
-  type StateProjectionBatch,
+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, Children, 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';
@@ -41,6 +29,8 @@ 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,
@@ -76,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 {
@@ -118,8 +115,6 @@ interface WorldTransformSpan {
   readonly worlds: Readonly<Float32Array>;
 }
 
-type GlobalTransformChangeQuery = Query<readonly [typeof GlobalTransform]>;
-
 function sameInstanceIdentitySet(
   current: Uint32Array | undefined,
   previous: Uint32Array | undefined,
@@ -1151,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;
@@ -1187,73 +1182,6 @@ interface PersistentCompositionEntry {
   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 = [
-  ChildOf,
-  MeshFilter,
-  MeshRenderer,
-  Instances,
-  SpriteInstances,
-  SpriteRegionOverride,
-  Skin,
-  Layer,
-  Visibility,
-  MorphWeights,
-  Points,
-  Lines,
-  SortKey,
-] as const;
-function createGlobalTransformChangeQuery(world: World): GlobalTransformChangeQuery {
-  const result = world.query({ read: [GlobalTransform], changed: [GlobalTransform] });
-  if (!result.ok) throw result.error;
-  const query = result.value as GlobalTransformChangeQuery;
-  for (const _span of query.spans().unwrap()) {
-    // The full rebuild consumed these values; establish the observation baseline.
-  }
-  return query;
-}
-
-function createRenderSourceState(world: World) {
-  // Numerical poses already have one span reader. Keep their table membership
-  // in this projection, without scanning their changed rows a second time.
-  const components = [...RENDERABLE_SOURCE_COMPONENTS, RuntimeMaterialValue, RuntimeMeshVertices];
-  const projection = createStateProjection(world, components, [
-    ...components,
-    Transform,
-    GlobalTransform,
-  ]);
-  const entities = new Map<number, EntityHandle>();
-  const contentHandles = new Map<number, readonly number[]>();
-  const batch = projection.read();
-  for (const index of batch.indices) {
-    const entity = projection.entity(index);
-    if (entity !== undefined) {
-      entities.set(index, entity);
-      const handles: number[] = [];
-      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) contentHandles.set(index, handles);
-    }
-  }
-  return { projection, entities, contentHandles, batch };
-}
-
-function isRenderableMember(world: World, entity: number): boolean {
-  return (
-    world.hasComponent(entity as EntityHandle, MeshRenderer) &&
-    world.hasComponent(entity as EntityHandle, Transform) &&
-    world.hasComponent(entity as EntityHandle, MeshFilter)
-  );
-}
-
 function sourceMembershipChanged(world: World, slot: RenderSceneSlot): boolean {
   const entity = slot.entityKey as EntityHandle;
   const snapshot = slot.snapshot;
@@ -1608,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;
@@ -1618,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));
   }
 
@@ -1632,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;
   }
@@ -1642,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);
@@ -1650,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 {
@@ -1710,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[],
@@ -1884,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 },
@@ -1897,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 &&
@@ -2708,7 +2711,7 @@ export class PersistentRenderScene {
     preserveVisibilityOnReorder = false,
   ): ExtractedFrame {
     const previousEntry = this.composition;
-    const sourceStates = worlds.map(createRenderSourceState);
+    const sourceStates = worlds.map((world) => createRenderSourceState(world));
     const candidateFrame = buildCandidateFrame({
       kind: 'partial',
       entitiesByWorld: sourceStates.map((source) => new Set(source.entities.values())),
@@ -2745,7 +2748,11 @@ export class PersistentRenderScene {
     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(
       renderables.map((snapshot) => identityKey(snapshot.worldId, snapshot.entityKey)),
@@ -2895,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);