@forgeax/engine-render 0.1.23 → 0.1.25

package/dist/{chunk-ZUWKAZ2I.mjs → chunk-TCLDX7SZ.mjs}

@@ -1,15 +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-YALPS44A.mjs';
-import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-4NPUASZR.mjs';
-import { GPU_SHADER_STAGE_COMPUTE, GPU_BUFFER_USAGE_STORAGE, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM, createHdrpBindGroupLayoutDescriptor, 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, pbrSkinMeshDynamicOffsets, worldEntityKey, buildPbrMaterialUserRegionEntries, buildBindGroupLayoutDescriptor, isStandardPbrMaterialShader, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, COOKIE_MATRIX_BYTES, matchPass, createPbrSkinMeshBindGroupEntries, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, SKIN_MATERIAL_SHADER_ID, PROBE_BLEND_RECORD_BYTE_SIZE, resolveRenderTargetMaterialSource, probeBlendRecordOffset, PROBE_BLEND_RECORD_STRIDE } from './chunk-HZUPSYW7.mjs';
-import { GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GPU_TEXTURE_USAGE_COPY_SRC, 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, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, StandardLightBudgetExceededError, RendererOperationError, StandardClusterIndexOverflowError, FXAA_POST_PROCESS_ID, VideoUploadUnsupportedError, VertexColorVariantConflictError } from './chunk-QODA5UKU.mjs';
-import { ok, err as err$1, toShared, ASSET_ERROR_HINTS, deriveTextureLayout, KNOWN_PASS_KINDS, derive, resolveMaterialTextureCoordinates, handleSlot } from '@forgeax/engine-types';
+import { DEFAULT_CLUSTER_GRID, DEFAULT_STANDARD_PROFILE, createIblKernelCache, MAX_LIGHTS, CLUSTER_GRID_STRIDE_U32, LIGHT_INDEX_LIST_CAPACITY, createStandardClusterLayout } from './chunk-E34VL5VI.mjs';
+import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-JSEDTZYS.mjs';
+import { GPU_SHADER_STAGE_COMPUTE, GPU_BUFFER_USAGE_STORAGE, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM, createHdrpBindGroupLayoutDescriptor, 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, worldEntityKey, instanceCollectionCacheKey, probeBlendRecordOffset, PROBE_BLEND_RECORD_STRIDE, pbrSkinMeshDynamicOffsets, buildPbrMaterialUserRegionEntries, buildBindGroupLayoutDescriptor, isStandardPbrMaterialShader, PROBE_BLEND_RECORD_BYTE_SIZE, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, COOKIE_MATRIX_BYTES, matchPass, createPbrSkinMeshBindGroupEntries, getOpaqueResourceIdentity, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, physicalTextureFields, isCanonicalStandardPbrMaterialShader, isStandardPbrSkinMaterialShader, SKIN_MATERIAL_SHADER_ID, resolveRenderTargetMaterialSource, materialBindGroupLayoutIdentity } from './chunk-HKXTW355.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, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, StandardLightBudgetExceededError, RendererOperationError, StandardClusterIndexOverflowError, FXAA_POST_PROCESS_ID, VideoUploadUnsupportedError } from './chunk-ZZ4YQ474.mjs';
+import { derive, ok, err as err$1, toShared, ASSET_ERROR_HINTS, deriveTextureLayout, handleSlot, KNOWN_PASS_KINDS, resolveMaterialTextureCoordinates } from '@forgeax/engine-types';
 import { ok as ok$1, err, RhiError } from '@forgeax/engine-rhi';
 import { mat3, vec3, mat4 } from '@forgeax/engine-math';
