@forgeax/engine-render 0.1.33 → 0.1.35

package/dist/{chunk-VOZWDM3L.mjs → chunk-LNIUIKQ7.mjs}

@@ -1,16 +1,15 @@
-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-LEAXOMYJ.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-3RTCJTH4.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-NB2S7ZRX.mjs';
+import { DEFAULT_CLUSTER_GRID, DEFAULT_STANDARD_PROFILE, createIblKernelCache, STANDARD_PBR_UBO_SIZE, MATERIAL_PER_ENTITY_STRIDE, MAX_LIGHTS, CLUSTER_GRID_STRIDE_U32, LIGHT_INDEX_LIST_CAPACITY, createStandardClusterLayout } from './chunk-SGPUJW3F.mjs';
+import { TRANSPARENT_SORT_MODE_LAYER_Z, TRANSPARENT_SORT_MODE_LAYER_Y, SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-XSFB7XXQ.mjs';
+import { probeBlendRecordOffset, PROBE_BLEND_RECORD_BYTE_SIZE, PROBE_BLEND_RECORD_STRIDE } from './chunk-RIPAEGI6.mjs';
+import { GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GPU_TEXTURE_USAGE_COPY_SRC, VertexColorVariantConflictError, GPU_SHADER_STAGE_COMPUTE, GPU_BUFFER_USAGE_STORAGE, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM, createHdrpBindGroupLayoutDescriptor, EquirectProjectionFailedError, SHADOW_ATLAS_DEFAULT_LAYERS, COOKIE_MATRIX_BYTES, SHADOW_ATLAS_DEFAULT_FACE_SIZE, ShadowAtlas, PointShadowAtlasUninitializedError, PointShadowAtlasBoundsViolationError, IES_SLICE_WIDTH, IES_SLICE_HEIGHT, COOKIE_SLICE_SIZE, StandardClusterTransportUnavailableError, GPU_SHADER_STAGE_VERTEX, GPU_SHADER_STAGE_FRAGMENT, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GPU_BUFFER_USAGE_INDEX, GPU_BUFFER_USAGE_VERTEX, isStandardPbrMaterialShader, worldEntityKey, instanceCollectionCacheKey, instanceUploadRangesForResident, createVisibilityBudget, GPU_BUFFER_USAGE_MAP_READ, getOpaqueResourceIdentity, pbrSkinMeshDynamicOffsets, gpuDrivenShadowDrawKey, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, buildPbrMaterialUserRegionEntries, buildBindGroupLayoutDescriptor, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, GPU_BUFFER_USAGE_COPY_SRC, GPU_BUFFER_USAGE_INDIRECT, StandardLightBudgetExceededError, EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES, gpuDrivenSourceDrawItemIndex, matchPass, createPbrSkinMeshBindGroupEntries, physicalTextureFields, isCanonicalStandardPbrMaterialShader, RendererOperationError, resolveRenderTargetMaterialSource, VideoUploadUnsupportedError, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, StandardClusterIndexOverflowError, isStandardPbrSkinMaterialShader, SKIN_MATERIAL_SHADER_ID, FXAA_POST_PROCESS_ID, gpuDrivenDrawKey, materialBindGroupLayoutIdentity } from './chunk-MXTWKZO4.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';
 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 { probeVideoHighPerfUpload, VIDEO_SOURCE_PROVIDER_KEY, videoSourceExtent } from '@forgeax/engine-graphics-extras';
+import { 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';
 
 // src/pipeline/render-extent.ts
@@ -119,6 +118,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 = {
@@ -1249,10 +1259,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",
@@ -1281,6 +1316,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, {
@@ -1295,6 +1331,7 @@ function getOrCreateSsaoFallbackTexture(runtime) {
   });
   if (!viewRes.ok) {
     runtime.errorRegistry.fire(viewRes.error);
+    destroyTexture(runtime, device, texRes.value);
     return null;
   }
   const samplerRes = device.createSampler({
@@ -1308,6 +1345,7 @@ function getOrCreateSsaoFallbackTexture(runtime) {
   });
   if (!samplerRes.ok) {
     runtime.errorRegistry.fire(samplerRes.error);
+    destroyTexture(runtime, device, texRes.value);
     return null;
   }
   const resources = {
@@ -1320,10 +1358,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);
@@ -1347,6 +1410,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();
@@ -1369,6 +1433,7 @@ function getOrCreateSsaoBuffers(runtime) {
   });
   if (!noiseTexRes.ok) {
     runtime.errorRegistry.fire(noiseTexRes.error);
+    destroyBuffer(runtime, device, kernelBufferRes.value);
     return null;
   }
   const noiseCopyRes = device.queue.writeTexture(
@@ -1383,6 +1448,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({
@@ -1393,6 +1459,7 @@ function getOrCreateSsaoBuffers(runtime) {
   });
   if (!uniformBufRes.ok) {
     runtime.errorRegistry.fire(uniformBufRes.error);
+    destroyCreatedSsaoResources(runtime, device, [kernelBufferRes.value], [noiseTexRes.value]);
     return null;
   }
   const buffers = {
@@ -1689,7 +1756,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;
@@ -1705,7 +1772,7 @@ function createHdrpUnifiedBindGroup(runtime, hdrpBuffers, meshStorageBuffer, ssa
           value: {
             buffer: meshStorageBuffer,
             offset: 0,
-            size: MESH_PER_ENTITY_STRIDE
+            size: meshBindingBytes
           }
         }
       },
@@ -1718,17 +1785,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
       ),
@@ -2445,7 +2511,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;
@@ -2453,7 +2519,7 @@ var POINTS_LINES_VIEW_BUFFER_SIZE = POINTS_LINES_VIEW_SLOT_STRIDE * POINTS_LINES
 var VIEW_UNIFORM_SLOT_STRIDE = 1024;
 var POINT_SHADOW_VIEW_SLOT_COUNT = 24;
 var CUBE_CAPTURE_VIEW_SLOT_BASE = 1 + POINT_SHADOW_VIEW_SLOT_COUNT;
-var REFLECTION_PROBE_VIEW_SLOT_BASE = CUBE_CAPTURE_VIEW_SLOT_BASE + 6;
+var REFLECTION_PROBE_VIEW_SLOT_BASE = CUBE_CAPTURE_VIEW_SLOT_BASE + 6 + 1;
 var REFLECTION_PROBE_VIEW_SLOT_COUNT = 16;
 var VIEW_UNIFORM_BUFFER_SIZE = VIEW_UNIFORM_SLOT_STRIDE * (REFLECTION_PROBE_VIEW_SLOT_BASE + REFLECTION_PROBE_VIEW_SLOT_COUNT);
 function pointShadowViewOffset(layer, face) {
@@ -2509,7 +2575,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);
@@ -2527,7 +2593,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;
@@ -2576,6 +2642,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++) {
@@ -2685,6 +2765,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;
@@ -2716,6 +2797,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(
@@ -2729,7 +2811,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",
         () => {
@@ -2811,8 +2894,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 ? [
               {
@@ -2860,7 +2955,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
@@ -4295,6 +4406,144 @@ var GpuTexture = class {
     return r;
   }
 };
+
+// src/record/sprite-instance-buffer.ts
+function interleaveSpriteInstanceBuffer(transforms, regions, includePrevious = false) {
+  const count = transforms.length / 16;
+  const stride = includePrevious ? 36 : 20;
+  const regionOffset = includePrevious ? 32 : 16;
+  const out = new Float32Array(count * stride);
+  for (let i = 0; i < count; i++) {
+    const dstBase = i * stride;
+    const transformBase = i * 16;
+    const regionBase = i * 4;
+    for (let k = 0; k < 16; k++) out[dstBase + k] = transforms[transformBase + k] ?? 0;
+    if (includePrevious) {
+      for (let k = 0; k < 16; k++) {
+        out[dstBase + 16 + k] = transforms[transformBase + k] ?? 0;
+      }
+    }
+    for (let k = 0; k < 4; k++) {
+      out[dstBase + regionOffset + k] = regions[regionBase + k] ?? 0;
+    }
+  }
+  return out;
+}
+function spriteInstancesCacheHit(entry, snapshot, requestedBytes) {
+  return entry !== void 0 && entry.uploadedArchVersion === snapshot.archVersion && entry.uploadedByteLength === requestedBytes;
+}
+function resolveSpriteInstancesBuffer(c, spriteEntry, fallbackBuffer, fallbackCount) {
+  const { runtime, frameState } = c;
+  let buffer = fallbackBuffer;
+  let count = fallbackCount;
+  const spriteInstancesSnap = spriteEntry.source.spriteInstances;
+  if (spriteInstancesSnap !== void 0) {
+    if (spriteInstancesSnap.instanceCount === 0) return { buffer, count: 0 };
+    const uniformFallback = runtime.device.caps.storageBuffer === false;
+    const interleaved = interleaveSpriteInstanceBuffer(
+      spriteInstancesSnap.transforms,
+      spriteInstancesSnap.regions,
+      !uniformFallback
+    );
+    const requestedBytes = interleaved.byteLength;
+    const cap = runtime.device.limits.maxStorageBufferBindingSize;
+    if (typeof cap === "number" && requestedBytes > cap) {
+      runtime.errorRegistry.fire(
+        new RhiError({
+          code: "limit-exceeded",
+          expected: `requestedBytes (${requestedBytes}) <= maxStorageBufferBindingSize (${cap})`,
+          hint: "reduce SpriteInstances instance count to fit within device.limits.maxStorageBufferBindingSize (144 bytes per instance: current mat4 64B + previous mat4 64B + region 16B)",
+          detail: {
+            maxStorageBufferBindingSize: cap,
+            requestedBytes
+          }
+        })
+      );
+    } else {
+      const cachedSpriteInst = frameState.instanceBuffers.get(
+        worldEntityKey(spriteEntry.source.worldId, spriteInstancesSnap.cacheKey)
+      );
+      let activeSpriteInst = null;
+      if (spriteInstancesCacheHit(cachedSpriteInst, spriteInstancesSnap, requestedBytes)) {
+        activeSpriteInst = cachedSpriteInst ?? null;
+      } else if (requestedBytes > 0) {
+        const bufRes = runtime.device.createBuffer({
+          size: requestedBytes,
+          usage: (uniformFallback ? GPU_BUFFER_USAGE_UNIFORM : GPU_BUFFER_USAGE_STORAGE) | GPU_BUFFER_USAGE_COPY_DST,
+          mappedAtCreation: false
+        });
+        if (!bufRes.ok) {
+          runtime.errorRegistry.fire(bufRes.error);
+        } else {
+          if (cachedSpriteInst !== void 0 && !cachedSpriteInst.buffer.isDestroyed) {
+            const r = cachedSpriteInst.buffer.destroy();
+            if (!r.ok) runtime.errorRegistry.fire(r.error);
+          }
+          const newBuf = new GpuBuffer(runtime.device, bufRes.value);
+          activeSpriteInst = {
+            buffer: newBuf,
+            uploadedArchVersion: spriteInstancesSnap.archVersion,
+            uploadedByteLength: requestedBytes
+          };
+          frameState.instanceBuffers.set(
+            worldEntityKey(spriteEntry.source.worldId, spriteInstancesSnap.cacheKey),
+            activeSpriteInst
+          );
+        }
+      }
+      if (activeSpriteInst !== null && requestedBytes > 0) {
+        const writeRes = runtime.device.queue.writeBuffer(
+          activeSpriteInst.buffer.handle,
+          0,
+          interleaved
+        );
+        if (!writeRes.ok) {
+          runtime.errorRegistry.fire(writeRes.error);
+        } else {
+          buffer = activeSpriteInst.buffer.handle;
+          count = spriteInstancesSnap.instanceCount;
+        }
+      }
+    }
+  }
+  return { buffer, count };
+}
+
+// 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;
@@ -4378,7 +4627,7 @@ var COMPRESSION_FEATURES = [
 function transmissionBackdropAvailable(limit) {
   return limit === void 0 || limit >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
 }
-var STANDARD_PHYSICAL_REQUIRED_SAMPLED_TEXTURES = 22;
+var STANDARD_PHYSICAL_REQUIRED_SAMPLED_TEXTURES = 23;
 function deriveDeviceFeatureAdmission(adapter, options) {
   const requiredFeatures = COMPRESSION_FEATURES.filter((feature) => adapter.features.has(feature));
   const timestampRequested = options?.gpuPassTiming !== void 0 || options?.captureGpuTimings === true;
@@ -4403,7 +4652,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,
@@ -4429,10 +4678,6 @@ function assembleMaterialWithSkylightEntries(materialEntries, skylight, transmis
     },
     {
       binding: iblStart + 5,
-      resource: { kind: "sampler", value: skylight.brdfLutSampler }
-    },
-    {
-      binding: iblStart + 6,
       resource: { kind: "buffer", value: { buffer: skylight.intensityBuffer } }
     }
   ];
@@ -4450,6 +4695,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];
@@ -4466,13 +4740,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) {
@@ -4736,116 +5012,6 @@ function deriveRenderDataCubemap(source) {
     cubeUsage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING | GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_COPY_SRC
   });
 }
-var STANDARD_PBR_UBO_SIZE = derive(DEFAULT_STANDARD_PBR_PARAM_SCHEMA).uboLayout.totalBytes;
-var MATERIAL_PER_ENTITY_STRIDE = Math.ceil(STANDARD_PBR_UBO_SIZE / 256) * 256;
-function resolveSurfaceProfile(storageFormat, viewFormat, facts) {
-  if (facts.surfaceViewFormats) {
-    return ok$1({
-      kind: "dual-view",
-      storageFormat,
-      viewFormat,
-      viewFormats: [viewFormat],
-      hasDisplayEndpoint: true
-    });
-  }
-  if (!facts.rawAttachment || !facts.floatRenderAttachment) {
-    return err(
-      new RhiError({
-        code: "webgpu-runtime-error",
-        expected: "raw surface attachment and rgba16float render attachment capabilities",
-        hint: "surface profile cannot establish a raw-only linear output route",
-        detail: {
-          error: {
-            code: "surface-raw-endpoint-failed",
-            message: "raw-only surface capabilities are incomplete"
-          }
-        }
-      })
-    );
-  }
-  return ok$1({
-    kind: "raw-only",
-    storageFormat,
-    viewFormat: storageFormat,
-    viewFormats: [],
-    hasDisplayEndpoint: false
-  });
-}
-function resolveSurfaceFormatPair(_backendKind, storage, view) {
-  return { storage, view };
-}
-function surfaceCapabilityFacts(device, storageFormat) {
-  const internal = device;
-  return {
-    surfaceViewFormats: internal.surfaceViewFormats ?? device.caps?.backendKind !== "wgpu-webgl2",
-    rawAttachment: storageFormat === "rgba8unorm" || storageFormat === "bgra8unorm",
-    floatRenderAttachment: device.caps?.rgba16floatRenderable ?? true
-  };
-}
-function configureSurface(context, device, format, colorAttachmentFormat) {
-  const backendKind = device.caps?.backendKind ?? "webgpu";
-  const isWebGl2 = backendKind === "wgpu-webgl2";
-  const surfaceFormats = resolveSurfaceFormatPair(
-    backendKind,
-    format,
-    colorAttachmentFormat
-  );
-  const profile = resolveSurfaceProfile(
-    surfaceFormats.storage,
-    surfaceFormats.view,
-    surfaceCapabilityFacts(device, surfaceFormats.storage)
-  );
-  if (!profile.ok) return profile;
-  const supportsTextureBinding = backendKind !== "wgpu-webgl2" && (device.caps?.storageBuffer ?? true);
-  const configured = context.configure({
-    device,
-    format: surfaceFormats.storage,
-    alphaMode: isWebGl2 ? "opaque" : "premultiplied",
-    usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT | (supportsTextureBinding ? GPU_TEXTURE_USAGE_TEXTURE_BINDING : 0) | (isWebGl2 ? 0 : GPU_TEXTURE_USAGE_COPY_SRC),
-    viewFormats: [...profile.value.viewFormats]
-  });
-  if (!configured.ok) return configured;
-  if (isWebGl2 && (context.presentationProof === void 0 || !context.presentationProof.descriptor || !context.presentationProof.acquisition || !context.presentationProof.validation || typeof context.presentationProof.surfaceIdentity !== "string" || context.presentationProof.surfaceIdentity.length === 0 || context.presentationProof.requested === void 0 || context.presentationProof.validated === void 0 || JSON.stringify(context.presentationProof.requested) !== JSON.stringify(context.presentationProof.validated))) {
-    return err(
-      new RhiError({
-        code: "webgpu-runtime-error",
-        expected: "WebGL2 surface storage has descriptor, acquisition, and validation proof",
-        hint: "run the concrete presentation probe and retain the last-known-good graph when proof is absent",
-        detail: {
-          error: {
-            code: "surface-raw-endpoint-failed",
-            message: "surface storage raw endpoint proof is incomplete"
-          }
-        }
-      })
-    );
-  }
-  return ok$1(void 0);
-}
-function selectSwapChainFormat(storageBufferCapable, surfaceViewFormats = true) {
-  if (!storageBufferCapable) {
-    return {
-      storage: "rgba8unorm",
-      view: surfaceViewFormats ? "rgba8unorm-srgb" : "rgba8unorm"
-    };
-  }
-  const nav = globalThis.navigator;
-  const gpu = nav?.gpu;
-  const getPreferred = gpu?.getPreferredCanvasFormat;
-  if (gpu !== void 0 && typeof getPreferred === "function") {
-    const storage = getPreferred.call(gpu);
-    const view = storage === "rgba8unorm" ? "rgba8unorm-srgb" : storage === "bgra8unorm" ? "bgra8unorm-srgb" : storage;
-    return {
-      storage,
-      view: surfaceViewFormats ? view : storage
-    };
-  }
-  return {
-    storage: "rgba8unorm",
-    view: surfaceViewFormats ? "rgba8unorm-srgb" : "rgba8unorm",
-    fallbackReason: "preferred-canvas-format-missing"
-  };
-}
 
 // src/record/main-pass-material.ts
 function selectMaterialGroup2(clusterGroup, meshGroup, group2Contract) {
@@ -4984,8 +5150,8 @@ function clearVideoUploadFailureEpisode(store, entityKey, clip) {
 }
 function videoTextureView(world, store, runtime, entityKey, clip, highPerfAvailable) {
   if (store === void 0) return void 0;
-  const provider = world.hasResource(VIDEO_ELEMENT_PROVIDER_KEY) ? world.getResource(VIDEO_ELEMENT_PROVIDER_KEY) : void 0;
-  const element = provider?.getElement(entityKey, clip);
+  const provider = !("resolveAsset" in world) && world.hasResource(VIDEO_SOURCE_PROVIDER_KEY) ? world.getResource(VIDEO_SOURCE_PROVIDER_KEY) : void 0;
+  const element = "resolveAsset" in world ? world.videoFrame(entityKey, clip) : provider?.getSource(entityKey, clip);
   if (element === void 0 && !highPerfAvailable) {
     if (markVideoUploadFailureEpisode(store, entityKey, clip)) {
       runtime.errorRegistry.fire(new VideoUploadUnsupportedError());
@@ -4996,9 +5162,9 @@ function videoTextureView(world, store, runtime, entityKey, clip, highPerfAvaila
     clearVideoUploadFailureEpisode(store, entityKey, clip);
     return store.getView(clip);
   }
-  const width = element.videoWidth;
-  const height = element.videoHeight;
-  if (width <= 0 || height <= 0 || element.readyState < 2) return store.getView(clip);
+  const extent = videoSourceExtent(element);
+  if (extent === void 0) return store.getView(clip);
+  const { width, height } = extent;
   const uploaded = store.uploadFrame(clip, element, width, height);
   if (uploaded === void 0) return store.getView(clip);
   if (!uploaded.ok) {
@@ -5252,7 +5418,7 @@ function recordIblMaterialBinding(frameState, materialBgl, bindGroup, entries, i
   if (receipt === void 0) return;
   const skylightBindingStart = entries.findIndex((entry) => entry.binding === iblStart);
   if (skylightBindingStart < 0) return;
-  const iblEntries = entries.slice(skylightBindingStart, skylightBindingStart + 7);
+  const iblEntries = entries.slice(skylightBindingStart, skylightBindingStart + 6);
   const projected = [];
   for (const entry of iblEntries) {
     if (entry.resource.kind === "externalTexture") continue;
@@ -5277,9 +5443,10 @@ function recordIblMaterialBinding(frameState, materialBgl, bindGroup, entries, i
     errors: []
   };
 }
-function isMaterialBgAssemblyCacheHit(cached, material, materialBgl, materialBuffer, skylightResources, materialResourceEpoch, transmissionBackdropView, sceneMaterialBuffer) {
-  if (transmissionBackdropView != 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 isMaterialBgAssemblyCacheHit(cached, material, materialBgl, materialBuffer, skylightResources, materialResourceEpoch, transmissionBackdropView, sceneMaterialBuffer, surfaceRawDepthView) {
+  if (transmissionBackdropView != null || surfaceRawDepthView != null || (material.textureSources?.size ?? 0) > 0)
+    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.intensityBuffer === skylightResources.intensityBuffer;
 }
 function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWorld = deps.world, materialShaderId = submeshMaterial.materialShaderId) {
   const {
@@ -5294,6 +5461,9 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
     materialBgShared,
     materialBgAssemblyCache,
     transmissionBackdropView,
+    surfaceRawDepthView,
+    surfaceNearestLayerView,
+    surfaceNearestDepthView,
     bindGroupCounts,
     frameState
   } = deps;
@@ -5303,6 +5473,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;
@@ -5322,7 +5521,8 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
       effectiveSkylightResources,
       store.materialResourceEpoch,
       transmissionBackdropView,
-      sceneMaterialBuffer
+      sceneMaterialBuffer,
+      surfaceRawDepthView
     )) {
       if (diagnosticsEnabled) {
         recordIblMaterialBinding(
@@ -5352,10 +5552,6 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
             },
             {
               binding: 6 + smUserRegionFields.length * 2,
-              resource: { kind: "sampler", value: effectiveSkylightResources.brdfLutSampler }
-            },
-            {
-              binding: 7 + smUserRegionFields.length * 2,
               resource: {
                 kind: "buffer",
                 value: { buffer: effectiveSkylightResources.intensityBuffer }
@@ -5464,14 +5660,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({
@@ -5500,6 +5698,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)
       })}`
@@ -5538,7 +5744,7 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
       "miss"
     );
   }
-  if (smMaterialHandle !== void 0 && !smHasVideoFields && materialResourcesResident && !hasActiveTransmissionBackdrop) {
+  if (smMaterialHandle !== void 0 && !smHasVideoFields && (submeshMaterial.textureSources?.size ?? 0) === 0 && materialResourcesResident && !hasActiveTransmissionBackdrop) {
     if (materialCacheKey !== void 0) {
       materialBgAssemblyCache.set(materialCacheKey, {
         material: submeshMaterial,
@@ -5592,7 +5798,6 @@ function resolveMaterialSkylight(runtime, pipelineState, skylight, skylightCount
     prefilterView: activeViews.pref,
     prefilterSampler: skylightFallback.sampler,
     brdfLutView: activeViews.brdf,
-    brdfLutSampler: skylightFallback.sampler,
     intensityBuffer: skylightFallback.intensityBuffer
   } : {
     irradianceView: skylightFallback.irradianceView,
@@ -5600,7 +5805,6 @@ function resolveMaterialSkylight(runtime, pipelineState, skylight, skylightCount
     prefilterView: skylightFallback.prefilterView,
     prefilterSampler: skylightFallback.sampler,
     brdfLutView: skylightFallback.brdfLutView,
-    brdfLutSampler: skylightFallback.sampler,
     intensityBuffer: skylightFallback.intensityBuffer
   };
   return { skylightResources, activeViews };
@@ -5615,6 +5819,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);
@@ -5666,9 +5975,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
     )
@@ -5754,6 +6064,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}`;
@@ -5768,13 +6081,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) {
@@ -5782,7 +6098,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) {
@@ -5793,7 +6109,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,
@@ -5829,6 +6145,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
   const bindingState = {
     pipeline: null,
     instancesBuffer: null,
+    instanceBindGroup: null,
     probeOffset: -1
   };
   const identityInstanceBuffer = pipelineState.identityInstanceBuffer;
@@ -5848,7 +6165,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);
@@ -5856,12 +6173,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;
@@ -5884,7 +6201,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
       void 0,
       layoutProjection,
       void 0,
-      void 0,
+      layoutKind,
       void 0,
       reflectionFallbackFormats,
       vertexEntry,
@@ -5909,6 +6226,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
         colorFormatOverride: colorFormat,
         additionalColorFormats: reflectionFallbackFormats,
         textureMask,
+        layoutKind,
         handle
       };
       if (shaderLookupCache === void 0) {
@@ -5927,6 +6245,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;
@@ -6009,8 +6328,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;
@@ -6153,10 +6481,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;
@@ -6202,7 +6531,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,
@@ -6211,11 +6540,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;
@@ -6260,7 +6599,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,
@@ -6271,7 +6610,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;
@@ -6291,13 +6631,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;
@@ -6339,12 +6684,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 {
@@ -6357,12 +6719,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
+                    }
+                  });
+                }
               )
             )
           );
@@ -6574,8 +6953,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) {
@@ -6601,6 +6982,22 @@ function resolveStorageInstanceChunks(c, entry, inst, cap, probeBuffer, probeOff
 function resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, useProbeBlend) {
   const { runtime, pipelineState, frameState } = c;
   const inst = entry.source.instances;
+  if (entry.source.spriteInstances !== void 0) {
+    const { buffer, count } = resolveSpriteInstancesBuffer(
+      c,
+      entry,
+      pipelineState.identityInstanceBuffer,
+      0
+    );
+    return count === 0 ? [] : [
+      {
+        instanceBuffer: buffer,
+        instanceBindGroup: resolveGeometryInstancesBindGroup(c, buffer, void 0),
+        probeOffset: -1,
+        instanceCount: count
+      }
+    ];
+  }
   const probeBinding = !useProbeBlend || !runtime.device.caps.storageBuffer || entry.source.probeBlendRecord === void 0 ? void 0 : resolveProbeBlendBuffer(
     c,
     entry.source.probeBlendRecord,
@@ -6617,6 +7014,7 @@ function resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, useProbe
           pipelineState.identityInstanceBuffer,
           probeBinding?.buffer
         ),
+        ...probeBinding?.buffer === void 0 ? {} : { probeBuffer: probeBinding.buffer },
         probeOffset: probeBinding?.offset ?? -1
       }
     ];
@@ -6729,8 +7127,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) {
@@ -6784,6 +7184,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();
@@ -6860,43 +7261,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;
@@ -6936,30 +7355,6 @@ function resolveGeometryInstancesBindGroup(c, instanceBuffer, probeBuffer) {
     bindGroupCounts
   );
 }
-function interleaveSpriteInstanceBuffer(transforms, regions, includePrevious = false) {
-  const count = transforms.length / 16;
-  const stride = includePrevious ? 36 : 20;
-  const regionOffset = includePrevious ? 32 : 16;
-  const out = new Float32Array(count * stride);
-  for (let i = 0; i < count; i++) {
-    const dstBase = i * stride;
-    const transformBase = i * 16;
-    const regionBase = i * 4;
-    for (let k = 0; k < 16; k++) out[dstBase + k] = transforms[transformBase + k] ?? 0;
-    if (includePrevious) {
-      for (let k = 0; k < 16; k++) {
-        out[dstBase + 16 + k] = transforms[transformBase + k] ?? 0;
-      }
-    }
-    for (let k = 0; k < 4; k++) {
-      out[dstBase + regionOffset + k] = regions[regionBase + k] ?? 0;
-    }
-  }
-  return out;
-}
-function spriteInstancesCacheHit(entry, snapshot, requestedBytes) {
-  return entry !== void 0 && entry.uploadedArchVersion === snapshot.archVersion && entry.uploadedByteLength === requestedBytes;
-}
 function computeSplitLdrSprite(validatedOrdered, tonemapActive, dispatch) {
   if (tonemapActive) return false;
   if (dispatch !== void 0 && dispatch.length > 0) {
@@ -7219,50 +7614,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;
@@ -7288,7 +7643,7 @@ 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;
@@ -7308,158 +7663,83 @@ function recordSpriteEntityDraws(c, spritePass, matchedIndices, resolveMaterialB
               code: "limit-exceeded",
               expected: `requestedBytes (${requestedBytes}) <= maxStorageBufferBindingSize (${cap})`,
               hint: "reduce the sprite batch to fit within device.limits.maxStorageBufferBindingSize or use a storage-capable backend",
-              detail: {
-                maxStorageBufferBindingSize: cap,
-                requestedBytes
-              }
-            })
-          );
-        } else {
-          const cachedSprite = frameState.instanceBuffers.get(
-            worldEntityKey(spriteEntry.source.worldId, spriteInst.cacheKey)
-          );
-          let activeSprite = null;
-          if (cachedSprite !== void 0 && cachedSprite.uploadedArchVersion === spriteInst.archVersion && cachedSprite.uploadedByteLength === requestedBytes) {
-            activeSprite = cachedSprite;
-          } else if (requestedBytes > 0) {
-            const bufRes = runtime.device.createBuffer({
-              size: requestedBytes,
-              usage: spriteBufUsage,
-              mappedAtCreation: false
-            });
-            if (!bufRes.ok) {
-              runtime.errorRegistry.fire(bufRes.error);
-            } else {
-              if (cachedSprite !== void 0 && !cachedSprite.buffer.isDestroyed) {
-                const r = cachedSprite.buffer.destroy();
-                if (!r.ok) runtime.errorRegistry.fire(r.error);
-              }
-              const newBuf = new GpuBuffer(runtime.device, bufRes.value);
-              activeSprite = {
-                buffer: newBuf,
-                uploadedArchVersion: spriteInst.archVersion,
-                uploadedByteLength: requestedBytes
-              };
-              frameState.instanceBuffers.set(
-                worldEntityKey(spriteEntry.source.worldId, spriteInst.cacheKey),
-                activeSprite
-              );
-            }
-          }
-          if (activeSprite !== null) {
-            const writeRes = runtime.device.queue.writeBuffer(
-              activeSprite.buffer.handle,
-              0,
-              instancePayload
-            );
-            if (!writeRes.ok) {
-              runtime.errorRegistry.fire(writeRes.error);
-            } else {
-              spriteInstanceBuffer = activeSprite.buffer.handle;
-              spriteInstanceCount = Math.max(1, spriteInst.instanceCount);
-            }
-          }
-        }
-      }
-    }
-    const _si = resolveSpriteInstancesBuffer(
-      c,
-      spriteEntry,
-      spriteInstanceBuffer,
-      spriteInstanceCount
-    );
-    spriteInstanceBuffer = _si.buffer;
-    spriteInstanceCount = _si.count;
-    const spriteGroup2 = entityShaderId === "forgeax::sprite-lit" && c.standardLighting?.kind === "clustered" ? c.hdrpClusterBindGroup : meshBindGroup;
-    const spriteInstancesBg = resolveGeometryInstancesBindGroup(c, spriteInstanceBuffer, void 0);
-    spritePass.setBindGroup(2, spriteGroup2, [i * MESH_PER_ENTITY_STRIDE]);
-    const materialSlot = materialSlotIndices[i]?.[0] ?? 0;
-    const spritePassBg = resolveMaterialBindGroup(
-      materialSlot,
-      spriteEntry.source.material,
-      spriteEntry.source.entityKey,
-      spriteEntry.world ?? world
-    );
-    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);
-  }
-}
-function resolveSpriteInstancesBuffer(c, spriteEntry, fallbackBuffer, fallbackCount) {
-  const { runtime, frameState } = c;
-  let buffer = fallbackBuffer;
-  let count = fallbackCount;
-  const spriteInstancesSnap = spriteEntry.source.spriteInstances;
-  if (spriteInstancesSnap !== void 0) {
-    const uniformFallback = runtime.device.caps.storageBuffer === false;
-    const interleaved = interleaveSpriteInstanceBuffer(
-      spriteInstancesSnap.transforms,
-      spriteInstancesSnap.regions,
-      !uniformFallback
-    );
-    const requestedBytes = interleaved.byteLength;
-    const cap = runtime.device.limits.maxStorageBufferBindingSize;
-    if (typeof cap === "number" && requestedBytes > cap) {
-      runtime.errorRegistry.fire(
-        new RhiError({
-          code: "limit-exceeded",
-          expected: `requestedBytes (${requestedBytes}) <= maxStorageBufferBindingSize (${cap})`,
-          hint: "reduce SpriteInstances instance count to fit within device.limits.maxStorageBufferBindingSize (144 bytes per instance: current mat4 64B + previous mat4 64B + region 16B)",
-          detail: {
-            maxStorageBufferBindingSize: cap,
-            requestedBytes
-          }
-        })
-      );
-    } else {
-      const cachedSpriteInst = frameState.instanceBuffers.get(
-        worldEntityKey(spriteEntry.source.worldId, spriteInstancesSnap.cacheKey)
-      );
-      let activeSpriteInst = null;
-      if (spriteInstancesCacheHit(cachedSpriteInst, spriteInstancesSnap, requestedBytes)) {
-        activeSpriteInst = cachedSpriteInst ?? null;
-      } else if (requestedBytes > 0) {
-        const bufRes = runtime.device.createBuffer({
-          size: requestedBytes,
-          usage: (uniformFallback ? GPU_BUFFER_USAGE_UNIFORM : GPU_BUFFER_USAGE_STORAGE) | GPU_BUFFER_USAGE_COPY_DST,
-          mappedAtCreation: false
-        });
-        if (!bufRes.ok) {
-          runtime.errorRegistry.fire(bufRes.error);
-        } else {
-          if (cachedSpriteInst !== void 0 && !cachedSpriteInst.buffer.isDestroyed) {
-            const r = cachedSpriteInst.buffer.destroy();
-            if (!r.ok) runtime.errorRegistry.fire(r.error);
-          }
-          const newBuf = new GpuBuffer(runtime.device, bufRes.value);
-          activeSpriteInst = {
-            buffer: newBuf,
-            uploadedArchVersion: spriteInstancesSnap.archVersion,
-            uploadedByteLength: requestedBytes
-          };
-          frameState.instanceBuffers.set(
-            worldEntityKey(spriteEntry.source.worldId, spriteInstancesSnap.cacheKey),
-            activeSpriteInst
-          );
-        }
-      }
-      if (activeSpriteInst !== null && requestedBytes > 0) {
-        const writeRes = runtime.device.queue.writeBuffer(
-          activeSpriteInst.buffer.handle,
-          0,
-          interleaved
-        );
-        if (!writeRes.ok) {
-          runtime.errorRegistry.fire(writeRes.error);
+              detail: {
+                maxStorageBufferBindingSize: cap,
+                requestedBytes
+              }
+            })
+          );
         } else {
-          buffer = activeSpriteInst.buffer.handle;
-          count = spriteInstancesSnap.instanceCount;
+          const cachedSprite = frameState.instanceBuffers.get(
+            worldEntityKey(spriteEntry.source.worldId, spriteInst.cacheKey)
+          );
+          let activeSprite = null;
+          if (cachedSprite !== void 0 && cachedSprite.uploadedArchVersion === spriteInst.archVersion && cachedSprite.uploadedByteLength === requestedBytes) {
+            activeSprite = cachedSprite;
+          } else if (requestedBytes > 0) {
+            const bufRes = runtime.device.createBuffer({
+              size: requestedBytes,
+              usage: spriteBufUsage,
+              mappedAtCreation: false
+            });
+            if (!bufRes.ok) {
+              runtime.errorRegistry.fire(bufRes.error);
+            } else {
+              if (cachedSprite !== void 0 && !cachedSprite.buffer.isDestroyed) {
+                const r = cachedSprite.buffer.destroy();
+                if (!r.ok) runtime.errorRegistry.fire(r.error);
+              }
+              const newBuf = new GpuBuffer(runtime.device, bufRes.value);
+              activeSprite = {
+                buffer: newBuf,
+                uploadedArchVersion: spriteInst.archVersion,
+                uploadedByteLength: requestedBytes
+              };
+              frameState.instanceBuffers.set(
+                worldEntityKey(spriteEntry.source.worldId, spriteInst.cacheKey),
+                activeSprite
+              );
+            }
+          }
+          if (activeSprite !== null) {
+            const writeRes = runtime.device.queue.writeBuffer(
+              activeSprite.buffer.handle,
+              0,
+              instancePayload
+            );
+            if (!writeRes.ok) {
+              runtime.errorRegistry.fire(writeRes.error);
+            } else {
+              spriteInstanceBuffer = activeSprite.buffer.handle;
+              spriteInstanceCount = Math.max(1, spriteInst.instanceCount);
+            }
+          }
         }
       }
     }
