@forgeax/engine-render 0.1.32 → 0.1.33

package/src/assembly/webgpu-ready.ts

@@ -57,7 +57,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 {
@@ -119,11 +119,12 @@ 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';
@@ -219,6 +220,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;
@@ -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')) {
@@ -1149,26 +1144,14 @@ export async function buildReadyWebGPU(
 
     // 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);
@@ -1354,40 +1337,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(
@@ -2514,10 +2500,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 +2731,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 +2780,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 +3074,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 +3091,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 +3116,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 +3141,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 +3181,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 +3203,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 +3247,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 +3302,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 +3324,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(
-            () =>
-              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);
-          });
-
-          const blurVParamsResult = runShimSyncStep(
+          // Four 16-byte std140 slices carry scatter for U0..U3.
+          const upsampleParamsResult = runShimSyncStep(
             () =>
               rhiDevice.createBuffer({
-                label: 'bloom-blur-v-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-v params UBO) succeeded',
+            'createBuffer (bloom-upsample 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 +3449,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 +3470,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 +3492,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 +3519,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 +3533,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 +3617,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;
       }
@@ -4039,24 +3994,17 @@ export async function buildReadyWebGPU(
       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,18 +4016,6 @@ 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,