@forgeax/engine-render 0.1.34 → 0.1.35

package/src/record/target-capture-graph.ts

@@ -0,0 +1,258 @@
+import type { RenderGraphBuilder, RenderGraphError } from '@forgeax/engine-render-graph';
+import type { Texture, TextureView } from '@forgeax/engine-rhi';
+import { ok, type Result } from '@forgeax/engine-types';
+import type { RenderPipelineFrame } from '../render-pipeline';
+import type { RenderTarget } from '../targets/contracts';
+import { resolveRenderTargetMaterialSource } from '../targets/material-source';
+import type { RenderTargetPhysical } from '../targets/physical';
+import { encodeMainPass } from './main-pass';
+import type { _InternalRenderPipelineContext } from './render-context';
+import type { ReflectionProbeGraphState } from './typed-frame-graph';
+
+export interface CubeCaptureGraphWork {
+  readonly target: RenderTarget;
+  readonly faceIndex: number;
+  readonly physical: RenderTargetPhysical;
+  readonly faceCamera: import('../render-contract').CameraSnapshot;
+  readonly viewBindGroupDynamicOffset: number;
+}
+
+export interface CubeCaptureGraphState {
+  work: readonly CubeCaptureGraphWork[];
+  reflectionProbes?: ReflectionProbeGraphState;
+}
+
+function renderTargetMipCount(work: CubeCaptureGraphWork): number {
+  const { descriptor } = work.physical;
+  return descriptor.mipLevels === 1
+    ? 1
+    : Math.floor(Math.log2(Math.max(descriptor.width, descriptor.height))) + 1;
+}
+
+export function addTargetCaptureGraphPasses(
+  builder: RenderGraphBuilder<RenderPipelineFrame>,
+  state: CubeCaptureGraphState,
+): Result<void, RenderGraphError> {
+  for (let index = 0; index < state.work.length; index += 1) {
+    const slot = index;
+    const initial = state.work[slot];
+    if (initial === undefined) continue;
+    const current = (): CubeCaptureGraphWork => state.work[slot] ?? initial;
+    const texture = builder.importTexture(
+      `cube-capture.${slot}.texture`,
+      {
+        format: initial.physical.descriptor.format,
+        size: {
+          width: initial.physical.descriptor.width,
+          height: initial.physical.descriptor.height,
+          depthOrArrayLayers:
+            initial.physical.descriptor.sampleCount === 4 ||
+            initial.physical.descriptor.shape === '2d'
+              ? 1
+              : 6,
+        },
+        mipLevelCount:
+          initial.physical.descriptor.sampleCount === 4 ? 1 : renderTargetMipCount(initial),
+        sampleCount: initial.physical.descriptor.sampleCount,
+        dimension: '2d',
+        usage: 0x10 | 0x04 | 0x01,
+      },
+      () => current().physical.colorTextures[current().faceIndex] ?? initial.physical.texture,
+    );
+    if (!texture.ok) return texture;
+    const color = builder.importView(
+      texture.value,
+      {
+        label: `cube-capture.${slot}.color`,
+        dimension: '2d',
+        baseMipLevel: 0,
+        mipLevelCount: 1,
+        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
+        arrayLayerCount: 1,
+      },
+      () =>
+        current().physical.faceViews[current().faceIndex] ??
+        initial.physical.faceViews[initial.faceIndex] ??
+        initial.physical.view,
+    );
+    if (!color.ok) return color;
+    const depthTexture = builder.importTexture(
+      `cube-capture.${slot}.depth-texture`,
+      {
+        format: 'depth24plus-stencil8',
+        size: {
+          width: initial.physical.descriptor.width,
+          height: initial.physical.descriptor.height,
+          depthOrArrayLayers:
+            initial.physical.descriptor.sampleCount === 4 ||
+            initial.physical.descriptor.shape === '2d'
+              ? 1
+              : 6,
+        },
+        mipLevelCount: 1,
+        sampleCount: initial.physical.descriptor.sampleCount,
+        dimension: '2d',
+        usage: 0x10,
+      },
+      () => current().physical.depthTextures[current().faceIndex] as Texture,
+    );
+    if (!depthTexture.ok) return depthTexture;
+    const depth = builder.importView(
+      depthTexture.value,
+      {
+        label: `cube-capture.${slot}.depth`,
+        dimension: '2d',
+        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
+        arrayLayerCount: 1,
+      },
+      () => current().physical.depthViews[current().faceIndex] as TextureView,
+    );
+    if (!depth.ok) return depth;
+    const resolveTexture =
+      initial.physical.descriptor.sampleCount === 4
+        ? builder.importTexture(
+            `cube-capture.${slot}.resolve-texture`,
+            {
+              format: initial.physical.descriptor.format,
+              size: {
+                width: initial.physical.descriptor.width,
+                height: initial.physical.descriptor.height,
+                depthOrArrayLayers: initial.physical.descriptor.shape === 'cube' ? 6 : 1,
+              },
+              mipLevelCount: renderTargetMipCount(initial),
+              sampleCount: 1,
+              dimension: '2d',
+              usage: 0x10 | 0x04 | 0x01,
+            },
+            () =>
+              current().physical.resolveTexture ??
+              initial.physical.resolveTexture ??
+              initial.physical.texture,
+          )
+        : undefined;
+    if (resolveTexture !== undefined && !resolveTexture.ok) return resolveTexture;
+    const resolve =
+      resolveTexture === undefined
+        ? undefined
+        : builder.importView(
+            resolveTexture.value,
+            {
+              label: `cube-capture.${slot}.resolve`,
+              dimension: '2d',
+              baseMipLevel: 0,
+              mipLevelCount: 1,
+              baseArrayLayer: initial.faceIndex,
+              arrayLayerCount: 1,
+            },
+            () =>
+              current().physical.resolveFaceViews[current().faceIndex] ??
+              initial.physical.resolveFaceViews[initial.faceIndex] ??
+              initial.physical.resolveView,
+          );
+    if (resolve !== undefined && !resolve.ok) return resolve;
+    const added = builder.addRasterPass(`cube-capture-face.${slot}`, {
+      accesses: [
+        { resource: color.value, usage: 'color-attachment' },
+        { resource: depth.value, usage: 'depth-stencil-write' },
+        ...(resolve === undefined
+          ? []
+          : [{ resource: resolve.value, usage: 'color-attachment' as const }]),
+      ],
+      colorAttachments: [
+        {
+          view: color.value,
+          ...(resolve === undefined ? {} : { resolveTarget: resolve.value }),
+          loadOp: 'clear',
+          storeOp: 'store',
+          clearValue: () => {
+            const clear =
+              current().physical.descriptor.shape === '2d'
+                ? current().faceCamera.clearColor
+                : [0, 0, 0, 1];
+            return { r: clear[0] ?? 0, g: clear[1] ?? 0, b: clear[2] ?? 0, a: clear[3] ?? 1 };
+          },
+        },
+      ],
+      depthStencilAttachment: {
+        view: depth.value,
+        depthClearValue: 1,
+        depthLoadOp: 'clear',
+        depthStoreOp: 'store',
+        stencilClearValue: 0,
+        stencilLoadOp: 'clear',
+        stencilStoreOp: 'store',
+      },
+      encode: ({ pass, frame, resources }) => {
+        const internal = frame as _InternalRenderPipelineContext;
+        const captureColor = resources.textureView(color.value);
+        if (!captureColor.ok) return;
+        const captureDepth = resources.textureView(depth.value);
+        if (!captureDepth.ok) return;
+        const captureResolve =
+          resolve === undefined ? undefined : resources.textureView(resolve.value);
+        if (resolve !== undefined && (captureResolve === undefined || !captureResolve.ok)) return;
+        const captureResolveView = captureResolve?.ok ? captureResolve.value : null;
+        const selfSampling = new Map<number, Set<number>>();
+        for (const row of internal.validatedOrdered) {
+          for (const material of row.source.materials) {
+            if (
+              ![...(material.textureSources?.values() ?? [])].some(
+                (source) => resolveRenderTargetMaterialSource(source)?.target === current().target,
+              )
+            )
+              continue;
+            let handles = selfSampling.get(row.renderableIndex);
+            if (handles === undefined) {
+              handles = new Set();
+              selfSampling.set(row.renderableIndex, handles);
+            }
+            handles.add(material.materialHandle ?? 0);
+          }
+        }
+        const captureContext = {
+          ...internal,
+          camera: current().faceCamera,
+          targetW: current().physical.descriptor.width,
+          targetH: current().physical.descriptor.height,
+          dispatch: (internal.captureDispatch ?? internal.dispatch).filter(
+            (entry) => !selfSampling.get(entry.renderableIndex)?.has(entry.materialHandle),
+          ),
+          foldDispatchPlan: null,
+
+          // Cube faces are raw scene captures, not display-camera HDR output.
+          // Select the PSO against the actual target attachment so an LDR
+          // cube target is rendered by a compatible forward pipeline.
+          tonemapActive: false,
+          skyboxActive: false,
+          transparentColorFormat: initial.physical.descriptor.format as GPUTextureFormat,
+          msaaActive: initial.physical.descriptor.sampleCount === 4,
+          viewBindGroupDynamicOffset: current().viewBindGroupDynamicOffset,
+          geometryColorView: captureColor.value,
+          geometryDepthView: captureDepth.value,
+          geometryColorResolveView: captureResolveView,
+          splitLdrSprite: false,
+          ldrSpritePassView: null,
+        };
+        delete captureContext.gpuDrivenDrawKeys;
+        delete captureContext.gpuDrivenStandardPbrFrameResources;
+        encodeMainPass(
+          captureContext,
+          pass,
+          { LightMode: ['Forward'] },
+          {
+            colorViews: [captureColor.value],
+            colorFormats: [initial.physical.descriptor.format as GPUTextureFormat],
+            depthView: captureDepth.value,
+            passKind: 'forward',
+            clearColor:
+              current().physical.descriptor.shape === '2d'
+                ? current().faceCamera.clearColor
+                : [0, 0, 0, 1],
+          },
+        );
+      },
+    });
+    if (!added.ok) return added;
+  }
+  return ok(undefined);
+}

