@forgeax/engine-render 0.1.24 → 0.1.26

package/dist/{chunk-YRUYGA4A.mjs → chunk-TMIASV2N.mjs}

@@ -1,12 +1,12 @@
 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-TFH5I7JJ.mjs';
-import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-YKB5DQV7.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, getOpaqueResourceIdentity, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, physicalTextureFields, isCanonicalStandardPbrMaterialShader, isStandardPbrSkinMaterialShader, SKIN_MATERIAL_SHADER_ID, PROBE_BLEND_RECORD_BYTE_SIZE, resolveRenderTargetMaterialSource, probeBlendRecordOffset, PROBE_BLEND_RECORD_STRIDE, materialBindGroupLayoutIdentity } from './chunk-KZFTK6DO.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-RR5L4SRS.mjs';
-import { derive, ok, err as err$1, toShared, ASSET_ERROR_HINTS, deriveTextureLayout, handleSlot, KNOWN_PASS_KINDS, resolveMaterialTextureCoordinates } 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-GF523LHF.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, isStandardPbrMaterialShader, worldEntityKey, instanceCollectionCacheKey, probeBlendRecordOffset, PROBE_BLEND_RECORD_STRIDE, pbrSkinMeshDynamicOffsets, SHADOW_CASTER_SHADER_ID, buildPbrMaterialUserRegionEntries, buildBindGroupLayoutDescriptor, PROBE_BLEND_RECORD_BYTE_SIZE, shadowCasterVariantSet, COOKIE_MATRIX_BYTES, matchPass, createPbrSkinMeshBindGroupEntries, physicalTextureFields, isCanonicalStandardPbrMaterialShader, getOpaqueResourceIdentity, resolveRenderTargetMaterialSource, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, isStandardPbrSkinMaterialShader, SKIN_MATERIAL_SHADER_ID, 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, VideoUploadUnsupportedError, StandardClusterIndexOverflowError, FXAA_POST_PROCESS_ID } from './chunk-ZZ4YQ474.mjs';
+import { derive, ok, err as err$1, toShared, ASSET_ERROR_HINTS, deriveTextureLayout, handleSlot, resolveMaterialTextureCoordinates, KNOWN_PASS_KINDS } 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, STANDARD_PIPELINE_PARAM_SCHEMA, DEFAULT_MSDF_TEXT_PARAM_SCHEMA, DEFAULT_SPRITE_PARAM_SCHEMA, DEFAULT_UNLIT_PARAM_SCHEMA } from '@forgeax/engine-shader';
@@ -231,7 +231,7 @@ function cacheKeyOf(spec) {
     stripSegment,
     `vl:${vlDigest}`,
     renderStateHash(renderState)
-  ].join(":") + uvSetCountSegment;
+  ].join(":") + uvSetCountSegment + (shader.vertexEntry === void 0 && shader.fragmentEntry === void 0 ? "" : `:entries:${JSON.stringify([shader.vertexEntry ?? null, shader.fragmentEntry ?? null])}`);
 }
 function variantSetFromVertexLayoutProjection(projection, authoredVariantSet) {
   const projected = projection.attributes.some((attribute) => attribute.key === "color");
@@ -283,29 +283,20 @@ 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,
-      entryPoint: modules.vertexEntryPoint ?? "vs_main",
+      entryPoint: spec.shader.vertexEntry ?? modules.vertexEntryPoint ?? "vs_main",
       buffers: vertexBuffers
     }
   };
   if (attachments.colorFormats.length > 0) {
     descriptor.fragment = {
       module: modules.fragment,
-      entryPoint: modules.fragmentEntryPoint ?? "fs_main",
+      entryPoint: spec.shader.fragmentEntry ?? modules.fragmentEntryPoint ?? "fs_main",
       targets: attachments.colorFormats.map((fmt) => {
         const target = { format: fmt };
         if (renderState?.blend !== void 0) {
@@ -4091,6 +4082,150 @@ 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, textureInjections = []) {
@@ -4565,14 +4700,6 @@ function isEntityFullyTransparent(source) {
   }
   return true;
 }
-function entityHasTransparentSubmesh(source) {
-  const mats = source.materials;
-  if (mats === void 0) return source.material.transparent === true;
-  for (let j = 0; j < mats.length; j++) {
-    if (mats[j]?.transparent === true) return true;
-  }
-  return false;
-}
 function isImageError(error) {
   if (typeof error !== "object" || error === null) return false;
   const code = error.code;
@@ -4939,7 +5066,7 @@ function isMaterialBgAssemblyCacheHit(cached, material, materialBgl, materialBuf
   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;
 }
-function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWorld = deps.world) {
+function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWorld = deps.world, materialShaderId = submeshMaterial.materialShaderId) {
   const {
     runtime,
     pipelineState,
@@ -4957,9 +5084,9 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
   } = deps;
   const effectiveSkylightResources = resolveReflectionProbeResources?.(materialWorld, entityKey) ?? skylightResources;
   const smMaterialHandle = submeshMaterial.materialHandle;
-  const materialCacheKey = smMaterialHandle === void 0 ? void 0 : `${materialWorld.identity}:${smMaterialHandle}`;
+  const materialCacheKey = smMaterialHandle === void 0 ? void 0 : `${materialWorld.identity}:${smMaterialHandle}:${materialShaderId ?? ""}`;
   const smHasVideoFields = (submeshMaterial.videoTextureFields?.size ?? 0) > 0;
-  const smShaderId = submeshMaterial.materialShaderId;
+  const smShaderId = materialShaderId;
   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;
@@ -5191,6 +5318,52 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
   }
   return smBindGroup;
 }
+var ZERO_SKYLIGHT_PAYLOAD = new Float32Array([0, 0, 0, 0, 0, 0, 0, 1]);
+function prepareMaterialSkylight(c) {
+  const { runtime, pipelineState, skylight, skylightCount } = c;
+  const skylightFallback = pipelineState.skylightFallback;
+  if (skylightFallback === null) {
+    throw new RhiError({
+      code: "webgpu-runtime-error",
+      expected: "pipelineState.skylightFallback != null when PBR pipeline is active",
+      hint: "createRenderer must allocate skylightFallback alongside the PBR pipeline (D-5 round-4)"
+    });
+  }
+  let activeViews;
+  runtime.device.queue.writeBuffer(skylightFallback.intensityBuffer, 0, ZERO_SKYLIGHT_PAYLOAD);
+  if (skylight !== void 0 && skylightCount >= 1) {
+    const [cr, cg, cb] = skylight.color;
+    const [qx, qy, qz, qw] = skylight.rotation;
+    const uniformPayload = new Float32Array([skylight.intensity, cr, cg, cb, qx, qy, qz, qw]);
+    runtime.device.queue.writeBuffer(skylightFallback.intensityBuffer, 0, uniformPayload);
+    const cache3 = getOrCreateIblCache(runtime.deviceScope);
+    if (cache3.irradianceView !== void 0 && cache3.prefilterView !== void 0 && cache3.brdfLutView !== void 0) {
+      activeViews = {
+        irr: cache3.irradianceView,
+        pref: cache3.prefilterView,
+        brdf: cache3.brdfLutView
+      };
+    }
+  }
+  const skylightResources = activeViews !== void 0 ? {
+    irradianceView: activeViews.irr,
+    irradianceSampler: skylightFallback.sampler,
+    prefilterView: activeViews.pref,
+    prefilterSampler: skylightFallback.sampler,
+    brdfLutView: activeViews.brdf,
+    brdfLutSampler: skylightFallback.sampler,
+    intensityBuffer: skylightFallback.intensityBuffer
+  } : {
+    irradianceView: skylightFallback.irradianceView,
+    irradianceSampler: skylightFallback.sampler,
+    prefilterView: skylightFallback.prefilterView,
+    prefilterSampler: skylightFallback.sampler,
+    brdfLutView: skylightFallback.brdfLutView,
+    brdfLutSampler: skylightFallback.sampler,
+    intensityBuffer: skylightFallback.intensityBuffer
+  };
+  return { skylightResources, activeViews };
+}
 
 // src/record/main-pass-geometry.ts
 function materialDiagnosticsEnabled2() {
@@ -5318,7 +5491,7 @@ function recordPointsLinesDraw(pass, plan) {
   }
   pass.draw(plan.vertexCount, 1, 0, 0);
 }
-function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sampleCount, meshGroup2, meshBindGroup, resolveMaterialBindGroup, passKind = "forward") {
+function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sampleCount, meshGroup2, meshBindGroup, resolveMaterialBindGroup, passKind = "forward", selectedDispatch) {
   const {
     runtime,
     pipelineState,
@@ -5332,6 +5505,17 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
     viewBindGroup,
     viewBindGroupDynamicOffset = 0
   } = c;
+  const materialPasses = /* @__PURE__ */ new Map();
+  for (const dispatch of selectedDispatch ?? []) {
+    let byMaterial = materialPasses.get(dispatch.renderableIndex);
+    if (byMaterial === void 0) {
+      byMaterial = /* @__PURE__ */ new Map();
+      materialPasses.set(dispatch.renderableIndex, byMaterial);
+    }
+    const passes = byMaterial.get(dispatch.materialHandle);
+    if (passes === void 0) byMaterial.set(dispatch.materialHandle, [dispatch]);
+    else passes.push(dispatch);
+  }
   const diagnosticsEnabled = materialDiagnosticsEnabled2();
   const colorFormatOverride = c.transparentColorFormat;
   const clusteredLighting = c.standardLighting?.kind === "clustered";
@@ -5360,19 +5544,19 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
   const recordOcclusionCandidate = (draw) => {
     draw();
   };
-  const resolveMaterialPipeline = (materialShaderId, renderState, topology, indexFormat, variantSet, colorFormat, layoutProjection) => {
+  const resolveMaterialPipeline = (materialShaderId, renderState, topology, indexFormat, variantSet, colorFormat, layoutProjection, vertexEntry, fragmentEntry) => {
     const reflectionFallbackFormats = materialShaderId === "forgeax::default-standard-pbr" && c.reflectionFallbackColorFormat !== void 0 ? [c.reflectionFallbackColorFormat] : void 0;
     const renderStateKey = renderStateHash(renderState);
     const shaderLookupCache = materialPipelineLookupCache.get(materialShaderId);
     const cachedLookups = shaderLookupCache?.get(renderStateKey);
     if (cachedLookups !== void 0) {
       for (const cached of cachedLookups) {
-        if (cached.isHdrTarget === isHdrTarget && cached.renderStateKey === renderStateKey && cached.topology === topology && cached.indexFormat === indexFormat && cached.variantSet === variantSet && cached.passKind === passKind && cached.layoutProjection.digest === layoutProjection.digest && cached.sampleCount === sampleCount && cached.colorFormatOverride === colorFormat && cached.additionalColorFormats?.join(",") === reflectionFallbackFormats?.join(",")) {
+        if (cached.isHdrTarget === isHdrTarget && cached.renderStateKey === renderStateKey && cached.topology === topology && cached.indexFormat === indexFormat && cached.variantSet === variantSet && cached.vertexEntry === vertexEntry && cached.fragmentEntry === fragmentEntry && cached.passKind === passKind && cached.layoutProjection.digest === layoutProjection.digest && cached.sampleCount === sampleCount && cached.colorFormatOverride === colorFormat && cached.additionalColorFormats?.join(",") === reflectionFallbackFormats?.join(",")) {
           return cached.handle;
         }
       }
     }
-    const resolvedVariantSetResult = variantSet === void 0 && (materialShaderId === "forgeax::sprite" || materialShaderId === "forgeax::sprite-lit") ? { ok: true, value: void 0 } : variantSetFromVertexLayoutProjection(layoutProjection, variantSet);
+    const resolvedVariantSetResult = runtime.getMaterialArtifact?.(materialShaderId) !== void 0 ? { ok: true, value: void 0 } : variantSet === void 0 && (materialShaderId === "forgeax::sprite" || materialShaderId === "forgeax::sprite-lit") ? { ok: true, value: void 0 } : variantSetFromVertexLayoutProjection(layoutProjection, variantSet);
     if (!resolvedVariantSetResult.ok) {
       runtime.errorRegistry.fire(resolvedVariantSetResult.error);
       return null;
@@ -5396,7 +5580,9 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
       layoutProjection,
       void 0,
       void 0,
-      reflectionFallbackFormats
+      reflectionFallbackFormats,
+      vertexEntry,
+      fragmentEntry
     ) ?? null;
     const handle = profilePhase === void 0 ? resolvePipeline() : profileGeometrySegment(c, passKind, "pipeline-selection", resolvePipeline);
     if (handle !== null) {
@@ -5407,6 +5593,8 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
         topology,
         indexFormat,
         variantSet,
+        vertexEntry,
+        fragmentEntry,
         passKind,
         layoutProjection,
         sampleCount,
@@ -5442,7 +5630,8 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
       continue;
     }
     if (matchedMaterials !== null && !matchedMaterials.has(entry.renderableIndex)) continue;
-    if (splitLdrSprite && isEntityFullyTransparent(entry.source)) continue;
+    if (selectedDispatch === void 0 && splitLdrSprite && isEntityFullyTransparent(entry.source))
+      continue;
     const stencilReference = entry.stencilReference ?? 0;
     if (stencilReference !== lastStencilReference) {
       pass.setStencilReference(stencilReference);
@@ -5658,182 +5847,180 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
         const materialHandle = submeshMaterial.materialHandle ?? 0;
         if (materialHandles === void 0 || !materialHandles.has(materialHandle)) continue;
       }
-      if (splitLdrSprite && submeshMaterial.transparent === true) {
-        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,
-        entry.source.entityKey,
-        entry.world ?? c.world
-      ) : profileGeometrySegment(
-        c,
-        passKind,
-        "material-bind-groups",
-        () => resolveMaterialBindGroup(
+      const draws = selectedDispatch === void 0 ? [void 0] : materialPasses.get(entry.renderableIndex)?.get(submeshMaterial.materialHandle ?? 0) ?? [];
+      for (const selectedPass of draws) {
+        const selectedShaderId = selectedPass === void 0 ? submeshMaterial.materialShaderId : selectedPass.materialShaderId;
+        const selectedRenderState = selectedPass === void 0 ? submeshMaterial.renderState : selectedPass.renderState;
+        const selectedStencil = (selectedPass === void 0 ? entry.stencilReference : selectedPass.stencilReference) ?? 0;
+        if (selectedStencil !== lastStencilReference) {
+          pass.setStencilReference(selectedStencil);
+          lastStencilReference = selectedStencil;
+        }
+        if (splitLdrSprite && (selectedPass === void 0 ? submeshMaterial.transparent === true : selectedRenderState?.blend !== void 0)) {
+          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,
           entry.source.entityKey,
-          entry.world ?? c.world
-        )
-      );
-      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 ? 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 ? {
-        ...submeshMaterial.renderState,
-        depthWriteEnabled: false,
-        depthCompare: "less-equal",
-        cullMode: "none",
-        blend: submeshMaterial.renderState?.blend ?? SPRITE_PREMULTIPLIED_ALPHA_BLEND
-      } : geometryRenderStateForTopology(smTopology, submeshMaterial.renderState);
-      const pipelineRenderState = geometryRenderStateForPass(basePipelineRenderState, passKind);
-      let smPipelineHandle;
-      let materialGroup2Contract;
-      let materialPipelineEntry = null;
-      if (smMaterialShaderId === void 0 || smMaterialShaderId === "forgeax::default-unlit") {
-        const unlitShaderId = smMaterialShaderId ?? "forgeax::default-unlit";
-        const unlitProjectionVariantResult = variantSetFromVertexLayoutProjection(
-          entry.mesh.layoutProjection,
-          void 0
+          entry.world ?? c.world,
+          selectedShaderId
+        ) : profileGeometrySegment(
+          c,
+          passKind,
+          "material-bind-groups",
+          () => resolveMaterialBindGroup(
+            materialSlot,
+            submeshMaterial,
+            entry.source.entityKey,
+            entry.world ?? c.world,
+            selectedShaderId
+          )
         );
-        if (!unlitProjectionVariantResult.ok) {
-          runtime.errorRegistry.fire(unlitProjectionVariantResult.error);
+        materialGroup1DynamicOffsets[0] = materialSlot * MATERIAL_PER_ENTITY_STRIDE;
+        pass.setBindGroup(1, perSubmeshBg, materialGroup1DynamicOffsets, 0, 1);
+        const smTopology = sm.topology;
+        const smMaterialShaderId = selectedPass !== void 0 ? selectedShaderId : entry.source.skin !== void 0 ? isStandardPbrSkinMaterialShader(submeshMaterial.materialShaderId) ? submeshMaterial.materialShaderId : SKIN_MATERIAL_SHADER_ID : submeshMaterial.materialShaderId;
+        const probeBlendAvailable = probeBlendRecordAvailable && isStandardPbrMaterialShader(smMaterialShaderId);
+        const isSpriteShader = smMaterialShaderId === "forgeax::sprite" || smMaterialShaderId === "forgeax::sprite-lit";
+        const basePipelineRenderState = isSpriteShader ? {
+          ...selectedRenderState,
+          depthWriteEnabled: false,
+          depthCompare: "less-equal",
+          cullMode: "none",
+          blend: selectedRenderState?.blend ?? SPRITE_PREMULTIPLIED_ALPHA_BLEND
+        } : geometryRenderStateForTopology(smTopology, selectedRenderState);
+        const pipelineRenderState = geometryRenderStateForPass(basePipelineRenderState, passKind);
+        let smPipelineHandle;
+        let materialGroup2Contract;
+        let materialPipelineEntry = null;
+        if (smMaterialShaderId === void 0 || smMaterialShaderId === "forgeax::default-unlit") {
+          const unlitShaderId = smMaterialShaderId ?? "forgeax::default-unlit";
+          const unlitProjectionVariantResult = variantSetFromVertexLayoutProjection(
+            entry.mesh.layoutProjection,
+            void 0
+          );
+          if (!unlitProjectionVariantResult.ok) {
+            runtime.errorRegistry.fire(unlitProjectionVariantResult.error);
+            continue;
+          }
+          const unlitHasColor = unlitProjectionVariantResult.value === "VERTEX_COLOR_AVAILABLE=true";
+          const unlitVariantSet = standardStorageVariantSet(
+            runtime.device.caps.storageBuffer,
+            unlitHasColor
+          );
+          const unlitRsp = resolveMaterialPipeline(
+            unlitShaderId,
+            pipelineRenderState,
+            smTopology,
+            entry.mesh.indexFormat,
+            unlitVariantSet,
+            colorFormatOverride,
+            entry.mesh.layoutProjection,
+            selectedPass?.vertexEntry,
+            selectedPass?.fragmentEntry
+          );
+          materialPipelineEntry = unlitRsp;
+          smPipelineHandle = unlitRsp?.pipeline ?? (colorFormatOverride === void 0 ? selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive) : null);
+        } else if (smMaterialShaderId !== void 0) {
+          const hasVertexColor = entry.mesh.layoutProjection.attributes.some(
+            (attribute) => attribute.key === "color"
+          );
+          const capabilityVariantSet = standardTopologyVariantSet(
+            c.standardLighting,
+            runtime.device.caps.storageBuffer,
+            hasVertexColor,
+            probeBlendAvailable
+          );
+          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,
+            smTopology,
+            entry.mesh.indexFormat,
+            variantSet,
+            colorFormatOverride,
+            entry.mesh.layoutProjection,
+            selectedPass?.vertexEntry,
+            selectedPass?.fragmentEntry
+          );
+          materialPipelineEntry = cachedPipeline;
+          smPipelineHandle = cachedPipeline?.pipeline ?? null;
+        } else {
+          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 unlitHasColor = unlitProjectionVariantResult.value === "VERTEX_COLOR_AVAILABLE=true";
-        const unlitVariantSet = standardStorageVariantSet(
-          runtime.device.caps.storageBuffer,
-          unlitHasColor
-        );
-        const unlitRsp = resolveMaterialPipeline(
-          unlitShaderId,
-          pipelineRenderState,
-          smTopology,
-          entry.mesh.indexFormat,
-          unlitVariantSet,
-          colorFormatOverride,
-          entry.mesh.layoutProjection
-        );
-        materialPipelineEntry = unlitRsp;
-        smPipelineHandle = unlitRsp?.pipeline ?? (colorFormatOverride === void 0 ? selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive) : null);
-      } else if (smMaterialShaderId !== void 0) {
-        const hasVertexColor = entry.mesh.layoutProjection.attributes.some(
-          (attribute) => attribute.key === "color"
-        );
-        const capabilityVariantSet = standardTopologyVariantSet(
-          c.standardLighting,
-          runtime.device.caps.storageBuffer,
-          hasVertexColor,
+        const instanceDraws2 = resolveGeometryInstanceBuffer(
+          c,
+          entry,
+          identityInstanceDraws,
           probeBlendAvailable
         );
-        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,
-          smTopology,
-          entry.mesh.indexFormat,
-          variantSet,
-          colorFormatOverride,
-          entry.mesh.layoutProjection
-        );
-        materialPipelineEntry = cachedPipeline;
-        smPipelineHandle = cachedPipeline?.pipeline ?? null;
-      } else {
-        smPipelineHandle = selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive);
-      }
-      if (smPipelineHandle === null) {
-        if (diagnosticsEnabled) {
+        if (instanceDraws2 === null) continue;
+        if (!isSkinEntry) {
+          materialGroup2Contract = materialPipelineEntry?.group2Contract;
+          if (materialGroup2Contract === void 0) continue;
+          const selectedGroup = selectMaterialGroup2(
+            meshGroup2,
+            meshBindGroup,
+            materialGroup2Contract
+          );
+          if (selectedGroup === null) continue;
+          group2BindGroup = selectedGroup;
+        }
+        if (diagnosticsEnabled && submeshMaterial.textureHandles !== void 0) {
           console.error(
-            `[render-material] draw skipped: ${JSON.stringify({
+            `[render-material] draw submitted: ${JSON.stringify({
               entityKey: entry.source.entityKey,
               materialHandle: submeshMaterial.materialHandle,
               shader: smMaterialShaderId,
-              reason: "pipeline-unavailable"
+              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
             })}`
           );
         }
-        continue;
-      }
-      const instanceDraws2 = resolveGeometryInstanceBuffer(
-        c,
-        entry,
-        identityInstanceDraws,
-        probeBlendAvailable
-      );
-      if (instanceDraws2 === null) continue;
-      if (!isSkinEntry) {
-        materialGroup2Contract = materialPipelineEntry?.group2Contract;
-        if (materialGroup2Contract === void 0) continue;
-        const selectedGroup = selectMaterialGroup2(
-          meshGroup2,
-          meshBindGroup,
-          materialGroup2Contract
-        );
-        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(
-          () => submitSubmeshDraws(
-            pass,
-            bindingState,
-            smPipelineHandle,
-            instanceDraws2,
-            entry.mesh.indexed,
-            sm.indexCount,
-            sm.vertexCount,
-            sm.indexOffset
-          )
-        );
-      } else {
-        profileGeometrySegment(
-          c,
-          passKind,
-          "draw-submit",
-          () => recordOcclusionCandidate(
+        pass.setBindGroup(2, group2BindGroup, group2DynamicOffsets);
+        if (profilePhase === void 0) {
+          recordOcclusionCandidate(
             () => submitSubmeshDraws(
               pass,
               bindingState,
@@ -5844,14 +6031,239 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
               sm.vertexCount,
               sm.indexOffset
             )
-          )
+          );
+        } else {
+          profileGeometrySegment(
+            c,
+            passKind,
+            "draw-submit",
+            () => recordOcclusionCandidate(
+              () => submitSubmeshDraws(
+                pass,
+                bindingState,
+                smPipelineHandle,
+                instanceDraws2,
+                entry.mesh.indexed,
+                sm.indexCount,
+                sm.vertexCount,
+                sm.indexOffset
+              )
+            )
+          );
+        }
+        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);
       }
-      if (diagnosticsEnabled && perSubmeshBg !== null) {
-        recordIblPipelineBinding(c, submeshMaterial, smPipelineHandle, perSubmeshBg);
+    }
+    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;
@@ -5877,74 +6289,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) {
@@ -5955,6 +6445,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();
@@ -5966,24 +6458,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);
         }
       }
     }
@@ -6123,8 +6648,13 @@ function interleaveSpriteInstanceBuffer(transforms, regions, includePrevious = f
 function spriteInstancesCacheHit(entry, snapshot, requestedBytes) {
   return entry !== void 0 && entry.uploadedArchVersion === snapshot.archVersion && entry.uploadedByteLength === requestedBytes;
 }
-function computeSplitLdrSprite(validatedOrdered, tonemapActive) {
+function computeSplitLdrSprite(validatedOrdered, tonemapActive, dispatch) {
   if (tonemapActive) return false;
+  if (dispatch !== void 0 && dispatch.length > 0) {
+    return dispatch.some(
+      (pass) => pass.tags.LightMode === "Forward" && pass.renderState?.blend !== void 0
+    );
+  }
   for (const entry of validatedOrdered) {
     if (entry === void 0) continue;
     const materials = entry.source.materials;
@@ -6136,7 +6666,7 @@ function computeSplitLdrSprite(validatedOrdered, tonemapActive) {
   }
   return false;
 }
-function recordSpritePass(c, pass, matchedIndices, materialSlotIndices, sampleCount, resolveMaterialBindGroup, skylightResources, graphPass) {
+function recordSpritePass(c, pass, matchedIndices, materialSlotIndices, sampleCount, resolveMaterialBindGroup, skylightResources, graphPass, selectedDispatch) {
   const {
     runtime,
     pipelineState,
@@ -6264,114 +6794,54 @@ function recordSpritePass(c, pass, matchedIndices, materialSlotIndices, sampleCo
       materialSlotIndices,
       sampleCount,
       resolveMaterialBindGroup,
-      meshGroup2
+      meshGroup2,
+      selectedDispatch
     );
     if (graphPass === void 0) spritePass.end();
   }
   return geometryPassEnded;
 }
-function recordSpriteTransparentPbrDraws(c, spritePass, matchedIndices, materialSlotIndices, sampleCount, resolveMaterialBindGroup, meshGroup2) {
-  const { runtime, pipelineState, validatedOrdered } = c;
-  const isHdrTarget = c.tonemapActive || transparentPassColorFormat(c, pipelineState) === "rgba16float";
-  let lastPbrSubPipelineHandle = null;
-  let lastPbrSubVertexBuffer = null;
-  let lastPbrSubIndexBuffer = null;
-  for (let i = 0; i < validatedOrdered.length; i++) {
-    const entry = validatedOrdered[i];
-    if (entry === void 0) continue;
-    if (matchedIndices !== null && !matchedIndices.has(entry.renderableIndex)) continue;
-    const entShaderId = entry.source.material.materialShaderId;
-    const entIsSprite = entShaderId === "forgeax::sprite" || entShaderId === "forgeax::sprite-lit";
-    if (entIsSprite) continue;
-    if (!entityHasTransparentSubmesh(entry.source)) continue;
-    if (entry.source.skin !== void 0 || entry.source.instances !== void 0) continue;
-    const matsForRebind = entry.source.materials;
-    if (entry.mesh.vertexBuffer !== lastPbrSubVertexBuffer) {
-      spritePass.setVertexBuffer(0, entry.mesh.vertexBuffer.handle);
-      lastPbrSubVertexBuffer = entry.mesh.vertexBuffer;
-    }
-    if (entry.mesh.indexed && entry.mesh.indexBuffer !== null && entry.mesh.indexBuffer !== lastPbrSubIndexBuffer) {
-      spritePass.setIndexBuffer(entry.mesh.indexBuffer.handle, entry.mesh.indexFormat);
-      lastPbrSubIndexBuffer = entry.mesh.indexBuffer;
+function recordSpriteTransparentPbrDraws(c, pass, matchedIndices, materialSlotIndices, sampleCount, resolveMaterialBindGroup, meshGroup2, selectedDispatch) {
+  const isSprite = (shader) => shader === "forgeax::sprite" || shader === "forgeax::sprite-lit";
+  const passes = selectedDispatch?.filter(
+    (entry) => entry.renderState?.blend !== void 0 && !isSprite(entry.materialShaderId) && (matchedIndices === null || matchedIndices.has(entry.renderableIndex))
+  );
+  const matched = /* @__PURE__ */ new Map();
+  const add = (index, handle) => {
+    let handles = matched.get(index);
+    if (handles === void 0) {
+      handles = /* @__PURE__ */ new Set();
+      matched.set(index, handles);
     }
-    for (let smIdx = 0; smIdx < entry.mesh.submeshes.length; smIdx++) {
-      const sm = entry.mesh.submeshes[smIdx];
-      if (sm === void 0) continue;
-      const matSlotIdx = sm.materialSlot;
-      const submeshMaterial = matsForRebind[matSlotIdx] ?? entry.source.material;
-      if (submeshMaterial.transparent !== true) continue;
-      const smShaderId = submeshMaterial.materialShaderId;
-      if (smShaderId === void 0) continue;
-      const probeBlendAvailable = runtime.device.caps.storageBuffer && entry.source.probeBlendRecord !== void 0 && isStandardPbrMaterialShader(smShaderId);
-      const probeBinding = probeBlendAvailable ? resolveProbeBlendBuffer(
-        c,
-        entry.source.probeBlendRecord,
-        worldEntityKey(entry.source.worldId, entry.source.entityKey)
-      ) : void 0;
-      const identityInstBg = resolveGeometryInstancesBindGroup(
-        c,
-        pipelineState.identityInstanceBuffer,
-        probeBinding?.buffer
-      );
-      if (probeBinding === void 0) spritePass.setBindGroup(3, identityInstBg);
-      else spritePass.setBindGroup(3, identityInstBg, [probeBinding.offset]);
-      const subVariantSet = standardTopologyVariantSet(
-        c.standardLighting,
-        runtime.device.caps.storageBuffer,
-        entry.mesh.layoutProjection.attributes.some((attribute) => attribute.key === "color"),
-        probeBlendAvailable
-      );
-      const projectionVariantSetResult = variantSetFromVertexLayoutProjection(
-        entry.mesh.layoutProjection,
-        subVariantSet
-      );
-      if (!projectionVariantSetResult.ok) {
-        runtime.errorRegistry.fire(projectionVariantSetResult.error);
-        continue;
-      }
-      const projectionVariantSet = projectionVariantSetResult.value;
-      const subPipelineEntry = c.runtime.getMaterialShaderPipelineEntry?.(
-        smShaderId,
-        isHdrTarget,
-        submeshMaterial.renderState,
-        sm.topology,
-        entry.mesh.indexFormat,
-        projectionVariantSet,
-        "forward",
-        void 0,
-        sampleCount,
-        // Non-sRGB blend view (same override the sprite path uses).
-        transparentPassColorFormat(c),
-        void 0,
-        void 0,
-        void 0,
-        entry.mesh.layoutProjection
-      ) ?? null;
-      if (subPipelineEntry === null) continue;
-      const submeshContract = subPipelineEntry.group2Contract;
-      const submeshGroup2 = selectMaterialGroup2(meshGroup2, c.meshBindGroup, submeshContract);
-      if (submeshGroup2 === null) continue;
-      spritePass.setBindGroup(2, submeshGroup2, [i * MESH_PER_ENTITY_STRIDE]);
-      const materialSlot = materialSlotIndices[i]?.[matSlotIdx] ?? materialSlotIndices[i]?.[0] ?? 0;
-      const subBg = resolveMaterialBindGroup(
-        materialSlot,
-        submeshMaterial,
-        entry.source.entityKey,
-        entry.world ?? c.world
-      );
-      spritePass.setBindGroup(1, subBg, [materialSlot * MATERIAL_PER_ENTITY_STRIDE]);
-      const subPipeline = subPipelineEntry.pipeline;
-      if (lastPbrSubPipelineHandle !== subPipeline) {
-        spritePass.setPipeline(subPipeline);
-        lastPbrSubPipelineHandle = subPipeline;
-      }
-      if (entry.mesh.indexed) {
-        spritePass.drawIndexed(sm.indexCount, 1, sm.indexOffset, 0, 0);
-      } else {
-        spritePass.draw(sm.vertexCount, 1, 0, 0);
+    handles.add(handle);
+  };
+  if (passes !== void 0) {
+    for (const entry of passes) add(entry.renderableIndex, entry.materialHandle);
+  } else {
+    for (const entry of c.validatedOrdered) {
+      if (matchedIndices !== null && !matchedIndices.has(entry.renderableIndex)) continue;
+      if (isSprite(entry.source.material.materialShaderId)) continue;
+      for (const material of entry.source.materials) {
+        if (material.transparent === true) add(entry.renderableIndex, material.materialHandle ?? 0);
       }
     }
   }
+  recordGeometryDraws(
+    {
+      ...c,
+      splitLdrSprite: false,
+      transparentColorFormat: transparentPassColorFormat(c)
+    },
+    pass,
+    matched,
+    materialSlotIndices,
+    sampleCount,
+    meshGroup2,
+    c.meshBindGroup,
+    resolveMaterialBindGroup,
+    "forward",
+    passes
+  );
 }
 function recordSpriteEntityDraws(c, spritePass, matchedIndices, skylightResources, spritePH, spritePH_withRegion, spriteLitPH, reportSpriteUnavailable) {
   const {
@@ -6521,7 +6991,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
@@ -6899,7 +7369,9 @@ function shadowShaderMap(c) {
         shaders.set(entry.renderableIndex, byMaterial);
       }
       byMaterial.set(entry.materialHandle, {
-        materialShaderId: entry.materialShaderId,
+        vertexEntry: entry.vertexEntry,
+        fragmentEntry: entry.fragmentEntry,
+        materialShaderId: entry.materialShaderId === "forgeax::default-standard-pbr" ? SHADOW_CASTER_SHADER_ID : entry.materialShaderId,
         renderState: entry.renderState
       });
     }
@@ -6982,13 +7454,15 @@ function encodeDirectionalShadowPass(c, pass, cascadeIndex, viewport) {
     `view-shadow-directional-${cascadeIndex}`
   );
   const materialBg = ensureSpotShadowMaterialBg(c);
-  if (pipeline === null || viewBg === null || materialBg === null) return;
-  c.frameState.directionalShadowCacheRecorded = true;
+  if (pipeline === null || viewBg === null || materialBg === null) {
+    c.frameState.directionalShadowCacheRecorded = false;
+    return;
+  }
   pass.setViewport(viewport.x, viewport.y, viewport.w, viewport.h, 0, 1);
   pass.setPipeline(pipeline);
   pass.setBindGroup(0, viewBg, [0, 0]);
   pass.setBindGroup(1, materialBg, [0]);
-  recordShadowCasterDraws(
+  const complete = recordShadowCasterDraws(
     c,
     pass,
     pipeline,
@@ -6996,6 +7470,7 @@ function encodeDirectionalShadowPass(c, pass, cascadeIndex, viewport) {
     buildMatchedRenderableIndices(c.dispatch, { LightMode: ["ShadowCaster"] }),
     shadowShaderMap(c)
   );
+  c.frameState.directionalShadowCacheRecorded = cascadeIndex === 0 ? complete : c.frameState.directionalShadowCacheRecorded && complete;
 }
 function encodePointShadowPass(c, pass, snapshotIndex, face) {
   const snapshot = c.frameState.pointShadowSnapshots[snapshotIndex];
@@ -7091,13 +7566,18 @@ function recordShadowCasterDraws(c, shadowPass, shadowPipeline2, shadowMeshBindG
   let shadowLastVertexBuffer = null;
   let shadowLastIndexBuffer = null;
   let shadowLastPipeline = shadowPipeline2;
+  let materialDeps;
+  let complete = true;
   for (let i = 0; i < validatedOrdered.length; i++) {
     const entry = validatedOrdered[i];
     if (entry === void 0) continue;
     if (matchedIndices !== null && !matchedIndices.has(entry.renderableIndex)) continue;
     if (entry.source.skin !== void 0) {
       const skinPipeline = skinnedShadowPipeline(c, entry);
-      if (skinPipeline === null) continue;
+      if (skinPipeline === null) {
+        complete = false;
+        continue;
+      }
       if (skinPipeline !== shadowLastPipeline) {
         shadowPass.setPipeline(skinPipeline);
         shadowLastPipeline = skinPipeline;
@@ -7131,67 +7611,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;
@@ -7201,7 +7637,7 @@ function recordShadowCasterDraws(c, shadowPass, shadowPipeline2, shadowMeshBindG
       const entryShadowShaderId = shadowDispatch?.materialShaderId;
       const entryShadowRenderState = shadowDispatch?.renderState;
       let entryShadowPipeline = entry.source.skin !== void 0 ? shadowLastPipeline : shadowPipeline2;
-      if (entry.source.skin === void 0 && entryShadowShaderId !== void 0 && (entryShadowShaderId !== "forgeax::default-shadow-caster" || entryShadowRenderState !== void 0)) {
+      if (entryShadowShaderId !== void 0 && (entryShadowShaderId !== "forgeax::default-shadow-caster" || entryShadowRenderState !== void 0 && entry.source.skin === void 0)) {
         entryShadowPipeline = runtime.getMaterialShaderPipeline?.(
           entryShadowShaderId,
           false,
@@ -7213,21 +7649,84 @@ function recordShadowCasterDraws(c, shadowPass, shadowPipeline2, shadowMeshBindG
           // indexFormat
           void 0,
           // variantSet — shadow caster has no variant axes
-          "shadow-caster"
+          "shadow-caster",
           // passKind
-        ) ?? shadowPipeline2;
+          void 0,
+          // meshAttributes
+          1,
+          void 0,
+          // colorFormatOverride
+          void 0,
+          // shaderUvSetCount
+          void 0,
+          // depthFormatOverride
+          void 0,
+          // vertexLayout
+          entry.mesh.layoutProjection,
+          void 0,
+          // shaderModuleMode
+          entry.source.skin === void 0 ? "pbr" : "pbr-skin",
+          void 0,
+          // additionalColorFormats
+          shadowDispatch?.vertexEntry,
+          shadowDispatch?.fragmentEntry
+        ) ?? null;
+      }
+      if (entryShadowPipeline === null) {
+        complete = false;
+        continue;
       }
       if (entryShadowPipeline !== shadowLastPipeline && entryShadowPipeline !== null) {
         shadowPass.setPipeline(entryShadowPipeline);
         shadowLastPipeline = entryShadowPipeline;
       }
-      if (entry.mesh.indexed) {
-        shadowPass.drawIndexed(sm.indexCount, shadowInstanceCount, sm.indexOffset, 0, 0);
+      if (entryShadowShaderId !== void 0 && entryShadowShaderId !== SHADOW_CASTER_SHADER_ID) {
+        materialDeps ??= {
+          runtime,
+          pipelineState,
+          world: c.world,
+          store: c.store,
+          materialSlice: STANDARD_PBR_UBO_SIZE,
+          videoHighPerfAvailable: probeVideoHighPerfUpload(runtime.device),
+          skylightResources: prepareMaterialSkylight(c).skylightResources,
+          resolveRenderTargetTextureSource: runtime.resolveRenderTargetTextureSource,
+          materialBgShared: c.frameState.materialBgShared,
+          materialBgAssemblyCache: c.materialBgAssemblyCache,
+          frameState: c.frameState,
+          bindGroupCounts: c.bindGroupCounts
+        };
+        const materialSlot = c.materialSlotIndices[i]?.[sm.materialSlot] ?? c.materialSlotIndices[i]?.[0];
+        if (materialSlot === void 0) {
+          throw new RhiError({
+            code: "rhi-descriptor-invalid",
+            expected: "a prepared material slot for each shadow submesh",
+            hint: "repair material slot preparation before recording shadows"
+          });
+        }
+        const materialGroup = buildPerSubmeshMaterialBg(
+          materialDeps,
+          submeshMaterial,
+          entry.source.entityKey,
+          entry.world ?? c.world,
+          entryShadowShaderId
+        );
+        shadowPass.setBindGroup(1, materialGroup, [materialSlot * MATERIAL_PER_ENTITY_STRIDE]);
       } else {
-        shadowPass.draw(sm.vertexCount, shadowInstanceCount, 0, 0);
+        const materialGroup = ensureSpotShadowMaterialBg(c);
+        if (materialGroup === null) continue;
+        shadowPass.setBindGroup(1, materialGroup, [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);
+        }
       }
     }
   }
+  return complete;
 }
 function ensureSpotShadowMaterialBg(c) {
   const { runtime, frameState, pipelineState } = c;
@@ -7287,7 +7786,6 @@ function ensureSpotShadowMaterialBg(c) {
 }
 
 // src/record/main-pass.ts
-var ZERO_SKYLIGHT_PAYLOAD = new Float32Array([0, 0, 0, 0, 0, 0, 0, 1]);
 function materialDiagnosticsEnabled3() {
   if (typeof globalThis !== "object" || globalThis === null || !("process" in globalThis)) {
     return false;
@@ -7336,8 +7834,6 @@ function recordMainPass(c, selector, options, graphPass) {
     meshBindGroup,
     frameState,
     bindGroupCounts,
-    skylight,
-    skylightCount,
     skyboxActive,
     splitLdrSprite,
     msaaActive,
@@ -7412,6 +7908,10 @@ function recordMainPass(c, selector, options, graphPass) {
   const matchedIndices = selector !== void 0 ? buildMatchedRenderableIndices(dispatch, selector) : null;
   const selectorMatchedMaterials = selector !== void 0 ? buildMatchedMaterialHandlesByRenderable(dispatch, selector) : null;
   const matchedMaterials = matchedMaterialsForRecordMode(c, selectorMatchedMaterials, recordMode);
+  const selectedDispatch = dispatch.length === 0 ? void 0 : filterDispatchBySelector(
+    dispatch,
+    selector ?? { LightMode: [passKind === "deferred" ? "Deferred" : "Forward"] }
+  );
   const recordContext = recordMode === void 0 ? c : {
     ...c,
     splitLdrSprite: recordMode === "transparent" ? false : c.splitLdrSprite
@@ -7427,47 +7927,7 @@ function recordMainPass(c, selector, options, graphPass) {
   }
   if (validatedOrdered.length > 0 && !clusteredBindGroupMissing) {
     const MATERIAL_SLICE = STANDARD_PBR_UBO_SIZE;
-    const skylightFallback = pipelineState.skylightFallback;
-    if (skylightFallback === null) {
-      throw new RhiError({
-        code: "webgpu-runtime-error",
-        expected: "pipelineState.skylightFallback != null when PBR pipeline is active",
-        hint: "createRenderer must allocate skylightFallback alongside the PBR pipeline (D-5 round-4)"
-      });
-    }
-    let activeViews;
-    runtime.device.queue.writeBuffer(skylightFallback.intensityBuffer, 0, ZERO_SKYLIGHT_PAYLOAD);
-    if (skylight !== void 0 && skylightCount >= 1) {
-      const [cr, cg, cb] = skylight.color;
-      const [qx, qy, qz, qw] = skylight.rotation;
-      const uniformPayload = new Float32Array([skylight.intensity, cr, cg, cb, qx, qy, qz, qw]);
-      runtime.device.queue.writeBuffer(skylightFallback.intensityBuffer, 0, uniformPayload);
-      const cache3 = getOrCreateIblCache(runtime.deviceScope);
-      if (cache3.irradianceView !== void 0 && cache3.prefilterView !== void 0 && cache3.brdfLutView !== void 0) {
-        activeViews = {
-          irr: cache3.irradianceView,
-          pref: cache3.prefilterView,
-          brdf: cache3.brdfLutView
-        };
-      }
-    }
-    const skylightResources = activeViews !== void 0 ? {
-      irradianceView: activeViews.irr,
-      irradianceSampler: skylightFallback.sampler,
-      prefilterView: activeViews.pref,
-      prefilterSampler: skylightFallback.sampler,
-      brdfLutView: activeViews.brdf,
-      brdfLutSampler: skylightFallback.sampler,
-      intensityBuffer: skylightFallback.intensityBuffer
-    } : {
-      irradianceView: skylightFallback.irradianceView,
-      irradianceSampler: skylightFallback.sampler,
-      prefilterView: skylightFallback.prefilterView,
-      prefilterSampler: skylightFallback.sampler,
-      brdfLutView: skylightFallback.brdfLutView,
-      brdfLutSampler: skylightFallback.sampler,
-      intensityBuffer: skylightFallback.intensityBuffer
-    };
+    const { skylightResources, activeViews } = prepareMaterialSkylight(c);
     if (materialDiagnosticsEnabled3()) {
       const activeCache = activeViews === void 0 ? void 0 : getOrCreateIblCache(runtime.deviceScope);
       const prefilterViewMipCount = activeCache?.prefilterFaceViewsByMip?.length ?? (activeViews === void 0 ? 1 : 0);
@@ -7477,7 +7937,9 @@ function recordMainPass(c, selector, options, graphPass) {
         deviceGeneration: runtime.deviceScope.generation,
         active: activeViews === void 0 ? "fallback" : "active",
         cache: {
-          identity: getOpaqueResourceIdentity(activeCache ?? skylightFallback),
+          identity: getOpaqueResourceIdentity(
+            activeCache ?? pipelineState.skylightFallback
+          ),
           generation: runtime.deviceScope.generation,
           prefilterMipCount: prefilterViewMipCount,
           prefilterViewMipCount
@@ -7563,110 +8025,13 @@ function recordMainPass(c, selector, options, graphPass) {
       bindGroupCounts,
       ...transmissionBackdropView === void 0 ? {} : { transmissionBackdropView }
     };
-    const buildPerSubmeshMaterialBg2 = (submeshMaterial, entityKey, materialWorld = world) => buildPerSubmeshMaterialBg(
+    const buildPerSubmeshMaterialBg2 = (submeshMaterial, entityKey, materialWorld = world, materialShaderId = submeshMaterial.materialShaderId) => buildPerSubmeshMaterialBg(
       perSubmeshMaterialBgDeps,
       submeshMaterial,
       entityKey,
-      materialWorld
+      materialWorld,
+      materialShaderId
     );
-    const cachedMaterialUboPayload = c.materialUboPayloadCache;
-    let materialUboPayload;
-    if (cachedMaterialUboPayload?.materialSlots === materialSlots && cachedMaterialUboPayload.materialSlotCount === materialSlotCount) {
-      materialUboPayload = cachedMaterialUboPayload.payload;
-    } else {
-      materialUboPayload = new Uint8Array(materialSlotCount * MATERIAL_PER_ENTITY_STRIDE);
-      const slotPayload = new Uint8Array(STANDARD_PBR_UBO_SIZE);
-      const slotPayloadF32 = new Float32Array(
-        slotPayload.buffer,
-        slotPayload.byteOffset,
-        slotPayload.byteLength / 4
-      );
-      for (let materialSlot = 0; materialSlot < materialSlots.length; materialSlot += 1) {
-        const mat = materialSlots[materialSlot];
-        const entry = validatedOrdered[materialSlotOwners[materialSlot] ?? -1];
-        if (mat === void 0 || entry === void 0) continue;
-        writePbrMaterialUboPayload(slotPayloadF32, mat);
-        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;
-          if (matHandleRaw !== void 0) {
-            const view = residentTextureView(entry.world ?? world, store, runtime, matHandleRaw);
-            if (view === void 0) {
-              const rawId = matHandleRaw;
-              if (!frameState.warnedMissingBaseColorTextureHandles.has(rawId)) {
-                frameState.warnedMissingBaseColorTextureHandles.add(rawId);
-                console.warn(
-                  `[forgeax] baseColor texture ${rawId} missing GPU view, rendering debug pink (shader=${materialShaderId ?? "<none>"} entityIndex=${entry.renderableIndex})`
-                );
-              }
-              runtime.errorRegistry.fire(
-                new RhiError({
-                  code: "asset-not-registered",
-                  expected: "material baseColor TextureAsset uploaded to GPU",
-                  hint: "register + uploadTexture the baseColor texture before draw([world], { cameraOwner: 0, resourceOwner: 0 }); rendering falls back to debug pink until then",
-                  detail: { assetHandle: rawId }
-                })
-              );
-              slotPayloadF32[0] = 1;
-              slotPayloadF32[1] = 0.4;
-              slotPayloadF32[2] = 0.7;
-            }
-          }
-        }
-        materialUboPayload.set(slotPayload, materialSlot * MATERIAL_PER_ENTITY_STRIDE);
-      }
-      for (const entry of validatedOrdered) {
-        const mat = entry.source.material;
-        const materialShaderId = mat.materialShaderId;
-        if (materialShaderId !== "forgeax::sprite" && materialShaderId !== "forgeax::sprite-lit")
-          continue;
-        const slicesAndMode = mat.paramSnapshot?.slicesAndMode;
-        if (slicesAndMode === void 0 || slicesAndMode.length < 4) continue;
-        const slicesArr = [
-          slicesAndMode[0] ?? 0,
-          slicesAndMode[1] ?? 0,
-          slicesAndMode[2] ?? 0,
-          slicesAndMode[3] ?? 0
-        ];
-        if (slicesArr[0] === 0 && slicesArr[1] === 0 && slicesArr[2] === 0 && slicesArr[3] === 0)
-          continue;
-        detectNineSliceScaleTooSmall(
-          entry.source.transform.world,
-          slicesArr,
-          entry.renderableIndex,
-          frameState.warnedNineSliceScaleEntities,
-          runtime.metrics
-        );
-      }
-      c.materialUboPayloadCache = {
-        materialSlots,
-        materialSlotCount,
-        payload: materialUboPayload
-      };
-    }
-    const materialUboUpload = runtime.device.queue.writeBuffer(
-      pipelineState.materialUniformBuffer.buffer,
-      0,
-      materialUboPayload
-    );
-    if (!materialUboUpload.ok) throw materialUboUpload.error;
     const preparedMaterialBindGroups = new Array(materialSlotCount);
     for (let materialSlot = 0; materialSlot < materialSlotCount; materialSlot += 1) {
       const material = materialSlots[materialSlot];
@@ -7679,7 +8044,7 @@ function recordMainPass(c, selector, options, graphPass) {
         owner.world ?? world
       );
     }
-    const resolveMaterialBindGroup = (materialSlot, material, entityKey, materialWorld = world) => material.materialShaderId !== POINTS_LINES_MATERIAL_SHADER_ID ? preparedMaterialBindGroups[materialSlot] ?? buildPerSubmeshMaterialBg2(material, entityKey, materialWorld) : buildPerSubmeshMaterialBg2(material, entityKey, materialWorld);
+    const resolveMaterialBindGroup = (materialSlot, material, entityKey, materialWorld = world, materialShaderId = material.materialShaderId) => materialShaderId === material.materialShaderId && materialShaderId !== POINTS_LINES_MATERIAL_SHADER_ID ? preparedMaterialBindGroups[materialSlot] ?? buildPerSubmeshMaterialBg2(material, entityKey, materialWorld, materialShaderId) : buildPerSubmeshMaterialBg2(material, entityKey, materialWorld, materialShaderId);
     pass.setBindGroup(0, viewBindGroup, [viewBindGroupDynamicOffset, 0]);
     const recordGeometry = () => {
       recordGeometryDraws(
@@ -7691,7 +8056,8 @@ function recordMainPass(c, selector, options, graphPass) {
         meshGroup2,
         meshBindGroup,
         resolveMaterialBindGroup,
-        passKind
+        passKind,
+        selectedDispatch
       );
     };
     if (c.profilePhase === void 0) {
@@ -7712,7 +8078,8 @@ function recordMainPass(c, selector, options, graphPass) {
         sampleCount,
         resolveMaterialBindGroup,
         skylightResources,
-        graphPass
+        graphPass,
+        selectedDispatch
       );
     }
   }
@@ -9562,6 +9929,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, geometryRenderStateForPass, geometryRenderStateForTopology, getOrBuildPipeline, getOrCreateHdrpBuffers, getOrCreateIblCache, getTemporalBindGroupResources, getTemporalGpuState, getTemporalParamsBuffer, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, incrementFoldedDrawsMetric, isTemporalFullscreenBinding, passKindPolicyTable, postProcessShaderEntrySignature, postProcessShaderModuleLabel, postProcessShaderPipelineLabel, prepareFrameLighting, resetHdrpBuffers, residentTextureView, 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-YRUYGA4A.mjs.map
-//# sourceMappingURL=chunk-YRUYGA4A.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, STANDARD_PBR_UBO_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, applyMaterialTextureUvScales, 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, detectNineSliceScaleTooSmall, 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, writePbrMaterialUboPayload, writePointsLinesViewUbo, writeShadowCasterUniforms, writeShadowParamsBuffer, writeSpotModifierTextures, writeViewUbo };
+//# sourceMappingURL=chunk-TMIASV2N.mjs.map
+//# sourceMappingURL=chunk-TMIASV2N.mjs.map