@forgeax/engine-render 0.1.33 → 0.1.34

package/src/assembly/webgpu-pbr-ready.ts

@@ -15,6 +15,7 @@ import {
   buildGpuDrivenPbrPipelineLayout,
   buildGpuDrivenPbrSkinPipelineLayout,
   buildPbrSkinLayouts,
+  buildSurfaceDirectInstancesBindGroupLayout,
   type PbrPipelineLayoutBundle,
   SKIN_MATERIAL_SHADER_ID,
 } from '../pbr-pipeline';
@@ -43,6 +44,7 @@ export interface GpuDrivenPbrReadyLayouts {
   readonly gpuDrivenInstancesBindGroupLayout: BindGroupLayout | null;
   readonly gpuDrivenPbrPipelineLayout: PipelineLayout | null;
   readonly gpuDrivenPbrSkinPipelineLayout: PipelineLayout | null;
+  readonly surfaceDirectInstancesBindGroupLayout: BindGroupLayout | null;
 }
 
 interface GpuDrivenPbrModuleInput {
@@ -183,6 +185,7 @@ export function buildGpuDrivenPbrReadyLayouts(
   let gpuDrivenInstancesBindGroupLayout: BindGroupLayout | null = null;
   let gpuDrivenPbrPipelineLayout: PipelineLayout | null = null;
   let gpuDrivenPbrSkinPipelineLayout: PipelineLayout | null = null;
+  let surfaceDirectInstancesBindGroupLayout: BindGroupLayout | null = null;
   const skinResult = runShimSyncStep(
     () => ok(buildPbrSkinLayouts(device, { storageBuffer: storageBufferCapable }, pbrLayouts)),
     'webgpu-runtime-error',
@@ -200,6 +203,9 @@ export function buildGpuDrivenPbrReadyLayouts(
         const instances = buildGpuDrivenPbrInstancesBindGroupLayout(device, {
           storageBuffer: true,
         });
+        const surfaceDirect = buildSurfaceDirectInstancesBindGroupLayout(device, {
+          storageBuffer: true,
+        });
         const rigid = buildGpuDrivenPbrPipelineLayout(device, pbrLayouts, instances);
         const skin =
           pbrSkinMeshBindGroupLayout === null
@@ -209,7 +215,7 @@ export function buildGpuDrivenPbrReadyLayouts(
                 { ...pbrLayouts, meshArrayBgl: pbrSkinMeshBindGroupLayout },
                 instances,
               );
-        return ok({ instances, rigid, skin });
+        return ok({ instances, rigid, skin, surfaceDirect });
       },
       'webgpu-runtime-error',
       'build GPU-driven PBR pipeline layouts succeeded',
@@ -219,6 +225,7 @@ export function buildGpuDrivenPbrReadyLayouts(
       gpuDrivenInstancesBindGroupLayout = layoutResult.value.instances;
       gpuDrivenPbrPipelineLayout = layoutResult.value.rigid;
       gpuDrivenPbrSkinPipelineLayout = layoutResult.value.skin;
+      surfaceDirectInstancesBindGroupLayout = layoutResult.value.surfaceDirect;
     }
   }
   return {
@@ -228,5 +235,6 @@ export function buildGpuDrivenPbrReadyLayouts(
     gpuDrivenInstancesBindGroupLayout,
     gpuDrivenPbrPipelineLayout,
     gpuDrivenPbrSkinPipelineLayout,
+    surfaceDirectInstancesBindGroupLayout,
   };
 }

package/src/assembly/webgpu-ready-per-pass.ts

@@ -0,0 +1,104 @@
+import type { PerPassResources } from '../record/render-context';
+
+export interface ReadyPerPassResourceInputs {
+  readonly fxaaPipeline: PerPassResources['fxaaPipeline'];
+  readonly fxaaBindGroupLayout: PerPassResources['fxaaBindGroupLayout'];
+  readonly fxaaSampler: PerPassResources['fxaaSampler'];
+  readonly skyboxPipeline: PerPassResources['skyboxPipeline'];
+  readonly skyboxPipelineMsaa: PerPassResources['skyboxPipelineMsaa'];
+  readonly skyboxBindGroupLayout: PerPassResources['skyboxBindGroupLayout'];
+  readonly skyboxSampler: PerPassResources['skyboxSampler'];
+  readonly skyboxRotationBuffer: PerPassResources['skyboxRotationBuffer'];
+  readonly shadowSampler: PerPassResources['shadowSampler'];
+  readonly shadowLightSpaceMatrix: PerPassResources['shadowLightSpaceMatrix'];
+  readonly shadowCsmLightViewProj: PerPassResources['shadowCsmLightViewProj'];
+  readonly shadowCsmSelection: PerPassResources['shadowCsmSelection'];
+  readonly bloomDownsamplePipeline: PerPassResources['bloomDownsamplePipeline'];
+  readonly bloomUpsamplePipeline: PerPassResources['bloomUpsamplePipeline'];
+  readonly bloomCompositePipeline: PerPassResources['bloomCompositePipeline'];
+  readonly bloomDownsampleBindGroupLayout: PerPassResources['bloomDownsampleBindGroupLayout'];
+  readonly bloomUpsampleBindGroupLayout: PerPassResources['bloomUpsampleBindGroupLayout'];
+  readonly bloomCompositeBindGroupLayout: PerPassResources['bloomCompositeBindGroupLayout'];
+  readonly bloomSampler: PerPassResources['bloomSampler'];
+  readonly bloomDownsampleParamsBuffer: PerPassResources['bloomDownsampleParamsBuffer'];
+  readonly bloomUpsampleParamsBuffer: PerPassResources['bloomUpsampleParamsBuffer'];
+  readonly bloomCompositeParamsBuffer: PerPassResources['bloomCompositeParamsBuffer'];
+  readonly ensureBloomResources: NonNullable<PerPassResources['ensureBloomResources']>;
+  readonly getBloomResources: NonNullable<PerPassResources['getBloomResources']>;
+  readonly commitBloomResources: NonNullable<PerPassResources['commitBloomResources']>;
+  readonly commitBloomFrameReceipts: NonNullable<PerPassResources['commitBloomFrameReceipts']>;
+  readonly discardBloomResources: NonNullable<PerPassResources['discardBloomResources']>;
+  readonly retireBloomResources: NonNullable<PerPassResources['retireBloomResources']>;
+  readonly drainBloomResources: NonNullable<PerPassResources['drainBloomResources']>;
+  readonly inspectBloomResources: NonNullable<PerPassResources['inspectBloomResources']>;
+  readonly ssaoCalcPipeline: PerPassResources['ssaoCalcPipeline'];
+  readonly ssaoBlurPipeline: PerPassResources['ssaoBlurPipeline'];
+  readonly ssaoBgl: PerPassResources['ssaoBgl'];
+}
+
+/** Creates the mutable per-pass slots owned by one prepared device generation. */
+export function createReadyPerPassResources(input: ReadyPerPassResourceInputs): PerPassResources {
+  return {
+    depthTexture: null,
+    depthTextureView: null,
+    depthTextureWidth: 0,
+    depthTextureHeight: 0,
+    configured: false,
+    hdrColorTexture: null,
+    hdrColorView: null,
+    hdrDepthTexture: null,
+    hdrDepthView: null,
+    hdrTextureWidth: 0,
+    hdrTextureHeight: 0,
+    hdrDepthSampleCount: 1,
+    fxaaPipeline: input.fxaaPipeline,
+    fxaaBindGroupLayout: input.fxaaBindGroupLayout,
+    fxaaSampler: input.fxaaSampler,
+    msaaColorTexture: null,
+    msaaColorView: null,
+    msaaSpriteColorTexture: null,
+    msaaSpriteColorView: null,
+    msaaDepthTexture: null,
+    msaaDepthView: null,
+    msaaTextureWidth: 0,
+    msaaTextureHeight: 0,
+    hdrColorMsaaTexture: null,
+    hdrColorMsaaView: null,
+    skyboxPipeline: input.skyboxPipeline,
+    skyboxPipelineMsaa: input.skyboxPipelineMsaa,
+    skyboxBindGroupLayout: input.skyboxBindGroupLayout,
+    skyboxSampler: input.skyboxSampler,
+    skyboxRotationBuffer: input.skyboxRotationBuffer,
+    shadowTexture: null,
+    shadowMapSize: 0,
+    shadowCascadeCount: 0,
+    shadowSampler: input.shadowSampler,
+    shadowLightSpaceMatrix: input.shadowLightSpaceMatrix,
+    shadowCsmLightViewProj: input.shadowCsmLightViewProj,
+    shadowCsmSelection: input.shadowCsmSelection,
+    bloomDownsamplePipeline: input.bloomDownsamplePipeline,
+    bloomUpsamplePipeline: input.bloomUpsamplePipeline,
+    bloomCompositePipeline: input.bloomCompositePipeline,
+    bloomDownsampleBindGroupLayout: input.bloomDownsampleBindGroupLayout,
+    bloomUpsampleBindGroupLayout: input.bloomUpsampleBindGroupLayout,
+    bloomCompositeBindGroupLayout: input.bloomCompositeBindGroupLayout,
+    bloomSampler: input.bloomSampler,
+    bloomDownsampleParamsBuffer: input.bloomDownsampleParamsBuffer,
+    bloomUpsampleParamsBuffer: input.bloomUpsampleParamsBuffer,
+    bloomCompositeParamsBuffer: input.bloomCompositeParamsBuffer,
+    ensureBloomResources: input.ensureBloomResources,
+    getBloomResources: input.getBloomResources,
+    commitBloomResources: input.commitBloomResources,
+    commitBloomFrameReceipts: input.commitBloomFrameReceipts,
+    discardBloomResources: input.discardBloomResources,
+    retireBloomResources: input.retireBloomResources,
+    drainBloomResources: input.drainBloomResources,
+    inspectBloomResources: input.inspectBloomResources,
+    ssaoCalcPipeline: input.ssaoCalcPipeline,
+    ssaoBlurPipeline: input.ssaoBlurPipeline,
+    ssaoBgl: input.ssaoBgl,
+    ssaoFilteringSampler: null,
+    ssaoDepthSampler: null,
+    ssaoFallbackRawView: null,
+  };
+}

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';
@@ -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,
@@ -129,6 +129,7 @@ import {
   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).
@@ -235,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') {
@@ -590,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) {
@@ -693,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
@@ -1111,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(
@@ -1119,27 +1133,18 @@ 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
@@ -1309,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.
@@ -1479,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.
@@ -1486,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',
@@ -1571,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;
@@ -1595,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
@@ -1622,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
@@ -2016,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
@@ -3879,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,
@@ -3924,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).
@@ -3952,44 +4035,15 @@ 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,
@@ -4020,13 +4074,13 @@ export async function buildReadyWebGPU(
       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;
 }

package/src/assembly/webgpu-renderer-bootstrap.ts

@@ -53,18 +53,6 @@ export async function tryCreateWebGPURenderer(
     onDeviceLost: (detail) => lossObserver.current?.(detail),
   });
 
-  if (pack._internal_getRawDevice && pack.translateErrorEventToRhiError) {
-    const backendDevice = pack._internal_getRawDevice(device);
-    if (backendDevice && typeof backendDevice === 'object') {
-      const target = backendDevice as {
-        onuncapturederror?: ((event: unknown) => void) | null;
-      };
-      target.onuncapturederror = (event: unknown): void => {
-        const translated = pack.translateErrorEventToRhiError?.(event);
-        if (translated && !translated.ok) errorRegistry.fire(translated.error);
-      };
-    }
-  }
   return {
     kind: 'ok',
     renderer: await createRenderer({