@forgeax/engine-render 0.1.2

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

@@ -0,0 +1,1705 @@
+import { frustum, mat4 } from '@forgeax/engine-math';
+import type {
+  GraphAccess,
+  GraphBuffer,
+  GraphResourceResolver,
+  RenderGraphBuilder,
+  RenderGraphError,
+} from '@forgeax/engine-render-graph';
+import type {
+  BindGroup,
+  BindGroupLayout,
+  RenderPipeline,
+  Result,
+  RhiDevice,
+  ShaderModule,
+} from '@forgeax/engine-rhi';
+import { err, ok, RhiError } from '@forgeax/engine-rhi';
+import { type MaterialRenderState, RenderQueue } from '@forgeax/engine-types';
+import { GPU_SCENE_WGSL } from '../gpu-scene-schema';
+import {
+  GPU_BUFFER_USAGE_COPY_DST,
+  GPU_BUFFER_USAGE_INDEX,
+  GPU_BUFFER_USAGE_UNIFORM,
+  GPU_BUFFER_USAGE_VERTEX,
+} from '../gpu-usage';
+import type { PersistentGpuDrivenState } from '../persistent-render-scene';
+import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
+import { type RasterItemKey, rasterItemKey } from '../record';
+import type {
+  RenderPipelineFrame,
+  RenderPipelineGpuDrivenProjection,
+  RenderPipelineGpuDrivenShadowProjection,
+} from '../render-pipeline';
+import type { MeshGpuHandles } from '../render-system';
+import {
+  buildRenderVisibilityViewDescriptors,
+  type CameraSnapshot,
+  type ExtractedFrame,
+  type RenderableSnapshot,
+} from '../render-system-extract';
+import {
+  buildBatchAlignedSubmission,
+  buildSubmissionCandidateMembership,
+  type GpuDrivenBatch,
+  type GpuDrivenCandidate,
+  type SubmissionCandidateMembership,
+  type SubmissionPlan,
+} from './batch-topology';
+import {
+  type CpuMultiViewVisibilityResult,
+  type CpuVisibilityCandidate,
+  executeCpuMultiViewVisibility,
+  GpuDrivenView,
+} from './view-gpu';
+
+const VERTEX_STAGE = 0x1;
+const FRAGMENT_STAGE = 0x2;
+const EMPTY_RESOURCE_CLASS = JSON.stringify({ textures: [], samplers: [], video: [] });
+
+function supportsRigidGpuDrivenProjection(mesh: MeshGpuHandles): boolean {
+  const attributes = mesh.layoutProjection.attributes;
+  const required = ['position', 'normal', 'uv', 'tangent'] as const;
+  return (
+    attributes.length === required.length &&
+    attributes.every((attribute, index) => attribute.key === required[index])
+  );
+}
+
+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;
+}
+`;
+
+/**
+ * Depth-only shadow raster companion for the shared GPU Scene visibility
+ * buffers. It deliberately has no material-dependent fragment stage: alpha
+ * test and custom ShadowCaster variants stay on the CPU contract until their
+ * own batch shader is available. Opaque casters use the same primitive,
+ * instance, transform and compact-visible tables as the main view.
+ */
+export const GPU_DRIVEN_SHADOW_WGSL = /* wgsl */ `
+${GPU_SCENE_WGSL}
+
+struct ShadowBatch {
+  lightViewProj: mat4x4<f32>,
+  visibleBase: u32,
+  pad0: u32,
+  pad1: u32,
+  pad2: u32,
+};
+
+@group(2) @binding(0) var<storage, read> primitives: array<GpuScenePrimitive>;
+@group(2) @binding(1) var<storage, read> instances: array<GpuSceneInstance>;
+@group(2) @binding(2) var<storage, read> transforms: array<GpuSceneTransform>;
+@group(2) @binding(3) var<storage, read> visibleItems: array<vec2<u32>>;
+@group(2) @binding(4) var<uniform> shadowBatch: ShadowBatch;
+
+struct VertexInput {
+  @location(0) position: vec3<f32>,
+};
+
+@vertex
+fn vs_main(input: VertexInput, @builtin(instance_index) instanceIndex: u32) -> @builtin(position) vec4<f32> {
+  let visible = visibleItems[shadowBatch.visibleBase + instanceIndex];
+  let sceneInstance = instances[visible.x];
+  let primitive = primitives[sceneInstance.primitiveIndex];
+  let world = transforms[primitive.transformIndex].currentWorld *
+    transforms[sceneInstance.transformIndex].currentWorld;
+  return shadowBatch.lightViewProj * world * vec4<f32>(input.position, 1.0);
+}
+`;
+
+interface PreparedBatch {
+  readonly batch: GpuDrivenBatch;
+  readonly mesh: MeshGpuHandles;
+  readonly renderState: MaterialRenderState | undefined;
+}
+
+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,
+  size?: number,
+) {
+  return {
+    kind: 'buffer' as const,
+    value: {
+      buffer,
+      ...(offset === undefined ? {} : { offset }),
+      ...(size === undefined ? {} : { size }),
+    },
+  };
+}
+
+function activeFrustum(camera: CameraSnapshot): Float32Array {
+  const projection = mat4.create();
+  if (camera.projection === 'orthographic') {
+    mat4.orthographic(
+      projection,
+      camera.orthoLeft,
+      camera.orthoRight,
+      camera.orthoBottom,
+      camera.orthoTop,
+      camera.near,
+      camera.far,
+    );
+  } else {
+    mat4.perspective(projection, camera.fov, camera.aspect, camera.near, camera.far);
+  }
+  const view = mat4.invert(mat4.create(), camera.world);
+  return frustum.fromViewProjection(
+    frustum.create(),
+    mat4.multiply(mat4.create(), projection, view),
+  );
+}
+
+export type GpuDrivenRasterEligibilityReason =
+  | 'missing-local-bounds-capability-lane'
+  | 'skinned-capability-lane'
+  | 'sprite-capability-lane'
+  | 'not-geometry-queue'
+  | 'unsafe-ordering'
+  | 'pbr-capability-lane'
+  | 'alpha-test-capability-lane'
+  | 'resource-bindings-capability-lane'
+  | 'transparent';
+
+export interface GpuDrivenRasterEligibility {
+  readonly eligible: boolean;
+  readonly reason: GpuDrivenRasterEligibilityReason | undefined;
+}
+
+/**
+ * The current shader remains a deliberately narrow capability lane. Semantic
+ * batch keys still retain PBR/alpha/resource/double-sided identity so those
+ * objects can share the CPU/shadow contract without being misreported as
+ * rigid-unlit GPU-owned raster work.
+ */
+export function gpuDrivenRasterEligibility(
+  snapshot: RenderableSnapshot,
+  batch: GpuDrivenBatch,
+): GpuDrivenRasterEligibility {
+  const material = snapshot.materials[batch.key.materialSlot] ?? snapshot.material;
+  const shader = material.materialShaderId ?? 'forgeax::default-unlit';
+  if (snapshot.localAabb === undefined) {
+    return { eligible: false, reason: 'missing-local-bounds-capability-lane' };
+  }
+  if (snapshot.skin !== undefined) return { eligible: false, reason: 'skinned-capability-lane' };
+  if (snapshot.spriteInstances !== undefined) {
+    return { eligible: false, reason: 'sprite-capability-lane' };
+  }
+  if (batch.key.queue !== RenderQueue.Geometry) {
+    return { eligible: false, reason: 'not-geometry-queue' };
+  }
+  if (!orderSafe(material.renderState)) return { eligible: false, reason: 'unsafe-ordering' };
+  if (batch.key.pbr || shader !== 'forgeax::default-unlit') {
+    return { eligible: false, reason: 'pbr-capability-lane' };
+  }
+  if (batch.key.alphaTest) return { eligible: false, reason: 'alpha-test-capability-lane' };
+  if (
+    batch.key.materialResourceClass !== EMPTY_RESOURCE_CLASS ||
+    material.baseColorTexture !== undefined
+  ) {
+    return { eligible: false, reason: 'resource-bindings-capability-lane' };
+  }
+  if (material.transparent === true) return { eligible: false, reason: 'transparent' };
+  return { eligible: true, reason: undefined };
+}
+
+function productionEligible(snapshot: RenderableSnapshot, batch: GpuDrivenBatch): boolean {
+  return gpuDrivenRasterEligibility(snapshot, batch).eligible;
+}
+
+function sameNumberArray(left: readonly number[], right: readonly number[]): boolean {
+  if (left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index] !== right[index]) return false;
+  }
+  return true;
+}
+
+function orderSafe(renderState: MaterialRenderState | undefined): boolean {
+  if (renderState === undefined) return true;
+  return (
+    renderState.blend === undefined &&
+    renderState.depthWriteEnabled !== false &&
+    renderState.depthCompare !== 'always' &&
+    renderState.stencil === undefined &&
+    renderState.stencilReadMask === undefined &&
+    renderState.stencilWriteMask === undefined
+  );
+}
+
+function meshSupportsBatch(mesh: MeshGpuHandles, batch: GpuDrivenBatch): boolean {
+  if (!supportsRigidGpuDrivenProjection(mesh)) return false;
+  return batch.key.drawKind === 'indexed'
+    ? mesh.indexed && mesh.indexBuffer !== null
+    : !mesh.indexed;
+}
+
+function filteredPlan(
+  source: SubmissionPlan,
+  slots: PersistentGpuDrivenState['slots'],
+  meshes: ReadonlyMap<number, MeshGpuHandles>,
+): {
+  readonly plan: SubmissionPlan;
+  readonly shadowPlan: SubmissionPlan;
+  readonly batches: readonly PreparedBatch[];
+  readonly itemKeys: ReadonlySet<RasterItemKey>;
+  readonly forwardItemKeys: ReadonlySet<RasterItemKey>;
+} {
+  const slotByPrimitive = new Map(slots.map((slot) => [slot.slot, slot] as const));
+  const itemKeys = new Set<RasterItemKey>();
+  const forwardItemKeys = new Set<RasterItemKey>();
+  let hasEarlierQueue = false;
+  for (const slot of slots) {
+    for (const draw of slot.snapshot.gpuDrivenDraws ?? []) {
+      const key = rasterItemKey(
+        slot.snapshot.worldId,
+        slot.snapshot.entityKey,
+        draw.submeshIndex,
+        draw.passIndex,
+      );
+      if (draw.queue === RenderQueue.Geometry) forwardItemKeys.add(key);
+      if (draw.queue < RenderQueue.Geometry) hasEarlierQueue = true;
+    }
+  }
+  const candidatesByBatch = new Map<number, readonly GpuDrivenCandidate[]>();
+  const shadowCandidatesByBatch = new Map<number, readonly GpuDrivenCandidate[]>();
+  const meshByBatch = new Map<number, MeshGpuHandles>();
+  const renderStateByBatch = new Map<number, MaterialRenderState | undefined>();
+  for (const batch of source.batches) {
+    const shadowCandidates = batch.candidates.filter(
+      (candidate) => slotByPrimitive.has(candidate.primitiveIndex) && batch.key.shadowCaster,
+    );
+    if (shadowCandidates.length > 0) {
+      shadowCandidatesByBatch.set(batch.batchId, Object.freeze(shadowCandidates));
+    }
+    const candidates = batch.candidates.filter((candidate) => {
+      const slot = slotByPrimitive.get(candidate.primitiveIndex);
+      if (slot === undefined || !productionEligible(slot.snapshot, batch)) return false;
+      const mesh = meshes.get(slot.snapshot.assetHandle);
+      if (mesh === undefined || !meshSupportsBatch(mesh, batch)) return false;
+      const draw = slot.snapshot.gpuDrivenDraws?.[candidate.drawItemIndex];
+      if (draw === undefined) return false;
+      itemKeys.add(
+        rasterItemKey(
+          slot.snapshot.worldId,
+          slot.snapshot.entityKey,
+          draw.submeshIndex,
+          draw.passIndex,
+        ),
+      );
+      return true;
+    });
+    if (candidates.length === 0) continue;
+    const first = slotByPrimitive.get(candidates[0]?.primitiveIndex ?? -1);
+    const mesh = first === undefined ? undefined : meshes.get(first.snapshot.assetHandle);
+    if (mesh === undefined || first === undefined) continue;
+    candidatesByBatch.set(batch.batchId, Object.freeze(candidates));
+    meshByBatch.set(batch.batchId, mesh);
+    const material = first.snapshot.materials[batch.key.materialSlot] ?? first.snapshot.material;
+    renderStateByBatch.set(batch.batchId, material.renderState);
+  }
+  const sourceShadowPlan = buildBatchAlignedSubmission(source, shadowCandidatesByBatch);
+  // The typed graph encodes the GPU Geometry lane before CPU recording in the
+  // same raster pass. If an earlier queue or an ineligible Geometry item is
+  // present, publishing only a subset would change stable queue order. Fail
+  // closed for the whole GPU lane and let the CPU path own every item.
+  if (hasEarlierQueue || itemKeys.size !== forwardItemKeys.size) {
+    return {
+      plan: Object.freeze({
+        revision: source.revision,
+        batches: Object.freeze([]),
+        candidateCount: 0,
+        visibleCapacity: 0,
+      }),
+      shadowPlan: sourceShadowPlan,
+      batches: Object.freeze([]),
+      itemKeys: new Set<RasterItemKey>(),
+      forwardItemKeys,
+    };
+  }
+  const plan = buildBatchAlignedSubmission(source, candidatesByBatch);
+  const batches: PreparedBatch[] = [];
+  for (const batch of plan.batches) {
+    const mesh = meshByBatch.get(batch.batchId);
+    if (mesh === undefined) continue;
+    batches.push({
+      batch,
+      mesh,
+      renderState: renderStateByBatch.get(batch.batchId),
+    });
+  }
+  return {
+    plan,
+    // Shadow topology is intentionally derived from the unfiltered source
+    // plan. The rigid-unlit forward capability lane must not remove PBR,
+    // alpha-test, or double-sided casters from the ShadowCaster pool.
+    shadowPlan: sourceShadowPlan,
+    batches: Object.freeze(batches),
+    itemKeys,
+    forwardItemKeys,
+  };
+}
+
+function filterShadowSubmissionBySlots(
+  source: SubmissionPlan,
+  shadowCasterSlotIndices: ReadonlySet<number> | undefined,
+): SubmissionPlan {
+  if (shadowCasterSlotIndices === undefined) return source;
+  const candidatesByBatch = new Map<number, readonly GpuDrivenCandidate[]>();
+  for (const batch of source.batches) {
+    const candidates = batch.candidates.filter((candidate) =>
+      shadowCasterSlotIndices.has(candidate.primitiveIndex),
+    );
+    if (candidates.length > 0) {
+      candidatesByBatch.set(batch.batchId, Object.freeze(candidates));
+    }
+  }
+  return buildBatchAlignedSubmission(source, candidatesByBatch);
+}
+
+type FilteredProductionPlan = ReturnType<typeof filteredPlan>;
+
+export interface GpuDrivenProductionInspection {
+  readonly gpuOwnedSnapshotsMaterialized: number;
+  readonly filteredPlanBuilds: number;
+  readonly gpuOwnedItemCount: number;
+  readonly candidateUploadBytes: number;
+  readonly batchUploadBytes: number;
+  readonly viewConstantsUploadBytes: number;
+  readonly batchBindGroupCreates: number;
+  readonly viewBindGroupCreates: number;
+  readonly topologyRevision: number | undefined;
+  readonly validatedGpuOwnedRows: number;
+  readonly cpuFallbackDrawItems: number;
+  readonly cpuVisibility: CpuMultiViewVisibilityResult | undefined;
+  readonly shadowBatchCount: number;
+  readonly shadowCandidateCount: number;
+  readonly shadowDrawCount: number;
+  readonly faults: readonly GpuDrivenVisibilityFault[];
+}
+
+export type GpuDrivenVisibilityFaultCode =
+  | 'visibility-overflow'
+  | 'gpu-capability-unavailable'
+  | 'gpu-scene-fact-unavailable'
+  | 'device-recovery-required'
+  | 'gpu-resource-failed';
+
+export interface GpuDrivenVisibilityFault {
+  readonly code: GpuDrivenVisibilityFaultCode;
+  readonly viewId: string;
+  readonly revision: number;
+  readonly fallback: 'cpu-batch-contract' | 'scene-rebuild';
+  readonly detail: string;
+}
+
+class GpuDrivenRigidRaster {
+  private readonly pipelines = new Map<string, RenderPipeline>();
+
+  private constructor(
+    private readonly device: RhiDevice,
+    private readonly layout: BindGroupLayout,
+    private readonly pipelineLayout: import('@forgeax/engine-rhi').PipelineLayout,
+    private readonly module: ShaderModule,
+  ) {}
+
+  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',
+      entries: [
+        { binding: 0, visibility: VERTEX_STAGE, buffer: { type: 'read-only-storage' } },
+        {
+          binding: 1,
+          visibility: VERTEX_STAGE,
+          buffer: { type: 'read-only-storage' },
+        },
+        {
+          binding: 2,
+          visibility: VERTEX_STAGE | FRAGMENT_STAGE,
+          buffer: { type: 'read-only-storage' },
+        },
+        { 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;
+    return ok(
+      new GpuDrivenRigidRaster(input.device, layout.value, pipelineLayout.value, module.value),
+    );
+  }
+
+  pipeline(
+    format: string,
+    sampleCount: 1 | 4,
+    vertexStride: 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 cached = this.pipelines.get(key);
+    if (cached !== undefined) return ok(cached);
+    const created = this.device.createRenderPipeline({
+      label: `gpu-driven-rigid-unlit.${key}`,
+      layout: this.pipelineLayout as unknown as GPUPipelineLayout,
+      vertex: {
+        module: this.module as unknown as GPUShaderModule,
+        entryPoint: 'vs_main',
+        buffers: [
+          {
+            arrayStride: vertexStride,
+            stepMode: 'vertex',
+            attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x3' }],
+          },
+        ],
+      },
+      fragment: {
+        module: this.module as unknown as GPUShaderModule,
+        entryPoint: 'fs_main',
+        targets: [
+          {
+            format: format as GPUTextureFormat,
+            ...(renderState?.blend === undefined ? {} : { blend: renderState.blend }),
+          },
+        ],
+      },
+      primitive: {
+        topology: topology as GPUPrimitiveTopology,
+        cullMode: renderState?.cullMode ?? 'back',
+        frontFace: renderState?.frontFace ?? 'ccw',
+        ...(stripIndexFormat === undefined ? {} : { stripIndexFormat }),
+      },
+      depthStencil: {
+        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,
+            },
+          }
+        : {}),
+    });
+    if (!created.ok) return created;
+    this.pipelines.set(key, created.value);
+    return created;
+  }
+
+  bindGroup(
+    scene: PersistentGpuDrivenState['scene'],
+    view: GpuDrivenView,
+    batch: GpuDrivenBatch,
+  ): 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',
+        }),
+      );
+    }
+    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),
+        },
+      ],
+    });
+  }
+}
+
+interface PreparedShadowBatch {
+  readonly batch: GpuDrivenBatch;
+  readonly mesh: MeshGpuHandles;
+  readonly pipeline: RenderPipeline;
+  readonly uniformOffset: number;
+}
+
+interface PreparedShadowView {
+  readonly cascadeIndex: number;
+  readonly view: GpuDrivenView;
+  readonly plan: SubmissionPlan;
+  readonly batches: readonly PreparedShadowBatch[];
+  readonly bindGroup: BindGroup;
+  readonly graphLabel: string;
+  readonly graphResources?: import('./view-gpu').GpuDrivenViewGraphResources;
+}
+
+class GpuDrivenShadowRaster {
+  private readonly pipelines = new Map<string, RenderPipeline>();
+  private readonly uniformBuffers = new Set<import('@forgeax/engine-rhi').Buffer>();
+  private readonly uniformByCascade = new Map<number, import('@forgeax/engine-rhi').Buffer>();
+  private readonly uniformCapacities = new Map<number, number>();
+
+  private constructor(
+    private readonly device: RhiDevice,
+    private readonly layout: BindGroupLayout,
+    private readonly pipelineLayout: import('@forgeax/engine-rhi').PipelineLayout,
+    private readonly module: ShaderModule,
+  ) {}
+
+  static create(input: {
+    readonly device: RhiDevice;
+    readonly shaderModuleFactory: PipelineBuilderShaderModuleFactory;
+    readonly viewBindGroupLayout: BindGroupLayout;
+    readonly materialBindGroupLayout: BindGroupLayout;
+  }): Result<GpuDrivenShadowRaster, RhiError> {
+    const layout = input.device.createBindGroupLayout({
+      label: 'gpu-driven-shadow-raster-bgl',
+      entries: [
+        { binding: 0, visibility: VERTEX_STAGE, buffer: { type: 'read-only-storage' } },
+        { binding: 1, visibility: VERTEX_STAGE, buffer: { type: 'read-only-storage' } },
+        { binding: 2, visibility: VERTEX_STAGE, buffer: { type: 'read-only-storage' } },
+        { binding: 3, visibility: VERTEX_STAGE, buffer: { type: 'read-only-storage' } },
+        {
+          binding: 4,
+          visibility: VERTEX_STAGE,
+          buffer: { type: 'uniform', hasDynamicOffset: true },
+        },
+      ],
+    });
+    if (!layout.ok) return layout;
+    const pipelineLayout = input.device.createPipelineLayout({
+      label: 'gpu-driven-shadow-raster-pl',
+      bindGroupLayouts: [input.viewBindGroupLayout, input.materialBindGroupLayout, layout.value],
+    });
+    if (!pipelineLayout.ok) return pipelineLayout;
+    const module = input.shaderModuleFactory.createShaderModule({
+      label: 'gpu-driven-shadow-raster',
+      code: GPU_DRIVEN_SHADOW_WGSL,
+    });
+    if (!module.ok) return module;
+    return ok(
+      new GpuDrivenShadowRaster(input.device, layout.value, pipelineLayout.value, module.value),
+    );
+  }
+
+  prepareView(input: {
+    readonly cascadeIndex: number;
+    readonly scene: PersistentGpuDrivenState['scene'];
+    readonly view: GpuDrivenView;
+    readonly plan: SubmissionPlan;
+    readonly lightViewProj: Float32Array;
+    readonly meshes: ReadonlyMap<number, MeshGpuHandles>;
+    readonly graphLabel: string;
+  }): Result<PreparedShadowView | undefined, RhiError> {
+    const eligibleBatches: Array<{
+      readonly batch: GpuDrivenBatch;
+      readonly mesh: MeshGpuHandles;
+    }> = [];
+    for (const batch of input.plan.batches) {
+      // The GPU shadow shader is the opaque rigid capability lane. Alpha-test,
+      // custom material shadow shaders, non-rigid geometry and line/point
+      // topology remain on the same batch-aligned CPU fallback contract.
+      if (batch.key.alphaTest) continue;
+      if (batch.key.topology !== 'triangle-list' && batch.key.topology !== 'triangle-strip') {
+        continue;
+      }
+      const mesh = input.meshes.get(batch.key.assetHandle);
+      if (mesh === undefined || !supportsRigidGpuDrivenProjection(mesh)) continue;
+      if (batch.key.drawKind === 'indexed' && (!mesh.indexed || mesh.indexBuffer === null)) {
+        continue;
+      }
+      if (batch.key.drawKind === 'non-indexed' && mesh.indexed) continue;
+      eligibleBatches.push({ batch, mesh });
+    }
+    if (eligibleBatches.length === 0 || input.view.visibleBuffer === undefined)
+      return ok(undefined);
+
+    const requiredBytes = Math.max(256, eligibleBatches.length * 256);
+    let uniformBuffer = this.uniformByCascade.get(input.cascadeIndex);
+    const currentCapacity = this.uniformCapacities.get(input.cascadeIndex) ?? 0;
+    if (uniformBuffer === undefined || currentCapacity < requiredBytes) {
+      const created = this.device.createBuffer({
+        label: `gpu-driven-shadow-cascade-${input.cascadeIndex}-uniforms`,
+        size: requiredBytes,
+        usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+        mappedAtCreation: false,
+      });
+      if (!created.ok) return created;
+      uniformBuffer = created.value;
+      this.uniformBuffers.add(uniformBuffer);
+      this.uniformByCascade.set(input.cascadeIndex, uniformBuffer);
+      this.uniformCapacities.set(input.cascadeIndex, requiredBytes);
+    }
+    const payload = new Uint8Array(requiredBytes);
+    for (let index = 0; index < eligibleBatches.length; index += 1) {
+      const item = eligibleBatches[index];
+      if (item === undefined) continue;
+      const offset = index * 256;
+      new Float32Array(payload.buffer, offset, 16).set(input.lightViewProj.subarray(0, 16));
+      new DataView(payload.buffer).setUint32(offset + 64, item.batch.visibleBase, true);
+    }
+    const write = this.device.queue.writeBuffer(uniformBuffer, 0, payload);
+    if (!write.ok) return write;
+    const visible = input.view.visibleBuffer;
+    const binding = this.device.createBindGroup({
+      label: `gpu-driven-shadow-cascade-${input.cascadeIndex}-bg`,
+      layout: this.layout,
+      entries: [
+        { binding: 0, resource: bufferBinding(input.scene.primitiveBuffer) },
+        { binding: 1, resource: bufferBinding(input.scene.instanceBuffer) },
+        { binding: 2, resource: bufferBinding(input.scene.transformBuffer) },
+        { binding: 3, resource: bufferBinding(visible) },
+        {
+          binding: 4,
+          resource: {
+            kind: 'buffer',
+            value: { buffer: uniformBuffer, offset: 0, size: 80 },
+          },
+        },
+      ],
+    });
+    if (!binding.ok) return binding;
+    const batches: PreparedShadowBatch[] = [];
+    for (let index = 0; index < eligibleBatches.length; index += 1) {
+      const item = eligibleBatches[index];
+      if (item === undefined) continue;
+      const pipeline = this.pipeline(item.mesh, item.batch);
+      if (!pipeline.ok) return pipeline;
+      batches.push({
+        batch: item.batch,
+        mesh: item.mesh,
+        pipeline: pipeline.value,
+        uniformOffset: index * 256,
+      });
+    }
+    return ok({
+      cascadeIndex: input.cascadeIndex,
+      view: input.view,
+      plan: input.plan,
+      batches: Object.freeze(batches),
+      bindGroup: binding.value,
+      graphLabel: input.graphLabel,
+    });
+  }
+
+  encode(
+    prepared: PreparedShadowView,
+    resources: GraphResourceResolver,
+    graphResources: import('./view-gpu').GpuDrivenViewGraphResources,
+    pass: import('@forgeax/engine-rhi').RhiRenderPassEncoder,
+  ): void {
+    const indirect = resources.buffer(graphResources.indirect);
+    if (!indirect.ok) throw indirect.error;
+    let currentPipeline: RenderPipeline | undefined;
+    let currentVertex: import('@forgeax/engine-rhi').Buffer | undefined;
+    let currentIndex: import('@forgeax/engine-rhi').Buffer | undefined;
+    for (const batch of prepared.batches) {
+      if (currentPipeline !== batch.pipeline) {
+        pass.setPipeline(batch.pipeline);
+        currentPipeline = batch.pipeline;
+      }
+      pass.setBindGroup(2, prepared.bindGroup, [batch.uniformOffset]);
+      if (currentVertex !== batch.mesh.vertexBuffer.handle) {
+        pass.setVertexBuffer(0, batch.mesh.vertexBuffer.handle);
+        currentVertex = batch.mesh.vertexBuffer.handle;
+      }
+      if (batch.mesh.indexBuffer !== null && batch.mesh.indexed) {
+        if (currentIndex !== batch.mesh.indexBuffer.handle) {
+          pass.setIndexBuffer(batch.mesh.indexBuffer.handle, batch.mesh.indexFormat);
+          currentIndex = batch.mesh.indexBuffer.handle;
+        }
+        pass.drawIndexedIndirect(indirect.value, batch.batch.indirectOffset);
+      } else {
+        pass.drawIndirect(indirect.value, batch.batch.indirectOffset);
+      }
+    }
+  }
+
+  dispose(): void {
+    for (const buffer of this.uniformBuffers) this.device.destroyBuffer(buffer);
+    this.uniformBuffers.clear();
+    this.uniformByCascade.clear();
+    this.uniformCapacities.clear();
+    this.pipelines.clear();
+  }
+
+  private pipeline(mesh: MeshGpuHandles, batch: GpuDrivenBatch): Result<RenderPipeline, RhiError> {
+    const stripIndexFormat =
+      batch.key.drawKind === 'indexed' && batch.key.topology === 'triangle-strip'
+        ? mesh.indexFormat
+        : undefined;
+    const key = `${batch.key.topology}|${stripIndexFormat ?? ''}|${batch.key.doubleSided ? 'none' : 'back'}`;
+    const cached = this.pipelines.get(key);
+    if (cached !== undefined) return ok(cached);
+    const created = this.device.createRenderPipeline({
+      label: `gpu-driven-shadow-${key}`,
+      layout: this.pipelineLayout as unknown as GPUPipelineLayout,
+      vertex: {
+        module: this.module as unknown as GPUShaderModule,
+        entryPoint: 'vs_main',
+        buffers: [
+          {
+            arrayStride: 48,
+            stepMode: 'vertex',
+            attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x3' }],
+          },
+        ],
+      },
+      primitive: {
+        topology: batch.key.topology as GPUPrimitiveTopology,
+        cullMode: batch.key.doubleSided ? 'none' : 'back',
+        frontFace: 'ccw',
+        ...(stripIndexFormat === undefined ? {} : { stripIndexFormat }),
+      },
+      depthStencil: {
+        format: 'depth32float',
+        depthWriteEnabled: true,
+        depthCompare: 'less',
+      },
+    });
+    if (!created.ok) return created;
+    this.pipelines.set(key, created.value);
+    return created;
+  }
+}
+
+export interface PreparedGpuDrivenFrame {
+  readonly topologySignature: string;
+  readonly ownedItemKeys: ReadonlySet<RasterItemKey>;
+  readonly ownsAllForwardItems: boolean;
+  /** Batch-aligned ShadowCaster candidates from the same topology revision. */
+  readonly shadowSubmission: SubmissionPlan;
+  project(
+    graph: RenderGraphBuilder<RenderPipelineFrame>,
+    format: string,
+    sampleCount: 1 | 4,
+  ): Result<RenderPipelineGpuDrivenProjection, RenderGraphError | RhiError>;
+}
+
+/**
+ * Per-view production submission. The batch-aligned plan owns candidate
+ * membership; candidateIndexByStableId is a one-way adapter for the existing
+ * direct RHI draw encoder and must not be used to generate another view list.
+ */
+export interface MultiViewProductionSubmission {
+  readonly source: 'multi-view-indirect';
+  readonly viewId: string;
+  readonly kind: 'main' | 'cascade';
+  readonly cascadeIndex: number | undefined;
+  readonly volumeRevision: number | undefined;
+  readonly spatialIndexRevision: number | undefined;
+  readonly overflow: boolean;
+  readonly plan: SubmissionPlan;
+  readonly candidateIndexByStableId: ReadonlyMap<number, number>;
+  /** Immutable candidate membership adapter shared by CPU shadow fallback and observation. */
+  readonly candidateIndices: ReadonlySet<number>;
+  readonly faults: readonly GpuDrivenVisibilityFault[];
+}
+
+export class GpuDrivenProduction {
+  private view: GpuDrivenView | undefined;
+  private raster: GpuDrivenRigidRaster | undefined;
+  private shadowRaster: GpuDrivenShadowRaster | undefined;
+  private readonly shadowViews = new Map<number, GpuDrivenView>();
+  private preparedShadowViews: readonly PreparedShadowView[] = [];
+  private readonly sceneIdentities = new WeakMap<object, number>();
+  private nextSceneIdentity = 1;
+  private filteredCache:
+    | {
+        readonly source: SubmissionPlan;
+        readonly meshResidencyEpoch: number;
+        readonly value: FilteredProductionPlan;
+      }
+    | undefined;
+  private gpuOwnedSnapshotsMaterialized = 0;
+  private filteredPlanBuilds = 0;
+  private gpuOwnedItemCount = 0;
+  private batchBindGroupCreates = 0;
+  private validatedGpuOwnedRows = 0;
+  private cpuFallbackDrawItems = 0;
+  private cpuVisibility: CpuMultiViewVisibilityResult | undefined;
+  /** Candidate-domain ShadowCaster membership projected onto persistent slots. */
+  private shadowCasterSlotIndices: ReadonlySet<number> | undefined;
+  private visibilityViews: readonly import('../render-system-extract').RenderVisibilityViewDescriptor[] =
+    [];
+  private shadowSubmission: SubmissionPlan | undefined;
+  private readonly shadowPlanCache = new Map<
+    string,
+    {
+      readonly source: SubmissionPlan;
+      readonly stableIds: readonly number[];
+      readonly generations: readonly number[];
+      readonly plan: SubmissionPlan;
+    }
+  >();
+  /**
+   * Reverse index for the immutable shadow topology. Cascade views provide
+   * stable slot ids, so rebuilding a view plan should walk the selected view
+   * domain instead of filtering every source candidate for every cascade.
+   */
+  private shadowCandidateMembership: SubmissionCandidateMembership | undefined;
+  private faults: readonly GpuDrivenVisibilityFault[] = [];
+  private signatureCache:
+    | {
+        readonly filtered: FilteredProductionPlan;
+        readonly sceneIdentity: number;
+        readonly viewResourceGeneration: number;
+        readonly meshResidencyEpoch: number;
+        readonly value: string;
+      }
+    | undefined;
+
+  constructor(
+    private readonly device: RhiDevice,
+    private readonly shaderModuleFactory: PipelineBuilderShaderModuleFactory,
+  ) {}
+
+  prepareCpuVisibility(input: {
+    readonly scene: PersistentGpuDrivenState | undefined;
+    readonly frame: ExtractedFrame;
+    readonly camera: CameraSnapshot | undefined;
+  }): CpuMultiViewVisibilityResult | undefined {
+    this.faults = [];
+    if (input.scene === undefined) {
+      this.cpuVisibility = undefined;
+      this.visibilityViews = [];
+      this.shadowCasterSlotIndices = undefined;
+      this.shadowPlanCache.clear();
+      this.shadowCandidateMembership = undefined;
+      return undefined;
+    }
+    const descriptors = buildRenderVisibilityViewDescriptors({
+      camera: input.camera,
+      directionalCsm: input.frame.lights.directionalCsm,
+      spatialIndexRevision: input.scene.scene.inspect().spatialIndex?.revision,
+    });
+    const batchBySlot = new Map<
+      number,
+      { readonly batchId: number; readonly instanceOrdinal: number }
+    >();
+    const capacityByBatch = new Map<number, number>();
+    for (const batch of input.scene.plan.batches) {
+      capacityByBatch.set(batch.batchId, batch.visibleCapacity);
+      for (const candidate of batch.candidates) {
+        if (!batchBySlot.has(candidate.primitiveIndex)) {
+          batchBySlot.set(candidate.primitiveIndex, {
+            batchId: batch.batchId,
+            instanceOrdinal: candidate.instanceOrdinal,
+          });
+        }
+      }
+    }
+    const candidateDomain = input.frame.candidateDomain;
+    const needsCandidateIdentityFallback =
+      candidateDomain !== undefined ||
+      input.scene.slots.some((slot) => slot.snapshot.candidateIndex === undefined);
+    let candidateIndexByIdentity: ReadonlyMap<string, number> = new Map<string, number>();
+    if (needsCandidateIdentityFallback) {
+      if (candidateDomain !== undefined) {
+        // The persistent candidate domain is the only owner that remains
+        // correct after projection removals compact the candidate array. A
+        // projection slot may still carry the old snapshot candidateIndex;
+        // never let that stale producer hint override the domain join.
+        candidateIndexByIdentity = candidateDomain.indexByIdentity;
+      } else {
+        const fallback = new Map<string, number>();
+        for (let index = 0; index < (input.frame.candidateRenderables?.length ?? 0); index += 1) {
+          const candidate = input.frame.candidateRenderables?.[index];
+          if (candidate !== undefined) {
+            fallback.set(`${candidate.worldId}:${candidate.entityKey}`, index);
+          }
+        }
+        candidateIndexByIdentity = fallback;
+      }
+    }
+    const candidatesBySlot = new Map<number, CpuVisibilityCandidate>();
+    const shadowCasterCandidateIndices =
+      input.frame.candidateDomain?.membership.shadowCasterCandidateIndices ??
+      input.frame.candidateDispatchMembership?.shadowCasterCandidateIndices;
+    const shadowCasterSlotIndices =
+      shadowCasterCandidateIndices === undefined ? undefined : new Set<number>();
+    for (const slot of input.scene.slots) {
+      const batch = batchBySlot.get(slot.slot);
+      const worldAabb =
+        slot.fact.bounds.status === 'present' ? slot.fact.bounds.worldAabb : undefined;
+      const candidateIndex =
+        candidateDomain === undefined
+          ? (slot.snapshot.candidateIndex ??
+            candidateIndexByIdentity.get(`${slot.worldId}:${slot.entityKey}`))
+          : candidateIndexByIdentity.get(`${slot.worldId}:${slot.entityKey}`);
+      const dispatchShadowCaster =
+        shadowCasterCandidateIndices === undefined ||
+        candidateIndex === undefined ||
+        shadowCasterCandidateIndices.has(candidateIndex);
+      if (
+        dispatchShadowCaster &&
+        slot.fact.casterEligibility !== 'ineligible' &&
+        shadowCasterSlotIndices !== undefined
+      ) {
+        shadowCasterSlotIndices.add(slot.slot);
+      }
+      candidatesBySlot.set(slot.slot, {
+        stableId: slot.slot,
+        generation: slot.generation,
+        candidateIndex,
+        worldAabb,
+        // Unknown authoring facts remain conservative. Only an explicit
+        // ineligible fact may remove a candidate from a shadow view.
+        casterEligible: slot.fact.casterEligibility !== 'ineligible' && dispatchShadowCaster,
+        batchId: batch?.batchId,
+        instanceOrdinal: batch?.instanceOrdinal,
+      });
+    }
+    this.shadowCasterSlotIndices =
+      shadowCasterSlotIndices === undefined
+        ? undefined
+        : (Object.freeze(shadowCasterSlotIndices) as ReadonlySet<number>);
+    const candidatesByView = new Map<string, readonly CpuVisibilityCandidate[]>();
+    const candidateUnion = new Map<number, CpuVisibilityCandidate>();
+    for (const view of descriptors) {
+      const hits =
+        view.broadphaseWorldAabb === undefined || input.scene.projection === undefined
+          ? input.scene.slots
+          : input.scene.projection.querySpatialIndex(view.broadphaseWorldAabb).hits;
+      const domain: CpuVisibilityCandidate[] = [];
+      for (const hit of hits) {
+        const candidate = candidatesBySlot.get(hit.slot);
+        if (candidate === undefined) continue;
+        domain.push(candidate);
+        candidateUnion.set(candidate.stableId, candidate);
+      }
+      candidatesByView.set(view.viewId, Object.freeze(domain));
+    }
+    const candidates = [...candidateUnion.values()];
+    // Main visibility is independent from the GPU batch domain. Keep its
+    // compact array large enough for non-GPU renderables in the broadphase
+    // domain, otherwise a valid CPU-only object would be reported as an
+    // artificial visibility overflow.
+    const capacity = Math.max(1, input.scene.plan.visibleCapacity, candidates.length);
+    const capacityByView = new Map(descriptors.map((view) => [view.viewId, capacity] as const));
+    this.visibilityViews = descriptors;
+    this.cpuVisibility = executeCpuMultiViewVisibility({
+      views: descriptors,
+      candidates,
+      candidatesByView,
+      capacityByView,
+      capacityByBatch,
+    });
+    return this.cpuVisibility;
+  }
+
+  prepare(input: {
+    readonly scene: PersistentGpuDrivenState | undefined;
+    readonly camera: CameraSnapshot;
+    readonly meshes: ReadonlyMap<number, MeshGpuHandles>;
+    readonly viewBindGroupLayout: BindGroupLayout;
+    readonly materialBindGroupLayout?: BindGroupLayout;
+    readonly meshResidencyEpoch: number;
+    readonly hdrp: boolean;
+  }): Result<PreparedGpuDrivenFrame | undefined, RhiError> {
+    this.gpuOwnedSnapshotsMaterialized = 0;
+    this.filteredPlanBuilds = 0;
+    this.batchBindGroupCreates = 0;
+    this.validatedGpuOwnedRows = 0;
+    this.cpuFallbackDrawItems = 0;
+    this.shadowSubmission = undefined;
+    this.shadowCandidateMembership = undefined;
+    this.preparedShadowViews = [];
+    if (input.scene === undefined) {
+      this.gpuOwnedItemCount = 0;
+      return ok(undefined);
+    }
+    const scene = input.scene;
+    let filtered = this.filteredCache?.value;
+    if (
+      filtered === undefined ||
+      this.filteredCache?.source !== scene.plan ||
+      this.filteredCache.meshResidencyEpoch !== input.meshResidencyEpoch
+    ) {
+      filtered = filteredPlan(scene.plan, scene.slots, input.meshes);
+      this.filteredCache = {
+        source: scene.plan,
+        meshResidencyEpoch: input.meshResidencyEpoch,
+        value: filtered,
+      };
+      this.gpuOwnedSnapshotsMaterialized = scene.slots.length;
+      this.filteredPlanBuilds = 1;
+    }
+    this.gpuOwnedItemCount = filtered.itemKeys.size;
+    const shadowSubmission = filterShadowSubmissionBySlots(
+      filtered.shadowPlan,
+      this.shadowCasterSlotIndices,
+    );
+    this.shadowSubmission = shadowSubmission;
+    if (
+      input.hdrp ||
+      !this.device.caps.compute ||
+      !this.device.caps.storageBuffer ||
+      !this.device.caps.indirectDrawing ||
+      (filtered.batches.length === 0 && shadowSubmission.batches.length === 0)
+    ) {
+      if (shadowSubmission.candidateCount > 0) {
+        this.addFault({
+          code: 'gpu-capability-unavailable',
+          viewId: 'all',
+          revision: shadowSubmission.revision,
+          fallback: 'cpu-batch-contract',
+          detail: input.hdrp
+            ? 'HDRP production raster does not expose the rigid shadow capability lane'
+            : 'compute, storage-buffer, indirect-drawing, or forward batch capability is unavailable',
+        });
+      }
+      return ok(undefined);
+    }
+    if (this.view === undefined) {
+      const created = GpuDrivenView.create({
+        device: this.device,
+        shaderModuleFactory: this.shaderModuleFactory,
+      });
+      if (!created.ok) {
+        this.addRhiFault(created.error, 'all', filtered.plan.revision);
+        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) {
+        this.addRhiFault(created.error, 'all', filtered.plan.revision);
+        return created;
+      }
+      this.raster = created.value;
+    }
+    if (this.shadowRaster === undefined && input.materialBindGroupLayout !== undefined) {
+      const created = GpuDrivenShadowRaster.create({
+        device: this.device,
+        shaderModuleFactory: this.shaderModuleFactory,
+        viewBindGroupLayout: input.viewBindGroupLayout,
+        materialBindGroupLayout: input.materialBindGroupLayout,
+      });
+      if (!created.ok) {
+        this.addRhiFault(created.error, 'all', shadowSubmission.revision);
+      } else {
+        this.shadowRaster = created.value;
+      }
+    }
+    const updated = this.view.update(filtered.plan, scene.scene, activeFrustum(input.camera));
+    if (!updated.ok) {
+      this.addRhiFault(updated.error, 'main', filtered.plan.revision);
+      return updated;
+    }
+    const shadowPrepared = this.prepareShadowViews(scene, shadowSubmission, input.meshes);
+    if (!shadowPrepared.ok) {
+      this.addRhiFault(shadowPrepared.error, 'all', shadowSubmission.revision);
+      return shadowPrepared;
+    }
+    const view = this.view;
+    const raster = this.raster;
+    const sceneIdentity = this.sceneIdentity(scene.scene);
+    const viewInspection = view.inspect();
+    let signature = this.signatureCache?.value;
+    if (
+      signature === undefined ||
+      this.signatureCache?.filtered !== filtered ||
+      this.signatureCache.sceneIdentity !== sceneIdentity ||
+      this.signatureCache.viewResourceGeneration !== viewInspection.resourceGeneration ||
+      this.signatureCache.meshResidencyEpoch !== input.meshResidencyEpoch
+    ) {
+      signature = JSON.stringify({
+        sceneIdentity,
+        revision: filtered.plan.revision,
+        meshResidencyEpoch: input.meshResidencyEpoch,
+        viewResourceGeneration: viewInspection.resourceGeneration,
+        batches: filtered.batches.map(({ batch, mesh }) => [
+          batch.batchId,
+          batch.generation,
+          batch.visibleBase,
+          batch.candidates.map((candidate) => [
+            candidate.primitiveIndex,
+            candidate.generation,
+            candidate.instanceOrdinal,
+          ]),
+          mesh.vboBytes,
+          mesh.iboBytes,
+          mesh.indexFormat,
+          mesh.layoutProjection.digest,
+        ]),
+        capacities: [
+          viewInspection.candidateCapacity,
+          viewInspection.batchCapacity,
+          viewInspection.indirectCapacity,
+        ],
+      });
+      this.signatureCache = {
+        filtered,
+        sceneIdentity,
+        viewResourceGeneration: viewInspection.resourceGeneration,
+        meshResidencyEpoch: input.meshResidencyEpoch,
+        value: signature,
+      };
+    }
+    return ok({
+      topologySignature: signature,
+      ownedItemKeys: filtered.itemKeys,
+      ownsAllForwardItems:
+        filtered.forwardItemKeys.size > 0 &&
+        [...filtered.forwardItemKeys].every((key) => filtered.itemKeys.has(key)),
+      shadowSubmission,
+      project: (graph, format, sampleCount) => {
+        const outputs = view.addPasses(graph);
+        if (!outputs.ok) return outputs;
+        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) {
+          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,
+            );
+            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,
+          );
+          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,
+          });
+        }
+        const shadow: RenderPipelineGpuDrivenShadowProjection[] = [];
+        const shadowRaster = this.shadowRaster;
+        if (shadowRaster !== undefined) {
+          for (const prepared of this.preparedShadowViews) {
+            const shadowOutputs = prepared.view.addPasses(graph, prepared.graphLabel);
+            if (!shadowOutputs.ok) return shadowOutputs;
+            const shadowAccesses: GraphAccess[] = [
+              { resource: shadowOutputs.value.primitive, usage: 'storage-read' },
+              { resource: shadowOutputs.value.instance, usage: 'storage-read' },
+              { resource: shadowOutputs.value.transform, usage: 'storage-read' },
+              { resource: shadowOutputs.value.visible, usage: 'storage-read' },
+              { resource: shadowOutputs.value.indirect, usage: 'indirect-read' },
+            ];
+            const meshBuffers = new Map<
+              number,
+              { readonly vertex: GraphBuffer; readonly index?: GraphBuffer }
+            >();
+            for (const batch of prepared.batches) {
+              let buffers = meshBuffers.get(batch.batch.key.assetHandle);
+              if (buffers === undefined) {
+                const vertex = graph.importBuffer(
+                  `${prepared.graphLabel}.mesh.${batch.batch.key.assetHandle}.vertex`,
+                  {
+                    size: batch.mesh.vboBytes,
+                    usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST,
+                  },
+                  () => batch.mesh.vertexBuffer.handle,
+                );
+                if (!vertex.ok) return vertex;
+                let index: GraphBuffer | undefined;
+                if (batch.mesh.indexBuffer !== null) {
+                  const imported = graph.importBuffer(
+                    `${prepared.graphLabel}.mesh.${batch.batch.key.assetHandle}.index`,
+                    {
+                      size: batch.mesh.iboBytes,
+                      usage: GPU_BUFFER_USAGE_INDEX | GPU_BUFFER_USAGE_COPY_DST,
+                    },
+                    () => batch.mesh.indexBuffer?.handle as import('@forgeax/engine-rhi').Buffer,
+                  );
+                  if (!imported.ok) return imported;
+                  index = imported.value;
+                }
+                buffers = { vertex: vertex.value, ...(index === undefined ? {} : { index }) };
+                meshBuffers.set(batch.batch.key.assetHandle, buffers);
+                shadowAccesses.push({ resource: buffers.vertex, usage: 'vertex-read' });
+                if (buffers.index !== undefined) {
+                  shadowAccesses.push({ resource: buffers.index, usage: 'index-read' });
+                }
+              }
+            }
+            shadow.push({
+              cascadeIndex: prepared.cascadeIndex,
+              accesses: Object.freeze(shadowAccesses),
+              batchCount: prepared.batches.length,
+              encode: (pass, resources) =>
+                shadowRaster.encode(prepared, resources, shadowOutputs.value, pass),
+            });
+          }
+        }
+        return ok({
+          accesses,
+          shadow: Object.freeze(shadow),
+          encode: (viewBindGroup, pass, resources: GraphResourceResolver) => {
+            pass.setBindGroup(0, viewBindGroup);
+            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;
+              if (batch.batch.key.drawKind === 'indexed') {
+                pass.drawIndexedIndirect(indirect.value, batch.batch.indirectOffset);
+              } else {
+                pass.drawIndirect(indirect.value, batch.batch.indirectOffset);
+              }
+            }
+          },
+        });
+      },
+    });
+  }
+
+  /**
+   * Intersect the four-view visibility result with the shared ShadowCaster
+   * topology. This is the only production candidate-to-submission join; CPU
+   * fallback devices consume the same immutable plans as indirect-capable
+   * devices.
+   */
+  multiViewSubmissions(): readonly MultiViewProductionSubmission[] {
+    if (this.cpuVisibility === undefined || this.shadowSubmission === undefined) {
+      return [];
+    }
+    const shadowSubmission = this.shadowSubmission;
+    return Object.freeze(
+      this.cpuVisibility.views.map((view) => {
+        const candidateIndexByStableId = new Map<number, number>();
+        for (const candidate of view.compactVisible) {
+          if (candidate.candidateIndex !== undefined) {
+            candidateIndexByStableId.set(candidate.stableId, candidate.candidateIndex);
+          }
+        }
+        const plan = this.shadowSubmissionForView(shadowSubmission, view);
+        const candidateIndices = new Set<number>();
+        for (const batch of plan.batches) {
+          for (const candidate of batch.candidates) {
+            const candidateIndex = candidateIndexByStableId.get(candidate.primitiveIndex);
+            if (candidateIndex !== undefined) candidateIndices.add(candidateIndex);
+          }
+        }
+        return Object.freeze({
+          source: 'multi-view-indirect' as const,
+          viewId: view.viewId,
+          kind: view.kind,
+          cascadeIndex: view.cascadeIndex,
+          volumeRevision: view.volumeRevision,
+          spatialIndexRevision: view.spatialIndexRevision,
+          overflow: view.overflow,
+          plan,
+          candidateIndexByStableId,
+          candidateIndices,
+          faults: Object.freeze(
+            this.faults.filter((fault) => fault.viewId === 'all' || fault.viewId === view.viewId),
+          ),
+        });
+      }),
+    );
+  }
+
+  private prepareShadowViews(
+    scene: PersistentGpuDrivenState,
+    shadowSource: SubmissionPlan,
+    meshes: ReadonlyMap<number, MeshGpuHandles>,
+  ): Result<void, RhiError> {
+    this.preparedShadowViews = [];
+    if (this.shadowRaster === undefined || this.cpuVisibility === undefined) return ok(undefined);
+    const slotByPrimitive = new Map(scene.slots.map((slot) => [slot.slot, slot] as const));
+    const descriptorByView = new Map(
+      this.visibilityViews.map((view) => [view.viewId, view] as const),
+    );
+    const prepared: PreparedShadowView[] = [];
+    for (const viewResult of this.cpuVisibility.views) {
+      if (viewResult.kind !== 'cascade' || viewResult.cascadeIndex === undefined) continue;
+      const descriptor = descriptorByView.get(viewResult.viewId);
+      if (
+        descriptor === undefined ||
+        descriptor.lightViewProj === undefined ||
+        descriptor.planes.length < 24 ||
+        viewResult.overflow
+      ) {
+        if (viewResult.overflow) {
+          this.addFault({
+            code: 'visibility-overflow',
+            viewId: viewResult.viewId,
+            revision: shadowSource.revision,
+            fallback: 'cpu-batch-contract',
+            detail:
+              'compact visibility capacity was exceeded; the complete CPU batch contract remains authoritative',
+          });
+        } else if (descriptor === undefined || descriptor.lightViewProj === undefined) {
+          this.addFault({
+            code: 'gpu-resource-failed',
+            viewId: viewResult.viewId,
+            revision: shadowSource.revision,
+            fallback: 'cpu-batch-contract',
+            detail: 'cascade volume did not publish a canonical raster matrix',
+          });
+        }
+        continue;
+      }
+      const plan = this.shadowSubmissionForView(shadowSource, viewResult);
+      if (plan.batches.length === 0) continue;
+      let gpuSafe = true;
+      for (const batch of plan.batches) {
+        const mesh = meshes.get(batch.key.assetHandle);
+        if (
+          batch.key.alphaTest ||
+          (batch.key.materialClass !== 'forgeax::default-unlit' &&
+            batch.key.materialClass !== 'forgeax::default-standard-pbr') ||
+          mesh === undefined ||
+          !supportsRigidGpuDrivenProjection(mesh) ||
+          (batch.key.topology !== 'triangle-list' && batch.key.topology !== 'triangle-strip') ||
+          (batch.key.drawKind === 'indexed' && (!mesh.indexed || mesh.indexBuffer === null)) ||
+          (batch.key.drawKind === 'non-indexed' && mesh.indexed)
+        ) {
+          gpuSafe = false;
+          break;
+        }
+        for (const candidate of batch.candidates) {
+          const slot = slotByPrimitive.get(candidate.primitiveIndex);
+          if (
+            slot === undefined ||
+            slot.fact.bounds.status !== 'present' ||
+            slot.snapshot.gpuDrivenDraws === undefined
+          ) {
+            gpuSafe = false;
+            break;
+          }
+        }
+        if (!gpuSafe) break;
+      }
+      if (!gpuSafe) {
+        this.addFault({
+          code: 'gpu-scene-fact-unavailable',
+          viewId: viewResult.viewId,
+          revision: shadowSource.revision,
+          fallback: 'cpu-batch-contract',
+          detail:
+            'one or more casters lack bounded GPU Scene facts required by the exact shadow cull',
+        });
+        continue;
+      }
+      let view = this.shadowViews.get(viewResult.cascadeIndex);
+      if (view === undefined) {
+        const created = GpuDrivenView.create({
+          device: this.device,
+          shaderModuleFactory: this.shaderModuleFactory,
+        });
+        if (!created.ok) {
+          this.addRhiFault(created.error, viewResult.viewId, shadowSource.revision);
+          continue;
+        }
+        view = created.value;
+        this.shadowViews.set(viewResult.cascadeIndex, view);
+      }
+      const updated = view.update(plan, scene.scene, descriptor.planes);
+      if (!updated.ok) {
+        this.addRhiFault(updated.error, viewResult.viewId, shadowSource.revision);
+        continue;
+      }
+      const shadowView = this.shadowRaster.prepareView({
+        cascadeIndex: viewResult.cascadeIndex,
+        scene: scene.scene,
+        view,
+        plan,
+        lightViewProj: descriptor.lightViewProj,
+        meshes,
+        graphLabel: `gpu-driven.shadow.cascade-${viewResult.cascadeIndex}`,
+      });
+      if (!shadowView.ok) {
+        this.addRhiFault(shadowView.error, viewResult.viewId, shadowSource.revision);
+        continue;
+      }
+      if (shadowView.value !== undefined) prepared.push(shadowView.value);
+    }
+    this.preparedShadowViews = Object.freeze(prepared);
+    return ok(undefined);
+  }
+
+  private shadowSubmissionForView(
+    shadowSubmission: SubmissionPlan,
+    view: CpuMultiViewVisibilityResult['views'][number],
+  ): SubmissionPlan {
+    const cached = this.shadowPlanCache.get(view.viewId);
+    const stableIds = view.compactVisible.map((candidate) => candidate.stableId);
+    const generations = view.compactVisible.map((candidate) => candidate.generation);
+    if (
+      cached !== undefined &&
+      cached.source === shadowSubmission &&
+      sameNumberArray(cached.stableIds, stableIds) &&
+      sameNumberArray(cached.generations, generations)
+    ) {
+      return cached.plan;
+    }
+    let reverse = this.shadowCandidateMembership;
+    if (reverse?.source !== shadowSubmission) {
+      reverse = buildSubmissionCandidateMembership(shadowSubmission);
+      this.shadowCandidateMembership = reverse;
+    }
+    const candidatesByBatch = new Map<number, GpuDrivenCandidate[]>();
+    // compactVisible is stable-id ordered because the CPU visibility owner
+    // sorts its candidate domain once. Appending each slot's source-order
+    // candidates therefore preserves the old deterministic order while
+    // changing the join from O(all shadow candidates per cascade) to
+    // O(selected candidates).
+    for (const visible of view.compactVisible) {
+      const entries = reverse.byPrimitiveIndex.get(visible.stableId);
+      if (entries === undefined) continue;
+      for (const entry of entries) {
+        if (entry.candidate.generation !== visible.generation) continue;
+        const candidates = candidatesByBatch.get(entry.batchId) ?? [];
+        candidates.push(entry.candidate);
+        candidatesByBatch.set(entry.batchId, candidates);
+      }
+    }
+    const frozenCandidatesByBatch = new Map<number, readonly GpuDrivenCandidate[]>();
+    for (const [batchId, candidates] of candidatesByBatch) {
+      frozenCandidatesByBatch.set(batchId, Object.freeze(candidates));
+    }
+    const plan = buildBatchAlignedSubmission(shadowSubmission, frozenCandidatesByBatch);
+    this.shadowPlanCache.set(view.viewId, {
+      source: shadowSubmission,
+      stableIds: Object.freeze(stableIds),
+      generations: Object.freeze(generations),
+      plan,
+    });
+    return plan;
+  }
+
+  dispose(): void {
+    this.view?.dispose();
+    for (const view of this.shadowViews.values()) view.dispose();
+    this.shadowViews.clear();
+    this.shadowRaster?.dispose();
+    this.view = undefined;
+    this.raster = undefined;
+    this.shadowRaster = undefined;
+    this.preparedShadowViews = [];
+    this.filteredCache = undefined;
+    this.signatureCache = undefined;
+    this.cpuVisibility = undefined;
+    this.shadowCasterSlotIndices = undefined;
+    this.shadowSubmission = undefined;
+    this.shadowPlanCache.clear();
+    this.shadowCandidateMembership = undefined;
+  }
+
+  inspect(): GpuDrivenProductionInspection {
+    const view = this.view?.inspect();
+    return {
+      gpuOwnedSnapshotsMaterialized: this.gpuOwnedSnapshotsMaterialized,
+      filteredPlanBuilds: this.filteredPlanBuilds,
+      gpuOwnedItemCount: this.gpuOwnedItemCount,
+      candidateUploadBytes: view?.candidateUploadBytes ?? 0,
+      batchUploadBytes: view?.batchUploadBytes ?? 0,
+      viewConstantsUploadBytes: view?.viewConstantsUploadBytes ?? 0,
+      batchBindGroupCreates: this.batchBindGroupCreates,
+      viewBindGroupCreates: view?.bindGroupCreates ?? 0,
+      topologyRevision: view?.topologyRevision,
+      validatedGpuOwnedRows: this.validatedGpuOwnedRows,
+      cpuFallbackDrawItems: this.cpuFallbackDrawItems,
+      cpuVisibility: this.cpuVisibility,
+      shadowBatchCount: this.shadowSubmission?.batches.length ?? 0,
+      shadowCandidateCount: this.shadowSubmission?.candidateCount ?? 0,
+      shadowDrawCount: this.preparedShadowViews.reduce(
+        (total, prepared) => total + prepared.batches.length,
+        0,
+      ),
+      faults: this.faults,
+    };
+  }
+
+  recordCpuValidation(
+    validated: readonly { readonly source: RenderableSnapshot }[],
+    gpuOwned: ReadonlySet<RasterItemKey>,
+  ): void {
+    let cpuFallbackItems = 0;
+    for (const row of validated) {
+      for (const draw of row.source.gpuDrivenDraws ?? []) {
+        const key = rasterItemKey(
+          row.source.worldId,
+          row.source.entityKey,
+          draw.submeshIndex,
+          draw.passIndex,
+        );
+        if (!gpuOwned.has(key)) cpuFallbackItems += 1;
+      }
+    }
+    this.cpuFallbackDrawItems = cpuFallbackItems;
+    // Validation remains a renderable/mesh-residency phase. Ownership is
+    // published only for item keys, so no validated row is GPU-owned.
+    this.validatedGpuOwnedRows = 0;
+  }
+
+  private sceneIdentity(scene: object): number {
+    const existing = this.sceneIdentities.get(scene);
+    if (existing !== undefined) return existing;
+    const identity = this.nextSceneIdentity;
+    this.nextSceneIdentity += 1;
+    this.sceneIdentities.set(scene, identity);
+    return identity;
+  }
+
+  private addFault(fault: GpuDrivenVisibilityFault): void {
+    this.faults = Object.freeze([...this.faults, Object.freeze(fault)]);
+  }
+
+  private addRhiFault(error: RhiError, viewId: string, revision: number): void {
+    const requiresRecovery = error.code === 'device-lost' || error.code === 'oom';
+    this.addFault({
+      code: requiresRecovery ? 'device-recovery-required' : 'gpu-resource-failed',
+      viewId,
+      revision,
+      fallback: requiresRecovery ? 'scene-rebuild' : 'cpu-batch-contract',
+      detail: `${error.code}: ${error.message}`,
+    });
+  }
+}