+    const _si = resolveSpriteInstancesBuffer(
+      c,
+      spriteEntry,
+      spriteInstanceBuffer,
+      spriteInstanceCount
+    );
+    spriteInstanceBuffer = _si.buffer;
+    spriteInstanceCount = _si.count;
+    const spriteGroup2 = entityShaderId === "forgeax::sprite-lit" && c.standardLighting?.kind === "clustered" ? c.hdrpClusterBindGroup : meshBindGroup;
+    const spriteInstancesBg = resolveGeometryInstancesBindGroup(c, spriteInstanceBuffer, void 0);
+    spritePass.setBindGroup(2, spriteGroup2, [i * MESH_PER_ENTITY_STRIDE]);
+    const materialSlot = materialSlotIndices[i]?.[0] ?? 0;
+    const spritePassBg = resolveMaterialBindGroup(
+      materialSlot,
+      spriteEntry.source.material,
+      spriteEntry.source.entityKey,
+      spriteEntry.world ?? world
+    );
+    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, 0);
   }
-  return { buffer, count };
 }
 function transparentPassColorFormat(c, pipelineState = c.pipelineState) {
   if (c.transparentColorFormat !== void 0) return c.transparentColorFormat;
@@ -7668,6 +7948,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);
@@ -7766,7 +8069,8 @@ function eligibleDraws(slot) {
           materialResourceClass: draw.materialResourceClass,
           preparedIdentity,
           resourceIdentity: draw.materialResourceClass,
-          admission
+          admission,
+          materialPass: material.deferredPass === true ? "deferred" : "forward-only"
         },
         prepared,
         ...candidatePayload(draw, snapshot)
