@forgeax/engine-render 0.1.19 → 0.1.21

package/src/assembly/factory.ts

@@ -50,7 +50,6 @@ import type {
   PipelineLayout,
   RenderPipeline,
   Result,
-  RhiAdapter,
   RhiCanvasContext,
   RhiDevice,
   Sampler,
@@ -59,6 +58,7 @@ import type {
 import { err, ok, RhiError, validateDrawArgs } from '@forgeax/engine-rhi';
 import { registerPropagateTransforms } from '@forgeax/engine-scene';
 import {
+  DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
   findVariantByKey,
   type MaterialShaderEntry,
   type MaterialShaderManifestEntry,
@@ -91,12 +91,16 @@ import {
   RendererOperationError,
   RenderFeatureCapabilityMissingError,
   RenderFeatureStageFailedError,
+  StandardProfileInvalidError,
 } from '../errors/render';
 import { createRenderFeatureHost, type RenderFeatureHost } from '../features/host';
 import type { RenderFeatureMaterialShaderBindingContract } from '../features/plan';
 import { RENDER_FEATURE_VERTEX_LAYOUTS } from '../features/prepared-graphics';
 import type { RenderFeature, RenderFeatureShaderModuleMode } from '../features/types';
-import type { PostProcessShaderEntry } from '../fullscreen-post-process-pass';
+import {
+  type PostProcessShaderEntry,
+  postProcessShaderModuleLabel,
+} from '../fullscreen-post-process-pass';
 import { glyphTextLayoutSystem } from '../glyph-text-layout-system';
 import { GpuBuffer } from '../gpu-resource';
 import { GPU_SHADER_STAGE_FRAGMENT, GPU_SHADER_STAGE_VERTEX } from '../gpu-stage';
@@ -134,9 +138,12 @@ import {
   SPOT_LIGHT_STD430_BYTES,
 } from '../light-buffer-layout';
 import {
+  buildPbrMaterialUserRegionEntries,
   buildPbrPipelineLayouts,
   buildPbrSkinLayouts,
-  isSkinnedShadowCasterVariant,
+  createHdrpSkinBindGroupLayoutDescriptor,
+  type PipelineGroup2Contract,
+  resolvePipelineGroup2Contract,
   SKIN_MATERIAL_SHADER_ID,
 } from '../pbr-pipeline';
 import { STANDARD_CLUSTER_MEMBERSHIP_WGSL, standardPipeline } from '../pipeline/standard-pipeline';
@@ -163,6 +170,15 @@ import {
 } from '../pipeline-spec';
 import { POINTS_LINES_MATERIAL_SHADER_ID } from '../points-lines/record';
 import type { FrameObservationOptions } from '../record/frame';
+import type { GpuPassTimingReason } from '../record/gpu-pass-timing/errors.js';
+import {
+  createGpuPassTimingSession,
+  DEFAULT_GPU_PASS_TIMING_OPTIONS,
+  type GpuPassTimingCapture,
+  type GpuPassTimingObservation,
+  type GpuPassTimingSession,
+} from '../record/gpu-pass-timing/index.js';
+import { GpuTimingCapture, type VolumeTimingObservation } from '../record/gpu-timing';
 import type { BloomPersistentBundle } from '../record/render-context';
 import { SHADOW_CASTER_BUFFER_SIZE } from '../record/shadow-pass';
 import { POINTS_LINES_VIEW_BUFFER_SIZE, VIEW_UNIFORM_BUFFER_SIZE } from '../record/view-ubo';
@@ -185,9 +201,12 @@ import type {
   RenderProfile,
   RenderResult,
   RenderWorldLease,
+  VolumetricFogShaderSources,
 } from '../render-contract';
-import { STANDARD_OUTPUT_TRANSFORM_FEATURE_ID } from '../render-contract';
+import { FXAA_POST_PROCESS_ID, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID } from '../render-contract';
+
 import {
+  attachGpuPassTimingSession,
   configureSurface,
   createRenderSystem,
   MATERIAL_PER_ENTITY_STRIDE,
@@ -195,6 +214,7 @@ import {
   type RenderSystem,
   selectSwapChainFormat,
 } from '../render-system';
+import { createGpuPassTimingObservationStore, observeGpuPassTimingDisabled } from '../renderer.js';
 import { postSpawnResolveJoints } from '../scene-instances/post-spawn-resolve-joints';
 import {
   createSkinPaletteAllocator,
@@ -202,7 +222,12 @@ import {
 } from '../systems/skin-palette-allocator';
 import { tilemapChunkExtractSystem } from '../tilemap-chunk-extract-system';
 import { EngineEnvironmentError, type RhiBackendPack } from './backend-contract';
+import {
+  deviceOptionsForAdapter,
+  STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES,
+} from './device-feature-admission';
 import type { RendererAssemblyImplementation, RendererHostImplementation } from './host-contract';
+import { createRenderTargetHost } from './render-target-host';
 import { projectRendererOutputInspection } from './renderer-inspection';
 import { isRendererStateOperational } from './renderer-lifecycle';
 
@@ -222,6 +247,19 @@ const GPU_ENVIRONMENT_ERROR_CODES = new Set([
   'oom',
 ]);
 
+/**
+ * The boot artifact is only a registry/prewarm seed. It is deliberately not
+ * an active lighting decision: every frame derives its Standard variant from
+ * `RenderPipelineFrame.standardLighting.kind` at record time. Keeping this
+ * boot-only value named as such prevents the eager module from becoming a
+ * second topology authority.
+ */
+const STANDARD_BOOT_TOPOLOGY_KIND: 'no-local-lights' | 'clustered' = 'no-local-lights';
+
+function standardBootClusterAxis(): boolean {
+  return STANDARD_BOOT_TOPOLOGY_KIND === 'clustered';
+}
+
 function classifyEnvErrorReason(
   base: string,
   primary: { code?: unknown; name?: unknown } | undefined,
@@ -446,18 +484,14 @@ export interface BundlerOptions {
 /**
  * Per-variant PipelineLayout selector (M4.5 / D-10 option A).
  *
- * The HDRP variant (`CLUSTER_FORWARD_AVAILABLE=true` or canonical `''`
- * all-true when the shader declares the cluster axis) needs the 7-slot
- * group(2) BGL chain (`hdrpPbrPipelineLayout`); URP variants
- * (`CLUSTER_FORWARD_AVAILABLE=false` / undefined / no axis) keep the
- * 1-slot mesh-array BGL chain (`pbrPipelineLayout`).
+ * The resolved HDRP group(2) contract needs the 7-slot BGL chain
+ * (`hdrpPbrPipelineLayout`); ordinary material contracts keep the 1-slot
+ * mesh-array BGL chain (`pbrPipelineLayout`). Variant keys select source
+ * artifacts only and never override this contract.
  *
- * Returns `null` only when the URP fallback layout itself is null
- * (Camera-only / empty-manifest path). When the HDRP layout is null but
- * URP exists, the HDRP variant gracefully falls back to URP — the WGSL
- * resolved upstream by `findVariantByKey` is the URP variant in that
- * case (manifest entry with all-true definesKey === '' was registered
- * with isHdrpActive=false at boot when storage-buffer caps are absent).
+ * Returns `null` when the selected layout is unavailable. An HDRP variant
+ * never falls back to the URP layout: its clustered WGSL and group(2) ABI
+ * must be admitted together or the draw fails closed.
  *
  * Pure function — exported for unit-test access (M4.5 / w35).
  */
@@ -465,8 +499,9 @@ export interface BundlerOptions {
  * Closed enum of pipeline-layout kinds the selector can dispatch to.
  *
  * `pbr` — standard PBR (1-entry mesh-array BGL).
- * `pbr-skin` — bug-20260611-skin-pipeline-layout: 2-entry mesh-array BGL
- *   (binding 0 meshes + binding 1 palette) for the `forgeax::pbr-skin`
+ * `pbr-skin` — bug-20260611-skin-pipeline-layout: 3-entry mesh-array BGL
+ *   (binding 0 meshes + binding 1 current palette + binding 2 previous
+ *   palette) for the `forgeax::pbr-skin`
  *   material shader.
  * `hdrp-pbr` — feat-20260609 HDRP cluster-forward variant (7-slot group(2)
  *   BGL substituted at slot 2).
@@ -486,7 +521,15 @@ export interface BundlerOptions {
  * material-shader layouts add a `LayoutKind` member + a PipelineState slot
  * + a switch arm here in one cut (charter P3 extensibility).
  */
-export type LayoutKind = 'pbr' | 'pbr-skin' | 'hdrp-pbr' | 'sprite-urp' | 'unlit-urp';
+export type LayoutKind = 'pbr' | 'pbr-skin' | 'hdrp-pbr' | 'hdrp-skin' | 'sprite-urp' | 'unlit-urp';
+
+/** The closed group(2) contract resolved from the selected WGSL artifact. */
+export type { PipelineGroup2Contract } from '../pbr-pipeline';
+export { resolvePipelineGroup2Contract } from '../pbr-pipeline';
+
+function directionalPcssCapable(backendKind: RhiDevice['caps']['backendKind']): boolean {
+  return backendKind === 'webgpu' || backendKind === 'wgpu-native';
+}
 
 /**
  * Return every device-capability HDRP PBR variant that needs a lazy module
@@ -499,17 +542,44 @@ export function selectHdrpPbrPrewarmVariants(
   manifestEntry: MaterialShaderManifestEntry | undefined,
   storageBufferCapable: boolean,
   transmissionCapable: boolean,
+  directionalPcssAvailable = true,
+  projectorAvailable: boolean = true,
 ): readonly MaterialShaderManifestEntry['variants'][number][] {
+  // HDRP's clustered group(2) ABI is storage-buffer backed. A downlevel
+  // WebGL2 device must stay on the URP variant; prewarming an HDRP source
+  // here would advertise an inactive route and can exceed its fragment
+  // uniform-buffer budget before the first frame.
+  if (!storageBufferCapable) return [];
   return (
     manifestEntry?.variants.filter(
       (variant) =>
         variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable &&
         variant.defines.CLUSTER_FORWARD_AVAILABLE === true &&
+        (!('DIRECTIONAL_PCSS_AVAILABLE' in variant.defines) ||
+          variant.defines.DIRECTIONAL_PCSS_AVAILABLE === directionalPcssAvailable) &&
+        (!('PROJECTOR_AVAILABLE' in variant.defines) ||
+          variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) &&
         (transmissionCapable || variant.defines.TRANSMISSION_AVAILABLE !== true),
     ) ?? []
   );
 }
 
+/** Return every active-capability pbr-skin variant used by URP and HDRP draws. */
+export function selectSkinPrewarmVariants(
+  manifestEntry: MaterialShaderManifestEntry | undefined,
+  storageBufferCapable: boolean,
+): readonly MaterialShaderManifestEntry['variants'][number][] {
+  return (
+    manifestEntry?.variants.filter(
+      (variant) =>
+        variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable &&
+        // The clustered skin ABI is only active on the storage-backed tier;
+        // storage=false must never prewarm or expose it as a usable variant.
+        (storageBufferCapable || variant.defines.CLUSTER_FORWARD_AVAILABLE !== true),
+    ) ?? []
+  );
+}
+
 /**
  * Select both Standard transmission states from the manifest for exact-label
  * prewarming. The requested keys come from declared variants; no key is
@@ -518,6 +588,8 @@ export function selectHdrpPbrPrewarmVariants(
 export function selectStandardPbrTransmissionPrewarmVariants(
   manifestEntry: MaterialShaderManifestEntry | undefined,
   storageBufferCapable: boolean,
+  directionalPcssAvailable = true,
+  projectorAvailable: boolean = true,
 ): readonly MaterialShaderManifestEntry['variants'][number][] {
   if (manifestEntry === undefined) {
     throw new Error('Standard material shader manifest row is missing');
@@ -527,8 +599,12 @@ export function selectStandardPbrTransmissionPrewarmVariants(
     const declared = manifestEntry.variants.find(
       (variant) =>
         variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable &&
-        variant.defines.CLUSTER_FORWARD_AVAILABLE === false &&
+        variant.defines.CLUSTER_FORWARD_AVAILABLE === standardBootClusterAxis() &&
         variant.defines.VERTEX_COLOR_AVAILABLE === false &&
+        (!('DIRECTIONAL_PCSS_AVAILABLE' in variant.defines) ||
+          variant.defines.DIRECTIONAL_PCSS_AVAILABLE === directionalPcssAvailable) &&
+        (!('PROJECTOR_AVAILABLE' in variant.defines) ||
+          variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) &&
         variant.defines.TRANSMISSION_AVAILABLE === transmissionAvailable,
     );
     if (declared === undefined) {
@@ -556,20 +632,28 @@ export function selectNoColorPbrVariant(
   manifestEntry: MaterialShaderManifestEntry | undefined,
   storageBufferCapable: boolean,
   variantSet: string | undefined,
+  directionalPcssAvailable = true,
+  projectorAvailable: boolean = true,
 ): MaterialShaderManifestEntry['variants'][number] | undefined {
-  const hdrpRequested =
-    variantSet === '' ||
-    // biome-ignore lint/complexity/useOptionalChain: G-14 requires an explicit undefined guard so no variant request becomes false.
-    (variantSet !== undefined && variantSet.includes('CLUSTER_FORWARD_AVAILABLE=true'));
+  const hdrpRequested = variantSet === '' || requestsClusterVariant(variantSet);
   return manifestEntry?.variants.find(
     (variant) =>
       variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable &&
       variant.defines.VERTEX_COLOR_AVAILABLE === false &&
+      (!('DIRECTIONAL_PCSS_AVAILABLE' in variant.defines) ||
+        variant.defines.DIRECTIONAL_PCSS_AVAILABLE === directionalPcssAvailable) &&
+      (!('PROJECTOR_AVAILABLE' in variant.defines) ||
+        variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) &&
       (!('CLUSTER_FORWARD_AVAILABLE' in variant.defines) ||
         variant.defines.CLUSTER_FORWARD_AVAILABLE === hdrpRequested),
   );
 }
 
+function requestsClusterVariant(variantSet: string | undefined): boolean {
+  if (variantSet === undefined) return false;
+  return variantSet.includes('CLUSTER_FORWARD_AVAILABLE=true');
+}
+
 export type MaterialShaderBindingContract = RenderFeatureMaterialShaderBindingContract;
 export type MaterialShaderVertexInputContract = 'none' | 'render-material';
 
@@ -623,6 +707,46 @@ export function resolveMaterialShaderVertexInputContract(
     : 'none';
 }
 
+/**
+ * Decide whether a custom material's user-region can use the shared PBR
+ * bind-group layout. Resource names are not part of a WebGPU layout contract:
+ * the only safe reuse test is that every derived binding in the custom schema
+ * is an identical prefix of the canonical user-region descriptor, including
+ * binding kind and its full shape (sample type, view dimension, sampler mode,
+ * dynamic-offset flags, and visibility). A texture3d/array or comparison /
+ * storage resource must therefore take the per-shader layout path even when
+ * its field count is small.
+ */
+export function isSharedMaterialUserRegionCompatible(
+  paramSchema: readonly ParamSchemaEntry[],
+): boolean {
+  const shared = buildPbrMaterialUserRegionEntries(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);
+  const candidate = buildPbrMaterialUserRegionEntries(paramSchema);
+  if (candidate.length > shared.length) return false;
+  return candidate.every((entry, index) => {
+    const canonical = shared[index];
+    if (canonical === undefined) return false;
+    return (
+      JSON.stringify({
+        binding: entry.binding,
+        visibility: entry.visibility,
+        buffer: entry.buffer ?? null,
+        sampler: entry.sampler ?? null,
+        texture: entry.texture ?? null,
+        storageTexture: entry.storageTexture ?? null,
+      }) ===
+      JSON.stringify({
+        binding: canonical.binding,
+        visibility: canonical.visibility,
+        buffer: canonical.buffer ?? null,
+        sampler: canonical.sampler ?? null,
+        texture: canonical.texture ?? null,
+        storageTexture: canonical.storageTexture ?? null,
+      })
+    );
+  });
+}
+
 export function allowsUnlitPreparedFallback(
   depthFormatOverride: GPUTextureFormat | null | undefined,
   vertexLayout: string | undefined,
@@ -656,8 +780,9 @@ export function selectPipelineLayoutForVariant(
     readonly pbrPipelineLayout: PipelineLayout | null;
     readonly hdrpPbrPipelineLayout: PipelineLayout | null;
     readonly pbrSkinPipelineLayout: PipelineLayout | null;
+    readonly hdrpSkinPipelineLayout?: PipelineLayout | null;
   } | null,
-  variantSet: string | undefined,
+  _variantSet: string | undefined,
   layoutKind?: LayoutKind,
 ): PipelineLayout | null {
   if (state === null) return null;
@@ -670,6 +795,9 @@ export function selectPipelineLayoutForVariant(
   if (layoutKind === 'pbr-skin') {
     return state.pbrSkinPipelineLayout;
   }
+  if (layoutKind === 'hdrp-skin') {
+    return state.hdrpSkinPipelineLayout ?? null;
+  }
   // bug-20260708 M2 (c): sprite / sprite-lit shaders reuse the URP 1-slot
   // mesh-array pipeline layout but their canonical all-true variant key
   // `''` (SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET) must NOT trigger
@@ -685,33 +813,19 @@ export function selectPipelineLayoutForVariant(
   if (layoutKind === 'unlit-urp') {
     return state.pbrPipelineLayout;
   }
-  // Static PBR callers can use the canonical all-true variant key (`''`)
-  // without becoming HDRP. Keep the shader variant identity independent from
-  // the pipeline-layout identity; shadow-caster static draws use this explicit
-  // kind so their ordinary mesh bind group remains compatible with the PSO.
+  // The resolved group(2) contract is authoritative for custom material
+  // shaders. A mesh-only composed WGSL uses the one-entry mesh BGL even when
+  // the renderer is otherwise running its HDRP lighting variant; allowing the
+  // variant key to re-select HDRP here recreates the mesh-vs-cluster mismatch.
   if (layoutKind === 'pbr') {
     return state.pbrPipelineLayout;
   }
-  // HDRP variant matches when:
-  //   - layoutKind === 'hdrp-pbr' (caller-driven, future-proof), OR
-  //   - variantSet is the canonical all-true key '' (boot-time HDRP
-  //     registration produces '' when both axes resolve to true), OR
-  //   - variantSet contains `CLUSTER_FORWARD_AVAILABLE=true` substring
-  //     (record-stage caller emits the expanded form).
-  // URP variants have CLUSTER_FORWARD_AVAILABLE=false explicitly, or omit
-  // the axis altogether, or pass undefined (no variant routing).
-  // G-14 (D-11): empty-string is the canonical all-true HDRP key, so we
-  // explicitly distinguish '' vs undefined rather than using an optional-chain
-  // (charter P3: explicit failure / no implicit empty-vs-missing collapse).
-  const isHdrpVariant =
-    layoutKind === 'hdrp-pbr' ||
-    variantSet === '' ||
-    // biome-ignore lint/complexity/useOptionalChain: G-14 grep gate forbids the optional-chain falsy collapse on variantSet.
-    (variantSet !== undefined && variantSet.includes('CLUSTER_FORWARD_AVAILABLE=true'));
-  if (isHdrpVariant && state.hdrpPbrPipelineLayout !== null) {
-    return state.hdrpPbrPipelineLayout;
-  }
-  return state.pbrPipelineLayout;
+  // Group(2) contract/layout kind is the sole layout authority. Variant keys
+  // identify WGSL artifacts, but must not independently select a bind-group
+  // layout; this prevents an empty/expanded key from bypassing the resolved
+  // storage contract.
+  const isHdrpVariant = layoutKind === 'hdrp-pbr';
+  return isHdrpVariant ? state.hdrpPbrPipelineLayout : state.pbrPipelineLayout;
 }
 
 /**
@@ -727,10 +841,14 @@ export function resolveMaterialShaderVariantSet(
   }>,
   backendKind: RhiDevice['caps']['backendKind'],
   storageBuffer: boolean,
+  projectorAvailable: boolean = true,
 ): string | undefined {
   const declaredAxes = new Set(variants.flatMap((variant) => Object.keys(variant.defines)));
   const declaresCapabilityVariants =
-    declaredAxes.has('WEBGL2_COMPAT') || declaredAxes.has('STORAGE_BUFFER_AVAILABLE');
+    declaredAxes.has('WEBGL2_COMPAT') ||
+    declaredAxes.has('STORAGE_BUFFER_AVAILABLE') ||
+    declaredAxes.has('DIRECTIONAL_PCSS_AVAILABLE') ||
+    declaredAxes.has('PROJECTOR_AVAILABLE');
   if (!declaresCapabilityVariants) return requestedVariantSet;
 
   const requested: Record<string, boolean> = {};
@@ -748,20 +866,24 @@ export function resolveMaterialShaderVariantSet(
           : axis === 'SKINNING_DISABLED'
             ? (requested[axis] ?? true)
             : axis === 'CLUSTER_FORWARD_AVAILABLE'
-              ? backendKind !== 'wgpu-webgl2' && (requested[axis] ?? false)
+              ? storageBuffer && backendKind !== 'wgpu-webgl2' && (requested[axis] ?? false)
               : axis === 'PER_INSTANCE_REGION'
                 ? requestedVariantSet === '' || (requested[axis] ?? false)
                 : axis === 'VERTEX_COLOR_AVAILABLE'
                   ? requestedVariantSet === '' || (requested[axis] ?? false)
                   : axis === 'TRANSMISSION_AVAILABLE'
                     ? (requested[axis] ?? false)
-                    : (requested[axis] ?? true);
+                    : axis === 'DIRECTIONAL_PCSS_AVAILABLE'
+                      ? directionalPcssCapable(backendKind)
+                      : axis === 'PROJECTOR_AVAILABLE'
+                        ? projectorAvailable
+                        : (requested[axis] ?? true);
   }
   const sorted = Object.entries(filtered).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
   return sorted.every(([, value]) => value)
-    ? requestedVariantSet === ''
-      ? ''
-      : undefined
+    ? requestedVariantSet === undefined
+      ? undefined
+      : ''
     : sorted.map(([name, value]) => `${name}=${value}`).join('+');
 }
 
@@ -825,6 +947,28 @@ export async function createRenderer(
   });
 }
 
+function markRendererBootstrapStage(
+  name: string,
+  detail?: Readonly<Record<string, unknown>>,
+): void {
+  const host = globalThis as {
+    __forgeaxRendererBootstrap?: {
+      readonly name: string;
+      readonly startedAt: number;
+      readonly previousElapsedMs: number;
+      readonly detail?: Readonly<Record<string, unknown>>;
+    };
+  };
+  const previous = host.__forgeaxRendererBootstrap;
+  const now = Date.now();
+  host.__forgeaxRendererBootstrap = {
+    name,
+    startedAt: now,
+    previousElapsedMs: previous === undefined ? 0 : now - previous.startedAt,
+    ...(detail === undefined ? {} : { detail }),
+  };
+}
+
 // ─── WebGPU branch ──────────────────────────────────────────────────────────
 
 /**
@@ -935,44 +1079,6 @@ type WebGPUOutcome =
   | { kind: 'rhi-err'; error: RhiError }
   | { kind: 'throw'; error: Error };
 
-// Optional compression is exposed on a device only when it is requested from
-// the adapter. Keep this capability projection shared by initial construction
-// and device-loss recovery; otherwise recovery silently drops BC/ETC2/ASTC
-// and already-catalogued compressed textures fail on the first new frame.
-const COMPRESSION_FEATURES: GPUFeatureName[] = [
-  'texture-compression-bc',
-  'texture-compression-etc2',
-  'texture-compression-astc',
-];
-
-// The Standard transmission fragment ABI needs 17 sampled textures across its
-// material, IBL, clustered-light, and SSAO bindings. Ordinary Standard draws
-// use the non-transmission variant and remain valid on the WebGPU minimum of
-// 16; only request the elevated limit when the adapter can provide it.
-const STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES = 17;
-
-function deviceOptionsForAdapter(adapter: Pick<RhiAdapter, 'features' | 'limits'>):
-  | {
-      requiredFeatures?: GPUFeatureName[];
-      requiredLimits?: GPUDeviceDescriptor['requiredLimits'];
-    }
-  | undefined {
-  const requiredFeatures = COMPRESSION_FEATURES.filter((feature) => adapter.features.has(feature));
-  const supportsTransmission =
-    (adapter.limits.maxSampledTexturesPerShaderStage ?? 0) >=
-    STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
-  return {
-    ...(requiredFeatures.length > 0 ? { requiredFeatures } : {}),
-    ...(supportsTransmission
-      ? {
-          requiredLimits: {
-            maxSampledTexturesPerShaderStage: STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES,
-          },
-        }
-      : {}),
-  };
-}
-
 /**
  * Goes through the strict two-step path exposed by the injected backend pack:
  *   `rhi.requestAdapter()` -> `adapter.requestDevice()`
@@ -1013,19 +1119,32 @@ async function tryCreateWebGPURenderer(
   // 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).
+  markRendererBootstrapStage('adapter-request-start');
   const adapterResult = await pack.rhi.requestAdapter(undefined, canvas);
+  markRendererBootstrapStage('adapter-request-end', {
+    ok: adapterResult.ok,
+    ...(adapterResult.ok ? {} : { code: adapterResult.error.code }),
+  });
   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);
+  const deviceOpts = deviceOptionsForAdapter(adapter, options);
+  markRendererBootstrapStage('device-request-start');
   const result = await adapter.requestDevice(deviceOpts);
+  markRendererBootstrapStage('device-request-end', {
+    ok: result.ok,
+    ...(result.ok ? {} : { code: result.error.code }),
+  });
   if (!result.ok) {
     return { kind: 'rhi-err', error: result.error };
   }
   const device: RhiDevice = result.value;
+  markRendererBootstrapStage('device-acquired', {
+    backendKind: device.caps.backendKind,
+  });
 
   // Acquire the canvas context through the backend pack (M3 / w16).
   // rhi-webgpu: internally calls canvas.getContext('webgpu') + branded wrap.
@@ -1150,16 +1269,30 @@ interface WebGPURendererInternals {
    * has wired the controller; identity stable across grow events.
    */
   meshSsboState?: MeshSsboState;
+  /** Device-bound, manifest-owned volumetric utility shader sources. */
+  volumetricFogShaders?: VolumetricFogShaderSources | undefined;
   /** 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;
+  gpuPassTimingSubmittedWork?: Promise<void> | undefined;
 }
 
 async function makeWebGPURenderer(
   internals: WebGPURendererInternals,
 ): Promise<RendererAssemblyImplementation> {
   let disposed = false;
+  let renderSystemForTargetPromotion: RenderSystem | undefined;
+  // The host keeps the zero-option createRenderTargetHost() seam compatible
+  // for package-local lifecycle tests while this assembly supplies the live
+  // DeviceScope generation callback.
+  const renderTargetHost = createRenderTargetHost({
+    rendererId: Symbol('renderer'),
+    getGeneration: () => activeDeviceScope.generation,
+    getDevice: () => internals.device,
+    canPromoteTarget: (target) =>
+      renderSystemForTargetPromotion?.isCubeCapturePending(target) !== true,
+  });
   const featureHostResult = createRenderFeatureHost(internals.options?.features ?? []);
   if (!featureHostResult.ok) throw featureHostResult.error;
   internals.featureHost = featureHostResult.value;
@@ -1174,6 +1307,28 @@ async function makeWebGPURenderer(
     featureHostResult.value.features.flatMap((feature) => feature.requiredMaterialShaders ?? []),
   );
   let requiredMaterialShaders = Object.freeze([...requiredMaterialShaderSet]);
+  const collectRequiredFullscreenPostProcesses = (
+    features: readonly RenderFeature<unknown>[],
+  ): readonly { readonly identity: string; readonly source: string }[] => {
+    const entries = new Map<string, { readonly identity: string; readonly source: string }>();
+    for (const feature of features) {
+      for (const entry of feature.requiredFullscreenPostProcesses ?? []) {
+        const existing = entries.get(entry.identity);
+        if (existing !== undefined && existing.source !== entry.source) {
+          throw new RhiError({
+            code: 'internal-error',
+            expected: `fullscreen identity '${entry.identity}' has one source across render features`,
+            hint: 'rename the conflicting fullscreen identity or make its WGSL source identical',
+          });
+        }
+        entries.set(entry.identity, entry);
+      }
+    }
+    return Object.freeze([...entries.values()]);
+  };
+  let requiredFullscreenPostProcesses = collectRequiredFullscreenPostProcesses(
+    featureHostResult.value.features,
+  );
   // Lazy ShaderCatalog instance (plan-strategy section S-10 / D-R10 / OQ-5
   // close): constructed on first access; subsequent accesses return the
   // same instance.
@@ -1216,6 +1371,28 @@ async function makeWebGPURenderer(
     }
     return sharedImmediateShaderModuleAdapter;
   };
+  const prewarmFullscreenFeatureModules = async (
+    feature: RenderFeature<unknown>,
+  ): Promise<Result<void, RhiError>> => {
+    for (const postProcess of feature.requiredFullscreenPostProcesses ?? []) {
+      const label = postProcessShaderModuleLabel(postProcess.identity, postProcess.source);
+      const shaderResult = internals.pack.createShaderModule
+        ? await internals.pack.createShaderModule(internals.device, {
+            code: postProcess.source,
+            label,
+          })
+        : await invokeDeviceCreateShaderModule(internals.device, {
+            code: postProcess.source,
+            label,
+          });
+      if (!shaderResult.ok) {
+        internals.errorRegistry.fire(shaderResult.error);
+        return err(shaderResult.error);
+      }
+      getShaderModuleAdapter().seedModule(label, shaderResult.value);
+    }
+    return ok(undefined);
+  };
   const getShader = (): ShaderCatalog => {
     if (shaderInstance === null) {
       // feat-20260608-create-app-param-surface-trim / M2 / D-2 q5-A:
@@ -1280,6 +1457,56 @@ async function makeWebGPURenderer(
   // lives in a standalone store; `assets` keeps the CPU POD registry only.
   const gpuStore = new GpuResidencyCache();
   let activeDeviceScope = DeviceScope.create(0, 'renderer');
+  const gpuPassTimingOptions = internals.options?.gpuPassTiming;
+  const timingRetentionFrames =
+    gpuPassTimingOptions?.retentionFrames !== undefined &&
+    Number.isInteger(gpuPassTimingOptions.retentionFrames) &&
+    gpuPassTimingOptions.retentionFrames >= 1 &&
+    gpuPassTimingOptions.retentionFrames <= 8
+      ? gpuPassTimingOptions.retentionFrames
+      : DEFAULT_GPU_PASS_TIMING_OPTIONS.retentionFrames;
+  let gpuPassTimingSession: GpuPassTimingSession | undefined;
+  let gpuPassTimingUnavailable: GpuPassTimingObservation | undefined;
+  const timingObservationStore =
+    gpuPassTimingOptions === undefined
+      ? undefined
+      : createGpuPassTimingObservationStore({
+          retentionFrames: timingRetentionFrames,
+          currentDeviceGeneration: () => activeDeviceScope.generation,
+        });
+  const retireGpuPassTimingSession = (): void => {
+    const retired = gpuPassTimingSession;
+    gpuPassTimingSession = undefined;
+    retired?.dispose();
+  };
+  const failedGpuPassTimingObservation = (error: GpuPassTimingReason): GpuPassTimingObservation => {
+    const latestKnownGood = timingObservationStore?.inspect().latestKnownGood;
+    return {
+      status: 'failed',
+      error,
+      ...(latestKnownGood === undefined ? {} : { latestKnownGood }),
+    };
+  };
+  const establishGpuPassTimingSession = (): void => {
+    retireGpuPassTimingSession();
+    gpuPassTimingUnavailable = undefined;
+    const timingOptions = gpuPassTimingOptions;
+    if (timingOptions === undefined) return;
+    const created = createGpuPassTimingSession(internals.device, timingOptions);
+    if (created.ok) {
+      gpuPassTimingSession = created.value;
+      return;
+    }
+    gpuPassTimingUnavailable = {
+      status: 'unavailable',
+      reason: created.error,
+      capability: {
+        timestampQuery: internals.device.caps.timestampQuery,
+        timestampPeriodNanoseconds: internals.device.caps.timestampPeriodNanoseconds,
+      },
+    };
+  };
+  establishGpuPassTimingSession();
   // feat-20260623-world-space-video-asset M4 / w16 (D-3): transient per-frame
   // video texture store, fully independent of gpuStore (AC-08). Configured with
   // the device alongside gpuStore below; threaded into the record stage via the
@@ -1413,7 +1640,10 @@ async function makeWebGPURenderer(
   // (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 materialShaderPipelineCache = new Map<
+    string,
+    { readonly pipeline: RenderPipeline; readonly group2Contract: PipelineGroup2Contract }
+  >();
   const materialShaderManifestEntryCache = new Map<string, MaterialShaderManifestEntry>();
   // Variant resolution only depends on the requested axes, device capability
   // axes, and the manifest entry that owns the declarations. Cache it by the
@@ -1628,6 +1858,18 @@ async function makeWebGPURenderer(
     }
     if (pipelineState === null) return null;
     const paramSchema = lookup.value.paramSchema;
+    // Reuse the shared BGL only when the complete derived resource shape is a
+    // canonical prefix. Field names alone are not a layout contract: a
+    // texture3d/array, comparison sampler, or storage buffer must never be
+    // paired with the PBR texture2d/filtering descriptor by accident.
+    if (isSharedMaterialUserRegionCompatible(paramSchema)) {
+      perShaderMaterialLayoutCache.set(materialShaderId, {
+        source: lookup.value.source,
+        paramSchema,
+        layout: null,
+      });
+      return null;
+    }
     const spec: PipelineSpec = {
       shader: { id: materialShaderId, passKind: 'forward', variantSet: undefined },
       attachments: { colorFormats: [], depthFormat: undefined, sampleCount: 1 },
@@ -1674,6 +1916,8 @@ async function makeWebGPURenderer(
         [],
         internals.device.caps.backendKind,
         internals.device.caps.storageBuffer,
+        (internals.device.limits.maxSampledTexturesPerShaderStage ?? 0) >=
+          STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES,
       );
     }
     const variants = manifestEntry.variants;
@@ -1682,13 +1926,17 @@ async function makeWebGPURenderer(
       byRequest = new Map();
       materialShaderVariantResolutionCache.set(variants, byRequest);
     }
-    const cacheKey = `${requestedVariantSet ?? '\u0000'}|${internals.device.caps.backendKind}|${internals.device.caps.storageBuffer ? '1' : '0'}`;
+    const projectorAvailable =
+      (internals.device.limits.maxSampledTexturesPerShaderStage ?? 0) >=
+      STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
+    const cacheKey = `${requestedVariantSet ?? '\u0000'}|${internals.device.caps.backendKind}|${internals.device.caps.storageBuffer ? '1' : '0'}|${projectorAvailable ? '1' : '0'}`;
     if (byRequest.has(cacheKey)) return byRequest.get(cacheKey);
     const resolved = resolveMaterialShaderVariantSet(
       requestedVariantSet,
       variants,
       internals.device.caps.backendKind,
       internals.device.caps.storageBuffer,
+      projectorAvailable,
     );
     byRequest.set(cacheKey, resolved);
     return resolved;
@@ -1714,6 +1962,7 @@ async function makeWebGPURenderer(
   // `internals.device` / `internals.pack` are read live, so a rebuild after a
   // device swap compiles against the new device.
   let tonemapRegistered = false;
+  let fxaaRegistered = false;
   let temporalPostProcessesRegistered = false;
   const buildPipeline = (scope: DeviceScope = activeDeviceScope): Promise<PipelineState> =>
     buildReadyWebGPU(
@@ -1724,6 +1973,7 @@ async function makeWebGPURenderer(
       internals.pack.createShaderModule,
       internals.errorRegistry,
       requiredMaterialShaders,
+      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
@@ -1743,9 +1993,12 @@ async function makeWebGPURenderer(
       // SPEC_CONST prewarm. Closure captures the Map declared just above so
       // the URP-variant prewarmed PSOs become visible to the URP record path
       // immediately (no 1-frame async-compile skip-draw window).
-      (key, pso) => {
+      (key, pso, group2Contract) => {
         if (!materialShaderPipelineCache.has(key)) {
-          materialShaderPipelineCache.set(key, pso);
+          materialShaderPipelineCache.set(key, {
+            pipeline: pso,
+            group2Contract,
+          });
         }
       },
       // feat-20260621 M-A3 (D-5): register the built-in tonemap on the unified
@@ -1764,6 +2017,19 @@ async function makeWebGPURenderer(
         });
         tonemapRegistered = true;
       },
+      // FXAA is recorded by the special graph primitive, but its final-output
+      // dither switch still uses the renderer-owned post-process params UBO.
+      // Register the declaration through the same lifecycle so recovery
+      // recreates the buffer on the replacement device.
+      (source: string) => {
+        if (fxaaRegistered) return;
+        renderSystem.registerBuiltinPostProcess(FXAA_POST_PROCESS_ID, {
+          source,
+          params: { byteSize: 16, defaultValue: new Uint8Array(16) },
+          reads: ['ldrColor'],
+        });
+        fxaaRegistered = true;
+      },
       (entries: { readonly motionBlur?: string; readonly taaResolve?: string }) => {
         if (temporalPostProcessesRegistered) return;
         if (entries.motionBlur !== undefined) {
@@ -1782,15 +2048,23 @@ async function makeWebGPURenderer(
         }
         temporalPostProcessesRegistered = true;
       },
+      (sources: VolumetricFogShaderSources) => {
+        internals.volumetricFogShaders = sources;
+      },
     );
+  markRendererBootstrapStage('renderer-initialization-start');
   const ready: Promise<Result<void, RhiError>> = buildPipeline().then(
     (state): Result<void, RhiError> => {
       pipelineState = state;
       readySettled = true;
+      markRendererBootstrapStage('renderer-initialized');
       return ok(undefined);
     },
     (e: unknown): Result<void, RhiError> => {
       readySettled = true;
+      markRendererBootstrapStage('renderer-initialization-failed', {
+        message: e instanceof Error ? e.message : String(e),
+      });
       if (e instanceof RhiError) return err(e);
       const message = e instanceof Error ? e.message : String(e);
       return err(
@@ -1827,6 +2101,9 @@ async function makeWebGPURenderer(
       pbrManifestEntry,
       internals.device.caps.storageBuffer,
       variantSet,
+      directionalPcssCapable(internals.device.caps.backendKind),
+      (internals.device.limits.maxSampledTexturesPerShaderStage ?? 0) >=
+        STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES,
     );
     if (noColorVariant !== undefined && noColorVariant.composedWgsl !== standardEntry.wgsl) {
       return { ...standardEntry, wgsl: noColorVariant.composedWgsl };
@@ -1842,10 +2119,10 @@ async function makeWebGPURenderer(
   // 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.
+  // `variantSet` identifies the shader artifact, while the resolved group(2)
+  // contract selects the matching Standard layout. A missing cluster layout
+  // is an explicit unavailable result; it must not silently bind the mesh-only
+  // layout to a clustered shader.
   const buildPipelineContext = (
     variantSet?: string,
     materialShaderId?: string,
@@ -1856,40 +2133,31 @@ async function makeWebGPURenderer(
     // 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).
+    // path is fully determined by the resolved group-2 contract, so
+    // key-presence is the only signal `deriveVertexBufferLayout` reads).
     meshAttributes?: VertexAttributeMap,
     vertexLayout?: string,
     vertexLayoutProjection?: VertexLayoutProjection,
     shaderModuleMode?: RenderFeatureShaderModuleMode,
+    group2Contract: PipelineGroup2Contract = 'mesh',
     layoutKindOverride?: LayoutKind,
   ) => {
-    // bug-20260611: derive LayoutKind from materialShaderId (caller-driven)
-    // so the selector body stays free of literal shader-id strings (AC-09).
-    // Skin shader gets its own 4-slot layout chain with 2-entry mesh-array
-    // BGL; everything else routes through the URP/HDRP variantSet logic.
-    // bug-20260708 M2 (c): sprite / sprite-lit map to 'sprite-urp' so the
-    // canonical all-true variant key `''` (used by SpriteInstances batches
-    // via SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET) does NOT route
-    // through the HDRP layout branch of the selector — sprite shaders have
-    // no HDRP variant, plan-strategy R-1' guard.
-    const layoutKind: LayoutKind | undefined =
-      layoutKindOverride ??
-      (materialShaderId === SKIN_MATERIAL_SHADER_ID ||
-      isSkinnedShadowCasterVariant(materialShaderId, variantSet)
-        ? 'pbr-skin'
-        : materialShaderId === 'forgeax::sprite' || materialShaderId === 'forgeax::sprite-lit'
-          ? 'sprite-urp'
-          : materialShaderId === 'forgeax::default-unlit'
-            ? 'unlit-urp'
-            : undefined);
+    const contractLayoutKind: LayoutKind =
+      group2Contract === 'cluster'
+        ? 'hdrp-pbr'
+        : group2Contract === 'skin-cluster'
+          ? 'hdrp-skin'
+          : group2Contract === 'skin'
+            ? 'pbr-skin'
+            : 'pbr';
+    const resolvedLayoutKind = layoutKindOverride ?? contractLayoutKind;
     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.
     const perShaderLayout =
-      !usesSharedBootMaterialLayout && layoutKind !== 'pbr-skin' && materialShaderId !== undefined
+      !usesSharedBootMaterialLayout && materialShaderId !== undefined
         ? getOrBuildPerShaderMaterialLayout(materialShaderId)
         : null;
     // feat-20260621-learn-render-5-5-parallax M2 / w6 (D-1): an authored
@@ -1941,7 +2209,7 @@ async function makeWebGPURenderer(
                 ? preparedMaterialLayout
                 : perShaderLayout !== null
                   ? perShaderLayout.pipelineLayout
-                  : selectPipelineLayoutForVariant(pipelineState, variantSet, layoutKind);
+                  : selectPipelineLayoutForVariant(pipelineState, variantSet, resolvedLayoutKind);
     if (pipelineLayout === null) return null;
     // feat-20260611-fox-skinning-vertex-attribute-chain M4 / w16 (D-4):
     // pbr-skin -> deriveVertexBufferLayout (single SSOT for skin/non-skin
@@ -1992,7 +2260,7 @@ async function makeWebGPURenderer(
                           : undefined,
                       ),
                     )
-                  : layoutKind === 'pbr-skin'
+                  : materialShaderId === SKIN_MATERIAL_SHADER_ID
                     ? toGpuVertexBufferLayouts(
                         deriveVertexBufferLayout(
                           meshAttributes ??
@@ -2038,7 +2306,7 @@ async function makeWebGPURenderer(
           : getShaderModuleAdapter(),
       pipelineLayout,
       vertexBuffers,
-      ...(layoutKind === 'pbr-skin' ? { layoutKind } : {}),
+      ...(resolvedLayoutKind === 'pbr-skin' ? { layoutKind: 'pbr-skin' as const } : {}),
     };
   };
   /**
@@ -2062,7 +2330,7 @@ async function makeWebGPURenderer(
     passKind: PassKind = 'forward',
     // bug-20260611-skin-pipeline-layout: thread materialShaderId so
     // buildPipelineContext can derive `LayoutKind === 'pbr-skin'` and pick
-    // the 2-entry mesh-array BGL chain.
+    // the 3-entry mesh-array BGL chain.
     materialShaderId?: string,
     // feat-20260611-fox-skinning-vertex-attribute-chain M4 / w16 (D-4):
     // pass the per-mesh `VertexAttributeMap` so the pbr-skin path's
@@ -2098,7 +2366,11 @@ async function makeWebGPURenderer(
     vertexLayoutProjection?: VertexLayoutProjection,
     shaderModuleMode?: RenderFeatureShaderModuleMode,
     layoutKindOverride?: LayoutKind,
-  ): RenderPipeline | null => {
+  ): {
+    readonly pipeline: RenderPipeline;
+    readonly group2Contract: PipelineGroup2Contract;
+  } | null => {
+    const group2Contract = resolvePipelineGroup2Contract(entry.source);
     const ctx = buildPipelineContext(
       variantSet,
       materialShaderId,
@@ -2106,6 +2378,7 @@ async function makeWebGPURenderer(
       vertexLayout,
       vertexLayoutProjection,
       shaderModuleMode,
+      group2Contract,
       layoutKindOverride,
     );
     if (ctx === null) return null;
@@ -2165,10 +2438,14 @@ async function makeWebGPURenderer(
       }
       return null;
     }
-    materialShaderPipelineCache.set(cacheKey, built.value);
-    return built.value;
+    const pipelineEntry = {
+      pipeline: built.value,
+      group2Contract,
+    } as const;
+    materialShaderPipelineCache.set(cacheKey, pipelineEntry);
+    return pipelineEntry;
   };
-  const getMaterialShaderPipeline = (
+  const resolveMaterialShaderPipelineEntry = (
     materialShaderId: string,
     isHdr: boolean,
     renderState?: MaterialRenderState,
@@ -2215,7 +2492,10 @@ async function makeWebGPURenderer(
     vertexLayoutProjection?: VertexLayoutProjection,
     shaderModuleMode: RenderFeatureShaderModuleMode = 'validated',
     layoutKindOverride?: LayoutKind,
-  ): RenderPipeline | null => {
+  ): {
+    readonly pipeline: RenderPipeline;
+    readonly group2Contract: PipelineGroup2Contract;
+  } | null => {
     // 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
@@ -2335,6 +2615,11 @@ async function makeWebGPURenderer(
     if (pipelineState === null) return null;
     const lookup = getShader().findMaterialArtifact(materialShaderId);
     if (!lookup.ok) {
+      // An explicit variant request is an exact artifact contract. There is
+      // no safe boot/PBR substitute: a substitute can pair the requested
+      // source identity with a different group(2) ABI and only fail at GPU
+      // validation. Let the caller retry after the manifest/artifact is fixed.
+      if (effectiveVariantSet !== undefined) return null;
       if (shouldDeferMissingPreparedMaterialShader(vertexLayout)) {
         // Prepared VFX draws bind only their feature-owned groups. The
         // built-in PBR fallback declares mesh/instance groups 2/3 and would
@@ -2455,24 +2740,26 @@ async function makeWebGPURenderer(
     // Use `!== undefined` so the empty-string case enters the lookup.
     if (effectiveVariantSet !== undefined) {
       const registry = getShader();
+      let matchedVariant = false;
       for (const msEntry of registry.materialShaderManifestEntries()) {
         if (msEntry.identifier === materialShaderId) {
           const variant = findVariantByKey(msEntry, effectiveVariantSet);
-          if (variant) {
-            // M3 / w12-w13: variant substitution carries the same source +
-            // paramSchema as the boot-registered entry; the binding layout
-            // is no longer carried on MaterialShaderEntry (deleted in
-            // w13) — buildPbrPipelineLayouts is the BGL SSOT and reads
-            // derive(paramSchema).bglEntries on demand.
-            shaderEntry = {
-              source: variant.composedWgsl,
-              paramSchema: lookup.value.paramSchema,
-              paramSchemaProjection: lookup.value.paramSchemaProjection,
-            };
-          }
+          if (variant === undefined) return null;
+          matchedVariant = true;
+          // M3 / w12-w13: variant substitution carries the same source +
+          // paramSchema as the boot-registered entry; the binding layout
+          // is no longer carried on MaterialShaderEntry (deleted in
+          // w13) — buildPbrPipelineLayouts is the BGL SSOT and reads
+          // derive(paramSchema).bglEntries on demand.
+          shaderEntry = {
+            source: variant.composedWgsl,
+            paramSchema: lookup.value.paramSchema,
+            paramSchemaProjection: lookup.value.paramSchemaProjection,
+          };
           break;
         }
       }
+      if (!matchedVariant) return null;
     }
     // feat-20260609 M4 / R3-fixup: append `-${passKind}` to the PSO label so
     // GPU debug captures (and the shadow-caster branch in the builder)
@@ -2513,7 +2800,7 @@ async function makeWebGPURenderer(
       passKind,
       // bug-20260611-skin-pipeline-layout: thread the registered materialShaderId
       // so buildPipelineContext can resolve LayoutKind='pbr-skin' for the skin
-      // shader (2-entry mesh-array BGL).
+      // shader (3-entry mesh-array BGL).
       materialShaderId,
       // feat-20260611-fox-skinning-vertex-attribute-chain M4 / w16 (D-4):
       // forward meshAttributes so the pbr-skin path's vertex buffer layout
@@ -2530,6 +2817,12 @@ async function makeWebGPURenderer(
       layoutKindOverride,
     );
   };
+  const getMaterialShaderPipelineEntry = (
+    ...args: Parameters<typeof resolveMaterialShaderPipelineEntry>
+  ) => resolveMaterialShaderPipelineEntry(...args);
+  const getMaterialShaderPipeline = (
+    ...args: Parameters<typeof resolveMaterialShaderPipelineEntry>
+  ): RenderPipeline | null => getMaterialShaderPipelineEntry(...args)?.pipeline ?? null;
   const getParamSchema = (materialShaderId: string) => {
     const lookup = getShader().findMaterialArtifact(materialShaderId);
     return lookup.ok ? lookup.value.paramSchema : undefined;
@@ -2650,6 +2943,10 @@ async function makeWebGPURenderer(
     shaderModuleFactory: {
       createShaderModule: (descriptor) => getShaderModuleAdapter().createShaderModule(descriptor),
     },
+    createShaderModule: (device, descriptor) =>
+      internals.pack.createShaderModule === undefined
+        ? Promise.resolve(invokeDeviceCreateShaderModule(device, descriptor))
+        : internals.pack.createShaderModule(device, descriptor),
     immediateShaderModuleFactory: {
       createShaderModule: (descriptor) =>
         getImmediateShaderModuleAdapter().createShaderModule(descriptor),
@@ -2686,6 +2983,7 @@ async function makeWebGPURenderer(
     errorRegistry: internals.errorRegistry,
     healthRegistry: internals.healthRegistry,
     getMaterialShaderPipeline,
+    getMaterialShaderPipelineEntry,
     getMaterialShaderBindingContract: getCachedMaterialShaderBindingContract,
     getParamSchema,
     getMaterialBindGroupLayout,
@@ -2705,7 +3003,93 @@ async function makeWebGPURenderer(
     get meshSsboState() {
       return internals.meshSsboState;
     },
+    get gpuPassTimingSession() {
+      return (
+        internals as WebGPURendererInternals & {
+          gpuPassTimingSession?: GpuPassTimingSession | undefined;
+        }
+      ).gpuPassTimingSession;
+    },
+    set gpuPassTimingSession(session: GpuPassTimingSession | undefined) {
+      (
+        internals as WebGPURendererInternals & {
+          gpuPassTimingSession?: GpuPassTimingSession | undefined;
+        }
+      ).gpuPassTimingSession = session;
+    },
+    get gpuPassTimingCapture() {
+      return (
+        internals as WebGPURendererInternals & {
+          gpuPassTimingCapture?: GpuPassTimingCapture | undefined;
+        }
+      ).gpuPassTimingCapture;
+    },
+    set gpuPassTimingCapture(capture: GpuPassTimingCapture | undefined) {
+      (
+        internals as WebGPURendererInternals & {
+          gpuPassTimingCapture?: GpuPassTimingCapture | undefined;
+        }
+      ).gpuPassTimingCapture = capture;
+    },
+    get gpuPassTimingSubmittedWork() {
+      return (
+        internals as WebGPURendererInternals & {
+          gpuPassTimingSubmittedWork?: Promise<void> | undefined;
+        }
+      ).gpuPassTimingSubmittedWork;
+    },
+    set gpuPassTimingSubmittedWork(completion: Promise<void> | undefined) {
+      (
+        internals as WebGPURendererInternals & {
+          gpuPassTimingSubmittedWork?: Promise<void> | undefined;
+        }
+      ).gpuPassTimingSubmittedWork = completion;
+    },
+    get gpuPassTimingFrameIdentity() {
+      return (
+        internals as WebGPURendererInternals & {
+          gpuPassTimingFrameIdentity?:
+            | import('../record/gpu-pass-timing/session.js').GpuPassTimingFrameIdentity
+            | undefined;
+        }
+      ).gpuPassTimingFrameIdentity;
+    },
+    set gpuPassTimingFrameIdentity(identity:
+      | import('../record/gpu-pass-timing/session.js').GpuPassTimingFrameIdentity
+      | undefined) {
+      (
+        internals as WebGPURendererInternals & {
+          gpuPassTimingFrameIdentity?:
+            | import('../record/gpu-pass-timing/session.js').GpuPassTimingFrameIdentity
+            | undefined;
+        }
+      ).gpuPassTimingFrameIdentity = identity;
+    },
+    get gpuPassTimingBeginReason() {
+      return (
+        internals as WebGPURendererInternals & {
+          gpuPassTimingBeginReason?: GpuPassTimingReason | undefined;
+        }
+      ).gpuPassTimingBeginReason;
+    },
+    set gpuPassTimingBeginReason(reason: GpuPassTimingReason | undefined) {
+      (
+        internals as WebGPURendererInternals & {
+          gpuPassTimingBeginReason?: GpuPassTimingReason | undefined;
+        }
+      ).gpuPassTimingBeginReason = reason;
+    },
+    getRenderTargetPhysical: (target) => renderTargetHost.getPhysicalTarget(target),
+    resolveRenderTargetTextureSource: (source) =>
+      renderTargetHost.resolveRenderTargetTextureSource(source),
+    encodeRenderTargetReadbacks: (encoder, faces) =>
+      renderTargetHost.encodePendingReadbacks(encoder, faces),
+    get volumetricFogShaders() {
+      return internals.volumetricFogShaders;
+    },
   });
+  attachGpuPassTimingSession(internals, gpuPassTimingSession);
+  renderSystemForTargetPromotion = renderSystem;
   if (
     internals.device.caps.backendKind === 'null' &&
     Array.from(getShader().entries()).length === 0
@@ -2730,7 +3114,12 @@ async function makeWebGPURenderer(
   const transformReleases = new Map<World, () => void>();
   const attachmentOwner = {};
   let frameId = 0;
-  let latestReceipt: FrameReceipt | undefined;
+  // Receipts remain valid for observation until their device generation is
+  // retired. Keeping a renderer-owned registry avoids treating a concurrent
+  // RAF submission as invalidation of an otherwise current receipt.
+  const currentReceipts = new Set<FrameReceipt>();
+  const issuedReceipts = new WeakSet<FrameReceipt>();
+  const receiptTimings = new WeakMap<FrameReceipt, Promise<VolumeTimingObservation>>();
   let surfaceReleased = false;
 
   const renderer: RendererAssemblyImplementation = {
@@ -2744,13 +3133,21 @@ async function makeWebGPURenderer(
       leasesByWorld.set(world, lease);
       return ok(lease);
     },
+    createRenderTarget: (descriptor) => renderTargetHost.createRenderTarget(descriptor),
+    resizeRenderTarget: (target, descriptor) =>
+      renderTargetHost.resizeRenderTarget(target, descriptor),
+    createRenderTargetTextureSource: (target, options) =>
+      renderTargetHost.createRenderTargetTextureSource(target, options),
+    requestTargetReadback: (target, request) =>
+      renderTargetHost.requestTargetReadback(target, request),
+    destroyRenderTarget: (target) => renderTargetHost.destroyRenderTarget(target),
     setProfile(profile: RenderProfile): RenderResult<void, RenderError> {
       const invalid = validateRenderProfile(profile);
       if (invalid !== undefined) {
         return err(
           new RendererOperationError('frame-input-invalid', {
             operation: 'set-profile',
-            cause: new RendererContractFailureError('draw', invalid),
+            cause: new StandardProfileInvalidError(invalid),
           }),
         );
       }
@@ -2794,6 +3191,8 @@ async function makeWebGPURenderer(
           ? {}
           : { presentationProof: internals.context.presentationProof }),
       });
+      const volumetricFog = renderSystem.volumetricFog;
+      const directionalShadow = renderSystem.directionalShadow;
       return Object.freeze({
         state,
         surface: surfaceReleased ? 'released' : 'available',
@@ -2807,12 +3206,15 @@ async function makeWebGPURenderer(
           (internals.featureHost?.features ?? []).map((feature) => feature.identity),
         ),
         featureDiagnostics: internals.featureHost?.diagnostics() ?? Object.freeze([]),
+        volumetricFog,
         frustumStats: Object.freeze({ ...renderSystem.frustumStats }),
         visibilityStats: Object.freeze({ ...renderSystem.visibilityStats }),
         renderScene: renderSystem.renderScene,
+        reflectionProbes: renderSystem.reflectionProbes,
         environment: renderSystem.environment,
         temporal: renderSystem.temporal,
         bloom: renderSystem.bloom,
+        directionalShadow,
         ...(renderSystem.temporalTargetInspection === undefined
           ? {}
           : { temporalTarget: Object.freeze(renderSystem.temporalTargetInspection) }),
@@ -2822,6 +3224,12 @@ async function makeWebGPURenderer(
         ...(renderSystem.transmission === undefined
           ? {}
           : { transmission: renderSystem.transmission }),
+        ...(renderSystem.standardLightingInspection === undefined
+          ? {}
+          : { standardLighting: Object.freeze({ ...renderSystem.standardLightingInspection }) }),
+        ...(renderSystem.pointShadowInspection === undefined
+          ? {}
+          : { pointShadow: Object.freeze({ ...renderSystem.pointShadowInspection }) }),
         meshMaterialBindings: Object.freeze(
           renderSystem.meshMaterialBindings.map((observation) =>
             Object.freeze({
@@ -2970,6 +3378,9 @@ async function makeWebGPURenderer(
     get bindGroupCounts() {
       return renderSystem.bindGroupCounts;
     },
+    configureStandard(config) {
+      renderSystem.configureStandard(config);
+    },
     renderFeatureDiagnostics() {
       return internals.featureHost?.diagnostics() ?? [];
     },
@@ -2995,6 +3406,35 @@ async function makeWebGPURenderer(
           new RenderFeatureCapabilityMissingError(feature.identity, host.size, missingCapability),
         );
       }
+      let nextRequiredFullscreenPostProcesses: readonly {
+        readonly identity: string;
+        readonly source: string;
+      }[];
+      try {
+        nextRequiredFullscreenPostProcesses = collectRequiredFullscreenPostProcesses([
+          ...host.features,
+          feature,
+        ]);
+      } catch (cause) {
+        const conflict =
+          cause instanceof RhiError
+            ? cause
+            : new RhiError({
+                code: 'internal-error',
+                expected: 'fullscreen feature declarations are internally consistent',
+                hint: 'repair the conflicting fullscreen identity/source declarations',
+              });
+        internals.errorRegistry.fire(conflict);
+        return err(
+          new RenderFeatureStageFailedError(feature.identity, -1, 'prepare', 'registration'),
+        );
+      }
+      const fullscreenPrewarm = await prewarmFullscreenFeatureModules(feature);
+      if (!fullscreenPrewarm.ok) {
+        return err(
+          new RenderFeatureStageFailedError(feature.identity, -1, 'prepare', 'registration'),
+        );
+      }
       for (const materialShaderId of feature.requiredMaterialShaders ?? []) {
         const lookup = getShader().findMaterialArtifact(materialShaderId);
         if (!lookup.ok) {
@@ -3033,6 +3473,7 @@ async function makeWebGPURenderer(
           requiredMaterialShaderSet.add(materialShaderId);
         }
         requiredMaterialShaders = Object.freeze([...requiredMaterialShaderSet]);
+        requiredFullscreenPostProcesses = nextRequiredFullscreenPostProcesses;
       }
       return installed;
     },
@@ -3061,6 +3502,7 @@ async function makeWebGPURenderer(
           }
         }
         requiredMaterialShaders = Object.freeze([...requiredMaterialShaderSet]);
+        requiredFullscreenPostProcesses = collectRequiredFullscreenPostProcesses(host.features);
       }
       return removed;
     },
@@ -3234,8 +3676,52 @@ async function makeWebGPURenderer(
       // through onError separately; the facade Result is the synchronous
       // summary AI users can ignore or branch on).
       try {
-        const submitted = renderSystem.draw(worlds, drawOptions, renderReadLeases);
+        renderTargetHost.beginFrame();
+        const timingHost = internals as WebGPURendererInternals & {
+          gpuPassTimingFrameIdentity?:
+            | {
+                readonly frameId: number;
+                readonly deviceGeneration: number;
+                readonly graphGeneration: number;
+              }
+            | undefined;
+          gpuPassTimingCapture?:
+            | import('../record/gpu-pass-timing/session.js').GpuPassTimingCapture
+            | undefined;
+          gpuPassTimingBeginReason?: GpuPassTimingReason | undefined;
+        };
+        const timingRequested =
+          isFrameRequest &&
+          (frameRequest?.profileFrame !== undefined ||
+            internals.options?.captureGpuTimings === true);
+        let volumeTimingCapture: GpuTimingCapture | undefined;
+        const volumeTimingUnavailableReason = timingRequested
+          ? 'timestamp capture is unavailable on this device'
+          : 'timestamp capture was not requested for this frame';
+        // The pass-timing session is authoritative when the feature is
+        // enabled. Keep the volume-specific capture for its existing
+        // benchmark path, but do not allocate two timestamp readbacks for a
+        // single receipt when both options are present.
+        if (timingRequested && gpuPassTimingOptions === undefined) {
+          const createdTiming = GpuTimingCapture.create(internals.device);
+          if (createdTiming.ok) volumeTimingCapture = createdTiming.value;
+        }
+        if (isFrameRequest) {
+          timingHost.gpuPassTimingFrameIdentity = {
+            frameId: frameId + 1,
+            deviceGeneration: activeDeviceScope.generation,
+            graphGeneration: 0,
+          };
+        }
+        const submitted = renderSystem.draw(
+          worlds,
+          drawOptions,
+          renderReadLeases,
+          volumeTimingCapture,
+        );
+        timingHost.gpuPassTimingFrameIdentity = undefined;
         if (!submitted) {
+          volumeTimingCapture?.discard();
           return err(
             new RendererContractFailureError(
               'draw',
@@ -3243,29 +3729,78 @@ async function makeWebGPURenderer(
             ),
           );
         }
+        const timingCompletion = timingHost.gpuPassTimingSubmittedWork;
+        timingHost.gpuPassTimingSubmittedWork = undefined;
         internals.pack.instrumentation?.onFrameBoundary?.();
+        const receiptFrameId = ++frameId;
+        const receiptGeneration = activeDeviceScope.generation;
+        const completed: FrameReceipt['completed'] = (
+          timingCompletion ?? internals.device.queue.onSubmittedWorkDone()
+        )
+          .then(() => ok(undefined))
+          .catch((cause: unknown) =>
+            err(
+              new RendererOperationError('device-operation-failed', {
+                operation: 'complete-frame',
+                frameId: receiptFrameId,
+                deviceGeneration: receiptGeneration,
+                cause: structuredRendererCause(cause, 'complete-frame'),
+              }),
+            ),
+          );
+        renderTargetHost.onFrameSubmitted(completed);
         if (isFrameRequest) {
-          const receiptFrameId = ++frameId;
-          const receiptGeneration = activeDeviceScope.generation;
-          const completed: FrameReceipt['completed'] = internals.device.queue
-            .onSubmittedWorkDone()
-            .then(() => ok(undefined))
-            .catch((cause: unknown) =>
-              err(
-                new RendererOperationError('device-operation-failed', {
-                  operation: 'complete-frame',
-                  frameId: receiptFrameId,
-                  deviceGeneration: receiptGeneration,
-                  cause: structuredRendererCause(cause, 'complete-frame'),
-                }),
-              ),
-            );
           const receipt = Object.freeze({
             frameId: receiptFrameId,
             deviceGeneration: receiptGeneration,
             completed,
           });
-          latestReceipt = receipt;
+          const passTimingCapture = timingHost.gpuPassTimingCapture;
+          const timingBeginReason = timingHost.gpuPassTimingBeginReason;
+          const timingSource =
+            passTimingCapture === undefined
+              ? gpuPassTimingUnavailable === undefined && timingBeginReason === undefined
+                ? undefined
+                : async (): Promise<GpuPassTimingObservation> =>
+                    gpuPassTimingUnavailable ??
+                    failedGpuPassTimingObservation(timingBeginReason as GpuPassTimingReason)
+              : async (): Promise<GpuPassTimingObservation> => {
+                  const observed = await passTimingCapture.observe();
+                  if (!observed.ok) {
+                    return failedGpuPassTimingObservation(observed.error);
+                  }
+                  const frame = observed.value;
+                  const unmeasured = frame.passes.find((pass) => pass.status === 'unmeasured');
+                  if (unmeasured !== undefined) {
+                    return { status: 'partial', frame, reason: unmeasured.reason };
+                  }
+                  if (frame.droppedPassCount > 0) {
+                    return {
+                      status: 'partial',
+                      frame,
+                      reason: {
+                        code: 'query-budget-exceeded',
+                        expected: 'all executed passes fit within the bounded query budget',
+                        hint: 'increase maxPassesPerFrame or simplify the pass graph',
+                        detail: { droppedPassCount: frame.droppedPassCount },
+                      },
+                    };
+                  }
+                  return { status: 'complete', frame };
+                };
+          timingObservationStore?.register(receipt, timingSource);
+          currentReceipts.add(receipt);
+          if (timingRequested && gpuPassTimingOptions === undefined) {
+            receiptTimings.set(
+              receipt,
+              volumeTimingCapture?.observation() ??
+                Promise.resolve({
+                  status: 'unavailable',
+                  reason: volumeTimingUnavailableReason,
+                }),
+            );
+          }
+          issuedReceipts.add(receipt);
           return ok(receipt);
         }
         return ok(undefined);
@@ -3289,11 +3824,18 @@ async function makeWebGPURenderer(
       receipt: FrameReceipt,
       request: FrameObservationRequest,
     ): Promise<RenderResult<FrameReceiptObservation, RenderError>> {
+      // The bounded pass contract owns `timings`; the volume timing producer
+      // owns the separate `volumeTimings` field. Keeping the fields distinct
+      // prevents consumers from having to discriminate an untagged union.
+      if (gpuPassTimingOptions !== undefined) {
+        return timingObservationStore === undefined
+          ? observeGpuPassTimingDisabled(receipt, request, () => activeDeviceScope.generation)
+          : timingObservationStore.observe(receipt, request);
+      }
       if (
-        latestReceipt === undefined ||
-        latestReceipt !== receipt ||
-        latestReceipt.frameId !== receipt.frameId ||
-        latestReceipt.deviceGeneration !== receipt.deviceGeneration
+        !currentReceipts.has(receipt) ||
+        !issuedReceipts.has(receipt) ||
+        receipt.deviceGeneration !== activeDeviceScope.generation
       ) {
         const currentGeneration = activeDeviceScope.generation;
         return err(
@@ -3316,11 +3858,27 @@ async function makeWebGPURenderer(
           }),
         );
       }
+      const targetReadbacks =
+        request.targetReadbacks === undefined || request.targetReadbacks.length === 0
+          ? undefined
+          : await renderTargetHost.observeTargetReadbacks(receipt, request.targetReadbacks);
+      if (targetReadbacks !== undefined && !targetReadbacks.ok) return targetReadbacks;
+      const volumeTimings = request.include.includes('timings')
+        ? await (receiptTimings.get(receipt) ??
+            Promise.resolve<VolumeTimingObservation>({
+              status: 'unavailable',
+              reason: 'timestamp capture was not requested for this frame',
+            }))
+        : undefined;
       return ok(
         Object.freeze({
           frameId: receipt.frameId,
           deviceGeneration: receipt.deviceGeneration,
           include: Object.freeze([...request.include]),
+          ...(targetReadbacks === undefined
+            ? {}
+            : { targetReadbacks: Object.freeze(targetReadbacks.value) }),
+          ...(volumeTimings === undefined ? {} : { volumeTimings }),
         }),
       );
     },
@@ -3395,6 +3953,8 @@ async function makeWebGPURenderer(
     dispose(): RenderResult<void, RenderError> {
       if (disposed) return ok(undefined);
       disposed = true;
+      currentReceipts.clear();
+      renderTargetHost.dispose();
       const cleanupFailures: RendererOperationCause[] = [];
       for (const world of attachedWorlds) {
         try {
@@ -3575,6 +4135,8 @@ async function makeWebGPURenderer(
         // a layout from the replacement device.
         emptyPostProcessBgl = null;
         internals.context.unconfigure();
+        retireGpuPassTimingSession();
+        attachGpuPassTimingSession(internals, undefined);
 
         // Step (b) / B-2 / B-AC-02: shed device-bound RenderSystem state minted by
         // the lost device — the render-graph pendingDestroy queue (its PooledTextures
@@ -3595,7 +4157,7 @@ async function makeWebGPURenderer(
         let device: RhiDevice;
         try {
           const deviceResult = await adapterResult.value.requestDevice(
-            deviceOptionsForAdapter(adapterResult.value),
+            deviceOptionsForAdapter(adapterResult.value, internals.options),
           );
           if (!deviceResult.ok) {
             return err(new RecoverError('recover-device-unavailable'));
@@ -3721,8 +4283,12 @@ async function makeWebGPURenderer(
         const previousDeviceScope = activeDeviceScope;
         activeDeviceScope = recoveryScope;
         pipelineState = candidatePipelineState;
+        currentReceipts.clear();
         gpuStore.bindDeviceScope(activeDeviceScope);
+        renderTargetHost.recover();
         previousDeviceScope.retire();
+        establishGpuPassTimingSession();
+        attachGpuPassTimingSession(internals, gpuPassTimingSession);
 
         // Re-evaluate feature capability gates against the replacement device.
         // Feature recovery is isolated from renderer recovery: a feature that is
@@ -3808,7 +4374,7 @@ export function exposeRenderer(renderer: RendererHostImplementation): Renderer {
   });
 
   return {
-    attach: (world) => {
+    attach: (world: World) => {
       const result = renderer.attach(world);
       return result.ok
         ? result
@@ -3819,6 +4385,12 @@ export function exposeRenderer(renderer: RendererHostImplementation): Renderer {
             }),
           );
     },
+    createRenderTarget: (descriptor) => renderer.createRenderTarget(descriptor),
+    resizeRenderTarget: (target, descriptor) => renderer.resizeRenderTarget(target, descriptor),
+    createRenderTargetTextureSource: (target, options) =>
+      renderer.createRenderTargetTextureSource(target, options),
+    requestTargetReadback: (target, request) => renderer.requestTargetReadback(target, request),
+    destroyRenderTarget: (target) => renderer.destroyRenderTarget(target),
     setProfile: (profile) => {
       if (!isRendererStateOperational(currentState)) {
         return err(
@@ -3831,7 +4403,7 @@ export function exposeRenderer(renderer: RendererHostImplementation): Renderer {
       return renderer.setProfile(profile);
     },
     state: () => currentState,
-    draw: (request) => {
+    draw: (request: RenderFrameInput) => {
       const result = renderer.drawFrame(request);
       if (!result.ok) return err(drawError(result.error));
       emit(
@@ -3844,8 +4416,9 @@ export function exposeRenderer(renderer: RendererHostImplementation): Renderer {
       return ok(result.value);
     },
     inspect: () => renderer.inspect(),
-    observe: (receipt, request) => renderer.observe(receipt, request),
-    subscribe: (listener) => {
+    observe: (receipt: FrameReceipt, request: FrameObservationRequest) =>
+      renderer.observe(receipt, request),
+    subscribe: (listener: RendererEventListener) => {
       if (disposed) return () => undefined;
       listeners.add(listener);
       return () => listeners.delete(listener);
@@ -3959,12 +4532,11 @@ function structuredRendererCause(cause: unknown, operation: string): RendererOpe
 const RENDER_PROFILE_KEYS = new Set([
   'pipelineId',
   'lightCount',
-  'lighting',
+  'renderPath',
   'shadows',
   'pbr',
   'ibl',
   'ssao',
-  'fallback',
   'postStages',
 ]);
 
@@ -3978,15 +4550,12 @@ function validateRenderProfile(profile: RenderProfile): string | undefined {
   if (!STANDARD_LIGHT_COUNTS.some((count) => count === profile.lightCount)) {
     return 'RenderProfile.lightCount must be 1, 32, or 256';
   }
-  if (profile.lighting !== 'direct' && profile.lighting !== 'clustered') {
-    return "RenderProfile.lighting must be 'direct' or 'clustered'";
+  if (profile.renderPath !== 'forward' && profile.renderPath !== 'deferred') {
+    return "RenderProfile.renderPath must be 'forward' or 'deferred'";
   }
   if (profile.shadows !== 'off' && profile.shadows !== 'hard' && profile.shadows !== 'filtered') {
     return "RenderProfile.shadows must be 'off', 'hard', or 'filtered'";
   }
-  if (profile.fallback !== 'native' && profile.fallback !== 'cpu-webgl2') {
-    return "RenderProfile.fallback must be 'native' or 'cpu-webgl2'";
-  }
   for (const field of ['pbr', 'ibl', 'ssao'] as const) {
     if (typeof profile[field] !== 'boolean') return `RenderProfile.${field} must be boolean`;
   }
@@ -4262,23 +4831,20 @@ function makeRhiNotAvailableError(): RhiError {
 // inverseViewProj mat4x4<f32> (64 B) appended at tail (offset 176, align 16,
 // total 176 + 64 = 240 B). Field added to common.wgsl View struct; host
 // writes the tail via queue.writeBuffer in render-system-record.
-// feat-20260613-csm-cascaded-shadow-maps M4 / w16: extended to 592 B.
+// feat-20260613-csm-cascaded-shadow-maps M4 / w16: extended to 960 B.
 // lightSpaceMatrix replaced by lightViewProj_A at offset 112; inverseViewProj
 // stays at offset 176; lightViewProj_B..D + splitPlanes[4] + cascadeCount +
-// cascadeBlend + tail padding appended after inverseViewProj. Total 148 f32
-// = 592 B, fixed independent of cascadeCount (AC-08).
-// feat-20260621-merge-directionallightshadow-into-directionallight M3 / m3-t3:
-// depthBias / normalBias / pcfKernelSize from the merged DirectionalLight
-// append at the formerly-free tail pad (bytes 504/508/512, floats 126/127/128).
-// VIEW_UBO_BYTES stays 592 (the host tail pad shrinks 88 B -> 64 B); the WGSL
-// View struct in common.wgsl carries the matching 3 f32 (SSOT comment synced).
+// cascadeBlend + tail padding appended after inverseViewProj. The directional
+// payload is 240 f32 = 960 B, placed in a 1024 B dynamic-uniform slot (AC-08).
+// M1 reserves [126]/[127] for depthBias/normalBias and [128..131] for the
+// directional filter carrier; the Spot matrix tail begins at float 132.
 // feat-20260625-spot-light-shadow-mapping w25 (scope-amend webkit-fallback):
-// grew 592 -> 784. The per-spot fragment-read perspective lightViewProj matrices
+// grew from the directional 960 B payload to the 1024 B slot. The per-spot fragment-read perspective lightViewProj matrices
 // (`array<mat4x4<f32>, 4>` = 256 B) fold from a standalone @group(0) binding 9
 // uniform buffer into the View UBO tail (bytes 528..784, 16 B-aligned after
-// pcfKernelSize at byte 512). This removes the 12th fragment-stage uniform
+// the directional filter carrier at bytes 512..528). This removes the 12th fragment-stage uniform
 // buffer that overflowed GLES 3.0's max_uniform_buffers_per_shader_stage = 11 on
-// the WebGL2 fallback path. render-system-record writes the full 196 f32 payload;
+// the WebGL2 fallback path. render-system-record writes the full 240 f32 payload;
 // common.wgsl `View.spotLightViewProj` is the matching SSOT.
 const VIEW_UBO_BYTES = VIEW_UNIFORM_BUFFER_SIZE;
 
@@ -4767,7 +5333,14 @@ async function prepareMaterialShaders(
     if (!capCheck.ok) throw capCheck.error;
     storageBufferCapable = !webgl2Downlevel && capCheck.value;
   }
-
+  // The shared PBR view/material ABI consumes the WebGPU minimum of 16
+  // fragment sampled textures. The authored SpotLight projector is the
+  // optional 17th texture; select its shader/BGL pair from the same limit so
+  // low-limit adapters keep analytic lighting instead of failing layout
+  // creation at boot.
+  const projectorAvailable =
+    (rhiDevice.limits.maxSampledTexturesPerShaderStage ?? 0) >=
+    STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
   // ── Step 1: manifest load ─────────────────────────────────────────────────
   const registry = getShader();
   const loaded = await registry.loadManifest();
@@ -4776,12 +5349,11 @@ async function prepareMaterialShaders(
   }
 
   // ── Step 1b: material shader variant resolution + registration ───────────
-  // feat-20260609-hdrp-cluster-fragment-ggx M1 / w7: dual-axis variant
-  // resolution. At boot time isHdrpActive is always false (URP default),
-  // so CLUSTER_FORWARD_AVAILABLE=false variant is selected. HDRP variant
-  // (CLUSTER_FORWARD_AVAILABLE=true) is resolved later when
-  // clustered Standard profile activation selects the clustered variant.
-  const isHdrpActive = false; // M4: wire to actual renderSystem.frameState.isHdrpActive
+  // Install the non-clustered artifact as the eager registry seed. This value
+  // only makes the pre-frame registry usable; record-time Standard topology is
+  // derived from the frame's prepared `standardLighting.kind` and never reads
+  // this boot seed as an active lighting decision.
+  const bootClusterAxis = standardBootClusterAxis();
   for (const msEntry of registry.materialShaderManifestEntries()) {
     // bug-20260610: skip synthetic non-material engine entries piggy-backing
     // on the materialShaders channel for variant surfacing (shadow_caster).
@@ -4792,6 +5364,11 @@ async function prepareMaterialShaders(
     const variantDefines: Record<string, boolean> = {
       STORAGE_BUFFER_AVAILABLE: storageBufferCapable,
     };
+    if (msEntry.variants.some((v) => 'DIRECTIONAL_PCSS_AVAILABLE' in v.defines)) {
+      variantDefines.DIRECTIONAL_PCSS_AVAILABLE = directionalPcssCapable(
+        rhiDevice.caps.backendKind,
+      );
+    }
     // User material manifests may declare WEBGL2_COMPAT alongside the shared
     // mesh-storage axis. The fallback backend must select that authored
     // branch at boot; otherwise it asks for the impossible bare
@@ -4803,11 +5380,17 @@ async function prepareMaterialShaders(
     // the axis (has a variant with this key), preserving backward compat for
     // entries without the pragma.
     if (msEntry.variants.some((v) => 'CLUSTER_FORWARD_AVAILABLE' in v.defines)) {
-      variantDefines.CLUSTER_FORWARD_AVAILABLE = isHdrpActive;
+      variantDefines.CLUSTER_FORWARD_AVAILABLE = bootClusterAxis;
     }
     if (msEntry.variants.some((v) => 'VERTEX_COLOR_AVAILABLE' in v.defines)) {
       variantDefines.VERTEX_COLOR_AVAILABLE = false;
     }
+    if (
+      msEntry.identifier === 'forgeax::default-standard-pbr' &&
+      msEntry.variants.some((v) => 'PROJECTOR_AVAILABLE' in v.defines)
+    ) {
+      variantDefines.PROJECTOR_AVAILABLE = projectorAvailable;
+    }
     if (
       msEntry.identifier === 'forgeax::default-standard-pbr' &&
       msEntry.variants.some((v) => 'TRANSMISSION_AVAILABLE' in v.defines)
@@ -4942,6 +5525,11 @@ async function buildReadyWebGPU(
    * frame while the shared async shader adapter is still warming up.
    */
   requiredMaterialShaders: readonly string[],
+  /** Fullscreen feature modules compiled before the first synchronous frame. */
+  requiredFullscreenPostProcesses: readonly {
+    readonly identity: string;
+    readonly source: string;
+  }[],
   // feat-20260608-mesh-ssbo-dynamic-grow-l1-lift-1024-entity-cap M2 /
   // T-M2-05 + M3 / T-M3-04: surface for setting `internals.growMeshSsbo`
   // + `internals.meshSsboState` so the record stage's
@@ -4970,7 +5558,11 @@ async function buildReadyWebGPU(
   // `getMaterialShaderPipeline` lookup hits a live PSO instead of falling
   // into a 1-frame async-compile skip-draw window. Idempotent: caller
   // guards against re-seeding when a key already exists.
-  seedMaterialShaderPipelineCache: (key: string, pso: RenderPipeline) => void,
+  seedMaterialShaderPipelineCache: (
+    key: string,
+    pso: RenderPipeline,
+    group2Contract: PipelineGroup2Contract,
+  ) => void,
   // feat-20260621 M-A3 (D-5): register the engine built-in tonemap onto the
   // unified post-process channel once the tonemap manifest entry's composed
   // WGSL is resolved. Invoked with the tonemap WGSL source string; the outer
@@ -4980,10 +5572,14 @@ async function buildReadyWebGPU(
   // tonemap source resolves inside this async function (after the manifest-load
   // await), by which point the synchronous `renderSystem` const is defined.
   registerBuiltinTonemap: (source: string) => void,
+  /** Register the special FXAA pass' final-output policy params UBO. */
+  registerBuiltinFxaa: (source: string) => void,
   registerBuiltinTemporalPostProcesses: (entries: {
     readonly motionBlur?: string;
     readonly taaResolve?: string;
   }) => void,
+  /** Install manifest-owned volume utility sources only after all three modules compile. */
+  setVolumetricFogShaderSources: (sources: VolumetricFogShaderSources) => void,
 ): Promise<PipelineState> {
   // bug-20260610: WebGL2 fallback path — read storage-buffer capability up
   // front so both Step 2 (shader-module compile, where we patch engine
@@ -5001,7 +5597,9 @@ async function buildReadyWebGPU(
     const capCheck = assertStorageBufferCap(capValue);
     storageBufferCapable = capCheck.ok ? !webgl2Downlevel && capCheck.value : !webgl2Downlevel;
   }
-
+  const projectorAvailable =
+    (rhiDevice.limits.maxSampledTexturesPerShaderStage ?? 0) >=
+    STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
   // bug-20260612: choose swap-chain storage / view formats by backend.
   // Channel 2 (native WebGPU) follows navigator.gpu.getPreferredCanvasFormat();
   // Channel 3 (wgpu-wasm GLES, storageBufferCapable=false) hard-codes
@@ -5072,6 +5670,10 @@ async function buildReadyWebGPU(
   let unlitModule: ShaderModule | null = null;
   let spriteModule: ShaderModule | null = null;
   let spriteLitModule: ShaderModule | null = null;
+  let pbrGroup2Contract: PipelineGroup2Contract | undefined;
+  let unlitGroup2Contract: PipelineGroup2Contract | undefined;
+  let spriteGroup2Contract: PipelineGroup2Contract | undefined;
+  let spriteLitGroup2Contract: PipelineGroup2Contract | undefined;
   let fxaaModule: ShaderModule | null = null;
   let skyboxModule: ShaderModule | null = null;
   let bloomBrightModule: ShaderModule | null = null;
@@ -5290,20 +5892,25 @@ async function buildReadyWebGPU(
       // CLUSTER_FORWARD_AVAILABLE in PR #344) only emits compound keys like
       // `CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=false`, so
       // findVariantByKey('STORAGE_BUFFER_AVAILABLE=false') silently misses.
-      // The fallback path forces isHdrpActive=false (Step 1b above), so the
-      // matching PBR variant is the (CFA=false, SBA=false) one — pick by
-      // defines fields and prefer CLUSTER_FORWARD_AVAILABLE=false when present;
-      // otherwise each STORAGE_BUFFER_AVAILABLE=false variant.
+      // The eager registry seed is the non-clustered boot artifact (the active
+      // frame topology is not known here). Pick by defines fields and prefer
+      // the boot cluster axis when present; otherwise use the storage axis.
       const idToVariantWgsl = new Map<string, string>();
       for (const ms of registry.materialShaderManifestEntries()) {
         const exact = ms.variants.find(
-          (v) =>
-            v.defines.STORAGE_BUFFER_AVAILABLE === false &&
-            (!('CLUSTER_FORWARD_AVAILABLE' in v.defines) ||
-              v.defines.CLUSTER_FORWARD_AVAILABLE === false) &&
-            (!('VERTEX_COLOR_AVAILABLE' in v.defines) ||
-              v.defines.VERTEX_COLOR_AVAILABLE === false) &&
-            (!('SKINNING_DISABLED' in v.defines) || v.defines.SKINNING_DISABLED === true),
+          (variant) =>
+            variant.defines.STORAGE_BUFFER_AVAILABLE === false &&
+            (!('CLUSTER_FORWARD_AVAILABLE' in variant.defines) ||
+              variant.defines.CLUSTER_FORWARD_AVAILABLE === standardBootClusterAxis()) &&
+            (!('VERTEX_COLOR_AVAILABLE' in variant.defines) ||
+              variant.defines.VERTEX_COLOR_AVAILABLE === false) &&
+            (!('DIRECTIONAL_PCSS_AVAILABLE' in variant.defines) ||
+              variant.defines.DIRECTIONAL_PCSS_AVAILABLE ===
+                directionalPcssCapable(rhiDevice.caps.backendKind)) &&
+            (!('PROJECTOR_AVAILABLE' in variant.defines) ||
+              variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) &&
+            (!('SKINNING_DISABLED' in variant.defines) ||
+              variant.defines.SKINNING_DISABLED === true),
         );
         const v = exact === undefined ? undefined : findVariantByKey(ms, exact.definesKey);
         if (v !== undefined) {
@@ -5332,8 +5939,8 @@ async function buildReadyWebGPU(
       }
     }
     // The flat `registry.entries()` map carries the canonical composed source,
-    // while the boot layout is the URP/device-capability contract. Select the
-    // matching runtime variant for every eager engine module, including native
+    // while this eager module uses the boot layout contract. Select the
+    // matching boot variant for every eager engine module, including native
     // WebGPU. Without this step the canonical PBR/Unlit source declares the
     // optional COLOR_0 vertex input while the boot SPEC_CONST layouts for
     // ordinary meshes do not provide location 13.
@@ -5343,11 +5950,16 @@ async function buildReadyWebGPU(
         (variant) =>
           variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable &&
           (!('CLUSTER_FORWARD_AVAILABLE' in variant.defines) ||
-            variant.defines.CLUSTER_FORWARD_AVAILABLE === false) &&
+            variant.defines.CLUSTER_FORWARD_AVAILABLE === standardBootClusterAxis()) &&
           (!('VERTEX_COLOR_AVAILABLE' in variant.defines) ||
             variant.defines.VERTEX_COLOR_AVAILABLE === false) &&
+          (!('PROJECTOR_AVAILABLE' in variant.defines) ||
+            variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) &&
           (!('SKINNING_DISABLED' in variant.defines) ||
             variant.defines.SKINNING_DISABLED === true) &&
+          (!('DIRECTIONAL_PCSS_AVAILABLE' in variant.defines) ||
+            variant.defines.DIRECTIONAL_PCSS_AVAILABLE ===
+              directionalPcssCapable(rhiDevice.caps.backendKind)) &&
           (!('TRANSMISSION_AVAILABLE' in variant.defines) ||
             variant.defines.TRANSMISSION_AVAILABLE === false),
       );
@@ -5480,6 +6092,101 @@ async function buildReadyWebGPU(
       seedShaderModule(label, shaderResult.value);
     }
 
+    // A boot-installed fullscreen feature has the same synchronous record
+    // contract as the built-in output transform: its module must be seeded
+    // before the caller can drive a tight frame loop. Otherwise the typed
+    // graph's first post-effect admission is correctly held back, but a
+    // synchronous consumer would only see the base image until it yields.
+    // Late-installed features use the matching registration path below.
+    for (const postProcess of requiredFullscreenPostProcesses) {
+      const label = postProcessShaderModuleLabel(postProcess.identity, postProcess.source);
+      const shaderResult = await runShimStep(
+        () =>
+          asyncCreateShaderModule
+            ? asyncCreateShaderModule(rhiDevice, { code: postProcess.source, label })
+            : invokeDeviceCreateShaderModule(rhiDevice, { code: postProcess.source, label }),
+        'shader-compile-failed',
+        `declared fullscreen render feature '${postProcess.identity}' compiled`,
+        `inspect the composed WGSL for '${postProcess.identity}' and check device.features`,
+      );
+      if (!shaderResult.ok) throw shaderResult.error;
+      seedShaderModule(label, shaderResult.value);
+    }
+
+    // The volume graph is authored from ECS state and therefore cannot be
+    // compiled while the static material manifest is assembled. Its pass
+    // encoder nevertheless uses the same shared lazy shader adapter, so the
+    // four utility modules must be prewarmed before the first synchronous
+    // draw. The sources come from the shader manifest (the package-owned WGSL
+    // files are the sole source of truth); compile all four first and only
+    // then publish the labels and source bundle. A partial bundle would let a
+    // later frame mix generations after a device recovery.
+    if (rhiDevice.caps.compute && rhiDevice.caps.storageTexture) {
+      const volumeSources = [
+        ['inject', 'volume_inject', (source: string) => source.includes('fn volume_inject(')],
+        ['temporal', 'volume_temporal', (source: string) => source.includes('fn volume_temporal(')],
+        [
+          'integrate',
+          'volume_integrate',
+          (source: string) => source.includes('fn volume_integrate('),
+        ],
+        ['composite', 'volume_composite', (source: string) => source.includes('fn volume_fs(')],
+      ] as const;
+      const resolved = volumeSources.map(([stage, label, matches]) => {
+        const entry = manifestEntries.find((candidate) => matches(candidate.wgsl));
+        return { stage, label, entry };
+      });
+      // Volumetric fog is an optional graph feature. Minimal hosts/tests may
+      // intentionally ship only material/post-process entries; keep those
+      // renderers bootable while still rejecting a partially declared volume
+      // bundle (which would otherwise fail later as a lazy pending pipeline).
+      const present = resolved.filter((candidate) => candidate.entry !== undefined).length;
+      if (present === 0) {
+        // No volume manifest entries: leave the source/module bundle unset and
+        // let the topology capability gate keep volume work disabled.
+      } else {
+        const missing = resolved.find((candidate) => candidate.entry === undefined);
+        if (missing !== undefined) {
+          throw new RhiError({
+            code: 'shader-compile-failed',
+            expected: 'shader manifest contains all four volumetric fog utility entries',
+            hint: `add the package-owned WGSL entry for '${missing.label}' to the engine shader manifest`,
+          });
+        }
+        const compiled = [] as Array<{
+          readonly stage: (typeof volumeSources)[number][0];
+          readonly label: string;
+          readonly source: string;
+          readonly module: ShaderModule;
+        }>;
+        for (const { stage, label, entry } of resolved) {
+          // `missing` above proves the narrowing for this loop; keep the guard
+          // explicit so a future refactor cannot publish an undefined source.
+          if (entry === undefined) throw new Error(`missing volumetric shader ${label}`);
+          const shaderResult = await runShimStep(
+            () =>
+              asyncCreateShaderModule
+                ? asyncCreateShaderModule(rhiDevice, { code: entry.wgsl, label })
+                : invokeDeviceCreateShaderModule(rhiDevice, { code: entry.wgsl, label }),
+            'shader-compile-failed',
+            `volumetric fog shader module '${label}' compiled`,
+            `inspect manifest WGSL for '${label}' and check device.features`,
+          );
+          if (!shaderResult.ok) throw shaderResult.error;
+          compiled.push({ stage, label, source: entry.wgsl, module: shaderResult.value });
+        }
+        for (const { label, module } of compiled) seedShaderModule(label, module);
+        setVolumetricFogShaderSources({
+          inject: compiled.find((candidate) => candidate.stage === 'inject')?.source as string,
+          temporal: compiled.find((candidate) => candidate.stage === 'temporal')?.source as string,
+          integrate: compiled.find((candidate) => candidate.stage === 'integrate')
+            ?.source as string,
+          composite: compiled.find((candidate) => candidate.stage === 'composite')
+            ?.source as string,
+        });
+      }
+    }
+
     const pbrShaderResult = await runShimStep(
       () =>
         asyncCreateShaderModule
@@ -5491,6 +6198,7 @@ async function buildReadyWebGPU(
     );
     if (!pbrShaderResult.ok) throw pbrShaderResult.error;
     pbrModule = pbrShaderResult.value;
+    pbrGroup2Contract = resolvePipelineGroup2Contract(pbrEntry.wgsl);
     // feat-20260629-multi-uv-set-support: a real extra-UV mesh creates a
     // layout-specific material PSO after the boot-time standard-layout PSO
     // has been pre-warmed. Seed the shared shader-module adapter under the
@@ -5511,7 +6219,12 @@ async function buildReadyWebGPU(
       (rhiDevice.limits.maxSampledTexturesPerShaderStage ?? 0) >=
       STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
     const transmissionVariants = transmissionCapable
-      ? selectStandardPbrTransmissionPrewarmVariants(pbrManifestEntry, storageBufferCapable)
+      ? selectStandardPbrTransmissionPrewarmVariants(
+          pbrManifestEntry,
+          storageBufferCapable,
+          directionalPcssCapable(rhiDevice.caps.backendKind),
+          projectorAvailable,
+        )
       : [];
 
     // HDRP uses the canonical all-true variant key (`''`) and the lazy
@@ -5549,6 +6262,8 @@ async function buildReadyWebGPU(
       pbrManifestEntry,
       storageBufferCapable,
       transmissionCapable,
+      directionalPcssCapable(rhiDevice.caps.backendKind),
+      projectorAvailable,
     )) {
       const moduleLabel = `module-forgeax::default-standard-pbr#${hdrpVariant.definesKey}`;
       let hdrpModule = prewarmedHdrpModules.get(hdrpVariant.composedWgsl);
@@ -5575,6 +6290,43 @@ async function buildReadyWebGPU(
       seedShaderModule(moduleLabel, hdrpModule);
     }
 
+    // Skin geometry uses the same lazy material-pipeline adapter as standard
+    // PBR, but its dedicated module was previously never warmed. A record
+    // frame therefore received a pending module result, skipped the skin PSO,
+    // and silently emitted no draw. Compile and seed every active-capability
+    // skin variant so both URP and HDRP resolve their exact PSO consumer on
+    // frame one (including the geometry-owned COLOR_0=false variant).
+    const pbrSkinManifestEntry = [...registry.materialShaderManifestEntries()].find(
+      (entry) => entry.identifier === SKIN_MATERIAL_SHADER_ID,
+    );
+    const activeSkinVariants = selectSkinPrewarmVariants(
+      pbrSkinManifestEntry,
+      storageBufferCapable,
+    );
+    for (const skinVariant of activeSkinVariants) {
+      const moduleLabel = `module-${SKIN_MATERIAL_SHADER_ID}#${skinVariant.definesKey}`;
+      const skinModuleResult = await runShimStep(
+        () =>
+          asyncCreateShaderModule
+            ? asyncCreateShaderModule(rhiDevice, {
+                code: skinVariant.composedWgsl,
+                label: moduleLabel,
+              })
+            : invokeDeviceCreateShaderModule(rhiDevice, {
+                code: skinVariant.composedWgsl,
+                label: moduleLabel,
+              }),
+        'shader-compile-failed',
+        `pbr-skin variant ${skinVariant.definesKey || '<default>'} compiled`,
+        'inspect the selected pbr-skin storage/cluster/color variant and device.features',
+      );
+      if (!skinModuleResult.ok) throw skinModuleResult.error;
+      seedShaderModule(moduleLabel, skinModuleResult.value);
+      if (skinVariant.definesKey === '') {
+        seedShaderModule(`module-${SKIN_MATERIAL_SHADER_ID}`, skinModuleResult.value);
+      }
+    }
+
     // M2-07-c: Materials.standard with an explicit renderState reaches the
     // lazy material pipeline path, whose module label includes the requested
     // variant set. Reuse the boot-compiled PBR module only for manifest
@@ -5599,6 +6351,7 @@ async function buildReadyWebGPU(
     );
     if (!unlitShaderResult.ok) throw unlitShaderResult.error;
     unlitModule = unlitShaderResult.value;
+    unlitGroup2Contract = resolvePipelineGroup2Contract(unlitEntry.wgsl);
     // Seed the shared lazy adapter with the eagerly compiled module so
     // prepared color-only PSOs build synchronously on their first frame.
     seedShaderModule('unlit', unlitModule);
@@ -5745,7 +6498,8 @@ async function buildReadyWebGPU(
     // frames (e.g. the hello-tonemap dawn smoke) would stall on a black frame
     // forever. Mirror the shadow_caster prewarm: await-compile the tonemap module
     // here and `seedShaderModule` it under the exact label
-    // `buildPostProcessPipeline` requests (`post-process-${id}-module`), so the
+    // `buildPostProcessPipeline` requests the content-addressed module label,
+    // so the
     // first `getPostProcessPipeline(STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, …)` hits the module cache
     // synchronously and builds the pipeline on frame 1.
     const tonemapPrewarm = await runShimStep(
@@ -5753,11 +6507,17 @@ async function buildReadyWebGPU(
         asyncCreateShaderModule
           ? asyncCreateShaderModule(rhiDevice, {
               code: tonemapEntry.wgsl,
-              label: `post-process-${STANDARD_OUTPUT_TRANSFORM_FEATURE_ID}-module`,
+              label: postProcessShaderModuleLabel(
+                STANDARD_OUTPUT_TRANSFORM_FEATURE_ID,
+                tonemapEntry.wgsl,
+              ),
             })
           : invokeDeviceCreateShaderModule(rhiDevice, {
               code: tonemapEntry.wgsl,
-              label: `post-process-${STANDARD_OUTPUT_TRANSFORM_FEATURE_ID}-module`,
+              label: postProcessShaderModuleLabel(
+                STANDARD_OUTPUT_TRANSFORM_FEATURE_ID,
+                tonemapEntry.wgsl,
+              ),
             }),
       'shader-compile-failed',
       'tonemap shader module compiled (unified post-process prewarm)',
@@ -5765,7 +6525,7 @@ async function buildReadyWebGPU(
     );
     if (!tonemapPrewarm.ok) throw tonemapPrewarm.error;
     seedShaderModule(
-      `post-process-${STANDARD_OUTPUT_TRANSFORM_FEATURE_ID}-module`,
+      postProcessShaderModuleLabel(STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, tonemapEntry.wgsl),
       tonemapPrewarm.value,
     );
     registerBuiltinTonemap(tonemapEntry.wgsl);
@@ -5782,18 +6542,18 @@ async function buildReadyWebGPU(
           asyncCreateShaderModule
             ? asyncCreateShaderModule(rhiDevice, {
                 code: entry.wgsl,
-                label: `post-process-${id}-module`,
+                label: postProcessShaderModuleLabel(id, entry.wgsl),
               })
             : invokeDeviceCreateShaderModule(rhiDevice, {
                 code: entry.wgsl,
-                label: `post-process-${id}-module`,
+                label: postProcessShaderModuleLabel(id, entry.wgsl),
               }),
         'shader-compile-failed',
         `${id} shader module compiled (unified post-process prewarm)`,
         `inspect manifest ${id} entry composed wgsl; check device.features`,
       );
       if (!prewarm.ok) throw prewarm.error;
-      seedShaderModule(`post-process-${id}-module`, prewarm.value);
+      seedShaderModule(postProcessShaderModuleLabel(id, entry.wgsl), prewarm.value);
     };
     await prewarmTemporal(motionBlurEntry, 'forgeax.motion-blur');
     await prewarmTemporal(taaResolveEntry, 'forgeax.taa-resolve');
@@ -5822,6 +6582,7 @@ async function buildReadyWebGPU(
       );
       if (!spriteShaderResult.ok) throw spriteShaderResult.error;
       spriteModule = spriteShaderResult.value;
+      spriteGroup2Contract = resolvePipelineGroup2Contract(spriteEntry.wgsl);
       // feat-20260625-refactor-sprite-as-transparent-mesh CI-fix: seed the
       // lazy adapter cache under the same label (`module-forgeax::sprite`)
       // that `getMaterialShaderPipeline -> buildAndCachePipeline ->
@@ -5892,7 +6653,44 @@ async function buildReadyWebGPU(
       );
       if (!spriteLitShaderResult.ok) throw spriteLitShaderResult.error;
       spriteLitModule = spriteLitShaderResult.value;
+      spriteLitGroup2Contract = resolvePipelineGroup2Contract(spriteLitEntryConst.wgsl);
       seedShaderModule('module-forgeax::sprite-lit', spriteLitShaderResult.value);
+      // Sprite-lit participates in the same Standard capability split as
+      // PBR. Record requests the explicit URP/HDRP variant per frame, so seed
+      // every device-matched artifact during readiness; a tight dawn/browser
+      // frame loop cannot yield to the async module adapter between draws.
+      const spriteLitManifestEntry = Array.from(registry.materialShaderManifestEntries()).find(
+        (entry) => entry.identifier === 'forgeax::sprite-lit',
+      );
+      const prewarmedSpriteLitModules = new Map<string, ShaderModule>([
+        [spriteLitEntryConst.wgsl, spriteLitShaderResult.value],
+      ]);
+      for (const variant of spriteLitManifestEntry?.variants ?? []) {
+        if (variant.defines.STORAGE_BUFFER_AVAILABLE !== storageBufferCapable) continue;
+        const moduleLabel = `module-forgeax::sprite-lit#${variant.definesKey}`;
+        let variantModule = prewarmedSpriteLitModules.get(variant.composedWgsl);
+        if (variantModule === undefined) {
+          const variantResult = await runShimStep(
+            () =>
+              asyncCreateShaderModule
+                ? asyncCreateShaderModule(rhiDevice, {
+                    code: variant.composedWgsl,
+                    label: moduleLabel,
+                  })
+                : invokeDeviceCreateShaderModule(rhiDevice, {
+                    code: variant.composedWgsl,
+                    label: moduleLabel,
+                  }),
+            'shader-compile-failed',
+            `sprite-lit variant ${variant.definesKey || '<default>'} compiled`,
+            'inspect the selected sprite-lit Standard capability variant and device.features',
+          );
+          if (!variantResult.ok) throw variantResult.error;
+          variantModule = variantResult.value;
+          prewarmedSpriteLitModules.set(variant.composedWgsl, variantModule);
+        }
+        seedShaderModule(moduleLabel, variantModule);
+      }
     }
 
     // feat-20260528-fxaa-post-processing: fxaa shader module is optional
@@ -5915,6 +6713,7 @@ async function buildReadyWebGPU(
       );
       if (!fxaaShaderResult.ok) throw fxaaShaderResult.error;
       fxaaModule = fxaaShaderResult.value;
+      registerBuiltinFxaa(fxaaEntry.wgsl);
     }
 
     // feat-20260531-skybox-env-background M3 / w15: skybox shader module.
@@ -6042,7 +6841,13 @@ async function buildReadyWebGPU(
   // buildReadyWebGPU (above) so Step 2 (variant patch) and this layout
   // build read the same value.
   const pbrLayouts = runShimSyncStep(
-    () => ok(buildPbrPipelineLayouts(rhiDevice, { storageBuffer: storageBufferCapable })),
+    () =>
+      ok(
+        buildPbrPipelineLayouts(rhiDevice, {
+          storageBuffer: storageBufferCapable,
+          projectorAvailable,
+        }),
+      ),
     'webgpu-runtime-error',
     'buildPbrPipelineLayouts succeeded',
     'check device.limits.maxBindingsPerBindGroup (need >=14) and maxBindGroupsPerPipelineLayout',
@@ -6061,15 +6866,14 @@ async function buildReadyWebGPU(
   // BGL at group(2) so an HDRP-variant PSO validates against the 7-slot
   // group(2) bindGroup that the record stage sets via hdrpClusterBindGroup.
   // Stays null when createBindGroupLayout / createPipelineLayout fails;
-  // selectPipelineLayoutForVariant gracefully falls back to pbrPipelineLayout
-  // (URP layout) so the manifest entry's URP variant WGSL still builds a
-  // valid PSO instead of hard-disabling the entire HDRP-variant build path.
+  // selectPipelineLayoutForVariant propagates that null so the clustered
+  // material remains unavailable instead of binding an incompatible layout.
   let hdrpPbrPipelineLayoutHandle: PipelineLayout | null = null;
   // The cluster layout is storage-buffer backed. On the WebGL2/fallback
   // capability tier its uniform-buffer projection exceeds the backend's
   // fragment-stage limit, and HDRP is not a valid route there anyway.
   if (storageBufferCapable) {
-    const hdrpUnifiedBglDesc = createHdrpBindGroupLayoutDescriptor(storageBufferCapable);
+    const hdrpUnifiedBglDesc = createHdrpBindGroupLayoutDescriptor();
     const hdrpUnifiedBglRes = rhiDevice.createBindGroupLayout(hdrpUnifiedBglDesc);
     if (hdrpUnifiedBglRes.ok) {
       const hdrpPlRes = rhiDevice.createPipelineLayout({
@@ -6140,23 +6944,26 @@ async function buildReadyWebGPU(
   // bug-20260611-skin-pipeline-layout-mesh-array-bgl-2bindings: boot-time
   // build of the skin-variant PipelineLayout. Mirrors the HDRP block above
   // (D-2 / D-3 in plan-strategy): reuse view / material / instances BGLs
-  // from `pbrLayouts` and only create a 2-entry mesh-array BGL (binding 0
-  // meshes + binding 1 palette) so the `forgeax::pbr-skin` shader's
+  // from `pbrLayouts` and only create a 3-entry mesh-array BGL (binding 0
+  // meshes + binding 1 current palette + binding 2 previous palette) so the
+  // `forgeax::pbr-skin` shader's
   // `@group(2) @binding(1) palette` declaration validates. Stays null when
   // createBindGroupLayout / createPipelineLayout fails;
   // selectPipelineLayoutForVariant returns null in that case (charter P3
   // explicit failure -- no silent fallback to URP layout, mirroring memory
   // anchor `hdrp-active-must-not-fallback-to-urp-pipeline`).
   let pbrSkinPipelineLayoutHandle: PipelineLayout | null = null;
-  // feat-20260611 R2 / M8 / w28: capture the 2-binding skin mesh-array BGL
+  // feat-20260611 R2 / M8 / w28: capture the 3-binding skin mesh-array BGL
   // produced by `buildPbrSkinLayouts` so the record stage can build a BG
-  // matching `pbr-skin-pl` (pipeline-layout BGL[2] is this 2-entry skin
+  // matching `pbr-skin-pl` (pipeline-layout BGL[2] is this 3-entry skin
   // BGL, NOT the 1-entry `pbr-mesh-array-bgl`). The BGL handle stays null
   // when the skin pipeline layout itself failed to build, keeping the skin
   // path explicitly disabled (charter P3 — record-stage falls back to URP
   // path which is correct for non-skin entries; skin entries hit the
   // explicit-failure branch).
   let pbrSkinMeshBindGroupLayoutHandle: BindGroupLayout | null = null;
+  let hdrpSkinPipelineLayoutHandle: PipelineLayout | null = null;
+  let hdrpSkinMeshBindGroupLayoutHandle: BindGroupLayout | null = null;
   {
     const skinLayoutsResult = runShimSyncStep(
       () =>
@@ -6172,6 +6979,29 @@ async function buildReadyWebGPU(
       pbrSkinMeshBindGroupLayoutHandle = skinLayoutsResult.value.meshArrayBgl;
     }
   }
+  // Keep HDRP skin construction on the same storage-capability gate as the
+  // ordinary Standard cluster layout above. There is no uniform-backed
+  // clustered skin route when storage buffers are unavailable.
+  if (storageBufferCapable) {
+    const skinBglResult = rhiDevice.createBindGroupLayout(
+      createHdrpSkinBindGroupLayoutDescriptor(),
+    );
+    if (skinBglResult.ok) {
+      const skinPlResult = rhiDevice.createPipelineLayout({
+        label: 'hdrp-skin-pl',
+        bindGroupLayouts: [
+          viewBglResult.value,
+          materialBglResult.value,
+          skinBglResult.value,
+          instancesBglResult.value,
+        ],
+      });
+      if (skinPlResult.ok) {
+        hdrpSkinPipelineLayoutHandle = skinPlResult.value;
+        hdrpSkinMeshBindGroupLayoutHandle = skinBglResult.value;
+      }
+    }
+  }
 
   // feat-20260612-skin-palette-per-frame-upload M1 / m1-2: skin palette
   // allocator. Replaces the prior 16320 B identity-seeded UBO stub (PR #353,
@@ -7048,17 +7878,20 @@ async function buildReadyWebGPU(
       fragmentEntryPoint?: string;
       layout?: unknown;
       label?: string;
+      group2Contract?: PipelineGroup2Contract;
     }
   >();
   if (unlitModule !== null)
     shaderModuleMap.set('forgeax::default-unlit', {
       vertex: unlitModule,
       fragment: unlitModule,
+      ...(unlitGroup2Contract === undefined ? {} : { group2Contract: unlitGroup2Contract }),
     });
   if (pbrModule !== null)
     shaderModuleMap.set('forgeax::default-standard-pbr', {
       vertex: pbrModule,
       fragment: pbrModule,
+      ...(pbrGroup2Contract === undefined ? {} : { group2Contract: pbrGroup2Contract }),
     });
   if (spriteModule !== null)
     // feat-20260625-refactor-sprite-as-transparent-mesh M3 / w14 (D-7):
@@ -7070,6 +7903,7 @@ async function buildReadyWebGPU(
     shaderModuleMap.set('forgeax::sprite', {
       vertex: spriteModule,
       fragment: spriteModule,
+      ...(spriteGroup2Contract === undefined ? {} : { group2Contract: spriteGroup2Contract }),
     });
   // feat-20260624-sprite-lit-shading-model-pure-2d-lighting M1' / t7:
   // sprite-lit shader registers under canonical `forgeax::sprite-lit` —
@@ -7078,6 +7912,7 @@ async function buildReadyWebGPU(
     shaderModuleMap.set('forgeax::sprite-lit', {
       vertex: spriteLitModule,
       fragment: spriteLitModule,
+      ...(spriteLitGroup2Contract === undefined ? {} : { group2Contract: spriteLitGroup2Contract }),
     });
   // M2-T4: fullscreen-post shader modules (tonemap + skybox) are registered
   // in their respective blocks after pipeline layout creation — layout is
@@ -7179,7 +8014,6 @@ async function buildReadyWebGPU(
     ...runtimeSpecConstTable,
     ...runtimeLinearLdrMaterialSpecTable,
   ];
-
   // Boot-time pre-warm: build SPEC_CONST entries whose shader modules are
   // compiled. Entries referencing a missing module are silently skipped
   // (the empty-manifest path — D-3). Each build failure for an available
@@ -7212,7 +8046,7 @@ async function buildReadyWebGPU(
     // `makeWebGPURenderer` scope) from the prewarmed `pipelineCache` for
     // SPEC_CONST entries whose `variantSet !== undefined`. The URP record
     // path queries `getMaterialShaderPipeline(...)` keyed off
-    // `cacheKeyOf(spec)` with `variantSet=URP_PBR_VARIANT_SET`; both caches
+    // `cacheKeyOf(spec)` with the non-clustered boot variant; both caches
     // generate keys via the same `cacheKeyOf` so the lookup hits the
     // boot-time prewarmed PSO instead of triggering a 1-frame async-compile
     // skip-draw. Seeding only variantSet-bearing entries keeps the
@@ -7222,11 +8056,12 @@ async function buildReadyWebGPU(
     // explicit instead of collapsing into one map (charter P3).
     for (const spec of runtimeSpecConstTable) {
       if (spec.shader.variantSet === undefined) continue;
-      if (shaderModuleMap.get(spec.shader.id) === undefined) continue;
+      const modules = shaderModuleMap.get(spec.shader.id);
+      if (modules === undefined) continue;
       const key = cacheKeyOf(spec);
       const built = pipelineCache.get(key);
-      if (built !== undefined) {
-        seedMaterialShaderPipelineCache(key, built as RenderPipeline);
+      if (built !== undefined && modules.group2Contract !== undefined) {
+        seedMaterialShaderPipelineCache(key, built as RenderPipeline, modules.group2Contract);
       }
     }
 
@@ -7234,11 +8069,12 @@ async function buildReadyWebGPU(
     // swap-chain view target. Seed every material entry, including no-variant
     // unlit, because tonemap=none reaches this cache directly on frame one.
     for (const spec of runtimeLinearLdrMaterialSpecTable) {
-      if (shaderModuleMap.get(spec.shader.id) === undefined) continue;
+      const modules = shaderModuleMap.get(spec.shader.id);
+      if (modules === undefined) continue;
       const key = cacheKeyOf(spec);
       const built = pipelineCache.get(key);
-      if (built !== undefined) {
-        seedMaterialShaderPipelineCache(key, built as RenderPipeline);
+      if (built !== undefined && modules.group2Contract !== undefined) {
+        seedMaterialShaderPipelineCache(key, built as RenderPipeline, modules.group2Contract);
       }
     }
   }
@@ -7446,15 +8282,15 @@ async function buildReadyWebGPU(
 
     // feat-20260528-fxaa-post-processing M2 / w10: FXAA pipeline prebuilt.
     // When the manifest contains the fxaa entry (rgb2luma marker, D-5),
-    // construct the 2-entry BGL (texture + sampler, no UBO per D-2),
+    // construct the 3-entry BGL (texture + sampler + output-policy UBO),
     // pipeline layout, fullscreen render pipeline (vertex = fullscreen
     // triangle from fxaa.wgsl, fragment = FXAA 3.11 algorithm), and
     // linear clamp-to-edge sampler. Mirrors the tonemap pipeline
     // construction pattern directly above.
     if (fxaaModule !== null) {
-      // FXAA BindGroupLayout: 2 entries (texture + sampler, no UBO).
-      // D-2: the fxaa.wgsl fragment stage declares @binding(0) texture_2d<f32>
-      // + @binding(1) sampler.
+      // FXAA BindGroupLayout: 3 entries (texture + sampler + output-policy UBO).
+      // The fxaa.wgsl fragment stage declares @binding(0) texture_2d<f32>,
+      // @binding(1) sampler, and @binding(2) FxaaParams.
       const fxaaBglResult = runShimSyncStep(
         () =>
           rhiDevice.createBindGroupLayout({
@@ -7470,6 +8306,11 @@ async function buildReadyWebGPU(
                 visibility: GPU_SHADER_STAGE_FRAGMENT,
                 sampler: { type: 'filtering' },
               },
+              {
+                binding: 2,
+                visibility: GPU_SHADER_STAGE_FRAGMENT,
+                buffer: { type: 'uniform' },
+              },
             ],
           }),
         'webgpu-runtime-error',
@@ -8505,6 +9346,7 @@ async function buildReadyWebGPU(
   }
 
   const pipelineState: PipelineState = {
+    device: rhiDevice,
     // feat-20260518-pbr-direct-lighting-mvp M5 / w22.10 (AC-06 dual->triple
     // pipeline + D-2 + D-10): three distinct GPU render-pipeline handles
     // backed by 2 distinct shader modules (unlit + pbr) x 2 vertex stride
@@ -8559,7 +9401,7 @@ async function buildReadyWebGPU(
     hdrpClusterMembershipPipeline,
     hdrpClusterMembershipBindGroupLayout,
     // bug-20260611-skin-pipeline-layout: skin-variant PipelineLayout (4-BGL
-    // chain with 2-entry mesh-array BGL substituted for the standard 1-entry
+    // chain with 3-entry mesh-array BGL substituted for the standard 1-entry
     // mesh-array BGL). Built at boot above (see pbrSkinPipelineLayoutHandle);
     // gated on the same unlit/pbr module presence so Camera-only and empty-
     // manifest paths see null. Selected per call by
@@ -8571,13 +9413,17 @@ async function buildReadyWebGPU(
     // Mirror the gating used by `pbrSkinPipelineLayout` -- both fields
     // come from the same `buildPbrSkinLayouts` call so they live or die
     // together. Surfaced on PipelineState so render-system-record can
-    // build a 2-binding BG matching `pbr-skin-pl` (was: 1-binding
+    // build a 3-binding BG matching `pbr-skin-pl` (was: 1-binding
     // `pbr-mesh-bg` + `pbr-mesh-array-bgl`, which the device rejected
     // every frame with `Bind group layout pbr-skin-mesh-array-bgl ... does
     // not match layout pbr-mesh-array-bgl` + Invalid CommandBuffer +
     // queue-submit-failed).
     pbrSkinMeshBindGroupLayout:
       unlitModule !== null && pbrModule !== null ? pbrSkinMeshBindGroupLayoutHandle : null,
+    hdrpSkinPipelineLayout:
+      unlitModule !== null && pbrModule !== null ? hdrpSkinPipelineLayoutHandle : null,
+    hdrpSkinMeshBindGroupLayout:
+      unlitModule !== null && pbrModule !== null ? hdrpSkinMeshBindGroupLayoutHandle : null,
     // feat-20260612-skin-palette-per-frame-upload M1 / m1-2: animator-ready
     // skin-palette allocator (replaces the prior identity-buffer stub).
     // Same gating as `pbrSkinPipelineLayout` -- `null` when the skin
@@ -8589,6 +9435,7 @@ async function buildReadyWebGPU(
     colorAttachmentFormat: swapChainFormats.view,
     surfaceProfile: surfaceViewFormats ? 'dual-view' : 'raw-only',
     viewBindGroupLayout: viewBglResult.value,
+    projectorAvailable,
     materialBindGroupLayout: materialBglResult.value,
     meshBindGroupLayout: meshArrayBglResult.value,
     viewUniformBuffer: viewUboResult.value,