@forgeax/engine-render 0.1.34 → 0.1.36

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,
@@ -2839,7 +2639,11 @@ export function ensureCompiledFrameGraph(
         ? {}
         : {
             projectGpuDrivenShadow: (identity) =>
-              gpuDriven.projectShadow?.(builder, identity) ?? ok(undefined),
+              // A newly compiled graph must include the shadow compute passes
+              // even when the producer cache hit. The graph owns its pass
+              // list; importing only the cached view resources would reuse
+              // stale indirect arguments after a topology replacement.
+              gpuDriven.projectShadow?.(builder, identity, true) ?? ok(undefined),
           }),
       contributeShadowFeatures: () =>
         (featureShadows ??= projectRenderFeatureShadows(
@@ -2924,7 +2728,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,11 +47,13 @@ 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';
 import { resolveGeometryInstanceBuffer } from '../record/main-pass-geometry';
 import { computeSplitLdrSprite } from '../record/main-pass-sprite-draws';
+import type { PreparedResolverCaches } from '../record/prepared-material-bindings';
 import { ensureProbeBlendRecordBuffer } from '../record/probe-blend-buffer';
 import {
   prepareRecoveryPipelineReadiness,
@@ -89,25 +91,16 @@ import type {
   RecoveryPointsLinesCandidate,
 } from './types';
 
-export interface PreparedResolverCaches {
-  readonly preparedPipelineIds: WeakMap<object, string>;
-  readonly preparedMaterialPipelineShaders: WeakMap<object, string>;
-  readonly preparedGroup0Pipelines: WeakSet<object>;
-  readonly preparedViewOnlyPipelines: WeakSet<object>;
-  readonly preparedRenderMaterialPipelines: WeakSet<object>;
-  readonly preparedAssetHandles: WeakMap<World, 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 +137,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 +222,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 +399,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 +438,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 +496,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 +506,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 +723,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. */

package/src/render-system-extract-tail.ts

@@ -183,7 +183,7 @@ import {
 } from './render-system-extract';
 import { buildShadowFrusta } from './scene/shadow-visibility';
 import { SHADOW_ATLAS_DEFAULT_LAYERS } from './shadow-atlas';
-import type { SkinPaletteReceipt } from './systems/skin-palette-types';
+import type { SkinPaletteReceipt, SkinPose } from './systems/skin-palette-types';
 
 function skinPaletteIdentity(world: World, entity: number): string {
   return `skin:${world.identity}:${entity}`;
@@ -2137,6 +2137,11 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           if (asset.kind !== 'material') {
             materialSnap = defaultMaterialSnapshot(handleRaw);
           } else {
+            // Program selection belongs to the shared source; RuntimeMaterialValue
+            // only projects the numeric parameter content resolved below.
+            const source = world.sharedRefs.resolve<string, Asset>(tagged);
+            const programOwner =
+              source.ok && source.value.kind === 'material' ? source.value : asset;
             // feat-20260529 M3 / w11: material parent chain inheritance via
             // read-through _materialWalk accessor (plan-strategy D-6).
             // The old direct asset.passes / asset.values read never
@@ -2186,7 +2191,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                   };
             try {
               materialProgramSelections = materialProgramSelectionsForMaterial(
-                asset,
+                programOwner,
                 assets,
                 materialContext,
               );
@@ -2198,10 +2203,14 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
               // publication error instead of guessing from module names/order.
               if (isMissingMaterialProgram(error) && materialContext?.geometry === 'mesh') {
                 try {
-                  const skinnedSelections = materialProgramSelectionsForMaterial(asset, assets, {
-                    ...materialContext,
-                    geometry: 'skinned',
-                  });
+                  const skinnedSelections = materialProgramSelectionsForMaterial(
+                    programOwner,
+                    assets,
+                    {
+                      ...materialContext,
+                      geometry: 'skinned',
+                    },
+                  );
                   if (
                     skinnedSelections?.some(materialProgramSelectionRequiresSkin) === true &&
                     gpuDrivenMesh !== undefined
@@ -2238,7 +2247,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                     ]),
                   );
             const materialSceneIndexProgramKeys = materialSceneIndexProgramKeysForMaterial(
-              asset,
+              programOwner,
               assets,
               materialContext,
             );
@@ -2739,6 +2748,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         // resolve / validate / write chain (D-9 reset already fired at
         // extractFrame entry; per-entity allocate + writeJointPalette here).
         let skinSlice: SkinPaletteReceipt | undefined;
+        let skinPose: SkinPose | undefined;
         const skinIdentity = hasSkin ? skinPaletteIdentity(world, entity) : undefined;
         const releaseSkinIdentity = (): void => {
           if (skinIdentity !== undefined) {
@@ -2850,6 +2860,17 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
               });
               skinPaletteAllocator.writePersistentJointPalette(receipt, ibms, jointWorlds);
               skinSlice = receipt;
+            } else {
+              skinPose = {
+                identity: skinPaletteIdentity(world, entity),
+                generation: ((skeletonHandleRaw >>> 0) ^ skeleton.jointCount) >>> 0,
+                jointCount: skeleton.jointCount,
+                ...(hasFiniteOrderedLocalAabb(skeleton.bounds)
+                  ? { bounds: new Float32Array(skeleton.bounds) }
+                  : {}),
+                inverseBindMatrices: ibms,
+                jointWorlds,
+              };
             }
           }
         }
@@ -2858,7 +2879,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         // projection. Do not publish a renderable or its staged dispatch when
         // palette extraction was unavailable; the record stage must never
         // reinterpret a skinned vertex stream through an ordinary mesh group.
-        if (skinSlice === undefined && hasSkin) {
+        if (skinSlice === undefined && skinPose === undefined && hasSkin) {
           releaseSkinIdentity();
           if (
             materialSnap.materialShaderId === 'forgeax::pbr-skin' ||
@@ -3128,6 +3149,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           entityKey: entity,
           ...(authorVisible ? {} : { authorVisible: false }),
           ...(skinSlice !== undefined ? { skin: skinSlice } : {}),
+          ...(skinPose === undefined ? {} : { skinPose }),
           ...(skin?.joints === undefined
             ? {}
             : { skinJointEntities: Array.from(skin.joints, (joint) => Number(joint)) }),
@@ -3136,21 +3158,24 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           ...(spriteInstancesSnap !== undefined ? { spriteInstances: spriteInstancesSnap } : {}),
           ...(pointsLines !== undefined ? { pointsLines } : {}),
         };
-        const gpuDrivenDraws = buildGpuDrivenDraws({
-          mesh: gpuDrivenMesh,
-          materials: materialsArr,
-          fallbackMaterial: materialSnap,
-          baseSnapshot: baseRenderable,
-          ...(getMaterialShaderArtifact === undefined ? {} : { getMaterialShaderArtifact }),
-          ...(lods === undefined
-            ? {}
-            : {
-                lodMeshes: lods.map((lod) => {
-                  const lower = assets?.lookup<Asset>(lod.mesh);
-                  return lower?.kind === 'mesh' ? lower : undefined;
-                }),
-              }),
-        });
+        const gpuDrivenDraws =
+          skinPose === undefined
+            ? buildGpuDrivenDraws({
+                mesh: gpuDrivenMesh,
+                materials: materialsArr,
+                fallbackMaterial: materialSnap,
+                baseSnapshot: baseRenderable,
+                ...(getMaterialShaderArtifact === undefined ? {} : { getMaterialShaderArtifact }),
+                ...(lods === undefined
+                  ? {}
+                  : {
+                      lodMeshes: lods.map((lod) => {
+                        const lower = assets?.lookup<Asset>(lod.mesh);
+                        return lower?.kind === 'mesh' ? lower : undefined;
+                      }),
+                    }),
+              })
+            : [];
         for (const draw of gpuDrivenDraws) {
           if (draw.preparationError === undefined) continue;
           worldInternal._routeError(draw.preparationError, {

package/src/render-system-extract.ts

@@ -792,6 +792,8 @@ export interface RenderableSnapshot {
    * Absent (`undefined`) means the entity is not skinned.
    */
   readonly skin?: SkinPaletteReceipt;
+  /** Source pose waiting for the receiving Renderer to assign a palette. */
+  readonly skinPose?: import('./systems/skin-palette-types').SkinPose;
   /** Joint identities consumed by the retained scene dependency index. */
   readonly skinJointEntities?: readonly number[];
   /** Source pass ownership retained with the scene record across view changes. */
@@ -2360,9 +2362,16 @@ export function resolveMaterialSnapshot(
   if (!resolvedResult.ok) return defaultMaterialSnapshot(handleRaw);
   const resolved = resolvedResult.value;
   const allPasses = resolved.passes;
-  const materialProgramKeys = materialProgramKeysForMaterial(asset, assetsRef, materialContext);
+  // Numeric World content changes values, never the immutable program owner.
+  const source = world.sharedRefs.resolve<string, Asset>(tagged);
+  const programOwner = source.ok && source.value.kind === 'material' ? source.value : asset;
+  const materialProgramKeys = materialProgramKeysForMaterial(
+    programOwner,
+    assetsRef,
+    materialContext,
+  );
   const materialSceneIndexProgramKeys = materialSceneIndexProgramKeysForMaterial(
-    asset,
+    programOwner,
     assetsRef,
     materialContext,
   );

package/src/render-system-presentation.ts

@@ -1,4 +1,4 @@
-import type { World } from '@forgeax/engine-ecs';
+import type { RenderResourceScope } from './publication/resource-scope';
 import type { RenderSystemInternals } from './record/render-context';
 import type { FramePresentation } from './render-contract';
 import type { DispatchEntry, RenderableSnapshot } from './render-system-extract';
@@ -20,7 +20,7 @@ export function projectFramePresentation(input: {
   readonly hasEnvironment: boolean;
   readonly submissionRenderables: readonly RenderableSnapshot[];
   readonly submissionDispatch: readonly DispatchEntry[];
-  readonly preparedWorlds: readonly World[];
+  readonly preparedWorlds: readonly RenderResourceScope[];
   readonly internals: RenderSystemInternals;
 }): FramePresentationProjection {
   const displayRenderableIndices = new Set<number>();

package/src/render-system-projections.ts

@@ -6,6 +6,7 @@ import type {
   LodOcclusionInspectionRow,
   LodOcclusionWorldInspection,
 } from './inspection-types';
+import type { RenderResourceScope } from './publication/resource-scope';
 import { worldEntityKey } from './record/frame-snapshot';
 import type { CameraSnapshot, DrawOwnerOptions } from './render-contract';
 import type { DispatchEntry, RenderableSnapshot } from './render-system-extract';
@@ -52,7 +53,7 @@ interface LodInspectionQuerySummary {
 }
 
 export function createLodWorldInspections(
-  worlds: readonly World[],
+  worlds: readonly RenderResourceScope[],
   renderables: readonly RenderableSnapshot[],
   submittedRenderables: readonly RenderableSnapshot[],
   camera: CameraSnapshot,
@@ -164,7 +165,7 @@ export function createLodWorldInspections(
 /** Apply the configured stable sub-sort to transparent dispatch entries. */
 export function sortTransparentDispatch(
   dispatch: DispatchEntry[],
-  world: World,
+  world: RenderResourceScope,
   cameras: readonly CameraSnapshot[],
   renderables: readonly RenderableSnapshot[],
 ): DispatchEntry[] {