@forgeax/engine-render 0.1.34 → 0.1.35

package/src/record/__tests__/video-texture-view.unit.test.ts

@@ -1,8 +1,8 @@
 import { type DynamicTextureDevice, DynamicTextureStore } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
 import {
-  VIDEO_ELEMENT_PROVIDER_KEY,
-  type VideoElementProvider,
+  VIDEO_SOURCE_PROVIDER_KEY,
+  type VideoSourceProvider,
 } from '@forgeax/engine-graphics-extras';
 import type { Result, RhiError, Texture, TextureView } from '@forgeax/engine-rhi';
 import { ok } from '@forgeax/engine-rhi';
@@ -53,16 +53,16 @@ describe('videoTextureView provider-loss recovery', () => {
     const store = makeStore(probe);
     const errors: { readonly code: string }[] = [];
     const runtime = runtimeWithErrors((error) => errors.push(error));
-    const provider: VideoElementProvider = {
-      getElement: vi.fn(() => VIDEO),
+    const provider: VideoSourceProvider = {
+      getSource: vi.fn(() => VIDEO),
     };
-    world.insertResource(VIDEO_ELEMENT_PROVIDER_KEY, provider);
+    world.insertResource(VIDEO_SOURCE_PROVIDER_KEY, provider);
 
     const lkg = videoTextureView(world, store, runtime, ENTITY, CLIP, false);
     expect(lkg).toBeDefined();
     expect(probe.copies).toBe(1);
 
-    world.removeResource(VIDEO_ELEMENT_PROVIDER_KEY);
+    world.removeResource(VIDEO_SOURCE_PROVIDER_KEY);
     expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
     expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
     expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
@@ -70,19 +70,19 @@ describe('videoTextureView provider-loss recovery', () => {
     expect(errors[0]?.code).toBe('video-upload-unsupported');
     expect(probe.copies).toBe(1);
 
-    world.insertResource(VIDEO_ELEMENT_PROVIDER_KEY, provider);
+    world.insertResource(VIDEO_SOURCE_PROVIDER_KEY, provider);
     expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
     expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
     expect(errors).toHaveLength(1);
     expect(probe.copies).toBe(3);
 
-    world.removeResource(VIDEO_ELEMENT_PROVIDER_KEY);
+    world.removeResource(VIDEO_SOURCE_PROVIDER_KEY);
     expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
     expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
     expect(errors).toHaveLength(2);
     expect(probe.copies).toBe(3);
 
-    world.insertResource(VIDEO_ELEMENT_PROVIDER_KEY, provider);
+    world.insertResource(VIDEO_SOURCE_PROVIDER_KEY, provider);
     expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
     expect(errors).toHaveLength(2);
     expect(probe.copies).toBe(4);

package/src/record/fold-buckets.ts

@@ -1,5 +1,4 @@
 import { HANDLE_NINESLICE_QUAD, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
-import type { World } from '@forgeax/engine-ecs';
 import { deriveVertexCount } from '@forgeax/engine-geometry';
 import { RhiError } from '@forgeax/engine-rhi';
 import type { MaterialRenderState, MeshAsset } from '@forgeax/engine-types';
@@ -9,6 +8,8 @@ import { materialBindingKey } from '../gpu-driven/material-bindings';
 import { GpuBuffer } from '../gpu-resource';
 import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_VERTEX } from '../gpu-usage';
 import { disposeTransientInstanceBuffers } from '../instance-buffer-cache';
+import type { RenderResourceScope } from '../publication/resource-scope';
+import { renderAssetByGuid } from '../publication/resource-scope';
 import type { DispatchEntry, MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
 import {
   getTransparentSortConfig,
@@ -151,14 +152,14 @@ function limitRowsToMeshSsboCapacity<T>(rows: readonly T[], availableSlots: numb
  */
 export function validateRenderables(
   internals: RenderSystemInternals,
-  world: World,
+  world: RenderResourceScope,
   // feat-20260709-editor-world-partition ENGINE-fix-round2 (defect 2): the full
   // worlds[] list. Each renderable's mesh handle is a user-tier slot in its OWN
   // world's sharedRefs; resolving against a foreign world either misses
   // (asset-not-registered) or resolves the wrong slot payload. `world` (the
   // resource-owner) is retained as the fallback for renderables whose worldId
   // is out of range (defensive; extractFrames always stamps a valid index).
-  worlds: readonly World[],
+  worlds: readonly RenderResourceScope[],
   pipelineState: PipelineState,
   frameState: RenderFrameState,
   renderables: readonly RenderableSnapshot[],
@@ -226,7 +227,9 @@ export function validateRenderables(
     // frames hit the O(1) cache.
     const meshAssetHandle = toShared<'MeshAsset'>(r.assetHandle);
     let meshHandles = internals.gpuStore.getMeshGpuHandles(meshAssetHandle, renderableWorld);
-    const lodMeshes = r.lods?.map((lod) => internals.assets.lookup<MeshAsset>(lod.mesh));
+    const lodMeshes = r.lods?.map((lod) =>
+      renderAssetByGuid<MeshAsset>(renderableWorld, internals.assets, lod.mesh),
+    );
     const resolvedLodMeshes =
       lodMeshes?.every((lod): lod is MeshAsset => lod?.kind === 'mesh') === true
         ? lodMeshes
@@ -793,7 +796,7 @@ export function cleanPerFrameCaches(
  * @internal
  */
 export function computeFoldBuckets(
-  world: World,
+  world: RenderResourceScope,
   frameState: RenderFrameState,
   transparentDispatch: readonly DispatchEntry[],
   renderables: readonly RenderableSnapshot[],

package/src/record/frame-snapshot.ts

@@ -1,7 +1,7 @@
+import type { RenderResourceScope } from '../publication/resource-scope';
 // @forgeax/engine-runtime - RenderSystem record stage: frame-snapshot.
 // Extracted from render-system-record.ts (feat-20260704 M3/w17, pure move).
 
-import type { World } from '@forgeax/engine-ecs';
 import type { RenderReadVersion } from '@forgeax/engine-ecs/projection';
 import { vec3 } from '@forgeax/engine-math';
 import type {
@@ -867,8 +867,8 @@ export interface BloomFrameReceipts {
  */
 export interface ValidatedRenderable {
   readonly source: RenderableSnapshot;
-  /** World that owns the renderable's asset handles and material snapshots. */
-  readonly world?: World;
+  /** RenderResourceScope that owns the renderable's asset handles and material snapshots. */
+  readonly world?: RenderResourceScope;
   readonly mesh: MeshGpuHandles;
   readonly renderableIndex: number;
   readonly renderState: MaterialRenderState | undefined;
@@ -900,7 +900,7 @@ export interface ValidatedRenderable {
  * @internal
  */
 export interface DirectionalShadowCache {
-  readonly worlds: readonly World[];
+  readonly worlds: readonly RenderResourceScope[];
   readonly worldStateTokens: readonly DirectionalShadowWorldState[];
   readonly assetCatalogEpoch: number;
   readonly pipelineHandle: number;
@@ -916,8 +916,8 @@ export interface DirectionalShadowCache {
  * ECS state that can change the contents of a directional shadow map.
  *
  * The ECS-owned RenderReadLease is the only render-facing mutation boundary.
- * Its version is intentionally conservative: any published World change
- * invalidates the cached atlas, while render never reaches through World for
+ * Its version is intentionally conservative: any published RenderResourceScope change
+ * invalidates the cached atlas, while render never reaches through RenderResourceScope for
  * component-clock storage.
  */
 export interface DirectionalShadowWorldState {

package/src/record/frame.ts

@@ -5,6 +5,8 @@ import {
   requiresProbeBlendRecord,
 } from '../gpu-driven/material-artifacts';
 import { projectMaterialBindingClasses } from '../gpu-driven/material-bindings';
+import type { RenderResourceScope } from '../publication/resource-scope';
+import { renderAssetByGuid, renderTime } from '../publication/resource-scope';
 import {
   buildDispatchPlan,
   cleanPerFrameCaches,
@@ -16,7 +18,6 @@ import { uploadMaterialUniforms } from './material-uniforms';
 // Extracted from render-system-record.ts (feat-20260704 M3/w17, pure move).
 
 import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
-import { Time, type World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
 import { frustum, mat4, vec3 } from '@forgeax/engine-math';
 import {
@@ -144,11 +145,14 @@ export type FrameObservationReadback = (
 ) => Promise<Result<Uint8Array, Error>>;
 
 /**
- * Fold World identity into the renderer-owned validation token. The GPU
+ * Fold RenderResourceScope identity into the renderer-owned validation token. The GPU
  * production owner receives only this opaque key; ECS identity and ordering
- * stay in the record owner where the World list is authoritative.
+ * stay in the record owner where the RenderResourceScope list is authoritative.
  */
-function residencyValidationCacheKey(world: World, worlds: readonly World[]): string {
+function residencyValidationCacheKey(
+  world: RenderResourceScope,
+  worlds: readonly RenderResourceScope[],
+): string {
   return [world.identity, ...worlds.map((candidate) => candidate.identity)].join('\u001f');
 }
 function renderableIdentity(snapshot: Pick<RenderableSnapshot, 'worldId' | 'entityKey'>): string {
@@ -327,7 +331,7 @@ import {
 /**
  * Resolve the GPU mesh view used by the optional production raster before its
  * filtering pass runs. The result is keyed by the retained RenderScene slot,
- * which preserves the World namespace already used by gpuStore. User meshes
+ * which preserves the RenderResourceScope namespace already used by gpuStore. User meshes
  * are pull-resident during record; relying only on the boot-time builtin map
  * would make the first frame classify every imported mesh as a CPU fallback
  * and would hide its LOD ranges from the GPU cull. Builtins are the only
@@ -336,7 +340,7 @@ import {
 export function gpuDrivenMeshesForFrame(
   internals: RenderSystemInternals,
   pipelineState: PipelineState,
-  worlds: readonly World[],
+  worlds: readonly RenderResourceScope[],
   scene: PersistentGpuDrivenState | undefined,
 ): ReadonlyMap<number, MeshGpuHandles> {
   const meshes = new Map<number, MeshGpuHandles>();
@@ -357,7 +361,7 @@ export function gpuDrivenMeshesForFrame(
       const asset = resolveAssetHandle<MeshAsset>(world, sharedHandle);
       if (asset.ok) {
         const lodMeshes = slot.snapshot.lods?.map((lod) =>
-          internals.assets.lookup<MeshAsset>(lod.mesh),
+          renderAssetByGuid<MeshAsset>(world, internals.assets, lod.mesh),
         );
         const resolvedLodMeshes =
           lodMeshes?.every((lod): lod is MeshAsset => lod?.kind === 'mesh') === true
@@ -382,6 +386,7 @@ export type RecordProfileRunner = <T>(phase: RenderRecordPhase, action: () => T)
 export interface CubeCaptureFrameInput {
   readonly captureDispatch?: readonly DispatchEntry[];
   readonly snapshots: readonly CubeCameraSnapshot[];
+  readonly auxiliaryCameras: readonly CameraSnapshot[];
   readonly scheduler: import('../capture/scheduler').CubeCaptureScheduler;
   readonly state: CubeCaptureGraphState;
   readonly reflectionProbes?: import('./render-context').ReflectionProbeRecordState;
@@ -437,6 +442,18 @@ function prepareCubeCapture(
         (CUBE_CAPTURE_VIEW_SLOT_BASE + physicalWork.length) * VIEW_UNIFORM_SLOT_STRIDE,
     });
   }
+  for (const camera of input.auxiliaryCameras) {
+    if (camera.target === undefined) continue;
+    const physical = internals.getRenderTargetPhysical?.(camera.target);
+    if (physical?.descriptor.shape !== '2d') continue;
+    physicalWork.push({
+      target: camera.target,
+      faceIndex: 0,
+      physical,
+      faceCamera: camera,
+      viewBindGroupDynamicOffset: (CUBE_CAPTURE_VIEW_SLOT_BASE + 6) * VIEW_UNIFORM_SLOT_STRIDE,
+    });
+  }
   input.state.work = physicalWork;
   return physicalWork;
 }
@@ -840,8 +857,8 @@ function resolveVolumetricFogHistoryContext(
  */
 function prepareSpotLightProjectorFrame(
   internals: RenderSystemInternals,
-  world: World,
-  worlds: readonly World[],
+  world: RenderResourceScope,
+  worlds: readonly RenderResourceScope[],
   lights: ExtractedLights,
   fog: ExtractedVolumetricFog | undefined,
 ): SpotLightProjectorFrameContext | undefined {
@@ -982,15 +999,15 @@ interface FrameClockSample {
 
 /** Read the render sample clock from the camera's composition world once per frame. */
 function frameClockSample(
-  world: World,
-  worlds: readonly World[],
+  world: RenderResourceScope,
+  worlds: readonly RenderResourceScope[],
   camera: CameraSnapshot,
   sampleTimeSeconds?: number,
 ): FrameClockSample {
   const owner = worlds[camera.worldId ?? 0] ?? world;
   const invalidSampleTime = sampleTimeSeconds !== undefined && !Number.isFinite(sampleTimeSeconds);
   try {
-    const clock = owner.getResource(Time);
+    const clock = renderTime(owner);
     return {
       deltaSeconds: Number.isFinite(clock.delta) ? Math.max(0, clock.delta) : 0,
       // Keep the raw host sample even when ECS accepted only a clamped
@@ -1007,7 +1024,7 @@ function frameClockSample(
       invalidSampleTime,
     };
   } catch {
-    // Test and recovery callers may provide a minimal World-shaped owner. An
+    // Test and recovery callers may provide a minimal RenderResourceScope-shaped owner. An
     // absent clock is an invalid temporal pair and therefore safely resets.
     return {
       deltaSeconds: 0,
@@ -1372,7 +1389,7 @@ function updateVolumetricFogInspection(
 
 export function recordFrame(
   internals: RenderSystemInternals,
-  world: World,
+  world: RenderResourceScope,
   cameras: CameraSnapshot[],
   lights: ExtractedLights,
   renderables: readonly RenderableSnapshot[],
@@ -1392,7 +1409,7 @@ export function recordFrame(
   // the per-world extract stage). Optional + defaulting to `[world]` keeps the
   // pre-split single-world identity path (worldId always 0) byte-for-byte and
   // the existing unit-test callers (which pass a single mock world) valid.
-  worlds: readonly World[] = [world],
+  worlds: readonly RenderResourceScope[] = [world],
   profilePhase?: RecordProfileRunner,
   gpuDriven?: {
     readonly owner: GpuDrivenProduction;
@@ -2270,7 +2287,7 @@ export function recordFrame(
       activeVolumetricFogSignature = resolvedHistory.signature;
       const previousTime = frameState.volumetricFogHistorySignature?.worldTimeSeconds;
       const currentTime = resolvedHistory.signature.worldTimeSeconds;
-      // Adjacent UBO lanes: validity, World time, elapsed time since accepted history.
+      // Adjacent UBO lanes: validity, RenderResourceScope time, elapsed time since accepted history.
       const historyParams = new Float32Array([
         activeVolumetricFogContext.historyValid ? 1 : 0,
         currentTime ?? 0,
@@ -2842,7 +2859,7 @@ export function recordFrame(
       // the picture authority: an identity frame publishes an identity
       // mapping, while a failed enable/disable candidate retains the previous
       // mapping together with its old picture. Never pair an LKG graph with
-      // the live World's newer camera component.
+      // the live RenderResourceScope's newer camera component.
       // The exact mapping used to populate the accepted graph's UBO is the
       // only mapping promoted with its receipt. This keeps an identity frame,
       // a retained barrel LKG and a normal nonzero frame on one context.
@@ -2855,7 +2872,10 @@ export function recordFrame(
       // prior tick into the next topology.
       acknowledgeRenderFeatureSubmission(getRenderFeatureGraphState(internals).plans);
     }
-    if (cubeCapture !== undefined && cubeCaptureWork.length > 0) {
+    if (
+      cubeCapture !== undefined &&
+      cubeCaptureWork.some((work) => work.physical.descriptor.shape === 'cube')
+    ) {
       const completed = cubeCapture.scheduler.completeSubmission(submitted, completion);
       if (!completed.ok) internals.errorRegistry.fire(completed.error);
     }
@@ -2980,7 +3000,7 @@ function readWorldState(lease: RenderReadLease): DirectionalShadowWorldState {
 
 function sameWorldState(
   cached: DirectionalShadowCache,
-  worlds: readonly World[],
+  worlds: readonly RenderResourceScope[],
   leases: readonly RenderReadLease[] | undefined,
 ): boolean {
   if (leases === undefined || leases.length !== worlds.length) return false;
@@ -2999,7 +3019,7 @@ function sameWorldState(
       changes = lease.readChanges(cachedState.version);
     } catch {
       // Treat malformed or foreign version evidence as stale and rebuild the
-      // atlas rather than reaching through World for a second mutation clock.
+      // atlas rather than reaching through RenderResourceScope for a second mutation clock.
       return false;
     }
     if (
@@ -3047,7 +3067,7 @@ function sameDirectionalShadowQuality(
 function prepareDirectionalShadowCache(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
-  worlds: readonly World[],
+  worlds: readonly RenderResourceScope[],
   leases: readonly RenderReadLease[] | undefined,
   lights: ExtractedLights,
   shadowMapSize: number | undefined,
@@ -3102,7 +3122,7 @@ function prepareDirectionalShadowCache(
   if (leases === undefined || leases.length !== worlds.length) {
     // Direct record-stage test harnesses may omit the host-owned leases. They
     // still exercise the real shadow encoder, but without the ECS read owner
-    // they must conservatively rebuild rather than inspect World internals.
+    // they must conservatively rebuild rather than inspect RenderResourceScope internals.
     return { reuse: false, next: null };
   }
   const worldStateTokens = leases.map(readWorldState);

package/src/record/helpers.ts

@@ -1,8 +1,8 @@
+import type { RenderResourceScope } from '../publication/resource-scope';
 // @forgeax/engine-runtime - RenderSystem record stage: helpers.
 // Extracted from render-system-record.ts (feat-20260704 M3/w17, pure move).
 
 import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
-import type { World } from '@forgeax/engine-ecs';
 import { type Mat4, mat4 } from '@forgeax/engine-math';
 import type { EquirectAsset } from '@forgeax/engine-types';
 import { toShared } from '@forgeax/engine-types';
@@ -140,7 +140,7 @@ export function warnMultiSkybox(
  */
 export function driveLazyEquirectProjection(
   internals: RenderSystemInternals,
-  world: World,
+  world: RenderResourceScope,
   frameState: Pick<RenderFrameState, 'firedEquirectProjectionFailedHandles'>,
   equirectHandle: number,
 ): void {

package/src/record/main-pass-geometry.ts

@@ -1,8 +1,9 @@
+import type { RenderResourceScope } from '../publication/resource-scope';
+import { resolveSpriteInstancesBuffer } from './sprite-instance-buffer';
 // @forgeax/engine-runtime - RenderSystem record stage: main-pass geometry draws.
 // feat-20260704 M5/w31: further-split from main-pass.ts (AC-05 <=1500 lines/file).
 // recordGeometryDraws + resolveGeometryInstanceBuffer, moved verbatim.
 
-import type { World } from '@forgeax/engine-ecs';
 import {
   type BindGroup,
   type Buffer,
@@ -495,7 +496,7 @@ export function recordGeometryDraws(
     materialSlot: number,
     submeshMaterial: MaterialSnapshot,
     entityKey: number,
-    materialWorld: World,
+    materialWorld: RenderResourceScope,
     materialShaderId?: string,
   ) => BindGroup,
   passKind: PassKind = 'forward',
@@ -1916,6 +1917,24 @@ export function resolveGeometryInstanceBuffer(
 ): readonly GeometryInstanceDraw[] | null {
   const { runtime, pipelineState, frameState } = c;
   const inst = entry.source.instances;
+  if (entry.source.spriteInstances !== undefined) {
+    const { buffer, count } = resolveSpriteInstancesBuffer(
+      c,
+      entry,
+      pipelineState.identityInstanceBuffer,
+      0,
+    );
+    return count === 0
+      ? []
+      : [
+          {
+            instanceBuffer: buffer,
+            instanceBindGroup: resolveGeometryInstancesBindGroup(c, buffer, undefined),
+            probeOffset: -1,
+            instanceCount: count,
+          },
+        ];
+  }
   const probeBinding =
     !useProbeBlend ||
     !runtime.device.caps.storageBuffer ||

package/src/record/main-pass-material.ts

@@ -1,14 +1,16 @@
 import { transmissionBackdropAvailable } from '../assembly/device-feature-admission';
 import { getOrCreateIblCache } from '../ibl/IblPipelineCache';
+import type { RenderResourceScope } from '../publication/resource-scope';
 import type { _InternalRenderPipelineContext } from './render-context';
 // @forgeax/engine-runtime - RenderSystem record stage: main-pass-material.
 // Extracted from render-system-record.ts (feat-20260704 M3/w17, pure move).
 
 import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
-import type { EntityHandle, World } from '@forgeax/engine-ecs';
+import type { EntityHandle } from '@forgeax/engine-ecs';
 import {
-  VIDEO_ELEMENT_PROVIDER_KEY,
-  type VideoElementProvider,
+  VIDEO_SOURCE_PROVIDER_KEY,
+  type VideoSourceProvider,
+  videoSourceExtent,
 } from '@forgeax/engine-graphics-extras';
 import {
   type BindGroup,
@@ -261,11 +263,11 @@ function materialDiagnosticsEnabled(): boolean {
 }
 
 export function residentTextureView(
-  world: World,
+  world: RenderResourceScope,
   store: GpuResidencyCache,
   runtime: RenderSystemRuntime,
   handle: Handle<'TextureAsset', 'shared'>,
-  worldId: World | number = world,
+  worldId: RenderResourceScope | number = world,
 ): TextureView | undefined {
   const podRes = resolveAssetHandle<TextureAsset>(world, handle);
   const diagnosticsEnabled = materialDiagnosticsEnabled();
@@ -323,11 +325,11 @@ export function residentTextureView(
 }
 
 function residentSampler(
-  world: World,
+  world: RenderResourceScope,
   store: GpuResidencyCache,
   runtime: RenderSystemRuntime,
   handle: Handle<'SamplerAsset', 'shared'>,
-  worldId: World | number = world,
+  worldId: RenderResourceScope | number = world,
 ): Sampler | undefined {
   const podRes = resolveAssetHandle<SamplerAsset>(world, handle);
   if (!podRes.ok) return undefined;
@@ -344,7 +346,7 @@ function residentSampler(
 // transient DynamicTextureStore, NOT the static `residentTextureView` /
 // `ensureResident` cache (video never enters that switch; AC-08).
 //
-// Per frame: ask the host-registered VideoElementProvider (World Resource,
+// Per frame: ask the host-registered VideoSourceProvider (RenderResourceScope Resource,
 // D-1) for this entity's HTMLVideoElement, upload its current frame via
 // `store.uploadFrame` (copyExternalImageToTexture), and return the resulting
 // view. When the provider is absent / returns no element / the element has no
@@ -404,7 +406,7 @@ function clearVideoUploadFailureEpisode(
 }
 
 export function videoTextureView(
-  world: World,
+  world: RenderResourceScope,
   store: DynamicTextureStore | undefined,
   runtime: RenderSystemRuntime,
   entityKey: number,
@@ -412,10 +414,14 @@ export function videoTextureView(
   highPerfAvailable: boolean,
 ): TextureView | undefined {
   if (store === undefined) return undefined;
-  const provider = world.hasResource(VIDEO_ELEMENT_PROVIDER_KEY)
-    ? world.getResource<VideoElementProvider>(VIDEO_ELEMENT_PROVIDER_KEY)
-    : undefined;
-  const element = provider?.getElement(entityKey as EntityHandle, clip);
+  const provider =
+    !('resolveAsset' in world) && world.hasResource(VIDEO_SOURCE_PROVIDER_KEY)
+      ? world.getResource<VideoSourceProvider>(VIDEO_SOURCE_PROVIDER_KEY)
+      : undefined;
+  const element =
+    'resolveAsset' in world
+      ? world.videoFrame(entityKey, clip)
+      : provider?.getSource(entityKey as EntityHandle, clip);
   // AC-10 double-miss: a VideoPlayer entity can reach NEITHER upload path this
   // frame — no host HTMLVideoElement (general copyExternalImageToTexture path)
   // AND no high-perf GPUExternalTexture path. This is the genuine "this backend
@@ -441,13 +447,9 @@ export function videoTextureView(
     clearVideoUploadFailureEpisode(store, entityKey, clip);
     return store.getView(clip);
   }
-  const width = element.videoWidth;
-  const height = element.videoHeight;
-  // Metadata dimensions can be non-zero before the decoder has produced a
-  // current frame. WebGPU rejects copyExternalImageToTexture in that window
-  // because the video element has no back resource yet; keep the previous
-  // frame/default view until HAVE_CURRENT_DATA (2) is reached.
-  if (width <= 0 || height <= 0 || element.readyState < 2) return store.getView(clip);
+  const extent = videoSourceExtent(element);
+  if (extent === undefined) return store.getView(clip);
+  const { width, height } = extent;
   const uploaded = store.uploadFrame(clip, element, width, height);
   if (uploaded === undefined) return store.getView(clip);
   if (!uploaded.ok) {
@@ -592,7 +594,7 @@ function writeNumericParamValue(
 export function applyMaterialTextureUvScales(
   payload: MaterialUboPayload,
   material: MaterialSnapshot,
-  world: World,
+  world: RenderResourceScope,
 ): void {
   const f32 = materialUboFloatView(payload);
   const coordinateSchema = materialCoordinateSchema(material);
@@ -940,14 +942,14 @@ export function applyParamSchemaDefaultsToUbo(
 export interface PerSubmeshMaterialBgDeps {
   readonly runtime: RenderSystemRuntime;
   readonly pipelineState: PipelineState;
-  readonly world: World;
+  readonly world: RenderResourceScope;
   readonly store: GpuResidencyCache;
   readonly materialSlice: number;
   readonly videoHighPerfAvailable: boolean;
   readonly skylightResources: SkylightBindGroupResources;
   readonly resolveRenderTargetTextureSource?: RenderSystemRuntime['resolveRenderTargetTextureSource'];
   readonly resolveReflectionProbeResources?: (
-    materialWorld: World,
+    materialWorld: RenderResourceScope,
     entityKey: number,
   ) => { readonly resources: SkylightBindGroupResources; readonly probeIndex: number } | undefined;
   readonly materialBgShared: Map<string, WeakMap<object, unknown>>;
@@ -979,7 +981,7 @@ function recordIblMaterialBinding(
   if (receipt === undefined) return;
   const skylightBindingStart = entries.findIndex((entry) => entry.binding === iblStart);
   if (skylightBindingStart < 0) return;
-  const iblEntries = entries.slice(skylightBindingStart, skylightBindingStart + 7);
+  const iblEntries = entries.slice(skylightBindingStart, skylightBindingStart + 6);
   const projected: IblBindingEntryInspection[] = [];
   for (const entry of iblEntries) {
     if (entry.resource.kind === 'externalTexture') continue;
@@ -1018,7 +1020,15 @@ export function isMaterialBgAssemblyCacheHit(
   sceneMaterialBuffer?: Buffer,
   surfaceRawDepthView?: TextureView | null,
 ): cached is MaterialBgAssemblyCacheEntry {
-  if (transmissionBackdropView != null || surfaceRawDepthView != null) return false;
+  // Logical target sources keep their identity when a resize promotes a new
+  // physical view. Resolve those views each frame; the lower binding cache is
+  // keyed by the actual GPU resources and still reuses unchanged bindings.
+  if (
+    transmissionBackdropView != null ||
+    surfaceRawDepthView != null ||
+    (material.textureSources?.size ?? 0) > 0
+  )
+    return false;
   return (
     cached?.material === material &&
     cached.materialResourceEpoch === materialResourceEpoch &&
@@ -1031,7 +1041,6 @@ export function isMaterialBgAssemblyCacheHit(
     cached.skylightResources.skylightPrefilterView === skylightResources.skylightPrefilterView &&
     cached.skylightResources.prefilterSampler === skylightResources.prefilterSampler &&
     cached.skylightResources.brdfLutView === skylightResources.brdfLutView &&
-    cached.skylightResources.brdfLutSampler === skylightResources.brdfLutSampler &&
     cached.skylightResources.intensityBuffer === skylightResources.intensityBuffer
   );
 }
@@ -1040,7 +1049,7 @@ export function buildPerSubmeshMaterialBg(
   deps: PerSubmeshMaterialBgDeps,
   submeshMaterial: MaterialSnapshot,
   entityKey: number,
-  materialWorld: World = deps.world,
+  materialWorld: RenderResourceScope = deps.world,
   materialShaderId: string | undefined = submeshMaterial.materialShaderId,
 ): BindGroup {
   const {
@@ -1175,10 +1184,6 @@ export function buildPerSubmeshMaterialBg(
             },
             {
               binding: 6 + smUserRegionFields.length * 2,
-              resource: { kind: 'sampler', value: effectiveSkylightResources.brdfLutSampler },
-            },
-            {
-              binding: 7 + smUserRegionFields.length * 2,
               resource: {
                 kind: 'buffer',
                 value: { buffer: effectiveSkylightResources.intensityBuffer },
@@ -1429,6 +1434,7 @@ export function buildPerSubmeshMaterialBg(
   if (
     smMaterialHandle !== undefined &&
     !smHasVideoFields &&
+    (submeshMaterial.textureSources?.size ?? 0) === 0 &&
     materialResourcesResident &&
     !hasActiveTransmissionBackdrop
   ) {
@@ -1532,7 +1538,6 @@ export function resolveMaterialSkylight(
           prefilterView: activeViews.pref,
           prefilterSampler: skylightFallback.sampler,
           brdfLutView: activeViews.brdf,
-          brdfLutSampler: skylightFallback.sampler,
           intensityBuffer: skylightFallback.intensityBuffer,
         }
       : {
@@ -1541,7 +1546,6 @@ export function resolveMaterialSkylight(
           prefilterView: skylightFallback.prefilterView,
           prefilterSampler: skylightFallback.sampler,
           brdfLutView: skylightFallback.brdfLutView,
-          brdfLutSampler: skylightFallback.sampler,
           intensityBuffer: skylightFallback.intensityBuffer,
         };
   return { skylightResources, activeViews };