@forgeax/engine-render 0.1.33 → 0.1.35

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

@@ -0,0 +1,1894 @@
+import { deriveVertexBufferLayoutFromProjection } from '@forgeax/engine-geometry';
+import type {
+  BindGroup,
+  BindGroupLayout,
+  Buffer,
+  RenderPipeline,
+  Result,
+  RhiDevice,
+  TextureFormat,
+} from '@forgeax/engine-rhi';
+import { err, ok, RhiError } from '@forgeax/engine-rhi';
+import type { MaterialShaderArtifact } from '@forgeax/engine-shader';
+import type { MaterialDynamicInputLayout, MaterialRenderState } from '@forgeax/engine-types';
+import type { MeshGpuHandles } from '../device/gpu-residency';
+import { GpuDrivenPreparationError } from '../errors/gpu-driven';
+import { GPU_SCENE_LAYOUTS } from '../gpu-scene-schema';
+import {
+  GPU_BUFFER_USAGE_COPY_DST,
+  GPU_BUFFER_USAGE_STORAGE,
+  GPU_BUFFER_USAGE_UNIFORM,
+} from '../gpu-usage';
+import { isCanonicalStandardPbrMaterialShader, isStandardPbrMaterialShader } from '../pbr-pipeline';
+import {
+  MESH_PER_ENTITY_STRIDE,
+  MESH_SSBO_BYTES,
+  packInstanceStorageBuffer,
+} from '../record/mesh-ssbo';
+import type { PipelineState, RenderSystemInternals } from '../record/render-context';
+import { PROBE_BLEND_RECORD_BYTE_SIZE } from '../scene/probe-blend-record';
+import type {
+  DynamicInputRange,
+  DynamicInputUploadReceipt,
+  ReadonlyDynamicInputPage,
+  SurfaceDynamicInputFrame,
+} from '../surface/dynamic-input';
+import type { GpuDrivenBatch } from './batch-topology';
+import { requiresProbeBlendRecord } from './material-artifacts';
+import type { GpuDrivenPbrProgram } from './pbr-program';
+import { resolveStandardPbrProgram } from './pbr-program';
+import {
+  GpuResourceAllocationLedger,
+  type GpuResourceAllocationToken,
+} from './resource-allocation';
+
+const SURFACE_FRAME_RECORD_BYTES = 48;
+const SURFACE_SHARED_FRAME_BYTES = 16;
+const SURFACE_DIRECT_ADDRESS_STRIDE = 256;
+
+interface SurfaceFrameRange {
+  readonly frameIndex: number;
+  readonly range?: DynamicInputRange;
+  readonly directMember?: {
+    readonly worldId: number;
+    readonly entityKey: number;
+    readonly drawItemIndex: number;
+    readonly instanceOrdinal: number;
+  };
+}
+
+interface SurfaceFrameRow {
+  readonly eventRangeStart: number;
+  readonly eventRangeCount: number;
+  readonly instanceIndex: number;
+  readonly backgroundAvailable: boolean;
+}
+
+interface SurfaceSharedFrameState {
+  readonly buffer: Buffer;
+  frameTime: number;
+  writes: number;
+}
+
+function sameSurfaceFrameRow(left: SurfaceFrameRow, right: SurfaceFrameRow): boolean {
+  return (
+    left.eventRangeStart === right.eventRangeStart &&
+    left.eventRangeCount === right.eventRangeCount &&
+    left.instanceIndex === right.instanceIndex &&
+    left.backgroundAvailable === right.backgroundAvailable
+  );
+}
+
+function bufferBinding(buffer: Buffer, offset?: number, size?: number) {
+  return {
+    kind: 'buffer' as const,
+    value: {
+      buffer,
+      ...(offset === undefined ? {} : { offset }),
+      ...(size === undefined ? {} : { size }),
+    },
+  };
+}
+
+function writeSurfaceFrameRecord(
+  view: DataView,
+  offset: number,
+  frameTime: number,
+  eventRangeStart: number,
+  eventRangeCount: number,
+  instanceIndex = 0,
+  backgroundAvailable = false,
+): void {
+  view.setFloat32(offset, frameTime, true);
+  view.setUint32(offset + 4, eventRangeStart, true);
+  view.setUint32(offset + 8, eventRangeCount, true);
+  view.setUint32(offset + 12, instanceIndex, true);
+  for (let lane = 0; lane < 4; lane += 1) view.setFloat32(offset + 16 + lane * 4, 0, true);
+  view.setFloat32(offset + 32, 0, true);
+  view.setUint32(offset + 36, 0, true);
+  view.setUint32(offset + 40, 0, true);
+  view.setUint32(offset + 44, backgroundAvailable ? 1 : 0, true);
+}
+
+function surfaceDynamicInputError(expected: string, hint: string): RhiError {
+  return new RhiError({ code: 'rhi-descriptor-invalid', expected, hint });
+}
+
+function sameDynamicInputLayout(
+  actual: MaterialDynamicInputLayout,
+  expected: MaterialDynamicInputLayout,
+): boolean {
+  return (
+    actual.identity === expected.identity &&
+    actual.name === expected.name &&
+    actual.stride === expected.stride &&
+    actual.maxRecords === expected.maxRecords &&
+    actual.maxDomains === expected.maxDomains &&
+    actual.maxPageBytes === expected.maxPageBytes &&
+    actual.maxBindings === expected.maxBindings &&
+    actual.maxEventsPerSample === expected.maxEventsPerSample &&
+    actual.fields.length === expected.fields.length &&
+    actual.fields.every((field, index) => {
+      const candidate = expected.fields[index];
+      return (
+        candidate !== undefined &&
+        field.name === candidate.name &&
+        field.type === candidate.type &&
+        field.offset === candidate.offset &&
+        field.size === candidate.size &&
+        field.alignment === candidate.alignment
+      );
+    })
+  );
+}
+
+function invalidSurfaceDynamicRange(
+  page: ReadonlyDynamicInputPage,
+  range: DynamicInputRange,
+  expectedDeviceGeneration: number | undefined,
+): string | undefined {
+  if (range.sourceId !== page.sourceId || range.pageId !== page.pageId) {
+    return 'each Surface dynamic range belongs to the submitted page source and page id';
+  }
+  if (
+    expectedDeviceGeneration !== undefined &&
+    range.deviceGeneration !== expectedDeviceGeneration
+  ) {
+    return 'each Surface dynamic range belongs to the current renderer device generation';
+  }
+  if (
+    range.bufferGeneration !== page.bufferGeneration ||
+    range.deviceGeneration !== page.deviceGeneration
+  ) {
+    return 'each Surface dynamic range belongs to the current page buffer and device generation';
+  }
+  if (
+    !Number.isSafeInteger(range.instanceIndex) ||
+    range.instanceIndex < 0 ||
+    range.instanceIndex > 0xffffffff
+  ) {
+    return 'each Surface dynamic range uses an exact unsigned 32-bit instance index';
+  }
+  if (
+    !Number.isSafeInteger(range.recordStart) ||
+    !Number.isSafeInteger(range.recordCount) ||
+    range.recordStart < 0 ||
+    range.recordCount <= 0 ||
+    range.recordStart + range.recordCount > page.schema.maxRecords ||
+    range.recordCount > page.schema.maxEventsPerSample
+  ) {
+    return 'each Surface dynamic range stays within the published record and per-sample budgets';
+  }
+  if (range.byteOffset !== range.recordStart * page.layout.stride) {
+    return 'each Surface dynamic range byte offset is derived from the published record stride';
+  }
+  if (
+    !Number.isSafeInteger(range.contentRevision) ||
+    range.contentRevision <= 0 ||
+    range.contentRevision > page.contentRevision
+  ) {
+    return 'each Surface dynamic range names a published page content revision';
+  }
+  return undefined;
+}
+
+type MaterialPipelineFactory = NonNullable<RenderSystemInternals['getMaterialShaderPipelineEntry']>;
+
+function materialArtifactProgramIdentity(artifact: MaterialShaderArtifact): string {
+  const source = artifact.specializationKey ?? artifact.wgsl;
+  let hash = 2166136261;
+  for (let index = 0; index < source.length; index += 1) {
+    hash ^= source.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `${source.length}:${hash >>> 0}`;
+}
+
+export 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 WeakSet<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 readonly surfaceInputBuffers = new Set<Buffer>();
+  /**
+   * Material-raster-owned buffers only. Visible, probe, palette and mesh
+   * buffers are supplied by their respective owners and are deliberately not
+   * registered here, so the production projection cannot double-count them.
+   */
+  private readonly allocationTokens = new WeakMap<Buffer, GpuResourceAllocationToken>();
+  private readonly allocationLedger: GpuResourceAllocationLedger;
+  private dynamicInputPage: ReadonlyDynamicInputPage | undefined;
+  private dynamicInputPageGeneration = 0;
+  private dynamicInputBuffer: Buffer;
+  private dynamicInputBufferSize: number;
+  private dynamicFrameBuffer: Buffer;
+  private dynamicFrameBufferSize: number;
+  private readonly dynamicSharedFrame: SurfaceSharedFrameState;
+  private directAddressBuffer: Buffer;
+  private directAddressBufferSize: number;
+  private readonly directAddresses = new Map<
+    string,
+    { readonly frameBase: number; readonly instanceCount: number; readonly byteOffset: number }
+  >();
+  private readonly directBindGroups = new Map<
+    string,
+    {
+      readonly instanceBuffer: Buffer;
+      readonly probeBuffer: Buffer;
+      readonly addressBuffer: Buffer;
+      readonly bindGroup: BindGroup;
+    }
+  >();
+  /** Last successfully queued frame rows, keyed by visible member identity. */
+  private readonly dynamicFrameRows = new Map<number, SurfaceFrameRow>();
+  private dynamicFrameRangeSource: readonly SurfaceFrameRange[] | undefined;
+  private dynamicInputRangeSource: readonly DynamicInputRange[] | undefined;
+  private dynamicInputFrameRanges: readonly SurfaceFrameRange[] | undefined;
+  private dynamicFrameRangeCapacity = 0;
+  private dynamicFrameMemberScans = 0;
+  private dynamicFrameRowAllocations = 0;
+  private pendingDynamicInputUpload:
+    | { readonly page: ReadonlyDynamicInputPage; readonly receipt: DynamicInputUploadReceipt }
+    | undefined;
+
+  private constructor(
+    private readonly device: RhiDevice,
+    private readonly pipelineLayout: import('@forgeax/engine-rhi').PipelineLayout,
+    private readonly meshLayout: BindGroupLayout,
+    private readonly instancesBindGroupLayout: BindGroupLayout,
+    private readonly surfaceDirectInstancesBindGroupLayout: BindGroupLayout | null,
+    private readonly programs: ReadonlyMap<string, GpuDrivenPbrProgram> | undefined,
+    private instancesBindGroup: BindGroup,
+    private readonly instanceBuffer: Buffer,
+    private readonly instanceBufferSize: number,
+    private visibleBuffer: Buffer,
+    private probeBlendRecordBuffer: Buffer | undefined,
+    private readonly artifact: MaterialShaderArtifact,
+    private readonly deformation: 'rigid' | 'skin',
+    private readonly pipelineFactory: MaterialPipelineFactory | undefined,
+    private paletteBuffer: Buffer | undefined,
+    private paletteBindingWindowBytes: number | undefined,
+    dynamicInputBuffer: Buffer,
+    dynamicInputFrameBuffer: Buffer,
+    dynamicSharedFrame: SurfaceSharedFrameState,
+    directAddressBuffer: Buffer,
+    ownsDynamicSharedFrame: boolean,
+    allocationLedger: GpuResourceAllocationLedger,
+  ) {
+    this.allocationLedger = allocationLedger;
+    this.dynamicInputBuffer = dynamicInputBuffer;
+    this.dynamicInputBufferSize = 16;
+    this.dynamicFrameBuffer = dynamicInputFrameBuffer;
+    this.dynamicFrameBufferSize = SURFACE_FRAME_RECORD_BYTES;
+    this.dynamicSharedFrame = dynamicSharedFrame;
+    this.directAddressBuffer = directAddressBuffer;
+    this.directAddressBufferSize = SURFACE_DIRECT_ADDRESS_STRIDE;
+    this.surfaceInputBuffers.add(dynamicInputBuffer);
+    this.surfaceInputBuffers.add(dynamicInputFrameBuffer);
+    this.surfaceInputBuffers.add(directAddressBuffer);
+    if (ownsDynamicSharedFrame) this.surfaceInputBuffers.add(dynamicSharedFrame.buffer);
+    this.trackOwnedBuffer(instanceBuffer, instanceBufferSize);
+    this.trackOwnedBuffer(dynamicInputBuffer, 16);
+    this.trackOwnedBuffer(dynamicInputFrameBuffer, SURFACE_FRAME_RECORD_BYTES);
+    this.trackOwnedBuffer(directAddressBuffer, SURFACE_DIRECT_ADDRESS_STRIDE);
+    if (ownsDynamicSharedFrame) {
+      this.trackOwnedBuffer(dynamicSharedFrame.buffer, SURFACE_SHARED_FRAME_BYTES);
+    }
+  }
+
+  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;
+    readonly sharedSurfaceFrame?: SurfaceSharedFrameState;
+    readonly probeBlendRecordBuffer?: Buffer;
+    /** 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 probeBlendRequested = requiresProbeBlendRecord(input.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 this scene-index program',
+          actual: 'no ProbeBlend record page was published for the prepared frame',
+          recovery: 'retry-same-draw',
+        }),
+      );
+    }
+    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 createdBuffers: Buffer[] = [];
+    const cleanupCreatedBuffers = (): void => {
+      for (const buffer of createdBuffers) input.device.destroyBuffer(buffer);
+      createdBuffers.length = 0;
+    };
+    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;
+    createdBuffers.push(instanceBuffer.value);
+    const instanceWrite = input.device.queue.writeBuffer(instanceBuffer.value, 0, instancePayload);
+    if (!instanceWrite.ok) {
+      cleanupCreatedBuffers();
+      return instanceWrite;
+    }
+    const dynamicInputBuffer = input.device.createBuffer({
+      label: 'surface-dynamic-input-page',
+      size: 16,
+      usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST,
+    });
+    if (!dynamicInputBuffer.ok) {
+      cleanupCreatedBuffers();
+      return dynamicInputBuffer;
+    }
+    createdBuffers.push(dynamicInputBuffer.value);
+    const dynamicInputWrite = input.device.queue.writeBuffer(
+      dynamicInputBuffer.value,
+      0,
+      new Uint32Array(4),
+    );
+    if (!dynamicInputWrite.ok) {
+      cleanupCreatedBuffers();
+      return dynamicInputWrite;
+    }
+    const dynamicFrameBuffer = input.device.createBuffer({
+      label: 'surface-dynamic-frame-input',
+      size: SURFACE_FRAME_RECORD_BYTES,
+      usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST,
+    });
+    if (!dynamicFrameBuffer.ok) {
+      cleanupCreatedBuffers();
+      return dynamicFrameBuffer;
+    }
+    createdBuffers.push(dynamicFrameBuffer.value);
+    const dynamicFramePayload = new Uint8Array(SURFACE_FRAME_RECORD_BYTES);
+    writeSurfaceFrameRecord(new DataView(dynamicFramePayload.buffer), 0, 0, 0, 0);
+    const dynamicFrameWrite = input.device.queue.writeBuffer(
+      dynamicFrameBuffer.value,
+      0,
+      dynamicFramePayload,
+    );
+    if (!dynamicFrameWrite.ok) {
+      cleanupCreatedBuffers();
+      return dynamicFrameWrite;
+    }
+    const directAddressBuffer = input.device.createBuffer({
+      label: 'surface-direct-addresses',
+      size: SURFACE_DIRECT_ADDRESS_STRIDE,
+      usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+    });
+    if (!directAddressBuffer.ok) {
+      cleanupCreatedBuffers();
+      return directAddressBuffer;
+    }
+    createdBuffers.push(directAddressBuffer.value);
+    const directAddressWrite = input.device.queue.writeBuffer(
+      directAddressBuffer.value,
+      0,
+      new Uint32Array(4),
+    );
+    if (!directAddressWrite.ok) {
+      cleanupCreatedBuffers();
+      return directAddressWrite;
+    }
+    let ownsDynamicSharedFrame = false;
+    let dynamicSharedFrame = input.sharedSurfaceFrame;
+    if (dynamicSharedFrame === undefined) {
+      const created = input.device.createBuffer({
+        label: 'surface-dynamic-shared-frame-input',
+        size: SURFACE_SHARED_FRAME_BYTES,
+        usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+      });
+      if (!created.ok) {
+        cleanupCreatedBuffers();
+        return created;
+      }
+      createdBuffers.push(created.value);
+      const initialized = input.device.queue.writeBuffer(created.value, 0, new Float32Array(4));
+      if (!initialized.ok) {
+        cleanupCreatedBuffers();
+        return initialized;
+      }
+      dynamicSharedFrame = { buffer: created.value, frameTime: 0, writes: 0 };
+      ownsDynamicSharedFrame = true;
+    }
+    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.probeBlendRecordBuffer ?? input.visibleBuffer),
+        },
+        {
+          binding: 2,
+          resource: bufferBinding(input.visibleBuffer),
+        },
+        { binding: 3, resource: bufferBinding(dynamicInputBuffer.value) },
+        { binding: 4, resource: bufferBinding(dynamicFrameBuffer.value) },
+        { binding: 5, resource: bufferBinding(dynamicSharedFrame.buffer) },
+      ],
+    });
+    if (!instancesBindGroup.ok) {
+      cleanupCreatedBuffers();
+      return instancesBindGroup;
+    }
+    const allocationLedger = new GpuResourceAllocationLedger();
+    return ok(
+      new MaterialAbiRasterAdapter(
+        input.device,
+        pipelineLayout,
+        meshLayout,
+        instancesBindGroupLayout,
+        input.pipelineState.surfaceDirectInstancesBindGroupLayout ?? null,
+        programs,
+        instancesBindGroup.value,
+        instanceBuffer.value,
+        instancePayload.byteLength,
+        input.visibleBuffer,
+        input.probeBlendRecordBuffer,
+        input.artifact,
+        deformation,
+        input.pipelineFactory,
+        input.paletteBuffer,
+        input.paletteBindingWindowBytes,
+        dynamicInputBuffer.value,
+        dynamicFrameBuffer.value,
+        dynamicSharedFrame,
+        directAddressBuffer.value,
+        ownsDynamicSharedFrame,
+        allocationLedger,
+      ),
+    );
+  }
+
+  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);
+  }
+
+  skinPaletteBinding():
+    | { readonly buffer: Buffer; readonly bindingWindowBytes: number }
+    | undefined {
+    return this.deformation === 'skin' &&
+      this.paletteBuffer !== undefined &&
+      this.paletteBindingWindowBytes !== undefined
+      ? { buffer: this.paletteBuffer, bindingWindowBytes: this.paletteBindingWindowBytes }
+      : 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(this.probeBlendRecordBuffer ?? visibleBuffer) },
+        { binding: 2, resource: bufferBinding(visibleBuffer) },
+        { binding: 3, resource: bufferBinding(this.dynamicInputBuffer) },
+        { binding: 4, resource: bufferBinding(this.dynamicFrameBuffer) },
+        { binding: 5, resource: bufferBinding(this.dynamicSharedFrame.buffer) },
+      ],
+    });
+    if (!created.ok) return created;
+    this.instancesBindGroup = created.value;
+    this.visibleBuffer = visibleBuffer;
+    return ok(undefined);
+  }
+
+  ensureProbeBlendRecordBuffer(buffer: Buffer | undefined): Result<void, RhiError> {
+    if (buffer === undefined || buffer === this.probeBlendRecordBuffer) return ok(undefined);
+    this.probeBlendRecordBuffer = buffer;
+    const rebound = this.rebuildInstancesBindGroup();
+    if (!rebound.ok) return rebound;
+    this.visibleWindowBindGroups.clear();
+    this.directBindGroups.clear();
+    return ok(undefined);
+  }
+
+  visibleWindowBindGroup(
+    visibleBase: number,
+    visibleCapacity: number,
+    surfaceFrameBase?: number,
+    surfaceFrameCapacity?: number,
+  ): Result<BindGroup, RhiError> {
+    return this.visibleWindowBindGroupForBuffer(
+      this.visibleBuffer,
+      visibleBase,
+      visibleCapacity,
+      surfaceFrameBase,
+      surfaceFrameCapacity,
+    );
+  }
+
+  visibleWindowBindGroupForBuffer(
+    visibleBuffer: Buffer,
+    visibleBase: number,
+    visibleCapacity: number,
+    surfaceFrameBase?: number,
+    surfaceFrameCapacity?: number,
+    shadowVisibleAlias = false,
+  ): Result<BindGroup, RhiError> {
+    const offset = visibleBase * 16;
+    const size = visibleCapacity * 16;
+    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})`,
+        }),
+      );
+    }
+    const frameBase = surfaceFrameBase === undefined ? undefined : surfaceFrameBase;
+    const frameCapacity = surfaceFrameCapacity ?? visibleCapacity;
+    const frameOffset =
+      frameBase === undefined ? undefined : frameBase * SURFACE_FRAME_RECORD_BYTES;
+    const frameSize =
+      frameBase === undefined ? undefined : frameCapacity * SURFACE_FRAME_RECORD_BYTES;
+    if (
+      frameOffset !== undefined &&
+      frameSize !== undefined &&
+      (frameOffset % 256 !== 0 ||
+        frameSize <= 0 ||
+        frameOffset + frameSize > this.dynamicFrameBufferSize)
+    ) {
+      return err(
+        new RhiError({
+          code: 'rhi-descriptor-invalid',
+          expected: 'the Surface frame window is aligned and contained by the frame buffer',
+          hint: `bind the renderer-owned compact Surface frame range (base=${frameBase}, capacity=${frameCapacity}, bufferBytes=${this.dynamicFrameBufferSize})`,
+        }),
+      );
+    }
+    let groups = this.visibleWindowBindGroups.get(visibleBuffer);
+    if (groups === undefined) {
+      groups = new Map();
+      this.visibleWindowBindGroups.set(visibleBuffer, groups);
+    }
+    const key = `${visibleBase}:${visibleCapacity}:${frameBase ?? -1}:${frameCapacity}:${shadowVisibleAlias ? 'shadow' : 'main'}`;
+    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:
+            shadowVisibleAlias || this.probeBlendRecordBuffer === undefined
+              ? bufferBinding(visibleBuffer, offset, size)
+              : bufferBinding(this.probeBlendRecordBuffer),
+        },
+        { binding: 2, resource: bufferBinding(visibleBuffer, offset, size) },
+        { binding: 3, resource: bufferBinding(this.dynamicInputBuffer) },
+        {
+          binding: 4,
+          resource: bufferBinding(this.dynamicFrameBuffer, frameOffset, frameSize),
+        },
+        { binding: 5, resource: bufferBinding(this.dynamicSharedFrame.buffer) },
+      ],
+    });
+    if (!created.ok) return created;
+    groups.set(key, created.value);
+    return ok(created.value);
+  }
+
+  shadowVisibleWindowBindGroupForBuffer(
+    visibleBuffer: Buffer,
+    visibleBase: number,
+    visibleCapacity: number,
+  ): Result<BindGroup, RhiError> {
+    return this.visibleWindowBindGroupForBuffer(
+      visibleBuffer,
+      visibleBase,
+      visibleCapacity,
+      undefined,
+      undefined,
+      true,
+    );
+  }
+
+  private ensureDirectSurfaceAddresses(
+    frameRanges: readonly SurfaceFrameRange[],
+  ): Result<void, RhiError> {
+    const members = new Map<string, SurfaceFrameRange[]>();
+    for (const entry of frameRanges) {
+      const member = entry.directMember;
+      if (member === undefined) continue;
+      const key = JSON.stringify([member.worldId, member.entityKey, member.drawItemIndex]);
+      const group = members.get(key);
+      if (group === undefined) members.set(key, [entry]);
+      else group.push(entry);
+    }
+    const addresses = new Map<
+      string,
+      { readonly frameBase: number; readonly instanceCount: number; readonly byteOffset: number }
+    >();
+    const memberCount = [...members.values()].reduce((count, group) => count + group.length, 0);
+    const payload = new Uint8Array(Math.max(1, memberCount) * SURFACE_DIRECT_ADDRESS_STRIDE);
+    const view = new DataView(payload.buffer);
+    let addressIndex = 0;
+    for (const [key, group] of members) {
+      group.sort(
+        (left, right) =>
+          (left.directMember?.instanceOrdinal ?? 0) - (right.directMember?.instanceOrdinal ?? 0),
+      );
+      const first = group[0];
+      const firstMember = first?.directMember;
+      if (first === undefined || firstMember === undefined) continue;
+      const frameBase = first.frameIndex - firstMember.instanceOrdinal;
+      if (
+        frameBase < 0 ||
+        group.some(
+          (entry, ordinal) =>
+            entry.directMember?.instanceOrdinal !== ordinal ||
+            entry.frameIndex !== frameBase + ordinal,
+        )
+      ) {
+        return err(
+          surfaceDynamicInputError(
+            'each direct Surface draw has contiguous local instance ordinals and one frame-row base',
+            `rebuild the retained member projection for draw ${key}`,
+          ),
+        );
+      }
+      for (let ordinal = 0; ordinal < group.length; ordinal += 1) {
+        const byteOffset = addressIndex * SURFACE_DIRECT_ADDRESS_STRIDE;
+        view.setUint32(byteOffset, frameBase + ordinal, true);
+        view.setUint32(byteOffset + 4, group.length - ordinal, true);
+        addresses.set(`${key}:${ordinal}`, {
+          frameBase: frameBase + ordinal,
+          instanceCount: group.length - ordinal,
+          byteOffset,
+        });
+        addressIndex += 1;
+      }
+    }
+    const replacementSize = Math.max(this.directAddressBufferSize, payload.byteLength);
+    const replacement = this.device.createBuffer({
+      label: 'surface-direct-addresses',
+      size: replacementSize,
+      usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+    });
+    if (!replacement.ok) return replacement;
+    this.trackOwnedBuffer(replacement.value, replacementSize);
+    const write = this.device.queue.writeBuffer(replacement.value, 0, payload);
+    if (!write.ok) {
+      this.rollbackOwnedBuffer(replacement.value);
+      return write;
+    }
+    const previous = this.directAddressBuffer;
+    this.directAddressBuffer = replacement.value;
+    this.directAddressBufferSize = replacementSize;
+    this.directAddresses.clear();
+    for (const [key, address] of addresses) this.directAddresses.set(key, address);
+    this.directBindGroups.clear();
+    this.surfaceInputBuffers.add(replacement.value);
+    this.surfaceInputBuffers.delete(previous);
+    this.retireProjectionBuffer(previous);
+    return ok(undefined);
+  }
+
+  directSurfaceInstances(input: {
+    readonly worldId: number;
+    readonly entityKey: number;
+    readonly drawItemIndex: number;
+    readonly instanceCount: number;
+    readonly firstInstanceOrdinal?: number;
+    readonly instanceBuffer: Buffer;
+    readonly probeBuffer?: Buffer;
+    readonly probeOffset?: number;
+  }): Result<
+    {
+      readonly bindGroup: BindGroup;
+      readonly dynamicOffsets: readonly number[];
+      readonly frameBase: number;
+    },
+    RhiError
+  > {
+    const layout = this.surfaceDirectInstancesBindGroupLayout;
+    if (layout === null) {
+      return err(
+        surfaceDynamicInputError(
+          'the current device publishes the direct Surface slot-3 layout',
+          'keep the draw on recovery until the storage-backed Surface ABI is ready',
+        ),
+      );
+    }
+    const drawKey = JSON.stringify([input.worldId, input.entityKey, input.drawItemIndex]);
+    const firstInstanceOrdinal = input.firstInstanceOrdinal ?? 0;
+    const key = `${drawKey}:${firstInstanceOrdinal}`;
+    const address = this.directAddresses.get(key);
+    if (address === undefined || address.instanceCount < input.instanceCount) {
+      return err(
+        surfaceDynamicInputError(
+          'the direct Surface draw resolves one retained frame base with the same instance count',
+          `rebuild the producer projection for draw ${drawKey} at ordinal ${firstInstanceOrdinal} (instances=${input.instanceCount})`,
+        ),
+      );
+    }
+    const probeOffset = input.probeOffset ?? 0;
+    if (!Number.isSafeInteger(probeOffset) || probeOffset < 0) {
+      return err(
+        surfaceDynamicInputError(
+          'the direct Surface Probe offset is a non-negative safe integer',
+          'discard the draw and rebuild its producer-owned Probe binding before retrying',
+        ),
+      );
+    }
+    const retainedProbeBuffer = input.probeBuffer ?? this.probeBlendRecordBuffer;
+    if (probeOffset !== 0 && retainedProbeBuffer === undefined) {
+      return err(
+        surfaceDynamicInputError(
+          'a non-zero direct Surface Probe offset has its matched producer Probe buffer',
+          'forward the producer Probe buffer with the direct draw or use a zero Probe offset',
+        ),
+      );
+    }
+    const probeBuffer = retainedProbeBuffer ?? this.dynamicInputBuffer;
+    const cached = this.directBindGroups.get(key);
+    if (
+      cached !== undefined &&
+      cached.instanceBuffer === input.instanceBuffer &&
+      cached.probeBuffer === probeBuffer &&
+      cached.addressBuffer === this.directAddressBuffer
+    ) {
+      return ok({
+        bindGroup: cached.bindGroup,
+        dynamicOffsets: [probeOffset],
+        frameBase: address.frameBase,
+      });
+    }
+    const created = this.device.createBindGroup({
+      label: `surface-direct-instances-${input.worldId}-${input.entityKey}-${input.drawItemIndex}`,
+      layout,
+      entries: [
+        { binding: 0, resource: bufferBinding(input.instanceBuffer) },
+        {
+          binding: 1,
+          resource: bufferBinding(
+            probeBuffer,
+            0,
+            retainedProbeBuffer === undefined ? 16 : PROBE_BLEND_RECORD_BYTE_SIZE,
+          ),
+        },
+        { binding: 3, resource: bufferBinding(this.dynamicInputBuffer) },
+        { binding: 4, resource: bufferBinding(this.dynamicFrameBuffer) },
+        { binding: 5, resource: bufferBinding(this.dynamicSharedFrame.buffer) },
+        {
+          binding: 6,
+          resource: bufferBinding(
+            this.directAddressBuffer,
+            address.byteOffset,
+            SURFACE_SHARED_FRAME_BYTES,
+          ),
+        },
+      ],
+    });
+    if (!created.ok) return created;
+    this.directBindGroups.set(key, {
+      instanceBuffer: input.instanceBuffer,
+      probeBuffer,
+      addressBuffer: this.directAddressBuffer,
+      bindGroup: created.value,
+    });
+    return ok({
+      bindGroup: created.value,
+      dynamicOffsets: [probeOffset],
+      frameBase: address.frameBase,
+    });
+  }
+
+  /**
+   * Upload the generic Surface page and frame/range records through the same
+   * prepared GPU-driven owner that binds instances and visible rows.
+   */
+  ensureSurfaceDynamicInput(
+    frame: SurfaceDynamicInputFrame | undefined,
+    recordCapacity: number,
+    frameTime = frame?.frameTime ?? 0,
+    expectedLayout?: MaterialDynamicInputLayout,
+    expectedDeviceGeneration?: number,
+    frameRanges?: readonly SurfaceFrameRange[],
+  ): Result<void, RhiError> {
+    this.pendingDynamicInputUpload = undefined;
+    if (!Number.isFinite(frameTime)) {
+      return err(
+        surfaceDynamicInputError(
+          'the frame-time snapshot is finite',
+          'pass the World/App time snapshot to the Render owner',
+        ),
+      );
+    }
+    if (!Number.isSafeInteger(recordCapacity) || recordCapacity <= 0) {
+      return err(
+        surfaceDynamicInputError(
+          'the GPU-driven Surface frame capacity is a positive safe integer',
+          'prepare the frame from the bounded RenderScene batch capacity',
+        ),
+      );
+    }
+    const page = frame?.page;
+    if (expectedLayout === undefined && page !== undefined) {
+      return err(
+        surfaceDynamicInputError(
+          'a dynamic input page is supplied only when the published Surface ABI declares one',
+          'remove the page or recook the material with its dynamicInput declaration',
+        ),
+      );
+    }
+    if (expectedLayout !== undefined && page === undefined) {
+      return err(
+        surfaceDynamicInputError(
+          'the published Surface ABI dynamicInput page is present for this draw',
+          'publish the renderer-owned page before preparing the Surface draw',
+        ),
+      );
+    }
+    const ranges = frame?.ranges ?? [];
+    let compactFrameRanges = frameRanges;
+    if (compactFrameRanges === undefined) {
+      if (ranges === this.dynamicInputRangeSource && this.dynamicInputFrameRanges !== undefined) {
+        compactFrameRanges = this.dynamicInputFrameRanges;
+      } else {
+        compactFrameRanges = Object.freeze(
+          ranges.map(
+            (range) => ({ frameIndex: range.instanceIndex, range }) satisfies SurfaceFrameRange,
+          ),
+        );
+        this.dynamicInputRangeSource = ranges;
+        this.dynamicInputFrameRanges = compactFrameRanges;
+      }
+    }
+    const frameRangesChanged = compactFrameRanges !== this.dynamicFrameRangeSource;
+    if (frameRangesChanged) {
+      const frameIndices = new Set<number>();
+      for (const entry of compactFrameRanges) {
+        if (!Number.isSafeInteger(entry.frameIndex) || entry.frameIndex < 0) {
+          return err(
+            surfaceDynamicInputError(
+              'every renderer-owned Surface frame index is a non-negative safe integer',
+              'derive the visible-member row from the retained GPU Scene window',
+            ),
+          );
+        }
+        if (frameIndices.has(entry.frameIndex)) {
+          return err(
+            surfaceDynamicInputError(
+              'each Surface frame row has one renderer-owned visible member',
+              'repair the filtered scene-index membership before encoding the frame',
+            ),
+          );
+        }
+        frameIndices.add(entry.frameIndex);
+        if (entry.range !== undefined && !ranges.includes(entry.range)) {
+          return err(
+            surfaceDynamicInputError(
+              'each Surface row references a range from the submitted frame',
+              'derive the visible-member mapping from the same SurfaceDynamicInputFrame instance',
+            ),
+          );
+        }
+      }
+    }
+    let uploaded: DynamicInputUploadReceipt | undefined;
+    if (page !== undefined) {
+      if (!sameDynamicInputLayout(page.layout, expectedLayout ?? page.layout)) {
+        return err(
+          surfaceDynamicInputError(
+            'the submitted Surface dynamic page matches the cooked MaterialProgramAbi layout',
+            'recreate the page from the published dynamicInput layout before drawing',
+          ),
+        );
+      }
+      if (
+        expectedDeviceGeneration !== undefined &&
+        page.deviceGeneration !== expectedDeviceGeneration
+      ) {
+        return err(
+          surfaceDynamicInputError(
+            'the submitted Surface dynamic page belongs to the current renderer device generation',
+            'reconfigure the page and retry after device recovery',
+          ),
+        );
+      }
+      if (
+        page.bytes.byteLength !== page.schema.maxPageBytes ||
+        page.layout.stride * page.schema.maxRecords > page.bytes.byteLength
+      ) {
+        return err(
+          surfaceDynamicInputError(
+            'the dynamic page byte length covers its derived bounded record layout',
+            'recreate the page through ReadonlyDynamicInputPage.create()',
+          ),
+        );
+      }
+      const begun = page.beginUpload();
+      if (!begun.ok) {
+        return err(
+          surfaceDynamicInputError(
+            'a live Surface dynamic input page can produce an upload receipt',
+            begun.error.hint,
+          ),
+        );
+      }
+      uploaded = begun.value;
+    }
+    if (frameRangesChanged) {
+      const rangeAddresses = new Set<number>();
+      for (const range of ranges) {
+        if (page === undefined) {
+          return err(
+            surfaceDynamicInputError(
+              'Surface dynamic ranges are paired with their renderer-owned page',
+              'provide the page that owns the submitted ranges',
+            ),
+          );
+        }
+        const invalidRange = invalidSurfaceDynamicRange(page, range, expectedDeviceGeneration);
+        if (invalidRange !== undefined) {
+          return err(
+            surfaceDynamicInputError(
+              'every Surface dynamic range matches the published page schema and generation',
+              invalidRange,
+            ),
+          );
+        }
+        if (rangeAddresses.has(range.instanceIndex)) {
+          return err(
+            surfaceDynamicInputError(
+              'each Surface dynamic instance address has one unambiguous record range',
+              'merge duplicate ranges before publishing the frame projection',
+            ),
+          );
+        }
+        rangeAddresses.add(range.instanceIndex);
+      }
+      const directAddresses = this.ensureDirectSurfaceAddresses(compactFrameRanges);
+      if (!directAddresses.ok) return directAddresses;
+    }
+    const pageChanged = page !== undefined && page !== this.dynamicInputPage;
+    const pageGenerationChanged =
+      page !== undefined && page.bufferGeneration !== this.dynamicInputPageGeneration;
+    if (page !== undefined) {
+      const requiredBytes = Math.max(16, page.bytes.byteLength);
+      const maxStorageBufferBindingSize = this.device.limits.maxStorageBufferBindingSize;
+      if (
+        Number.isFinite(maxStorageBufferBindingSize) &&
+        requiredBytes > maxStorageBufferBindingSize
+      ) {
+        return err(
+          new RhiError({
+            code: 'limit-exceeded',
+            expected: 'the Surface dynamic page fits maxStorageBufferBindingSize',
+            hint: 'reduce the published dynamic page budget before entering the GPU lane',
+            detail: { maxStorageBufferBindingSize, requestedBytes: requiredBytes },
+          }),
+        );
+      }
+      if (requiredBytes > this.dynamicInputBufferSize || pageChanged || pageGenerationChanged) {
+        const replacement = this.device.createBuffer({
+          label: 'surface-dynamic-input-page',
+          size: requiredBytes,
+          usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST,
+        });
+        if (!replacement.ok) return replacement;
+        this.trackOwnedBuffer(replacement.value, requiredBytes);
+        const initialWrite = this.device.queue.writeBuffer(replacement.value, 0, page.bytes);
+        if (!initialWrite.ok) {
+          this.rollbackOwnedBuffer(replacement.value);
+          return initialWrite;
+        }
+        const previous = this.dynamicInputBuffer;
+        const previousSize = this.dynamicInputBufferSize;
+        const previousPage = this.dynamicInputPage;
+        const previousGeneration = this.dynamicInputPageGeneration;
+        this.dynamicInputBuffer = replacement.value;
+        this.dynamicInputBufferSize = requiredBytes;
+        this.dynamicInputPage = page;
+        this.dynamicInputPageGeneration = page.bufferGeneration;
+        this.surfaceInputBuffers.add(replacement.value);
+        const rebound = this.rebuildInstancesBindGroup();
+        if (!rebound.ok) {
+          this.dynamicInputBuffer = previous;
+          this.dynamicInputBufferSize = previousSize;
+          this.dynamicInputPage = previousPage;
+          this.dynamicInputPageGeneration = previousGeneration;
+          this.surfaceInputBuffers.delete(replacement.value);
+          this.rollbackOwnedBuffer(replacement.value);
+          return rebound;
+        }
+        this.visibleWindowBindGroups.clear();
+        this.directBindGroups.clear();
+        this.retireProjectionBuffer(previous);
+      } else {
+        for (const range of uploaded?.ranges ?? []) {
+          const write = this.device.queue.writeBuffer(
+            this.dynamicInputBuffer,
+            range.byteStart,
+            page.bytes.slice(range.byteStart, range.byteEnd),
+          );
+          if (!write.ok) return write;
+        }
+        this.dynamicInputPage = page;
+        this.dynamicInputPageGeneration = page.bufferGeneration;
+      }
+      this.pendingDynamicInputUpload =
+        uploaded === undefined ? undefined : { page, receipt: uploaded };
+    }
+
+    const compactRangeCapacity = frameRangesChanged
+      ? compactFrameRanges.reduce((capacity, entry) => Math.max(capacity, entry.frameIndex + 1), 0)
+      : this.dynamicFrameRangeCapacity;
+    const capacity = Math.max(1, recordCapacity, compactRangeCapacity);
+    if (capacity > Number.MAX_SAFE_INTEGER / SURFACE_FRAME_RECORD_BYTES) {
+      return err(
+        surfaceDynamicInputError(
+          'the Surface frame record allocation fits the JavaScript safe integer range',
+          'reduce the explicit instance address range before preparing the frame',
+        ),
+      );
+    }
+    const requiredFrameBytes = capacity * SURFACE_FRAME_RECORD_BYTES;
+    const maxStorageBufferBindingSize = this.device.limits.maxStorageBufferBindingSize;
+    if (
+      Number.isFinite(maxStorageBufferBindingSize) &&
+      requiredFrameBytes > maxStorageBufferBindingSize
+    ) {
+      return err(
+        new RhiError({
+          code: 'limit-exceeded',
+          expected: 'the Surface frame records fit maxStorageBufferBindingSize',
+          hint: 'reduce the explicit instance address range or the batch capacity',
+          detail: { maxStorageBufferBindingSize, requestedBytes: requiredFrameBytes },
+        }),
+      );
+    }
+    let frameBufferReplaced = false;
+    if (requiredFrameBytes > this.dynamicFrameBufferSize) {
+      const replacement = this.device.createBuffer({
+        label: 'surface-dynamic-frame-input',
+        size: requiredFrameBytes,
+        usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST,
+      });
+      if (!replacement.ok) return replacement;
+      this.trackOwnedBuffer(replacement.value, requiredFrameBytes);
+      const previous = this.dynamicFrameBuffer;
+      const previousSize = this.dynamicFrameBufferSize;
+      this.dynamicFrameBuffer = replacement.value;
+      this.dynamicFrameBufferSize = requiredFrameBytes;
+      this.surfaceInputBuffers.add(replacement.value);
+      const rebound = this.rebuildInstancesBindGroup();
+      if (!rebound.ok) {
+        this.dynamicFrameBuffer = previous;
+        this.dynamicFrameBufferSize = previousSize;
+        this.surfaceInputBuffers.delete(replacement.value);
+        this.rollbackOwnedBuffer(replacement.value);
+        return rebound;
+      }
+      this.visibleWindowBindGroups.clear();
+      this.directBindGroups.clear();
+      this.retireProjectionBuffer(previous);
+      this.dynamicFrameRows.clear();
+      this.dynamicFrameRangeSource = undefined;
+      frameBufferReplaced = true;
+    }
+
+    if (frameTime !== this.dynamicSharedFrame.frameTime) {
+      const payload = new Float32Array(4);
+      payload[0] = frameTime;
+      const write = this.device.queue.writeBuffer(this.dynamicSharedFrame.buffer, 0, payload);
+      if (!write.ok) return write;
+      this.dynamicSharedFrame.frameTime = frameTime;
+      this.dynamicSharedFrame.writes += 1;
+    }
+
+    if (!frameBufferReplaced && !frameRangesChanged) {
+      return ok(undefined);
+    }
+
+    const desiredFrameRows = new Map<number, SurfaceFrameRow>();
+    for (const entry of compactFrameRanges) {
+      this.dynamicFrameMemberScans += 1;
+      desiredFrameRows.set(entry.frameIndex, {
+        eventRangeStart: entry.range?.recordStart ?? 0,
+        eventRangeCount: entry.range?.recordCount ?? 0,
+        instanceIndex: entry.range?.instanceIndex ?? 0,
+        // A Surface submission is prepared only for the typed medium graph,
+        // whose Standard producer has already published the sampled raw-depth
+        // pair. Keep this bit in the frame ABI so the shader consumes the
+        // graph-paired resources rather than interpreting zero facts as a
+        // zero optical path.
+        backgroundAvailable: true,
+      });
+    }
+    // A compact index can disappear when visibility or LOD changes. Clear
+    // the old row while its buffer still exists so a reused visible window
+    // cannot observe the prior event range. The zero row is retained in the
+    // CPU cache and therefore costs one write only at retirement.
+    for (const [frameIndex] of this.dynamicFrameRows) {
+      if (desiredFrameRows.has(frameIndex)) continue;
+      if ((frameIndex + 1) * SURFACE_FRAME_RECORD_BYTES > this.dynamicFrameBufferSize) {
+        continue;
+      }
+      desiredFrameRows.set(frameIndex, {
+        eventRangeStart: 0,
+        eventRangeCount: 0,
+        instanceIndex: 0,
+        backgroundAvailable: false,
+      });
+    }
+    for (const [frameIndex, row] of desiredFrameRows) {
+      const previous = this.dynamicFrameRows.get(frameIndex);
+      if (!frameBufferReplaced && previous !== undefined && sameSurfaceFrameRow(previous, row))
+        continue;
+      const payload = new Uint8Array(SURFACE_FRAME_RECORD_BYTES);
+      this.dynamicFrameRowAllocations += 1;
+      writeSurfaceFrameRecord(
+        new DataView(payload.buffer),
+        0,
+        0,
+        row.eventRangeStart,
+        row.eventRangeCount,
+        row.instanceIndex,
+        row.backgroundAvailable,
+      );
+      const frameWrite = this.device.queue.writeBuffer(
+        this.dynamicFrameBuffer,
+        frameIndex * SURFACE_FRAME_RECORD_BYTES,
+        payload,
+      );
+      if (!frameWrite.ok) return frameWrite;
+      this.dynamicFrameRows.set(frameIndex, row);
+    }
+    this.dynamicFrameRangeSource = compactFrameRanges;
+    this.dynamicFrameRangeCapacity = compactRangeCapacity;
+    return ok(undefined);
+  }
+
+  commitSurfaceDynamicInput(): Result<void, RhiError> {
+    if (this.pendingDynamicInputUpload === undefined) return ok(undefined);
+    const { page, receipt } = this.pendingDynamicInputUpload;
+    const committed = page.commitUpload(receipt);
+    if (!committed.ok) {
+      return err(
+        surfaceDynamicInputError(
+          'the Surface dynamic page upload remains current through every queue write',
+          committed.error.hint,
+        ),
+      );
+    }
+    this.pendingDynamicInputUpload = undefined;
+    return ok(undefined);
+  }
+
+  abortSurfaceDynamicInput(): void {
+    this.pendingDynamicInputUpload = undefined;
+  }
+
+  private rebuildInstancesBindGroup(): Result<void, RhiError> {
+    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(this.probeBlendRecordBuffer ?? this.visibleBuffer),
+        },
+        { binding: 2, resource: bufferBinding(this.visibleBuffer) },
+        { binding: 3, resource: bufferBinding(this.dynamicInputBuffer) },
+        { binding: 4, resource: bufferBinding(this.dynamicFrameBuffer) },
+        { binding: 5, resource: bufferBinding(this.dynamicSharedFrame.buffer) },
+      ],
+    });
+    if (!created.ok) return created;
+    this.instancesBindGroup = created.value;
+    return ok(undefined);
+  }
+
+  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 pipelineUvSetCount = isCanonicalStandardPbrMaterialShader(selectedArtifact.material)
+      ? shaderUvSetCount
+      : (selectedArtifact.uvSetCount ?? shaderUvSetCount);
+    const vertexLayout = deriveVertexBufferLayoutFromProjection(layoutProjection, {
+      shaderUvSetCount: pipelineUvSetCount,
+    })[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${pipelineUvSetCount}`;
+    const cached = this.pipelines.get(key);
+    if (cached !== undefined) return ok(cached);
+    if (this.pipelineFactory !== undefined) {
+      const expectsClusteredGroup =
+        isStandardPbrMaterialShader(selectedArtifact.material) &&
+        (selectedArtifact.variantSet === '' ||
+          selectedArtifact.variantSet?.includes('CLUSTER_FORWARD_AVAILABLE=true') === true);
+      const layoutKind = expectsClusteredGroup
+        ? this.deformation === 'skin'
+          ? 'gpu-driven-cluster-skin'
+          : 'gpu-driven-cluster-pbr'
+        : this.deformation === 'skin'
+          ? 'gpu-driven-skin'
+          : 'gpu-driven-pbr';
+      const pipelineEntry = this.pipelineFactory(
+        selectedArtifact.specializationKey ?? selectedArtifact.material,
+        false,
+        renderState,
+        topology,
+        stripIndexFormat,
+        selectedArtifact.variantSet,
+        'forward',
+        undefined,
+        sampleCount,
+        format,
+        pipelineUvSetCount,
+        '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',
+        layoutKind,
+        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 = expectsClusteredGroup
+        ? this.deformation === 'skin'
+          ? 'skin-cluster'
+          : 'cluster'
+        : this.deformation === 'skin'
+          ? 'skin'
+          : 'mesh';
+      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((additionalFormat) => ({ format: additionalFormat })),
+        ],
+      },
+      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_PER_ENTITY_STRIDE,
+        (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_PER_ENTITY_STRIDE, rows.byteLength),
+    );
+    if (!created.ok) return created;
+    return ok(created.value.bindGroup);
+  }
+
+  projectionBuffer(
+    key: string,
+  ): { readonly buffer: Buffer; readonly bindingBytes: number } | undefined {
+    const projection = this.stagedProjectionBindings.get(key) ?? this.projectionBindings.get(key);
+    return projection === undefined
+      ? undefined
+      : { buffer: projection.buffer, bindingBytes: projection.capacityBytes };
+  }
+
+  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_PER_ENTITY_STRIDE,
+        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);
+  }
+
+  /** 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;
+    this.trackOwnedBuffer(buffer.value, capacityBytes);
+    this.projectionBuffers.add(buffer.value);
+    const write = this.device.queue.writeBuffer(buffer.value, 0, rows);
+    if (!write.ok) {
+      this.rollbackOwnedBuffer(buffer.value);
+      return write;
+    }
+    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.rollbackOwnedBuffer(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 {
+    if (this.projectionDisposed) return;
+    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.dynamicFrameRows.clear();
+    this.dynamicFrameRangeSource = undefined;
+    this.dynamicInputRangeSource = undefined;
+    this.dynamicInputFrameRanges = undefined;
+    this.dynamicFrameRangeCapacity = 0;
+    this.destroyProjectionBuffer(this.instanceBuffer);
+    for (const buffer of this.surfaceInputBuffers) this.destroyProjectionBuffer(buffer);
+    this.surfaceInputBuffers.clear();
+  }
+
+  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;
+    const token = this.allocationTokens.get(buffer);
+    if (token !== undefined) this.allocationLedger.retire(token);
+    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.surfaceInputBuffers.delete(buffer);
+    const token = this.allocationTokens.get(buffer);
+    if (token !== undefined) this.allocationLedger.release(token);
+    this.device.destroyBuffer(buffer);
+  }
+
+  private trackOwnedBuffer(buffer: Buffer, bytes: number): void {
+    if (this.allocationTokens.has(buffer)) return;
+    this.allocationTokens.set(buffer, this.allocationLedger.allocate(bytes));
+  }
+
+  private rollbackOwnedBuffer(buffer: Buffer): void {
+    if (this.destroyedProjectionBuffers.has(buffer)) return;
+    this.destroyedProjectionBuffers.add(buffer);
+    this.projectionBuffers.delete(buffer);
+    this.surfaceInputBuffers.delete(buffer);
+    this.pendingProjectionRetirements.delete(buffer);
+    const token = this.allocationTokens.get(buffer);
+    if (token !== undefined) this.allocationLedger.rollback(token);
+    this.device.destroyBuffer(buffer);
+  }
+
+  get instancesFrameGroup(): BindGroup {
+    return this.instancesBindGroup;
+  }
+
+  get surfaceDynamicInputBuffer(): Buffer {
+    return this.dynamicInputBuffer;
+  }
+
+  get surfaceDynamicFrameBuffer(): Buffer {
+    return this.dynamicFrameBuffer;
+  }
+
+  get surfaceDynamicSharedFrameBuffer(): Buffer {
+    return this.dynamicSharedFrame.buffer;
+  }
+
+  get surfaceDynamicInputBufferSize(): number {
+    return this.dynamicInputBufferSize;
+  }
+
+  get surfaceDynamicFrameBufferSize(): number {
+    return this.dynamicFrameBufferSize;
+  }
+
+  get surfaceDynamicSharedFrameBufferSize(): number {
+    return SURFACE_SHARED_FRAME_BYTES;
+  }
+
+  get surfaceDynamicFrameRowAllocations(): number {
+    return this.dynamicFrameRowAllocations;
+  }
+
+  get surfaceDynamicFrameMemberScans(): number {
+    return this.dynamicFrameMemberScans;
+  }
+
+  /** Logical bytes owned by this adapter; external scene buffers are excluded. */
+  get resourceAllocation(): import('../inspection-types').GpuResourceAllocationInspection {
+    return this.allocationLedger.inspect();
+  }
+
+  get surfaceDynamicFrameTimeWrites(): number {
+    return this.dynamicSharedFrame.writes;
+  }
+
+  get surfaceDynamicSharedFrameState(): SurfaceSharedFrameState {
+    return this.dynamicSharedFrame;
+  }
+
+  get kind(): 'rigid' | 'skin' {
+    return this.deformation;
+  }
+}