@forgeax/engine-render 0.1.21 → 0.1.23

package/src/assembly/factory.ts

@@ -54,12 +54,17 @@ import type {
   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,
@@ -130,13 +135,7 @@ 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,
@@ -169,6 +168,22 @@ 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 {
@@ -309,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
@@ -449,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
@@ -463,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
@@ -473,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 ───────────────────────────
@@ -541,25 +561,42 @@ function directionalPcssCapable(backendKind: RhiDevice['caps']['backendKind']):
 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),
     ) ?? []
   );
 }
@@ -575,7 +612,9 @@ export function selectSkinPrewarmVariants(
         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),
+        (storageBufferCapable || variant.defines.CLUSTER_FORWARD_AVAILABLE !== true) &&
+        // ProbeBlend is selected per object, never by the boot skin module.
+        variant.defines.PROBE_BLEND_AVAILABLE !== true,
     ) ?? []
   );
 }
@@ -590,6 +629,7 @@ export function selectStandardPbrTransmissionPrewarmVariants(
   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');
@@ -605,6 +645,9 @@ export function selectStandardPbrTransmissionPrewarmVariants(
           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) {
@@ -632,18 +675,24 @@ 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 === '' || 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),
   );
@@ -654,6 +703,11 @@ function requestsClusterVariant(variantSet: string | undefined): boolean {
   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';
 
@@ -778,14 +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,
+  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
@@ -793,7 +851,9 @@ 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;
@@ -818,14 +878,19 @@ export function selectPipelineLayoutForVariant(
   // 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;
   }
   // Group(2) contract/layout kind is the sole layout authority. Variant keys
   // identify WGSL artifacts, but must not independently select a bind-group
   // layout; this prevents an empty/expanded key from bypassing the resolved
   // storage contract.
   const isHdrpVariant = layoutKind === 'hdrp-pbr';
-  return isHdrpVariant ? state.hdrpPbrPipelineLayout : state.pbrPipelineLayout;
+  if (isHdrpVariant) {
+    return probeBlendVariant
+      ? (state.hdrpProbePbrPipelineLayout ?? null)
+      : state.hdrpPbrPipelineLayout;
+  }
+  return probeBlendVariant ? (state.pbrProbePipelineLayout ?? null) : state.pbrPipelineLayout;
 }
 
 /**
@@ -841,12 +906,13 @@ 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;
@@ -856,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] =
@@ -871,13 +953,22 @@ export function resolveMaterialShaderVariantSet(
                 ? requestedVariantSet === '' || (requested[axis] ?? false)
                 : axis === 'VERTEX_COLOR_AVAILABLE'
                   ? requestedVariantSet === '' || (requested[axis] ?? false)
-                  : axis === 'TRANSMISSION_AVAILABLE'
-                    ? (requested[axis] ?? false)
-                    : axis === 'DIRECTIONAL_PCSS_AVAILABLE'
-                      ? directionalPcssCapable(backendKind)
-                      : 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)
@@ -907,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
@@ -995,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',
@@ -1227,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;
@@ -1457,6 +1551,7 @@ 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 &&
@@ -1916,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;
@@ -1929,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;
@@ -1962,6 +2056,43 @@ 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> =>
@@ -2056,6 +2187,7 @@ async function makeWebGPURenderer(
   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);
@@ -2101,6 +2233,7 @@ 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,
@@ -2366,6 +2499,7 @@ async function makeWebGPURenderer(
     vertexLayoutProjection?: VertexLayoutProjection,
     shaderModuleMode?: RenderFeatureShaderModuleMode,
     layoutKindOverride?: LayoutKind,
+    additionalColorFormats?: readonly GPUTextureFormat[],
   ): {
     readonly pipeline: RenderPipeline;
     readonly group2Contract: PipelineGroup2Contract;
@@ -2401,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,
@@ -2492,6 +2630,7 @@ async function makeWebGPURenderer(
     vertexLayoutProjection?: VertexLayoutProjection,
     shaderModuleMode: RenderFeatureShaderModuleMode = 'validated',
     layoutKindOverride?: LayoutKind,
+    additionalColorFormats?: readonly GPUTextureFormat[],
   ): {
     readonly pipeline: RenderPipeline;
     readonly group2Contract: PipelineGroup2Contract;
@@ -2575,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'
@@ -2667,6 +2810,8 @@ async function makeWebGPURenderer(
           vertexLayout,
           vertexLayoutProjection,
           shaderModuleMode,
+          layoutKindOverride,
+          additionalColorFormats,
         );
       }
       const pbrEntry = findStandardPbrEntry(effectiveVariantSet);
@@ -2721,6 +2866,8 @@ async function makeWebGPURenderer(
         vertexLayout,
         vertexLayoutProjection,
         shaderModuleMode,
+        layoutKindOverride,
+        additionalColorFormats,
       );
     }
     // feat-20260609 M4 / w31: resolve variant WGSL from manifest when
@@ -2815,6 +2962,7 @@ async function makeWebGPURenderer(
       vertexLayoutProjection,
       shaderModuleMode,
       layoutKindOverride,
+      additionalColorFormats,
     );
   };
   const getMaterialShaderPipelineEntry = (
@@ -2827,6 +2975,37 @@ async function makeWebGPURenderer(
     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
@@ -2931,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;
     },
@@ -2960,6 +3146,9 @@ async function makeWebGPURenderer(
     get device() {
       return internals.device;
     },
+    get beforeSubmit() {
+      return internals.pack.instrumentation?.beforeSubmit;
+    },
     get deviceScope() {
       return activeDeviceScope;
     },
@@ -2986,6 +3175,7 @@ async function makeWebGPURenderer(
     getMaterialShaderPipelineEntry,
     getMaterialShaderBindingContract: getCachedMaterialShaderBindingContract,
     getParamSchema,
+    getMaterialShaderArtifact,
     getMaterialBindGroupLayout,
     metrics,
     // feat-20260609 M4 / T-10-a: post-process pipeline factory (CONCERN-1 fix).
@@ -3166,6 +3356,12 @@ async function makeWebGPURenderer(
         );
       }
     },
+    inspectLodOcclusion() {
+      return {
+        lodOcclusion: renderSystem.lodOcclusionInspection,
+        gpuDriven: renderSystem.gpuDrivenInspection,
+      };
+    },
     inspect(): RenderInspection {
       const health = internals.healthRegistry.getLastSnapshot();
       const state = disposed
@@ -3211,9 +3407,11 @@ async function makeWebGPURenderer(
         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
           ? {}
@@ -3221,6 +3419,9 @@ async function makeWebGPURenderer(
         ...(renderSystem.motionBlurInspection === undefined
           ? {}
           : { motionBlur: Object.freeze(renderSystem.motionBlurInspection) }),
+        ...(renderSystem.lodOcclusionInspection === undefined
+          ? {}
+          : { lodOcclusion: Object.freeze(renderSystem.lodOcclusionInspection) }),
         ...(renderSystem.transmission === undefined
           ? {}
           : { transmission: renderSystem.transmission }),
@@ -3731,12 +3932,15 @@ 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 completed: FrameReceipt['completed'] = (
-          timingCompletion ?? internals.device.queue.onSubmittedWorkDone()
-        )
+        const queueCompletion = timingCompletion ?? internals.device.queue.onSubmittedWorkDone();
+        const completed: FrameReceipt['completed'] = Promise.all([
+          queueCompletion,
+          reflectionFallbackCompletion ?? Promise.resolve(),
+        ])
           .then(() => ok(undefined))
           .catch((cause: unknown) =>
             err(
@@ -3858,6 +4062,7 @@ async function makeWebGPURenderer(
           }),
         );
       }
+      await renderSystem.observeLodOcclusion();
       const targetReadbacks =
         request.targetReadbacks === undefined || request.targetReadbacks.length === 0
           ? undefined
@@ -4283,6 +4488,7 @@ async function makeWebGPURenderer(
         const previousDeviceScope = activeDeviceScope;
         activeDeviceScope = recoveryScope;
         pipelineState = candidatePipelineState;
+        promotePipelineExtendedLighting(candidatePipelineState, activeDeviceScope);
         currentReceipts.clear();
         gpuStore.bindDeviceScope(activeDeviceScope);
         renderTargetHost.recover();
@@ -5333,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
@@ -5385,6 +5592,15 @@ async function prepareMaterialShaders(
     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)
@@ -5397,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
@@ -5597,6 +5824,7 @@ 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;
@@ -5868,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
@@ -5909,6 +6137,9 @@ async function buildReadyWebGPU(
                 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),
         );
@@ -5949,19 +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 === 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) {
@@ -6224,6 +6460,7 @@ async function buildReadyWebGPU(
           storageBufferCapable,
           directionalPcssCapable(rhiDevice.caps.backendKind),
           projectorAvailable,
+          extendedLightingShaderAvailable,
         )
       : [];
 
@@ -6261,6 +6498,7 @@ async function buildReadyWebGPU(
     for (const hdrpVariant of selectHdrpPbrPrewarmVariants(
       pbrManifestEntry,
       storageBufferCapable,
+      extendedLightingShaderAvailable,
       transmissionCapable,
       directionalPcssCapable(rhiDevice.caps.backendKind),
       projectorAvailable,
@@ -6845,6 +7083,7 @@ async function buildReadyWebGPU(
       ok(
         buildPbrPipelineLayouts(rhiDevice, {
           storageBuffer: storageBufferCapable,
+          extendedLighting: extendedLightingShaderAvailable,
           projectorAvailable,
         }),
       ),
@@ -6857,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):
@@ -6869,6 +7109,7 @@ async function buildReadyWebGPU(
   // 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.
@@ -6888,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;
+      }
     }
   }
 
@@ -6953,6 +7211,7 @@ async function buildReadyWebGPU(
   // explicit failure -- no silent fallback to URP layout, mirroring memory
   // anchor `hdrp-active-must-not-fallback-to-urp-pipeline`).
   let pbrSkinPipelineLayoutHandle: PipelineLayout | null = null;
+  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 3-entry skin
@@ -6976,6 +7235,7 @@ async function buildReadyWebGPU(
     );
     if (skinLayoutsResult.ok) {
       pbrSkinPipelineLayoutHandle = skinLayoutsResult.value.pipelineLayout;
+      pbrSkinProbePipelineLayoutHandle = skinLayoutsResult.value.probePipelineLayout;
       pbrSkinMeshBindGroupLayoutHandle = skinLayoutsResult.value.meshArrayBgl;
     }
   }
@@ -7342,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
@@ -7569,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.
@@ -9389,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
@@ -9398,6 +9831,8 @@ 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
@@ -9409,6 +9844,8 @@ 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
@@ -9435,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,
@@ -9450,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,
@@ -9475,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