@forgeax/engine-render 0.1.7 → 0.1.20

package/src/assembly/factory.ts

@@ -59,6 +59,7 @@ import type {
 import { err, ok, RhiError, validateDrawArgs } from '@forgeax/engine-rhi';
 import { registerPropagateTransforms } from '@forgeax/engine-scene';
 import {
+  DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
   findVariantByKey,
   type MaterialShaderEntry,
   type MaterialShaderManifestEntry,
@@ -77,9 +78,12 @@ import type {
   VertexAttributeMap,
 } from '@forgeax/engine-types';
 import { derive, handleSlot } from '@forgeax/engine-types';
+
+export type { MaterialShaderManifestEntry } from '@forgeax/engine-shader';
+
 import { GpuResidencyCache, type MeshGpuHandles } from '../device/gpu-residency';
 import { createEngineMetrics } from '../engine-metrics';
-import { RecoverError, type RecoverFailure, RenderRecoveryError } from '../errors/recover';
+import { RecoverError, type RecoverFailure } from '../errors/recover';
 import {
   FrameReceiptStaleError,
   type RenderError,
@@ -90,8 +94,9 @@ import {
   RenderFeatureStageFailedError,
 } 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 } from '../features/types';
+import type { RenderFeature, RenderFeatureShaderModuleMode } from '../features/types';
 import type { PostProcessShaderEntry } from '../fullscreen-post-process-pass';
 import { glyphTextLayoutSystem } from '../glyph-text-layout-system';
 import { GpuBuffer } from '../gpu-resource';
@@ -115,6 +120,7 @@ import {
   FALLBACK_BYTES_PER_ROW,
   type SkylightFallback,
 } from '../ibl/skylight-bind-group';
+import type { BloomInspection } from '../inspection-types';
 import {
   DeviceScope,
   HealthListenerRegistry,
@@ -129,15 +135,19 @@ import {
   SPOT_LIGHT_STD430_BYTES,
 } from '../light-buffer-layout';
 import {
+  buildPbrMaterialUserRegionEntries,
   buildPbrPipelineLayouts,
   buildPbrSkinLayouts,
+  isSkinnedShadowCasterVariant,
   SKIN_MATERIAL_SHADER_ID,
 } from '../pbr-pipeline';
 import { STANDARD_CLUSTER_MEMBERSHIP_WGSL, standardPipeline } from '../pipeline/standard-pipeline';
+import { inspectStandardBloomGraph } from '../pipeline/standard-post';
 import {
   DEFAULT_STANDARD_PROFILE,
   STANDARD_LIGHT_COUNTS,
   STANDARD_PIPELINE_ID,
+  STANDARD_POST_STAGE_NAMES,
 } from '../pipeline/standard-profile';
 import { buildPipelineForMaterialShader } from '../pipeline-builder';
 import {
@@ -155,6 +165,8 @@ import {
 } from '../pipeline-spec';
 import { POINTS_LINES_MATERIAL_SHADER_ID } from '../points-lines/record';
 import type { FrameObservationOptions } from '../record/frame';
+import { GpuTimingCapture, type VolumeTimingObservation } from '../record/gpu-timing';
+import type { BloomPersistentBundle } from '../record/render-context';
 import { SHADOW_CASTER_BUFFER_SIZE } from '../record/shadow-pass';
 import { POINTS_LINES_VIEW_BUFFER_SIZE, VIEW_UNIFORM_BUFFER_SIZE } from '../record/view-ubo';
 import type {
@@ -176,8 +188,9 @@ import type {
   RenderProfile,
   RenderResult,
   RenderWorldLease,
+  VolumetricFogShaderSources,
 } from '../render-contract';
-import { STANDARD_TONEMAP_FEATURE_ID } from '../render-contract';
+import { STANDARD_OUTPUT_TRANSFORM_FEATURE_ID } from '../render-contract';
 import {
   configureSurface,
   createRenderSystem,
@@ -194,6 +207,8 @@ import {
 import { tilemapChunkExtractSystem } from '../tilemap-chunk-extract-system';
 import { EngineEnvironmentError, type RhiBackendPack } from './backend-contract';
 import type { RendererAssemblyImplementation, RendererHostImplementation } from './host-contract';
+import { projectRendererOutputInspection } from './renderer-inspection';
+import { isRendererStateOperational } from './renderer-lifecycle';
 
 export { assembleMaterialProjection } from './material/assembly';
 export {
@@ -232,6 +247,9 @@ function loadRhiPack(
   const createShaderModule = mod.createShaderModule as
     | RhiBackendPack['createShaderModule']
     | undefined;
+  const createShaderModuleImmediate = mod.createShaderModuleImmediate as
+    | RhiBackendPack['createShaderModuleImmediate']
+    | undefined;
   const translateErrorEventToRhiError = mod.translateErrorEventToRhiError as
     | RhiBackendPack['translateErrorEventToRhiError']
     | undefined;
@@ -241,6 +259,7 @@ function loadRhiPack(
   return {
     rhi,
     ...(createShaderModule === undefined ? {} : { createShaderModule }),
+    ...(createShaderModuleImmediate === undefined ? {} : { createShaderModuleImmediate }),
     ...(translateErrorEventToRhiError === undefined ? {} : { translateErrorEventToRhiError }),
     ...(rawDeviceAccessor === undefined ? {} : { _internal_getRawDevice: rawDeviceAccessor }),
     ...(instrumentation === undefined ? {} : { instrumentation }),
@@ -477,20 +496,67 @@ export type LayoutKind = 'pbr' | 'pbr-skin' | 'hdrp-pbr' | 'sprite-urp' | 'unlit
  * Return every device-capability HDRP PBR variant that needs a lazy module
  * label seeded during renderer boot. Color availability is intentionally not
  * filtered: colored and no-color meshes use distinct composed WGSL modules.
+ * Transmission is filtered by the same sampled-texture capability gate as
+ * Standard transmission because HDRP shares the material texture ABI.
  */
 export function selectHdrpPbrPrewarmVariants(
   manifestEntry: MaterialShaderManifestEntry | undefined,
   storageBufferCapable: boolean,
+  transmissionCapable: boolean,
+  projectorAvailable: boolean = true,
 ): readonly MaterialShaderManifestEntry['variants'][number][] {
   return (
     manifestEntry?.variants.filter(
       (variant) =>
         variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable &&
-        variant.defines.CLUSTER_FORWARD_AVAILABLE === true,
+        variant.defines.CLUSTER_FORWARD_AVAILABLE === true &&
+        (!('PROJECTOR_AVAILABLE' in variant.defines) ||
+          variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) &&
+        (transmissionCapable || variant.defines.TRANSMISSION_AVAILABLE !== true),
     ) ?? []
   );
 }
 
+/**
+ * Select both Standard transmission states from the manifest for exact-label
+ * prewarming. The requested keys come from declared variants; no key is
+ * synthesized and no source fallback is permitted.
+ */
+export function selectStandardPbrTransmissionPrewarmVariants(
+  manifestEntry: MaterialShaderManifestEntry | undefined,
+  storageBufferCapable: boolean,
+  projectorAvailable: boolean = true,
+): readonly MaterialShaderManifestEntry['variants'][number][] {
+  if (manifestEntry === undefined) {
+    throw new Error('Standard material shader manifest row is missing');
+  }
+  const selected: MaterialShaderManifestEntry['variants'][number][] = [];
+  for (const transmissionAvailable of [false, true]) {
+    const declared = manifestEntry.variants.find(
+      (variant) =>
+        variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable &&
+        variant.defines.CLUSTER_FORWARD_AVAILABLE === false &&
+        variant.defines.VERTEX_COLOR_AVAILABLE === false &&
+        (!('PROJECTOR_AVAILABLE' in variant.defines) ||
+          variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) &&
+        variant.defines.TRANSMISSION_AVAILABLE === transmissionAvailable,
+    );
+    if (declared === undefined) {
+      throw new Error(
+        `Standard material shader manifest lacks exact TRANSMISSION_AVAILABLE=${transmissionAvailable} prewarm variant`,
+      );
+    }
+    const exact = findVariantByKey(manifestEntry, declared.definesKey);
+    if (exact === undefined) {
+      throw new Error(
+        `Standard material shader manifest exact lookup failed for TRANSMISSION_AVAILABLE=${transmissionAvailable}`,
+      );
+    }
+    selected.push(exact);
+  }
+  return selected;
+}
+
 /**
  * Select the PBR variant that matches a fallback mesh with no COLOR_0 input.
  * Unknown/custom material IDs may still use the legacy PBR fallback, so that
@@ -500,24 +566,24 @@ export function selectNoColorPbrVariant(
   manifestEntry: MaterialShaderManifestEntry | undefined,
   storageBufferCapable: boolean,
   variantSet: string | undefined,
+  projectorAvailable: boolean = true,
 ): MaterialShaderManifestEntry['variants'][number] | undefined {
   const hdrpRequested =
-    variantSet === '' || (variantSet?.includes('CLUSTER_FORWARD_AVAILABLE=true') ?? false);
+    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'));
   return manifestEntry?.variants.find(
     (variant) =>
       variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable &&
       variant.defines.VERTEX_COLOR_AVAILABLE === false &&
+      (!('PROJECTOR_AVAILABLE' in variant.defines) ||
+        variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) &&
       (!('CLUSTER_FORWARD_AVAILABLE' in variant.defines) ||
         variant.defines.CLUSTER_FORWARD_AVAILABLE === hdrpRequested),
   );
 }
 
-export type MaterialShaderBindingContract =
-  | 'group-0'
-  | 'group-0-resource'
-  | 'view-only'
-  | 'view-and-scene-depth'
-  | 'render-material';
+export type MaterialShaderBindingContract = RenderFeatureMaterialShaderBindingContract;
 export type MaterialShaderVertexInputContract = 'none' | 'render-material';
 
 export function resolveMaterialShaderBindingContract(
@@ -570,6 +636,46 @@ export function resolveMaterialShaderVertexInputContract(
     : 'none';
 }
 
+/**
+ * Decide whether a custom material's user-region can use the shared PBR
+ * bind-group layout. Resource names are not part of a WebGPU layout contract:
+ * the only safe reuse test is that every derived binding in the custom schema
+ * is an identical prefix of the canonical user-region descriptor, including
+ * binding kind and its full shape (sample type, view dimension, sampler mode,
+ * dynamic-offset flags, and visibility). A texture3d/array or comparison /
+ * storage resource must therefore take the per-shader layout path even when
+ * its field count is small.
+ */
+export function isSharedMaterialUserRegionCompatible(
+  paramSchema: readonly ParamSchemaEntry[],
+): boolean {
+  const shared = buildPbrMaterialUserRegionEntries(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);
+  const candidate = buildPbrMaterialUserRegionEntries(paramSchema);
+  if (candidate.length > shared.length) return false;
+  return candidate.every((entry, index) => {
+    const canonical = shared[index];
+    if (canonical === undefined) return false;
+    return (
+      JSON.stringify({
+        binding: entry.binding,
+        visibility: entry.visibility,
+        buffer: entry.buffer ?? null,
+        sampler: entry.sampler ?? null,
+        texture: entry.texture ?? null,
+        storageTexture: entry.storageTexture ?? null,
+      }) ===
+      JSON.stringify({
+        binding: canonical.binding,
+        visibility: canonical.visibility,
+        buffer: canonical.buffer ?? null,
+        sampler: canonical.sampler ?? null,
+        texture: canonical.texture ?? null,
+        storageTexture: canonical.storageTexture ?? null,
+      })
+    );
+  });
+}
+
 export function allowsUnlitPreparedFallback(
   depthFormatOverride: GPUTextureFormat | null | undefined,
   vertexLayout: string | undefined,
@@ -632,6 +738,13 @@ 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.
+  if (layoutKind === 'pbr') {
+    return state.pbrPipelineLayout;
+  }
   // HDRP variant matches when:
   //   - layoutKind === 'hdrp-pbr' (caller-driven, future-proof), OR
   //   - variantSet is the canonical all-true key '' (boot-time HDRP
@@ -667,10 +780,13 @@ export function resolveMaterialShaderVariantSet(
   }>,
   backendKind: RhiDevice['caps']['backendKind'],
   storageBuffer: boolean,
+  projectorAvailable: boolean = true,
 ): string | undefined {
   const declaredAxes = new Set(variants.flatMap((variant) => Object.keys(variant.defines)));
   const declaresCapabilityVariants =
-    declaredAxes.has('WEBGL2_COMPAT') || declaredAxes.has('STORAGE_BUFFER_AVAILABLE');
+    declaredAxes.has('WEBGL2_COMPAT') ||
+    declaredAxes.has('STORAGE_BUFFER_AVAILABLE') ||
+    declaredAxes.has('PROJECTOR_AVAILABLE');
   if (!declaresCapabilityVariants) return requestedVariantSet;
 
   const requested: Record<string, boolean> = {};
@@ -685,7 +801,19 @@ export function resolveMaterialShaderVariantSet(
         ? backendKind === 'wgpu-webgl2'
         : axis === 'STORAGE_BUFFER_AVAILABLE'
           ? backendKind !== 'wgpu-webgl2' && storageBuffer
-          : (requested[axis] ?? true);
+          : axis === 'SKINNING_DISABLED'
+            ? (requested[axis] ?? true)
+            : axis === 'CLUSTER_FORWARD_AVAILABLE'
+              ? 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);
   }
   const sorted = Object.entries(filtered).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
   return sorted.every(([, value]) => value)
@@ -875,11 +1003,38 @@ const COMPRESSION_FEATURES: GPUFeatureName[] = [
   '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'>,
-): { requiredFeatures: GPUFeatureName[] } | undefined {
+  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));
-  return requiredFeatures.length > 0 ? { requiredFeatures } : undefined;
+  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,
+          },
+        }
+      : {}),
+  };
 }
 
 /**
@@ -929,7 +1084,7 @@ async function tryCreateWebGPURenderer(
   const adapter = adapterResult.value;
   // M4 w28: filter compression features from adapter.features (AC-07). The
   // same helper is used by recover() below so both paths share one profile.
-  const deviceOpts = deviceOptionsForAdapter(adapter);
+  const deviceOpts = deviceOptionsForAdapter(adapter, options);
   const result = await adapter.requestDevice(deviceOpts);
   if (!result.ok) {
     return { kind: 'rhi-err', error: result.error };
@@ -1059,6 +1214,8 @@ interface WebGPURendererInternals {
    * has wired the controller; identity stable across grow events.
    */
   meshSsboState?: MeshSsboState;
+  /** Device-bound, manifest-owned volumetric utility shader sources. */
+  volumetricFogShaders?: VolumetricFogShaderSources | undefined;
   /** Host-owned producer features; created before device-bound assembly starts. */
   featureHost?: RenderFeatureHost;
   /** App-owned overlay capability read by the typed graph at frame time. */
@@ -1097,16 +1254,34 @@ async function makeWebGPURenderer(
   // compile across both paths (charter P4 consistent abstraction +
   // architecture-principles #6 idempotency).
   let sharedShaderModuleAdapter: ShaderDeviceAdapterInternal | null = null;
+  // Generated feature programs (currently VFX) opt into the handle-first
+  // adapter. Keep it separate from the validated adapter so ordinary render
+  // pipelines retain the compiler-readiness barrier that prevents first-frame
+  // black output on Dawn.
+  let sharedImmediateShaderModuleAdapter: ShaderDeviceAdapterInternal | null = null;
   const getShaderModuleAdapter = (): ShaderDeviceAdapterInternal => {
     if (sharedShaderModuleAdapter === null) {
       sharedShaderModuleAdapter = makeShaderDeviceAdapter(
         internals.device,
         internals.errorRegistry,
         internals.pack.createShaderModule,
+        internals.pack.createShaderModuleImmediate,
       );
     }
     return sharedShaderModuleAdapter;
   };
+  const getImmediateShaderModuleAdapter = (): ShaderDeviceAdapterInternal => {
+    if (sharedImmediateShaderModuleAdapter === null) {
+      sharedImmediateShaderModuleAdapter = makeShaderDeviceAdapter(
+        internals.device,
+        internals.errorRegistry,
+        internals.pack.createShaderModule,
+        internals.pack.createShaderModuleImmediate,
+        'immediate',
+      );
+    }
+    return sharedImmediateShaderModuleAdapter;
+  };
   const getShader = (): ShaderCatalog => {
     if (shaderInstance === null) {
       // feat-20260608-create-app-param-surface-trim / M2 / D-2 q5-A:
@@ -1326,13 +1501,13 @@ async function makeWebGPURenderer(
   >();
   const preparedMaterialPipelineLayoutCache = new Map<string, PipelineLayout>();
   // feat-20260621-learn-render-5-5-parallax M2 / w6 (D-1): per-shader material
-  // BGL + pipeline layout cache. A custom material shader declaring >3
-  // user-region textures (e.g. parallax `heightTexture`) needs a material BGL
-  // whose user-region + injection start differ from the shared built-in
-  // derived shared layout, plus a pipeline layout [view, perShaderMaterialBgl,
-  // meshArray, instances] that the PSO builds against. Built lazily on first
-  // request and cached by shaderId; 4-or-fewer-texture shaders never enter the cache
-  // (they reuse the shared layout, byte-for-byte the built-in shape — D-2).
+  // BGL + pipeline layout cache. Every authored material shader owns the
+  // user-region binding order emitted by its paramSchema, plus the shared
+  // engine-injection suffix. A custom shader with four-or-fewer textures can
+  // still differ from the standard PBR order (for example, baseColorTexture
+  // followed directly by normalTexture), so it cannot safely reuse the
+  // standard material BGL. Built lazily on first request and cached by
+  // shaderId; built-in shader IDs continue to use the boot-time shared layout.
   type PerShaderMaterialLayout = {
     materialBgl: BindGroupLayout;
     pipelineLayout: PipelineLayout;
@@ -1343,6 +1518,16 @@ async function makeWebGPURenderer(
     readonly layout: PerShaderMaterialLayout | null;
   };
   const perShaderMaterialLayoutCache = new Map<string, PerShaderMaterialLayoutCacheEntry>();
+  const isEngineOwnedMaterialShader = (materialShaderId: string): boolean =>
+    materialShaderId === 'forgeax::default-unlit' ||
+    materialShaderId === 'forgeax::default-shadow-caster' ||
+    materialShaderId === 'forgeax::sprite' ||
+    materialShaderId === 'forgeax::sprite-lit' ||
+    materialShaderId === 'forgeax::default-sprite' ||
+    materialShaderId === 'forgeax::msdf-text' ||
+    materialShaderId === 'forgeax::default-standard-pbr' ||
+    materialShaderId === 'forgeax::pbr-skin' ||
+    materialShaderId === 'forgeax::default-standard-pbr-skin';
   // Material binding contracts are derived from WGSL source, but the lookup
   // is also used by the per-submesh bind-group path. Cache the derived value
   // per renderer so a frame does not re-run the comment stripping and regex
@@ -1477,7 +1662,9 @@ async function makeWebGPURenderer(
     if (cached !== undefined) return cached;
     if (pipelineState === null) return null;
     const materialBgl =
-      getOrBuildPerShaderMaterialLayout(materialShaderId)?.materialBgl ??
+      (isEngineOwnedMaterialShader(materialShaderId)
+        ? undefined
+        : getOrBuildPerShaderMaterialLayout(materialShaderId)?.materialBgl) ??
       pipelineState.materialBindGroupLayout;
     const result = internals.device.createPipelineLayout({
       label: `prepared-material-pl-${materialShaderId}`,
@@ -1490,15 +1677,15 @@ async function makeWebGPURenderer(
     preparedMaterialPipelineLayoutCache.set(materialShaderId, result.value);
     return result.value;
   };
-  // Returns the per-shader { materialBgl, pipelineLayout } for a custom shader
-  // whose user-region texture count exceeds the built-in 4, or null when the
-  // shader resolves to the shared built-in layout (4 textures) / is
-  // unregistered / pipelineState is not ready. Pure-ish: builds + caches on
-  // miss via the same buildBindGroupLayoutDescriptor SSOT (kind
-  // 'pbr-material-merged' + materialParamSchema) used by buildPbrPipelineLayouts.
+  // Returns the per-shader { materialBgl, pipelineLayout } for an authored
+  // shader, or null when it is unregistered / pipelineState is not ready.
+  // Pure-ish: builds + caches on miss via the same
+  // buildBindGroupLayoutDescriptor SSOT (kind 'pbr-material-merged' +
+  // materialParamSchema) used by buildPbrPipelineLayouts.
   const getOrBuildPerShaderMaterialLayout = (
     materialShaderId: string,
   ): PerShaderMaterialLayout | null => {
+    if (isEngineOwnedMaterialShader(materialShaderId)) return null;
     const lookup = getShader().findMaterialArtifact(materialShaderId);
     if (!lookup.ok) return null;
     const cached = perShaderMaterialLayoutCache.get(materialShaderId);
@@ -1507,9 +1694,11 @@ async function makeWebGPURenderer(
     }
     if (pipelineState === null) return null;
     const paramSchema = lookup.value.paramSchema;
-    // 4-or-fewer user-region textures derive to the same shape as the shared
-    // built-in BGL -> reuse it (D-2; no per-shader entry).
-    if (derive(paramSchema).textureFieldNames.size <= 4) {
+    // Reuse the shared BGL only when the complete derived resource shape is a
+    // canonical prefix. Field names alone are not a layout contract: a
+    // texture3d/array, comparison sampler, or storage buffer must never be
+    // paired with the PBR texture2d/filtering descriptor by accident.
+    if (isSharedMaterialUserRegionCompatible(paramSchema)) {
       perShaderMaterialLayoutCache.set(materialShaderId, {
         source: lookup.value.source,
         paramSchema,
@@ -1563,6 +1752,8 @@ async function makeWebGPURenderer(
         [],
         internals.device.caps.backendKind,
         internals.device.caps.storageBuffer,
+        (internals.device.limits.maxSampledTexturesPerShaderStage ?? 0) >=
+          STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES,
       );
     }
     const variants = manifestEntry.variants;
@@ -1571,13 +1762,17 @@ async function makeWebGPURenderer(
       byRequest = new Map();
       materialShaderVariantResolutionCache.set(variants, byRequest);
     }
-    const cacheKey = `${requestedVariantSet ?? '\u0000'}|${internals.device.caps.backendKind}|${internals.device.caps.storageBuffer ? '1' : '0'}`;
+    const projectorAvailable =
+      (internals.device.limits.maxSampledTexturesPerShaderStage ?? 0) >=
+      STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
+    const cacheKey = `${requestedVariantSet ?? '\u0000'}|${internals.device.caps.backendKind}|${internals.device.caps.storageBuffer ? '1' : '0'}|${projectorAvailable ? '1' : '0'}`;
     if (byRequest.has(cacheKey)) return byRequest.get(cacheKey);
     const resolved = resolveMaterialShaderVariantSet(
       requestedVariantSet,
       variants,
       internals.device.caps.backendKind,
       internals.device.caps.storageBuffer,
+      projectorAvailable,
     );
     byRequest.set(cacheKey, resolved);
     return resolved;
@@ -1603,9 +1798,11 @@ 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 buildPipeline = (): Promise<PipelineState> =>
+  let temporalPostProcessesRegistered = false;
+  const buildPipeline = (scope: DeviceScope = activeDeviceScope): Promise<PipelineState> =>
     buildReadyWebGPU(
       internals.device,
+      scope,
       getShader,
       gpuStore,
       internals.pack.createShaderModule,
@@ -1644,13 +1841,34 @@ async function makeWebGPURenderer(
       // tonemap into this channel each frame (render-system-extract.ts w13).
       (source: string) => {
         if (tonemapRegistered) return;
-        renderSystem.registerBuiltinPostProcess(STANDARD_TONEMAP_FEATURE_ID, {
+        renderSystem.registerBuiltinPostProcess(STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, {
           source,
           params: { byteSize: 16, defaultValue: new Uint8Array(16) },
           reads: ['hdrColor'],
         });
         tonemapRegistered = true;
       },
+      (entries: { readonly motionBlur?: string; readonly taaResolve?: string }) => {
+        if (temporalPostProcessesRegistered) return;
+        if (entries.motionBlur !== undefined) {
+          renderSystem.registerBuiltinPostProcess('forgeax.motion-blur', {
+            source: entries.motionBlur,
+            params: { byteSize: 16, defaultValue: new Uint8Array(16) },
+            reads: ['scene-color', 'scene-temporal'],
+          });
+        }
+        if (entries.taaResolve !== undefined) {
+          renderSystem.registerBuiltinPostProcess('forgeax.taa-resolve', {
+            source: entries.taaResolve,
+            params: { byteSize: 16, defaultValue: new Uint8Array(16) },
+            reads: ['scene-color', 'scene-temporal', 'taa-history-color', 'taa-history-temporal'],
+          });
+        }
+        temporalPostProcessesRegistered = true;
+      },
+      (sources: VolumetricFogShaderSources) => {
+        internals.volumetricFogShaders = sources;
+      },
     );
   const ready: Promise<Result<void, RhiError>> = buildPipeline().then(
     (state): Result<void, RhiError> => {
@@ -1696,6 +1914,8 @@ async function makeWebGPURenderer(
       pbrManifestEntry,
       internals.device.caps.storageBuffer,
       variantSet,
+      (internals.device.limits.maxSampledTexturesPerShaderStage ?? 0) >=
+        STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES,
     );
     if (noColorVariant !== undefined && noColorVariant.composedWgsl !== standardEntry.wgsl) {
       return { ...standardEntry, wgsl: noColorVariant.composedWgsl };
@@ -1730,6 +1950,8 @@ async function makeWebGPURenderer(
     meshAttributes?: VertexAttributeMap,
     vertexLayout?: string,
     vertexLayoutProjection?: VertexLayoutProjection,
+    shaderModuleMode?: RenderFeatureShaderModuleMode,
+    layoutKindOverride?: LayoutKind,
   ) => {
     // bug-20260611: derive LayoutKind from materialShaderId (caller-driven)
     // so the selector body stays free of literal shader-id strings (AC-09).
@@ -1741,17 +1963,17 @@ async function makeWebGPURenderer(
     // through the HDRP layout branch of the selector — sprite shaders have
     // no HDRP variant, plan-strategy R-1' guard.
     const layoutKind: LayoutKind | undefined =
-      materialShaderId === SKIN_MATERIAL_SHADER_ID
+      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;
+            : undefined);
     const usesSharedBootMaterialLayout =
-      materialShaderId === 'forgeax::default-standard-pbr' ||
-      materialShaderId === 'forgeax::default-unlit' ||
-      materialShaderId === SKIN_MATERIAL_SHADER_ID;
+      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.
@@ -1759,12 +1981,11 @@ async function makeWebGPURenderer(
       !usesSharedBootMaterialLayout && layoutKind !== 'pbr-skin' && materialShaderId !== undefined
         ? getOrBuildPerShaderMaterialLayout(materialShaderId)
         : null;
-    // feat-20260621-learn-render-5-5-parallax M2 / w6 (D-1): a custom shader
-    // with >3 user-region textures owns a per-shader pipeline layout (its
-    // material BGL is wider than the shared built-in 18-entry). Skin / HDRP
-    // keep their dedicated layouts; everything else falls back to the shared
-    // URP/HDRP selector. 3-texture customs return null here -> shared layout
-    // (D-2 byte-for-byte).
+    // feat-20260621-learn-render-5-5-parallax M2 / w6 (D-1): an authored
+    // shader owns a per-shader pipeline layout derived from its paramSchema,
+    // because its compact texture order may differ from standard PBR even
+    // when it declares only a few textures. Skin / HDRP keep their dedicated
+    // layouts; built-in material IDs remain on the shared boot-time layout.
     const bindingContract =
       materialShaderId === undefined
         ? 'render-material'
@@ -1900,9 +2121,13 @@ async function makeWebGPURenderer(
                         ] satisfies readonly GPUVertexBufferLayout[]);
     return {
       device: internals.device,
-      shaderModuleFactory: getShaderModuleAdapter(),
+      shaderModuleFactory:
+        shaderModuleMode === 'immediate'
+          ? getImmediateShaderModuleAdapter()
+          : getShaderModuleAdapter(),
       pipelineLayout,
       vertexBuffers,
+      ...(layoutKind === 'pbr-skin' ? { layoutKind } : {}),
     };
   };
   /**
@@ -1960,6 +2185,8 @@ async function makeWebGPURenderer(
     depthFormatOverride?: GPUTextureFormat | null,
     vertexLayout?: string,
     vertexLayoutProjection?: VertexLayoutProjection,
+    shaderModuleMode?: RenderFeatureShaderModuleMode,
+    layoutKindOverride?: LayoutKind,
   ): RenderPipeline | null => {
     const ctx = buildPipelineContext(
       variantSet,
@@ -1967,6 +2194,8 @@ async function makeWebGPURenderer(
       meshAttributes,
       vertexLayout,
       vertexLayoutProjection,
+      shaderModuleMode,
+      layoutKindOverride,
     );
     if (ctx === null) return null;
     // bug-20260612: route the LDR color format through pipelineState so the
@@ -1976,6 +2205,11 @@ async function makeWebGPURenderer(
     // the explicit null check).
     if (pipelineState === null) return null;
     const ldrColorFormat = colorFormatOverride ?? pipelineState.colorAttachmentFormat;
+    const fragmentEntry =
+      isHdr &&
+      (materialShaderId === 'forgeax::sprite' || materialShaderId === 'forgeax::sprite-lit')
+        ? 'fs_main_hdr'
+        : undefined;
     const built = buildPipelineForMaterialShader(
       cacheKey,
       // The catalog entry is projected into the material-shader entry shape.
@@ -2009,7 +2243,7 @@ async function makeWebGPURenderer(
           }
         : undefined,
       undefined, // vertexEntry — default vs_main
-      undefined, // fragmentEntry — default fs_main
+      fragmentEntry,
       undefined, // defines — none
       passKind,
       sampleCount,
@@ -2068,6 +2302,8 @@ async function makeWebGPURenderer(
     depthFormatOverride?: GPUTextureFormat | null,
     vertexLayout?: string,
     vertexLayoutProjection?: VertexLayoutProjection,
+    shaderModuleMode: RenderFeatureShaderModuleMode = 'validated',
+    layoutKindOverride?: LayoutKind,
   ): RenderPipeline | null => {
     // WebGL2 is a downlevel backend even when the record stage asks for the
     // native-capability variant string. Resolve the variant axes at this
@@ -2082,7 +2318,14 @@ async function makeWebGPURenderer(
     // (stored in materialShaderUvSetCounts during prepareMaterialShaders).
     const resolvedUvSetCount = shaderUvSetCount ?? materialShaderUvSetCounts.get(materialShaderId);
     const manifestEntry = findMaterialShaderManifestEntry(materialShaderId);
-    const resolvedVariantSet = resolveCachedMaterialShaderVariantSet(variantSet, manifestEntry);
+    // Sprite's omitted request is the boot-selected default artifact. The
+    // explicit empty key remains the PER_INSTANCE_REGION=true request used by
+    // SpriteInstances, so only that path is capability-rewritten here.
+    const resolvedVariantSet =
+      variantSet === undefined &&
+      (materialShaderId === 'forgeax::sprite' || materialShaderId === 'forgeax::sprite-lit')
+        ? undefined
+        : resolveCachedMaterialShaderVariantSet(variantSet, manifestEntry);
     // The record stage also composes engine capability axes for user shaders.
     // Keep only manifest-declared axes for non-engine material IDs: a plain
     // custom shader must not collapse that request to '' because '' is the
@@ -2227,6 +2470,7 @@ async function makeWebGPURenderer(
           depthFormatOverride,
           vertexLayout,
           vertexLayoutProjection,
+          shaderModuleMode,
         );
       }
       const pbrEntry = findStandardPbrEntry(effectiveVariantSet);
@@ -2280,6 +2524,7 @@ async function makeWebGPURenderer(
         depthFormatOverride,
         vertexLayout,
         vertexLayoutProjection,
+        shaderModuleMode,
       );
     }
     // feat-20260609 M4 / w31: resolve variant WGSL from manifest when
@@ -2370,6 +2615,8 @@ async function makeWebGPURenderer(
       depthFormatOverride,
       vertexLayout,
       vertexLayoutProjection,
+      shaderModuleMode,
+      layoutKindOverride,
     );
   };
   const getParamSchema = (materialShaderId: string) => {
@@ -2378,10 +2625,11 @@ async function makeWebGPURenderer(
   };
   // 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 layout (empty for group-0 shaders, wider for >3-texture
-  // custom shaders). Returns undefined for the ordinary 3-texture path so the
-  // record stage falls back to the shared built-in materialBindGroupLayout.
+  // the matching paramSchema-derived layout. Returns undefined only for
+  // group-0 / view-only contracts or an unavailable shader layout; built-in
+  // material IDs continue to resolve through the shared layout path.
   const getMaterialBindGroupLayout = (materialShaderId: string): BindGroupLayout | undefined => {
+    if (isEngineOwnedMaterialShader(materialShaderId)) return undefined;
     const contract = getCachedMaterialShaderBindingContract(materialShaderId);
     if (contract === 'group-0') {
       return getOrBuildGroup0MaterialLayout()?.materialBgl;
@@ -2458,7 +2706,11 @@ async function makeWebGPURenderer(
       fragment: {
         module: moduleResult.value,
         entryPoint: 'fs_main',
-        targets: [{ format: colorFormat }],
+        targets:
+          entry.source.includes('@location(1) temporal') &&
+          entry.source.includes('TaaResolveOutput')
+            ? [{ format: colorFormat }, { format: colorFormat }]
+            : [{ format: colorFormat }],
       },
       primitive: { topology: 'triangle-list', cullMode: 'none', frontFace: 'ccw' },
       depthStencil: undefined,
@@ -2487,6 +2739,10 @@ async function makeWebGPURenderer(
     shaderModuleFactory: {
       createShaderModule: (descriptor) => getShaderModuleAdapter().createShaderModule(descriptor),
     },
+    immediateShaderModuleFactory: {
+      createShaderModule: (descriptor) =>
+        getImmediateShaderModuleAdapter().createShaderModule(descriptor),
+    },
     profiler: internals.options?.profiler,
     // feat-20260622-s5 M3 / w17: device + context read live off `internals` via
     // getters so the recover() rebuild (which swaps internals.device /
@@ -2499,6 +2755,9 @@ async function makeWebGPURenderer(
     get deviceScope() {
       return activeDeviceScope;
     },
+    invalidateShaderModule: (label: string) => {
+      sharedShaderModuleAdapter?.invalidateModule(label);
+    },
     get context() {
       return internals.context;
     },
@@ -2535,7 +2794,22 @@ async function makeWebGPURenderer(
     get meshSsboState() {
       return internals.meshSsboState;
     },
+    get volumetricFogShaders() {
+      return internals.volumetricFogShaders;
+    },
   });
+  if (
+    internals.device.caps.backendKind === 'null' &&
+    Array.from(getShader().entries()).length === 0
+  ) {
+    // RhiNull validates graph topology only; keep the built-in identity
+    // registered so structural frames do not fail before graph inspection.
+    renderSystem.registerBuiltinPostProcess(STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, {
+      source: '',
+      params: { byteSize: 16, defaultValue: new Uint8Array(16) },
+      reads: ['hdrColor'],
+    });
+  }
   // The Standard pipeline is the sole built-in graph owner. Feature plans are
   // projected into that graph directly; no second post-process registry is
   // installed for fullscreen producers.
@@ -2548,7 +2822,8 @@ async function makeWebGPURenderer(
   const transformReleases = new Map<World, () => void>();
   const attachmentOwner = {};
   let frameId = 0;
-  let latestReceipt: FrameReceipt | undefined;
+  const issuedReceipts = new WeakSet<FrameReceipt>();
+  const receiptTimings = new WeakMap<FrameReceipt, Promise<VolumeTimingObservation>>();
   let surfaceReleased = false;
 
   const renderer: RendererAssemblyImplementation = {
@@ -2596,6 +2871,23 @@ async function makeWebGPURenderer(
           : health.reason === 'internal-fault' || !readySettled
             ? 'faulted'
             : 'alive';
+      const surfaceStorage = pipelineState?.format ?? 'rgba8unorm';
+      const surfaceDisplay = pipelineState?.colorAttachmentFormat ?? 'rgba8unorm';
+      const observationId = `${STANDARD_OUTPUT_TRANSFORM_FEATURE_ID}:frame-${frameId}`;
+      const outputInspection = projectRendererOutputInspection({
+        graph: renderSystem.perFrameGraphInfo,
+        surfaceAvailable: !surfaceReleased && pipelineState !== null,
+        surfaceStorage,
+        surfaceDisplay,
+        ...(pipelineState?.surfaceProfile === undefined
+          ? {}
+          : { surfaceProfile: pipelineState.surfaceProfile }),
+        rgba16floatRenderable: internals.device.caps.rgba16floatRenderable,
+        ...(internals.context?.presentationProof === undefined
+          ? {}
+          : { presentationProof: internals.context.presentationProof }),
+      });
+      const volumetricFog = renderSystem.volumetricFog;
       return Object.freeze({
         state,
         surface: surfaceReleased ? 'released' : 'available',
@@ -2609,9 +2901,22 @@ async function makeWebGPURenderer(
           (internals.featureHost?.features ?? []).map((feature) => feature.identity),
         ),
         featureDiagnostics: internals.featureHost?.diagnostics() ?? Object.freeze([]),
+        volumetricFog,
         frustumStats: Object.freeze({ ...renderSystem.frustumStats }),
         visibilityStats: Object.freeze({ ...renderSystem.visibilityStats }),
         renderScene: renderSystem.renderScene,
+        environment: renderSystem.environment,
+        temporal: renderSystem.temporal,
+        bloom: renderSystem.bloom,
+        ...(renderSystem.temporalTargetInspection === undefined
+          ? {}
+          : { temporalTarget: Object.freeze(renderSystem.temporalTargetInspection) }),
+        ...(renderSystem.motionBlurInspection === undefined
+          ? {}
+          : { motionBlur: Object.freeze(renderSystem.motionBlurInspection) }),
+        ...(renderSystem.transmission === undefined
+          ? {}
+          : { transmission: renderSystem.transmission }),
         meshMaterialBindings: Object.freeze(
           renderSystem.meshMaterialBindings.map((observation) =>
             Object.freeze({
@@ -2630,6 +2935,22 @@ async function makeWebGPURenderer(
           createBindGroup: renderSystem.bindGroupCounts.createBindGroup,
           keys: Object.freeze([...renderSystem.bindGroupCounts.keys]),
         }),
+        ...outputInspection,
+        observation: Object.freeze({
+          observationId,
+          frameId,
+          ...(renderSystem.lastSuccessfulCameraAntialias === undefined
+            ? {}
+            : { antialias: renderSystem.lastSuccessfulCameraAntialias }),
+          ...(outputInspection.surfaceProfile === undefined
+            ? {}
+            : { surfaceProfile: outputInspection.surfaceProfile }),
+          rgba16floatRenderable: internals.device.caps.rgba16floatRenderable,
+          passNames: Object.freeze([...outputInspection.graphPassNames]),
+          ...(outputInspection.standardOutputColor === undefined
+            ? {}
+            : { standardOutputColor: Object.freeze({ ...outputInspection.standardOutputColor }) }),
+        }),
       });
     },
     get device(): RhiDevice {
@@ -2720,6 +3041,12 @@ async function makeWebGPURenderer(
     observeCurrentFrame(options: FrameObservationOptions) {
       return renderSystem.observeCurrentFrame(options);
     },
+    getCurrentGraphTarget(name: string) {
+      return renderSystem.getCurrentGraphTarget(name);
+    },
+    requestGraphTargetCapture(request) {
+      renderSystem.requestGraphTargetCapture(request);
+    },
     get frustumStats() {
       return renderSystem.frustumStats;
     },
@@ -2991,14 +3318,34 @@ async function makeWebGPURenderer(
       // Configure context lazily on first draw (D-S1 single-point
       // exemption): GPUCanvasContext.configure({device}) needs a raw
       // The canvas context is configured through the RHI device scope.
-      ensureContextConfigured(internals, pipelineState, internals.errorRegistry);
+      const contextConfigured = ensureContextConfigured(
+        internals,
+        pipelineState,
+        internals.errorRegistry,
+      );
+      if (!contextConfigured.ok) return contextConfigured;
       // w24 — facade-level try/catch produces Result.err on unexpected throw
       // (D-P6 dual-channel preserved: per-stage RhiError continues to fan out
       // through onError separately; the facade Result is the synchronous
       // summary AI users can ignore or branch on).
       try {
-        const submitted = renderSystem.draw(worlds, drawOptions, renderReadLeases);
+        const timingRequested =
+          isFrameRequest &&
+          (frameRequest?.profileFrame !== undefined ||
+            internals.options?.captureGpuTimings === true);
+        let timingCapture: GpuTimingCapture | undefined;
+        let timingUnavailableReason = timingRequested
+          ? 'timestamp capture is unavailable on this device'
+          : 'timestamp capture was not requested for this frame';
+        if (timingRequested) {
+          const createdTiming = GpuTimingCapture.create(internals.device);
+          if (createdTiming.ok) timingCapture = createdTiming.value;
+          else
+            timingUnavailableReason = `timestamp capture setup failed: ${createdTiming.error.code}`;
+        }
+        const submitted = renderSystem.draw(worlds, drawOptions, renderReadLeases, timingCapture);
         if (!submitted) {
+          timingCapture?.discard();
           return err(
             new RendererContractFailureError(
               'draw',
@@ -3028,7 +3375,15 @@ async function makeWebGPURenderer(
             deviceGeneration: receiptGeneration,
             completed,
           });
-          latestReceipt = receipt;
+          receiptTimings.set(
+            receipt,
+            timingCapture?.observation() ??
+              Promise.resolve({
+                status: 'unavailable',
+                reason: timingUnavailableReason,
+              }),
+          );
+          issuedReceipts.add(receipt);
           return ok(receipt);
         }
         return ok(undefined);
@@ -3053,10 +3408,8 @@ async function makeWebGPURenderer(
       request: FrameObservationRequest,
     ): Promise<RenderResult<FrameReceiptObservation, RenderError>> {
       if (
-        latestReceipt === undefined ||
-        latestReceipt !== receipt ||
-        latestReceipt.frameId !== receipt.frameId ||
-        latestReceipt.deviceGeneration !== receipt.deviceGeneration
+        !issuedReceipts.has(receipt) ||
+        receipt.deviceGeneration !== activeDeviceScope.generation
       ) {
         const currentGeneration = activeDeviceScope.generation;
         return err(
@@ -3079,11 +3432,19 @@ async function makeWebGPURenderer(
           }),
         );
       }
+      const timings = request.include.includes('timings')
+        ? await (receiptTimings.get(receipt) ??
+            Promise.resolve({
+              status: 'unavailable',
+              reason: 'timing receipt was not retained',
+            }))
+        : undefined;
       return ok(
         Object.freeze({
           frameId: receipt.frameId,
           deviceGeneration: receipt.deviceGeneration,
           include: Object.freeze([...request.include]),
+          ...(timings === undefined ? {} : { timings }),
         }),
       );
     },
@@ -3159,13 +3520,6 @@ async function makeWebGPURenderer(
       if (disposed) return ok(undefined);
       disposed = true;
       const cleanupFailures: RendererOperationCause[] = [];
-      try {
-        activeDeviceScope.dispose();
-      } catch (cause) {
-        const error = wrapDisposeError(cause, 'activeDeviceScope.dispose');
-        cleanupFailures.push(error);
-        internals.errorRegistry.fire(error);
-      }
       for (const world of attachedWorlds) {
         try {
           const derivedSystemName = derivedSystemNames.get(world);
@@ -3247,6 +3601,18 @@ async function makeWebGPURenderer(
         cleanupFailures.push(error);
         internals.errorRegistry.fire(error);
       }
+      // Retire assembly-owned device resources only after the surface and
+      // renderer-owned GPU pools have been released. The wgpu WebGL2 surface
+      // still needs a live device while `unconfigure()` presents its pending
+      // image; disposing the scope first lets wasm finalizers race that
+      // presentation and can surface a parking_lot panic in WebKit.
+      try {
+        activeDeviceScope.dispose();
+      } catch (cause) {
+        const error = wrapDisposeError(cause, 'activeDeviceScope.dispose');
+        cleanupFailures.push(error);
+        internals.errorRegistry.fire(error);
+      }
       // Step 5: the IBL cache is keyed by the retired DeviceScope generation.
       // It is no longer reachable through the active renderer scope, while
       // the device teardown owns the child GPU handles.
@@ -3326,6 +3692,7 @@ async function makeWebGPURenderer(
         // buffer (or crash the browser GPU process). Keep the ShaderCatalog's
         // CPU material/source catalogue, but rebuild this device-bound adapter.
         sharedShaderModuleAdapter = null;
+        sharedImmediateShaderModuleAdapter = null;
         // The fullscreen post-process builder keeps one empty group-0 layout
         // outside RenderSystem's frame cache. It is also device-bound, so retain
         // the source/registration but force the next post-process pass to derive
@@ -3352,7 +3719,7 @@ async function makeWebGPURenderer(
         let device: RhiDevice;
         try {
           const deviceResult = await adapterResult.value.requestDevice(
-            deviceOptionsForAdapter(adapterResult.value),
+            deviceOptionsForAdapter(adapterResult.value, internals.options),
           );
           if (!deviceResult.ok) {
             return err(new RecoverError('recover-device-unavailable'));
@@ -3372,6 +3739,13 @@ async function makeWebGPURenderer(
         // swap is observed without reconstructing the RenderSystem.
         internals.device = device;
         internals.context = ctxResult.value;
+        // Build the replacement graph under a fresh renderer-owned scope. The
+        // old committed scope remains authoritative until every rebuild step
+        // succeeds, so a failed recovery cannot publish a half-built scope.
+        const recoveryScope = DeviceScope.create(
+          activeDeviceScope.generation + 1,
+          activeDeviceScope.owner,
+        );
         // Re-attach the device.lost fan-out to the new device's lost Promise,
         // reusing the SAME registries the host already subscribed to (SSOT
         // helper). When this device is lost again, health() flips to
@@ -3419,10 +3793,13 @@ async function makeWebGPURenderer(
         // the first post-recovery upload; unlike CPU asset payloads, these
         // handles cannot survive a device replacement.
         dynamicTextureStore.configureGpuDevice(adaptDynamicTextureDevice(internals.device));
+        let candidatePipelineState: PipelineState | undefined;
         const abortDisposedRecovery = (): Result<void, RecoverFailure> | undefined => {
           if (!disposed) return undefined;
           gpuStore.destroyAll();
+          candidatePipelineState?.perPassResources.drainBloomResources?.();
           renderSystem.disposeFrameState();
+          recoveryScope.abandon();
           materialShaderPipelineCache.clear();
           perShaderMaterialLayoutCache.clear();
           group0ResourceLayouts.clear();
@@ -3441,7 +3818,7 @@ async function makeWebGPURenderer(
           );
           const abortedAfterShaders = abortDisposedRecovery();
           if (abortedAfterShaders !== undefined) return abortedAfterShaders;
-          pipelineState = await buildPipeline();
+          candidatePipelineState = await buildPipeline(recoveryScope);
           const abortedAfterPipeline = abortDisposedRecovery();
           if (abortedAfterPipeline !== undefined) return abortedAfterPipeline;
           renderSystem.restorePostProcessResources();
@@ -3449,6 +3826,8 @@ async function makeWebGPURenderer(
           // Pipeline rebuild failed against the new device. Treat as a device
           // unavailability (the device was acquired but is not usable); health
           // stays `device-lost` so the host can retry.
+          candidatePipelineState?.perPassResources.drainBloomResources?.();
+          recoveryScope.abandon();
           const aborted = abortDisposedRecovery();
           if (aborted !== undefined) return aborted;
           return err(new RecoverError('recover-device-unavailable'));
@@ -3456,27 +3835,18 @@ async function makeWebGPURenderer(
         const abortedAfterPostProcess = abortDisposedRecovery();
         if (abortedAfterPostProcess !== undefined) return abortedAfterPostProcess;
 
-        const replacementResult = await activeDeviceScope.replace(
-          activeDeviceScope.generation + 1,
-          [],
-        );
-        if (!replacementResult.ok) {
-          const detail = replacementResult.error.primary.detail;
-          return err(
-            new RenderRecoveryError(
-              disposed ? 'recover-disposed-during-rebuild' : 'recover-lifecycle-failed',
-              {
-                owner: detail.owner,
-                generation: detail.generation,
-                recovery: disposed ? 'stop' : 'recover',
-                receipt: replacementResult.error.receipt,
-                cause: replacementResult.error,
-              },
-            ),
-          );
+        // Promote only after the complete replacement build is ready. The old
+        // scope is then retired exactly once; a failed attempt abandons its
+        // candidate in the catch path and can be retried with a new generation.
+        if (candidatePipelineState === undefined) {
+          recoveryScope.abandon();
+          return err(new RecoverError('recover-device-unavailable'));
         }
-        activeDeviceScope = replacementResult.value;
+        const previousDeviceScope = activeDeviceScope;
+        activeDeviceScope = recoveryScope;
+        pipelineState = candidatePipelineState;
         gpuStore.bindDeviceScope(activeDeviceScope);
+        previousDeviceScope.retire();
 
         // Re-evaluate feature capability gates against the replacement device.
         // Feature recovery is isolated from renderer recovery: a feature that is
@@ -3574,7 +3944,7 @@ export function exposeRenderer(renderer: RendererHostImplementation): Renderer {
           );
     },
     setProfile: (profile) => {
-      if (currentState !== 'alive') {
+      if (!isRendererStateOperational(currentState)) {
         return err(
           new RendererOperationError('renderer-state-invalid', {
             operation: 'set-profile',
@@ -3647,7 +4017,7 @@ export function exposeRenderer(renderer: RendererHostImplementation): Renderer {
             const error = new RendererOperationError('recovery-failed', {
               operation: 'recover',
               oldGeneration,
-              cause: result.error,
+              cause: structuredRendererCause(result.error, 'recover'),
             });
             emit(Object.freeze({ kind: 'error', error }));
             return err(error);
@@ -3690,13 +4060,24 @@ function structuredRendererCause(cause: unknown, operation: string): RendererOpe
       typeof candidate.expected === 'string' &&
       typeof candidate.hint === 'string'
     ) {
-      return candidate as RendererOperationCause;
+      return {
+        code: candidate.code,
+        expected: candidate.expected,
+        hint: candidate.hint,
+        ...(candidate.detail === undefined ? {} : { detail: candidate.detail }),
+      };
     }
   }
-  return new RendererContractFailureError(
+  const contractFailure = new RendererContractFailureError(
     'draw',
     `${operation}: ${cause instanceof Error ? cause.message : String(cause)}`,
   );
+  return {
+    code: contractFailure.code,
+    expected: contractFailure.expected,
+    hint: contractFailure.hint,
+    detail: contractFailure.detail,
+  };
 }
 
 const RENDER_PROFILE_KEYS = new Set([
@@ -3711,6 +4092,7 @@ const RENDER_PROFILE_KEYS = new Set([
   'tone',
   'antialias',
   'sky',
+  'volumetricFog',
   'fallback',
   'postStages',
 ]);
@@ -3731,32 +4113,31 @@ function validateRenderProfile(profile: RenderProfile): string | undefined {
   if (profile.shadows !== 'off' && profile.shadows !== 'hard' && profile.shadows !== 'filtered') {
     return "RenderProfile.shadows must be 'off', 'hard', or 'filtered'";
   }
-  if (
-    profile.tone !== 'none' &&
-    profile.tone !== 'aces-filmic' &&
-    profile.tone !== 'agx' &&
-    profile.tone !== 'cineon' &&
-    profile.tone !== 'linear' &&
-    profile.tone !== 'neutral' &&
-    profile.tone !== 'reinhard' &&
-    profile.tone !== 'reinhard-extended'
-  ) {
-    return 'RenderProfile.tone is not a supported Standard tone';
-  }
-  if (
-    profile.antialias !== 'none' &&
-    profile.antialias !== 'fxaa' &&
-    profile.antialias !== 'msaa'
-  ) {
-    return "RenderProfile.antialias must be 'none', 'fxaa', or 'msaa'";
-  }
   if (profile.fallback !== 'native' && profile.fallback !== 'cpu-webgl2') {
     return "RenderProfile.fallback must be 'native' or 'cpu-webgl2'";
   }
-  for (const field of ['pbr', 'ibl', 'ssao', 'bloom', 'sky'] as const) {
+  for (const field of ['pbr', 'ibl', 'ssao'] as const) {
     if (typeof profile[field] !== 'boolean') return `RenderProfile.${field} must be boolean`;
   }
-  const stages = ['transparent-blend', 'bloom', 'tone', 'fxaa', 'output'] as const;
+  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) ||
     profile.postStages.length !== stages.length ||
@@ -3807,8 +4188,11 @@ interface ShaderDeviceAdapterInternal extends ShaderCatalogDevice {
    * `module-forgeax::default-shadow-caster` returns OK on frame 1.
    */
   seedModule(label: string, module: ShaderModule): void;
+  invalidateModule(label: string): void;
 }
 
+type ShaderModuleAdapterMode = 'validated' | 'immediate';
+
 function makeShaderDeviceAdapter(
   rhiDevice: RhiDevice,
   _errorRegistry: RhiErrorListenerRegistry,
@@ -3818,10 +4202,18 @@ function makeShaderDeviceAdapter(
         desc: { code: string; label?: string | undefined },
       ) => Promise<Result<ShaderModule, RhiError>>)
     | undefined,
+  immediateCreateShaderModule:
+    | ((
+        device: RhiDevice,
+        desc: { code: string; label?: string | undefined },
+      ) => Result<ShaderModule, RhiError>)
+    | undefined,
+  mode: ShaderModuleAdapterMode = 'validated',
 ): ShaderDeviceAdapterInternal {
   const moduleCache = new Map<string, ShaderModule>();
   const errorCache = new Map<string, RhiError>();
-  const pending = new Set<string>();
+  const pending = new Map<string, number>();
+  const epochs = new Map<string, number>();
 
   return {
     createShaderModule(desc): Result<ShaderModule, RhiError> {
@@ -3831,18 +4223,39 @@ function makeShaderDeviceAdapter(
       const cachedError = errorCache.get(key);
       if (cachedError !== undefined) return err(cachedError);
 
+      // WebGPU's raw createShaderModule is synchronous. Only the explicitly
+      // selected immediate adapter uses that entry: generated feature programs
+      // can avoid a slow getCompilationInfo() round trip, while the default
+      // validated adapter keeps the compiler-readiness barrier for ordinary
+      // render pipelines. The public async factory still owns diagnostics;
+      // pipeline creation remains the validation point for the fast path.
+      if (mode === 'immediate' && immediateCreateShaderModule !== undefined) {
+        const immediateResult = immediateCreateShaderModule(rhiDevice, {
+          code: desc.code,
+          ...(desc.label === undefined ? {} : { label: desc.label }),
+        });
+        if (immediateResult.ok) {
+          moduleCache.set(key, immediateResult.value);
+          return immediateResult;
+        }
+        errorCache.set(key, immediateResult.error);
+        return immediateResult;
+      }
+
       // Fire async creation; first sync call returns pending error (the AI consumer retry pattern).
       // M3 D-P4: rhi-webgpu supplies the async factory; rhi-wgpu (no top-level
       // async factory) falls back to the synchronous device.createShaderModule
       // entry which already returns Result<ShaderModule, RhiError>.
       if (!pending.has(key)) {
-        pending.add(key);
+        const epoch = epochs.get(key) ?? 0;
+        pending.set(key, epoch);
         const desc2: { code: string; label?: string | undefined } = { code: desc.code };
         if (desc.label !== undefined) desc2.label = desc.label;
         const asyncResult: Promise<Result<ShaderModule, RhiError>> = asyncCreateShaderModule
           ? asyncCreateShaderModule(rhiDevice, desc2)
           : invokeDeviceCreateShaderModule(rhiDevice, desc2);
         void asyncResult.then((result) => {
+          if (pending.get(key) !== epoch || (epochs.get(key) ?? 0) !== epoch) return;
           if (result.ok) {
             moduleCache.set(key, result.value);
           } else {
@@ -3857,6 +4270,12 @@ function makeShaderDeviceAdapter(
     seedModule(label: string, module: ShaderModule): void {
       moduleCache.set(label, module);
     },
+    invalidateModule(label: string): void {
+      epochs.set(label, (epochs.get(label) ?? 0) + 1);
+      moduleCache.delete(label);
+      errorCache.delete(label);
+      pending.delete(label);
+    },
   };
 }
 
@@ -4102,7 +4521,11 @@ const HDR_COLOR_ATTACHMENT_FORMAT: GPUTextureFormat = 'rgba16float';
 // so it is intentionally absent here. A `mipmap:true` texture in an
 // un-prewarmed format surfaces a structured RhiError at record (never an
 // async stall) -- the falsifiable anchor for an incomplete prewarm list.
-const MIPMAP_PREWARM_FORMATS: readonly GPUTextureFormat[] = ['rgba8unorm-srgb', 'rgba8unorm'];
+const MIPMAP_PREWARM_FORMATS: readonly GPUTextureFormat[] = [
+  'rgba8unorm-srgb',
+  'rgba8unorm',
+  'rgba16float',
+];
 
 // feat-20260531-bloom-first-declarative-render-graph-pass / w13:
 // UBO sizes for bloom params (std140 layout).
@@ -4491,6 +4914,14 @@ async function prepareMaterialShaders(
     if (!capCheck.ok) throw capCheck.error;
     storageBufferCapable = !webgl2Downlevel && capCheck.value;
   }
+  // The shared PBR view/material ABI consumes the WebGPU minimum of 16
+  // fragment sampled textures. The authored SpotLight projector is the
+  // optional 17th texture; select its shader/BGL pair from the same limit so
+  // low-limit adapters keep analytic lighting instead of failing layout
+  // creation at boot.
+  const projectorAvailable =
+    (rhiDevice.limits.maxSampledTexturesPerShaderStage ?? 0) >=
+    STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
 
   // ── Step 1: manifest load ─────────────────────────────────────────────────
   const registry = getShader();
@@ -4516,6 +4947,13 @@ async function prepareMaterialShaders(
     const variantDefines: Record<string, boolean> = {
       STORAGE_BUFFER_AVAILABLE: storageBufferCapable,
     };
+    // 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
+    // `STORAGE_BUFFER_AVAILABLE=false` key and fails before the first frame.
+    if (msEntry.variants.some((v) => 'WEBGL2_COMPAT' in v.defines)) {
+      variantDefines.WEBGL2_COMPAT = webgl2Downlevel;
+    }
     // Only include CLUSTER_FORWARD_AVAILABLE when the material shader declares
     // the axis (has a variant with this key), preserving backward compat for
     // entries without the pragma.
@@ -4525,6 +4963,18 @@ async function prepareMaterialShaders(
     if (msEntry.variants.some((v) => 'VERTEX_COLOR_AVAILABLE' in v.defines)) {
       variantDefines.VERTEX_COLOR_AVAILABLE = false;
     }
+    if (
+      msEntry.identifier === 'forgeax::default-standard-pbr' &&
+      msEntry.variants.some((v) => 'PROJECTOR_AVAILABLE' in v.defines)
+    ) {
+      variantDefines.PROJECTOR_AVAILABLE = projectorAvailable;
+    }
+    if (
+      msEntry.identifier === 'forgeax::default-standard-pbr' &&
+      msEntry.variants.some((v) => 'TRANSMISSION_AVAILABLE' in v.defines)
+    ) {
+      variantDefines.TRANSMISSION_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
@@ -4539,6 +4989,9 @@ async function prepareMaterialShaders(
     if (msEntry.variants.some((v) => 'PER_INSTANCE_REGION' in v.defines)) {
       variantDefines.PER_INSTANCE_REGION = false;
     }
+    if (msEntry.variants.some((v) => 'SKINNING_DISABLED' in v.defines)) {
+      variantDefines.SKINNING_DISABLED = true;
+    }
     const sortedEntries = Object.entries(variantDefines).sort(([a], [b]) =>
       a < b ? -1 : a > b ? 1 : 0,
     );
@@ -4546,6 +4999,13 @@ async function prepareMaterialShaders(
       ? ''
       : sortedEntries.map(([k, v]) => `${k}=${v}`).join('+');
     const chosen = findVariantByKey(msEntry, definesKey);
+    if (msEntry.variants.length > 0 && chosen === undefined) {
+      throw new RhiError({
+        code: 'shader-compile-failed',
+        expected: `material shader '${msEntry.identifier}' declares the exact boot variant '${definesKey}'`,
+        hint: 'regenerate the shader manifest with the complete variant Cartesian product',
+      });
+    }
     const wgsl = chosen?.composedWgsl ?? msEntry.composedWgsl;
     if (wgsl.length > 0) {
       const existing = registry.findMaterialArtifact(msEntry.identifier);
@@ -4627,6 +5087,7 @@ async function prepareMaterialShaders(
 
 async function buildReadyWebGPU(
   rhiDevice: RhiDevice,
+  rendererScope: DeviceScope,
   getShader: () => ShaderCatalog,
   gpuStore: GpuResidencyCache,
   asyncCreateShaderModule:
@@ -4680,6 +5141,12 @@ 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,
+  registerBuiltinTemporalPostProcesses: (entries: {
+    readonly motionBlur?: string;
+    readonly taaResolve?: string;
+  }) => void,
+  /** Install manifest-owned volume utility sources only after all three modules compile. */
+  setVolumetricFogShaderSources: (sources: VolumetricFogShaderSources) => void,
 ): Promise<PipelineState> {
   // bug-20260610: WebGL2 fallback path — read storage-buffer capability up
   // front so both Step 2 (shader-module compile, where we patch engine
@@ -4697,6 +5164,9 @@ async function buildReadyWebGPU(
     const capCheck = assertStorageBufferCap(capValue);
     storageBufferCapable = capCheck.ok ? !webgl2Downlevel && capCheck.value : !webgl2Downlevel;
   }
+  const projectorAvailable =
+    (rhiDevice.limits.maxSampledTexturesPerShaderStage ?? 0) >=
+    STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
 
   // bug-20260612: choose swap-chain storage / view formats by backend.
   // Channel 2 (native WebGPU) follows navigator.gpu.getPreferredCanvasFormat();
@@ -4706,7 +5176,10 @@ async function buildReadyWebGPU(
   // pipeline target, configure() call, and color-attachment format —
   // single SSOT, no scattered branches. See selectSwapChainFormat
   // (above the SWAP_CHAIN_*_FORMAT historical constants).
-  const swapChainFormats = selectSwapChainFormat(storageBufferCapable);
+  const surfaceViewFormats =
+    (rhiDevice as unknown as { readonly surfaceViewFormats?: boolean }).surfaceViewFormats ??
+    !webgl2Downlevel;
+  const swapChainFormats = selectSwapChainFormat(storageBufferCapable, surfaceViewFormats);
   // The 'null' (headless RhiNull) backend has no UA preferred-canvas-format by
   // design; the rgba8unorm fallback is its intended steady state, not a
   // degraded one — firing 'rhi-not-available' there is territorially wrong
@@ -4811,6 +5284,7 @@ async function buildReadyWebGPU(
     let pbrEntry = findEngineManifestEntry('forgeax::default-standard-pbr');
     let unlitEntry = findEngineManifestEntry('forgeax::default-unlit');
     let tonemapEntry: ManifestEntry | undefined;
+    let motionBlurEntry: ManifestEntry | undefined;
     let spriteEntry: ManifestEntry | undefined;
     // sprite-lit identification marker is the `spriteLitShadeAccum`
     // helper (defined in sprite-lit.wgsl, absent from sprite.wgsl). The
@@ -4820,6 +5294,7 @@ async function buildReadyWebGPU(
     // their paramSchema mirror) does not mis-classify sprite-lit as
     // sprite.
     let spriteLitEntry: ManifestEntry | undefined;
+    let taaResolveEntry: ManifestEntry | undefined;
     let iblEquirectEntry: ManifestEntry | undefined;
     let iblIrradianceEntry: ManifestEntry | undefined;
     let iblPrefilterEntry: ManifestEntry | undefined;
@@ -4844,6 +5319,14 @@ async function buildReadyWebGPU(
         tonemapEntry ??= entry;
         continue;
       }
+      if (entry.wgsl.includes('MotionBlurParams')) {
+        motionBlurEntry ??= entry;
+        continue;
+      }
+      if (entry.wgsl.includes('fs_taa_resolve')) {
+        taaResolveEntry ??= entry;
+        continue;
+      }
       if (entry.wgsl.includes('spriteLitShadeAccum')) {
         // sprite-lit identification — must precede the `pivotAndSize`
         // marker since sprite-lit also carries that field (paramSchema
@@ -4985,10 +5468,12 @@ async function buildReadyWebGPU(
             (!('CLUSTER_FORWARD_AVAILABLE' in v.defines) ||
               v.defines.CLUSTER_FORWARD_AVAILABLE === false) &&
             (!('VERTEX_COLOR_AVAILABLE' in v.defines) ||
-              v.defines.VERTEX_COLOR_AVAILABLE === false),
+              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),
         );
-        const v =
-          exact ?? ms.variants.find((cand) => cand.defines.STORAGE_BUFFER_AVAILABLE === false);
+        const v = exact === undefined ? undefined : findVariantByKey(ms, exact.definesKey);
         if (v !== undefined) {
           idToVariantWgsl.set(ms.identifier, v.composedWgsl);
         }
@@ -5028,13 +5513,15 @@ async function buildReadyWebGPU(
           (!('CLUSTER_FORWARD_AVAILABLE' in variant.defines) ||
             variant.defines.CLUSTER_FORWARD_AVAILABLE === false) &&
           (!('VERTEX_COLOR_AVAILABLE' in variant.defines) ||
-            variant.defines.VERTEX_COLOR_AVAILABLE === false),
+            variant.defines.VERTEX_COLOR_AVAILABLE === false) &&
+          (!('PROJECTOR_AVAILABLE' in variant.defines) ||
+            variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) &&
+          (!('SKINNING_DISABLED' in variant.defines) ||
+            variant.defines.SKINNING_DISABLED === true) &&
+          (!('TRANSMISSION_AVAILABLE' in variant.defines) ||
+            variant.defines.TRANSMISSION_AVAILABLE === false),
       );
-      const variant =
-        exact ??
-        ms.variants.find(
-          (candidate) => candidate.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable,
-        );
+      const variant = exact === undefined ? undefined : findVariantByKey(ms, exact.definesKey);
       if (variant !== undefined) {
         idToRuntimeVariantWgsl.set(ms.identifier, variant.composedWgsl);
       }
@@ -5163,6 +5650,80 @@ async function buildReadyWebGPU(
       seedShaderModule(label, shaderResult.value);
     }
 
+    // The volume graph is authored from ECS state and therefore cannot be
+    // compiled while the static material manifest is assembled. Its pass
+    // encoder nevertheless uses the same shared lazy shader adapter, so the
+    // four utility modules must be prewarmed before the first synchronous
+    // draw. The sources come from the shader manifest (the package-owned WGSL
+    // files are the sole source of truth); compile all four first and only
+    // then publish the labels and source bundle. A partial bundle would let a
+    // later frame mix generations after a device recovery.
+    if (rhiDevice.caps.compute && rhiDevice.caps.storageTexture) {
+      const volumeSources = [
+        ['inject', 'volume_inject', (source: string) => source.includes('fn volume_inject(')],
+        ['temporal', 'volume_temporal', (source: string) => source.includes('fn volume_temporal(')],
+        [
+          'integrate',
+          'volume_integrate',
+          (source: string) => source.includes('fn volume_integrate('),
+        ],
+        ['composite', 'volume_composite', (source: string) => source.includes('fn volume_fs(')],
+      ] as const;
+      const resolved = volumeSources.map(([stage, label, matches]) => {
+        const entry = manifestEntries.find((candidate) => matches(candidate.wgsl));
+        return { stage, label, entry };
+      });
+      // Volumetric fog is an optional graph feature. Minimal hosts/tests may
+      // intentionally ship only material/post-process entries; keep those
+      // renderers bootable while still rejecting a partially declared volume
+      // bundle (which would otherwise fail later as a lazy pending pipeline).
+      const present = resolved.filter((candidate) => candidate.entry !== undefined).length;
+      if (present === 0) {
+        // No volume manifest entries: leave the source/module bundle unset and
+        // let the topology capability gate keep volume work disabled.
+      } else {
+        const missing = resolved.find((candidate) => candidate.entry === undefined);
+        if (missing !== undefined) {
+          throw new RhiError({
+            code: 'shader-compile-failed',
+            expected: 'shader manifest contains all four volumetric fog utility entries',
+            hint: `add the package-owned WGSL entry for '${missing.label}' to the engine shader manifest`,
+          });
+        }
+        const compiled = [] as Array<{
+          readonly stage: (typeof volumeSources)[number][0];
+          readonly label: string;
+          readonly source: string;
+          readonly module: ShaderModule;
+        }>;
+        for (const { stage, label, entry } of resolved) {
+          // `missing` above proves the narrowing for this loop; keep the guard
+          // explicit so a future refactor cannot publish an undefined source.
+          if (entry === undefined) throw new Error(`missing volumetric shader ${label}`);
+          const shaderResult = await runShimStep(
+            () =>
+              asyncCreateShaderModule
+                ? asyncCreateShaderModule(rhiDevice, { code: entry.wgsl, label })
+                : invokeDeviceCreateShaderModule(rhiDevice, { code: entry.wgsl, label }),
+            'shader-compile-failed',
+            `volumetric fog shader module '${label}' compiled`,
+            `inspect manifest WGSL for '${label}' and check device.features`,
+          );
+          if (!shaderResult.ok) throw shaderResult.error;
+          compiled.push({ stage, label, source: entry.wgsl, module: shaderResult.value });
+        }
+        for (const { label, module } of compiled) seedShaderModule(label, module);
+        setVolumetricFogShaderSources({
+          inject: compiled.find((candidate) => candidate.stage === 'inject')?.source as string,
+          temporal: compiled.find((candidate) => candidate.stage === 'temporal')?.source as string,
+          integrate: compiled.find((candidate) => candidate.stage === 'integrate')
+            ?.source as string,
+          composite: compiled.find((candidate) => candidate.stage === 'composite')
+            ?.source as string,
+        });
+      }
+    }
+
     const pbrShaderResult = await runShimStep(
       () =>
         asyncCreateShaderModule
@@ -5190,6 +5751,16 @@ async function buildReadyWebGPU(
     if (pbrVariant !== undefined) {
       seedShaderModule(`module-forgeax::default-standard-pbr#${pbrVariant.definesKey}`, pbrModule);
     }
+    const transmissionCapable =
+      (rhiDevice.limits.maxSampledTexturesPerShaderStage ?? 0) >=
+      STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
+    const transmissionVariants = transmissionCapable
+      ? selectStandardPbrTransmissionPrewarmVariants(
+          pbrManifestEntry,
+          storageBufferCapable,
+          projectorAvailable,
+        )
+      : [];
 
     // HDRP uses the canonical all-true variant key (`''`) and the lazy
     // material pipeline adapter therefore requests a distinct module label.
@@ -5197,9 +5768,36 @@ async function buildReadyWebGPU(
     // label. Color availability is part of the geometry-owned variant axis, so
     // both colored and no-color HDRP sources must be retained.
     const prewarmedHdrpModules = new Map<string, ShaderModule>([[pbrEntry.wgsl, pbrModule]]);
+    for (const transmissionVariant of transmissionVariants) {
+      const moduleLabel = `module-forgeax::default-standard-pbr#${transmissionVariant.definesKey}`;
+      let transmissionModule = prewarmedHdrpModules.get(transmissionVariant.composedWgsl);
+      if (transmissionModule === undefined) {
+        const transmissionModuleResult = await runShimStep(
+          () =>
+            asyncCreateShaderModule
+              ? asyncCreateShaderModule(rhiDevice, {
+                  code: transmissionVariant.composedWgsl,
+                  label: moduleLabel,
+                })
+              : invokeDeviceCreateShaderModule(rhiDevice, {
+                  code: transmissionVariant.composedWgsl,
+                  label: moduleLabel,
+                }),
+          'shader-compile-failed',
+          'Standard transmission shader module compiled',
+          'inspect the composed Standard transmission variant WGSL and check device.features',
+        );
+        if (!transmissionModuleResult.ok) throw transmissionModuleResult.error;
+        transmissionModule = transmissionModuleResult.value;
+        prewarmedHdrpModules.set(transmissionVariant.composedWgsl, transmissionModule);
+      }
+      seedShaderModule(moduleLabel, transmissionModule);
+    }
     for (const hdrpVariant of selectHdrpPbrPrewarmVariants(
       pbrManifestEntry,
       storageBufferCapable,
+      transmissionCapable,
+      projectorAvailable,
     )) {
       const moduleLabel = `module-forgeax::default-standard-pbr#${hdrpVariant.definesKey}`;
       let hdrpModule = prewarmedHdrpModules.get(hdrpVariant.composedWgsl);
@@ -5335,6 +5933,49 @@ async function buildReadyWebGPU(
       // uses so the lazy build's createShaderModule call hits OK on
       // frame 1.
       seedShaderModule('module-forgeax::default-shadow-caster', shadowCasterShaderResult.value);
+
+      // The shadow caster now has independent storage and skinning axes. The
+      // canonical all-true entry remains the ordinary static source through
+      // SKINNING_DISABLED=true; skinned meshes request the explicit false
+      // variant. Prewarm both for the active storage capability so neither
+      // path loses its first shadow frame to the lazy module retry contract.
+      const shadowCasterManifestEntry = Array.from(registry.materialShaderManifestEntries()).find(
+        (candidate) => candidate.identifier === 'forgeax::default-shadow-caster',
+      );
+      const activeShadowVariants = shadowCasterManifestEntry?.variants.filter(
+        (variant) =>
+          variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable &&
+          typeof variant.defines.SKINNING_DISABLED === 'boolean',
+      );
+      for (const variant of activeShadowVariants ?? []) {
+        if (variant.definesKey === '') {
+          seedShaderModule(
+            'module-forgeax::default-shadow-caster#',
+            shadowCasterShaderResult.value,
+          );
+          continue;
+        }
+        const variantShaderResult = await runShimStep(
+          () =>
+            asyncCreateShaderModule
+              ? asyncCreateShaderModule(rhiDevice, {
+                  code: variant.composedWgsl,
+                  label: `shadow_caster#${variant.definesKey}`,
+                })
+              : invokeDeviceCreateShaderModule(rhiDevice, {
+                  code: variant.composedWgsl,
+                  label: `shadow_caster#${variant.definesKey}`,
+                }),
+          'shader-compile-failed',
+          `shadow_caster variant ${variant.definesKey || '<default>'} compiled`,
+          'inspect the selected shadow_caster storage/skinning variant and device.features',
+        );
+        if (!variantShaderResult.ok) throw variantShaderResult.error;
+        seedShaderModule(
+          `module-forgeax::default-shadow-caster#${variant.definesKey}`,
+          variantShaderResult.value,
+        );
+      }
     }
 
     // feat-20260621 M-A3 (D-5): register the built-in tonemap onto the unified
@@ -5354,27 +5995,62 @@ async function buildReadyWebGPU(
     // 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
-    // first `getPostProcessPipeline(STANDARD_TONEMAP_FEATURE_ID, …)` hits the module cache
+    // first `getPostProcessPipeline(STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, …)` hits the module cache
     // synchronously and builds the pipeline on frame 1.
     const tonemapPrewarm = await runShimStep(
       () =>
         asyncCreateShaderModule
           ? asyncCreateShaderModule(rhiDevice, {
               code: tonemapEntry.wgsl,
-              label: `post-process-${STANDARD_TONEMAP_FEATURE_ID}-module`,
+              label: `post-process-${STANDARD_OUTPUT_TRANSFORM_FEATURE_ID}-module`,
             })
           : invokeDeviceCreateShaderModule(rhiDevice, {
               code: tonemapEntry.wgsl,
-              label: `post-process-${STANDARD_TONEMAP_FEATURE_ID}-module`,
+              label: `post-process-${STANDARD_OUTPUT_TRANSFORM_FEATURE_ID}-module`,
             }),
       'shader-compile-failed',
       'tonemap shader module compiled (unified post-process prewarm)',
       'inspect manifest tonemap entry composed wgsl; check device.features',
     );
     if (!tonemapPrewarm.ok) throw tonemapPrewarm.error;
-    seedShaderModule(`post-process-${STANDARD_TONEMAP_FEATURE_ID}-module`, tonemapPrewarm.value);
+    seedShaderModule(
+      `post-process-${STANDARD_OUTPUT_TRANSFORM_FEATURE_ID}-module`,
+      tonemapPrewarm.value,
+    );
     registerBuiltinTonemap(tonemapEntry.wgsl);
 
+    // Temporal fullscreen passes execute synchronously from the compiled graph,
+    // so their shader modules must be warmed before the initialization barrier
+    // resolves. Otherwise the first tight draw loop sees an asynchronous
+    // `rhi-not-available` result and leaves the temporal targets cleared even
+    // though the graph topology is present.
+    const prewarmTemporal = async (entry: ManifestEntry | undefined, id: string) => {
+      if (entry === undefined) return;
+      const prewarm = await runShimStep(
+        () =>
+          asyncCreateShaderModule
+            ? asyncCreateShaderModule(rhiDevice, {
+                code: entry.wgsl,
+                label: `post-process-${id}-module`,
+              })
+            : invokeDeviceCreateShaderModule(rhiDevice, {
+                code: entry.wgsl,
+                label: `post-process-${id}-module`,
+              }),
+        '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);
+    };
+    await prewarmTemporal(motionBlurEntry, 'forgeax.motion-blur');
+    await prewarmTemporal(taaResolveEntry, 'forgeax.taa-resolve');
+    registerBuiltinTemporalPostProcesses({
+      ...(motionBlurEntry === undefined ? {} : { motionBlur: motionBlurEntry.wgsl }),
+      ...(taaResolveEntry === undefined ? {} : { taaResolve: taaResolveEntry.wgsl }),
+    });
+
     // feat-20260520-2d-sprite-layer-mvp M-3 / w24: sprite shader module
     // is optional in the 3-tuple legacy manifest (back-compat for apps
     // that locked their manifest URL before this feat). With the
@@ -5410,6 +6086,36 @@ async function buildReadyWebGPU(
       // shares the generic per-MaterialShader lazy build path, which now
       // needs the explicit seed to preserve frame-1 readiness.
       seedShaderModule('module-forgeax::sprite', spriteShaderResult.value);
+      const spriteManifestEntry = Array.from(registry.materialShaderManifestEntries()).find(
+        (entry) => entry.identifier === 'forgeax::sprite',
+      );
+      const regionVariant = spriteManifestEntry?.variants.find(
+        (variant) =>
+          variant.defines.PER_INSTANCE_REGION === true &&
+          variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable,
+      );
+      if (regionVariant !== undefined) {
+        const regionShaderResult = await runShimStep(
+          () =>
+            asyncCreateShaderModule
+              ? asyncCreateShaderModule(rhiDevice, {
+                  code: regionVariant.composedWgsl,
+                  label: `sprite#${regionVariant.definesKey}`,
+                })
+              : invokeDeviceCreateShaderModule(rhiDevice, {
+                  code: regionVariant.composedWgsl,
+                  label: `sprite#${regionVariant.definesKey}`,
+                }),
+          'shader-compile-failed',
+          `sprite variant ${regionVariant.definesKey || '<default>'} compiled`,
+          'inspect the selected sprite PER_INSTANCE_REGION variant and device.features',
+        );
+        if (!regionShaderResult.ok) throw regionShaderResult.error;
+        seedShaderModule(
+          `module-forgeax::sprite#${regionVariant.definesKey}`,
+          regionShaderResult.value,
+        );
+      }
     }
 
     // feat-20260624-sprite-lit-shading-model-pure-2d-lighting M1' / t7:
@@ -5482,15 +6188,12 @@ async function buildReadyWebGPU(
       skyboxModule = skyboxShaderResult.value;
     }
 
-    // feat-20260531-bloom-first-declarative-render-graph-pass / w13:
-    // bloom shader modules are optional (apps with legacy manifests without
-    // bloom.wgsl continue to boot). Identified by the uniform-struct-name
-    // markers 'BloomBrightParams' / 'BloomBlurParams' / 'BloomCompositeParams'
-    // (see triage above; struct names survive naga_oil composition). When
-    // present, each module is compiled here; pipeline construction happens
-    // alongside the FXAA / tonemap pipelines below.
+    // Bloom shader modules remain available to the lazy Bloom pipeline owner.
+    // Their construction is still part of renderer readiness because the
+    // backend may expose only an asynchronous module factory; the expensive
+    // pipeline, binding, and parameter resources stay deferred until admission.
     if (bloomBrightEntry !== undefined) {
-      const brightShaderResult = await runShimStep(
+      const result = await runShimStep(
         () =>
           asyncCreateShaderModule
             ? asyncCreateShaderModule(rhiDevice, {
@@ -5505,17 +6208,14 @@ async function buildReadyWebGPU(
         'bloom-bright shader module compiled',
         'inspect manifest bloom-bright entry composed wgsl; check device.features',
       );
-      if (!brightShaderResult.ok) throw brightShaderResult.error;
-      bloomBrightModule = brightShaderResult.value;
+      if (!result.ok) throw result.error;
+      bloomBrightModule = result.value;
     }
     if (bloomBlurEntry !== undefined) {
-      const blurShaderResult = await runShimStep(
+      const result = await runShimStep(
         () =>
           asyncCreateShaderModule
-            ? asyncCreateShaderModule(rhiDevice, {
-                code: bloomBlurEntry.wgsl,
-                label: 'bloom-blur',
-              })
+            ? asyncCreateShaderModule(rhiDevice, { code: bloomBlurEntry.wgsl, label: 'bloom-blur' })
             : invokeDeviceCreateShaderModule(rhiDevice, {
                 code: bloomBlurEntry.wgsl,
                 label: 'bloom-blur',
@@ -5524,11 +6224,11 @@ async function buildReadyWebGPU(
         'bloom-blur shader module compiled',
         'inspect manifest bloom-blur entry composed wgsl; check device.features',
       );
-      if (!blurShaderResult.ok) throw blurShaderResult.error;
-      bloomBlurModule = blurShaderResult.value;
+      if (!result.ok) throw result.error;
+      bloomBlurModule = result.value;
     }
     if (bloomCompositeEntry !== undefined) {
-      const compositeShaderResult = await runShimStep(
+      const result = await runShimStep(
         () =>
           asyncCreateShaderModule
             ? asyncCreateShaderModule(rhiDevice, {
@@ -5543,8 +6243,8 @@ async function buildReadyWebGPU(
         'bloom-composite shader module compiled',
         'inspect manifest bloom-composite entry composed wgsl; check device.features',
       );
-      if (!compositeShaderResult.ok) throw compositeShaderResult.error;
-      bloomCompositeModule = compositeShaderResult.value;
+      if (!result.ok) throw result.error;
+      bloomCompositeModule = result.value;
     }
     // feat-20260612-hdrp-ssao M6 / w27: SSAO shader module compilation.
     // Optional manifest entry — absent on legacy manifests (zero-overhead
@@ -5576,11 +6276,11 @@ async function buildReadyWebGPU(
   // The factory builds 4 BindGroupLayouts (view + material + mesh-array +
   // instances) and the 4-slot pipeline layout in one call, throwing on each
   // device.createBindGroupLayout / device.createPipelineLayout failure.
-  // material BGL now carries 14 entries (material 0..6 + Skylight 7..13 via
+  // material BGL now carries 24 entries (material 0..16 + Skylight 17..23 via
   // mergeSkylightIntoMaterialBgl) -- pipeline layout itself stays at 4 slots,
   // no @group(4) allocated (D-5 round-4 fix for the round-2 maxBindGroups=4
   // BLOCKER). The unlit pipeline currently shares this 14-entry layout
-  // (carrying fallback identity at binding 7..13 from the record stage);
+  // (carrying fallback identity at binding 17..23 from the record stage);
   // future split via `buildUnlitMaterialBgl` is exposed for tests.
   //
   // feat-20260520-directional-light-shadow-mapping merge: view BGL entries
@@ -5591,7 +6291,13 @@ async function buildReadyWebGPU(
   // buildReadyWebGPU (above) so Step 2 (variant patch) and this layout
   // build read the same value.
   const pbrLayouts = runShimSyncStep(
-    () => ok(buildPbrPipelineLayouts(rhiDevice, { storageBuffer: storageBufferCapable })),
+    () =>
+      ok(
+        buildPbrPipelineLayouts(rhiDevice, {
+          storageBuffer: storageBufferCapable,
+          projectorAvailable,
+        }),
+      ),
     'webgpu-runtime-error',
     'buildPbrPipelineLayouts succeeded',
     'check device.limits.maxBindingsPerBindGroup (need >=14) and maxBindGroupsPerPipelineLayout',
@@ -5614,7 +6320,10 @@ async function buildReadyWebGPU(
   // (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.
   let hdrpPbrPipelineLayoutHandle: PipelineLayout | null = null;
-  {
+  // The cluster layout is storage-buffer backed. On the WebGL2/fallback
+  // capability tier its uniform-buffer projection exceeds the backend's
+  // fragment-stage limit, and HDRP is not a valid route there anyway.
+  if (storageBufferCapable) {
     const hdrpUnifiedBglDesc = createHdrpBindGroupLayoutDescriptor(storageBufferCapable);
     const hdrpUnifiedBglRes = rhiDevice.createBindGroupLayout(hdrpUnifiedBglDesc);
     if (hdrpUnifiedBglRes.ok) {
@@ -6922,6 +7631,59 @@ async function buildReadyWebGPU(
   let bloomBlurHParamsBufferHandle: Buffer | null = null;
   let bloomBlurVParamsBufferHandle: Buffer | null = null;
   let bloomCompositeParamsBufferHandle: Buffer | null = null;
+  let bloomResourcesReady = false;
+  let ensureBloomResources: (() => void) | undefined;
+  let bloomActiveBundle: BloomPersistentBundle | undefined;
+  let bloomCandidateBundle: BloomPersistentBundle | undefined;
+  const retiringBloomBundles = new Set<BloomPersistentBundle>();
+  let bloomGeneration = 0;
+  let lastSuccessfulBloomReceipts:
+    | import('../record/frame-snapshot').BloomFrameReceipts
+    | undefined;
+  const getBloomResourcesStable = (): BloomPersistentBundle | null =>
+    bloomCandidateBundle ?? bloomActiveBundle ?? null;
+  let commitBloomResources: (() => void) | undefined;
+  let discardBloomResources: (() => void) | undefined;
+  let retireBloomResources: ((completion: Promise<unknown>) => void) | undefined;
+  let drainBloomResources: (() => void) | undefined;
+  let inspectBloomResources:
+    | ((graph?: import('@forgeax/engine-render-graph').CompiledRenderGraphInfo) => BloomInspection)
+    | undefined;
+  const ensureBloomResourcesStable = (): void => {
+    ensureBloomResources?.();
+  };
+  const retireBloomResourcesStable = (completion: Promise<unknown>): void => {
+    retireBloomResources?.(completion);
+  };
+  const commitBloomResourcesStable = (): void => {
+    commitBloomResources?.();
+  };
+  const discardBloomResourcesStable = (): void => {
+    discardBloomResources?.();
+  };
+  const drainBloomResourcesStable = (): void => {
+    drainBloomResources?.();
+  };
+  const inspectBloomResourcesStable = (
+    graph?: import('@forgeax/engine-render-graph').CompiledRenderGraphInfo,
+  ): BloomInspection => {
+    return (
+      inspectBloomResources?.(graph) ?? {
+        graphStatus: 'empty',
+        enabled: false,
+        targetCount: 0,
+        targetBytes: 0,
+        resourceCount: 0,
+        passCount: 0,
+        encodeCount: 0,
+        bindGroupCount: 0,
+        uploadCount: 0,
+        residentChildBytes: 0,
+        generation: 0,
+        state: 'off',
+      }
+    );
+  };
   // feat-20260612-hdrp-ssao M6 / w26 + w43: SSAO pipeline handles (D-A).
   // calc + blur RenderPipeline pair sharing a dedicated 6-entry BGL.
   // Optional — null when manifest lacks hdrp-ssao entry.
@@ -7222,361 +7984,560 @@ async function buildReadyWebGPU(
     //   bloom-blur-v  : same BGL, same module as blur-h, V-axis texelSize
     //   bloom-composite: 2-tex + sampler + UBO@3 BGL, rgba16float target
 
-    // Shared bloom sampler: linear filter + clamp-to-edge (all 4 passes
-    // sample from textures using fullscreen triangle UVs).
-    if (bloomBrightModule !== null || bloomBlurModule !== null || bloomCompositeModule !== null) {
-      const bloomSamplerResult = runShimSyncStep(
-        () =>
-          rhiDevice.createSampler({
-            label: 'bloom-sampler',
-            magFilter: 'linear',
-            minFilter: 'linear',
-            mipmapFilter: 'linear',
-            addressModeU: 'clamp-to-edge',
-            addressModeV: 'clamp-to-edge',
-          }),
-        'webgpu-runtime-error',
-        'createSampler (bloom) succeeded',
-        'check device.limits.maxSamplersPerShaderStage',
-      );
-      if (!bloomSamplerResult.ok) throw bloomSamplerResult.error;
-      bloomSamplerHandle = bloomSamplerResult.value;
-    }
+    ensureBloomResources = (): void => {
+      if (bloomResourcesReady) return;
+      const candidateScope = rendererScope.createChild(`${rendererScope.owner}:standard-bloom`);
+      const adopt = <T>(
+        kind: Parameters<DeviceScope['_adopt']>[0],
+        value: T,
+        cleanup: (value: T) => void,
+      ): T => {
+        candidateScope._adopt(kind, value, cleanup);
+        return value;
+      };
+      try {
+        // Shared bloom sampler: linear filter + clamp-to-edge (all 4 passes
+        // sample from textures using fullscreen triangle UVs).
+        if (
+          bloomBrightModule !== null ||
+          bloomBlurModule !== null ||
+          bloomCompositeModule !== null
+        ) {
+          const bloomSamplerResult = runShimSyncStep(
+            () =>
+              rhiDevice.createSampler({
+                label: 'bloom-sampler',
+                magFilter: 'linear',
+                minFilter: 'linear',
+                mipmapFilter: 'linear',
+                addressModeU: 'clamp-to-edge',
+                addressModeV: 'clamp-to-edge',
+              }),
+            'webgpu-runtime-error',
+            'createSampler (bloom) succeeded',
+            'check device.limits.maxSamplersPerShaderStage',
+          );
+          if (!bloomSamplerResult.ok) throw bloomSamplerResult.error;
+          bloomSamplerHandle = adopt('binding', bloomSamplerResult.value, () => undefined);
+        }
 
-    // Bloom bright: 1-tex + sampler + UBO@2 BGL (D-4).
-    if (bloomBrightModule !== null && bloomSamplerHandle !== null) {
-      const brightBglResult = runShimSyncStep(
-        () =>
-          rhiDevice.createBindGroupLayout({
-            label: 'bloom-bright-bgl',
-            entries: [
-              {
-                binding: 0,
-                visibility: GPU_SHADER_STAGE_FRAGMENT,
-                texture: { sampleType: 'float', viewDimension: '2d' },
+        // Bloom bright: 1-tex + sampler + UBO@2 BGL (D-4).
+        if (bloomBrightModule !== null && bloomSamplerHandle !== null) {
+          const brightBglResult = runShimSyncStep(
+            () =>
+              rhiDevice.createBindGroupLayout({
+                label: 'bloom-bright-bgl',
+                entries: [
+                  {
+                    binding: 0,
+                    visibility: GPU_SHADER_STAGE_FRAGMENT,
+                    texture: { sampleType: 'float', viewDimension: '2d' },
+                  },
+                  {
+                    binding: 1,
+                    visibility: GPU_SHADER_STAGE_FRAGMENT,
+                    sampler: { type: 'filtering' },
+                  },
+                  {
+                    binding: 2,
+                    visibility: GPU_SHADER_STAGE_FRAGMENT,
+                    buffer: { type: 'uniform' },
+                  },
+                ],
+              }),
+            'webgpu-runtime-error',
+            'createBindGroupLayout(bloom-bright) succeeded',
+            'check device.limits.maxBindGroupsPerPipelineLayout',
+          );
+          if (!brightBglResult.ok) throw brightBglResult.error;
+          bloomBrightBglHandle = adopt('binding', brightBglResult.value, () => undefined);
+
+          const brightPlResult = runShimSyncStep(
+            () =>
+              rhiDevice.createPipelineLayout({
+                label: 'bloom-bright-pl',
+                bindGroupLayouts: [brightBglResult.value],
+              }),
+            'webgpu-runtime-error',
+            'createPipelineLayout(bloom-bright) succeeded',
+            'verify bloom-bright BindGroupLayout matches shader @group(0) bindings',
+          );
+          if (!brightPlResult.ok) throw brightPlResult.error;
+          adopt('binding', brightPlResult.value, () => undefined);
+
+          // M2-T4: bloom-bright pipeline via getOrBuildPipeline (lazy-build).
+          {
+            const brightSpec: PipelineSpec = {
+              shader: {
+                id: 'forgeax::post::bloom-bright',
+                passKind: 'post-process',
+                variantSet: undefined,
               },
-              {
-                binding: 1,
-                visibility: GPU_SHADER_STAGE_FRAGMENT,
-                sampler: { type: 'filtering' },
+              attachments: {
+                colorFormats: [HDR_COLOR_ATTACHMENT_FORMAT],
+                depthFormat: undefined,
+                sampleCount: 1,
               },
-              {
-                binding: 2,
-                visibility: GPU_SHADER_STAGE_FRAGMENT,
-                buffer: { type: 'uniform' },
+              geometry: {
+                topology: 'triangle-list',
+                stripIndexFormat: undefined,
+                vertexLayout: {},
               },
-            ],
-          }),
-        'webgpu-runtime-error',
-        'createBindGroupLayout(bloom-bright) succeeded',
-        'check device.limits.maxBindGroupsPerPipelineLayout',
-      );
-      if (!brightBglResult.ok) throw brightBglResult.error;
-      bloomBrightBglHandle = brightBglResult.value;
-
-      const brightPlResult = runShimSyncStep(
-        () =>
-          rhiDevice.createPipelineLayout({
-            label: 'bloom-bright-pl',
-            bindGroupLayouts: [brightBglResult.value],
-          }),
-        'webgpu-runtime-error',
-        'createPipelineLayout(bloom-bright) succeeded',
-        'verify bloom-bright BindGroupLayout matches shader @group(0) bindings',
-      );
-      if (!brightPlResult.ok) throw brightPlResult.error;
+              renderState: { cullMode: 'none' },
+            };
+            const modules = {
+              vertex: bloomBrightModule,
+              fragment: bloomBrightModule,
+              layout: brightPlResult.value,
+            };
+            try {
+              bloomBrightPipelineHandle = getOrBuildPipeline(
+                brightSpec,
+                pipelineDeviceProvider,
+                pipelineCache,
+                modules,
+              ) as RenderPipeline;
+              bloomBrightPipelineHandle = adopt(
+                'pipeline',
+                bloomBrightPipelineHandle,
+                () => undefined,
+              );
+            } catch (err) {
+              if (err instanceof PipelineSpecError) throw err;
+              throw new PipelineSpecError({
+                code: 'pipeline-build-failed',
+                detail: { cause: err },
+                hint: 'createRenderPipeline (bloom-bright fullscreen) failed; inspect gpuMessage',
+              });
+            }
+          }
 
-      // M2-T4: bloom-bright pipeline via getOrBuildPipeline (lazy-build).
-      {
-        const brightSpec: PipelineSpec = {
-          shader: {
-            id: 'forgeax::post::bloom-bright',
-            passKind: 'post-process',
-            variantSet: undefined,
-          },
-          attachments: {
-            colorFormats: [HDR_COLOR_ATTACHMENT_FORMAT],
-            depthFormat: undefined,
-            sampleCount: 1,
-          },
-          geometry: {
-            topology: 'triangle-list',
-            stripIndexFormat: undefined,
-            vertexLayout: {},
-          },
-          renderState: { cullMode: 'none' },
-        };
-        const modules = {
-          vertex: bloomBrightModule,
-          fragment: bloomBrightModule,
-          layout: brightPlResult.value,
-        };
-        try {
-          bloomBrightPipelineHandle = getOrBuildPipeline(
-            brightSpec,
-            pipelineDeviceProvider,
-            pipelineCache,
-            modules,
-          ) as RenderPipeline;
-        } catch (err) {
-          if (err instanceof PipelineSpecError) throw err;
-          throw new PipelineSpecError({
-            code: 'pipeline-build-failed',
-            detail: { cause: err },
-            hint: 'createRenderPipeline (bloom-bright fullscreen) failed; inspect gpuMessage',
+          // Bright params UBO: 16 B std140 (threshold f32 + 12 B pad).
+          const brightParamsResult = runShimSyncStep(
+            () =>
+              rhiDevice.createBuffer({
+                label: 'bloom-bright-params-ubo',
+                size: BRIGHT_PARAMS_BYTES,
+                usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+                mappedAtCreation: false,
+              }),
+            'webgpu-runtime-error',
+            'createBuffer (bloom-bright params UBO) succeeded',
+            'check device.limits.maxUniformBufferBindingSize',
+          );
+          if (!brightParamsResult.ok) throw brightParamsResult.error;
+          bloomBrightParamsBufferHandle = adopt('buffer', brightParamsResult.value, (value) => {
+            rhiDevice.destroyBuffer(value);
           });
         }
-      }
-
-      // Bright params UBO: 16 B std140 (threshold f32 + 12 B pad).
-      const brightParamsResult = runShimSyncStep(
-        () =>
-          rhiDevice.createBuffer({
-            label: 'bloom-bright-params-ubo',
-            size: BRIGHT_PARAMS_BYTES,
-            usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-            mappedAtCreation: false,
-          }),
-        'webgpu-runtime-error',
-        'createBuffer (bloom-bright params UBO) succeeded',
-        'check device.limits.maxUniformBufferBindingSize',
-      );
-      if (!brightParamsResult.ok) throw brightParamsResult.error;
-      bloomBrightParamsBufferHandle = brightParamsResult.value;
-    }
 
-    // Bloom blur H/V: same BGL (1-tex + sampler + UBO@2), same module,
-    // two separate pipelines with per-axis texelSize (D-1, D-4).
-    if (bloomBlurModule !== null && bloomSamplerHandle !== null) {
-      const blurBglResult = runShimSyncStep(
-        () =>
-          rhiDevice.createBindGroupLayout({
-            label: 'bloom-blur-bgl',
-            entries: [
-              {
-                binding: 0,
-                visibility: GPU_SHADER_STAGE_FRAGMENT,
-                texture: { sampleType: 'float', viewDimension: '2d' },
+        // Bloom blur H/V: same BGL (1-tex + sampler + UBO@2), same module,
+        // two separate pipelines with per-axis texelSize (D-1, D-4).
+        if (bloomBlurModule !== null && bloomSamplerHandle !== null) {
+          const blurBglResult = runShimSyncStep(
+            () =>
+              rhiDevice.createBindGroupLayout({
+                label: 'bloom-blur-bgl',
+                entries: [
+                  {
+                    binding: 0,
+                    visibility: GPU_SHADER_STAGE_FRAGMENT,
+                    texture: { sampleType: 'float', viewDimension: '2d' },
+                  },
+                  {
+                    binding: 1,
+                    visibility: GPU_SHADER_STAGE_FRAGMENT,
+                    sampler: { type: 'filtering' },
+                  },
+                  {
+                    binding: 2,
+                    visibility: GPU_SHADER_STAGE_FRAGMENT,
+                    buffer: { type: 'uniform' },
+                  },
+                ],
+              }),
+            'webgpu-runtime-error',
+            'createBindGroupLayout(bloom-blur) succeeded',
+            'check device.limits.maxBindGroupsPerPipelineLayout',
+          );
+          if (!blurBglResult.ok) throw blurBglResult.error;
+          bloomBlurBglHandle = adopt('binding', blurBglResult.value, () => undefined);
+
+          const blurPlResult = runShimSyncStep(
+            () =>
+              rhiDevice.createPipelineLayout({
+                label: 'bloom-blur-pl',
+                bindGroupLayouts: [blurBglResult.value],
+              }),
+            'webgpu-runtime-error',
+            'createPipelineLayout(bloom-blur) succeeded',
+            'verify bloom-blur BindGroupLayout matches shader @group(0) bindings',
+          );
+          if (!blurPlResult.ok) throw blurPlResult.error;
+          adopt('binding', blurPlResult.value, () => undefined);
+
+          // M2-T4: bloom-blur H/V pipelines via getOrBuildPipeline (lazy-build).
+          // H and V share the same PSO descriptor — only per-axis texelSize UBO
+          // distinguishes them at record time. getOrBuildPipeline cache-hit on the
+          // second call returns the same handle (identical spec, identical PSO).
+          {
+            const blurSpec: PipelineSpec = {
+              shader: {
+                id: 'forgeax::post::bloom-blur',
+                passKind: 'post-process',
+                variantSet: undefined,
               },
-              {
-                binding: 1,
-                visibility: GPU_SHADER_STAGE_FRAGMENT,
-                sampler: { type: 'filtering' },
+              attachments: {
+                colorFormats: [HDR_COLOR_ATTACHMENT_FORMAT],
+                depthFormat: undefined,
+                sampleCount: 1,
               },
-              {
-                binding: 2,
-                visibility: GPU_SHADER_STAGE_FRAGMENT,
-                buffer: { type: 'uniform' },
+              geometry: {
+                topology: 'triangle-list',
+                stripIndexFormat: undefined,
+                vertexLayout: {},
               },
-            ],
-          }),
-        'webgpu-runtime-error',
-        'createBindGroupLayout(bloom-blur) succeeded',
-        'check device.limits.maxBindGroupsPerPipelineLayout',
-      );
-      if (!blurBglResult.ok) throw blurBglResult.error;
-      bloomBlurBglHandle = blurBglResult.value;
+              renderState: { cullMode: 'none' },
+            };
+            const modules = {
+              vertex: bloomBlurModule,
+              fragment: bloomBlurModule,
+              layout: blurPlResult.value,
+              label: 'bloom-blur-h-pipeline',
+            };
+            try {
+              bloomBlurHPipelineHandle = getOrBuildPipeline(
+                blurSpec,
+                pipelineDeviceProvider,
+                pipelineCache,
+                modules,
+              ) as RenderPipeline;
+              bloomBlurHPipelineHandle = adopt(
+                'pipeline',
+                bloomBlurHPipelineHandle,
+                () => undefined,
+              );
+            } catch (err) {
+              if (err instanceof PipelineSpecError) throw err;
+              throw new PipelineSpecError({
+                code: 'pipeline-build-failed',
+                detail: { cause: err },
+                hint: 'createRenderPipeline (bloom-blur-h fullscreen) failed; inspect gpuMessage',
+              });
+            }
+            // V is cache-hit on the same spec (identical PSO; per-axis UBO differentiates at record time).
+            bloomBlurVPipelineHandle = bloomBlurHPipelineHandle;
+          }
 
-      const blurPlResult = runShimSyncStep(
-        () =>
-          rhiDevice.createPipelineLayout({
-            label: 'bloom-blur-pl',
-            bindGroupLayouts: [blurBglResult.value],
-          }),
-        'webgpu-runtime-error',
-        'createPipelineLayout(bloom-blur) succeeded',
-        'verify bloom-blur BindGroupLayout matches shader @group(0) bindings',
-      );
-      if (!blurPlResult.ok) throw blurPlResult.error;
+          // Blur params UBOs: 16 B std140 (texelSize.xy + radius + pad) each.
+          // bug-20260625: one per axis -- H and V must not share a buffer (the
+          // shared-buffer writeBuffer race made both passes blur vertically).
+          const blurHParamsResult = runShimSyncStep(
+            () =>
+              rhiDevice.createBuffer({
+                label: 'bloom-blur-h-params-ubo',
+                size: BLUR_PARAMS_BYTES,
+                usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+                mappedAtCreation: false,
+              }),
+            'webgpu-runtime-error',
+            'createBuffer (bloom-blur-h params UBO) succeeded',
+            'check device.limits.maxUniformBufferBindingSize',
+          );
+          if (!blurHParamsResult.ok) throw blurHParamsResult.error;
+          bloomBlurHParamsBufferHandle = adopt('buffer', blurHParamsResult.value, (value) => {
+            rhiDevice.destroyBuffer(value);
+          });
 
-      // M2-T4: bloom-blur H/V pipelines via getOrBuildPipeline (lazy-build).
-      // H and V share the same PSO descriptor — only per-axis texelSize UBO
-      // distinguishes them at record time. getOrBuildPipeline cache-hit on the
-      // second call returns the same handle (identical spec, identical PSO).
-      {
-        const blurSpec: PipelineSpec = {
-          shader: {
-            id: 'forgeax::post::bloom-blur',
-            passKind: 'post-process',
-            variantSet: undefined,
-          },
-          attachments: {
-            colorFormats: [HDR_COLOR_ATTACHMENT_FORMAT],
-            depthFormat: undefined,
-            sampleCount: 1,
-          },
-          geometry: {
-            topology: 'triangle-list',
-            stripIndexFormat: undefined,
-            vertexLayout: {},
-          },
-          renderState: { cullMode: 'none' },
-        };
-        const modules = {
-          vertex: bloomBlurModule,
-          fragment: bloomBlurModule,
-          layout: blurPlResult.value,
-          label: 'bloom-blur-h-pipeline',
-        };
-        try {
-          bloomBlurHPipelineHandle = getOrBuildPipeline(
-            blurSpec,
-            pipelineDeviceProvider,
-            pipelineCache,
-            modules,
-          ) as RenderPipeline;
-        } catch (err) {
-          if (err instanceof PipelineSpecError) throw err;
-          throw new PipelineSpecError({
-            code: 'pipeline-build-failed',
-            detail: { cause: err },
-            hint: 'createRenderPipeline (bloom-blur-h fullscreen) failed; inspect gpuMessage',
+          const blurVParamsResult = runShimSyncStep(
+            () =>
+              rhiDevice.createBuffer({
+                label: 'bloom-blur-v-params-ubo',
+                size: BLUR_PARAMS_BYTES,
+                usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+                mappedAtCreation: false,
+              }),
+            'webgpu-runtime-error',
+            'createBuffer (bloom-blur-v params UBO) succeeded',
+            'check device.limits.maxUniformBufferBindingSize',
+          );
+          if (!blurVParamsResult.ok) throw blurVParamsResult.error;
+          bloomBlurVParamsBufferHandle = adopt('buffer', blurVParamsResult.value, (value) => {
+            rhiDevice.destroyBuffer(value);
           });
         }
-        // V is cache-hit on the same spec (identical PSO; per-axis UBO differentiates at record time).
-        bloomBlurVPipelineHandle = bloomBlurHPipelineHandle;
-      }
-
-      // Blur params UBOs: 16 B std140 (texelSize.xy + radius + pad) each.
-      // bug-20260625: one per axis -- H and V must not share a buffer (the
-      // shared-buffer writeBuffer race made both passes blur vertically).
-      const blurHParamsResult = runShimSyncStep(
-        () =>
-          rhiDevice.createBuffer({
-            label: 'bloom-blur-h-params-ubo',
-            size: BLUR_PARAMS_BYTES,
-            usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-            mappedAtCreation: false,
-          }),
-        'webgpu-runtime-error',
-        'createBuffer (bloom-blur-h params UBO) succeeded',
-        'check device.limits.maxUniformBufferBindingSize',
-      );
-      if (!blurHParamsResult.ok) throw blurHParamsResult.error;
-      bloomBlurHParamsBufferHandle = blurHParamsResult.value;
-
-      const blurVParamsResult = runShimSyncStep(
-        () =>
-          rhiDevice.createBuffer({
-            label: 'bloom-blur-v-params-ubo',
-            size: BLUR_PARAMS_BYTES,
-            usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-            mappedAtCreation: false,
-          }),
-        'webgpu-runtime-error',
-        'createBuffer (bloom-blur-v params UBO) succeeded',
-        'check device.limits.maxUniformBufferBindingSize',
-      );
-      if (!blurVParamsResult.ok) throw blurVParamsResult.error;
-      bloomBlurVParamsBufferHandle = blurVParamsResult.value;
-    }
 
-    // Bloom composite: 2-tex + sampler + UBO@3 BGL (D-4, D-5).
-    if (bloomCompositeModule !== null && bloomSamplerHandle !== null) {
-      const compositeBglResult = runShimSyncStep(
-        () =>
-          rhiDevice.createBindGroupLayout({
-            label: 'bloom-composite-bgl',
-            entries: [
-              {
-                binding: 0,
-                visibility: GPU_SHADER_STAGE_FRAGMENT,
-                texture: { sampleType: 'float', viewDimension: '2d' },
-              },
-              {
-                binding: 1,
-                visibility: GPU_SHADER_STAGE_FRAGMENT,
-                texture: { sampleType: 'float', viewDimension: '2d' },
+        // Bloom composite: 2-tex + sampler + UBO@3 BGL (D-4, D-5).
+        if (bloomCompositeModule !== null && bloomSamplerHandle !== null) {
+          const compositeBglResult = runShimSyncStep(
+            () =>
+              rhiDevice.createBindGroupLayout({
+                label: 'bloom-composite-bgl',
+                entries: [
+                  {
+                    binding: 0,
+                    visibility: GPU_SHADER_STAGE_FRAGMENT,
+                    texture: { sampleType: 'float', viewDimension: '2d' },
+                  },
+                  {
+                    binding: 1,
+                    visibility: GPU_SHADER_STAGE_FRAGMENT,
+                    texture: { sampleType: 'float', viewDimension: '2d' },
+                  },
+                  {
+                    binding: 2,
+                    visibility: GPU_SHADER_STAGE_FRAGMENT,
+                    sampler: { type: 'filtering' },
+                  },
+                  {
+                    binding: 3,
+                    visibility: GPU_SHADER_STAGE_FRAGMENT,
+                    buffer: { type: 'uniform' },
+                  },
+                ],
+              }),
+            'webgpu-runtime-error',
+            'createBindGroupLayout(bloom-composite) succeeded',
+            'check device.limits.maxBindGroupsPerPipelineLayout',
+          );
+          if (!compositeBglResult.ok) throw compositeBglResult.error;
+          bloomCompositeBglHandle = adopt('binding', compositeBglResult.value, () => undefined);
+
+          const compositePlResult = runShimSyncStep(
+            () =>
+              rhiDevice.createPipelineLayout({
+                label: 'bloom-composite-pl',
+                bindGroupLayouts: [compositeBglResult.value],
+              }),
+            'webgpu-runtime-error',
+            'createPipelineLayout(bloom-composite) succeeded',
+            'verify bloom-composite BindGroupLayout matches shader @group(0) bindings',
+          );
+          if (!compositePlResult.ok) throw compositePlResult.error;
+          adopt('binding', compositePlResult.value, () => undefined);
+
+          // M2-T4: bloom-composite pipeline via getOrBuildPipeline (lazy-build).
+          {
+            const compositeSpec: PipelineSpec = {
+              shader: {
+                id: 'forgeax::post::bloom-composite',
+                passKind: 'post-process',
+                variantSet: undefined,
               },
-              {
-                binding: 2,
-                visibility: GPU_SHADER_STAGE_FRAGMENT,
-                sampler: { type: 'filtering' },
+              attachments: {
+                colorFormats: [HDR_COLOR_ATTACHMENT_FORMAT],
+                depthFormat: undefined,
+                sampleCount: 1,
               },
-              {
-                binding: 3,
-                visibility: GPU_SHADER_STAGE_FRAGMENT,
-                buffer: { type: 'uniform' },
+              geometry: {
+                topology: 'triangle-list',
+                stripIndexFormat: undefined,
+                vertexLayout: {},
               },
-            ],
-          }),
-        'webgpu-runtime-error',
-        'createBindGroupLayout(bloom-composite) succeeded',
-        'check device.limits.maxBindGroupsPerPipelineLayout',
-      );
-      if (!compositeBglResult.ok) throw compositeBglResult.error;
-      bloomCompositeBglHandle = compositeBglResult.value;
+              renderState: { cullMode: 'none' },
+            };
+            const modules = {
+              vertex: bloomCompositeModule,
+              fragment: bloomCompositeModule,
+              layout: compositePlResult.value,
+            };
+            try {
+              bloomCompositePipelineHandle = getOrBuildPipeline(
+                compositeSpec,
+                pipelineDeviceProvider,
+                pipelineCache,
+                modules,
+              ) as RenderPipeline;
+              bloomCompositePipelineHandle = adopt(
+                'pipeline',
+                bloomCompositePipelineHandle,
+                () => undefined,
+              );
+            } catch (err) {
+              if (err instanceof PipelineSpecError) throw err;
+              throw new PipelineSpecError({
+                code: 'pipeline-build-failed',
+                detail: { cause: err },
+                hint: 'createRenderPipeline (bloom-composite fullscreen) failed; inspect gpuMessage',
+              });
+            }
+          }
 
-      const compositePlResult = runShimSyncStep(
-        () =>
-          rhiDevice.createPipelineLayout({
-            label: 'bloom-composite-pl',
-            bindGroupLayouts: [compositeBglResult.value],
-          }),
-        'webgpu-runtime-error',
-        'createPipelineLayout(bloom-composite) succeeded',
-        'verify bloom-composite BindGroupLayout matches shader @group(0) bindings',
-      );
-      if (!compositePlResult.ok) throw compositePlResult.error;
+          // Composite params UBO: 16 B std140 (intensity f32 + 12 B pad).
+          const compositeParamsResult = runShimSyncStep(
+            () =>
+              rhiDevice.createBuffer({
+                label: 'bloom-composite-params-ubo',
+                size: COMPOSITE_PARAMS_BYTES,
+                usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+                mappedAtCreation: false,
+              }),
+            'webgpu-runtime-error',
+            'createBuffer (bloom-composite params UBO) succeeded',
+            'check device.limits.maxUniformBufferBindingSize',
+          );
+          if (!compositeParamsResult.ok) throw compositeParamsResult.error;
+          bloomCompositeParamsBufferHandle = adopt(
+            'buffer',
+            compositeParamsResult.value,
+            (value) => {
+              rhiDevice.destroyBuffer(value);
+            },
+          );
+        }
 
-      // M2-T4: bloom-composite pipeline via getOrBuildPipeline (lazy-build).
-      {
-        const compositeSpec: PipelineSpec = {
-          shader: {
-            id: 'forgeax::post::bloom-composite',
-            passKind: 'post-process',
-            variantSet: undefined,
-          },
-          attachments: {
-            colorFormats: [HDR_COLOR_ATTACHMENT_FORMAT],
-            depthFormat: undefined,
-            sampleCount: 1,
-          },
-          geometry: {
-            topology: 'triangle-list',
-            stripIndexFormat: undefined,
-            vertexLayout: {},
-          },
-          renderState: { cullMode: 'none' },
+        bloomCandidateBundle = {
+          scope: candidateScope,
+          generation: bloomGeneration + 1,
+          bloomBrightPipeline: bloomBrightPipelineHandle,
+          bloomBlurHPipeline: bloomBlurHPipelineHandle,
+          bloomBlurVPipeline: bloomBlurVPipelineHandle,
+          bloomCompositePipeline: bloomCompositePipelineHandle,
+          bloomBrightBindGroupLayout: bloomBrightBglHandle,
+          bloomBlurBindGroupLayout: bloomBlurBglHandle,
+          bloomCompositeBindGroupLayout: bloomCompositeBglHandle,
+          bloomSampler: bloomSamplerHandle,
+          bloomBrightParamsBuffer: bloomBrightParamsBufferHandle,
+          bloomBlurHParamsBuffer: bloomBlurHParamsBufferHandle,
+          bloomBlurVParamsBuffer: bloomBlurVParamsBufferHandle,
+          bloomCompositeParamsBuffer: bloomCompositeParamsBufferHandle,
         };
-        const modules = {
-          vertex: bloomCompositeModule,
-          fragment: bloomCompositeModule,
-          layout: compositePlResult.value,
+        inspectBloomResources = (graph): BloomInspection => {
+          const retiring = [...retiringBloomBundles].sort(
+            (left, right) => left.generation - right.generation,
+          );
+          const active = bloomActiveBundle?.scope.isAlive() ? bloomActiveBundle : undefined;
+          const liveRetiring = retiring.filter((bundle) => bundle.scope.state === 'retiring');
+          const selected = active ?? liveRetiring[liveRetiring.length - 1];
+          if (selected === undefined) {
+            return {
+              graphStatus: 'empty',
+              enabled: false,
+              targetCount: 0,
+              targetBytes: 0,
+              resourceCount: 0,
+              passCount: 0,
+              encodeCount: 0,
+              bindGroupCount: 0,
+              uploadCount: 0,
+              residentChildBytes: 0,
+              generation: 0,
+              state: 'off',
+            };
+          }
+          const state = active === undefined ? 'retiring' : 'active';
+          const ownedBundles = [...(active === undefined ? [] : [active]), ...liveRetiring];
+          const graphInspection = inspectStandardBloomGraph(graph);
+          const receipts = lastSuccessfulBloomReceipts ?? {
+            uploadCount: 0,
+            bindGroupCount: 0,
+            encodeCount: 0,
+          };
+          return {
+            graphStatus: active === undefined ? 'empty' : graphInspection.status,
+            enabled: active !== undefined,
+            targetCount: active === undefined ? 0 : graphInspection.targetCount,
+            targetBytes: active === undefined ? 0 : graphInspection.targetBytes,
+            resourceCount: ownedBundles.reduce(
+              (count, bundle) => count + bundle.scope.resourceDelta(),
+              0,
+            ),
+            passCount: active === undefined ? 0 : graphInspection.passCount,
+            encodeCount: active === undefined ? 0 : receipts.encodeCount,
+            bindGroupCount: active === undefined ? 0 : receipts.bindGroupCount,
+            uploadCount: active === undefined ? 0 : receipts.uploadCount,
+            residentChildBytes: 0,
+            generation: selected?.generation ?? 0,
+            state,
+          };
         };
-        try {
-          bloomCompositePipelineHandle = getOrBuildPipeline(
-            compositeSpec,
-            pipelineDeviceProvider,
-            pipelineCache,
-            modules,
-          ) as RenderPipeline;
-        } catch (err) {
-          if (err instanceof PipelineSpecError) throw err;
-          throw new PipelineSpecError({
-            code: 'pipeline-build-failed',
-            detail: { cause: err },
-            hint: 'createRenderPipeline (bloom-composite fullscreen) failed; inspect gpuMessage',
-          });
-        }
+        commitBloomResources = () => {
+          if (bloomCandidateBundle?.scope !== candidateScope) return;
+          bloomActiveBundle = bloomCandidateBundle;
+          bloomCandidateBundle = undefined;
+          bloomGeneration += 1;
+          bloomResourcesReady = true;
+        };
+        discardBloomResources = () => {
+          if (bloomCandidateBundle?.scope !== candidateScope) return;
+          candidateScope.abandon();
+          bloomCandidateBundle = undefined;
+          bloomResourcesReady = false;
+        };
+        const reportBloomFenceFailure = (cause: unknown): void => {
+          if (cause instanceof RhiError) {
+            errorRegistry.fire(cause);
+            return;
+          }
+          const detailError = {
+            code: 'bloom-fence-rejected',
+            message: String(cause),
+            ...(cause instanceof Error ? { name: cause.name } : {}),
+          };
+          errorRegistry.fire(
+            new RhiError({
+              code: 'webgpu-runtime-error',
+              expected: 'Bloom queue completion resolves after the submitted frame retires',
+              hint: 'inspect renderer errors for the queue completion cause',
+              detail: { error: detailError },
+            }),
+          );
+        };
+        retireBloomResources = (completion) => {
+          const retiring = bloomActiveBundle;
+          if (retiring === undefined) return;
+          bloomActiveBundle = undefined;
+          bloomResourcesReady = false;
+          retiringBloomBundles.add(retiring);
+          retiring.scope.beginRetire();
+          void completion.then(
+            () => {
+              if (!retiringBloomBundles.has(retiring)) return;
+              retiring.scope.retire();
+              retiringBloomBundles.delete(retiring);
+            },
+            (cause) => {
+              if (!retiringBloomBundles.has(retiring)) return;
+              reportBloomFenceFailure(cause);
+              retiring.scope.retire();
+              retiringBloomBundles.delete(retiring);
+            },
+          );
+        };
+        drainBloomResources = () => {
+          if (bloomCandidateBundle !== undefined) {
+            bloomCandidateBundle.scope.abandon();
+            bloomCandidateBundle = undefined;
+          }
+          if (bloomActiveBundle !== undefined) {
+            bloomActiveBundle.scope.retire();
+            bloomActiveBundle = undefined;
+          }
+          for (const retiring of retiringBloomBundles) retiring.scope.retire();
+          retiringBloomBundles.clear();
+          bloomResourcesReady = false;
+        };
+      } catch (cause) {
+        candidateScope.abandon();
+        if (bloomCandidateBundle?.scope === candidateScope) bloomCandidateBundle = undefined;
+        commitBloomResources = undefined;
+        discardBloomResources = undefined;
+        drainBloomResources = undefined;
+        bloomBrightPipelineHandle = null;
+        bloomBlurHPipelineHandle = null;
+        bloomBlurVPipelineHandle = null;
+        bloomCompositePipelineHandle = null;
+        bloomBrightBglHandle = null;
+        bloomBlurBglHandle = null;
+        bloomCompositeBglHandle = null;
+        bloomSamplerHandle = null;
+        bloomBrightParamsBufferHandle = null;
+        bloomBlurHParamsBufferHandle = null;
+        bloomBlurVParamsBufferHandle = null;
+        bloomCompositeParamsBufferHandle = null;
+        throw cause;
       }
-
-      // Composite params UBO: 16 B std140 (intensity f32 + 12 B pad).
-      const compositeParamsResult = runShimSyncStep(
-        () =>
-          rhiDevice.createBuffer({
-            label: 'bloom-composite-params-ubo',
-            size: COMPOSITE_PARAMS_BYTES,
-            usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-            mappedAtCreation: false,
-          }),
-        'webgpu-runtime-error',
-        'createBuffer (bloom-composite params UBO) succeeded',
-        'check device.limits.maxUniformBufferBindingSize',
-      );
-      if (!compositeParamsResult.ok) throw compositeParamsResult.error;
-      bloomCompositeParamsBufferHandle = compositeParamsResult.value;
-    }
+    };
 
     // ── feat-20260612-hdrp-ssao M6 / w26 + w43 + M8 / w37 ───────────────────
     //
@@ -7798,7 +8759,7 @@ async function buildReadyWebGPU(
     if (!prewarmRes.ok) throw prewarmRes.error;
   }
 
-  return {
+  const pipelineState: PipelineState = {
     // 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
@@ -7881,7 +8842,9 @@ async function buildReadyWebGPU(
     meshes: meshHandles,
     format: swapChainFormats.storage,
     colorAttachmentFormat: swapChainFormats.view,
+    surfaceProfile: surfaceViewFormats ? 'dual-view' : 'raw-only',
     viewBindGroupLayout: viewBglResult.value,
+    projectorAvailable,
     materialBindGroupLayout: materialBglResult.value,
     meshBindGroupLayout: meshArrayBglResult.value,
     viewUniformBuffer: viewUboResult.value,
@@ -7990,18 +8953,28 @@ async function buildReadyWebGPU(
       // (ensureLazyTexture, slot width/height tracking for size-drift rebuild).
       // BindGroup caches survive until the intermediate view is invalidated
       // by a resize (width/height drift forces null).
-      bloomBrightPipeline: bloomBrightPipelineHandle,
-      bloomBlurHPipeline: bloomBlurHPipelineHandle,
-      bloomBlurVPipeline: bloomBlurVPipelineHandle,
-      bloomCompositePipeline: bloomCompositePipelineHandle,
-      bloomBrightBindGroupLayout: bloomBrightBglHandle,
-      bloomBlurBindGroupLayout: bloomBlurBglHandle,
-      bloomCompositeBindGroupLayout: bloomCompositeBglHandle,
-      bloomSampler: bloomSamplerHandle,
-      bloomBrightParamsBuffer: bloomBrightParamsBufferHandle,
-      bloomBlurHParamsBuffer: bloomBlurHParamsBufferHandle,
-      bloomBlurVParamsBuffer: bloomBlurVParamsBufferHandle,
-      bloomCompositeParamsBuffer: bloomCompositeParamsBufferHandle,
+      bloomBrightPipeline: null,
+      bloomBlurHPipeline: null,
+      bloomBlurVPipeline: null,
+      bloomCompositePipeline: null,
+      bloomBrightBindGroupLayout: null,
+      bloomBlurBindGroupLayout: null,
+      bloomCompositeBindGroupLayout: null,
+      bloomSampler: null,
+      bloomBrightParamsBuffer: null,
+      bloomBlurHParamsBuffer: null,
+      bloomBlurVParamsBuffer: null,
+      bloomCompositeParamsBuffer: null,
+      ensureBloomResources: ensureBloomResourcesStable,
+      getBloomResources: getBloomResourcesStable,
+      commitBloomResources: commitBloomResourcesStable,
+      commitBloomFrameReceipts: (receipts) => {
+        lastSuccessfulBloomReceipts = receipts;
+      },
+      discardBloomResources: discardBloomResourcesStable,
+      retireBloomResources: retireBloomResourcesStable,
+      drainBloomResources: drainBloomResourcesStable,
+      inspectBloomResources: inspectBloomResourcesStable,
       bloomBrightTexture: null,
       bloomBrightView: null,
       bloomBrightWidth: 0,
@@ -8026,6 +8999,7 @@ async function buildReadyWebGPU(
       ssaoFallbackRawView: null,
     },
   };
+  return pipelineState;
 }
 
 /**
@@ -8050,8 +9024,8 @@ function ensureContextConfigured(
   internals: WebGPURendererInternals,
   state: PipelineState,
   errorRegistry: RhiErrorListenerRegistry,
-): void {
-  if (state.perPassResources.configured) return;
+): Result<void, RhiError> {
+  if (state.perPassResources.configured) return ok(undefined);
   // M6 / w41 (feat-20260510-rhi-resource-creation): configure goes through
   // the forgeax `RhiCanvasContext` surface; the shim resolves the forgeax
   // RhiDevice back to the underlying raw GPUDevice via RAW_DEVICE_MAP
@@ -8064,7 +9038,7 @@ function ensureContextConfigured(
   const configuredDevice = internals.pack.instrumentation?.resolveSurfaceDevice?.(internals.device);
   if (configuredDevice !== undefined && !configuredDevice.ok) {
     errorRegistry.fire(configuredDevice.error);
-    return;
+    return err(configuredDevice.error);
   }
   const cfgResult = configureSurface(
     internals.context,
@@ -8074,7 +9048,7 @@ function ensureContextConfigured(
   );
   if (!cfgResult.ok) {
     errorRegistry.fire(cfgResult.error);
-    return;
+    return err(cfgResult.error);
   }
   state.perPassResources.configured = true;
   // bug-20260612: write the actually-configured swap-chain storage format
@@ -8087,6 +9061,7 @@ function ensureContextConfigured(
   // `${storage}-srgb` partner — derived, not duplicated.
   (globalThis as { __forgeaxSwapChainFormat?: GPUTextureFormat }).__forgeaxSwapChainFormat =
     state.format;
+  return ok(undefined);
 }
 
 /**