-import { deriveVertexLayoutProjection, deriveVertexBufferLayout } from '@forgeax/engine-geometry';
+import { deriveVertexLayoutProjection, 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, DEFAULT_MSDF_TEXT_PARAM_SCHEMA, DEFAULT_SPRITE_PARAM_SCHEMA, DEFAULT_UNLIT_PARAM_SCHEMA } from '@forgeax/engine-shader';
+import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA, STANDARD_PIPELINE_PARAM_SCHEMA, DEFAULT_MSDF_TEXT_PARAM_SCHEMA, DEFAULT_SPRITE_PARAM_SCHEMA, DEFAULT_UNLIT_PARAM_SCHEMA } from '@forgeax/engine-shader';
 import { isCompressedFormat, bytesPerRow, blockParamsForFormat } from '@forgeax/engine-codec';
 
 function resolveOutputDither(config) {
@@ -283,18 +283,9 @@ function buildPipelineDescriptor(spec, modules) {
   const { attachments, geometry, renderState } = spec;
   const vertexBuffers = geometry.vertexLayoutProjection === void 0 ? deriveVertexBufferLayout(geometry.vertexLayout, {
     ...geometry.shaderUvSetCount !== void 0 ? { shaderUvSetCount: geometry.shaderUvSetCount } : {}
-  }) : geometry.vertexLayoutProjection.attributes.length === 0 ? [] : [
-    {
-      arrayStride: geometry.vertexLayoutProjection.arrayStride,
-      attributes: geometry.vertexLayoutProjection.attributes.map(
-        ({ shaderLocation, offset, format }) => ({
-          shaderLocation,
-          offset,
-          format
-        })
-      )
-    }
-  ];
+  }) : deriveVertexBufferLayoutFromProjection(geometry.vertexLayoutProjection, {
+    ...geometry.shaderUvSetCount !== void 0 ? { shaderUvSetCount: geometry.shaderUvSetCount } : {}
+  });
   const descriptor = {
     vertex: {
       module: modules.vertex,
@@ -839,10 +830,10 @@ function extractEntryResourceHandle(entry) {
   }
   return v;
 }
+var BIND_GROUP_CHAIN_LEAF_KEY = {};
 function getOrCreateFromChain(root, handles, variant, factory, counts) {
   let node = root;
-  for (let i = 0; i < handles.length - 1; i++) {
-    const h = handles[i];
+  for (const h of handles) {
     let next = node.get(h);
     if (next === void 0) {
       next = /* @__PURE__ */ new WeakMap();
@@ -850,11 +841,10 @@ function getOrCreateFromChain(root, handles, variant, factory, counts) {
     }
     node = next;
   }
-  const last = handles[handles.length - 1];
-  let leaf = node.get(last);
+  let leaf = node.get(BIND_GROUP_CHAIN_LEAF_KEY);
   if (leaf === void 0) {
     leaf = /* @__PURE__ */ new Map();
-    node.set(last, leaf);
+    node.set(BIND_GROUP_CHAIN_LEAF_KEY, leaf);
   }
   const hit = leaf.get(variant);
   if (hit !== void 0) return hit;
@@ -2260,8 +2250,8 @@ function computeProjectionMatrix(camera) {
       proj,
       camera.orthoLeft,
       camera.orthoRight,
-      camera.orthoBottom,
       camera.orthoTop,
+      camera.orthoBottom,
       camera.near,
       camera.far
     );
@@ -2355,9 +2345,9 @@ function writeViewUbo(queue, viewUniformBuffer, camera, light, lights, spotShado
   const VIEW_PAYLOAD_FLOATS = 240;
   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) * light.intensity;
-  viewPayload[17] = (light.direction[1] ?? -1) * light.intensity;
-  viewPayload[18] = (light.direction[2] ?? 0) * light.intensity;
+  viewPayload[16] = light.direction[0] ?? 0;
+  viewPayload[17] = light.direction[1] ?? -1;
+  viewPayload[18] = light.direction[2] ?? 0;
   viewPayload[20] = light.color[0] ?? 0;
   viewPayload[21] = light.color[1] ?? 0;
   viewPayload[22] = light.color[2] ?? 0;
@@ -3607,10 +3597,15 @@ function iblPipelineError(stage, code, cause) {
     detail: { stage, ...{}  }
   };
 }
-function runIblPrecompute(opts) {
+async function runIblPrecompute(opts) {
   const { device, scope } = opts;
   const cache3 = getOrCreateIblCache(scope);
   const outputFormat = cache3.outputFormat ?? "rgba16float";
+  const generation = scope.generation;
+  const candidate = {};
+  const fail = (stage, cause) => {
+    return Promise.resolve(err(badAlloc(stage, cause)));
+  };
   if (cache3.equirectToCubePipeline === void 0 || cache3.irradiancePipeline === void 0 || cache3.prefilterPipeline === void 0 || cache3.brdfLutPipeline === void 0) {
     return err({
       code: "ibl-precompute-not-dispatched",
@@ -3619,7 +3614,7 @@ function runIblPrecompute(opts) {
       detail: { stage: "pipeline-cache" }
     });
   }
-  if (cache3.irradianceTexture === void 0) {
+  {
     const textureResult = device.createTexture({
       label: "ibl-irradiance-cube",
       size: { width: IRRADIANCE_SIZE, height: IRRADIANCE_SIZE, depthOrArrayLayers: 6 },
@@ -3631,15 +3626,15 @@ function runIblPrecompute(opts) {
       viewFormats: [],
       textureBindingViewDimension: void 0
     });
-    if (!textureResult.ok) return err(badAlloc("irradiance-texture", textureResult.error));
-    cache3.irradianceTexture = textureResult.value;
+    if (!textureResult.ok) return fail("irradiance-texture", textureResult.error);
+    candidate.irradianceTexture = adoptIblTexture(scope, device, textureResult.value);
     const cubeViewResult = device.createTextureView(textureResult.value, {
       label: "ibl-irradiance-cube-view",
       dimension: "cube",
       arrayLayerCount: 6
     });
-    if (!cubeViewResult.ok) return err(badAlloc("irradiance-view", cubeViewResult.error));
-    cache3.irradianceView = cubeViewResult.value;
+    if (!cubeViewResult.ok) return fail("irradiance-view", cubeViewResult.error);
+    candidate.irradianceView = cubeViewResult.value;
     const faceViews = [];
     for (let f = 0; f < 6; f++) {
       const viewResult = device.createTextureView(textureResult.value, {
@@ -3648,12 +3643,12 @@ function runIblPrecompute(opts) {
         baseArrayLayer: f,
         arrayLayerCount: 1
       });
-      if (!viewResult.ok) return err(badAlloc("irradiance-face-view", viewResult.error));
+      if (!viewResult.ok) return fail("irradiance-face-view", viewResult.error);
       faceViews.push(viewResult.value);
     }
-    cache3.irradianceFaceViews = faceViews;
+    candidate.irradianceFaceViews = faceViews;
   }
-  if (cache3.prefilterTexture === void 0) {
+  {
     const textureResult = device.createTexture({
       label: "ibl-prefilter-cube",
       size: { width: PREFILTER_SIZE, height: PREFILTER_SIZE, depthOrArrayLayers: 6 },
@@ -3665,8 +3660,8 @@ function runIblPrecompute(opts) {
       viewFormats: [],
       textureBindingViewDimension: void 0
     });
-    if (!textureResult.ok) return err(badAlloc("prefilter-texture", textureResult.error));
-    cache3.prefilterTexture = textureResult.value;
+    if (!textureResult.ok) return fail("prefilter-texture", textureResult.error);
+    candidate.prefilterTexture = adoptIblTexture(scope, device, textureResult.value);
     const cubeViewResult = device.createTextureView(textureResult.value, {
       label: "ibl-prefilter-cube-view",
       dimension: "cube",
@@ -3674,8 +3669,8 @@ function runIblPrecompute(opts) {
       baseMipLevel: 0,
       mipLevelCount: PREFILTER_MIP_LEVELS
     });
-    if (!cubeViewResult.ok) return err(badAlloc("prefilter-view", cubeViewResult.error));
-    cache3.prefilterView = cubeViewResult.value;
+    if (!cubeViewResult.ok) return fail("prefilter-view", cubeViewResult.error);
+    candidate.prefilterView = cubeViewResult.value;
     const mipViews = [];
     for (let m = 0; m < PREFILTER_MIP_LEVELS; m++) {
       const faces = [];
@@ -3688,14 +3683,14 @@ function runIblPrecompute(opts) {
           baseArrayLayer: f,
           arrayLayerCount: 1
         });
-        if (!viewResult.ok) return err(badAlloc("prefilter-face-view", viewResult.error));
+        if (!viewResult.ok) return fail("prefilter-face-view", viewResult.error);
         faces.push(viewResult.value);
       }
       mipViews.push(faces);
     }
-    cache3.prefilterFaceViewsByMip = mipViews;
+    candidate.prefilterFaceViewsByMip = mipViews;
   }
-  if (cache3.brdfLutTexture === void 0) {
+  {
     const textureResult = device.createTexture({
       label: "ibl-brdf-lut",
       size: { width: BRDF_LUT_SIZE, height: BRDF_LUT_SIZE, depthOrArrayLayers: 1 },
@@ -3707,14 +3702,14 @@ function runIblPrecompute(opts) {
       viewFormats: [],
       textureBindingViewDimension: void 0
     });
-    if (!textureResult.ok) return err(badAlloc("brdf-lut-texture", textureResult.error));
-    cache3.brdfLutTexture = textureResult.value;
+    if (!textureResult.ok) return fail("brdf-lut-texture", textureResult.error);
+    candidate.brdfLutTexture = adoptIblTexture(scope, device, textureResult.value);
     const viewResult = device.createTextureView(textureResult.value, {
       label: "ibl-brdf-lut-view",
       dimension: "2d"
     });
-    if (!viewResult.ok) return err(badAlloc("brdf-lut-view", viewResult.error));
-    cache3.brdfLutView = viewResult.value;
+    if (!viewResult.ok) return fail("brdf-lut-view", viewResult.error);
+    candidate.brdfLutView = viewResult.value;
   }
   const samplerResult = device.createSampler({
     label: "ibl-precompute-sampler",
@@ -3725,11 +3720,33 @@ function runIblPrecompute(opts) {
     addressModeV: "clamp-to-edge",
     addressModeW: "clamp-to-edge"
   });
-  if (!samplerResult.ok) return err(badAlloc("sampler", samplerResult.error));
+  if (!samplerResult.ok) return fail("sampler", samplerResult.error);
   const sampler = samplerResult.value;
-  const encoderResult = device.createCommandEncoder({ label: "ibl-precompute-encoder" });
-  if (!encoderResult.ok) return err(badAlloc("encoder", encoderResult.error));
-  const encoder = encoderResult.value;
+  let encoderResult = device.createCommandEncoder({
+    label: "ibl-precompute-encoder-equirect-to-cube"
+  });
+  if (!encoderResult.ok) return fail("encoder-equirect-to-cube", encoderResult.error);
+  let encoder = encoderResult.value;
+  const submitStage = async (stage, createNextEncoder) => {
+    const finishRes = encoder.finish();
+    if (!finishRes.ok) return err(badAlloc(`${stage}-finish`, finishRes.error));
+    const submitRes = device.queue.submit([finishRes.value]);
+    if (!submitRes.ok) return err(badAlloc(`${stage}-submit`, submitRes.error));
+    try {
+      await device.queue.onSubmittedWorkDone();
+    } catch {
+      return err(badAlloc(`${stage}-fence`));
+    }
+    if (!scope.isAlive() || scope.generation !== generation) {
+      return err(badAlloc(`${stage}-device-scope-generation`));
+    }
+    if (createNextEncoder) {
+      encoderResult = device.createCommandEncoder({ label: `ibl-precompute-encoder-${stage}` });
+      if (!encoderResult.ok) return err(badAlloc(`${stage}-next-encoder`, encoderResult.error));
+      encoder = encoderResult.value;
+    }
+    return ok$1(true);
+  };
   const faceUniformsBgl = cache3.faceUniformsBgl;
   const equirectGroup1Bgl = cache3.equirectGroup1Bgl;
   const cubeGroup1Bgl = cache3.cubeGroup1Bgl;
@@ -3738,11 +3755,16 @@ function runIblPrecompute(opts) {
   const irradiancePipeline = cache3.irradiancePipeline;
   const prefilterPipeline = cache3.prefilterPipeline;
   const brdfLutPipeline = cache3.brdfLutPipeline;
-  const irrFaceViews = cache3.irradianceFaceViews;
-  const prefMipViews = cache3.prefilterFaceViewsByMip;
-  const brdfLutView = cache3.brdfLutView;
-  if (faceUniformsBgl === void 0 || equirectGroup1Bgl === void 0 || cubeGroup1Bgl === void 0 || prefilterGroup0Bgl === void 0 || equirectPipeline === void 0 || irradiancePipeline === void 0 || prefilterPipeline === void 0 || brdfLutPipeline === void 0 || irrFaceViews === void 0 || prefMipViews === void 0 || brdfLutView === void 0) {
-    return err(badAlloc("ibl-cache-resources"));
+  const candidateIrradianceTexture = candidate.irradianceTexture;
+  const candidateIrradianceView = candidate.irradianceView;
+  const irrFaceViews = candidate.irradianceFaceViews;
+  const candidatePrefilterTexture = candidate.prefilterTexture;
+  const candidatePrefilterView = candidate.prefilterView;
+  const prefMipViews = candidate.prefilterFaceViewsByMip;
+  const candidateBrdfLutTexture = candidate.brdfLutTexture;
+  const brdfLutView = candidate.brdfLutView;
+  if (faceUniformsBgl === void 0 || equirectGroup1Bgl === void 0 || cubeGroup1Bgl === void 0 || prefilterGroup0Bgl === void 0 || equirectPipeline === void 0 || irradiancePipeline === void 0 || prefilterPipeline === void 0 || brdfLutPipeline === void 0 || candidateIrradianceTexture === void 0 || candidateIrradianceView === void 0 || irrFaceViews === void 0 || candidatePrefilterTexture === void 0 || candidatePrefilterView === void 0 || prefMipViews === void 0 || candidateBrdfLutTexture === void 0 || brdfLutView === void 0) {
+    return fail("ibl-cache-resources");
   }
   const equirectBgResult = device.createBindGroup({
     label: "ibl-equirect-bg",
@@ -3752,7 +3774,7 @@ function runIblPrecompute(opts) {
       { binding: 1, resource: { kind: "sampler", value: sampler } }
     ]
   });
-  if (!equirectBgResult.ok) return err(badAlloc("equirect-bg", equirectBgResult.error));
+  if (!equirectBgResult.ok) return fail("equirect-bg", equirectBgResult.error);
   const equirectBg = equirectBgResult.value;
   const cubeBgResult = device.createBindGroup({
     label: "ibl-cube-bg",
@@ -3762,12 +3784,12 @@ function runIblPrecompute(opts) {
       { binding: 1, resource: { kind: "sampler", value: sampler } }
     ]
   });
-  if (!cubeBgResult.ok) return err(badAlloc("cube-bg", cubeBgResult.error));
+  if (!cubeBgResult.ok) return fail("cube-bg", cubeBgResult.error);
   const cubeBg = cubeBgResult.value;
   const cubeFaceViews = opts.cubeFaceViews;
   for (let face = 0; face < 6; face++) {
     const cubeFaceView = cubeFaceViews[face];
-    if (cubeFaceView === void 0) return err(badAlloc("cube-face-view"));
+    if (cubeFaceView === void 0) return fail("cube-face-view");
     const pass = encoder.beginRenderPass({
       label: "ibl-equirect-to-cube",
       colorAttachments: [
@@ -3796,7 +3818,7 @@ function runIblPrecompute(opts) {
         }
       ]
     });
-    if (!faceBgResult.ok) return err(badAlloc("face-bg", faceBgResult.error));
+    if (!faceBgResult.ok) return fail("face-bg", faceBgResult.error);
     pass.setPipeline(equirectPipeline);
     pass.setBindGroup(0, faceBgResult.value);
     pass.setBindGroup(1, equirectBg);
@@ -3804,9 +3826,11 @@ function runIblPrecompute(opts) {
     pass.draw(6, 1, face * 6, 0);
     pass.end();
   }
+  const cubeStage = await submitStage("equirect-to-cube", true);
+  if (!cubeStage.ok) return err(cubeStage.error);
   for (let face = 0; face < 6; face++) {
     const irrFaceView = irrFaceViews[face];
-    if (irrFaceView === void 0) return err(badAlloc("irradiance-face-view"));
+    if (irrFaceView === void 0) return fail("irradiance-face-view");
     const pass = encoder.beginRenderPass({
       label: "ibl-irradiance",
       colorAttachments: [
@@ -3835,21 +3859,23 @@ function runIblPrecompute(opts) {
         }
       ]
     });
-    if (!faceBgResult.ok) return err(badAlloc("irr-face-bg", faceBgResult.error));
+    if (!faceBgResult.ok) return fail("irr-face-bg", faceBgResult.error);
     pass.setPipeline(irradiancePipeline);
     pass.setBindGroup(0, faceBgResult.value);
     pass.setBindGroup(1, cubeBg);
     pass.setVertexBuffer(0, opts.cubeVertexBuffer);
     pass.draw(6, 1, face * 6, 0);
     pass.end();
+    const irradianceFaceStage = await submitStage(`irradiance-face-${face}`, true);
+    if (!irradianceFaceStage.ok) return err(irradianceFaceStage.error);
   }
   for (let mip = 0; mip < PREFILTER_MIP_LEVELS; mip++) {
     const mipFaceViews = prefMipViews[mip];
-    if (mipFaceViews === void 0) return err(badAlloc("prefilter-mip-views"));
+    if (mipFaceViews === void 0) return fail("prefilter-mip-views");
     for (let face = 0; face < 6; face++) {
       const subIdx = mip * 6 + face;
       const mipFaceView = mipFaceViews[face];
-      if (mipFaceView === void 0) return err(badAlloc("prefilter-face-view"));
+      if (mipFaceView === void 0) return fail("prefilter-face-view");
       const pass = encoder.beginRenderPass({
         label: "ibl-prefilter",
         colorAttachments: [
@@ -3889,7 +3915,7 @@ function runIblPrecompute(opts) {
           }
         ]
       });
-      if (!bgResult.ok) return err(badAlloc("pref-bg", bgResult.error));
+      if (!bgResult.ok) return fail("pref-bg", bgResult.error);
       pass.setPipeline(prefilterPipeline);
       pass.setBindGroup(0, bgResult.value);
       pass.setBindGroup(1, cubeBg);
@@ -3898,6 +3924,8 @@ function runIblPrecompute(opts) {
       pass.end();
     }
   }
+  const prefilterStage = await submitStage("prefilter", true);
+  if (!prefilterStage.ok) return err(prefilterStage.error);
   {
     const pass = encoder.beginRenderPass({
       label: "ibl-brdf-lut",
@@ -3914,16 +3942,37 @@ function runIblPrecompute(opts) {
     pass.draw(3, 1, 0, 0);
     pass.end();
   }
-  const finishRes = encoder.finish();
-  if (!finishRes.ok) return err(badAlloc("finish", finishRes.error));
-  const cmdBuffer = finishRes.value;
-  const submitRes = device.queue.submit([cmdBuffer]);
-  if (!submitRes.ok) return err(badAlloc("queue.submit", submitRes.error));
+  const brdfStage = await submitStage("brdf-lut", false);
+  if (!brdfStage.ok) return err(brdfStage.error);
+  const promoted = {
+    irradianceTexture: candidateIrradianceTexture,
+    irradianceView: candidateIrradianceView,
+    irradianceFaceViews: irrFaceViews,
+    prefilterTexture: candidatePrefilterTexture,
+    prefilterView: candidatePrefilterView,
+    prefilterFaceViewsByMip: prefMipViews,
+    brdfLutTexture: candidateBrdfLutTexture,
+    brdfLutView
+  };
+  cache3.irradianceTexture = promoted.irradianceTexture;
+  cache3.irradianceView = promoted.irradianceView;
+  cache3.irradianceFaceViews = promoted.irradianceFaceViews;
+  cache3.prefilterTexture = promoted.prefilterTexture;
+  cache3.prefilterView = promoted.prefilterView;
+  cache3.prefilterFaceViewsByMip = promoted.prefilterFaceViewsByMip;
+  cache3.brdfLutTexture = promoted.brdfLutTexture;
+  cache3.brdfLutView = promoted.brdfLutView;
   cache3.irradianceBakeCount += 1;
   cache3.prefilterBakeCount += 1;
   cache3.brdfLutBakeCount += 1;
   return ok$1({ submitted: true });
 }
+function adoptIblTexture(scope, device, texture) {
+  scope._adopt("texture", texture, (value) => {
+    device.destroyTexture(value);
+  });
+  return texture;
+}
 function badAlloc(stage, cause) {
   return {
     code: "ibl-precompute-not-dispatched",
@@ -4033,9 +4082,153 @@ var GpuTexture = class {
   }
 };
 
+// src/instances.ts
+var MATRIX_STRIDE = 16;
+function appendRange(ranges, start, end) {
+  if (start >= end) return;
+  let index = 0;
+  while (index < ranges.length) {
+    const existing = ranges[index];
+    if (existing === void 0 || existing.end >= start) break;
+    index += 1;
+  }
+  while (index < ranges.length) {
+    const existing = ranges[index];
+    if (existing === void 0 || existing.start > end) break;
+    start = Math.min(start, existing.start);
+    end = Math.max(end, existing.end);
+    ranges.splice(index, 1);
+  }
+  ranges.splice(index, 0, { start, end });
+}
+var InstanceProjectionStore = class {
+  nextId = 1;
+  identities = /* @__PURE__ */ new WeakMap();
+  records = /* @__PURE__ */ new Map();
+  project(world, entity, transforms) {
+    let entities = this.identities.get(world);
+    if (entities === void 0) {
+      entities = /* @__PURE__ */ new Map();
+      this.identities.set(world, entities);
+    }
+    let collectionId = entities.get(entity);
+    if (collectionId === void 0) {
+      collectionId = this.nextId++;
+      entities.set(entity, collectionId);
+    }
+    const previous = this.records.get(collectionId);
+    const unchanged = previous !== void 0 && previous.transforms.length === transforms.length && previous.transforms.every((value, index) => Object.is(value, transforms[index]));
+    const record = unchanged ? previous : {
+      collectionId,
+      world,
+      entity,
+      transforms: new Float32Array(transforms),
+      count: transforms.length / MATRIX_STRIDE,
+      revision: (previous?.revision ?? 0) + 1
+    };
+    this.records.set(collectionId, record);
+    return { ...this.info(record), transforms: record.transforms };
+  }
+  retain(ids) {
+    for (const [id, record] of this.records) {
+      if (ids.has(id)) continue;
+      this.identities.get(record.world)?.delete(record.entity);
+      this.records.delete(id);
+    }
+  }
+  /** Release one producer-owned collection when its render identity is removed. */
+  release(world, entity) {
+    const entities = this.identities.get(world);
+    const collectionId = entities?.get(entity);
+    if (collectionId === void 0) return;
+    entities?.delete(entity);
+    this.records.delete(collectionId);
+  }
+  dispose() {
+    this.records.clear();
+    this.identities = /* @__PURE__ */ new WeakMap();
+  }
+  /**
+   * Return detached residency facts for every live collection.
+   *
+   * @internal Joins CPU projection identity with the active device residency;
+   * callers only receive immutable PODs and never GPU handles.
+   */
+  _inspections(residency, frameNumber) {
+    return Object.freeze(
+      [...this.records.values()].map(
+        (record) => this.projectInspection(record, residency?.get(record.collectionId), frameNumber)
+      )
+    );
+  }
+  info(record) {
+    return Object.freeze({
+      collectionId: record.collectionId,
+      count: record.count,
+      revision: record.revision
+    });
+  }
+  projectInspection(record, residency, frameNumber) {
+    return Object.freeze({
+      ...this.info(record),
+      residentGeneration: residency?.residentGeneration,
+      lane: residency?.lane ?? "unresident",
+      uploadRanges: Object.freeze(
+        residency?.frameNumber === frameNumber ? residency.uploadRanges.map((range) => ({ ...range })) : []
+      ),
+      uploadedBytes: residency?.frameNumber === frameNumber ? residency.uploadedBytes : 0,
+      requestedBytes: residency?.requestedBytes ?? record.count * MATRIX_STRIDE * 4,
+      supportedBytes: residency?.supportedBytes,
+      backend: residency?.backend ?? "unknown",
+      owner: "renderer.instances",
+      error: residency?.error
+    });
+  }
+};
+function recordInstanceResidency(residency, input) {
+  const previous = residency.get(input.collectionId);
+  const sameFrame = previous !== void 0 && previous.frameNumber === input.frameNumber && previous.error === void 0;
+  const uploadRanges = sameFrame ? [...previous.uploadRanges].reduce(
+    (ranges, range) => {
+      appendRange(ranges, range.start, range.end);
+      return ranges;
+    },
+    input.uploadRanges.map((range) => ({ ...range }))
+  ) : input.uploadRanges.map((range) => ({ ...range }));
+  residency.set(input.collectionId, {
+    frameNumber: input.frameNumber,
+    residentGeneration: input.residentGeneration,
+    lane: input.lane,
+    uploadRanges,
+    uploadedBytes: sameFrame ? previous.uploadedBytes + input.uploadedBytes : input.uploadedBytes,
+    requestedBytes: input.requestedBytes,
+    supportedBytes: input.supportedBytes,
+    backend: input.backend,
+    error: void 0
+  });
+}
+function recordInstanceFailure(residency, input) {
+  residency.set(input.collectionId, {
+    frameNumber: -1,
+    residentGeneration: void 0,
+    lane: "unavailable",
+    uploadRanges: [],
+    uploadedBytes: 0,
+    requestedBytes: input.facts.requestedBytes,
+    supportedBytes: input.facts.supportedBytes,
+    backend: input.facts.backend,
+    error: {
+      code: input.code,
+      expected: input.expected,
+      hint: input.hint,
+      detail: { ...input.facts }
+    }
+  });
+}
+
 // src/ibl/skylight-bind-group.ts
 var FALLBACK_BYTES_PER_ROW = 256;
-function assembleMaterialWithSkylightEntries(materialEntries, skylight, transmission) {
+function assembleMaterialWithSkylightEntries(materialEntries, skylight, transmission, textureInjections = []) {
   const iblStart = materialEntries.length;
   const result = [
     ...materialEntries,
@@ -4081,6 +4274,22 @@ function assembleMaterialWithSkylightEntries(materialEntries, skylight, transmis
       resource: { kind: "textureView", value: transmissionView }
     }
   );
+  const clearcoatStart = result.length;
+  for (let index = 0; index < textureInjections.length; index += 1) {
+    const resource = textureInjections[index];
+    if (resource === void 0) continue;
+    const binding = clearcoatStart + resource.slot * 2;
+    result.push(
+      {
+        binding,
+        resource: { kind: "sampler", value: resource.sampler }
+      },
+      {
+        binding: binding + 1,
+        resource: { kind: "textureView", value: resource.view }
+      }
+    );
+  }
   return result;
 }
 function createSkylightFallback(device, queue) {
@@ -4344,8 +4553,8 @@ 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 = 384;
-var MATERIAL_PER_ENTITY_STRIDE = 512;
+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({
@@ -4504,17 +4713,64 @@ function isImageError(error) {
   const code = error.code;
   return typeof code === "string" && code.startsWith("image-");
 }
+function materialDiagnosticsEnabled() {
+  if (typeof globalThis !== "object" || globalThis === null || !("process" in globalThis)) {
+    return false;
+  }
+  const processValue = globalThis.process;
+  return processValue?.env?.FORGEAX_MATERIAL_DIAGNOSTICS === "1";
+}
 function residentTextureView(world, store, runtime, handle, worldId = world) {
   const podRes = resolveAssetHandle(world, handle);
-  if (!podRes.ok) return void 0;
+  const diagnosticsEnabled = materialDiagnosticsEnabled();
+  if (!podRes.ok) {
+    if (diagnosticsEnabled) {
+      console.error(
+        `[render-material] texture resolve failed: ${JSON.stringify({ handle: handleSlot(handle), error: podRes.error })}`
+      );
+    }
+    return void 0;
+  }
   const residentRes = store.ensureResident(handle, podRes.value, worldId);
   if (!residentRes.ok) {
     if (residentRes.error instanceof RhiError || isImageError(residentRes.error)) {
       runtime.errorRegistry.fire(residentRes.error);
     }
+    if (diagnosticsEnabled) {
+      console.error(
+        `[render-material] texture residency failed: ${JSON.stringify({
+          handle: handleSlot(handle),
+          pod: {
+            kind: podRes.value.kind,
+            shape: podRes.value.shape,
+            format: podRes.value.format,
+            dataByteLength: podRes.value.data.byteLength,
+            mips: podRes.value.mips
+          },
+          error: residentRes.error
+        })}`
+      );
+    }
     return void 0;
   }
-  return store.getTextureGpuView(handle, worldId);
+  const view = store.getTextureGpuView(handle, worldId);
+  if (diagnosticsEnabled) {
+    console.error(
+      `[render-material] texture residency ready: ${JSON.stringify({
+        handle: handleSlot(handle),
+        pod: {
+          kind: podRes.value.kind,
+          shape: podRes.value.shape,
+          format: podRes.value.format,
+          dataByteLength: podRes.value.data.byteLength,
+          mips: podRes.value.mips
+        },
+        receipt: "receipt" in residentRes.value ? residentRes.value.receipt : void 0,
+        viewReady: view !== void 0
+      })}`
+    );
+  }
+  return view;
 }
 function residentSampler(world, store, runtime, handle, worldId = world) {
   const podRes = resolveAssetHandle(world, handle);
@@ -4581,24 +4837,12 @@ var BUILTIN_USER_REGION_TEXTURE_FIELDS = [
   "baseColorTexture",
   "metallicRoughnessTexture",
   "normalTexture",
-  "specularTintTexture",
   "emissiveTexture",
   "occlusionTexture",
   "transmissionTexture",
   "thicknessTexture"
 ];
 var LEGACY_MATERIAL_TEXTURE_SCALE_OFFSET = 80;
-var STANDARD_PBR_TEXTURE_SCALE_OFFSET = 128;
-var MATERIAL_TEXTURE_SCALE_FIELDS = [
-  "baseColorTexture",
-  "metallicRoughnessTexture",
-  "normalTexture",
-  "specularTintTexture",
-  "emissiveTexture",
-  "occlusionTexture",
-  "transmissionTexture",
-  "thicknessTexture"
-];
 var LEGACY_MATERIAL_TEXTURE_SCALE_FIELDS = [
   "baseColorTexture",
   "metallicRoughnessTexture",
@@ -4606,75 +4850,7 @@ var LEGACY_MATERIAL_TEXTURE_SCALE_FIELDS = [
   "emissiveTexture",
   "occlusionTexture"
 ];
-var STANDARD_PBR_TEXTURE_COORDINATE_OFFSET = 128;
-var STANDARD_PBR_TEXTURE_COORDINATE_STRIDE = 8;
 var DEFAULT_LEGACY_TEXTURE_SCALES = new Float32Array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
-var DEFAULT_STANDARD_TEXTURE_COORDINATES = new Float32Array([
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1
-]);
 function materialTextureUvScale(texture) {
   if (texture === void 0) return [1, 1];
   return deriveTextureExtent(
@@ -4722,17 +4898,13 @@ function applyMaterialTextureUvScales(payload, material, world) {
     }
     return;
   }
-  const textureScaleOffset = isStandardPbrMaterialShader(material.materialShaderId) ? STANDARD_PBR_TEXTURE_SCALE_OFFSET : LEGACY_MATERIAL_TEXTURE_SCALE_OFFSET;
-  const isStandardPbr = textureScaleOffset === STANDARD_PBR_TEXTURE_SCALE_OFFSET;
+  const textureScaleOffset = LEGACY_MATERIAL_TEXTURE_SCALE_OFFSET;
   const hasTextureMetadata = material.textureCoordinates !== void 0 || material.textureHandles !== void 0 || material.videoTextureFields !== void 0 || material.baseColorTexture !== void 0 || material.metallicRoughnessTexture !== void 0 || material.normalTexture !== void 0 || material.emissiveTexture !== void 0 || material.occlusionTexture !== void 0;
   if (!hasTextureMetadata) {
-    f32.set(
-      isStandardPbr ? DEFAULT_STANDARD_TEXTURE_COORDINATES : DEFAULT_LEGACY_TEXTURE_SCALES,
-      textureScaleOffset / 4
-    );
+    f32.set(DEFAULT_LEGACY_TEXTURE_SCALES, textureScaleOffset / 4);
     return;
   }
-  const fields = isStandardPbr ? MATERIAL_TEXTURE_SCALE_FIELDS : LEGACY_MATERIAL_TEXTURE_SCALE_FIELDS;
+  const fields = LEGACY_MATERIAL_TEXTURE_SCALE_FIELDS;
   for (let index = 0; index < fields.length; index++) {
     const field = fields[index];
     if (field === void 0) continue;
@@ -4740,32 +4912,16 @@ function applyMaterialTextureUvScales(payload, material, world) {
     const resolved = handle === void 0 ? void 0 : resolveAssetHandle(world, handle);
     const texture = resolved?.ok === true ? resolved.value : void 0;
     const [u, v] = materialTextureUvScale(texture);
-    if (isStandardPbr) {
-      const coordinates = material.textureCoordinates?.get(field);
-      const transform = coordinates?.transform;
-      const offset = STANDARD_PBR_TEXTURE_COORDINATE_OFFSET / 4 + index * STANDARD_PBR_TEXTURE_COORDINATE_STRIDE;
-      f32[offset] = transform?.offset?.[0] ?? 0;
-      f32[offset + 1] = transform?.offset?.[1] ?? 0;
-      f32[offset + 2] = transform?.scale?.[0] ?? 1;
-      f32[offset + 3] = transform?.scale?.[1] ?? 1;
-      f32[offset + 4] = coordinates?.set ?? 0;
-      f32[offset + 5] = transform?.rotation ?? 0;
-      f32[offset + 6] = u;
-      f32[offset + 7] = v;
-    } else {
-      const offset = textureScaleOffset / 4 + index * 2;
-      f32[offset] = u;
-      f32[offset + 1] = v;
-    }
+    const offset = textureScaleOffset / 4 + index * 2;
+    f32[offset] = u;
+    f32[offset + 1] = v;
   }
 }
 function materialCoordinateSchema(material) {
-  if (isStandardPbrMaterialShader(material.materialShaderId) && material.paramSnapshot !== void 0) {
-    return DEFAULT_STANDARD_PBR_PARAM_SCHEMA;
-  }
   if (material.materialParamSchema !== void 0 && material.materialParamSchema.length > 0) {
     return material.materialParamSchema;
   }
+  if (isStandardPbrMaterialShader(material.materialShaderId)) return STANDARD_PIPELINE_PARAM_SCHEMA;
   switch (material.materialShaderId) {
     case "forgeax::default-unlit":
       return DEFAULT_UNLIT_PARAM_SCHEMA;
@@ -4790,6 +4946,9 @@ function defaultViewForUserRegionField(field, pipelineState, schema) {
   }
   if (field === "normalTexture") return pipelineState.defaultNormalTextureView;
   if (field === "baseColorTexture") return pipelineState.fallbackTextureView;
+  if (field === "anisotropyTexture") {
+    return pipelineState.defaultAnisotropyTextureView ?? pipelineState.defaultNormalTextureView;
+  }
   return pipelineState.defaultWhiteTextureView;
 }
 function detectNineSliceScaleTooSmall(transformWorld, slices, renderableIndex, seenIndices, metrics) {
@@ -4814,58 +4973,54 @@ function writePbrMaterialUboPayload(buf, material) {
   }
   buf.fill(0);
   const f32 = materialUboFloatView(buf);
-  f32[0] = material.baseColor[0] ?? 0;
-  f32[1] = material.baseColor[1] ?? 0;
-  f32[2] = material.baseColor[2] ?? 0;
-  f32[3] = 1;
-  f32[4] = material.metallic;
-  f32[5] = material.roughness;
-  f32[6] = 2;
-  f32[7] = 1;
-  f32[8] = 0;
-  f32[9] = 0;
-  const em = material.emissive;
-  f32[12] = em?.[0] ?? 0;
-  f32[13] = em?.[1] ?? 0;
-  f32[14] = em?.[2] ?? 0;
-  f32[15] = material.emissiveIntensity ?? 0;
-  f32[16] = material.occlusionStrength ?? 1;
-  const alphaCutoff = material.paramSnapshot?.alphaCutoff;
-  f32[17] = typeof alphaCutoff === "number" ? alphaCutoff : 0;
-  f32[18] = material.clearcoat ?? 0;
-  f32[19] = material.clearcoatRoughness ?? 0.5;
-  const specularTint = material.specularTint;
-  f32[20] = specularTint?.[0] ?? 1;
-  f32[21] = specularTint?.[1] ?? 1;
-  f32[22] = specularTint?.[2] ?? 1;
-  const snapshotNumber = (name, fallback) => {
-    const value = material.paramSnapshot?.[name];
-    return typeof value === "number" ? value : fallback;
-  };
-  const snapshotVec3 = (name, fallback) => {
-    const value = material.paramSnapshot?.[name];
-    return Array.isArray(value) ? [value[0] ?? fallback[0], value[1] ?? fallback[1], value[2] ?? fallback[2]] : fallback;
+  const schema = material.materialParamSchema === void 0 || material.materialParamSchema.length === 0 ? STANDARD_PIPELINE_PARAM_SCHEMA : material.materialParamSchema;
+  const snapshot = material.paramSnapshot;
+  const fallback = (name, entry) => {
+    switch (name) {
+      case "baseColor":
+        return [
+          material.baseColor[0] ?? 1,
+          material.baseColor[1] ?? 1,
+          material.baseColor[2] ?? 1,
+          1
+        ];
+      case "metallic":
+        return material.metallic;
+      case "roughness":
+        return material.roughness;
+      case "specularColor":
+        return material.specularColor ?? [1, 1, 1];
+      case "normalScale":
+        return material.normalScale ?? 1;
+      case "emissive":
+        return material.emissive ?? [0, 0, 0];
+      case "emissiveIntensity":
+        return material.emissiveIntensity ?? 0;
+      case "occlusionStrength":
+        return material.occlusionStrength ?? 1;
+      default:
+        return entry.default;
+    }
   };
-  f32[23] = material.normalScale ?? snapshotNumber("normalScale", 1);
-  f32[24] = snapshotNumber("transmission", 0);
-  f32[25] = snapshotNumber("ior", 1.5);
-  f32[26] = snapshotNumber("thickness", 0);
-  const attenuationColor = snapshotVec3("attenuationColor", [1, 1, 1]);
-  f32[28] = attenuationColor[0];
-  f32[29] = attenuationColor[1];
-  f32[30] = attenuationColor[2];
-  f32[31] = snapshotNumber("attenuationDistance", 0);
-  const paramSnap = material.paramSnapshot;
-  if (paramSnap !== void 0) {
-    material.materialShaderId;
+  for (const entry of derivedParamSchema(schema).uboLayout.entries) {
+    const value = snapshot?.[entry.name] ?? fallback(entry.name, schema.find((item) => item.name === entry.name) ?? entry);
+    const offset = entry.offset / 4;
+    const width = entry.size / 4;
+    if (typeof value === "number") {
+      f32[offset] = value;
+    } else if (Array.isArray(value)) {
+      for (let index = 0; index < Math.min(width, value.length); index += 1) {
+        const component = value[index];
+        if (typeof component === "number") f32[offset + index] = component;
+      }
+    }
   }
 }
 function applyParamSnapshotToUbo(payload, paramSchema, paramSnapshot) {
   if (paramSchema === void 0) return;
   if (paramSnapshot === void 0) return;
   const f32 = materialUboFloatView(payload);
-  const effectiveSchema = Object.hasOwn(paramSnapshot, "transmission") && Object.hasOwn(paramSnapshot, "ior") && Object.hasOwn(paramSnapshot, "thickness") ? DEFAULT_STANDARD_PBR_PARAM_SCHEMA : paramSchema;
-  const { uboLayout } = derivedParamSchema(effectiveSchema);
+  const { uboLayout } = derivedParamSchema(paramSchema);
   for (const entry of uboLayout.entries) {
     const value = paramSnapshot[entry.name];
     if (value === void 0) continue;
@@ -4885,6 +5040,36 @@ function applyParamSnapshotToUbo(payload, paramSchema, paramSnapshot) {
     }
   }
 }
+function recordIblMaterialBinding(frameState, materialBgl, bindGroup, entries, iblStart, cache3) {
+  const receipt = frameState.iblBindingInspection;
+  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 projected = [];
+  for (const entry of iblEntries) {
+    if (entry.resource.kind === "externalTexture") continue;
+    const value = entry.resource.kind === "buffer" ? entry.resource.value.buffer : entry.resource.value;
+    if (typeof value !== "object" || value === null) continue;
+    projected.push({
+      binding: entry.binding,
+      kind: entry.resource.kind,
+      resourceIdentity: getOpaqueResourceIdentity(value)
+    });
+  }
+  frameState.iblBindingInspection = {
+    ...receipt,
+    material: {
+      bindGroupIdentity: getOpaqueResourceIdentity(bindGroup),
+      materialBglIdentity: getOpaqueResourceIdentity(materialBgl),
+      cache: cache3,
+      skylightBindingStart: iblEntries[0]?.binding ?? 0,
+      entries: projected,
+      reflectionBindings: projected.map((entry) => entry.binding)
+    },
+    errors: []
+  };
+}
 function isMaterialBgAssemblyCacheHit(cached, material, materialBgl, materialBuffer, skylightResources, materialResourceEpoch, transmissionBackdropView) {
   if (transmissionBackdropView != null) return false;
   return cached?.material === material && cached.materialResourceEpoch === materialResourceEpoch && cached.materialBgl === materialBgl && cached.materialBuffer === materialBuffer && cached.skylightResources.irradianceView === skylightResources.irradianceView && cached.skylightResources.irradianceSampler === skylightResources.irradianceSampler && cached.skylightResources.prefilterView === skylightResources.prefilterView && cached.skylightResources.prefilterSampler === skylightResources.prefilterSampler && cached.skylightResources.brdfLutView === skylightResources.brdfLutView && cached.skylightResources.brdfLutSampler === skylightResources.brdfLutSampler && cached.skylightResources.intensityBuffer === skylightResources.intensityBuffer;
@@ -4902,16 +5087,22 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
     materialBgShared,
     materialBgAssemblyCache,
     transmissionBackdropView,
-    bindGroupCounts
+    bindGroupCounts,
+    frameState
   } = deps;
   const effectiveSkylightResources = resolveReflectionProbeResources?.(materialWorld, entityKey) ?? skylightResources;
   const smMaterialHandle = submeshMaterial.materialHandle;
   const materialCacheKey = smMaterialHandle === void 0 ? void 0 : `${materialWorld.identity}:${smMaterialHandle}`;
   const smHasVideoFields = (submeshMaterial.videoTextureFields?.size ?? 0) > 0;
   const smShaderId = submeshMaterial.materialShaderId;
-  const smPerShaderBgl = smShaderId !== void 0 ? runtime.getMaterialBindGroupLayout?.(smShaderId) : void 0;
+  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;
+  const standardMaterial = isStandardPbrMaterialShader(smShaderId);
+  const physicalFields = standardMaterial && smSchema !== void 0 ? physicalTextureFields(smSchema) : [];
+  const smUserRegionFields = smPerShaderBgl === void 0 || isCanonicalStandardPbrMaterialShader(smShaderId) ? BUILTIN_USER_REGION_TEXTURE_FIELDS : userRegionTextureFieldOrder(smSchema).filter((field) => !physicalFields.includes(field));
   const hasActiveTransmissionBackdrop = transmissionBackdropView != null;
+  const diagnosticsEnabled = materialDiagnosticsEnabled();
   if (smMaterialHandle !== void 0 && !smHasVideoFields && !hasActiveTransmissionBackdrop) {
     const cached = materialCacheKey === void 0 ? void 0 : materialBgAssemblyCache.get(materialCacheKey);
     if (isMaterialBgAssemblyCacheHit(
@@ -4923,11 +5114,48 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
       store.materialResourceEpoch,
       transmissionBackdropView
     )) {
+      if (diagnosticsEnabled) {
+        recordIblMaterialBinding(
+          frameState,
+          smMaterialBgl,
+          cached.bindGroup,
+          [
+            {
+              binding: 1 + smUserRegionFields.length * 2,
+              resource: { kind: "textureView", value: skylightResources.irradianceView }
+            },
+            {
+              binding: 2 + smUserRegionFields.length * 2,
+              resource: { kind: "sampler", value: skylightResources.irradianceSampler }
+            },
+            {
+              binding: 3 + smUserRegionFields.length * 2,
+              resource: { kind: "textureView", value: skylightResources.prefilterView }
+            },
+            {
+              binding: 4 + smUserRegionFields.length * 2,
+              resource: { kind: "sampler", value: skylightResources.prefilterSampler }
+            },
+            {
+              binding: 5 + smUserRegionFields.length * 2,
+              resource: { kind: "textureView", value: skylightResources.brdfLutView }
+            },
+            {
+              binding: 6 + smUserRegionFields.length * 2,
+              resource: { kind: "sampler", value: skylightResources.brdfLutSampler }
+            },
+            {
+              binding: 7 + smUserRegionFields.length * 2,
+              resource: { kind: "buffer", value: { buffer: skylightResources.intensityBuffer } }
+            }
+          ],
+          1 + smUserRegionFields.length * 2,
+          "hit"
+        );
+      }
       return cached.bindGroup;
     }
   }
-  const smSchema = submeshMaterial.materialParamSchema ?? (smShaderId !== void 0 ? runtime.getParamSchema?.(smShaderId) : void 0);
-  const smUserRegionFields = smPerShaderBgl === void 0 || isStandardPbrMaterialShader(smShaderId) ? BUILTIN_USER_REGION_TEXTURE_FIELDS : userRegionTextureFieldOrder(smSchema);
   let materialResourcesResident = true;
   const smSamplerForField = (field) => {
     const handle = field === void 0 ? void 0 : submeshMaterial.samplerHandles?.get(field);
@@ -4993,6 +5221,33 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
       }
     );
   }
+  const physicalTextureInjections = [];
+  for (let slot = 0; slot < physicalFields.length; slot += 1) {
+    const field = physicalFields[slot];
+    if (field === void 0) continue;
+    let view = defaultViewForUserRegionField(field, pipelineState, smSchema);
+    const targetSource = materialRenderTargetSourceForField(
+      submeshMaterial,
+      field,
+      resolveRenderTargetTextureSource
+    );
+    if (targetSource !== void 0) {
+      if (targetSource.textureView !== void 0) view = targetSource.textureView;
+      else materialResourcesResident = false;
+    } else {
+      const handle = submeshMaterial.textureHandles?.get(field);
+      if (handle !== void 0) {
+        const resident = residentTextureView(materialWorld, store, runtime, handle);
+        if (resident !== void 0) view = resident;
+        else materialResourcesResident = false;
+      }
+    }
+    physicalTextureInjections.push({
+      slot,
+      sampler: smSamplerForField(field),
+      view
+    });
+  }
   const transmissionSampler = transmissionBackdropView != null ? effectiveSkylightResources.prefilterSampler : pipelineState.defaultSampler;
   const smMergedEntries = assembleMaterialWithSkylightEntries(
     smBaseEntries,
@@ -5000,7 +5255,8 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
     {
       sampler: transmissionSampler,
       ...transmissionBackdropView === void 0 ? {} : { backdropView: transmissionBackdropView }
-    }
+    },
+    physicalTextureInjections
   );
   const createBindGroup = () => {
     const result = runtime.device.createBindGroup({
@@ -5011,14 +5267,51 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
     if (!result.ok) throw result.error;
     return result.value;
   };
+  const materialCacheHandles = smMergedEntries.map((entry) => extractEntryResourceHandle(entry));
+  if (diagnosticsEnabled && submeshMaterial.textureHandles === void 0 && smMaterialHandle !== void 0) {
+    console.error(
+      `[render-material] scalar material cache handles: ${JSON.stringify({
+        entityKey,
+        materialHandle: smMaterialHandle,
+        shader: smShaderId,
+        paramSnapshot: submeshMaterial.paramSnapshot,
+        handleTypes: materialCacheHandles.map((handle) => typeof handle)
+      })}`
+    );
+  }
+  if (diagnosticsEnabled && materialCacheHandles.some((handle) => typeof handle !== "object" || handle === null)) {
+    console.error(
+      `[render-material] invalid material cache handle: ${JSON.stringify({
+        entityKey,
+        materialHandle: smMaterialHandle,
+        shader: smShaderId,
+        entries: smMergedEntries.map((entry, index) => ({
+          index,
+          binding: entry.binding,
+          kind: entry.resource.kind,
+          handleType: typeof materialCacheHandles[index]
+        }))
+      })}`
+    );
+  }
   const smBindGroup = hasActiveTransmissionBackdrop ? createBindGroup() : getOrCreatePerEntity(
     materialBgShared,
     smShaderId ?? "",
-    smMergedEntries.map((e) => extractEntryResourceHandle(e)),
+    materialCacheHandles,
     "material-shared",
     createBindGroup,
     bindGroupCounts
   );
+  if (diagnosticsEnabled) {
+    recordIblMaterialBinding(
+      frameState,
+      smMaterialBgl,
+      smBindGroup,
+      smMergedEntries,
+      smBaseEntries.length,
+      "miss"
+    );
+  }
   if (smMaterialHandle !== void 0 && !smHasVideoFields && materialResourcesResident && !hasActiveTransmissionBackdrop) {
     if (materialCacheKey !== void 0) {
       materialBgAssemblyCache.set(materialCacheKey, {
@@ -5035,6 +5328,85 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
 }
 
 // src/record/main-pass-geometry.ts
+function materialDiagnosticsEnabled2() {
+  if (typeof globalThis !== "object" || globalThis === null || !("process" in globalThis)) {
+    return false;
+  }
+  const processValue = globalThis.process;
+  return processValue?.env?.FORGEAX_MATERIAL_DIAGNOSTICS === "1";
+}
+function requestsStandardTransmissionVariant(material) {
+  return material.materialShaderId === "forgeax::default-standard-pbr" && material.paramSnapshot?.transmission !== void 0;
+}
+function recordIblPipelineBinding(c, material, pipeline, materialGroup) {
+  const receipt = c.frameState.iblBindingInspection;
+  if (receipt === void 0 || !isStandardPbrMaterialShader(material.materialShaderId)) return;
+  const materialBgl = c.runtime.getMaterialBindGroupLayout?.(
+    material.materialShaderId ?? "forgeax::default-standard-pbr"
+  ) ?? c.pipelineState.materialBindGroupLayout;
+  c.frameState.iblBindingInspection = {
+    ...receipt,
+    pipeline: {
+      pipelineIdentity: getOpaqueResourceIdentity(pipeline),
+      effectiveMaterialLayoutIdentity: effectiveMaterialLayoutIdentity(
+        material.materialShaderId ?? "forgeax::default-standard-pbr",
+        material.materialParamSchema
+      ),
+      materialBglIdentity: getOpaqueResourceIdentity(materialBgl),
+      bindGroupIdentity: getOpaqueResourceIdentity(materialGroup),
+      drawFrameId: c.frameState.frameNumber
+    }
+  };
+  const materialReceipt = c.frameState.iblBindingInspection.material;
+  const errors = [];
+  if (materialReceipt !== void 0 && materialReceipt.materialBglIdentity !== getOpaqueResourceIdentity(materialBgl)) {
+    errors.push("material-pipeline-bgl-identity-mismatch");
+  }
+  if (materialReceipt !== void 0 && materialReceipt.bindGroupIdentity !== getOpaqueResourceIdentity(materialGroup)) {
+    errors.push("material-bind-group-identity-mismatch");
+  }
+  if (materialReceipt !== void 0) {
+    const expectedResourceIdentities = [
+      receipt.resources.irradiance.viewIdentity,
+      receipt.resources.irradiance.samplerIdentity,
+      receipt.resources.prefilter.viewIdentity,
+      receipt.resources.prefilter.samplerIdentity,
+      receipt.resources.brdfLut.viewIdentity,
+      receipt.resources.brdfLut.samplerIdentity,
+      receipt.resources.intensityBufferIdentity
+    ];
+    const actualResourceIdentities = materialReceipt.entries.filter((entry) => entry.binding >= materialReceipt.skylightBindingStart).slice(0, expectedResourceIdentities.length).map((entry) => entry.resourceIdentity);
+    if (actualResourceIdentities.length !== expectedResourceIdentities.length || actualResourceIdentities.some(
+      (identity, index) => identity !== expectedResourceIdentities[index]
+    )) {
+      errors.push("material-ibl-resource-identity-mismatch");
+    }
+  }
+  c.frameState.iblBindingInspection = {
+    ...c.frameState.iblBindingInspection,
+    status: errors.length === 0 ? "binding-chain-consistent" : "binding-chain-mismatch",
+    errors
+  };
+}
+var SHARED_BOOT_MATERIAL_SHADER_IDS = /* @__PURE__ */ new Set([
+  "forgeax::default-unlit",
+  "forgeax::default-shadow-caster",
+  "forgeax::sprite",
+  "forgeax::sprite-lit",
+  "forgeax::default-sprite",
+  "forgeax::msdf-text",
+  "forgeax::default-standard-pbr",
+  "forgeax::pbr-skin",
+  "forgeax::default-standard-pbr-skin"
+]);
+function effectiveMaterialLayoutIdentity(materialShaderId, materialParamSchema) {
+  if (materialParamSchema === void 0) return void 0;
+  const hasStandardPhysicalMaps = isStandardPbrMaterialShader(materialShaderId) && physicalTextureFields(materialParamSchema).length > 0;
+  if (SHARED_BOOT_MATERIAL_SHADER_IDS.has(materialShaderId) && !hasStandardPhysicalMaps) {
+    return void 0;
+  }
+  return materialBindGroupLayoutIdentity(materialShaderId, materialParamSchema);
+}
 function geometryRenderStateForPass(base, passKind) {
   if (passKind !== "temporal") return base;
   return {
@@ -5095,6 +5467,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
     viewBindGroup,
     viewBindGroupDynamicOffset = 0
   } = c;
+  const diagnosticsEnabled = materialDiagnosticsEnabled2();
   const colorFormatOverride = c.transparentColorFormat;
   const clusteredLighting = c.standardLighting?.kind === "clustered";
   const isHdrTarget = tonemapActive || colorFormatOverride === "rgba16float";
@@ -5289,7 +5662,10 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
     const probeBlendRecordAvailable = runtime.device.caps.storageBuffer && entry.source.probeBlendRecord !== void 0;
     const skinAllocator = pipelineState.skinPaletteAllocator;
     const skinSlice = entry.source.skin;
-    const clusteredSkin = clusteredLighting;
+    const clusteredSkin = clusteredLighting && entry.source.materials.every((material) => {
+      const shaderId = material.materialShaderId;
+      return !isStandardPbrSkinMaterialShader(shaderId) || isCanonicalStandardPbrMaterialShader(shaderId);
+    });
     const skinMeshBindGroupLayout = clusteredSkin ? pipelineState.hdrpSkinMeshBindGroupLayout : pipelineState.pbrSkinMeshBindGroupLayout;
     const hdrpSkinBuffers = isSkinEntry && clusteredSkin ? getOrCreateHdrpBuffers(runtime, frameState.installedPipelineConfig?.clusterGrid) : null;
     const skinResources = isSkinEntry && skinMeshBindGroupLayout !== null && skinAllocator !== null && skinSlice !== void 0 && (!clusteredSkin || hdrpSkinBuffers !== null) ? {
@@ -5390,6 +5766,19 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
         entry.source.skin?.byteOffset ?? 0
       );
     } else if (isSkinEntry) {
+      if (diagnosticsEnabled) {
+        console.error(
+          `[render-material] skin draw skipped: ${JSON.stringify({
+            entityKey: entry.source.entityKey,
+            materialHandle: entry.source.material.materialHandle,
+            reason: "skin-pipeline-unavailable",
+            skinResourcesReady: skinResources !== null,
+            skinPsoReady: skinPsoProbe !== null,
+            paletteBufferReady: skinSlice?.buffer !== void 0,
+            paletteByteOffset: skinSlice?.byteOffset
+          })}`
+        );
+      }
       continue;
     }
     let perSubmeshBg = null;
@@ -5408,6 +5797,18 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
         continue;
       }
       const materialSlot = materialSlotIndices[i]?.[matSlotIdx] ?? materialSlotIndices[i]?.[0] ?? 0;
+      const processValue = globalThis.process;
+      if (processValue?.env?.FORGEAX_MATERIAL_PIPELINE_DIAGNOSTICS === "1" && (submeshMaterial.materialShaderId === "forgeax::default-standard-pbr" || submeshMaterial.materialShaderId === "forgeax::pbr-skin")) {
+        console.error(
+          `[render-material] draw receipt: ${JSON.stringify({
+            entityIndex: entry.renderableIndex,
+            materialSlot,
+            materialHandle: submeshMaterial.materialHandle,
+            clearcoat: submeshMaterial.paramSnapshot?.clearcoat,
+            shader: submeshMaterial.materialShaderId
+          })}`
+        );
+      }
       perSubmeshBg = profilePhase === void 0 ? resolveMaterialBindGroup(
         materialSlot,
         submeshMaterial,
@@ -5427,7 +5828,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
       materialGroup1DynamicOffsets[0] = materialSlot * MATERIAL_PER_ENTITY_STRIDE;
       pass.setBindGroup(1, perSubmeshBg, materialGroup1DynamicOffsets, 0, 1);
       const smTopology = sm.topology;
-      const smMaterialShaderId = entry.source.skin !== void 0 ? SKIN_MATERIAL_SHADER_ID : submeshMaterial.materialShaderId;
+      const smMaterialShaderId = entry.source.skin !== void 0 ? isStandardPbrSkinMaterialShader(submeshMaterial.materialShaderId) ? submeshMaterial.materialShaderId : SKIN_MATERIAL_SHADER_ID : submeshMaterial.materialShaderId;
       const probeBlendAvailable = probeBlendRecordAvailable && isStandardPbrMaterialShader(smMaterialShaderId);
       const isSpriteShader = smMaterialShaderId === "forgeax::sprite" || smMaterialShaderId === "forgeax::sprite-lit";
       const basePipelineRenderState = isSpriteShader ? {
@@ -5477,7 +5878,9 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
           hasVertexColor,
           probeBlendAvailable
         );
-        const variantSet = isSpriteShader ? smMaterialShaderId === "forgeax::sprite" && entry.source.spriteInstances !== void 0 ? "" : void 0 : entry.variantSet === void 0 ? capabilityVariantSet : capabilityVariantSet === "" ? entry.variantSet : `${capabilityVariantSet}+${entry.variantSet}`;
+        const transmissionAvailable = requestsStandardTransmissionVariant(submeshMaterial);
+        const materialCapabilityVariantSet = transmissionAvailable && !capabilityVariantSet.includes("TRANSMISSION_AVAILABLE=") ? `${capabilityVariantSet === "" ? "" : `${capabilityVariantSet}+`}TRANSMISSION_AVAILABLE=true` : capabilityVariantSet;
+        const variantSet = isSpriteShader ? smMaterialShaderId === "forgeax::sprite" && entry.source.spriteInstances !== void 0 ? "" : void 0 : entry.variantSet === void 0 ? materialCapabilityVariantSet : capabilityVariantSet === "" ? entry.variantSet : `${capabilityVariantSet}+${entry.variantSet}`;
         const cachedPipeline = resolveMaterialPipeline(
           smMaterialShaderId,
           pipelineRenderState,
@@ -5493,6 +5896,16 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
         smPipelineHandle = selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive);
       }
       if (smPipelineHandle === null) {
+        if (diagnosticsEnabled) {
+          console.error(
+            `[render-material] draw skipped: ${JSON.stringify({
+              entityKey: entry.source.entityKey,
+              materialHandle: submeshMaterial.materialHandle,
+              shader: smMaterialShaderId,
+              reason: "pipeline-unavailable"
+            })}`
+          );
+        }
         continue;
       }
       const instanceDraws2 = resolveGeometryInstanceBuffer(
@@ -5513,6 +5926,29 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
         if (selectedGroup === null) continue;
         group2BindGroup = selectedGroup;
       }
+      if (diagnosticsEnabled && submeshMaterial.textureHandles !== void 0) {
+        console.error(
+          `[render-material] draw submitted: ${JSON.stringify({
+            entityKey: entry.source.entityKey,
+            materialHandle: submeshMaterial.materialHandle,
+            shader: smMaterialShaderId,
+            textureHandles: [...submeshMaterial.textureHandles.entries()].map(
+              ([field, handle]) => ({
+                field,
+                handle
+              })
+            ),
+            skin: isSkinEntry ? {
+              resourcesReady: skinResources !== null,
+              psoReady: skinPsoProbe !== null,
+              paletteBufferReady: skinSlice?.buffer !== void 0,
+              paletteByteOffset: skinSlice?.byteOffset,
+              dynamicOffsets: [...group2DynamicOffsets]
+            } : void 0,
+            pipelineReady: true
+          })}`
+        );
+      }
       pass.setBindGroup(2, group2BindGroup, group2DynamicOffsets);
       if (profilePhase === void 0) {
         recordOcclusionCandidate(
@@ -5546,8 +5982,218 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
           )
         );
       }
+      if (diagnosticsEnabled && perSubmeshBg !== null) {
+        recordIblPipelineBinding(c, submeshMaterial, smPipelineHandle, perSubmeshBg);
+      }
+    }
+  }
+}
+function uploadInstanceRanges(c, inst, buffer, ranges, storageBacked, sourceOffsetInstances = 0) {
+  const strideBytes = (storageBacked ? INSTANCE_STORAGE_STRIDE_FLOATS : 16) * Float32Array.BYTES_PER_ELEMENT;
+  const uploadedRanges = [];
+  let uploadedBytes = 0;
+  for (const range of ranges) {
+    const start = Math.max(0, Math.min(inst.instanceCount, range.start));
+    const end = Math.max(start, Math.min(inst.instanceCount, range.end));
+    if (end <= start) continue;
+    const source = inst.transforms.subarray(
+      (sourceOffsetInstances + start) * 16,
+      (sourceOffsetInstances + end) * 16
+    );
+    const payload = storageBacked ? packInstanceStorageBuffer(source) : source;
+    const written = c.runtime.device.queue.writeBuffer(buffer, start * strideBytes, payload);
+    if (!written.ok) {
+      c.runtime.errorRegistry.fire(written.error);
+      return { ok: false, ranges: uploadedRanges, bytes: uploadedBytes };
+    }
+    uploadedRanges.push({ start, end });
+    uploadedBytes += payload.byteLength;
+  }
+  return { ok: true, ranges: uploadedRanges, bytes: uploadedBytes };
+}
+function reportInstanceResidency(c, inst, input) {
+  if (inst.collectionId === void 0 || c.frameState.instanceResidency === void 0) return;
+  recordInstanceResidency(c.frameState.instanceResidency, {
+    collectionId: inst.collectionId,
+    frameNumber: c.frameState.frameNumber,
+    residentGeneration: c.runtime.deviceScope.generation,
+    lane: input.lane,
+    requestedBytes: input.requestedBytes,
+    supportedBytes: input.supportedBytes,
+    uploadRanges: input.uploadRanges,
+    uploadedBytes: input.uploadedBytes,
+    backend: c.runtime.device.caps.backendKind
+  });
+}
+function reportInstanceFailure(c, inst, error, requestedBytes, supportedBytes) {
+  if (inst.collectionId === void 0 || c.frameState.instanceResidency === void 0) return;
+  recordInstanceFailure(c.frameState.instanceResidency, {
+    collectionId: inst.collectionId,
+    code: error.code,
+    expected: error.expected,
+    hint: error.hint,
+    facts: {
+      requestedBytes,
+      supportedBytes,
+      backend: c.runtime.device.caps.backendKind,
+      owner: "renderer.instances",
+      cause: error.code,
+      recovery: error.hint
+    }
+  });
+}
+function clearInstanceChunksForOwner(c, ownerKey) {
+  const chunks = c.frameState.instanceBufferChunks;
+  if (chunks === void 0) return;
+  const prefix = `${ownerKey}:`;
+  for (const [key, entry] of chunks.entries()) {
+    if (!key.startsWith(prefix)) continue;
+    if (!entry.buffer.isDestroyed) {
+      const destroyed = entry.buffer.destroy();
+      if (!destroyed.ok) c.runtime.errorRegistry.fire(destroyed.error);
+    }
+    chunks.delete(key);
+  }
+}
+function resolveStorageInstanceChunks(c, entry, inst, cap, probeBuffer, probeOffset) {
+  const { runtime, frameState } = c;
+  const strideBytes = INSTANCE_STORAGE_STRIDE_FLOATS * Float32Array.BYTES_PER_ELEMENT;
+  const chunkCapacity = Math.floor(cap / strideBytes);
+  if (chunkCapacity < 1) {
+    reportInstanceFailure(
+      c,
+      inst,
+      {
+        code: "limit-exceeded",
+        expected: `maxStorageBufferBindingSize (${cap}) >= ${strideBytes}`,
+        hint: "use a backend with storage-buffer bindings large enough for one InstanceData record"
+      },
+      inst.instanceCount * strideBytes,
+      cap
+    );
+    runtime.errorRegistry.fire(
+      new RhiError({
+        code: "limit-exceeded",
+        expected: `maxStorageBufferBindingSize (${cap}) >= ${strideBytes}`,
+        hint: "use a backend with storage-buffer bindings large enough for one InstanceData record",
+        detail: { maxStorageBufferBindingSize: cap, requestedBytes: strideBytes }
+      })
+    );
+    return null;
+  }
+  const ownerKey = instanceCollectionCacheKey(entry.source.worldId, inst);
+  const chunks = frameState.instanceBufferChunks;
+  const activeKeys = /* @__PURE__ */ new Set();
+  const draws = [];
+  const uploadedRanges = [];
+  let uploadedBytes = 0;
+  for (let start = 0; start < inst.instanceCount; start += chunkCapacity) {
+    const end = Math.min(inst.instanceCount, start + chunkCapacity);
+    const count = end - start;
+    const chunkKey = `${ownerKey}:${start}`;
+    activeKeys.add(chunkKey);
+    const payloadBytes = count * strideBytes;
+    const previous = chunks?.get(chunkKey);
+    let active = previous !== void 0 && previous.uploadedArchVersion === inst.archVersion && previous.uploadedByteLength === payloadBytes ? previous : void 0;
+    let activeIsNew = false;
+    if (active === void 0) {
+      const created = runtime.device.createBuffer({
+        size: payloadBytes,
+        usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST,
+        mappedAtCreation: false
+      });
+      if (!created.ok) {
+        runtime.errorRegistry.fire(created.error);
+        reportInstanceFailure(c, inst, created.error, inst.instanceCount * strideBytes, cap);
+        return null;
+      }
+      if (previous !== void 0 && !previous.buffer.isDestroyed) {
+        const destroyed = previous.buffer.destroy();
+        if (!destroyed.ok) runtime.errorRegistry.fire(destroyed.error);
+      }
+      active = {
+        buffer: new GpuBuffer(runtime.device, created.value),
+        uploadedArchVersion: inst.archVersion,
+        uploadedByteLength: payloadBytes
+      };
+      activeIsNew = true;
+      chunks?.set(chunkKey, active);
+      if (chunks === void 0) frameState.transientInstanceBuffers.push(active);
+    }
+    if (active === void 0) return null;
+    const needsUpload = activeIsNew || active.uploadedRevision !== (inst.revision ?? inst.archVersion);
+    const rangesToUpload = [
+      {
+        start: 0,
+        end: count
+      }
+    ];
+    if (needsUpload && rangesToUpload.length > 0) {
+      const upload = uploadInstanceRanges(
+        c,
+        inst,
+        active.buffer.handle,
+        rangesToUpload,
+        true,
+        start
+      );
+      for (const range of upload.ranges) {
+        uploadedRanges.push({ start: range.start + start, end: range.end + start });
+      }
+      uploadedBytes += upload.bytes;
+      if (!upload.ok) {
+        reportInstanceFailure(
+          c,
+          inst,
+          {
+            code: "queue-write-buffer-failed",
+            expected: "the renderer-owned instance storage buffer accepts the complete instance payload",
+            hint: "retry after the active device is healthy or recover the renderer"
+          },
+          inst.instanceCount * strideBytes,
+          cap
+        );
+        return null;
+      }
     }
+    if (needsUpload) {
+      {
+        const published = { ...active, uploadedRevision: inst.revision ?? inst.archVersion };
+        active = published;
+        chunks?.set(chunkKey, published);
+      }
+    }
+    const activeBuffer = active;
+    draws.push({
+      instanceBuffer: activeBuffer.buffer.handle,
+      instanceBindGroup: resolveGeometryInstancesBindGroup(
+        c,
+        activeBuffer.buffer.handle,
+        probeBuffer
+      ),
+      probeOffset,
+      instanceCount: count
+    });
   }
+  if (chunks !== void 0) {
+    const prefix = `${ownerKey}:`;
+    for (const [key, stale] of chunks.entries()) {
+      if (!key.startsWith(prefix) || activeKeys.has(key)) continue;
+      if (!stale.buffer.isDestroyed) {
+        const destroyed = stale.buffer.destroy();
+        if (!destroyed.ok) runtime.errorRegistry.fire(destroyed.error);
+      }
+      chunks.delete(key);
+    }
+  }
+  reportInstanceResidency(c, inst, {
+    lane: "chunked-storage",
+    requestedBytes: inst.instanceCount * strideBytes,
+    supportedBytes: cap,
+    uploadRanges: uploadedRanges,
+    uploadedBytes
+  });
+  return draws;
 }
 function resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, useProbeBlend) {
   const { runtime, pipelineState, frameState } = c;
@@ -5573,74 +6219,152 @@ function resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, useProbe
     ];
   }
   if (inst.instanceCount === 0) return [];
+  const entityCacheKey = instanceCollectionCacheKey(entry.source.worldId, inst);
+  const revision = inst.revision ?? inst.archVersion;
+  const sameRevision = (cached) => cached.uploadedRevision === revision;
+  const fullRange = [{ start: 0, end: inst.instanceCount }];
   let instanceBuffer = pipelineState.identityInstanceBuffer;
   let instanceCount = 1;
   {
     const uniformFallback = runtime.device.caps.storageBuffer === false;
     let instanceBufferUsage = GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST;
     if (uniformFallback && inst.instanceCount > MAX_UNIFORM_INSTANCES) {
+      const ownerKey = instanceCollectionCacheKey(entry.source.worldId, inst);
+      const chunks = frameState.instanceBufferChunks;
+      const activeKeys = /* @__PURE__ */ new Set();
       const draws = [];
+      const uniformStrideBytes = 16 * Float32Array.BYTES_PER_ELEMENT;
+      const uploadedRanges = [];
+      let uploadedBytes = 0;
       for (let start = 0; start < inst.instanceCount; start += MAX_UNIFORM_INSTANCES) {
         const count = Math.min(MAX_UNIFORM_INSTANCES, inst.instanceCount - start);
-        const chunk = inst.transforms.subarray(start * 16, (start + count) * 16);
-        const bufRes = runtime.device.createBuffer({
-          size: INSTANCE_UBO_FULL_ARRAY_BYTES,
-          usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-          mappedAtCreation: false
-        });
-        if (!bufRes.ok) {
-          runtime.errorRegistry.fire(bufRes.error);
-          return null;
+        const chunkKey = `${ownerKey}:${start}`;
+        activeKeys.add(chunkKey);
+        const payloadBytes = count * uniformStrideBytes;
+        const previous = chunks?.get(chunkKey);
+        let active = previous !== void 0 && previous.uploadedArchVersion === inst.archVersion && previous.uploadedByteLength === payloadBytes ? previous : void 0;
+        let activeIsNew = false;
+        if (active === void 0) {
+          const created = runtime.device.createBuffer({
+            size: INSTANCE_UBO_FULL_ARRAY_BYTES,
+            usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+            mappedAtCreation: false
+          });
+          if (!created.ok) {
+            runtime.errorRegistry.fire(created.error);
+            reportInstanceFailure(
+              c,
+              inst,
+              created.error,
+              inst.instanceCount * uniformStrideBytes,
+              MAX_UNIFORM_INSTANCES * uniformStrideBytes
+            );
+            return null;
+          }
+          if (previous !== void 0 && !previous.buffer.isDestroyed) {
+            const destroyed = previous.buffer.destroy();
+            if (!destroyed.ok) runtime.errorRegistry.fire(destroyed.error);
+          }
+          active = {
+            buffer: new GpuBuffer(runtime.device, created.value),
+            uploadedArchVersion: inst.archVersion,
+            uploadedByteLength: payloadBytes
+          };
+          activeIsNew = true;
+          chunks?.set(chunkKey, active);
+          if (chunks === void 0) frameState.transientInstanceBuffers.push(active);
         }
-        const buffer = new GpuBuffer(runtime.device, bufRes.value);
-        frameState.transientInstanceBuffers.push({
-          buffer,
-          uploadedArchVersion: inst.archVersion,
-          uploadedByteLength: chunk.byteLength
-        });
-        const writeRes = runtime.device.queue.writeBuffer(buffer.handle, 0, chunk);
-        if (!writeRes.ok) {
-          runtime.errorRegistry.fire(writeRes.error);
-          return null;
+        const needsUpload = activeIsNew || !sameRevision(active);
+        const rangesToUpload = [
+          {
+            start: 0,
+            end: count
+          }
+        ];
+        if (needsUpload && rangesToUpload.length > 0) {
+          const upload = uploadInstanceRanges(
+            c,
+            inst,
+            active.buffer.handle,
+            rangesToUpload,
+            false,
+            start
+          );
+          for (const range of upload.ranges) {
+            uploadedRanges.push({ start: range.start + start, end: range.end + start });
+          }
+          uploadedBytes += upload.bytes;
+          if (!upload.ok) {
+            reportInstanceFailure(
+              c,
+              inst,
+              {
+                code: "queue-write-buffer-failed",
+                expected: "the renderer-owned instance uniform buffer accepts the complete instance payload",
+                hint: "retry after the active device is healthy or recover the renderer"
+              },
+              inst.instanceCount * uniformStrideBytes,
+              MAX_UNIFORM_INSTANCES * uniformStrideBytes
+            );
+            return null;
+          }
+        }
+        if (needsUpload) {
+          const published = { ...active, uploadedRevision: revision };
+          active = published;
+          chunks?.set(chunkKey, published);
         }
         draws.push({
-          instanceBuffer: buffer.handle,
+          instanceBuffer: active.buffer.handle,
           instanceBindGroup: resolveGeometryInstancesBindGroup(
             c,
-            buffer.handle,
+            active.buffer.handle,
             probeBinding?.buffer
           ),
           probeOffset: probeBinding?.offset ?? -1,
           instanceCount: count
         });
       }
+      if (chunks !== void 0) {
+        const prefix = `${ownerKey}:`;
+        for (const [key, stale] of chunks.entries()) {
+          if (!key.startsWith(prefix) || activeKeys.has(key)) continue;
+          if (!stale.buffer.isDestroyed) {
+            const destroyed = stale.buffer.destroy();
+            if (!destroyed.ok) runtime.errorRegistry.fire(destroyed.error);
+          }
+          chunks.delete(key);
+        }
+      }
+      reportInstanceResidency(c, inst, {
+        lane: "chunked-uniform",
+        requestedBytes: inst.instanceCount * uniformStrideBytes,
+        supportedBytes: MAX_UNIFORM_INSTANCES * uniformStrideBytes,
+        uploadRanges: uploadedRanges,
+        uploadedBytes
+      });
       return draws;
     }
     if (uniformFallback) {
       instanceBufferUsage = GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST;
     }
     {
-      const instancePayload = uniformFallback ? inst.transforms : packInstanceStorageBuffer(inst.transforms);
-      const requestedBytes = instancePayload.byteLength;
+      const requestedBytes = inst.instanceCount * (uniformFallback ? 16 : INSTANCE_STORAGE_STRIDE_FLOATS) * Float32Array.BYTES_PER_ELEMENT;
       const cap = runtime.device.limits.maxStorageBufferBindingSize;
       if (!uniformFallback && typeof cap === "number" && cap > 0 && requestedBytes > cap) {
-        runtime.errorRegistry.fire(
-          new RhiError({
-            code: "limit-exceeded",
-            expected: `requestedBytes (${requestedBytes}) <= maxStorageBufferBindingSize (${cap})`,
-            hint: "reduce instance count to fit within device.limits.maxStorageBufferBindingSize, or split transforms across multiple Instances entries",
-            detail: {
-              maxStorageBufferBindingSize: cap,
-              requestedBytes
-            }
-          })
+        const chunked = resolveStorageInstanceChunks(
+          c,
+          entry,
+          inst,
+          cap,
+          probeBinding?.buffer,
+          probeBinding?.offset ?? -1
         );
-        return null;
+        return chunked;
       } else {
-        const cached = frameState.instanceBuffers.get(
-          worldEntityKey(entry.source.worldId, inst.cacheKey)
-        );
+        const cached = frameState.instanceBuffers.get(entityCacheKey);
         let active = null;
+        let activeIsNew = false;
         if (cached !== void 0 && cached.uploadedArchVersion === inst.archVersion && cached.uploadedByteLength === requestedBytes) {
           active = cached;
         } else if (requestedBytes > 0) {
@@ -5651,6 +6375,8 @@ 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();
@@ -5662,24 +6388,57 @@ function resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, useProbe
               uploadedArchVersion: inst.archVersion,
               uploadedByteLength: requestedBytes
             };
-            frameState.instanceBuffers.set(
-              worldEntityKey(entry.source.worldId, inst.cacheKey),
-              active
-            );
+            activeIsNew = true;
+            if (active !== null) {
+              frameState.instanceBuffers.set(entityCacheKey, active);
+            }
           }
         }
         if (active !== null) {
-          const writeRes = runtime.device.queue.writeBuffer(
-            active.buffer.handle,
-            0,
-            instancePayload
-          );
-          if (!writeRes.ok) {
-            runtime.errorRegistry.fire(writeRes.error);
-          } else {
-            instanceBuffer = active.buffer.handle;
-            instanceCount = Math.max(1, inst.instanceCount);
+          const needsUpload = activeIsNew || !sameRevision(active);
+          const ranges = [fullRange[0]];
+          let uploadRanges = [];
+          let uploadedBytes = 0;
+          if (needsUpload && ranges.length > 0) {
+            const upload = uploadInstanceRanges(
+              c,
+              inst,
+              active.buffer.handle,
+              ranges,
+              !uniformFallback
+            );
+            uploadRanges = upload.ranges;
+            uploadedBytes = upload.bytes;
+            if (!upload.ok) {
+              reportInstanceFailure(
+                c,
+                inst,
+                {
+                  code: "queue-write-buffer-failed",
+                  expected: "the renderer-owned instance buffer accepts the complete instance payloads",
+                  hint: "retry after the active device is healthy or recover the renderer"
+                },
+                requestedBytes,
+                uniformFallback ? MAX_UNIFORM_INSTANCES * Float32Array.BYTES_PER_ELEMENT * 16 : typeof cap === "number" ? cap : void 0
+              );
+              return null;
+            }
           }
+          if (needsUpload) {
+            const published = { ...active, uploadedRevision: revision };
+            frameState.instanceBuffers.set(entityCacheKey, published);
+            active = published;
+          }
+          instanceBuffer = active.buffer.handle;
+          instanceCount = Math.max(1, inst.instanceCount);
+          reportInstanceResidency(c, inst, {
+            lane: uniformFallback ? "direct-uniform" : "direct-storage",
+            requestedBytes,
+            supportedBytes: uniformFallback ? MAX_UNIFORM_INSTANCES * Float32Array.BYTES_PER_ELEMENT * 16 : typeof cap === "number" ? cap : void 0,
+            uploadRanges,
+            uploadedBytes
+          });
+          clearInstanceChunksForOwner(c, entityCacheKey);
         }
       }
     }
@@ -6125,9 +6884,10 @@ function recordSpriteEntityDraws(c, spritePass, matchedIndices, skylightResource
       spritePass.setVertexBuffer(0, spriteEntry.mesh.vertexBuffer.handle);
       lastSpriteVertexBuffer = spriteEntry.mesh.vertexBuffer;
     }
-    if (spriteEntry.mesh.indexBuffer !== null && spriteEntry.mesh.indexBuffer !== lastSpriteIndexBuffer) {
-      spritePass.setIndexBuffer(spriteEntry.mesh.indexBuffer.handle, spriteEntry.mesh.indexFormat);
-      lastSpriteIndexBuffer = spriteEntry.mesh.indexBuffer;
+    const indexBuffer = spriteEntry.mesh.indexBuffer;
+    if (indexBuffer !== null && indexBuffer !== lastSpriteIndexBuffer) {
+      spritePass.setIndexBuffer(indexBuffer.handle, spriteEntry.mesh.indexFormat);
+      lastSpriteIndexBuffer = indexBuffer;
     }
     let spriteInstanceBuffer = pipelineState.identityInstanceBuffer;
     let spriteInstanceCount = 1;
@@ -6216,7 +6976,7 @@ function recordSpriteEntityDraws(c, spritePass, matchedIndices, skylightResource
             new RhiError({
               code: "limit-exceeded",
               expected: `requestedBytes (${requestedBytes}) <= maxStorageBufferBindingSize (${cap})`,
-              hint: "reduce instance count to fit within device.limits.maxStorageBufferBindingSize, or split transforms across multiple Instances entries",
+              hint: "reduce the sprite batch to fit within device.limits.maxStorageBufferBindingSize or use a storage-capable backend",
               detail: {
                 maxStorageBufferBindingSize: cap,
                 requestedBytes
@@ -6282,6 +7042,7 @@ function recordSpriteEntityDraws(c, spritePass, matchedIndices, skylightResource
     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 spriteTexHandle = spriteEntry.source.material.baseColorTexture;
     let spriteTexView = pipelineState.defaultWhiteTextureView;
     if (spriteTexHandle !== void 0) {
@@ -6312,7 +7073,6 @@ function recordSpriteEntityDraws(c, spritePass, matchedIndices, skylightResource
       },
       bindGroupCounts
     );
-    const materialSlot = materialSlotIndices[i]?.[0] ?? 0;
     spritePass.setBindGroup(1, spritePassBg, [materialSlot * MATERIAL_PER_ENTITY_STRIDE]);
     spritePass.setBindGroup(3, spriteInstancesBg);
     spritePass.drawIndexed(spriteEntry.mesh.indexCount, spriteInstanceCount, 0, 0, 0);
@@ -6593,9 +7353,16 @@ function shadowShaderMap(c) {
         byMaterial = /* @__PURE__ */ new Map();
         shaders.set(entry.renderableIndex, byMaterial);
       }
+      const candidateSlots = c.materialSlotIndices[entry.renderableIndex] ?? c.materialSlotIndices.flat();
+      const materialSlot = candidateSlots.find(
+        (slot) => c.materialSlots[slot]?.materialHandle === entry.materialHandle
+      );
       byMaterial.set(entry.materialHandle, {
-        materialShaderId: entry.materialShaderId,
-        renderState: entry.renderState
+        materialHandle: entry.materialHandle,
+        materialShaderId: entry.materialShaderId === "forgeax::default-standard-pbr" ? SHADOW_CASTER_SHADER_ID : entry.materialShaderId,
+        renderState: entry.renderState,
+        materialSlot,
+        paramSnapshot: entry.paramSnapshot
       });
     }
   }
@@ -6826,67 +7593,23 @@ function recordShadowCasterDraws(c, shadowPass, shadowPipeline2, shadowMeshBindG
     } else {
       shadowPass.setBindGroup(2, shadowMeshBindGroup, [i * MESH_PER_ENTITY_STRIDE]);
     }
-    let shadowInstanceBuffer = pipelineState.identityInstanceBuffer;
-    let shadowInstanceCount = 1;
-    const shadowInst = entry.source.instances;
-    if (shadowInst?.instanceCount === 0) continue;
-    if (shadowInst !== void 0) {
-      const uniformFallback = runtime.device.caps.storageBuffer === false;
-      if (uniformFallback && shadowInst.instanceCount > MAX_UNIFORM_INSTANCES) {
-        shadowInstanceCount = shadowInst.instanceCount;
-        shadowInstanceBuffer = pipelineState.identityInstanceBuffer;
-      } else {
-        const bufUsage = uniformFallback ? GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST : GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST;
-        const instancePayload = uniformFallback ? shadowInst.transforms : packInstanceStorageBuffer(shadowInst.transforms);
-        const requestedBytes = instancePayload.byteLength;
-        const cached = c.frameState.instanceBuffers.get(
-          worldEntityKey(entry.source.worldId, shadowInst.cacheKey)
-        );
-        let active = null;
-        if (cached !== void 0 && cached.uploadedArchVersion === shadowInst.archVersion && cached.uploadedByteLength === requestedBytes) {
-          active = cached;
-        } else if (requestedBytes > 0) {
-          const bufRes = runtime.device.createBuffer({
-            size: requestedBytes,
-            usage: bufUsage,
-            mappedAtCreation: false
-          });
-          if (!bufRes.ok) {
-            runtime.errorRegistry.fire(bufRes.error);
-          } else {
-            if (cached !== void 0 && !cached.buffer.isDestroyed) {
-              const r = cached.buffer.destroy();
-              if (!r.ok) runtime.errorRegistry.fire(r.error);
-            }
-            const newBuffer = new GpuBuffer(runtime.device, bufRes.value);
-            active = {
-              buffer: newBuffer,
-              uploadedArchVersion: shadowInst.archVersion,
-              uploadedByteLength: requestedBytes
-            };
-            c.frameState.instanceBuffers.set(
-              worldEntityKey(entry.source.worldId, shadowInst.cacheKey),
-              active
-            );
-          }
-        }
-        if (active !== null) {
-          const writeRes = runtime.device.queue.writeBuffer(
-            active.buffer.handle,
-            0,
-            instancePayload
-          );
-          if (!writeRes.ok) {
-            runtime.errorRegistry.fire(writeRes.error);
-          } else {
-            shadowInstanceBuffer = active.buffer.handle;
-            shadowInstanceCount = Math.max(1, shadowInst.instanceCount);
-          }
+    const shadowInstanceDraws = resolveGeometryInstanceBuffer(
+      c,
+      entry,
+      [
+        {
+          instanceBuffer: pipelineState.identityInstanceBuffer,
+          instanceBindGroup: resolveGeometryInstancesBindGroup(
+            c,
+            pipelineState.identityInstanceBuffer
+          ),
+          instanceCount: 1,
+          probeOffset: -1
         }
-      }
-    }
-    const shadowInstancesBg = resolveGeometryInstancesBindGroup(c, shadowInstanceBuffer);
-    shadowPass.setBindGroup(3, shadowInstancesBg);
+      ],
+      false
+    );
+    if (shadowInstanceDraws === null) continue;
     for (const sm of shadowSubmeshes) {
       if (sm.topology !== "triangle-list" && sm.topology !== "triangle-strip") {
         continue;
@@ -6916,10 +7639,13 @@ function recordShadowCasterDraws(c, shadowPass, shadowPipeline2, shadowMeshBindG
         shadowPass.setPipeline(entryShadowPipeline);
         shadowLastPipeline = entryShadowPipeline;
       }
-      if (entry.mesh.indexed) {
-        shadowPass.drawIndexed(sm.indexCount, shadowInstanceCount, sm.indexOffset, 0, 0);
-      } else {
-        shadowPass.draw(sm.vertexCount, shadowInstanceCount, 0, 0);
+      for (const instanceDraw of shadowInstanceDraws) {
+        shadowPass.setBindGroup(3, instanceDraw.instanceBindGroup);
+        if (entry.mesh.indexed) {
+          shadowPass.drawIndexed(sm.indexCount, instanceDraw.instanceCount, sm.indexOffset, 0, 0);
+        } else {
+          shadowPass.draw(sm.vertexCount, instanceDraw.instanceCount, 0, 0);
+        }
       }
     }
   }
@@ -6983,7 +7709,13 @@ function ensureSpotShadowMaterialBg(c) {
 
 // src/record/main-pass.ts
 var ZERO_SKYLIGHT_PAYLOAD = new Float32Array([0, 0, 0, 0, 0, 0, 0, 1]);
-var TRANSMISSION_VARIANT_SET = "TRANSMISSION_AVAILABLE=true";
+function materialDiagnosticsEnabled3() {
+  if (typeof globalThis !== "object" || globalThis === null || !("process" in globalThis)) {
+    return false;
+  }
+  const processValue = globalThis.process;
+  return processValue?.env?.FORGEAX_MATERIAL_DIAGNOSTICS === "1";
+}
 function isTransmissionMaterial(material) {
   return material.materialShaderId === "forgeax::default-standard-pbr" && typeof material.paramSnapshot?.transmission === "number" && material.paramSnapshot.transmission > 0;
 }
@@ -7103,11 +7835,7 @@ function recordMainPass(c, selector, options, graphPass) {
   const matchedMaterials = matchedMaterialsForRecordMode(c, selectorMatchedMaterials, recordMode);
   const recordContext = recordMode === void 0 ? c : {
     ...c,
-    splitLdrSprite: recordMode === "transparent" ? false : c.splitLdrSprite,
-    validatedOrdered: c.validatedOrdered.map((entry) => ({
-      ...entry,
-      ...recordMode === "transmission" ? { variantSet: TRANSMISSION_VARIANT_SET } : {}
-    }))
+    splitLdrSprite: recordMode === "transparent" ? false : c.splitLdrSprite
   };
   if (clusteredBindGroupMissing) {
     runtime.errorRegistry.fire(
@@ -7161,6 +7889,62 @@ function recordMainPass(c, selector, options, graphPass) {
       brdfLutSampler: skylightFallback.sampler,
       intensityBuffer: skylightFallback.intensityBuffer
     };
+    if (materialDiagnosticsEnabled3()) {
+      const activeCache = activeViews === void 0 ? void 0 : getOrCreateIblCache(runtime.deviceScope);
+      const prefilterViewMipCount = activeCache?.prefilterFaceViewsByMip?.length ?? (activeViews === void 0 ? 1 : 0);
+      frameState.iblBindingInspection = {
+        status: "binding-chain-consistent",
+        frameId: frameState.frameNumber,
+        deviceGeneration: runtime.deviceScope.generation,
+        active: activeViews === void 0 ? "fallback" : "active",
+        cache: {
+          identity: getOpaqueResourceIdentity(activeCache ?? skylightFallback),
+          generation: runtime.deviceScope.generation,
+          prefilterMipCount: prefilterViewMipCount,
+          prefilterViewMipCount
+        },
+        sampler: {
+          expected: {
+            magFilter: "linear",
+            minFilter: "linear",
+            mipmapFilter: "linear",
+            addressModeU: "clamp-to-edge",
+            addressModeV: "clamp-to-edge",
+            addressModeW: "clamp-to-edge"
+          },
+          identities: [
+            getOpaqueResourceIdentity(skylightResources.irradianceSampler),
+            getOpaqueResourceIdentity(skylightResources.prefilterSampler),
+            getOpaqueResourceIdentity(skylightResources.brdfLutSampler)
+          ]
+        },
+        resources: {
+          irradiance: {
+            viewIdentity: getOpaqueResourceIdentity(skylightResources.irradianceView),
+            samplerIdentity: getOpaqueResourceIdentity(
+              skylightResources.irradianceSampler
+            ),
+            deviceGeneration: runtime.deviceScope.generation
+          },
+          prefilter: {
+            viewIdentity: getOpaqueResourceIdentity(skylightResources.prefilterView),
+            samplerIdentity: getOpaqueResourceIdentity(
+              skylightResources.prefilterSampler
+            ),
+            deviceGeneration: runtime.deviceScope.generation
+          },
+          brdfLut: {
+            viewIdentity: getOpaqueResourceIdentity(skylightResources.brdfLutView),
+            samplerIdentity: getOpaqueResourceIdentity(skylightResources.brdfLutSampler),
+            deviceGeneration: runtime.deviceScope.generation
+          },
+          intensityBufferIdentity: getOpaqueResourceIdentity(
+            skylightResources.intensityBuffer
+          )
+        },
+        errors: []
+      };
+    }
     const perSubmeshMaterialBgDeps = {
       runtime,
       pipelineState,
@@ -7196,6 +7980,7 @@ function recordMainPass(c, selector, options, graphPass) {
       },
       materialBgShared: frameState.materialBgShared,
       materialBgAssemblyCache: c.materialBgAssemblyCache,
+      frameState,
       bindGroupCounts,
       ...transmissionBackdropView === void 0 ? {} : { transmissionBackdropView }
     };
@@ -7225,6 +8010,20 @@ function recordMainPass(c, selector, options, graphPass) {
         const materialShaderId = mat.materialShaderId;
         const schema = mat.materialParamSchema ?? (materialShaderId !== void 0 ? runtime.getParamSchema?.(materialShaderId) : void 0);
         applyParamSnapshotToUbo(slotPayloadF32, schema, mat.paramSnapshot);
+        const processValue = globalThis.process;
+        if (processValue?.env?.FORGEAX_MATERIAL_PIPELINE_DIAGNOSTICS === "1" && (materialShaderId === "forgeax::default-standard-pbr" || materialShaderId === "forgeax::pbr-skin")) {
+          console.error(
+            `[render-material] UBO receipt: ${JSON.stringify({
+              entityIndex: entry.renderableIndex,
+              materialHandle: mat.materialHandle,
+              materialShaderId,
+              clearcoat: slotPayloadF32[32],
+              clearcoatRoughness: slotPayloadF32[33],
+              clearcoatNormalScale: slotPayloadF32[34],
+              paramSnapshot: mat.paramSnapshot
+            })}`
+          );
+        }
         applyMaterialTextureUvScales(slotPayloadF32, mat, world);
         {
           const matHandleRaw = mat.baseColorTexture;
@@ -9184,6 +9983,6 @@ function addTaaResolvePass(graph, current, currentTemporal, previousColor, previ
   });
 }
 
-export { BYTES_PER_DIRECT_LIGHT_SLOT, CAPTURE_VIEW_PROJS, CUBEMAP_FACE_VERTICES, CUBE_CAPTURE_VIEW_SLOT_BASE, DEFERRED_COLOR_FORMATS, DEPTH_MIN_PARAMS_BYTE_SIZE, FALLBACK_BYTES_PER_ROW, GpuBuffer, GpuTexture, MATERIAL_PER_ENTITY_STRIDE, MESH_SSBO_BYTES, 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, TYPED_BLOOM_PASS_NAMES, VIEW_UNIFORM_BUFFER_SIZE, VIEW_UNIFORM_BYTES, VIEW_UNIFORM_SLOT_STRIDE, abortTemporalGpuSubmit, addReflectionFallbackObservationPass, addStandardSceneDataPass, addTaaResolvePass, addTypedBloomPasses, addTypedCompositePostEffects, addTypedFrameObservationPass, addTypedFullscreenPass, addTypedOutputTransformPass, addTypedScenePass, addTypedSkyboxPass, addTypedSsaoPasses, addTypedTemporalResolvePass, aggregateTemporalDemand, 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, deriveRenderDataCubemap, deriveRenderDataMesh, deriveRenderDataTexture, describeTemporalDemand, driveLazyEquirectProjection, encodeDirectionalShadowPass, encodeMainPass, encodePointShadowPass, encodeSpotShadowPass, ensureMeshSsboCapacity, entryHasDepthRead, evaluateFoldBucketUniformCap, foldDispatchBuckets, geometryRenderStateForTopology, getOrBuildPipeline, getOrCreateHdrpBuffers, getOrCreateIblCache, getTemporalGpuState, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, incrementFoldedDrawsMetric, isTemporalFullscreenBinding, postProcessShaderEntrySignature, postProcessShaderModuleLabel, postProcessShaderPipelineLabel, prepareFrameLighting, resetHdrpBuffers, residentTextureView, resolveOutputDither, resolveSkyboxActive, resolveSsaoParameters, resolveSurfaceFormatPair, resolveSurfaceProfile, retireTemporalGpuState, retireTemporalGpuStateAfterFence, runIblPrecompute, selectLazyEquirectHandle, selectSwapChainFormat, setIblComposedShaders, standardTemporalLaneAdmission, standardTemporalPostOrder, temporalReadIndex, temporalWriteIndex, typedFrameClearColor, uploadMeshSsboBatch, variantSetFromDefines, warnMultiSkybox, warnMultiSkylight, warnZeroLightStandard, writeHdrpClusterAndSsaoBuffers, writePointsLinesViewUbo, writeShadowCasterUniforms, writeShadowParamsBuffer, writeSpotModifierTextures, writeViewUbo };
-//# sourceMappingURL=chunk-ZUWKAZ2I.mjs.map
-//# sourceMappingURL=chunk-ZUWKAZ2I.mjs.map
+export { BYTES_PER_DIRECT_LIGHT_SLOT, CAPTURE_VIEW_PROJS, CUBEMAP_FACE_VERTICES, CUBE_CAPTURE_VIEW_SLOT_BASE, DEFERRED_COLOR_FORMATS, DEPTH_MIN_PARAMS_BYTE_SIZE, FALLBACK_BYTES_PER_ROW, GpuBuffer, GpuTexture, InstanceProjectionStore, MATERIAL_PER_ENTITY_STRIDE, MESH_SSBO_BYTES, 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, TYPED_BLOOM_PASS_NAMES, VIEW_UNIFORM_BUFFER_SIZE, VIEW_UNIFORM_BYTES, VIEW_UNIFORM_SLOT_STRIDE, abortTemporalGpuSubmit, addReflectionFallbackObservationPass, addStandardSceneDataPass, addTaaResolvePass, addTypedBloomPasses, addTypedCompositePostEffects, addTypedFrameObservationPass, addTypedFullscreenPass, addTypedOutputTransformPass, addTypedScenePass, addTypedSkyboxPass, addTypedSsaoPasses, addTypedTemporalResolvePass, aggregateTemporalDemand, 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, deriveRenderDataCubemap, deriveRenderDataMesh, deriveRenderDataTexture, describeTemporalDemand, driveLazyEquirectProjection, encodeDirectionalShadowPass, encodeMainPass, encodePointShadowPass, encodeSpotShadowPass, ensureMeshSsboCapacity, entryHasDepthRead, evaluateFoldBucketUniformCap, foldDispatchBuckets, geometryRenderStateForPass, geometryRenderStateForTopology, getOrBuildPipeline, getOrCreateHdrpBuffers, getOrCreateIblCache, getTemporalBindGroupResources, getTemporalGpuState, getTemporalParamsBuffer, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, incrementFoldedDrawsMetric, isTemporalFullscreenBinding, passKindPolicyTable, postProcessShaderEntrySignature, postProcessShaderModuleLabel, postProcessShaderPipelineLabel, prepareFrameLighting, resetHdrpBuffers, residentTextureView, resolveGeometryInstanceBuffer, resolveOutputDither, resolveSkyboxActive, resolveSsaoParameters, resolveSurfaceFormatPair, resolveSurfaceProfile, retireTemporalGpuState, retireTemporalGpuStateAfterFence, runIblPrecompute, selectLazyEquirectHandle, selectSwapChainFormat, setIblComposedShaders, standardStorageVariantSet, standardTemporalLaneAdmission, standardTemporalPostOrder, standardTopologyVariantSet, temporalReadIndex, temporalWriteIndex, typedFrameClearColor, uploadMeshSsboBatch, variantSetFromDefines, variantSetFromVertexLayoutProjection, warnMultiSkybox, warnMultiSkylight, warnZeroLightStandard, writeHdrpClusterAndSsaoBuffers, writePointsLinesViewUbo, writeShadowCasterUniforms, writeShadowParamsBuffer, writeSpotModifierTextures, writeViewUbo };
+//# sourceMappingURL=chunk-TCLDX7SZ.mjs.map
+//# sourceMappingURL=chunk-TCLDX7SZ.mjs.map