@forgeax/engine-render 0.1.34 → 0.1.36

package/src/features/host.ts

@@ -133,6 +133,8 @@ export interface RenderFeatureStageEvent {
 }
 
 export interface RenderFeatureFrameInput {
+  readonly publishedFeatures?: readonly { readonly identity: string; readonly data: unknown }[];
+  readonly onFeatureSourceSubmitted?: (identity: string, feedback: unknown) => void;
   readonly worlds: readonly import('@forgeax/engine-ecs').World[];
   readonly owner: number;
   readonly frameNumber: number;
@@ -1454,7 +1456,10 @@ export function runRenderFeatureFrame(
     const extracted = invokeStage(
       slot,
       'extract',
-      () => slot.feature.extract(extractContext),
+      () => {
+        const published = input.publishedFeatures?.find((row) => row.identity === identity);
+        return published === undefined ? slot.feature.extract(extractContext) : ok(published.data);
+      },
       stageEvents,
       errors,
     );
@@ -1655,11 +1660,14 @@ export function runRenderFeatureFrame(
       continue;
     }
     planExecutionProjections.set(plannedFrame, projected.value);
-    if (feature.onFrameSubmitted !== undefined) {
+    if (feature.onFrameSubmitted !== undefined || feature.onSourceFrameSubmitted !== undefined) {
       submissionSensitivePlans.add(plannedFrame);
-      submissionAcknowledgments.set(plannedFrame, () =>
-        feature.onFrameSubmitted?.(extracted.value, projected.value),
-      );
+      submissionAcknowledgments.set(plannedFrame, () => {
+        feature.onFrameSubmitted?.(extracted.value, projected.value);
+        if (input.publishedFeatures?.some((row) => row.identity === identity))
+          input.onFeatureSourceSubmitted?.(identity, declared.value.sourceFeedback);
+        else feature.onSourceFrameSubmitted?.(extracted.value, declared.value.sourceFeedback);
+      });
     }
     plans.push(plannedFrame);
     if (feature.onFrameAborted !== undefined) {

package/src/features/particle-mesh-layout.ts

@@ -0,0 +1,25 @@
+import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
+
+// Mesh attributes keep geometry's canonical packing. Only locations change:
+// the particle instance occupies 4..9 and custom material inputs occupy 10..13.
+export const PARTICLE_MESH_DEFAULTS = {
+  position: [0, 0, 0],
+  normal: [0, 0, 1],
+  uv: [0, 0],
+  tangent: [1, 0, 0, 1],
+  uv1: [0, 0],
+  color: [1, 1, 1, 1],
+} as const;
+export const PARTICLE_MESH_GEOMETRY = deriveVertexLayoutProjection(
+  Object.fromEntries(Object.keys(PARTICLE_MESH_DEFAULTS).map((key) => [key, new Float32Array()])),
+);
+
+export const PARTICLE_MESH_VERTEX_BUFFER = {
+  arrayStride: PARTICLE_MESH_GEOMETRY.arrayStride,
+  stepMode: 'vertex' as const,
+  attributes: PARTICLE_MESH_GEOMETRY.attributes.map(({ key, shaderLocation, offset, format }) => ({
+    shaderLocation: key === 'color' ? 14 : key === 'uv1' ? 15 : shaderLocation,
+    offset,
+    format,
+  })),
+};

package/src/features/plan.ts

@@ -237,6 +237,8 @@ export type RenderFeaturePassDeclaration =
  * access is derived from these roles rather than duplicated as reads/writes.
  */
 export interface RenderFeaturePlan {
+  /** Source acknowledgment facts; never part of GPU resource or graph identity. */
+  readonly sourceFeedback?: unknown;
   readonly resources: readonly RenderFeatureResourceDeclaration[];
   readonly passes: readonly RenderFeaturePassDeclaration[];
 }

package/src/features/types.ts

@@ -171,6 +171,8 @@ export interface RenderFeature<FrameData> {
     readonly source: string;
   }[];
   extract(context: RenderFeatureExtractContext): Result<FrameData, RenderError>;
+  /** GUID roots needed by the declarative plan; the publisher carries their asset closure. */
+  assetDependencies?(data: FrameData): readonly string[];
   plan(data: FrameData, context: RenderFeaturePlanContext): Result<RenderFeaturePlan, RenderError>;
   /**
    * Consume frame-owned producer state only after the compiled graph reached
@@ -178,6 +180,12 @@ export interface RenderFeature<FrameData> {
    * extracted frame and never during declarative planning.
    */
   onFrameSubmitted?(data: FrameData, submission?: RenderFeatureSubmission): void;
+  /**
+   * Consume source-owned intents after submission; feedback must be structured-cloneable.
+   * A sealed successor may have been extracted before this acknowledgment. Ordered
+   * intent producers must identify already-submitted work instead of replaying it.
+   */
+  onSourceFrameSubmitted?(data: FrameData, feedback: unknown): void;
   /**
    * Discard frame-owned producer state when graph admission or submission is
    * rejected.  This is the symmetric recovery path for onFrameSubmitted.

package/src/glyph-text-layout-system.ts

@@ -158,7 +158,7 @@ interface GlyphTextData {
  */
 export function glyphTextLayoutSystem(
   world: World,
-  gpuStore: GpuResidencyCache,
+  gpuStore: Pick<GpuResidencyCache, 'updateMesh'>,
 ): Result<void, TextError> {
   resetFontConcurrency();
 
@@ -200,7 +200,7 @@ function collectGlyphEntities(world: World): EntityHandle[] {
  */
 function processEntity(
   world: World,
-  gpuStore: GpuResidencyCache,
+  gpuStore: Pick<GpuResidencyCache, 'updateMesh'>,
   entity: EntityHandle,
 ): TextError | null {
   const gtRes = world.get(entity, GlyphText);

package/src/gpu-driven/production-raster.ts

@@ -1359,6 +1359,7 @@ export interface PreparedGpuDrivenFrame {
   readonly projectShadow?: (
     graph: RenderGraphBuilder<RenderPipelineFrame>,
     identity: ShadowViewIdentity,
+    forceCompute?: boolean,
   ) => Result<ShadowViewProjection | undefined, RenderGraphError>;
   readonly updateShadowViews?: (
     views: readonly Omit<ShadowViewUpdateInput, 'sourcePlan' | 'scene'>[],
@@ -2572,7 +2573,12 @@ export class GpuDrivenProduction {
         ?.inspect()
         .map(
           (entry) =>
-            `${shadowViewIdentityKey(entry.identity)}:${entry.cache}:${entry.generation}:${entry.sourceRevision}:${entry.resourceGeneration}`,
+            // Cache decisions and logical update generations are frame-local
+            // producer state. They must not feed the compiled graph key: a
+            // graph replacement may intentionally invalidate a shadow view
+            // once without creating a graph-rebuild feedback loop. Resource
+            // and source-plan generations remain real graph dependencies.
+            `${shadowViewIdentityKey(entry.identity)}:${entry.sourceRevision}:${entry.resourceGeneration}`,
         )
         .join('|') ?? '';
     const production = this;
@@ -2689,10 +2695,10 @@ export class GpuDrivenProduction {
                 frameNumber,
               ),
           }),
-      projectShadow: (graph, identity) => {
+      projectShadow: (graph, identity, forceCompute = false) => {
         if (!shadowViewPool.isActive(identity) || shadowViewPool.submission(identity) === undefined)
           return ok(undefined);
-        return shadowViewPool.project(graph, identity);
+        return shadowViewPool.project(graph, identity, forceCompute);
       },
       updateShadowViews: (views) =>
         shadowFiltered.plan.batches.length > 0

package/src/gpu-driven/shadow-ownership.ts

@@ -1,5 +1,5 @@
-import type { World } from '@forgeax/engine-ecs';
 import { gpuDrivenShadowDrawKey } from '../extract/gpu-driven';
+import type { RenderResourceScope } from '../publication/resource-scope';
 import { worldEntityKey } from '../record/frame-snapshot';
 import type { ShadowCasterMembership } from '../render-system-extract';
 
@@ -7,12 +7,12 @@ const WORLD_ENTITY_KEY_STRIDE = 4294967296;
 
 /**
  * Extract emits world/entity keys in the transient `worlds[]` index domain,
- * while PersistentRenderScene owns stable renderer-local World keys for the
+ * while PersistentRenderScene owns stable renderer-local RenderResourceScope keys for the
  * retained GPU scene. Rebase ShadowCaster ownership at this orchestration
  * boundary before both GPU projection and CPU residual recording consume it.
  */
 export function rebaseShadowCasterOwnership(
-  worlds: readonly World[],
+  worlds: readonly RenderResourceScope[],
   stableWorldKeys: readonly number[],
   entityKeys: ReadonlySet<number>,
   drawKeys: ReadonlySet<string>,

package/src/gpu-driven/shadow-views.ts

@@ -395,14 +395,39 @@ export class ShadowViewStatePool {
   project<FrameCtx extends RenderGraphFrame>(
     builder: RenderGraphBuilder<FrameCtx>,
     identity: ShadowViewIdentity,
+    forceCompute = false,
   ): Result<ShadowViewProjection, RenderGraphError> {
     const record = this.records.get(identityKey(identity));
     if (record === undefined) return err(graphStateError(identity));
     const cacheHit = record.cache === 'hit' && !record.invalidated;
+    // A graph replacement must carry the shadow compute passes even when the
+    // view itself is a cache hit. The graph owns the pass list, so omitting
+    // compute work while importing a replacement graph would leave its
+    // indirect arguments stale. The normal pool contract still skips work on
+    // a cache hit; graph projection opts in explicitly at that boundary.
+    const includeCompute = forceCompute || !cacheHit;
+    let forceComputePending = forceCompute;
+    let lastFrame: FrameCtx | undefined;
+    let executeForFrame = false;
+    const executeCompute = (frame: FrameCtx): boolean => {
+      if (frame !== lastFrame) {
+        lastFrame = frame;
+        const currentRecord = this.records.get(identityKey(record.identity));
+        executeForFrame =
+          forceComputePending ||
+          currentRecord === undefined ||
+          currentRecord.cache !== 'hit' ||
+          currentRecord.invalidated;
+        forceComputePending = false;
+      }
+      return executeForFrame;
+    };
     const projected = record.view.addPasses(
       builder,
       shadowViewLabelPrefix(record.identity),
-      !cacheHit,
+      includeCompute,
+      undefined,
+      includeCompute ? executeCompute : undefined,
     );
     if (!projected.ok) return projected;
     return ok({
@@ -411,7 +436,7 @@ export class ShadowViewStatePool {
       generation: record.generation,
       plan: record.plan,
       view: record.view,
-      passNames: cacheHit ? Object.freeze([]) : passNames(record.identity),
+      passNames: includeCompute ? passNames(record.identity) : Object.freeze([]),
       graphResources: projected.value,
     });
   }

package/src/gpu-driven/view-gpu.ts

@@ -982,6 +982,7 @@ export class GpuDrivenView {
     labelPrefix = 'gpu-driven',
     includeCompute = true,
     surfaceSubmissionObservation?: () => SurfaceSubmissionCandidate | undefined,
+    executeIf?: (frame: FrameCtx) => boolean,
   ): Result<GpuDrivenViewGraphResources, RenderGraphError> {
     const buffers = this.buffers;
     const bindGroup = this.bindGroup;
@@ -1099,6 +1100,7 @@ export class GpuDrivenView {
         { resource: view.value, usage: 'uniform-read' },
         { resource: counters.value, usage: 'storage-read-write' },
       ],
+      ...(executeIf === undefined ? {} : { executeIf }),
       encode: ({ pass }) => {
         pass.setPipeline(this.resetPipeline);
         pass.setBindGroup(0, bindGroup);
@@ -1116,6 +1118,7 @@ export class GpuDrivenView {
         { resource: counters.value, usage: 'storage-read-write' },
         { resource: visible.value, usage: 'storage-read-write' },
       ],
+      ...(executeIf === undefined ? {} : { executeIf }),
       encode: ({ pass }) => {
         pass.setPipeline(this.cullPipeline);
         pass.setBindGroup(0, bindGroup);
@@ -1130,6 +1133,7 @@ export class GpuDrivenView {
         { resource: counters.value, usage: 'storage-read' },
         { resource: indirect.value, usage: 'storage-read-write' },
       ],
+      ...(executeIf === undefined ? {} : { executeIf }),
       encode: ({ pass }) => {
         pass.setPipeline(this.finalizePipeline);
         pass.setBindGroup(0, bindGroup);
@@ -1148,6 +1152,7 @@ export class GpuDrivenView {
         { resource: indirect.value, usage: 'copy-src' },
         { resource: lodReadback.value, usage: 'copy-dst' },
       ],
+      ...(executeIf === undefined ? {} : { executeIf }),
       encode: ({ encoder, resources }) => {
         // A cached graph may run while an observer is awaiting mapAsync on the
         // previous copy. WebGPU forbids submitting a copy into a

package/src/ibl/frame-resources.ts

@@ -32,7 +32,6 @@ export function resolveFrameSkylightResources(
     prefilterView: resident?.prefilterView ?? fallback.prefilterView,
     prefilterSampler: fallback.sampler,
     brdfLutView: resident?.brdfLutView ?? fallback.brdfLutView,
-    brdfLutSampler: fallback.sampler,
     intensityBuffer: fallback.intensityBuffer,
   });
 }

package/src/ibl/skylight-bind-group.ts

@@ -1,20 +1,20 @@
 // skylight-bind-group.ts -- Skylight resources merged into @group(1) PBR
-// material BGL (binding 7..13) + fallback identity resource bundle. The
+// material BGL (binding 7..12) + fallback identity resource bundle. The
 // complete Standard material group appends transmission entries.
 //
 // Plan-strategy D-5 (round-4 REVISED): the round-2 stand-alone @group(4)
 // Skylight BindGroupLayout collided with WebGPU's default maxBindGroups=4
 // limit, blocking pbr-pl pipeline-layout creation in chrome-beta. Round-4
-// rewrites the contract: Skylight 7 entries are **appended** to the
-// existing PBR material BindGroupLayout at bindings 7..13; pipeline layout
+// rewrites the contract: Skylight 6 entries are **appended** to the
+// existing PBR material BindGroupLayout at bindings 7..12; pipeline layout
 // stays at 4 slots `[view, material, mesh, instances]`; unlit pipeline is
 // untouched (it uses its own material BGL).
 //
 // Surface (M2 round-4 / t40 amend):
 //   - mergeSkylightIntoMaterialBgl(materialBglEntries): given the existing
 //     7 PBR material BindGroupLayout entries (binding 0..6), returns the
-//     merged 14-entry array with Skylight resources at binding 7..13
-//     [irrTex, irrSampler, prefTex, prefSampler, brdfTex, brdfSampler,
+//     merged 13-entry array with Skylight resources at binding 7..12
+//     [irrTex, irrSampler, prefTex, prefSampler, brdfTex,
 //     uniform { intensity: f32 }]. The merge is a pure function -- caller
 //     (createRenderer) is responsible for passing the result to
 //     `device.createBindGroupLayout`.
@@ -124,13 +124,13 @@ export interface SkylightQueue {
  */
 export interface SkylightBindGroupResources {
   readonly irradianceView: TextureView;
+  /** Shared by diffuse irradiance and the BRDF lookup table. */
   readonly irradianceSampler: Sampler;
   readonly prefilterView: TextureView;
   /** Present only when the per-draw prefilter slot was replaced by a local probe. */
   readonly skylightPrefilterView?: TextureView;
   readonly prefilterSampler: Sampler;
   readonly brdfLutView: TextureView;
-  readonly brdfLutSampler: Sampler;
   readonly intensityBuffer: Buffer;
 }
 
@@ -143,7 +143,7 @@ export interface SkylightBindGroupResources {
  *
  * No stand-alone `bindGroup` field: the round-2 stand-alone Skylight BG
  * is gone (D-5 round-4); the fallback resources flow into the PBR
- * material BG at binding 7..13.
+ * material BG at binding 7..12.
  */
 export interface SkylightFallback {
   readonly irradianceTexture: Texture;
@@ -159,7 +159,7 @@ export interface SkylightFallback {
 // ─── Pure merger: BindGroupLayout entries (D-5 round-4) ─────────────────────
 
 /**
- * Append the 7 Skylight BindGroupLayout entries after the existing PBR
+ * Append the 6 Skylight BindGroupLayout entries after the existing PBR
  * user-region entries. Pure function -- the
  * caller passes the result to `device.createBindGroupLayout`. Charter P4
  * consistent abstraction: one BGL holds material + Skylight together,
@@ -208,16 +208,10 @@ export function mergeSkylightIntoMaterialBgl(
     visibility: GPU_SHADER_STAGE_FRAGMENT,
     texture: { sampleType: 'float', viewDimension: '2d' },
   } as BglEntry);
-  // binding 12: brdfLutSampler
+  // binding 12: uniform { intensity: f32 }
   merged.push({
     binding: skylightBindingStart + 5,
     visibility: GPU_SHADER_STAGE_FRAGMENT,
-    sampler: { type: 'filtering' },
-  } as BglEntry);
-  // binding 13: uniform { intensity: f32 }
-  merged.push({
-    binding: skylightBindingStart + 6,
-    visibility: GPU_SHADER_STAGE_FRAGMENT,
     buffer: { type: 'uniform' },
   } as BglEntry);
   return merged;
@@ -226,7 +220,7 @@ export function mergeSkylightIntoMaterialBgl(
 // ─── Pure merger: BindGroupEntry values (assembly site) ─────────────────────
 
 /**
- * Append the 7 Skylight BindGroupEntry resources (binding 7..13) onto the
+ * Append the 6 Skylight BindGroupEntry resources (binding 7..12) onto the
  * existing PBR material BindGroupEntry values (binding 0..6). The caller
  * passes the result to `device.createBindGroup` as part of the merged
  * material BG.
@@ -301,10 +295,6 @@ export function assembleMaterialWithSkylightEntries(
     },
     {
       binding: iblStart + 5,
-      resource: { kind: 'sampler', value: skylight.brdfLutSampler },
-    },
-    {
-      binding: iblStart + 6,
       resource: { kind: 'buffer', value: { buffer: skylight.intensityBuffer } },
     },
   ];
@@ -413,11 +403,9 @@ export function createSkylightFallback(
   device: SkylightDevice,
   queue: SkylightQueue,
 ): SkylightFallback {
-  // One sampler shared across the three texture slots. The PBR material
-  // BindGroup still declares 3 separate sampler bindings (D-5 round-4
-  // ordering at binding 8/10/12), so we pass the same handle three times
-  // in assembleMaterialWithSkylightEntries; WebGPU spec permits sampler
-  // reuse across BindGroupEntry slots.
+  // Diffuse IBL and the BRDF LUT share one binding; prefilter remains a
+  // separate binding so per-draw reflection probes can replace it. Both
+  // bindings use this linear-clamp sampler for the global environment.
   const samplerResult = device.createSampler({
     label: 'skylight-fallback-sampler',
     magFilter: 'linear',

package/src/index.ts

@@ -560,6 +560,15 @@ export {
   type PointsStyleInput,
 } from './points-lines/admission.js';
 export type { PointsLinesInspection } from './points-lines/inspection.js';
+export {
+  type PublishedRenderFrameInput,
+  type RenderPublication,
+  RenderPublicationError,
+  type RenderPublicationIdentity,
+  renderPublicationTransfers,
+} from './publication/contract';
+export { createRenderPublisher, type RenderPublicationCandidate } from './publication/publisher';
+export { RenderPublicationTargetOwner, type RenderTargetAuthoring } from './publication/targets';
 /**
  * Public bounded GPU pass facts. Use the single `gpuPassTiming` opt-in,
  * `draw()` receipt, and `observe(receipt, { include: ['timings'] })` route.

package/src/instances.ts

@@ -1,4 +1,3 @@
-import type { World } from '@forgeax/engine-ecs';
 import { InstanceTransformsStrideMismatchError } from '@forgeax/engine-ecs/projection';
 import type { RhiErrorCode } from '@forgeax/engine-rhi';
 
@@ -93,7 +92,7 @@ export function instanceUploadRangesForResident(
 }
 
 interface Projection extends InstanceCollectionSnapshot {
-  readonly world: World;
+  readonly world: object;
   readonly entity: number;
 }
 interface Residency {
@@ -112,11 +111,15 @@ interface Residency {
 export class InstanceProjectionStore {
   private nextId = 1;
   private nextGeneration = 1;
-  private identities = new WeakMap<World, Map<number, InstanceCollectionId>>();
+  private identities = new WeakMap<object, Map<number, InstanceCollectionId>>();
   private readonly records = new Map<InstanceCollectionId, Projection>();
   private readonly residency = new Map<InstanceCollectionId, Residency>();
 
-  project(world: World, entity: number, transforms: ArrayLike<number>): InstanceCollectionSnapshot {
+  project(
+    world: object,
+    entity: number,
+    transforms: ArrayLike<number>,
+  ): InstanceCollectionSnapshot {
     const collectionId =
       this.identities.get(world)?.get(entity) ?? (this.nextId++ as InstanceCollectionId);
     const previous = this.records.get(collectionId);
@@ -147,7 +150,7 @@ export class InstanceProjectionStore {
 
   /** Called only after the owning RenderScene accepts its prepared changes. */
   accept(
-    world: World,
+    world: object,
     entity: number,
     snapshot: {
       readonly collectionId?: InstanceCollectionId;
@@ -175,7 +178,7 @@ export class InstanceProjectionStore {
     });
   }
 
-  release(world: World, entity: number): void {
+  release(world: object, entity: number): void {
     const entities = this.identities.get(world);
     const id = entities?.get(entity);
     if (id === undefined) return;

package/src/pbr-pipeline.ts

@@ -6,7 +6,7 @@
 //     material BGL grows from the derived user region by appending the 7
 //     Skylight resources via `mergeSkylightIntoMaterialBgl`. The
 //     unlit pipeline keeps its 7-entry material BGL (no Skylight binding
-//     7..13 contamination) so unlit demos don't carry IBL state.
+//     7..12 contamination) so unlit demos don't carry IBL state.
 //   - charter P4: same pipeline layout shape drives Skylight present +
 //     absent paths -- AI users do not branch on Skylight existence.
 //   - feat-20260520-skylight-ibl-cubemap M4 / t59 (round-4): the
@@ -158,7 +158,10 @@ export function buildPbrMaterialUserRegionEntries(
   let entries = derived.bglEntries.map(
     (entry): GPUBindGroupLayoutEntry => ({
       binding: entry.binding,
-      visibility: entry.visibility,
+      visibility:
+        entry.texture !== undefined || entry.sampler !== undefined
+          ? GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT
+          : entry.visibility,
       ...(entry.buffer === undefined ? {} : { buffer: entry.buffer }),
       ...(entry.sampler === undefined ? {} : { sampler: entry.sampler }),
       ...(entry.texture === undefined ? {} : { texture: entry.texture }),
@@ -209,8 +212,8 @@ export function buildPbrMaterialUserRegionEntries(
 //                (group(0) bindings 3..7); this kind is the seam for
 //                each per-material shadow override surface a future feat
 //                wires onto group(1).
-//   - 'ibl'      the 7 IBL / Skylight entries (irradiance / prefilter
-//                cube + brdfLut 2d + 3 samplers + intensity uniform).
+//   - 'ibl'      the 6 IBL / Skylight entries (irradiance / prefilter
+//                cube + brdfLut 2d + 2 samplers + intensity uniform).
 //                Used by `buildPbrPipelineLayouts` after the user-region
 //                user paramSchema entries are emitted.
 //   - 'lightmap' the 4 emissive + occlusion entries (sampler + texture
@@ -224,7 +227,7 @@ export function buildPbrMaterialUserRegionEntries(
 //                placeholders because their shaders do not read these slots.
 export type InjectionKind = keyof typeof INJECTION_KIND_LENGTHS;
 
-const IBL_INJECTION_LENGTH = 7;
+const IBL_INJECTION_LENGTH = 6;
 const LIGHTMAP_INJECTION_LENGTH = 4;
 const SHADOW_INJECTION_LENGTH = 2;
 const TRANSMISSION_INJECTION_LENGTH = 2;
@@ -283,16 +286,10 @@ export function appendInjection(
           visibility: GPU_SHADER_STAGE_FRAGMENT,
           texture: { sampleType: 'float', viewDimension: '2d' },
         },
-        // binding start+5: brdfLutSampler
+        // binding start+5: uniform { intensity: f32 }
         {
           binding: start + 5,
           visibility: GPU_SHADER_STAGE_FRAGMENT,
-          sampler: { type: 'filtering' },
-        },
-        // binding start+6: uniform { intensity: f32 }
-        {
-          binding: start + 6,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
           buffer: { type: 'uniform' },
         },
       ];
@@ -1119,13 +1116,13 @@ export function pbrSkinMeshDynamicOffsets(
 
 /**
  * Build a stand-alone 7-entry unlit material BGL. Round-4 D-5 keeps unlit
- * material BG isolated from Skylight binding 7..13 -- unlit demos do not
+ * material BG isolated from Skylight binding 7..12 -- unlit demos do not
  * pay for IBL state. The unlit pipeline still binds material at slot 1,
  * just with a 7-entry layout.
  *
  * Note: at the moment the runtime still routes both unlit + standard
  * through a single 14-entry pipeline layout; the unlit material BG
- * carries fallback identity resources at binding 7..13. This factory is
+ * carries fallback identity resources at binding 7..12. This factory is
  * exported as a future-proof seam for the moment when unlit demos own
  * their own pipeline layout (t57 (e) test pins the contract today so the
  * eventual split has a green target).
@@ -1241,7 +1238,7 @@ export const SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET = '';
  *
  * Three groups by derivation source:
  * 1. Shader-derived (paramSchema reflection + injection chain):
- *    - `'pbr-material-merged'` — derived user region + Skylight 7 + transmission 2
+ *    - `'pbr-material-merged'` — derived user region + Skylight 6 + transmission 2
  *    - `'unlit-material'` — 7 entries: base PBR material only (no inject)
  *    - `'hdrp-7-slot'` — 7 entries (binding 0 + 3..8): HDRP cluster + SSAO group(2) BGL
  * 2. Caps-driven literal shapes (no shader):
@@ -1638,11 +1635,11 @@ export function buildBindGroupLayoutDescriptor(
     }
     case 'pbr-material-merged': {
       // Material BGL: per-shader user-region (derive(paramSchema).bglEntries)
-      // + IBL injection (7) + transmission injection (2). The user-region
+      // + IBL injection (6) + transmission injection (2). The user-region
       // size is the only variable; injection start = userRegion.length so a
       // custom schema shifts IBL/transmission by its sampler/texture pairs.
-      // The built-in standard-PBR schema is 17 + 7 + 2 = 26 entries;
-      // clearcoat texture pairs are derived from the effective root schema.
+      // The built-in standard-PBR user region has 15 entries;
+      // scene rows follow injection, and physical texture pairs follow the effective root schema.
       //
       // Schema source priority (D-1): explicit materialParamSchema option >
       // registry lookup of spec.shader.id > built-in standard-PBR fallback.

package/src/pipeline/standard-output/lut-gpu.ts

@@ -1,6 +1,5 @@
 import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
-import type { World } from '@forgeax/engine-ecs';
 import type { RenderGraphBuilder, RenderGraphError } from '@forgeax/engine-render-graph';
 import type {
   BindGroup,
@@ -13,6 +12,7 @@ import type {
 } from '@forgeax/engine-rhi';
 import { err, type Handle, ok, type Result, type TextureAsset } from '@forgeax/engine-types';
 import type { GpuResidencyCache, TextureGpuEntry } from '../../device/gpu-residency';
+import type { RenderResourceScope } from '../../publication/resource-scope';
 import type { RenderPipelineFrame, RenderPipelineTarget } from '../../render-pipeline';
 import {
   admitStandardColorLut,
@@ -41,7 +41,7 @@ export interface StandardLutGraphProjection {
 }
 
 export interface StandardLutGpuPreparationInput {
-  readonly world: World;
+  readonly world: RenderResourceScope;
   readonly handle: Handle<'TextureAsset', 'shared'>;
   readonly strength: number;
   readonly assets: AssetRegistry;
@@ -125,7 +125,7 @@ export function prepareStandardLutGpu(
   if (!asset.ok) {
     return failure(
       'standard-lut-residency-failed',
-      'the authored TextureAsset handle resolves in the active World',
+      'the authored TextureAsset handle resolves in the active RenderResourceScope',
       'register or rebuild the TextureAsset, then retry the same camera generation',
       causeDetail(asset.error),
     );

package/src/pipeline/standard-output/resources.ts

@@ -1,6 +1,6 @@
-import type { World } from '@forgeax/engine-ecs';
 import { err, ok, type Result, RhiError } from '@forgeax/engine-rhi';
 import { toShared } from '@forgeax/engine-types';
+import type { RenderResourceScope } from '../../publication/resource-scope';
 import type { RenderFrameState } from '../../record/frame-snapshot';
 import type { RenderSystemInternals } from '../../record/render-context';
 import type { CameraSnapshot } from '../../render-contract';
@@ -17,7 +17,7 @@ export function prepareStandardOutputResources(
   state: RenderFrameState,
   internals: RenderSystemInternals,
   camera: CameraSnapshot | undefined,
-  world: World,
+  world: RenderResourceScope,
 ): Result<void, RhiError> {
   const output = camera?.output;
   if (output?.exposure.kind === 'auto') {