@@ -8034,6 +8338,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,
@@ -8045,7 +8350,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) {
@@ -8131,6 +8439,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() {
@@ -8482,6 +9194,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";
 }
@@ -8598,7 +9311,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; }
@@ -8683,9 +9396,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,
   );
 }
 
@@ -8708,10 +9423,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;
 }
 `
@@ -8773,6 +9500,8 @@ 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. */
@@ -9013,7 +9742,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() {
@@ -9058,6 +9788,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;
@@ -9066,6 +9797,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);
@@ -9079,7 +9830,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
@@ -9121,6 +9881,9 @@ var GpuDrivenView = class _GpuDrivenView {
         ),
         geometryWork,
         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;
@@ -9129,7 +9892,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;
@@ -9209,14 +9972,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;
@@ -9282,9 +10045,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 }) => {
@@ -9295,12 +10062,32 @@ 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,
+            indirectBufferIdentity,
+            indirectReadbackOffset,
+            ...submittedObservation === void 0 ? {} : {
+              surfaceReadbackSnapshot: () => submittedObservation.gpuReadbackSnapshot()
+            },
             ...this.telemetrySubmit === void 0 ? {} : { submit: this.telemetrySubmit }
           };
         }
@@ -9336,6 +10123,7 @@ var GpuDrivenView = class _GpuDrivenView {
     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;
   }
@@ -9372,6 +10160,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}`,
@@ -9381,6 +10170,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;
@@ -9404,7 +10196,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,
@@ -9413,7 +10205,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
       }
