@forgeax/engine-render 0.1.32 → 0.1.34

package/src/assembly/webgpu-ready.ts

@@ -30,6 +30,7 @@ import type { ManifestEntry } from '@forgeax/engine-types';
 import { handleSlot } from '@forgeax/engine-types';
 import { prewarmDepthOfField } from '../features/depth-of-field/depth-of-field-assembly';
 import { prewarmAtmosphereShaders } from './atmosphere-shader-prewarm';
+import { selectCloudShadowCompatibleEntry } from './cloud-shadow-entry';
 import { prewarmSsrShaders } from './ssr-shader-prewarm';
 
 export type { MaterialShaderManifestEntry } from '@forgeax/engine-shader';
@@ -57,7 +58,7 @@ import {
   FALLBACK_BYTES_PER_ROW,
   type SkylightFallback,
 } from '../ibl/skylight-bind-group';
-import type { BloomInspection } from '../inspection-types';
+import { type BloomInspection, emptyBloomInspection } from '../inspection-types';
 import type { DeviceScope, RhiErrorListenerRegistry } from '../lifecycle';
 import { assertStorageBufferCap } from '../light-buffer-layout';
 import {
@@ -85,11 +86,10 @@ import { deriveExtendedLightingCapability } from '../prepare/extended-lighting/r
 import type { BloomPersistentBundle } from '../record/render-context';
 import { SHADOW_CASTER_BUFFER_SIZE } from '../record/shadow-pass';
 import { POINTS_LINES_VIEW_BUFFER_SIZE } from '../record/view-ubo';
-import {
-  type AtmosphereShaderSources,
-  type SsrShaderSources,
-  STANDARD_OUTPUT_TRANSFORM_FEATURE_ID,
-  type VolumetricFogShaderSources,
+import type {
+  AtmosphereShaderSources,
+  SsrShaderSources,
+  VolumetricFogShaderSources,
 } from '../render-contract';
 import {
   MATERIAL_PER_ENTITY_STRIDE,
@@ -119,15 +119,17 @@ import {
   selectProbePrewarmVariants,
   selectStandardPbrTransmissionPrewarmVariants,
 } from './shader-prewarm-policy';
+import { createTemporalShaderPrewarmer } from './temporal-post-process-prewarm';
 import { buildGpuDrivenPbrReadyLayouts, buildGpuDrivenPbrReadyModules } from './webgpu-pbr-ready';
 import {
-  BLUR_PARAMS_BYTES,
-  BRIGHT_PARAMS_BYTES,
-  COMPOSITE_PARAMS_BYTES,
+  BLOOM_COMPOSITE_PARAMS_BYTES,
+  BLOOM_DOWNSAMPLE_PARAMS_BYTES,
+  BLOOM_UPSAMPLE_PARAMS_BYTES,
   HDR_COLOR_ATTACHMENT_FORMAT,
   VIEW_UBO_BYTES,
 } from './webgpu-ready-contract';
 import { prewarmMipmapPipeline } from './webgpu-ready-mipmap';
+import { createReadyPerPassResources } from './webgpu-ready-per-pass';
 
 /**
  * Build the `Renderer.initialization` Promise (D-S3 three-step strict-serial chain).
@@ -219,6 +221,7 @@ export async function buildReadyWebGPU(
   registerBuiltinTonemap: (source: string) => void,
   /** Register the special FXAA pass' final-output policy params UBO. */
   registerBuiltinFxaa: (source: string) => void,
+  registerBuiltinAnalyticFog: (source: string) => void,
   registerBuiltinTemporalPostProcesses: (entries: {
     readonly motionBlur?: string;
     readonly taaResolve?: string;
@@ -233,8 +236,7 @@ export async function buildReadyWebGPU(
 ): Promise<PipelineState> {
   const extendedLightingShaderAvailable = deriveExtendedLightingCapability(rhiDevice).admitted;
   // Shader and layout construction consume the same storage capability.
-  const capValue = (rhiDevice.limits as Readonly<Record<string, number>>)
-    .maxStorageBuffersPerShaderStage;
+  const capValue = rhiDevice.limits.maxStorageBuffersPerShaderStage;
   const webgl2Downlevel = rhiDevice.caps.backendKind === 'wgpu-webgl2';
   let storageBufferCapable = !webgl2Downlevel && rhiDevice.caps.storageBuffer;
   if (typeof capValue === 'number') {
@@ -320,8 +322,8 @@ export async function buildReadyWebGPU(
   let spriteLitModule: ShaderModule | null = null;
   let fxaaModule: ShaderModule | null = null;
   let skyboxModule: ShaderModule | null = null;
-  let bloomBrightModule: ShaderModule | null = null;
-  let bloomBlurModule: ShaderModule | null = null;
+  let bloomDownsampleModule: ShaderModule | null = null;
+  let bloomUpsampleModule: ShaderModule | null = null;
   let bloomCompositeModule: ShaderModule | null = null;
   let ssaoModule: ShaderModule | null = null;
   const findEngineManifestEntry = (identifier: string): ManifestEntry | undefined => {
@@ -385,8 +387,8 @@ export async function buildReadyWebGPU(
     let probeBackgroundEntry: ManifestEntry | undefined;
     let fxaaEntry: ManifestEntry | undefined;
     let skyboxEntry: ManifestEntry | undefined;
-    let bloomBrightEntry: ManifestEntry | undefined;
-    let bloomBlurEntry: ManifestEntry | undefined;
+    let bloomDownsampleEntry: ManifestEntry | undefined;
+    let bloomUpsampleEntry: ManifestEntry | undefined;
     let bloomCompositeEntry: ManifestEntry | undefined;
     let ssaoEntry: ManifestEntry | undefined;
     // feat-20260609 R3-fixup: shadow_caster module pre-bake. T-009 deleted
@@ -462,23 +464,16 @@ export async function buildReadyWebGPU(
         skyboxEntry ??= entry;
         continue;
       }
-      // feat-20260531-bloom-first-declarative-render-graph-pass / w13:
-      // bloom marker triage (D-7). Identify the 3 bloom WGSL modules by their
-      // unique uniform-struct names ('BloomBrightParams' in bloom-bright.wgsl,
-      // 'BloomBlurParams' in bloom-blur.wgsl shared by H/V pipelines,
-      // 'BloomCompositeParams' in bloom-composite.wgsl). Struct names are naga
-      // IR and survive naga_oil composition unchanged -- unlike the original
-      // `// bloomBrightExtract` content-marker COMMENTS, which naga's WGSL
-      // writeback drops (comments are not part of the IR), leaving the markers
-      // absent from the composed `entry.wgsl` so the triage never matched and
-      // bloom silently never initialised (bug-20260625). Same survives-naga
-      // rationale as the SSAO `fs_ssao_calc` entry-point marker below.
-      if (entry.wgsl.includes('BloomBrightParams')) {
-        bloomBrightEntry ??= entry;
+      // Multiscale Bloom marker triage. The composed WGSL retains these
+      // uniform-struct names through naga_oil, so shader ownership is resolved
+      // from the cooked manifest rather than from a runtime compiler or a
+      // second heuristic path.
+      if (entry.wgsl.includes('BloomDownsampleParams')) {
+        bloomDownsampleEntry ??= entry;
         continue;
       }
-      if (entry.wgsl.includes('BloomBlurParams')) {
-        bloomBlurEntry ??= entry;
+      if (entry.wgsl.includes('BloomUpsampleParams')) {
+        bloomUpsampleEntry ??= entry;
         continue;
       }
       if (entry.wgsl.includes('BloomCompositeParams')) {
@@ -595,11 +590,25 @@ export async function buildReadyWebGPU(
       return wgsl !== undefined ? { ...entry, wgsl } : entry;
     };
     pbrEntry = patchRuntimeVariant(pbrEntry, 'forgeax::default-standard-pbr');
+    const pbrMaterialEntry = Array.from(registry.materialShaderManifestEntries()).find(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+    pbrEntry = selectCloudShadowCompatibleEntry(pbrEntry, pbrMaterialEntry, projectorAvailable);
     if (pbrSkinEntry !== undefined) {
       pbrSkinEntry = patchRuntimeVariant(
         patchRuntimeVariant(pbrSkinEntry, SKIN_MATERIAL_SHADER_ID),
         'forgeax::default-standard-pbr-skin',
       );
+      const pbrSkinMaterialEntry = Array.from(registry.materialShaderManifestEntries()).find(
+        (entry) =>
+          entry.identifier === SKIN_MATERIAL_SHADER_ID ||
+          entry.identifier === 'forgeax::default-standard-pbr-skin',
+      );
+      pbrSkinEntry = selectCloudShadowCompatibleEntry(
+        pbrSkinEntry,
+        pbrSkinMaterialEntry,
+        projectorAvailable,
+      );
     }
     unlitEntry = patchRuntimeVariant(unlitEntry, 'forgeax::default-unlit');
     if (shadowCasterEntry !== undefined) {
@@ -698,7 +707,7 @@ export async function buildReadyWebGPU(
       seedShaderModule,
     });
     for (const postProcess of requiredFullscreenPostProcesses) {
-      const label = postProcessShaderModuleLabel(postProcess.identity, postProcess.source);
+      const label = postProcessShaderModuleLabel(postProcess.source);
       const shaderResult = await runShimStep(
         () =>
           asyncCreateShaderModule
@@ -1116,7 +1125,7 @@ export async function buildReadyWebGPU(
     // frames (e.g. the hello-tonemap dawn smoke) would stall on a black frame
     // forever. Mirror the shadow_caster prewarm: await-compile the tonemap module
     // here and `seedShaderModule` it under the exact label
-    // `buildPostProcessPipeline` requests (`post-process-${id}-module`), so the
+    // `buildPostProcessPipeline` requests (keyed by shader source), so the
     // first `getPostProcessPipeline(STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, …)` hits the module cache
     // synchronously and builds the pipeline on frame 1.
     const tonemapPrewarm = await runShimStep(
@@ -1124,51 +1133,30 @@ export async function buildReadyWebGPU(
         asyncCreateShaderModule
           ? asyncCreateShaderModule(rhiDevice, {
               code: tonemapEntry.wgsl,
-              label: postProcessShaderModuleLabel(
-                STANDARD_OUTPUT_TRANSFORM_FEATURE_ID,
-                tonemapEntry.wgsl,
-              ),
+              label: postProcessShaderModuleLabel(tonemapEntry.wgsl),
             })
           : invokeDeviceCreateShaderModule(rhiDevice, {
               code: tonemapEntry.wgsl,
-              label: postProcessShaderModuleLabel(
-                STANDARD_OUTPUT_TRANSFORM_FEATURE_ID,
-                tonemapEntry.wgsl,
-              ),
+              label: postProcessShaderModuleLabel(tonemapEntry.wgsl),
             }),
       '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(
-      postProcessShaderModuleLabel(STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, tonemapEntry.wgsl),
-      tonemapPrewarm.value,
-    );
+    seedShaderModule(postProcessShaderModuleLabel(tonemapEntry.wgsl), tonemapPrewarm.value);
     registerBuiltinTonemap(tonemapEntry.wgsl);
 
     // Prewarm temporal fullscreen modules before readiness so first-frame
     // recording cannot encounter an asynchronous compile miss.
-    const prewarmTemporal = async (entry: ManifestEntry | undefined, id: string) => {
-      if (entry === undefined) return;
-      const prewarm = await runShimStep(
-        () =>
-          asyncCreateShaderModule
-            ? asyncCreateShaderModule(rhiDevice, {
-                code: entry.wgsl,
-                label: postProcessShaderModuleLabel(id, entry.wgsl),
-              })
-            : invokeDeviceCreateShaderModule(rhiDevice, {
-                code: entry.wgsl,
-                label: postProcessShaderModuleLabel(id, entry.wgsl),
-              }),
-        'shader-compile-failed',
-        `${id} shader module compiled (unified post-process prewarm)`,
-        `inspect manifest ${id} entry composed wgsl; check device.features`,
-      );
-      if (!prewarm.ok) throw prewarm.error;
-      seedShaderModule(postProcessShaderModuleLabel(id, entry.wgsl), prewarm.value);
-    };
+    const prewarmTemporal = createTemporalShaderPrewarmer({
+      device: rhiDevice,
+      asyncCreateShaderModule,
+      seedShaderModule,
+    });
+    const analyticFogEntry = findEngineManifestEntry('forgeax::analytic-fog');
+    await prewarmTemporal(analyticFogEntry, 'forgeax.analytic-fog');
+    if (analyticFogEntry !== undefined) registerBuiltinAnalyticFog(analyticFogEntry.wgsl);
     await prewarmTemporal(motionBlurEntry, 'forgeax.motion-blur');
     await prewarmTemporal(taaResolveEntry, 'forgeax.taa-resolve');
     await prewarmDepthOfField(manifestEntries, prewarmTemporal, registerBuiltinDepthOfField);
@@ -1326,6 +1314,12 @@ export async function buildReadyWebGPU(
       if (!fxaaShaderResult.ok) throw fxaaShaderResult.error;
       fxaaModule = fxaaShaderResult.value;
       registerBuiltinFxaa(fxaaEntry.wgsl);
+      // The typed graph may need a second FXAA pipeline for a graph-owned
+      // linear-LDR target (for example BarrelDistortion + FXAA). Seed the
+      // shared post-process adapter with the already compiled module so that
+      // this alternate color format is available on the first submitted
+      // frame instead of waiting for an async recompile.
+      seedShaderModule(postProcessShaderModuleLabel(fxaaEntry.wgsl), fxaaModule);
     }
 
     // feat-20260531-skybox-env-background M3 / w15: skybox shader module.
@@ -1354,40 +1348,43 @@ export async function buildReadyWebGPU(
     // 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) {
+    if (bloomDownsampleEntry !== undefined) {
       const result = await runShimStep(
         () =>
           asyncCreateShaderModule
             ? asyncCreateShaderModule(rhiDevice, {
-                code: bloomBrightEntry.wgsl,
-                label: 'bloom-bright',
+                code: bloomDownsampleEntry.wgsl,
+                label: 'bloom-downsample',
               })
             : invokeDeviceCreateShaderModule(rhiDevice, {
-                code: bloomBrightEntry.wgsl,
-                label: 'bloom-bright',
+                code: bloomDownsampleEntry.wgsl,
+                label: 'bloom-downsample',
               }),
         'shader-compile-failed',
-        'bloom-bright shader module compiled',
-        'inspect manifest bloom-bright entry composed wgsl; check device.features',
+        'bloom-downsample shader module compiled',
+        'inspect manifest bloom-downsample entry composed wgsl; check device.features',
       );
       if (!result.ok) throw result.error;
-      bloomBrightModule = result.value;
+      bloomDownsampleModule = result.value;
     }
-    if (bloomBlurEntry !== undefined) {
+    if (bloomUpsampleEntry !== undefined) {
       const result = await runShimStep(
         () =>
           asyncCreateShaderModule
-            ? asyncCreateShaderModule(rhiDevice, { code: bloomBlurEntry.wgsl, label: 'bloom-blur' })
+            ? asyncCreateShaderModule(rhiDevice, {
+                code: bloomUpsampleEntry.wgsl,
+                label: 'bloom-upsample',
+              })
             : invokeDeviceCreateShaderModule(rhiDevice, {
-                code: bloomBlurEntry.wgsl,
-                label: 'bloom-blur',
+                code: bloomUpsampleEntry.wgsl,
+                label: 'bloom-upsample',
               }),
         'shader-compile-failed',
-        'bloom-blur shader module compiled',
-        'inspect manifest bloom-blur entry composed wgsl; check device.features',
+        'bloom-upsample shader module compiled',
+        'inspect manifest bloom-upsample entry composed wgsl; check device.features',
       );
       if (!result.ok) throw result.error;
-      bloomBlurModule = result.value;
+      bloomUpsampleModule = result.value;
     }
     if (bloomCompositeEntry !== undefined) {
       const result = await runShimStep(
@@ -1493,6 +1490,7 @@ export async function buildReadyWebGPU(
   let hdrpPbrPipelineLayoutHandle: PipelineLayout | null = null;
   let hdrpMeshBindGroupLayoutHandle: BindGroupLayout | null = null;
   let hdrpProbePbrPipelineLayoutHandle: PipelineLayout | null = null;
+  let hdrpUnifiedBglHandle: BindGroupLayout | 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.
@@ -1500,6 +1498,7 @@ export async function buildReadyWebGPU(
     const hdrpUnifiedBglDesc = createHdrpBindGroupLayoutDescriptor();
     const hdrpUnifiedBglRes = rhiDevice.createBindGroupLayout(hdrpUnifiedBglDesc);
     if (hdrpUnifiedBglRes.ok) {
+      hdrpUnifiedBglHandle = hdrpUnifiedBglRes.value;
       hdrpMeshBindGroupLayoutHandle = hdrpUnifiedBglRes.value;
       const hdrpPlRes = rhiDevice.createPipelineLayout({
         label: 'hdrp-pbr-pl',
@@ -1585,6 +1584,7 @@ export async function buildReadyWebGPU(
     gpuDrivenInstancesBindGroupLayout: gpuDrivenInstancesBindGroupLayoutHandle,
     gpuDrivenPbrPipelineLayout: gpuDrivenPbrPipelineLayoutHandle,
     gpuDrivenPbrSkinPipelineLayout: gpuDrivenPbrSkinPipelineLayoutHandle,
+    surfaceDirectInstancesBindGroupLayout: surfaceDirectInstancesBindGroupLayoutHandle,
   } = buildGpuDrivenPbrReadyLayouts(rhiDevice, storageBufferCapable, pbrLayouts.value);
   let hdrpSkinPipelineLayoutHandle: PipelineLayout | null = null;
   let hdrpSkinMeshBindGroupLayoutHandle: BindGroupLayout | null = null;
@@ -1609,6 +1609,46 @@ export async function buildReadyWebGPU(
     }
   }
 
+  // GPU-driven Standard batches use the compact scene-index slot(3) while
+  // retaining the same clustered group(2) bind group that the ordinary main
+  // pass publishes. Build a matching pipeline layout from those exact
+  // producer-owned layouts; a separate URP mesh-array layout would validate
+  // the indirect draw but reject its clustered bind group at encode time.
+  let gpuDrivenClusterPbrPipelineLayoutHandle: PipelineLayout | null = null;
+  let gpuDrivenClusterPbrSkinPipelineLayoutHandle: PipelineLayout | null = null;
+  if (
+    storageBufferCapable &&
+    hdrpUnifiedBglHandle !== null &&
+    gpuDrivenInstancesBindGroupLayoutHandle !== null
+  ) {
+    const rigidResult = rhiDevice.createPipelineLayout({
+      label: 'pbr-gpu-driven-cluster-pl',
+      bindGroupLayouts: [
+        viewBglResult.value,
+        materialBglResult.value,
+        hdrpUnifiedBglHandle,
+        gpuDrivenInstancesBindGroupLayoutHandle,
+      ],
+    });
+    if (rigidResult.ok) gpuDrivenClusterPbrPipelineLayoutHandle = rigidResult.value;
+  }
+  if (
+    storageBufferCapable &&
+    hdrpSkinMeshBindGroupLayoutHandle !== null &&
+    gpuDrivenInstancesBindGroupLayoutHandle !== null
+  ) {
+    const skinResult = rhiDevice.createPipelineLayout({
+      label: 'pbr-skin-gpu-driven-cluster-pl',
+      bindGroupLayouts: [
+        viewBglResult.value,
+        materialBglResult.value,
+        hdrpSkinMeshBindGroupLayoutHandle,
+        gpuDrivenInstancesBindGroupLayoutHandle,
+      ],
+    });
+    if (skinResult.ok) gpuDrivenClusterPbrSkinPipelineLayoutHandle = skinResult.value;
+  }
+
   // feat-20260612-skin-palette-per-frame-upload M1 / m1-2: skin palette
   // allocator. Replaces the prior 16320 B identity-seeded UBO stub (PR #353,
   // feat-20260611 R2 / M8 / w28 IS-14, retired identity-buffer field) with
@@ -1636,9 +1676,7 @@ export async function buildReadyWebGPU(
   const skinPaletteLimitKey = storageBufferCapable
     ? 'maxStorageBufferBindingSize'
     : 'maxUniformBufferBindingSize';
-  const skinPaletteDeviceLimit = (rhiDevice.limits as Readonly<Record<string, number>>)[
-    skinPaletteLimitKey
-  ];
+  const skinPaletteDeviceLimit = rhiDevice.limits[skinPaletteLimitKey];
   const SKIN_PALETTE_MAX_BINDING_BYTES =
     typeof skinPaletteDeviceLimit === 'number' && skinPaletteDeviceLimit > 0
       ? skinPaletteDeviceLimit
@@ -2030,6 +2068,24 @@ export async function buildReadyWebGPU(
   );
   if (!defaultSamplerResult.ok) throw defaultSamplerResult.error;
 
+  // r32float Surface raw-depth views are unfilterable. Keep their sampler
+  // distinct from the filtering material sampler so WebGPU's sample-type
+  // validation remains explicit at the material BGL boundary.
+  const surfaceMediumDepthSamplerResult = runShimSyncStep(
+    () =>
+      rhiDevice.createSampler({
+        label: 'surface-medium-depth-sampler',
+        magFilter: 'nearest',
+        minFilter: 'nearest',
+        addressModeU: 'clamp-to-edge',
+        addressModeV: 'clamp-to-edge',
+      }),
+    'webgpu-runtime-error',
+    'createSampler (single-layer medium raw depth) succeeded',
+    'check device.limits.maxSamplersPerShaderStage',
+  );
+  if (!surfaceMediumDepthSamplerResult.ok) throw surfaceMediumDepthSamplerResult.error;
+
   // feat-20260520-directional-light-shadow-mapping M1c / w8 + M2 / w14:
   // shadow comparison sampler — clamp-to-edge, linear filter, compare:'less'.
   // Used for shadow map sampling in M2/M3 and shadow depth pass. comparison
@@ -2514,10 +2570,10 @@ export async function buildReadyWebGPU(
         } else if (fragModule === skyboxModule) {
           const msaa = d.multisample as Record<string, unknown> | undefined;
           label = msaa !== undefined ? 'skybox-pipeline-msaa' : 'skybox-pipeline';
-        } else if (fragModule === bloomBrightModule) {
-          label = 'bloom-bright-pipeline';
-        } else if (fragModule === bloomBlurModule) {
-          label = (d.label as string) ?? 'bloom-blur-h-pipeline';
+        } else if (fragModule === bloomDownsampleModule) {
+          label = 'bloom-downsample-pipeline';
+        } else if (fragModule === bloomUpsampleModule) {
+          label = 'bloom-upsample-pipeline';
         } else if (fragModule === bloomCompositeModule) {
           label = 'bloom-composite-pipeline';
         } else if (fragModule === ssaoModule) {
@@ -2745,23 +2801,18 @@ export async function buildReadyWebGPU(
   let skyboxSamplerHandle: Sampler | null = null;
   let skyboxRotationBufferHandle: Buffer | null = null;
   let skyboxPipelineMsaaHandle: RenderPipeline | null = null;
-  // feat-20260531-bloom-first-declarative-render-graph-pass / w13:
-  // bloom pipeline handles (D-1, D-4, D-6). Bright + 2x blur (H/V per-axis)
-  // + 1x composite = 4 pipelines. Blur H/V share the same WGSL module but
-  // are separate pipelines with per-axis texelSize baked at creation (D-1).
-  // All 4 use rgba16float target format (D-6).
-  let bloomBrightPipelineHandle: RenderPipeline | null = null;
-  let bloomBlurHPipelineHandle: RenderPipeline | null = null;
-  let bloomBlurVPipelineHandle: RenderPipeline | null = null;
+  // Multiscale Bloom pipeline handles. One level-parameterized downsample
+  // pipeline and one tent upsample pipeline serve the whole five-level graph;
+  // the composite is the only other Bloom pipeline. All use rgba16float.
+  let bloomDownsamplePipelineHandle: RenderPipeline | null = null;
+  let bloomUpsamplePipelineHandle: RenderPipeline | null = null;
   let bloomCompositePipelineHandle: RenderPipeline | null = null;
-  let bloomBrightBglHandle: BindGroupLayout | null = null;
-  let bloomBlurBglHandle: BindGroupLayout | null = null;
+  let bloomDownsampleBglHandle: BindGroupLayout | null = null;
+  let bloomUpsampleBglHandle: BindGroupLayout | null = null;
   let bloomCompositeBglHandle: BindGroupLayout | null = null;
   let bloomSamplerHandle: Sampler | null = null;
-  let bloomBrightParamsBufferHandle: Buffer | null = null;
-  // bug-20260625: separate H/V blur params UBOs (see PerPassResources comment).
-  let bloomBlurHParamsBufferHandle: Buffer | null = null;
-  let bloomBlurVParamsBufferHandle: Buffer | null = null;
+  let bloomDownsampleParamsBufferHandle: Buffer | null = null;
+  let bloomUpsampleParamsBufferHandle: Buffer | null = null;
   let bloomCompositeParamsBufferHandle: Buffer | null = null;
   let bloomResourcesReady = false;
   let ensureBloomResources: (() => void) | undefined;
@@ -2799,22 +2850,7 @@ export async function buildReadyWebGPU(
   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',
-      }
-    );
+    return inspectBloomResources?.(graph) ?? emptyBloomInspection();
   };
   // feat-20260612-hdrp-ssao M6 / w26 + w43: SSAO pipeline handles (D-A).
   // calc + blur RenderPipeline pair sharing a dedicated 6-entry BGL.
@@ -3108,18 +3144,10 @@ export async function buildReadyWebGPU(
       skyboxRotationBufferHandle = skyboxRotationBufferResult.value;
     }
 
-    // feat-20260531-bloom-first-declarative-render-graph-pass / w13:
-    // bloom pipeline assembly (D-1, D-4, D-6). Assembled inside the
-    // (unlit+pbr+tonemap) gate for rhiDevice access but bloom modules
-    // are optional — each guard is independent. When bloom modules are
-    // absent (legacy manifest), handles stay null and execute closures
-    // skip the bloom passes entirely (zero-overhead opt-out).
-    //
-    // Pipeline roster:
-    //   bloom-bright  : 1-tex + sampler + UBO@2 BGL, rgba16float target
-    //   bloom-blur-h  : same BGL, same module as blur-v, H-axis texelSize
-    //   bloom-blur-v  : same BGL, same module as blur-h, V-axis texelSize
-    //   bloom-composite: 2-tex + sampler + UBO@3 BGL, rgba16float target
+    // Multiscale Bloom pipeline assembly. The runtime owns exactly one
+    // parameterized downsample PSO, one tent upsample PSO, and one composite
+    // PSO. The graph owns the five downsample and up to four upsample target
+    // instances; no axis/radius compatibility route is retained.
 
     ensureBloomResources = (): void => {
       if (bloomResourcesReady) return;
@@ -3133,11 +3161,11 @@ export async function buildReadyWebGPU(
         return value;
       };
       try {
-        // Shared bloom sampler: linear filter + clamp-to-edge (all 4 passes
+        // Shared Bloom sampler: linear filter + clamp-to-edge (all passes
         // sample from textures using fullscreen triangle UVs).
         if (
-          bloomBrightModule !== null ||
-          bloomBlurModule !== null ||
+          bloomDownsampleModule !== null ||
+          bloomUpsampleModule !== null ||
           bloomCompositeModule !== null
         ) {
           const bloomSamplerResult = runShimSyncStep(
@@ -3158,12 +3186,12 @@ export async function buildReadyWebGPU(
           bloomSamplerHandle = adopt('binding', bloomSamplerResult.value, () => undefined);
         }
 
-        // Bloom bright: 1-tex + sampler + UBO@2 BGL (D-4).
-        if (bloomBrightModule !== null && bloomSamplerHandle !== null) {
-          const brightBglResult = runShimSyncStep(
+        // Bloom downsample: source texture + sampler + one level slice.
+        if (bloomDownsampleModule !== null && bloomSamplerHandle !== null) {
+          const downsampleBglResult = runShimSyncStep(
             () =>
               rhiDevice.createBindGroupLayout({
-                label: 'bloom-bright-bgl',
+                label: 'bloom-downsample-bgl',
                 entries: [
                   {
                     binding: 0,
@@ -3183,30 +3211,30 @@ export async function buildReadyWebGPU(
                 ],
               }),
             'webgpu-runtime-error',
-            'createBindGroupLayout(bloom-bright) succeeded',
+            'createBindGroupLayout(bloom-downsample) succeeded',
             'check device.limits.maxBindGroupsPerPipelineLayout',
           );
-          if (!brightBglResult.ok) throw brightBglResult.error;
-          bloomBrightBglHandle = adopt('binding', brightBglResult.value, () => undefined);
+          if (!downsampleBglResult.ok) throw downsampleBglResult.error;
+          bloomDownsampleBglHandle = adopt('binding', downsampleBglResult.value, () => undefined);
 
-          const brightPlResult = runShimSyncStep(
+          const downsamplePlResult = runShimSyncStep(
             () =>
               rhiDevice.createPipelineLayout({
-                label: 'bloom-bright-pl',
-                bindGroupLayouts: [brightBglResult.value],
+                label: 'bloom-downsample-pl',
+                bindGroupLayouts: [downsampleBglResult.value],
               }),
             'webgpu-runtime-error',
-            'createPipelineLayout(bloom-bright) succeeded',
-            'verify bloom-bright BindGroupLayout matches shader @group(0) bindings',
+            'createPipelineLayout(bloom-downsample) succeeded',
+            'verify bloom-downsample BindGroupLayout matches shader @group(0) bindings',
           );
-          if (!brightPlResult.ok) throw brightPlResult.error;
-          adopt('binding', brightPlResult.value, () => undefined);
+          if (!downsamplePlResult.ok) throw downsamplePlResult.error;
+          adopt('binding', downsamplePlResult.value, () => undefined);
 
-          // M2-T4: bloom-bright pipeline via getOrBuildPipeline (lazy-build).
+          // One pipeline serves D0 extraction and D1..D4 fixed reduction.
           {
-            const brightSpec: PipelineSpec = {
+            const downsampleSpec: PipelineSpec = {
               shader: {
-                id: 'forgeax::post::bloom-bright',
+                id: 'forgeax::post::bloom-downsample',
                 passKind: 'post-process',
                 variantSet: undefined,
               },
@@ -3223,20 +3251,21 @@ export async function buildReadyWebGPU(
               renderState: { cullMode: 'none' },
             };
             const modules = {
-              vertex: bloomBrightModule,
-              fragment: bloomBrightModule,
-              layout: brightPlResult.value,
+              vertex: bloomDownsampleModule,
+              fragment: bloomDownsampleModule,
+              layout: downsamplePlResult.value,
+              label: 'bloom-downsample-pipeline',
             };
             try {
-              bloomBrightPipelineHandle = getOrBuildPipeline(
-                brightSpec,
+              bloomDownsamplePipelineHandle = getOrBuildPipeline(
+                downsampleSpec,
                 pipelineDeviceProvider,
                 pipelineCache,
                 modules,
               ) as RenderPipeline;
-              bloomBrightPipelineHandle = adopt(
+              bloomDownsamplePipelineHandle = adopt(
                 'pipeline',
-                bloomBrightPipelineHandle,
+                bloomDownsamplePipelineHandle,
                 () => undefined,
               );
             } catch (err) {
@@ -3244,37 +3273,41 @@ export async function buildReadyWebGPU(
               throw new PipelineSpecError({
                 code: 'pipeline-build-failed',
                 detail: { cause: err },
-                hint: 'createRenderPipeline (bloom-bright fullscreen) failed; inspect gpuMessage',
+                hint: 'createRenderPipeline (bloom-downsample fullscreen) failed; inspect gpuMessage',
               });
             }
           }
 
-          // Bright params UBO: 16 B std140 (threshold f32 + 12 B pad).
-          const brightParamsResult = runShimSyncStep(
+          // Five 32-byte std140 slices: threshold, knee, destination extent,
+          // level and padding. The level is selected by the graph pass.
+          const downsampleParamsResult = runShimSyncStep(
             () =>
               rhiDevice.createBuffer({
-                label: 'bloom-bright-params-ubo',
-                size: BRIGHT_PARAMS_BYTES,
+                label: 'bloom-downsample-params-ubo',
+                size: BLOOM_DOWNSAMPLE_PARAMS_BYTES,
                 usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
                 mappedAtCreation: false,
               }),
             'webgpu-runtime-error',
-            'createBuffer (bloom-bright params UBO) succeeded',
+            'createBuffer (bloom-downsample params UBO) succeeded',
             'check device.limits.maxUniformBufferBindingSize',
           );
-          if (!brightParamsResult.ok) throw brightParamsResult.error;
-          bloomBrightParamsBufferHandle = adopt('buffer', brightParamsResult.value, (value) => {
-            rhiDevice.destroyBuffer(value);
-          });
+          if (!downsampleParamsResult.ok) throw downsampleParamsResult.error;
+          bloomDownsampleParamsBufferHandle = adopt(
+            'buffer',
+            downsampleParamsResult.value,
+            (value) => {
+              rhiDevice.destroyBuffer(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(
+        // Bloom upsample: current/coarse textures + sampler + scatter slice.
+        if (bloomUpsampleModule !== null && bloomSamplerHandle !== null) {
+          const upsampleBglResult = runShimSyncStep(
             () =>
               rhiDevice.createBindGroupLayout({
-                label: 'bloom-blur-bgl',
+                label: 'bloom-upsample-bgl',
                 entries: [
                   {
                     binding: 0,
@@ -3284,43 +3317,45 @@ export async function buildReadyWebGPU(
                   {
                     binding: 1,
                     visibility: GPU_SHADER_STAGE_FRAGMENT,
-                    sampler: { type: 'filtering' },
+                    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-blur) succeeded',
+            'createBindGroupLayout(bloom-upsample) succeeded',
             'check device.limits.maxBindGroupsPerPipelineLayout',
           );
-          if (!blurBglResult.ok) throw blurBglResult.error;
-          bloomBlurBglHandle = adopt('binding', blurBglResult.value, () => undefined);
+          if (!upsampleBglResult.ok) throw upsampleBglResult.error;
+          bloomUpsampleBglHandle = adopt('binding', upsampleBglResult.value, () => undefined);
 
-          const blurPlResult = runShimSyncStep(
+          const upsamplePlResult = runShimSyncStep(
             () =>
               rhiDevice.createPipelineLayout({
-                label: 'bloom-blur-pl',
-                bindGroupLayouts: [blurBglResult.value],
+                label: 'bloom-upsample-pl',
+                bindGroupLayouts: [upsampleBglResult.value],
               }),
             'webgpu-runtime-error',
-            'createPipelineLayout(bloom-blur) succeeded',
-            'verify bloom-blur BindGroupLayout matches shader @group(0) bindings',
+            'createPipelineLayout(bloom-upsample) succeeded',
+            'verify bloom-upsample BindGroupLayout matches shader @group(0) bindings',
           );
-          if (!blurPlResult.ok) throw blurPlResult.error;
-          adopt('binding', blurPlResult.value, () => undefined);
+          if (!upsamplePlResult.ok) throw upsamplePlResult.error;
+          adopt('binding', upsamplePlResult.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).
+          // One pipeline serves every coarse-to-fine edge.
           {
-            const blurSpec: PipelineSpec = {
+            const upsampleSpec: PipelineSpec = {
               shader: {
-                id: 'forgeax::post::bloom-blur',
+                id: 'forgeax::post::bloom-upsample',
                 passKind: 'post-process',
                 variantSet: undefined,
               },
@@ -3337,21 +3372,21 @@ export async function buildReadyWebGPU(
               renderState: { cullMode: 'none' },
             };
             const modules = {
-              vertex: bloomBlurModule,
-              fragment: bloomBlurModule,
-              layout: blurPlResult.value,
-              label: 'bloom-blur-h-pipeline',
+              vertex: bloomUpsampleModule,
+              fragment: bloomUpsampleModule,
+              layout: upsamplePlResult.value,
+              label: 'bloom-upsample-pipeline',
             };
             try {
-              bloomBlurHPipelineHandle = getOrBuildPipeline(
-                blurSpec,
+              bloomUpsamplePipelineHandle = getOrBuildPipeline(
+                upsampleSpec,
                 pipelineDeviceProvider,
                 pipelineCache,
                 modules,
               ) as RenderPipeline;
-              bloomBlurHPipelineHandle = adopt(
+              bloomUpsamplePipelineHandle = adopt(
                 'pipeline',
-                bloomBlurHPipelineHandle,
+                bloomUpsamplePipelineHandle,
                 () => undefined,
               );
             } catch (err) {
@@ -3359,47 +3394,26 @@ export async function buildReadyWebGPU(
               throw new PipelineSpecError({
                 code: 'pipeline-build-failed',
                 detail: { cause: err },
-                hint: 'createRenderPipeline (bloom-blur-h fullscreen) failed; inspect gpuMessage',
+                hint: 'createRenderPipeline (bloom-upsample fullscreen) failed; inspect gpuMessage',
               });
             }
-            // 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(
+          // Four 16-byte std140 slices carry scatter for U0..U3.
+          const upsampleParamsResult = runShimSyncStep(
             () =>
               rhiDevice.createBuffer({
-                label: 'bloom-blur-h-params-ubo',
-                size: BLUR_PARAMS_BYTES,
+                label: 'bloom-upsample-params-ubo',
+                size: BLOOM_UPSAMPLE_PARAMS_BYTES,
                 usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
                 mappedAtCreation: false,
               }),
             'webgpu-runtime-error',
-            'createBuffer (bloom-blur-h params UBO) succeeded',
+            'createBuffer (bloom-upsample params UBO) succeeded',
             'check device.limits.maxUniformBufferBindingSize',
           );
-          if (!blurHParamsResult.ok) throw blurHParamsResult.error;
-          bloomBlurHParamsBufferHandle = adopt('buffer', blurHParamsResult.value, (value) => {
-            rhiDevice.destroyBuffer(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 = adopt('buffer', blurVParamsResult.value, (value) => {
+          if (!upsampleParamsResult.ok) throw upsampleParamsResult.error;
+          bloomUpsampleParamsBufferHandle = adopt('buffer', upsampleParamsResult.value, (value) => {
             rhiDevice.destroyBuffer(value);
           });
         }
@@ -3505,7 +3519,7 @@ export async function buildReadyWebGPU(
             () =>
               rhiDevice.createBuffer({
                 label: 'bloom-composite-params-ubo',
-                size: COMPOSITE_PARAMS_BYTES,
+                size: BLOOM_COMPOSITE_PARAMS_BYTES,
                 usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
                 mappedAtCreation: false,
               }),
@@ -3526,17 +3540,15 @@ export async function buildReadyWebGPU(
         bloomCandidateBundle = {
           scope: candidateScope,
           generation: bloomGeneration + 1,
-          bloomBrightPipeline: bloomBrightPipelineHandle,
-          bloomBlurHPipeline: bloomBlurHPipelineHandle,
-          bloomBlurVPipeline: bloomBlurVPipelineHandle,
+          bloomDownsamplePipeline: bloomDownsamplePipelineHandle,
+          bloomUpsamplePipeline: bloomUpsamplePipelineHandle,
           bloomCompositePipeline: bloomCompositePipelineHandle,
-          bloomBrightBindGroupLayout: bloomBrightBglHandle,
-          bloomBlurBindGroupLayout: bloomBlurBglHandle,
+          bloomDownsampleBindGroupLayout: bloomDownsampleBglHandle,
+          bloomUpsampleBindGroupLayout: bloomUpsampleBglHandle,
           bloomCompositeBindGroupLayout: bloomCompositeBglHandle,
           bloomSampler: bloomSamplerHandle,
-          bloomBrightParamsBuffer: bloomBrightParamsBufferHandle,
-          bloomBlurHParamsBuffer: bloomBlurHParamsBufferHandle,
-          bloomBlurVParamsBuffer: bloomBlurVParamsBufferHandle,
+          bloomDownsampleParamsBuffer: bloomDownsampleParamsBufferHandle,
+          bloomUpsampleParamsBuffer: bloomUpsampleParamsBufferHandle,
           bloomCompositeParamsBuffer: bloomCompositeParamsBufferHandle,
         };
         inspectBloomResources = (graph): BloomInspection => {
@@ -3550,6 +3562,10 @@ export async function buildReadyWebGPU(
             return {
               graphStatus: 'empty',
               enabled: false,
+              levelCount: 0,
+              levelDimensions: [],
+              downsamplePassCount: 0,
+              upsamplePassCount: 0,
               targetCount: 0,
               targetBytes: 0,
               resourceCount: 0,
@@ -3573,6 +3589,10 @@ export async function buildReadyWebGPU(
           return {
             graphStatus: active === undefined ? 'empty' : graphInspection.status,
             enabled: active !== undefined,
+            levelCount: active === undefined ? 0 : graphInspection.levelCount,
+            levelDimensions: active === undefined ? [] : graphInspection.levelDimensions,
+            downsamplePassCount: active === undefined ? 0 : graphInspection.downsamplePassCount,
+            upsamplePassCount: active === undefined ? 0 : graphInspection.upsamplePassCount,
             targetCount: active === undefined ? 0 : graphInspection.targetCount,
             targetBytes: active === undefined ? 0 : graphInspection.targetBytes,
             resourceCount: ownedBundles.reduce(
@@ -3583,7 +3603,14 @@ export async function buildReadyWebGPU(
             encodeCount: active === undefined ? 0 : receipts.encodeCount,
             bindGroupCount: active === undefined ? 0 : receipts.bindGroupCount,
             uploadCount: active === undefined ? 0 : receipts.uploadCount,
-            residentChildBytes: 0,
+            // The graph owns the target allocations.  Use its validated
+            // descriptor byte sum for the active child; zero is reserved for
+            // an absent/invalid current graph, never a placeholder for a
+            // live Bloom allocation.
+            residentChildBytes:
+              active === undefined || graphInspection.status !== 'valid'
+                ? 0
+                : graphInspection.targetBytes,
             generation: selected?.generation ?? 0,
             state,
           };
@@ -3660,17 +3687,15 @@ export async function buildReadyWebGPU(
         commitBloomResources = undefined;
         discardBloomResources = undefined;
         drainBloomResources = undefined;
-        bloomBrightPipelineHandle = null;
-        bloomBlurHPipelineHandle = null;
-        bloomBlurVPipelineHandle = null;
+        bloomDownsamplePipelineHandle = null;
+        bloomUpsamplePipelineHandle = null;
         bloomCompositePipelineHandle = null;
-        bloomBrightBglHandle = null;
-        bloomBlurBglHandle = null;
+        bloomDownsampleBglHandle = null;
+        bloomUpsampleBglHandle = null;
         bloomCompositeBglHandle = null;
         bloomSamplerHandle = null;
-        bloomBrightParamsBufferHandle = null;
-        bloomBlurHParamsBufferHandle = null;
-        bloomBlurVParamsBufferHandle = null;
+        bloomDownsampleParamsBufferHandle = null;
+        bloomUpsampleParamsBufferHandle = null;
         bloomCompositeParamsBufferHandle = null;
         throw cause;
       }
@@ -3924,6 +3949,18 @@ export async function buildReadyWebGPU(
     gpuDrivenPbrPrograms,
     gpuDrivenPbrSkinPipelineLayout:
       unlitModule !== null && pbrModule !== null ? gpuDrivenPbrSkinPipelineLayoutHandle : null,
+    surfaceDirectInstancesBindGroupLayout:
+      unlitModule !== null && pbrModule !== null
+        ? surfaceDirectInstancesBindGroupLayoutHandle
+        : null,
+    gpuDrivenClusterPbrPipelineLayout:
+      unlitModule !== null && pbrModule !== null ? gpuDrivenClusterPbrPipelineLayoutHandle : null,
+    gpuDrivenClusterPbrSkinPipelineLayout:
+      unlitModule !== null && pbrModule !== null
+        ? gpuDrivenClusterPbrSkinPipelineLayoutHandle
+        : null,
+    gpuDrivenClusterMeshBindGroupLayout:
+      unlitModule !== null && pbrModule !== null ? hdrpUnifiedBglHandle : null,
     // HDRP variant uses the unified group(2) layout built above.
     hdrpPbrPipelineLayout:
       unlitModule !== null && pbrModule !== null ? hdrpPbrPipelineLayoutHandle : null,
@@ -3969,6 +4006,7 @@ export async function buildReadyWebGPU(
     probeInstancesBindGroupLayout: probeInstancesBglResult.value,
     identityInstanceBuffer: identityInstanceResult.value,
     defaultSampler: defaultSamplerResult.value,
+    surfaceMediumDepthSampler: surfaceMediumDepthSamplerResult.value,
     fallbackTextureView: fallbackTextureViewResult.value,
     defaultWhiteTextureView: fallbackTextureViewResult.value,
     // Exactly neutral half-float RG=(0.5,0.5) decodes to tangent (0,0,1).
@@ -3997,66 +4035,30 @@ export async function buildReadyWebGPU(
     // matrices fold into the View UBO tail (`view.spotLightViewProj`); no
     // dedicated buffer / view-BG binding 9 (WebGL2 uniform-buffer budget).
     skylightFallback,
-    // feat-20260529-rendergraph-pass-abstraction M3 / w11 (D-2 + Finding 3):
-    // per-pass mutable resource slots moved to PerPassResources.
-    perPassResources: {
-      depthTexture: null,
-      depthTextureView: null,
-      depthTextureWidth: 0,
-      depthTextureHeight: 0,
-      configured: false,
-      hdrColorTexture: null,
-      hdrColorView: null,
-      hdrDepthTexture: null,
-      hdrDepthView: null,
-      hdrTextureWidth: 0,
-      hdrTextureHeight: 0,
-      hdrDepthSampleCount: 1,
+    perPassResources: createReadyPerPassResources({
       fxaaPipeline: fxaaPipelineHandle,
       fxaaBindGroupLayout: fxaaBglHandle,
       fxaaSampler: fxaaSamplerHandle,
-      // feat-20260604-learn-render-4.10-anti-aliasing-msaa M2 / w7: MSAA
-      // attachment slots. All null/0 until the first antialias='msaa' frame.
-      msaaColorTexture: null,
-      msaaColorView: null,
-      msaaSpriteColorTexture: null,
-      msaaSpriteColorView: null,
-      msaaDepthTexture: null,
-      msaaDepthView: null,
-      msaaTextureWidth: 0,
-      msaaTextureHeight: 0,
-      hdrColorMsaaTexture: null,
-      hdrColorMsaaView: null,
       skyboxPipeline: skyboxPipelineHandle,
       skyboxPipelineMsaa: skyboxPipelineMsaaHandle,
       skyboxBindGroupLayout: skyboxBglHandle,
       skyboxSampler: skyboxSamplerHandle,
       skyboxRotationBuffer: skyboxRotationBufferHandle,
-      shadowTexture: null,
-      shadowMapSize: 0,
-      shadowCascadeCount: 0,
       shadowSampler: shadowSamplerResult.value,
       shadowLightSpaceMatrix: null,
       shadowCsmLightViewProj: null,
       shadowCsmSelection: null,
-      // feat-20260531-bloom-first-declarative-render-graph-pass / w13 + w16:
-      // bloom per-pass resource slots. Pipeline handles assembled during
-      // buildReadyWebGPU (marker-triage + compile + createRenderPipeline).
-      // Intermediate textures are allocate in the execute closures at 1/2-res
-      // (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: null,
-      bloomBlurHPipeline: null,
-      bloomBlurVPipeline: null,
+      // Multiscale Bloom pipeline handles are generation-owned by the ready
+      // builder; graph targets are frame-owned and are not stored here.
+      bloomDownsamplePipeline: null,
+      bloomUpsamplePipeline: null,
       bloomCompositePipeline: null,
-      bloomBrightBindGroupLayout: null,
-      bloomBlurBindGroupLayout: null,
+      bloomDownsampleBindGroupLayout: null,
+      bloomUpsampleBindGroupLayout: null,
       bloomCompositeBindGroupLayout: null,
       bloomSampler: null,
-      bloomBrightParamsBuffer: null,
-      bloomBlurHParamsBuffer: null,
-      bloomBlurVParamsBuffer: null,
+      bloomDownsampleParamsBuffer: null,
+      bloomUpsampleParamsBuffer: null,
       bloomCompositeParamsBuffer: null,
       ensureBloomResources: ensureBloomResourcesStable,
       getBloomResources: getBloomResourcesStable,
@@ -4068,29 +4070,17 @@ export async function buildReadyWebGPU(
       retireBloomResources: retireBloomResourcesStable,
       drainBloomResources: drainBloomResourcesStable,
       inspectBloomResources: inspectBloomResourcesStable,
-      bloomBrightTexture: null,
-      bloomBrightView: null,
-      bloomBrightWidth: 0,
-      bloomBrightHeight: 0,
-      bloomBlurHTexture: null,
-      bloomBlurHView: null,
-      bloomBlurHWidth: 0,
-      bloomBlurHHeight: 0,
-      bloomBlurVTexture: null,
-      bloomBlurVView: null,
-      bloomBlurVWidth: 0,
-      bloomBlurVHeight: 0,
       // feat-20260612-hdrp-ssao M6 / w26 + M8 / w38: SSAO pipeline slots.
       ssaoCalcPipeline: ssaoCalcPipelineHandle,
       ssaoBlurPipeline: ssaoBlurPipelineHandle,
       ssaoBgl: ssaoBglHandle,
-      // M8 / w38: lazy-allocated on first SSAO record frame. Sampler kinds
-      // and the 1x1 ssaoRaw fallback view are constant across frames and
-      // cached after first construction.
-      ssaoFilteringSampler: null,
-      ssaoDepthSampler: null,
-      ssaoFallbackRawView: null,
-    },
+    }),
   };
+  // Boot-time fallback resources submit real GPU work before the renderer is
+  // published. Keep initialization as the readiness barrier for the first
+  // frame: a Worker can otherwise receive `ready`, start its frame deadline,
+  // and report `frame-submitted` while that earlier queue work still holds the
+  // receipt's completion fence.
+  await queue.onSubmittedWorkDone();
   return pipelineState;
 }