package/src/record/typed-frame-graph.ts

@@ -1,3 +1,7 @@
+import { addTargetCaptureGraphPasses, type CubeCaptureGraphState } from './target-capture-graph';
+
+export type { CubeCaptureGraphState, CubeCaptureGraphWork } from './target-capture-graph';
+
 import { encodeMipmapLevel } from '@forgeax/engine-assets-runtime';
 import {
   type CompiledRenderGraph,
@@ -95,8 +99,6 @@ import type {
 import type { ExtractedLights, ExtractedVolumetricFog } from '../render-system-extract';
 import { SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS } from '../shadow-atlas';
 import type { SsrAdmissionResult, SsrSpatialAdmission } from '../ssr/admission';
-import type { RenderTarget } from '../targets/contracts';
-import type { RenderTargetPhysical } from '../targets/physical';
 import {
   abortTemporalGpuSubmit,
   CLOUD_HISTORY_FORMATS,
@@ -607,19 +609,6 @@ export function createTemporalGraphRoster(input: {
   };
 }
 
-export interface CubeCaptureGraphWork {
-  readonly target: RenderTarget;
-  readonly faceIndex: number;
-  readonly physical: RenderTargetPhysical;
-  readonly faceCamera: import('../render-contract').CameraSnapshot;
-  readonly viewBindGroupDynamicOffset: number;
-}
-
-export interface CubeCaptureGraphState {
-  work: readonly CubeCaptureGraphWork[];
-  reflectionProbes?: ReflectionProbeGraphState;
-}
-
 export interface ReflectionProbeFilterGraphWork {
   readonly probeIndex: number;
   readonly faceIndex: number;
@@ -666,195 +655,6 @@ export function boundedReflectionProbeFilterWork(
   return state.work.slice(0, Math.max(0, state.maxStepsPerFrame));
 }
 
-function renderTargetMipCount(work: CubeCaptureGraphWork): number {
-  const { descriptor } = work.physical;
-  return descriptor.mipLevels === 1
-    ? 1
-    : Math.floor(Math.log2(Math.max(descriptor.width, descriptor.height))) + 1;
-}
-
-function addCubeCaptureGraphPasses(
-  builder: RenderGraphBuilder<RenderPipelineFrame>,
-  state: CubeCaptureGraphState,
-): Result<void, RenderGraphError> {
-  for (let index = 0; index < state.work.length; index += 1) {
-    const slot = index;
-    const initial = state.work[slot];
-    if (initial === undefined) continue;
-    const current = (): CubeCaptureGraphWork => state.work[slot] ?? initial;
-    const texture = builder.importTexture(
-      `cube-capture.${slot}.texture`,
-      {
-        format: initial.physical.descriptor.format,
-        size: {
-          width: initial.physical.descriptor.width,
-          height: initial.physical.descriptor.height,
-          depthOrArrayLayers: initial.physical.descriptor.sampleCount === 4 ? 1 : 6,
-        },
-        mipLevelCount:
-          initial.physical.descriptor.sampleCount === 4 ? 1 : renderTargetMipCount(initial),
-        sampleCount: initial.physical.descriptor.sampleCount,
-        dimension: '2d',
-        usage: 0x10 | 0x04 | 0x01,
-      },
-      () => current().physical.colorTextures[current().faceIndex] ?? initial.physical.texture,
-    );
-    if (!texture.ok) return texture;
-    const color = builder.importView(
-      texture.value,
-      {
-        label: `cube-capture.${slot}.color`,
-        dimension: '2d',
-        baseMipLevel: 0,
-        mipLevelCount: 1,
-        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
-        arrayLayerCount: 1,
-      },
-      () =>
-        current().physical.faceViews[current().faceIndex] ??
-        initial.physical.faceViews[initial.faceIndex] ??
-        initial.physical.view,
-    );
-    if (!color.ok) return color;
-    const depthTexture = builder.importTexture(
-      `cube-capture.${slot}.depth-texture`,
-      {
-        format: 'depth24plus-stencil8',
-        size: {
-          width: initial.physical.descriptor.width,
-          height: initial.physical.descriptor.height,
-          depthOrArrayLayers: initial.physical.descriptor.sampleCount === 4 ? 1 : 6,
-        },
-        mipLevelCount: 1,
-        sampleCount: initial.physical.descriptor.sampleCount,
-        dimension: '2d',
-        usage: 0x10,
-      },
-      () => current().physical.depthTextures[current().faceIndex] as Texture,
-    );
-    if (!depthTexture.ok) return depthTexture;
-    const depth = builder.importView(
-      depthTexture.value,
-      {
-        label: `cube-capture.${slot}.depth`,
-        dimension: '2d',
-        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
-        arrayLayerCount: 1,
-      },
-      () => current().physical.depthViews[current().faceIndex] as TextureView,
-    );
-    if (!depth.ok) return depth;
-    const resolveTexture =
-      initial.physical.descriptor.sampleCount === 4
-        ? builder.importTexture(
-            `cube-capture.${slot}.resolve-texture`,
-            {
-              format: initial.physical.descriptor.format,
-              size: {
-                width: initial.physical.descriptor.width,
-                height: initial.physical.descriptor.height,
-                depthOrArrayLayers: 6,
-              },
-              mipLevelCount: renderTargetMipCount(initial),
-              sampleCount: 1,
-              dimension: '2d',
-              usage: 0x10 | 0x04 | 0x01,
-            },
-            () =>
-              current().physical.resolveTexture ??
-              initial.physical.resolveTexture ??
-              initial.physical.texture,
-          )
-        : undefined;
-    if (resolveTexture !== undefined && !resolveTexture.ok) return resolveTexture;
-    const resolve =
-      resolveTexture === undefined
-        ? undefined
-        : builder.importView(
-            resolveTexture.value,
-            {
-              label: `cube-capture.${slot}.resolve`,
-              dimension: '2d',
-              baseMipLevel: 0,
-              mipLevelCount: 1,
-              baseArrayLayer: initial.faceIndex,
-              arrayLayerCount: 1,
-            },
-            () =>
-              current().physical.resolveFaceViews[current().faceIndex] ??
-              initial.physical.resolveFaceViews[initial.faceIndex] ??
-              initial.physical.resolveView,
-          );
-    if (resolve !== undefined && !resolve.ok) return resolve;
-    const added = builder.addRasterPass(`cube-capture-face.${slot}`, {
-      accesses: [
-        { resource: color.value, usage: 'color-attachment' },
-        { resource: depth.value, usage: 'depth-stencil-write' },
-        ...(resolve === undefined
-          ? []
-          : [{ resource: resolve.value, usage: 'color-attachment' as const }]),
-      ],
-      colorAttachments: [
-        {
-          view: color.value,
-          ...(resolve === undefined ? {} : { resolveTarget: resolve.value }),
-          loadOp: 'clear',
-          storeOp: 'store',
-          clearValue: () => {
-            return { r: 0, g: 0, b: 0, a: 1 };
-          },
-        },
-      ],
-      depthStencilAttachment: {
-        view: depth.value,
-        depthClearValue: 1,
-        depthLoadOp: 'clear',
-        depthStoreOp: 'store',
-        stencilClearValue: 0,
-        stencilLoadOp: 'clear',
-        stencilStoreOp: 'store',
-      },
-      encode: ({ pass, frame, resources }) => {
-        const internal = frame as _InternalRenderPipelineContext;
-        const captureColor = resources.textureView(color.value);
-        if (!captureColor.ok) return;
-        const captureDepth = resources.textureView(depth.value);
-        if (!captureDepth.ok) return;
-        const captureResolve =
-          resolve === undefined ? undefined : resources.textureView(resolve.value);
-        if (resolve !== undefined && (captureResolve === undefined || !captureResolve.ok)) return;
-        const captureResolveView = captureResolve?.ok ? captureResolve.value : null;
-        const captureContext = {
-          ...internal,
-          camera: current().faceCamera,
-          // Cube faces are raw scene captures, not display-camera HDR output.
-          // Select the PSO against the actual target attachment so an LDR
-          // cube target is rendered by a compatible forward pipeline.
-          tonemapActive: false,
-          skyboxActive: false,
-          transparentColorFormat: initial.physical.descriptor.format as GPUTextureFormat,
-          msaaActive: initial.physical.descriptor.sampleCount === 4,
-          viewBindGroupDynamicOffset: current().viewBindGroupDynamicOffset,
-          geometryColorView: captureColor.value,
-          geometryDepthView: captureDepth.value,
-          geometryColorResolveView: captureResolveView,
-          splitLdrSprite: false,
-          ldrSpritePassView: null,
-        };
-        encodeMainPass(captureContext, pass, undefined, {
-          colorViews: [captureColor.value],
-          colorFormats: [initial.physical.descriptor.format as GPUTextureFormat],
-          depthView: captureDepth.value,
-          passKind: 'forward',
-          clearColor: [0, 0, 0, 1],
-        });
-      },
-    });
-    if (!added.ok) return added;
-  }
-  return ok(undefined);
-}
-
 export function addReflectionProbeGraphPasses(
   builder: RenderGraphBuilder<RenderPipelineFrame>,
   state: ReflectionProbeGraphState,
@@ -2669,7 +2469,7 @@ export function ensureCompiledFrameGraph(
     // rotation must not invalidate the graph or its cached bind groups.
     occlusionQuery:
       occlusion === undefined ? undefined : { active: true, sampleCount: occlusion.sampleCount },
-    cubeCaptureSlots: cubeCaptureState?.work.length ?? 0,
+    cubeCaptureSlots: cubeCaptureState?.work.map((work) => work.physical.descriptor),
     reflectionProbeSlots: cubeCaptureState?.reflectionProbes?.work.map((work) => [
       work.probeIndex,
       work.rawCaptureFace ?? -1,
@@ -2924,7 +2724,7 @@ export function ensureCompiledFrameGraph(
         if (!reflectionProbes.ok) return reflectionProbes;
         return cubeCaptureState === undefined
           ? ok(undefined)
-          : addCubeCaptureGraphPasses(builder, cubeCaptureState);
+          : addTargetCaptureGraphPasses(builder, cubeCaptureState);
       },
       hasFeature: (identity) =>
         projectedFeaturePlans.value.some((execution) => execution.featureIdentity === identity),

package/src/record/view-ubo.ts

@@ -30,7 +30,7 @@ export const POINTS_LINES_VIEW_BUFFER_SIZE =
 export const VIEW_UNIFORM_SLOT_STRIDE = 1024;
 export const POINT_SHADOW_VIEW_SLOT_COUNT = 24;
 export const CUBE_CAPTURE_VIEW_SLOT_BASE = 1 + POINT_SHADOW_VIEW_SLOT_COUNT;
-export const REFLECTION_PROBE_VIEW_SLOT_BASE = CUBE_CAPTURE_VIEW_SLOT_BASE + 6;
+export const REFLECTION_PROBE_VIEW_SLOT_BASE = CUBE_CAPTURE_VIEW_SLOT_BASE + 6 + 1;
 export const REFLECTION_PROBE_VIEW_SLOT_COUNT = 16;
 export const VIEW_UNIFORM_BUFFER_SIZE =
   VIEW_UNIFORM_SLOT_STRIDE * (REFLECTION_PROBE_VIEW_SLOT_BASE + REFLECTION_PROBE_VIEW_SLOT_COUNT);

package/src/record/volume-params.ts

@@ -1,7 +1,7 @@
-import type { World } from '@forgeax/engine-ecs';
 import { vec3 } from '@forgeax/engine-math';
 import { type Buffer, RhiError } from '@forgeax/engine-rhi';
 import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM } from '../gpu-usage';
+import type { RenderResourceScope } from '../publication/resource-scope';
 import type { SpotLightProjectorFrameContext, VolumetricFogFrameContext } from '../render-contract';
 import type { ExtractedLights, ExtractedVolumetricFog } from '../render-system-extract';
 import { VOLUMETRIC_FOG_PARAMS_BYTES } from '../volume/resources';
@@ -57,8 +57,8 @@ export function stageVolumetricFogParams(
 function prepareVolumetricFogMember(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
-  world: World,
-  worlds: readonly World[],
+  world: RenderResourceScope,
+  worlds: readonly RenderResourceScope[],
   fog: ExtractedVolumetricFog | undefined,
   lights: ExtractedLights,
   volumeCapability: boolean,
@@ -157,7 +157,7 @@ function prepareVolumetricFogMember(
     frameState.temporalFrame !== undefined && frameState.temporalFrame.resetReason === 'none'
       ? 1
       : 0;
-  // World elapsed time is the sole authored-medium clock.
+  // RenderResourceScope elapsed time is the sole authored-medium clock.
   params[32] = fog.worldTimeSeconds ?? 0;
   return {
     densityTexture: resident.value.texture.handle,
@@ -180,8 +180,8 @@ function prepareVolumetricFogMember(
 export function prepareVolumetricFogFrame(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
-  world: World,
-  worlds: readonly World[],
+  world: RenderResourceScope,
+  worlds: readonly RenderResourceScope[],
   fog: ExtractedVolumetricFog | undefined,
   lights: ExtractedLights,
   volumeCapability: boolean,

package/src/recovery/render-system-candidate.ts

@@ -47,6 +47,7 @@ import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
 import { standardTopologyVariantSet } from '../pipeline-spec';
 import { inspectPointShadow } from '../point-shadow-inspection';
 import type { PreparedGraphicsResolver } from '../prepare/prepared-graphics-resolver';
+import type { RenderResourceScope } from '../publication/resource-scope';
 import { gpuDrivenMeshesForFrame, validateRenderables } from '../record/frame';
 import { prepareFrameLighting } from '../record/frame-lighting';
 import type { RenderFrameState, ValidatedRenderable } from '../record/frame-snapshot';
@@ -95,19 +96,19 @@ export interface PreparedResolverCaches {
   readonly preparedGroup0Pipelines: WeakSet<object>;
   readonly preparedViewOnlyPipelines: WeakSet<object>;
   readonly preparedRenderMaterialPipelines: WeakSet<object>;
-  readonly preparedAssetHandles: WeakMap<World, Map<string, number>>;
+  readonly preparedAssetHandles: WeakMap<RenderResourceScope, Map<string, number>>;
 }
 
 export interface RecoveryFrameSeed {
   readonly frame: ExtractedFrame;
-  readonly worlds: readonly World[];
+  readonly worlds: readonly RenderResourceScope[];
   readonly cameraOwner: number;
   readonly resourceOwner: number;
   readonly width: number;
   readonly height: number;
   /** Last submitted Surface page is reused while the replacement device warms. */
   readonly surfaceDynamicInput?: SurfaceDynamicInputFrame;
-  /** Last submitted World/App time snapshot for the Surface frame ABI. */
+  /** Last submitted RenderResourceScope/App time snapshot for the Surface frame ABI. */
   readonly frameTime?: number;
   /** Exact forward artifacts accepted by the submitted frame. */
   readonly materialArtifacts?: ReadonlyMap<string, MaterialShaderArtifact>;
@@ -144,7 +145,7 @@ export interface RenderSystemRecoveryDependencies {
   readonly createPreparedResolverFactory: (
     runtime: RenderSystemInternals,
     gpuWork: RenderFeatureGpuWorkOwner,
-    worlds: readonly World[],
+    worlds: readonly RenderResourceScope[],
     caches: PreparedResolverCaches,
   ) => (input: RenderFeaturePreparedGraphicsResolverInput) => PreparedGraphicsResolver;
   readonly createPreparedResolverCaches: () => PreparedResolverCaches;
@@ -229,7 +230,7 @@ export function createRenderSystemRecovery(
   } = deps;
 
   // This is a detached CPU projection, retained only after queue submission.
-  // It is not a World/lease cache and it never carries target or scheduler state.
+  // It is not a RenderResourceScope/lease cache and it never carries target or scheduler state.
   let lastSuccessfulFrameSeed: RecoveryFrameSeed | undefined;
 
   const createRecoveryCandidateFrameState = (): RenderFrameState => {
@@ -406,7 +407,7 @@ export function createRenderSystemRecovery(
     // A successful clear-only draw can have no display camera. There is no
     // frame graph to rehydrate in that case, but the device generation is
     // still recoverable; the next camera-bearing draw will build its graph
-    // from the current World composition.
+    // from the current RenderResourceScope composition.
     if (camera === undefined) return { kind: 'no-seed' };
 
     const candidateFrameState = createRecoveryCandidateFrameState();
@@ -445,7 +446,6 @@ export function createRenderSystemRecovery(
       if (pendingOutput !== undefined) retireAutoExposureGpuResources(pendingOutput);
       candidateFrameState.pendingAutoExposureGpuResources = undefined;
       for (const work of setupWorks) work.discard();
-      setupWorks.length = 0;
       const graph = candidateFrameState.compiledFrameGraph;
       candidateFrameState.compiledFrameGraph = null;
       candidateFrameState.perFrameGraph = null;
@@ -504,7 +504,7 @@ export function createRenderSystemRecovery(
         candidateFrameState,
         runtime.internals,
         camera,
-        seed.worlds[seed.cameraOwner] as World,
+        seed.worlds[seed.cameraOwner] as RenderResourceScope,
       );
       if (!output.ok) return failed('candidate Standard output preparation failed', output.error);
       const gpuScene = persistentRenderScene.prepareRecoveryGpuDrivenCandidate(
@@ -514,7 +514,7 @@ export function createRenderSystemRecovery(
       candidateGpuDrivenScene = gpuScene.value;
       candidateValidated = validateRenderables(
         runtime.internals,
-        seed.worlds[seed.cameraOwner] as World,
+        seed.worlds[seed.cameraOwner] as RenderResourceScope,
         seed.worlds,
         runtime.pipelineState,
         candidateFrameState,
@@ -731,7 +731,7 @@ export function createRenderSystemRecovery(
           cloudHistory: seed.frame.cloudLayer !== undefined,
         });
         const featureFrame = runRenderFeatureFrame(candidateFeatureHost, {
-          worlds: seed.worlds,
+          worlds: seed.worlds.filter((world): world is World => !('resolveAsset' in world)),
           owner: seed.resourceOwner,
           frameNumber: candidateFrameState.frameNumber,
           selectedCamera: camera,

package/src/render-contract.ts

@@ -62,6 +62,7 @@ import type {
 } from './inspection-types.js';
 import type { InstanceCollectionInspection } from './instances.js';
 import type { RenderExtent } from './pipeline/render-extent.js';
+import type { PublishedRenderFrameInput, RenderPublicationIdentity } from './publication/contract';
 import type { RenderSceneBounds } from './scene/render-scene-types.js';
 import type { SsrAdmissionIdentity } from './ssr/identity.js';
 import type {
@@ -446,7 +447,9 @@ export interface Renderer {
   dynamicGeometryReceipt(candidate: DynamicGeometryCandidate): DynamicGeometryReceipt | undefined;
   cancelDynamicGeometry(candidate: DynamicGeometryCandidate): Result<void, DynamicGeometryError>;
   retireDynamicGeometry(candidate: DynamicGeometryCandidate): Result<void, DynamicGeometryError>;
-  draw(input: RenderFrameInput): RenderResult<FrameReceipt, RenderError>;
+  draw(
+    input: RenderFrameInput | PublishedRenderFrameInput,
+  ): RenderResult<FrameReceipt, RenderError>;
   /**
    * Arm one upcoming submitted frame for explicit color-domain observation.
    * Observation buffers are not created, copied, mapped, or retained until a
@@ -1062,6 +1065,8 @@ export type RenderPhaseSkipReason =
 
 /** First-version options bag (intentionally empty; reserved for v0.1). */
 export interface RendererOptions {
+  /** Bind a source session before receiving any publication. */
+  readonly publicationSource?: RenderPublicationIdentity;
   /** Producer-owned features installed by the renderer host. */
   readonly features?: readonly RenderFeature<unknown>[] | undefined;
   /** Standard profile consumed by the single renderer-owned pipeline. */