@forgeax/engine-render 0.1.32 → 0.1.34

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

@@ -1,4 +1,3 @@
-import { deriveVertexBufferLayoutFromProjection } from '@forgeax/engine-geometry';
 import { frustum, mat3, mat4 } from '@forgeax/engine-math';
 import type {
   GraphAccess,
@@ -28,11 +27,11 @@ import {
   gpuDrivenShadowDrawKey,
   gpuDrivenSourceDrawItemIndex,
 } from '../extract/gpu-driven';
-import { GPU_SCENE_LAYOUTS } from '../gpu-scene-schema';
 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 type {
@@ -42,12 +41,15 @@ import type {
   GpuDrivenProductionInspection,
   GpuDrivenStructureMetrics,
 } from '../inspection-types';
-import { isStandardPbrMaterialShader, resolvePipelineGroup2Contract } from '../pbr-pipeline';
+import {
+  isCanonicalStandardPbrMaterialShader,
+  isStandardPbrMaterialShader,
+  resolvePipelineGroup2Contract,
+} from '../pbr-pipeline';
 import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
 import type { ValidatedRenderable } from '../record/frame-snapshot';
-import { worldEntityKey } from '../record/frame-snapshot';
+import { getOpaqueResourceIdentity, worldEntityKey } from '../record/frame-snapshot';
 import { geometryRenderStateForTopology } from '../record/main-pass-material';
-import { MESH_SSBO_BYTES, packInstanceStorageBuffer } from '../record/mesh-ssbo';
 import {
   MATERIAL_PER_ENTITY_STRIDE,
   type PipelineState,
@@ -55,7 +57,6 @@ import {
 } from '../record/render-context';
 import type { CameraSnapshot } from '../render-contract';
 import type {
-  GpuDrivenSceneMeshBinding,
   GpuDrivenStandardPbrFrameResources,
   RenderPipelineFrame,
   RenderPipelineGpuDrivenProjection,
@@ -69,14 +70,27 @@ import type {
 import type { PersistentGpuDrivenState } from '../scene/render-scene';
 import { selectLod } from '../scene/visibility/lod-selector';
 import type { OcclusionFrameProjection } from '../scene/visibility/occlusion-runtime';
+import type {
+  DynamicInputRange,
+  ReadonlyDynamicInputPage,
+  SurfaceDynamicInputFrame,
+} from '../surface/dynamic-input';
+import {
+  admitSingleLayerMediumSubmission,
+  type SurfaceGpuSubmissionAdmission,
+} from '../surface/gpu-driven';
+import type { SurfaceSubmissionCandidate } from '../surface/submission-observation';
 import {
   type GpuDrivenBatch,
   type GpuDrivenCandidate,
+  inspectResourceClassSplits,
   projectedHeightForCandidate,
   type SubmissionPlan,
 } from './batch-topology';
+import { requiresProbeBlendRecord } from './material-artifacts';
 import { materialBindingKey } from './material-bindings';
-import { type GpuDrivenPbrProgram, resolveStandardPbrProgram } from './pbr-program';
+import { MaterialAbiRasterAdapter } from './production-raster-material';
+import { combineGpuResourceAllocationInspections } from './resource-allocation';
 import {
   type ShadowViewIdentity,
   type ShadowViewProjection,
@@ -84,7 +98,12 @@ import {
   type ShadowViewUpdateInput,
   shadowViewIdentityKey,
 } from './shadow-views';
-import { type GpuDrivenLodSelectionInspection, GpuDrivenView, selectGpuLodLane } from './view-gpu';
+import {
+  type GpuDrivenLodSelectionInspection,
+  type GpuDrivenLodSubmitIdentity,
+  GpuDrivenView,
+  selectGpuLodLane,
+} from './view-gpu';
 
 export interface StandardPbrSceneCandidate {
   readonly primitiveIndex: number;
@@ -95,6 +114,39 @@ export interface StandardPbrSceneCandidate {
   readonly materialIndex?: number;
 }
 
+/** Keep visible.x and the selected group(2) mesh page in one address domain. */
+export function resolveGpuDrivenMeshGroup(input: {
+  readonly clustered: boolean;
+  readonly deformation: 'rigid' | 'skin';
+  readonly meshBindGroup: BindGroup;
+  readonly meshProjectionBuffer: Buffer;
+  readonly meshProjectionBytes: number;
+  readonly frameResources: Pick<
+    GpuDrivenStandardPbrFrameResources,
+    'clusterBindGroup' | 'clusterBindGroupForMesh' | 'clusterBindGroupForSkin'
+  >;
+  readonly skinPaletteBinding?:
+    | { readonly buffer: Buffer; readonly bindingWindowBytes: number }
+    | undefined;
+}): BindGroup | undefined {
+  if (!input.clustered) return input.meshBindGroup;
+  if (input.deformation === 'skin') {
+    const palette = input.skinPaletteBinding;
+    return palette === undefined
+      ? undefined
+      : input.frameResources.clusterBindGroupForSkin?.(
+          input.meshProjectionBuffer,
+          input.meshProjectionBytes,
+          palette.buffer,
+          palette.bindingWindowBytes,
+        );
+  }
+  return input.frameResources.clusterBindGroupForMesh?.(
+    input.meshProjectionBuffer,
+    input.meshProjectionBytes,
+  );
+}
+
 export interface StandardPbrSceneProjection {
   readonly entryPoint: string;
   readonly layoutIdentity: string;
@@ -253,21 +305,34 @@ interface PreparedBatch {
   readonly slotGeneration: number;
 }
 
-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 }),
-    },
+/**
+ * Renderer-owned join between the scene-index candidate rows and a Surface
+ * producer range. The user-facing range keeps its formal instance address;
+ * the frame row is assigned after the RenderScene plan has been filtered and
+ * its visible bases are known.
+ */
+interface SurfaceFrameRange {
+  readonly frameIndex: number;
+  readonly range?: DynamicInputRange;
+  readonly directMember: {
+    readonly worldIdentity: string;
+    readonly worldId: number;
+    readonly entityKey: number;
+    readonly drawItemIndex: number;
+    readonly instanceOrdinal: number;
   };
 }
 
+interface SurfaceFrameProjection {
+  readonly ranges: readonly SurfaceFrameRange[];
+  readonly consumptionRanges: readonly DynamicInputRange[];
+  readonly capacity: number;
+}
+
+function surfaceDynamicInputError(expected: string, hint: string): RhiError {
+  return new RhiError({ code: 'rhi-descriptor-invalid', expected, hint });
+}
+
 function activeFrustum(camera: CameraSnapshot): Float32Array {
   const projection = mat4.create();
   if (camera.projection === 'orthographic') {
@@ -925,6 +990,136 @@ function shadowCasterMembershipSignature(
 
 type FilteredProductionPlan = ReturnType<typeof filteredPlan>;
 
+function isSingleLayerMediumArtifact(artifact: MaterialShaderArtifact): boolean {
+  return artifact.receipt?.surface?.model === 'single-layer-medium';
+}
+
+function isSingleLayerMediumBatch(batch: PreparedBatch): boolean {
+  return isSingleLayerMediumArtifact(batch.artifact);
+}
+
+/**
+ * Join Surface ranges to the renderer-owned candidate rows in the visible
+ * stream. The GPU culler may assign atomic compact slots in any order, but
+ * each member preserves the candidate's batch-local projected row in
+ * `visibleItems.x`; frame rows use that same identity rather than the slot.
+ * The producer's `instanceIndex` remains in the range and is copied into the
+ * frame record for the Surface ABI.
+ */
+function buildSurfaceFrameRanges(
+  filtered: FilteredProductionPlan,
+  ranges: readonly DynamicInputRange[],
+  scene: PersistentGpuDrivenState,
+): Result<readonly SurfaceFrameRange[], RhiError> {
+  const slotsByPrimitive = new Map(scene.slots.map((slot) => [slot.slot, slot]));
+  const surfaceMembers: Array<{
+    readonly frameIndex: number;
+    readonly identity: string;
+    readonly directMember: SurfaceFrameRange['directMember'];
+  }> = [];
+  for (const prepared of filtered.batches) {
+    if (!isSingleLayerMediumBatch(prepared)) continue;
+    let visibleMemberIndex = 0;
+    for (const candidate of prepared.batch.candidates) {
+      if (
+        (candidate as GpuDrivenCandidate & { readonly submitAdmission?: boolean })
+          .submitAdmission === false
+      ) {
+        continue;
+      }
+      const slot = slotsByPrimitive.get(candidate.primitiveIndex);
+      const worldIdentity = slot === undefined ? undefined : scene.worldIdentities?.[slot.worldId];
+      if (slot === undefined || worldIdentity === undefined) {
+        return err(
+          new RhiError({
+            code: 'rhi-descriptor-invalid',
+            expected:
+              'every admitted medium draw member has a renderer slot and public World identity',
+            hint: `rebuild the persistent scene projection before publishing Surface ranges (primitive=${candidate.primitiveIndex})`,
+          }),
+        );
+      }
+      surfaceMembers.push({
+        frameIndex: prepared.batch.visibleBase + visibleMemberIndex,
+        directMember: {
+          worldIdentity,
+          worldId: slot.worldId,
+          entityKey: slot.entityKey,
+          drawItemIndex: candidate.drawItemIndex,
+          instanceOrdinal: candidate.instanceOrdinal,
+        },
+        identity: JSON.stringify([
+          worldIdentity,
+          slot.entityKey,
+          candidate.drawItemIndex,
+          candidate.instanceOrdinal,
+        ]),
+      });
+      visibleMemberIndex += 1;
+    }
+  }
+  if (ranges.length === 0) {
+    return ok(
+      Object.freeze(
+        surfaceMembers.map(({ frameIndex, directMember }) => ({ frameIndex, directMember })),
+      ),
+    );
+  }
+  const rangeByIdentity = new Map<string, DynamicInputRange>();
+  for (const range of ranges) {
+    const identity = JSON.stringify([
+      range.member.worldIdentity,
+      range.member.entityKey,
+      range.member.drawItemIndex,
+      range.member.instanceOrdinal,
+    ]);
+    if (rangeByIdentity.has(identity)) {
+      return err(
+        new RhiError({
+          code: 'rhi-descriptor-invalid',
+          expected: 'at most one Surface dynamic range for each stable draw member',
+          hint: `remove the duplicate producer range for member ${identity}`,
+        }),
+      );
+    }
+    rangeByIdentity.set(identity, range);
+  }
+  if (ranges.length !== surfaceMembers.length) {
+    return err(
+      new RhiError({
+        code: 'rhi-descriptor-invalid',
+        expected: 'one stable-identity Surface dynamic range for every admitted medium draw member',
+        hint: `publish one range per admitted Surface member (ranges=${ranges.length}, members=${surfaceMembers.length})`,
+      }),
+    );
+  }
+  const frameRanges: SurfaceFrameRange[] = [];
+  for (const member of surfaceMembers) {
+    const range = rangeByIdentity.get(member.identity);
+    if (range === undefined) {
+      return err(
+        new RhiError({
+          code: 'rhi-descriptor-invalid',
+          expected: 'every admitted medium draw member resolves one stable-identity Surface range',
+          hint: `publish the missing producer range for member ${member.identity}`,
+        }),
+      );
+    }
+    rangeByIdentity.delete(member.identity);
+    frameRanges.push({ frameIndex: member.frameIndex, range, directMember: member.directMember });
+  }
+  if (rangeByIdentity.size !== 0) {
+    return err(
+      new RhiError({
+        code: 'rhi-descriptor-invalid',
+        expected: 'every Surface range identifies an admitted medium draw member',
+        hint: `remove ranges for non-admitted members: ${[...rangeByIdentity.keys()].join(', ')}`,
+      }),
+    );
+  }
+  return ok(Object.freeze(frameRanges));
+}
+
 function sceneRequiresGpuDrivenArtifact(scene: PersistentGpuDrivenState): boolean {
   return scene.plan.batches.some((batch) =>
     batch.candidates.some((candidate) => {
@@ -1134,736 +1329,11 @@ function materialArtifactSignature(
 }
 
 /** The GPU-driven bridge to the existing four-group Standard PBR pipeline. */
-class MaterialAbiRasterAdapter {
-  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 pipelineLayout: import('@forgeax/engine-rhi').PipelineLayout,
-    private readonly meshLayout: BindGroupLayout,
-    private readonly instancesBindGroupLayout: BindGroupLayout,
-    private readonly programs: ReadonlyMap<string, GpuDrivenPbrProgram> | undefined,
-    private instancesBindGroup: BindGroup,
-    private readonly instanceBuffer: Buffer,
-    private readonly instanceBufferSize: number,
-    private visibleBuffer: Buffer,
-    private readonly artifact: MaterialShaderArtifact,
-    private readonly deformation: 'rigid' | 'skin',
-    private readonly pipelineFactory: MaterialPipelineFactory | undefined,
-    private paletteBuffer: Buffer | undefined,
-    private paletteBindingWindowBytes: number | undefined,
-  ) {}
-
-  static create(input: {
-    readonly device: RhiDevice;
-    readonly pipelineState: PipelineState;
-    readonly artifact: MaterialShaderArtifact;
-    readonly visibleBuffer: Buffer;
-    readonly deformation?: 'rigid' | 'skin';
-    readonly paletteBuffer?: Buffer;
-    readonly paletteBindingWindowBytes?: number;
-    /** Renderer-owned factory for the selected artifact's actual PSO. */
-    readonly pipelineFactory?: MaterialPipelineFactory;
-  }): Result<MaterialAbiRasterAdapter, RhiError | GpuDrivenPreparationError> {
-    const deformation = input.deformation ?? 'rigid';
-    const receipt = input.artifact.receipt;
-    if (receipt === undefined) {
-      return err(
-        new RhiError({
-          code: 'rhi-not-available',
-          expected: 'published MaterialProgramAbi receipt for the selected material artifact',
-          hint: 'recook and publish the material before creating a GPU-driven raster owner',
-        }),
-      );
-    }
-    const materialRowMatchesSceneTable =
-      receipt.materialRow.byteLength === GPU_SCENE_LAYOUTS.material.stride &&
-      new Set(receipt.materialRow.fields).size === receipt.materialRow.fields.length;
-    if (!materialRowMatchesSceneTable) {
-      return err(
-        new GpuDrivenPreparationError('material-abi-not-executable', {
-          reason: 'material-abi-not-executable',
-          owner: 'material',
-          expected: `scene-index material row ${GPU_SCENE_LAYOUTS.material.stride} bytes with unique producer fields`,
-          actual: `row ${receipt.materialRow.byteLength} bytes with fields ${receipt.materialRow.fields.join(',')}`,
-        }),
-      );
-    }
-    if (
-      receipt.reflection.layoutIdentity !== input.artifact.layoutIdentity ||
-      receipt.directEntry.length === 0 ||
-      receipt.sceneIndexEntry.length === 0 ||
-      receipt.resourceSlots.some((slot) => slot.group !== 1)
-    ) {
-      return err(
-        new RhiError({
-          code: 'rhi-descriptor-invalid',
-          expected: `complete selected MaterialProgramAbi reflection, scene row stride ${GPU_SCENE_LAYOUTS.material.stride}, and resource slots`,
-          hint: 'repair the producer publication or use the owner for its non-scene material layout',
-        }),
-      );
-    }
-    // Scene-index shaders declare the dedicated slot-3 ABI. Keep the legacy
-    // fields as a compatibility fallback for synthetic fixtures; the real
-    // factory publishes the dedicated handles whenever the capable storage
-    // lane is enabled, so production draws never bind the direct-draw BGL.
-    const pipelineLayout =
-      deformation === 'skin'
-        ? input.pipelineState.gpuDrivenPbrSkinPipelineLayout
-        : 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 ' : ''}published material pipeline layout`,
-          hint: 'initialize the producer material pipeline before enabling GPU-driven raster',
-        }),
-      );
-    }
-    const programs = input.pipelineState.gpuDrivenPbrPrograms;
-    if (
-      input.pipelineFactory === undefined &&
-      (programs === undefined ||
-        resolveStandardPbrProgram(
-          programs,
-          input.artifact.material,
-          input.artifact.receipt?.vertexInputs.some((attribute) => attribute.semantic === 'color'),
-        ) === undefined)
-    ) {
-      return err(
-        new RhiError({
-          code: 'rhi-not-available',
-          expected: `producer-owned ${deformation === 'skin' ? 'skinned ' : ''}material shader module for the current device generation`,
-          hint: 'publish the selected material 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 ' : ''}material 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,
-          resource: bufferBinding(instanceBuffer.value, 0, instancePayload.byteLength),
-        },
-        {
-          binding: 1,
-          resource: bufferBinding(input.visibleBuffer),
-        },
-        {
-          binding: 2,
-          resource: bufferBinding(input.visibleBuffer),
-        },
-      ],
-    });
-    if (!instancesBindGroup.ok) return instancesBindGroup;
-    return ok(
-      new MaterialAbiRasterAdapter(
-        input.device,
-        pipelineLayout,
-        meshLayout,
-        instancesBindGroupLayout,
-        programs,
-        instancesBindGroup.value,
-        instanceBuffer.value,
-        instancePayload.byteLength,
-        input.visibleBuffer,
-        input.artifact,
-        deformation,
-        input.pipelineFactory,
-        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,
-    layoutProjection: MeshGpuHandles['layoutProjection'],
-    shaderUvSetCount: number,
-    topology: GpuDrivenBatch['key']['topology'],
-    stripIndexFormat: 'uint16' | 'uint32' | undefined,
-    renderState: MaterialRenderState | undefined,
-    selectedArtifact: MaterialShaderArtifact = this.artifact,
-    additionalColorFormats: readonly TextureFormat[] = [],
-  ): Result<RenderPipeline, RhiError> {
-    const vertexLayout = deriveVertexBufferLayoutFromProjection(layoutProjection, {
-      shaderUvSetCount,
-    })[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 receipt = selectedArtifact.receipt;
-    if (receipt === undefined) {
-      return err(
-        new RhiError({
-          code: 'rhi-not-available',
-          expected: 'selected MaterialProgramAbi receipt for GPU-driven raster',
-          hint: 'keep the draw on the producer recovery path until its ABI is published',
-        }),
-      );
-    }
-    const program =
-      this.programs === undefined
-        ? undefined
-        : resolveStandardPbrProgram(
-            this.programs,
-            this.artifact.material,
-            layoutProjection.attributes.some((attribute) => attribute.key === 'color'),
-          );
-    if (this.pipelineFactory === undefined && program === undefined) {
-      return err(
-        new RhiError({
-          code: 'rhi-not-available',
-          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}:${additionalColorFormats.join(',')}|${sampleCount}|${vertexLayout.arrayStride}|${topology}|${stripIndexFormat ?? ''}|${JSON.stringify(renderState ?? null)}|${selectedArtifact.material}|${selectedArtifact.layoutIdentity}|${receipt.receiptIdentity}|${receipt.generation}|${selectedArtifact.variantSet ?? ''}|${materialArtifactProgramIdentity(selectedArtifact)}|${selectedArtifact.vertexEntry ?? receipt.sceneIndexEntry}|${selectedArtifact.fragmentEntry ?? ''}|${layoutProjection.digest}|uv${shaderUvSetCount}`;
-    const cached = this.pipelines.get(key);
-    if (cached !== undefined) return ok(cached);
-    if (this.pipelineFactory !== undefined) {
-      const pipelineEntry = this.pipelineFactory(
-        selectedArtifact.specializationKey ?? selectedArtifact.material,
-        false,
-        renderState,
-        topology,
-        stripIndexFormat,
-        selectedArtifact.variantSet,
-        'forward',
-        undefined,
-        sampleCount,
-        format,
-        selectedArtifact.uvSetCount ?? shaderUvSetCount,
-        'depth24plus-stencil8',
-        undefined,
-        layoutProjection,
-        // GPU-driven receipts are already producer-validated. Use the
-        // synchronous shader-module adapter for this submission seam so a
-        // newly loaded authored material cannot lose its first draw to the
-        // ordinary async pre-bake warm-up window.
-        'immediate',
-        this.deformation === 'skin' ? 'gpu-driven-skin' : 'gpu-driven-pbr',
-        receipt.sceneIndexEntry,
-        additionalColorFormats,
-        selectedArtifact.vertexEntry,
-        selectedArtifact.fragmentEntry,
-      );
-      if (pipelineEntry === null) {
-        return err(
-          new RhiError({
-            code: 'rhi-not-available',
-            expected: `producer-owned scene-index pipeline for material '${selectedArtifact.material}'`,
-            hint: 'publish a matching program, entry, layout and resource contract before GPU admission',
-          }),
-        );
-      }
-      const expectedGroup2Contract = resolvePipelineGroup2Contract(selectedArtifact.wgsl);
-      if (pipelineEntry.group2Contract !== expectedGroup2Contract) {
-        return err(
-          new RhiError({
-            code: 'rhi-descriptor-invalid',
-            expected: `GPU-driven ${this.deformation === 'skin' ? 'skinned ' : ''}material pipeline group(2) ${expectedGroup2Contract} contract`,
-            hint: 'custom attachment or incompatible group(2) layouts remain on their specialized lane',
-          }),
-        );
-      }
-      this.pipelines.set(key, pipelineEntry.pipeline);
-      return ok(pipelineEntry.pipeline);
-    }
-    if (
-      program === undefined ||
-      selectedArtifact.material !== this.artifact.material ||
-      selectedArtifact.layoutIdentity !== this.artifact.layoutIdentity ||
-      selectedArtifact.receipt?.receiptIdentity !== this.artifact.receipt?.receiptIdentity
-    ) {
-      return err(
-        new RhiError({
-          code: 'rhi-not-available',
-          expected: 'selected material pipeline factory for the requested ABI artifact',
-          hint: 'do not pair a receipt-backed custom or color variant with the legacy fixed module',
-        }),
-      );
-    }
-    const pipeline = this.device.createRenderPipeline({
-      label: `standard-pbr-gpu-driven.${key}`,
-      layout: this.pipelineLayout,
-      vertex: {
-        module: program.module,
-        entryPoint: selectedArtifact.vertexEntry ?? receipt.sceneIndexEntry,
-        buffers: [
-          {
-            arrayStride: vertexLayout.arrayStride,
-            stepMode: 'vertex',
-            attributes: vertexLayout.attributes.map(({ shaderLocation, offset, format }) => ({
-              shaderLocation,
-              offset,
-              format: format as GPUVertexFormat,
-            })),
-          },
-        ],
-      },
-      fragment: {
-        module: program.module,
-        entryPoint: 'fs_main',
-        targets: [format, ...additionalColorFormats].map((format) => ({ 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;
-  }
-
-  /**
-   * Drop only program-derived caches when a publication switches. Resource
-   * buffers stay alive until their normal fence retirement, while the next
-   * draw must obtain a PSO for the new artifact rather than reuse the old one.
-   */
-  invalidatePipelineCache(): void {
-    this.pipelines.clear();
-  }
-
-  projectionBindGroup(
-    rows: Float32Array,
-    key?: string,
-    capacityRows?: number,
-  ): Result<BindGroup, RhiError> {
-    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);
-    }
-    const created = this.createProjectionBinding(rows, Math.max(MESH_SSBO_BYTES, rows.byteLength));
-    if (!created.ok) return created;
-    return ok(created.value.bindGroup);
-  }
-
-  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);
-  }
-
-  sceneMeshBinding(key: string): GpuDrivenSceneMeshBinding {
-    const binding = this.stagedProjectionBindings.get(key) ?? this.projectionBindings.get(key);
-    if (binding === undefined)
-      throw new RhiError({
-        code: 'rhi-not-available',
-        expected: 'retained scene mesh projection',
-        hint: 'prepare this batch projection before binding its lighting resources',
-      });
-    return {
-      meshBuffer: binding.buffer,
-      meshBytes: binding.capacityBytes,
-      ...(this.deformation === 'skin' && this.paletteBuffer !== undefined
-        ? { paletteBuffer: this.paletteBuffer }
-        : {}),
-    };
-  }
-
-  /** Stage the projection keys required by the frame being prepared. */
-  stageProjectionKeys(keys: ReadonlySet<string>): void {
-    this.stagedProjectionKeys = new Set(keys);
-    this.activeProjectionRowsAtStage.clear();
-  }
-
-  /** 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);
-      }
-    }
-    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();
-  }
-
-  /** 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();
-  }
-
-  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: 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) {
-      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,
-    });
-    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 {
-    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);
-      },
-    );
-  }
-
-  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;
+  /** Composition-local world indices mapped to the stable identities used by draw keys. */
+  readonly worldKeys: readonly number[];
   /** 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. */
@@ -1871,6 +1341,8 @@ export interface PreparedGpuDrivenFrame {
   /** Concrete main-pass draw identities claimed by the GPU projection. */
   readonly drawKeys?: ReadonlySet<string>;
   readonly standardPbrFrameResources: GpuDrivenStandardPbrFrameResources;
+  /** Published Surface admission and its pass lane decision. */
+  readonly surfaceSubmission?: SurfaceGpuSubmissionAdmission;
   readonly occlusion?: OcclusionFrameProjection;
   /** @internal Commits a replacement generation only after graph promotion. */
   readonly _commitResourceReplacement: () => void;
@@ -1878,6 +1350,8 @@ export interface PreparedGpuDrivenFrame {
   readonly _commitGpuResourceReplacement?: () => void;
   /** @internal Discards staged shadow cache publication after a failed frame. */
   readonly _abortResourceReplacement?: () => void;
+  /** @internal Marks validated dynamic ranges consumed only after queue submit. */
+  readonly _consumeSurfaceDynamicInput?: (frameNumber: number) => Result<void, RhiError>;
   /** 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. */
@@ -1898,6 +1372,7 @@ export interface PreparedGpuDrivenFrame {
     graph: RenderGraphBuilder<RenderPipelineFrame>,
     format: TextureFormat,
     sampleCount: 1 | 4,
+    surfaceSubmissionObservation?: () => SurfaceSubmissionCandidate | undefined,
     additionalColorFormats?: readonly TextureFormat[],
   ): Result<RenderPipelineGpuDrivenProjection, RenderGraphError | RhiError>;
 }
@@ -1931,6 +1406,7 @@ interface GpuDrivenCpuValidationTelemetryCache {
   readonly cacheKey: string;
   readonly validated: readonly { readonly source: RenderableSnapshot }[];
   readonly gpuOwnedDrawKeys: ReadonlySet<string>;
+  readonly worldKeys: readonly number[] | undefined;
   readonly gpuOwnedDrawCount: number;
   readonly totalDrawItems: number;
   readonly gpuOwnedRows: number;
@@ -2042,6 +1518,26 @@ export class GpuDrivenProduction {
         readonly value: FilteredProductionPlan;
       }
     | undefined;
+  private surfaceFrameRangeCache:
+    | {
+        readonly filtered: FilteredProductionPlan;
+        readonly slots: PersistentGpuDrivenState['slots'];
+        readonly page: ReadonlyDynamicInputPage | undefined;
+        readonly projectionRevision: number;
+        readonly value: SurfaceFrameProjection;
+      }
+    | undefined;
+  private consumedSurfaceInput:
+    | {
+        readonly page: ReadonlyDynamicInputPage;
+        readonly projectionRevision: number;
+        readonly contentRevision: number;
+        readonly bufferGeneration: number;
+        readonly deviceGeneration: number;
+      }
+    | undefined;
+  private surfaceFrameRangeBuilds = 0;
+  private surfaceFrameRangeMemberScans = 0;
   private shadowFilteredCache:
     | {
         readonly source: SubmissionPlan;
@@ -2094,6 +1590,8 @@ export class GpuDrivenProduction {
   >();
   private shadowDrawKeysByView = new Map<string, ReadonlySet<string>>();
   private shadowExpectedDrawKeys = new Set<string>();
+  private surfaceSubmission: SurfaceGpuSubmissionAdmission | undefined;
+  private surfaceArtifactInspection: GpuDrivenProductionInspection['surfaceArtifact'];
   private shadowBatchProjectionSource: SubmissionPlan | undefined;
   private skinPaletteBuffer: Buffer | undefined;
   private committedPaletteContentRevision: number | undefined;
@@ -2133,6 +1631,110 @@ export class GpuDrivenProduction {
     private readonly recoveryCount = 0,
   ) {}
 
+  private resolveSurfaceFrameRanges(
+    filtered: FilteredProductionPlan,
+    frame: SurfaceDynamicInputFrame | undefined,
+    scene: PersistentGpuDrivenState,
+  ): Result<SurfaceFrameProjection, RhiError> {
+    const ranges = frame?.ranges ?? [];
+    const projectionRevision = frame?.projectionRevision ?? 0;
+    if (!Number.isSafeInteger(projectionRevision) || projectionRevision < 0) {
+      return err(
+        surfaceDynamicInputError(
+          'the Surface projection revision is a non-negative safe integer',
+          'advance the producer-owned projection revision only when membership or addresses change',
+        ),
+      );
+    }
+    const cached = this.surfaceFrameRangeCache;
+    if (
+      cached?.filtered === filtered &&
+      cached.slots === scene.slots &&
+      cached.page === frame?.page &&
+      cached.projectionRevision === projectionRevision
+    ) {
+      return ok(cached.value);
+    }
+    this.surfaceFrameRangeBuilds += 1;
+    for (const prepared of filtered.batches) {
+      if (!isSingleLayerMediumBatch(prepared)) continue;
+      for (const candidate of prepared.batch.candidates) {
+        if (
+          (candidate as GpuDrivenCandidate & { readonly submitAdmission?: boolean })
+            .submitAdmission !== false
+        ) {
+          this.surfaceFrameRangeMemberScans += 1;
+        }
+      }
+    }
+    const built = buildSurfaceFrameRanges(filtered, ranges, scene);
+    if (!built.ok) return built;
+    let capacity = 1;
+    const consumptionRanges: DynamicInputRange[] = [];
+    for (const entry of built.value) {
+      capacity = Math.max(capacity, entry.frameIndex + 1);
+      if (entry.range !== undefined) consumptionRanges.push(entry.range);
+    }
+    const value = {
+      ranges: built.value,
+      consumptionRanges: Object.freeze(consumptionRanges),
+      capacity,
+    };
+    return ok(value);
+  }
+
+  private rememberSurfaceFrameProjection(
+    filtered: FilteredProductionPlan,
+    frame: SurfaceDynamicInputFrame | undefined,
+    scene: PersistentGpuDrivenState,
+    value: SurfaceFrameProjection,
+  ): void {
+    this.surfaceFrameRangeCache = {
+      filtered,
+      slots: scene.slots,
+      page: frame?.page,
+      projectionRevision: frame?.projectionRevision ?? 0,
+      value,
+    };
+  }
+
+  private consumeSurfaceDynamicInput(
+    page: ReadonlyDynamicInputPage,
+    ranges: readonly DynamicInputRange[],
+    projectionRevision: number,
+    frameNumber: number,
+  ): Result<void, RhiError> {
+    const consumed = this.consumedSurfaceInput;
+    if (
+      consumed?.page === page &&
+      consumed.projectionRevision === projectionRevision &&
+      consumed.contentRevision === page.contentRevision &&
+      consumed.bufferGeneration === page.bufferGeneration &&
+      consumed.deviceGeneration === page.deviceGeneration
+    ) {
+      return ok(undefined);
+    }
+    for (const range of ranges) {
+      const receipt = page.consume(range, frameNumber);
+      if (!receipt.ok) {
+        return err(
+          surfaceDynamicInputError(
+            'each submitted Surface dynamic range was uploaded before graph consumption',
+            receipt.error.hint,
+          ),
+        );
+      }
+    }
+    this.consumedSurfaceInput = {
+      page,
+      projectionRevision,
+      contentRevision: page.contentRevision,
+      bufferGeneration: page.bufferGeneration,
+      deviceGeneration: page.deviceGeneration,
+    };
+    return ok(undefined);
+  }
+
   /**
    * Reuse the last producer-resolved residency rows when all source identity
    * and generation fences still match. Renderables and dispatch entries are
@@ -2219,6 +1821,10 @@ export class GpuDrivenProduction {
     readonly meshBySlot: ReadonlyMap<number, MeshGpuHandles>;
     readonly viewBindGroupLayout: BindGroupLayout;
     readonly meshResidencyEpoch: number;
+    /** Optional for legacy Standard callers; omitted means non-HDRP. */
+    readonly hdrp?: boolean;
+    /** Explicit Standard topology; cluster resources are bound by main-pass. */
+    readonly clustered?: boolean;
     readonly materialBindingClasses?: ReadonlyMap<string, string>;
     /** Cooked producer artifact selected from the frame material catalog. */
     readonly materialArtifact?: MaterialShaderArtifact;
@@ -2232,6 +1838,8 @@ export class GpuDrivenProduction {
     readonly materialArtifacts?: ReadonlyMap<string, MaterialShaderArtifact>;
     /** Per-draw shadow-pass artifacts keyed by the same prepared identity. */
     readonly shadowMaterialArtifacts?: ReadonlyMap<string, MaterialShaderArtifact>;
+    /** Retained ProbeBlend record page; slot N is addressed at aligned lane N+1. */
+    readonly probeBlendRecordBuffer?: Buffer;
     readonly materialPipelineState?: PipelineState;
     readonly standardPbrPipelineState?: PipelineState;
     /** Existing renderer owner that builds the selected artifact PSO/BGL. */
@@ -2246,10 +1854,19 @@ export class GpuDrivenProduction {
     readonly activeEntityRevision?: number;
     /** Total extracted candidates, including facet-suppressed rows. */
     readonly telemetryCandidateCount?: number;
+    /** Public receipt identity for the GPU telemetry copy encoded this frame. */
+    readonly telemetrySubmit?: GpuDrivenLodSubmitIdentity;
     readonly occlusion?: OcclusionFrameProjection;
     /** Per-frame deltas from the existing RenderScene/GPU Scene/palette owners. */
     readonly structureMetrics?: GpuDrivenStructureMetrics;
+    /** World/App frame-time snapshot consumed by authored Surface code. */
+    readonly frameTime?: number;
+    /** Current RHI device generation used for Surface admission. */
+    readonly deviceGeneration?: number;
+    /** Renderer-owned generic read-only Surface page and instance ranges. */
+    readonly surfaceDynamicInput?: SurfaceDynamicInputFrame;
   }): Result<PreparedGpuDrivenFrame | undefined, RhiError | GpuDrivenPreparationError> {
+    this.surfaceArtifactInspection = undefined;
     this.gpuOwnedSnapshotsMaterialized = 0;
     this.filteredPlanBuilds = 0;
     this.batchBindGroupCreates = 0;
@@ -2278,6 +1895,7 @@ export class GpuDrivenProduction {
     this.laneReason = 'capability';
     this.submissionState = 'idle';
     this.shadowExpectedDrawKeys = new Set();
+    this.surfaceSubmission = undefined;
     const capability = classifyRecoveryCapability({
       generation: 0,
       shaderCompilation: true,
@@ -2288,6 +1906,7 @@ export class GpuDrivenProduction {
     });
     if (
       input.scene === undefined ||
+      (input.hdrp === true && input.clustered !== true) ||
       selectGpuLodLane(this.device.caps) === 'cpu' ||
       capability.status === 'disabled'
     ) {
@@ -2325,6 +1944,57 @@ export class GpuDrivenProduction {
     const materialArtifact = input.materialArtifact ?? input.standardPbrArtifact;
     const skinArtifact = input.materialSkinArtifact ?? input.standardPbrSkinArtifact;
     const materialPipelineState = input.materialPipelineState ?? input.standardPbrPipelineState;
+    const surfaceArtifact = [
+      materialArtifact,
+      skinArtifact,
+      ...(input.materialArtifacts === undefined ? [] : input.materialArtifacts.values()),
+    ].find((artifact) => artifact?.receipt?.surface?.model === 'single-layer-medium');
+    this.surfaceArtifactInspection =
+      surfaceArtifact?.receipt === undefined
+        ? undefined
+        : Object.freeze({
+            material: surfaceArtifact.material,
+            specializationKey: surfaceArtifact.specializationKey,
+            variantSet: surfaceArtifact.variantSet,
+            layoutIdentity: surfaceArtifact.layoutIdentity,
+            receiptIdentity: surfaceArtifact.receipt.receiptIdentity,
+            receiptGeneration: surfaceArtifact.receipt.generation,
+            directEntry: surfaceArtifact.receipt.directEntry,
+            sceneIndexEntry: surfaceArtifact.receipt.sceneIndexEntry,
+          });
+    const surfaceDynamicInputLayout = surfaceArtifact?.receipt?.surface?.dynamicInput?.layout;
+    if (surfaceArtifact?.receipt?.surface !== undefined) {
+      const deviceGeneration = input.deviceGeneration ?? 1;
+      const admitted = admitSingleLayerMediumSubmission({
+        abi: surfaceArtifact.receipt,
+        caps: {
+          compute: this.device.caps.compute,
+          storageBuffer: this.device.caps.storageBuffer,
+          indirectDrawing: this.device.caps.indirectDrawing,
+        },
+        sceneIndexReady: surfaceArtifact.receipt.sceneIndexEntry.length > 0,
+        resourcesReady:
+          surfaceArtifact.receipt.reflection.layoutIdentity === surfaceArtifact.layoutIdentity,
+        dynamicInputReady:
+          surfaceArtifact.receipt.surface.dynamicInput === undefined ||
+          input.surfaceDynamicInput !== undefined,
+        deviceGeneration,
+        preparedDeviceGeneration: deviceGeneration,
+      });
+      if (!admitted.ok) {
+        this.lane = 'blocked';
+        this.laneReason = 'resource-not-ready';
+        const failure = new GpuDrivenPreparationError('resource-not-ready', {
+          reason: 'material-resource-missing',
+          owner: 'material',
+          expected: admitted.error.expected,
+          actual: JSON.stringify(admitted.error.actual),
+        });
+        this.preparationFailure = preparationFailureInspection(failure);
+        return err(failure);
+      }
+      this.surfaceSubmission = admitted.value;
+    }
     const artifactSignature = `${materialArtifactSignature(
       input.materialArtifacts,
       materialArtifact,
@@ -2560,6 +2230,7 @@ export class GpuDrivenProduction {
     }
     const updated = this.view.update(filtered.plan, scene.scene, activeFrustum(input.camera));
     if (!updated.ok) return updated;
+    this.view.setTelemetrySubmit(input.telemetrySubmit);
     this.telemetryPrepared = true;
     const view = this.view;
     const visibleBuffer = view.visibleBuffer;
@@ -2582,6 +2253,20 @@ export class GpuDrivenProduction {
         }),
       );
     }
+    const probeBlendRequested = filtered.batches.some(({ artifact }) =>
+      requiresProbeBlendRecord(artifact),
+    );
+    if (probeBlendRequested && input.probeBlendRecordBuffer === undefined) {
+      return err(
+        new GpuDrivenPreparationError('resource-not-ready', {
+          reason: 'material-resource-missing',
+          owner: 'material',
+          expected: 'the retained ProbeBlend record page for every scene-index probe draw',
+          actual: 'the prepared frame did not publish its ProbeBlend record page',
+          recovery: 'retry-same-draw',
+        }),
+      );
+    }
     const committedArtifactChanged =
       this.committedProjectionSource !== undefined &&
       this.committedProjectionSource.materialArtifactSignature !== artifactSignature;
@@ -2607,10 +2292,15 @@ export class GpuDrivenProduction {
         ...(input.materialPipelineFactory === undefined
           ? {}
           : { pipelineFactory: input.materialPipelineFactory }),
+        ...(input.probeBlendRecordBuffer === undefined
+          ? {}
+          : { probeBlendRecordBuffer: input.probeBlendRecordBuffer }),
       });
       if (!created.ok) return created;
       this.materialRaster = created.value;
     } else {
+      const probe = this.materialRaster.ensureProbeBlendRecordBuffer(input.probeBlendRecordBuffer);
+      if (!probe.ok) return probe;
       const rebound = this.materialRaster.ensureVisibleBuffer(visibleBuffer);
       if (!rebound.ok) return rebound;
     }
@@ -2656,6 +2346,10 @@ export class GpuDrivenProduction {
           deformation: 'skin',
           paletteBuffer: skinSnapshot.buffer,
           paletteBindingWindowBytes: skinAllocator.bindingWindowBytes,
+          sharedSurfaceFrame: materialRaster.surfaceDynamicSharedFrameState,
+          ...(input.probeBlendRecordBuffer === undefined
+            ? {}
+            : { probeBlendRecordBuffer: input.probeBlendRecordBuffer }),
           ...(input.materialPipelineFactory === undefined
             ? {}
             : { pipelineFactory: input.materialPipelineFactory }),
@@ -2663,6 +2357,8 @@ export class GpuDrivenProduction {
         if (!created.ok) return created;
         this.skinRaster = created.value;
       } else {
+        const probe = this.skinRaster.ensureProbeBlendRecordBuffer(input.probeBlendRecordBuffer);
+        if (!probe.ok) return probe;
         const rebound = this.skinRaster.ensureVisibleBuffer(visibleBuffer);
         if (!rebound.ok) return rebound;
         const palette = this.skinRaster.ensurePaletteBuffer(
@@ -2679,6 +2375,52 @@ export class GpuDrivenProduction {
       }
     }
     const skinRaster = this.skinRaster;
+    if (this.surfaceSubmission !== undefined) {
+      const surfaceFrameRangesResult = this.resolveSurfaceFrameRanges(
+        filtered,
+        input.surfaceDynamicInput,
+        input.scene,
+      );
+      if (!surfaceFrameRangesResult.ok) return surfaceFrameRangesResult;
+      const surfaceFrameProjection = surfaceFrameRangesResult.value;
+      const surfaceFrameRanges = surfaceFrameProjection.ranges;
+      const surfaceFrameCapacity = Math.max(
+        filtered.plan.visibleCapacity,
+        surfaceFrameProjection.capacity,
+      );
+      const surfaceInput = materialRaster.ensureSurfaceDynamicInput(
+        input.surfaceDynamicInput,
+        surfaceFrameCapacity,
+        input.surfaceDynamicInput?.frameTime ?? input.frameTime ?? 0,
+        surfaceDynamicInputLayout,
+        input.deviceGeneration ?? 1,
+        surfaceFrameRanges,
+      );
+      if (!surfaceInput.ok) return surfaceInput;
+      if (skinRaster !== undefined) {
+        const skinSurfaceInput = skinRaster.ensureSurfaceDynamicInput(
+          input.surfaceDynamicInput,
+          surfaceFrameCapacity,
+          input.surfaceDynamicInput?.frameTime ?? input.frameTime ?? 0,
+          surfaceDynamicInputLayout,
+          input.deviceGeneration ?? 1,
+          surfaceFrameRanges,
+        );
+        if (!skinSurfaceInput.ok) return skinSurfaceInput;
+      }
+      const committedSurfaceInput = materialRaster.commitSurfaceDynamicInput();
+      if (!committedSurfaceInput.ok) return committedSurfaceInput;
+      if (skinRaster !== undefined) {
+        const committedSkinSurfaceInput = skinRaster.commitSurfaceDynamicInput();
+        if (!committedSkinSurfaceInput.ok) return committedSkinSurfaceInput;
+      }
+      this.rememberSurfaceFrameProjection(
+        filtered,
+        input.surfaceDynamicInput,
+        input.scene,
+        surfaceFrameProjection,
+      );
+    }
     const shadowViewPool = this.shadowViews;
     if (shadowViewPool === undefined) {
       return err(
@@ -2834,25 +2576,83 @@ export class GpuDrivenProduction {
         )
         .join('|') ?? '';
     const production = this;
+    const surfaceDynamicInputForCommit =
+      this.surfaceSubmission !== undefined && input.surfaceDynamicInput !== undefined
+        ? {
+            page: input.surfaceDynamicInput.page,
+            ranges: this.surfaceFrameRangeCache?.value.consumptionRanges ?? [],
+            projectionRevision: input.surfaceDynamicInput.projectionRevision,
+          }
+        : undefined;
     return ok({
       get topologySignature() {
         const shadow = shadowTopologySignature();
         return shadow.length === 0 ? signature : `${signature}|shadow=${shadow}`;
       },
       ownsAllDrawItems: filtered.ownsAllDrawItems,
+      worldKeys: scene.worldKeys ?? [],
       ...(input.occlusion === undefined ? {} : { occlusion: input.occlusion }),
       ownsAllShadowCasters,
       drawKeys: filtered.drawKeys,
       shadowDrawKeys: shadowFiltered.shadowDrawKeys,
+      ...(this.surfaceSubmission === undefined
+        ? {}
+        : { surfaceSubmission: this.surfaceSubmission }),
       get shadowDrawKeysByView() {
         return new Map(production.shadowDrawKeysByView);
       },
       standardPbrFrameResources: {
+        resourceGeneration: viewInspection.resourceGeneration,
         materialBindGroups: [],
         materialSlotIndicesByEntity: new Map(),
         instancesBindGroup: materialRaster.instancesFrameGroup,
         materialStride: MATERIAL_PER_ENTITY_STRIDE,
         sceneMaterialBuffer: scene.scene.materialBuffer,
+        ...(this.surfaceSubmission === undefined
+          ? {}
+          : {
+              surfaceDynamicInput: {
+                page: materialRaster.surfaceDynamicInputBuffer,
+                frame: materialRaster.surfaceDynamicFrameBuffer,
+                sharedFrame: materialRaster.surfaceDynamicSharedFrameBuffer,
+                pageBytes: materialRaster.surfaceDynamicInputBufferSize,
+                frameBytes: materialRaster.surfaceDynamicFrameBufferSize,
+                sharedFrameBytes: materialRaster.surfaceDynamicSharedFrameBufferSize,
+              },
+              surfaceDirectInstances: (directInput) => {
+                const resolved = materialRaster.directSurfaceInstances(directInput);
+                if (!resolved.ok) return resolved;
+                const firstInstanceOrdinal = directInput.firstInstanceOrdinal ?? 0;
+                const memberIds: string[] = [];
+                for (let index = 0; index < directInput.instanceCount; index += 1) {
+                  const instanceOrdinal = firstInstanceOrdinal + index;
+                  const frameRange = this.surfaceFrameRangeCache?.value.ranges.find(
+                    ({ directMember }) =>
+                      directMember.worldId === directInput.worldId &&
+                      directMember.entityKey === directInput.entityKey &&
+                      directMember.drawItemIndex === directInput.drawItemIndex &&
+                      directMember.instanceOrdinal === instanceOrdinal,
+                  );
+                  if (frameRange === undefined) {
+                    return err(
+                      surfaceDynamicInputError(
+                        'every direct Surface command resolves the retained public member identity',
+                        `rebuild the Surface projection for world=${directInput.worldId}, entity=${directInput.entityKey}, draw=${directInput.drawItemIndex}, instance=${instanceOrdinal}`,
+                      ),
+                    );
+                  }
+                  memberIds.push(
+                    JSON.stringify([
+                      frameRange.directMember.worldIdentity,
+                      frameRange.directMember.entityKey,
+                      frameRange.directMember.drawItemIndex,
+                      frameRange.directMember.instanceOrdinal,
+                    ]),
+                  );
+                }
+                return ok({ ...resolved.value, memberIds: Object.freeze(memberIds) });
+              },
+            }),
       },
       _commitGpuResourceReplacement: () => {
         view._commitResourceReplacement();
@@ -2868,6 +2668,8 @@ export class GpuDrivenProduction {
         this.lastKnownGoodGeneration = view.inspect().resourceGeneration;
       },
       _abortResourceReplacement: () => {
+        materialRaster.abortSurfaceDynamicInput();
+        skinRaster?.abortSurfaceDynamicInput();
         shadowViewPool._abortResourceReplacement();
         materialRaster.abortProjectionBindings();
         skinRaster?.abortProjectionBindings();
@@ -2875,6 +2677,18 @@ export class GpuDrivenProduction {
         this.submissionState = 'aborted';
         this.retryCount += 1;
       },
+      ...(surfaceDynamicInputForCommit === undefined ||
+      surfaceDynamicInputForCommit.ranges.length === 0
+        ? {}
+        : {
+            _consumeSurfaceDynamicInput: (frameNumber: number) =>
+              this.consumeSurfaceDynamicInput(
+                surfaceDynamicInputForCommit.page,
+                surfaceDynamicInputForCommit.ranges,
+                surfaceDynamicInputForCommit.projectionRevision,
+                frameNumber,
+              ),
+          }),
       projectShadow: (graph, identity) => {
         if (!shadowViewPool.isActive(identity) || shadowViewPool.submission(identity) === undefined)
           return ok(undefined);
@@ -2902,25 +2716,75 @@ export class GpuDrivenProduction {
           ),
         );
       },
-      project: (graph, format, sampleCount, additionalColorFormats) => {
+      project: (
+        graph,
+        format,
+        sampleCount,
+        surfaceSubmissionObservation,
+        additionalColorFormats,
+      ) => {
         this.indirectDrawCount = admittedRasterBatchCount(filtered.plan);
-        const outputs = view.addPasses(graph);
+        const outputs = view.addPasses(graph, 'gpu-driven', true, surfaceSubmissionObservation);
         if (!outputs.ok) return outputs;
         if (materialRaster !== undefined && filtered.batches.length > 0) {
+          let surfacePage: GraphBuffer | undefined;
+          let surfaceFrame: GraphBuffer | undefined;
+          let surfaceSharedFrame: GraphBuffer | undefined;
+          if (this.surfaceSubmission !== undefined) {
+            const importedPage = graph.importBuffer(
+              'gpu-driven.surface.dynamic-input',
+              {
+                size: materialRaster.surfaceDynamicInputBufferSize,
+                usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST,
+              },
+              () => materialRaster.surfaceDynamicInputBuffer,
+            );
+            if (!importedPage.ok) return importedPage;
+            const importedFrame = graph.importBuffer(
+              'gpu-driven.surface.frame-input',
+              {
+                size: materialRaster.surfaceDynamicFrameBufferSize,
+                usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST,
+              },
+              () => materialRaster.surfaceDynamicFrameBuffer,
+            );
+            if (!importedFrame.ok) return importedFrame;
+            const importedSharedFrame = graph.importBuffer(
+              'gpu-driven.surface.shared-frame-input',
+              {
+                size: materialRaster.surfaceDynamicSharedFrameBufferSize,
+                usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+              },
+              () => materialRaster.surfaceDynamicSharedFrameBuffer,
+            );
+            if (!importedSharedFrame.ok) return importedSharedFrame;
+            surfacePage = importedPage.value;
+            surfaceFrame = importedFrame.value;
+            surfaceSharedFrame = importedSharedFrame.value;
+          }
           const standardProjected: Array<{
             readonly batch: GpuDrivenBatch;
+            readonly artifact: MaterialShaderArtifact;
             readonly mesh: MeshGpuHandles;
             readonly materialEntityKey: number;
             readonly vertex: GraphBuffer;
             readonly index?: GraphBuffer;
-            readonly pipelineFor: (
-              formats: readonly TextureFormat[],
-            ) => Result<RenderPipeline, RhiError>;
             readonly meshBindGroup: BindGroup;
+            readonly meshProjectionBuffer: Buffer;
+            readonly meshProjectionBytes: number;
             readonly raster: MaterialAbiRasterAdapter;
             readonly deformation: 'rigid' | 'skin';
             readonly clustered: boolean;
             readonly projectionKey: string;
+            readonly pipelineFor: (
+              formats: readonly TextureFormat[],
+            ) => Result<RenderPipeline, RhiError>;
+            readonly nearestPipelineFor?: (
+              formats: readonly TextureFormat[],
+            ) => Result<RenderPipeline, RhiError>;
+            readonly colorPipelineFor?: (
+              formats: readonly TextureFormat[],
+            ) => Result<RenderPipeline, RhiError>;
           }> = [];
           const standardAccesses: GraphAccess[] = [
             { resource: outputs.value.primitive, usage: 'storage-read' },
@@ -2929,6 +2793,15 @@ export class GpuDrivenProduction {
             { resource: outputs.value.visible, usage: 'storage-read' },
             { resource: outputs.value.transform, usage: 'storage-read' },
             { resource: outputs.value.indirect, usage: 'indirect-read' },
+            ...(surfacePage === undefined
+              ? []
+              : [{ resource: surfacePage, usage: 'storage-read' as const }]),
+            ...(surfaceFrame === undefined
+              ? []
+              : [{ resource: surfaceFrame, usage: 'storage-read' as const }]),
+            ...(surfaceSharedFrame === undefined
+              ? []
+              : [{ resource: surfaceSharedFrame, usage: 'uniform-read' as const }]),
           ];
           const meshBuffers = new Map<
             MeshGpuHandles,
@@ -2955,10 +2828,10 @@ export class GpuDrivenProduction {
               );
             }
             // 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.
+            // facet applies its active-entity admission. Project mesh rows and
+            // frame rows from the same admitted sequence; visible.x is the
+            // batch-local candidate identity, while the atomic slot is only
+            // the draw order chosen by the GPU culler.
             const candidates = admittedCandidates.flatMap((candidate) => {
               const slot = projectionSlot(candidate.primitiveIndex);
               return slot === undefined ? [] : [sceneCandidate(slot, candidate)];
@@ -2976,12 +2849,23 @@ export class GpuDrivenProduction {
                 }),
               );
             }
+            const projectionKey = gpuDrivenProjectionKey(prepared.batch, deformation, artifact);
             const meshBindGroup = raster.projectionBindGroup(
               projection.value.rows,
-              gpuDrivenProjectionKey(prepared.batch, deformation, artifact),
+              projectionKey,
               prepared.batch.candidates.length,
             );
             if (!meshBindGroup.ok) return meshBindGroup;
+            const meshProjection = raster.projectionBuffer(projectionKey);
+            if (meshProjection === undefined) {
+              return err(
+                new RhiError({
+                  code: 'internal-error',
+                  expected: 'retained batch-local mesh projection buffer',
+                  hint: 'keep the projected BindGroup and its buffer on one retained identity',
+                }),
+              );
+            }
             const materialSlot = projectionSlot(admittedCandidates[0]?.primitiveIndex ?? -1);
             if (materialSlot === undefined) {
               return err(
@@ -3024,8 +2908,18 @@ export class GpuDrivenProduction {
                 standardAccesses.push({ resource: buffers.index, usage: 'index-read' });
               }
             }
+            const shaderUvSetCount = isCanonicalStandardPbrMaterialShader(artifact.material)
+              ? materialPipelineState.standardPbrShaderUvSetCount
+              : (artifact.uvSetCount ?? materialPipelineState.standardPbrShaderUvSetCount);
+            const stripIndexFormat =
+              prepared.batch.key.drawKind === 'indexed' &&
+              (prepared.batch.key.topology === 'line-strip' ||
+                prepared.batch.key.topology === 'triangle-strip')
+                ? prepared.mesh.indexFormat
+                : undefined;
             const pipelineFor = (
               formats: readonly TextureFormat[],
+              selectedArtifact: MaterialShaderArtifact = artifact,
             ): Result<RenderPipeline, RhiError> => {
               return raster.pipeline(
                 formats[0] ?? format,
@@ -3035,22 +2929,31 @@ export class GpuDrivenProduction {
                 // Standard count is only a fallback for legacy synthetic
                 // fixtures; using it for a custom program would add aliases
                 // the shader never declares (or omit a declared custom set).
-                artifact.uvSetCount ?? materialPipelineState.standardPbrShaderUvSetCount,
+                shaderUvSetCount,
                 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,
+                stripIndexFormat,
                 prepared.renderState,
-                artifact,
+                selectedArtifact,
                 formats.slice(1),
               );
             };
             const initialPipeline = pipelineFor([format, ...(additionalColorFormats ?? [])]);
             if (!initialPipeline.ok) return initialPipeline;
+            let nearestPipelineFor:
+              | ((formats: readonly TextureFormat[]) => Result<RenderPipeline, RhiError>)
+              | undefined;
+            let colorPipelineFor:
+              | ((formats: readonly TextureFormat[]) => Result<RenderPipeline, RhiError>)
+              | undefined;
+            if (isSingleLayerMediumArtifact(artifact)) {
+              nearestPipelineFor = (formats) =>
+                pipelineFor(formats, { ...artifact, fragmentEntry: 'fs_nearest_layer' });
+              colorPipelineFor = (formats) =>
+                pipelineFor(formats, { ...artifact, fragmentEntry: 'fs_color' });
+            }
             standardProjected.push({
               batch: prepared.batch,
+              artifact,
               mesh: prepared.mesh,
               materialEntityKey: worldEntityKey(
                 materialSlot.snapshot.worldId,
@@ -3058,7 +2961,11 @@ export class GpuDrivenProduction {
               ),
               ...buffers,
               pipelineFor,
+              ...(nearestPipelineFor === undefined ? {} : { nearestPipelineFor }),
+              ...(colorPipelineFor === undefined ? {} : { colorPipelineFor }),
               meshBindGroup: meshBindGroup.value,
+              meshProjectionBuffer: meshProjection.buffer,
+              meshProjectionBytes: meshProjection.bindingBytes,
               raster,
               deformation,
               clustered: ['cluster', 'skin-cluster'].includes(
@@ -3087,6 +2994,8 @@ export class GpuDrivenProduction {
               pass,
               resources: GraphResourceResolver,
               frameResources: GpuDrivenStandardPbrFrameResources,
+              filter,
+              fragmentEntryPoint,
             ) => {
               // The shared Standard view BGL carries two dynamic buffers:
               // the frame view UBO and the per-frame shadow/light table. GPU
@@ -3098,6 +3007,18 @@ export class GpuDrivenProduction {
               let currentVertex: GraphBuffer | undefined;
               let currentIndex: GraphBuffer | undefined;
               for (const batch of rasterDispatches) {
+                const isMedium = isSingleLayerMediumArtifact(batch.artifact);
+                if (
+                  (filter === 'single-layer-medium' && !isMedium) ||
+                  ((filter === 'opaque' ||
+                    filter === 'deferred-opaque' ||
+                    filter === 'forward-only-opaque') &&
+                    isMedium) ||
+                  (filter === 'deferred-opaque' && batch.batch.key.materialPass !== 'deferred') ||
+                  (filter === 'forward-only-opaque' && batch.batch.key.materialPass === 'deferred')
+                ) {
+                  continue;
+                }
                 const globalMaterialSlots = frameResources.materialSlotIndicesByEntity.get(
                   batch.materialEntityKey,
                 );
@@ -3118,14 +3039,19 @@ export class GpuDrivenProduction {
                   !frameResources.selectedMaterialSlots.has(globalMaterialSlot)
                 )
                   continue;
-                const selectedPipeline = batch.pipelineFor(
+                const pipelineFor =
+                  fragmentEntryPoint === 'fs_nearest_layer'
+                    ? (batch.nearestPipelineFor ?? batch.pipelineFor)
+                    : fragmentEntryPoint === 'fs_color'
+                      ? (batch.colorPipelineFor ?? batch.pipelineFor)
+                      : batch.pipelineFor;
+                const selectedPipeline = pipelineFor(
                   frameResources.colorFormats ?? [format, ...(additionalColorFormats ?? [])],
                 );
                 if (!selectedPipeline.ok) throw selectedPipeline.error;
-                const pipeline = selectedPipeline.value;
-                if (currentPipeline !== pipeline) {
-                  pass.setPipeline(pipeline);
-                  currentPipeline = pipeline;
+                if (currentPipeline !== selectedPipeline.value) {
+                  pass.setPipeline(selectedPipeline.value);
+                  currentPipeline = selectedPipeline.value;
                 }
                 const materialBindGroup = frameResources.materialBindGroups[globalMaterialSlot];
                 if (materialBindGroup === undefined) {
@@ -3138,21 +3064,30 @@ export class GpuDrivenProduction {
                 pass.setBindGroup(1, materialBindGroup, [
                   globalMaterialSlot * frameResources.materialStride,
                 ]);
-                const meshBindGroup = batch.clustered
-                  ? frameResources.resolveClusteredMeshBindGroup?.(
-                      batch.raster.sceneMeshBinding(batch.projectionKey),
-                    )
-                  : batch.meshBindGroup;
-                if (meshBindGroup === undefined)
+                const group2 = resolveGpuDrivenMeshGroup({
+                  clustered: batch.clustered,
+                  deformation: batch.deformation,
+                  meshBindGroup: batch.meshBindGroup,
+                  meshProjectionBuffer: batch.meshProjectionBuffer,
+                  meshProjectionBytes: batch.meshProjectionBytes,
+                  frameResources,
+                  skinPaletteBinding: batch.raster.skinPaletteBinding(),
+                });
+                if (group2 === undefined) {
                   throw new RhiError({
                     code: 'rhi-not-available',
-                    expected: 'current scene-index lighting binding',
-                    hint: 'resolve clustered surface resources during the material pass',
+                    expected: 'clustered Standard group(2) BindGroup for GPU-driven batch',
+                    hint: 'publish the frame-owned cluster lighting resources before indirect encode',
                   });
-                pass.setBindGroup(2, meshBindGroup, batch.deformation === 'skin' ? [0, 0, 0] : [0]);
+                }
+                pass.setBindGroup(2, group2, batch.deformation === 'skin' ? [0, 0, 0] : [0]);
                 const visibleWindow = batch.raster.visibleWindowBindGroup(
                   batch.batch.visibleBase,
                   batch.batch.visibleCapacity,
+                  isSingleLayerMediumArtifact(batch.artifact) ? batch.batch.visibleBase : undefined,
+                  isSingleLayerMediumArtifact(batch.artifact)
+                    ? batch.batch.visibleCapacity
+                    : undefined,
                 );
                 if (!visibleWindow.ok) throw visibleWindow.error;
                 pass.setBindGroup(3, visibleWindow.value);
@@ -3175,6 +3110,29 @@ export class GpuDrivenProduction {
                 } else {
                   pass.drawIndirect(indirect.value, batch.batch.indirectOffset);
                 }
+                const surfacePass =
+                  isMedium && fragmentEntryPoint === 'fs_nearest_layer'
+                    ? 'nearest-layer'
+                    : isMedium && fragmentEntryPoint === 'fs_color'
+                      ? 'color'
+                      : undefined;
+                if (surfacePass !== undefined) {
+                  frameResources.surfaceSubmissionObservation?.record(surfacePass, {
+                    kind:
+                      batch.batch.key.drawKind === 'indexed'
+                        ? 'draw-indexed-indirect'
+                        : 'draw-indirect',
+                    indirectBufferIdentity: getOpaqueResourceIdentity(indirect.value as object),
+                    indirectOffset: batch.batch.indirectOffset,
+                    pipelineIdentity: getOpaqueResourceIdentity(selectedPipeline as object),
+                    ...(batch.artifact.receipt === undefined
+                      ? {}
+                      : {
+                          receiptIdentity: batch.artifact.receipt.receiptIdentity,
+                          receiptGeneration: batch.artifact.receipt.generation,
+                        }),
+                  });
+                }
                 this.encodedIndirectDraws += 1;
               }
             },
@@ -3363,7 +3321,7 @@ export class GpuDrivenProduction {
           batch.candidates.length,
         );
         if (!meshBindGroup.ok) return meshBindGroup;
-        const visibleBindGroup = raster.visibleWindowBindGroupForBuffer(
+        const visibleBindGroup = raster.shadowVisibleWindowBindGroupForBuffer(
           visibleBuffer,
           batch.visibleBase,
           batch.visibleCapacity,
@@ -3443,6 +3401,8 @@ export class GpuDrivenProduction {
     this.skinRaster?.dispose();
     this.skinRaster = undefined;
     this.filteredCache = undefined;
+    this.surfaceFrameRangeCache = undefined;
+    this.consumedSurfaceInput = undefined;
     this.signatureCache = undefined;
     this.validatedResidencyCache = undefined;
     this.cpuValidationTelemetryCache = undefined;
@@ -3457,11 +3417,22 @@ export class GpuDrivenProduction {
     this.skinPaletteBuffer = undefined;
     this.committedPaletteContentRevision = undefined;
     this.preparationFailure = undefined;
+    this.surfaceArtifactInspection = undefined;
     this.overflowRecoveryRequired = false;
   }
 
   inspect(): GpuDrivenProductionInspection {
     const view = this.view?.inspect();
+    const filtered = this.filteredCache?.value;
+    const resourceAllocation = combineGpuResourceAllocationInspections([
+      ...(view === undefined ? [] : [view.resourceAllocation]),
+      ...(this.materialRaster === undefined ? [] : [this.materialRaster.resourceAllocation]),
+      ...(this.skinRaster === undefined ? [] : [this.skinRaster.resourceAllocation]),
+    ]);
+    const resourceClasses =
+      filtered === undefined
+        ? undefined
+        : inspectResourceClassSplits({ batches: filtered.batches.map(({ batch }) => batch) });
     const channels: GpuDrivenLaneSummary[] = [];
     const mainTotalDrawCount = this.mainTotalDrawItems;
     const mainClaimedDrawCount = this.telemetryOverflow
@@ -3567,11 +3538,23 @@ export class GpuDrivenProduction {
       }
     }
     return {
+      ...(this.surfaceArtifactInspection === undefined
+        ? {}
+        : { surfaceArtifact: this.surfaceArtifactInspection }),
       residencyValidationScans: this.residencyValidationScans,
       residencyValidationCacheHits: this.residencyValidationCacheHits,
       cpuValidationScans: this.cpuValidationScans,
       cpuValidationCacheHits: this.cpuValidationCacheHits,
       ...this.structureMetrics,
+      surfaceFrameRangeBuilds: this.surfaceFrameRangeBuilds,
+      surfaceFrameMemberScans:
+        this.surfaceFrameRangeMemberScans +
+        (this.materialRaster?.surfaceDynamicFrameMemberScans ?? 0) +
+        (this.skinRaster?.surfaceDynamicFrameMemberScans ?? 0),
+      surfaceFrameRowAllocations:
+        (this.materialRaster?.surfaceDynamicFrameRowAllocations ?? 0) +
+        (this.skinRaster?.surfaceDynamicFrameRowAllocations ?? 0),
+      surfaceFrameTimeWrites: this.materialRaster?.surfaceDynamicFrameTimeWrites ?? 0,
       gpuOwnedSnapshotsMaterialized: this.gpuOwnedSnapshotsMaterialized,
       filteredPlanBuilds: this.filteredPlanBuilds,
       gpuOwnedEntityCount: this.gpuOwnedEntityCount,
@@ -3602,6 +3585,23 @@ export class GpuDrivenProduction {
       recoveryCount: this.recoveryCount,
       retryCount: this.retryCount,
       lastKnownGoodGeneration: this.lastKnownGoodGeneration,
+      ...(resourceAllocation === undefined ? {} : { resourceAllocation }),
+      resourceAllocationOwners: Object.freeze({
+        ...(view === undefined ? {} : { gpuDrivenView: view.resourceAllocation }),
+        ...(this.materialRaster === undefined
+          ? {}
+          : { materialRaster: this.materialRaster.resourceAllocation }),
+        ...(this.skinRaster === undefined
+          ? {}
+          : { skinRaster: this.skinRaster.resourceAllocation }),
+      }),
+      ...(resourceClasses === undefined
+        ? {}
+        : {
+            resourceClassCount: resourceClasses.resourceClassCount,
+            resourceClassSplits: resourceClasses.resourceClassSplits,
+            resourceClassSplitReasons: resourceClasses.resourceClassSplitReasons,
+          }),
     };
   }
 
@@ -3638,11 +3638,53 @@ export class GpuDrivenProduction {
           this.laneReason = 'overflow';
         }
       }
-      if (selection === undefined || telemetryCandidateCount <= 0) return selection;
+      if (selection === undefined) return selection;
       if (filtered === undefined) return selection;
-      const preparedByBatchId = new Map(
-        filtered.batches.map((prepared) => [prepared.batch.batchId, prepared] as const),
+      type LodBatchAttribution = {
+        readonly batch: GpuDrivenBatch;
+        readonly worldKey: number;
+        readonly primitiveSlot: number;
+        readonly slotGeneration: number;
+        readonly artifact?: MaterialShaderArtifact;
+      };
+      const preparedByBatchId = new Map<number, LodBatchAttribution>(
+        filtered.batches.map((prepared) => [
+          prepared.batch.batchId,
+          {
+            batch: prepared.batch,
+            worldKey: prepared.worldKey,
+            primitiveSlot: prepared.primitiveSlot,
+            slotGeneration: prepared.slotGeneration,
+            artifact: prepared.artifact,
+          },
+        ]),
       );
+      const projectedCandidateCount =
+        telemetryCandidateCount > 0 ? telemetryCandidateCount : selection.candidateCount;
+      // Selector-only batches remain in filtered.plan so their GPU counters
+      // can describe candidates suppressed from the raster admission lane.
+      // They have no PreparedBatch entry because no draw is encoded, but they
+      // still need the same World join for receipt attribution. Recover that
+      // metadata from the stable primitive slot instead of dropping the whole
+      // readback when the first such batch is encountered.
+      const filteredSlots = this.filteredCache?.slots;
+      const filteredWorldKeys = this.filteredCache?.worldKeys;
+      if (filteredSlots !== undefined) {
+        const slotByPrimitive = new Map(filteredSlots.map((slot) => [slot.slot, slot] as const));
+        for (const batch of filtered.plan.batches) {
+          if (preparedByBatchId.has(batch.batchId)) continue;
+          const candidate = batch.candidates[0];
+          const slot =
+            candidate === undefined ? undefined : slotByPrimitive.get(candidate.primitiveIndex);
+          if (slot === undefined) continue;
+          preparedByBatchId.set(batch.batchId, {
+            batch,
+            worldKey: filteredWorldKeys?.[slot.snapshot.worldId] ?? slot.snapshot.worldId,
+            primitiveSlot: slot.slot,
+            slotGeneration: slot.generation,
+          });
+        }
+      }
       const worldSelections = new Map<
         number,
         {
@@ -3655,9 +3697,36 @@ export class GpuDrivenProduction {
           readonly lodHistogram: Map<number, number>;
         }
       >();
+      const lodHistogram = new Map<number, number>();
+      // The selector visits the full captured plan, including candidates that
+      // the CPU visibility projection suppressed. Use that same plan for the
+      // LOD denominator so World attribution cannot fail merely because the
+      // two lanes have different frustum scopes.
+      let lodCandidateCount = 0;
+      let lodVisible = 0;
       for (const batchSelection of selection.batches) {
         const prepared = preparedByBatchId.get(batchSelection.batchId);
-        if (prepared === undefined) return selection;
+        // Selector-only or otherwise non-raster batches remain in the GPU
+        // telemetry plan. They have no material producer row and therefore do
+        // not invalidate readback evidence for the prepared Surface batches.
+        if (prepared === undefined) continue;
+        // The GPU selector also visits ordinary GPU-driven meshes so one
+        // compact compute path can populate their indirect args. Those rows
+        // are level-0 by construction, but they are not LOD candidates and
+        // must not enter receipt-bound LOD attribution. Batch topology keeps
+        // LOD coverage/ranges in the grouping key, so a batch is expected to
+        // be homogeneous; fail closed if a producer violates that invariant
+        // instead of guessing a split for aggregate counters.
+        const lodCandidateRows = prepared.batch.candidates.filter(
+          (candidate) => (candidate.lodCoverages?.length ?? 0) > 1,
+        );
+        if (lodCandidateRows.length === 0) continue;
+        if (lodCandidateRows.length !== batchSelection.candidateCount) return undefined;
+        lodCandidateCount += batchSelection.candidateCount;
+        lodVisible += batchSelection.visible;
+        for (const row of batchSelection.lodHistogram) {
+          lodHistogram.set(row.level, (lodHistogram.get(row.level) ?? 0) + row.count);
+        }
         let aggregate = worldSelections.get(prepared.worldKey);
         if (aggregate === undefined) {
           aggregate = {
@@ -3683,8 +3752,50 @@ export class GpuDrivenProduction {
       }
       return {
         ...selection,
-        candidateCount: telemetryCandidateCount,
-        occluded: Math.max(0, telemetryCandidateCount - selection.visible),
+        candidateCount: lodCandidateCount > 0 ? lodCandidateCount : projectedCandidateCount,
+        visible: lodCandidateCount > 0 ? lodVisible : selection.visible,
+        occluded: Math.max(
+          0,
+          (lodCandidateCount > 0 ? lodCandidateCount : projectedCandidateCount) -
+            (lodCandidateCount > 0 ? lodVisible : selection.visible),
+        ),
+        lodHistogram: Object.freeze(
+          [...lodHistogram.entries()]
+            .sort(([left], [right]) => left - right)
+            .map(([level, count]) => Object.freeze({ level, count })),
+        ),
+        surfaceActualMemberIds: Object.freeze(
+          selection.actualMembers.flatMap((member) => {
+            const prepared = preparedByBatchId.get(member.batchId);
+            if (
+              prepared === undefined ||
+              prepared.artifact === undefined ||
+              !isSingleLayerMediumArtifact(prepared.artifact)
+            ) {
+              return [];
+            }
+            const slot = this.filteredCache?.slots.find(
+              (candidate) => candidate.slot === member.primitiveIndex,
+            );
+            if (slot === undefined) return [];
+            const frameRange = this.surfaceFrameRangeCache?.value.ranges.find(
+              ({ directMember }) =>
+                directMember.worldId === slot.worldId &&
+                directMember.entityKey === slot.entityKey &&
+                directMember.drawItemIndex === member.drawItemIndex &&
+                directMember.instanceOrdinal === member.instanceOrdinal,
+            );
+            if (frameRange === undefined) return [];
+            return [
+              JSON.stringify([
+                frameRange.directMember.worldIdentity,
+                frameRange.directMember.entityKey,
+                frameRange.directMember.drawItemIndex,
+                frameRange.directMember.instanceOrdinal,
+              ]),
+            ];
+          }),
+        ),
         worldSelections: Object.freeze(
           [...worldSelections.values()].map((aggregate) =>
             Object.freeze({
@@ -3710,6 +3821,7 @@ export class GpuDrivenProduction {
     validated: readonly { readonly source: RenderableSnapshot }[],
     gpuOwnedDrawKeys: ReadonlySet<string>,
     cacheKey?: string,
+    worldKeys?: readonly number[],
   ): void {
     const cached = this.cpuValidationTelemetryCache;
     if (
@@ -3717,7 +3829,8 @@ export class GpuDrivenProduction {
       cached !== undefined &&
       cached.cacheKey === cacheKey &&
       cached.validated === validated &&
-      cached.gpuOwnedDrawKeys === gpuOwnedDrawKeys
+      cached.gpuOwnedDrawKeys === gpuOwnedDrawKeys &&
+      cached.worldKeys === worldKeys
     ) {
       this.applyCpuValidationTelemetry(cached);
       this.cpuValidationCacheHits += 1;
@@ -3755,7 +3868,10 @@ export class GpuDrivenProduction {
       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),
+          worldEntityKey(
+            worldKeys?.[row.source.worldId] ?? row.source.worldId,
+            row.source.entityKey,
+          ),
           material.materialHandle ?? -1,
           gpuDrivenSourceDrawItemIndex(draw, compactIndex),
         );
@@ -3800,6 +3916,7 @@ export class GpuDrivenProduction {
         cacheKey,
         validated,
         gpuOwnedDrawKeys,
+        worldKeys,
         gpuOwnedDrawCount: this.gpuOwnedDrawItems,
         totalDrawItems: this.mainTotalDrawItems,
         gpuOwnedRows: this.validatedGpuOwnedRows,