@@ -9439,10 +10231,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;
@@ -9459,11 +10255,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
@@ -9891,6 +10695,7 @@ function ensureTypedShadowViewBg(c, viewOffset, cascadeOffset, variant) {
     );
   }
   const projectorAvailable = pipelineState.projectorAvailable !== false;
+  const lowLimitCloudBindings = !extendedLighting && !projectorAvailable;
   try {
     return getOrCreateFromChain(
       frameState.viewBindGroupCache,
@@ -9903,7 +10708,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,
       () => {
@@ -9979,7 +10785,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;
@@ -10358,6 +11180,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,
@@ -11192,7 +12015,6 @@ function ensureSpotShadowMaterialBg(c) {
       prefilterView: fb.prefilterView,
       prefilterSampler: fb.sampler,
       brdfLutView: fb.brdfLutView,
-      brdfLutSampler: fb.sampler,
       intensityBuffer: fb.intensityBuffer
     },
     transmissionBackdropAvailable(runtime.device.limits.maxSampledTexturesPerShaderStage) ? void 0 : null
@@ -11246,7 +12068,6 @@ function ensureGpuDrivenAlphaMaskMaterialBg(c, projection) {
     prefilterView: fallback.prefilterView,
     prefilterSampler: fallback.sampler,
     brdfLutView: fallback.brdfLutView,
-    brdfLutSampler: fallback.sampler,
     intensityBuffer: fallback.intensityBuffer
   };
   const deps = {
@@ -11272,7 +12093,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({
@@ -11295,7 +12119,6 @@ function ensureGpuDrivenCustomShadowMaterialBg(c, projection) {
     prefilterView: fallback.prefilterView,
     prefilterSampler: fallback.sampler,
     brdfLutView: fallback.brdfLutView,
-    brdfLutSampler: fallback.sampler,
     intensityBuffer: fallback.intensityBuffer
   };
   const deps = {
@@ -11334,18 +12157,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;
@@ -11388,11 +12216,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];
@@ -11404,12 +12235,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,
@@ -11420,6 +12248,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;
@@ -11500,7 +12380,7 @@ function recordMainPass(c, selector, options, graphPass) {
           identities: [
             getOpaqueResourceIdentity(skylightResources.irradianceSampler),
             getOpaqueResourceIdentity(skylightResources.prefilterSampler),
-            getOpaqueResourceIdentity(skylightResources.brdfLutSampler)
+            getOpaqueResourceIdentity(skylightResources.irradianceSampler)
           ]
         },
         resources: {
@@ -11520,7 +12400,9 @@ function recordMainPass(c, selector, options, graphPass) {
           },
           brdfLut: {
             viewIdentity: getOpaqueResourceIdentity(skylightResources.brdfLutView),
-            samplerIdentity: getOpaqueResourceIdentity(skylightResources.brdfLutSampler),
+            samplerIdentity: getOpaqueResourceIdentity(
+              skylightResources.irradianceSampler
+            ),
             deviceGeneration: runtime.deviceScope.generation
           },
           intensityBufferIdentity: getOpaqueResourceIdentity(
@@ -11565,7 +12447,6 @@ function recordMainPass(c, selector, options, graphPass) {
           skylightPrefilterView: skylightResources.prefilterView,
           prefilterSampler: row.sampler,
           brdfLutView: skylightResources.brdfLutView,
-          brdfLutSampler: skylightResources.brdfLutSampler,
           intensityBuffer: row.uniformBuffer
         };
         return { resources: probeResources, probeIndex: row.index };
@@ -11577,7 +12458,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,
@@ -11590,6 +12474,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(
@@ -11660,7 +12545,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) {
@@ -11680,7 +12568,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",
@@ -11691,7 +12579,9 @@ function recordMainPass(c, selector, options, graphPass) {
         viewBindGroup,
         pass,
         options.gpuDriven.resources,
-        gpuDrivenStandardPbrFrameResources
+        gpuDrivenStandardPbrFrameResources,
+        options.gpuDrivenFilter,
+        options?.fragmentEntryPoint
       );
     }
     if (passKind === "forward" && recordMode === void 0) {
@@ -12049,7 +12939,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) {
@@ -12096,7 +12986,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, {
@@ -12115,7 +13005,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();
@@ -12146,8 +13048,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({
@@ -12157,7 +13059,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) {
@@ -12191,7 +13095,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"
@@ -12205,6 +13112,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);
@@ -12219,6 +13134,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,
@@ -12229,7 +13147,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 } }
   ];
@@ -12249,6 +13167,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,
@@ -12540,7 +13464,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;
@@ -12733,6 +13663,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,
@@ -12756,8 +13691,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,
@@ -12808,6 +13750,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,
@@ -12842,16 +13837,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;
 }
@@ -13135,7 +14131,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"
@@ -13177,8 +14177,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(
@@ -13190,6 +14194,7 @@ function addTypedScenePass(graph, options) {
         {
           directionalShadow,
           spotShadow,
+          cloudShadow,
           projector: internal.spotLightProjector?.view ?? internal.volumetricFog?.projectorView,
           projectorSampler: internal.spotLightProjector?.sampler ?? internal.volumetricFog?.projectorSampler
         },
@@ -13225,11 +14230,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;
@@ -13772,6 +14783,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;
@@ -13797,6 +14813,6 @@ function addTaaResolvePass(graph, current, currentTemporal, previousColor, previ
   });
 }
 
-export { BLOOM_COMPOSITE_PARAMS_BYTES, BLOOM_DOWNSAMPLE_PARAMS_BYTES, BLOOM_UPSAMPLE_PARAMS_BYTES, 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, DEPTH_TEXTURE_FORMAT, FALLBACK_BYTES_PER_ROW, GPU_DRIVEN_VIEW_WGSL, GPU_SCENE_LAYOUTS, GpuBuffer, GpuDrivenView, GpuTexture, HDR_COLOR_ATTACHMENT_FORMAT, MATERIAL_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, 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, 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, standardBloomAdmitted, standardStorageVariantSet, standardTemporalLaneAdmission, standardTemporalPostOrder, standardTopologyVariantSet, temporalReadIndex, temporalWriteIndex, transmissionBackdropAvailable, uploadMeshSsboBatch, variantSetFromDefines, variantSetFromVertexLayoutProjection, warnMultiSkybox, warnMultiSkylight, warnZeroLightStandard, writeHdrpClusterAndSsaoBuffers, writePbrMaterialUboPayload, writePointsLinesViewUbo, writeShadowCasterUniforms, writeShadowParamsBuffer, writeSpotModifierTextures, writeViewUbo };
-//# sourceMappingURL=chunk-VOZWDM3L.mjs.map
-//# sourceMappingURL=chunk-VOZWDM3L.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, 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, 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, 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, retireTemporalGpuState, retireTemporalGpuStateAfterFence, runIblPrecompute, selectGpuDrivenSceneIndexVariant, selectGpuLodLane, selectHdrpPbrPrewarmVariants, selectLazyEquirectHandle, selectLod, selectProbePrewarmVariants, selectSkinPrewarmVariants, selectStandardPbrTransmissionPrewarmVariants, 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-LNIUIKQ7.mjs.map
+//# sourceMappingURL=chunk-LNIUIKQ7.mjs.map