@forgeax/engine-render 0.1.29 → 0.1.31

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

@@ -24,9 +24,11 @@ import type { MeshGpuHandles } from '../device/gpu-residency';
 import { GpuDrivenPreparationError } from '../errors/gpu-driven';
 import {
   gpuDrivenDrawKey,
+  gpuDrivenMaterialArtifactKey,
   gpuDrivenShadowDrawKey,
   gpuDrivenSourceDrawItemIndex,
 } from '../extract/gpu-driven';
+import { GPU_SCENE_LAYOUTS } from '../gpu-scene-schema';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_INDEX,
@@ -40,14 +42,20 @@ import type {
   GpuDrivenProductionInspection,
   GpuDrivenStructureMetrics,
 } from '../inspection-types';
+import { isStandardPbrMaterialShader, resolvePipelineGroup2Contract } from '../pbr-pipeline';
 import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
 import type { ValidatedRenderable } from '../record/frame-snapshot';
 import { worldEntityKey } from '../record/frame-snapshot';
 import { geometryRenderStateForTopology } from '../record/main-pass-material';
 import { MESH_SSBO_BYTES, packInstanceStorageBuffer } from '../record/mesh-ssbo';
-import type { PipelineState } from '../record/render-context';
+import {
+  MATERIAL_PER_ENTITY_STRIDE,
+  type PipelineState,
+  type RenderSystemInternals,
+} from '../record/render-context';
 import type { CameraSnapshot } from '../render-contract';
 import type {
+  GpuDrivenSceneMeshBinding,
   GpuDrivenStandardPbrFrameResources,
   RenderPipelineFrame,
   RenderPipelineGpuDrivenProjection,
@@ -67,6 +75,7 @@ import {
   projectedHeightForCandidate,
   type SubmissionPlan,
 } from './batch-topology';
+import { materialBindingKey } from './material-bindings';
 import { type GpuDrivenPbrProgram, resolveStandardPbrProgram } from './pbr-program';
 import {
   type ShadowViewIdentity,
@@ -99,10 +108,17 @@ export interface GpuDrivenShadowBatchProjection {
   readonly meshBindGroup: BindGroup;
   readonly visibleBindGroup: BindGroup;
   readonly deformation: 'rigid' | 'skin';
+  /** Actual producer-selected shadow-pass artifact for this batch. */
+  readonly shadowArtifact: MaterialShaderArtifact;
+  /** Pass entry points selected by the authored ShadowCaster dispatch. */
+  readonly shadowVertexEntry?: string;
+  readonly shadowFragmentEntry?: string;
   /** Material snapshot used to assemble the receipt-owned alpha-mask BG. */
   readonly material: MaterialSnapshot;
   /** Composite entity identity used only for video-resource routing. */
   readonly materialEntityKey: number;
+  /** Geometry-owned COLOR_0 fact shared by main and shadow ABI variants. */
+  readonly vertexColorAvailable: boolean;
 }
 
 /**
@@ -227,6 +243,8 @@ export function adaptStandardPbrFrameResources(input: {
 interface PreparedBatch {
   readonly batch: GpuDrivenBatch;
   readonly mesh: MeshGpuHandles;
+  /** Exact producer artifact selected by every draw in this homogeneous batch. */
+  readonly artifact: MaterialShaderArtifact;
   readonly renderState: MaterialRenderState | undefined;
   /** Stable World attachment key used to join same-submit GPU counters. */
   readonly worldKey: number;
@@ -298,12 +316,8 @@ function hasFiniteOrderedBounds(bounds: Float32Array | undefined): boolean {
 
 function skinLaneReason(
   snapshot: RenderableSnapshot,
-  material: MaterialSnapshot,
 ): 'skin-bounds-missing' | 'skin-address-missing' | undefined {
-  const isSkinnedPbr =
-    material.materialShaderId === 'forgeax::pbr-skin' ||
-    material.materialShaderId === 'forgeax::default-standard-pbr-skin';
-  if (!isSkinnedPbr || snapshot.skin === undefined) return undefined;
+  if (snapshot.skin === undefined) return undefined;
   if (!hasFiniteOrderedBounds(snapshot.skin.bounds)) return 'skin-bounds-missing';
   if (
     snapshot.skin.storageOrUniform !== 'storage' ||
@@ -347,15 +361,19 @@ function preparedPbrCandidateEligible(
   snapshot: RenderableSnapshot,
   batch: GpuDrivenBatch,
   candidate: GpuDrivenBatch['candidates'][number],
-  skinArtifact?: MaterialShaderArtifact,
+  artifact: MaterialShaderArtifact | undefined,
 ): boolean {
   const material = snapshot.materials[batch.key.materialSlot] ?? snapshot.material;
   const prepared = candidate.prepared;
   if (prepared === undefined) return false;
-  const standard =
-    prepared.identity.material === 'forgeax::default-standard-pbr' ||
-    prepared.identity.material === 'forgeax::pbr-skin' ||
-    prepared.identity.material === 'forgeax::default-standard-pbr-skin';
+  const receipt = artifact?.receipt;
+  const publishedAbiMatches =
+    receipt !== undefined &&
+    artifact?.material === prepared.identity.material &&
+    (prepared.receiptIdentity === undefined ||
+      (prepared.receiptIdentity === receipt.receiptIdentity &&
+        prepared.receiptGeneration === receipt.generation)) &&
+    receipt.reflection.layoutIdentity === artifact?.layoutIdentity;
   const alphaBlend = material.transparent === true || material.renderState?.blend !== undefined;
   const cpuOnlyMaterialResources =
     (material.textureSources?.size ?? 0) > 0 || (material.videoTextureFields?.size ?? 0) > 0;
@@ -363,18 +381,19 @@ function preparedPbrCandidateEligible(
   // GPU-owned candidate set so the residual transmission draw is not swallowed
   // by the generic Standard PBR lane.
   const transmission =
+    isStandardPbrMaterialShader(prepared.identity.material) &&
     typeof material.paramSnapshot?.transmission === 'number' &&
     material.paramSnapshot.transmission > 0;
   const skinReady =
     prepared.identity.deformation !== 'skin' ||
-    (skinArtifact?.receipt?.skinPaletteAddress !== undefined &&
+    (artifact?.receipt?.skinPaletteAddress !== undefined &&
       snapshot.skin?.storageOrUniform === 'storage' &&
       snapshot.skin.customDataStart >= 0 &&
       Number.isInteger(snapshot.skin.customDataStart) &&
       snapshot.skin.buffer !== undefined &&
       hasFiniteOrderedBounds(snapshot.skin.bounds));
   return (
-    standard &&
+    publishedAbiMatches &&
     !alphaBlend &&
     !cpuOnlyMaterialResources &&
     !transmission &&
@@ -432,7 +451,13 @@ function gpuDrivenProjectionKey(
   deformation: 'rigid' | 'skin',
   artifact: MaterialShaderArtifact,
 ): string {
-  return `${batch.batchId}:${batch.generation}:${deformation}:${artifact.layoutIdentity}`;
+  const receipt = artifact.receipt;
+  return `${batch.batchId}:${batch.generation}:${gpuDrivenMaterialArtifactKey({
+    material: artifact.material,
+    deformation,
+    receiptIdentity: receipt?.receiptIdentity,
+    receiptGeneration: receipt?.generation ?? 0,
+  })}:${artifact.variantSet ?? ''}:${materialArtifactProgramIdentity(artifact)}:${artifact.vertexEntry ?? receipt?.sceneIndexEntry ?? ''}:${artifact.fragmentEntry ?? ''}`;
 }
 
 function gpuDrivenShadowProjectionKey(
@@ -454,6 +479,26 @@ function sourceDrawForCandidate(
   );
 }
 
+const materialArtifactProgramIdentities = new WeakMap<
+  MaterialShaderArtifact,
+  { readonly source: string; readonly identity: string }
+>();
+
+/** Hash a publication once; replacement source invalidates the same artifact key. */
+function materialArtifactProgramIdentity(artifact: MaterialShaderArtifact): string {
+  const source = artifact.specializationKey ?? artifact.wgsl;
+  const cached = materialArtifactProgramIdentities.get(artifact);
+  if (cached?.source === source) return cached.identity;
+  let hash = 2166136261;
+  for (let index = 0; index < source.length; index += 1) {
+    hash ^= source.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  const identity = `${source.length}:${hash >>> 0}`;
+  materialArtifactProgramIdentities.set(artifact, { source, identity });
+  return identity;
+}
+
 function shadowKeysForCandidate(
   slot: PersistentGpuDrivenState['slots'][number],
   candidate: GpuDrivenBatch['candidates'][number],
@@ -524,8 +569,10 @@ function shadowMembershipIsGpuCompatible(
   const membership = matching[0];
   if (membership?.cpuReason !== undefined) return false;
   if (membership?.renderState !== undefined) return false;
-  const shader = membership?.materialShaderId;
-  return shader === undefined || shader === 'forgeax::default-shadow-caster';
+  // Older synthetic membership fixtures omit the producer flag and remain
+  // compatible; extracted records always carry it. A false flag is an
+  // authored/producer decision and must keep the draw on its CPU lane.
+  return membership?.gpuDrivenEligible !== false;
 }
 
 function selectedLodLevel(candidate: GpuDrivenCandidate): number {
@@ -578,6 +625,9 @@ function filteredPlan(
   camera?: CameraSnapshot,
   activeEntityKeys?: ReadonlySet<number>,
   worldKeys?: readonly number[],
+  materialArtifact?: MaterialShaderArtifact,
+  materialArtifacts?: ReadonlyMap<string, MaterialShaderArtifact>,
+  materialBindingClasses?: ReadonlyMap<string, string>,
 ): {
   readonly plan: SubmissionPlan;
   readonly batches: readonly PreparedBatch[];
@@ -601,6 +651,7 @@ function filteredPlan(
     }
   }
   const eligibleMainCandidates = new Set<string>();
+  const eligibleArtifacts = new Map<string, MaterialShaderArtifact>();
   const drawKeys = new Set<string>();
   const eligibleShadowCandidates = new Set<string>();
   const shadowDrawKeys = new Set<string>();
@@ -617,13 +668,23 @@ function filteredPlan(
       for (const candidate of batch.candidates) {
         if (candidate.primitiveIndex !== slot.slot) continue;
         const draw = sourceDrawForCandidate(slot, candidate);
+        const selectedArtifact = artifactForPreparedCandidate(
+          candidate,
+          materialArtifacts,
+          materialArtifact,
+          skinArtifact,
+        );
         const mainEligible =
           draw !== undefined &&
-          preparedPbrCandidateEligible(slot.snapshot, batch, candidate, skinArtifact) &&
+          preparedPbrCandidateEligible(slot.snapshot, batch, candidate, selectedArtifact) &&
           mesh !== undefined &&
           meshSupportsBatch(mesh, batch);
+        const candidateKey = shadowCandidateKey(candidate);
+        if (mainEligible && selectedArtifact !== undefined) {
+          eligibleArtifacts.set(candidateKey, selectedArtifact);
+        }
         if (!shadowSelectionProvided && mainEligible && draw !== undefined) {
-          eligibleMainCandidates.add(shadowCandidateKey(candidate));
+          eligibleMainCandidates.add(candidateKey);
           const material = slot.snapshot.materials[draw.materialSlot] ?? slot.snapshot.material;
           drawKeys.add(
             gpuDrivenDrawKey(
@@ -661,6 +722,7 @@ function filteredPlan(
     {
       readonly source: GpuDrivenBatch;
       readonly mesh: MeshGpuHandles;
+      readonly artifact: MaterialShaderArtifact;
       readonly renderState: MaterialRenderState | undefined;
       readonly candidates: GpuDrivenCandidate[];
     }
@@ -684,6 +746,8 @@ function filteredPlan(
       if (slot === undefined) continue;
       const mesh = meshBySlot.get(slot.slot);
       if (mesh === undefined) continue;
+      const artifact = eligibleArtifacts.get(shadowCandidateKey(candidate));
+      if (artifact === undefined) continue;
       const physicalLodRanges = mesh.lodRanges
         ?.slice(1)
         .map((ranges) => ranges[candidate.drawItemIndex]);
@@ -701,7 +765,23 @@ function filteredPlan(
       const selectedRange = selectedLodRange(batch, projected);
       const groupKey = JSON.stringify({
         key: batch.key,
+        artifact: [
+          artifact.material,
+          artifact.layoutIdentity,
+          artifact.receipt?.receiptIdentity ?? '',
+          artifact.receipt?.generation ?? 0,
+          artifact.variantSet ?? '',
+          materialArtifactProgramIdentity(artifact),
+        ],
         worldKey: worldKeyFor(slot),
+        bindingClass:
+          materialBindingClasses?.get(
+            materialBindingKey(
+              slot.snapshot,
+              (slot.snapshot.materials[batch.key.materialSlot] ?? slot.snapshot.material)
+                .materialHandle ?? -1,
+            ),
+          ) ?? '',
         lodCoverages: projected.lodCoverages ?? null,
         lodRanges: projected.lodRanges ?? null,
         selectedRange,
@@ -713,6 +793,7 @@ function filteredPlan(
         groups.set(groupKey, {
           source: batch,
           mesh,
+          artifact,
           renderState: geometryRenderStateForTopology(batch.key.topology, material.renderState),
           candidates: [projected],
         });
@@ -765,6 +846,7 @@ function filteredPlan(
     batches.push({
       batch: filtered,
       mesh: group.mesh,
+      artifact: group.artifact,
       renderState: group.renderState,
       worldKey: worldKeyFor(firstSlot),
       primitiveSlot: firstSlot.slot,
@@ -833,6 +915,7 @@ function shadowCasterMembershipSignature(
         entry.materialShaderId ?? '',
         JSON.stringify(entry.renderState ?? null),
         entry.cpuReason ?? '',
+        entry.gpuDrivenEligible === undefined ? '' : String(entry.gpuDrivenEligible),
       ].join(':'),
     )
     .sort()
@@ -845,11 +928,8 @@ type FilteredProductionPlan = ReturnType<typeof filteredPlan>;
 function sceneRequiresGpuDrivenArtifact(scene: PersistentGpuDrivenState): boolean {
   return scene.plan.batches.some((batch) =>
     batch.candidates.some((candidate) => {
-      const material = candidate.prepared?.identity.material;
       return (
-        (material === 'forgeax::default-standard-pbr' ||
-          material === 'forgeax::pbr-skin' ||
-          material === 'forgeax::default-standard-pbr-skin') &&
+        candidate.prepared?.receiptIdentity !== undefined &&
         (candidate.prepared?.identity.deformation === 'rigid' ||
           candidate.prepared?.identity.deformation === 'skin')
       );
@@ -857,6 +937,31 @@ function sceneRequiresGpuDrivenArtifact(scene: PersistentGpuDrivenState): boolea
   );
 }
 
+function missingMaterialArtifact(
+  scene: PersistentGpuDrivenState,
+  artifacts: ReadonlyMap<string, MaterialShaderArtifact> | undefined,
+  rigidFallback: MaterialShaderArtifact | undefined,
+  skinFallback: MaterialShaderArtifact | undefined,
+): GpuDrivenPreparationError | undefined {
+  for (const batch of scene.plan.batches) {
+    for (const candidate of batch.candidates) {
+      const prepared = candidate.prepared;
+      if (prepared?.receiptIdentity === undefined) continue;
+      if (
+        artifactForPreparedCandidate(candidate, artifacts, rigidFallback, skinFallback) !==
+        undefined
+      )
+        continue;
+      return new GpuDrivenPreparationError('missing-material-receipt', {
+        reason: 'material-receipt-missing',
+        owner: 'material',
+        expected: `published artifact for ${prepared.identity.material} (${prepared.receiptIdentity}@${prepared.receiptGeneration})`,
+      });
+    }
+  }
+  return undefined;
+}
+
 function nonCpuPreparationFailure(
   scene: PersistentGpuDrivenState,
 ): { readonly error: GpuDrivenPreparationError; readonly drawKeys: readonly string[] } | undefined {
@@ -926,8 +1031,110 @@ function sameEntityKeySet(
   return true;
 }
 
+type MaterialPipelineFactory = NonNullable<RenderSystemInternals['getMaterialShaderPipelineEntry']>;
+
+function artifactForPreparedCandidate(
+  candidate: GpuDrivenBatch['candidates'][number],
+  artifacts: ReadonlyMap<string, MaterialShaderArtifact> | undefined,
+  rigidFallback: MaterialShaderArtifact | undefined,
+  skinFallback: MaterialShaderArtifact | undefined,
+): MaterialShaderArtifact | undefined {
+  const prepared = candidate.prepared;
+  if (prepared === undefined) return undefined;
+  const exact = artifacts?.get(
+    gpuDrivenMaterialArtifactKey({
+      material: prepared.identity.material,
+      deformation: prepared.identity.deformation,
+      receiptIdentity: prepared.receiptIdentity,
+      receiptGeneration: prepared.receiptGeneration,
+    }),
+  );
+  if (exact !== undefined) return exact;
+  // A map supplied by the real record path is authoritative. A receipt-backed
+  // draw missing from it is a producer/load failure, not permission to pair
+  // the draw with another material's artifact.
+  if (artifacts !== undefined && prepared.receiptIdentity !== undefined) return undefined;
+  const fallback = prepared.identity.deformation === 'skin' ? skinFallback : rigidFallback;
+  return fallback?.material === prepared.identity.material ? fallback : undefined;
+}
+
+function shadowArtifactForPreparedCandidate(
+  candidate: GpuDrivenBatch['candidates'][number],
+  artifacts: ReadonlyMap<string, MaterialShaderArtifact> | undefined,
+  fallback: MaterialShaderArtifact | undefined,
+): MaterialShaderArtifact | undefined {
+  const prepared = candidate.prepared;
+  if (prepared === undefined) return undefined;
+  const exact = artifacts?.get(
+    gpuDrivenMaterialArtifactKey({
+      material: prepared.identity.material,
+      deformation: prepared.identity.deformation,
+      receiptIdentity: prepared.receiptIdentity,
+      receiptGeneration: prepared.receiptGeneration,
+    }),
+  );
+  if (exact !== undefined) return exact;
+  // Direct production fixtures predate the separate shadow publication map.
+  // They are allowed to reuse the already validated artifact; a real frame
+  // passes the authoritative map and therefore fails closed on a missing
+  // shadow program instead of silently selecting the forward program.
+  return artifacts === undefined ? fallback : undefined;
+}
+
+function materialArtifactSignature(
+  artifacts: ReadonlyMap<string, MaterialShaderArtifact> | undefined,
+  rigidFallback: MaterialShaderArtifact | undefined,
+  skinFallback: MaterialShaderArtifact | undefined,
+): string {
+  const rows =
+    artifacts === undefined
+      ? []
+      : [...artifacts.entries()]
+          .map(([key, artifact]) => [
+            key,
+            artifact.material,
+            artifact.layoutIdentity,
+            artifact.receipt?.receiptIdentity ?? '',
+            artifact.receipt?.generation ?? 0,
+            artifact.variantSet ?? '',
+            materialArtifactProgramIdentity(artifact),
+            artifact.vertexEntry ?? artifact.receipt?.sceneIndexEntry ?? '',
+            artifact.fragmentEntry ?? '',
+          ])
+          .sort((left, right) => String(left[0] ?? '').localeCompare(String(right[0] ?? '')));
+  return JSON.stringify({
+    rows,
+    rigid:
+      rigidFallback === undefined
+        ? undefined
+        : [
+            rigidFallback.material,
+            rigidFallback.layoutIdentity,
+            rigidFallback.receipt?.receiptIdentity ?? '',
+            rigidFallback.receipt?.generation ?? 0,
+            rigidFallback.variantSet ?? '',
+            materialArtifactProgramIdentity(rigidFallback),
+            rigidFallback.vertexEntry ?? rigidFallback.receipt?.sceneIndexEntry ?? '',
+            rigidFallback.fragmentEntry ?? '',
+          ],
+    skin:
+      skinFallback === undefined
+        ? undefined
+        : [
+            skinFallback.material,
+            skinFallback.layoutIdentity,
+            skinFallback.receipt?.receiptIdentity ?? '',
+            skinFallback.receipt?.generation ?? 0,
+            skinFallback.variantSet ?? '',
+            materialArtifactProgramIdentity(skinFallback),
+            skinFallback.vertexEntry ?? skinFallback.receipt?.sceneIndexEntry ?? '',
+            skinFallback.fragmentEntry ?? '',
+          ],
+  });
+}
+
 /** The GPU-driven bridge to the existing four-group Standard PBR pipeline. */
-class StandardPbrRasterAdapter {
+class MaterialAbiRasterAdapter {
   private readonly pipelines = new Map<string, RenderPipeline>();
   private readonly projectionBuffers = new Set<Buffer>();
   private readonly projectionBindings = new Map<
@@ -966,13 +1173,14 @@ class StandardPbrRasterAdapter {
     private readonly pipelineLayout: import('@forgeax/engine-rhi').PipelineLayout,
     private readonly meshLayout: BindGroupLayout,
     private readonly instancesBindGroupLayout: BindGroupLayout,
-    private readonly programs: ReadonlyMap<string, GpuDrivenPbrProgram>,
+    private readonly programs: ReadonlyMap<string, GpuDrivenPbrProgram> | undefined,
     private instancesBindGroup: BindGroup,
     private readonly instanceBuffer: Buffer,
     private readonly instanceBufferSize: number,
     private visibleBuffer: Buffer,
     private readonly artifact: MaterialShaderArtifact,
     private readonly deformation: 'rigid' | 'skin',
+    private readonly pipelineFactory: MaterialPipelineFactory | undefined,
     private paletteBuffer: Buffer | undefined,
     private paletteBindingWindowBytes: number | undefined,
   ) {}
@@ -985,8 +1193,51 @@ class StandardPbrRasterAdapter {
     readonly deformation?: 'rigid' | 'skin';
     readonly paletteBuffer?: Buffer;
     readonly paletteBindingWindowBytes?: number;
-  }): Result<StandardPbrRasterAdapter, RhiError> {
+    /** Renderer-owned factory for the selected artifact's actual PSO. */
+    readonly pipelineFactory?: MaterialPipelineFactory;
+  }): Result<MaterialAbiRasterAdapter, RhiError | GpuDrivenPreparationError> {
     const deformation = input.deformation ?? 'rigid';
+    const receipt = input.artifact.receipt;
+    if (receipt === undefined) {
+      return err(
+        new RhiError({
+          code: 'rhi-not-available',
+          expected: 'published MaterialProgramAbi receipt for the selected material artifact',
+          hint: 'recook and publish the material before creating a GPU-driven raster owner',
+        }),
+      );
+    }
+    const materialRowMatchesSceneTable =
+      receipt.materialRow.byteLength === GPU_SCENE_LAYOUTS.material.stride &&
+      new Set(receipt.materialRow.fields).size === receipt.materialRow.fields.length;
+    if (!materialRowMatchesSceneTable) {
+      return err(
+        new GpuDrivenPreparationError('material-abi-not-executable', {
+          reason: 'material-abi-not-executable',
+          owner: 'material',
+          expected: `scene-index material row ${GPU_SCENE_LAYOUTS.material.stride} bytes with unique producer fields`,
+          actual: `row ${receipt.materialRow.byteLength} bytes with fields ${receipt.materialRow.fields.join(',')}`,
+        }),
+      );
+    }
+    if (
+      receipt.reflection.layoutIdentity !== input.artifact.layoutIdentity ||
+      receipt.directEntry.length === 0 ||
+      receipt.sceneIndexEntry.length === 0 ||
+      receipt.resourceSlots.some((slot) => slot.group !== 1)
+    ) {
+      return err(
+        new RhiError({
+          code: 'rhi-descriptor-invalid',
+          expected: `complete selected MaterialProgramAbi reflection, scene row stride ${GPU_SCENE_LAYOUTS.material.stride}, and resource slots`,
+          hint: 'repair the producer publication or use the owner for its non-scene material layout',
+        }),
+      );
+    }
+    // Scene-index shaders declare the dedicated slot-3 ABI. Keep the legacy
+    // fields as a compatibility fallback for synthetic fixtures; the real
+    // factory publishes the dedicated handles whenever the capable storage
+    // lane is enabled, so production draws never bind the direct-draw BGL.
     const pipelineLayout =
       deformation === 'skin'
         ? input.pipelineState.gpuDrivenPbrSkinPipelineLayout
@@ -996,25 +1247,26 @@ class StandardPbrRasterAdapter {
       return err(
         new RhiError({
           code: 'rhi-not-available',
-          expected: `${deformation === 'skin' ? 'skinned ' : ''}Standard PBR pipeline layout`,
-          hint: 'initialize the producer Standard PBR pipeline before enabling GPU-driven raster',
+          expected: `${deformation === 'skin' ? 'skinned ' : ''}published material pipeline layout`,
+          hint: 'initialize the producer material pipeline before enabling GPU-driven raster',
         }),
       );
     }
     const programs = input.pipelineState.gpuDrivenPbrPrograms;
     if (
-      programs === undefined ||
-      resolveStandardPbrProgram(
-        programs,
-        input.artifact.material,
-        input.artifact.receipt?.vertexInputs.some((attribute) => attribute.semantic === 'color'),
-      ) === undefined
+      input.pipelineFactory === undefined &&
+      (programs === undefined ||
+        resolveStandardPbrProgram(
+          programs,
+          input.artifact.material,
+          input.artifact.receipt?.vertexInputs.some((attribute) => attribute.semantic === 'color'),
+        ) === undefined)
     ) {
       return err(
         new RhiError({
           code: 'rhi-not-available',
-          expected: `producer-owned ${deformation === 'skin' ? 'skinned ' : ''}Standard PBR shader module for the current device generation`,
-          hint: 'publish the validated Standard PBR module from buildReadyWebGPU before enabling GPU-driven raster',
+          expected: `producer-owned ${deformation === 'skin' ? 'skinned ' : ''}material shader module for the current device generation`,
+          hint: 'publish the selected material module from buildReadyWebGPU before enabling GPU-driven raster',
         }),
       );
     }
@@ -1026,7 +1278,7 @@ class StandardPbrRasterAdapter {
       return err(
         new RhiError({
           code: 'rhi-not-available',
-          expected: `${deformation === 'skin' ? 'skinned ' : ''}Standard PBR mesh bind-group layout`,
+          expected: `${deformation === 'skin' ? 'skinned ' : ''}material mesh bind-group layout`,
           hint: 'publish the exact mesh-array layout selected by the material receipt',
         }),
       );
@@ -1077,7 +1329,7 @@ class StandardPbrRasterAdapter {
     });
     if (!instancesBindGroup.ok) return instancesBindGroup;
     return ok(
-      new StandardPbrRasterAdapter(
+      new MaterialAbiRasterAdapter(
         input.device,
         pipelineLayout,
         meshLayout,
@@ -1089,6 +1341,7 @@ class StandardPbrRasterAdapter {
         input.visibleBuffer,
         input.artifact,
         deformation,
+        input.pipelineFactory,
         input.paletteBuffer,
         input.paletteBindingWindowBytes,
       ),
@@ -1190,6 +1443,8 @@ class StandardPbrRasterAdapter {
     topology: GpuDrivenBatch['key']['topology'],
     stripIndexFormat: 'uint16' | 'uint32' | undefined,
     renderState: MaterialRenderState | undefined,
+    selectedArtifact: MaterialShaderArtifact = this.artifact,
+    additionalColorFormats: readonly TextureFormat[] = [],
   ): Result<RenderPipeline, RhiError> {
     const vertexLayout = deriveVertexBufferLayoutFromProjection(layoutProjection, {
       shaderUvSetCount,
@@ -1203,12 +1458,25 @@ class StandardPbrRasterAdapter {
         }),
       );
     }
-    const program = resolveStandardPbrProgram(
-      this.programs,
-      this.artifact.material,
-      layoutProjection.attributes.some((attribute) => attribute.key === 'color'),
-    );
-    if (program === undefined) {
+    const receipt = selectedArtifact.receipt;
+    if (receipt === undefined) {
+      return err(
+        new RhiError({
+          code: 'rhi-not-available',
+          expected: 'selected MaterialProgramAbi receipt for GPU-driven raster',
+          hint: 'keep the draw on the producer recovery path until its ABI is published',
+        }),
+      );
+    }
+    const program =
+      this.programs === undefined
+        ? undefined
+        : resolveStandardPbrProgram(
+            this.programs,
+            this.artifact.material,
+            layoutProjection.attributes.some((attribute) => attribute.key === 'color'),
+          );
+    if (this.pipelineFactory === undefined && program === undefined) {
       return err(
         new RhiError({
           code: 'rhi-not-available',
@@ -1217,15 +1485,78 @@ class StandardPbrRasterAdapter {
         }),
       );
     }
-    const key = `${format}|${sampleCount}|${vertexLayout.arrayStride}|${topology}|${stripIndexFormat ?? ''}|${JSON.stringify(renderState ?? null)}|${program.artifact.layoutIdentity}|${layoutProjection.digest}|uv${shaderUvSetCount}`;
+    const key = `${format}:${additionalColorFormats.join(',')}|${sampleCount}|${vertexLayout.arrayStride}|${topology}|${stripIndexFormat ?? ''}|${JSON.stringify(renderState ?? null)}|${selectedArtifact.material}|${selectedArtifact.layoutIdentity}|${receipt.receiptIdentity}|${receipt.generation}|${selectedArtifact.variantSet ?? ''}|${materialArtifactProgramIdentity(selectedArtifact)}|${selectedArtifact.vertexEntry ?? receipt.sceneIndexEntry}|${selectedArtifact.fragmentEntry ?? ''}|${layoutProjection.digest}|uv${shaderUvSetCount}`;
     const cached = this.pipelines.get(key);
     if (cached !== undefined) return ok(cached);
+    if (this.pipelineFactory !== undefined) {
+      const pipelineEntry = this.pipelineFactory(
+        selectedArtifact.specializationKey ?? selectedArtifact.material,
+        false,
+        renderState,
+        topology,
+        stripIndexFormat,
+        selectedArtifact.variantSet,
+        'forward',
+        undefined,
+        sampleCount,
+        format,
+        selectedArtifact.uvSetCount ?? shaderUvSetCount,
+        'depth24plus-stencil8',
+        undefined,
+        layoutProjection,
+        // GPU-driven receipts are already producer-validated. Use the
+        // synchronous shader-module adapter for this submission seam so a
+        // newly loaded authored material cannot lose its first draw to the
+        // ordinary async pre-bake warm-up window.
+        'immediate',
+        this.deformation === 'skin' ? 'gpu-driven-skin' : 'gpu-driven-pbr',
+        receipt.sceneIndexEntry,
+        additionalColorFormats,
+        selectedArtifact.vertexEntry,
+        selectedArtifact.fragmentEntry,
+      );
+      if (pipelineEntry === null) {
+        return err(
+          new RhiError({
+            code: 'rhi-not-available',
+            expected: `producer-owned scene-index pipeline for material '${selectedArtifact.material}'`,
+            hint: 'publish a matching program, entry, layout and resource contract before GPU admission',
+          }),
+        );
+      }
+      const expectedGroup2Contract = resolvePipelineGroup2Contract(selectedArtifact.wgsl);
+      if (pipelineEntry.group2Contract !== expectedGroup2Contract) {
+        return err(
+          new RhiError({
+            code: 'rhi-descriptor-invalid',
+            expected: `GPU-driven ${this.deformation === 'skin' ? 'skinned ' : ''}material pipeline group(2) ${expectedGroup2Contract} contract`,
+            hint: 'custom attachment or incompatible group(2) layouts remain on their specialized lane',
+          }),
+        );
+      }
+      this.pipelines.set(key, pipelineEntry.pipeline);
+      return ok(pipelineEntry.pipeline);
+    }
+    if (
+      program === undefined ||
+      selectedArtifact.material !== this.artifact.material ||
+      selectedArtifact.layoutIdentity !== this.artifact.layoutIdentity ||
+      selectedArtifact.receipt?.receiptIdentity !== this.artifact.receipt?.receiptIdentity
+    ) {
+      return err(
+        new RhiError({
+          code: 'rhi-not-available',
+          expected: 'selected material pipeline factory for the requested ABI artifact',
+          hint: 'do not pair a receipt-backed custom or color variant with the legacy fixed module',
+        }),
+      );
+    }
     const pipeline = this.device.createRenderPipeline({
       label: `standard-pbr-gpu-driven.${key}`,
       layout: this.pipelineLayout,
       vertex: {
         module: program.module,
-        entryPoint: program.artifact.receipt?.sceneIndexEntry ?? 'vs_scene_index',
+        entryPoint: selectedArtifact.vertexEntry ?? receipt.sceneIndexEntry,
         buffers: [
           {
             arrayStride: vertexLayout.arrayStride,
@@ -1241,7 +1572,7 @@ class StandardPbrRasterAdapter {
       fragment: {
         module: program.module,
         entryPoint: 'fs_main',
-        targets: [{ format }],
+        targets: [format, ...additionalColorFormats].map((format) => ({ format })),
       },
       primitive: {
         topology,
@@ -1261,6 +1592,15 @@ class StandardPbrRasterAdapter {
     return pipeline;
   }
 
+  /**
+   * Drop only program-derived caches when a publication switches. Resource
+   * buffers stay alive until their normal fence retirement, while the next
+   * draw must obtain a PSO for the new artifact rather than reuse the old one.
+   */
+  invalidatePipelineCache(): void {
+    this.pipelines.clear();
+  }
+
   projectionBindGroup(
     rows: Float32Array,
     key?: string,
@@ -1307,6 +1647,23 @@ class StandardPbrRasterAdapter {
     return this.writeProjectionRows(key, retained, rows);
   }
 
+  sceneMeshBinding(key: string): GpuDrivenSceneMeshBinding {
+    const binding = this.stagedProjectionBindings.get(key) ?? this.projectionBindings.get(key);
+    if (binding === undefined)
+      throw new RhiError({
+        code: 'rhi-not-available',
+        expected: 'retained scene mesh projection',
+        hint: 'prepare this batch projection before binding its lighting resources',
+      });
+    return {
+      meshBuffer: binding.buffer,
+      meshBytes: binding.capacityBytes,
+      ...(this.deformation === 'skin' && this.paletteBuffer !== undefined
+        ? { paletteBuffer: this.paletteBuffer }
+        : {}),
+    };
+  }
+
   /** Stage the projection keys required by the frame being prepared. */
   stageProjectionKeys(keys: ReadonlySet<string>): void {
     this.stagedProjectionKeys = new Set(keys);
@@ -1541,6 +1898,7 @@ export interface PreparedGpuDrivenFrame {
     graph: RenderGraphBuilder<RenderPipelineFrame>,
     format: TextureFormat,
     sampleCount: 1 | 4,
+    additionalColorFormats?: readonly TextureFormat[],
   ): Result<RenderPipelineGpuDrivenProjection, RenderGraphError | RhiError>;
 }
 
@@ -1665,8 +2023,8 @@ export function classifyRecoveryCapability(
 export class GpuDrivenProduction {
   private disposed = false;
   private view: GpuDrivenView | undefined;
-  private standardRaster: StandardPbrRasterAdapter | undefined;
-  private skinRaster: StandardPbrRasterAdapter | undefined;
+  private materialRaster: MaterialAbiRasterAdapter | undefined;
+  private skinRaster: MaterialAbiRasterAdapter | undefined;
   private readonly sceneIdentities = new WeakMap<object, number>();
   private nextSceneIdentity = 1;
   private filteredCache:
@@ -1680,6 +2038,7 @@ export class GpuDrivenProduction {
         readonly activeEntityRevision?: number;
         readonly activeEntityKeys?: ReadonlySet<number>;
         readonly skinArtifact?: MaterialShaderArtifact;
+        readonly materialArtifactSignature: string;
         readonly value: FilteredProductionPlan;
       }
     | undefined;
@@ -1693,6 +2052,7 @@ export class GpuDrivenProduction {
         readonly meshResidencyEpoch: number;
         readonly membership: string;
         readonly skinArtifact?: MaterialShaderArtifact;
+        readonly materialArtifactSignature: string;
         readonly value: FilteredProductionPlan;
       }
     | undefined;
@@ -1743,8 +2103,7 @@ export class GpuDrivenProduction {
         readonly filtered: FilteredProductionPlan;
         readonly scene: PersistentGpuDrivenState['scene'];
         readonly contentRevision: number;
-        readonly artifact: MaterialShaderArtifact;
-        readonly skinArtifact: MaterialShaderArtifact | undefined;
+        readonly materialArtifactSignature: string;
       }
     | undefined;
   private validatedResidencyCache: GpuDrivenResidencyValidationCache | undefined;
@@ -1860,12 +2219,23 @@ export class GpuDrivenProduction {
     readonly meshBySlot: ReadonlyMap<number, MeshGpuHandles>;
     readonly viewBindGroupLayout: BindGroupLayout;
     readonly meshResidencyEpoch: number;
-    readonly hdrp: boolean;
+    readonly materialBindingClasses?: ReadonlyMap<string, string>;
     /** Cooked producer artifact selected from the frame material catalog. */
+    readonly materialArtifact?: MaterialShaderArtifact;
+    /** Compatibility input for callers that have not migrated their name. */
     readonly standardPbrArtifact?: MaterialShaderArtifact;
     /** Cooked producer artifact for the GPU skinning variant. */
+    readonly materialSkinArtifact?: MaterialShaderArtifact;
+    /** Compatibility input for callers that have not migrated their name. */
     readonly standardPbrSkinArtifact?: MaterialShaderArtifact;
+    /** Per-draw producer artifacts keyed by prepared identity and receipt. */
+    readonly materialArtifacts?: ReadonlyMap<string, MaterialShaderArtifact>;
+    /** Per-draw shadow-pass artifacts keyed by the same prepared identity. */
+    readonly shadowMaterialArtifacts?: ReadonlyMap<string, MaterialShaderArtifact>;
+    readonly materialPipelineState?: PipelineState;
     readonly standardPbrPipelineState?: PipelineState;
+    /** Existing renderer owner that builds the selected artifact PSO/BGL. */
+    readonly materialPipelineFactory?: MaterialPipelineFactory;
     /** Extracted ShadowCaster ownership keyed by concrete draw item and pass. */
     readonly shadowCasterDrawKeys?: ReadonlySet<string>;
     /** Structured ShadowCaster ownership facts for exact pass admission. */
@@ -1905,7 +2275,7 @@ export class GpuDrivenProduction {
       paletteUploadBytes: 0,
     };
     this.lane = 'cpu-semantic';
-    this.laneReason = input.hdrp ? 'unsupported' : 'capability';
+    this.laneReason = 'capability';
     this.submissionState = 'idle';
     this.shadowExpectedDrawKeys = new Set();
     const capability = classifyRecoveryCapability({
@@ -1918,7 +2288,6 @@ export class GpuDrivenProduction {
     });
     if (
       input.scene === undefined ||
-      input.hdrp ||
       selectGpuLodLane(this.device.caps) === 'cpu' ||
       capability.status === 'disabled'
     ) {
@@ -1953,10 +2322,18 @@ export class GpuDrivenProduction {
       this.preparationFailure = preparationFailureInspection(preparationFailure.error);
       return err(preparationFailure.error);
     }
-    const standardArtifact = input.standardPbrArtifact;
-    const skinArtifact = input.standardPbrSkinArtifact;
-    const standardPipelineState = input.standardPbrPipelineState;
-    if (standardArtifact === undefined || standardPipelineState === undefined) {
+    const materialArtifact = input.materialArtifact ?? input.standardPbrArtifact;
+    const skinArtifact = input.materialSkinArtifact ?? input.standardPbrSkinArtifact;
+    const materialPipelineState = input.materialPipelineState ?? input.standardPbrPipelineState;
+    const artifactSignature = `${materialArtifactSignature(
+      input.materialArtifacts,
+      materialArtifact,
+      skinArtifact,
+    )}|shadow=${materialArtifactSignature(input.shadowMaterialArtifacts, undefined, undefined)}|bindings=${JSON.stringify([...(input.materialBindingClasses ?? [])])}`;
+    if (
+      (materialArtifact === undefined && input.materialArtifacts === undefined) ||
+      materialPipelineState === undefined
+    ) {
       this.gpuOwnedEntityCount = 0;
       this.laneReason = 'resource-not-ready';
       if (sceneRequiresGpuDrivenArtifact(input.scene)) {
@@ -1967,22 +2344,39 @@ export class GpuDrivenProduction {
         this.mainTotalDrawItems = Math.max(this.mainTotalDrawItems, this.blockedDrawItems);
         this.lane = 'blocked';
         const failure =
-          standardArtifact === undefined
+          materialArtifact === undefined && input.materialArtifacts === undefined
             ? new GpuDrivenPreparationError('missing-material-receipt', {
                 reason: 'material-receipt-missing',
                 owner: 'material',
-                expected: 'producer-owned Standard PBR GPU-driven artifact',
+                expected: 'producer-owned MaterialProgramAbi GPU-driven artifact',
               })
             : new GpuDrivenPreparationError('resource-not-ready', {
                 reason: 'material-resource-missing',
                 owner: 'material',
-                expected: 'producer-owned Standard PBR GPU-driven pipeline state',
+                expected: 'producer-owned GPU-driven material pipeline state',
               });
         this.preparationFailure = preparationFailureInspection(failure);
         return err(failure);
       }
       return ok(undefined);
     }
+    const missingArtifact = missingMaterialArtifact(
+      scene,
+      input.materialArtifacts,
+      materialArtifact,
+      skinArtifact,
+    );
+    if (missingArtifact !== undefined) {
+      this.gpuOwnedEntityCount = 0;
+      this.lane = 'blocked';
+      this.laneReason = 'resource-not-ready';
+      this.blockedDrawItems = scene.plan.batches.reduce(
+        (total, batch) => total + batch.candidates.length,
+        0,
+      );
+      this.preparationFailure = preparationFailureInspection(missingArtifact);
+      return err(missingArtifact);
+    }
     const projectionFingerprint =
       this.filteredCache?.source === scene.plan &&
       this.filteredCache.lodProjectionFingerprint === ''
@@ -2005,7 +2399,8 @@ export class GpuDrivenProduction {
       this.filteredCache.meshResidencyEpoch !== input.meshResidencyEpoch ||
       this.filteredCache.lodProjectionFingerprint !== projectionFingerprint ||
       !cachedVisibilityMatches ||
-      this.filteredCache.skinArtifact !== skinArtifact
+      this.filteredCache.skinArtifact !== skinArtifact ||
+      this.filteredCache.materialArtifactSignature !== artifactSignature
     ) {
       filtered = filteredPlan(
         scene.plan,
@@ -2017,6 +2412,9 @@ export class GpuDrivenProduction {
         input.camera,
         input.activeEntityKeys,
         scene.worldKeys,
+        materialArtifact,
+        input.materialArtifacts,
+        input.materialBindingClasses,
       );
       this.filteredCache = {
         source: scene.plan,
@@ -2032,6 +2430,7 @@ export class GpuDrivenProduction {
           ? {}
           : { activeEntityKeys: input.activeEntityKeys }),
         ...(skinArtifact === undefined ? {} : { skinArtifact }),
+        materialArtifactSignature: artifactSignature,
         value: filtered,
       };
       this.gpuOwnedSnapshotsMaterialized = scene.slots.length;
@@ -2060,7 +2459,8 @@ export class GpuDrivenProduction {
       this.shadowFilteredCache.lodProjectionFingerprint !== projectionFingerprint ||
       this.shadowFilteredCache.meshResidencyEpoch !== input.meshResidencyEpoch ||
       this.shadowFilteredCache.membership !== shadowMembership ||
-      this.shadowFilteredCache.skinArtifact !== skinArtifact
+      this.shadowFilteredCache.skinArtifact !== skinArtifact ||
+      this.shadowFilteredCache.materialArtifactSignature !== artifactSignature
     ) {
       const projectedShadowFiltered = filteredPlan(
         scene.plan,
@@ -2072,6 +2472,8 @@ export class GpuDrivenProduction {
         input.camera,
         undefined,
         scene.worldKeys,
+        materialArtifact,
+        input.materialArtifacts,
       );
       shadowFiltered = projectedShadowFiltered;
       this.shadowFilteredCache = {
@@ -2083,6 +2485,7 @@ export class GpuDrivenProduction {
         meshResidencyEpoch: input.meshResidencyEpoch,
         membership: shadowMembership,
         ...(skinArtifact === undefined ? {} : { skinArtifact }),
+        materialArtifactSignature: artifactSignature,
         value: shadowFiltered,
       };
     }
@@ -2117,32 +2520,30 @@ export class GpuDrivenProduction {
       filtered,
       scene: scene.scene,
       contentRevision: scene.scene.contentRevision,
-      artifact: standardArtifact,
-      skinArtifact,
+      materialArtifactSignature: artifactSignature,
     };
     const previousSource = this.committedProjectionSource;
     const reuseProjectionRows =
       previousSource?.filtered === filtered &&
       previousSource.scene === scene.scene &&
       previousSource.contentRevision === scene.scene.contentRevision &&
-      previousSource.artifact === standardArtifact &&
-      previousSource.skinArtifact === skinArtifact;
+      previousSource.materialArtifactSignature === artifactSignature;
     if (!reuseProjectionRows) {
       const slotsByPrimitive = new Map(scene.slots.map((slot) => [slot.slot, slot] as const));
+      const representative = filtered.batches[0];
+      if (representative === undefined) return ok(undefined);
       const projection = projectStandardPbrScene({
-        artifact: standardArtifact,
-        candidates: filtered.batches.flatMap(({ batch }) =>
-          batch.candidates.flatMap((candidate) => {
-            const slot = slotsByPrimitive.get(candidate.primitiveIndex);
-            return slot === undefined ? [] : [sceneCandidate(slot, candidate)];
-          }),
-        ),
+        artifact: representative.artifact,
+        candidates: representative.batch.candidates.flatMap((candidate) => {
+          const slot = slotsByPrimitive.get(candidate.primitiveIndex);
+          return slot === undefined ? [] : [sceneCandidate(slot, candidate)];
+        }),
       });
       if (!projection.ok) {
         return err(
           new RhiError({
             code: 'shader-compile-failed',
-            expected: 'receipt-derived Standard PBR scene projection',
+            expected: 'receipt-derived material scene projection',
             hint: 'publish one validated MaterialShaderArtifact receipt before entering the GPU lane',
           }),
         );
@@ -2171,26 +2572,55 @@ export class GpuDrivenProduction {
         }),
       );
     }
-    if (this.standardRaster === undefined) {
-      const created = StandardPbrRasterAdapter.create({
+    const representativeArtifact = materialArtifact ?? filtered.batches[0]?.artifact;
+    if (representativeArtifact === undefined) {
+      return err(
+        new RhiError({
+          code: 'rhi-not-available',
+          expected: 'one selected MaterialProgramAbi artifact for GPU-driven batches',
+          hint: 'keep receipt-backed draws blocked until Catalog/load publishes their artifact',
+        }),
+      );
+    }
+    const committedArtifactChanged =
+      this.committedProjectionSource !== undefined &&
+      this.committedProjectionSource.materialArtifactSignature !== artifactSignature;
+    if (committedArtifactChanged) {
+      // ShadowViewStatePool's cache token is light/view scoped and cannot see
+      // a material publication replacement. Drop the retained projections at
+      // the same boundary as the main PSO cache so a cache hit cannot replay
+      // the previous shadow program or BGL with the new receipt.
+      this.shadowBatchProjections.clear();
+      this.shadowBatchProjectionSource = undefined;
+      this.shadowViews?.invalidate();
+    }
+    if (this.committedProjectionSource?.materialArtifactSignature !== artifactSignature) {
+      this.materialRaster?.invalidatePipelineCache();
+      this.skinRaster?.invalidatePipelineCache();
+    }
+    if (this.materialRaster === undefined) {
+      const created = MaterialAbiRasterAdapter.create({
         device: this.device,
-        pipelineState: standardPipelineState,
-        artifact: standardArtifact,
+        pipelineState: materialPipelineState,
+        artifact: representativeArtifact,
         visibleBuffer,
+        ...(input.materialPipelineFactory === undefined
+          ? {}
+          : { pipelineFactory: input.materialPipelineFactory }),
       });
       if (!created.ok) return created;
-      this.standardRaster = created.value;
+      this.materialRaster = created.value;
     } else {
-      const rebound = this.standardRaster.ensureVisibleBuffer(visibleBuffer);
+      const rebound = this.materialRaster.ensureVisibleBuffer(visibleBuffer);
       if (!rebound.ok) return rebound;
     }
-    const standardRaster = this.standardRaster;
-    if (standardRaster === undefined) {
+    const materialRaster = this.materialRaster;
+    if (materialRaster === undefined) {
       return err(
         new RhiError({
           code: 'internal-error',
-          expected: 'Standard PBR raster adapter after prepared artifact admission',
-          hint: 'keep Standard PBR artifact and PipelineState on one frame identity',
+          expected: 'material ABI raster adapter after prepared artifact admission',
+          hint: 'keep the selected material artifact and PipelineState on one frame identity',
         }),
       );
     }
@@ -2201,9 +2631,10 @@ export class GpuDrivenProduction {
       const skinSnapshot = scene.slots.find(
         (slot) => slot.slot === skinBatch.batch.candidates[0]?.primitiveIndex,
       )?.snapshot.skin;
-      const skinAllocator = standardPipelineState.skinPaletteAllocator;
+      const skinAllocator = materialPipelineState.skinPaletteAllocator;
+      const selectedSkinArtifact = skinArtifact ?? skinBatch.artifact;
       if (
-        skinArtifact === undefined ||
+        selectedSkinArtifact === undefined ||
         skinSnapshot === undefined ||
         skinAllocator === null ||
         skinAllocator === undefined
@@ -2211,20 +2642,23 @@ export class GpuDrivenProduction {
         return err(
           new RhiError({
             code: 'rhi-not-available',
-            expected: 'skinned Standard PBR artifact and persistent palette owner',
+            expected: 'skinned material artifact and persistent palette owner',
             hint: 'keep missing skin producer resources on the CPU deformation path',
           }),
         );
       }
       if (this.skinRaster === undefined) {
-        const created = StandardPbrRasterAdapter.create({
+        const created = MaterialAbiRasterAdapter.create({
           device: this.device,
-          pipelineState: standardPipelineState,
-          artifact: skinArtifact,
+          pipelineState: materialPipelineState,
+          artifact: selectedSkinArtifact,
           visibleBuffer,
           deformation: 'skin',
           paletteBuffer: skinSnapshot.buffer,
           paletteBindingWindowBytes: skinAllocator.bindingWindowBytes,
+          ...(input.materialPipelineFactory === undefined
+            ? {}
+            : { pipelineFactory: input.materialPipelineFactory }),
         });
         if (!created.ok) return created;
         this.skinRaster = created.value;
@@ -2257,11 +2691,11 @@ export class GpuDrivenProduction {
     }
     // A pose can change while conservative bounds, allocation and scene rows
     // remain unchanged. Read the palette owner, never optional telemetry.
-    const paletteContentRevision = standardPipelineState.skinPaletteAllocator?.contentRevision;
+    const paletteContentRevision = materialPipelineState.skinPaletteAllocator?.contentRevision;
     if (paletteContentRevision !== this.committedPaletteContentRevision)
       shadowViewPool.invalidate();
     const abortProvisionalResources = (): void => {
-      standardRaster.abortProjectionBindings();
+      materialRaster.abortProjectionBindings();
       skinRaster?.abortProjectionBindings();
       shadowViewPool._abortResourceReplacement();
     };
@@ -2275,13 +2709,13 @@ export class GpuDrivenProduction {
     };
     // Start the provisional resource set before any retained row is updated;
     // an aborted graph can then restore the active rows from its snapshot.
-    standardRaster.stageProjectionKeys(new Set());
+    materialRaster.stageProjectionKeys(new Set());
     skinRaster?.stageProjectionKeys(new Set());
     for (const prepared of filtered.batches) {
       if (reuseProjectionRows) {
         const deformation = prepared.batch.candidates[0]?.prepared?.identity.deformation ?? 'rigid';
-        const raster = deformation === 'skin' ? skinRaster : standardRaster;
-        const artifact = deformation === 'skin' ? skinArtifact : standardArtifact;
+        const raster = deformation === 'skin' ? skinRaster : materialRaster;
+        const artifact = prepared.artifact;
         if (raster !== undefined && artifact !== undefined)
           raster.noteProjectionKey(gpuDrivenProjectionKey(prepared.batch, deformation, artifact));
         continue;
@@ -2293,9 +2727,9 @@ export class GpuDrivenProduction {
       );
       if (admittedCandidates.length === 0) continue;
       const deformation = admittedCandidates[0]?.prepared?.identity.deformation ?? 'rigid';
-      const raster = deformation === 'skin' ? skinRaster : standardRaster;
-      const artifact = deformation === 'skin' ? skinArtifact : standardArtifact;
-      if (raster === undefined || artifact === undefined) continue;
+      const raster = deformation === 'skin' ? skinRaster : materialRaster;
+      const artifact = prepared.artifact;
+      if (raster === undefined) continue;
       const projectionKey = gpuDrivenProjectionKey(prepared.batch, deformation, artifact);
       raster.noteProjectionKey(projectionKey);
       const candidates = admittedCandidates.flatMap((candidate) => {
@@ -2308,7 +2742,7 @@ export class GpuDrivenProduction {
         return err(
           new RhiError({
             code: 'shader-compile-failed',
-            expected: 'receipt-derived Standard PBR scene projection',
+            expected: 'receipt-derived material scene projection',
             hint: 'keep the retained projection rows on the current material receipt',
           }),
         );
@@ -2342,9 +2776,10 @@ export class GpuDrivenProduction {
         sceneIdentity,
         revision: filtered.plan.revision,
         meshResidencyEpoch: input.meshResidencyEpoch,
+        materialArtifactSignature: artifactSignature,
         standardPbrLayoutIdentity: this.standardPbrProjection?.layoutIdentity,
         viewResourceGeneration: viewInspection.resourceGeneration,
-        batches: filtered.batches.map(({ batch, mesh }) => [
+        batches: filtered.batches.map(({ batch, mesh, artifact }) => [
           batch.batchId,
           batch.generation,
           batch.visibleBase,
@@ -2369,6 +2804,12 @@ export class GpuDrivenProduction {
           mesh.iboBytes,
           mesh.indexFormat,
           mesh.uvSetCount,
+          artifact.material,
+          artifact.layoutIdentity,
+          artifact.receipt?.receiptIdentity,
+          artifact.receipt?.generation,
+          artifact.variantSet,
+          artifact.wgsl.length,
         ]),
         capacities: [
           viewInspection.candidateCapacity,
@@ -2409,8 +2850,8 @@ export class GpuDrivenProduction {
       standardPbrFrameResources: {
         materialBindGroups: [],
         materialSlotIndicesByEntity: new Map(),
-        instancesBindGroup: standardRaster.instancesFrameGroup,
-        materialStride: 512,
+        instancesBindGroup: materialRaster.instancesFrameGroup,
+        materialStride: MATERIAL_PER_ENTITY_STRIDE,
         sceneMaterialBuffer: scene.scene.materialBuffer,
       },
       _commitGpuResourceReplacement: () => {
@@ -2419,7 +2860,7 @@ export class GpuDrivenProduction {
       _commitResourceReplacement: () => {
         view._commitResourceReplacement();
         shadowViewPool._commitResourceReplacement();
-        standardRaster.commitProjectionBindings();
+        materialRaster.commitProjectionBindings();
         skinRaster?.commitProjectionBindings();
         this.committedProjectionSource = projectionSource;
         this.committedPaletteContentRevision = paletteContentRevision;
@@ -2428,7 +2869,7 @@ export class GpuDrivenProduction {
       },
       _abortResourceReplacement: () => {
         shadowViewPool._abortResourceReplacement();
-        standardRaster.abortProjectionBindings();
+        materialRaster.abortProjectionBindings();
         skinRaster?.abortProjectionBindings();
         this.committedProjectionSource = undefined;
         this.submissionState = 'aborted';
@@ -2443,8 +2884,10 @@ export class GpuDrivenProduction {
         shadowFiltered.plan.batches.length > 0
           ? this.updateShadowViews(
               views,
-              standardArtifact,
+              materialArtifact,
               skinArtifact,
+              input.materialArtifacts,
+              input.shadowMaterialArtifacts,
               shadowFiltered,
               scene,
               input.shadowCasterDrawKeys,
@@ -2459,21 +2902,25 @@ export class GpuDrivenProduction {
           ),
         );
       },
-      project: (graph, format, sampleCount) => {
+      project: (graph, format, sampleCount, additionalColorFormats) => {
         this.indirectDrawCount = admittedRasterBatchCount(filtered.plan);
         const outputs = view.addPasses(graph);
         if (!outputs.ok) return outputs;
-        if (standardRaster !== undefined && standardArtifact !== undefined) {
+        if (materialRaster !== undefined && filtered.batches.length > 0) {
           const standardProjected: Array<{
             readonly batch: GpuDrivenBatch;
             readonly mesh: MeshGpuHandles;
             readonly materialEntityKey: number;
             readonly vertex: GraphBuffer;
             readonly index?: GraphBuffer;
-            readonly pipeline: RenderPipeline;
+            readonly pipelineFor: (
+              formats: readonly TextureFormat[],
+            ) => Result<RenderPipeline, RhiError>;
             readonly meshBindGroup: BindGroup;
-            readonly raster: StandardPbrRasterAdapter;
+            readonly raster: MaterialAbiRasterAdapter;
             readonly deformation: 'rigid' | 'skin';
+            readonly clustered: boolean;
+            readonly projectionKey: string;
           }> = [];
           const standardAccesses: GraphAccess[] = [
             { resource: outputs.value.primitive, usage: 'storage-read' },
@@ -2496,14 +2943,14 @@ export class GpuDrivenProduction {
             );
             if (admittedCandidates.length === 0) continue;
             const deformation = admittedCandidates[0]?.prepared?.identity.deformation ?? 'rigid';
-            const raster = deformation === 'skin' ? skinRaster : standardRaster;
-            const artifact = deformation === 'skin' ? skinArtifact : standardArtifact;
-            if (raster === undefined || artifact === undefined) {
+            const raster = deformation === 'skin' ? skinRaster : materialRaster;
+            const artifact = prepared.artifact;
+            if (raster === undefined) {
               return err(
                 new RhiError({
                   code: 'rhi-not-available',
-                  expected: `${deformation === 'skin' ? 'skinned ' : ''}Standard PBR GPU-driven raster owner`,
-                  hint: 'keep an unsupported deformation on the CPU fallback lane',
+                  expected: `${deformation === 'skin' ? 'skinned ' : ''}published material ABI raster owner`,
+                  hint: 'publish the selected material artifact before entering the GPU lane',
                 }),
               );
             }
@@ -2524,7 +2971,7 @@ export class GpuDrivenProduction {
               return err(
                 new RhiError({
                   code: 'shader-compile-failed',
-                  expected: 'receipt-derived Standard PBR scene projection',
+                  expected: 'receipt-derived material scene projection',
                   hint: 'keep the frame artifact receipt and projected rows on one identity',
                 }),
               );
@@ -2577,20 +3024,31 @@ export class GpuDrivenProduction {
                 standardAccesses.push({ resource: buffers.index, usage: 'index-read' });
               }
             }
-            const pipeline = raster.pipeline(
-              format,
-              sampleCount,
-              prepared.mesh.layoutProjection,
-              standardPipelineState.standardPbrShaderUvSetCount,
-              prepared.batch.key.topology,
-              prepared.batch.key.drawKind === 'indexed' &&
-                (prepared.batch.key.topology === 'line-strip' ||
-                  prepared.batch.key.topology === 'triangle-strip')
-                ? prepared.mesh.indexFormat
-                : undefined,
-              prepared.renderState,
-            );
-            if (!pipeline.ok) return pipeline;
+            const pipelineFor = (
+              formats: readonly TextureFormat[],
+            ): Result<RenderPipeline, RhiError> => {
+              return raster.pipeline(
+                formats[0] ?? format,
+                sampleCount,
+                prepared.mesh.layoutProjection,
+                // The producer receipt owns the selected shader's UV ABI. The
+                // Standard count is only a fallback for legacy synthetic
+                // fixtures; using it for a custom program would add aliases
+                // the shader never declares (or omit a declared custom set).
+                artifact.uvSetCount ?? materialPipelineState.standardPbrShaderUvSetCount,
+                prepared.batch.key.topology,
+                prepared.batch.key.drawKind === 'indexed' &&
+                  (prepared.batch.key.topology === 'line-strip' ||
+                    prepared.batch.key.topology === 'triangle-strip')
+                  ? prepared.mesh.indexFormat
+                  : undefined,
+                prepared.renderState,
+                artifact,
+                formats.slice(1),
+              );
+            };
+            const initialPipeline = pipelineFor([format, ...(additionalColorFormats ?? [])]);
+            if (!initialPipeline.ok) return initialPipeline;
             standardProjected.push({
               batch: prepared.batch,
               mesh: prepared.mesh,
@@ -2599,10 +3057,14 @@ export class GpuDrivenProduction {
                 materialSlot.snapshot.entityKey,
               ),
               ...buffers,
-              pipeline: pipeline.value,
+              pipelineFor,
               meshBindGroup: meshBindGroup.value,
               raster,
               deformation,
+              clustered: ['cluster', 'skin-cluster'].includes(
+                resolvePipelineGroup2Contract(artifact.wgsl),
+              ),
+              projectionKey: gpuDrivenProjectionKey(prepared.batch, deformation, artifact),
             });
           }
           if (
@@ -2612,7 +3074,7 @@ export class GpuDrivenProduction {
             return err(
               new RhiError({
                 code: 'internal-error',
-                expected: 'one actual Standard PBR raster dispatch for each eligible batch',
+                expected: 'one actual material ABI raster dispatch for each eligible batch',
                 hint: 'repair the receipt-backed batch projection before encoding the frame',
               }),
             );
@@ -2636,10 +3098,6 @@ export class GpuDrivenProduction {
               let currentVertex: GraphBuffer | undefined;
               let currentIndex: GraphBuffer | undefined;
               for (const batch of rasterDispatches) {
-                if (currentPipeline !== batch.pipeline) {
-                  pass.setPipeline(batch.pipeline);
-                  currentPipeline = batch.pipeline;
-                }
                 const globalMaterialSlots = frameResources.materialSlotIndicesByEntity.get(
                   batch.materialEntityKey,
                 );
@@ -2655,6 +3113,20 @@ export class GpuDrivenProduction {
                     hint: 'populate materialSlotIndicesByEntity from the main-pass material producer',
                   });
                 }
+                if (
+                  frameResources.selectedMaterialSlots !== undefined &&
+                  !frameResources.selectedMaterialSlots.has(globalMaterialSlot)
+                )
+                  continue;
+                const selectedPipeline = batch.pipelineFor(
+                  frameResources.colorFormats ?? [format, ...(additionalColorFormats ?? [])],
+                );
+                if (!selectedPipeline.ok) throw selectedPipeline.error;
+                const pipeline = selectedPipeline.value;
+                if (currentPipeline !== pipeline) {
+                  pass.setPipeline(pipeline);
+                  currentPipeline = pipeline;
+                }
                 const materialBindGroup = frameResources.materialBindGroups[globalMaterialSlot];
                 if (materialBindGroup === undefined) {
                   throw new RhiError({
@@ -2666,11 +3138,18 @@ export class GpuDrivenProduction {
                 pass.setBindGroup(1, materialBindGroup, [
                   globalMaterialSlot * frameResources.materialStride,
                 ]);
-                pass.setBindGroup(
-                  2,
-                  batch.meshBindGroup,
-                  batch.deformation === 'skin' ? [0, 0, 0] : [0],
-                );
+                const meshBindGroup = batch.clustered
+                  ? frameResources.resolveClusteredMeshBindGroup?.(
+                      batch.raster.sceneMeshBinding(batch.projectionKey),
+                    )
+                  : batch.meshBindGroup;
+                if (meshBindGroup === undefined)
+                  throw new RhiError({
+                    code: 'rhi-not-available',
+                    expected: 'current scene-index lighting binding',
+                    hint: 'resolve clustered surface resources during the material pass',
+                  });
+                pass.setBindGroup(2, meshBindGroup, batch.deformation === 'skin' ? [0, 0, 0] : [0]);
                 const visibleWindow = batch.raster.visibleWindowBindGroup(
                   batch.batch.visibleBase,
                   batch.batch.visibleCapacity,
@@ -2704,8 +3183,8 @@ export class GpuDrivenProduction {
         return err(
           new RhiError({
             code: 'internal-error',
-            expected: 'Standard PBR raster projection branch',
-            hint: 'preserve the artifact-backed Standard PBR branch as the only raster owner',
+            expected: 'material ABI raster projection branch',
+            hint: 'preserve the selected-artifact branch as the only raster owner',
           }),
         );
       },
@@ -2714,8 +3193,10 @@ export class GpuDrivenProduction {
 
   updateShadowViews(
     views: readonly Omit<ShadowViewUpdateInput, 'sourcePlan' | 'scene'>[],
-    artifact: MaterialShaderArtifact,
+    artifact: MaterialShaderArtifact | undefined,
     skinArtifact: MaterialShaderArtifact | undefined,
+    materialArtifacts: ReadonlyMap<string, MaterialShaderArtifact> | undefined,
+    shadowMaterialArtifacts: ReadonlyMap<string, MaterialShaderArtifact> | undefined,
     filtered: FilteredProductionPlan,
     scene: PersistentGpuDrivenState,
     shadowCasterDrawKeys: ReadonlySet<string> | undefined,
@@ -2730,13 +3211,13 @@ export class GpuDrivenProduction {
     }
     const nextProjections = new Map<string, ReadonlyMap<number, GpuDrivenShadowBatchProjection>>();
     const nextShadowDrawKeysByView = new Map<string, ReadonlySet<string>>();
-    const standardRaster = this.standardRaster;
-    if (standardRaster === undefined) {
+    const materialRaster = this.materialRaster;
+    if (materialRaster === undefined) {
       return err(
         new RhiError({
           code: 'internal-error',
-          expected: 'Standard PBR raster adapter for shadow projection',
-          hint: 'prepare the artifact-backed raster owner before updating shadow views',
+          expected: 'material ABI raster adapter for shadow projection',
+          hint: 'prepare the selected-artifact raster owner before updating shadow views',
         }),
       );
     }
@@ -2760,11 +3241,23 @@ export class GpuDrivenProduction {
         nextShadowDrawKeysByView.set(identityKey, previousClaims);
         for (const batch of updated.value.plan.batches) {
           const deformation = batch.candidates[0]?.prepared?.identity.deformation ?? 'rigid';
-          const batchArtifact = deformation === 'skin' ? skinArtifact : artifact;
-          const raster = deformation === 'skin' ? this.skinRaster : standardRaster;
-          if (batchArtifact !== undefined && raster !== undefined) {
+          const batchArtifact =
+            preparedByBatch.get(batch.batchId)?.artifact ??
+            artifactForPreparedCandidate(
+              batch.candidates[0] as GpuDrivenBatch['candidates'][number],
+              materialArtifacts,
+              artifact,
+              skinArtifact,
+            );
+          const shadowArtifact = shadowArtifactForPreparedCandidate(
+            batch.candidates[0] as GpuDrivenBatch['candidates'][number],
+            shadowMaterialArtifacts,
+            batchArtifact,
+          );
+          const raster = deformation === 'skin' ? this.skinRaster : materialRaster;
+          if (shadowArtifact !== undefined && raster !== undefined) {
             raster.noteProjectionKey(
-              gpuDrivenShadowProjectionKey(identityKey, batch, deformation, batchArtifact),
+              gpuDrivenShadowProjectionKey(identityKey, batch, deformation, shadowArtifact),
             );
           }
         }
@@ -2822,14 +3315,19 @@ export class GpuDrivenProduction {
           );
         }
         const deformation = batch.candidates[0]?.prepared?.identity.deformation ?? 'rigid';
-        const raster = deformation === 'skin' ? this.skinRaster : standardRaster;
-        const batchArtifact = deformation === 'skin' ? skinArtifact : artifact;
-        if (raster === undefined || batchArtifact === undefined) {
+        const raster = deformation === 'skin' ? this.skinRaster : materialRaster;
+        const batchArtifact = prepared.artifact;
+        const shadowArtifact = shadowArtifactForPreparedCandidate(
+          batch.candidates[0] as GpuDrivenBatch['candidates'][number],
+          shadowMaterialArtifacts,
+          batchArtifact,
+        );
+        if (raster === undefined || batchArtifact === undefined || shadowArtifact === undefined) {
           return err(
             new RhiError({
               code: 'rhi-not-available',
-              expected: `${deformation === 'skin' ? 'skinned ' : ''}Standard PBR shadow projection owner`,
-              hint: 'keep a shadow batch on the CPU caster path until its material receipt is ready',
+              expected: `${deformation === 'skin' ? 'skinned ' : ''}selected shadow MaterialProgramAbi artifact`,
+              hint: 'publish a matching shadow-pass program before entering the capable shadow lane',
             }),
           );
         }
@@ -2842,13 +3340,13 @@ export class GpuDrivenProduction {
           );
           return [sceneCandidate(slot, candidate, materialIndex)];
         });
-        const projected = projectStandardPbrScene({ artifact: batchArtifact, candidates });
+        const projected = projectStandardPbrScene({ artifact: shadowArtifact, candidates });
         if (!projected.ok) {
           return err(
             new RhiError({
               code: 'shader-compile-failed',
               expected: 'receipt-derived shadow scene-index projection',
-              hint: 'publish one validated Standard PBR receipt per shadow batch',
+              hint: 'publish one validated material receipt per shadow batch',
             }),
           );
         }
@@ -2856,7 +3354,7 @@ export class GpuDrivenProduction {
           identityKey,
           batch,
           deformation,
-          batchArtifact,
+          shadowArtifact,
         );
         raster.noteProjectionKey(projectionKey);
         const meshBindGroup = raster.projectionBindGroup(
@@ -2887,16 +3385,36 @@ export class GpuDrivenProduction {
             }),
           );
         }
+        const firstWorldEntity = worldEntityKey(
+          firstSlot.snapshot.worldId,
+          firstSlot.snapshot.entityKey,
+        );
+        const shadowEntry = shadowCasterMembership?.find(
+          (membership) =>
+            membership.worldEntity === firstWorldEntity &&
+            membership.materialHandle === (material.materialHandle ?? -1) &&
+            membership.drawItemIndex === firstCandidate?.drawItemIndex,
+        );
         projections.set(batch.batchId, {
           mesh: prepared.mesh,
           meshBindGroup: meshBindGroup.value,
           visibleBindGroup: visibleBindGroup.value,
           deformation,
+          shadowArtifact,
+          ...(shadowEntry?.vertexEntry === undefined
+            ? {}
+            : { shadowVertexEntry: shadowEntry.vertexEntry }),
+          ...(shadowEntry?.fragmentEntry === undefined
+            ? {}
+            : { shadowFragmentEntry: shadowEntry.fragmentEntry }),
           material,
           materialEntityKey: worldEntityKey(
             firstSlot.snapshot.worldId,
             firstSlot.snapshot.entityKey,
           ),
+          vertexColorAvailable: prepared.mesh.layoutProjection.attributes.some(
+            (attribute) => attribute.key === 'color',
+          ),
         });
       }
       nextProjections.set(identityKey, projections);
@@ -2919,8 +3437,8 @@ export class GpuDrivenProduction {
     this.disposed = true;
     this.view?.dispose();
     this.view = undefined;
-    this.standardRaster?.dispose();
-    this.standardRaster = undefined;
+    this.materialRaster?.dispose();
+    this.materialRaster = undefined;
     this.committedProjectionSource = undefined;
     this.skinRaster?.dispose();
     this.skinRaster = undefined;
@@ -3222,8 +3740,7 @@ export class GpuDrivenProduction {
       if (draws.length === 0) {
         totalDrawItems += 1;
         this.cpuFallbackDrawItems += 1;
-        const material = row.source.material;
-        const skinReason = skinLaneReason(row.source, material);
+        const skinReason = skinLaneReason(row.source);
         if (skinReason !== undefined) {
           this.cpuDeformationFallbackDrawItems += 1;
           addDeformationReason(skinReason);
@@ -3248,7 +3765,7 @@ export class GpuDrivenProduction {
         }
         this.cpuFallbackDrawItems += 1;
         cpuResidual = true;
-        const skinReason = skinLaneReason(row.source, material);
+        const skinReason = skinLaneReason(row.source);
         if (skinReason !== undefined) {
           this.cpuDeformationFallbackDrawItems += 1;
           addDeformationReason(skinReason);