@forgeax/engine-render 0.1.24 → 0.1.26

package/src/record/main-pass-geometry.ts

@@ -19,6 +19,11 @@ import {
 } from '../gpu-usage';
 import { createHdrpSkinUnifiedBindGroup, getOrCreateHdrpBuffers } from '../hdrp-buffers';
 import type { InstanceBufferCacheEntry } from '../instance-buffer-cache';
+import {
+  type InstanceCollectionFailureCode,
+  recordInstanceFailure,
+  recordInstanceResidency,
+} from '../instances';
 import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from '../materials';
 import {
   createPbrSkinMeshBindGroupEntries,
@@ -39,13 +44,17 @@ import {
 import type { PointsLinesRecordPlan } from '../points-lines/record';
 import { POINTS_LINES_MATERIAL_SHADER_ID } from '../points-lines/record';
 import type { RenderRecordPhase } from '../render-contract';
-import type { MaterialSnapshot } from '../render-system-extract';
+import type { DispatchEntry, MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
 import {
   PROBE_BLEND_RECORD_BYTE_SIZE,
   PROBE_BLEND_RECORD_STRIDE,
   probeBlendRecordOffset,
 } from '../scene/probe-blend-record';
-import { getOpaqueResourceIdentity, worldEntityKey } from './frame-snapshot';
+import {
+  getOpaqueResourceIdentity,
+  instanceCollectionCacheKey,
+  worldEntityKey,
+} from './frame-snapshot';
 import {
   geometryRenderStateForTopology,
   isEntityFullyTransparent,
@@ -54,6 +63,7 @@ import {
 } from './main-pass-material';
 import {
   getOrCreateFromChain,
+  INSTANCE_STORAGE_STRIDE_FLOATS,
   INSTANCE_UBO_FULL_ARRAY_BYTES,
   MAX_UNIFORM_INSTANCES,
   MESH_PER_ENTITY_STRIDE,
@@ -73,6 +83,18 @@ type GeometryInstanceDraw = {
   readonly instanceCount: number;
 };
 
+type InstanceUploadResult =
+  | {
+      readonly ok: true;
+      readonly ranges: readonly { readonly start: number; readonly end: number }[];
+      readonly bytes: number;
+    }
+  | {
+      readonly ok: false;
+      readonly ranges: readonly { readonly start: number; readonly end: number }[];
+      readonly bytes: number;
+    };
+
 type GeometryBindingState = {
   pipeline: RenderPipeline | null;
   instancesBuffer: Buffer | null;
@@ -98,6 +120,8 @@ type MaterialPipelineLookup = {
   readonly topology: PrimitiveTopology;
   readonly indexFormat: 'uint16' | 'uint32';
   readonly variantSet: string | undefined;
+  readonly vertexEntry: string | undefined;
+  readonly fragmentEntry: string | undefined;
   readonly passKind: PassKind;
   readonly layoutProjection: import('@forgeax/engine-geometry').VertexLayoutProjection;
   readonly sampleCount: number;
@@ -343,8 +367,10 @@ export function recordGeometryDraws(
     submeshMaterial: MaterialSnapshot,
     entityKey: number,
     materialWorld: World,
+    materialShaderId?: string,
   ) => BindGroup,
   passKind: PassKind = 'forward',
+  selectedDispatch?: readonly DispatchEntry[],
 ): void {
   const {
     runtime,
@@ -359,6 +385,17 @@ export function recordGeometryDraws(
     viewBindGroup,
     viewBindGroupDynamicOffset = 0,
   } = c;
+  const materialPasses = new Map<number, Map<number, DispatchEntry[]>>();
+  for (const dispatch of selectedDispatch ?? []) {
+    let byMaterial = materialPasses.get(dispatch.renderableIndex);
+    if (byMaterial === undefined) {
+      byMaterial = new Map();
+      materialPasses.set(dispatch.renderableIndex, byMaterial);
+    }
+    const passes = byMaterial.get(dispatch.materialHandle);
+    if (passes === undefined) byMaterial.set(dispatch.materialHandle, [dispatch]);
+    else passes.push(dispatch);
+  }
   const diagnosticsEnabled = materialDiagnosticsEnabled();
   const colorFormatOverride = c.transparentColorFormat as GPUTextureFormat | undefined;
   // The prepared Standard topology is the frame authority. A bind-group
@@ -416,6 +453,8 @@ export function recordGeometryDraws(
     variantSet: string | undefined,
     colorFormat: GPUTextureFormat | undefined,
     layoutProjection: import('@forgeax/engine-geometry').VertexLayoutProjection,
+    vertexEntry?: string,
+    fragmentEntry?: string,
   ): MaterialShaderPipelineEntry | null => {
     // The fallback MRT is an extension of the built-in Standard PBR output
     // contract only.  The render pass may carry a second attachment whenever
@@ -441,6 +480,8 @@ export function recordGeometryDraws(
           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 &&
@@ -452,10 +493,12 @@ export function recordGeometryDraws(
       }
     }
     const resolvedVariantSetResult =
-      variantSet === undefined &&
-      (materialShaderId === 'forgeax::sprite' || materialShaderId === 'forgeax::sprite-lit')
+      runtime.getMaterialArtifact?.(materialShaderId) !== undefined
         ? ({ ok: true, value: undefined } as const)
-        : variantSetFromVertexLayoutProjection(layoutProjection, variantSet);
+        : variantSet === undefined &&
+            (materialShaderId === 'forgeax::sprite' || materialShaderId === 'forgeax::sprite-lit')
+          ? ({ ok: true, value: undefined } as const)
+          : variantSetFromVertexLayoutProjection(layoutProjection, variantSet);
     if (!resolvedVariantSetResult.ok) {
       runtime.errorRegistry.fire(resolvedVariantSetResult.error);
       return null;
@@ -486,6 +529,8 @@ export function recordGeometryDraws(
         undefined,
         undefined,
         reflectionFallbackFormats,
+        vertexEntry,
+        fragmentEntry,
       ) ?? null;
     const handle =
       profilePhase === undefined
@@ -506,6 +551,8 @@ export function recordGeometryDraws(
         topology,
         indexFormat,
         variantSet,
+        vertexEntry,
+        fragmentEntry,
         passKind,
         layoutProjection,
         sampleCount,
@@ -569,7 +616,8 @@ export function recordGeometryDraws(
     // decal submesh) is NOT skipped at the entity level; its opaque submeshes
     // draw here and the per-submesh loop below skips the transparent ones
     // (they are drawn in the blend sub-pass instead).
-    if (splitLdrSprite && isEntityFullyTransparent(entry.source)) continue;
+    if (selectedDispatch === undefined && splitLdrSprite && isEntityFullyTransparent(entry.source))
+      continue;
 
     const pipelineTag: 'unlit' = 'unlit';
 
@@ -953,295 +1001,315 @@ export function recordGeometryDraws(
         const materialHandle = submeshMaterial.materialHandle ?? 0;
         if (materialHandles === undefined || !materialHandles.has(materialHandle)) continue;
       }
-      // feat-city-glb Bug 5 (per-submesh transparency): in the LDR split, a
-      // transparent submesh is drawn in the blend sub-pass (non-sRGB view),
-      // NOT here in the sRGB geometry pass. Skip it. Opaque submeshes of the
-      // same (mixed) mesh still draw here. Single-material / fully-opaque
-      // meshes are unaffected (their submesh materials are not transparent).
-      if (splitLdrSprite && submeshMaterial.transparent === true) {
-        continue;
-      }
-      // bug-20260610 layer 7d: per-submesh BG construction. Texture
-      // views resolve from `matsForRebind[smIdx]` so the j-th submesh
-      // sees its own materials[j] textures (baseColor / MR / normal /
-      // emissive / occlusion). Pick slot j when materials.length covers
-      // smIdx; otherwise fall back to slot 0 (count-mismatch already
-      // filtered by extract; this guard handles the materials.length=1
-      // single-material path mapped over multi-submesh meshes safely).
-      // This BG drops entityKey: identical-texture-set submeshes
-      // (whether on the same entity or different ones) share one BG via
-      // the shaderId-outer `materialBgShared` cache. The 14 handle
-      // objects form the WeakMap chain and fully discriminate the
-      // binding state since sampler/textureView/buffer handle identities
-      // are stable across frames.
-      //
-      // feat-20260625-refactor-sprite-as-transparent-mesh M3 / w13:
-      // sprite materials now use the same per-submesh BG construction
-      // (the sprite-specific BG branch above is deleted; sprite per-
-      // submesh single-slot is still enforced via materialSlotIndices
-      // and the sprite-shaped paramSnapshot fills the PBR-shaped BGL
-      // bindings via fallback textures for the 4 unused slots).
-      // feat-city-glb Bug 5: per-submesh material BG assembly extracted to
-      // the shared `buildPerSubmeshMaterialBg` closure (also called by the
-      // LDR blend sub-pass). Resolves the shader's user-region textures
-      // (baseColor/MR/normal + a custom Nth texture), emissive/occlusion
-      // injection, and Skylight merge; deduped cross-entity via the
-      // shaderId-outer `materialBgShared` cache.
-      const materialSlot = materialSlotIndices[i]?.[matSlotIdx] ?? materialSlotIndices[i]?.[0] ?? 0;
-      const processValue = (
-        globalThis as {
-          process?: { env?: Record<string, string | undefined> };
+      const draws: readonly (DispatchEntry | undefined)[] =
+        selectedDispatch === undefined
+          ? [undefined]
+          : (materialPasses.get(entry.renderableIndex)?.get(submeshMaterial.materialHandle ?? 0) ??
+            []);
+      for (const selectedPass of draws) {
+        const selectedShaderId =
+          selectedPass === undefined
+            ? submeshMaterial.materialShaderId
+            : selectedPass.materialShaderId;
+        const selectedRenderState =
+          selectedPass === undefined ? submeshMaterial.renderState : selectedPass.renderState;
+        const selectedStencil =
+          (selectedPass === undefined ? entry.stencilReference : selectedPass.stencilReference) ??
+          0;
+        if (selectedStencil !== lastStencilReference) {
+          pass.setStencilReference(selectedStencil);
+          lastStencilReference = selectedStencil;
         }
-      ).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 === undefined
-          ? resolveMaterialBindGroup(
+        // feat-city-glb Bug 5 (per-submesh transparency): in the LDR split, a
+        // transparent submesh is drawn in the blend sub-pass (non-sRGB view),
+        // NOT here in the sRGB geometry pass. Skip it. Opaque submeshes of the
+        // same (mixed) mesh still draw here. Single-material / fully-opaque
+        // meshes are unaffected (their submesh materials are not transparent).
+        if (
+          splitLdrSprite &&
+          (selectedPass === undefined
+            ? submeshMaterial.transparent === true
+            : selectedRenderState?.blend !== undefined)
+        ) {
+          continue;
+        }
+        // bug-20260610 layer 7d: per-submesh BG construction. Texture
+        // views resolve from `matsForRebind[smIdx]` so the j-th submesh
+        // sees its own materials[j] textures (baseColor / MR / normal /
+        // emissive / occlusion). Pick slot j when materials.length covers
+        // smIdx; otherwise fall back to slot 0 (count-mismatch already
+        // filtered by extract; this guard handles the materials.length=1
+        // single-material path mapped over multi-submesh meshes safely).
+        // This BG drops entityKey: identical-texture-set submeshes
+        // (whether on the same entity or different ones) share one BG via
+        // the shaderId-outer `materialBgShared` cache. The 14 handle
+        // objects form the WeakMap chain and fully discriminate the
+        // binding state since sampler/textureView/buffer handle identities
+        // are stable across frames.
+        //
+        // feat-20260625-refactor-sprite-as-transparent-mesh M3 / w13:
+        // sprite materials now use the same per-submesh BG construction
+        // (the sprite-specific BG branch above is deleted; sprite per-
+        // submesh single-slot is still enforced via materialSlotIndices
+        // and the sprite-shaped paramSnapshot fills the PBR-shaped BGL
+        // bindings via fallback textures for the 4 unused slots).
+        // feat-city-glb Bug 5: per-submesh material BG assembly extracted to
+        // the shared `buildPerSubmeshMaterialBg` closure (also called by the
+        // LDR blend sub-pass). Resolves the shader's user-region textures
+        // (baseColor/MR/normal + a custom Nth texture), emissive/occlusion
+        // injection, and Skylight merge; deduped cross-entity via the
+        // shaderId-outer `materialBgShared` cache.
+        const materialSlot =
+          materialSlotIndices[i]?.[matSlotIdx] ?? materialSlotIndices[i]?.[0] ?? 0;
+        const processValue = (
+          globalThis as {
+            process?: { env?: Record<string, string | undefined> };
+          }
+        ).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,
-              submeshMaterial,
-              entry.source.entityKey,
-              entry.world ?? c.world,
-            )
-          : profileGeometrySegment(c, passKind, 'material-bind-groups', () =>
-              resolveMaterialBindGroup(
+              materialHandle: submeshMaterial.materialHandle,
+              clearcoat: submeshMaterial.paramSnapshot?.clearcoat,
+              shader: submeshMaterial.materialShaderId,
+            })}`,
+          );
+        }
+        perSubmeshBg =
+          profilePhase === undefined
+            ? resolveMaterialBindGroup(
                 materialSlot,
                 submeshMaterial,
                 entry.source.entityKey,
                 entry.world ?? c.world,
-              ),
+                selectedShaderId,
+              )
+            : profileGeometrySegment(c, passKind, 'material-bind-groups', () =>
+                resolveMaterialBindGroup(
+                  materialSlot,
+                  submeshMaterial,
+                  entry.source.entityKey,
+                  entry.world ?? c.world,
+                  selectedShaderId,
+                ),
+              );
+        materialGroup1DynamicOffsets[0] = materialSlot * MATERIAL_PER_ENTITY_STRIDE;
+        pass.setBindGroup(1, perSubmeshBg, materialGroup1DynamicOffsets, 0, 1);
+        const smTopology = sm.topology;
+        const smMaterialShaderId =
+          selectedPass !== undefined
+            ? selectedShaderId
+            : entry.source.skin !== undefined
+              ? 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';
+        // Preserve the dedicated sprite-pass state when the linear-LDR graph
+        // routes a sprite through this generic geometry path. Negative scale
+        // flips winding, so back-face culling would erase the quad.
+        const basePipelineRenderState = isSpriteShader
+          ? {
+              ...selectedRenderState,
+              depthWriteEnabled: false,
+              depthCompare: 'less-equal' as const,
+              cullMode: 'none' as const,
+              blend: selectedRenderState?.blend ?? SPRITE_PREMULTIPLIED_ALPHA_BLEND,
+            }
+          : geometryRenderStateForTopology(smTopology, selectedRenderState);
+        const pipelineRenderState = geometryRenderStateForPass(basePipelineRenderState, passKind);
+        let smPipelineHandle: typeof pipelineState.unlitPipeline;
+        let materialGroup2Contract: 'mesh' | 'skin' | 'cluster' | 'skin-cluster' | undefined;
+        let materialPipelineEntry: MaterialShaderPipelineEntry | null = null;
+        if (smMaterialShaderId === undefined || smMaterialShaderId === 'forgeax::default-unlit') {
+          const unlitShaderId = smMaterialShaderId ?? 'forgeax::default-unlit';
+          const unlitProjectionVariantResult = variantSetFromVertexLayoutProjection(
+            entry.mesh.layoutProjection,
+            undefined,
+          );
+          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 === undefined
+              ? selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive)
+              : null);
+        } else if (smMaterialShaderId !== undefined) {
+          // feat-20260609 M4.5 / w38 (D-11): the variantSet handed to
+          // getMaterialShaderPipeline MUST mirror the boot-time
+          // `definesKey` rule at createRenderer.ts:2483-2485 (sortedEntries
+          // .every(v=>v===true) ? '' : 'A=v+...'). manifest variant.definesKey
+          // is `''` for the all-true variant, so HDRP (both axes true) must
+          // pass the canonical empty key to hit that variant via
+          // findVariantByKey. Passing the expanded form would produce a
+          // miss and silently fall back to the registered default WGSL,
+          // creating a layout/binding mismatch under HDRP.
+          //
+          // URP path passes the explicit expanded form because the URP
+          // variant's manifest definesKey IS that exact non-empty string
+          // (CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true)
+          // -- the canonical-empty rule only applies to the all-true case.
+          const hasVertexColor = entry.mesh.layoutProjection.attributes.some(
+            (attribute) => attribute.key === 'color',
+          );
+          // The all-true HDRP variant uses the canonical empty key only when
+          // every variant axis is true. A plain mesh adds the geometry-owned
+          // VERTEX_COLOR_AVAILABLE=false axis, so retain the two capability
+          // axes explicitly or the selector would silently choose the URP
+          // group(2) layout for an HDRP cluster bind group.
+          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;
+          // Sprite's base request must retain the boot-selected artifact. Only
+          // SpriteInstances uses the explicit empty key for the
+          // PER_INSTANCE_REGION=true variant; synthesizing the generic PBR
+          // capability axes for a base sprite would invent a lazy module label
+          // that has no boot seed and skip the first HDR draw.
+          const variantSet = isSpriteShader
+            ? smMaterialShaderId === 'forgeax::sprite' && entry.source.spriteInstances !== undefined
+              ? ''
+              : undefined
+            : entry.variantSet === undefined
+              ? 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,
+          );
+          // feat-20260615-pipeline-spec-ssot M6-T1: cache miss resolves to
+          // null uniformly across URP / HDRP / skin shaders. Charter P3
+          // explicit failure: the pre-M6 URP-path silent fallback to the
+          // boot-time `pipelineState.standardPipeline*` (M4.5-followup w43)
+          // masked real PipelineSpecError build failures behind a
+          // layout-compatible-but-wrong PSO. The per-submesh
+          // `if (smPipelineHandle === null) continue` skip-draw (which
+          // already covered HDRP-active and skin miss paths) is now the
+          // single uniform recovery shape -- one frame of skip-draw on
+          // first-touch, then the cached PSO flows in once the async
+          // build resolves. The pre-loop skin-PSO probe still skips the
+          // entire entry on first-submesh probe miss; this site only
+          // fires on per-submesh topology variance miss.
+          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',
+              })}`,
             );
-      materialGroup1DynamicOffsets[0] = materialSlot * MATERIAL_PER_ENTITY_STRIDE;
-      pass.setBindGroup(1, perSubmeshBg, materialGroup1DynamicOffsets, 0, 1);
-      const smTopology = sm.topology;
-      const smMaterialShaderId =
-        entry.source.skin !== undefined
-          ? 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';
-      // Preserve the dedicated sprite-pass state when the linear-LDR graph
-      // routes a sprite through this generic geometry path. Negative scale
-      // flips winding, so back-face culling would erase the quad.
-      const basePipelineRenderState = isSpriteShader
-        ? {
-            ...submeshMaterial.renderState,
-            depthWriteEnabled: false,
-            depthCompare: 'less-equal' as const,
-            cullMode: 'none' as const,
-            blend: submeshMaterial.renderState?.blend ?? SPRITE_PREMULTIPLIED_ALPHA_BLEND,
           }
-        : geometryRenderStateForTopology(smTopology, submeshMaterial.renderState);
-      const pipelineRenderState = geometryRenderStateForPass(basePipelineRenderState, passKind);
-      let smPipelineHandle: typeof pipelineState.unlitPipeline;
-      let materialGroup2Contract: 'mesh' | 'skin' | 'cluster' | 'skin-cluster' | undefined;
-      let materialPipelineEntry: MaterialShaderPipelineEntry | null = null;
-      if (smMaterialShaderId === undefined || smMaterialShaderId === 'forgeax::default-unlit') {
-        const unlitShaderId = smMaterialShaderId ?? 'forgeax::default-unlit';
-        const unlitProjectionVariantResult = variantSetFromVertexLayoutProjection(
-          entry.mesh.layoutProjection,
-          undefined,
-        );
-        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,
-        );
-        materialPipelineEntry = unlitRsp;
-        smPipelineHandle =
-          unlitRsp?.pipeline ??
-          (colorFormatOverride === undefined
-            ? selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive)
-            : null);
-      } else if (smMaterialShaderId !== undefined) {
-        // feat-20260609 M4.5 / w38 (D-11): the variantSet handed to
-        // getMaterialShaderPipeline MUST mirror the boot-time
-        // `definesKey` rule at createRenderer.ts:2483-2485 (sortedEntries
-        // .every(v=>v===true) ? '' : 'A=v+...'). manifest variant.definesKey
-        // is `''` for the all-true variant, so HDRP (both axes true) must
-        // pass the canonical empty key to hit that variant via
-        // findVariantByKey. Passing the expanded form would produce a
-        // miss and silently fall back to the registered default WGSL,
-        // creating a layout/binding mismatch under HDRP.
-        //
-        // URP path passes the explicit expanded form because the URP
-        // variant's manifest definesKey IS that exact non-empty string
-        // (CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true)
-        // -- the canonical-empty rule only applies to the all-true case.
-        const hasVertexColor = entry.mesh.layoutProjection.attributes.some(
-          (attribute) => attribute.key === 'color',
-        );
-        // The all-true HDRP variant uses the canonical empty key only when
-        // every variant axis is true. A plain mesh adds the geometry-owned
-        // VERTEX_COLOR_AVAILABLE=false axis, so retain the two capability
-        // axes explicitly or the selector would silently choose the URP
-        // group(2) layout for an HDRP cluster bind group.
-        const capabilityVariantSet = standardTopologyVariantSet(
-          c.standardLighting,
-          runtime.device.caps.storageBuffer,
-          hasVertexColor,
+        // The probe record is an ABI extension of the built-in Standard PBR
+        // shaders only. RenderScene may retain a record on every projected
+        // renderable, but unlit/custom shaders still use the one-binding
+        // instances BGL and must never receive the probe bind group. Resolve
+        // this per submesh so mixed-material meshes cannot cross the layouts.
+        const instanceDraws = resolveGeometryInstanceBuffer(
+          c,
+          entry,
+          identityInstanceDraws,
           probeBlendAvailable,
         );
-        const transmissionAvailable = requestsStandardTransmissionVariant(submeshMaterial);
-        const materialCapabilityVariantSet =
-          transmissionAvailable && !capabilityVariantSet.includes('TRANSMISSION_AVAILABLE=')
-            ? `${capabilityVariantSet === '' ? '' : `${capabilityVariantSet}+`}TRANSMISSION_AVAILABLE=true`
-            : capabilityVariantSet;
-        // Sprite's base request must retain the boot-selected artifact. Only
-        // SpriteInstances uses the explicit empty key for the
-        // PER_INSTANCE_REGION=true variant; synthesizing the generic PBR
-        // capability axes for a base sprite would invent a lazy module label
-        // that has no boot seed and skip the first HDR draw.
-        const variantSet = isSpriteShader
-          ? smMaterialShaderId === 'forgeax::sprite' && entry.source.spriteInstances !== undefined
-            ? ''
-            : undefined
-          : entry.variantSet === undefined
-            ? materialCapabilityVariantSet
-            : capabilityVariantSet === ''
-              ? entry.variantSet
-              : `${capabilityVariantSet}+${entry.variantSet}`;
-        const cachedPipeline = resolveMaterialPipeline(
-          smMaterialShaderId,
-          pipelineRenderState,
-          smTopology,
-          entry.mesh.indexFormat,
-          variantSet,
-          colorFormatOverride,
-          entry.mesh.layoutProjection,
-        );
-        // feat-20260615-pipeline-spec-ssot M6-T1: cache miss resolves to
-        // null uniformly across URP / HDRP / skin shaders. Charter P3
-        // explicit failure: the pre-M6 URP-path silent fallback to the
-        // boot-time `pipelineState.standardPipeline*` (M4.5-followup w43)
-        // masked real PipelineSpecError build failures behind a
-        // layout-compatible-but-wrong PSO. The per-submesh
-        // `if (smPipelineHandle === null) continue` skip-draw (which
-        // already covered HDRP-active and skin miss paths) is now the
-        // single uniform recovery shape -- one frame of skip-draw on
-        // first-touch, then the cached PSO flows in once the async
-        // build resolves. The pre-loop skin-PSO probe still skips the
-        // entire entry on first-submesh probe miss; this site only
-        // fires on per-submesh topology variance miss.
-        materialPipelineEntry = cachedPipeline;
-        smPipelineHandle = cachedPipeline?.pipeline ?? null;
-      } else {
-        smPipelineHandle = selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive);
-      }
-
-      if (smPipelineHandle === null) {
-        if (diagnosticsEnabled) {
+        if (instanceDraws === null) continue;
+        // Standard clustered PBR variants declare the unified cluster/SSAO
+        // group(2) layout. Unlit and other URP-layout materials must bind the
+        // ordinary mesh group instead; choosing one group for the whole pass
+        // makes Dawn reject an otherwise valid unlit pipeline and invalidates
+        // the command buffer before it reaches the surface.
+        if (!isSkinEntry) {
+          materialGroup2Contract = materialPipelineEntry?.group2Contract;
+          if (materialGroup2Contract === undefined) continue;
+          const selectedGroup = selectMaterialGroup2(
+            meshGroup2,
+            meshBindGroup,
+            materialGroup2Contract,
+          );
+          if (selectedGroup === null) continue;
+          group2BindGroup = selectedGroup;
+        }
+        if (diagnosticsEnabled && submeshMaterial.textureHandles !== undefined) {
           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 !== undefined,
+                    paletteByteOffset: skinSlice?.byteOffset,
+                    dynamicOffsets: [...group2DynamicOffsets],
+                  }
+                : undefined,
+              pipelineReady: true,
             })}`,
           );
         }
-        continue;
-      }
-      // The probe record is an ABI extension of the built-in Standard PBR
-      // shaders only. RenderScene may retain a record on every projected
-      // renderable, but unlit/custom shaders still use the one-binding
-      // instances BGL and must never receive the probe bind group. Resolve
-      // this per submesh so mixed-material meshes cannot cross the layouts.
-      const instanceDraws = resolveGeometryInstanceBuffer(
-        c,
-        entry,
-        identityInstanceDraws,
-        probeBlendAvailable,
-      );
-      if (instanceDraws === null) continue;
-      // Standard clustered PBR variants declare the unified cluster/SSAO
-      // group(2) layout. Unlit and other URP-layout materials must bind the
-      // ordinary mesh group instead; choosing one group for the whole pass
-      // makes Dawn reject an otherwise valid unlit pipeline and invalidates
-      // the command buffer before it reaches the surface.
-      if (!isSkinEntry) {
-        materialGroup2Contract = materialPipelineEntry?.group2Contract;
-        if (materialGroup2Contract === undefined) continue;
-        const selectedGroup = selectMaterialGroup2(
-          meshGroup2,
-          meshBindGroup,
-          materialGroup2Contract,
-        );
-        if (selectedGroup === null) continue;
-        group2BindGroup = selectedGroup;
-      }
-      if (diagnosticsEnabled && submeshMaterial.textureHandles !== undefined) {
-        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 !== undefined,
-                  paletteByteOffset: skinSlice?.byteOffset,
-                  dynamicOffsets: [...group2DynamicOffsets],
-                }
-              : undefined,
-            pipelineReady: true,
-          })}`,
-        );
-      }
-      pass.setBindGroup(2, group2BindGroup, group2DynamicOffsets);
+        pass.setBindGroup(2, group2BindGroup, group2DynamicOffsets);
 
-      if (profilePhase === undefined) {
-        recordOcclusionCandidate(() =>
-          submitSubmeshDraws(
-            pass,
-            bindingState,
-            smPipelineHandle,
-            instanceDraws,
-            entry.mesh.indexed,
-            sm.indexCount,
-            sm.vertexCount,
-            sm.indexOffset,
-          ),
-        );
-      } else {
-        profileGeometrySegment(c, passKind, 'draw-submit', () =>
+        if (profilePhase === undefined) {
           recordOcclusionCandidate(() =>
             submitSubmeshDraws(
               pass,
@@ -1253,11 +1321,26 @@ export function recordGeometryDraws(
               sm.vertexCount,
               sm.indexOffset,
             ),
-          ),
-        );
-      }
-      if (diagnosticsEnabled && perSubmeshBg !== null) {
-        recordIblPipelineBinding(c, submeshMaterial, smPipelineHandle, perSubmeshBg);
+          );
+        } else {
+          profileGeometrySegment(c, passKind, 'draw-submit', () =>
+            recordOcclusionCandidate(() =>
+              submitSubmeshDraws(
+                pass,
+                bindingState,
+                smPipelineHandle,
+                instanceDraws,
+                entry.mesh.indexed,
+                sm.indexCount,
+                sm.vertexCount,
+                sm.indexOffset,
+              ),
+            ),
+          );
+        }
+        if (diagnosticsEnabled && perSubmeshBg !== null) {
+          recordIblPipelineBinding(c, submeshMaterial, smPipelineHandle, perSubmeshBg);
+        }
       }
     }
   }
@@ -1268,8 +1351,285 @@ export function recordGeometryDraws(
  *
  * @internal
  */
-function resolveGeometryInstanceBuffer(
-  c: _InternalRenderPipelineContext,
+function uploadInstanceRanges(
+  c: Pick<
+    _InternalRenderPipelineContext,
+    'runtime' | 'pipelineState' | 'frameState' | 'bindGroupCounts'
+  >,
+  inst: NonNullable<RenderableSnapshot['instances']>,
+  buffer: Buffer,
+  ranges: readonly { readonly start: number; readonly end: number }[],
+  storageBacked: boolean,
+  sourceOffsetInstances = 0,
+): InstanceUploadResult {
+  const strideBytes =
+    (storageBacked ? INSTANCE_STORAGE_STRIDE_FLOATS : 16) * Float32Array.BYTES_PER_ELEMENT;
+  const uploadedRanges: { start: number; end: number }[] = [];
+  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 };
+}
+
+export function reportInstanceResidency(
+  c: Pick<
+    _InternalRenderPipelineContext,
+    'runtime' | 'pipelineState' | 'frameState' | 'bindGroupCounts'
+  >,
+  inst: NonNullable<RenderableSnapshot['instances']>,
+  input: {
+    readonly lane: 'direct-storage' | 'chunked-storage' | 'direct-uniform' | 'chunked-uniform';
+    readonly requestedBytes: number;
+    readonly supportedBytes: number | undefined;
+    readonly uploadRanges: readonly { readonly start: number; readonly end: number }[];
+    readonly uploadedBytes: number;
+  },
+): void {
+  if (inst.collectionId === undefined || c.frameState.instanceResidency === undefined) 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: Pick<
+    _InternalRenderPipelineContext,
+    'runtime' | 'pipelineState' | 'frameState' | 'bindGroupCounts'
+  >,
+  inst: NonNullable<RenderableSnapshot['instances']>,
+  error: {
+    readonly code: InstanceCollectionFailureCode;
+    readonly expected: string;
+    readonly hint: string;
+  },
+  requestedBytes: number,
+  supportedBytes: number | undefined,
+): void {
+  if (inst.collectionId === undefined || c.frameState.instanceResidency === undefined) 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: Pick<
+    _InternalRenderPipelineContext,
+    'runtime' | 'pipelineState' | 'frameState' | 'bindGroupCounts'
+  >,
+  ownerKey: number,
+): void {
+  const chunks = c.frameState.instanceBufferChunks;
+  if (chunks === undefined) 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);
+  }
+}
+
+export function resolveStorageInstanceChunks(
+  c: Pick<
+    _InternalRenderPipelineContext,
+    'runtime' | 'pipelineState' | 'frameState' | 'bindGroupCounts'
+  >,
+  entry: _InternalRenderPipelineContext['validatedOrdered'][number],
+  inst: NonNullable<RenderableSnapshot['instances']>,
+  cap: number,
+  probeBuffer: Buffer | undefined,
+  probeOffset: number,
+): readonly GeometryInstanceDraw[] | null {
+  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 = new Set<string>();
+  const draws: GeometryInstanceDraw[] = [];
+  const uploadedRanges: { start: number; end: number }[] = [];
+  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);
+    // Keep stable-resident checks arithmetic-only; packing is deferred to the
+    // upload path below, where a new or dirty range actually needs payload.
+    const payloadBytes = count * strideBytes;
+    const previous = chunks?.get(chunkKey);
+    let active =
+      previous !== undefined &&
+      previous.uploadedArchVersion === inst.archVersion &&
+      previous.uploadedByteLength === payloadBytes
+        ? previous
+        : undefined;
+    let activeIsNew = false;
+    if (active === undefined) {
+      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 !== undefined && !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 === undefined) frameState.transientInstanceBuffers.push(active);
+    }
+    if (active === undefined) return null;
+    const needsUpload =
+      activeIsNew || active.uploadedRevision !== (inst.revision ?? inst.archVersion);
+    const rangesToUpload = [
+      {
+        start: 0,
+        end: count,
+      },
+    ];
+    if (needsUpload && rangesToUpload.length > 0) {
+      const upload = uploadInstanceRanges(
+        c,
+        inst,
+        active.buffer.handle,
+        rangesToUpload,
+        true,
+        start,
+      );
+      for (const range of upload.ranges) {
+        uploadedRanges.push({ start: range.start + start, end: range.end + start });
+      }
+      uploadedBytes += upload.bytes;
+      if (!upload.ok) {
+        reportInstanceFailure(
+          c,
+          inst,
+          {
+            code: 'queue-write-buffer-failed',
+            expected:
+              'the renderer-owned instance storage buffer accepts the complete instance payload',
+            hint: 'retry after the active device is healthy or recover the renderer',
+          },
+          inst.instanceCount * strideBytes,
+          cap,
+        );
+        return null;
+      }
+    }
+    if (needsUpload) {
+      {
+        const published = { ...active, uploadedRevision: inst.revision ?? inst.archVersion };
+        active = published;
+        chunks?.set(chunkKey, published);
+      }
+    }
+    const activeBuffer = active;
+    draws.push({
+      instanceBuffer: activeBuffer.buffer.handle,
+      instanceBindGroup: resolveGeometryInstancesBindGroup(
+        c,
+        activeBuffer.buffer.handle,
+        probeBuffer,
+      ),
+      probeOffset,
+      instanceCount: count,
+    });
+  }
+  if (chunks !== undefined) {
+    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;
+}
+
+export function resolveGeometryInstanceBuffer(
+  c: Pick<
+    _InternalRenderPipelineContext,
+    'runtime' | 'pipelineState' | 'frameState' | 'bindGroupCounts'
+  >,
   entry: _InternalRenderPipelineContext['validatedOrdered'][number],
   identityInstanceDraws: readonly GeometryInstanceDraw[],
   useProbeBlend: boolean,
@@ -1304,6 +1664,11 @@ function resolveGeometryInstanceBuffer(
   // A present, empty Instances array means zero draws. Do not fall back to
   // the shared identity buffer, which would silently render one instance.
   if (inst.instanceCount === 0) return [];
+  const entityCacheKey = instanceCollectionCacheKey(entry.source.worldId, inst);
+  const revision = inst.revision ?? inst.archVersion;
+  const sameRevision = (cached: InstanceBufferCacheEntry): boolean =>
+    cached.uploadedRevision === revision;
+  const fullRange = [{ start: 0, end: inst.instanceCount }] as const;
   let instanceBuffer: Buffer = pipelineState.identityInstanceBuffer;
   let instanceCount = 1;
   {
@@ -1315,41 +1680,126 @@ function resolveGeometryInstanceBuffer(
     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 = new Set<string>();
       const draws: GeometryInstanceDraw[] = [];
+      const uniformStrideBytes = 16 * Float32Array.BYTES_PER_ELEMENT;
+      const uploadedRanges: { start: number; end: number }[] = [];
+      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 !== undefined &&
+          previous.uploadedArchVersion === inst.archVersion &&
+          previous.uploadedByteLength === payloadBytes
+            ? previous
+            : undefined;
+        let activeIsNew = false;
+        if (active === undefined) {
+          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 !== undefined && !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 === undefined) 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 !== undefined) {
+        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) {
@@ -1359,31 +1809,30 @@ function resolveGeometryInstanceBuffer(
     {
       // Cap-gate (LimitExceededDetail single emit point — feat-20260514
       // M3 / w15 anchor): `requestedBytes <= maxStorageBufferBindingSize`.
-      const instancePayload = uniformFallback
-        ? inst.transforms
-        : packInstanceStorageBuffer(inst.transforms);
-      const requestedBytes = instancePayload.byteLength;
+      // Derive the size from the authoring count; storage packing is deferred
+      // until uploadInstanceRanges confirms a new or dirty resident.
+      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 {
         // Look up the cached GPU buffer or create a fresh one when the
         // archetype version bumped or the byte length changed.
-        const cached = frameState.instanceBuffers.get(
-          worldEntityKey(entry.source.worldId, inst.cacheKey),
-        );
+        // entityCacheKey is the worldEntityKey + collectionId namespace.
+        const cached = frameState.instanceBuffers.get(entityCacheKey);
         let active: InstanceBufferCacheEntry | null = null;
+        let activeIsNew = false;
         if (
           cached !== undefined &&
           cached.uploadedArchVersion === inst.archVersion &&
@@ -1398,6 +1847,8 @@ function resolveGeometryInstanceBuffer(
           });
           if (!bufRes.ok) {
             runtime.errorRegistry.fire(bufRes.error);
+            reportInstanceFailure(c, inst, bufRes.error, requestedBytes, cap);
+            return null;
           } else {
             // feat-20260619 M4 / F12: destroy the old cached buffer
             // before replacing it with the new one (D-6).
@@ -1411,24 +1862,67 @@ function resolveGeometryInstanceBuffer(
               uploadedArchVersion: inst.archVersion,
               uploadedByteLength: requestedBytes,
             };
-            frameState.instanceBuffers.set(
-              worldEntityKey(entry.source.worldId, inst.cacheKey),
-              active,
-            );
+            activeIsNew = true;
+            if (active !== null) {
+              // Keep the collection identity in the worldEntityKey namespace.
+              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: readonly { readonly start: number; readonly end: number }[] = [];
+          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
+                    : undefined,
+              );
+              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
+                : undefined,
+            uploadRanges,
+            uploadedBytes,
+          });
+          clearInstanceChunksForOwner(c, entityCacheKey);
         }
       }
       // The cache write above is keyed by worldEntityKey(worldId, cacheKey)
@@ -1446,7 +1940,10 @@ function resolveGeometryInstanceBuffer(
 }
 
 export function resolveProbeBlendBuffer(
-  c: _InternalRenderPipelineContext,
+  c: Pick<
+    _InternalRenderPipelineContext,
+    'runtime' | 'pipelineState' | 'frameState' | 'bindGroupCounts'
+  >,
   record: import('../scene/probe-blend-record').ProbeBlendRecord | undefined,
   entityKey?: number,
 ): { readonly buffer: Buffer; readonly offset: number } {
@@ -1494,7 +1991,10 @@ export function resolveProbeBlendBuffer(
 }
 
 export function resolveGeometryInstancesBindGroup(
-  c: _InternalRenderPipelineContext,
+  c: Pick<
+    _InternalRenderPipelineContext,
+    'runtime' | 'pipelineState' | 'frameState' | 'bindGroupCounts'
+  >,
   instanceBuffer: Buffer,
   probeBuffer?: Buffer,
 ): BindGroup {