@forgeax/engine-render 0.1.28 → 0.1.30

package/src/assembly/webgpu-renderer.ts

@@ -1,24 +1,5 @@
-// @forgeax/engine-render — concrete Renderer lifecycle and frame interpreter.
-//
-// The Runtime host selects one typed backend pack before this assembly runs.
-//
-// **D-P4 three-channel error propagation** (RK-04 + plan-strategy §7.3):
-//   (a) Construction-time → `createRenderer(...)` rejects with
-//       `EngineEnvironmentError` whose `detail.webgpuError` is the Channel 2
-//       `RhiError` and `detail.wgpuError` is the Channel 3 failure (when both
-//       channels fail; AI users `try { await createRenderer(...) } catch (e) {
-//       switch (e.detail.webgpuError?.code) { ... } }`).
-//   (b) Run-time pipeline build → `renderer.initialization` rejects with the
-//       structured `RhiError` (`shader-compile-failed` / `limit-exceeded` /
-//       `webgpu-runtime-error` / ...); AI users `await renderer.initialization`.
-//   (c) error fan-out → `renderer.subscribe(listener)` captures the same
-//       errors as a fallback observability channel (charter proposition 4
-//       structured + proposition 9 graceful degradation).
-//
-// AC-15 source-level: this file uses `globalThis.navigator` rather than
-// `navigator` directly; it never touches `window` or `document`.
-
-import type { MipmapShaderModuleFactory } from '@forgeax/engine-assets-runtime';
+// @forgeax/engine-render — WebGPU renderer lifecycle/frame interpreter.
+// Runtime selects the backend; structured RHI errors and browser isolation stay intact.
 import {
   AssetRegistry,
   adaptDynamicTextureDevice,
@@ -28,12 +9,12 @@ import { audioLoader } from '@forgeax/engine-audio-webaudio';
 import { Update, type World } from '@forgeax/engine-ecs';
 import { createRenderReadLease, type RenderReadLease } from '@forgeax/engine-ecs/projection';
 import {
-  deriveVertexBufferLayout,
-  deriveVertexBufferLayoutFromProjection,
+  DEFAULT_VERTEX_ATTRIBUTE_MAP,
   type VertexLayoutProjection,
 } from '@forgeax/engine-geometry';
 import type {
   BindGroupLayout,
+  Buffer,
   PipelineLayout,
   RenderPipeline,
   Result,
@@ -50,19 +31,17 @@ import {
   standardPhysicalTextureFields,
 } from '@forgeax/engine-shader';
 import type {
-  ImportTransport,
   MaterialRenderState,
   ParamSchemaEntry,
   PassKind,
   PrimitiveTopology,
   VertexAttributeMap,
 } from '@forgeax/engine-types';
-import { createDynamicGeometryLifecycle } from '../dynamic-geometry';
+import { transmissionBackdropAvailable } from './device-feature-admission';
 
 export type { MaterialShaderManifestEntry } from '@forgeax/engine-shader';
 
 import { GpuResidencyCache } from '../device/gpu-residency';
-import type { DeviceResourceKind } from '../device/resource-types';
 import { createEngineMetrics } from '../engine-metrics';
 import { createRecoveryFailedError, RecoverError, type RecoverFailure } from '../errors/recover';
 import {
@@ -74,7 +53,7 @@ import {
   RenderFeatureCapabilityMissingError,
   RenderFeatureStageFailedError,
 } from '../errors/render';
-import { createRenderFeatureHost, type RenderFeatureHost } from '../features/host';
+import { createRenderFeatureHost } from '../features/host';
 import { RENDER_FEATURE_VERTEX_LAYOUTS } from '../features/prepared-graphics';
 import type { RenderFeature, RenderFeatureShaderModuleMode } from '../features/types';
 import {
@@ -84,13 +63,9 @@ import {
 import { glyphTextLayoutSystem } from '../glyph-text-layout-system';
 import { GPU_SHADER_STAGE_FRAGMENT, GPU_SHADER_STAGE_VERTEX } from '../gpu-stage';
 import type { BloomInspection } from '../inspection-types';
+import { DeviceScope } from '../lifecycle';
 import {
-  DeviceScope,
-  HealthListenerRegistry,
-  LostListenerRegistry,
-  RhiErrorListenerRegistry,
-} from '../lifecycle';
-import {
+  createHdrpBindGroupLayoutDescriptor,
   isCanonicalStandardPbrMaterialShader,
   isStandardPbrMaterialShader,
   type PipelineGroup2Contract,
@@ -105,6 +80,7 @@ import {
   cacheKeyOf,
   colorFormatsForPassKind,
   type PipelineSpec,
+  PipelineSpecError,
   passKindPolicyTable,
 } from '../pipeline-spec';
 import type { ExtendedLightingResourceCandidate } from '../prepare/extended-lighting/resources';
@@ -122,6 +98,7 @@ import {
   promoteExtendedLightingCandidate,
 } from '../prepare/extended-lighting/state';
 import type { FrameObservationOptions } from '../record/frame';
+import { getTextureIdentity } from '../record/frame-snapshot';
 import type { GpuPassTimingReason } from '../record/gpu-pass-timing/errors.js';
 import {
   createGpuPassTimingSession,
@@ -131,14 +108,14 @@ import {
   type GpuPassTimingSession,
 } from '../record/gpu-pass-timing/index.js';
 import { GpuTimingCapture, type VolumeTimingObservation } from '../record/gpu-timing';
-import type { RecoveryColdWorkGuard } from '../record/render-context';
 import type {
+  AtmosphereShaderSources,
   DrawOwnerOptions,
+  FrameObservationDomain,
   FrameObservationRequest,
   FrameReceipt,
   FrameReceiptObservation,
   HealthSnapshot,
-  RenderDebugOverlay,
   RendererErrorListener,
   RendererLostListener,
   RendererOptions,
@@ -147,6 +124,7 @@ import type {
   RenderProfile,
   RenderResult,
   RenderWorldLease,
+  SsrShaderSources,
   VolumetricFogShaderSources,
 } from '../render-contract';
 import { FXAA_POST_PROCESS_ID, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID } from '../render-contract';
@@ -163,11 +141,18 @@ import { createGpuPassTimingObservationStore, observeGpuPassTimingDisabled } fro
 import { postSpawnResolveJoints } from '../scene-instances/post-spawn-resolve-joints';
 import type { RenderTarget } from '../targets/contracts';
 import { tilemapChunkExtractSystem } from '../tilemap-chunk-extract-system';
+import type { TypedFrameObservationCapture } from '../typed-render-graph-primitives';
 import type { RhiBackendPack } from './backend-contract';
 import type { BundlerOptions } from './bundler-contract';
-import { deviceOptionsForAdapter } from './device-feature-admission';
-import { createDynamicGeometryHost } from './dynamic-geometry-host';
+import { createRendererDynamicGeometryController } from './dynamic-geometry-host';
 import type { RendererAssemblyImplementation } from './host-contract';
+import {
+  isEngineOwnedMaterialShader,
+  resolveMaterialPipelineBindGroups,
+  resolveMaterialPipelineShaderId,
+  resolveMaterialPipelineVertexEntry,
+  resolveRendererMaterialShaderArtifact,
+} from './material/pipeline-helpers';
 import {
   allowsUnlitPreparedFallback,
   invokeDeviceCreateShaderModule,
@@ -188,7 +173,6 @@ import {
   shouldDeferMissingPreparedMaterialShader,
 } from './material-shader-policy';
 import type { MeshSsboGrowResult, MeshSsboState } from './mesh-ssbo-grow';
-import { attachDeviceLostFanout } from './recovery/device-loss-fanout';
 import {
   type GenerationAggregate,
   type GenerationPublication,
@@ -201,32 +185,48 @@ import {
   structuredRendererCause,
   validateRenderProfile,
 } from './renderer-facade';
+import { projectRendererFeatureInspection } from './renderer-feature-inspection';
 import {
   type ContinuationTerminator,
   createContinuationTerminator,
 } from './renderer-frame-transaction';
-import { ensureContextConfigured, wrapDisposeError } from './renderer-helpers';
+import {
+  ensureContextConfigured,
+  rendererInitializationError,
+  rendererInitializationPipelineError,
+  wrapDisposeError,
+} from './renderer-helpers';
 import { projectRendererOutputInspection } from './renderer-inspection';
 import {
   createRecoveryContinuation,
   createRecoveryDeadline,
   createSingleFlight,
-  type RecoveryGuidance,
   type RecoveryPhase,
 } from './renderer-lifecycle';
+import { derivedPhysicsFrameError } from './webgpu-renderer-guards';
+import {
+  createRecoveryFailureLocation,
+  type RecoveryFailureLocation,
+} from './webgpu-renderer-recovery-failure';
+
+export type { RecoveryFailureLocation } from './webgpu-renderer-recovery-failure';
+
 import { STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES } from './shader-prewarm-policy';
 import { buildReadyWebGPU } from './webgpu-ready';
 import { DEPTH_TEXTURE_FORMAT, HDR_COLOR_ATTACHMENT_FORMAT } from './webgpu-ready-contract';
+import { adaptMipmapShaderModuleFactory } from './webgpu-ready-mipmap';
+import {
+  tryCreateWebGPURenderer as tryCreateWebGPURendererBootstrap,
+  type WebGPURendererInternals,
+} from './webgpu-renderer-bootstrap';
+import type { WebGPUOutcome } from './webgpu-renderer-contract';
+import { disposeObservationCaptureSet } from './webgpu-renderer-observation';
 import {
-  BILLBOARD_MATERIAL_INSTANCE_VERTEX_BUFFERS,
-  DEFAULT_VERTEX_ATTRS,
-  MESH_GEOMETRY_MATERIAL_INSTANCE_VERTEX_BUFFERS,
-  PBR_SKIN_SENTINEL_ATTR_BUFFER,
-  POSITION_SIZE_COLOR_INSTANCE_VERTEX_BUFFERS,
+  isPreparedMaterialVertexLayout,
   PREPARED_INSTANCE_VERTEX_ATTRS,
   PREPARED_MATERIAL_INSTANCE_VERTEX_ATTRS,
-  TOPOLOGY_SEGMENT_INSTANCE_VERTEX_BUFFERS,
-  toGpuVertexBufferLayouts,
+  particleMaterialInputVertexBuffers,
+  resolveWebGPUVertexBufferLayouts,
 } from './webgpu-vertex-layouts';
 
 export type { BundlerOptions } from './bundler-contract';
@@ -249,366 +249,45 @@ export {
   selectPipelineLayoutForVariant,
   shouldDeferMissingPreparedMaterialShader,
 } from './material-shader-policy';
-export type {
-  MeshSsboBufferWrapper,
-  MeshSsboGrowController,
-  MeshSsboGrowControllerInit,
-  MeshSsboGrowDevice,
-  MeshSsboGrowErrorRegistry,
-  MeshSsboGrowResult,
-  MeshSsboState,
-} from './mesh-ssbo-grow';
 export {
   createMeshSsboGrowController,
   deriveStorageBufferCeiling,
   INITIAL_MESH_SSBO_SLOT_COUNT,
+  type MeshSsboBufferWrapper,
+  type MeshSsboGrowController,
+  type MeshSsboGrowControllerInit,
+  type MeshSsboGrowDevice,
+  type MeshSsboGrowErrorRegistry,
+  type MeshSsboGrowResult,
+  type MeshSsboState,
   requireMeshSsboBuffer,
 } from './mesh-ssbo-grow';
 export { exposeRenderer } from './renderer-facade';
 export {
+  selectGpuDrivenSceneIndexVariant,
   selectHdrpPbrPrewarmVariants,
   selectProbePrewarmVariants,
   selectSkinPrewarmVariants,
   selectStandardPbrTransmissionPrewarmVariants,
 } from './shader-prewarm-policy';
+export type { WebGPUOutcome, WebGPURendererInternals } from './webgpu-renderer-contract';
+export { disposeObservationCaptureSet } from './webgpu-renderer-observation';
 
-function adaptMipmapShaderModuleFactory(
-  factory: RhiBackendPack['createShaderModule'],
-): MipmapShaderModuleFactory | undefined {
-  if (factory === undefined) return undefined;
-  return (device, descriptor) => factory(device as RhiDevice, descriptor);
-}
-
-// Re-export registerAdvanceAnimationPlayer so consumers can wire it.
-// Re-export registerPropagateTransforms so consumers can wire the
-// Transform.world mat4 derivation (audio listener sync + picking read the
-// derived Transform.world from scripts).
-
-/**
- * Bundler-layer injection accepted by `createRenderer` (and proxied by
- * `createApp`) as the optional third argument.
- *
- * feat-20260608-create-app-param-surface-trim / M2 / D-3: aggregates the two
- * host-injected build-tool channels:
- *
- *   - shaderManifestUrl: the URL the host's vite-plugin-shader emit step
- *     wrote `manifest.json` to. When this field is omitted (or `bundler`
- *     itself is omitted), createRenderer falls back to
- *     '/shaders/manifest.json' (D-2 q5-A) so the LO 1.1 zero-config takeoff
- *     path keeps working without explicit injection. Tests can inject via a
- *     `data:application/json,...` URL to bypass fetch.
- *
- *   - importTransport: dev-only ImportTransport forwarded verbatim to the
- *     AssetRegistry third ctor slot so DDC-miss assets can lazy-import.
- *     Absent => shipped form (a DDC miss fails fast with `asset-not-imported`).
- *
- * The interface is structurally shared with `@forgeax/engine-app` while this
- * package keeps the renderer independent from the host package.
- */
-// ─── Backend pack — M3 auto-select internal shape ───────────────────────────
-
-// ─── WebGPU branch ──────────────────────────────────────────────────────────
-
-/**
- * Wire the spec `device.lost` Promise into the lost / error / health channels
- * (research §F-4 / R2). A genuine device loss fans out through `errorRegistry`
- * so the public `renderer.subscribe` error event triggers, and
- * through `healthRegistry` so `health().reason` flips to `'device-lost'`
- * (feat-20260622-s5 M1/M2). Explicit renderer teardown is observable through
- * `onLost`, but is not a runtime error and must not manufacture an RhiError.
- *
- * Extracted to a single helper (SSOT) so the createRenderer assembly path AND
- * the recover() rebuild path attach byte-identical fan-out to whichever device
- * is current — recover() mints a fresh device whose own `lost` Promise must be
- * re-wired to the SAME registries the host already subscribed to.
- */
-// Device loss wiring lives in the recovery assembly seam so boot and recovery
-// cannot drift into separate lifecycle event paths.
-
-/**
- * tryCreateWebGPURenderer returns three kinds of outcome (fix-f1 / w16):
- * - `ok`           → Renderer created successfully
- * - `rhi-err`      → RHI Result.err path (preserves the original RhiError
- *                    for AI consumers to read; now includes context acquisition
- *                    failures via pack.rhi.acquireCanvasContext)
- * - `throw`        → exception path (caught and wrapped by the caller as
- *                    an Error)
- */
-export type WebGPUOutcome =
-  | { kind: 'ok'; renderer: RendererAssemblyImplementation }
-  | { kind: 'rhi-err'; error: RhiError }
-  | { kind: 'throw'; error: Error };
-
-/**
- * Goes through the strict two-step path exposed by the injected backend pack:
- *   `rhi.requestAdapter()` -> `adapter.requestDevice()`
- * (M6 fix-up [w51] retires the legacy single-step factory per plan-strategy
- * §6 M3 break-point #2 + AGENTS.md break-point list 2026-05-10 #2). Returns
- * `Result<RhiAdapter, RhiError>` then `Result<RhiDevice, RhiError>`; each
- * failure / failure to acquire the canvas WebGPU context returns a
- * structured outcome so the caller can decide on fallback and error-
- * preservation strategy (plan-strategy §7.3).
- *
- * fix-f1: on either Result.err path the original `RhiError` is preserved
- * via the `rhi-err` outcome — when fallback also fails, AI consumers read
- * it via `EngineEnvironmentError.detail.webgpuError.code`.
- *
- * w19 / M4: context acquisition goes through `pack.rhi.acquireCanvasContext(canvas)`
- * — a polymorphic entry owned by the selected backend adapter.
- * The backend pack is selected BEFORE this call (in `loadBackendPack` /
- * the Channel 2→3 fallback in `createRenderer`), so the canvas context
- * is never type-locked by a wrong backend's acquisition attempt.
- */
+/** Bundler injection and the WebGPU renderer construction entry points. */
 let nextDerivedSystemId = 0;
-
 export async function tryCreateWebGPURenderer(
   canvas: HTMLCanvasElement | OffscreenCanvas,
   options: RendererOptions | undefined,
   pack: RhiBackendPack,
-  // feat-20260608 M2 / D-3: BundlerOptions threaded verbatim. Carries
-  // shaderManifestUrl (consumed in getShader fallback ~30 lines below) and
-  // importTransport (forwarded to the AssetRegistry third ctor slot;
-  // undefined keeps the shipped form, AC-08).
   bundler: BundlerOptions | undefined,
 ): Promise<WebGPUOutcome> {
-  const importTransport = bundler?.importTransport;
-  // M6 fix-up [w51]: spec-aligned two-step path. Step 1 - requestAdapter()
-  // surfaces adapter.features / adapter.limits (capability pre-screen,
-  // charter proposition 4 forward-reachable). Step 2 - adapter.requestDevice()
-  // requests the actual device. M3 D-P4: `pack.rhi` is the auto-selected
-  // backend singleton (rhi-webgpu / rhi-wgpu / explicit escape hatch).
-  // w19: thread canvas as compatibleSurface so the wgpu GL backend can
-  // enumerate adapters against it (escape hatch, capability-gated).
-  const adapterResult = await pack.rhi.requestAdapter(undefined, canvas);
-  if (!adapterResult.ok) {
-    return { kind: 'rhi-err', error: adapterResult.error };
-  }
-  const adapter = adapterResult.value;
-  // M4 w28: filter compression features from adapter.features (AC-07). The
-  // same helper is used by recover() below so both paths share one profile.
-  const deviceOpts = deviceOptionsForAdapter(adapter, options);
-  const result = await adapter.requestDevice(deviceOpts);
-  if (!result.ok) {
-    return { kind: 'rhi-err', error: result.error };
-  }
-  const device: RhiDevice = result.value;
-
-  // Acquire the canvas context through the backend pack (M3 / w16).
-  // rhi-webgpu: internally calls canvas.getContext('webgpu') + branded wrap.
-  // rhi-wgpu: internally calls wasm createSurface(canvas) + configure.
-  // When context acquisition fails (null from canvas.getContext or wasm
-  // createSurface throws), the pack returns Result.err(RhiError).
-  const ctxResult = pack.rhi.acquireCanvasContext(canvas);
-  if (!ctxResult.ok) {
-    return { kind: 'rhi-err', error: ctxResult.error };
-  }
-  const context: RhiCanvasContext = ctxResult.value;
-
-  const lostRegistry = new LostListenerRegistry();
-  const errorRegistry = new RhiErrorListenerRegistry();
-  const healthRegistry = new HealthListenerRegistry();
-  const lossObserver: {
-    current?: (detail: string) => void;
-  } = {};
-  const generationState: {
-    current: number;
-    onStaleLoss?: () => void;
-  } = { current: 0 };
-  // device.lost dual-track (research §F-4 / R2 countermeasure): the spec
-  // Promise is passed through to the lost-fan-out registry (extracted to
-  // attachDeviceLostFanout so the recover() rebuild path re-attaches the
-  // SAME wiring to the freshly-minted device — SSOT, one fan-out shape).
-  attachDeviceLostFanout(device, pack, {
-    lostRegistry,
-    errorRegistry,
-    healthRegistry,
-    generation: 0,
-    currentGeneration: () => generationState.current,
-    onStaleLoss: () => generationState.onStaleLoss?.(),
-    onDeviceLost: (detail) => lossObserver.current?.(detail),
-  });
-
-  // D-VD2 Round 2 wire-up part 2: register the spec `onuncapturederror`
-  // listener on the raw GPUDevice so GPUUncapturedErrorEvent (validation /
-  // oom / internal) is translated to the 17-member RhiErrorCode union +
-  // dispatched through the public Renderer event subscription. When the pack does not expose a
-  // raw-device escape hatch (rhi-wgpu wasm path, custom escape hatch), the
-  // listener registration is skipped — the device.lost dual-channel above
-  // still fires through `RhiDevice.lost` Promise on every path (graceful
-  // degradation per charter proposition 9; per-path coverage matrix in
-  // packages/engine/README.md `## Error model`).
-  if (pack._internal_getRawDevice && pack.translateErrorEventToRhiError) {
-    const backendDevice = pack._internal_getRawDevice(device);
-    if (backendDevice && typeof backendDevice === 'object') {
-      const target = backendDevice as {
-        onuncapturederror?: ((event: unknown) => void) | null;
-      };
-      // Spec form: `device.onuncapturederror = (event) => ...`. The listener
-      // sets a property handler (spec normative GPUDevice extends EventTarget
-      // and exposes `onuncapturederror` as a settable callback property);
-      // engine writes through the property so each pre-existing handler that
-      // an AI user assigned would be replaced (last-write-wins; spec lifetime
-      // is device-scoped so engine ownership is OK — AI users observe via
-      // the Renderer event subscription, not the raw property).
-      target.onuncapturederror = (event: unknown): void => {
-        const translated = pack.translateErrorEventToRhiError?.(event);
-        if (translated && !translated.ok) {
-          errorRegistry.fire(translated.error);
-        }
-      };
-    }
-  }
-  return {
-    kind: 'ok',
-    renderer: await makeWebGPURenderer({
-      canvas,
-      device,
-      context,
-      options,
-      bundler,
-      lostRegistry,
-      errorRegistry,
-      healthRegistry,
-      pack,
-      importTransport,
-      lossObserver,
-      generationState,
-    }),
-  };
-}
-
-export interface WebGPURendererInternals {
-  canvas: HTMLCanvasElement | OffscreenCanvas;
-  device: RhiDevice;
-  // M6 / w41 (feat-20260510-rhi-resource-creation): forgeax RhiCanvasContext
-  // brand; RenderSystem + ensureContextConfigured both go through the RHI
-  // surface (charter proposition 5 consistent abstraction red line).
-  context: RhiCanvasContext;
-  options: RendererOptions | undefined;
-  /**
-   * feat-20260608-create-app-param-surface-trim / M2 / D-3: BundlerOptions
-   * forwarded verbatim from createRenderer's third arg. Carries
-   * shaderManifestUrl (host-injected vite-plugin-shader emit URL; absent =>
-   * createRenderer falls back to '/shaders/manifest.json') and the
-   * importTransport that previously rode a dedicated internal slot.
-   */
-  bundler: BundlerOptions | undefined;
-  lostRegistry: LostListenerRegistry;
-  errorRegistry: RhiErrorListenerRegistry;
-  healthRegistry: HealthListenerRegistry;
-  /** M3 D-P4 auto-select pack — carries the dynamic-imported rhi-webgpu / rhi-wgpu singleton + optional async shader factory. */
-  pack: RhiBackendPack;
-  /**
-   * feat-20260604-hdr-equirect-cube-importer-loader M4 / w16 (D-3): the
-   * dev-only ImportTransport, forwarded verbatim from createRenderer to the
-   * AssetRegistry third ctor slot. `undefined` keeps the shipped form (DDC
-   * miss fails fast with `asset-not-imported`, AC-08).
-   */
-  importTransport?: ImportTransport | undefined;
-  /**
-   * feat-20260608-mesh-ssbo-dynamic-grow-l1-lift-1024-entity-cap M2 / T-M2-05:
-   * mesh-SSBO grow hook surfaced by `makeWebGPURenderer` after the controller
-   * is constructed. Undefined before `makeWebGPURenderer` runs; populated by
-   * the time the renderer is returned to the caller. M3's record stage reads
-   * this field via the runtime path that bridges into render-system-record.ts
-   * (the bridging plumbing is in M3's targetFiles).
-   *
-   * Returns `{ ok: true }` when the grow completed (or short-circuited
-   * idempotently); `{ ok: false, code }` with a fired structured error
-   * (`MeshSsboCeilingReachedError` or `MeshSsboCapacityExceededError`) when
-   * the request cannot be satisfied. Never throws (D-5).
-   */
-  growMeshSsbo?: (neededSlots: number) => MeshSsboGrowResult;
-  /**
-   * feat-20260608-mesh-ssbo-dynamic-grow-l1-lift-1024-entity-cap M3 / T-M3-04:
-   * read-only handle to the grow controller's state (slotCount + wrapper
-   * refs), surfaced alongside `growMeshSsbo` so `ensureMeshSsboCapacity`
-   * (record-stage wiring) can short-circuit when slotCount already covers the
-   * frame's renderable count and so the dev-mode info log can report the
-   * before/after slot count transition. Undefined until buildReadyWebGPU
-   * has wired the controller; identity stable across grow events.
-   */
-  meshSsboState?: MeshSsboState;
-  /** Host-owned producer features; created before device-bound assembly starts. */
-  featureHost?: RenderFeatureHost;
-  /** App-owned overlay capability read by the typed graph at frame time. */
-  debugOverlay?: RenderDebugOverlay;
-  /** Composed renderer utility sources installed atomically at build-ready. */
-  volumetricFogShaders?: VolumetricFogShaderSources | undefined;
-  gpuPassTimingSubmittedWork?: Promise<void> | undefined;
-  lossObserver: { current?: (detail: string) => void };
-  generationState: {
-    current: number;
-    onStaleLoss?: () => void;
-  };
-  recoveryColdWorkGuard?: RecoveryColdWorkGuard | undefined;
-  getMaterialShaderUvSetCount?: (materialShaderId: string) => number | undefined;
-}
-
-export interface RecoveryFailureLocation {
-  readonly phase: RecoveryPhase;
-  readonly retryable: boolean;
-  readonly guidance: RecoveryGuidance;
-  readonly owner: string;
-  readonly resourceKind: DeviceResourceKind;
-  readonly cause: unknown;
+  return tryCreateWebGPURendererBootstrap(canvas, options, pack, bundler, makeWebGPURenderer);
 }
-
-function recoveryCauseCode(cause: unknown): string | undefined {
-  if (typeof cause !== 'object' || cause === null) return undefined;
-  const directCode = (cause as { readonly code?: unknown }).code;
-  if (typeof directCode === 'string') return directCode;
-  const detail = (cause as { readonly detail?: unknown }).detail;
-  if (typeof detail !== 'object' || detail === null) return undefined;
-  const detailCode = (detail as { readonly code?: unknown }).code;
-  if (typeof detailCode === 'string') return detailCode;
-  return recoveryCauseCode((detail as { readonly cause?: unknown }).cause);
-}
-
-function createRecoveryFailureLocation(
-  phase: RecoveryPhase,
-  cause: unknown,
-  overrides: Partial<Omit<RecoveryFailureLocation, 'phase' | 'cause'>> = {},
-): RecoveryFailureLocation {
-  const code = recoveryCauseCode(cause) ?? '';
-  const resourceKind: DeviceResourceKind = code.includes('shader')
-    ? 'shader'
-    : code.includes('buffer')
-      ? 'buffer'
-      : code.includes('texture')
-        ? 'texture'
-        : code.includes('binding')
-          ? 'binding'
-          : phase === 'rehydrate'
-            ? 'shader'
-            : phase === 'acquire-adapter' || phase === 'acquire-device'
-              ? 'surface'
-              : phase === 'publish' || phase === 'cleanup'
-                ? 'surface'
-                : 'pipeline';
-  const owner =
-    code.includes('shader') || phase === 'rehydrate'
-      ? 'shader'
-      : phase === 'acquire-adapter' || phase === 'acquire-device'
-        ? 'backend'
-        : phase === 'compile-graph'
-          ? 'pipeline'
-          : 'renderer';
-  return {
-    phase,
-    retryable: false,
-    guidance: 'repair-owner',
-    owner,
-    resourceKind,
-    cause,
-    ...overrides,
-  };
-}
-
 async function makeWebGPURenderer(
   internals: WebGPURendererInternals,
 ): Promise<RendererAssemblyImplementation> {
   let disposed = false;
+  const observeTiming = observeGpuPassTimingDisabled;
   const frameContinuations = new Set<ContinuationTerminator>();
   type RecoveryInspection = RenderInspection['recovery'];
   let recoveryAttempt = 0;
@@ -893,27 +572,16 @@ async function makeWebGPURenderer(
   // looks up MeshFilter.assetHandle here per frame; buildReadyWebGPU step 3
   // uploads the registry's builtin mesh geometry to GPU buffers so the
   // RenderSystem can route MeshFilter.assetHandle to a real (vbo, ibo) pair.
-  //
   // feat-20260527 M1 / w1: ShaderCatalog is now eager-constructed and
   // constructor-injected into AssetRegistry (plan-strategy D-1). The
   // ShaderCatalogDevice adapter (shared between the catalog and per-MaterialShader
   // pipeline cache) is already available at this point.
   const shaderCatalog = getShader();
-
-  // feat-20260528-material-shader-registration-unification M3 / w14:
-  // placeholder hardcoded installMaterialArtifact calls deleted.
-  //
   // bug-20260601-hello-tonemap-material-register M1 (plan-strategy D-1):
   // All material-shader entries are now registered from the manifest
   // BEFORE the renderer is returned, so `register<MaterialAsset>` referencing
   // an engine shader succeeds without waiting for `renderer.initialization`.
-
-  // feat-20260623-asset-payload-generic-open-registry M3 / w10: host apps
-  // that need custom loaders register them on `assets.loaders.register(...)`.
-  // feat-20260604-hdr-equirect-cube-importer-loader M4 / w16 (D-3 / AC-05):
-  // the host-injected ImportTransport (or undefined for the shipped form) is
-  // threaded into the AssetRegistry ctor -- the construction-time-
-  // only single injection point (no setter, no illegal intermediate state).
+  // Host-injected ImportTransport remains a constructor-only dependency.
   // feat-20260705-runtime-tier2-decomposition M1 / w10 (D-1 / D-2): the sole
   // production assembly point injects (a) the post-spawn hook
   // `postSpawnResolveJoints` (auto-wire Skin.joints; D-1) and the audio
@@ -945,8 +613,7 @@ async function makeWebGPURenderer(
       renderSystemForTargetPromotion?.isCubeCapturePending(target) !== true,
   });
   // feat-20260527-sprite-nineslice M4 / w16 (D-5): detached host-owned
-  // EngineMetrics counter, threaded to the record
-  // stage via `RenderSystemRuntime.metrics` so soft-warns
+  // EngineMetrics counter reaches the record stage via `RenderSystemRuntime.metrics`.
   // (`nineslice.scale-too-small`, `nineslice.tile-needs-repeat-sampler`) bump
   // counters through the owning service (charter P3 machine-readable signals
   // over a per-frame console.warn flood). Each renderer assembly owns its own
@@ -1016,14 +683,12 @@ async function makeWebGPURenderer(
   // feat-20260707 M5 / w33 (D-11 + D-8): project the RhiCaps three-way
   // compression triple into the codec-facing `TranscodeCaps` and wire it into
   // the registry so the texture / equirect Basis arms can pick a transcode
-  // target. One-line projection; the loader stays a pure consumer of the
-  // declared ctx input (Pipeline Isolation).
+  // target. One-line projection; the loader stays a pure consumer of declared ctx input (Pipeline Isolation).
   assets.setTranscodeCaps({
     bc: internals.device.caps.textureCompressionBc,
     etc2: internals.device.caps.textureCompressionEtc2,
     astc: internals.device.caps.textureCompressionAstc,
   });
-
   // M1 (bug-20260601-hello-tonemap-material-register D-1/D-2): prepare
   // engine-shipped material shaders (cap gate + manifest load + registration)
   // so they are available in ShaderCatalog before `register<MaterialAsset>`.
@@ -1039,25 +704,6 @@ async function makeWebGPURenderer(
   // count is asserted explicitly. Missing mesh sets are clamp-to-last aliases.
   materialShaderUvSetCounts.set('forgeax::default-standard-pbr', 8);
   materialShaderUvSetCounts.set(SKIN_MATERIAL_SHADER_ID, 8);
-  // M5 wiring (feat-20260517-vite-plugin-image-build-time-cook w14b): hand
-  // the RhiDevice to the AssetRegistry so `loadByGuid<TextureAsset>` ->
-  // `loadTextureFromEntry` -> `uploadTexture` actually runs the GPU
-  // upload step plan-strategy section 3.2 sequence specifies. Without
-  // this call uploadTexture step 3 short-circuits with `Result.ok(undefined)`
-  // and the render-system materialBindGroup falls through to the 1x1
-  // white fallback view (charter P3 violation: silent loss of texture).
-  // bug-20260518 D-1: configureGpuDevice gains a 2nd parameter --
-  // `pack.createShaderModule`, the top-level async shader-module factory
-  // (rhi-webgpu / rhi-wgpu both expose it). The runtime mipmap utility uses
-  // this factory inside `generateMipmaps` instead of the (now-deleted)
-  // synchronous `device.createShaderModule` member. The parameter is
-  // structurally optional at this call-site so the explicit-rhi escape
-  // hatch (D-R5) without a top-level factory still routes through the
-  // existing `invokeDeviceCreateShaderModule` fallback in
-  // buildReadyWebGPU; AssetRegistry.uploadTexture's mipmap branch surfaces
-  // the missing-factory case as a structured `rhi-not-available` error
-  // (charter P3 explicit failure) rather than throwing here.
-  //
   const packShaderFactory = adaptMipmapShaderModuleFactory(internals.pack.createShaderModule);
   // The RhiDevice surface satisfies `MipmapBlitDevice` (createTexture +
   // createTextureView + createCommandEncoder + createBindGroup +
@@ -1128,28 +774,6 @@ async function makeWebGPURenderer(
     gpuStore.bindDeviceScope(activeDeviceScope);
   };
   let readySettled = false;
-  // w24 — Renderer.initialization returns Promise<Result<void, RhiError>>: resolve
-  // ok(undefined) on success / resolve err(RhiError) on failure. The legacy
-  // reject path is converted by a `.then() / .catch()` wrap so the inner
-  // factory (`buildReadyWebGPU`) keeps its reject-on-error shape (research
-  // F-3 internal contract preserved) while the public surface settles
-  // strictly resolve-only (charter proposition 4 explicit failure - AI
-  // users branch on `.ok` instead of try/catch).
-  // feat-20260523-shader-template-instance-split M9-T03 (D-PipelineBuilder):
-  // per-MaterialShader pipeline cache (LDR + HDR variants keyed by
-  // `${materialShaderId}:${ldr|hdr}`). Map is owned by the renderer (lifetime
-  // = Renderer) so cache hits persist across draw calls but reset between
-  // renderers. Map.get / .set are sync; the underlying shader-module compile
-  // is async-cached inside `makeShaderDeviceAdapter` (1-frame warmup -- first
-  // miss returns Result.err('rhi-not-available'); after the async build
-  // resolves the adapter caches the module, the next miss-then-build returns
-  // Ok and lands in this Map).
-  //
-  // M6 fix-up: declared BEFORE `buildReadyWebGPU` so the boot-time SPEC_CONST
-  // prewarm step inside that promise can seed URP-variant entries directly
-  // (the seeding closure captures this Map by reference; ordering is safe
-  // because the prewarm step runs strictly before the first frame's
-  // `getMaterialShaderPipeline` lookup that would consume it).
   const materialShaderPipelineCache = new Map<string, RenderPipeline>();
   const materialShaderPipelineGroup2Contracts = new WeakMap<object, PipelineGroup2Contract>();
   const materialShaderManifestEntryCache = new Map<string, MaterialShaderManifestEntry>();
@@ -1172,14 +796,7 @@ async function makeWebGPURenderer(
     { materialBgl: BindGroupLayout; pipelineLayout: PipelineLayout }
   >();
   const preparedMaterialPipelineLayoutCache = new Map<string, PipelineLayout>();
-  // feat-20260621-learn-render-5-5-parallax M2 / w6 (D-1): per-shader material
-  // BGL + pipeline layout cache. Every authored material shader owns the
-  // user-region binding order emitted by its paramSchema, plus the shared
-  // engine-injection suffix. A custom shader with four-or-fewer textures can
-  // still differ from the standard PBR order (for example, baseColorTexture
-  // followed directly by normalTexture), so it cannot safely reuse the
-  // standard material BGL. Built lazily on first request and cached by
-  // shaderId; built-in shader IDs continue to use the boot-time shared layout.
+  // Cache authored material layouts by their exact mesh and lighting contract.
   type PerShaderMaterialLayout = {
     materialBgl: BindGroupLayout;
     pipelineLayout: PipelineLayout;
@@ -1191,16 +808,6 @@ async function makeWebGPURenderer(
     readonly layout: PerShaderMaterialLayout | null;
   };
   const perShaderMaterialLayoutCache = new Map<string, PerShaderMaterialLayoutCacheEntry>();
-  const isEngineOwnedMaterialShader = (materialShaderId: string): boolean =>
-    materialShaderId === 'forgeax::default-unlit' ||
-    materialShaderId === 'forgeax::default-shadow-caster' ||
-    materialShaderId === 'forgeax::sprite' ||
-    materialShaderId === 'forgeax::sprite-lit' ||
-    materialShaderId === 'forgeax::default-sprite' ||
-    materialShaderId === 'forgeax::msdf-text' ||
-    materialShaderId === 'forgeax::default-standard-pbr' ||
-    materialShaderId === 'forgeax::pbr-skin' ||
-    materialShaderId === 'forgeax::default-standard-pbr-skin';
   // Material binding contracts are derived from WGSL source, but the lookup
   // is also used by the per-submesh bind-group path. Cache the derived value
   // per renderer so a frame does not re-run the comment stripping and regex
@@ -1415,9 +1022,23 @@ async function makeWebGPURenderer(
   };
   const getOrBuildPreparedMaterialPipelineLayout = (
     materialShaderId: string,
+    clustered = false,
   ): PipelineLayout | null => {
     const cacheState = currentPipelineCacheState();
-    const cached = cacheState.preparedMaterialPipelineLayoutCache.get(materialShaderId);
+    const lookup = getShader().findMaterialArtifact(materialShaderId);
+    const source = lookup.ok ? lookup.value.source : '';
+    const hasView =
+      /@group\s*\(\s*0\s*\)\s*@binding\s*\(\s*0\s*\)\s*var\s*<\s*uniform\s*>\s*view(?:X_naga_oil_mod_[A-Z0-9]+)?\b/u.test(
+        source,
+      );
+    const hasSceneDepthAtZero =
+      /@group\s*\(\s*0\s*\)\s*@binding\s*\(\s*0\s*\)[^;]*texture_depth_2d\b/u.test(source);
+    const hasSceneDepthAtOne =
+      /@group\s*\(\s*0\s*\)\s*@binding\s*\(\s*1\s*\)[^;]*texture_depth_2d\b/u.test(source);
+    const sceneInputKind =
+      hasSceneDepthAtOne && hasView ? 'view-depth' : hasSceneDepthAtZero ? 'depth' : 'view';
+    const cacheKey = `${materialShaderId}:${clustered ? 'cluster' : 'mesh'}:${sceneInputKind}`;
+    const cached = cacheState.preparedMaterialPipelineLayoutCache.get(cacheKey);
     if (cached !== undefined) return cached;
     const currentState = currentPipelineState();
     if (currentState === null) return null;
@@ -1426,31 +1047,90 @@ async function makeWebGPURenderer(
         ? undefined
         : getOrBuildPerShaderMaterialLayout(materialShaderId)?.materialBgl) ??
       currentState.materialBindGroupLayout;
+    let sceneInputLayout: BindGroupLayout = currentState.viewBindGroupLayout;
+    if (sceneInputKind !== 'view') {
+      const sceneInputLayoutResult = currentBuildDevice().createBindGroupLayout({
+        label: `prepared-material-${sceneInputKind}-${materialShaderId}`,
+        entries:
+          sceneInputKind === 'view-depth'
+            ? [
+                {
+                  binding: 0,
+                  visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
+                  buffer: { type: 'uniform' as const },
+                },
+                {
+                  binding: 1,
+                  visibility: GPU_SHADER_STAGE_FRAGMENT,
+                  texture: {
+                    sampleType: 'depth' as const,
+                    viewDimension: '2d' as const,
+                    multisampled: false,
+                  },
+                },
+              ]
+            : [
+                {
+                  binding: 0,
+                  visibility: GPU_SHADER_STAGE_FRAGMENT,
+                  texture: {
+                    sampleType: 'depth' as const,
+                    viewDimension: '2d' as const,
+                    multisampled: false,
+                  },
+                },
+              ],
+      });
+      if (!sceneInputLayoutResult.ok) {
+        internals.errorRegistry.fire(sceneInputLayoutResult.error);
+        return null;
+      }
+      sceneInputLayout = sceneInputLayoutResult.value;
+    }
+    const usesMaterialGroup = clustered || /@group\s*\(\s*1\s*\)/u.test(source);
+    const lightingLayout = clustered
+      ? currentBuildDevice().createBindGroupLayout({
+          label: `prepared-material-lighting-${materialShaderId}`,
+          entries: createHdrpBindGroupLayoutDescriptor().entries.filter(
+            (entry) => entry.binding >= 3,
+          ),
+        })
+      : undefined;
+    if (lightingLayout !== undefined && !lightingLayout.ok) {
+      internals.errorRegistry.fire(lightingLayout.error);
+      return null;
+    }
     const result = currentBuildDevice().createPipelineLayout({
       label: `prepared-material-pl-${materialShaderId}`,
-      bindGroupLayouts: [currentState.viewBindGroupLayout, materialBgl],
+      bindGroupLayouts: [
+        sceneInputLayout,
+        ...(usesMaterialGroup ? [materialBgl] : []),
+        ...(lightingLayout?.ok ? [lightingLayout.value] : []),
+      ],
     });
     if (!result.ok) {
       internals.errorRegistry.fire(result.error);
       return null;
     }
-    cacheState.preparedMaterialPipelineLayoutCache.set(materialShaderId, result.value);
+    cacheState.preparedMaterialPipelineLayoutCache.set(cacheKey, result.value);
     return result.value;
   };
   const getOrBuildPerShaderMaterialLayout = (
     materialShaderId: string,
     explicitParamSchema?: readonly ParamSchemaEntry[],
     layoutKind: LayoutKind = 'pbr',
+    clustered = false,
   ): PerShaderMaterialLayout | null => {
     const cacheState = currentPipelineCacheState();
     const currentState = currentPipelineState();
     if (currentState === null) return null;
-    if (isEngineOwnedMaterialShader(materialShaderId)) return null;
+    if (isEngineOwnedMaterialShader(materialShaderId) && !clustered) return null;
     const lookup = getShader().findMaterialArtifact(materialShaderId);
     const source = lookup.ok ? lookup.value.source : '';
     const paramSchema = lookup.ok ? lookup.value.paramSchema : explicitParamSchema;
     if (paramSchema === undefined) return null;
-    const cached = cacheState.perShaderMaterialLayoutCache.get(materialShaderId);
+    const cacheKey = `${materialShaderId}:${layoutKind}:${clustered}`;
+    const cached = cacheState.perShaderMaterialLayoutCache.get(cacheKey);
     if (
       cached?.source === source &&
       cached.paramSchema === paramSchema &&
@@ -1466,8 +1146,8 @@ async function makeWebGPURenderer(
       isStandardPbrMaterialShader(materialShaderId) ||
       standardPhysicalTextureFields(paramSchema).length > 0;
     const isStandardMapLayout = requiresStandardMapLayout;
-    if (!isStandardMapLayout && isSharedMaterialUserRegionCompatible(paramSchema)) {
-      cacheState.perShaderMaterialLayoutCache.set(materialShaderId, {
+    if (!clustered && !isStandardMapLayout && isSharedMaterialUserRegionCompatible(paramSchema)) {
+      cacheState.perShaderMaterialLayoutCache.set(cacheKey, {
         source,
         paramSchema,
         layoutKind,
@@ -1484,26 +1164,27 @@ async function makeWebGPURenderer(
     const desc = buildBindGroupLayoutDescriptor(spec, {
       kind: 'pbr-material-merged',
       materialParamSchema: paramSchema,
+      caps: {
+        storageBuffer: currentBuildDevice().caps.storageBuffer,
+        transmissionBackdrop: transmissionBackdropAvailable(
+          currentBuildDevice().limits.maxSampledTexturesPerShaderStage,
+        ),
+      },
     });
     const bglRes = currentBuildDevice().createBindGroupLayout(desc);
     if (!bglRes.ok) {
       internals.errorRegistry.fire(bglRes.error);
       return null;
     }
-    const meshLayout =
-      layoutKind === 'pbr-skin'
-        ? currentState.pbrSkinMeshBindGroupLayout
-        : layoutKind === 'hdrp-skin'
-          ? currentState.hdrpSkinMeshBindGroupLayout
-          : currentState.meshBindGroupLayout;
-    if (meshLayout === null) return null;
+    const bindGroups = resolveMaterialPipelineBindGroups(layoutKind, currentState, clustered);
+    if (bindGroups === null) return null;
     const plRes = currentBuildDevice().createPipelineLayout({
       label: `pbr-pl-${materialShaderId}`,
       bindGroupLayouts: [
         currentState.viewBindGroupLayout,
         bglRes.value,
-        meshLayout,
-        currentState.instancesBindGroupLayout,
+        bindGroups.meshLayout,
+        bindGroups.instancesLayout,
       ],
     });
     if (!plRes.ok) {
@@ -1511,7 +1192,7 @@ async function makeWebGPURenderer(
       return null;
     }
     const built = { materialBgl: bglRes.value, pipelineLayout: plRes.value };
-    cacheState.perShaderMaterialLayoutCache.set(materialShaderId, {
+    cacheState.perShaderMaterialLayoutCache.set(cacheKey, {
       source,
       paramSchema,
       layoutKind,
@@ -1621,14 +1302,16 @@ async function makeWebGPURenderer(
       residencyStore,
       internals.pack.createShaderModule,
       internals.errorRegistry,
-      requiredMaterialShaders,
+      candidateBuildState === undefined
+        ? requiredMaterialShaders
+        : [
+            ...new Set([...requiredMaterialShaders, ...getShader().materialShaderIdentifiers()]),
+          ].filter(
+            (id) => requiredMaterialShaders.includes(id) || !isEngineOwnedMaterialShader(id),
+          ),
+      materialShaderUvSetCounts.get('forgeax::default-standard-pbr') ?? 0,
       requiredFullscreenPostProcesses,
-      // feat-20260608-mesh-ssbo-dynamic-grow-l1-lift-1024-entity-cap M2 /
-      // T-M2-05 + M3 / T-M3-04: callback set by buildReadyWebGPU once
-      // meshSsboController is wired. Both the grow hook AND the read-only
-      // state ref land on `internals` so the record stage (M3
-      // ensureMeshSsboCapacity) can read slotCount + call grow through
-      // RenderSystemInternals.
+      // Publish growth and capacity together for the active or candidate device.
       (hook, state) => {
         if (candidateBuildState !== undefined) {
           candidateBuildState.growMeshSsbo = hook;
@@ -1638,14 +1321,12 @@ async function makeWebGPURenderer(
           internals.meshSsboState = state;
         }
       },
-      // feat-20260609 R3-fixup: seed the lazy adapter cache with the
-      // eagerly-compiled shadow_caster module.
+      // Both module adapters consume the generation's eager shader cache.
       (label, module) => {
         getShaderModuleAdapter().seedModule(label, module);
+        getImmediateShaderModuleAdapter().seedModule(label, module);
       },
-      // M6 fix-up: seed the active or candidate material pipeline cache from
-      // the boot-time SPEC_CONST prewarm. Recovery builds must never put a
-      // candidate-device PSO into the retired generation's cache.
+      // Prewarm only the active build generation's material pipeline cache.
       (key, pso, group2Contract) => {
         const pipelineCache = currentPipelineCacheState().materialShaderPipelineCache;
         if (!pipelineCache.has(key)) {
@@ -1653,13 +1334,7 @@ async function makeWebGPURenderer(
         }
         materialShaderPipelineGroup2Contracts.set(pso as object, group2Contract);
       },
-      // feat-20260621 M-A3 (D-5): register the built-in tonemap on the unified
-      // post-process channel once buildReadyWebGPU resolves the tonemap manifest
-      // entry's composed WGSL. Fires after the manifest-load await, by which point
-      // `renderSystem` (declared synchronously below) is defined. The 16 B params
-      // schema mirrors the prior dedicated UBO: [exposure(f32), whitePoint(f32),
-      // mode(u32), pad(f32)]; the extract stage bridges Camera.exposure/whitePoint/
-      // tonemap into this channel each frame (render-system-extract.ts w13).
+      // Register the output transform after manifest loading, once RenderSystem exists.
       (source: string) => {
         if (candidateBuildState !== undefined || tonemapRegistered) return;
         renderSystem.registerBuiltinPostProcess(STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, {
@@ -1699,7 +1374,18 @@ async function makeWebGPURenderer(
       (sources: VolumetricFogShaderSources) => {
         internals.volumetricFogShaders = sources;
       },
-    );
+      (sources: SsrShaderSources) => {
+        internals.ssrShaders = sources;
+      },
+      (sources: AtmosphereShaderSources) => {
+        internals.atmosphereShaders = sources;
+      },
+    ).then(async (state) => {
+      // draw() is synchronous. Complete the opt-in capability probe before
+      // publishing readiness, including when rebuilding a lost device.
+      await renderSystem.initializeSsr(device);
+      return state;
+    });
   const ready: Promise<Result<void, RhiError>> = buildPipeline().then(
     (state): Result<void, RhiError> => {
       pipelineState = state;
@@ -1710,14 +1396,8 @@ async function makeWebGPURenderer(
     (e: unknown): Result<void, RhiError> => {
       readySettled = true;
       if (e instanceof RhiError) return err(e);
-      const message = e instanceof Error ? e.message : String(e);
-      return err(
-        new RhiError({
-          code: 'webgpu-runtime-error',
-          expected: 'Renderer.initialization three-step strict-serial succeeds',
-          hint: `pipeline build raised: ${message}`,
-        }),
-      );
+      if (e instanceof PipelineSpecError) return err(rendererInitializationPipelineError(e));
+      return err(rendererInitializationError(e));
     },
   );
   /**
@@ -1760,33 +1440,17 @@ async function makeWebGPURenderer(
     }
     return standardEntry;
   };
-  // Shared builder context for the per-MaterialShader pipeline cache.
-  // Built once; reused for both registered shader IDs and fallback
-  // paths (D-3). Null when manifest is empty (Camera-only path).
-  //
-  // feat-20260609-hdrp-cluster-fragment-ggx M4.5 / w37 (D-10 option A):
-  // `variantSet` parameter selects between URP `pbrPipelineLayout` (1-slot
-  // group(2) BGL) and HDRP `hdrpPbrPipelineLayout` (7-slot group(2) BGL)
-  // via `selectPipelineLayoutForVariant`. When undefined (legacy callers
-  // / fallback path) the URP layout is used preserving prior behaviour.
   const buildPipelineContext = (
     variantSet?: string,
     materialShaderId?: string,
     group2Contract: PipelineGroup2Contract = 'mesh',
-    // feat-20260611-fox-skinning-vertex-attribute-chain M4 / w16 (D-4):
-    // when layoutKind === 'pbr-skin' the SSOT for the vertex buffer layout
-    // is `deriveVertexBufferLayout` (vertex-attribute-layout.ts) — the same
-    // function that the WGSL @location(N) declarations / naga reflect tests
-    // consume. A caller passing a real `MeshAsset.attributes` produces the
-    // exact 6-attribute / 72-byte layout the skin shader expects; passing
-    // undefined falls into the synthetic 6-key sentinel below (the skin
-    // path is fully determined by layoutKind, so key-presence is the only
-    // signal `deriveVertexBufferLayout` reads — values never matter).
+    // Skin layouts derive their vertex ABI from the shared attribute projection.
     meshAttributes?: VertexAttributeMap,
     vertexLayout?: string,
     vertexLayoutProjection?: VertexLayoutProjection,
     shaderModuleMode?: RenderFeatureShaderModuleMode,
     layoutKindOverride?: LayoutKind,
+    particleInputLanes?: number,
   ) => {
     const contractLayoutKind: LayoutKind =
       group2Contract === 'cluster'
@@ -1797,20 +1461,21 @@ async function makeWebGPURenderer(
             ? 'pbr-skin'
             : 'pbr';
     const layoutKind = layoutKindOverride ?? contractLayoutKind;
+    const gpuClustered =
+      (layoutKind === 'gpu-driven-pbr' || layoutKind === 'gpu-driven-skin') &&
+      (group2Contract === 'cluster' || group2Contract === 'skin-cluster');
     const usesSharedBootMaterialLayout =
-      materialShaderId !== undefined && isEngineOwnedMaterialShader(materialShaderId);
-    // Built-in PBR/unlit/skin layouts are assembled at boot. Re-deriving a
-    // per-shader layout from the expanded PBR schema would bypass the HDRP
-    // group(2) selector and bind the URP mesh BGL to the cluster pipeline.
+      !gpuClustered &&
+      materialShaderId !== undefined &&
+      isEngineOwnedMaterialShader(materialShaderId);
+    // Built-in layouts are assembled at boot; authored layouts must not bypass
+    // the HDRP group(2) selector or bind the URP mesh BGL to a cluster PSO.
     const perShaderLayout =
       !usesSharedBootMaterialLayout && materialShaderId !== undefined
-        ? getOrBuildPerShaderMaterialLayout(materialShaderId, undefined, layoutKind)
+        ? getOrBuildPerShaderMaterialLayout(materialShaderId, undefined, layoutKind, gpuClustered)
         : null;
-    // feat-20260621-learn-render-5-5-parallax M2 / w6 (D-1): an authored
-    // shader owns a per-shader pipeline layout derived from its paramSchema,
-    // because its compact texture order may differ from standard PBR even
-    // when it declares only a few textures. Skin / HDRP keep their dedicated
-    // layouts; built-in material IDs remain on the shared boot-time layout.
+    // Authored shaders retain their own material schema and selected mesh
+    // layout, including skin. Built-in IDs keep their boot-time layout.
     const bindingContract =
       materialShaderId === undefined
         ? 'render-material'
@@ -1827,11 +1492,12 @@ async function makeWebGPURenderer(
         ? getOrBuildViewAndSceneDepthMaterialPipelineLayout()
         : null;
     const preparedMaterialLayout =
-      bindingContract === 'render-material' &&
+      (bindingContract === 'render-material' ||
+        bindingContract === 'render-material-with-scene-depth' ||
+        bindingContract === 'render-material-and-scene-depth') &&
       materialShaderId !== undefined &&
-      (vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInstance ||
-        vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInstance)
-        ? getOrBuildPreparedMaterialPipelineLayout(materialShaderId)
+      isPreparedMaterialVertexLayout(vertexLayout)
+        ? getOrBuildPreparedMaterialPipelineLayout(materialShaderId, group2Contract === 'cluster')
         : null;
     const materialShaderLookup =
       materialShaderId === undefined
@@ -1873,64 +1539,15 @@ async function makeWebGPURenderer(
               )
             : undefined))
         : undefined;
-    const vertexBuffers: readonly GPUVertexBufferLayout[] =
-      vertexInputContract === 'none'
-        ? []
-        : vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.positionSizeColorInstance
-          ? POSITION_SIZE_COLOR_INSTANCE_VERTEX_BUFFERS
-          : vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInstance
-            ? BILLBOARD_MATERIAL_INSTANCE_VERTEX_BUFFERS
-            : vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.topologySegmentInstance
-              ? TOPOLOGY_SEGMENT_INSTANCE_VERTEX_BUFFERS
-              : vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInstance
-                ? MESH_GEOMETRY_MATERIAL_INSTANCE_VERTEX_BUFFERS
-                : vertexLayoutProjection !== undefined
-                  ? toGpuVertexBufferLayouts(
-                      deriveVertexBufferLayoutFromProjection(
-                        vertexLayoutProjection,
-                        resolvedUvSetCount !== undefined
-                          ? { shaderUvSetCount: resolvedUvSetCount }
-                          : undefined,
-                      ),
-                    )
-                  : layoutKind === 'pbr-skin'
-                    ? toGpuVertexBufferLayouts(
-                        deriveVertexBufferLayout(
-                          meshAttributes ??
-                            ({
-                              position: PBR_SKIN_SENTINEL_ATTR_BUFFER,
-                              normal: PBR_SKIN_SENTINEL_ATTR_BUFFER,
-                              uv: PBR_SKIN_SENTINEL_ATTR_BUFFER,
-                              tangent: PBR_SKIN_SENTINEL_ATTR_BUFFER,
-                              skinIndex: PBR_SKIN_SENTINEL_ATTR_BUFFER,
-                              skinWeight: PBR_SKIN_SENTINEL_ATTR_BUFFER,
-                            } satisfies VertexAttributeMap),
-                          resolvedUvSetCount !== undefined
-                            ? { shaderUvSetCount: resolvedUvSetCount }
-                            : undefined,
-                        ),
-                      )
-                    : meshAttributes !== undefined ||
-                        (resolvedUvSetCount !== undefined && resolvedUvSetCount > 1)
-                      ? toGpuVertexBufferLayouts(
-                          deriveVertexBufferLayout(
-                            meshAttributes ?? DEFAULT_VERTEX_ATTRS,
-                            resolvedUvSetCount !== undefined && resolvedUvSetCount > 1
-                              ? { shaderUvSetCount: resolvedUvSetCount }
-                              : undefined,
-                          ),
-                        )
-                      : ([
-                          {
-                            arrayStride: 12 * 4,
-                            attributes: [
-                              { shaderLocation: 0, offset: 0, format: 'float32x3' as const },
-                              { shaderLocation: 1, offset: 3 * 4, format: 'float32x3' as const },
-                              { shaderLocation: 2, offset: 6 * 4, format: 'float32x2' as const },
-                              { shaderLocation: 3, offset: 8 * 4, format: 'float32x4' as const },
-                            ],
-                          },
-                        ] satisfies readonly GPUVertexBufferLayout[]);
+    const vertexBuffers = resolveWebGPUVertexBufferLayouts({
+      vertexInputContract,
+      vertexLayout,
+      vertexLayoutProjection,
+      resolvedUvSetCount,
+      layoutKind,
+      meshAttributes,
+      particleInputLanes,
+    });
     return {
       device: currentBuildDevice(),
       shaderModuleFactory:
@@ -1939,7 +1556,7 @@ async function makeWebGPURenderer(
           : getShaderModuleAdapter(),
       pipelineLayout,
       vertexBuffers,
-      ...(layoutKind === 'pbr-skin' ? { layoutKind } : {}),
+      ...(layoutKind === 'pbr-skin' || layoutKind === 'gpu-driven-skin' ? { layoutKind } : {}),
     };
   };
   /**
@@ -1999,11 +1616,26 @@ async function makeWebGPURenderer(
     vertexLayoutProjection?: VertexLayoutProjection,
     shaderModuleMode?: RenderFeatureShaderModuleMode,
     layoutKindOverride?: LayoutKind,
+    vertexEntryPoint?: string,
     additionalColorFormats?: readonly GPUTextureFormat[],
     vertexEntry?: string,
     authoredFragmentEntry?: string,
+    particleInputLanes?: number,
+    coverageOnly = false,
   ): RenderPipeline | null => {
-    const group2Contract = resolvePipelineGroup2Contract(entry.source);
+    const declaredGroup2Contract = resolvePipelineGroup2Contract(entry.source);
+    const group2Contract =
+      declaredGroup2Contract === 'mesh' &&
+      (materialShaderId === 'forgeax::vfx-render.particles.mesh' ||
+        materialShaderId === 'forgeax::vfx-render.particles.mesh-inputs') &&
+      (variantSet === '' || variantSet?.includes('CLUSTER_FORWARD_AVAILABLE=true') === true)
+        ? 'cluster'
+        : declaredGroup2Contract;
+    const resolvedVertexEntry = resolveMaterialPipelineVertexEntry(
+      layoutKindOverride,
+      vertexEntryPoint,
+      vertexEntry,
+    );
     const ctx = buildPipelineContext(
       variantSet,
       materialShaderId,
@@ -2013,13 +1645,9 @@ async function makeWebGPURenderer(
       vertexLayoutProjection,
       shaderModuleMode,
       layoutKindOverride,
+      particleInputLanes,
     );
     if (ctx === null) return null;
-    // bug-20260612: route the LDR color format through pipelineState so the
-    // backend-aware swap-chain format chosen at buildReadyWebGPU flows here.
-    // Callers gate on pipelineState !== null before reaching this lambda
-    // (search "buildAndCachePipeline" call sites — every one is preceded by
-    // the explicit null check).
     const currentState = currentPipelineState();
     if (currentState === null) return null;
     const ldrColorFormat = colorFormatOverride ?? currentState.colorAttachmentFormat;
@@ -2042,12 +1670,14 @@ async function makeWebGPURenderer(
             ? undefined
             : [isHdr ? HDR_COLOR_ATTACHMENT_FORMAT : ldrColorFormat, ...additionalColorFormats],
         depthFormat:
-          depthFormatOverride === null ? undefined : (depthFormatOverride ?? DEPTH_TEXTURE_FORMAT),
+          depthFormatOverride === null
+            ? undefined
+            : passKindPolicyTable[passKind]?.shape === 'depth-only'
+              ? (depthFormatOverride ?? 'depth32float')
+              : (depthFormatOverride ?? DEPTH_TEXTURE_FORMAT),
+        coverageOnly,
         label,
         // feat-20260604 w16-b: the shader-MODULE cache identity. Stable across
-        // topology / renderState / isHdr / indexFormat (all baked into the PSO,
-        // not the module), so every pipeline variant of the same shader source
-        // reuses one compiled module instead of forcing a fresh async compile
         // per variant. See PipelineBuilderContext.moduleLabel.
         moduleLabel,
       },
@@ -2066,7 +1696,7 @@ async function makeWebGPURenderer(
               : {}),
           }
         : undefined,
-      vertexEntry,
+      resolvedVertexEntry,
       fragmentEntry,
       undefined, // defines — none
       passKind,
@@ -2079,10 +1709,7 @@ async function makeWebGPURenderer(
       return null;
     }
     currentPipelineCacheState().materialShaderPipelineCache.set(cacheKey, built.value);
-    materialShaderPipelineGroup2Contracts.set(
-      built.value as object,
-      resolvePipelineGroup2Contract(entry.source),
-    );
+    materialShaderPipelineGroup2Contracts.set(built.value as object, group2Contract);
     return built.value;
   };
   const getMaterialShaderPipeline = (
@@ -2093,11 +1720,6 @@ async function makeWebGPURenderer(
     indexFormat?: 'uint16' | 'uint32',
     variantSet?: string,
     passKind: PassKind = 'forward',
-    // feat-20260611-fox-skinning-vertex-attribute-chain M4 / w16 (D-4):
-    // forwarded to `buildAndCachePipeline -> buildPipelineContext` so the
-    // pbr-skin layout chain reads from the `deriveVertexBufferLayout` SSOT.
-    // Optional: existing callers (URP / HDRP / shadow-depth) pass undefined
-    // and the hardcoded 4-attribute layout is preserved (AC-04 zero-regression).
     meshAttributes?: VertexAttributeMap,
     // bug-20260615 M2 / m2-1: sampleCount is threaded through to the cache key,
     // buildAndCachePipeline, and ultimately buildPipelineForMaterialShader which
@@ -2132,10 +1754,14 @@ async function makeWebGPURenderer(
     vertexLayoutProjection?: VertexLayoutProjection,
     shaderModuleMode: RenderFeatureShaderModuleMode = 'validated',
     layoutKindOverride?: LayoutKind,
+    vertexEntryPoint?: string,
     additionalColorFormats?: readonly GPUTextureFormat[],
     vertexEntry?: string,
     fragmentEntry?: string,
+    particleInputLanes?: number,
   ): RenderPipeline | null => {
+    const coverageOnly =
+      passKind === 'temporal' && variantSet?.split('+').includes('COVERAGE_ONLY=true') === true;
     // WebGL2 is a downlevel backend even when the record stage asks for the
     // native-capability variant string. Resolve the variant axes at this
     // shared PSO seam so the shader source, BGL layout, and cache key agree on
@@ -2148,10 +1774,11 @@ async function makeWebGPURenderer(
       (currentState !== null ? currentState.colorAttachmentFormat : 'bgra8unorm-srgb');
     // feat-20260629 M4: auto-fill shaderUvSetCount from naga reflection
     // (stored in materialShaderUvSetCounts during prepareMaterialShaders).
+    const materialShaderIdForPass = resolveMaterialPipelineShaderId(materialShaderId, passKind);
     const pipelineShaderId = resolveMaterialShaderBackendArtifactKey(
-      materialShaderId,
+      materialShaderIdForPass,
       internals.device.caps.backendKind,
-      assets.getMaterialArtifact(materialShaderId),
+      assets.getMaterialArtifact(materialShaderIdForPass),
     );
     const materialShaderLookup = getShader().findMaterialArtifact(pipelineShaderId);
     const materialShaderSource = materialShaderLookup.ok
@@ -2175,20 +1802,14 @@ async function makeWebGPURenderer(
       (pipelineShaderId === 'forgeax::sprite' || pipelineShaderId === 'forgeax::sprite-lit')
         ? undefined
         : resolveCachedMaterialShaderVariantSet(variantSet, manifestEntry);
-    // The record stage also composes engine capability axes for user shaders.
-    // Keep only manifest-declared axes for non-engine material IDs: a plain
-    // custom shader must not collapse that request to '' because '' is the
-    // canonical HDRP variant key and would pair an HDRP PSO with the URP mesh
-    // bind group. Builtin forgeax:: shaders keep the compatibility request
+    // The record stage composes capability axes; plain custom shaders retain
+    // only manifest-declared axes so '' cannot select an HDRP mesh layout.
+    // Builtin forgeax:: shaders keep the compatibility request
     // when a reduced test/legacy manifest omits variant metadata.
     // A single-source manifest entry must stay on its canonical module key;
     // otherwise a synthesized capability axis races the prewarmed module.
     let effectiveVariantSet = normalizeMaterialShaderVariantSet(resolvedVariantSet, manifestEntry);
-    // Runtime-published authored materials are installed from their immutable
-    // cooked artifact, not from the build-time material-shader manifest. The
-    // published artifact identity already selects the backend-specific bytes;
-    // an absent manifest therefore means the source itself is the canonical
-    // pipeline module and must not carry a synthesized capability key.
+    // A published artifact is already backend-specific; no manifest means no synthesized key.
     if (manifestEntry === undefined) effectiveVariantSet = undefined;
     if (
       vertexLayoutProjection === undefined &&
@@ -2227,25 +1848,16 @@ async function makeWebGPURenderer(
       effectiveVariantSet =
         filteredVariantParts.length === 0 ? undefined : filteredVariantParts.join('+');
     }
-    // feat-20260615-pipeline-spec-ssot M2-T2: cache key derived from PipelineSpec
-    // 4-axis SSOT via cacheKeyOf(spec). The spec carries all 4 axes (shader /
-    // attachments / geometry / renderState), replacing the legacy 8-segment string
-    // construction. vertexLayout is now included in the cache key (was previously
-    // threaded but not hashed — research F1 R-VertexLayout-Cache). sampleCount is
-    // cast to 1 | 4 for the closed spec axis.
-    // M2-fixup follow-up: LDR color format SSOT is `pipelineState.colorAttachmentFormat`
-    // (set in buildReadyWebGPU from selectSwapChainFormat). Hardcoding 'bgra8unorm-srgb'
-    // here let the cache key drift from the prewarm key on backends where
-    // getPreferredCanvasFormat returns rgba8unorm (dawn-node, lavapipe, wgpu-wasm GLES),
-    // forcing a redundant second PSO build on first-frame URP record path.
     const colorFormat: GPUTextureFormat = isHdr ? 'rgba16float' : ldrColorFormat;
     const isDepthOnlyPass = passKindPolicyTable[passKind]?.shape === 'depth-only';
+    const resolvedVertexEntry = vertexEntry ?? vertexEntryPoint;
+    const inputVertexBuffers = particleMaterialInputVertexBuffers(vertexLayout, particleInputLanes);
     const spec: PipelineSpec = {
       shader: {
         id: pipelineShaderId,
         passKind,
         variantSet: effectiveVariantSet,
-        ...(vertexEntry === undefined ? {} : { vertexEntry }),
+        ...(resolvedVertexEntry === undefined ? {} : { vertexEntry: resolvedVertexEntry }),
         ...(fragmentEntry === undefined ? {} : { fragmentEntry }),
       },
       attachments: {
@@ -2254,7 +1866,7 @@ async function makeWebGPURenderer(
             ? colorFormatsForPassKind(passKind, colorFormat)
             : [colorFormat, ...additionalColorFormats],
         depthFormat: isDepthOnlyPass
-          ? 'depth32float'
+          ? (depthFormatOverride ?? 'depth32float')
           : depthFormatOverride === null
             ? undefined
             : (depthFormatOverride ?? 'depth24plus-stencil8'),
@@ -2267,11 +1879,9 @@ async function makeWebGPURenderer(
           meshAttributes ??
           (vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.positionSizeColorInstance
             ? PREPARED_INSTANCE_VERTEX_ATTRS
-            : vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInstance ||
-                vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.topologySegmentInstance ||
-                vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInstance
+            : isPreparedMaterialVertexLayout(vertexLayout)
               ? PREPARED_MATERIAL_INSTANCE_VERTEX_ATTRS
-              : DEFAULT_VERTEX_ATTRS),
+              : DEFAULT_VERTEX_ATTRIBUTE_MAP),
         // Thread the shader-declared count whenever it is greater than one.
         // Built-in PBR reserves all eight supported UV inputs; single-UV meshes
         // remain byte-stable because missing sets are clamp-to-last aliases.
@@ -2279,10 +1889,11 @@ async function makeWebGPURenderer(
           ? { shaderUvSetCount: resolvedUvSetCount }
           : {}),
         ...(vertexLayoutProjection === undefined ? {} : { vertexLayoutProjection }),
+        ...(inputVertexBuffers === undefined ? {} : { vertexBuffers: inputVertexBuffers }),
       },
       renderState,
     };
-    const cacheKey = cacheKeyOf(spec);
+    const cacheKey = `${cacheKeyOf(spec)}|vertex:${resolvedVertexEntry ?? 'vs_main'}`;
     const cached = currentPipelineCacheState().materialShaderPipelineCache.get(cacheKey);
     if (cached !== undefined) return cached;
     if (pipelineState === null) return null;
@@ -2336,7 +1947,12 @@ async function makeWebGPURenderer(
           vertexLayoutProjection,
           shaderModuleMode,
           layoutKindOverride,
+          vertexEntryPoint,
           additionalColorFormats,
+          undefined,
+          undefined,
+          undefined,
+          coverageOnly,
         );
       }
       const pbrEntry = findStandardPbrEntry(effectiveVariantSet);
@@ -2392,7 +2008,12 @@ async function makeWebGPURenderer(
         vertexLayoutProjection,
         shaderModuleMode,
         layoutKindOverride,
+        vertexEntryPoint,
         additionalColorFormats,
+        undefined,
+        undefined,
+        undefined,
+        coverageOnly,
       );
     }
     // feat-20260609 M4 / w31: resolve variant WGSL from manifest when
@@ -2485,9 +2106,12 @@ async function makeWebGPURenderer(
       vertexLayoutProjection,
       shaderModuleMode,
       layoutKindOverride,
+      vertexEntryPoint,
       additionalColorFormats,
       vertexEntry,
       fragmentEntry,
+      particleInputLanes,
+      coverageOnly,
     );
   };
   const getMaterialShaderPipelineEntry = (
@@ -2549,7 +2173,7 @@ async function makeWebGPURenderer(
   const buildPostProcessPipeline = (
     entry: PostProcessShaderEntry,
     bgl: BindGroupLayout,
-    colorFormat: GPUTextureFormat,
+    colorFormats: readonly GPUTextureFormat[],
     label: string,
   ): RenderPipeline | null => {
     const moduleFactory = getShaderModuleAdapter();
@@ -2597,12 +2221,12 @@ async function makeWebGPURenderer(
       },
       fragment: {
         module: moduleResult.value,
-        entryPoint: 'fs_main',
-        targets:
-          entry.source.includes('@location(1) temporal') &&
-          entry.source.includes('TaaResolveOutput')
-            ? [{ format: colorFormat }, { format: colorFormat }]
-            : [{ format: colorFormat }],
+        // The typed graph reuses the composed tonemap module for separate
+        // linear-LDR and final-encoding passes.  Preserve the selected entry
+        // point; forcing fs_main encodes the linear-LDR intermediate a second
+        // time and breaks the Three.js stage contract.
+        entryPoint: entry.fragmentEntryPoint ?? 'fs_main',
+        targets: colorFormats.map((format) => ({ format })),
       },
       primitive: { topology: 'triangle-list', cullMode: 'none', frontFace: 'ccw' },
       depthStencil: undefined,
@@ -2623,6 +2247,7 @@ async function makeWebGPURenderer(
       return internals.bundler?.build;
     },
     ssrIdentity: internals.options?.ssrIdentity,
+    captureReflectionFallbackReadback: internals.options?.captureReflectionFallbackReadback,
     get standardProfile() {
       return activeProfile;
     },
@@ -2633,10 +2258,7 @@ async function makeWebGPURenderer(
     setFeatureHost: (host) => {
       internals.featureHost = host;
     },
-    // Keep the feature-facing factory stable while resolving the adapter at
-    // call time. Renderer recovery swaps the device and invalidates the
-    // per-device adapter; a boot-time snapshot would feed recovered VFX
-    // programs shader modules owned by the lost device.
+    // Resolve the adapter at call time so recovered devices get fresh modules.
     shaderModuleFactory: {
       createShaderModule: (descriptor) => getShaderModuleAdapter().createShaderModule(descriptor),
     },
@@ -2645,11 +2267,8 @@ async function makeWebGPURenderer(
         getImmediateShaderModuleAdapter().createShaderModule(descriptor),
     },
     profiler: internals.options?.profiler,
-    // feat-20260622-s5 M3 / w17: device + context read live off `internals` via
-    // getters so the recover() rebuild (which swaps internals.device /
-    // internals.context for a freshly-acquired pair) is observed by the record
-    // stage without reconstructing the RenderSystem (RenderSystemRuntime.device
-    // / RenderSystemInternals.context are read at frame time, not cached).
+    // Keep device/context getters live so recovery swaps are observed by the
+    // record stage without reconstructing the RenderSystem.
     get device() {
       return internals.device;
     },
@@ -2666,6 +2285,28 @@ async function makeWebGPURenderer(
     ...(internals.pack.instrumentation?.resolveSurfaceDevice === undefined
       ? {}
       : { resolveSurfaceDevice: internals.pack.instrumentation.resolveSurfaceDevice }),
+    // The graph records receipt-bound color observations through the same
+    // renderer-owned capture bridge consumed after queue submission. Keep the
+    // identity and demand live on internals so recovery and per-frame graph
+    // rebuilds observe the current device without reconstructing RenderSystem.
+    get deviceGeneration() {
+      return activeDeviceScope.generation;
+    },
+    get observationFrameId() {
+      return internals.observationFrameId;
+    },
+    get observationGraphGeneration() {
+      return internals.observationGraphGeneration;
+    },
+    set observationGraphGeneration(generation: number | undefined) {
+      internals.observationGraphGeneration = generation;
+    },
+    get observationCaptureOwner() {
+      return internals.observationCaptureOwner;
+    },
+    get observationCaptureDomains() {
+      return internals.observationCaptureDomains;
+    },
     invalidateShaderModule: (label: string) => {
       activeShaderState.sharedShaderModuleAdapter?.invalidateModule(label);
     },
@@ -2692,10 +2333,16 @@ async function makeWebGPURenderer(
     getMaterialShaderPipeline,
     getMaterialShaderPipelineEntry,
     getMaterialShaderBindingContract: getCachedMaterialShaderBindingContract,
+    getMaterialShaderArtifact: (materialShaderId, options = {}) =>
+      resolveRendererMaterialShaderArtifact(
+        materialShaderId,
+        getShader(),
+        pipelineState?.gpuDrivenPbrPrograms,
+        options,
+      ),
     getParamSchema,
     getMaterialBindGroupLayout,
     metrics,
-    // feat-20260609 M4 / T-10-a: post-process pipeline factory (CONCERN-1 fix).
     // createRenderSystem wraps this in a per-RenderSystem cache + the public
     // getPostProcessPipeline lookup the dispatcher reads at frame time.
     buildPostProcessPipeline,
@@ -2786,6 +2433,13 @@ async function makeWebGPURenderer(
     get volumetricFogShaders() {
       return internals.volumetricFogShaders;
     },
+    // Readiness-prewarmed SSR sources stay visible through the live internals seam.
+    get ssrShaders() {
+      return internals.ssrShaders;
+    },
+    get atmosphereShaders() {
+      return internals.atmosphereShaders;
+    },
   });
   attachGpuPassTimingSession(internals, gpuPassTimingSession);
   renderSystemForTargetPromotion = renderSystem;
@@ -2809,33 +2463,199 @@ async function makeWebGPURenderer(
   const attachedWorlds = new Set<World>();
   const attachedLeases = new Map<RenderReadLease, World>();
   const leasesByWorld = new Map<World, RenderReadLease>();
-  const dynamicGeometry = createDynamicGeometryLifecycle();
-  const dynamicGeometryHost = createDynamicGeometryHost({
-    lifecycle: dynamicGeometry,
-    attachedWorlds,
-    getGpuStore: () => gpuStore,
-    currentGeneration: () => activeDeviceScope.generation,
-    onTopologyChanged: () => renderSystem.invalidateGeometryHistory(),
-    isConsumedByRenderFrame: (candidate) =>
-      renderSystem.isDynamicGeometryConsumed(
-        candidate.world as World,
-        candidate.entity ?? -1,
-        candidate.meshHandle,
-      ),
-  });
+  const { lifecycle: dynamicGeometry, host: dynamicGeometryHost } =
+    createRendererDynamicGeometryController({
+      attachedWorlds,
+      getGpuStore: () => gpuStore,
+      currentGeneration: () => activeDeviceScope.generation,
+      renderSystem,
+    });
   const derivedSystemNames = new Map<World, string>();
   const transformReleases = new Map<World, () => void>();
   const attachmentOwner = {};
   let frameId = 0;
-  // Receipts remain observable until their device generation is retired. A
-  // registry avoids invalidating a still-valid frame merely because another
-  // submission completed in the meantime.
-  const currentReceipts = new Set<FrameReceipt>();
+  // Caller-owned receipts remain observable; Renderer does not retain every submitted receipt.
   const issuedReceipts = new WeakSet<FrameReceipt>();
   const receiptTimings = new WeakMap<FrameReceipt, Promise<VolumeTimingObservation>>();
   let latestReceipt: FrameReceipt | undefined;
+  let pendingObservationDomains: readonly FrameObservationDomain[] | undefined;
+  let observationAllocationCount = 0;
+  let observationLiveCount = 0;
+  let observationPeakLiveCount = 0;
+  let observationMapCount = 0;
+  let observationReadbackCount = 0;
+  let observationLiveByteLength = 0;
+  const observationCaptureOwner = (() => {
+    const capturesByFrame = new Map<number, TypedFrameObservationCapture[]>();
+    return {
+      register(capture: TypedFrameObservationCapture): void {
+        const captures = capturesByFrame.get(capture.frameNumber) ?? [];
+        captures.push(capture);
+        capturesByFrame.set(capture.frameNumber, captures);
+        observationAllocationCount += 1;
+        observationLiveCount += 1;
+        observationPeakLiveCount = Math.max(observationPeakLiveCount, observationLiveCount);
+        observationLiveByteLength += capture.bytesPerRow * capture.height;
+      },
+      consume(frameNumber: number): readonly TypedFrameObservationCapture[] {
+        const captures = capturesByFrame.get(frameNumber) ?? [];
+        capturesByFrame.delete(frameNumber);
+        return Object.freeze(captures);
+      },
+      drain(): readonly TypedFrameObservationCapture[] {
+        const captures = [...capturesByFrame.values()].flat();
+        capturesByFrame.clear();
+        return Object.freeze(captures);
+      },
+    };
+  })();
+  Object.assign(internals, { observationCaptureOwner });
+  let expectedObservationGraphGeneration: number | undefined;
+  Object.defineProperty(internals, 'observationGraphGeneration', {
+    configurable: true,
+    get: () => expectedObservationGraphGeneration,
+    set: (generation: number | undefined) => {
+      expectedObservationGraphGeneration = generation;
+    },
+  });
+  type ObservationCaptureRead = () => Promise<
+    RenderResult<
+      readonly {
+        readonly capture: TypedFrameObservationCapture;
+        readonly bytes: Uint8Array;
+      }[],
+      RenderError
+    >
+  >;
+  const receiptObservationCaptures = new Map<FrameReceipt, ObservationCaptureRead>();
+  const receiptObservationBuffers = new Map<
+    FrameReceipt,
+    readonly TypedFrameObservationCapture[]
+  >();
+  const destroyedObservationBuffers = new WeakSet<Buffer>();
+  const observationBufferCleanupFailures = new WeakMap<Buffer, RendererContractFailureError>();
+  const failedObservationCaptures = new Map<Buffer, TypedFrameObservationCapture>();
+  const disposeObservationCaptures = (
+    captures: readonly TypedFrameObservationCapture[],
+  ): RendererContractFailureError | undefined => {
+    const wasDestroyed = new Set(
+      captures
+        .filter((capture) => destroyedObservationBuffers.has(capture.buffer))
+        .map((capture) => capture.buffer),
+    );
+    const result = disposeObservationCaptureSet(
+      captures,
+      destroyedObservationBuffers,
+      observationBufferCleanupFailures,
+      (failure) => internals.errorRegistry.fire(failure),
+    );
+    for (const capture of captures) {
+      if (!wasDestroyed.has(capture.buffer) && destroyedObservationBuffers.has(capture.buffer)) {
+        observationLiveCount = Math.max(0, observationLiveCount - 1);
+        observationLiveByteLength = Math.max(
+          0,
+          observationLiveByteLength - capture.bytesPerRow * capture.height,
+        );
+      }
+    }
+    return result;
+  };
+  const disposeOwnedObservationCaptures = (
+    captures: readonly TypedFrameObservationCapture[],
+  ): RendererContractFailureError | undefined => {
+    const failure = disposeObservationCaptures(captures);
+    if (failure !== undefined) {
+      for (const capture of captures) {
+        if (!destroyedObservationBuffers.has(capture.buffer)) {
+          failedObservationCaptures.set(capture.buffer, capture);
+        }
+      }
+    }
+    return failure;
+  };
+  const readObservationCapture = async (
+    capture: TypedFrameObservationCapture,
+  ): Promise<RenderResult<Uint8Array, RenderError>> => {
+    try {
+      if (typeof capture.buffer.mapAsync !== 'function') {
+        const cleanupFailure = disposeObservationCaptures([capture]);
+        return err(
+          cleanupFailure ??
+            new RendererContractFailureError(
+              'observe',
+              `the ${capture.domain} receipt-bound readback backend has no mapAsync capability`,
+            ),
+        );
+      }
+      observationMapCount += 1;
+      const mapped = await capture.buffer.mapAsync(1);
+      if (!mapped.ok) {
+        const cleanupFailure = disposeObservationCaptures([capture]);
+        return err(
+          cleanupFailure ??
+            new RendererContractFailureError(
+              'observe',
+              `mapping ${capture.domain} receipt-bound readback failed: ${mapped.error.code}`,
+            ),
+        );
+      }
+      const range = mapped.value.getMappedRange();
+      if (!range.ok) {
+        mapped.value.unmap();
+        const cleanupFailure = disposeObservationCaptures([capture]);
+        return err(
+          cleanupFailure ??
+            new RendererContractFailureError(
+              'observe',
+              `reading ${capture.domain} receipt-bound readback failed: ${range.error.code}`,
+            ),
+        );
+      }
+      const bytes = new Uint8Array(range.value.slice(0));
+      mapped.value.unmap();
+      observationReadbackCount += 1;
+      const cleanupFailure = disposeObservationCaptures([capture]);
+      if (cleanupFailure !== undefined) return err(cleanupFailure);
+      return ok(bytes);
+    } catch (cause) {
+      const cleanupFailure = disposeObservationCaptures([capture]);
+      return err(
+        cleanupFailure ??
+          new RendererContractFailureError(
+            'observe',
+            `reading ${capture.domain} receipt-bound readback threw: ${
+              cause instanceof Error ? cause.message : String(cause)
+            }`,
+          ),
+      );
+    }
+  };
+
+  const disposeReceiptObservationCaptures = (): RendererContractFailureError | undefined => {
+    let firstFailure: RendererContractFailureError | undefined;
+    for (const [receipt, captures] of receiptObservationBuffers) {
+      const failure = disposeObservationCaptures(captures);
+      firstFailure ??= failure;
+      if (captures.every((capture) => destroyedObservationBuffers.has(capture.buffer))) {
+        receiptObservationBuffers.delete(receipt);
+      }
+    }
+    receiptObservationCaptures.clear();
+    const retryCaptures = [...failedObservationCaptures.values()];
+    const retryFailure = disposeObservationCaptures(retryCaptures);
+    firstFailure ??= retryFailure;
+    for (const capture of retryCaptures) {
+      if (destroyedObservationBuffers.has(capture.buffer)) {
+        failedObservationCaptures.delete(capture.buffer);
+      }
+    }
+    const ownedFailure = disposeOwnedObservationCaptures(observationCaptureOwner.drain());
+    firstFailure ??= ownedFailure;
+    return firstFailure;
+  };
   let surfaceReleased = false;
   const renderer: RendererAssemblyImplementation = {
+    instances: renderSystem.instances,
     attach(world: World): RenderResult<RenderWorldLease, RenderError> {
       const attached = this.attachScene(world);
       if (!attached.ok) {
@@ -2886,6 +2706,7 @@ async function makeWebGPURenderer(
         gpuDriven: renderSystem.gpuDrivenInspection,
       };
     },
+    bounds: (world, entity) => (disposed ? undefined : renderSystem.bounds(world, entity)),
     inspect(): RenderInspection {
       const health = internals.healthRegistry.getLastSnapshot();
       const deviceLost = health.reason === 'device-lost';
@@ -2926,6 +2747,8 @@ async function makeWebGPURenderer(
           ? {}
           : { surfaceProfile: pipelineState.surfaceProfile }),
         rgba16floatRenderable: internals.device.caps.rgba16floatRenderable,
+        autoExposure: renderSystem.autoExposure,
+        standardLut: renderSystem.standardLut,
         ...(internals.context?.presentationProof === undefined
           ? {}
           : { presentationProof: internals.context.presentationProof }),
@@ -2943,16 +2766,18 @@ async function makeWebGPURenderer(
           frameId,
           deviceGeneration: activeDeviceScope.generation,
         }),
-        features: Object.freeze(
-          (internals.featureHost?.features ?? []).map((feature) => feature.identity),
-        ),
-        featureDiagnostics: internals.featureHost?.diagnostics() ?? Object.freeze([]),
+        ...projectRendererFeatureInspection(internals.featureHost),
+        featureGraph: renderSystem.featureGraphInspection,
+        materialTextureSources: renderSystem.materialTextureSources,
         frustumStats: Object.freeze({ ...renderSystem.frustumStats }),
         visibilityStats: Object.freeze({ ...renderSystem.visibilityStats }),
         instanceCollections: Object.freeze(
           renderSystem.instanceCollectionsInspection.map((collection) =>
             Object.freeze({
               ...collection,
+              dirtyRanges: Object.freeze(
+                collection.dirtyRanges.map((range) => Object.freeze({ ...range })),
+              ),
               uploadRanges: Object.freeze(
                 collection.uploadRanges.map((range) => Object.freeze({ ...range })),
               ),
@@ -2969,8 +2794,10 @@ async function makeWebGPURenderer(
         ),
         dynamicGeometry: dynamicGeometry.inspect(),
         renderScene: renderSystem.renderScene,
+        ...(renderSystem.iblBinding === undefined ? {} : { iblBinding: renderSystem.iblBinding }),
         reflectionProbes: renderSystem.reflectionProbes,
         ssrDependencies: renderSystem.ssrDependencies,
+        ssr: renderSystem.ssr,
         volumetricFog,
         environment: renderSystem.environment,
         temporal: renderSystem.temporal,
@@ -3024,7 +2851,13 @@ async function makeWebGPURenderer(
             lastGeneration: latestReceipt?.deviceGeneration,
           }),
         }),
-        ...outputInspection,
+        output: Object.freeze({
+          ...outputInspection,
+          graphPassNames: Object.freeze([...outputInspection.graphPassNames]),
+          ...(outputInspection.standardOutputColor === undefined
+            ? {}
+            : { standardOutputColor: Object.freeze({ ...outputInspection.standardOutputColor }) }),
+        }),
         observation: Object.freeze({
           observationId,
           frameId,
@@ -3039,6 +2872,14 @@ async function makeWebGPURenderer(
           ...(outputInspection.standardOutputColor === undefined
             ? {}
             : { standardOutputColor: Object.freeze({ ...outputInspection.standardOutputColor }) }),
+          resourceStats: Object.freeze({
+            allocationCount: observationAllocationCount,
+            liveCount: observationLiveCount,
+            peakLiveCount: observationPeakLiveCount,
+            mapCount: observationMapCount,
+            readbackCount: observationReadbackCount,
+            liveByteLength: observationLiveByteLength,
+          }),
         }),
       });
     },
@@ -3131,6 +2972,38 @@ async function makeWebGPURenderer(
     observeCurrentFrame(options: FrameObservationOptions) {
       return renderSystem.observeCurrentFrame(options);
     },
+    requestObservation(
+      domains: readonly FrameObservationDomain[],
+    ): RenderResult<void, RenderError> {
+      if (disposed) {
+        return err(
+          new RendererOperationError('renderer-state-invalid', {
+            operation: 'request-observation',
+            state: 'disposed',
+          }),
+        );
+      }
+      if (
+        !Array.isArray(domains) ||
+        domains.length === 0 ||
+        domains.some(
+          (domain) => domain !== 'linear-hdr' && domain !== 'linear-ldr' && domain !== 'final-srgb',
+        ) ||
+        new Set(domains).size !== domains.length
+      ) {
+        return err(
+          new RendererOperationError('frame-input-invalid', {
+            operation: 'request-observation',
+            cause: new RendererContractFailureError(
+              'request-observation',
+              'domains must be a non-empty set of linear-hdr, linear-ldr, and final-srgb values',
+            ),
+          }),
+        );
+      }
+      pendingObservationDomains = Object.freeze([...domains]);
+      return ok(undefined);
+    },
     getCurrentGraphTarget(name: string) {
       return renderSystem.getCurrentGraphTarget(name);
     },
@@ -3313,27 +3186,8 @@ async function makeWebGPURenderer(
           : worlds.map((world) => leasesByWorld.get(world)).every((lease) => lease !== undefined)
             ? worlds.map((world) => leasesByWorld.get(world) as RenderReadLease)
             : undefined;
-      for (const world of worlds) {
-        if (!world.hasResource('PhysicsWorld')) continue;
-        const physics = world.getResource<{
-          readonly getDerivedAdmission?: () => unknown;
-          readonly getDerivedRecoveryState?: () => string;
-        }>('PhysicsWorld');
-        if (
-          physics?.getDerivedAdmission?.() !== undefined ||
-          physics?.getDerivedRecoveryState?.() === 'rebuild-required'
-        ) {
-          return err(
-            new RendererOperationError('frame-input-invalid', {
-              operation: 'draw',
-              cause: new RendererContractFailureError(
-                'draw',
-                'paired geometry admission must finish physics step and writeback in a healthy World before draw',
-              ),
-            }),
-          );
-        }
-      }
+      const physicsFrameError = derivedPhysicsFrameError(worlds);
+      if (physicsFrameError !== undefined) return err(physicsFrameError);
       if (frameRequest !== undefined && worlds.length !== frameRequest.leases.length) {
         return err(
           new RendererOperationError('world-lease-invalid', {
@@ -3369,6 +3223,9 @@ async function makeWebGPURenderer(
           ? {
               cameraOwner,
               resourceOwner,
+              ...(frameRequest.camera.entityKey === undefined
+                ? {}
+                : { cameraEntityKey: frameRequest.camera.entityKey }),
               ...(frameRequest.profileFrame === undefined
                 ? {}
                 : { profileFrame: frameRequest.profileFrame }),
@@ -3486,6 +3343,9 @@ async function makeWebGPURenderer(
           gpuPassTimingCapture?: GpuPassTimingCapture | undefined;
           gpuPassTimingSubmittedWork?: Promise<void> | undefined;
           gpuPassTimingBeginReason?: GpuPassTimingReason | undefined;
+          observationFrameId?: number | undefined;
+          observationGraphGeneration?: number | undefined;
+          observationCaptureDomains?: readonly FrameObservationDomain[] | undefined;
         };
         const timingRequested =
           isFrameRequest &&
@@ -3500,6 +3360,9 @@ async function makeWebGPURenderer(
           if (createdTiming.ok) volumeTimingCapture = createdTiming.value;
         }
         if (isFrameRequest) {
+          timingHost.observationFrameId = frameId + 1;
+          timingHost.observationGraphGeneration = undefined;
+          timingHost.observationCaptureDomains = pendingObservationDomains;
           timingHost.gpuPassTimingFrameIdentity = {
             frameId: frameId + 1,
             deviceGeneration: activeDeviceScope.generation,
@@ -3507,9 +3370,13 @@ async function makeWebGPURenderer(
           };
         }
         const submitted = renderSystem.draw(worlds, drawOptions, readLeases, volumeTimingCapture);
+        timingHost.observationFrameId = undefined;
+        timingHost.observationCaptureDomains = undefined;
         timingHost.gpuPassTimingFrameIdentity = undefined;
         if (!submitted) {
+          const cleanupFailure = disposeOwnedObservationCaptures(observationCaptureOwner.drain());
           volumeTimingCapture?.discard();
+          if (cleanupFailure !== undefined) return err(cleanupFailure);
           return err(
             new RendererContractFailureError(
               'draw',
@@ -3524,7 +3391,9 @@ async function makeWebGPURenderer(
         gpuStore.trackMeshSubmission(queueCompletion);
         internals.pack.instrumentation?.onFrameBoundary?.();
         if (!isFrameRequest) {
+          const cleanupFailure = disposeOwnedObservationCaptures(observationCaptureOwner.drain());
           renderTargetHost.onFrameSubmitted();
+          if (cleanupFailure !== undefined) return err(cleanupFailure);
           return ok(undefined);
         }
         const receiptFrameId = ++frameId;
@@ -3599,13 +3468,39 @@ async function makeWebGPURenderer(
         ]).finally(() => {
           frameContinuations.delete(continuation);
         });
+        const captures = observationCaptureOwner.consume(receiptFrameId);
+        pendingObservationDomains = undefined;
+        const receiptGraphGeneration = timingHost.observationGraphGeneration ?? 0;
         const receipt = Object.freeze({
           frameId: receiptFrameId,
           deviceGeneration: receiptGeneration,
+          backendId: internals.device.caps.backendKind,
+          graphGeneration: receiptGraphGeneration,
           completed,
         });
         renderTargetHost.onFrameSubmitted(completed);
         latestReceipt = receipt;
+        if (captures.length > 0) {
+          const captureRead: ObservationCaptureRead = async () => {
+            const completion = await completed;
+            if (!completion.ok) {
+              const cleanupFailure = disposeObservationCaptures(captures);
+              return cleanupFailure === undefined ? completion : err(cleanupFailure);
+            }
+            const read = [];
+            for (const capture of captures) {
+              const bytes = await readObservationCapture(capture);
+              if (!bytes.ok) {
+                const cleanupFailure = disposeObservationCaptures(captures);
+                return cleanupFailure === undefined ? bytes : err(cleanupFailure);
+              }
+              read.push({ capture, bytes: bytes.value });
+            }
+            return ok(read);
+          };
+          receiptObservationBuffers.set(receipt, captures);
+          receiptObservationCaptures.set(receipt, captureRead);
+        }
         const passTimingCapture = timingHost.gpuPassTimingCapture;
         const timingBeginReason = timingHost.gpuPassTimingBeginReason;
         const timingSource =
@@ -3638,7 +3533,6 @@ async function makeWebGPURenderer(
                 return { status: 'complete', frame };
               };
         timingObservationStore?.register(receipt, timingSource);
-        currentReceipts.add(receipt);
         if (timingRequested && gpuPassTimingOptions === undefined) {
           receiptTimings.set(
             receipt,
@@ -3653,6 +3547,11 @@ async function makeWebGPURenderer(
         dynamicGeometryHost.publishDynamicGeometry(receipt, worlds, frameRequest?.fixedStep);
         return ok(receipt);
       } catch (cause) {
+        internals.observationFrameId = undefined;
+        internals.observationCaptureDomains = undefined;
+        internals.gpuPassTimingFrameIdentity = undefined;
+        const cleanupFailure = disposeOwnedObservationCaptures(observationCaptureOwner.drain());
+        if (cleanupFailure !== undefined) return err(cleanupFailure);
         const error =
           cause instanceof Error
             ? { code: 'unknown' as const, message: cause.message, name: cause.name }
@@ -3672,15 +3571,37 @@ async function makeWebGPURenderer(
       receipt: FrameReceipt,
       request: FrameObservationRequest,
     ): Promise<RenderResult<FrameReceiptObservation, RenderError>> {
-      if (gpuPassTimingOptions !== undefined) {
+      const includesDomain = (request.include as readonly string[]).some(
+        (include) =>
+          include === 'linear-hdr' || include === 'linear-ldr' || include === 'final-srgb',
+      );
+      let timingObservation: GpuPassTimingObservation | undefined;
+      if (
+        includesDomain &&
+        gpuPassTimingOptions !== undefined &&
+        request.include.includes('timings')
+      ) {
+        const timingResult =
+          timingObservationStore === undefined
+            ? await observeGpuPassTimingDisabled(
+                receipt,
+                request,
+                () => activeDeviceScope.generation,
+              )
+            : await timingObservationStore.observe(receipt, request);
+        if (!timingResult.ok) return timingResult;
+        timingObservation = timingResult.value.timings;
+      }
+      if (gpuPassTimingOptions !== undefined && !includesDomain) {
         return timingObservationStore === undefined
-          ? observeGpuPassTimingDisabled(receipt, request, () => activeDeviceScope.generation)
+          ? observeTiming(receipt, request, () => activeDeviceScope.generation)
           : timingObservationStore.observe(receipt, request);
       }
       if (
-        !currentReceipts.has(receipt) ||
+        disposed ||
         !issuedReceipts.has(receipt) ||
-        receipt.deviceGeneration !== activeDeviceScope.generation
+        receipt.deviceGeneration !== activeDeviceScope.generation ||
+        receipt.backendId !== internals.device.caps.backendKind
       ) {
         const currentGeneration = activeDeviceScope.generation;
         return err(
@@ -3703,6 +3624,97 @@ async function makeWebGPURenderer(
           }),
         );
       }
+      const requestedDomains = (request.include as readonly string[]).filter(
+        (include): include is TypedFrameObservationCapture['domain'] =>
+          include === 'linear-hdr' || include === 'linear-ldr' || include === 'final-srgb',
+      );
+      let observations: FrameReceiptObservation['observations'];
+      if (requestedDomains.length > 0) {
+        if (new Set(requestedDomains).size !== requestedDomains.length) {
+          return err(
+            new RendererContractFailureError(
+              'observe',
+              'each receipt-bound color domain may be requested only once',
+            ),
+          );
+        }
+        const readCaptures = receiptObservationCaptures.get(receipt);
+        receiptObservationCaptures.delete(receipt);
+        if (readCaptures === undefined) {
+          return err(
+            new RendererContractFailureError(
+              'observe',
+              'receipt-bound color-domain observations were not explicitly armed before draw, are stale, duplicated, or unavailable',
+            ),
+          );
+        }
+        const capturesResult = await readCaptures();
+        if (!capturesResult.ok) return capturesResult;
+        const captures = capturesResult.value;
+        const graphGenerations = new Set(captures.map(({ capture }) => capture.graphGeneration));
+        if (
+          captures.some(
+            ({ capture }) =>
+              capture.frameNumber !== receipt.frameId ||
+              capture.deviceGeneration !== receipt.deviceGeneration ||
+              capture.backendId !== internals.device.caps.backendKind ||
+              (receipt.graphGeneration !== undefined &&
+                capture.graphGeneration !== receipt.graphGeneration),
+          ) ||
+          graphGenerations.size !== 1
+        ) {
+          return err(
+            new RendererContractFailureError(
+              'observe',
+              'receipt-bound color-domain captures crossed frame, device, backend, or graph identity',
+            ),
+          );
+        }
+        const byDomain = new Map(
+          captures.map(({ capture, bytes }) => [capture.domain, { capture, bytes }]),
+        );
+        if (
+          byDomain.size !== captures.length ||
+          requestedDomains.some((domain) => !byDomain.has(domain))
+        ) {
+          return err(
+            new RendererContractFailureError(
+              'observe',
+              'receipt-bound color-domain captures must contain one source per requested domain',
+            ),
+          );
+        }
+        const read: NonNullable<FrameReceiptObservation['observations']>[number][] = [];
+        for (const domain of requestedDomains) {
+          const resolved = byDomain.get(domain);
+          if (resolved === undefined) continue;
+          const { capture, bytes } = resolved;
+          read.push({
+            domain,
+            bytes,
+            metadata: {
+              frameId: receipt.frameId,
+              deviceGeneration: receipt.deviceGeneration,
+              backendId: receipt.backendId,
+              format: capture.format,
+              graphGeneration: capture.graphGeneration,
+              textureIdentity: getTextureIdentity(capture.texture),
+              readbackIdentity: getTextureIdentity(
+                capture.buffer as unknown as import('@forgeax/engine-rhi').Texture,
+              ),
+              width: capture.width,
+              height: capture.height,
+              bytesPerRow: capture.bytesPerRow,
+              footprint: { resourceCount: 1, bindGroupCount: 0 },
+            },
+          });
+        }
+        observations = Object.freeze(read);
+        const receiptCaptures = receiptObservationBuffers.get(receipt);
+        if (receiptCaptures?.every((capture) => destroyedObservationBuffers.has(capture.buffer))) {
+          receiptObservationBuffers.delete(receipt);
+        }
+      }
       await renderSystem.observeLodOcclusion();
       const targetReadbacks =
         request.targetReadbacks === undefined || request.targetReadbacks.length === 0
@@ -3716,15 +3728,17 @@ async function makeWebGPURenderer(
               reason: 'timestamp capture was not requested for this frame',
             }))
         : undefined;
+      const observation = await observeTiming(receipt, request, () => activeDeviceScope.generation);
+      if (!observation.ok) return observation;
       return ok(
         Object.freeze({
-          frameId: receipt.frameId,
-          deviceGeneration: receipt.deviceGeneration,
-          include: Object.freeze([...request.include]),
+          ...observation.value,
           ...(targetReadbacks === undefined
             ? {}
             : { targetReadbacks: Object.freeze(targetReadbacks.value) }),
+          ...(timingObservation === undefined ? {} : { timings: timingObservation }),
           ...(volumeTimings === undefined ? {} : { volumeTimings }),
+          ...(observations === undefined ? {} : { observations }),
         }),
       );
     },
@@ -3783,31 +3797,24 @@ async function makeWebGPURenderer(
      * `disposed` latch flips up-front so a re-entrant dispose (or a draw
      * that races with the cascade) short-circuits.
      *
-     * NOT calling `device.destroy()` on the raw GPUDevice (w25 lesson from
-     * feat-20260517-vite-plugin-image-build-time-cook CI-fix v4): w23
-     * attempted to evict stale devices from the chromium WebGPU adapter
-     * pool via `_internal_getRawDevice`, but the explicit destroy
-     * accelerated pool poisoning -- after the first `dispose()` the
-     * chromium adapter pool started recycling the just-destroyed device
-     * into the next `requestDevice` so the NEXT test's `Engine.create`
-     * resolved with `ready.error.code: 'device-lost'`. Cross-test isolation
-     * moved to the vitest infra layer (`browser.isolate: true`) instead of
-     * test code self-managing device lifecycle.
+     * Raw-device destruction is owned by backend lifetime, not this facade.
+     * Browser test isolation handles adapter-pool reuse between tests.
      *
      * Stays in sync with the `Renderer.dispose` row of the README "API index".
      */
     dispose(): RenderResult<void, RenderError> {
       if (disposed) return ok(undefined);
       disposed = true;
-      for (const world of attachedWorlds) {
-        dynamicGeometryHost.invalidateDynamicGeometryWorld(world);
-      }
+      for (const world of attachedWorlds) dynamicGeometryHost.invalidateDynamicGeometryWorld(world);
       dynamicGeometry.dispose();
       for (const continuation of frameContinuations) {
         continuation.terminate({ code: 'disposed' });
       }
-      currentReceipts.clear();
       const cleanupFailures: RendererOperationCause[] = [];
+      const observationCleanupFailure = disposeReceiptObservationCaptures();
+      if (observationCleanupFailure !== undefined) {
+        cleanupFailures.push(observationCleanupFailure);
+      }
       for (const world of attachedWorlds) {
         try {
           const derivedSystemName = derivedSystemNames.get(world);
@@ -3956,6 +3963,10 @@ async function makeWebGPURenderer(
       return internals.healthRegistry.getLastSnapshot();
     },
     recover(): Promise<Result<void, RecoverFailure>> {
+      const observationCleanupFailure = disposeReceiptObservationCaptures();
+      if (observationCleanupFailure !== undefined) {
+        return Promise.resolve(err(new RecoverError('recover-device-unavailable')));
+      }
       return recoveryFlight.run();
     },
   };
@@ -3973,7 +3984,6 @@ async function makeWebGPURenderer(
     candidatePostProcessResources: RecoveryPostProcessResources,
     recoveryRootBundle: RecoveryRootBundle,
     recoveryGraphCandidate: RecoveryGraphCandidate | undefined,
-    recoveryColdWorkGuard: RecoveryColdWorkGuard,
   ): void => {
     if (!candidate.scope.isAlive()) {
       throw new Error('Renderer generation candidate is not publishable.');
@@ -4020,9 +4030,6 @@ async function makeWebGPURenderer(
     // fallback pipeline or residency entry. Candidate preparation populated
     // these caches already; a miss here is a hard recovery failure, not an
     // opportunity to hide cold work inside the first visible frame.
-    candidate.producerBindings.gpuStore.setRecoveryColdWorkGuard(recoveryColdWorkGuard);
-    internals.recoveryColdWorkGuard = recoveryColdWorkGuard;
-    if (recoveryGraphCandidate !== undefined) recoveryColdWorkGuard.arm();
     renderSystem.publishRecoveryPostProcessResources(candidatePostProcessResources);
     if (recoveryGraphCandidate !== undefined) {
       renderSystem.publishRecoveryGraphCandidate(recoveryGraphCandidate);
@@ -4069,6 +4076,13 @@ async function makeWebGPURenderer(
     buildPipeline,
     getMaterialShaderPipeline,
     getMaterialShaderPipelineEntry,
+    getMaterialShaderArtifact: (materialShaderId, options = {}) =>
+      resolveRendererMaterialShaderArtifact(
+        materialShaderId,
+        getShader(),
+        pipelineState?.gpuDrivenPbrPrograms,
+        options,
+      ),
     getCachedMaterialShaderBindingContract,
     getParamSchema,
     getMaterialBindGroupLayout,