@forgeax/engine-render 0.1.27 → 0.1.29

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

@@ -14,7 +14,6 @@ import type {
   RenderPipeline,
   Result,
   RhiDevice,
-  ShaderModule,
   TextureFormat,
 } from '@forgeax/engine-rhi';
 import { err, ok, RhiError } from '@forgeax/engine-rhi';
@@ -22,24 +21,43 @@ import type { MaterialShaderArtifact } from '@forgeax/engine-shader';
 import type { MaterialRenderState } from '@forgeax/engine-types';
 import type { DeviceScope, LifecycleResourceSpec } from '../device/device-scope';
 import type { MeshGpuHandles } from '../device/gpu-residency';
-import { GPU_SCENE_WGSL } from '../gpu-scene-schema';
+import { GpuDrivenPreparationError } from '../errors/gpu-driven';
+import {
+  gpuDrivenDrawKey,
+  gpuDrivenShadowDrawKey,
+  gpuDrivenSourceDrawItemIndex,
+} from '../extract/gpu-driven';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_INDEX,
   GPU_BUFFER_USAGE_STORAGE,
-  GPU_BUFFER_USAGE_UNIFORM,
   GPU_BUFFER_USAGE_VERTEX,
 } from '../gpu-usage';
-import { assembleMaterialWithSkylightEntries } from '../ibl/skylight-bind-group';
-import type { GpuDrivenProductionInspection } from '../inspection-types';
+import type {
+  GpuDrivenLaneReason,
+  GpuDrivenLaneSummary,
+  GpuDrivenPreparationFailureInspection,
+  GpuDrivenProductionInspection,
+  GpuDrivenStructureMetrics,
+} from '../inspection-types';
 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 } from '../record/mesh-ssbo';
+import { MESH_SSBO_BYTES, packInstanceStorageBuffer } from '../record/mesh-ssbo';
 import type { PipelineState } from '../record/render-context';
 import type { CameraSnapshot } from '../render-contract';
-import type { RenderPipelineFrame, RenderPipelineGpuDrivenProjection } from '../render-pipeline';
-import type { RenderableSnapshot } from '../render-system-extract';
+import type {
+  GpuDrivenStandardPbrFrameResources,
+  RenderPipelineFrame,
+  RenderPipelineGpuDrivenProjection,
+} from '../render-pipeline';
+import type {
+  DispatchEntry,
+  MaterialSnapshot,
+  RenderableSnapshot,
+  ShadowCasterMembership,
+} from '../render-system-extract';
 import type { PersistentGpuDrivenState } from '../scene/render-scene';
 import { selectLod } from '../scene/visibility/lod-selector';
 import type { OcclusionFrameProjection } from '../scene/visibility/occlusion-runtime';
@@ -49,20 +67,23 @@ import {
   projectedHeightForCandidate,
   type SubmissionPlan,
 } from './batch-topology';
