@forgeax/engine-render 0.1.32 → 0.1.34

package/dist/{chunk-JRIPCMYC.mjs → chunk-MKDIT2EM.mjs}

@@ -1,9 +1,10 @@
 import { TRANSPARENT_SORT_MODE_LAYER_Z, TRANSPARENT_SORT_MODE_LAYER_Y } from './chunk-RXZ3RGOU.mjs';
-import { DEFAULT_CLUSTER_GRID, DEFAULT_STANDARD_PROFILE, createIblKernelCache, MAX_LIGHTS, CLUSTER_GRID_STRIDE_U32, LIGHT_INDEX_LIST_CAPACITY, createStandardClusterLayout } from './chunk-S665NJNF.mjs';
+import { DEFAULT_CLUSTER_GRID, DEFAULT_STANDARD_PROFILE, createIblKernelCache, MAX_LIGHTS, CLUSTER_GRID_STRIDE_U32, LIGHT_INDEX_LIST_CAPACITY, createStandardClusterLayout } from './chunk-OCDLEI6I.mjs';
 import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-BLXGONR2.mjs';
-import { GPU_SHADER_STAGE_COMPUTE, GPU_BUFFER_USAGE_STORAGE, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM, createHdrpBindGroupLayoutDescriptor, COOKIE_MATRIX_BYTES, IES_SLICE_WIDTH, IES_SLICE_HEIGHT, COOKIE_SLICE_SIZE, GPU_SHADER_STAGE_VERTEX, GPU_SHADER_STAGE_FRAGMENT, GPU_BUFFER_USAGE_INDEX, GPU_BUFFER_USAGE_VERTEX, isStandardPbrMaterialShader, GPU_BUFFER_USAGE_MAP_READ, pbrSkinMeshDynamicOffsets, instanceCollectionCacheKey, worldEntityKey, gpuDrivenShadowDrawKey, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, buildPbrMaterialUserRegionEntries, buildBindGroupLayoutDescriptor, GPU_BUFFER_USAGE_COPY_SRC, GPU_BUFFER_USAGE_INDIRECT, EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES, gpuDrivenSourceDrawItemIndex, matchPass, createPbrSkinMeshBindGroupEntries, physicalTextureFields, isCanonicalStandardPbrMaterialShader, getOpaqueResourceIdentity, resolveRenderTargetMaterialSource, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, isStandardPbrSkinMaterialShader, SKIN_MATERIAL_SHADER_ID, PROBE_BLEND_RECORD_BYTE_SIZE, gpuDrivenDrawKey, probeBlendRecordOffset, PROBE_BLEND_RECORD_STRIDE, materialBindGroupLayoutIdentity } from './chunk-DRR7D3KX.mjs';
-import { GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GPU_TEXTURE_USAGE_COPY_SRC, VertexColorVariantConflictError, EquirectProjectionFailedError, SHADOW_ATLAS_DEFAULT_LAYERS, SHADOW_ATLAS_DEFAULT_FACE_SIZE, ShadowAtlas, PointShadowAtlasUninitializedError, PointShadowAtlasBoundsViolationError, StandardClusterTransportUnavailableError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, GPU_TEXTURE_USAGE_TEXTURE_BINDING, createVisibilityBudget, instanceUploadRangesForResident, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, StandardLightBudgetExceededError, RendererOperationError, VideoUploadUnsupportedError, StandardClusterIndexOverflowError, FXAA_POST_PROCESS_ID } from './chunk-6TFBXLRJ.mjs';
+import { GPU_SHADER_STAGE_COMPUTE, GPU_BUFFER_USAGE_STORAGE, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM, createHdrpBindGroupLayoutDescriptor, COOKIE_MATRIX_BYTES, IES_SLICE_WIDTH, IES_SLICE_HEIGHT, COOKIE_SLICE_SIZE, GPU_SHADER_STAGE_VERTEX, GPU_SHADER_STAGE_FRAGMENT, GPU_BUFFER_USAGE_INDEX, GPU_BUFFER_USAGE_VERTEX, isStandardPbrMaterialShader, probeBlendRecordOffset, worldEntityKey, instanceCollectionCacheKey, PROBE_BLEND_RECORD_BYTE_SIZE, GPU_BUFFER_USAGE_MAP_READ, getOpaqueResourceIdentity, pbrSkinMeshDynamicOffsets, gpuDrivenShadowDrawKey, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, buildPbrMaterialUserRegionEntries, buildBindGroupLayoutDescriptor, GPU_BUFFER_USAGE_COPY_SRC, GPU_BUFFER_USAGE_INDIRECT, EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES, PROBE_BLEND_RECORD_STRIDE, gpuDrivenSourceDrawItemIndex, matchPass, createPbrSkinMeshBindGroupEntries, physicalTextureFields, isCanonicalStandardPbrMaterialShader, resolveRenderTargetMaterialSource, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, isStandardPbrSkinMaterialShader, SKIN_MATERIAL_SHADER_ID, gpuDrivenDrawKey, materialBindGroupLayoutIdentity } from './chunk-SHFUFJ5N.mjs';
+import { GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GPU_TEXTURE_USAGE_COPY_SRC, VertexColorVariantConflictError, EquirectProjectionFailedError, SHADOW_ATLAS_DEFAULT_LAYERS, SHADOW_ATLAS_DEFAULT_FACE_SIZE, ShadowAtlas, PointShadowAtlasUninitializedError, PointShadowAtlasBoundsViolationError, StandardClusterTransportUnavailableError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, GPU_TEXTURE_USAGE_TEXTURE_BINDING, instanceUploadRangesForResident, createVisibilityBudget, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, StandardLightBudgetExceededError, RendererOperationError, VideoUploadUnsupportedError, StandardClusterIndexOverflowError, FXAA_POST_PROCESS_ID } from './chunk-WEX45HKH.mjs';
 import { derive, ok, err as err$1, toShared, ASSET_ERROR_HINTS, deriveTextureLayout, handleSlot, resolveMaterialTextureCoordinates, KNOWN_PASS_KINDS } from '@forgeax/engine-types';
+import { RenderGraphError } from '@forgeax/engine-render-graph';
 import { ok as ok$1, err, RhiError } from '@forgeax/engine-rhi';
 import { mat3, vec3, mat4 } from '@forgeax/engine-math';
 import { deriveVertexLayoutProjection, DEFAULT_VERTEX_ATTRIBUTE_MAP, deriveVertexBufferLayout, deriveVertexBufferLayoutFromProjection } from '@forgeax/engine-geometry';
@@ -11,7 +12,6 @@ import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import { probeVideoHighPerfUpload, VIDEO_ELEMENT_PROVIDER_KEY } from '@forgeax/engine-graphics-extras';
 import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA, STANDARD_PIPELINE_PARAM_SCHEMA, GPU_DRIVEN_MATERIAL_ROW_BYTES, findVariantByKey, DEFAULT_MSDF_TEXT_PARAM_SCHEMA, DEFAULT_SPRITE_PARAM_SCHEMA, DEFAULT_UNLIT_PARAM_SCHEMA, STANDARD_PHYSICAL_TEXTURE_FIELDS, STANDARD_TEXTURE_MASK_OVERRIDE } from '@forgeax/engine-shader';
 import { isCompressedFormat, bytesPerRow, blockParamsForFormat } from '@forgeax/engine-codec';
-import { RenderGraphError } from '@forgeax/engine-render-graph';
 
 // src/pipeline/render-extent.ts
 function renderExtentSize(extent, domain) {
@@ -119,6 +119,17 @@ function importRenderPipelineSurface(graph, topology) {
     }
   });
 }
+function renderPipelineCloudHistoryTargets(input) {
+  const entries = [
+    ["cloud-history-radiance-previous", input.previousRadiance],
+    ["cloud-history-radiance-current", input.currentRadiance],
+    ["cloud-history-transmittance-previous", input.previousTransmittance],
+    ["cloud-history-transmittance-current", input.currentTransmittance],
+    ["cloud-history-depth-previous", input.previousDepth],
+    ["cloud-history-depth-current", input.currentDepth]
+  ];
+  return entries.map(([name, target]) => ({ name, kind: "scene-color", ...target }));
+}
 var STORAGE_BUFFER_MIN_REQUIRED = 4;
 var BYTES_PER_DIRECT_LIGHT_SLOT = 80;
 var DirectLightSlotKind = {
@@ -449,7 +460,7 @@ var passKindPolicyTable = {
     },
     defaultDepthOps: void 0
   },
