@forgeax/engine-render 0.1.20 → 0.1.23

package/src/assembly/factory.ts

@@ -50,17 +50,21 @@ import type {
   PipelineLayout,
   RenderPipeline,
   Result,
-  RhiAdapter,
   RhiCanvasContext,
   RhiDevice,
   Sampler,
   ShaderModule,
+  TextureView,
 } from '@forgeax/engine-rhi';
 import { err, ok, RhiError, validateDrawArgs } from '@forgeax/engine-rhi';
 import { registerPropagateTransforms } from '@forgeax/engine-scene';
 import {
+  createStandardPbrArtifactReceipt,
   DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
   findVariantByKey,
+  LTC_TABLE_HEIGHT,
+  LTC_TABLE_WIDTH,
+  LTC_TABLES,
   type MaterialShaderEntry,
   type MaterialShaderManifestEntry,
   ShaderCatalog,
@@ -92,12 +96,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';
@@ -127,18 +135,14 @@ import {
   LostListenerRegistry,
   RhiErrorListenerRegistry,
 } from '../lifecycle';
-import {
-  assertStorageBufferCap,
-  LIGHT_ARRAY_HEADER_BYTES,
-  LIGHT_ARRAY_MAX_SLOTS,
-  POINT_LIGHT_STD430_BYTES,
-  SPOT_LIGHT_STD430_BYTES,
-} from '../light-buffer-layout';
+import { assertStorageBufferCap } 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';
@@ -164,7 +168,31 @@ import {
   PipelineSpecError,
 } from '../pipeline-spec';
 import { POINTS_LINES_MATERIAL_SHADER_ID } from '../points-lines/record';
+import type { ExtendedLightingResourceCandidate } from '../prepare/extended-lighting/resources';
+import {
+  COOKIE_MATRIX_BYTES,
+  COOKIE_SLICE_SIZE,
+  deriveExtendedLightingCapability,
+  EXTENDED_LIGHTING_TOPOLOGY,
+  extendedLightingSampledTextureCapacityAvailable,
+  IES_SLICE_HEIGHT,
+  IES_SLICE_WIDTH,
+} from '../prepare/extended-lighting/resources';
+import { createCookieProjectionMatrixData } from '../prepare/extended-lighting/spot-modifiers';
+import {
+  createExtendedLightingState,
+  projectExtendedLightingInspection,
+  promoteExtendedLightingCandidate,
+} from '../prepare/extended-lighting/state';
 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';
@@ -190,8 +218,10 @@ import type {
   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,
@@ -199,6 +229,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,
@@ -206,7 +237,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';
 
@@ -226,6 +262,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,
@@ -275,8 +324,8 @@ function adaptMipmapShaderModuleFactory(
 
 // Re-export registerAdvanceAnimationPlayer so consumers can wire it.
 // Re-export registerPropagateTransforms so consumers can wire the
-// Transform.world mat4 derivation (audio listener sync + picking read the
-// derived Transform.world from scripts).
+// GlobalTransform.world mat4 derivation (audio listener sync + picking read the
+// derived GlobalTransform.world from scripts).
 
 // feat-20260611-fox-skinning-vertex-attribute-chain M4 / w16 (D-4): a single
 // shared empty ArrayBuffer used by `buildPipelineContext` to synthesize the
@@ -415,7 +464,7 @@ function toGpuVertexBufferLayouts(
  * Bundler-layer injection accepted by `createRenderer` (and proxied by
  * `createApp`) as the optional third argument.
  *
- * feat-20260608-create-app-param-surface-trim / M2 / D-3: aggregates the two
+ * feat-20260608-create-app-param-surface-trim / M2 / D-3: aggregates the three
  * host-injected build-tool channels:
  *
  *   - shaderManifestUrl: the URL the host's vite-plugin-shader emit step
@@ -429,6 +478,9 @@ function toGpuVertexBufferLayouts(
  *     AssetRegistry third ctor slot so DDC-miss assets can lazy-import.
  *     Absent => shipped form (a DDC miss fails fast with `asset-not-imported`).
  *
+ *   - build: exact checkout revision emitted by the build-tool adapter and
+ *     carried into renderer-owned inspection identity.
+ *
  * The interface is duplicated structurally in `@forgeax/engine-app`
  * (BundlerOptions exported from packages/app); demos consume through the app
  * package, the engine accepts via this local minimal shape so packages/runtime
@@ -439,6 +491,8 @@ function toGpuVertexBufferLayouts(
 export interface BundlerOptions {
   readonly importTransport?: ImportTransport | undefined;
   readonly shaderManifestUrl?: string | undefined;
+  /** Exact checkout revision emitted by the build-tool adapter. */
+  readonly build?: string | undefined;
 }
 
 // ─── Backend pack — M3 auto-select internal shape ───────────────────────────
@@ -450,18 +504,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).
  */
@@ -469,8 +519,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).
@@ -490,7 +541,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
@@ -502,17 +561,60 @@ export type LayoutKind = 'pbr' | 'pbr-skin' | 'hdrp-pbr' | 'sprite-urp' | 'unlit
 export function selectHdrpPbrPrewarmVariants(
   manifestEntry: MaterialShaderManifestEntry | undefined,
   storageBufferCapable: boolean,
-  transmissionCapable: boolean,
+  extendedLightingShaderAvailableOrTransmissionCapable = true,
+  transmissionCapable = true,
+  directionalPcssAvailable = true,
   projectorAvailable: boolean = true,
 ): readonly MaterialShaderManifestEntry['variants'][number][] {
+  const variants = manifestEntry?.variants ?? [];
+  const hasExtendedLightingAxis = variants.some(
+    (variant) => 'EXTENDED_LIGHTING_AVAILABLE' in variant.defines,
+  );
+  const extendedLightingShaderAvailable = hasExtendedLightingAxis
+    ? extendedLightingShaderAvailableOrTransmissionCapable
+    : true;
+  const effectiveTransmissionCapable = hasExtendedLightingAxis
+    ? transmissionCapable
+    : extendedLightingShaderAvailableOrTransmissionCapable;
+  // 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(
+    variants.filter(
       (variant) =>
         variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable &&
+        (!('EXTENDED_LIGHTING_AVAILABLE' in variant.defines) ||
+          variant.defines.EXTENDED_LIGHTING_AVAILABLE === extendedLightingShaderAvailable) &&
         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),
+        // ProbeBlend is an object-level opt-in. Boot/prewarm modules must
+        // stay on the no-probe ABI; a probe record selects its true variant
+        // later together with the probe-enabled slot-3 BGL.
+        variant.defines.PROBE_BLEND_AVAILABLE !== true &&
+        (effectiveTransmissionCapable || 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) &&
+        // ProbeBlend is selected per object, never by the boot skin module.
+        variant.defines.PROBE_BLEND_AVAILABLE !== true,
     ) ?? []
   );
 }
@@ -525,7 +627,9 @@ export function selectHdrpPbrPrewarmVariants(
 export function selectStandardPbrTransmissionPrewarmVariants(
   manifestEntry: MaterialShaderManifestEntry | undefined,
   storageBufferCapable: boolean,
+  directionalPcssAvailable = true,
   projectorAvailable: boolean = true,
+  extendedLightingShaderAvailable = true,
 ): readonly MaterialShaderManifestEntry['variants'][number][] {
   if (manifestEntry === undefined) {
     throw new Error('Standard material shader manifest row is missing');
@@ -535,10 +639,15 @@ 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) &&
+        (!('EXTENDED_LIGHTING_AVAILABLE' in variant.defines) ||
+          variant.defines.EXTENDED_LIGHTING_AVAILABLE === extendedLightingShaderAvailable) &&
+        variant.defines.PROBE_BLEND_AVAILABLE !== true &&
         variant.defines.TRANSMISSION_AVAILABLE === transmissionAvailable,
     );
     if (declared === undefined) {
@@ -566,23 +675,39 @@ export function selectNoColorPbrVariant(
   manifestEntry: MaterialShaderManifestEntry | undefined,
   storageBufferCapable: boolean,
   variantSet: string | undefined,
+  extendedLightingShaderAvailable = true,
+  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);
+  const probeBlendRequested = requestsProbeBlendVariant(variantSet);
   return manifestEntry?.variants.find(
     (variant) =>
       variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable &&
+      (!('EXTENDED_LIGHTING_AVAILABLE' in variant.defines) ||
+        variant.defines.EXTENDED_LIGHTING_AVAILABLE === extendedLightingShaderAvailable) &&
       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) &&
+      (!('PROBE_BLEND_AVAILABLE' in variant.defines) ||
+        variant.defines.PROBE_BLEND_AVAILABLE === probeBlendRequested) &&
       (!('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');
+}
+
+function requestsProbeBlendVariant(variantSet: string | undefined): boolean {
+  if (variantSet === undefined) return false;
+  return variantSet.includes('PROBE_BLEND_AVAILABLE=true');
+}
+
 export type MaterialShaderBindingContract = RenderFeatureMaterialShaderBindingContract;
 export type MaterialShaderVertexInputContract = 'none' | 'render-material';
 
@@ -707,13 +832,18 @@ export function shouldDeferMissingPreparedMaterialShader(
 export function selectPipelineLayoutForVariant(
   state: {
     readonly pbrPipelineLayout: PipelineLayout | null;
+    readonly pbrProbePipelineLayout?: PipelineLayout | null;
     readonly hdrpPbrPipelineLayout: PipelineLayout | null;
+    readonly hdrpProbePbrPipelineLayout?: PipelineLayout | null;
     readonly pbrSkinPipelineLayout: PipelineLayout | null;
+    readonly pbrSkinProbePipelineLayout?: PipelineLayout | null;
+    readonly hdrpSkinPipelineLayout?: PipelineLayout | null;
   } | null,
   variantSet: string | undefined,
   layoutKind?: LayoutKind,
 ): PipelineLayout | null {
   if (state === null) return null;
+  const probeBlendVariant = variantSet?.includes('PROBE_BLEND_AVAILABLE=true') === true;
   // bug-20260611: skin layout selection takes precedence over HDRP variant
   // resolution. HDRP × skin is OOS-1 (plan-strategy R-2 — left for a
   // dedicated feat); when an HDRP-variant skin call ever lands, we fail
@@ -721,7 +851,12 @@ export function selectPipelineLayoutForVariant(
   // (charter P3 explicit failure, mirrors memory anchor
   // `hdrp-active-must-not-fallback-to-urp-pipeline`).
   if (layoutKind === 'pbr-skin') {
-    return state.pbrSkinPipelineLayout;
+    return probeBlendVariant
+      ? (state.pbrSkinProbePipelineLayout ?? null)
+      : 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
@@ -738,33 +873,24 @@ 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;
+    return probeBlendVariant ? (state.pbrProbePipelineLayout ?? null) : 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;
+  // 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';
+  if (isHdrpVariant) {
+    return probeBlendVariant
+      ? (state.hdrpProbePbrPipelineLayout ?? null)
+      : state.hdrpPbrPipelineLayout;
   }
-  return state.pbrPipelineLayout;
+  return probeBlendVariant ? (state.pbrProbePipelineLayout ?? null) : state.pbrPipelineLayout;
 }
 
 /**
@@ -780,12 +906,14 @@ export function resolveMaterialShaderVariantSet(
   }>,
   backendKind: RhiDevice['caps']['backendKind'],
   storageBuffer: boolean,
-  projectorAvailable: boolean = true,
+  maxSampledTexturesPerShaderStageOrProjectorAvailable?: number | boolean,
 ): 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('EXTENDED_LIGHTING_AVAILABLE') ||
+    declaredAxes.has('DIRECTIONAL_PCSS_AVAILABLE') ||
     declaredAxes.has('PROJECTOR_AVAILABLE');
   if (!declaresCapabilityVariants) return requestedVariantSet;
 
@@ -794,6 +922,22 @@ export function resolveMaterialShaderVariantSet(
     const separator = part.indexOf('=');
     if (separator > 0) requested[part.slice(0, separator)] = part.slice(separator + 1) === 'true';
   }
+  const sampledTextureLimit =
+    typeof maxSampledTexturesPerShaderStageOrProjectorAvailable === 'number'
+      ? maxSampledTexturesPerShaderStageOrProjectorAvailable
+      : undefined;
+  const extendedLightingAvailable =
+    sampledTextureLimit === undefined
+      ? true
+      : backendKind !== 'wgpu-webgl2' &&
+        storageBuffer &&
+        extendedLightingSampledTextureCapacityAvailable(sampledTextureLimit);
+  const projectorAvailable =
+    typeof maxSampledTexturesPerShaderStageOrProjectorAvailable === 'boolean'
+      ? maxSampledTexturesPerShaderStageOrProjectorAvailable
+      : sampledTextureLimit === undefined
+        ? true
+        : sampledTextureLimit >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
   const filtered: Record<string, boolean> = {};
   for (const axis of declaredAxes) {
     filtered[axis] =
@@ -804,22 +948,33 @@ 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)
-                    : axis === 'PROJECTOR_AVAILABLE'
-                      ? projectorAvailable
-                      : (requested[axis] ?? true);
+                  : axis === 'EXTENDED_LIGHTING_AVAILABLE'
+                    ? // This is a backend-owned ABI axis, just like projector
+                      // and directional PCSS. An omitted caller request must
+                      // inherit the device-admitted view layout; defaulting it
+                      // to false pairs an extended view BGL with the projector
+                      // WGSL and fails WebGPU validation at binding 11.
+                      extendedLightingAvailable
+                    : axis === 'PROBE_BLEND_AVAILABLE'
+                      ? storageBuffer && (requested[axis] ?? false)
+                      : axis === 'TRANSMISSION_AVAILABLE'
+                        ? (requested[axis] ?? false)
+                        : axis === 'DIRECTIONAL_PCSS_AVAILABLE'
+                          ? directionalPcssCapable(backendKind)
+                          : axis === 'PROJECTOR_AVAILABLE'
+                            ? projectorAvailable
+                            : (requested[axis] ?? false);
   }
   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('+');
 }
 
@@ -843,8 +998,9 @@ export async function createRenderer(
   options?: RendererOptions,
   // feat-20260608-create-app-param-surface-trim / M2 / D-3: the third arg is
   // now BundlerOptions -- the build-tool injection channel that aggregates
-  // (a) shaderManifestUrl (vite-plugin-shader emit URL) and (b) importTransport
-  // (dev-only AssetRegistry transport from feat-20260604). Both fields
+  // (a) shaderManifestUrl (vite-plugin-shader emit URL), (b) importTransport,
+  // (dev-only AssetRegistry transport from feat-20260604), and (c) build
+  // identity for renderer-owned inspection evidence. All fields are
   // optional so {} is a valid call shape. Absent => both shipped-form
   // fallbacks fire: shaderManifestUrl falls back to '/shaders/manifest.json'
   // (D-2 q5-A, ~30 lines below); importTransport stays undefined (AssetRegistry
@@ -883,6 +1039,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 ──────────────────────────────────────────────────────────
 
 /**
@@ -909,7 +1087,11 @@ function attachDeviceLostFanout(
   },
 ): void {
   const { lostRegistry, errorRegistry, healthRegistry, onDeviceLost } = registries;
-  device.lost
+  // Backend fixtures may compose a deterministic loss signal with the native
+  // promise so the real recovery path can be exercised without manufacturing
+  // a second renderer health state. Production packs leave this hook absent.
+  const lost = pack.instrumentation?.deviceLost?.(device) ?? device.lost;
+  lost
     .then((info) => {
       const safe = {
         reason: info?.reason ?? 'unknown',
@@ -993,50 +1175,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'>,
-  options?: Pick<RendererOptions, 'captureGpuTimings'>,
-):
-  | {
-      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;
-  if (options?.captureGpuTimings === true && adapter.features.has('timestamp-query')) {
-    requiredFeatures.push('timestamp-query');
-  }
-  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()`
@@ -1077,7 +1215,12 @@ 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 };
   }
@@ -1085,11 +1228,19 @@ async function tryCreateWebGPURenderer(
   // M4 w28: filter compression features from adapter.features (AC-07). The
   // same helper is used by recover() below so both paths share one profile.
   const deviceOpts = deviceOptionsForAdapter(adapter, options);
+  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.
@@ -1172,10 +1323,8 @@ interface WebGPURendererInternals {
   options: RendererOptions | undefined;
   /**
    * feat-20260608-create-app-param-surface-trim / M2 / D-3: BundlerOptions
-   * forwarded verbatim from createRenderer's third arg. Carries
-   * shaderManifestUrl (host-injected vite-plugin-shader emit URL; absent =>
-   * createRenderer falls back to '/shaders/manifest.json') and the
-   * importTransport that previously rode a dedicated internal slot.
+   * forwarded verbatim from createRenderer's third arg. Carries the
+   * host-injected shaderManifestUrl, importTransport, and exact build identity.
    */
   bundler: BundlerOptions | undefined;
   lostRegistry: LostListenerRegistry;
@@ -1220,12 +1369,24 @@ interface WebGPURendererInternals {
   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;
@@ -1240,6 +1401,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.
@@ -1282,6 +1465,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:
@@ -1346,6 +1551,57 @@ 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');
+  let extendedLightingState = createExtendedLightingState(activeDeviceScope.generation);
+  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
@@ -1479,7 +1735,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
@@ -1752,8 +2011,7 @@ async function makeWebGPURenderer(
         [],
         internals.device.caps.backendKind,
         internals.device.caps.storageBuffer,
-        (internals.device.limits.maxSampledTexturesPerShaderStage ?? 0) >=
-          STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES,
+        internals.device.limits.maxSampledTexturesPerShaderStage,
       );
     }
     const variants = manifestEntry.variants;
@@ -1765,14 +2023,14 @@ async function makeWebGPURenderer(
     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'}`;
+    const cacheKey = `${requestedVariantSet ?? '\u0000'}|${internals.device.caps.backendKind}|${internals.device.caps.storageBuffer ? '1' : '0'}|${internals.device.limits.maxSampledTexturesPerShaderStage ?? 'unknown'}|${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,
+      internals.device.limits.maxSampledTexturesPerShaderStage,
     );
     byRequest.set(cacheKey, resolved);
     return resolved;
@@ -1798,6 +2056,44 @@ 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;
+  const promotePipelineExtendedLighting = (state: PipelineState, scope: DeviceScope): void => {
+    if (
+      state.extendedLightingAvailable !== true ||
+      state.iesProfileTexture === undefined ||
+      state.cookieTexture === undefined ||
+      state.cookieMatrixBuffer === undefined ||
+      state.iesProfileTextureView === undefined ||
+      state.cookieTextureView === undefined ||
+      state.ltcLambertTextureView === undefined ||
+      state.ltcGgxTextureView === undefined
+    ) {
+      return;
+    }
+    // The pipeline builder owns these already-resident GPU handles. Project
+    // that completed bundle into the inspection state so the public receipt
+    // cannot report an empty candidate while the record path is consuming the
+    // same IES/Cookie/LTC resources. The candidate is metadata-only here; no
+    // second GPU allocation or lifecycle owner is introduced.
+    const candidate: ExtendedLightingResourceCandidate = {
+      topology: EXTENDED_LIGHTING_TOPOLOGY,
+      generation: scope.generation,
+      scope,
+      iesSliceCount: 0,
+      cookieSliceCount: 0,
+      cookieMatrices: 0,
+      sampler: state.defaultSampler,
+      iesTexture: state.iesProfileTexture,
+      cookieTexture: state.cookieTexture,
+      cookieMatrixBuffer: state.cookieMatrixBuffer,
+      descriptorBytes:
+        IES_SLICE_WIDTH * IES_SLICE_HEIGHT * 2 * 32 +
+        COOKIE_SLICE_SIZE * COOKIE_SLICE_SIZE * 4 * 32 +
+        COOKIE_MATRIX_BYTES,
+      uploadCount: 5,
+    };
+    extendedLightingState = promoteExtendedLightingCandidate(extendedLightingState, candidate);
+  };
+  let fxaaRegistered = false;
   let temporalPostProcessesRegistered = false;
   const buildPipeline = (scope: DeviceScope = activeDeviceScope): Promise<PipelineState> =>
     buildReadyWebGPU(
@@ -1808,6 +2104,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
@@ -1827,9 +2124,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
@@ -1848,6 +2148,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) {
@@ -1870,14 +2183,20 @@ async function makeWebGPURenderer(
         internals.volumetricFogShaders = sources;
       },
     );
+  markRendererBootstrapStage('renderer-initialization-start');
   const ready: Promise<Result<void, RhiError>> = buildPipeline().then(
     (state): Result<void, RhiError> => {
       pipelineState = state;
+      promotePipelineExtendedLighting(state, activeDeviceScope);
       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(
@@ -1914,6 +2233,8 @@ async function makeWebGPURenderer(
       pbrManifestEntry,
       internals.device.caps.storageBuffer,
       variantSet,
+      deriveExtendedLightingCapability(internals.device).admitted,
+      directionalPcssCapable(internals.device.caps.backendKind),
       (internals.device.limits.maxSampledTexturesPerShaderStage ?? 0) >=
         STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES,
     );
@@ -1931,10 +2252,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,
@@ -1945,40 +2266,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
@@ -2030,7 +2342,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
@@ -2081,7 +2393,7 @@ async function makeWebGPURenderer(
                           : undefined,
                       ),
                     )
-                  : layoutKind === 'pbr-skin'
+                  : materialShaderId === SKIN_MATERIAL_SHADER_ID
                     ? toGpuVertexBufferLayouts(
                         deriveVertexBufferLayout(
                           meshAttributes ??
@@ -2127,7 +2439,7 @@ async function makeWebGPURenderer(
           : getShaderModuleAdapter(),
       pipelineLayout,
       vertexBuffers,
-      ...(layoutKind === 'pbr-skin' ? { layoutKind } : {}),
+      ...(resolvedLayoutKind === 'pbr-skin' ? { layoutKind: 'pbr-skin' as const } : {}),
     };
   };
   /**
@@ -2151,7 +2463,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
@@ -2187,7 +2499,12 @@ async function makeWebGPURenderer(
     vertexLayoutProjection?: VertexLayoutProjection,
     shaderModuleMode?: RenderFeatureShaderModuleMode,
     layoutKindOverride?: LayoutKind,
-  ): RenderPipeline | null => {
+    additionalColorFormats?: readonly GPUTextureFormat[],
+  ): {
+    readonly pipeline: RenderPipeline;
+    readonly group2Contract: PipelineGroup2Contract;
+  } | null => {
+    const group2Contract = resolvePipelineGroup2Contract(entry.source);
     const ctx = buildPipelineContext(
       variantSet,
       materialShaderId,
@@ -2195,6 +2512,7 @@ async function makeWebGPURenderer(
       vertexLayout,
       vertexLayoutProjection,
       shaderModuleMode,
+      group2Contract,
       layoutKindOverride,
     );
     if (ctx === null) return null;
@@ -2217,6 +2535,10 @@ async function makeWebGPURenderer(
       {
         ...ctx,
         colorFormat: isHdr ? HDR_COLOR_ATTACHMENT_FORMAT : ldrColorFormat,
+        colorFormats:
+          additionalColorFormats === undefined
+            ? undefined
+            : [isHdr ? HDR_COLOR_ATTACHMENT_FORMAT : ldrColorFormat, ...additionalColorFormats],
         depthFormat:
           depthFormatOverride === null ? undefined : (depthFormatOverride ?? DEPTH_TEXTURE_FORMAT),
         label,
@@ -2254,10 +2576,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,
@@ -2304,7 +2630,11 @@ async function makeWebGPURenderer(
     vertexLayoutProjection?: VertexLayoutProjection,
     shaderModuleMode: RenderFeatureShaderModuleMode = 'validated',
     layoutKindOverride?: LayoutKind,
-  ): RenderPipeline | null => {
+    additionalColorFormats?: readonly GPUTextureFormat[],
+  ): {
+    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
@@ -2384,10 +2714,14 @@ async function makeWebGPURenderer(
     // getPreferredCanvasFormat returns rgba8unorm (dawn-node, lavapipe, wgpu-wasm GLES),
     // forcing a redundant second PSO build on first-frame URP record path.
     const colorFormat: GPUTextureFormat = isHdr ? 'rgba16float' : ldrColorFormat;
+    const attachmentFormats =
+      additionalColorFormats === undefined
+        ? colorFormatsForPassKind(passKind, colorFormat)
+        : [colorFormat, ...additionalColorFormats];
     const spec: PipelineSpec = {
       shader: { id: materialShaderId, passKind, variantSet: effectiveVariantSet },
       attachments: {
-        colorFormats: colorFormatsForPassKind(passKind, colorFormat),
+        colorFormats: attachmentFormats,
         depthFormat:
           passKind === 'shadow-caster' || passKind === 'point-shadow-caster'
             ? 'depth32float'
@@ -2424,6 +2758,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
@@ -2471,6 +2810,8 @@ async function makeWebGPURenderer(
           vertexLayout,
           vertexLayoutProjection,
           shaderModuleMode,
+          layoutKindOverride,
+          additionalColorFormats,
         );
       }
       const pbrEntry = findStandardPbrEntry(effectiveVariantSet);
@@ -2525,6 +2866,8 @@ async function makeWebGPURenderer(
         vertexLayout,
         vertexLayoutProjection,
         shaderModuleMode,
+        layoutKindOverride,
+        additionalColorFormats,
       );
     }
     // feat-20260609 M4 / w31: resolve variant WGSL from manifest when
@@ -2544,24 +2887,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)
@@ -2602,7 +2947,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
@@ -2617,12 +2962,50 @@ async function makeWebGPURenderer(
       vertexLayoutProjection,
       shaderModuleMode,
       layoutKindOverride,
+      additionalColorFormats,
     );
   };
+  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;
   };
+  const getMaterialShaderArtifact = (materialShaderId: string) => {
+    if (
+      materialShaderId !== 'forgeax::default-standard-pbr' &&
+      materialShaderId !== 'forgeax::default-standard-pbr-skin'
+    ) {
+      return undefined;
+    }
+    const lookup = getShader().findMaterialArtifact(materialShaderId);
+    if (!lookup.ok) return undefined;
+    const receipt = createStandardPbrArtifactReceipt(
+      materialShaderId === 'forgeax::default-standard-pbr-skin',
+    );
+    const uvSetCount = materialShaderUvSetCounts.get(materialShaderId);
+    return {
+      material: materialShaderId,
+      pass: 'forward',
+      wgsl: lookup.value.source,
+      layoutIdentity: receipt.reflection.layoutIdentity,
+      ...(uvSetCount === undefined ? {} : { uvSetCount }),
+      bindings: [],
+      deps: [],
+      vertexInputs: receipt.vertexInputs.map(
+        (input): Readonly<Record<string, unknown>> => ({
+          semantic: input.semantic,
+          location: input.location,
+          format: input.format,
+        }),
+      ),
+      receipt,
+    };
+  };
   // feat-20260621-learn-render-5-5-parallax M2 / w6 (D-1): expose the per-shader
   // material BGL so the record stage creates the material bind group against
   // the matching paramSchema-derived layout. Returns undefined only for
@@ -2727,6 +3110,13 @@ async function makeWebGPURenderer(
   );
   const renderSystem: RenderSystem = createRenderSystem({
     canvas: internals.canvas,
+    // Keep inspection submits tied to the exact build-tool revision. This
+    // bridge is independent of the SSR identity and is required by
+    // renderer-owned LOD World attribution.
+    get build() {
+      return internals.bundler?.build;
+    },
+    ssrIdentity: internals.options?.ssrIdentity,
     get standardProfile() {
       return activeProfile;
     },
@@ -2739,6 +3129,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),
@@ -2752,6 +3146,9 @@ async function makeWebGPURenderer(
     get device() {
       return internals.device;
     },
+    get beforeSubmit() {
+      return internals.pack.instrumentation?.beforeSubmit;
+    },
     get deviceScope() {
       return activeDeviceScope;
     },
@@ -2775,8 +3172,10 @@ async function makeWebGPURenderer(
     errorRegistry: internals.errorRegistry,
     healthRegistry: internals.healthRegistry,
     getMaterialShaderPipeline,
+    getMaterialShaderPipelineEntry,
     getMaterialShaderBindingContract: getCachedMaterialShaderBindingContract,
     getParamSchema,
+    getMaterialShaderArtifact,
     getMaterialBindGroupLayout,
     metrics,
     // feat-20260609 M4 / T-10-a: post-process pipeline factory (CONCERN-1 fix).
@@ -2794,10 +3193,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
@@ -2822,6 +3304,10 @@ async function makeWebGPURenderer(
   const transformReleases = new Map<World, () => void>();
   const attachmentOwner = {};
   let frameId = 0;
+  // 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;
@@ -2837,13 +3323,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),
           }),
         );
       }
@@ -2862,6 +3356,12 @@ async function makeWebGPURenderer(
         );
       }
     },
+    inspectLodOcclusion() {
+      return {
+        lodOcclusion: renderSystem.lodOcclusionInspection,
+        gpuDriven: renderSystem.gpuDrivenInspection,
+      };
+    },
     inspect(): RenderInspection {
       const health = internals.healthRegistry.getLastSnapshot();
       const state = disposed
@@ -2888,6 +3388,7 @@ async function makeWebGPURenderer(
           : { presentationProof: internals.context.presentationProof }),
       });
       const volumetricFog = renderSystem.volumetricFog;
+      const directionalShadow = renderSystem.directionalShadow;
       return Object.freeze({
         state,
         surface: surfaceReleased ? 'released' : 'available',
@@ -2905,18 +3406,31 @@ async function makeWebGPURenderer(
         frustumStats: Object.freeze({ ...renderSystem.frustumStats }),
         visibilityStats: Object.freeze({ ...renderSystem.visibilityStats }),
         renderScene: renderSystem.renderScene,
+        reflectionProbes: renderSystem.reflectionProbes,
+        ssrDependencies: renderSystem.ssrDependencies,
         environment: renderSystem.environment,
         temporal: renderSystem.temporal,
         bloom: renderSystem.bloom,
+        extendedLighting: projectExtendedLightingInspection(extendedLightingState),
+        directionalShadow,
         ...(renderSystem.temporalTargetInspection === undefined
           ? {}
           : { temporalTarget: Object.freeze(renderSystem.temporalTargetInspection) }),
         ...(renderSystem.motionBlurInspection === undefined
           ? {}
           : { motionBlur: Object.freeze(renderSystem.motionBlurInspection) }),
+        ...(renderSystem.lodOcclusionInspection === undefined
+          ? {}
+          : { lodOcclusion: Object.freeze(renderSystem.lodOcclusionInspection) }),
         ...(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({
@@ -3065,6 +3579,9 @@ async function makeWebGPURenderer(
     get bindGroupCounts() {
       return renderSystem.bindGroupCounts;
     },
+    configureStandard(config) {
+      renderSystem.configureStandard(config);
+    },
     renderFeatureDiagnostics() {
       return internals.featureHost?.diagnostics() ?? [];
     },
@@ -3090,6 +3607,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) {
@@ -3128,6 +3674,7 @@ async function makeWebGPURenderer(
           requiredMaterialShaderSet.add(materialShaderId);
         }
         requiredMaterialShaders = Object.freeze([...requiredMaterialShaderSet]);
+        requiredFullscreenPostProcesses = nextRequiredFullscreenPostProcesses;
       }
       return installed;
     },
@@ -3156,6 +3703,7 @@ async function makeWebGPURenderer(
           }
         }
         requiredMaterialShaders = Object.freeze([...requiredMaterialShaderSet]);
+        requiredFullscreenPostProcesses = collectRequiredFullscreenPostProcesses(host.features);
       }
       return removed;
     },
@@ -3329,23 +3877,52 @@ async function makeWebGPURenderer(
       // through onError separately; the facade Result is the synchronous
       // summary AI users can ignore or branch on).
       try {
+        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 timingCapture: GpuTimingCapture | undefined;
-        let timingUnavailableReason = timingRequested
+        let volumeTimingCapture: GpuTimingCapture | undefined;
+        const volumeTimingUnavailableReason = timingRequested
           ? 'timestamp capture is unavailable on this device'
           : 'timestamp capture was not requested for this frame';
-        if (timingRequested) {
+        // 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) timingCapture = createdTiming.value;
-          else
-            timingUnavailableReason = `timestamp capture setup failed: ${createdTiming.error.code}`;
+          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, timingCapture);
+        const submitted = renderSystem.draw(
+          worlds,
+          drawOptions,
+          renderReadLeases,
+          volumeTimingCapture,
+        );
+        timingHost.gpuPassTimingFrameIdentity = undefined;
         if (!submitted) {
-          timingCapture?.discard();
+          volumeTimingCapture?.discard();
           return err(
             new RendererContractFailureError(
               'draw',
@@ -3353,36 +3930,80 @@ async function makeWebGPURenderer(
             ),
           );
         }
+        const timingCompletion = timingHost.gpuPassTimingSubmittedWork;
+        timingHost.gpuPassTimingSubmittedWork = undefined;
+        const reflectionFallbackCompletion = renderSystem.reflectionFallbackCompletion;
         internals.pack.instrumentation?.onFrameBoundary?.();
+        const receiptFrameId = ++frameId;
+        const receiptGeneration = activeDeviceScope.generation;
+        const queueCompletion = timingCompletion ?? internals.device.queue.onSubmittedWorkDone();
+        const completed: FrameReceipt['completed'] = Promise.all([
+          queueCompletion,
+          reflectionFallbackCompletion ?? Promise.resolve(),
+        ])
+          .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,
           });
-          receiptTimings.set(
-            receipt,
-            timingCapture?.observation() ??
-              Promise.resolve({
-                status: 'unavailable',
-                reason: timingUnavailableReason,
-              }),
-          );
+          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);
         }
@@ -3407,7 +4028,16 @@ 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 (
+        !currentReceipts.has(receipt) ||
         !issuedReceipts.has(receipt) ||
         receipt.deviceGeneration !== activeDeviceScope.generation
       ) {
@@ -3432,11 +4062,17 @@ async function makeWebGPURenderer(
           }),
         );
       }
-      const timings = request.include.includes('timings')
+      await renderSystem.observeLodOcclusion();
+      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({
+            Promise.resolve<VolumeTimingObservation>({
               status: 'unavailable',
-              reason: 'timing receipt was not retained',
+              reason: 'timestamp capture was not requested for this frame',
             }))
         : undefined;
       return ok(
@@ -3444,7 +4080,10 @@ async function makeWebGPURenderer(
           frameId: receipt.frameId,
           deviceGeneration: receipt.deviceGeneration,
           include: Object.freeze([...request.include]),
-          ...(timings === undefined ? {} : { timings }),
+          ...(targetReadbacks === undefined
+            ? {}
+            : { targetReadbacks: Object.freeze(targetReadbacks.value) }),
+          ...(volumeTimings === undefined ? {} : { volumeTimings }),
         }),
       );
     },
@@ -3519,6 +4158,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 {
@@ -3699,6 +4340,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
@@ -3845,8 +4488,13 @@ async function makeWebGPURenderer(
         const previousDeviceScope = activeDeviceScope;
         activeDeviceScope = recoveryScope;
         pipelineState = candidatePipelineState;
+        promotePipelineExtendedLighting(candidatePipelineState, activeDeviceScope);
+        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
@@ -3932,7 +4580,7 @@ export function exposeRenderer(renderer: RendererHostImplementation): Renderer {
   });
 
   return {
-    attach: (world) => {
+    attach: (world: World) => {
       const result = renderer.attach(world);
       return result.ok
         ? result
@@ -3943,6 +4591,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(
@@ -3955,7 +4609,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(
@@ -3968,8 +4622,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);
@@ -4083,17 +4738,11 @@ function structuredRendererCause(cause: unknown, operation: string): RendererOpe
 const RENDER_PROFILE_KEYS = new Set([
   'pipelineId',
   'lightCount',
-  'lighting',
+  'renderPath',
   'shadows',
   'pbr',
   'ibl',
   'ssao',
-  'bloom',
-  'tone',
-  'antialias',
-  'sky',
-  'volumetricFog',
-  'fallback',
   'postStages',
 ]);
 
@@ -4107,36 +4756,15 @@ 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`;
   }
-  if (profile.volumetricFog !== undefined) {
-    if (profile.volumetricFog.quality !== 'low' && profile.volumetricFog.quality !== 'high')
-      return "RenderProfile.volumetricFog.quality must be 'low' or 'high'";
-    if (profile.volumetricFog.depth !== 48 && profile.volumetricFog.depth !== 64) {
-      return 'RenderProfile.volumetricFog.depth must be 48 or 64';
-    }
-    if (profile.volumetricFog.tileSize !== 4 && profile.volumetricFog.tileSize !== 16) {
-      return 'RenderProfile.volumetricFog.tileSize must be 4 or 16';
-    }
-    if (profile.volumetricFog.quality === 'low' && profile.volumetricFog.depth !== 48)
-      return 'RenderProfile.volumetricFog.low must use depth 48';
-    if (profile.volumetricFog.quality === 'high' && profile.volumetricFog.depth !== 64)
-      return 'RenderProfile.volumetricFog.high must use depth 64';
-    if (profile.volumetricFog.quality === 'low' && profile.volumetricFog.tileSize !== 16)
-      return 'RenderProfile.volumetricFog.low must use tileSize 16';
-    if (profile.volumetricFog.quality === 'high' && profile.volumetricFog.tileSize !== 4)
-      return 'RenderProfile.volumetricFog.high must use tileSize 4';
-  }
   const stages = STANDARD_POST_STAGE_NAMES;
   if (
     !Array.isArray(profile.postStages) ||
@@ -4409,23 +5037,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;
 
@@ -4914,6 +5539,7 @@ async function prepareMaterialShaders(
     if (!capCheck.ok) throw capCheck.error;
     storageBufferCapable = !webgl2Downlevel && capCheck.value;
   }
+  const extendedLightingShaderAvailable = deriveExtendedLightingCapability(rhiDevice).admitted;
   // 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
@@ -4922,7 +5548,6 @@ async function prepareMaterialShaders(
   const projectorAvailable =
     (rhiDevice.limits.maxSampledTexturesPerShaderStage ?? 0) >=
     STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
-
   // ── Step 1: manifest load ─────────────────────────────────────────────────
   const registry = getShader();
   const loaded = await registry.loadManifest();
@@ -4931,12 +5556,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).
@@ -4947,6 +5571,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
@@ -4958,11 +5587,20 @@ 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.variants.some((v) => 'PROBE_BLEND_AVAILABLE' in v.defines)) {
+      // ProbeBlendRecord is an object-level opt-in, not a device capability.
+      // The boot/default module must stay on the no-probe ABI; record-stage
+      // entries with a retained record request the explicit true variant.
+      variantDefines.PROBE_BLEND_AVAILABLE = false;
+    }
+    if (msEntry.variants.some((v) => 'EXTENDED_LIGHTING_AVAILABLE' in v.defines)) {
+      variantDefines.EXTENDED_LIGHTING_AVAILABLE = extendedLightingShaderAvailable;
+    }
     if (
       msEntry.identifier === 'forgeax::default-standard-pbr' &&
       msEntry.variants.some((v) => 'PROJECTOR_AVAILABLE' in v.defines)
@@ -4975,6 +5613,17 @@ async function prepareMaterialShaders(
     ) {
       variantDefines.TRANSMISSION_AVAILABLE = false;
     }
+    // The fallback MRT is a record-time opt-in. Boot registration must select
+    // the ordinary single-target Standard artifact when the manifest declares
+    // the axis; record-time topology derives the true branch only after the
+    // fallback attachment has been admitted. Omitting this false value asks
+    // the closed manifest for a non-existent partial key.
+    if (
+      msEntry.identifier === 'forgeax::default-standard-pbr' &&
+      msEntry.variants.some((v) => 'REFLECTION_FALLBACK_AVAILABLE' in v.defines)
+    ) {
+      variantDefines.REFLECTION_FALLBACK_AVAILABLE = false;
+    }
     // bug-20260708 M2 (a): PER_INSTANCE_REGION axis default = false at boot.
     // Per-entity spritePH path (`main-pass-sprite-draws.ts:511-513`) expects
     // `variantSet=undefined` to resolve to the PIR=false shader source (64B
@@ -5103,6 +5752,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
@@ -5131,7 +5785,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
@@ -5141,6 +5799,8 @@ 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;
@@ -5164,10 +5824,10 @@ async function buildReadyWebGPU(
     const capCheck = assertStorageBufferCap(capValue);
     storageBufferCapable = capCheck.ok ? !webgl2Downlevel && capCheck.value : !webgl2Downlevel;
   }
+  const extendedLightingShaderAvailable = deriveExtendedLightingCapability(rhiDevice).admitted;
   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
@@ -5238,6 +5898,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;
@@ -5432,7 +6096,7 @@ async function buildReadyWebGPU(
     // bug-20260610: WebGL2 fallback path — when storageBufferCapable=false
     // the variant-aware Step 1b registers material shaders with the
     // STORAGE_BUFFER_AVAILABLE=false WGSL (uniform fallback for meshes /
-    // pointLights / instances), but Step 2 above triaged pbr/unlit/sprite/
+    // meshes / instances), but Step 2 above triaged pbr/unlit/sprite/
     // pbr-skin/msdf-text from the FLAT `registry.entries()` map which only
     // contains the default (storage) variant. Compiling those with
     // STORAGE_BUFFER_AVAILABLE=true while the pipeline layout is built
@@ -5456,22 +6120,28 @@ 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) &&
-            (!('PROJECTOR_AVAILABLE' in v.defines) ||
-              v.defines.PROJECTOR_AVAILABLE === projectorAvailable) &&
-            (!('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) &&
+            (!('REFLECTION_FALLBACK_AVAILABLE' in variant.defines) ||
+              variant.defines.REFLECTION_FALLBACK_AVAILABLE === false) &&
+            variant.defines.PROBE_BLEND_AVAILABLE !== true &&
+            (!('SKINNING_DISABLED' in variant.defines) ||
+              variant.defines.SKINNING_DISABLED === true),
         );
         const v = exact === undefined ? undefined : findVariantByKey(ms, exact.definesKey);
         if (v !== undefined) {
@@ -5500,8 +6170,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.
@@ -5510,16 +6180,24 @@ async function buildReadyWebGPU(
       const exact = ms.variants.find(
         (variant) =>
           variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable &&
+          (!('EXTENDED_LIGHTING_AVAILABLE' in variant.defines) ||
+            variant.defines.EXTENDED_LIGHTING_AVAILABLE === extendedLightingShaderAvailable) &&
           (!('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) &&
+          variant.defines.PROBE_BLEND_AVAILABLE !== true &&
           (!('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),
+            variant.defines.TRANSMISSION_AVAILABLE === false) &&
+          (!('REFLECTION_FALLBACK_AVAILABLE' in variant.defines) ||
+            variant.defines.REFLECTION_FALLBACK_AVAILABLE === false),
       );
       const variant = exact === undefined ? undefined : findVariantByKey(ms, exact.definesKey);
       if (variant !== undefined) {
@@ -5650,6 +6328,27 @@ 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
@@ -5735,6 +6434,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
@@ -5758,7 +6458,9 @@ async function buildReadyWebGPU(
       ? selectStandardPbrTransmissionPrewarmVariants(
           pbrManifestEntry,
           storageBufferCapable,
+          directionalPcssCapable(rhiDevice.caps.backendKind),
           projectorAvailable,
+          extendedLightingShaderAvailable,
         )
       : [];
 
@@ -5796,7 +6498,9 @@ async function buildReadyWebGPU(
     for (const hdrpVariant of selectHdrpPbrPrewarmVariants(
       pbrManifestEntry,
       storageBufferCapable,
+      extendedLightingShaderAvailable,
       transmissionCapable,
+      directionalPcssCapable(rhiDevice.caps.backendKind),
       projectorAvailable,
     )) {
       const moduleLabel = `module-forgeax::default-standard-pbr#${hdrpVariant.definesKey}`;
@@ -5824,6 +6528,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
@@ -5848,6 +6589,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);
@@ -5994,7 +6736,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(
@@ -6002,11 +6745,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)',
@@ -6014,7 +6763,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);
@@ -6031,18 +6780,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');
@@ -6071,6 +6820,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 ->
@@ -6141,7 +6891,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
@@ -6164,6 +6951,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.
@@ -6295,6 +7083,7 @@ async function buildReadyWebGPU(
       ok(
         buildPbrPipelineLayouts(rhiDevice, {
           storageBuffer: storageBufferCapable,
+          extendedLighting: extendedLightingShaderAvailable,
           projectorAvailable,
         }),
       ),
@@ -6307,6 +7096,7 @@ async function buildReadyWebGPU(
   const materialBglResult = ok(pbrLayouts.value.materialBgl);
   const meshArrayBglResult = ok(pbrLayouts.value.meshArrayBgl);
   const instancesBglResult = ok(pbrLayouts.value.instancesBgl);
+  const probeInstancesBglResult = ok(pbrLayouts.value.probeInstancesBgl);
   const pipelineLayoutResult = ok(pbrLayouts.value.pipelineLayout);
 
   // feat-20260609-hdrp-cluster-fragment-ggx M4.5 / w36 (D-10 option A):
@@ -6316,15 +7106,15 @@ 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;
+  let hdrpProbePbrPipelineLayoutHandle: 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({
@@ -6339,6 +7129,23 @@ async function buildReadyWebGPU(
       if (hdrpPlRes.ok) {
         hdrpPbrPipelineLayoutHandle = hdrpPlRes.value;
       }
+      // ProbeBlendRecord adds a fragment-visible storage binding and is not a
+      // legal downlevel extension of the uniform-fallback/WebGL2 layout. Keep
+      // the HDRP probe PSO on the same capability gate as the standard probe
+      // PSO; otherwise layout construction itself exceeds GLES' uniform
+      // buffer limit before a probe draw can be rejected cleanly.
+      if (storageBufferCapable) {
+        const hdrpProbePlRes = rhiDevice.createPipelineLayout({
+          label: 'hdrp-probe-pbr-pl',
+          bindGroupLayouts: [
+            viewBglResult.value,
+            materialBglResult.value,
+            hdrpUnifiedBglRes.value,
+            probeInstancesBglResult.value,
+          ],
+        });
+        if (hdrpProbePlRes.ok) hdrpProbePbrPipelineLayoutHandle = hdrpProbePlRes.value;
+      }
     }
   }
 
@@ -6395,23 +7202,27 @@ 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
+  let pbrSkinProbePipelineLayoutHandle: PipelineLayout | null = null;
+  // 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(
       () =>
@@ -6424,9 +7235,33 @@ async function buildReadyWebGPU(
     );
     if (skinLayoutsResult.ok) {
       pbrSkinPipelineLayoutHandle = skinLayoutsResult.value.pipelineLayout;
+      pbrSkinProbePipelineLayoutHandle = skinLayoutsResult.value.probePipelineLayout;
       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,
@@ -6767,54 +7602,6 @@ async function buildReadyWebGPU(
   // count >= 2 in createRenderer.ts — definition + this exposure).
   setGrowMeshSsboHook(meshSsboController.growMeshSsbo, meshSsboController.state);
 
-  // feat-20260519-light-casters-point-spot-pbr M3 / w20 (D-S1 + D-S2):
-  // PointLight + SpotLight std430 storage buffers. Header 16 B (count u32 +
-  // 12 B pad) + 4-slot first-slice cap (32 B / 48 B per slot). Sized
-  // generously so that the buffer.size never changes once allocated; per-
-  // frame writeBuffer overwrites the entire range (D-S6 full rewrite +
-  // charter P3 explicit failure: stable buffer.size means no orphan slot
-  // reuse).
-  const POINT_LIGHTS_BUFFER_BYTES =
-    LIGHT_ARRAY_HEADER_BYTES + POINT_LIGHT_STD430_BYTES * LIGHT_ARRAY_MAX_SLOTS;
-  const SPOT_LIGHTS_BUFFER_BYTES =
-    LIGHT_ARRAY_HEADER_BYTES + SPOT_LIGHT_STD430_BYTES * LIGHT_ARRAY_MAX_SLOTS;
-  // bug-20260610: WebGL2 fallback — pointLights / spotLights buffers must
-  // be UNIFORM-usage (the storage variant of the shader is gated by
-  // STORAGE_BUFFER_AVAILABLE; the uniform-fallback path expects uniform
-  // buffers). Without this swap, the buffer-creation succeeds (driver still
-  // accepts STORAGE flag), but `createBindGroup` validation rejects the
-  // mismatch: `Usage flags BufferUsages(COPY_DST | STORAGE) ... do not
-  // contain required usage flags BufferUsages(UNIFORM)`.
-  const LIGHTS_BUFFER_USAGE = storageBufferCapable
-    ? GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST
-    : GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST;
-  const pointLightsBufferResult = runShimSyncStep(
-    () =>
-      rhiDevice.createBuffer({
-        label: 'pbr-point-lights-ssbo',
-        size: POINT_LIGHTS_BUFFER_BYTES,
-        usage: LIGHTS_BUFFER_USAGE,
-        mappedAtCreation: false,
-      }),
-    'webgpu-runtime-error',
-    'createBuffer (point-lights ssbo) succeeded',
-    'check device.limits.maxStorageBufferBindingSize',
-  );
-  if (!pointLightsBufferResult.ok) throw pointLightsBufferResult.error;
-  const spotLightsBufferResult = runShimSyncStep(
-    () =>
-      rhiDevice.createBuffer({
-        label: 'pbr-spot-lights-ssbo',
-        size: SPOT_LIGHTS_BUFFER_BYTES,
-        usage: LIGHTS_BUFFER_USAGE,
-        mappedAtCreation: false,
-      }),
-    'webgpu-runtime-error',
-    'createBuffer (spot-lights ssbo) succeeded',
-    'check device.limits.maxStorageBufferBindingSize',
-  );
-  if (!spotLightsBufferResult.ok) throw spotLightsBufferResult.error;
-
   // feat-20260513-instanced-mesh M3 (T-M3-2): identity-mat4 fallback
   // storage buffer. Single 64-byte storage buffer carrying one identity
   // mat4 column-major. Renderables without an `Instances` component bind
@@ -6994,6 +7781,225 @@ async function buildReadyWebGPU(
   );
   if (!fallbackTextureViewResult.ok) throw fallbackTextureViewResult.error;
 
+  let iesModifierFallbackTexture: import('@forgeax/engine-rhi').Texture | undefined;
+  let cookieModifierFallbackTexture: import('@forgeax/engine-rhi').Texture | undefined;
+  let cookieModifierFallbackMatrixBuffer: Buffer | undefined;
+  let iesModifierFallbackView: TextureView | undefined;
+  let cookieModifierFallbackView: TextureView | undefined;
+  let residentLtcLambertView: TextureView | undefined;
+  let residentLtcGgxView: TextureView | undefined;
+  const requireExtendedResource = <T>(value: T | undefined, name: string): T => {
+    if (value === undefined) {
+      throw new Error(`extended-lighting resource missing: ${name}`);
+    }
+    return value;
+  };
+
+  if (extendedLightingShaderAvailable) {
+    // The direct-light modifier ABI is a 32-layer array. It is created only
+    // for the matching extended-lighting topology; the no-extension variant
+    // has no IES/Cookie/LTC declarations or sampled resources at all.
+    const modifierArrayLayers = 32;
+    const iesModifierBytesPerRow = IES_SLICE_WIDTH * 2;
+    const cookieModifierBytesPerRow = COOKIE_SLICE_SIZE * 4;
+    const iesModifierFallbackData = new Uint8Array(
+      iesModifierBytesPerRow * IES_SLICE_HEIGHT * modifierArrayLayers,
+    );
+    for (let offset = 0; offset < iesModifierFallbackData.length; offset += 2) {
+      iesModifierFallbackData[offset] = 0;
+      iesModifierFallbackData[offset + 1] = 0x3c;
+    }
+    const cookieModifierFallbackData = new Uint8Array(
+      cookieModifierBytesPerRow * COOKIE_SLICE_SIZE * modifierArrayLayers,
+    );
+    cookieModifierFallbackData.fill(0xff);
+    const iesModifierFallbackResult = runShimSyncStep(
+      () =>
+        rhiDevice.createTexture({
+          label: 'fallback-ies-profile-array',
+          size: {
+            width: IES_SLICE_WIDTH,
+            height: IES_SLICE_HEIGHT,
+            depthOrArrayLayers: modifierArrayLayers,
+          },
+          mipLevelCount: 1,
+          sampleCount: 1,
+          dimension: '2d',
+          format: 'r16float',
+          usage: GPU_TEXTURE_USAGE_TEXTURE_BINDING | GPU_TEXTURE_USAGE_COPY_DST,
+          viewFormats: [],
+          textureBindingViewDimension: undefined,
+        }),
+      'webgpu-runtime-error',
+      'createTexture (fallback IES array) succeeded',
+      'check array-layer and texture-binding limits',
+    );
+    if (!iesModifierFallbackResult.ok) throw iesModifierFallbackResult.error;
+    const cookieModifierFallbackResult = runShimSyncStep(
+      () =>
+        rhiDevice.createTexture({
+          label: 'fallback-cookie-array',
+          size: {
+            width: COOKIE_SLICE_SIZE,
+            height: COOKIE_SLICE_SIZE,
+            depthOrArrayLayers: modifierArrayLayers,
+          },
+          mipLevelCount: 1,
+          sampleCount: 1,
+          dimension: '2d',
+          format: 'rgba8unorm',
+          usage: GPU_TEXTURE_USAGE_TEXTURE_BINDING | GPU_TEXTURE_USAGE_COPY_DST,
+          viewFormats: [],
+          textureBindingViewDimension: undefined,
+        }),
+      'webgpu-runtime-error',
+      'createTexture (fallback Cookie array) succeeded',
+      'check array-layer and texture-binding limits',
+    );
+    if (!cookieModifierFallbackResult.ok) throw cookieModifierFallbackResult.error;
+    const iesWrite = runShimSyncStep(
+      () =>
+        queue.writeTexture(
+          { texture: iesModifierFallbackResult.value, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } },
+          iesModifierFallbackData,
+          { offset: 0, bytesPerRow: iesModifierBytesPerRow, rowsPerImage: IES_SLICE_HEIGHT },
+          {
+            width: IES_SLICE_WIDTH,
+            height: IES_SLICE_HEIGHT,
+            depthOrArrayLayers: modifierArrayLayers,
+          },
+        ),
+      'queue-write-buffer-out-of-bounds',
+      'queue.writeTexture (fallback IES array) succeeded',
+      'verify modifier IES array row alignment',
+    );
+    if (!iesWrite.ok) throw iesWrite.error;
+    const cookieWrite = runShimSyncStep(
+      () =>
+        queue.writeTexture(
+          {
+            texture: cookieModifierFallbackResult.value,
+            mipLevel: 0,
+            origin: { x: 0, y: 0, z: 0 },
+          },
+          cookieModifierFallbackData,
+          { offset: 0, bytesPerRow: cookieModifierBytesPerRow, rowsPerImage: COOKIE_SLICE_SIZE },
+          {
+            width: COOKIE_SLICE_SIZE,
+            height: COOKIE_SLICE_SIZE,
+            depthOrArrayLayers: modifierArrayLayers,
+          },
+        ),
+      'queue-write-buffer-out-of-bounds',
+      'queue.writeTexture (fallback Cookie array) succeeded',
+      'verify modifier Cookie array row alignment',
+    );
+    if (!cookieWrite.ok) throw cookieWrite.error;
+    const iesModifierFallbackViewResult = runShimSyncStep(
+      () =>
+        rhiDevice.createTextureView(iesModifierFallbackResult.value, {
+          label: 'fallback-ies-profile-array-view',
+          dimension: '2d-array',
+          arrayLayerCount: modifierArrayLayers,
+        }),
+      'webgpu-runtime-error',
+      'createTextureView (fallback IES array) succeeded',
+      'verify 2d-array view matches modifier BGL',
+    );
+    if (!iesModifierFallbackViewResult.ok) throw iesModifierFallbackViewResult.error;
+    iesModifierFallbackTexture = iesModifierFallbackResult.value;
+    iesModifierFallbackView = iesModifierFallbackViewResult.value;
+    const cookieModifierFallbackViewResult = runShimSyncStep(
+      () =>
+        rhiDevice.createTextureView(cookieModifierFallbackResult.value, {
+          label: 'fallback-cookie-array-view',
+          dimension: '2d-array',
+          arrayLayerCount: modifierArrayLayers,
+        }),
+      'webgpu-runtime-error',
+      'createTextureView (fallback Cookie array) succeeded',
+      'verify 2d-array view matches modifier BGL',
+    );
+    if (!cookieModifierFallbackViewResult.ok) throw cookieModifierFallbackViewResult.error;
+    cookieModifierFallbackTexture = cookieModifierFallbackResult.value;
+    cookieModifierFallbackView = cookieModifierFallbackViewResult.value;
+
+    const cookieMatrixFallbackData = createCookieProjectionMatrixData(modifierArrayLayers);
+    const cookieMatrixBufferResult = runShimSyncStep(
+      () =>
+        rhiDevice.createBuffer({
+          label: 'fallback-cookie-matrices',
+          size: COOKIE_MATRIX_BYTES,
+          usage: GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_UNIFORM,
+          mappedAtCreation: false,
+        }),
+      'webgpu-runtime-error',
+      'createBuffer (fallback Cookie matrices) succeeded',
+      'check uniform-buffer size and usage support',
+    );
+    if (!cookieMatrixBufferResult.ok) throw cookieMatrixBufferResult.error;
+    const cookieMatrixWrite = runShimSyncStep(
+      () =>
+        rhiDevice.queue.writeBuffer(cookieMatrixBufferResult.value, 0, cookieMatrixFallbackData),
+      'queue-write-buffer-out-of-bounds',
+      'queue.writeBuffer (fallback Cookie matrices) succeeded',
+      'verify Cookie matrix payload alignment',
+    );
+    if (!cookieMatrixWrite.ok) throw cookieMatrixWrite.error;
+    cookieModifierFallbackMatrixBuffer = cookieMatrixBufferResult.value;
+
+    const createResidentLtcView = (label: string, table: Uint16Array): TextureView => {
+      const textureResult = runShimSyncStep(
+        () =>
+          rhiDevice.createTexture({
+            label,
+            size: { width: LTC_TABLE_WIDTH, height: LTC_TABLE_HEIGHT, depthOrArrayLayers: 1 },
+            mipLevelCount: 1,
+            sampleCount: 1,
+            dimension: '2d',
+            format: 'rgba16float',
+            usage: GPU_TEXTURE_USAGE_TEXTURE_BINDING | GPU_TEXTURE_USAGE_COPY_DST,
+            viewFormats: [],
+            textureBindingViewDimension: undefined,
+          }),
+        'webgpu-runtime-error',
+        `createTexture (${label}) succeeded`,
+        'check resident LTC table texture capabilities',
+      );
+      if (!textureResult.ok) throw textureResult.error;
+      const uploadResult = runShimSyncStep(
+        () =>
+          queue.writeTexture(
+            { texture: textureResult.value, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } },
+            new Uint8Array(table.buffer, table.byteOffset, table.byteLength),
+            { offset: 0, bytesPerRow: LTC_TABLE_WIDTH * 8, rowsPerImage: LTC_TABLE_HEIGHT },
+            { width: LTC_TABLE_WIDTH, height: LTC_TABLE_HEIGHT, depthOrArrayLayers: 1 },
+          ),
+        'queue-write-buffer-out-of-bounds',
+        `queue.writeTexture (${label}) succeeded`,
+        'verify resident LTC table row alignment',
+      );
+      if (!uploadResult.ok) throw uploadResult.error;
+      const viewResult = runShimSyncStep(
+        () =>
+          rhiDevice.createTextureView(textureResult.value, {
+            label: `${label}-view`,
+            dimension: '2d',
+          }),
+        'webgpu-runtime-error',
+        `createTextureView (${label}) succeeded`,
+        'verify resident LTC view matches shader binding',
+      );
+      if (!viewResult.ok) throw viewResult.error;
+      return viewResult.value;
+    };
+    residentLtcLambertView = createResidentLtcView(
+      'extended-lighting-ltc-lambert',
+      LTC_TABLES.lambert,
+    );
+    residentLtcGgxView = createResidentLtcView('extended-lighting-ltc-ggx', LTC_TABLES.ggx);
+  }
+
   // Normal-slot fallback: 1x1 RGBA8 (128, 128, 255, 255). pbr.wgsl decodes
   // sample.rg * 2 - 1 + z = sqrt(1 - x^2 - y^2), so RG=(128,128)=0.5 maps
   // to tangent (0, 0, 1) -- zero perturbation when normalTexture is absent.
@@ -7303,17 +8309,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):
@@ -7325,6 +8334,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` —
@@ -7333,6 +8343,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
@@ -7434,7 +8445,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
@@ -7467,7 +8477,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
@@ -7477,11 +8487,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);
       }
     }
 
@@ -7489,11 +8500,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);
       }
     }
   }
@@ -7701,15 +8713,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({
@@ -7725,6 +8737,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',
@@ -8760,6 +9777,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
@@ -8802,6 +9820,8 @@ async function buildReadyWebGPU(
     // standard pipeline fields above).
     pbrPipelineLayout:
       unlitModule !== null && pbrModule !== null ? pipelineLayoutResult.value : null,
+    pbrProbePipelineLayout:
+      unlitModule !== null && pbrModule !== null ? pbrLayouts.value.probePipelineLayout : null,
     // feat-20260609-hdrp-cluster-fragment-ggx M4.5 / w36 (D-10 option A):
     // HDRP-variant PipelineLayout (4-BGL chain with HDRP unified 7-slot
     // group(2) BGL substituted for the URP 1-slot mesh-array BGL). Built
@@ -8811,10 +9831,12 @@ async function buildReadyWebGPU(
     // `selectPipelineLayoutForVariant` based on the caller's variantSet.
     hdrpPbrPipelineLayout:
       unlitModule !== null && pbrModule !== null ? hdrpPbrPipelineLayoutHandle : null,
+    hdrpProbePbrPipelineLayout:
+      unlitModule !== null && pbrModule !== null ? hdrpProbePbrPipelineLayoutHandle : null,
     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
@@ -8822,17 +9844,23 @@ async function buildReadyWebGPU(
     // `LayoutKind = 'pbr-skin'`.
     pbrSkinPipelineLayout:
       unlitModule !== null && pbrModule !== null ? pbrSkinPipelineLayoutHandle : null,
+    pbrSkinProbePipelineLayout:
+      unlitModule !== null && pbrModule !== null ? pbrSkinProbePipelineLayoutHandle : null,
     // feat-20260611 R2 / M8 / w28 (IS-14): record-stage skin BG plumbing.
     // 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
@@ -8844,6 +9872,7 @@ async function buildReadyWebGPU(
     colorAttachmentFormat: swapChainFormats.view,
     surfaceProfile: surfaceViewFormats ? 'dual-view' : 'raw-only',
     viewBindGroupLayout: viewBglResult.value,
+    extendedLightingAvailable: extendedLightingShaderAvailable,
     projectorAvailable,
     materialBindGroupLayout: materialBglResult.value,
     meshBindGroupLayout: meshArrayBglResult.value,
@@ -8859,9 +9888,8 @@ async function buildReadyWebGPU(
     // `{ buffer: Buffer; sizeInBytes: number }` in T-M2-06 to match.
     materialUniformBuffer: meshSsboState.material,
     meshStorageBuffer: meshSsboState.mesh,
-    pointLightsBuffer: pointLightsBufferResult.value,
-    spotLightsBuffer: spotLightsBufferResult.value,
     instancesBindGroupLayout: instancesBglResult.value,
+    probeInstancesBindGroupLayout: probeInstancesBglResult.value,
     identityInstanceBuffer: identityInstanceResult.value,
     defaultSampler: defaultSamplerResult.value,
     nearestSampler: nearestSamplerResult.value,
@@ -8884,6 +9912,23 @@ async function buildReadyWebGPU(
     // feat-20260520-directional-light-shadow-mapping M2 / w14 (D-1):
     // 1x1 depth32float fallback bound at viewBindGroup binding(3).
     shadowFallbackTextureView: shadowFallbackViewResult.value,
+    ...(extendedLightingShaderAvailable
+      ? {
+          iesProfileTexture: requireExtendedResource(iesModifierFallbackTexture, 'ies texture'),
+          cookieTexture: requireExtendedResource(cookieModifierFallbackTexture, 'cookie texture'),
+          cookieMatrixBuffer: requireExtendedResource(
+            cookieModifierFallbackMatrixBuffer,
+            'cookie matrix buffer',
+          ),
+          iesProfileTextureView: requireExtendedResource(iesModifierFallbackView, 'ies view'),
+          cookieTextureView: requireExtendedResource(cookieModifierFallbackView, 'cookie view'),
+          ltcLambertTextureView: requireExtendedResource(
+            residentLtcLambertView,
+            'ltc lambert view',
+          ),
+          ltcGgxTextureView: requireExtendedResource(residentLtcGgxView, 'ltc ggx view'),
+        }
+      : {}),
     // feat-20260612-point-light-shadows-urp-hdrp Round-2 F-1: 1x1x6
     // depth32float cube_array fallback bound at viewBindGroup binding(5)
     // when no PointLightShadow snapshots are active. Always-present