+import { type GpuDrivenPbrProgram, resolveStandardPbrProgram } from './pbr-program';
 import {
-  GPU_DRIVEN_VIEW_WGSL,
-  type GpuDrivenLodSelectionInspection,
-  GpuDrivenView,
-  selectGpuLodLane,
-} from './view-gpu';
-
-const VERTEX_STAGE = 0x1;
-const FRAGMENT_STAGE = 0x2;
-const EMPTY_RESOURCE_CLASS = JSON.stringify({ textures: [], samplers: [], video: [] });
+  type ShadowViewIdentity,
+  type ShadowViewProjection,
+  ShadowViewStatePool,
+  type ShadowViewUpdateInput,
+  shadowViewIdentityKey,
+} from './shadow-views';
+import { type GpuDrivenLodSelectionInspection, GpuDrivenView, selectGpuLodLane } from './view-gpu';
 
 export interface StandardPbrSceneCandidate {
   readonly primitiveIndex: number;
   readonly world: Float32Array;
+  /** Optional per-instance local transform selected by BatchTopology. */
+  readonly instanceTransform?: Float32Array;
+  /** Optional GPU Scene material row carried by the shadow projection. */
+  readonly materialIndex?: number;
 }
 
 export interface StandardPbrSceneProjection {
@@ -73,6 +94,17 @@ export interface StandardPbrSceneProjection {
   readonly rows: Float32Array;
 }
 
+export interface GpuDrivenShadowBatchProjection {
+  readonly mesh: MeshGpuHandles;
+  readonly meshBindGroup: BindGroup;
+  readonly visibleBindGroup: BindGroup;
+  readonly deformation: 'rigid' | 'skin';
+  /** 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;
+}
+
 /**
  * Build the producer-owned Standard PBR scene-index projection. The receipt is
  * the only source of the vertex entry and layout identity; callers cannot
@@ -97,12 +129,16 @@ export function projectStandardPbrScene(input: {
   for (let index = 0; index < input.candidates.length; index += 1) {
     const candidate = input.candidates[index];
     if (candidate === undefined) continue;
+    const world =
+      candidate.instanceTransform === undefined
+        ? candidate.world
+        : mat4.multiply(mat4.create(), candidate.world, candidate.instanceTransform);
     const base = index * 48;
     for (let value = 0; value < 16; value += 1) {
-      rows[base + value] = candidate.world[value] ?? 0;
-      rows[base + 28 + value] = candidate.world[value] ?? 0;
+      rows[base + value] = world[value] ?? 0;
+      rows[base + 28 + value] = world[value] ?? 0;
     }
-    const normalMatrix = mat3.normalMatrix(normal, candidate.world);
+    const normalMatrix = mat3.normalMatrix(normal, world);
     for (let column = 0; column < 3; column += 1) {
       const source = column * 3;
       const target = base + 16 + column * 4;
@@ -110,6 +146,11 @@ export function projectStandardPbrScene(input: {
       rows[target + 1] = normalMatrix[source + 1] ?? 0;
       rows[target + 2] = normalMatrix[source + 2] ?? 0;
     }
+    // The final temporal metadata lane is otherwise unused by the shadow
+    // vertex path. Carry the concrete scene-material row there so skinned
+    // GPU-driven alpha-mask shadows can keep the palette base in visible.y
+    // without introducing a second visible-stream ABI.
+    rows[base + 47] = candidate.materialIndex ?? 0;
   }
   return {
     ok: true,
@@ -183,50 +224,6 @@ export function adaptStandardPbrFrameResources(input: {
   };
 }
 
-export const GPU_DRIVEN_RIGID_UNLIT_WGSL = /* wgsl */ `
-${GPU_SCENE_WGSL}
-
-struct ViewData {
-  slots: array<vec4<f32>, 49>,
-};
-
-@group(0) @binding(0) var<uniform> view: ViewData;
-@group(1) @binding(0) var<storage, read> primitives: array<GpuScenePrimitive>;
-@group(1) @binding(1) var<storage, read> instances: array<GpuSceneInstance>;
-@group(1) @binding(2) var<storage, read> materials: array<GpuSceneMaterial>;
-@group(1) @binding(3) var<storage, read> visibleItems: array<vec2<u32>>;
-@group(1) @binding(4) var<storage, read> transforms: array<GpuSceneTransform>;
-
-struct VertexInput {
-  @location(0) position: vec3<f32>,
-};
-
-struct VertexOutput {
-  @builtin(position) position: vec4<f32>,
-  @location(0) color: vec4<f32>,
-};
-
-@vertex
-fn vs_main(input: VertexInput, @builtin(instance_index) instanceIndex: u32) -> VertexOutput {
-  let viewProjection = mat4x4<f32>(view.slots[0], view.slots[1], view.slots[2], view.slots[3]);
-  let visible = visibleItems[instanceIndex];
-  let sceneInstance = instances[visible.x];
-  let primitiveIndex = sceneInstance.primitiveIndex;
-  let primitive = primitives[primitiveIndex];
-  let material = materials[visible.y];
-  var output: VertexOutput;
-  let world = transforms[primitive.transformIndex].currentWorld * transforms[sceneInstance.transformIndex].currentWorld;
-  output.position = viewProjection * world * vec4<f32>(input.position, 1.0);
-  output.color = material.params0;
-  return output;
-}
-
-@fragment
-fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
-  return input.color;
-}
-`;
-
 interface PreparedBatch {
   readonly batch: GpuDrivenBatch;
   readonly mesh: MeshGpuHandles;
@@ -238,13 +235,6 @@ interface PreparedBatch {
   readonly slotGeneration: number;
 }
 
-interface ProjectedBatch extends PreparedBatch {
-  readonly bindings: BindGroup;
-  readonly pipeline: RenderPipeline;
-  readonly vertex: GraphBuffer;
-  readonly index?: GraphBuffer;
-}
-
 function bufferBinding(
   buffer: import('@forgeax/engine-rhi').Buffer,
   offset?: number,
@@ -282,46 +272,117 @@ function activeFrustum(camera: CameraSnapshot): Float32Array {
   );
 }
 
+function hasFiniteOrderedBounds(bounds: Float32Array | undefined): boolean {
+  if (bounds === undefined || bounds.length < 6) return false;
+  for (let index = 0; index < 6; index += 1) {
+    if (!Number.isFinite(bounds[index])) return false;
+  }
+  const minX = bounds[0];
+  const minY = bounds[1];
+  const minZ = bounds[2];
+  const maxX = bounds[3];
+  const maxY = bounds[4];
+  const maxZ = bounds[5];
+  return (
+    minX !== undefined &&
+    minY !== undefined &&
+    minZ !== undefined &&
+    maxX !== undefined &&
+    maxY !== undefined &&
+    maxZ !== undefined &&
+    minX <= maxX &&
+    minY <= maxY &&
+    minZ <= maxZ
+  );
+}
+
+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 (!hasFiniteOrderedBounds(snapshot.skin.bounds)) return 'skin-bounds-missing';
+  if (
+    snapshot.skin.storageOrUniform !== 'storage' ||
+    !Number.isInteger(snapshot.skin.customDataStart) ||
+    snapshot.skin.customDataStart < 0 ||
+    snapshot.skin.buffer === undefined
+  ) {
+    return 'skin-address-missing';
+  }
+  return undefined;
+}
+
 /**
- * LOD projected height is a view fact, not a scene-topology fact. Keep the
- * filtered plan cache scene-stable while still rebuilding its candidate
- * heights whenever a camera input used by the selector changes.
+ * Derived projected heights invalidate the prepared plan only when a
+ * candidate has more than its implicit root LOD row. No-LOD plans have no
+ * view-dependent selection. Root matrix edits and camera edits feed the same
+ * height calculation; retaining the empty key for absent LOD avoids rebuilding
+ * their candidate and batch uploads on every camera frame.
  */
-function lodProjectionFingerprint(camera: CameraSnapshot): string {
-  return JSON.stringify({
-    position: Array.from(camera.position),
-    world: Array.from(camera.world),
-    projection: camera.projection,
-    fov: camera.fov,
-    aspect: camera.aspect,
-    orthoHeight: camera.orthoTop - camera.orthoBottom,
-  });
+function lodProjectionFingerprint(
+  source: SubmissionPlan,
+  camera: CameraSnapshot,
+  slots: PersistentGpuDrivenState['slots'],
+): string {
+  const primitives = new Set<number>();
+  for (const batch of source.batches) {
+    for (const candidate of batch.candidates) {
+      if ((candidate.lodCoverages?.length ?? 0) > 1) primitives.add(candidate.primitiveIndex);
+    }
+  }
+  if (primitives.size === 0) return '';
+  const heights: number[] = [];
+  for (const slot of slots) {
+    if (primitives.has(slot.slot))
+      heights.push(slot.slot, projectedHeightForCandidate(slot, camera));
+  }
+  return JSON.stringify(heights);
 }
 
-function productionEligible(snapshot: RenderableSnapshot, batch: GpuDrivenBatch): boolean {
+function preparedPbrCandidateEligible(
+  snapshot: RenderableSnapshot,
+  batch: GpuDrivenBatch,
+  candidate: GpuDrivenBatch['candidates'][number],
+  skinArtifact?: MaterialShaderArtifact,
+): boolean {
   const material = snapshot.materials[batch.key.materialSlot] ?? snapshot.material;
-  const shader = material.materialShaderId ?? 'forgeax::default-unlit';
+  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 alphaBlend = material.transparent === true || material.renderState?.blend !== undefined;
+  const cpuOnlyMaterialResources =
+    (material.textureSources?.size ?? 0) > 0 || (material.videoTextureFields?.size ?? 0) > 0;
+  // Transmission has a separate CPU semantic pass today. Keep it out of the
+  // GPU-owned candidate set so the residual transmission draw is not swallowed
+  // by the generic Standard PBR lane.
+  const transmission =
+    typeof material.paramSnapshot?.transmission === 'number' &&
+    material.paramSnapshot.transmission > 0;
+  const skinReady =
+    prepared.identity.deformation !== 'skin' ||
+    (skinArtifact?.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 (
-    shader === 'forgeax::default-unlit' &&
-    // The production rigid shader owns triangle-list raster only. Lines and
-    // points stay with their CPU/specialized topology owners.
-    batch.key.topology === 'triangle-list' &&
-    batch.key.materialResourceClass === EMPTY_RESOURCE_CLASS &&
-    material.baseColorTexture === undefined &&
-    material.transparent !== true
+    standard &&
+    !alphaBlend &&
+    !cpuOnlyMaterialResources &&
+    !transmission &&
+    (prepared.identity.deformation === 'rigid' || prepared.identity.deformation === 'skin') &&
+    skinReady
   );
 }
 
-/**
- * Prepared Standard PBR draws have an explicit receipt identity on their
- * batch key. Unprepared batches stay on the rigid production shader; the
- * presence of a frame-wide PBR artifact is not permission to reinterpret an
- * unlit batch with the PBR bind-group layout.
- */
-function isStandardPbrBatch(batch: GpuDrivenBatch): boolean {
-  return batch.key.preparedIdentity !== undefined;
-}
-
 function meshSupportsBatch(mesh: MeshGpuHandles, batch: GpuDrivenBatch): boolean {
   if (
     batch.candidates.some((candidate) => {
@@ -341,6 +402,132 @@ function meshSupportsBatch(mesh: MeshGpuHandles, batch: GpuDrivenBatch): boolean
     : !mesh.indexed;
 }
 
+function sceneCandidate(
+  slot: PersistentGpuDrivenState['slots'][number],
+  candidate: GpuDrivenBatch['candidates'][number],
+  materialIndex?: number,
+): StandardPbrSceneCandidate {
+  const transforms = slot.snapshot.instances?.transforms;
+  return {
+    primitiveIndex: candidate.primitiveIndex,
+    world: slot.snapshot.transform.world,
+    ...(transforms === undefined
+      ? {}
+      : {
+          instanceTransform: transforms.subarray(
+            candidate.instanceOrdinal * 16,
+            candidate.instanceOrdinal * 16 + 16,
+          ),
+        }),
+    ...(materialIndex === undefined ? {} : { materialIndex }),
+  };
+}
+
+function shadowCandidateKey(candidate: GpuDrivenBatch['candidates'][number]): string {
+  return `${candidate.primitiveIndex}:${candidate.drawItemIndex}:${candidate.instanceOrdinal}`;
+}
+
+function gpuDrivenProjectionKey(
+  batch: GpuDrivenBatch,
+  deformation: 'rigid' | 'skin',
+  artifact: MaterialShaderArtifact,
+): string {
+  return `${batch.batchId}:${batch.generation}:${deformation}:${artifact.layoutIdentity}`;
+}
+
+function gpuDrivenShadowProjectionKey(
+  viewKey: string,
+  batch: GpuDrivenBatch,
+  deformation: 'rigid' | 'skin',
+  artifact: MaterialShaderArtifact,
+): string {
+  return `shadow:${viewKey}:${gpuDrivenProjectionKey(batch, deformation, artifact)}`;
+}
+
+function sourceDrawForCandidate(
+  slot: PersistentGpuDrivenState['slots'][number],
+  candidate: GpuDrivenBatch['candidates'][number],
+): NonNullable<RenderableSnapshot['gpuDrivenDraws']>[number] | undefined {
+  return slot.snapshot.gpuDrivenDraws?.find(
+    (draw, compactIndex) =>
+      gpuDrivenSourceDrawItemIndex(draw, compactIndex) === candidate.drawItemIndex,
+  );
+}
+
+function shadowKeysForCandidate(
+  slot: PersistentGpuDrivenState['slots'][number],
+  candidate: GpuDrivenBatch['candidates'][number],
+  shadowCasterDrawKeys: ReadonlySet<string> | undefined,
+  shadowCasterMembership: readonly ShadowCasterMembership[] | undefined,
+): readonly string[] {
+  const draw = sourceDrawForCandidate(slot, candidate);
+  if (draw === undefined) return [];
+  const material = slot.snapshot.materials[draw.materialSlot] ?? slot.snapshot.material;
+  const worldEntity = worldEntityKey(slot.snapshot.worldId, slot.snapshot.entityKey);
+  const base = gpuDrivenDrawKey(
+    worldEntity,
+    material.materialHandle ?? -1,
+    candidate.drawItemIndex,
+  );
+  if (shadowCasterMembership !== undefined) {
+    const keys = new Set<string>();
+    for (const membership of shadowCasterMembership) {
+      if (
+        membership.worldEntity === worldEntity &&
+        membership.materialHandle === (material.materialHandle ?? -1) &&
+        membership.drawItemIndex === candidate.drawItemIndex
+      ) {
+        keys.add(
+          gpuDrivenShadowDrawKey(
+            membership.worldEntity,
+            membership.materialHandle,
+            membership.drawItemIndex,
+            membership.passIndex,
+          ),
+        );
+      }
+    }
+    return [...keys];
+  }
+  if (shadowCasterDrawKeys === undefined) return [];
+  return [...shadowCasterDrawKeys].filter((key) => {
+    const parts = key.split(':');
+    return parts.length === 4 && `${parts[0]}:${parts[1]}:${parts[2]}` === base;
+  });
+}
+
+function shadowMembershipIsGpuCompatible(
+  slot: PersistentGpuDrivenState['slots'][number],
+  candidate: GpuDrivenBatch['candidates'][number],
+  shadowCasterDrawKeys: ReadonlySet<string> | undefined,
+  shadowCasterMembership: readonly ShadowCasterMembership[] | undefined,
+): boolean {
+  const keys = shadowKeysForCandidate(
+    slot,
+    candidate,
+    shadowCasterDrawKeys,
+    shadowCasterMembership,
+  );
+  if (keys.length !== 1) return false;
+  if (shadowCasterMembership === undefined) return true;
+  const draw = sourceDrawForCandidate(slot, candidate);
+  if (draw === undefined) return false;
+  const material = slot.snapshot.materials[draw.materialSlot] ?? slot.snapshot.material;
+  const worldEntity = worldEntityKey(slot.snapshot.worldId, slot.snapshot.entityKey);
+  const matching = shadowCasterMembership.filter(
+    (membership) =>
+      membership.worldEntity === worldEntity &&
+      membership.materialHandle === (material.materialHandle ?? -1) &&
+      membership.drawItemIndex === candidate.drawItemIndex,
+  );
+  if (matching.length !== 1) return false;
+  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';
+}
+
 function selectedLodLevel(candidate: GpuDrivenCandidate): number {
   const coverages = candidate.lodCoverages;
   if (coverages === undefined || coverages.length <= 1) return 0;
@@ -368,28 +555,38 @@ function selectedLodRange(
   );
 }
 
-/**
- * One raster indirect command is emitted for each selector batch that has at
- * least one admitted candidate. Selector-only batches remain in the compute
- * and readback plan, but they must not inflate the raster command count.
- */
 function admittedRasterBatchCount(plan: SubmissionPlan): number {
   return plan.batches.reduce((count, batch) => count + (batch.visibleCapacity > 0 ? 1 : 0), 0);
 }
 
+function gpuDrawEntityCount(drawKeys: ReadonlySet<string>): number {
+  const entities = new Set<string>();
+  for (const key of drawKeys) {
+    const separator = key.indexOf(':');
+    if (separator > 0) entities.add(key.slice(0, separator));
+  }
+  return entities.size;
+}
+
 function filteredPlan(
   source: SubmissionPlan,
   slots: PersistentGpuDrivenState['slots'],
-  meshes: ReadonlyMap<number, MeshGpuHandles>,
-  camera: CameraSnapshot,
+  meshBySlot: ReadonlyMap<number, MeshGpuHandles>,
+  shadowCasterDrawKeys?: ReadonlySet<string>,
+  skinArtifact?: MaterialShaderArtifact,
+  shadowCasterMembership?: readonly ShadowCasterMembership[],
+  camera?: CameraSnapshot,
   activeEntityKeys?: ReadonlySet<number>,
   worldKeys?: readonly number[],
 ): {
   readonly plan: SubmissionPlan;
   readonly batches: readonly PreparedBatch[];
-  readonly entityKeys: ReadonlySet<number>;
-  /** No source primitive can enter this lane without a topology/material change. */
-  readonly topologyInvariantEmpty: boolean;
+  /** True only when every source draw item/instance has a main GPU candidate. */
+  readonly ownsAllDrawItems: boolean;
+  /** Concrete entity/material/draw identities claimed by this projection. */
+  readonly drawKeys: ReadonlySet<string>;
+  /** Extracted concrete ShadowCaster keys actually claimed by this plan. */
+  readonly shadowDrawKeys: ReadonlySet<string>;
 } {
   const slotByPrimitive = new Map(slots.map((slot) => [slot.slot, slot] as const));
   const participatingByPrimitive = new Map<number, Set<GpuDrivenBatch>>();
@@ -403,42 +600,62 @@ function filteredPlan(
       }
     }
   }
-  const entityKeys = new Set<number>();
+  const eligibleMainCandidates = new Set<string>();
+  const drawKeys = new Set<string>();
+  const eligibleShadowCandidates = new Set<string>();
+  const shadowDrawKeys = new Set<string>();
+  const shadowSelectionProvided =
+    shadowCasterDrawKeys !== undefined || shadowCasterMembership !== undefined;
   const worldKeyFor = (slot: PersistentGpuDrivenState['slots'][number]): number =>
     worldKeys?.[slot.snapshot.worldId] ?? slot.snapshot.worldId;
   const activeKey = (slot: PersistentGpuDrivenState['slots'][number]): number =>
     worldEntityKey(worldKeyFor(slot), slot.snapshot.entityKey);
-  const eligiblePrimitives = new Set<number>();
-  let topologyEligiblePrimitiveCount = 0;
   for (const slot of slots) {
-    const mesh = meshes.get(slot.snapshot.assetHandle);
-    const participating = participatingByPrimitive.get(slot.slot);
-    const participatingBatches = participating === undefined ? [] : [...participating];
-    const topologyEligible =
-      participatingBatches.length > 0 &&
-      participatingBatches.length === (slot.snapshot.gpuDrivenDraws?.length ?? 0) &&
-      participatingBatches.every((batch) => productionEligible(slot.snapshot, batch));
-    if (topologyEligible) topologyEligiblePrimitiveCount += 1;
-    if (
-      mesh !== undefined &&
-      topologyEligible &&
-      participatingBatches.every((batch) => meshSupportsBatch(mesh, batch))
-    ) {
-      eligiblePrimitives.add(slot.slot);
-      // Record validation still keys extracted renderables by their current
-      // stable world/entity key. Suppressed candidates remain in the GPU
-      // selector, but only admitted entities are owned by the compacted draw.
-      if (activeEntityKeys === undefined || activeEntityKeys.has(activeKey(slot))) {
-        entityKeys.add(activeKey(slot));
+    const mesh = meshBySlot.get(slot.slot);
+    const participating = participatingByPrimitive.get(slot.slot) ?? new Set<GpuDrivenBatch>();
+    for (const batch of participating) {
+      for (const candidate of batch.candidates) {
+        if (candidate.primitiveIndex !== slot.slot) continue;
+        const draw = sourceDrawForCandidate(slot, candidate);
+        const mainEligible =
+          draw !== undefined &&
+          preparedPbrCandidateEligible(slot.snapshot, batch, candidate, skinArtifact) &&
+          mesh !== undefined &&
+          meshSupportsBatch(mesh, batch);
+        if (!shadowSelectionProvided && mainEligible && draw !== undefined) {
+          eligibleMainCandidates.add(shadowCandidateKey(candidate));
+          const material = slot.snapshot.materials[draw.materialSlot] ?? slot.snapshot.material;
+          drawKeys.add(
+            gpuDrivenDrawKey(
+              worldEntityKey(worldKeyFor(slot), slot.snapshot.entityKey),
+              material.materialHandle ?? -1,
+              candidate.drawItemIndex,
+            ),
+          );
+        }
+        if (
+          shadowSelectionProvided &&
+          mainEligible &&
+          shadowMembershipIsGpuCompatible(
+            slot,
+            candidate,
+            shadowCasterDrawKeys,
+            shadowCasterMembership,
+          )
+        ) {
+          eligibleShadowCandidates.add(shadowCandidateKey(candidate));
+          for (const key of shadowKeysForCandidate(
+            slot,
+            candidate,
+            shadowCasterDrawKeys,
+            shadowCasterMembership,
+          )) {
+            shadowDrawKeys.add(key);
+          }
+        }
       }
     }
   }
-  // BatchTopology deliberately keeps LOD candidates individually addressable
-  // so topology updates never alias a candidate's selector state.  Once the
-  // camera has projected the candidates, the renderer can safely coalesce
-  // candidates that have identical immutable geometry/LOD facts and the same
-  // selected range.  The GPU selector uses the same no-history inputs below,
-  // so one indirect range remains correct for every candidate in a group.
   const groups = new Map<
     string,
     {
@@ -451,15 +668,21 @@ function filteredPlan(
   for (const batch of source.batches) {
     const candidates = batch.candidates.filter((candidate) => {
       const slot = slotByPrimitive.get(candidate.primitiveIndex);
-      if (slot === undefined || !eligiblePrimitives.has(slot.slot)) return false;
-      const mesh = meshes.get(slot.snapshot.assetHandle);
+      if (slot === undefined) return false;
+      if (
+        !shadowSelectionProvided
+          ? !eligibleMainCandidates.has(shadowCandidateKey(candidate))
+          : !eligibleShadowCandidates.has(shadowCandidateKey(candidate))
+      )
+        return false;
+      const mesh = meshBySlot.get(slot.slot);
       return mesh !== undefined && meshSupportsBatch(mesh, batch);
     });
     if (candidates.length === 0) continue;
     for (const candidate of candidates) {
       const slot = slotByPrimitive.get(candidate.primitiveIndex);
       if (slot === undefined) continue;
-      const mesh = meshes.get(slot.snapshot.assetHandle);
+      const mesh = meshBySlot.get(slot.slot);
       if (mesh === undefined) continue;
       const physicalLodRanges = mesh.lodRanges
         ?.slice(1)
@@ -467,7 +690,10 @@ function filteredPlan(
       const projected = Object.freeze({
         ...candidate,
         submitAdmission: activeEntityKeys === undefined || activeEntityKeys.has(activeKey(slot)),
-        projectedHeight: projectedHeightForCandidate(slot, camera),
+        projectedHeight:
+          camera === undefined
+            ? (candidate.projectedHeight ?? Number.NaN)
+            : projectedHeightForCandidate(slot, camera),
         ...(physicalLodRanges?.every((range) => range !== undefined)
           ? { lodRanges: physicalLodRanges as NonNullable<typeof candidate.lodRanges> }
           : {}),
@@ -495,7 +721,6 @@ function filteredPlan(
       }
     }
   }
-
   const batches: PreparedBatch[] = [];
   let visibleBase = 0;
   const filteredBatches: GpuDrivenBatch[] = [];
@@ -521,7 +746,19 @@ function filteredPlan(
     });
     visibleBase += admittedCount;
     filteredBatches.push(filtered);
-    const firstCandidate = group.candidates[0];
+    // Keep every selector batch id unique even when no current entity is
+    // admitted to raster. The zero-admission batch still feeds LOD telemetry,
+    // while the following raster batch must not reuse its indirect slot.
+    batchId += 1;
+    // A selector batch can retain facet-suppressed candidates for LOD
+    // telemetry. Raster ownership, however, must be represented by an
+    // admitted candidate; using the first retained row can point material
+    // routing at an entity that the main-pass producer intentionally omitted.
+    const firstCandidate = group.candidates.find(
+      (candidate) =>
+        (candidate as GpuDrivenCandidate & { readonly submitAdmission?: boolean })
+          .submitAdmission !== false,
+    );
     const firstSlot =
       firstCandidate === undefined ? undefined : slotByPrimitive.get(firstCandidate.primitiveIndex);
     if (firstCandidate === undefined || firstSlot === undefined) continue;
@@ -533,23 +770,142 @@ function filteredPlan(
       primitiveSlot: firstSlot.slot,
       slotGeneration: firstSlot.generation,
     });
-    batchId += 1;
   }
+  const ownershipSlots =
+    activeEntityKeys === undefined
+      ? slots
+      : slots.filter((slot) => activeEntityKeys.has(activeKey(slot)));
+  const ownsAllDrawItems =
+    !shadowSelectionProvided &&
+    ownershipSlots.every((slot) => {
+      const draws = slot.snapshot.gpuDrivenDraws ?? [];
+      if (draws.length === 0) return false;
+      const instanceCount = slot.snapshot.instances?.instanceCount ?? 1;
+      const candidates = source.batches.flatMap((batch) =>
+        batch.candidates.filter((candidate) => candidate.primitiveIndex === slot.slot),
+      );
+      return (
+        candidates.length === draws.length * instanceCount &&
+        candidates.every((candidate) => {
+          if (!eligibleMainCandidates.has(shadowCandidateKey(candidate))) return false;
+          const draw = sourceDrawForCandidate(slot, candidate);
+          if (draw === undefined) return false;
+          const material = slot.snapshot.materials[draw.materialSlot] ?? slot.snapshot.material;
+          return drawKeys.has(
+            gpuDrivenDrawKey(
+              worldEntityKey(worldKeyFor(slot), slot.snapshot.entityKey),
+              material.materialHandle ?? -1,
+              candidate.drawItemIndex,
+            ),
+          );
+        })
+      );
+    });
   return {
     plan: Object.freeze({
       revision: source.revision,
+      payloadRevision: source.payloadRevision,
       batches: Object.freeze(filteredBatches),
       candidateCount: filteredBatches.reduce((total, batch) => total + batch.candidates.length, 0),
       visibleCapacity: visibleBase,
     }),
     batches: Object.freeze(batches),
-    entityKeys,
-    topologyInvariantEmpty: topologyEligiblePrimitiveCount === 0,
+    ownsAllDrawItems,
+    drawKeys,
+    shadowDrawKeys,
   };
 }
 
+function shadowCasterMembershipSignature(
+  drawKeys: ReadonlySet<string> | undefined,
+  membership: readonly ShadowCasterMembership[] | undefined,
+): string {
+  const keySignature = drawKeys === undefined ? '*' : [...drawKeys].sort().join(',');
+  if (membership === undefined) return keySignature;
+  const membershipSignature = membership
+    .map((entry) =>
+      [
+        entry.worldEntity,
+        entry.renderableIndex,
+        entry.drawItemIndex,
+        entry.materialHandle,
+        entry.passIndex,
+        entry.materialShaderId ?? '',
+        JSON.stringify(entry.renderState ?? null),
+        entry.cpuReason ?? '',
+      ].join(':'),
+    )
+    .sort()
+    .join(',');
+  return `${keySignature}|membership=${membershipSignature}`;
+}
+
 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?.identity.deformation === 'rigid' ||
+          candidate.prepared?.identity.deformation === 'skin')
+      );
+    }),
+  );
+}
+
+function nonCpuPreparationFailure(
+  scene: PersistentGpuDrivenState,
+): { readonly error: GpuDrivenPreparationError; readonly drawKeys: readonly string[] } | undefined {
+  const drawKeys: string[] = [];
+  let first: GpuDrivenPreparationError | undefined;
+  for (const slot of scene.slots) {
+    const draws = slot.snapshot.gpuDrivenDraws ?? [];
+    for (const [compactIndex, draw] of draws.entries()) {
+      const error = draw.preparationError;
+      if (error === undefined || error.detail.recovery === 'route-cpu-lane') continue;
+      const material = slot.snapshot.materials[draw.materialSlot] ?? slot.snapshot.material;
+      drawKeys.push(
+        gpuDrivenDrawKey(
+          worldEntityKey(slot.snapshot.worldId, slot.snapshot.entityKey),
+          material.materialHandle ?? -1,
+          gpuDrivenSourceDrawItemIndex(draw, compactIndex),
+        ),
+      );
+      first ??= error;
+    }
+  }
+  return first === undefined ? undefined : { error: first, drawKeys };
+}
+
+function preparationFailureInspection(
+  error: GpuDrivenPreparationError,
+): GpuDrivenPreparationFailureInspection {
+  return Object.freeze({
+    code: error.code,
+    expected: error.expected,
+    hint: error.hint,
+    detail: error.detail,
+  });
+}
+
+function shadowOwnershipFailureInspection(
+  viewPass: GpuDrivenLaneSummary['viewPass'],
+): GpuDrivenPreparationFailureInspection {
+  return preparationFailureInspection(
+    new GpuDrivenPreparationError('shadow-ownership', {
+      reason: 'shadow-ownership-missing',
+      owner: 'shadow',
+      expected: 'one GPU-compatible owner for every declared ShadowCaster pass',
+      actual: `${viewPass} contains a residual ShadowCaster draw item`,
+      recovery: 'route-cpu-lane',
+    }),
+  );
+}
+
 export interface GpuDrivenWorldLodSelectionInspection {
   readonly worldKey: number;
   readonly primitiveSlot: number;
@@ -570,89 +926,322 @@ function sameEntityKeySet(
   return true;
 }
 
-class GpuDrivenRigidRaster {
+/** The GPU-driven bridge to the existing four-group Standard PBR pipeline. */
+class StandardPbrRasterAdapter {
   private readonly pipelines = new Map<string, RenderPipeline>();
+  private readonly projectionBuffers = new Set<Buffer>();
+  private readonly projectionBindings = new Map<
+    string,
+    {
+      readonly buffer: Buffer;
+      readonly bindGroup: BindGroup;
+      readonly capacityBytes: number;
+      rows: Float32Array;
+    }
+  >();
+  /**
+   * Projection rows are graph-generation resources. A new topology may stage
+   * a replacement before the graph is promoted; keeping staged bindings out
+   * of the active map lets an aborted graph leave the last submitted rows
+   * intact. Superseded buffers are fence-retired on promotion.
+   */
+  private readonly stagedProjectionBindings = new Map<
+    string,
+    {
+      readonly buffer: Buffer;
+      readonly bindGroup: BindGroup;
+      readonly capacityBytes: number;
+      rows: Float32Array;
+    }
+  >();
+  private readonly pendingProjectionRetirements = new Set<Buffer>();
+  private readonly destroyedProjectionBuffers = new Set<Buffer>();
+  private projectionDisposed = false;
+  private stagedProjectionKeys = new Set<string>();
+  private readonly activeProjectionRowsAtStage = new Map<string, Float32Array>();
+  private readonly visibleWindowBindGroups = new Map<Buffer, Map<string, BindGroup>>();
 
   private constructor(
     private readonly device: RhiDevice,
-    private readonly layout: BindGroupLayout,
     private readonly pipelineLayout: import('@forgeax/engine-rhi').PipelineLayout,
-    private readonly module: ShaderModule,
+    private readonly meshLayout: BindGroupLayout,
+    private readonly instancesBindGroupLayout: BindGroupLayout,
+    private readonly programs: ReadonlyMap<string, GpuDrivenPbrProgram>,
+    private instancesBindGroup: BindGroup,
+    private readonly instanceBuffer: Buffer,
+    private readonly instanceBufferSize: number,
+    private visibleBuffer: Buffer,
+    private readonly artifact: MaterialShaderArtifact,
+    private readonly deformation: 'rigid' | 'skin',
+    private paletteBuffer: Buffer | undefined,
+    private paletteBindingWindowBytes: number | undefined,
   ) {}
 
   static create(input: {
     readonly device: RhiDevice;
-    readonly shaderModuleFactory: PipelineBuilderShaderModuleFactory;
-    readonly viewBindGroupLayout: BindGroupLayout;
-  }): Result<GpuDrivenRigidRaster, RhiError> {
-    const layout = input.device.createBindGroupLayout({
-      label: 'gpu-driven-rigid-raster-bgl',
+    readonly pipelineState: PipelineState;
+    readonly artifact: MaterialShaderArtifact;
+    readonly visibleBuffer: Buffer;
+    readonly deformation?: 'rigid' | 'skin';
+    readonly paletteBuffer?: Buffer;
+    readonly paletteBindingWindowBytes?: number;
+  }): Result<StandardPbrRasterAdapter, RhiError> {
+    const deformation = input.deformation ?? 'rigid';
+    const pipelineLayout =
+      deformation === 'skin'
+        ? input.pipelineState.gpuDrivenPbrSkinPipelineLayout
+        : input.pipelineState.gpuDrivenPbrPipelineLayout;
+    const instancesBindGroupLayout = input.pipelineState.gpuDrivenInstancesBindGroupLayout;
+    if (pipelineLayout == null || instancesBindGroupLayout == null) {
+      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',
+        }),
+      );
+    }
+    const programs = input.pipelineState.gpuDrivenPbrPrograms;
+    if (
+      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',
+        }),
+      );
+    }
+    const meshLayout =
+      deformation === 'skin'
+        ? input.pipelineState.pbrSkinMeshBindGroupLayout
+        : input.pipelineState.meshBindGroupLayout;
+    if (meshLayout === null) {
+      return err(
+        new RhiError({
+          code: 'rhi-not-available',
+          expected: `${deformation === 'skin' ? 'skinned ' : ''}Standard PBR mesh bind-group layout`,
+          hint: 'publish the exact mesh-array layout selected by the material receipt',
+        }),
+      );
+    }
+    if (
+      deformation === 'skin' &&
+      (input.paletteBuffer === undefined || input.paletteBindingWindowBytes === undefined)
+    ) {
+      return err(
+        new RhiError({
+          code: 'rhi-not-available',
+          expected: 'persistent skin palette buffer and binding window',
+          hint: 'keep the palette receipt and the GPU-driven skinned projection on one frame identity',
+        }),
+      );
+    }
+    const identity = new Float32Array(16);
+    identity[0] = 1;
+    identity[5] = 1;
+    identity[10] = 1;
+    identity[15] = 1;
+    const instancePayload = packInstanceStorageBuffer(identity);
+    const instanceBuffer = input.device.createBuffer({
+      label: 'standard-pbr-gpu-driven-instance-data',
+      size: instancePayload.byteLength,
+      usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST,
+    });
+    if (!instanceBuffer.ok) return instanceBuffer;
+    const instanceWrite = input.device.queue.writeBuffer(instanceBuffer.value, 0, instancePayload);
+    if (!instanceWrite.ok) return instanceWrite;
+    const instancesBindGroup = input.device.createBindGroup({
+      label: 'standard-pbr-gpu-driven-visible-instances-bg',
+      layout: instancesBindGroupLayout,
       entries: [
-        { binding: 0, visibility: VERTEX_STAGE, buffer: { type: 'read-only-storage' } },
+        {
+          binding: 0,
+          resource: bufferBinding(instanceBuffer.value, 0, instancePayload.byteLength),
+        },
         {
           binding: 1,
-          visibility: VERTEX_STAGE,
-          buffer: { type: 'read-only-storage' },
+          resource: bufferBinding(input.visibleBuffer),
         },
         {
           binding: 2,
-          visibility: VERTEX_STAGE | FRAGMENT_STAGE,
-          buffer: { type: 'read-only-storage' },
+          resource: bufferBinding(input.visibleBuffer),
         },
-        { binding: 3, visibility: VERTEX_STAGE, buffer: { type: 'read-only-storage' } },
-        { binding: 4, visibility: VERTEX_STAGE, buffer: { type: 'read-only-storage' } },
       ],
     });
-    if (!layout.ok) return layout;
-    const pipelineLayout = input.device.createPipelineLayout({
-      label: 'gpu-driven-rigid-raster-pl',
-      bindGroupLayouts: [input.viewBindGroupLayout, layout.value],
-    });
-    if (!pipelineLayout.ok) return pipelineLayout;
-    const module = input.shaderModuleFactory.createShaderModule({
-      label: 'gpu-driven-rigid-unlit',
-      code: GPU_DRIVEN_RIGID_UNLIT_WGSL,
-    });
-    if (!module.ok) return module;
+    if (!instancesBindGroup.ok) return instancesBindGroup;
     return ok(
-      new GpuDrivenRigidRaster(input.device, layout.value, pipelineLayout.value, module.value),
+      new StandardPbrRasterAdapter(
+        input.device,
+        pipelineLayout,
+        meshLayout,
+        instancesBindGroupLayout,
+        programs,
+        instancesBindGroup.value,
+        instanceBuffer.value,
+        instancePayload.byteLength,
+        input.visibleBuffer,
+        input.artifact,
+        deformation,
+        input.paletteBuffer,
+        input.paletteBindingWindowBytes,
+      ),
     );
   }
 
+  ensurePaletteBuffer(
+    paletteBuffer: Buffer | undefined,
+    paletteBindingWindowBytes: number | undefined,
+  ): Result<void, RhiError> {
+    if (this.deformation !== 'skin') return ok(undefined);
+    if (paletteBuffer === undefined || paletteBindingWindowBytes === undefined) {
+      return err(
+        new RhiError({
+          code: 'rhi-not-available',
+          expected: 'persistent skin palette buffer and binding window',
+          hint: 'publish a storage-backed SkinPaletteReceipt before the GPU-driven skinned lane',
+        }),
+      );
+    }
+    this.paletteBuffer = paletteBuffer;
+    this.paletteBindingWindowBytes = paletteBindingWindowBytes;
+    return ok(undefined);
+  }
+
+  ensureVisibleBuffer(visibleBuffer: Buffer): Result<void, RhiError> {
+    if (this.visibleBuffer === visibleBuffer) return ok(undefined);
+    const created = this.device.createBindGroup({
+      label: 'standard-pbr-gpu-driven-visible-instances-bg',
+      layout: this.instancesBindGroupLayout,
+      entries: [
+        {
+          binding: 0,
+          resource: bufferBinding(this.instanceBuffer, 0, this.instanceBufferSize),
+        },
+        { binding: 1, resource: bufferBinding(visibleBuffer) },
+        { binding: 2, resource: bufferBinding(visibleBuffer) },
+      ],
+    });
+    if (!created.ok) return created;
+    this.instancesBindGroup = created.value;
+    this.visibleBuffer = visibleBuffer;
+    return ok(undefined);
+  }
+
+  visibleWindowBindGroup(
+    visibleBase: number,
+    visibleCapacity: number,
+  ): Result<BindGroup, RhiError> {
+    return this.visibleWindowBindGroupForBuffer(this.visibleBuffer, visibleBase, visibleCapacity);
+  }
+
+  visibleWindowBindGroupForBuffer(
+    visibleBuffer: Buffer,
+    visibleBase: number,
+    visibleCapacity: number,
+  ): Result<BindGroup, RhiError> {
+    const offset = visibleBase * 8;
+    const size = visibleCapacity * 8;
+    if (offset % 256 !== 0 || size <= 0) {
+      return err(
+        new RhiError({
+          code: 'rhi-descriptor-invalid',
+          expected: '256-byte-aligned non-empty visible window',
+          hint: `allocate each GPU-driven batch visible window on the portable storage-buffer boundary (base=${visibleBase}, capacity=${visibleCapacity}, offset=${offset}, size=${size})`,
+        }),
+      );
+    }
+    let groups = this.visibleWindowBindGroups.get(visibleBuffer);
+    if (groups === undefined) {
+      groups = new Map();
+      this.visibleWindowBindGroups.set(visibleBuffer, groups);
+    }
+    const key = `${visibleBase}:${visibleCapacity}`;
+    const cached = groups.get(key);
+    if (cached !== undefined) return ok(cached);
+    const created = this.device.createBindGroup({
+      label: `standard-pbr-gpu-driven-visible-window-${visibleBase}`,
+      layout: this.instancesBindGroupLayout,
+      entries: [
+        {
+          binding: 0,
+          resource: bufferBinding(this.instanceBuffer, 0, this.instanceBufferSize),
+        },
+        { binding: 1, resource: bufferBinding(visibleBuffer, offset, size) },
+        { binding: 2, resource: bufferBinding(visibleBuffer, offset, size) },
+      ],
+    });
+    if (!created.ok) return created;
+    groups.set(key, created.value);
+    return ok(created.value);
+  }
+
   pipeline(
     format: TextureFormat,
     sampleCount: 1 | 4,
-    vertexStride: number,
+    layoutProjection: MeshGpuHandles['layoutProjection'],
+    shaderUvSetCount: number,
     topology: GpuDrivenBatch['key']['topology'],
     stripIndexFormat: 'uint16' | 'uint32' | undefined,
     renderState: MaterialRenderState | undefined,
   ): Result<RenderPipeline, RhiError> {
-    const key = `${format}|${sampleCount}|${vertexStride}|${topology}|${stripIndexFormat ?? ''}|${JSON.stringify(renderState ?? null)}`;
+    const vertexLayout = deriveVertexBufferLayoutFromProjection(layoutProjection, {
+      shaderUvSetCount,
+    })[0];
+    if (vertexLayout === undefined) {
+      return err(
+        new RhiError({
+          code: 'shader-compile-failed',
+          expected: 'non-empty geometry VertexLayoutProjection',
+          hint: 'prepare a receipt-compatible mesh projection before Standard PBR raster',
+        }),
+      );
+    }
+    const program = resolveStandardPbrProgram(
+      this.programs,
+      this.artifact.material,
+      layoutProjection.attributes.some((attribute) => attribute.key === 'color'),
+    );
+    if (program === undefined) {
+      return err(
+        new RhiError({
+          code: 'rhi-not-available',
+          expected: 'producer-owned Standard PBR program matching the geometry vertex layout',
+          hint: 'publish both vertex-color variants for the current device generation',
+        }),
+      );
+    }
+    const key = `${format}|${sampleCount}|${vertexLayout.arrayStride}|${topology}|${stripIndexFormat ?? ''}|${JSON.stringify(renderState ?? null)}|${program.artifact.layoutIdentity}|${layoutProjection.digest}|uv${shaderUvSetCount}`;
     const cached = this.pipelines.get(key);
     if (cached !== undefined) return ok(cached);
-    const created = this.device.createRenderPipeline({
-      label: `gpu-driven-rigid-unlit.${key}`,
+    const pipeline = this.device.createRenderPipeline({
+      label: `standard-pbr-gpu-driven.${key}`,
       layout: this.pipelineLayout,
       vertex: {
-        module: this.module,
-        entryPoint: 'vs_main',
+        module: program.module,
+        entryPoint: program.artifact.receipt?.sceneIndexEntry ?? 'vs_scene_index',
         buffers: [
           {
-            arrayStride: vertexStride,
+            arrayStride: vertexLayout.arrayStride,
             stepMode: 'vertex',
-            attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x3' }],
+            attributes: vertexLayout.attributes.map(({ shaderLocation, offset, format }) => ({
+              shaderLocation,
+              offset,
+              format: format as GPUVertexFormat,
+            })),
           },
         ],
       },
       fragment: {
-        module: this.module,
+        module: program.module,
         entryPoint: 'fs_main',
-        targets: [
-          {
-            format,
-            ...(renderState?.blend === undefined ? {} : { blend: renderState.blend }),
-          },
-        ],
+        targets: [{ format }],
       },
       primitive: {
         topology,
@@ -664,272 +1253,290 @@ class GpuDrivenRigidRaster {
         format: 'depth24plus-stencil8',
         depthWriteEnabled: renderState?.depthWriteEnabled ?? true,
         depthCompare: renderState?.depthCompare ?? 'less',
-        ...(renderState?.stencil === undefined
-          ? {}
-          : {
-              stencilFront: renderState.stencil,
-              stencilBack: renderState.stencil,
-              stencilReadMask: renderState.stencilReadMask,
-              stencilWriteMask: renderState.stencilWriteMask,
-            }),
       },
-      ...(sampleCount === 4
-        ? {
-            multisample: {
-              count: 4,
-              alphaToCoverageEnabled: renderState?.alphaToCoverageEnabled ?? false,
-            },
-          }
-        : {}),
+      ...(sampleCount === 4 ? { multisample: { count: 4 } } : {}),
     });
-    if (!created.ok) return created;
-    this.pipelines.set(key, created.value);
-    return created;
+    if (!pipeline.ok) return pipeline;
+    this.pipelines.set(key, pipeline.value);
+    return pipeline;
   }
 
-  bindGroup(
-    scene: PersistentGpuDrivenState['scene'],
-    view: GpuDrivenView,
-    batch: GpuDrivenBatch,
+  projectionBindGroup(
+    rows: Float32Array,
+    key?: string,
+    capacityRows?: number,
   ): Result<BindGroup, RhiError> {
-    const visible = view.visibleBuffer;
-    if (visible === undefined) {
-      return err(
-        new RhiError({
-          code: 'internal-error',
-          expected: 'GPU-driven view buffers exist after a successful view update',
-          hint: 'prepare the GPU-driven view before projecting its raster batches',
-        }),
+    if (key !== undefined) {
+      const capacityBytes = Math.max(
+        MESH_SSBO_BYTES,
+        (capacityRows ?? Math.ceil(rows.byteLength / MESH_SSBO_BYTES)) * MESH_SSBO_BYTES,
       );
+      const retained = this.stagedProjectionBindings.get(key) ?? this.projectionBindings.get(key);
+      if (retained !== undefined && retained.capacityBytes >= capacityBytes) {
+        const write = this.writeProjectionRows(key, retained, rows);
+        if (!write.ok) return write;
+        return ok(retained.bindGroup);
+      }
+      const created = this.createProjectionBinding(rows, capacityBytes);
+      if (!created.ok) return created;
+      this.stagedProjectionBindings.set(key, created.value);
+      return ok(created.value.bindGroup);
     }
-    return this.device.createBindGroup({
-      label: `gpu-driven-rigid-batch-${batch.batchId}`,
-      layout: this.layout,
-      entries: [
-        { binding: 0, resource: bufferBinding(scene.primitiveBuffer) },
-        { binding: 1, resource: bufferBinding(scene.instanceBuffer) },
-        { binding: 2, resource: bufferBinding(scene.materialBuffer) },
-        {
-          binding: 3,
-          resource: bufferBinding(visible, batch.visibleBase * 8, batch.visibleCapacity * 8),
-        },
-        {
-          binding: 4,
-          resource: bufferBinding(scene.transformBuffer),
-        },
-      ],
-    });
+    const created = this.createProjectionBinding(rows, Math.max(MESH_SSBO_BYTES, rows.byteLength));
+    if (!created.ok) return created;
+    return ok(created.value.bindGroup);
   }
-}
 
-/** The GPU-driven bridge to the existing four-group Standard PBR pipeline. */
-class StandardPbrRasterAdapter {
-  private readonly pipelines = new Map<string, RenderPipeline>();
-  private readonly projectionBuffers: Buffer[] = [];
+  refreshProjectionRows(key: string, rows: Float32Array): Result<void, RhiError> {
+    const retained = this.stagedProjectionBindings.get(key) ?? this.projectionBindings.get(key);
+    if (retained === undefined) return ok(undefined);
+    if (rows.byteLength > retained.capacityBytes) {
+      const capacityBytes = Math.max(
+        MESH_SSBO_BYTES,
+        Math.ceil(rows.byteLength / MESH_SSBO_BYTES) * MESH_SSBO_BYTES,
+      );
+      const replacement = this.createProjectionBinding(rows, capacityBytes);
+      if (!replacement.ok) return replacement;
+      const previousStaged = this.stagedProjectionBindings.get(key);
+      if (previousStaged !== undefined && previousStaged.buffer !== replacement.value.buffer) {
+        this.retireProjectionBuffer(previousStaged.buffer);
+      }
+      this.stagedProjectionBindings.set(key, replacement.value);
+      return ok(undefined);
+    }
+    return this.writeProjectionRows(key, retained, rows);
+  }
 
-  private constructor(
-    private readonly device: RhiDevice,
-    private readonly pipelineLayout: import('@forgeax/engine-rhi').PipelineLayout,
-    private readonly meshLayout: BindGroupLayout,
-    private readonly module: ShaderModule,
-    private readonly materialBindGroup: BindGroup,
-    private readonly instancesBindGroup: BindGroup,
-    private readonly artifact: MaterialShaderArtifact,
-  ) {}
+  /** Stage the projection keys required by the frame being prepared. */
+  stageProjectionKeys(keys: ReadonlySet<string>): void {
+    this.stagedProjectionKeys = new Set(keys);
+    this.activeProjectionRowsAtStage.clear();
+  }
 
-  static create(input: {
-    readonly device: RhiDevice;
-    readonly shaderModuleFactory: PipelineBuilderShaderModuleFactory;
-    readonly pipelineState: PipelineState;
-    readonly artifact: MaterialShaderArtifact;
-  }): Result<StandardPbrRasterAdapter, RhiError> {
-    const pipelineLayout = input.pipelineState.pbrPipelineLayout;
-    const fallback = input.pipelineState.skylightFallback;
-    if (pipelineLayout === null || fallback === null) {
-      return err(
-        new RhiError({
-          code: 'rhi-not-available',
-          expected: 'Standard PBR pipeline layout and Skylight fallback',
-          hint: 'initialize the Standard PBR pipeline before enabling GPU-driven raster',
-        }),
-      );
+  /** Add a shadow projection key discovered while updating a view plan. */
+  noteProjectionKey(key: string): void {
+    this.stagedProjectionKeys.add(key);
+  }
+
+  /** Promote staged projection resources after the command buffer submits. */
+  commitProjectionBindings(): void {
+    const keep = new Set(this.stagedProjectionKeys);
+    for (const [key, staged] of this.stagedProjectionBindings) {
+      if (!keep.has(key)) {
+        this.retireProjectionBuffer(staged.buffer);
+        continue;
+      }
+      const previous = this.projectionBindings.get(key);
+      this.projectionBindings.set(key, staged);
+      if (previous !== undefined && previous.buffer !== staged.buffer) {
+        this.retireProjectionBuffer(previous.buffer);
+      }
     }
-    const module = input.shaderModuleFactory.createShaderModule({
-      label: 'standard-pbr-gpu-driven-scene-index',
-      code: input.artifact.wgsl,
-    });
-    if (!module.ok) return module;
-    const materialBuffer = input.device.createBuffer({
-      label: 'standard-pbr-gpu-driven-material-row',
-      size: 384,
-      usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-    });
-    if (!materialBuffer.ok) return materialBuffer;
-    const materialPayload = new Float32Array(96);
-    materialPayload[0] = 1;
-    materialPayload[1] = 1;
-    materialPayload[2] = 1;
-    materialPayload[3] = 1;
-    materialPayload[5] = 1;
-    materialPayload[6] = 1;
-    const materialWrite = input.device.queue.writeBuffer(materialBuffer.value, 0, materialPayload);
-    if (!materialWrite.ok) return materialWrite;
-    const baseEntries = [
-      { binding: 0, resource: bufferBinding(materialBuffer.value, 0, 384) },
-      ...Array.from({ length: 8 }, (_, index) => [
-        {
-          binding: index * 2 + 1,
-          resource: { kind: 'sampler' as const, value: fallback.sampler },
-        },
-        {
-          binding: index * 2 + 2,
-          resource: {
-            kind: 'textureView' as const,
-            value:
-              index === 2
-                ? input.pipelineState.defaultNormalTextureView
-                : input.pipelineState.defaultWhiteTextureView,
-          },
-        },
-      ]).flat(),
-    ];
-    const materialEntries = assembleMaterialWithSkylightEntries(
-      baseEntries,
-      {
-        irradianceView: fallback.irradianceView,
-        irradianceSampler: fallback.sampler,
-        prefilterView: fallback.prefilterView,
-        prefilterSampler: fallback.sampler,
-        brdfLutView: fallback.brdfLutView,
-        brdfLutSampler: fallback.sampler,
-        intensityBuffer: fallback.intensityBuffer,
-      },
-      { sampler: fallback.sampler, backdropView: input.pipelineState.defaultWhiteTextureView },
-    );
-    const materialBindGroup = input.device.createBindGroup({
-      label: 'standard-pbr-gpu-driven-material-bg',
-      layout: input.pipelineState.materialBindGroupLayout,
-      entries: materialEntries,
-    });
-    if (!materialBindGroup.ok) return materialBindGroup;
-    const instancesBindGroup = input.device.createBindGroup({
-      label: 'standard-pbr-gpu-driven-identity-instances-bg',
-      layout: input.pipelineState.instancesBindGroupLayout,
-      entries: [
-        {
-          binding: 0,
-          resource: bufferBinding(input.pipelineState.identityInstanceBuffer),
-        },
-      ],
-    });
-    if (!instancesBindGroup.ok) return instancesBindGroup;
-    return ok(
-      new StandardPbrRasterAdapter(
-        input.device,
-        pipelineLayout,
-        input.pipelineState.meshBindGroupLayout,
-        module.value,
-        materialBindGroup.value,
-        instancesBindGroup.value,
-        input.artifact,
-      ),
-    );
+    this.stagedProjectionBindings.clear();
+    for (const [key, active] of this.projectionBindings) {
+      if (!keep.has(key)) {
+        this.projectionBindings.delete(key);
+        this.retireProjectionBuffer(active.buffer);
+      }
+    }
+    this.stagedProjectionKeys.clear();
+    this.activeProjectionRowsAtStage.clear();
   }
 
-  pipeline(
-    format: TextureFormat,
-    sampleCount: 1 | 4,
-    layoutProjection: MeshGpuHandles['layoutProjection'],
-    topology: GpuDrivenBatch['key']['topology'],
-    stripIndexFormat: 'uint16' | 'uint32' | undefined,
-    renderState: MaterialRenderState | undefined,
-  ): Result<RenderPipeline, RhiError> {
-    const projectedLayout = deriveVertexBufferLayoutFromProjection(
-      layoutProjection,
-      this.artifact.uvSetCount === undefined
-        ? undefined
-        : { shaderUvSetCount: this.artifact.uvSetCount },
-    )[0];
-    const vertexStride = projectedLayout?.arrayStride ?? layoutProjection.arrayStride;
-    const attributes = projectedLayout?.attributes ?? layoutProjection.attributes;
-    const key = `${format}|${sampleCount}|${vertexStride}|${topology}|${stripIndexFormat ?? ''}|${JSON.stringify(renderState ?? null)}|${this.artifact.layoutIdentity}`;
-    const cached = this.pipelines.get(key);
-    if (cached !== undefined) return ok(cached);
-    const pipeline = this.device.createRenderPipeline({
-      label: `standard-pbr-gpu-driven.${key}`,
-      layout: this.pipelineLayout,
-      vertex: {
-        module: this.module,
-        entryPoint: this.artifact.receipt?.sceneIndexEntry ?? 'vs_scene_index',
-        buffers: [
-          {
-            arrayStride: vertexStride,
-            stepMode: 'vertex',
-            attributes: attributes.map(({ shaderLocation, offset, format }) => ({
-              shaderLocation,
-              offset,
-              format: format as GPUVertexFormat,
-            })),
-          },
-        ],
-      },
-      fragment: {
-        module: this.module,
-        entryPoint: 'fs_main',
-        targets: [{ format }],
-      },
-      primitive: {
-        topology,
-        cullMode: renderState?.cullMode ?? 'back',
-        frontFace: renderState?.frontFace ?? 'ccw',
-        ...(stripIndexFormat === undefined ? {} : { stripIndexFormat }),
-      },
-      depthStencil: {
-        format: 'depth24plus-stencil8',
-        depthWriteEnabled: renderState?.depthWriteEnabled ?? true,
-        depthCompare: renderState?.depthCompare ?? 'less',
-      },
-      ...(sampleCount === 4 ? { multisample: { count: 4 } } : {}),
-    });
-    if (!pipeline.ok) return pipeline;
-    this.pipelines.set(key, pipeline.value);
-    return pipeline;
+  /** Discard resources created for an aborted graph while retaining LKG rows. */
+  abortProjectionBindings(): void {
+    for (const [key, rows] of this.activeProjectionRowsAtStage) {
+      const active = this.projectionBindings.get(key);
+      if (active === undefined) continue;
+      const restored = this.device.queue.writeBuffer(active.buffer, 0, rows);
+      if (restored.ok) active.rows = new Float32Array(rows);
+    }
+    for (const staged of this.stagedProjectionBindings.values()) {
+      this.retireProjectionBuffer(staged.buffer);
+    }
+    this.stagedProjectionBindings.clear();
+    this.stagedProjectionKeys.clear();
+    this.activeProjectionRowsAtStage.clear();
   }
 
-  projectionBindGroup(rows: Float32Array): Result<BindGroup, RhiError> {
+  private createProjectionBinding(
+    rows: Float32Array,
+    capacityBytes: number,
+  ): Result<
+    {
+      readonly buffer: Buffer;
+      readonly bindGroup: BindGroup;
+      readonly capacityBytes: number;
+      rows: Float32Array;
+    },
+    RhiError
+  > {
     const buffer = this.device.createBuffer({
       label: 'standard-pbr-gpu-driven-scene-meshes',
-      size: Math.max(MESH_SSBO_BYTES, rows.byteLength),
+      size: capacityBytes,
       usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST,
     });
     if (!buffer.ok) return buffer;
     const write = this.device.queue.writeBuffer(buffer.value, 0, rows);
-    if (!write.ok) return write;
-    this.projectionBuffers.push(buffer.value);
-    return this.device.createBindGroup({
+    if (!write.ok) {
+      this.destroyProjectionBuffer(buffer.value);
+      return write;
+    }
+    this.projectionBuffers.add(buffer.value);
+    const entries = [
+      { binding: 0, resource: bufferBinding(buffer.value, 0, capacityBytes) },
+      ...(this.deformation === 'skin' &&
+      this.paletteBuffer !== undefined &&
+      this.paletteBindingWindowBytes !== undefined
+        ? [
+            {
+              binding: 1,
+              // The scene-index second lane is a global palette row. Bind the
+              // complete arena so rows beyond the legacy 255-joint window
+              // remain addressable; the shader performs the row selection.
+              resource: bufferBinding(this.paletteBuffer),
+            },
+            {
+              binding: 2,
+              // The dedicated GPU-driven skin layout keeps the current /
+              // previous palette pair used by the direct skin layout. The
+              // scene-index shader currently reads the current arena, but
+              // the shared layout still requires a complete binding shape.
+              resource: bufferBinding(this.paletteBuffer),
+            },
+          ]
+        : []),
+    ];
+    const bindGroup = this.device.createBindGroup({
       label: 'standard-pbr-gpu-driven-scene-mesh-bg',
       layout: this.meshLayout,
-      entries: [{ binding: 0, resource: bufferBinding(buffer.value, 0, rows.byteLength) }],
+      entries,
+    });
+    if (!bindGroup.ok) {
+      this.destroyProjectionBuffer(buffer.value);
+      return bindGroup;
+    }
+    return ok({
+      buffer: buffer.value,
+      bindGroup: bindGroup.value,
+      capacityBytes,
+      rows: new Float32Array(rows),
     });
   }
 
+  private writeProjectionRows(
+    key: string,
+    binding: {
+      readonly buffer: Buffer;
+      readonly bindGroup: BindGroup;
+      readonly capacityBytes: number;
+      rows: Float32Array;
+    },
+    rows: Float32Array,
+  ): Result<void, RhiError> {
+    // Active bindings are the last-known-good graph resources. Keep one CPU
+    // snapshot so an aborted candidate can restore their exact contents
+    // without allocating a second GPU buffer on every stable frame.
+    if (
+      this.stagedProjectionBindings.get(key) === undefined &&
+      !this.activeProjectionRowsAtStage.has(key)
+    ) {
+      this.activeProjectionRowsAtStage.set(key, new Float32Array(binding.rows));
+    }
+    const write = this.device.queue.writeBuffer(binding.buffer, 0, rows);
+    if (!write.ok) return write;
+    binding.rows = new Float32Array(rows);
+    return ok(undefined);
+  }
+
   dispose(): void {
-    for (const buffer of this.projectionBuffers) this.device.destroyBuffer(buffer);
-    this.projectionBuffers.length = 0;
+    this.projectionDisposed = true;
+    for (const binding of this.projectionBindings.values()) {
+      this.destroyProjectionBuffer(binding.buffer);
+    }
+    for (const binding of this.stagedProjectionBindings.values()) {
+      this.destroyProjectionBuffer(binding.buffer);
+    }
+    for (const buffer of this.projectionBuffers) this.destroyProjectionBuffer(buffer);
+    for (const buffer of this.pendingProjectionRetirements) {
+      this.destroyProjectionBuffer(buffer);
+    }
+    this.projectionBindings.clear();
+    this.stagedProjectionBindings.clear();
+    this.activeProjectionRowsAtStage.clear();
+    this.projectionBuffers.clear();
+    this.pendingProjectionRetirements.clear();
+    this.device.destroyBuffer(this.instanceBuffer);
+  }
+
+  private retireProjectionBuffer(buffer: Buffer): void {
+    if (this.destroyedProjectionBuffers.has(buffer)) return;
+    this.projectionBuffers.delete(buffer);
+    if (this.projectionDisposed) {
+      this.destroyProjectionBuffer(buffer);
+      return;
+    }
+    if (!this.pendingProjectionRetirements.add(buffer)) return;
+    void this.device.queue.onSubmittedWorkDone().then(
+      () => {
+        this.pendingProjectionRetirements.delete(buffer);
+        this.destroyProjectionBuffer(buffer);
+      },
+      () => {
+        this.pendingProjectionRetirements.delete(buffer);
+        this.destroyProjectionBuffer(buffer);
+      },
+    );
   }
 
-  get frameGroups(): readonly [BindGroup, BindGroup] {
-    return [this.materialBindGroup, this.instancesBindGroup];
+  private destroyProjectionBuffer(buffer: Buffer): void {
+    if (this.destroyedProjectionBuffers.has(buffer)) return;
+    this.destroyedProjectionBuffers.add(buffer);
+    this.projectionBuffers.delete(buffer);
+    this.device.destroyBuffer(buffer);
+  }
+
+  get instancesFrameGroup(): BindGroup {
+    return this.instancesBindGroup;
+  }
+
+  get kind(): 'rigid' | 'skin' {
+    return this.deformation;
   }
 }
 
 export interface PreparedGpuDrivenFrame {
   readonly topologySignature: string;
-  readonly entityKeys: ReadonlySet<number>;
-  readonly ownsAllRenderables: boolean;
+  /** True when every source draw item/instance is claimed by the GPU lane. */
+  readonly ownsAllDrawItems: boolean;
+  /** True only when the extracted ShadowCaster channel is fully represented. */
+  readonly ownsAllShadowCasters?: boolean;
+  /** Concrete main-pass draw identities claimed by the GPU projection. */
+  readonly drawKeys?: ReadonlySet<string>;
+  readonly standardPbrFrameResources: GpuDrivenStandardPbrFrameResources;
   readonly occlusion?: OcclusionFrameProjection;
   /** @internal Commits a replacement generation only after graph promotion. */
   readonly _commitResourceReplacement: () => void;
+  /** @internal Retires superseded view buffers when graph compilation promotes them. */
+  readonly _commitGpuResourceReplacement?: () => void;
+  /** @internal Discards staged shadow cache publication after a failed frame. */
+  readonly _abortResourceReplacement?: () => void;
+  /** Concrete ShadowCaster keys claimed by the GPU subset for this frame. */
+  readonly shadowDrawKeys?: ReadonlySet<string>;
+  /** View-scoped ShadowCaster claims consumed by each shadow record pass. */
+  readonly shadowDrawKeysByView?: ReadonlyMap<string, ReadonlySet<string>>;
+  readonly projectShadow?: (
+    graph: RenderGraphBuilder<RenderPipelineFrame>,
+    identity: ShadowViewIdentity,
+  ) => Result<ShadowViewProjection | undefined, RenderGraphError>;
+  readonly updateShadowViews?: (
+    views: readonly Omit<ShadowViewUpdateInput, 'sourcePlan' | 'scene'>[],
+  ) => Result<void, RhiError>;
+  readonly shadowViewPool?: ShadowViewStatePool;
+  readonly shadowBatchProjections?: ReadonlyMap<
+    string,
+    ReadonlyMap<number, GpuDrivenShadowBatchProjection>
+  >;
   project(
     graph: RenderGraphBuilder<RenderPipelineFrame>,
     format: TextureFormat,
@@ -937,6 +1544,70 @@ export interface PreparedGpuDrivenFrame {
   ): Result<RenderPipelineGpuDrivenProjection, RenderGraphError | RhiError>;
 }
 
+/**
+ * Renderer-owned identity token for the validation that resolves renderable
+ * assets to GPU meshes. The token is deliberately narrower than a frame
+ * number: unchanged persistent scene snapshots can reuse the resolved rows,
+ * while a mesh/device/pipeline generation change forces a fresh producer read.
+ */
+export interface GpuDrivenResidencyValidationInput {
+  /** Opaque renderer-computed world/source identity and generation fence. */
+  readonly cacheKey: string;
+  readonly renderables: readonly RenderableSnapshot[];
+  readonly transparentDispatch: readonly DispatchEntry[];
+  readonly pipelineState: PipelineState;
+  readonly pipelineHandle: number;
+  readonly meshResidencyEpoch: number;
+  readonly deviceGeneration: number;
+  readonly assetCatalogEpoch: number;
+}
+
+interface GpuDrivenResidencyValidationCache extends GpuDrivenResidencyValidationInput {
+  readonly value: readonly ValidatedRenderable[];
+  readonly dispatchRenderableIndices: readonly (number | undefined)[];
+  readonly renderableIdentities: readonly RenderableSnapshot[];
+  readonly dispatchIdentities: readonly DispatchEntry[];
+}
+
+interface GpuDrivenCpuValidationTelemetryCache {
+  readonly cacheKey: string;
+  readonly validated: readonly { readonly source: RenderableSnapshot }[];
+  readonly gpuOwnedDrawKeys: ReadonlySet<string>;
+  readonly gpuOwnedDrawCount: number;
+  readonly totalDrawItems: number;
+  readonly gpuOwnedRows: number;
+  readonly cpuFallbackDrawItems: number;
+  readonly cpuSemanticFallbackDrawItems: number;
+  readonly cpuDeformationFallbackDrawItems: number;
+  readonly cpuDeformationReasons: ReadonlyMap<
+    'skin-bounds-missing' | 'skin-address-missing' | 'resource-not-ready',
+    number
+  >;
+  readonly blockedDrawItems: number;
+}
+
+function sameIdentitySequence<T extends object>(
+  expected: readonly T[],
+  actual: readonly T[],
+): boolean {
+  if (expected.length !== actual.length) return false;
+  for (let index = 0; index < expected.length; index += 1) {
+    if (expected[index] !== actual[index]) return false;
+  }
+  return true;
+}
+
+function sameDispatchRenderableIndices(
+  expected: readonly (number | undefined)[],
+  actual: readonly DispatchEntry[],
+): boolean {
+  if (expected.length !== actual.length) return false;
+  for (let index = 0; index < expected.length; index += 1) {
+    if (expected[index] !== actual[index]?.renderableIndex) return false;
+  }
+  return true;
+}
+
 export interface RecoveryCapabilityFacts {
   readonly generation: number;
   readonly shaderCompilation: boolean;
@@ -994,17 +1665,34 @@ export function classifyRecoveryCapability(
 export class GpuDrivenProduction {
   private disposed = false;
   private view: GpuDrivenView | undefined;
-  private raster: GpuDrivenRigidRaster | undefined;
   private standardRaster: StandardPbrRasterAdapter | undefined;
+  private skinRaster: StandardPbrRasterAdapter | undefined;
   private readonly sceneIdentities = new WeakMap<object, number>();
   private nextSceneIdentity = 1;
   private filteredCache:
     | {
         readonly source: SubmissionPlan;
+        readonly scene: PersistentGpuDrivenState['scene'];
+        readonly slots: PersistentGpuDrivenState['slots'];
+        readonly worldKeys: PersistentGpuDrivenState['worldKeys'];
         readonly meshResidencyEpoch: number;
         readonly lodProjectionFingerprint: string;
         readonly activeEntityRevision?: number;
         readonly activeEntityKeys?: ReadonlySet<number>;
+        readonly skinArtifact?: MaterialShaderArtifact;
+        readonly value: FilteredProductionPlan;
+      }
+    | undefined;
+  private shadowFilteredCache:
+    | {
+        readonly source: SubmissionPlan;
+        readonly scene: PersistentGpuDrivenState['scene'];
+        readonly slots: PersistentGpuDrivenState['slots'];
+        readonly worldKeys: PersistentGpuDrivenState['worldKeys'];
+        readonly lodProjectionFingerprint: string;
+        readonly meshResidencyEpoch: number;
+        readonly membership: string;
+        readonly skinArtifact?: MaterialShaderArtifact;
         readonly value: FilteredProductionPlan;
       }
     | undefined;
@@ -1014,13 +1702,62 @@ export class GpuDrivenProduction {
   private batchBindGroupCreates = 0;
   private validatedGpuOwnedRows = 0;
   private cpuFallbackDrawItems = 0;
+  private cpuSemanticFallbackDrawItems = 0;
+  private cpuDeformationFallbackDrawItems = 0;
+  private readonly cpuDeformationReasons = new Map<
+    'skin-bounds-missing' | 'skin-address-missing' | 'resource-not-ready',
+    number
+  >();
+  private blockedDrawItems = 0;
+  private preparationFailure: GpuDrivenPreparationFailureInspection | undefined;
+  private encodedIndirectDraws = 0;
   private telemetryPrepared = false;
   private telemetryCandidateCount = 0;
   private telemetryGeometryWork = 0;
   private telemetryRootGeometryWork = 0;
+  private telemetryOverflow = false;
   private indirectDrawCount = 0;
-  private sceneRowsRequired = true;
+  private gpuOwnedDrawItems = 0;
+  private mainTotalDrawItems = 0;
+  private lane: 'gpu' | 'cpu-semantic' | 'cpu-deformation' | 'blocked' = 'cpu-semantic';
+  private laneReason: GpuDrivenLaneReason = 'capability';
+  private submissionState: 'idle' | 'pending' | 'submitted' | 'aborted' = 'idle';
+  private retryCount = 0;
+  private lastKnownGoodGeneration: number | undefined;
+  private overflowRecoveryRequired = false;
+  private shadowViews: ShadowViewStatePool | undefined;
+  private shadowSourcePlan: SubmissionPlan | undefined;
+  private shadowScene: PersistentGpuDrivenState['scene'] | undefined;
+  private shadowBatchProjections = new Map<
+    string,
+    ReadonlyMap<number, GpuDrivenShadowBatchProjection>
+  >();
+  private shadowDrawKeysByView = new Map<string, ReadonlySet<string>>();
+  private shadowExpectedDrawKeys = new Set<string>();
+  private shadowBatchProjectionSource: SubmissionPlan | undefined;
+  private skinPaletteBuffer: Buffer | undefined;
+  private committedPaletteContentRevision: number | undefined;
   private standardPbrProjection: StandardPbrSceneProjection | undefined;
+  private committedProjectionSource:
+    | {
+        readonly filtered: FilteredProductionPlan;
+        readonly scene: PersistentGpuDrivenState['scene'];
+        readonly contentRevision: number;
+        readonly artifact: MaterialShaderArtifact;
+        readonly skinArtifact: MaterialShaderArtifact | undefined;
+      }
+    | undefined;
+  private validatedResidencyCache: GpuDrivenResidencyValidationCache | undefined;
+  private residencyValidationCacheHits = 0;
+  private residencyValidationScans = 0;
+  private cpuValidationTelemetryCache: GpuDrivenCpuValidationTelemetryCache | undefined;
+  private cpuValidationCacheHits = 0;
+  private cpuValidationScans = 0;
+  private structureMetrics: GpuDrivenStructureMetrics = {
+    worldEntitiesScanned: 0,
+    sceneTableUploadBytes: 0,
+    paletteUploadBytes: 0,
+  };
   private signatureCache:
     | {
         readonly filtered: FilteredProductionPlan;
@@ -1034,8 +1771,67 @@ export class GpuDrivenProduction {
   constructor(
     private readonly device: RhiDevice,
     private readonly shaderModuleFactory: PipelineBuilderShaderModuleFactory,
+    private readonly recoveryCount = 0,
   ) {}
 
+  /**
+   * Reuse the last producer-resolved residency rows when all source identity
+   * and generation fences still match. Renderables and dispatch entries are
+   * checked element-by-element as well as by their stable object identities so
+   * an accidental in-place mutation cannot reuse stale renderable indices.
+   */
+  reuseResidencyValidation(
+    input: GpuDrivenResidencyValidationInput,
+  ): readonly ValidatedRenderable[] | undefined {
+    const cached = this.validatedResidencyCache;
+    if (
+      cached === undefined ||
+      cached.cacheKey !== input.cacheKey ||
+      cached.pipelineState !== input.pipelineState ||
+      cached.pipelineState.device !== this.device ||
+      cached.pipelineHandle !== input.pipelineHandle ||
+      cached.meshResidencyEpoch !== input.meshResidencyEpoch ||
+      cached.deviceGeneration !== input.deviceGeneration ||
+      cached.assetCatalogEpoch !== input.assetCatalogEpoch ||
+      !sameIdentitySequence(cached.renderableIdentities, input.renderables) ||
+      !sameIdentitySequence(cached.dispatchIdentities, input.transparentDispatch) ||
+      !sameDispatchRenderableIndices(cached.dispatchRenderableIndices, input.transparentDispatch)
+    ) {
+      return undefined;
+    }
+    this.residencyValidationCacheHits += 1;
+    return cached.value;
+  }
+
+  /** Publish the producer-owned rows after a completed residency validation. */
+  rememberResidencyValidation(
+    input: GpuDrivenResidencyValidationInput,
+    value: readonly ValidatedRenderable[],
+  ): void {
+    this.validatedResidencyCache = {
+      ...input,
+      value,
+      renderableIdentities: input.renderables,
+      dispatchIdentities: input.transparentDispatch,
+      dispatchRenderableIndices: input.transparentDispatch.map((entry) => entry.renderableIndex),
+    };
+    this.residencyValidationScans += 1;
+  }
+
+  private applyCpuValidationTelemetry(cache: GpuDrivenCpuValidationTelemetryCache): void {
+    this.gpuOwnedDrawItems = cache.gpuOwnedDrawCount;
+    this.mainTotalDrawItems = cache.totalDrawItems;
+    this.validatedGpuOwnedRows = cache.gpuOwnedRows;
+    this.cpuFallbackDrawItems = cache.cpuFallbackDrawItems;
+    this.cpuSemanticFallbackDrawItems = cache.cpuSemanticFallbackDrawItems;
+    this.cpuDeformationFallbackDrawItems = cache.cpuDeformationFallbackDrawItems;
+    this.cpuDeformationReasons.clear();
+    for (const [reason, count] of cache.cpuDeformationReasons) {
+      this.cpuDeformationReasons.set(reason, count);
+    }
+    this.blockedDrawItems = cache.blockedDrawItems;
+  }
+
   static forDevice(
     device: RhiDevice,
     shaderModuleFactory: PipelineBuilderShaderModuleFactory,
@@ -1043,34 +1839,6 @@ export class GpuDrivenProduction {
     return new GpuDrivenProduction(device, shaderModuleFactory);
   }
 
-  /** Recovery has no frame retry: await generated programs before preparing the graph. */
-  static async forRecoveryDevice(
-    device: RhiDevice,
-    factory: PipelineBuilderShaderModuleFactory,
-    createShaderModule: (descriptor: {
-      code: string;
-      label?: string;
-    }) => Promise<Result<ShaderModule, RhiError>>,
-  ): Promise<Result<GpuDrivenProduction, RhiError>> {
-    const modules = new Map<string, ShaderModule>();
-    for (const descriptor of [
-      { label: 'gpu-driven-view', code: GPU_DRIVEN_VIEW_WGSL },
-      { label: 'gpu-driven-rigid-unlit', code: GPU_DRIVEN_RIGID_UNLIT_WGSL },
-    ]) {
-      const module = await createShaderModule(descriptor);
-      if (!module.ok) return module;
-      modules.set(descriptor.code, module.value);
-    }
-    return ok(
-      new GpuDrivenProduction(device, {
-        createShaderModule: (descriptor) => {
-          const module = modules.get(descriptor.code);
-          return module === undefined ? factory.createShaderModule(descriptor) : ok(module);
-        },
-      }),
-    );
-  }
-
   createRecoveryRoot(scope: DeviceScope): LifecycleResourceSpec<unknown> {
     return {
       kind: 'scene-table',
@@ -1088,10 +1856,20 @@ export class GpuDrivenProduction {
   prepare(input: {
     readonly scene: PersistentGpuDrivenState | undefined;
     readonly camera: CameraSnapshot;
-    readonly meshes: ReadonlyMap<number, MeshGpuHandles>;
+    /** GPU meshes projected by retained RenderScene slot, never raw asset handle. */
+    readonly meshBySlot: ReadonlyMap<number, MeshGpuHandles>;
     readonly viewBindGroupLayout: BindGroupLayout;
     readonly meshResidencyEpoch: number;
     readonly hdrp: boolean;
+    /** Cooked producer artifact selected from the frame material catalog. */
+    readonly standardPbrArtifact?: MaterialShaderArtifact;
+    /** Cooked producer artifact for the GPU skinning variant. */
+    readonly standardPbrSkinArtifact?: MaterialShaderArtifact;
+    readonly standardPbrPipelineState?: PipelineState;
+    /** Extracted ShadowCaster ownership keyed by concrete draw item and pass. */
+    readonly shadowCasterDrawKeys?: ReadonlySet<string>;
+    /** Structured ShadowCaster ownership facts for exact pass admission. */
+    readonly shadowCasterMembership?: readonly ShadowCasterMembership[];
     /** Entity keys admitted by the persistent visibility facet for this view. */
     readonly activeEntityKeys?: ReadonlySet<number>;
     /** Collision-free renderer-owned revision for the active visibility set. */
@@ -1099,20 +1877,37 @@ export class GpuDrivenProduction {
     /** Total extracted candidates, including facet-suppressed rows. */
     readonly telemetryCandidateCount?: number;
     readonly occlusion?: OcclusionFrameProjection;
-    /** Cooked producer artifact selected from the frame material catalog. */
-    readonly standardPbrArtifact?: MaterialShaderArtifact;
-    readonly standardPbrPipelineState?: PipelineState;
-  }): Result<PreparedGpuDrivenFrame | undefined, RhiError> {
+    /** Per-frame deltas from the existing RenderScene/GPU Scene/palette owners. */
+    readonly structureMetrics?: GpuDrivenStructureMetrics;
+  }): Result<PreparedGpuDrivenFrame | undefined, RhiError | GpuDrivenPreparationError> {
     this.gpuOwnedSnapshotsMaterialized = 0;
     this.filteredPlanBuilds = 0;
     this.batchBindGroupCreates = 0;
     this.validatedGpuOwnedRows = 0;
     this.cpuFallbackDrawItems = 0;
+    this.cpuSemanticFallbackDrawItems = 0;
+    this.cpuDeformationFallbackDrawItems = 0;
+    this.cpuDeformationReasons.clear();
+    this.blockedDrawItems = 0;
+    this.preparationFailure = undefined;
+    this.encodedIndirectDraws = 0;
     this.telemetryPrepared = false;
     this.telemetryCandidateCount = input.telemetryCandidateCount ?? 0;
     this.telemetryGeometryWork = 0;
     this.telemetryRootGeometryWork = 0;
+    this.telemetryOverflow = false;
     this.indirectDrawCount = 0;
+    this.gpuOwnedDrawItems = 0;
+    this.mainTotalDrawItems = 0;
+    this.structureMetrics = input.structureMetrics ?? {
+      worldEntitiesScanned: 0,
+      sceneTableUploadBytes: 0,
+      paletteUploadBytes: 0,
+    };
+    this.lane = 'cpu-semantic';
+    this.laneReason = input.hdrp ? 'unsupported' : 'capability';
+    this.submissionState = 'idle';
+    this.shadowExpectedDrawKeys = new Set();
     const capability = classifyRecoveryCapability({
       generation: 0,
       shaderCompilation: true,
@@ -1122,26 +1917,79 @@ export class GpuDrivenProduction {
       multisample: true,
     });
     if (
-      input.hdrp ||
       input.scene === undefined ||
-      capability.status === 'disabled' ||
-      selectGpuLodLane(this.device.caps) === 'cpu'
+      input.hdrp ||
+      selectGpuLodLane(this.device.caps) === 'cpu' ||
+      capability.status === 'disabled'
     ) {
       this.gpuOwnedEntityCount = 0;
-      this.sceneRowsRequired = false;
       return ok(undefined);
     }
+    if (this.overflowRecoveryRequired && this.view !== undefined) {
+      const recovered = this.view._recoverFromOverflow();
+      if (!recovered.ok) {
+        this.gpuOwnedEntityCount = 0;
+        this.lane = 'blocked';
+        this.laneReason = 'capacity';
+        return recovered;
+      }
+      this.overflowRecoveryRequired = false;
+    }
     const scene = input.scene;
-    const projectionFingerprint = lodProjectionFingerprint(input.camera);
-    // An empty filtered plan means this topology/mesh-residency pair has no
-    // renderables that this production lane can own. Camera and visibility
-    // inputs only affect admitted candidates and LOD selection, so they cannot
-    // turn that empty topology into an eligible one. Keep the negative result
-    // resident instead of rescanning every scene slot as the camera moves.
-    const cachedPlanIsTopologyInvariant = this.filteredCache?.value.topologyInvariantEmpty === true;
-    const cachedPlanIsCameraInvariant = cachedPlanIsTopologyInvariant;
+    const preparationFailure = nonCpuPreparationFailure(scene);
+    if (preparationFailure !== undefined) {
+      this.gpuOwnedEntityCount = 0;
+      // A capable candidate that cannot be prepared is a stopped promotion,
+      // not a CPU-semantic lane. Keep the concrete rejected draw count in the
+      // detached channel so an inspector can repair the producer and retry the
+      // same view-pass without guessing from an error string.
+      this.blockedDrawItems = preparationFailure.drawKeys.length;
+      this.mainTotalDrawItems = Math.max(
+        this.mainTotalDrawItems,
+        scene.plan.batches.reduce((total, batch) => total + batch.candidates.length, 0),
+      );
+      this.lane = 'blocked';
+      this.laneReason = 'resource-not-ready';
+      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) {
+      this.gpuOwnedEntityCount = 0;
+      this.laneReason = 'resource-not-ready';
+      if (sceneRequiresGpuDrivenArtifact(input.scene)) {
+        this.blockedDrawItems = input.scene.plan.batches.reduce(
+          (total, batch) => total + batch.candidates.length,
+          0,
+        );
+        this.mainTotalDrawItems = Math.max(this.mainTotalDrawItems, this.blockedDrawItems);
+        this.lane = 'blocked';
+        const failure =
+          standardArtifact === undefined
+            ? new GpuDrivenPreparationError('missing-material-receipt', {
+                reason: 'material-receipt-missing',
+                owner: 'material',
+                expected: 'producer-owned Standard PBR GPU-driven artifact',
+              })
+            : new GpuDrivenPreparationError('resource-not-ready', {
+                reason: 'material-resource-missing',
+                owner: 'material',
+                expected: 'producer-owned Standard PBR GPU-driven pipeline state',
+              });
+        this.preparationFailure = preparationFailureInspection(failure);
+        return err(failure);
+      }
+      return ok(undefined);
+    }
+    const projectionFingerprint =
+      this.filteredCache?.source === scene.plan &&
+      this.filteredCache.lodProjectionFingerprint === ''
+        ? ''
+        : lodProjectionFingerprint(scene.plan, input.camera, scene.slots);
     const cachedVisibilityMatches =
-      cachedPlanIsCameraInvariant || this.filteredCache === undefined
+      this.filteredCache === undefined
         ? true
         : input.activeEntityRevision !== undefined &&
             this.filteredCache.activeEntityRevision !== undefined
@@ -1151,22 +1999,30 @@ export class GpuDrivenProduction {
     if (
       filtered === undefined ||
       this.filteredCache?.source !== scene.plan ||
-      (!cachedPlanIsTopologyInvariant &&
-        this.filteredCache.meshResidencyEpoch !== input.meshResidencyEpoch) ||
-      (!cachedPlanIsCameraInvariant &&
-        this.filteredCache.lodProjectionFingerprint !== projectionFingerprint) ||
-      !cachedVisibilityMatches
+      this.filteredCache?.scene !== scene.scene ||
+      this.filteredCache?.slots !== scene.slots ||
+      this.filteredCache?.worldKeys !== scene.worldKeys ||
+      this.filteredCache.meshResidencyEpoch !== input.meshResidencyEpoch ||
+      this.filteredCache.lodProjectionFingerprint !== projectionFingerprint ||
+      !cachedVisibilityMatches ||
+      this.filteredCache.skinArtifact !== skinArtifact
     ) {
       filtered = filteredPlan(
         scene.plan,
         scene.slots,
-        input.meshes,
+        input.meshBySlot,
+        undefined,
+        skinArtifact,
+        undefined,
         input.camera,
         input.activeEntityKeys,
         scene.worldKeys,
       );
       this.filteredCache = {
         source: scene.plan,
+        scene: scene.scene,
+        slots: scene.slots,
+        worldKeys: scene.worldKeys,
         meshResidencyEpoch: input.meshResidencyEpoch,
         lodProjectionFingerprint: projectionFingerprint,
         ...(input.activeEntityRevision === undefined
@@ -1175,36 +2031,110 @@ export class GpuDrivenProduction {
         ...(input.activeEntityKeys === undefined
           ? {}
           : { activeEntityKeys: input.activeEntityKeys }),
+        ...(skinArtifact === undefined ? {} : { skinArtifact }),
         value: filtered,
       };
       this.gpuOwnedSnapshotsMaterialized = scene.slots.length;
       this.filteredPlanBuilds = 1;
     }
-    this.gpuOwnedEntityCount = filtered.entityKeys.size;
-    this.sceneRowsRequired = !filtered.topologyInvariantEmpty;
-    // Publish the command count from the current filtered plan on every
-    // prepare call. A cached graph does not call project() again on stable
-    // frames, so deriving this only while compiling the raster pass would
-    // transiently report zero after prepare() reset the per-frame counters.
+    this.gpuOwnedEntityCount = gpuDrawEntityCount(filtered.drawKeys);
     this.indirectDrawCount = admittedRasterBatchCount(filtered.plan);
-    if (filtered.batches.length === 0) return ok(undefined);
-    this.standardPbrProjection = undefined;
-    const usesStandardPbrRaster = filtered.batches.every(({ batch }) => isStandardPbrBatch(batch));
-    if (usesStandardPbrRaster && input.standardPbrArtifact !== undefined) {
+    if (filtered.batches.length === 0) {
+      this.laneReason = 'unsupported';
+      return ok(undefined);
+    }
+    this.lane = 'gpu';
+    this.laneReason = 'none';
+    this.submissionState = 'pending';
+    const shadowMembership = shadowCasterMembershipSignature(
+      input.shadowCasterDrawKeys,
+      input.shadowCasterMembership,
+    );
+    let shadowFiltered = this.shadowFilteredCache?.value;
+    if (
+      shadowFiltered === undefined ||
+      this.shadowFilteredCache?.source !== scene.plan ||
+      this.shadowFilteredCache.scene !== scene.scene ||
+      this.shadowFilteredCache.slots !== scene.slots ||
+      this.shadowFilteredCache.worldKeys !== scene.worldKeys ||
+      this.shadowFilteredCache.lodProjectionFingerprint !== projectionFingerprint ||
+      this.shadowFilteredCache.meshResidencyEpoch !== input.meshResidencyEpoch ||
+      this.shadowFilteredCache.membership !== shadowMembership ||
+      this.shadowFilteredCache.skinArtifact !== skinArtifact
+    ) {
+      const projectedShadowFiltered = filteredPlan(
+        scene.plan,
+        scene.slots,
+        input.meshBySlot,
+        input.shadowCasterDrawKeys,
+        skinArtifact,
+        input.shadowCasterMembership,
+        input.camera,
+        undefined,
+        scene.worldKeys,
+      );
+      shadowFiltered = projectedShadowFiltered;
+      this.shadowFilteredCache = {
+        source: scene.plan,
+        scene: scene.scene,
+        slots: scene.slots,
+        worldKeys: scene.worldKeys,
+        lodProjectionFingerprint: projectionFingerprint,
+        meshResidencyEpoch: input.meshResidencyEpoch,
+        membership: shadowMembership,
+        ...(skinArtifact === undefined ? {} : { skinArtifact }),
+        value: shadowFiltered,
+      };
+    }
+    this.shadowSourcePlan = shadowFiltered.plan;
+    this.shadowScene = scene.scene;
+    const shadowCasterKeys =
+      input.shadowCasterMembership === undefined
+        ? input.shadowCasterDrawKeys
+        : new Set(
+            input.shadowCasterMembership.map((membership) =>
+              gpuDrivenShadowDrawKey(
+                membership.worldEntity,
+                membership.materialHandle,
+                membership.drawItemIndex,
+                membership.passIndex,
+              ),
+            ),
+          );
+    this.shadowExpectedDrawKeys = new Set(shadowCasterKeys ?? []);
+    const ownsAllShadowCasters =
+      shadowCasterKeys === undefined ||
+      [...shadowCasterKeys].every((key) => shadowFiltered.shadowDrawKeys.has(key));
+    if (this.shadowViews === undefined) {
+      const created = ShadowViewStatePool.create({
+        device: this.device,
+        shaderModuleFactory: this.shaderModuleFactory,
+      });
+      if (!created.ok) return created;
+      this.shadowViews = created.value;
+    }
+    const projectionSource = {
+      filtered,
+      scene: scene.scene,
+      contentRevision: scene.scene.contentRevision,
+      artifact: standardArtifact,
+      skinArtifact,
+    };
+    const previousSource = this.committedProjectionSource;
+    const reuseProjectionRows =
+      previousSource?.filtered === filtered &&
+      previousSource.scene === scene.scene &&
+      previousSource.contentRevision === scene.scene.contentRevision &&
+      previousSource.artifact === standardArtifact &&
+      previousSource.skinArtifact === skinArtifact;
+    if (!reuseProjectionRows) {
       const slotsByPrimitive = new Map(scene.slots.map((slot) => [slot.slot, slot] as const));
       const projection = projectStandardPbrScene({
-        artifact: input.standardPbrArtifact,
+        artifact: standardArtifact,
         candidates: filtered.batches.flatMap(({ batch }) =>
           batch.candidates.flatMap((candidate) => {
             const slot = slotsByPrimitive.get(candidate.primitiveIndex);
-            return slot === undefined
-              ? []
-              : [
-                  {
-                    primitiveIndex: candidate.primitiveIndex,
-                    world: slot.snapshot.transform.world,
-                  },
-                ];
+            return slot === undefined ? [] : [sceneCandidate(slot, candidate)];
           }),
         ),
       });
@@ -1218,16 +2148,6 @@ export class GpuDrivenProduction {
         );
       }
       this.standardPbrProjection = projection.value;
-      if (input.standardPbrPipelineState !== undefined && this.standardRaster === undefined) {
-        const created = StandardPbrRasterAdapter.create({
-          device: this.device,
-          shaderModuleFactory: this.shaderModuleFactory,
-          pipelineState: input.standardPbrPipelineState,
-          artifact: input.standardPbrArtifact,
-        });
-        if (!created.ok) return created;
-        this.standardRaster = created.value;
-      }
     }
     if (this.view === undefined) {
       const created = GpuDrivenView.create({
@@ -1237,22 +2157,177 @@ export class GpuDrivenProduction {
       if (!created.ok) return created;
       this.view = created.value;
     }
-    if (this.raster === undefined) {
-      const created = GpuDrivenRigidRaster.create({
-        device: this.device,
-        shaderModuleFactory: this.shaderModuleFactory,
-        viewBindGroupLayout: input.viewBindGroupLayout,
-      });
-      if (!created.ok) return created;
-      this.raster = created.value;
-    }
     const updated = this.view.update(filtered.plan, scene.scene, activeFrustum(input.camera));
     if (!updated.ok) return updated;
     this.telemetryPrepared = true;
     const view = this.view;
-    const raster = this.raster;
+    const visibleBuffer = view.visibleBuffer;
+    if (visibleBuffer === undefined) {
+      return err(
+        new RhiError({
+          code: 'internal-error',
+          expected: 'GpuDrivenView visible buffer after update',
+          hint: 'keep the visible-index binding request on the updated GPU scene view',
+        }),
+      );
+    }
+    if (this.standardRaster === undefined) {
+      const created = StandardPbrRasterAdapter.create({
+        device: this.device,
+        pipelineState: standardPipelineState,
+        artifact: standardArtifact,
+        visibleBuffer,
+      });
+      if (!created.ok) return created;
+      this.standardRaster = created.value;
+    } else {
+      const rebound = this.standardRaster.ensureVisibleBuffer(visibleBuffer);
+      if (!rebound.ok) return rebound;
+    }
     const standardRaster = this.standardRaster;
-    const standardArtifact = input.standardPbrArtifact;
+    if (standardRaster === 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',
+        }),
+      );
+    }
+    const skinBatch = filtered.batches.find(
+      ({ batch }) => batch.candidates[0]?.prepared?.identity.deformation === 'skin',
+    );
+    if (skinBatch !== undefined) {
+      const skinSnapshot = scene.slots.find(
+        (slot) => slot.slot === skinBatch.batch.candidates[0]?.primitiveIndex,
+      )?.snapshot.skin;
+      const skinAllocator = standardPipelineState.skinPaletteAllocator;
+      if (
+        skinArtifact === undefined ||
+        skinSnapshot === undefined ||
+        skinAllocator === null ||
+        skinAllocator === undefined
+      ) {
+        return err(
+          new RhiError({
+            code: 'rhi-not-available',
+            expected: 'skinned Standard PBR artifact and persistent palette owner',
+            hint: 'keep missing skin producer resources on the CPU deformation path',
+          }),
+        );
+      }
+      if (this.skinRaster === undefined) {
+        const created = StandardPbrRasterAdapter.create({
+          device: this.device,
+          pipelineState: standardPipelineState,
+          artifact: skinArtifact,
+          visibleBuffer,
+          deformation: 'skin',
+          paletteBuffer: skinSnapshot.buffer,
+          paletteBindingWindowBytes: skinAllocator.bindingWindowBytes,
+        });
+        if (!created.ok) return created;
+        this.skinRaster = created.value;
+      } else {
+        const rebound = this.skinRaster.ensureVisibleBuffer(visibleBuffer);
+        if (!rebound.ok) return rebound;
+        const palette = this.skinRaster.ensurePaletteBuffer(
+          skinSnapshot.buffer,
+          skinAllocator.bindingWindowBytes,
+        );
+        if (!palette.ok) return palette;
+      }
+      if (this.skinPaletteBuffer !== skinSnapshot.buffer) {
+        this.skinPaletteBuffer = skinSnapshot.buffer;
+        this.shadowBatchProjections.clear();
+        this.shadowBatchProjectionSource = undefined;
+        this.shadowViews?.invalidate();
+      }
+    }
+    const skinRaster = this.skinRaster;
+    const shadowViewPool = this.shadowViews;
+    if (shadowViewPool === undefined) {
+      return err(
+        new RhiError({
+          code: 'internal-error',
+          expected: 'ShadowViewStatePool after GPU-driven preparation',
+          hint: 'publish view-keyed shadow state with the prepared frame',
+        }),
+      );
+    }
+    // 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;
+    if (paletteContentRevision !== this.committedPaletteContentRevision)
+      shadowViewPool.invalidate();
+    const abortProvisionalResources = (): void => {
+      standardRaster.abortProjectionBindings();
+      skinRaster?.abortProjectionBindings();
+      shadowViewPool._abortResourceReplacement();
+    };
+    // The render graph is cached by topology, while transforms are frame
+    // data. Refresh retained scene-row buffers here so a cached graph reads
+    // the current world matrices without forcing a topology rebuild.
+    let slotsByPrimitive: Map<number, PersistentGpuDrivenState['slots'][number]> | undefined;
+    const projectionSlot = (index: number) => {
+      slotsByPrimitive ??= new Map(scene.slots.map((slot) => [slot.slot, slot] as const));
+      return slotsByPrimitive.get(index);
+    };
+    // 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());
+    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;
+        if (raster !== undefined && artifact !== undefined)
+          raster.noteProjectionKey(gpuDrivenProjectionKey(prepared.batch, deformation, artifact));
+        continue;
+      }
+      const admittedCandidates = prepared.batch.candidates.filter(
+        (candidate) =>
+          (candidate as GpuDrivenCandidate & { readonly submitAdmission?: boolean })
+            .submitAdmission !== false,
+      );
+      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 projectionKey = gpuDrivenProjectionKey(prepared.batch, deformation, artifact);
+      raster.noteProjectionKey(projectionKey);
+      const candidates = admittedCandidates.flatMap((candidate) => {
+        const slot = projectionSlot(candidate.primitiveIndex);
+        return slot === undefined ? [] : [sceneCandidate(slot, candidate)];
+      });
+      const projection = projectStandardPbrScene({ artifact, candidates });
+      if (!projection.ok) {
+        abortProvisionalResources();
+        return err(
+          new RhiError({
+            code: 'shader-compile-failed',
+            expected: 'receipt-derived Standard PBR scene projection',
+            hint: 'keep the retained projection rows on the current material receipt',
+          }),
+        );
+      }
+      const refreshed = raster.refreshProjectionRows(projectionKey, projection.value.rows);
+      if (!refreshed.ok) {
+        abortProvisionalResources();
+        return refreshed;
+      }
+    }
+    // Bindings created by the graph projection below are provisional until
+    // the frame submits. A successful commit promotes exactly these keys and
+    // fence-retires any superseded batch generation; an abort keeps the last
+    // known-good active set and drops only staged bindings. Shadow view update
+    // adds its keyed projections to the same staged set.
+    if (this.shadowBatchProjectionSource !== shadowFiltered.plan) {
+      this.shadowBatchProjections.clear();
+      this.shadowBatchProjectionSource = shadowFiltered.plan;
+    }
     const sceneIdentity = this.sceneIdentity(scene.scene);
     const viewInspection = view.inspect();
     let signature = this.signatureCache?.value;
@@ -1272,13 +2347,24 @@ export class GpuDrivenProduction {
         batches: filtered.batches.map(({ batch, mesh }) => [
           batch.batchId,
           batch.generation,
-          batch.visibleCapacity,
           batch.visibleBase,
+          batch.visibleCapacity,
           batch.candidates.map((candidate) => [
             candidate.primitiveIndex,
             candidate.generation,
             candidate.instanceOrdinal,
           ]),
+          batch.candidates
+            .filter(
+              (candidate) =>
+                (candidate as GpuDrivenCandidate & { readonly submitAdmission?: boolean })
+                  .submitAdmission !== false,
+            )
+            .map((candidate) => [
+              candidate.primitiveIndex,
+              candidate.generation,
+              candidate.instanceOrdinal,
+            ]),
           mesh.vboBytes,
           mesh.iboBytes,
           mesh.indexFormat,
@@ -1286,7 +2372,6 @@ export class GpuDrivenProduction {
         ]),
         capacities: [
           viewInspection.candidateCapacity,
-          viewInspection.visibleBufferCapacity,
           viewInspection.batchCapacity,
           viewInspection.indirectCapacity,
         ],
@@ -1299,31 +2384,96 @@ export class GpuDrivenProduction {
         value: signature,
       };
     }
+    const shadowTopologySignature = () =>
+      this.shadowViews
+        ?.inspect()
+        .map(
+          (entry) =>
+            `${shadowViewIdentityKey(entry.identity)}:${entry.cache}:${entry.generation}:${entry.sourceRevision}:${entry.resourceGeneration}`,
+        )
+        .join('|') ?? '';
+    const production = this;
     return ok({
-      topologySignature: signature,
-      entityKeys: filtered.entityKeys,
-      ownsAllRenderables:
-        input.activeEntityKeys === undefined
-          ? filtered.entityKeys.size === scene.slots.length
-          : filtered.entityKeys.size === input.activeEntityKeys.size,
+      get topologySignature() {
+        const shadow = shadowTopologySignature();
+        return shadow.length === 0 ? signature : `${signature}|shadow=${shadow}`;
+      },
+      ownsAllDrawItems: filtered.ownsAllDrawItems,
       ...(input.occlusion === undefined ? {} : { occlusion: input.occlusion }),
-      _commitResourceReplacement: () => view._commitResourceReplacement(),
+      ownsAllShadowCasters,
+      drawKeys: filtered.drawKeys,
+      shadowDrawKeys: shadowFiltered.shadowDrawKeys,
+      get shadowDrawKeysByView() {
+        return new Map(production.shadowDrawKeysByView);
+      },
+      standardPbrFrameResources: {
+        materialBindGroups: [],
+        materialSlotIndicesByEntity: new Map(),
+        instancesBindGroup: standardRaster.instancesFrameGroup,
+        materialStride: 512,
+        sceneMaterialBuffer: scene.scene.materialBuffer,
+      },
+      _commitGpuResourceReplacement: () => {
+        view._commitResourceReplacement();
+      },
+      _commitResourceReplacement: () => {
+        view._commitResourceReplacement();
+        shadowViewPool._commitResourceReplacement();
+        standardRaster.commitProjectionBindings();
+        skinRaster?.commitProjectionBindings();
+        this.committedProjectionSource = projectionSource;
+        this.committedPaletteContentRevision = paletteContentRevision;
+        this.submissionState = 'submitted';
+        this.lastKnownGoodGeneration = view.inspect().resourceGeneration;
+      },
+      _abortResourceReplacement: () => {
+        shadowViewPool._abortResourceReplacement();
+        standardRaster.abortProjectionBindings();
+        skinRaster?.abortProjectionBindings();
+        this.committedProjectionSource = undefined;
+        this.submissionState = 'aborted';
+        this.retryCount += 1;
+      },
+      projectShadow: (graph, identity) => {
+        if (!shadowViewPool.isActive(identity) || shadowViewPool.submission(identity) === undefined)
+          return ok(undefined);
+        return shadowViewPool.project(graph, identity);
+      },
+      updateShadowViews: (views) =>
+        shadowFiltered.plan.batches.length > 0
+          ? this.updateShadowViews(
+              views,
+              standardArtifact,
+              skinArtifact,
+              shadowFiltered,
+              scene,
+              input.shadowCasterDrawKeys,
+              input.shadowCasterMembership,
+            )
+          : this.disableShadowViews(),
+      shadowViewPool,
+      get shadowBatchProjections() {
+        return new Map(
+          [...production.shadowBatchProjections].map(
+            ([key, projections]) => [key, new Map(projections)] as const,
+          ),
+        );
+      },
       project: (graph, format, sampleCount) => {
         this.indirectDrawCount = admittedRasterBatchCount(filtered.plan);
         const outputs = view.addPasses(graph);
         if (!outputs.ok) return outputs;
-        if (
-          usesStandardPbrRaster &&
-          standardRaster !== undefined &&
-          standardArtifact !== undefined
-        ) {
+        if (standardRaster !== undefined && standardArtifact !== undefined) {
           const standardProjected: Array<{
             readonly batch: GpuDrivenBatch;
             readonly mesh: MeshGpuHandles;
+            readonly materialEntityKey: number;
             readonly vertex: GraphBuffer;
             readonly index?: GraphBuffer;
             readonly pipeline: RenderPipeline;
             readonly meshBindGroup: BindGroup;
+            readonly raster: StandardPbrRasterAdapter;
+            readonly deformation: 'rigid' | 'skin';
           }> = [];
           const standardAccesses: GraphAccess[] = [
             { resource: outputs.value.primitive, usage: 'storage-read' },
@@ -1333,25 +2483,41 @@ export class GpuDrivenProduction {
             { resource: outputs.value.transform, usage: 'storage-read' },
             { resource: outputs.value.indirect, usage: 'indirect-read' },
           ];
-          const slotsByPrimitive = new Map(scene.slots.map((slot) => [slot.slot, slot] as const));
           const meshBuffers = new Map<
-            number,
+            MeshGpuHandles,
             { readonly vertex: GraphBuffer; readonly index?: GraphBuffer }
           >();
           for (const prepared of filtered.batches) {
-            const candidates = prepared.batch.candidates.flatMap((candidate) => {
-              const slot = slotsByPrimitive.get(candidate.primitiveIndex);
-              return slot === undefined
-                ? []
-                : [
-                    {
-                      primitiveIndex: candidate.primitiveIndex,
-                      world: slot.snapshot.transform.world,
-                    },
-                  ];
+            if (prepared.batch.visibleCapacity === 0) continue;
+            const admittedCandidates = prepared.batch.candidates.filter(
+              (candidate) =>
+                (candidate as GpuDrivenCandidate & { readonly submitAdmission?: boolean })
+                  .submitAdmission !== false,
+            );
+            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) {
+              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',
+                }),
+              );
+            }
+            // The visible stream is compacted after the persistent visibility
+            // facet applies its active-entity admission. Project the mesh rows
+            // from that same admitted sequence so visible.x remains the
+            // batch-local row identity even when a suppressed candidate sits
+            // between two submitted candidates.
+            const candidates = admittedCandidates.flatMap((candidate) => {
+              const slot = projectionSlot(candidate.primitiveIndex);
+              return slot === undefined ? [] : [sceneCandidate(slot, candidate)];
             });
             const projection = projectStandardPbrScene({
-              artifact: standardArtifact,
+              artifact,
               candidates,
             });
             if (!projection.ok) {
@@ -1363,12 +2529,26 @@ export class GpuDrivenProduction {
                 }),
               );
             }
-            const meshBindGroup = standardRaster.projectionBindGroup(projection.value.rows);
+            const meshBindGroup = raster.projectionBindGroup(
+              projection.value.rows,
+              gpuDrivenProjectionKey(prepared.batch, deformation, artifact),
+              prepared.batch.candidates.length,
+            );
             if (!meshBindGroup.ok) return meshBindGroup;
-            let buffers = meshBuffers.get(prepared.batch.key.assetHandle);
+            const materialSlot = projectionSlot(admittedCandidates[0]?.primitiveIndex ?? -1);
+            if (materialSlot === undefined) {
+              return err(
+                new RhiError({
+                  code: 'internal-error',
+                  expected: 'batch representative entity for global material slot projection',
+                  hint: 'preserve the retained scene identity when projecting the GPU batch',
+                }),
+              );
+            }
+            let buffers = meshBuffers.get(prepared.mesh);
             if (buffers === undefined) {
               const vertex = graph.importBuffer(
-                `gpu-driven.standard.${prepared.batch.key.assetHandle}.vertex`,
+                `gpu-driven.standard.${prepared.worldKey}.${prepared.batch.key.assetHandle}.vertex`,
                 {
                   size: prepared.mesh.vboBytes,
                   usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST,
@@ -1380,7 +2560,7 @@ export class GpuDrivenProduction {
               if (prepared.mesh.indexBuffer !== null) {
                 const indexHandle = prepared.mesh.indexBuffer;
                 const imported = graph.importBuffer(
-                  `gpu-driven.standard.${prepared.batch.key.assetHandle}.index`,
+                  `gpu-driven.standard.${prepared.worldKey}.${prepared.batch.key.assetHandle}.index`,
                   {
                     size: prepared.mesh.iboBytes,
                     usage: GPU_BUFFER_USAGE_INDEX | GPU_BUFFER_USAGE_COPY_DST,
@@ -1391,16 +2571,17 @@ export class GpuDrivenProduction {
                 index = imported.value;
               }
               buffers = { vertex: vertex.value, ...(index === undefined ? {} : { index }) };
-              meshBuffers.set(prepared.batch.key.assetHandle, buffers);
+              meshBuffers.set(prepared.mesh, buffers);
               standardAccesses.push({ resource: buffers.vertex, usage: 'vertex-read' });
               if (buffers.index !== undefined) {
                 standardAccesses.push({ resource: buffers.index, usage: 'index-read' });
               }
             }
-            const pipeline = standardRaster.pipeline(
+            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' ||
@@ -1413,31 +2594,89 @@ export class GpuDrivenProduction {
             standardProjected.push({
               batch: prepared.batch,
               mesh: prepared.mesh,
+              materialEntityKey: worldEntityKey(
+                materialSlot.snapshot.worldId,
+                materialSlot.snapshot.entityKey,
+              ),
               ...buffers,
               pipeline: pipeline.value,
               meshBindGroup: meshBindGroup.value,
+              raster,
+              deformation,
             });
           }
-          const [materialBindGroup, instancesBindGroup] = standardRaster.frameGroups;
+          if (
+            standardProjected.length === 0 ||
+            standardProjected.length !== filtered.batches.length
+          ) {
+            return err(
+              new RhiError({
+                code: 'internal-error',
+                expected: 'one actual Standard PBR raster dispatch for each eligible batch',
+                hint: 'repair the receipt-backed batch projection before encoding the frame',
+              }),
+            );
+          }
+          const rasterDispatches = Object.freeze(standardProjected);
           return ok({
             accesses: standardAccesses,
-            encode: (viewBindGroup, pass, resources: GraphResourceResolver) => {
-              // pbr-view-bgl has two dynamic uniform bindings: the frame view
-              // slot and the optional Points/Lines style slot.  Standard
-              // draws do not use the latter, but WebGPU still requires one
-              // offset per dynamic binding.
+            encode: (
+              viewBindGroup,
+              pass,
+              resources: GraphResourceResolver,
+              frameResources: GpuDrivenStandardPbrFrameResources,
+            ) => {
+              // The shared Standard view BGL carries two dynamic buffers:
+              // the frame view UBO and the per-frame shadow/light table. GPU
+              // indirect draws use the same zero offsets as direct draws;
+              // supplying only one offset makes Dawn reject the command
+              // buffer before the indirect work can reach the rasterizer.
               pass.setBindGroup(0, viewBindGroup, [0, 0]);
-              pass.setBindGroup(1, materialBindGroup, [0]);
-              pass.setBindGroup(3, instancesBindGroup);
               let currentPipeline: RenderPipeline | undefined;
               let currentVertex: GraphBuffer | undefined;
               let currentIndex: GraphBuffer | undefined;
-              for (const batch of standardProjected) {
+              for (const batch of rasterDispatches) {
                 if (currentPipeline !== batch.pipeline) {
                   pass.setPipeline(batch.pipeline);
                   currentPipeline = batch.pipeline;
                 }
-                pass.setBindGroup(2, batch.meshBindGroup, [0]);
+                const globalMaterialSlots = frameResources.materialSlotIndicesByEntity.get(
+                  batch.materialEntityKey,
+                );
+                const globalMaterialSlot =
+                  globalMaterialSlots?.[batch.batch.key.materialSlot] ??
+                  (frameResources.materialSlotIndicesByEntity.size === 0
+                    ? batch.batch.key.materialSlot
+                    : undefined);
+                if (globalMaterialSlot === undefined) {
+                  throw new RhiError({
+                    code: 'rhi-not-available',
+                    expected: `frame-global material slot for entity ${batch.materialEntityKey}`,
+                    hint: 'populate materialSlotIndicesByEntity from the main-pass material producer',
+                  });
+                }
+                const materialBindGroup = frameResources.materialBindGroups[globalMaterialSlot];
+                if (materialBindGroup === undefined) {
+                  throw new RhiError({
+                    code: 'rhi-not-available',
+                    expected: `material bind group for global slot ${globalMaterialSlot}`,
+                    hint: 'keep GPU-driven material selection on the main-pass producer contract',
+                  });
+                }
+                pass.setBindGroup(1, materialBindGroup, [
+                  globalMaterialSlot * frameResources.materialStride,
+                ]);
+                pass.setBindGroup(
+                  2,
+                  batch.meshBindGroup,
+                  batch.deformation === 'skin' ? [0, 0, 0] : [0],
+                );
+                const visibleWindow = batch.raster.visibleWindowBindGroup(
+                  batch.batch.visibleBase,
+                  batch.batch.visibleCapacity,
+                );
+                if (!visibleWindow.ok) throw visibleWindow.error;
+                pass.setBindGroup(3, visibleWindow.value);
                 if (currentVertex !== batch.vertex) {
                   const vertex = resources.buffer(batch.vertex);
                   if (!vertex.ok) throw vertex.error;
@@ -1457,129 +2696,222 @@ export class GpuDrivenProduction {
                 } else {
                   pass.drawIndirect(indirect.value, batch.batch.indirectOffset);
                 }
+                this.encodedIndirectDraws += 1;
               }
             },
           });
         }
-        const projected: ProjectedBatch[] = [];
-        const accesses: GraphAccess[] = [
-          { resource: outputs.value.primitive, usage: 'storage-read' },
-          { resource: outputs.value.instance, usage: 'storage-read' },
-          { resource: outputs.value.material, usage: 'storage-read' },
-          { resource: outputs.value.visible, usage: 'storage-read' },
-          { resource: outputs.value.transform, usage: 'storage-read' },
-          { resource: outputs.value.indirect, usage: 'indirect-read' },
-        ];
-        const meshBuffers = new Map<
-          number,
-          { readonly vertex: GraphBuffer; readonly index?: GraphBuffer }
-        >();
-        for (const prepared of filtered.batches) {
-          // A selector-only batch can have zero admitted candidates. Keep it
-          // in the GPU selector and readback counters, but do not create a
-          // raster bind group or encode a zero-instance indirect draw.
-          if (prepared.batch.visibleCapacity === 0) continue;
-          let buffers = meshBuffers.get(prepared.batch.key.assetHandle);
-          if (buffers === undefined) {
-            const vertex = graph.importBuffer(
-              `gpu-driven.mesh.${prepared.batch.key.assetHandle}.vertex`,
-              {
-                size: prepared.mesh.vboBytes,
-                usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST,
-              },
-              () => prepared.mesh.vertexBuffer.handle,
+        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',
+          }),
+        );
+      },
+    });
+  }
+
+  updateShadowViews(
+    views: readonly Omit<ShadowViewUpdateInput, 'sourcePlan' | 'scene'>[],
+    artifact: MaterialShaderArtifact,
+    skinArtifact: MaterialShaderArtifact | undefined,
+    filtered: FilteredProductionPlan,
+    scene: PersistentGpuDrivenState,
+    shadowCasterDrawKeys: ReadonlySet<string> | undefined,
+    shadowCasterMembership: readonly ShadowCasterMembership[] | undefined,
+  ): Result<void, RhiError> {
+    if (
+      this.shadowViews === undefined ||
+      this.shadowSourcePlan === undefined ||
+      this.shadowScene === undefined
+    ) {
+      return ok(undefined);
+    }
+    const nextProjections = new Map<string, ReadonlyMap<number, GpuDrivenShadowBatchProjection>>();
+    const nextShadowDrawKeysByView = new Map<string, ReadonlySet<string>>();
+    const standardRaster = this.standardRaster;
+    if (standardRaster === 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',
+        }),
+      );
+    }
+    let slotsByPrimitive: Map<number, PersistentGpuDrivenState['slots'][number]> | undefined;
+    const preparedByBatch = new Map(filtered.batches.map((entry) => [entry.batch.batchId, entry]));
+    for (const input of views) {
+      const updated = this.shadowViews.update({
+        ...input,
+        sourcePlan: this.shadowSourcePlan,
+        scene: this.shadowScene,
+      });
+      if (!updated.ok) return updated;
+      const identityKey = shadowViewIdentityKey(input.identity);
+      const previousProjections = this.shadowBatchProjections.get(identityKey);
+      const previousClaims = this.shadowDrawKeysByView.get(identityKey);
+      if (
+        updated.value.cache === 'hit' &&
+        previousProjections !== undefined &&
+        previousClaims !== undefined
+      ) {
+        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) {
+            raster.noteProjectionKey(
+              gpuDrivenShadowProjectionKey(identityKey, batch, deformation, batchArtifact),
             );
-            if (!vertex.ok) return vertex;
-            let index: GraphBuffer | undefined;
-            const indexHandle = prepared.mesh.indexBuffer;
-            if (indexHandle !== null) {
-              const imported = graph.importBuffer(
-                `gpu-driven.mesh.${prepared.batch.key.assetHandle}.index`,
-                {
-                  size: prepared.mesh.iboBytes,
-                  usage: GPU_BUFFER_USAGE_INDEX | GPU_BUFFER_USAGE_COPY_DST,
-                },
-                () => indexHandle.handle,
-              );
-              if (!imported.ok) return imported;
-              index = imported.value;
-            }
-            buffers = { vertex: vertex.value, ...(index === undefined ? {} : { index }) };
-            meshBuffers.set(prepared.batch.key.assetHandle, buffers);
-            accesses.push({ resource: buffers.vertex, usage: 'vertex-read' });
-            if (buffers.index !== undefined) {
-              accesses.push({ resource: buffers.index, usage: 'index-read' });
-            }
           }
-          const pipeline = raster.pipeline(
-            format,
-            sampleCount,
-            prepared.mesh.layoutProjection.arrayStride,
-            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,
+        }
+        nextProjections.set(identityKey, previousProjections);
+        continue;
+      }
+      slotsByPrimitive ??= new Map(scene.slots.map((slot) => [slot.slot, slot] as const));
+      const viewClaimedKeys = new Set<string>();
+      for (const batch of updated.value.plan.batches) {
+        for (const candidate of batch.candidates) {
+          const slot = slotsByPrimitive?.get(candidate.primitiveIndex);
+          if (slot === undefined) continue;
+          if (
+            !shadowMembershipIsGpuCompatible(
+              slot,
+              candidate,
+              shadowCasterDrawKeys,
+              shadowCasterMembership,
+            )
+          ) {
+            continue;
+          }
+          for (const key of shadowKeysForCandidate(
+            slot,
+            candidate,
+            shadowCasterDrawKeys,
+            shadowCasterMembership,
+          )) {
+            if (filtered.shadowDrawKeys.has(key)) viewClaimedKeys.add(key);
+          }
+        }
+      }
+      nextShadowDrawKeysByView.set(identityKey, Object.freeze(viewClaimedKeys));
+      const submission = this.shadowViews.submission(input.identity);
+      const visibleBuffer = submission?.view.visibleBuffer;
+      if (submission === undefined || visibleBuffer === undefined) {
+        return err(
+          new RhiError({
+            code: 'internal-error',
+            expected: 'shadow view visible buffer after update',
+            hint: 'publish the per-view visible window before recording indirect shadow draws',
+          }),
+        );
+      }
+      const projections = new Map<number, GpuDrivenShadowBatchProjection>();
+      for (const batch of submission.plan.batches) {
+        const prepared = preparedByBatch.get(batch.batchId);
+        if (prepared === undefined) {
+          return err(
+            new RhiError({
+              code: 'internal-error',
+              expected: `prepared shadow mesh batch ${batch.batchId}`,
+              hint: 'keep filtered shadow topology and per-view projection on one frame identity',
+            }),
           );
-          if (!pipeline.ok) return pipeline;
-          const bindings = raster.bindGroup(scene.scene, view, prepared.batch);
-          if (!bindings.ok) return bindings;
-          this.batchBindGroupCreates += 1;
-          projected.push({
-            ...prepared,
-            ...buffers,
-            pipeline: pipeline.value,
-            bindings: bindings.value,
-          });
         }
-        this.indirectDrawCount = projected.length;
-        return ok({
-          accesses,
-          encode: (viewBindGroup, pass, resources: GraphResourceResolver) => {
-            // pbr-view-bgl carries the vertex-only Points/Lines UBO at binding
-            // 10 as a dynamic uniform buffer.  The production view group is
-            // shared by the GPU-driven raster pipeline, so even rigid draws
-            // must provide the binding-10 offset (zero selects the frame
-            // default slot).
-            pass.setBindGroup(0, viewBindGroup, [0, 0]);
-            let currentPipeline: RenderPipeline | undefined;
-            let currentVertex: GraphBuffer | undefined;
-            let currentIndex: GraphBuffer | undefined;
-            for (const batch of projected) {
-              if (currentPipeline !== batch.pipeline) {
-                pass.setPipeline(batch.pipeline);
-                currentPipeline = batch.pipeline;
-              }
-              pass.setBindGroup(1, batch.bindings);
-              if (currentVertex !== batch.vertex) {
-                const vertex = resources.buffer(batch.vertex);
-                if (!vertex.ok) throw vertex.error;
-                pass.setVertexBuffer(0, vertex.value);
-                currentVertex = batch.vertex;
-              }
-              if (batch.index !== undefined && currentIndex !== batch.index) {
-                const index = resources.buffer(batch.index);
-                if (!index.ok) throw index.error;
-                pass.setIndexBuffer(index.value, batch.mesh.indexFormat);
-                currentIndex = batch.index;
-              }
-              const indirect = resources.buffer(outputs.value.indirect);
-              if (!indirect.ok) throw indirect.error;
-              const draw = (): void => {
-                if (batch.batch.key.drawKind === 'indexed') {
-                  pass.drawIndexedIndirect(indirect.value, batch.batch.indirectOffset);
-                } else {
-                  pass.drawIndirect(indirect.value, batch.batch.indirectOffset);
-                }
-              };
-              draw();
-            }
-          },
+        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) {
+          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',
+            }),
+          );
+        }
+        const candidates = batch.candidates.flatMap((candidate) => {
+          const slot = slotsByPrimitive?.get(candidate.primitiveIndex);
+          if (slot === undefined) return [];
+          const materialIndex = scene.scene.materialIndexForSlot(
+            candidate.primitiveIndex,
+            batch.key.materialSlot,
+          );
+          return [sceneCandidate(slot, candidate, materialIndex)];
         });
-      },
-    });
+        const projected = projectStandardPbrScene({ artifact: batchArtifact, 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',
+            }),
+          );
+        }
+        const projectionKey = gpuDrivenShadowProjectionKey(
+          identityKey,
+          batch,
+          deformation,
+          batchArtifact,
+        );
+        raster.noteProjectionKey(projectionKey);
+        const meshBindGroup = raster.projectionBindGroup(
+          projected.value.rows,
+          projectionKey,
+          batch.candidates.length,
+        );
+        if (!meshBindGroup.ok) return meshBindGroup;
+        const visibleBindGroup = raster.visibleWindowBindGroupForBuffer(
+          visibleBuffer,
+          batch.visibleBase,
+          batch.visibleCapacity,
+        );
+        if (!visibleBindGroup.ok) return visibleBindGroup;
+        const firstCandidate = batch.candidates[0];
+        const firstSlot =
+          firstCandidate === undefined
+            ? undefined
+            : slotsByPrimitive.get(firstCandidate.primitiveIndex);
+        const material =
+          firstSlot?.snapshot.materials[batch.key.materialSlot] ?? firstSlot?.snapshot.material;
+        if (firstSlot === undefined || material === undefined) {
+          return err(
+            new RhiError({
+              code: 'internal-error',
+              expected: `material snapshot for shadow batch ${batch.batchId}`,
+              hint: 'keep the GPU-driven shadow material projection aligned with the retained slot',
+            }),
+          );
+        }
+        projections.set(batch.batchId, {
+          mesh: prepared.mesh,
+          meshBindGroup: meshBindGroup.value,
+          visibleBindGroup: visibleBindGroup.value,
+          deformation,
+          material,
+          materialEntityKey: worldEntityKey(
+            firstSlot.snapshot.worldId,
+            firstSlot.snapshot.entityKey,
+          ),
+        });
+      }
+      nextProjections.set(identityKey, projections);
+    }
+    this.shadowViews.retain(views.map((input) => input.identity));
+    this.shadowBatchProjections = nextProjections;
+    this.shadowDrawKeysByView = nextShadowDrawKeysByView;
+    return ok(undefined);
+  }
+
+  private disableShadowViews(): Result<void, RhiError> {
+    this.shadowViews?.retain([]);
+    this.shadowBatchProjections = new Map();
+    this.shadowDrawKeysByView = new Map();
+    return ok(undefined);
   }
 
   dispose(): void {
@@ -1587,20 +2919,141 @@ export class GpuDrivenProduction {
     this.disposed = true;
     this.view?.dispose();
     this.view = undefined;
-    this.raster = undefined;
+    this.standardRaster?.dispose();
+    this.standardRaster = undefined;
+    this.committedProjectionSource = undefined;
+    this.skinRaster?.dispose();
+    this.skinRaster = undefined;
     this.filteredCache = undefined;
     this.signatureCache = undefined;
-    this.sceneRowsRequired = true;
-  }
-
-  /** Whether the current production topology can consume GPU Scene row updates. */
-  requiresSceneRows(): boolean {
-    return this.sceneRowsRequired;
+    this.validatedResidencyCache = undefined;
+    this.cpuValidationTelemetryCache = undefined;
+    this.shadowViews?.dispose();
+    this.shadowViews = undefined;
+    this.shadowSourcePlan = undefined;
+    this.shadowScene = undefined;
+    this.shadowBatchProjections = new Map();
+    this.shadowDrawKeysByView = new Map();
+    this.shadowExpectedDrawKeys = new Set();
+    this.shadowBatchProjectionSource = undefined;
+    this.skinPaletteBuffer = undefined;
+    this.committedPaletteContentRevision = undefined;
+    this.preparationFailure = undefined;
+    this.overflowRecoveryRequired = false;
   }
 
   inspect(): GpuDrivenProductionInspection {
     const view = this.view?.inspect();
+    const channels: GpuDrivenLaneSummary[] = [];
+    const mainTotalDrawCount = this.mainTotalDrawItems;
+    const mainClaimedDrawCount = this.telemetryOverflow
+      ? 0
+      : Math.min(this.gpuOwnedDrawItems, mainTotalDrawCount);
+    const mainResidualDrawCount = Math.max(0, mainTotalDrawCount - mainClaimedDrawCount);
+    const mainFacts = {
+      totalDrawCount: mainTotalDrawCount,
+      claimedDrawCount: mainClaimedDrawCount,
+      residualDrawCount: mainResidualDrawCount,
+    };
+    if (mainClaimedDrawCount > 0 || (this.lane !== 'gpu' && this.lane !== 'blocked')) {
+      channels.push({
+        viewPass: 'main',
+        viewIndex: 0,
+        lane: this.lane,
+        reason: this.laneReason,
+        drawCount: mainClaimedDrawCount,
+        ...mainFacts,
+      });
+    }
+    if (this.cpuSemanticFallbackDrawItems > 0) {
+      channels.push({
+        viewPass: 'main',
+        viewIndex: 0,
+        lane: 'cpu-semantic',
+        reason: 'unsupported',
+        drawCount: this.cpuSemanticFallbackDrawItems,
+        ...mainFacts,
+      });
+    }
+    if (this.cpuDeformationFallbackDrawItems > 0) {
+      const reasons =
+        this.cpuDeformationReasons.size === 0
+          ? ([['resource-not-ready', this.cpuDeformationFallbackDrawItems]] as const)
+          : this.cpuDeformationReasons.entries();
+      for (const [reason, drawCount] of reasons) {
+        channels.push({
+          viewPass: 'main',
+          viewIndex: 0,
+          lane: 'cpu-deformation',
+          reason,
+          drawCount,
+          ...mainFacts,
+        });
+      }
+    }
+    if (this.blockedDrawItems > 0) {
+      channels.push({
+        viewPass: 'main',
+        viewIndex: 0,
+        lane: 'blocked',
+        reason: 'resource-not-ready',
+        drawCount: this.blockedDrawItems,
+        ...mainFacts,
+        ...(this.preparationFailure === undefined ? {} : { failure: this.preparationFailure }),
+      });
+    }
+    for (const entry of this.shadowViews?.inspect() ?? []) {
+      // Retained view resources outlive admission. An idle frame has no
+      // current GPU projection and must not publish last frame's channels.
+      if (this.submissionState === 'idle' || channels.length >= 32) break;
+      const key = shadowViewIdentityKey(entry.identity);
+      const claimed = this.shadowDrawKeysByView.get(key)?.size ?? 0;
+      const total = Math.max(this.shadowExpectedDrawKeys.size, claimed);
+      const effectiveClaimed = this.telemetryOverflow ? 0 : Math.min(claimed, total);
+      const residual = Math.max(0, total - effectiveClaimed);
+      if (total === 0) continue;
+      const projected = this.shadowBatchProjections.has(key) && entry.batchCount > 0;
+      const viewPass =
+        entry.identity.kind === 'directional'
+          ? 'directional-shadow'
+          : entry.identity.kind === 'point'
+            ? 'point-shadow'
+            : 'spot-shadow';
+      if (projected && effectiveClaimed > 0) {
+        channels.push({
+          viewPass,
+          viewIndex: entry.identity.index,
+          ...(entry.identity.face === undefined ? {} : { face: entry.identity.face }),
+          lane: this.telemetryOverflow ? 'blocked' : 'gpu',
+          reason: this.telemetryOverflow ? 'overflow' : 'none',
+          drawCount: effectiveClaimed,
+          totalDrawCount: total,
+          claimedDrawCount: effectiveClaimed,
+          residualDrawCount: residual,
+        });
+      }
+      if (residual > 0) {
+        const failure = shadowOwnershipFailureInspection(viewPass);
+        channels.push({
+          viewPass,
+          viewIndex: entry.identity.index,
+          ...(entry.identity.face === undefined ? {} : { face: entry.identity.face }),
+          lane: 'blocked',
+          reason: this.telemetryOverflow ? 'overflow' : 'shadow-ownership',
+          drawCount: residual,
+          totalDrawCount: total,
+          claimedDrawCount: effectiveClaimed,
+          residualDrawCount: residual,
+          failure,
+        });
+      }
+    }
     return {
+      residencyValidationScans: this.residencyValidationScans,
+      residencyValidationCacheHits: this.residencyValidationCacheHits,
+      cpuValidationScans: this.cpuValidationScans,
+      cpuValidationCacheHits: this.cpuValidationCacheHits,
+      ...this.structureMetrics,
       gpuOwnedSnapshotsMaterialized: this.gpuOwnedSnapshotsMaterialized,
       filteredPlanBuilds: this.filteredPlanBuilds,
       gpuOwnedEntityCount: this.gpuOwnedEntityCount,
@@ -1620,19 +3073,54 @@ export class GpuDrivenProduction {
           : 0,
       batchCount: view?.batchCount ?? 0,
       indirectDrawCount: this.indirectDrawCount,
+      encodedIndirectDraws: this.encodedIndirectDraws,
+      channels: Object.freeze(channels.map((channel) => Object.freeze(channel))),
+      resourceGeneration: view?.resourceGeneration,
+      candidateCapacity: view?.candidateCapacity ?? 0,
+      batchCapacity: view?.batchCapacity ?? 0,
+      indirectCapacity: view?.indirectCapacity ?? 0,
+      overflow: this.telemetryOverflow,
+      submitted: this.submissionState === 'submitted',
+      recoveryCount: this.recoveryCount,
+      retryCount: this.retryCount,
+      lastKnownGoodGeneration: this.lastKnownGoodGeneration,
     };
   }
 
   /** Read renderer-owned LOD counters copied by the last GPU submission. */
   readLodSelection(): Promise<GpuDrivenLodSelectionInspection | undefined> {
     if (!this.telemetryPrepared) return Promise.resolve(undefined);
-    return (this.view?.readLodSelection() ?? Promise.resolve(undefined)).then((selection) => {
+    const view = this.view;
+    const filtered = this.filteredCache?.value;
+    const telemetryCandidateCount = this.telemetryCandidateCount;
+    if (view === undefined) return Promise.resolve(undefined);
+    return view.readLodSelection().then((selection) => {
+      // The observer is asynchronous and prepare() may have published a new
+      // filtered plan while mapAsync was pending. Do not attach old counters to
+      // the new world/primitive cache; the next real copy will be observed on
+      // its own generation.
+      if (
+        !this.telemetryPrepared ||
+        this.view !== view ||
+        this.filteredCache?.value !== filtered ||
+        this.telemetryCandidateCount !== telemetryCandidateCount
+      ) {
+        return undefined;
+      }
       if (selection !== undefined) {
         this.telemetryGeometryWork = selection.geometryWork;
         this.telemetryRootGeometryWork = selection.rootGeometryWork;
+        this.telemetryOverflow = selection.overflow;
+        if (selection.overflow) {
+          if (!this.overflowRecoveryRequired) this.retryCount += 1;
+          this.overflowRecoveryRequired = true;
+          this.submissionState = 'aborted';
+          this.lastKnownGoodGeneration = undefined;
+          this.lane = 'blocked';
+          this.laneReason = 'overflow';
+        }
       }
-      if (selection === undefined || this.telemetryCandidateCount <= 0) return selection;
-      const filtered = this.filteredCache?.value;
+      if (selection === undefined || telemetryCandidateCount <= 0) return selection;
       if (filtered === undefined) return selection;
       const preparedByBatchId = new Map(
         filtered.batches.map((prepared) => [prepared.batch.batchId, prepared] as const),
@@ -1677,8 +3165,8 @@ export class GpuDrivenProduction {
       }
       return {
         ...selection,
-        candidateCount: this.telemetryCandidateCount,
-        occluded: Math.max(0, this.telemetryCandidateCount - selection.visible),
+        candidateCount: telemetryCandidateCount,
+        occluded: Math.max(0, telemetryCandidateCount - selection.visible),
         worldSelections: Object.freeze(
           [...worldSelections.values()].map((aggregate) =>
             Object.freeze({
@@ -1702,24 +3190,109 @@ export class GpuDrivenProduction {
 
   recordCpuValidation(
     validated: readonly { readonly source: RenderableSnapshot }[],
-    gpuOwned: ReadonlySet<number>,
-    worldKeys?: readonly number[],
+    gpuOwnedDrawKeys: ReadonlySet<string>,
+    cacheKey?: string,
   ): void {
-    this.cpuFallbackDrawItems = validated.length;
+    const cached = this.cpuValidationTelemetryCache;
+    if (
+      cacheKey !== undefined &&
+      cached !== undefined &&
+      cached.cacheKey === cacheKey &&
+      cached.validated === validated &&
+      cached.gpuOwnedDrawKeys === gpuOwnedDrawKeys
+    ) {
+      this.applyCpuValidationTelemetry(cached);
+      this.cpuValidationCacheHits += 1;
+      return;
+    }
+    this.cpuFallbackDrawItems = 0;
+    this.cpuSemanticFallbackDrawItems = 0;
+    this.cpuDeformationFallbackDrawItems = 0;
+    this.cpuDeformationReasons.clear();
+    this.blockedDrawItems = 0;
     let gpuOwnedRows = 0;
+    let totalDrawItems = 0;
+    const addDeformationReason = (
+      reason: 'skin-bounds-missing' | 'skin-address-missing' | 'resource-not-ready',
+    ): void => {
+      this.cpuDeformationReasons.set(reason, (this.cpuDeformationReasons.get(reason) ?? 0) + 1);
+    };
     for (const row of validated) {
-      if (
-        gpuOwned.has(
-          worldEntityKey(
-            worldKeys?.[row.source.worldId] ?? row.source.worldId,
-            row.source.entityKey,
-          ),
-        )
-      ) {
-        gpuOwnedRows += 1;
+      const draws = row.source.gpuDrivenDraws ?? [];
+      if (draws.length === 0) {
+        totalDrawItems += 1;
+        this.cpuFallbackDrawItems += 1;
+        const material = row.source.material;
+        const skinReason = skinLaneReason(row.source, material);
+        if (skinReason !== undefined) {
+          this.cpuDeformationFallbackDrawItems += 1;
+          addDeformationReason(skinReason);
+        } else {
+          this.cpuSemanticFallbackDrawItems += 1;
+        }
+        continue;
       }
+      totalDrawItems += draws.length;
+      let gpuOwned = false;
+      let cpuResidual = false;
+      for (const [compactIndex, draw] of draws.entries()) {
+        const material = row.source.materials[draw.materialSlot] ?? row.source.material;
+        const key = gpuDrivenDrawKey(
+          worldEntityKey(row.source.worldId, row.source.entityKey),
+          material.materialHandle ?? -1,
+          gpuDrivenSourceDrawItemIndex(draw, compactIndex),
+        );
+        if (gpuOwnedDrawKeys.has(key)) {
+          gpuOwned = true;
+          continue;
+        }
+        this.cpuFallbackDrawItems += 1;
+        cpuResidual = true;
+        const skinReason = skinLaneReason(row.source, material);
+        if (skinReason !== undefined) {
+          this.cpuDeformationFallbackDrawItems += 1;
+          addDeformationReason(skinReason);
+        } else if (draw.preparationError?.detail.recovery === 'route-cpu-lane') {
+          // Geometry/UV incompatibility is an explicit semantic CPU lane,
+          // not a failed capable submission.
+          this.cpuSemanticFallbackDrawItems += 1;
+        } else if (draw.preparationError?.detail.owner === 'skin') {
+          this.cpuDeformationFallbackDrawItems += 1;
+          addDeformationReason(
+            draw.preparationError.detail.reason === 'skin-address-missing'
+              ? 'skin-address-missing'
+              : 'resource-not-ready',
+          );
+        } else if (draw.preparationError !== undefined) {
+          this.blockedDrawItems += 1;
+        } else {
+          this.cpuSemanticFallbackDrawItems += 1;
+        }
+      }
+      // A row is only CPU-validated when it still has a CPU residual. GPU-only
+      // rows are already admitted by the concrete draw-key set and must not
+      // inflate the per-frame CPU validation budget.
+      if (gpuOwned && cpuResidual) gpuOwnedRows += 1;
     }
+    this.gpuOwnedDrawItems = gpuOwnedDrawKeys.size;
+    this.mainTotalDrawItems = totalDrawItems;
     this.validatedGpuOwnedRows = gpuOwnedRows;
+    this.cpuValidationScans += 1;
+    if (cacheKey !== undefined) {
+      this.cpuValidationTelemetryCache = {
+        cacheKey,
+        validated,
+        gpuOwnedDrawKeys,
+        gpuOwnedDrawCount: this.gpuOwnedDrawItems,
+        totalDrawItems: this.mainTotalDrawItems,
+        gpuOwnedRows: this.validatedGpuOwnedRows,
+        cpuFallbackDrawItems: this.cpuFallbackDrawItems,
+        cpuSemanticFallbackDrawItems: this.cpuSemanticFallbackDrawItems,
+        cpuDeformationFallbackDrawItems: this.cpuDeformationFallbackDrawItems,
+        cpuDeformationReasons: new Map(this.cpuDeformationReasons),
+        blockedDrawItems: this.blockedDrawItems,
+      };
+    }
   }
 
   private sceneIdentity(scene: object): number {