-  "bloom-bright": {
+  "bloom-downsample": {
     shape: "color-only",
     defaultColorOps: {
       loadOp: "clear",
@@ -458,7 +469,7 @@ var passKindPolicyTable = {
     },
     defaultDepthOps: void 0
   },
-  "bloom-blur": {
+  "bloom-upsample": {
     shape: "color-only",
     defaultColorOps: {
       loadOp: "clear",
@@ -780,7 +791,7 @@ function buildSpecConstTable(ldrViewFormat) {
     // has sampleCount=4. Both use empty vertexLayout (fullscreen triangle, no
     // attributes) and cullMode='none' (forward cull for fullscreen-quad passthrough).
     //
-    // Shadow-probe / fxaa / bloom 4-stage / SSAO 2-stage are lazy-build — not in
+    // Shadow-probe / fxaa / Bloom 10-pass / SSAO 2-stage are lazy-build — not in
     // SPEC_CONST_TABLE (R-D4 decision: only entries that are always-present on
     // every boot).
     // tonemap LDR S1 (writes to runtime-resolved swap-chain LDR view format)
@@ -853,16 +864,34 @@ var MESH_UBO_FULL_ARRAY_BYTES = 112 * 128;
 var INSTANCE_UBO_FULL_ARRAY_BYTES = 80 * 128;
 var MAX_UNIFORM_INSTANCES = 128;
 var INSTANCE_STORAGE_STRIDE_FLOATS = 32;
-function packInstanceStorageBuffer(transforms) {
+function hasStableGenerationColumn(generations, count) {
+  if (generations === void 0 || generations.length !== count) return false;
+  const seen = /* @__PURE__ */ new Set();
+  for (const generation of generations) {
+    if (generation === 0 || seen.has(generation)) return false;
+    seen.add(generation);
+  }
+  return true;
+}
+function packInstanceStorageBuffer(transforms, previousTransforms = transforms, generations, previousGenerations) {
   const count = Math.floor(transforms.length / 16);
   const out = new Float32Array(count * INSTANCE_STORAGE_STRIDE_FLOATS);
+  const previousCount = Math.floor(previousTransforms.length / 16);
+  const generationInput = generations !== void 0 || previousGenerations !== void 0;
+  const identityProof = hasStableGenerationColumn(generations, count) && hasStableGenerationColumn(previousGenerations, previousCount);
+  const previousIndexByGeneration = identityProof ? new Map(
+    Array.from(previousGenerations ?? [], (generation, index) => [generation, index])
+  ) : void 0;
   for (let i = 0; i < count; i++) {
     const sourceBase = i * 16;
     const targetBase = i * INSTANCE_STORAGE_STRIDE_FLOATS;
+    const previousIndex = identityProof ? previousIndexByGeneration?.get(generations?.[i] ?? 0) : !generationInput && previousCount === count ? i : void 0;
+    const sameIdentity = previousIndex !== void 0 && previousIndex < previousCount;
+    const previousBase = (previousIndex ?? i) * 16;
     for (let k = 0; k < 16; k++) {
       const value = transforms[sourceBase + k] ?? 0;
       out[targetBase + k] = value;
-      out[targetBase + 16 + k] = value;
+      out[targetBase + 16 + k] = sameIdentity ? previousTransforms[previousBase + k] ?? value : value;
     }
   }
   return out;
@@ -1008,6 +1037,7 @@ function uploadMeshSsboBatch(queue, meshStorageBuffer, validatedOrdered, foldDis
       _meshSsboScratchFloats[slot + 38] = 1;
       _meshSsboScratchFloats[slot + 43] = 1;
       _meshSsboScratchFloats[slot + 44] = 1;
+      _meshSsboScratchFloats[slot + 45] = 1;
     } else {
       const worldFromLocal = entry.source.transform.world;
       for (let k = 0; k < 16; k++) _meshSsboScratchFloats[slot + k] = worldFromLocal[k] ?? 0;
@@ -1034,6 +1064,7 @@ function uploadMeshSsboBatch(queue, meshStorageBuffer, validatedOrdered, foldDis
         }
       }
       _meshSsboScratchFloats[slot + 44] = entry.source.temporal?.reactive === true || reactiveMaterial ? 1 : 0;
+      _meshSsboScratchFloats[slot + 45] = entry.source.temporal?.motionValid === false ? 0 : 1;
     }
   }
   if (neededBytes > 0) {
@@ -1229,10 +1260,35 @@ function generateSsaoNoise(seed = 0) {
 var BYTES_PER_KERNEL_ELEMENT = 16;
 var UNIFORM_BYTES = 256;
 var fallbackCache = /* @__PURE__ */ new WeakMap();
+function destroyBuffer(runtime, device, buffer) {
+  const destroyed = device.destroyBuffer(buffer);
+  if (!destroyed.ok) runtime.errorRegistry.fire(destroyed.error);
+}
+function destroyTexture(runtime, device, texture) {
+  const destroyed = device.destroyTexture(texture);
+  if (!destroyed.ok) runtime.errorRegistry.fire(destroyed.error);
+}
+function retireSsaoResources(device, release) {
+  const queue = device.queue;
+  if (typeof queue.onSubmittedWorkDone === "function") {
+    try {
+      void queue.onSubmittedWorkDone().then(release, release);
+      return;
+    } catch {
+    }
+  }
+  release();
+}
+function destroySsaoFallbackResources(runtime, resources) {
+  destroyTexture(runtime, resources.device, resources.texture);
+}
 function getOrCreateSsaoFallbackTexture(runtime) {
   const cached = fallbackCache.get(runtime);
   if (cached !== void 0 && cached.device === runtime.device) return cached;
-  if (cached !== void 0) fallbackCache.delete(runtime);
+  if (cached !== void 0) {
+    fallbackCache.delete(runtime);
+    retireSsaoResources(cached.device, () => destroySsaoFallbackResources(runtime, cached));
+  }
   const device = runtime.device;
   const texRes = device.createTexture({
     label: "hdrp-ssao-fallback-white",
@@ -1261,6 +1317,7 @@ function getOrCreateSsaoFallbackTexture(runtime) {
   );
   if (!writeRes.ok) {
     runtime.errorRegistry.fire(writeRes.error);
+    destroyTexture(runtime, device, texRes.value);
     return null;
   }
   const viewRes = device.createTextureView(texRes.value, {
@@ -1275,6 +1332,7 @@ function getOrCreateSsaoFallbackTexture(runtime) {
   });
   if (!viewRes.ok) {
     runtime.errorRegistry.fire(viewRes.error);
+    destroyTexture(runtime, device, texRes.value);
     return null;
   }
   const samplerRes = device.createSampler({
@@ -1288,6 +1346,7 @@ function getOrCreateSsaoFallbackTexture(runtime) {
   });
   if (!samplerRes.ok) {
     runtime.errorRegistry.fire(samplerRes.error);
+    destroyTexture(runtime, device, texRes.value);
     return null;
   }
   const resources = {
@@ -1300,10 +1359,35 @@ function getOrCreateSsaoFallbackTexture(runtime) {
   return resources;
 }
 var cache = /* @__PURE__ */ new WeakMap();
+function destroySsaoBufferResources(runtime, buffers) {
+  for (const buffer of [buffers.kernelBuffer, buffers.uniformBuffer]) {
+    destroyBuffer(runtime, buffers.device, buffer);
+  }
+  destroyTexture(runtime, buffers.device, buffers.noiseTexture);
+}
+function destroyCreatedSsaoResources(runtime, device, buffers, textures) {
+  for (const buffer of buffers) destroyBuffer(runtime, device, buffer);
+  for (const texture of textures) destroyTexture(runtime, device, texture);
+}
+function resetSsaoResources(runtime) {
+  const buffers = cache.get(runtime);
+  if (buffers !== void 0) {
+    cache.delete(runtime);
+    retireSsaoResources(buffers.device, () => destroySsaoBufferResources(runtime, buffers));
+  }
+  const fallback = fallbackCache.get(runtime);
+  if (fallback !== void 0) {
+    fallbackCache.delete(runtime);
+    retireSsaoResources(fallback.device, () => destroySsaoFallbackResources(runtime, fallback));
+  }
+}
 function getOrCreateSsaoBuffers(runtime) {
   const cached = cache.get(runtime);
   if (cached !== void 0 && cached.device === runtime.device) return cached;
-  if (cached !== void 0) cache.delete(runtime);
+  if (cached !== void 0) {
+    cache.delete(runtime);
+    retireSsaoResources(cached.device, () => destroySsaoBufferResources(runtime, cached));
+  }
   const device = runtime.device;
   const kernelSamples = generateSsaoKernel();
   const kernelData = new Float32Array(SSAO_KERNEL_SAMPLE_COUNT * 4);
@@ -1327,6 +1411,7 @@ function getOrCreateSsaoBuffers(runtime) {
   const kernelWriteRes = device.queue.writeBuffer(kernelBufferRes.value, 0, kernelData);
   if (!kernelWriteRes.ok) {
     runtime.errorRegistry.fire(kernelWriteRes.error);
+    destroyBuffer(runtime, device, kernelBufferRes.value);
     return null;
   }
   const noiseData = generateSsaoNoise();
@@ -1349,6 +1434,7 @@ function getOrCreateSsaoBuffers(runtime) {
   });
   if (!noiseTexRes.ok) {
     runtime.errorRegistry.fire(noiseTexRes.error);
+    destroyBuffer(runtime, device, kernelBufferRes.value);
     return null;
   }
   const noiseCopyRes = device.queue.writeTexture(
@@ -1363,6 +1449,7 @@ function getOrCreateSsaoBuffers(runtime) {
   );
   if (!noiseCopyRes.ok) {
     runtime.errorRegistry.fire(noiseCopyRes.error);
+    destroyCreatedSsaoResources(runtime, device, [kernelBufferRes.value], [noiseTexRes.value]);
     return null;
   }
   const uniformBufRes = device.createBuffer({
@@ -1373,6 +1460,7 @@ function getOrCreateSsaoBuffers(runtime) {
   });
   if (!uniformBufRes.ok) {
     runtime.errorRegistry.fire(uniformBufRes.error);
+    destroyCreatedSsaoResources(runtime, device, [kernelBufferRes.value], [noiseTexRes.value]);
     return null;
   }
   const buffers = {
@@ -1669,7 +1757,7 @@ function createStandardSurfaceLightingBindGroup(runtime, layout, grid, ssaoOptio
   }
   return result.value;
 }
-function createHdrpUnifiedBindGroup(runtime, hdrpBuffers, meshStorageBuffer, ssaoOptions = { enabled: false }) {
+function createHdrpUnifiedBindGroup(runtime, hdrpBuffers, meshStorageBuffer, ssaoOptions = { enabled: false }, meshBindingBytes = MESH_PER_ENTITY_STRIDE) {
   const fallback = getOrCreateSsaoFallbackTexture(runtime);
   if (fallback === null) return null;
   const ssaoTexView = ssaoOptions.enabled ? ssaoOptions.ssaoBlurredView : fallback.view;
@@ -1685,7 +1773,7 @@ function createHdrpUnifiedBindGroup(runtime, hdrpBuffers, meshStorageBuffer, ssa
           value: {
             buffer: meshStorageBuffer,
             offset: 0,
-            size: MESH_PER_ENTITY_STRIDE
+            size: meshBindingBytes
           }
         }
       },
@@ -1698,17 +1786,16 @@ function createHdrpUnifiedBindGroup(runtime, hdrpBuffers, meshStorageBuffer, ssa
   }
   return result.value;
 }
-function createHdrpSkinUnifiedBindGroup(runtime, hdrpBuffers, layout, meshStorageBuffer, paletteBuffer, paletteBindingWindowBytes, ssaoOptions = { enabled: false }) {
+function createHdrpSkinUnifiedBindGroup(runtime, hdrpBuffers, layout, meshStorageBuffer, paletteBuffer, paletteBindingWindowBytes, ssaoOptions = { enabled: false }, meshBindingBytes = MESH_PER_ENTITY_STRIDE) {
   const fallback = getOrCreateSsaoFallbackTexture(runtime);
   if (fallback === null) return null;
-  const meshSize = MESH_PER_ENTITY_STRIDE;
   const result = runtime.device.createBindGroup({
     label: "hdrp-skin-unified-bg-group2",
     layout,
     entries: [
       ...createPbrSkinMeshBindGroupEntries(
         meshStorageBuffer,
-        meshSize,
+        meshBindingBytes,
         paletteBuffer,
         paletteBindingWindowBytes
       ),
@@ -2425,7 +2512,7 @@ function computeProjectionMatrix(camera) {
   }
   return proj;
 }
-var VIEW_UNIFORM_BYTES = 960;
+var VIEW_UNIFORM_BYTES = 1024;
 var POINTS_LINES_VIEW_BYTES = 160;
 var POINTS_LINES_VIEW_SLOT_STRIDE = 256;
 var POINTS_LINES_VIEW_SLOT_COUNT = 1024;
@@ -2489,7 +2576,7 @@ function writePointsLinesViewUbo(queue, buffer, camera, width, height, model, st
   const uploaded = queue.writeBuffer(buffer, byteOffset, payload);
   if (!uploaded.ok) throw uploaded.error;
 }
-function writeViewUbo(queue, viewUniformBuffer, camera, light, lights, spotShadowSnapshots, temporalOrOffset, projectorSpotIndex) {
+function writeViewUbo(queue, viewUniformBuffer, camera, light, lights, spotShadowSnapshots, temporalOrOffset, projectorSpotIndex, cloudShadowProjection) {
   const byteOffset = typeof temporalOrOffset === "number" ? temporalOrOffset : 0;
   const resolvedTemporal = typeof temporalOrOffset === "number" ? void 0 : temporalOrOffset;
   const projMatrix = computeProjectionMatrix(camera);
@@ -2507,7 +2594,7 @@ function writeViewUbo(queue, viewUniformBuffer, camera, light, lights, spotShado
   }
   const mainProjection = mat4.create();
   mat4.multiply(mainProjection, jitteredProjection, viewMatrix);
-  const VIEW_PAYLOAD_FLOATS = 240;
+  const VIEW_PAYLOAD_FLOATS = 256;
   const viewPayload = new Float32Array(VIEW_PAYLOAD_FLOATS);
   for (let i = 0; i < 16; i++) viewPayload[i] = mainProjection[i] ?? 0;
   viewPayload[16] = light.direction[0] ?? 0;
@@ -2556,6 +2643,20 @@ function writeViewUbo(queue, viewUniformBuffer, camera, light, lights, spotShado
     viewPayload[238] = ssr.maxRoughness;
     viewPayload[239] = 1;
   }
+  if (cloudShadowProjection !== void 0) {
+    viewPayload[240] = cloudShadowProjection.origin[0] ?? 0;
+    viewPayload[241] = cloudShadowProjection.origin[1] ?? 0;
+    viewPayload[242] = cloudShadowProjection.origin[2] ?? 0;
+    viewPayload[244] = cloudShadowProjection.right[0] ?? 0;
+    viewPayload[245] = cloudShadowProjection.right[1] ?? 0;
+    viewPayload[246] = cloudShadowProjection.right[2] ?? 0;
+    viewPayload[248] = cloudShadowProjection.up[0] ?? 0;
+    viewPayload[249] = cloudShadowProjection.up[1] ?? 0;
+    viewPayload[250] = cloudShadowProjection.up[2] ?? 0;
+    viewPayload[252] = cloudShadowProjection.range;
+    viewPayload[253] = cloudShadowProjection.lowSun ? 0 : 1;
+    viewPayload[254] = cloudShadowProjection.lowSun ? 1 : 0;
+  }
   if (lights.splitPlanes !== void 0) {
     for (let s = 0; s < 4; s++) {
       for (let lane = 0; lane < 4; lane++) {
@@ -2665,6 +2766,7 @@ function buildPerFrameBindGroups(internals, frameState, pipelineState, hasValida
       const b5View = atlasViewMaybe !== null ? atlasViewMaybe : pipelineState.shadowAtlasFallbackTextureView;
       const graphSpotShadowView = graphTargets?.spotShadow;
       const b8View = graphSpotShadowView !== void 0 ? graphSpotShadowView : pipelineState.shadowFallbackTextureView;
+      const cloudShadowView = graphTargets?.cloudShadow ?? pipelineState.defaultWhiteTextureView;
       const extendedLighting = pipelineState.extendedLightingAvailable ?? true;
       const iesProfileTextureView = pipelineState.iesProfileTextureView;
       const cookieTextureView = pipelineState.cookieTextureView;
@@ -2696,6 +2798,7 @@ function buildPerFrameBindGroups(internals, frameState, pipelineState, hasValida
         extendedLightingResources.cookieMatrixBuffer
       ] : [];
       const projectorAvailable = pipelineState.projectorAvailable !== false;
+      const lowLimitCloudBindings = !extendedLighting && !projectorAvailable;
       const b11View = graphTargets?.projector ?? pipelineState.defaultWhiteTextureView;
       const b12Sampler = graphTargets?.projectorSampler ?? pipelineState.defaultSampler;
       viewBindGroup = getOrCreateFromChain(
@@ -2709,7 +2812,8 @@ function buildPerFrameBindGroups(internals, frameState, pipelineState, hasValida
           b8View,
           ...extendedLightingViews,
           ...extendedLightingResources === void 0 && projectorAvailable ? [b11View, b12Sampler] : [],
-          pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer
+          pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer,
+          ...lowLimitCloudBindings ? [] : [cloudShadowView, pipelineState.defaultSampler]
         ],
         "view-main",
         () => {
@@ -2791,8 +2895,20 @@ function buildPerFrameBindGroups(internals, frameState, pipelineState, hasValida
               }
             },
             ...extendedLightingResources === void 0 && projectorAvailable ? [
-              { binding: 11, resource: { kind: "textureView", value: b11View } },
-              { binding: 12, resource: { kind: "sampler", value: b12Sampler } }
+              {
+                binding: 11,
+                resource: {
+                  kind: "textureView",
+                  value: b11View
+                }
+              },
+              {
+                binding: 12,
+                resource: {
+                  kind: "sampler",
+                  value: b12Sampler
+                }
+              }
             ] : [],
             ...extendedLightingResources !== void 0 ? [
               {
@@ -2840,7 +2956,23 @@ function buildPerFrameBindGroups(internals, frameState, pipelineState, hasValida
                   }
                 }
               }
-            ] : []
+            ] : [],
+            ...lowLimitCloudBindings ? [] : [
+              {
+                binding: 16,
+                resource: {
+                  kind: "textureView",
+                  value: cloudShadowView
+                }
+              },
+              {
+                binding: 17,
+                resource: {
+                  kind: "sampler",
+                  value: pipelineState.defaultSampler
+                }
+              }
+            ]
             // feat-20260625-spot-light-shadow-mapping w25: the per-spot
             // fragment-read lightViewProj matrices fold into the View UBO
             // (binding 0, `view.spotLightViewProj`) — no standalone binding 9
@@ -4275,6 +4407,42 @@ var GpuTexture = class {
     return r;
   }
 };
+
+// src/record/fold-instance-buffer.ts
+function resolveFoldInstanceBuffer(c, bucket, headIndex) {
+  const { runtime, frameState } = c;
+  const key = -1 - ((bucket.materialHandle & 65535) << 16 | headIndex & 65535);
+  const uniform = runtime.device.caps.storageBuffer === false;
+  const payload = uniform ? bucket.transforms : packInstanceStorageBuffer(bucket.transforms);
+  let resident = frameState.instanceBuffers.get(key);
+  if (resident === void 0 || resident.uploadedByteLength !== payload.byteLength) {
+    const created = runtime.device.createBuffer({
+      size: payload.byteLength,
+      usage: (uniform ? GPU_BUFFER_USAGE_UNIFORM : GPU_BUFFER_USAGE_STORAGE) | GPU_BUFFER_USAGE_COPY_DST,
+      mappedAtCreation: false
+    });
+    if (!created.ok) {
+      runtime.errorRegistry.fire(created.error);
+      return null;
+    }
+    if (resident !== void 0 && !resident.buffer.isDestroyed) {
+      const destroyed = resident.buffer.destroy();
+      if (!destroyed.ok) runtime.errorRegistry.fire(destroyed.error);
+    }
+    resident = {
+      buffer: new GpuBuffer(runtime.device, created.value),
+      uploadedArchVersion: bucket.bucketSize,
+      uploadedByteLength: payload.byteLength
+    };
+    frameState.instanceBuffers.set(key, resident);
+  }
+  const written = runtime.device.queue.writeBuffer(resident.buffer.handle, 0, payload);
+  if (!written.ok) {
+    runtime.errorRegistry.fire(written.error);
+    return null;
+  }
+  return resident.buffer.handle;
+}
 var STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES = 18;
 function isOrdinaryMaterialVariant(variant) {
   return variant.defines.COVERAGE_ONLY !== true;
@@ -4383,7 +4551,7 @@ function deviceOptionsForAdapter(adapter, options) {
 
 // src/ibl/skylight-bind-group.ts
 var FALLBACK_BYTES_PER_ROW = 256;
-function assembleMaterialWithSkylightEntries(materialEntries, skylight, transmission, textureInjections = []) {
+function assembleMaterialWithSkylightEntries(materialEntries, skylight, transmission, textureInjections = [], surfaceMedium) {
   const iblStart = materialEntries.length;
   const result = [
     ...materialEntries,
@@ -4430,6 +4598,35 @@ function assembleMaterialWithSkylightEntries(materialEntries, skylight, transmis
         resource: { kind: "textureView", value: transmissionView }
       }
     );
+  if (surfaceMedium !== void 0) {
+    const surfaceStart = result.length;
+    result.push(
+      {
+        binding: surfaceStart,
+        resource: { kind: "sampler", value: surfaceMedium.rawDepthSampler }
+      },
+      {
+        binding: surfaceStart + 1,
+        resource: { kind: "textureView", value: surfaceMedium.rawDepthView }
+      },
+      {
+        binding: surfaceStart + 2,
+        resource: { kind: "sampler", value: surfaceMedium.nearestLayerSampler }
+      },
+      {
+        binding: surfaceStart + 3,
+        resource: { kind: "textureView", value: surfaceMedium.nearestLayerView }
+      },
+      {
+        binding: surfaceStart + 4,
+        resource: { kind: "sampler", value: surfaceMedium.nearestDepthSampler }
+      },
+      {
+        binding: surfaceStart + 5,
+        resource: { kind: "textureView", value: surfaceMedium.nearestDepthView }
+      }
+    );
+  }
   const physicalStart = 26;
   for (let index = 0; index < textureInjections.length; index += 1) {
     const resource = textureInjections[index];
@@ -4446,13 +4643,15 @@ function assembleMaterialWithSkylightEntries(materialEntries, skylight, transmis
       }
     );
   }
-  result.push({
-    binding: 47,
-    resource: {
-      kind: "textureView",
-      value: skylight.skylightPrefilterView ?? skylight.prefilterView
-    }
-  });
+  if (surfaceMedium === void 0) {
+    result.push({
+      binding: 47,
+      resource: {
+        kind: "textureView",
+        value: skylight.skylightPrefilterView ?? skylight.prefilterView
+      }
+    });
+  }
   return result;
 }
 function createSkylightFallback(device, queue) {
@@ -5257,8 +5456,8 @@ function recordIblMaterialBinding(frameState, materialBgl, bindGroup, entries, i
     errors: []
   };
 }
-function isMaterialBgAssemblyCacheHit(cached, material, materialBgl, materialBuffer, skylightResources, materialResourceEpoch, transmissionBackdropView, sceneMaterialBuffer) {
-  if (transmissionBackdropView != null) return false;
+function isMaterialBgAssemblyCacheHit(cached, material, materialBgl, materialBuffer, skylightResources, materialResourceEpoch, transmissionBackdropView, sceneMaterialBuffer, surfaceRawDepthView) {
+  if (transmissionBackdropView != null || surfaceRawDepthView != null) return false;
   return cached?.material === material && cached.materialResourceEpoch === materialResourceEpoch && cached.materialBgl === materialBgl && cached.materialBuffer === materialBuffer && cached.sceneMaterialBuffer === sceneMaterialBuffer && cached.skylightResources.irradianceView === skylightResources.irradianceView && cached.skylightResources.irradianceSampler === skylightResources.irradianceSampler && cached.skylightResources.prefilterView === skylightResources.prefilterView && cached.skylightResources.skylightPrefilterView === skylightResources.skylightPrefilterView && cached.skylightResources.prefilterSampler === skylightResources.prefilterSampler && cached.skylightResources.brdfLutView === skylightResources.brdfLutView && cached.skylightResources.brdfLutSampler === skylightResources.brdfLutSampler && cached.skylightResources.intensityBuffer === skylightResources.intensityBuffer;
 }
 function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWorld = deps.world, materialShaderId = submeshMaterial.materialShaderId) {
@@ -5274,6 +5473,9 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
     materialBgShared,
     materialBgAssemblyCache,
     transmissionBackdropView,
+    surfaceRawDepthView,
+    surfaceNearestLayerView,
+    surfaceNearestDepthView,
     bindGroupCounts,
     frameState
   } = deps;
@@ -5283,6 +5485,35 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
   const materialCacheKey = smMaterialHandle === void 0 ? void 0 : `${materialWorld.identity}:${smMaterialHandle}:${materialShaderId ?? ""}:${selectedProbe?.probeIndex ?? "sky"}`;
   const smHasVideoFields = (submeshMaterial.videoTextureFields?.size ?? 0) > 0;
   const smShaderId = materialShaderId;
+  const selectedMaterialShaderArtifact = smShaderId === void 0 ? void 0 : runtime.getMaterialShaderArtifact?.(smShaderId);
+  const selectedMediumShader = smShaderId === "forgeax::single-layer-medium" || selectedMaterialShaderArtifact?.receipt?.surface?.model === "single-layer-medium";
+  let surfaceMediumResources;
+  if (selectedMediumShader) {
+    if (surfaceRawDepthView == null) {
+      throw new RhiError({
+        code: "rhi-descriptor-invalid",
+        expected: "single-layer medium material bind group has producer-owned raw depth",
+        hint: "admit the Surface material only from a graph pass with an available raw-depth pair"
+      });
+    }
+    const nearestLayerView = surfaceNearestLayerView ?? transmissionBackdropView;
+    const nearestDepthView = surfaceNearestDepthView ?? pipelineState.shadowFallbackTextureView;
+    if (nearestLayerView == null || pipelineState.surfaceMediumDepthSampler === void 0) {
+      throw new RhiError({
+        code: "rhi-descriptor-invalid",
+        expected: "single-layer medium material bind group has paired nearest resources and depth sampler",
+        hint: "publish the nearest-layer target and the non-filtering raw-depth sampler before recording the Surface pass"
+      });
+    }
+    surfaceMediumResources = {
+      rawDepthSampler: pipelineState.surfaceMediumDepthSampler,
+      rawDepthView: surfaceRawDepthView,
+      nearestLayerSampler: effectiveSkylightResources.prefilterSampler,
+      nearestLayerView,
+      nearestDepthSampler: pipelineState.surfaceMediumDepthSampler,
+      nearestDepthView
+    };
+  }
   const smSchema = (smShaderId !== void 0 ? runtime.getParamSchema?.(smShaderId) : void 0) ?? submeshMaterial.materialParamSchema;
   const smPerShaderBgl = smShaderId !== void 0 ? runtime.getMaterialBindGroupLayout?.(smShaderId, smSchema) : void 0;
   const smMaterialBgl = smPerShaderBgl ?? pipelineState.materialBindGroupLayout;
@@ -5302,7 +5533,8 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
       effectiveSkylightResources,
       store.materialResourceEpoch,
       transmissionBackdropView,
-      sceneMaterialBuffer
+      sceneMaterialBuffer,
+      surfaceRawDepthView
     )) {
       if (diagnosticsEnabled) {
         recordIblMaterialBinding(
@@ -5444,14 +5676,16 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
     });
   }
   const transmissionSampler = transmissionBackdropView != null ? effectiveSkylightResources.prefilterSampler : pipelineState.defaultSampler;
+  const keepMediumBackdropSlots = surfaceMediumResources !== void 0;
   const smMergedEntries = assembleMaterialWithSkylightEntries(
     smBaseEntries,
     effectiveSkylightResources,
-    transmissionBackdropAvailable(runtime.device.limits.maxSampledTexturesPerShaderStage) ? {
+    transmissionBackdropAvailable(runtime.device.limits.maxSampledTexturesPerShaderStage) || keepMediumBackdropSlots ? {
       sampler: transmissionSampler,
-      ...transmissionBackdropView === void 0 ? {} : { backdropView: transmissionBackdropView }
+      ...transmissionBackdropView === void 0 ? { backdropView: pipelineState.defaultWhiteTextureView } : { backdropView: transmissionBackdropView }
     } : null,
-    physicalTextureInjections
+    physicalTextureInjections,
+    surfaceMediumResources
   );
   if (runtime.device.caps.storageBuffer) {
     smMergedEntries.push({
@@ -5480,6 +5714,14 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
         entityKey,
         materialHandle: smMaterialHandle,
         shader: smShaderId,
+        surfaceModel: submeshMaterial.surfaceModel,
+        layoutIdentity: getOpaqueResourceIdentity(smMaterialBgl),
+        bindings: smMergedEntries.map((entry) => entry.binding),
+        graphResources: {
+          rawDepth: surfaceRawDepthView != null,
+          nearestLayer: surfaceNearestLayerView != null,
+          nearestDepth: surfaceNearestDepthView != null
+        },
         paramSnapshot: submeshMaterial.paramSnapshot,
         handleTypes: materialCacheHandles.map((handle) => typeof handle)
       })}`
@@ -5595,6 +5837,111 @@ function prepareMaterialSkylight(c) {
   );
 }
 
+// src/record/probe-blend-buffer.ts
+function isProbeBlendProjection(input) {
+  return !Array.isArray(input);
+}
+function retireProbeBlendRecordBuffer(buffer) {
+  const destroy = () => {
+    if (!buffer.isDestroyed) void buffer.destroy();
+  };
+  void buffer.device.queue.onSubmittedWorkDone().then(destroy, destroy);
+}
+function createCompleteProbeBlendBuffer(device, requiredCapacity, records) {
+  const created = device.createBuffer({
+    label: "probe-blend-records",
+    size: requiredCapacity * PROBE_BLEND_RECORD_STRIDE,
+    usage: (device.caps.storageBuffer ? GPU_BUFFER_USAGE_STORAGE : GPU_BUFFER_USAGE_UNIFORM) | GPU_BUFFER_USAGE_COPY_DST,
+    mappedAtCreation: false
+  });
+  if (!created.ok) throw created.error;
+  const candidate = new GpuBuffer(device, created.value);
+  const cache3 = /* @__PURE__ */ new Map();
+  try {
+    for (const { cacheKey, record } of records) {
+      const uploaded = device.queue.writeBuffer(
+        candidate.handle,
+        probeBlendRecordOffset(record.objectKey),
+        record.bytes
+      );
+      if (!uploaded.ok) throw uploaded.error;
+      cache3.set(cacheKey, {
+        generation: record.generation,
+        bytes: new Uint8Array(record.bytes)
+      });
+    }
+  } catch (cause) {
+    void candidate.destroy();
+    throw cause;
+  }
+  return { buffer: candidate, cache: cache3 };
+}
+function ensureProbeBlendRecordBuffer(device, frameState, input) {
+  const projection = input !== void 0 && isProbeBlendProjection(input) ? input : void 0;
+  const records = input === void 0 ? [] : projection?.records ?? input;
+  let buffer = frameState.probeBlendRecordBuffer;
+  const accepted = frameState.probeBlendRecordProjection;
+  if (projection !== void 0 && accepted?.projection === projection && accepted.device === device) {
+    if (records.length === 0) return void 0;
+    if (accepted.buffer === buffer && buffer !== void 0 && !buffer.isDestroyed) {
+      return buffer.handle;
+    }
+  }
+  if (records.length === 0) {
+    if (projection !== void 0) {
+      frameState.probeBlendBuffers.clear();
+      frameState.probeBlendRecordProjection = {
+        projection,
+        device,
+        buffer: void 0
+      };
+    }
+    return void 0;
+  }
+  const requiredCapacity = projection?.capacity ?? records.reduce((capacity, { record }) => Math.max(capacity, record.objectKey + 2), 1);
+  const grows = buffer === void 0 || buffer.isDestroyed || buffer.device !== device || frameState.probeBlendRecordBufferCapacity < requiredCapacity;
+  const hasAcceptedBaseline = projection !== void 0 && accepted !== void 0 && accepted.device === device && accepted.buffer === buffer && buffer !== void 0 && !buffer.isDestroyed && accepted.projection.sourceIdentity === projection.sourceIdentity && accepted.projection.revision === projection.baseRevision;
+  const requiresCompletePublish = grows || projection !== void 0 && (!hasAcceptedBaseline || projection.dirtyRecords.length > 1);
+  if (requiresCompletePublish) {
+    const candidate = createCompleteProbeBlendBuffer(device, requiredCapacity, records);
+    const previous = buffer;
+    buffer = candidate.buffer;
+    frameState.probeBlendRecordBuffer = candidate.buffer;
+    frameState.probeBlendRecordBufferCapacity = requiredCapacity;
+    frameState.probeBlendBuffers.clear();
+    for (const [key, value] of candidate.cache) frameState.probeBlendBuffers.set(key, value);
+    if (projection === void 0) delete frameState.probeBlendRecordProjection;
+    else frameState.probeBlendRecordProjection = { projection, device, buffer: candidate.buffer };
+    if (previous !== void 0) retireProbeBlendRecordBuffer(previous);
+    return candidate.buffer.handle;
+  }
+  if (buffer === void 0) return void 0;
+  const changed = projection?.dirtyRecords ?? records;
+  const cacheUpdates = [];
+  for (const { cacheKey, record } of changed) {
+    const cached = frameState.probeBlendBuffers.get(cacheKey);
+    const unchanged = cached !== void 0 && cached.generation === record.generation && cached.bytes.length === record.bytes.length && cached.bytes.every((value, index) => value === record.bytes[index]);
+    if (unchanged) continue;
+    const uploaded = device.queue.writeBuffer(
+      buffer.handle,
+      probeBlendRecordOffset(record.objectKey),
+      record.bytes
+    );
+    if (!uploaded.ok) throw uploaded.error;
+    cacheUpdates.push([
+      cacheKey,
+      { generation: record.generation, bytes: new Uint8Array(record.bytes) }
+    ]);
+  }
+  for (const [cacheKey, value] of cacheUpdates) frameState.probeBlendBuffers.set(cacheKey, value);
+  for (const cacheKey of projection?.removedCacheKeys ?? []) {
+    frameState.probeBlendBuffers.delete(cacheKey);
+  }
+  if (projection === void 0) delete frameState.probeBlendRecordProjection;
+  else frameState.probeBlendRecordProjection = { projection, device, buffer };
+  return buffer.handle;
+}
+
 // src/record/main-pass-geometry.ts
 function sameOpaqueTemporalDraw(a, b) {
   return (isStandardPbrMaterialShader(a.materialShaderId) || a.tags.SurfaceKind === "standard" && b.tags.SurfaceKind === "standard" && a.tags.SurfaceModule === b.tags.SurfaceModule) && a.materialShaderId === b.materialShaderId && a.renderState?.blend === void 0 && b.renderState?.blend === void 0 && a.renderState?.stencil === void 0 && b.renderState?.stencil === void 0 && a.stencilReference === b.stencilReference && renderStateHash(a.renderState) === renderStateHash(b.renderState);
@@ -5646,9 +5993,10 @@ function isGpuDrivenMainClaimedSubmesh(c, source, submeshIndex, drawIndices) {
   if (drawItemIndex === void 0 || draw === void 0) return false;
   const material = source.materials[draw.materialSlot] ?? source.material;
   const sourceDrawItemIndex = gpuDrivenSourceDrawItemIndex(draw, drawItemIndex);
+  const stableWorld = c.gpuDrivenWorldKeys?.[source.worldId] ?? source.worldId;
   return c.gpuDrivenDrawKeys?.has(
     gpuDrivenDrawKey(
-      worldEntityKey(source.worldId, source.entityKey),
+      worldEntityKey(stableWorld, source.entityKey),
       material.materialHandle ?? -1,
       sourceDrawItemIndex
     )
@@ -5734,6 +6082,9 @@ function geometryRenderStateForPass(base, passKind, coverageOnly = false) {
     depthCompare: "less-equal"
   };
 }
+function authoredTransparentDepthWrite(transparent, renderState) {
+  return (transparent === true || renderState?.blend !== void 0) && renderState?.depthWriteEnabled === true;
+}
 function geometryRecordPhase(passKind, segment) {
   const pass = passKind === "deferred" ? "g-buffer" : "forward";
   return `record/graph-execute/${pass}/${segment}`;
@@ -5748,13 +6099,16 @@ function submitSubmeshDraws(pass, state, pipeline, instanceDraws, indexed, index
     state.pipeline = pipeline;
   }
   for (const instanceDraw of instanceDraws) {
-    if (instanceDraw.instanceBuffer !== state.instancesBuffer || instanceDraw.probeOffset !== state.probeOffset) {
-      if (instanceDraw.probeOffset < 0) {
+    if (instanceDraw.instanceBuffer !== state.instancesBuffer || instanceDraw.instanceBindGroup !== state.instanceBindGroup || instanceDraw.probeOffset !== state.probeOffset) {
+      if (instanceDraw.dynamicOffsets !== void 0) {
+        pass.setBindGroup(3, instanceDraw.instanceBindGroup, instanceDraw.dynamicOffsets);
+      } else if (instanceDraw.probeOffset < 0) {
         pass.setBindGroup(3, instanceDraw.instanceBindGroup);
       } else {
         pass.setBindGroup(3, instanceDraw.instanceBindGroup, [instanceDraw.probeOffset]);
       }
       state.instancesBuffer = instanceDraw.instanceBuffer;
+      state.instanceBindGroup = instanceDraw.instanceBindGroup;
       state.probeOffset = instanceDraw.probeOffset;
     }
     if (indexed) {
@@ -5762,7 +6116,7 @@ function submitSubmeshDraws(pass, state, pipeline, instanceDraws, indexed, index
     } else {
       pass.draw(vertexCount, instanceDraw.instanceCount, 0, 0);
     }
-    onDraw?.();
+    onDraw?.(instanceDraw, indexed ? "draw-indexed" : "draw");
   }
 }
 function recordPointsLinesDraw(pass, plan) {
@@ -5773,7 +6127,7 @@ function recordPointsLinesDraw(pass, plan) {
   }
   pass.draw(plan.vertexCount, 1, 0, 0);
 }
-function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sampleCount, meshGroup2, meshBindGroup, resolveMaterialBindGroup, passKind = "forward", selectedDispatch, colorFormats = [], coverageOnly = false) {
+function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sampleCount, meshGroup2, meshBindGroup, resolveMaterialBindGroup, passKind = "forward", selectedDispatch, colorFormats = [], coverageOnly = false, fragmentEntryPoint, surfacePass, transparentDepthWrite = false) {
   const {
     runtime,
     pipelineState,
@@ -5809,6 +6163,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
   const bindingState = {
     pipeline: null,
     instancesBuffer: null,
+    instanceBindGroup: null,
     probeOffset: -1
   };
   const identityInstanceBuffer = pipelineState.identityInstanceBuffer;
@@ -5828,7 +6183,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
   const recordOcclusionCandidate = (draw) => {
     draw();
   };
-  const resolveMaterialPipeline = (materialShaderId, renderState, topology, indexFormat, variantSet, colorFormat, layoutProjection, vertexEntry, fragmentEntry, textureMask) => {
+  const resolveMaterialPipeline = (materialShaderId, renderState, topology, indexFormat, variantSet, colorFormat, layoutProjection, vertexEntry, fragmentEntry, textureMask, layoutKind) => {
     const pipelineVariantSet = withCoverageVariant(variantSet);
     const reflectionFallbackFormats = materialShaderId === "forgeax::default-standard-pbr" && c.reflectionFallbackColorFormat !== void 0 ? passKind === "deferred" ? colorFormats.slice(1) : [c.reflectionFallbackColorFormat] : void 0;
     const renderStateKey = renderStateHash(renderState);
@@ -5836,12 +6191,12 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
     const cachedLookups = shaderLookupCache?.get(renderStateKey);
     if (cachedLookups !== void 0) {
       for (const cached of cachedLookups) {
-        if (cached.isHdrTarget === isHdrTarget && cached.renderStateKey === renderStateKey && cached.topology === topology && cached.indexFormat === indexFormat && cached.variantSet === pipelineVariantSet && cached.vertexEntry === vertexEntry && cached.fragmentEntry === fragmentEntry && cached.textureMask === textureMask && cached.passKind === passKind && cached.layoutProjection.digest === layoutProjection.digest && cached.sampleCount === sampleCount && cached.colorFormatOverride === colorFormat && cached.additionalColorFormats?.join(",") === reflectionFallbackFormats?.join(",")) {
+        if (cached.isHdrTarget === isHdrTarget && cached.renderStateKey === renderStateKey && cached.topology === topology && cached.indexFormat === indexFormat && cached.variantSet === pipelineVariantSet && cached.vertexEntry === vertexEntry && cached.fragmentEntry === fragmentEntry && cached.textureMask === textureMask && cached.layoutKind === layoutKind && cached.passKind === passKind && cached.layoutProjection.digest === layoutProjection.digest && cached.sampleCount === sampleCount && cached.colorFormatOverride === colorFormat && cached.additionalColorFormats?.join(",") === reflectionFallbackFormats?.join(",")) {
           return cached.handle;
         }
       }
     }
-    const resolvedVariantSetResult = runtime.getMaterialArtifact?.(materialShaderId) !== void 0 ? { ok: true, value: void 0 } : pipelineVariantSet === void 0 && (materialShaderId === "forgeax::sprite" || materialShaderId === "forgeax::sprite-lit") ? { ok: true, value: void 0 } : variantSetFromVertexLayoutProjection(layoutProjection, pipelineVariantSet);
+    const resolvedVariantSetResult = runtime.getMaterialArtifact?.(materialShaderId) !== void 0 && layoutKind === void 0 ? { ok: true, value: void 0 } : pipelineVariantSet === void 0 && (materialShaderId === "forgeax::sprite" || materialShaderId === "forgeax::sprite-lit") ? { ok: true, value: void 0 } : variantSetFromVertexLayoutProjection(layoutProjection, pipelineVariantSet);
     if (!resolvedVariantSetResult.ok) {
       runtime.errorRegistry.fire(resolvedVariantSetResult.error);
       return null;
@@ -5864,7 +6219,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
       void 0,
       layoutProjection,
       void 0,
-      void 0,
+      layoutKind,
       void 0,
       reflectionFallbackFormats,
       vertexEntry,
@@ -5889,6 +6244,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
         colorFormatOverride: colorFormat,
         additionalColorFormats: reflectionFallbackFormats,
         textureMask,
+        layoutKind,
         handle
       };
       if (shaderLookupCache === void 0) {
@@ -5907,6 +6263,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
   for (let i = 0; i < validatedOrdered.length; i++) {
     const entry = validatedOrdered[i];
     if (entry === void 0) continue;
+    if (c.foldDispatchPlan?.skipIndices.has(i) === true) continue;
     const pointsLinesSubmission = c.pointsLines?.prepare(entry, clusteredLighting);
     if (entry.source.pointsLines !== void 0 && pointsLinesSubmission?.plan.drawCount !== 1)
       continue;
@@ -5989,8 +6346,17 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
       }
     }
     dispatchCounts.unlit += 1;
-    const instanceDraws = resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, false);
-    if (instanceDraws === null) continue;
+    const fold = c.foldDispatchPlan?.headBuckets.get(i);
+    const foldBuffer = fold === void 0 ? null : resolveFoldInstanceBuffer(c, fold, i);
+    const baseInstanceDraws = fold === void 0 ? resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, false) : foldBuffer === null ? null : [
+      {
+        instanceBuffer: foldBuffer,
+        instanceBindGroup: resolveGeometryInstancesBindGroup(c, foldBuffer, void 0),
+        probeOffset: -1,
+        instanceCount: fold.bucketSize
+      }
+    ];
+    if (baseInstanceDraws === null) continue;
     let group2BindGroup = meshGroup2;
     meshGroup2DynamicOffsets[0] = i * MESH_PER_ENTITY_STRIDE;
     let group2DynamicOffsets = meshGroup2DynamicOffsets;
@@ -6133,10 +6499,11 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
       if (passKind === "forward" && isGpuDrivenMainClaimedSubmesh(c, entry.source, smIdx, gpuDrivenDrawIndices)) {
         continue;
       }
-      const draws = selectedDispatch === void 0 ? [void 0] : materialPasses.get(entry.renderableIndex)?.get(submeshMaterial.materialHandle ?? 0) ?? [];
+      const selectedMaterialPasses = materialPasses.get(entry.renderableIndex)?.get(submeshMaterial.materialHandle ?? 0);
+      const draws = selectedDispatch === void 0 || selectedMaterialPasses === void 0 && submeshMaterial.surfaceModel === "single-layer-medium" && matchedMaterials?.get(entry.renderableIndex)?.has(submeshMaterial.materialHandle ?? 0) ? [void 0] : selectedMaterialPasses ?? [];
       for (const selectedPass of draws) {
         const vertexEntry = passKind === "temporal" ? void 0 : selectedPass?.vertexEntry;
-        const fragmentEntry = passKind === "temporal" ? void 0 : selectedPass?.fragmentEntry;
+        const fragmentEntry = passKind === "temporal" ? void 0 : fragmentEntryPoint ?? selectedPass?.fragmentEntry;
         const selectedShaderId = selectedPass === void 0 ? submeshMaterial.materialShaderId : selectedPass.materialShaderId;
         const selectedRenderState = selectedPass === void 0 ? submeshMaterial.renderState : selectedPass.renderState;
         const selectedStencil = (selectedPass === void 0 ? entry.stencilReference : selectedPass.stencilReference) ?? 0;
@@ -6182,7 +6549,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
         pass.setBindGroup(1, perSubmeshBg, materialGroup1DynamicOffsets, 0, 1);
         const smTopology = sm.topology;
         const smMaterialShaderId = selectedPass !== void 0 ? selectedShaderId : entry.source.skin !== void 0 ? isStandardPbrSkinMaterialShader(submeshMaterial.materialShaderId) ? submeshMaterial.materialShaderId : SKIN_MATERIAL_SHADER_ID : submeshMaterial.materialShaderId;
-        const probeBlendAvailable = probeBlendRecordAvailable && isStandardPbrMaterialShader(smMaterialShaderId);
+        const probeBlendAvailable = probeBlendRecordAvailable && (isStandardPbrMaterialShader(smMaterialShaderId) || submeshMaterial.surfaceModel === "single-layer-medium");
         const isSpriteShader = smMaterialShaderId === "forgeax::sprite" || smMaterialShaderId === "forgeax::sprite-lit";
         const basePipelineRenderState = isSpriteShader ? {
           ...selectedRenderState,
@@ -6191,11 +6558,21 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
           cullMode: "none",
           blend: selectedRenderState?.blend ?? SPRITE_PREMULTIPLIED_ALPHA_BLEND
         } : geometryRenderStateForTopology(smTopology, selectedRenderState);
-        const pipelineRenderState = geometryRenderStateForPass(
+        let pipelineRenderState = geometryRenderStateForPass(
           basePipelineRenderState,
           passKind,
           coverageOnly
         );
+        if (transparentDepthWrite && passKind === "forward" && (submeshMaterial.transparent === true || selectedRenderState?.blend !== void 0)) {
+          pipelineRenderState = {
+            ...pipelineRenderState,
+            depthWriteEnabled: authoredTransparentDepthWrite(
+              submeshMaterial.transparent,
+              selectedRenderState
+            ),
+            depthCompare: "less-equal"
+          };
+        }
         let smPipelineHandle;
         let materialGroup2Contract;
         let materialPipelineEntry = null;
@@ -6240,7 +6617,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
           );
           const transmissionAvailable = requestsStandardTransmissionVariant(submeshMaterial);
           const materialCapabilityVariantSet = transmissionAvailable && !capabilityVariantSet.includes("TRANSMISSION_AVAILABLE=") ? `${capabilityVariantSet}+TRANSMISSION_AVAILABLE=true` : capabilityVariantSet;
-          const variantSet = isSpriteShader ? smMaterialShaderId === "forgeax::sprite" && entry.source.spriteInstances !== void 0 ? "" : void 0 : entry.variantSet === void 0 ? materialCapabilityVariantSet : `${materialCapabilityVariantSet}+${entry.variantSet}`;
+          const variantSet = isSpriteShader ? smMaterialShaderId === "forgeax::sprite-lit" ? materialCapabilityVariantSet : entry.source.spriteInstances !== void 0 ? "" : void 0 : entry.variantSet === void 0 ? materialCapabilityVariantSet : `${materialCapabilityVariantSet}+${entry.variantSet}`;
           const cachedPipeline = resolveMaterialPipeline(
             smMaterialShaderId,
             pipelineRenderState,
@@ -6251,7 +6628,8 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
             entry.mesh.layoutProjection,
             vertexEntry,
             fragmentEntry,
-            submeshMaterial.standardTextureMask
+            submeshMaterial.standardTextureMask,
+            submeshMaterial.surfaceModel === "single-layer-medium" && passKind === "forward" ? capabilityVariantSet.includes("CLUSTER_FORWARD_AVAILABLE=true") ? "surface-direct-cluster-pbr" : "surface-direct-pbr" : void 0
           );
           materialPipelineEntry = cachedPipeline;
           smPipelineHandle = cachedPipeline?.pipeline ?? null;
@@ -6271,13 +6649,18 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
           }
           continue;
         }
-        const instanceDraws2 = resolveGeometryInstanceBuffer(
+        const resolvedInstanceDraws = probeBlendAvailable ? resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, true) : baseInstanceDraws;
+        if (resolvedInstanceDraws === null) continue;
+        const compactDrawIndex = gpuDrivenDrawIndices.get(smIdx);
+        const compactDraw = compactDrawIndex === void 0 ? void 0 : entry.source.gpuDrivenDraws?.[compactDrawIndex];
+        const sourceDrawItemIndex = compactDrawIndex === void 0 || compactDraw === void 0 ? smIdx : gpuDrivenSourceDrawItemIndex(compactDraw, compactDrawIndex);
+        const instanceDraws = submeshMaterial.surfaceModel === "single-layer-medium" && passKind === "forward" ? resolveSurfaceDirectInstanceDraws(
           c,
           entry,
-          identityInstanceDraws,
-          probeBlendAvailable
-        );
-        if (instanceDraws2 === null) continue;
+          sourceDrawItemIndex,
+          resolvedInstanceDraws
+        ) : resolvedInstanceDraws;
+        if (instanceDraws === null) continue;
         if (!isSkinEntry) {
           materialGroup2Contract = materialPipelineEntry?.group2Contract;
           if (materialGroup2Contract === void 0) continue;
@@ -6319,12 +6702,29 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
               pass,
               bindingState,
               smPipelineHandle,
-              instanceDraws2,
+              instanceDraws,
               entry.mesh.indexed,
               sm.indexCount,
               sm.vertexCount,
               sm.indexOffset,
-              () => c.onRenderableDraw?.(entry)
+              (draw, command) => {
+                c.onRenderableDraw?.(entry, smIdx);
+                if (surfacePass === void 0 || draw.surfaceFrameBase === void 0) return;
+                c.frameState.surfaceSubmissionObservation?.record(surfacePass, {
+                  kind: command,
+                  count: entry.mesh.indexed ? sm.indexCount : sm.vertexCount,
+                  first: entry.mesh.indexed ? sm.indexOffset : 0,
+                  instanceCount: draw.instanceCount,
+                  firstInstance: 0,
+                  surfaceFrameBase: draw.surfaceFrameBase,
+                  memberIds: draw.surfaceMemberIds ?? [],
+                  pipelineIdentity: getOpaqueResourceIdentity(smPipelineHandle),
+                  ...materialPipelineEntry?.receipt === void 0 ? {} : {
+                    receiptIdentity: materialPipelineEntry.receipt.identity,
+                    receiptGeneration: materialPipelineEntry.receipt.generation
+                  }
+                });
+              }
             )
           );
         } else {
@@ -6337,12 +6737,29 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
                 pass,
                 bindingState,
                 smPipelineHandle,
-                instanceDraws2,
+                instanceDraws,
                 entry.mesh.indexed,
                 sm.indexCount,
                 sm.vertexCount,
                 sm.indexOffset,
-                () => c.onRenderableDraw?.(entry)
+                (draw, command) => {
+                  c.onRenderableDraw?.(entry, smIdx);
+                  if (surfacePass === void 0 || draw.surfaceFrameBase === void 0) return;
+                  c.frameState.surfaceSubmissionObservation?.record(surfacePass, {
+                    kind: command,
+                    count: entry.mesh.indexed ? sm.indexCount : sm.vertexCount,
+                    first: entry.mesh.indexed ? sm.indexOffset : 0,
+                    instanceCount: draw.instanceCount,
+                    firstInstance: 0,
+                    surfaceFrameBase: draw.surfaceFrameBase,
+                    memberIds: draw.surfaceMemberIds ?? [],
+                    pipelineIdentity: getOpaqueResourceIdentity(smPipelineHandle),
+                    ...materialPipelineEntry?.receipt === void 0 ? {} : {
+                      receiptIdentity: materialPipelineEntry.receipt.identity,
+                      receiptGeneration: materialPipelineEntry.receipt.generation
+                    }
+                  });
+                }
               )
             )
           );
@@ -6354,7 +6771,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
     }
   }
 }
-function uploadInstanceRanges(c, inst, buffer, ranges, storageBacked, sourceOffsetInstances = 0) {
+function uploadInstanceRanges(c, inst, buffer, ranges, storageBacked, sourceOffsetInstances = 0, previousInst = void 0) {
   const strideBytes = (storageBacked ? INSTANCE_STORAGE_STRIDE_FLOATS : 16) * Float32Array.BYTES_PER_ELEMENT;
   const uploadedRanges = [];
   let uploadedBytes = 0;
@@ -6366,7 +6783,20 @@ function uploadInstanceRanges(c, inst, buffer, ranges, storageBacked, sourceOffs
       (sourceOffsetInstances + start) * 16,
       (sourceOffsetInstances + end) * 16
     );
-    const payload = storageBacked ? packInstanceStorageBuffer(source) : source;
+    const hasIdentityProof = inst.generations !== void 0 && previousInst?.generations !== void 0;
+    const previousSource = hasIdentityProof ? previousInst?.transforms : previousInst?.transforms.subarray(
+      (sourceOffsetInstances + start) * 16,
+      (sourceOffsetInstances + end) * 16
+    );
+    const currentGenerations = inst.generations?.subarray(
+      sourceOffsetInstances + start,
+      sourceOffsetInstances + end
+    );
+    const previousGenerations = hasIdentityProof ? previousInst?.generations : previousInst?.generations?.subarray(
+      sourceOffsetInstances + start,
+      sourceOffsetInstances + end
+    );
+    const payload = storageBacked ? packInstanceStorageBuffer(source, previousSource, currentGenerations, previousGenerations) : source;
     const written = c.runtime.device.queue.writeBuffer(buffer, start * strideBytes, payload);
     if (!written.ok) {
       c.runtime.errorRegistry.fire(written.error);
@@ -6504,7 +6934,8 @@ function resolveStorageInstanceChunks(c, entry, inst, cap, probeBuffer, probeOff
         active.buffer.handle,
         rangesToUpload,
         true,
-        start
+        start,
+        entry.source.temporal?.previousInstances
       );
       for (const range of upload.ranges) {
         uploadedRanges.push({ start: range.start + start, end: range.end + start });
@@ -6540,8 +6971,10 @@ function resolveStorageInstanceChunks(c, entry, inst, cap, probeBuffer, probeOff
         activeBuffer.buffer.handle,
         probeBuffer
       ),
+      ...probeBuffer === void 0 ? {} : { probeBuffer },
       probeOffset,
-      instanceCount: count
+      instanceCount: count,
+      firstInstanceOrdinal: start
     });
   }
   if (chunks !== void 0) {
@@ -6583,6 +7016,7 @@ function resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, useProbe
           pipelineState.identityInstanceBuffer,
           probeBinding?.buffer
         ),
+        ...probeBinding?.buffer === void 0 ? {} : { probeBuffer: probeBinding.buffer },
         probeOffset: probeBinding?.offset ?? -1
       }
     ];
@@ -6661,7 +7095,8 @@ function resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, useProbe
             active.buffer.handle,
             rangesToUpload,
             false,
-            start
+            start,
+            entry.source.temporal?.previousInstances
           );
           for (const range of upload.ranges) {
             uploadedRanges.push({ start: range.start + start, end: range.end + start });
@@ -6694,8 +7129,10 @@ function resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, useProbe
             active.buffer.handle,
             probeBinding?.buffer
           ),
+          ...probeBinding?.buffer === void 0 ? {} : { probeBuffer: probeBinding.buffer },
           probeOffset: probeBinding?.offset ?? -1,
-          instanceCount: count
+          instanceCount: count,
+          firstInstanceOrdinal: start
         });
       }
       if (chunks !== void 0) {
@@ -6749,6 +7186,7 @@ function resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, useProbe
           if (!bufRes.ok) {
             runtime.errorRegistry.fire(bufRes.error);
             reportInstanceFailure(c, inst, bufRes.error, requestedBytes, cap);
+            return null;
           } else {
             if (cached !== void 0 && !cached.buffer.isDestroyed) {
               const r = cached.buffer.destroy();
@@ -6781,7 +7219,9 @@ function resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, useProbe
               inst,
               active.buffer.handle,
               ranges,
-              !uniformFallback
+              !uniformFallback,
+              0,
+              entry.source.temporal?.previousInstances
             );
             uploadRanges = upload.ranges;
             uploadedBytes = upload.bytes;
@@ -6823,43 +7263,61 @@ function resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, useProbe
     {
       instanceBuffer,
       instanceBindGroup: resolveGeometryInstancesBindGroup(c, instanceBuffer, probeBinding?.buffer),
+      ...probeBinding?.buffer === void 0 ? {} : { probeBuffer: probeBinding.buffer },
       probeOffset: probeBinding?.offset ?? -1,
       instanceCount
     }
   ];
 }
+function resolveSurfaceDirectInstanceDraws(c, entry, drawItemIndex, draws) {
+  const resolve = c.gpuDrivenStandardPbrFrameResources?.surfaceDirectInstances;
+  if (resolve === void 0) {
+    c.runtime.errorRegistry.fire(
+      new RhiError({
+        code: "rhi-not-available",
+        expected: "the prepared Surface producer publishes the direct slot-3 resource closure",
+        hint: "prepare the retained Surface frame before recording direct medium draws"
+      })
+    );
+    return null;
+  }
+  const resolved = [];
+  for (const draw of draws) {
+    const direct = resolve({
+      worldId: entry.source.worldId,
+      entityKey: entry.source.entityKey,
+      drawItemIndex,
+      instanceCount: draw.instanceCount,
+      firstInstanceOrdinal: draw.firstInstanceOrdinal ?? 0,
+      instanceBuffer: draw.instanceBuffer,
+      ...draw.probeBuffer === void 0 ? {} : { probeBuffer: draw.probeBuffer },
+      ...draw.probeOffset < 0 ? {} : {
+        probeOffset: draw.probeOffset
+      }
+    });
+    if (!direct.ok) {
+      c.runtime.errorRegistry.fire(direct.error);
+      return null;
+    }
+    resolved.push({
+      ...draw,
+      instanceBindGroup: direct.value.bindGroup,
+      dynamicOffsets: direct.value.dynamicOffsets,
+      surfaceFrameBase: direct.value.frameBase,
+      surfaceMemberIds: direct.value.memberIds
+    });
+  }
+  return resolved;
+}
 function resolveProbeBlendBuffer(c, record, entityKey) {
   const { runtime, frameState } = c;
-  const usage = runtime.device.caps.storageBuffer ? GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST : GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST;
   if (record === void 0) throw new Error("probe blend record is required for probe allocation");
   if (entityKey === void 0) throw new Error("probe blend record requires an entity key");
-  const offset = probeBlendRecordOffset(record.objectKey);
-  const requiredCapacity = record.objectKey + 2;
-  let buffer = frameState.probeBlendRecordBuffer;
-  if (buffer === void 0 || frameState.probeBlendRecordBufferCapacity < requiredCapacity) {
-    const created = runtime.device.createBuffer({
-      label: "probe-blend-records",
-      size: requiredCapacity * PROBE_BLEND_RECORD_STRIDE,
-      usage,
-      mappedAtCreation: false
-    });
-    if (!created.ok) throw created.error;
-    buffer = new GpuBuffer(runtime.device, created.value);
-    frameState.probeBlendRecordBuffer = buffer;
-    frameState.probeBlendRecordBufferCapacity = requiredCapacity;
-    frameState.probeBlendBuffers.clear();
-  }
-  const cached = frameState.probeBlendBuffers.get(entityKey);
-  const unchanged = cached !== void 0 && cached.generation === record.generation && cached.bytes.length === record.bytes.length && cached.bytes.every((value, index) => value === record.bytes[index]);
-  if (!unchanged) {
-    const uploaded = runtime.device.queue.writeBuffer(buffer.handle, offset, record.bytes);
-    if (!uploaded.ok) throw uploaded.error;
-    frameState.probeBlendBuffers.set(entityKey, {
-      generation: record.generation,
-      bytes: new Uint8Array(record.bytes)
-    });
-  }
-  return { buffer: buffer.handle, offset };
+  const buffer = ensureProbeBlendRecordBuffer(runtime.device, frameState, [
+    { cacheKey: entityKey, record }
+  ]);
+  if (buffer === void 0) throw new Error("probe blend record buffer allocation failed");
+  return { buffer, offset: probeBlendRecordOffset(record.objectKey) };
 }
 function resolveGeometryInstancesBindGroup(c, instanceBuffer, probeBuffer) {
   const { runtime, pipelineState, frameState, bindGroupCounts } = c;
@@ -7182,50 +7640,10 @@ function recordSpriteEntityDraws(c, spritePass, matchedIndices, resolveMaterialB
     const spriteInst = spriteEntry.source.instances;
     const useFold = foldHeadBucket !== void 0 && spriteInst === void 0;
     if (useFold && foldHeadBucket !== void 0) {
-      const bucketCacheKey = -1 - ((foldHeadBucket.materialHandle & 65535) << 16 | i & 65535);
-      const uniformFallback = runtime.device.caps.storageBuffer === false;
-      const bucketPayload = uniformFallback ? foldHeadBucket.transforms : packInstanceStorageBuffer(foldHeadBucket.transforms);
-      const bucketBytes = bucketPayload.byteLength;
-      const bucketBufUsage = uniformFallback ? GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST : GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST;
-      const cachedBucket = frameState.instanceBuffers.get(bucketCacheKey);
-      let activeBucket = null;
-      if (cachedBucket !== void 0 && cachedBucket.uploadedArchVersion === foldHeadBucket.bucketSize && cachedBucket.uploadedByteLength === bucketBytes) {
-        activeBucket = cachedBucket;
-      } else if (bucketBytes > 0) {
-        const bufRes = runtime.device.createBuffer({
-          size: bucketBytes,
-          usage: bucketBufUsage,
-          mappedAtCreation: false
-        });
-        if (!bufRes.ok) {
-          runtime.errorRegistry.fire(bufRes.error);
-        } else {
-          if (cachedBucket !== void 0 && !cachedBucket.buffer.isDestroyed) {
-            const r = cachedBucket.buffer.destroy();
-            if (!r.ok) runtime.errorRegistry.fire(r.error);
-          }
-          const newBuf = new GpuBuffer(runtime.device, bufRes.value);
-          activeBucket = {
-            buffer: newBuf,
-            uploadedArchVersion: foldHeadBucket.bucketSize,
-            uploadedByteLength: bucketBytes
-          };
-          frameState.instanceBuffers.set(bucketCacheKey, activeBucket);
-        }
-      }
-      if (activeBucket !== null) {
-        const writeRes = runtime.device.queue.writeBuffer(
-          activeBucket.buffer.handle,
-          0,
-          bucketPayload
-        );
-        if (!writeRes.ok) {
-          runtime.errorRegistry.fire(writeRes.error);
-        } else {
-          spriteInstanceBuffer = activeBucket.buffer.handle;
-          spriteInstanceCount = foldHeadBucket.bucketSize;
-        }
-      }
+      const buffer = resolveFoldInstanceBuffer(c, foldHeadBucket, i);
+      if (buffer === null) continue;
+      spriteInstanceBuffer = buffer;
+      spriteInstanceCount = foldHeadBucket.bucketSize;
     } else if (spriteInst !== void 0) {
       const uniformFallback = runtime.device.caps.storageBuffer === false;
       let spriteBufUsage = GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST;
@@ -7251,13 +7669,18 @@ function recordSpriteEntityDraws(c, spritePass, matchedIndices, resolveMaterialB
           );
           spritePass.setBindGroup(3, spriteInstBg);
           spritePass.drawIndexed(spriteEntry.mesh.indexCount, spriteInstanceCount, 0, 0, 0);
-          c.onRenderableDraw?.(spriteEntry);
+          c.onRenderableDraw?.(spriteEntry, 0);
           continue;
         }
         spriteBufUsage = GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST;
       }
       {
-        const instancePayload = uniformFallback ? spriteInst.transforms : packInstanceStorageBuffer(spriteInst.transforms);
+        const instancePayload = uniformFallback ? spriteInst.transforms : packInstanceStorageBuffer(
+          spriteInst.transforms,
+          spriteEntry.source.temporal?.previousInstances?.transforms,
+          spriteInst.generations,
+          spriteEntry.source.temporal?.previousInstances?.generations
+        );
         const requestedBytes = instancePayload.byteLength;
         const cap = runtime.device.limits.maxStorageBufferBindingSize;
         if (typeof cap === "number" && requestedBytes > cap) {
@@ -7341,7 +7764,7 @@ function recordSpriteEntityDraws(c, spritePass, matchedIndices, resolveMaterialB
     spritePass.setBindGroup(1, spritePassBg, [materialSlot * MATERIAL_PER_ENTITY_STRIDE]);
     spritePass.setBindGroup(3, spriteInstancesBg);
     spritePass.drawIndexed(spriteEntry.mesh.indexCount, spriteInstanceCount, 0, 0, 0);
-    c.onRenderableDraw?.(spriteEntry);
+    c.onRenderableDraw?.(spriteEntry, 0);
   }
 }
 function resolveSpriteInstancesBuffer(c, spriteEntry, fallbackBuffer, fallbackCount) {
@@ -7626,6 +8049,29 @@ function selectLod(input) {
 
 // src/gpu-driven/batch-topology.ts
 var GPU_DRIVEN_SKIN_FLAG = 2147483648;
+function inspectResourceClassSplits(plan) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const batch of plan.batches) {
+    const resourceIdentity = batch.key.resourceIdentity ?? batch.key.materialResourceClass;
+    const group = groups.get(resourceIdentity) ?? { batchIds: [], candidateCount: 0 };
+    group.batchIds.push(batch.batchId);
+    group.candidateCount += batch.candidates.length;
+    groups.set(resourceIdentity, group);
+  }
+  const resourceClassSplits = [...groups.entries()].sort(([left], [right]) => left.localeCompare(right)).map(
+    ([resourceIdentity, group]) => Object.freeze({
+      resourceIdentity,
+      batchIds: Object.freeze([...group.batchIds].sort((left, right) => left - right)),
+      candidateCount: group.candidateCount
+    })
+  );
+  const resourceClassSplitReasons = resourceClassSplits.length <= 1 ? [] : resourceClassSplits.map(({ resourceIdentity }) => `resource-class:${resourceIdentity}`);
+  return Object.freeze({
+    resourceClassCount: resourceClassSplits.length,
+    resourceClassSplits: Object.freeze(resourceClassSplits),
+    resourceClassSplitReasons: Object.freeze(resourceClassSplitReasons)
+  });
+}
 var submissionCandidateMembershipCache = /* @__PURE__ */ new WeakMap();
 function buildSubmissionCandidateMembership(source) {
   const cached = submissionCandidateMembershipCache.get(source);
@@ -7724,7 +8170,8 @@ function eligibleDraws(slot) {
           materialResourceClass: draw.materialResourceClass,
           preparedIdentity,
           resourceIdentity: draw.materialResourceClass,
-          admission
+          admission,
+          materialPass: material.deferredPass === true ? "deferred" : "forward-only"
         },
         prepared,
         ...candidatePayload(draw, snapshot)
@@ -7992,6 +8439,7 @@ var BatchTopology = class {
   inspect() {
     let candidateCount = 0;
     for (const batch of this.batches.values()) candidateCount += batch.candidates.size;
+    const resourceClasses = inspectResourceClassSplits(this.plan());
     return {
       revision: this.revision,
       batchCount: this.batches.size,
@@ -8003,7 +8451,10 @@ var BatchTopology = class {
       membershipChecks: this.membershipChecks,
       membershipAllocations: this.membershipAllocations,
       candidateAdds: this.candidateAdds,
-      candidateRemoves: this.candidateRemoves
+      candidateRemoves: this.candidateRemoves,
+      resourceClassCount: resourceClasses.resourceClassCount,
+      resourceClassSplits: resourceClasses.resourceClassSplits,
+      resourceClassSplitReasons: resourceClasses.resourceClassSplitReasons
     };
   }
   add(slot) {
@@ -8089,6 +8540,410 @@ var BatchTopology = class {
     };
   }
 };
+function decodeSurfaceIndirectParameters(input) {
+  const ranges = input.recording.passes.flatMap(
+    (pass) => pass.ranges.map((range) => ({ pass: pass.pass, ...range }))
+  );
+  if (input.byteOffset < 0 || input.byteLength < 0 || input.byteOffset + input.byteLength > input.bytes.byteLength) {
+    return err$1({
+      code: "indirect-readback-truncated",
+      expected: "the indirect readback range is contained by the mapped buffer",
+      hint: "retain the complete GPU indirect command copy before mapping it",
+      actual: {
+        byteOffset: input.byteOffset,
+        byteLength: input.byteLength,
+        bufferBytes: input.bytes.byteLength
+      }
+    });
+  }
+  const values = new DataView(input.bytes, input.byteOffset, input.byteLength);
+  const decoded = [];
+  for (const range of ranges) {
+    if (range.indirectBufferIdentity !== input.indirectBufferIdentity) {
+      return err$1({
+        code: "indirect-readback-metadata-mismatch",
+        expected: "every Surface indirect range names the copied indirect buffer",
+        hint: "discard the readback and wait for the matching resource generation",
+        actual: {
+          pass: range.pass,
+          expectedBufferIdentity: input.indirectBufferIdentity,
+          actualBufferIdentity: range.indirectBufferIdentity
+        }
+      });
+    }
+    const offset = range.indirectOffset;
+    if (!Number.isInteger(offset) || offset < 0 || offset % 4 !== 0 || offset + 20 > values.byteLength) {
+      return err$1({
+        code: "indirect-readback-truncated",
+        expected: "each indirect range is a 20-byte aligned command inside the copied buffer",
+        hint: "discard truncated selector readback instead of publishing partial draw parameters",
+        actual: { pass: range.pass, indirectOffset: offset, readbackBytes: values.byteLength }
+      });
+    }
+    const indexed = range.kind === "draw-indexed-indirect";
+    decoded.push(
+      Object.freeze({
+        sequence: input.recording.sequence,
+        frameId: input.recording.frameId,
+        deviceGeneration: input.recording.deviceGeneration,
+        resourceGeneration: input.recording.resourceGeneration,
+        viewIdentity: input.recording.viewIdentity,
+        pass: range.pass,
+        kind: range.kind,
+        indirectBufferIdentity: range.indirectBufferIdentity,
+        indirectOffset: offset,
+        count: values.getUint32(offset, true),
+        first: values.getUint32(offset + 8, true),
+        instanceCount: values.getUint32(offset + 4, true),
+        baseVertex: indexed ? values.getInt32(offset + 12, true) : 0,
+        firstInstance: values.getUint32(indexed ? offset + 16 : offset + 12, true)
+      })
+    );
+  }
+  return ok(Object.freeze(decoded));
+}
+var MAX_COMMANDS_PER_PASS = 32;
+function isIndirect(command) {
+  return command.kind === "draw-indirect" || command.kind === "draw-indexed-indirect";
+}
+function sameReadbackPass(receipt, snapshot) {
+  if (receipt.pass !== snapshot.pass || receipt.totalCommandCount !== snapshot.totalCommandCount || receipt.savedCommandCount !== snapshot.savedCommandCount || receipt.droppedCommandCount !== snapshot.droppedCommandCount || receipt.truncated !== snapshot.truncated) {
+    return false;
+  }
+  const ranges = receipt.commands.flatMap(
+    (command) => command.kind === "draw-indirect" || command.kind === "draw-indexed-indirect" ? [
+      {
+        kind: command.kind,
+        indirectBufferIdentity: command.indirectBufferIdentity,
+        indirectOffset: command.indirectOffset
+      }
+    ] : []
+  );
+  return ranges.length === snapshot.ranges.length && ranges.every((range, index) => {
+    const expected = snapshot.ranges[index];
+    return expected !== void 0 && range.kind === expected.kind && range.indirectBufferIdentity === expected.indirectBufferIdentity && range.indirectOffset === expected.indirectOffset;
+  });
+}
+function sameIndirectParameters(recording, parameters) {
+  const expected = recording.passes.flatMap(
+    (pass) => pass.ranges.map((range) => ({ pass: pass.pass, ...range }))
+  );
+  return expected.length === parameters.length && expected.every((range, index) => {
+    const actual = parameters[index];
+    return actual !== void 0 && actual.sequence === recording.sequence && actual.frameId === recording.frameId && actual.deviceGeneration === recording.deviceGeneration && actual.resourceGeneration === recording.resourceGeneration && actual.viewIdentity === recording.viewIdentity && actual.pass === range.pass && actual.kind === range.kind && actual.indirectBufferIdentity === range.indirectBufferIdentity && actual.indirectOffset === range.indirectOffset;
+  });
+}
+var SurfaceSubmissionCandidate = class {
+  constructor(owner, sequence, frameId, requestedLane, deviceGeneration, viewIdentity, resourceGeneration) {
+    this.owner = owner;
+    this.sequence = sequence;
+    this.frameId = frameId;
+    this.requestedLane = requestedLane;
+    this.deviceGeneration = deviceGeneration;
+    this.viewIdentity = viewIdentity;
+    this.resolvedResourceGeneration = resourceGeneration;
+  }
+  owner;
+  sequence;
+  frameId;
+  requestedLane;
+  deviceGeneration;
+  viewIdentity;
+  passes = /* @__PURE__ */ new Map();
+  state = "recording";
+  resolvedResourceGeneration;
+  actualLaneReason;
+  setResourceGeneration(generation) {
+    if (this.state === "recording") this.resolvedResourceGeneration = generation;
+  }
+  get resourceGeneration() {
+    return this.resolvedResourceGeneration;
+  }
+  setActualLaneReason(reason) {
+    if (this.state === "recording") this.actualLaneReason = reason;
+  }
+  record(pass, command) {
+    if (this.state !== "recording") return;
+    let recording = this.passes.get(pass);
+    if (recording === void 0) {
+      recording = { commands: [], totalCommandCount: 0, sawIndirect: false };
+      this.passes.set(pass, recording);
+    }
+    recording.totalCommandCount += 1;
+    recording.sawIndirect ||= isIndirect(command);
+    if (recording.commands.length >= MAX_COMMANDS_PER_PASS) return;
+    const programEvidence = command.receiptIdentity === void 0 || command.receiptGeneration === void 0 ? "missing" : "producer-receipt";
+    recording.commands.push(Object.freeze({ ...command, programEvidence }));
+  }
+  /** Snapshot consumed only by the readback copy encoded for this candidate. */
+  gpuReadbackSnapshot() {
+    if (this.state !== "submitted") return void 0;
+    const passes = ["nearest-layer", "color"].flatMap((pass) => {
+      const recording = this.passes.get(pass);
+      if (recording === void 0) return [];
+      if (!recording.sawIndirect) return [];
+      const ranges = recording.commands.flatMap(
+        (command) => isIndirect(command) ? [
+          Object.freeze({
+            kind: command.kind,
+            indirectBufferIdentity: command.indirectBufferIdentity,
+            indirectOffset: command.indirectOffset
+          })
+        ] : []
+      );
+      const savedCommandCount = recording.commands.length;
+      return [
+        Object.freeze({
+          pass,
+          totalCommandCount: recording.totalCommandCount,
+          savedCommandCount,
+          droppedCommandCount: recording.totalCommandCount - savedCommandCount,
+          truncated: recording.totalCommandCount > savedCommandCount,
+          ranges: Object.freeze(ranges)
+        })
+      ];
+    });
+    return Object.freeze({
+      sequence: this.sequence,
+      frameId: this.frameId,
+      deviceGeneration: this.deviceGeneration,
+      resourceGeneration: this.resourceGeneration,
+      viewIdentity: this.viewIdentity,
+      passes: Object.freeze(passes)
+    });
+  }
+  get laneReason() {
+    return this.actualLaneReason;
+  }
+  submit(completed, graphGeneration) {
+    if (this.state !== "recording") return;
+    this.state = "submitted";
+    this.owner.submit(this, completed, graphGeneration, this.passes);
+  }
+  abort() {
+    if (this.state === "recording") this.state = "aborted";
+  }
+};
+var SurfaceSubmissionObservationOwner = class {
+  constructor(currentDeviceGeneration) {
+    this.currentDeviceGeneration = currentDeviceGeneration;
+  }
+  currentDeviceGeneration;
+  sequence = 0;
+  acceptedSequence = 0;
+  latest;
+  begin(input) {
+    this.sequence += 1;
+    return new SurfaceSubmissionCandidate(
+      this,
+      this.sequence,
+      input.frameId,
+      input.requestedLane,
+      input.deviceGeneration,
+      "main:0",
+      input.resourceGeneration
+    );
+  }
+  inspect() {
+    return this.latest;
+  }
+  /** Attach only selector-visible members copied for this exact completed recording. */
+  publishGpuMembers(readback, targetOrLegacyMembers) {
+    const target = targetOrLegacyMembers === void 0 || Array.isArray(targetOrLegacyMembers) ? void 0 : targetOrLegacyMembers;
+    if (typeof readback === "number" || target === void 0) return;
+    const latest = this.latest;
+    const recording = readback.recording;
+    if (latest === void 0 || latest.status !== "completed" || latest.actualLane !== "gpu-driven" || latest.sequence !== recording.sequence || latest.frameId !== recording.frameId || latest.deviceGeneration !== recording.deviceGeneration || latest.resourceGeneration !== recording.resourceGeneration || latest.viewIdentity !== recording.viewIdentity || latest.frameId !== target.frameId || latest.deviceGeneration !== target.deviceGeneration || latest.passes.length !== recording.passes.length || !latest.passes.every((pass, index) => {
+      const snapshot = recording.passes[index];
+      return snapshot !== void 0 && sameReadbackPass(pass, snapshot);
+    })) {
+      return;
+    }
+    if (readback.indirectParameters === void 0 || !sameIndirectParameters(recording, readback.indirectParameters)) {
+      return;
+    }
+    this.latest = Object.freeze({
+      ...latest,
+      passes: Object.freeze(
+        latest.passes.map((pass) => {
+          const passParameters = readback.indirectParameters?.filter(
+            (parameter) => parameter.pass === pass.pass
+          );
+          return Object.freeze({
+            ...pass,
+            memberEvidence: readback.indirectParameters === void 0 ? "indirect-readback-required" : pass.truncated ? "indirect-visible-readback-truncated" : "indirect-visible-readback",
+            memberIds: Object.freeze([...readback.memberIds]),
+            ...pass.truncated || passParameters === void 0 ? {} : { indirectParameters: Object.freeze(passParameters) }
+          });
+        })
+      )
+    });
+  }
+  submit(candidate, completed, graphGeneration, recordings) {
+    const sequence = candidate.sequence;
+    const passes = ["nearest-layer", "color"].flatMap((pass) => {
+      const recording = recordings.get(pass);
+      if (recording === void 0 || recording.totalCommandCount === 0) return [];
+      const savedCommandCount = recording.commands.length;
+      const truncated = recording.totalCommandCount > savedCommandCount;
+      return [
+        Object.freeze({
+          pass,
+          commandCount: recording.totalCommandCount,
+          totalCommandCount: recording.totalCommandCount,
+          savedCommandCount,
+          droppedCommandCount: recording.totalCommandCount - savedCommandCount,
+          truncated,
+          memberEvidence: recording.sawIndirect ? "indirect-readback-required" : truncated ? "direct-command-members-truncated" : "direct-command-members",
+          commands: Object.freeze([...recording.commands])
+        })
+      ];
+    });
+    if (passes.length === 0) return;
+    const actualLane = [...recordings.values()].some((recording) => recording.sawIndirect) ? "gpu-driven" : "direct";
+    const submitted = Object.freeze({
+      sequence,
+      frameId: candidate.frameId,
+      requestedLane: candidate.requestedLane,
+      actualLane,
+      ...candidate.laneReason === void 0 ? {} : { actualLaneReason: candidate.laneReason },
+      deviceGeneration: candidate.deviceGeneration,
+      graphGeneration,
+      viewIdentity: candidate.viewIdentity,
+      resourceGeneration: candidate.resourceGeneration,
+      status: "submitted",
+      passes: Object.freeze(passes)
+    });
+    this.latest = submitted;
+    void completed.then(
+      () => {
+        if (sequence !== this.sequence || sequence < this.acceptedSequence || this.currentDeviceGeneration() !== candidate.deviceGeneration) {
+          return;
+        }
+        this.acceptedSequence = sequence;
+        this.latest = Object.freeze({ ...submitted, status: "completed" });
+      },
+      () => void 0
+    );
+  }
+};
+
+// src/gpu-driven/resource-allocation.ts
+var GpuResourceAllocationLedger = class {
+  nextId = 1;
+  live = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  liveBytes = 0;
+  pendingBytes = 0;
+  peakBytes = 0;
+  successfulAllocationCount = 0;
+  successfulAllocationBytes = 0;
+  retiredBytes = 0;
+  failedAllocationRollbacks = 0;
+  failedAllocationRollbackBytes = 0;
+  allocate(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0) {
+      throw new RangeError(`GPU allocation bytes must be finite and non-negative (got ${bytes})`);
+    }
+    const token = { id: this.nextId++, bytes };
+    this.live.set(token.id, token.bytes);
+    this.liveBytes += token.bytes;
+    this.successfulAllocationCount += 1;
+    this.successfulAllocationBytes += token.bytes;
+    this.updatePeak();
+    return token;
+  }
+  retire(token) {
+    const bytes = this.live.get(token.id);
+    if (bytes === void 0) return;
+    this.live.delete(token.id);
+    this.liveBytes -= bytes;
+    this.pending.set(token.id, bytes);
+    this.pendingBytes += bytes;
+    this.updatePeak();
+  }
+  release(token) {
+    const pendingBytes = this.pending.get(token.id);
+    if (pendingBytes !== void 0) {
+      this.pending.delete(token.id);
+      this.pendingBytes -= pendingBytes;
+      this.retiredBytes += pendingBytes;
+      return;
+    }
+    const liveBytes = this.live.get(token.id);
+    if (liveBytes !== void 0) {
+      this.live.delete(token.id);
+      this.liveBytes -= liveBytes;
+      this.retiredBytes += liveBytes;
+    }
+  }
+  rollback(token) {
+    const bytes = this.live.get(token.id);
+    if (bytes === void 0) return;
+    this.live.delete(token.id);
+    this.liveBytes -= bytes;
+    this.failedAllocationRollbacks += 1;
+    this.failedAllocationRollbackBytes += bytes;
+  }
+  inspect() {
+    return {
+      unit: "engine-allocation-bytes",
+      physicalResidency: "unknown",
+      liveBytes: this.liveBytes,
+      pendingRetirementBytes: this.pendingBytes,
+      peakBytes: this.peakBytes,
+      successfulAllocationCount: this.successfulAllocationCount,
+      successfulAllocationBytes: this.successfulAllocationBytes,
+      pendingRetirementCount: this.pending.size,
+      retiredBytes: this.retiredBytes,
+      failedAllocationRollbacks: this.failedAllocationRollbacks,
+      failedAllocationRollbackBytes: this.failedAllocationRollbackBytes
+    };
+  }
+  updatePeak() {
+    this.peakBytes = Math.max(this.peakBytes, this.liveBytes + this.pendingBytes);
+  }
+};
+function combineGpuResourceAllocationInspections(inspections) {
+  if (inspections.length === 0) return void 0;
+  const liveBytes = inspections.reduce((sum, value) => sum + value.liveBytes, 0);
+  const pendingRetirementBytes = inspections.reduce(
+    (sum, value) => sum + value.pendingRetirementBytes,
+    0
+  );
+  const peakBytes = Math.max(
+    liveBytes + pendingRetirementBytes,
+    ...inspections.map((value) => value.peakBytes)
+  );
+  return {
+    unit: "engine-allocation-bytes",
+    physicalResidency: "unknown",
+    liveBytes,
+    pendingRetirementBytes,
+    peakBytes,
+    successfulAllocationCount: inspections.reduce(
+      (sum, value) => sum + value.successfulAllocationCount,
+      0
+    ),
+    successfulAllocationBytes: inspections.reduce(
+      (sum, value) => sum + value.successfulAllocationBytes,
+      0
+    ),
+    pendingRetirementCount: inspections.reduce(
+      (sum, value) => sum + value.pendingRetirementCount,
+      0
+    ),
+    retiredBytes: inspections.reduce((sum, value) => sum + value.retiredBytes, 0),
+    failedAllocationRollbacks: inspections.reduce(
+      (sum, value) => sum + value.failedAllocationRollbacks,
+      0
+    ),
+    failedAllocationRollbackBytes: inspections.reduce(
+      (sum, value) => sum + value.failedAllocationRollbackBytes,
+      0
+    )
+  };
+}
 
 // src/scene/visibility/occlusion-confidence.ts
 function createConfidenceState() {
@@ -8440,6 +9295,7 @@ var COUNTER_WORDS = 2 + LOD_ROW_CAPACITY + 2;
 var GEOMETRY_WORK_COUNTER_OFFSET = 2 + LOD_ROW_CAPACITY;
 var ROOT_GEOMETRY_WORK_COUNTER_OFFSET = GEOMETRY_WORK_COUNTER_OFFSET + 1;
 var COUNTER_STRIDE = COUNTER_WORDS * 4;
+var INDIRECT_COMMAND_BYTES = 20;
 function selectGpuLodLane(caps) {
   return caps.compute && caps.storageBuffer && caps.indirectDrawing ? "gpu" : "cpu";
 }
@@ -8556,7 +9412,7 @@ fn selectLodLevel(
 @group(0) @binding(4) var<storage, read> batches: array<BatchRecord>;
 @group(0) @binding(5) var<uniform> view: ViewConstants;
 @group(0) @binding(6) var<storage, read_write> counters: array<atomic<u32>>;
-@group(0) @binding(7) var<storage, read_write> visibleIndices: array<vec2<u32>>;
+@group(0) @binding(7) var<storage, read_write> visibleIndices: array<vec4<u32>>;
 @group(0) @binding(8) var<storage, read_write> indirectArgs: array<u32>;
 
 fn counterIndex(batchIndex: u32) -> u32 { return batchIndex * ${COUNTER_WORDS}u; }
@@ -8641,9 +9497,11 @@ fn cullView(@builtin(global_invocation_id) id: vec3<u32>) {
   if ((candidate.materialSlot & 0x80000000u) != 0u) {
     materialOrPalette = instance.customDataStart;
   }
-  visibleIndices[candidate.visibleBase + localVisible] = vec2<u32>(
+  visibleIndices[candidate.visibleBase + localVisible] = vec4<u32>(
     candidate.submitAdmission >> 1u,
     materialOrPalette,
+    candidate.primitiveIndex + 1u,
+    candidate.generation,
   );
 }
 
@@ -8666,10 +9524,22 @@ fn finalizeView(@builtin(global_invocation_id) id: vec3<u32>) {
   let candidate = candidates[batch.candidateBase];
   let selectedLod = selectLodLevel(candidate.projectedHeight, candidate.previousLevel, candidate.historyValid != 0u, candidate.lodRows, candidate.lodCount);
   let lod = candidate.lodRows[selectedLod];
-  indirectArgs[args] = select(batch.count, lod.indexCount, candidate.lodCount > 0u);
+  var drawCount = batch.count;
+  var drawFirst = batch.first;
+  var drawBaseVertex: i32 = 0;
+  if (candidate.lodCount > 0u) {
+    drawCount = lod.indexCount;
+    if (batch.indexed != 0u) {
+      drawFirst = lod.firstIndex;
+      drawBaseVertex = lod.baseVertex;
+    }
+  } else if (batch.indexed != 0u) {
+    drawBaseVertex = batch.baseVertex;
+  }
+  indirectArgs[args] = drawCount;
   indirectArgs[args + 1u] = visibleCount;
-  indirectArgs[args + 2u] = select(batch.first, lod.firstIndex, candidate.lodCount > 0u && batch.indexed != 0u);
-  indirectArgs[args + 3u] = select(0u, bitcast<u32>(lod.baseVertex), candidate.lodCount > 0u && batch.indexed != 0u);
+  indirectArgs[args + 2u] = drawFirst;
+  indirectArgs[args + 3u] = bitcast<u32>(drawBaseVertex);
   indirectArgs[args + 4u] = 0u;
 }
 `
@@ -8731,11 +9601,18 @@ var GpuDrivenView = class _GpuDrivenView {
   bindGroupCreates = 0;
   bufferRebuilds = 0;
   resourceGeneration = 0;
+  allocationLedger = new GpuResourceAllocationLedger();
+  allocationTokens = /* @__PURE__ */ new WeakMap();
   /** The last readback copy that was actually encoded and is not consumed. */
   telemetryPending;
+  /** Receipt identity for the copy pass encoded by the current frame. */
+  telemetrySubmit;
   /** Coalesce observers while the readback buffer is map-pending. */
   lodSelectionReadback;
   lodSelection;
+  setTelemetrySubmit(identity) {
+    this.telemetrySubmit = identity;
+  }
   static create(input) {
     const { device, shaderModuleFactory } = input;
     const labelPrefix = input.labelPrefix ?? "gpu-driven-view";
@@ -8966,7 +9843,8 @@ var GpuDrivenView = class _GpuDrivenView {
       viewConstantsUploadBytes: this.viewConstantsUploadBytes,
       bindGroupCreates: this.bindGroupCreates,
       bufferRebuilds: this.bufferRebuilds,
-      resourceGeneration: this.resourceGeneration
+      resourceGeneration: this.resourceGeneration,
+      resourceAllocation: this.allocationLedger.inspect()
     };
   }
   get visibleBuffer() {
@@ -9011,6 +9889,7 @@ var GpuDrivenView = class _GpuDrivenView {
       let overflow = false;
       let geometryWork = 0;
       let rootGeometryWork = 0;
+      const actualMembers = [];
       const histogram = /* @__PURE__ */ new Map();
       for (let batchIndex = 0; batchIndex < plan.batches.length; batchIndex += 1) {
         const offset = batchIndex * COUNTER_STRIDE;
@@ -9019,6 +9898,26 @@ var GpuDrivenView = class _GpuDrivenView {
           values.getUint32(offset, true),
           plan.batches[batchIndex]?.visibleCapacity ?? 0
         );
+        const batch = plan.batches[batchIndex];
+        const admitted = batch?.candidates.filter(
+          (candidate) => candidate.submitAdmission !== false
+        ) ?? [];
+        for (let visibleIndex = 0; visibleIndex < batchVisible; visibleIndex += 1) {
+          const visibleOffset = this.batchCapacity * COUNTER_STRIDE + ((batch?.visibleBase ?? 0) + visibleIndex) * 16;
+          const projectionIndex = values.getUint32(visibleOffset, true);
+          const primitiveIndex = values.getUint32(visibleOffset + 8, true) - 1;
+          const generation = values.getUint32(visibleOffset + 12, true);
+          const candidate = admitted[projectionIndex];
+          if (batch !== void 0 && candidate !== void 0 && candidate.primitiveIndex === primitiveIndex && candidate.generation === generation) {
+            actualMembers.push({
+              batchId: batch.batchId,
+              primitiveIndex,
+              generation,
+              drawItemIndex: candidate.drawItemIndex,
+              instanceOrdinal: candidate.instanceOrdinal
+            });
+          }
+        }
         visible += batchVisible;
         overflow ||= batchOverflow;
         geometryWork += values.getUint32(offset + GEOMETRY_WORK_COUNTER_OFFSET * 4, true);
@@ -9032,7 +9931,16 @@ var GpuDrivenView = class _GpuDrivenView {
         return void 0;
       }
       const candidateCount = plan.candidateCount;
+      const surfaceReadback = copy.surfaceReadbackSnapshot?.();
+      const surfaceIndirectReadback = surfaceReadback === void 0 ? void 0 : decodeSurfaceIndirectParameters({
+        bytes: range.value,
+        byteOffset: copy.indirectReadbackOffset,
+        byteLength: this.indirectCapacity * INDIRECT_COMMAND_BYTES,
+        indirectBufferIdentity: copy.indirectBufferIdentity,
+        recording: surfaceReadback
+      });
       this.lodSelection = Object.freeze({
+        resourceGeneration: copy.resourceGeneration,
         candidateCount,
         batchCount: plan.batches.length,
         // Selector-only batches remain in the plan/readback but the production
@@ -9073,7 +9981,11 @@ var GpuDrivenView = class _GpuDrivenView {
           })
         ),
         geometryWork,
-        rootGeometryWork
+        rootGeometryWork,
+        actualMembers: Object.freeze(actualMembers),
+        ...surfaceReadback === void 0 ? {} : { surfaceReadback },
+        ...surfaceIndirectReadback === void 0 ? {} : surfaceIndirectReadback.ok ? { surfaceIndirectParameters: surfaceIndirectReadback.value } : { surfaceIndirectReadbackError: surfaceIndirectReadback.error },
+        ...copy.submit === void 0 ? {} : { submit: copy.submit }
       });
       this.telemetryPending = void 0;
       return this.lodSelection;
@@ -9081,7 +9993,7 @@ var GpuDrivenView = class _GpuDrivenView {
       mapped.value.unmap();
     }
   }
-  addPasses(builder, labelPrefix = "gpu-driven", includeCompute = true) {
+  addPasses(builder, labelPrefix = "gpu-driven", includeCompute = true, surfaceSubmissionObservation) {
     const buffers = this.buffers;
     const bindGroup = this.bindGroup;
     const plan = this.plan;
@@ -9161,14 +10073,14 @@ var GpuDrivenView = class _GpuDrivenView {
     const lodReadback = importBuffer(
       `${labelPrefix}.lod-selection-readback`,
       buffers.lodReadback,
-      this.batchCapacity * COUNTER_STRIDE,
+      this.batchCapacity * COUNTER_STRIDE + this.visibleBufferCapacity * 16 + this.indirectCapacity * INDIRECT_COMMAND_BYTES,
       GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST
     );
     if (!lodReadback.ok) return lodReadback;
     const visible = importBuffer(
       `${labelPrefix}.visible`,
       buffers.visible,
-      this.visibleBufferCapacity * 8,
+      this.visibleBufferCapacity * 16,
       GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_SRC
     );
     if (!visible.ok) return visible;
@@ -9234,9 +10146,13 @@ var GpuDrivenView = class _GpuDrivenView {
     });
     if (!finalize.ok) return finalize;
     const graphResourceGeneration = this.resourceGeneration;
+    const indirectReadbackOffset = this.batchCapacity * COUNTER_STRIDE + this.visibleBufferCapacity * 16;
+    const indirectBufferIdentity = getOpaqueResourceIdentity(buffers.indirect);
     const readback = builder.addCopyPass(`${labelPrefix}.lod-selection-readback`, {
       accesses: [
         { resource: counters.value, usage: "copy-src" },
+        { resource: visible.value, usage: "copy-src" },
+        { resource: indirect.value, usage: "copy-src" },
         { resource: lodReadback.value, usage: "copy-dst" }
       ],
       encode: ({ encoder, resources }) => {
@@ -9247,12 +10163,33 @@ var GpuDrivenView = class _GpuDrivenView {
           resources.buffer(lodReadback.value).unwrap(),
           this.batchCapacity * COUNTER_STRIDE
         );
+        encoder.copyBufferToBuffer(
+          resources.buffer(visible.value).unwrap(),
+          0,
+          resources.buffer(lodReadback.value).unwrap(),
+          this.batchCapacity * COUNTER_STRIDE,
+          this.visibleBufferCapacity * 16
+        );
+        encoder.copyBufferToBuffer(
+          resources.buffer(indirect.value).unwrap(),
+          0,
+          resources.buffer(lodReadback.value).unwrap(),
+          indirectReadbackOffset,
+          this.indirectCapacity * INDIRECT_COMMAND_BYTES
+        );
         const submittedPlan = this.plan;
         if (this.buffers === buffers && submittedPlan !== void 0 && this.resourceGeneration === graphResourceGeneration) {
+          const submittedObservation = surfaceSubmissionObservation?.();
           this.telemetryPending = {
             buffers,
             plan: submittedPlan,
-            resourceGeneration: graphResourceGeneration
+            resourceGeneration: graphResourceGeneration,
+            indirectBufferIdentity,
+            indirectReadbackOffset,
+            ...submittedObservation === void 0 ? {} : {
+              surfaceReadbackSnapshot: () => submittedObservation.gpuReadbackSnapshot()
+            },
+            ...this.telemetrySubmit === void 0 ? {} : { submit: this.telemetrySubmit }
           };
         }
       }
@@ -9284,8 +10221,10 @@ var GpuDrivenView = class _GpuDrivenView {
     this.sceneMaterial = void 0;
     this.sceneCapacity = 0;
     this.telemetryPending = void 0;
+    this.telemetrySubmit = void 0;
     this.lodSelectionReadback = void 0;
     this.lodSelection = void 0;
+    for (const generation of buffers) this.retireGeneration(generation);
     this.destroyAfterSubmittedWork(buffers);
     void this.pipelineLayout;
   }
@@ -9322,6 +10261,7 @@ var GpuDrivenView = class _GpuDrivenView {
     const nextBatch = nextCapacity(batchCapacity);
     const nextIndirect = nextCapacity(indirectCapacity);
     const created = {};
+    const createdTokens = [];
     const allocate = (name, size, usage) => {
       const buffer = this.device.createBuffer({
         label: `gpu-driven-view-${name}`,
@@ -9331,6 +10271,9 @@ var GpuDrivenView = class _GpuDrivenView {
       });
       if (!buffer.ok) return buffer;
       created[name] = buffer.value;
+      const token = this.allocationLedger.allocate(size);
+      this.allocationTokens.set(buffer.value, token);
+      createdTokens.push(token);
       return ok$1(void 0);
     };
     const storage = GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_SRC;
@@ -9354,7 +10297,7 @@ var GpuDrivenView = class _GpuDrivenView {
         storage: false
       },
       { name: "counters", size: nextBatch * COUNTER_STRIDE, usage: storage, storage: true },
-      { name: "visible", size: nextVisible * 8, usage: storage, storage: true },
+      { name: "visible", size: nextVisible * 16, usage: storage, storage: true },
       {
         name: "indirect",
         size: nextIndirect * 20,
@@ -9363,7 +10306,7 @@ var GpuDrivenView = class _GpuDrivenView {
       },
       {
         name: "lodReadback",
-        size: nextBatch * COUNTER_STRIDE,
+        size: nextBatch * COUNTER_STRIDE + nextVisible * 16 + nextIndirect * INDIRECT_COMMAND_BYTES,
         usage: GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST,
         storage: false
       }
@@ -9389,10 +10332,14 @@ var GpuDrivenView = class _GpuDrivenView {
       const result = allocate(request.name, request.size, request.usage);
       if (!result.ok) {
         for (const buffer of Object.values(created)) this.device.destroyBuffer(buffer);
+        for (const token of createdTokens) this.allocationLedger.rollback(token);
         return result;
       }
     }
-    if (this.buffers !== void 0) this.supersededBuffers.push(this.buffers);
+    if (this.buffers !== void 0) {
+      this.supersededBuffers.push(this.buffers);
+      this.retireGeneration(this.buffers);
+    }
     this.buffers = created;
     this.candidateCapacity = nextCandidate;
     this.visibleBufferCapacity = nextVisible;
@@ -9409,11 +10356,19 @@ var GpuDrivenView = class _GpuDrivenView {
       for (const buffers of generations) {
         for (const buffer of Object.values(buffers)) {
           this.device.destroyBuffer(buffer);
+          const token = this.allocationTokens.get(buffer);
+          if (token !== void 0) this.allocationLedger.release(token);
         }
       }
     };
     void this.device.queue.onSubmittedWorkDone().then(release, release);
   }
+  retireGeneration(generation) {
+    for (const buffer of Object.values(generation)) {
+      const token = this.allocationTokens.get(buffer);
+      if (token !== void 0) this.allocationLedger.retire(token);
+    }
+  }
 };
 
 // src/gpu-driven/shadow-views.ts
@@ -9841,6 +10796,7 @@ function ensureTypedShadowViewBg(c, viewOffset, cascadeOffset, variant) {
     );
   }
   const projectorAvailable = pipelineState.projectorAvailable !== false;
+  const lowLimitCloudBindings = !extendedLighting && !projectorAvailable;
   try {
     return getOrCreateFromChain(
       frameState.viewBindGroupCache,
@@ -9853,7 +10809,8 @@ function ensureTypedShadowViewBg(c, viewOffset, cascadeOffset, variant) {
         pipelineState.shadowCasterCascadeBuffer,
         pipelineState.shadowFallbackTextureView,
         ...extendedLighting ? extendedLightingCacheKeys : projectorAvailable ? [pipelineState.defaultWhiteTextureView, pipelineState.defaultSampler] : [],
-        pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer
+        pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer,
+        ...lowLimitCloudBindings ? [] : [pipelineState.defaultWhiteTextureView, pipelineState.defaultSampler]
       ],
       variant,
       () => {
@@ -9929,7 +10886,23 @@ function ensureTypedShadowViewBg(c, viewOffset, cascadeOffset, variant) {
                 binding: 12,
                 resource: { kind: "sampler", value: pipelineState.defaultSampler }
               }
-            ] : []
+            ] : [],
+            ...lowLimitCloudBindings ? [] : [
+              {
+                binding: 16,
+                resource: {
+                  kind: "textureView",
+                  value: pipelineState.defaultWhiteTextureView
+                }
+              },
+              {
+                binding: 17,
+                resource: {
+                  kind: "sampler",
+                  value: pipelineState.defaultSampler
+                }
+              }
+            ]
           ]
         });
         if (!created.ok) throw created.error;
@@ -10308,6 +11281,7 @@ function recordGpuDrivenShadowIfPublished(c, pass, identity) {
       visibleBindGroup: projection.visibleBindGroup,
       deformation: projection.deformation,
       materialGroup,
+      ...batch.key.admission === "alpha-mask" ? { alphaMaskMaterialGroup: materialGroup } : {},
       vertexBuffer: projection.mesh.vertexBuffer.handle,
       ...batch.key.drawKind === "indexed" && projection.mesh.indexBuffer !== null ? {
         indexBuffer: projection.mesh.indexBuffer.handle,
@@ -10853,7 +11827,12 @@ function recordShadowCasterDraws(c, shadowPass, shadowPipeline2, shadowMeshBindG
         }
       } else {
         const bufUsage = uniformFallback ? GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST : GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST;
-        const instancePayload = uniformFallback ? shadowInst.transforms : packInstanceStorageBuffer(shadowInst.transforms);
+        const instancePayload = uniformFallback ? shadowInst.transforms : packInstanceStorageBuffer(
+          shadowInst.transforms,
+          entry.source.temporal?.previousInstances?.transforms,
+          shadowInst.generations,
+          entry.source.temporal?.previousInstances?.generations
+        );
         const requestedBytes = instancePayload.byteLength;
         const cap = runtime.device.limits.maxStorageBufferBindingSize;
         if (!uniformFallback && typeof cap === "number" && cap > 0 && requestedBytes > cap) {
@@ -11217,7 +12196,10 @@ function ensureGpuDrivenAlphaMaskMaterialBg(c, projection) {
   return bindGroup;
 }
 function ensureGpuDrivenCustomShadowMaterialBg(c, projection) {
-  const shaderId = projection.shadowArtifact.material;
+  const shaderId = projection.shadowArtifact.specializationKey ?? projection.shadowArtifact.material;
+  const materialKey = `shadow-material-custom:${shaderId}:${projection.materialEntityKey}:${projection.material.materialHandle ?? -1}:${c.store.materialResourceEpoch}`;
+  const cached = c.materialBgAssemblyCache.get(materialKey);
+  if (cached !== void 0) return cached.bindGroup;
   const fallback = c.pipelineState.skylightFallback;
   if (fallback === null) {
     throw new RhiError({
@@ -11279,18 +12261,23 @@ function isTransmissionMaterial(material) {
   return material.materialShaderId === "forgeax::default-standard-pbr" && typeof material.paramSnapshot?.transmission === "number" && material.paramSnapshot.transmission > 0;
 }
 function matchesRecordMode(material, mode) {
+  const medium = material.surfaceModel === "single-layer-medium" || material.materialShaderId === "forgeax::single-layer-medium";
+  if (mode === "single-layer-medium-nearest-layer" || mode === "single-layer-medium-color") {
+    return medium;
+  }
   const transmission = isTransmissionMaterial(material);
   if (mode === "transmission") return transmission;
-  if (mode === "transparent") return material.transparent === true && !transmission;
-  return !transmission && material.transparent !== true;
+  if (mode === "transparent") return material.transparent === true && !transmission && !medium;
+  return !transmission && material.transparent !== true && !medium;
 }
 function matchedMaterialsForRecordMode(c, matchedMaterials, mode) {
   if (mode === void 0) return matchedMaterials;
+  const surfaceMode = mode === "single-layer-medium-nearest-layer" || mode === "single-layer-medium-color";
   const filtered = /* @__PURE__ */ new Map();
   for (const entry of c.validatedOrdered) {
     const dispatchHandles = matchedMaterials?.get(entry.renderableIndex);
-    if (matchedMaterials !== null && dispatchHandles === void 0) continue;
-    const candidateHandles = dispatchHandles ?? (mode === "transmission" ? [] : entry.source.materials.map((material) => material.materialHandle ?? 0));
+    if (!surfaceMode && matchedMaterials !== null && dispatchHandles === void 0) continue;
+    const candidateHandles = surfaceMode ? entry.source.materials.map((material) => material.materialHandle ?? 0) : dispatchHandles ?? (mode === "transmission" ? [] : entry.source.materials.map((material) => material.materialHandle ?? 0));
     const handles = /* @__PURE__ */ new Set();
     for (const handle of candidateHandles) {
       const material = entry.source.materials.find((candidate) => (candidate.materialHandle ?? 0) === handle) ?? entry.source.material;
@@ -11333,11 +12320,14 @@ function recordMainPass(c, selector, options, graphPass) {
   const passKind = options?.passKind ?? "forward";
   const recordMode = options?.recordMode;
   const transmissionBackdropView = options?.transmissionBackdropView;
-  if (recordMode === "transmission" && transmissionBackdropView == null) {
+  const surfaceRawDepthView = options?.surfaceRawDepthView;
+  const surfaceNearestLayerView = options?.surfaceNearestLayerView;
+  const surfaceNearestDepthView = options?.surfaceNearestDepthView;
+  if ((recordMode === "transmission" || recordMode === "single-layer-medium-nearest-layer" || recordMode === "single-layer-medium-color") && transmissionBackdropView == null) {
     throw new RhiError({
       code: "webgpu-runtime-error",
-      expected: "transmissionBackdropView != null for transmission record mode",
-      hint: "the typed Standard transmission pass must resolve its private backdrop view"
+      expected: "transmissionBackdropView != null for a backdrop-consuming record mode",
+      hint: "the typed Standard backdrop pass must resolve its graph-paired color view"
     });
   }
   const colorViews = options?.colorViews ?? [geometryColorView];
@@ -11349,12 +12339,9 @@ function recordMainPass(c, selector, options, graphPass) {
   const videoHighPerfAvailable = probeVideoHighPerfUpload(runtime.device);
   const clusteredLighting = c.standardLighting?.kind === "clustered";
   const clusteredBindGroupMissing = validatedOrdered.length > 0 && !standardTopologyBindGroupReady(c.standardLighting, hdrpClusterBindGroup);
+  const hdrpBuffers = clusteredLighting ? getOrCreateHdrpBuffers(runtime, frameState.installedPipelineConfig?.clusterGrid) : null;
   let hdrpSsaoBindGroup = null;
-  if (clusteredLighting && hdrpClusterBindGroup !== null && c.hdrpSsaoBlurredView !== void 0) {
-    const hdrpBuffers = getOrCreateHdrpBuffers(
-      runtime,
-      frameState.installedPipelineConfig?.clusterGrid
-    );
+  if (hdrpClusterBindGroup !== null && c.hdrpSsaoBlurredView !== void 0) {
     if (hdrpBuffers !== null) {
       hdrpSsaoBindGroup = createHdrpUnifiedBindGroup(
         runtime,
@@ -11365,6 +12352,58 @@ function recordMainPass(c, selector, options, graphPass) {
     }
   }
   const meshGroup2 = clusteredLighting ? hdrpSsaoBindGroup ?? hdrpClusterBindGroup : meshBindGroup;
+  if (gpuDrivenStandardPbrFrameResources !== void 0) {
+    gpuDrivenStandardPbrFrameResources.clusterBindGroup = clusteredLighting && meshGroup2 !== null ? meshGroup2 : void 0;
+    if (hdrpBuffers === null) {
+      gpuDrivenStandardPbrFrameResources.clusterBindGroupForMesh = void 0;
+      gpuDrivenStandardPbrFrameResources.clusterBindGroupForSkin = void 0;
+    } else {
+      const projectedGroups = /* @__PURE__ */ new Map();
+      gpuDrivenStandardPbrFrameResources.clusterBindGroupForMesh = (meshBuffer, bindingBytes) => {
+        const cached = projectedGroups.get(meshBuffer);
+        if (cached !== void 0) return cached;
+        const created = createHdrpUnifiedBindGroup(
+          runtime,
+          hdrpBuffers,
+          meshBuffer,
+          c.hdrpSsaoBlurredView === void 0 ? { enabled: false } : { enabled: true, ssaoBlurredView: c.hdrpSsaoBlurredView },
+          bindingBytes
+        );
+        if (created !== null) projectedGroups.set(meshBuffer, created);
+        return created ?? void 0;
+      };
+      const projectedSkinGroups = /* @__PURE__ */ new Map();
+      gpuDrivenStandardPbrFrameResources.clusterBindGroupForSkin = (meshBuffer, meshBindingBytes, paletteBuffer, paletteBindingWindowBytes) => {
+        let meshGroups = projectedSkinGroups.get(meshBuffer);
+        if (meshGroups === void 0) {
+          meshGroups = /* @__PURE__ */ new Map();
+          projectedSkinGroups.set(meshBuffer, meshGroups);
+        }
+        let paletteGroups = meshGroups.get(paletteBuffer);
+        if (paletteGroups === void 0) {
+          paletteGroups = /* @__PURE__ */ new Map();
+          meshGroups.set(paletteBuffer, paletteGroups);
+        }
+        const bindingKey = `${meshBindingBytes}:${paletteBindingWindowBytes}`;
+        const cached = paletteGroups.get(bindingKey);
+        if (cached !== void 0) return cached;
+        const skinLayout = pipelineState.hdrpSkinMeshBindGroupLayout;
+        if (skinLayout === null) return void 0;
+        const created = createHdrpSkinUnifiedBindGroup(
+          runtime,
+          hdrpBuffers,
+          skinLayout,
+          meshBuffer,
+          paletteBuffer,
+          paletteBindingWindowBytes,
+          c.hdrpSsaoBlurredView === void 0 ? { enabled: false } : { enabled: true, ssaoBlurredView: c.hdrpSsaoBlurredView },
+          meshBindingBytes
+        );
+        if (created !== null) paletteGroups.set(bindingKey, created);
+        return created ?? void 0;
+      };
+    }
+  }
   let geometryPassEnded = false;
   const mainColorLoadOp = skyboxActive ? "load" : "clear";
   const mainPassResolves = passKind === "forward" && msaaActive && geometryColorResolveView !== null && !splitLdrSprite;
@@ -11522,7 +12561,10 @@ function recordMainPass(c, selector, options, graphPass) {
       ...gpuDrivenStandardPbrFrameResources?.sceneMaterialBuffer === void 0 && gpuDrivenSceneMaterialBuffer === void 0 ? {} : {
         sceneMaterialBuffer: gpuDrivenStandardPbrFrameResources?.sceneMaterialBuffer ?? gpuDrivenSceneMaterialBuffer
       },
-      ...transmissionBackdropView === void 0 ? {} : { transmissionBackdropView }
+      ...transmissionBackdropView === void 0 ? {} : { transmissionBackdropView },
+      ...surfaceRawDepthView === void 0 ? {} : { surfaceRawDepthView },
+      ...surfaceNearestLayerView === void 0 ? {} : { surfaceNearestLayerView },
+      ...surfaceNearestDepthView === void 0 ? {} : { surfaceNearestDepthView }
     };
     const buildPerSubmeshMaterialBg2 = (submeshMaterial, entityKey, materialWorld = world, materialShaderId = submeshMaterial.materialShaderId) => buildPerSubmeshMaterialBg(
       perSubmeshMaterialBgDeps,
@@ -11535,6 +12577,7 @@ function recordMainPass(c, selector, options, graphPass) {
     for (let materialSlot = 0; materialSlot < materialSlotCount; materialSlot += 1) {
       const material = materialSlots[materialSlot];
       if (material === void 0 || (material.videoTextureFields?.size ?? 0) > 0) continue;
+      if (recordMode !== void 0 && !matchesRecordMode(material, recordMode)) continue;
       const owner = materialSlotOwners[materialSlot];
       if (owner === void 0) continue;
       preparedMaterialBindGroups[materialSlot] = buildPerSubmeshMaterialBg2(
@@ -11605,7 +12648,10 @@ function recordMainPass(c, selector, options, graphPass) {
         passKind,
         selectedDispatch,
         colorFormats,
-        options?.coverageOnly ?? false
+        options?.coverageOnly ?? false,
+        options?.fragmentEntryPoint,
+        recordMode === "single-layer-medium-nearest-layer" ? "nearest-layer" : recordMode === "single-layer-medium-color" ? "color" : void 0,
+        options?.transparentDepthWrite ?? false
       );
     };
     if (c.profilePhase === void 0) {
@@ -11625,7 +12671,7 @@ function recordMainPass(c, selector, options, graphPass) {
           hint: "publish the current frame view/light/shadow bind group before GPU raster"
         });
       }
-      if (gpuDrivenStandardPbrFrameResources === void 0) {
+      if (gpuDrivenStandardPbrFrameResources === void 0 || gpuDrivenStandardPbrFrameResources.materialBindGroups.length === 0) {
         throw new RhiError({
           code: "rhi-not-available",
           expected: "complete main-pass Standard PBR material bind-group receipt",
@@ -11636,7 +12682,9 @@ function recordMainPass(c, selector, options, graphPass) {
         viewBindGroup,
         pass,
         options.gpuDriven.resources,
-        gpuDrivenStandardPbrFrameResources
+        gpuDrivenStandardPbrFrameResources,
+        options.gpuDrivenFilter,
+        options?.fragmentEntryPoint
       );
     }
     if (passKind === "forward" && recordMode === void 0) {
@@ -11660,6 +12708,27 @@ function recordMainPass(c, selector, options, graphPass) {
 function encodeMainPass(c, pass, selector, options) {
   return recordMainPass(c, selector, options, pass);
 }
+
+// src/assembly/webgpu-ready-contract.ts
+var VIEW_UBO_BYTES = VIEW_UNIFORM_BUFFER_SIZE;
+var MIPMAP_PREWARM_FORMATS = [
+  "rgba8unorm-srgb",
+  "rgba8unorm",
+  "rgba16float"
+];
+var BLOOM_UNIFORM_PARAMS_STRIDE_BYTES = 256;
+var BLOOM_DOWNSAMPLE_PARAMS_BYTES = 5 * BLOOM_UNIFORM_PARAMS_STRIDE_BYTES;
+var BLOOM_UPSAMPLE_PARAMS_BYTES = 4 * BLOOM_UNIFORM_PARAMS_STRIDE_BYTES;
+var BLOOM_COMPOSITE_PARAMS_BYTES = 16;
+var HDR_COLOR_ATTACHMENT_FORMAT = "rgba16float";
+var DEPTH_TEXTURE_FORMAT = "depth24plus-stencil8";
+
+// src/bloom-admission.ts
+function standardBloomAdmitted(camera) {
+  return camera !== void 0 && camera.bloom === "on" && camera.bloomIntensity > 0 && camera.tonemap !== "none";
+}
+
+// src/record/skybox-post-pass.ts
 function recordSkyboxPass(c, graphPass) {
   if (!c.skyboxActive) return;
   const skyboxSnapshot = c.skybox;
@@ -11767,179 +12836,138 @@ function throwBloomRecordFailure(expected) {
     hint: "repair the Bloom candidate resources before retrying the frame"
   });
 }
-function recordBloomBrightPass(_c, resolve, graphPass) {
-  const { runtime, encoder, camera, tonemapActive, frameState, bindGroupCounts } = _c;
-  const pp = _c.bloomResources;
-  if (camera.bloom !== "on" || !tonemapActive) return;
-  if (pp === null || pp === void 0) {
-    throwBloomRecordFailure("Bloom persistent resources are ready before bright-pass encoding");
-  }
-  if (pp.bloomBrightPipeline === null || pp.bloomBrightBindGroupLayout === null || pp.bloomSampler === null || pp.bloomBrightParamsBuffer === null) {
-    throwBloomRecordFailure("Bloom bright pass has pipeline, layout, sampler, and params buffer");
-  }
-  const bloomBrightView = resolve?.resolve("bloomBright");
-  const hdrColorView = resolve?.resolve("hdrColor");
-  if (!bloomBrightView || !hdrColorView) {
-    throwBloomRecordFailure("Bloom bright pass resolves its source and target views");
-  }
-  const bglBright = pp.bloomBrightBindGroupLayout;
-  const bloomSampler = pp.bloomSampler;
-  const paramsBuffer = pp.bloomBrightParamsBuffer;
-  const brightParams = new Float32Array(4);
-  brightParams[0] = camera.bloomThreshold;
-  brightParams[1] = 0;
-  brightParams[2] = 0;
-  brightParams[3] = 0;
-  const paramsWrite = runtime.device.queue.writeBuffer(paramsBuffer, 0, brightParams);
-  if (!paramsWrite.ok) throw paramsWrite.error;
-  stageBloomUpload(_c);
-  const bindGroup = getOrCreateFromChain(
-    frameState.postProcessBgCache,
-    [hdrColorView],
-    "bloom-bright",
-    () => {
-      const bgRes = runtime.device.createBindGroup({
-        label: "bloom-bright-bg",
-        layout: bglBright,
-        entries: [
-          { binding: 0, resource: { kind: "textureView", value: hdrColorView } },
-          { binding: 1, resource: { kind: "sampler", value: bloomSampler } },
-          { binding: 2, resource: { kind: "buffer", value: { buffer: paramsBuffer } } }
-        ]
-      });
-      if (!bgRes.ok) throw bgRes.error;
-      return bgRes.value;
-    },
-    bindGroupCounts
-  );
-  const pass = graphPass ?? encoder.beginRenderPass(
-    buildBeginRenderPassDescriptor(
-      { depthFormat: void 0},
-      { colorViews: [bloomBrightView] },
-      "bloom-bright"
-    )
-  );
-  pass.setPipeline(pp.bloomBrightPipeline);
-  pass.setBindGroup(0, bindGroup);
-  stageBloomBindGroup(_c);
-  pass.draw(3, 1, 0, 0);
-  stageBloomEncode(_c);
-  if (graphPass === void 0) pass.end();
+function bloomRecordActive(c) {
+  return standardBloomAdmitted(c.camera) && c.tonemapActive;
 }
-function recordBloomBlurHPass(_c, resolve, graphPass) {
-  const { runtime, encoder, camera, targetW, tonemapActive, frameState, bindGroupCounts } = _c;
+function recordBloomDownsamplePass(_c, resolve, graphPass, level = 0, destinationSize) {
+  const { runtime, encoder, camera, frameState, bindGroupCounts } = _c;
   const pp = _c.bloomResources;
-  if (camera.bloom !== "on" || !tonemapActive) return;
-  if (pp === null || pp === void 0) {
-    throwBloomRecordFailure("Bloom persistent resources are ready before blur-H encoding");
-  }
-  if (pp.bloomBlurHPipeline === null || pp.bloomBlurBindGroupLayout === null || pp.bloomSampler === null || pp.bloomBlurHParamsBuffer === null) {
-    throwBloomRecordFailure("Bloom blur-H pass has pipeline, layout, sampler, and params buffer");
+  if (!bloomRecordActive(_c)) return;
+  if (pp === void 0 || pp === null || pp.bloomDownsamplePipeline === null || pp.bloomDownsampleBindGroupLayout === null || pp.bloomSampler === null || pp.bloomDownsampleParamsBuffer === null) {
+    throwBloomRecordFailure("Bloom downsample resources are ready before encoding");
   }
-  const bloomBlurHView = resolve?.resolve("bloomBlurH");
-  const bloomBrightView = resolve?.resolve("bloomBright");
-  if (!bloomBlurHView || !bloomBrightView) {
-    throwBloomRecordFailure("Bloom blur-H pass resolves its source and target views");
-  }
-  const bglBlur = pp.bloomBlurBindGroupLayout;
+  const downsamplePipeline = pp.bloomDownsamplePipeline;
+  const downsampleLayout = pp.bloomDownsampleBindGroupLayout;
   const bloomSampler = pp.bloomSampler;
-  const paramsBuffer = pp.bloomBlurHParamsBuffer;
-  const bw = Math.floor(targetW / 2);
-  const blurParams = new Float32Array(4);
-  blurParams[0] = bw > 0 ? 1 / bw : 1;
-  blurParams[1] = 0;
-  blurParams[2] = camera.bloomBlurRadius;
-  blurParams[3] = 0;
-  const paramsWrite = runtime.device.queue.writeBuffer(paramsBuffer, 0, blurParams);
-  if (!paramsWrite.ok) throw paramsWrite.error;
+  const downsampleParamsBuffer = pp.bloomDownsampleParamsBuffer;
+  const sourceName = level === 0 ? "hdrColor" : `bloomDownsample${level - 1}`;
+  const targetName = `bloomDownsample${level}`;
+  const sourceView = resolve?.resolve(sourceName);
+  const targetView = resolve?.resolve(targetName);
+  if (sourceView === void 0 || targetView === void 0) {
+    throwBloomRecordFailure(`Bloom downsample level ${level} resolves source and target views`);
+  }
+  const size = destinationSize ?? {
+    width: Math.max(1, Math.ceil(_c.targetW / 2)),
+    height: Math.max(1, Math.ceil(_c.targetH / 2))
+  };
+  const params = new Float32Array([
+    camera.bloomThreshold,
+    camera.bloomSoftKnee,
+    size.width,
+    size.height,
+    level,
+    0,
+    0,
+    0
+  ]);
+  const offset = level * BLOOM_UNIFORM_PARAMS_STRIDE_BYTES;
+  const upload = runtime.device.queue.writeBuffer(pp.bloomDownsampleParamsBuffer, offset, params);
+  if (!upload.ok) throw upload.error;
   stageBloomUpload(_c);
   const bindGroup = getOrCreateFromChain(
     frameState.postProcessBgCache,
-    [bloomBrightView],
-    "bloom-blur-h",
+    [sourceView, downsampleParamsBuffer],
+    `bloom-downsample-${level}`,
     () => {
-      const bgRes = runtime.device.createBindGroup({
-        label: "bloom-blur-h-bg",
-        layout: bglBlur,
+      const created = runtime.device.createBindGroup({
+        label: `bloom-downsample-${level}-bg`,
+        layout: downsampleLayout,
         entries: [
-          { binding: 0, resource: { kind: "textureView", value: bloomBrightView } },
+          { binding: 0, resource: { kind: "textureView", value: sourceView } },
           { binding: 1, resource: { kind: "sampler", value: bloomSampler } },
-          { binding: 2, resource: { kind: "buffer", value: { buffer: paramsBuffer } } }
+          {
+            binding: 2,
+            resource: {
+              kind: "buffer",
+              value: { buffer: downsampleParamsBuffer, offset, size: 32 }
+            }
+          }
         ]
       });
-      if (!bgRes.ok) throw bgRes.error;
-      return bgRes.value;
+      if (!created.ok) throw created.error;
+      return created.value;
     },
     bindGroupCounts
   );
   const pass = graphPass ?? encoder.beginRenderPass(
     buildBeginRenderPassDescriptor(
       { depthFormat: void 0},
-      { colorViews: [bloomBlurHView] },
-      "bloom-blur"
+      { colorViews: [targetView] },
+      "bloom-downsample"
     )
   );
-  pass.setPipeline(pp.bloomBlurHPipeline);
+  pass.setPipeline(downsamplePipeline);
   pass.setBindGroup(0, bindGroup);
   stageBloomBindGroup(_c);
   pass.draw(3, 1, 0, 0);
   stageBloomEncode(_c);
   if (graphPass === void 0) pass.end();
 }
-function recordBloomBlurVPass(_c, resolve, graphPass) {
-  const { runtime, encoder, camera, targetH, tonemapActive, frameState, bindGroupCounts } = _c;
+function recordBloomUpsamplePass(_c, resolve, graphPass, level = 0) {
+  const { runtime, encoder, frameState, bindGroupCounts } = _c;
   const pp = _c.bloomResources;
-  if (camera.bloom !== "on" || !tonemapActive) return;
-  if (pp === null || pp === void 0) {
-    throwBloomRecordFailure("Bloom persistent resources are ready before blur-V encoding");
-  }
-  if (pp.bloomBlurVPipeline === null || pp.bloomBlurBindGroupLayout === null || pp.bloomSampler === null || pp.bloomBlurVParamsBuffer === null) {
-    throwBloomRecordFailure("Bloom blur-V pass has pipeline, layout, sampler, and params buffer");
+  if (!bloomRecordActive(_c)) return;
+  if (pp === void 0 || pp === null || pp.bloomUpsamplePipeline === null || pp.bloomUpsampleBindGroupLayout === null || pp.bloomSampler === null || pp.bloomUpsampleParamsBuffer === null) {
+    throwBloomRecordFailure("Bloom upsample resources are ready before encoding");
   }
-  const bloomBlurVView = resolve?.resolve("bloomBlurV");
-  const bloomBlurHView = resolve?.resolve("bloomBlurH");
-  if (!bloomBlurVView || !bloomBlurHView) {
-    throwBloomRecordFailure("Bloom blur-V pass resolves its source and target views");
-  }
-  const bglBlur = pp.bloomBlurBindGroupLayout;
+  const upsamplePipeline = pp.bloomUpsamplePipeline;
+  const upsampleLayout = pp.bloomUpsampleBindGroupLayout;
   const bloomSampler = pp.bloomSampler;
-  const paramsBuffer = pp.bloomBlurVParamsBuffer;
-  const bh = Math.floor(targetH / 2);
-  const blurParams = new Float32Array(4);
-  blurParams[0] = 0;
-  blurParams[1] = bh > 0 ? 1 / bh : 1;
-  blurParams[2] = camera.bloomBlurRadius;
-  blurParams[3] = 0;
-  const paramsWrite = runtime.device.queue.writeBuffer(paramsBuffer, 0, blurParams);
-  if (!paramsWrite.ok) throw paramsWrite.error;
+  const upsampleParamsBuffer = pp.bloomUpsampleParamsBuffer;
+  const currentView = resolve?.resolve(`bloomDownsample${level}`);
+  const nextUpsampleView = resolve?.resolve(`bloomUpsample${level + 1}`);
+  const coarseView = nextUpsampleView ?? resolve?.resolve(`bloomDownsample${level + 1}`);
+  const targetView = resolve?.resolve(`bloomUpsample${level}`);
+  if (currentView === void 0 || coarseView === void 0 || targetView === void 0) {
+    throwBloomRecordFailure(`Bloom upsample level ${level} resolves adjacent pyramid views`);
+  }
+  const params = new Float32Array([_c.camera.bloomScatter, 0, 0, 0]);
+  const offset = level * BLOOM_UNIFORM_PARAMS_STRIDE_BYTES;
+  const upload = runtime.device.queue.writeBuffer(pp.bloomUpsampleParamsBuffer, offset, params);
+  if (!upload.ok) throw upload.error;
   stageBloomUpload(_c);
   const bindGroup = getOrCreateFromChain(
     frameState.postProcessBgCache,
-    [bloomBlurHView],
-    "bloom-blur-v",
+    [currentView, coarseView, upsampleParamsBuffer],
+    `bloom-upsample-${level}`,
     () => {
-      const bgRes = runtime.device.createBindGroup({
-        label: "bloom-blur-v-bg",
-        layout: bglBlur,
+      const created = runtime.device.createBindGroup({
+        label: `bloom-upsample-${level}-bg`,
+        layout: upsampleLayout,
         entries: [
-          { binding: 0, resource: { kind: "textureView", value: bloomBlurHView } },
-          { binding: 1, resource: { kind: "sampler", value: bloomSampler } },
-          { binding: 2, resource: { kind: "buffer", value: { buffer: paramsBuffer } } }
+          { binding: 0, resource: { kind: "textureView", value: currentView } },
+          { binding: 1, resource: { kind: "textureView", value: coarseView } },
+          { binding: 2, resource: { kind: "sampler", value: bloomSampler } },
+          {
+            binding: 3,
+            resource: { kind: "buffer", value: { buffer: upsampleParamsBuffer, offset, size: 16 } }
+          }
         ]
       });
-      if (!bgRes.ok) throw bgRes.error;
-      return bgRes.value;
+      if (!created.ok) throw created.error;
+      return created.value;
     },
     bindGroupCounts
   );
   const pass = graphPass ?? encoder.beginRenderPass(
     buildBeginRenderPassDescriptor(
       { depthFormat: void 0},
-      { colorViews: [bloomBlurVView] },
-      "bloom-blur"
+      { colorViews: [targetView] },
+      "bloom-upsample"
     )
   );
-  pass.setPipeline(pp.bloomBlurVPipeline);
+  pass.setPipeline(upsamplePipeline);
   pass.setBindGroup(0, bindGroup);
   stageBloomBindGroup(_c);
   pass.draw(3, 1, 0, 0);
@@ -11947,9 +12975,9 @@ function recordBloomBlurVPass(_c, resolve, graphPass) {
   if (graphPass === void 0) pass.end();
 }
 function recordBloomCompositePass(_c, resolve, graphPass) {
-  const { runtime, encoder, camera, tonemapActive, frameState, bindGroupCounts } = _c;
+  const { runtime, encoder, camera, frameState, bindGroupCounts } = _c;
   const pp = _c.bloomResources;
-  if (camera.bloom !== "on" || !tonemapActive) return;
+  if (!bloomRecordActive(_c)) return;
   if (pp === null || pp === void 0) {
     throwBloomRecordFailure("Bloom persistent resources are ready before composite encoding");
   }
@@ -11959,10 +12987,11 @@ function recordBloomCompositePass(_c, resolve, graphPass) {
     );
   }
   const hdrColorView = resolve?.resolve("hdrColor");
-  const bloomBlurVView = resolve?.resolve("bloomBlurV");
+  const bloomView = resolve?.resolve("bloomUpsample0");
+  const finestBloomView = bloomView ?? resolve?.resolve("bloomDownsample0");
   const hdrCompositedView = resolve?.resolve("hdrComposited");
-  if (!hdrColorView || !bloomBlurVView || !hdrCompositedView) {
-    throwBloomRecordFailure("Bloom composite pass resolves its source and target views");
+  if (!hdrColorView || !finestBloomView || !hdrCompositedView) {
+    throwBloomRecordFailure("Bloom composite pass resolves scene, finest Bloom, and target views");
   }
   const bglComposite = pp.bloomCompositeBindGroupLayout;
   const bloomSampler = pp.bloomSampler;
@@ -11977,7 +13006,7 @@ function recordBloomCompositePass(_c, resolve, graphPass) {
   stageBloomUpload(_c);
   const bindGroup = getOrCreateFromChain(
     frameState.postProcessBgCache,
-    [hdrColorView, bloomBlurVView],
+    [hdrColorView, finestBloomView],
     "bloom-composite",
     () => {
       const bgRes = runtime.device.createBindGroup({
@@ -11985,7 +13014,7 @@ function recordBloomCompositePass(_c, resolve, graphPass) {
         layout: bglComposite,
         entries: [
           { binding: 0, resource: { kind: "textureView", value: hdrColorView } },
-          { binding: 1, resource: { kind: "textureView", value: bloomBlurVView } },
+          { binding: 1, resource: { kind: "textureView", value: finestBloomView } },
           { binding: 2, resource: { kind: "sampler", value: bloomSampler } },
           {
             binding: 3,
@@ -12013,7 +13042,7 @@ function recordBloomCompositePass(_c, resolve, graphPass) {
   stageBloomEncode(_c);
   if (graphPass === void 0) pass.end();
 }
-function recordFxaaPass(c, resolve, graphPass, paramsOverride) {
+function recordFxaaPass(c, resolve, graphPass, paramsOverride, graphOutputFormat) {
   const { runtime, pipelineState, encoder, camera, currentTexture } = c;
   const fxaaActive = camera.antialias === "fxaa";
   if (fxaaActive && pipelineState.perPassResources.fxaaPipeline !== null && pipelineState.perPassResources.fxaaBindGroupLayout !== null && pipelineState.perPassResources.fxaaSampler !== null && runtime.getPostProcessParamsBuffer !== void 0) {
@@ -12060,7 +13089,7 @@ function recordFxaaPass(c, resolve, graphPass, paramsOverride) {
       },
       c.bindGroupCounts
     );
-    const fxaaColorFormat = runtime.device.caps.storageBuffer ? pipelineState.format : pipelineState.colorAttachmentFormat;
+    const fxaaColorFormat = graphPass !== void 0 && graphOutputFormat !== void 0 ? graphOutputFormat : runtime.device.caps.storageBuffer ? pipelineState.format : pipelineState.colorAttachmentFormat;
     let fxaaPass = graphPass;
     if (fxaaPass === void 0) {
       const fxaaOutputView = runtime.device.createTextureView(currentTexture, {
@@ -12079,7 +13108,19 @@ function recordFxaaPass(c, resolve, graphPass, paramsOverride) {
         )
       );
     }
-    fxaaPass.setPipeline(pipelineState.perPassResources.fxaaPipeline);
+    let fxaaPipeline = pipelineState.perPassResources.fxaaPipeline;
+    if (graphPass !== void 0 && graphOutputFormat !== void 0) {
+      const entry = runtime.lookupPostProcess?.(FXAA_POST_PROCESS_ID);
+      const rebuilt = entry === void 0 || runtime.getPostProcessPipeline === void 0 ? null : runtime.getPostProcessPipeline(
+        FXAA_POST_PROCESS_ID,
+        fxaaBglLayout,
+        [graphOutputFormat],
+        entry
+      );
+      if (rebuilt !== null) fxaaPipeline = rebuilt;
+    }
+    if (fxaaPipeline === null) return;
+    fxaaPass.setPipeline(fxaaPipeline);
     fxaaPass.setBindGroup(0, fxaaBg);
     fxaaPass.draw(3, 1, 0, 0);
     if (graphPass === void 0) fxaaPass.end();
@@ -12110,8 +13151,8 @@ function postProcessSourceDigest(source) {
 function postProcessShaderPipelineLabel(identity, source) {
   return `post-process-${identity}-pso-${postProcessSourceDigest(source)}`;
 }
-function postProcessShaderModuleLabel(identity, source) {
-  return `${postProcessShaderPipelineLabel(identity, source)}-module`;
+function postProcessShaderModuleLabel(source) {
+  return `post-process-module-${postProcessSourceDigest(source)}`;
 }
 function postProcessShaderEntrySignature(entry) {
   return JSON.stringify({
@@ -12121,7 +13162,9 @@ function postProcessShaderEntrySignature(entry) {
       byteSize: entry.params.byteSize,
       defaultValue: Array.from(entry.params.defaultValue)
     },
-    reads: entry.reads
+    reads: entry.reads,
+    usesView: entry.usesView,
+    storageBindings: entry.storageBindings
   });
 }
 function isTemporalFullscreenBinding(values) {
@@ -12155,7 +13198,10 @@ var DEPTH_MIN_PARAMS_BYTE_SIZE = 16;
 function buildFullscreenPostProcessPass(ctx, entry, depthMultisampled = false) {
   const { device } = ctx;
   const hasDepth = entryHasDepthRead(entry);
-  const bglKind = hasDepth ? depthMultisampled ? "fullscreen-post-with-scene-depth-msaa" : "fullscreen-post-with-scene-depth" : entry.params !== void 0 ? "fullscreen-post-with-params" : "fullscreen-post";
+  const hasMultisampledColor = (entry.reads ?? []).some(
+    (read) => typeof read !== "string" && read.sampleType === "multisampled-float"
+  );
+  const bglKind = hasDepth ? depthMultisampled ? hasMultisampledColor ? "fullscreen-post-with-paired-msaa" : "fullscreen-post-with-scene-depth-msaa" : "fullscreen-post-with-scene-depth" : entry.params !== void 0 ? "fullscreen-post-with-params" : "fullscreen-post";
   const descriptor = buildBindGroupLayoutDescriptor(FULLSCREEN_DEFAULT_SPEC, { kind: bglKind });
   const colorReads = (entry.reads ?? []).filter(
     (read) => typeof read === "string" || read.sampleType !== "depth"
@@ -12169,6 +13215,14 @@ function buildFullscreenPostProcessPass(ctx, entry, depthMultisampled = false) {
       texture: { sampleType: "float", viewDimension: "2d" }
     });
   }
+  const firstStorageBinding = firstExtraBinding + extraColorCount;
+  for (const [index, binding] of (entry.storageBindings ?? []).entries()) {
+    descriptor.entries.push({
+      binding: binding ?? firstStorageBinding + index,
+      visibility: GPU_SHADER_STAGE_FRAGMENT,
+      buffer: { type: "read-only-storage" }
+    });
+  }
   const bglRes = device.createBindGroupLayout(descriptor);
   if (!bglRes.ok) {
     ctx.errorRegistry.fire(bglRes.error);
@@ -12183,6 +13237,9 @@ function buildFullscreenPostProcessPass(ctx, entry, depthMultisampled = false) {
     extraColorBindings: Object.freeze(
       Array.from({ length: extraColorCount }, (_, index) => firstExtraBinding + index)
     ),
+    extraStorageBindings: Object.freeze(
+      (entry.storageBindings ?? []).map((binding, index) => binding ?? firstStorageBinding + index)
+    ),
     createHandle: (name, pipeline, paramsBuffer) => ({
       name,
       paramsBuffer,
@@ -12193,7 +13250,7 @@ function buildFullscreenPostProcessPass(ctx, entry, depthMultisampled = false) {
     })
   };
 }
-function createFullscreenBindGroup(device, bgl, inputView, sampler, paramsBuffer, depthTexView, depthSampler, additionalViews = []) {
+function createFullscreenBindGroup(device, bgl, inputView, sampler, paramsBuffer, depthTexView, depthSampler, additionalViews = [], additionalBuffers = []) {
   const entries = [
     { binding: 0, resource: { kind: "textureView", value: inputView } }
   ];
@@ -12213,6 +13270,12 @@ function createFullscreenBindGroup(device, bgl, inputView, sampler, paramsBuffer
       resource: { kind: "textureView", value: additional.view }
     });
   }
+  for (const additional of additionalBuffers) {
+    entries.push({
+      binding: additional.binding,
+      resource: { kind: "buffer", value: { buffer: additional.buffer } }
+    });
+  }
   const res = device.createBindGroup({
     label: "fullscreen-post-process-bg",
     layout: bgl,
@@ -12504,7 +13567,13 @@ function dispatchFullscreenPass(ctx, name, shader, color, reads, resolveCtx, com
         detail: { readsKey: reads[0] ?? "ldrColor", passName: name }
       });
     }
-    recordFxaaPass(requireRenderGraphRecordContext(ctx), resolveCtx, graphPass, paramsOverride);
+    recordFxaaPass(
+      requireRenderGraphRecordContext(ctx),
+      resolveCtx,
+      graphPass,
+      paramsOverride,
+      graphOutputFormat
+    );
     return;
   }
   const lookup = ctx.runtime.lookupPostProcess;
@@ -12697,6 +13766,11 @@ var TEMPORAL_HISTORY_FORMATS = Object.freeze({
   temporal: "rgba16float",
   stability: "r8unorm"
 });
+var CLOUD_HISTORY_FORMATS = Object.freeze({
+  radiance: "rgba16float",
+  transmittance: "rgba16float",
+  depth: "rgba16float"
+});
 function createSurface(device, childScope, label, width, height, format = TEMPORAL_HISTORY_FORMATS.color) {
   const texture = device.createTexture({
     label,
@@ -12720,8 +13794,15 @@ function createSurface(device, childScope, label, width, height, format = TEMPOR
   if (!view.ok) throw view.error;
   return { texture: texture.value, view: view.value };
 }
-function createState(device, scope, width, height) {
+function cloudHistoryExtent(width, height) {
+  return {
+    width: Math.max(1, Math.ceil(width / 2)),
+    height: Math.max(1, Math.ceil(height / 2))
+  };
+}
+function createState(device, scope, width, height, cloudHistoryEnabled) {
   const childScope = scope.createChild(`${scope.owner}:temporal`);
+  const cloudExtent = cloudHistoryExtent(width, height);
   try {
     return {
       device,
@@ -12772,6 +13853,59 @@ function createState(device, scope, width, height) {
           TEMPORAL_HISTORY_FORMATS.stability
         )
       ],
+      cloudHistoryEnabled,
+      cloudRadiance: cloudHistoryEnabled ? [
+        createSurface(
+          device,
+          childScope,
+          "cloud-history-radiance-a",
+          cloudExtent.width,
+          cloudExtent.height
+        ),
+        createSurface(
+          device,
+          childScope,
+          "cloud-history-radiance-b",
+          cloudExtent.width,
+          cloudExtent.height
+        )
+      ] : void 0,
+      cloudTransmittance: cloudHistoryEnabled ? [
+        createSurface(
+          device,
+          childScope,
+          "cloud-history-transmittance-a",
+          cloudExtent.width,
+          cloudExtent.height,
+          CLOUD_HISTORY_FORMATS.transmittance
+        ),
+        createSurface(
+          device,
+          childScope,
+          "cloud-history-transmittance-b",
+          cloudExtent.width,
+          cloudExtent.height,
+          CLOUD_HISTORY_FORMATS.transmittance
+        )
+      ] : void 0,
+      cloudDepth: cloudHistoryEnabled ? [
+        createSurface(
+          device,
+          childScope,
+          "cloud-history-depth-a",
+          cloudExtent.width,
+          cloudExtent.height,
+          CLOUD_HISTORY_FORMATS.depth
+        ),
+        createSurface(
+          device,
+          childScope,
+          "cloud-history-depth-b",
+          cloudExtent.width,
+          cloudExtent.height,
+          CLOUD_HISTORY_FORMATS.depth
+        )
+      ] : void 0,
       bindGroupLayout: void 0,
       sampler: void 0,
       temporalSampler: void 0,
@@ -12806,16 +13940,17 @@ function getTemporalParamsBuffer(state) {
   state.paramsBuffer = created.value;
   return created.value;
 }
-function getTemporalGpuState(frameState, device, scope, width, height) {
+function getTemporalGpuState(frameState, device, scope, width, height, cloudHistoryRequested = false) {
+  const wantsCloudHistory = cloudHistoryRequested || frameState.pendingCloudHistoryActive === true || frameState.cloudHistoryActive === true;
+  const matches = (state) => state !== void 0 && state.scope === scope && state.width === width && state.height === height && // Cloud history is a demand-shaped part of the temporal allocation. Keep
+  // the two shapes distinct so turning CloudLayer off retires its six HDR
+  // surfaces instead of retaining them on an otherwise TAA-only frame.
+  state.cloudHistoryEnabled === wantsCloudHistory;
   const staged = frameState.temporalGpuState;
-  if (staged !== void 0 && staged.scope === scope && staged.width === width && staged.height === height) {
-    return staged;
-  }
+  if (matches(staged)) return staged;
   const existing = frameState.activeTemporalGpuState;
-  if (existing !== void 0 && existing.scope === scope && existing.width === width && existing.height === height) {
-    return existing;
-  }
-  const next = createState(device, scope, width, height);
+  if (matches(existing)) return existing;
+  const next = createState(device, scope, width, height, wantsCloudHistory);
   frameState.temporalGpuState = next;
   return next;
 }
@@ -13099,7 +14234,11 @@ function addTypedScenePass(graph, options) {
       resource: target.view,
       usage: "sampled-read"
     })),
+    ...options.cloudShadow === void 0 ? [] : [{ resource: options.cloudShadow.view, usage: "sampled-read" }],
     ...options.transmissionBackdrop === void 0 ? [] : [{ resource: options.transmissionBackdrop, usage: "sampled-read" }],
+    ...options.surfacePair?.rawDepth.status === "available" ? [{ resource: options.surfacePair.rawDepth.view, usage: "sampled-read" }] : [],
+    ...options.recordMode === "single-layer-medium-color" && options.surfaceNearestLayer !== void 0 ? [{ resource: options.surfaceNearestLayer, usage: "sampled-read" }] : [],
+    ...options.recordMode === "single-layer-medium-color" && options.surfaceNearestDepth !== void 0 ? [{ resource: options.surfaceNearestDepth, usage: "sampled-read" }] : [],
     ...options.environment === void 0 ? [] : [options.environment.irradiance, options.environment.prefilter].map((resource) => ({
       resource,
       usage: "sampled-read"
@@ -13141,8 +14280,12 @@ function addTypedScenePass(graph, options) {
       const internal = frame;
       const directionalShadow = options.directionalShadow === void 0 ? void 0 : resolvedView(resources, options.directionalShadow.view);
       const spotShadow = options.spotShadow === void 0 ? void 0 : resolvedView(resources, options.spotShadow.view);
+      const cloudShadow = options.cloudShadow === void 0 ? void 0 : resolvedView(resources, options.cloudShadow.view);
       const ssao = options.ssao === void 0 ? void 0 : resolvedView(resources, options.ssao.view);
       const transmissionBackdrop = options.transmissionBackdrop === void 0 ? null : resolvedView(resources, options.transmissionBackdrop);
+      const surfaceRawDepth = options.surfacePair?.rawDepth.status === "available" ? resolvedView(resources, options.surfacePair.rawDepth.view) : null;
+      const surfaceNearestLayer = options.surfaceNearestLayer === void 0 ? null : resolvedView(resources, options.surfaceNearestLayer);
+      const surfaceNearestDepth = options.surfaceNearestDepth === void 0 ? null : resolvedView(resources, options.surfaceNearestDepth);
       internal.frameState.currentDirectionalShadowView = directionalShadow ?? null;
       internal.frameState.currentSpotShadowView = spotShadow ?? null;
       const groups = buildPerFrameBindGroups(
@@ -13154,6 +14297,7 @@ function addTypedScenePass(graph, options) {
         {
           directionalShadow,
           spotShadow,
+          cloudShadow,
           projector: internal.spotLightProjector?.view ?? internal.volumetricFog?.projectorView,
           projectorSampler: internal.spotLightProjector?.sampler ?? internal.volumetricFog?.projectorSampler
         },
@@ -13189,11 +14333,17 @@ function addTypedScenePass(graph, options) {
         passKind: options.passKind ?? "forward",
         ...options.clearColor === void 0 ? {} : { clearColor: options.clearColor },
         ...options.recordMode === void 0 ? {} : { recordMode: options.recordMode },
+        ...options.transparentDepthWrite === void 0 ? {} : { transparentDepthWrite: options.transparentDepthWrite },
         ...options.coverageOnly === void 0 ? {} : { coverageOnly: options.coverageOnly },
         ...options.excludeSelector === void 0 ? {} : { excludeSelector: options.excludeSelector },
         ...options.includeSelector === void 0 ? {} : { includeSelector: options.includeSelector },
         ...options.transmissionBackdrop === void 0 ? {} : { transmissionBackdropView: transmissionBackdrop },
-        ...options.gpuDriven === void 0 ? {} : { gpuDriven: { projection: options.gpuDriven, resources } }
+        ...surfaceRawDepth === null ? {} : { surfaceRawDepthView: surfaceRawDepth },
+        ...surfaceNearestLayer === null ? {} : { surfaceNearestLayerView: surfaceNearestLayer },
+        ...surfaceNearestDepth === null ? {} : { surfaceNearestDepthView: surfaceNearestDepth },
+        ...options.recordMode === "single-layer-medium-nearest-layer" ? { fragmentEntryPoint: "fs_nearest_layer" } : options.recordMode === "single-layer-medium-color" ? { fragmentEntryPoint: "fs_color" } : {},
+        ...options.gpuDriven === void 0 ? {} : { gpuDriven: { projection: options.gpuDriven, resources } },
+        ...options.gpuDrivenFilter === void 0 ? {} : { gpuDrivenFilter: options.gpuDrivenFilter }
       });
       if (passContext.materialUboPayloadCache !== void 0) {
         internal.materialUboPayloadCache = passContext.materialUboPayloadCache;
@@ -13232,46 +14382,32 @@ function addReflectionFallbackObservationPass(graph, target) {
   });
 }
 var TYPED_BLOOM_PASS_NAMES = {
-  bright: "bloom-bright",
-  blurH: "bloom-blur-h",
-  blurV: "bloom-blur-v",
+  downsample: "bloom-downsample",
+  upsample: "bloom-upsample",
   composite: "bloom-composite"
 };
+function typedBloomLevelPassName(kind, level) {
+  return `${TYPED_BLOOM_PASS_NAMES[kind]}-${level}`;
+}
 function addTypedBloomPasses(graph, targets) {
   const named = {
     hdrColor: targets.scene,
-    hdrComposited: targets.composited,
-    bloomBright: targets.bright,
-    bloomBlurH: targets.blurH,
-    bloomBlurV: targets.blurV
+    hdrComposited: targets.composited
   };
-  const descriptors = [
-    {
-      name: TYPED_BLOOM_PASS_NAMES.bright,
-      reads: [targets.scene],
-      write: targets.bright,
-      encode: recordBloomBrightPass
-    },
-    {
-      name: TYPED_BLOOM_PASS_NAMES.blurH,
-      reads: [targets.bright],
-      write: targets.blurH,
-      encode: recordBloomBlurHPass
-    },
-    {
-      name: TYPED_BLOOM_PASS_NAMES.blurV,
-      reads: [targets.blurH],
-      write: targets.blurV,
-      encode: recordBloomBlurVPass
-    },
-    {
-      name: TYPED_BLOOM_PASS_NAMES.composite,
-      reads: [targets.scene, targets.blurV],
-      write: targets.composited,
-      encode: recordBloomCompositePass
-    }
-  ];
-  for (const descriptor of descriptors) {
+  targets.downsample.forEach((target, level) => {
+    named[`bloomDownsample${level}`] = target;
+  });
+  targets.upsample.forEach((target, level) => {
+    named[`bloomUpsample${level}`] = target;
+  });
+  const add = (name, reads, write, encode, level) => {
+    const descriptor = {
+      name,
+      reads,
+      write,
+      encode,
+      level
+    };
     const added = graph.addRasterPass(descriptor.name, {
       accesses: [
         ...descriptor.reads.map((target) => ({
@@ -13291,12 +14427,80 @@ function addTypedBloomPasses(graph, targets) {
       encode: ({ pass, frame, resources }) => descriptor.encode(
         frame,
         legacyResolver(resources, named),
-        pass
+        pass,
+        descriptor.level,
+        descriptor.level === void 0 ? void 0 : targets.levelDimensions[descriptor.level]
       )
     });
+    return added.ok ? ok(void 0) : added;
+  };
+  for (const [level, write] of targets.downsample.entries()) {
+    const source = level === 0 ? targets.scene : targets.downsample[level - 1];
+    if (source === void 0) {
+      return err$1(
+        new RenderGraphError({
+          code: "resource-resolution-failed",
+          expected: "Bloom downsample levels form one adjacent pyramid",
+          hint: "rebuild the Standard Bloom target declaration from one level list",
+          detail: { resourceLabel: `bloom-level-${level}` }
+        })
+      );
+    }
+    const added = add(
+      typedBloomLevelPassName("downsample", level),
+      [source],
+      write,
+      (frame, resolve, pass, passLevel) => recordBloomDownsamplePass(
+        frame,
+        resolve,
+        pass,
+        passLevel ?? level,
+        targets.levelDimensions[passLevel ?? level]
+      ),
+      level
+    );
     if (!added.ok) return added;
   }
-  return ok(void 0);
+  for (let level = targets.upsample.length - 1; level >= 0; level -= 1) {
+    const current = targets.downsample[level];
+    const coarse = level === targets.downsample.length - 2 ? targets.downsample[level + 1] : targets.upsample[level + 1];
+    const write = targets.upsample[level];
+    if (current === void 0 || coarse === void 0 || write === void 0) {
+      return err$1(
+        new RenderGraphError({
+          code: "resource-resolution-failed",
+          expected: "Bloom downsample and upsample levels form one adjacent pyramid",
+          hint: "rebuild the Standard Bloom target declaration from one level list",
+          detail: { resourceLabel: `bloom-level-${level}` }
+        })
+      );
+    }
+    const added = add(
+      typedBloomLevelPassName("upsample", level),
+      [current, coarse],
+      write,
+      (frame, resolve, pass, passLevel) => recordBloomUpsamplePass(frame, resolve, pass, passLevel ?? level),
+      level
+    );
+    if (!added.ok) return added;
+  }
+  const finest = targets.upsample[0] ?? targets.downsample[0];
+  if (finest === void 0) {
+    return err$1(
+      new RenderGraphError({
+        code: "resource-resolution-failed",
+        expected: "Bloom has at least one downsample level",
+        hint: "derive Bloom levels from a positive output extent",
+        detail: { resourceLabel: "bloom-downsample-0" }
+      })
+    );
+  }
+  return add(
+    TYPED_BLOOM_PASS_NAMES.composite,
+    [targets.scene, finest],
+    targets.composited,
+    (frame, resolve, pass) => recordBloomCompositePass(frame, resolve, pass)
+  );
 }
 function addTypedSsaoPasses(graph, targets) {
   const calc = graph.addRasterPass("ssao-calc", {
@@ -13682,6 +14886,11 @@ function addStandardSceneDataPass(graph, target, depth) {
     color: target,
     depth,
     selector: { LightMode: ["Deferred", "Forward"] },
+    // The temporal producer runs before the Surface raw-depth/nearest-layer
+    // pair. Keep it on the ordinary opaque Standard lane rather than asking
+    // a medium material to assemble a bind group from resources that this
+    // pass cannot own yet.
+    recordMode: "opaque",
     passKind: "temporal",
     // The temporal producer re-rasterizes the current scene after the main
     // color pass has populated depth. Its output is a semantic motion target;
@@ -13707,6 +14916,6 @@ function addTaaResolvePass(graph, current, currentTemporal, previousColor, previ
   });
 }
 
-export { BYTES_PER_DIRECT_LIGHT_SLOT, BatchTopology, CAPTURE_VIEW_PROJS, CUBEMAP_FACE_VERTICES, CUBE_CAPTURE_VIEW_SLOT_BASE, DEFERRED_COLOR_FORMATS, DEPTH_MIN_PARAMS_BYTE_SIZE, FALLBACK_BYTES_PER_ROW, GPU_DRIVEN_VIEW_WGSL, GPU_SCENE_LAYOUTS, GpuBuffer, GpuDrivenView, GpuTexture, MATERIAL_PER_ENTITY_STRIDE, MESH_SSBO_BYTES, OcclusionConfidenceScheduler, POINTS_LINES_MATERIAL_SHADER_ID, POINTS_LINES_VIEW_BUFFER_SIZE, PREFILTER_MIP_LEVELS, PREFILTER_SIZE, PipelineSpecError, PostProcessError, REFLECTION_PROBE_VIEW_SLOT_BASE, SHADOW_CASTER_BUFFER_SIZE, STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES, STANDARD_PBR_UBO_SIZE, ShadowViewStatePool, TEMPORAL_HISTORY_FORMATS, TYPED_BLOOM_PASS_NAMES, VIEW_UNIFORM_BUFFER_SIZE, VIEW_UNIFORM_BYTES, VIEW_UNIFORM_SLOT_STRIDE, abortTemporalGpuSubmit, addReflectionFallbackObservationPass, addStandardSceneDataPass, addTaaResolvePass, addTypedBloomPasses, addTypedCompositePostEffects, addTypedFrameObservationPass, addTypedFullscreenPass, addTypedOutputTransformPass, addTypedScenePass, addTypedSkyboxPass, addTypedSsaoPasses, addTypedTemporalResolvePass, aggregateTemporalDemand, applyMaterialTextureUvScales, applyParamSchemaDefaultsToUbo, applyParamSnapshotToUbo, assembleMaterialWithSkylightEntries, assertStorageBufferCap, buildFoldDispatchPlan, buildFullscreenPostProcessPass, buildLinearLdrMaterialSpecTable, buildPerFrameBindGroups, buildSpecConstTable, cacheKeyOf, cleanPerEntityCache, colorFormatsForPassKind, commitTemporalGpuSubmit, computeProjectionMatrix, computeSplitLdrSprite, computeViewMatrix, configureSurface, createClusterBinScratch, createFullscreenBindGroup, createHdrpClusterMembershipBindGroupLayoutDescriptor, createIblPipelines, createPointsLinesLaneAdapter, createPointsLinesLaneContract, createRenderPipelineTarget, createSkylightFallback, createStandardSceneDataTarget, createStandardSurfaceLightingBindGroup, decideVisibility, defaultViewForUserRegionField, deriveRenderDataCubemap, deriveRenderDataMesh, deriveRenderDataTexture, deriveRenderExtent, describeTemporalDemand, detectNineSliceScaleTooSmall, deviceOptionsForAdapter, driveLazyEquirectProjection, encodeDirectionalShadowPass, encodeMainPass, encodePointShadowPass, encodeSpotShadowPass, ensureMeshSsboCapacity, entryHasDepthRead, evaluateFoldBucketUniformCap, foldDispatchBuckets, geometryRenderStateForPass, geometryRenderStateForTopology, getIblProbeBackgroundSource, getOrBuildPipeline, getOrCreateFromChain, getOrCreateHdrpBuffers, getOrCreateIblCache, getTemporalBindGroupResources, getTemporalGpuState, getTemporalParamsBuffer, gpuSceneFieldOffset, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, incrementFoldedDrawsMetric, isTemporalFullscreenBinding, packInstanceStorageBuffer, passKindPolicyTable, postProcessShaderEntrySignature, postProcessShaderModuleLabel, postProcessShaderPipelineLabel, prepareFrameLighting, prepareMaterialSkylight, prewarmMaterialShaderVariants, projectedHeightForCandidate, renderExtentSize, resetHdrpBuffers, residentTextureView, resolveMaterialSkylight, resolveOutputDither, resolveReflectionProbeBinding, resolveSkyboxActive, resolveSsaoParameters, resolveSurfaceFormatPair, resolveSurfaceProfile, retireTemporalGpuState, retireTemporalGpuStateAfterFence, runIblPrecompute, selectGpuDrivenSceneIndexVariant, selectGpuLodLane, selectHdrpPbrPrewarmVariants, selectLazyEquirectHandle, selectLod, selectProbePrewarmVariants, selectSkinPrewarmVariants, selectStandardPbrTransmissionPrewarmVariants, selectSwapChainFormat, setIblComposedShaders, shadowViewIdentityKey, shadowViewRasterAccesses, shouldIssueRetest, standardStorageVariantSet, standardTemporalLaneAdmission, standardTemporalPostOrder, standardTopologyVariantSet, temporalReadIndex, temporalWriteIndex, transmissionBackdropAvailable, uploadMeshSsboBatch, variantSetFromDefines, variantSetFromVertexLayoutProjection, warnMultiSkybox, warnMultiSkylight, warnZeroLightStandard, writeHdrpClusterAndSsaoBuffers, writePbrMaterialUboPayload, writePointsLinesViewUbo, writeShadowCasterUniforms, writeShadowParamsBuffer, writeSpotModifierTextures, writeViewUbo };
-//# sourceMappingURL=chunk-JRIPCMYC.mjs.map
-//# sourceMappingURL=chunk-JRIPCMYC.mjs.map
+export { BLOOM_COMPOSITE_PARAMS_BYTES, BLOOM_DOWNSAMPLE_PARAMS_BYTES, BLOOM_UPSAMPLE_PARAMS_BYTES, BYTES_PER_DIRECT_LIGHT_SLOT, BatchTopology, CAPTURE_VIEW_PROJS, CLOUD_HISTORY_FORMATS, CUBEMAP_FACE_VERTICES, CUBE_CAPTURE_VIEW_SLOT_BASE, DEFERRED_COLOR_FORMATS, DEPTH_MIN_PARAMS_BYTE_SIZE, DEPTH_TEXTURE_FORMAT, FALLBACK_BYTES_PER_ROW, GPU_DRIVEN_VIEW_WGSL, GPU_SCENE_LAYOUTS, GpuBuffer, GpuDrivenView, GpuResourceAllocationLedger, GpuTexture, HDR_COLOR_ATTACHMENT_FORMAT, MATERIAL_PER_ENTITY_STRIDE, MESH_PER_ENTITY_STRIDE, MESH_SSBO_BYTES, MIPMAP_PREWARM_FORMATS, OcclusionConfidenceScheduler, POINTS_LINES_MATERIAL_SHADER_ID, POINTS_LINES_VIEW_BUFFER_SIZE, PREFILTER_MIP_LEVELS, PREFILTER_SIZE, PipelineSpecError, PostProcessError, REFLECTION_PROBE_VIEW_SLOT_BASE, SHADOW_CASTER_BUFFER_SIZE, STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES, STANDARD_PBR_UBO_SIZE, ShadowViewStatePool, SurfaceSubmissionObservationOwner, TEMPORAL_HISTORY_FORMATS, TYPED_BLOOM_PASS_NAMES, VIEW_UBO_BYTES, VIEW_UNIFORM_BYTES, VIEW_UNIFORM_SLOT_STRIDE, abortTemporalGpuSubmit, addReflectionFallbackObservationPass, addStandardSceneDataPass, addTaaResolvePass, addTypedBloomPasses, addTypedCompositePostEffects, addTypedFrameObservationPass, addTypedFullscreenPass, addTypedOutputTransformPass, addTypedScenePass, addTypedSkyboxPass, addTypedSsaoPasses, addTypedTemporalResolvePass, aggregateTemporalDemand, applyMaterialTextureUvScales, applyParamSchemaDefaultsToUbo, applyParamSnapshotToUbo, assembleMaterialWithSkylightEntries, assertStorageBufferCap, buildFoldDispatchPlan, buildFullscreenPostProcessPass, buildLinearLdrMaterialSpecTable, buildPerFrameBindGroups, buildSpecConstTable, cacheKeyOf, cleanPerEntityCache, colorFormatsForPassKind, combineGpuResourceAllocationInspections, commitTemporalGpuSubmit, computeProjectionMatrix, computeSplitLdrSprite, computeViewMatrix, configureSurface, createClusterBinScratch, createFullscreenBindGroup, createHdrpClusterMembershipBindGroupLayoutDescriptor, createIblPipelines, createPointsLinesLaneAdapter, createPointsLinesLaneContract, createRenderPipelineTarget, createSkylightFallback, createStandardSceneDataTarget, createStandardSurfaceLightingBindGroup, decideVisibility, defaultViewForUserRegionField, deriveRenderDataCubemap, deriveRenderDataMesh, deriveRenderDataTexture, deriveRenderExtent, describeTemporalDemand, detectNineSliceScaleTooSmall, deviceOptionsForAdapter, driveLazyEquirectProjection, encodeDirectionalShadowPass, encodeMainPass, encodePointShadowPass, encodeSpotShadowPass, ensureMeshSsboCapacity, ensureProbeBlendRecordBuffer, entryHasDepthRead, evaluateFoldBucketUniformCap, foldDispatchBuckets, geometryRenderStateForPass, geometryRenderStateForTopology, getIblProbeBackgroundSource, getOrBuildPipeline, getOrCreateFromChain, getOrCreateHdrpBuffers, getOrCreateIblCache, getTemporalBindGroupResources, getTemporalGpuState, getTemporalParamsBuffer, gpuSceneFieldOffset, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, incrementFoldedDrawsMetric, inspectResourceClassSplits, isTemporalFullscreenBinding, packInstanceStorageBuffer, passKindPolicyTable, postProcessShaderEntrySignature, postProcessShaderModuleLabel, postProcessShaderPipelineLabel, prepareFrameLighting, prepareMaterialSkylight, prewarmMaterialShaderVariants, projectedHeightForCandidate, renderExtentSize, renderPipelineCloudHistoryTargets, resetHdrpBuffers, resetSsaoResources, residentTextureView, resolveGeometryInstanceBuffer, resolveMaterialSkylight, resolveOutputDither, resolveReflectionProbeBinding, resolveSkyboxActive, resolveSsaoParameters, resolveSurfaceFormatPair, resolveSurfaceProfile, retireTemporalGpuState, retireTemporalGpuStateAfterFence, runIblPrecompute, selectGpuDrivenSceneIndexVariant, selectGpuLodLane, selectHdrpPbrPrewarmVariants, selectLazyEquirectHandle, selectLod, selectProbePrewarmVariants, selectSkinPrewarmVariants, selectStandardPbrTransmissionPrewarmVariants, selectSwapChainFormat, setIblComposedShaders, shadowViewIdentityKey, shadowViewRasterAccesses, shouldIssueRetest, stageTemporalGpuSubmit, standardBloomAdmitted, standardStorageVariantSet, standardTemporalLaneAdmission, standardTemporalPostOrder, standardTopologyVariantSet, temporalReadIndex, temporalWriteIndex, transmissionBackdropAvailable, uploadMeshSsboBatch, variantSetFromDefines, variantSetFromVertexLayoutProjection, warnMultiSkybox, warnMultiSkylight, warnZeroLightStandard, writeHdrpClusterAndSsaoBuffers, writePbrMaterialUboPayload, writePointsLinesViewUbo, writeShadowCasterUniforms, writeShadowParamsBuffer, writeSpotModifierTextures, writeViewUbo };
+//# sourceMappingURL=chunk-MKDIT2EM.mjs.map
+//# sourceMappingURL=chunk-MKDIT2EM.mjs.map