@forgeax/engine-render 0.1.24 → 0.1.26

package/dist/construct-renderer.mjs

@@ -1,22 +1,22 @@
-import { inspectVolumetricFog, inspectLodOcclusion, resolveSsrAdmissionGeneration, projectSsrDependencies, inspectReflectionFallback, admitReflectionProbe, DEFAULT_REFLECTION_PROBE_LIMITS, buildReflectionProbeTable, advanceProbeFilter, buildCubeCameraFaceViews, commitProbeFilterStep, resolveReflectionFallbackSource, deriveReflectionFallbackProjection, reflectionFallbackCoverage, reflectionFallbackSourceKey, reflectionFallbackProjectionSignature, createProbeFilterState, ReflectionProbeProjection, admitPointsLines, inspectPointShadow } from './chunk-UQYS7FRM.mjs';
-import { createExtendedLightingState, promoteExtendedLightingCandidate, OcclusionRenderRuntime, extractFrames, viewKey, primitiveKey, glyphTextLayoutSystem, projectExtendedLightingInspection, viewKeyId, primitiveKeyId, ProbeBlendSceneProjection, SKYLIGHT_RECOVERY_FALLBACK, InstanceBoundsCache, fingerprintNumericArray, createCookieProjectionMatrixData } from './chunk-Z3YYH2MB.mjs';
+import { inspectVolumetricFog, inspectLodOcclusion, resolveSsrAdmissionGeneration, projectSsrDependencies, inspectReflectionFallback, admitReflectionProbe, DEFAULT_REFLECTION_PROBE_LIMITS, buildReflectionProbeTable, advanceProbeFilter, buildCubeCameraFaceViews, commitProbeFilterStep, resolveReflectionFallbackSource, deriveReflectionFallbackProjection, reflectionFallbackCoverage, reflectionFallbackSourceKey, reflectionFallbackProjectionSignature, createProbeFilterState, ReflectionProbeProjection, admitPointsLines, inspectPointShadow } from './chunk-KM2NOX2I.mjs';
+import { createExtendedLightingState, promoteExtendedLightingCandidate, OcclusionRenderRuntime, extractFrames, viewKey, primitiveKey, glyphTextLayoutSystem, projectExtendedLightingInspection, viewKeyId, primitiveKeyId, ProbeBlendSceneProjection, SKYLIGHT_RECOVERY_FALLBACK, InstanceBoundsCache, fingerprintNumericArray, createCookieProjectionMatrixData } from './chunk-YUQXSEHG.mjs';
 import './chunk-FJ6P52EE.mjs';
-import { MeshFilter, MeshRenderer, Instances, Layer, Visibility, Camera, MotionBlur, DirectionalLight, LightProbe, PointLight, PointLightShadow, SpotLight, Skylight, SkyboxBackground, PostProcessParams, ReflectionProbe, VolumetricFog, projectMeshMaterialBindingObservation, createVisibilityBudget, hasVolumetricFogCapability, CUBE_CAMERA_FACE_ORDER, CAMERA_PROJECTION_ORTHOGRAPHIC } from './chunk-Q752SHI5.mjs';
+import { MeshFilter, MeshRenderer, Instances, Layer, Visibility, Points, Lines, SortKey, Camera, MotionBlur, DirectionalLight, LightProbe, PointLight, PointLightShadow, SpotLight, Skylight, SkyboxBackground, PostProcessParams, ReflectionProbe, VolumetricFog, projectMeshMaterialBindingObservation, createVisibilityBudget, hasVolumetricFogCapability, CUBE_CAMERA_FACE_ORDER, CAMERA_PROJECTION_ORTHOGRAPHIC } from './chunk-ADHHVYLW.mjs';
 import { SpriteInstances, SpriteRegionOverride, TileLayer, decodeSortScope, Tilemap } from './chunk-JDWARUOI.mjs';
-import { assertStorageBufferCap, GpuBuffer, GpuTexture, deriveRenderDataTexture, deriveRenderDataMesh, deriveRenderDataCubemap, createIblPipelines, CUBEMAP_FACE_VERTICES, runIblPrecompute, createClusterBinScratch, resetHdrpBuffers, retireTemporalGpuState, PostProcessError, entryHasDepthRead, DEPTH_MIN_PARAMS_BYTE_SIZE, postProcessShaderModuleLabel, resolveSsaoParameters, buildPerFrameBindGroups, postProcessShaderEntrySignature, PipelineSpecError, CAPTURE_VIEW_PROJS, PREFILTER_MIP_LEVELS, selectSwapChainFormat, setIblComposedShaders, POINTS_LINES_MATERIAL_SHADER_ID, createHdrpClusterMembershipBindGroupLayoutDescriptor, createSkylightFallback, buildSpecConstTable, buildLinearLdrMaterialSpecTable, getOrBuildPipeline, cacheKeyOf, REFLECTION_PROBE_VIEW_SLOT_BASE, VIEW_UNIFORM_SLOT_STRIDE, getOrCreateIblCache, postProcessShaderPipelineLabel, createPointsLinesLaneAdapter, computeViewMatrix, computeProjectionMatrix, prepareFrameLighting, warnMultiSkylight, warnMultiSkybox, selectLazyEquirectHandle, driveLazyEquirectProjection, warnZeroLightStandard, writeShadowParamsBuffer, writeSpotModifierTextures, writeHdrpClusterAndSsaoBuffers, resolveSkyboxActive, computeSplitLdrSprite, writeViewUbo, writePointsLinesViewUbo, writeShadowCasterUniforms, uploadMeshSsboBatch, passKindPolicyTable, colorFormatsForPassKind, configureSurface, VIEW_UNIFORM_BUFFER_SIZE, POINTS_LINES_VIEW_BUFFER_SIZE, SHADOW_CASTER_BUFFER_SIZE, FALLBACK_BYTES_PER_ROW, PREFILTER_SIZE, geometryRenderStateForTopology, assembleMaterialWithSkylightEntries, MESH_SSBO_BYTES, createPointsLinesLaneContract, foldDispatchBuckets, CUBE_CAPTURE_VIEW_SLOT_BASE, variantSetFromDefines, cleanPerEntityCache, ensureMeshSsboCapacity, buildFoldDispatchPlan, evaluateFoldBucketUniformCap, incrementFoldedDrawsMetric, buildFullscreenPostProcessPass, getTemporalGpuState, getTemporalParamsBuffer, getTemporalBindGroupResources, resolveSurfaceFormatPair, resolveSurfaceProfile, encodeMainPass, abortTemporalGpuSubmit, commitTemporalGpuSubmit, retireTemporalGpuStateAfterFence, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, DEFERRED_COLOR_FORMATS, aggregateTemporalDemand, standardTemporalLaneAdmission, addTypedScenePass, addTypedSsaoPasses, typedFrameClearColor, addTypedSkyboxPass, createStandardSceneDataTarget, addStandardSceneDataPass, addTypedFrameObservationPass, temporalReadIndex, temporalWriteIndex, addReflectionFallbackObservationPass, BYTES_PER_DIRECT_LIGHT_SLOT, createRenderPipelineTarget, resolveOutputDither, addTypedTemporalResolvePass, addTypedBloomPasses, addTypedOutputTransformPass, addTypedFullscreenPass, addTypedCompositePostEffects, standardTopologyVariantSet, geometryRenderStateForPass, standardStorageVariantSet, getOrCreateHdrpBuffers, encodeDirectionalShadowPass, encodePointShadowPass, encodeSpotShadowPass, VIEW_UNIFORM_BYTES, variantSetFromVertexLayoutProjection, MATERIAL_PER_ENTITY_STRIDE, isTemporalFullscreenBinding, createFullscreenBindGroup, applyParamSnapshotToUbo, residentTextureView, TYPED_BLOOM_PASS_NAMES } from './chunk-YRUYGA4A.mjs';
+import { assertStorageBufferCap, GpuBuffer, GpuTexture, deriveRenderDataTexture, deriveRenderDataMesh, deriveRenderDataCubemap, createIblPipelines, CUBEMAP_FACE_VERTICES, runIblPrecompute, InstanceProjectionStore, createClusterBinScratch, resetHdrpBuffers, retireTemporalGpuState, PostProcessError, entryHasDepthRead, DEPTH_MIN_PARAMS_BYTE_SIZE, postProcessShaderModuleLabel, resolveSsaoParameters, buildPerFrameBindGroups, postProcessShaderEntrySignature, PipelineSpecError, CAPTURE_VIEW_PROJS, PREFILTER_MIP_LEVELS, selectSwapChainFormat, setIblComposedShaders, POINTS_LINES_MATERIAL_SHADER_ID, createHdrpClusterMembershipBindGroupLayoutDescriptor, createSkylightFallback, buildSpecConstTable, buildLinearLdrMaterialSpecTable, getOrBuildPipeline, cacheKeyOf, REFLECTION_PROBE_VIEW_SLOT_BASE, VIEW_UNIFORM_SLOT_STRIDE, getOrCreateIblCache, postProcessShaderPipelineLabel, createPointsLinesLaneAdapter, computeViewMatrix, computeProjectionMatrix, prepareFrameLighting, warnMultiSkylight, warnMultiSkybox, selectLazyEquirectHandle, driveLazyEquirectProjection, warnZeroLightStandard, writeShadowParamsBuffer, writeSpotModifierTextures, writeHdrpClusterAndSsaoBuffers, resolveSkyboxActive, computeSplitLdrSprite, writeViewUbo, writePointsLinesViewUbo, writeShadowCasterUniforms, uploadMeshSsboBatch, passKindPolicyTable, colorFormatsForPassKind, configureSurface, VIEW_UNIFORM_BUFFER_SIZE, POINTS_LINES_VIEW_BUFFER_SIZE, SHADOW_CASTER_BUFFER_SIZE, FALLBACK_BYTES_PER_ROW, PREFILTER_SIZE, geometryRenderStateForTopology, assembleMaterialWithSkylightEntries, MESH_SSBO_BYTES, createPointsLinesLaneContract, foldDispatchBuckets, CUBE_CAPTURE_VIEW_SLOT_BASE, variantSetFromDefines, cleanPerEntityCache, ensureMeshSsboCapacity, buildFoldDispatchPlan, evaluateFoldBucketUniformCap, incrementFoldedDrawsMetric, writePbrMaterialUboPayload, applyParamSnapshotToUbo, applyMaterialTextureUvScales, residentTextureView, MATERIAL_PER_ENTITY_STRIDE, detectNineSliceScaleTooSmall, resolveGeometryInstanceBuffer, buildFullscreenPostProcessPass, getTemporalGpuState, getTemporalParamsBuffer, getTemporalBindGroupResources, resolveSurfaceFormatPair, resolveSurfaceProfile, encodeMainPass, STANDARD_PBR_UBO_SIZE, abortTemporalGpuSubmit, commitTemporalGpuSubmit, retireTemporalGpuStateAfterFence, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, DEFERRED_COLOR_FORMATS, aggregateTemporalDemand, standardTemporalLaneAdmission, addTypedScenePass, addTypedSsaoPasses, typedFrameClearColor, addTypedSkyboxPass, createStandardSceneDataTarget, addStandardSceneDataPass, addTypedFrameObservationPass, temporalReadIndex, temporalWriteIndex, addReflectionFallbackObservationPass, BYTES_PER_DIRECT_LIGHT_SLOT, createRenderPipelineTarget, resolveOutputDither, addTypedTemporalResolvePass, addTypedBloomPasses, addTypedOutputTransformPass, addTypedFullscreenPass, addTypedCompositePostEffects, standardTopologyVariantSet, geometryRenderStateForPass, standardStorageVariantSet, getOrCreateHdrpBuffers, encodeDirectionalShadowPass, encodePointShadowPass, encodeSpotShadowPass, VIEW_UNIFORM_BYTES, variantSetFromVertexLayoutProjection, isTemporalFullscreenBinding, createFullscreenBindGroup, TYPED_BLOOM_PASS_NAMES } from './chunk-TMIASV2N.mjs';
 import { getTransparentSortConfig, TRANSPARENT_SORT_MODE_DISTANCE, TRANSPARENT_SORT_MODE_LAYER_Z, TRANSPARENT_SORT_MODE_LAYER_Y, TRANSPARENT_SORT_MODE_LAYER_YZ } from './chunk-RXZ3RGOU.mjs';
-import { DEFAULT_STANDARD_PROFILE, DEFAULT_CLUSTER_GRID, createSceneDataCatalog, STANDARD_PIPELINE_ID, STANDARD_LIGHT_COUNTS, STANDARD_POST_STAGE_NAMES, resolveVolumetricFogProfile, isSceneDataTarget } from './chunk-TFH5I7JJ.mjs';
-import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-YKB5DQV7.mjs';
-import { DeviceScope, SKIN_MATERIAL_SHADER_ID, EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_MAP_READ, resolveRenderTargetMaterialSource, createRenderTargetMaterialSource, deriveExtendedLightingCapability, GPU_BUFFER_USAGE_VERTEX, GPU_BUFFER_USAGE_INDEX, EXTENDED_LIGHTING_TOPOLOGY, GPU_BUFFER_USAGE_UNIFORM, getTextureIdentity, worldEntityKey, createHdrpBindGroupLayoutDescriptor, createHdrpSkinBindGroupLayoutDescriptor, IES_SLICE_WIDTH, IES_SLICE_HEIGHT, COOKIE_SLICE_SIZE, COOKIE_MATRIX_BYTES, makeZeroCameraFallbackSnapshot, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_COPY_SRC, buildPbrPipelineLayouts, buildPbrSkinLayouts, GPU_BUFFER_USAGE_STORAGE, resolvePipelineGroup2Contract, GPU_SHADER_STAGE_FRAGMENT, validateGraphTargetCaptureReadback, isCanonicalStandardPbrMaterialShader, isStandardPbrMaterialShader, buildBindGroupLayoutDescriptor, GPU_BUFFER_USAGE_INDIRECT, buildPbrMaterialUserRegionEntries, extendedLightingSampledTextureCapacityAvailable, GPU_SHADER_STAGE_VERTEX, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, shadowCasterVariantSet, SHADOW_CASTER_SHADER_ID, LifecycleTransaction } from './chunk-KZFTK6DO.mjs';
-import { RendererContractFailureError, RendererOperationError, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, RenderTargetStateInvalidError, RenderTargetOperationFailedError, RenderTargetCapabilityMissingError, RenderTargetDescriptorInvalidError, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, RENDER_PHASE_CATALOG, FrameReceiptStaleError, RenderFeatureStageFailedError, RenderFeatureCapabilityMissingError, RenderFeatureRegistrationConflictError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_SRC, EnvironmentGenerationFailedError, PointsLinesMaterialUnsupportedError, StandardProfileInvalidError, TransmissionCapabilityMissingError, SHADOW_ATLAS_DEFAULT_LAYERS, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, TemporalFrameSubmitError, ObservationUnavailableError, RenderFeaturePreparationFailedError, PointsLinesPrepareFailedError, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SceneDataUnavailableError, RenderFeatureDrawRecordingFailedError, PointShadowAtlasUninitializedError, SkinPaletteOverflowError, RenderFeaturePreparedStateMismatchError, FXAA_POST_PROCESS_ID } from './chunk-RR5L4SRS.mjs';
+import { DEFAULT_STANDARD_PROFILE, DEFAULT_CLUSTER_GRID, createSceneDataCatalog, STANDARD_PIPELINE_ID, STANDARD_LIGHT_COUNTS, STANDARD_POST_STAGE_NAMES, resolveVolumetricFogProfile, isSceneDataTarget } from './chunk-E34VL5VI.mjs';
+import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-GF523LHF.mjs';
+import { DeviceScope, SKIN_MATERIAL_SHADER_ID, EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_MAP_READ, resolveRenderTargetMaterialSource, createRenderTargetMaterialSource, deriveExtendedLightingCapability, GPU_BUFFER_USAGE_VERTEX, GPU_BUFFER_USAGE_INDEX, EXTENDED_LIGHTING_TOPOLOGY, GPU_BUFFER_USAGE_UNIFORM, getTextureIdentity, worldEntityKey, createHdrpBindGroupLayoutDescriptor, createHdrpSkinBindGroupLayoutDescriptor, IES_SLICE_WIDTH, IES_SLICE_HEIGHT, COOKIE_SLICE_SIZE, COOKIE_MATRIX_BYTES, makeZeroCameraFallbackSnapshot, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_COPY_SRC, buildPbrPipelineLayouts, buildPbrSkinLayouts, GPU_BUFFER_USAGE_STORAGE, resolvePipelineGroup2Contract, GPU_SHADER_STAGE_FRAGMENT, instanceCollectionCacheKey, validateGraphTargetCaptureReadback, isCanonicalStandardPbrMaterialShader, isStandardPbrMaterialShader, buildBindGroupLayoutDescriptor, GPU_BUFFER_USAGE_INDIRECT, buildPbrMaterialUserRegionEntries, extendedLightingSampledTextureCapacityAvailable, GPU_SHADER_STAGE_VERTEX, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, shadowCasterVariantSet, SHADOW_CASTER_SHADER_ID, LifecycleTransaction } from './chunk-HKXTW355.mjs';
+import { RendererContractFailureError, RendererOperationError, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, RenderTargetStateInvalidError, RenderTargetOperationFailedError, RenderTargetCapabilityMissingError, RenderTargetDescriptorInvalidError, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, RENDER_PHASE_CATALOG, FrameReceiptStaleError, RenderFeatureStageFailedError, RenderFeatureCapabilityMissingError, RenderFeatureRegistrationConflictError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_SRC, EnvironmentGenerationFailedError, PointsLinesMaterialUnsupportedError, StandardProfileInvalidError, TransmissionCapabilityMissingError, SHADOW_ATLAS_DEFAULT_LAYERS, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, TemporalFrameSubmitError, ObservationUnavailableError, RenderFeaturePreparationFailedError, PointsLinesPrepareFailedError, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SceneDataUnavailableError, RenderFeatureDrawRecordingFailedError, PointShadowAtlasUninitializedError, SkinPaletteOverflowError, RenderFeaturePreparedStateMismatchError, FXAA_POST_PROCESS_ID } from './chunk-ZZ4YQ474.mjs';
 import { ok, err, RhiError, validateDrawArgs } from '@forgeax/engine-rhi';
 import { AssetRegistry, DynamicTextureStore, adaptDynamicTextureDevice, getOrCreateMipmapPipeline, prepareMipmaps, blitMipmapsSync, HANDLE_CUBE, HANDLE_TRIANGLE, HANDLE_QUAD, HANDLE_SPHERE, HANDLE_NINESLICE_QUAD, BuiltinAssetRegistry, resolveAssetHandle, numMipLevels, encodeMipmapLevel, resolveTilesetRuntime, MeshSsboCeilingReachedError, MeshSsboCapacityExceededError } from '@forgeax/engine-assets-runtime';
 import { audioLoader } from '@forgeax/engine-audio-webaudio';
 import { Update } from '@forgeax/engine-ecs';
 import { createRenderReadLease } from '@forgeax/engine-ecs/projection';
 import { PROCEDURAL_FLOATS_PER_VERTEX, deriveVertexLayoutProjection, deriveVertexBufferLayoutFromProjection, deriveVertexBufferLayout } from '@forgeax/engine-geometry';
-import { Transform, GlobalTransform, ChildOf, collectSubtree, Name, registerPropagateTransforms, Children } from '@forgeax/engine-scene';
-import { ShaderCatalog, findVariantByKey, LTC_TABLES, standardPhysicalTextureFields, LTC_TABLE_HEIGHT, LTC_TABLE_WIDTH, DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from '@forgeax/engine-shader';
+import { GlobalTransform, ChildOf, MorphWeights, collectSubtree, Name, registerPropagateTransforms, Children, Transform } from '@forgeax/engine-scene';
+import { ShaderCatalog, findVariantByKey, STANDARD_PIPELINE_PARAM_SCHEMA, LTC_TABLES, standardPhysicalTextureFields, LTC_TABLE_HEIGHT, LTC_TABLE_WIDTH, DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from '@forgeax/engine-shader';
 import { halfFloat, mat4, vec3, frustum, box3, mat3 } from '@forgeax/engine-math';
 import { err as err$1, ok as ok$1, derive, handleSlot, toShared, deriveTextureLayout, ASSET_ERROR_HINTS, countExtraUvSets, RenderQueue, IMAGE_ERROR_HINTS, unwrapHandle } from '@forgeax/engine-types';
 import { createCurrentFrameObservationLease, RenderGraphError, RenderGraphBuilder } from '@forgeax/engine-render-graph';
@@ -5904,8 +5904,8 @@ function pipelineCreationHint(error) {
 }
 function buildPipelineForMaterialShader(id, entry, ctx, renderState, geometry, vertexEntry, fragmentEntry, defines, passKind = "forward", sampleCount = 1) {
   const label = ctx.label ?? `pbr-pipeline-${id}`;
-  const vsEntry = (passKind === "temporal" ? "vs_temporal" : "vs_main");
-  const fsEntry = fragmentEntry ?? (passKind === "temporal" ? "fs_temporal" : passKind === "deferred" ? "fs_gbuffer" : "fs_main");
+  const vsEntry = vertexEntry ?? (passKind === "temporal" ? "vs_temporal" : "vs_main");
+  const fsEntry = fragmentEntry ?? (passKind === "temporal" ? "fs_temporal" : passKind === "deferred" ? "fs_gbuffer" : passKind === "shadow-caster" ? "fs_shadow" : "fs_main");
   let source = entry.source;
   const moduleResult = ctx.shaderModuleFactory.createShaderModule({
     code: source,
@@ -5928,12 +5928,13 @@ function buildPipelineForMaterialShader(id, entry, ctx, renderState, geometry, v
       vertex: {
         module: shaderModule,
         entryPoint: vsEntry,
-        buffers: ctx.layoutKind === "pbr-skin" ? [...ctx.vertexBuffers] : [
-          {
-            arrayStride: 12 * 4,
-            attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }]
-          }
-        ]
+        // Surface-backed Standard shadow entries evaluate the same material
+        // surface as Forward/Deferred, so their vertex stage consumes normal,
+        // UV, and tangent inputs in addition to position. Keep the complete
+        // derived mesh layout here; extra attributes remain legal for legacy
+        // position-only custom casters, while trimming to position would make
+        // the built-in Surface shadow shader fail WebGPU validation.
+        buffers: [...ctx.vertexBuffers]
       },
       // Vertex-only depth pass writes `fragment: undefined` (GPU derives
       // depth from gl_Position.z). A custom ShadowCaster shader with a
@@ -8880,6 +8881,7 @@ function popMin(heap) {
   return first;
 }
 function decideVisibility(input) {
+  if (!input.authorVisible) return { draw: false, stage: "author" };
   if (!input.validBounds) return { draw: true, stage: "bounds" };
   if (input.occlusion.status === "hidden" && input.occlusion.queryable) {
     return { draw: false, stage: "occlusion" };
@@ -10438,6 +10440,26 @@ var GpuDrivenProduction = class _GpuDrivenProduction {
   static forDevice(device, shaderModuleFactory) {
     return new _GpuDrivenProduction(device, shaderModuleFactory);
   }
+  /** Recovery has no frame retry: await generated programs before preparing the graph. */
+  static async forRecoveryDevice(device, factory, createShaderModule) {
+    const modules = /* @__PURE__ */ new Map();
+    for (const descriptor of [
+      { label: "gpu-driven-view", code: GPU_DRIVEN_VIEW_WGSL },
+      { label: "gpu-driven-rigid-unlit", code: GPU_DRIVEN_RIGID_UNLIT_WGSL }
+    ]) {
+      const module = await createShaderModule(descriptor);
+      if (!module.ok) return module;
+      modules.set(descriptor.code, module.value);
+    }
+    return ok(
+      new _GpuDrivenProduction(device, {
+        createShaderModule: (descriptor) => {
+          const module = modules.get(descriptor.code);
+          return module === void 0 ? factory.createShaderModule(descriptor) : ok(module);
+        }
+      })
+    );
+  }
   createRecoveryRoot(scope) {
     return {
       kind: "scene-table",
@@ -11661,6 +11683,27 @@ var StandardPointsLinesOwner = class {
   }
 };
 
+// src/instance-buffer-cache.ts
+function destroyInstanceBufferEntries(entries, errorRegistry) {
+  for (const entry of entries) {
+    if (entry.buffer.isDestroyed) continue;
+    const r = entry.buffer.destroy();
+    if (!r.ok && errorRegistry) errorRegistry.fire(r.error);
+  }
+}
+function disposeInstanceBuffers(map, errorRegistry) {
+  destroyInstanceBufferEntries(map.values(), errorRegistry);
+  map.clear();
+}
+function disposeInstanceBufferChunks(map, errorRegistry) {
+  destroyInstanceBufferEntries(map.values(), errorRegistry);
+  map.clear();
+}
+function disposeTransientInstanceBuffers(entries, errorRegistry) {
+  destroyInstanceBufferEntries(entries, errorRegistry);
+  entries.length = 0;
+}
+
 // src/pipeline/standard-lighting/inspection.ts
 function inspectStandardClusterTransport(transport, prepared) {
   return Object.freeze({
@@ -11703,22 +11746,117 @@ function inspectStandardLighting(input) {
   }
   return inspectStandardClusterTransport(input.transport, input.prepared);
 }
-
-// src/instance-buffer-cache.ts
-function destroyInstanceBufferEntries(entries, errorRegistry) {
-  for (const entry of entries) {
-    if (entry.buffer.isDestroyed) continue;
-    const r = entry.buffer.destroy();
-    if (!r.ok && errorRegistry) errorRegistry.fire(r.error);
+function uploadMaterialUniforms(c) {
+  const {
+    runtime,
+    world,
+    store,
+    pipelineState,
+    validatedOrdered,
+    frameState,
+    materialSlots,
+    materialSlotOwners,
+    materialSlotCount
+  } = c;
+  if (materialSlotCount === 0) return;
+  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
+    };
   }
-}
-function disposeInstanceBuffers(map, errorRegistry) {
-  destroyInstanceBufferEntries(map.values(), errorRegistry);
-  map.clear();
-}
-function disposeTransientInstanceBuffers(entries, errorRegistry) {
-  destroyInstanceBufferEntries(entries, errorRegistry);
-  entries.length = 0;
+  const materialUboUpload = runtime.device.queue.writeBuffer(
+    pipelineState.materialUniformBuffer.buffer,
+    0,
+    materialUboPayload
+  );
+  if (!materialUboUpload.ok) throw materialUboUpload.error;
 }
 
 // src/volume/temporal.ts
@@ -14908,7 +15046,11 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
     const materialSlots = dispatchPlan.materialSlots;
     const materialSlotOwners = dispatchPlan.materialSlotOwners;
     const materialSlotCount = dispatchPlan.materialSlotCount;
-    const splitLdrSprite = computeSplitLdrSprite(validatedOrdered, tonemapActive);
+    const splitLdrSprite = computeSplitLdrSprite(
+      validatedOrdered,
+      tonemapActive,
+      transparentDispatch
+    );
     let ldrSpritePassView = null;
     if (splitLdrSprite) {
       const unormViewRes = internals.device.createTextureView(currentTexture, {});
@@ -15084,6 +15226,7 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
       directionalShadowCacheReuse: directionalShadowCache.reuse,
       ...profilePhase !== void 0 ? { profilePhase } : {}
     };
+    uploadMaterialUniforms(passCtx);
     const fallbackReadbackRequest = createReflectionFallbackReadbackRequest(internals, frameState);
     if (fallbackReadbackRequest !== void 0) {
       frameState.reflectionFallbackReadback = fallbackReadbackRequest;
@@ -15592,13 +15735,19 @@ function cleanPerFrameCaches(internals, frameState, validated, retainedEntityKey
     disposeTransientInstanceBuffers(frameState.transientInstanceBuffers, internals.errorRegistry);
   }
   const validatedEntityKeys = new Set(retainedEntityKeys);
+  const validatedInstanceKeys = new Set(retainedEntityKeys);
   for (const v of validated) {
-    validatedEntityKeys.add(worldEntityKey(v.source.worldId, v.source.entityKey));
+    const entityKey = worldEntityKey(v.source.worldId, v.source.entityKey);
+    validatedEntityKeys.add(entityKey);
+    validatedInstanceKeys.add(entityKey);
+    if (v.source.instances !== void 0) {
+      validatedInstanceKeys.add(instanceCollectionCacheKey(v.source.worldId, v.source.instances));
+    }
   }
   cleanPerEntityCache(frameState.materialBgPerEntity, validatedEntityKeys);
   cleanPerEntityCache(frameState.instancesBgPerEntity, validatedEntityKeys);
   for (const [key, entry] of frameState.instanceBuffers.entries()) {
-    if (!validatedEntityKeys.has(key)) {
+    if (!validatedInstanceKeys.has(key)) {
       if (!entry.buffer.isDestroyed) {
         const r = entry.buffer.destroy();
         if (!r.ok) internals.errorRegistry.fire(r.error);
@@ -15606,6 +15755,24 @@ function cleanPerFrameCaches(internals, frameState, validated, retainedEntityKey
       frameState.instanceBuffers.delete(key);
     }
   }
+  if (frameState.instanceResidency !== void 0) {
+    const liveCollections = new Set(validated.map((entry) => entry.source.instances?.collectionId));
+    for (const id of frameState.instanceResidency.keys()) {
+      if (!liveCollections.has(id)) frameState.instanceResidency.delete(id);
+    }
+  }
+  if (frameState.instanceBufferChunks !== void 0) {
+    for (const [key, entry] of frameState.instanceBufferChunks.entries()) {
+      const separator = key.indexOf(":");
+      const ownerKey = separator < 0 ? Number.NaN : Number(key.slice(0, separator));
+      if (validatedInstanceKeys.has(ownerKey)) continue;
+      if (!entry.buffer.isDestroyed) {
+        const r = entry.buffer.destroy();
+        if (!r.ok) internals.errorRegistry.fire(r.error);
+      }
+      frameState.instanceBufferChunks.delete(key);
+    }
+  }
   if (frameState.morphBuffers !== void 0) {
     for (const [key, entry] of frameState.morphBuffers.entries()) {
       if (validatedEntityKeys.has(key)) continue;
@@ -16271,6 +16438,8 @@ function createRenderSystemRecovery(deps) {
       currentDirectionalShadowView: null,
       currentSpotShadowView: null,
       instanceBuffers: /* @__PURE__ */ new Map(),
+      instanceBufferChunks: /* @__PURE__ */ new Map(),
+      instanceResidency: /* @__PURE__ */ new Map(),
       morphBuffers: /* @__PURE__ */ new Map(),
       hdrpClusterBinScratch: createClusterBinScratch(),
       hdrpClusterGridScratch: null,
@@ -16346,7 +16515,7 @@ function createRenderSystemRecovery(deps) {
   const discardRecoveryGraphCandidate = (candidate) => {
     candidate.release();
   };
-  const prepareRecoveryGraphCandidate = (runtime) => {
+  const prepareRecoveryGraphCandidate = async (runtime) => {
     const seed = lastSuccessfulFrameSeed;
     if (seed === void 0) return { kind: "no-seed" };
     const camera = seed.frame.cameras[0];
@@ -16404,6 +16573,13 @@ function createRenderSystemRecovery(deps) {
       candidateGpuDrivenScene = void 0;
       candidatePointsLines?.release();
       candidatePointsLines = void 0;
+      disposeInstanceBuffers(candidateFrameState.instanceBuffers, runtime.internals.errorRegistry);
+      if (candidateFrameState.instanceBufferChunks !== void 0) {
+        disposeInstanceBufferChunks(
+          candidateFrameState.instanceBufferChunks,
+          runtime.internals.errorRegistry
+        );
+      }
       candidateGpuStore.destroyAll();
     };
     const markPublished = () => {
@@ -16421,10 +16597,14 @@ function createRenderSystemRecovery(deps) {
       if (!gpuScene.ok) return failed2("candidate GPU scene preparation failed", gpuScene.error);
       candidateGpuDrivenScene = gpuScene.value;
       if (candidateGpuDrivenScene.state !== void 0) {
-        candidateGpuDrivenProduction = GpuDrivenProduction.forDevice(
+        const production = await GpuDrivenProduction.forRecoveryDevice(
           runtime.internals.device,
-          gpuDrivenShaderFactory
+          gpuDrivenShaderFactory,
+          (descriptor) => internals.createShaderModule === void 0 ? Promise.resolve(gpuDrivenShaderFactory.createShaderModule(descriptor)) : internals.createShaderModule(runtime.internals.device, descriptor)
         );
+        if (!production.ok)
+          return failed2("candidate GPU-driven shader preparation failed", production.error);
+        candidateGpuDrivenProduction = production.value;
         const prepared = candidateGpuDrivenProduction.prepare({
           scene: candidateGpuDrivenScene.state,
           camera,
@@ -16583,6 +16763,24 @@ function createRenderSystemRecovery(deps) {
       if (candidateValidated.length !== seed.frame.renderables.length) {
         return failed2("candidate validation did not retain every LKG-visible renderable");
       }
+      for (const entry of candidateValidated) {
+        if (entry.source.instances === void 0) continue;
+        const prepared = resolveGeometryInstanceBuffer(
+          {
+            runtime: runtime.internals,
+            pipelineState: runtime.pipelineState,
+            frameState: candidateFrameState,
+            bindGroupCounts: { createBindGroup: 0, keys: [] }
+          },
+          entry,
+          [],
+          false
+        );
+        if (prepared === null) return failed2("candidate instance preparation failed");
+      }
+      for (const [id, residency] of candidateFrameState.instanceResidency ?? []) {
+        candidateFrameState.instanceResidency?.set(id, { ...residency, frameNumber: -1 });
+      }
       const lighting = prepareFrameLighting(
         runtime.internals,
         candidateFrameState,
@@ -16604,7 +16802,11 @@ function createRenderSystemRecovery(deps) {
         validated: candidateValidated,
         dispatch: seed.frame.dispatch,
         shadowCastersActive: seed.frame.lights.pointShadow.length > 0 || seed.frame.lights.spot.some((spot) => spot.castShadow === true) || (seed.frame.lights.lightViewProj?.length ?? 0) > 0,
-        splitLdrSprite: computeSplitLdrSprite(candidateValidated, camera.tonemap !== "none"),
+        splitLdrSprite: computeSplitLdrSprite(
+          candidateValidated,
+          camera.tonemap !== "none",
+          seed.frame.dispatch
+        ),
         reflectionFallbackAvailable: candidateFrameState.reflectionFallbackDemand === true
       });
       const candidatePostProcessIds = /* @__PURE__ */ new Set([
@@ -18319,6 +18521,10 @@ var GpuScene = class _GpuScene {
     drawTemplate: [],
     material: []
   };
+  /** Transform rows whose previous value advances only after submit. */
+  pendingTemporalTransforms = /* @__PURE__ */ new Set();
+  /** Previous rows whose post-submit upload must be retried before the next draw. */
+  pendingTemporalUploads = /* @__PURE__ */ new Set();
   static create(device, initialCapacity = 256) {
     if (!device.caps.storageBuffer) {
       return ok({ status: "unavailable", reason: "storage-buffer-unavailable" });
@@ -18345,26 +18551,37 @@ var GpuScene = class _GpuScene {
     return this.buffers.material;
   }
   sync(delta) {
-    if (delta.createdSlots.length === 0 && delta.updatedSlots.length === 0 && delta.recreatedSlots.length === 0 && delta.removedSlots.length === 0) {
+    for (const transformIndex of this.pendingTemporalUploads) {
+      this.writesByTable.transform.push(transformIndex);
+    }
+    const pendingWrites = TABLE_NAMES.some((name) => this.writesByTable[name].length > 0);
+    if (delta.createdSlots.length === 0 && delta.updatedSlots.length === 0 && delta.recreatedSlots.length === 0 && delta.removedSlots.length === 0 && !pendingWrites) {
       this.noChangeFrames += 1;
       return ok({ ranges: 0, bytes: 0, grew: false, cleared: 0 });
     }
     const writesByTable = this.writesByTable;
-    for (const name of TABLE_NAMES) writesByTable[name].length = 0;
-    if (!this.identityUploaded) writesByTable.transform.push(0);
+    if (!this.identityUploaded && !writesByTable.transform.includes(0)) {
+      writesByTable.transform.push(0);
+    }
     let highestChangedSlot = -1;
-    for (const records of [delta.createdSlots, delta.recreatedSlots]) {
+    const contentUpdatedSlots = delta.contentUpdatedSlots ?? [];
+    const contentUpdatedSlotIds = new Set(contentUpdatedSlots.map((record) => record.slot));
+    const allocationResets = /* @__PURE__ */ new Set();
+    for (const record of delta.removedSlots) {
+      if (record.slot > highestChangedSlot) highestChangedSlot = record.slot;
+      this.clearSlot(record.slot, writesByTable);
+    }
+    for (const records of [delta.createdSlots, contentUpdatedSlots, delta.recreatedSlots]) {
       for (const record of records) {
+        const previous = this.allocations[record.slot];
         this.ensureAllocation(record, writesByTable);
+        if (previous !== this.allocations[record.slot]) allocationResets.add(record.slot);
         if (record.slot > highestChangedSlot) highestChangedSlot = record.slot;
       }
     }
     for (const record of delta.updatedSlots) {
       if (record.slot > highestChangedSlot) highestChangedSlot = record.slot;
     }
-    for (const record of delta.removedSlots) {
-      if (record.slot > highestChangedSlot) highestChangedSlot = record.slot;
-    }
     const requiredCapacity = Math.max(
       highestChangedSlot + 1,
       this.instances.requiredCapacity(),
@@ -18378,11 +18595,18 @@ var GpuScene = class _GpuScene {
       if (!grown.ok) return grown;
     }
     for (const record of delta.createdSlots) this.writeSlot(record, true, writesByTable);
-    for (const record of delta.updatedSlots) this.writeRootTransform(record, false, writesByTable);
+    for (const record of contentUpdatedSlots) {
+      this.writeSlot(record, allocationResets.has(record.slot), writesByTable);
+    }
+    for (const record of delta.updatedSlots) {
+      if (contentUpdatedSlotIds.has(record.slot)) continue;
+      this.writeRootTransform(record, false, writesByTable);
+    }
     for (const record of delta.recreatedSlots) this.writeSlot(record, true, writesByTable);
-    for (const record of delta.removedSlots) this.clearSlot(record.slot, writesByTable);
     const uploaded = this.uploadRows(writesByTable);
     if (!uploaded.ok) return uploaded;
+    this.pendingTemporalUploads.clear();
+    for (const name of TABLE_NAMES) writesByTable[name].length = 0;
     this.identityUploaded = true;
     this.clearedSlots += delta.removedSlots.length;
     return ok({
@@ -18394,27 +18618,47 @@ var GpuScene = class _GpuScene {
   }
   /** Publish current transforms as previous only after a successful submit. */
   commitTemporalFrame(enabled = true) {
-    if (!enabled) return ok(void 0);
-    const nextTransform = this.tableBytes.transform.slice(0);
-    const next = new Uint8Array(nextTransform);
-    const current = this.transformBytes;
+    if (!enabled) {
+      this.pendingTemporalTransforms.clear();
+      this.pendingTemporalUploads.clear();
+      return ok(void 0);
+    }
+    if (this.pendingTemporalTransforms.size === 0) return ok(void 0);
     const currentOffset = offset(TRANSFORM, "currentWorld");
     const previousOffset = offset(TRANSFORM, "previousWorld");
-    for (let index = 0; index < this.capacity; index += 1) {
-      next.set(
-        current.subarray(
+    const ranges = coalesceSlots([...this.pendingTemporalTransforms]);
+    for (const range of ranges) {
+      for (let index = range.start; index < range.end; index += 1) {
+        this.pendingTemporalUploads.add(index);
+      }
+    }
+    for (const range of ranges) {
+      for (let index = range.start; index < range.end; index += 1) {
+        this.transformBytes.copyWithin(
+          index * TRANSFORM.stride + previousOffset,
           index * TRANSFORM.stride + currentOffset,
           index * TRANSFORM.stride + currentOffset + 64
-        ),
-        index * TRANSFORM.stride + previousOffset
+        );
+      }
+    }
+    for (const range of ranges) {
+      const firstOffset = range.start * TRANSFORM.stride;
+      const lastOffset = range.end * TRANSFORM.stride;
+      const uploaded = this.device.queue.writeBuffer(
+        this.buffers.transform,
+        firstOffset,
+        this.transformBytes.subarray(firstOffset, lastOffset)
       );
+      if (!uploaded.ok) return uploaded;
     }
-    const uploaded = this.device.queue.writeBuffer(this.buffers.transform, 0, next);
-    if (!uploaded.ok) return uploaded;
-    this.tableBytes.transform = nextTransform;
-    this.refreshTransformViews();
-    this.uploadRanges += 1;
-    this.uploadBytes += next.byteLength;
+    this.pendingTemporalTransforms.clear();
+    this.pendingTemporalUploads.clear();
+    const bytes2 = ranges.reduce(
+      (total, range) => total + (range.end - range.start) * TRANSFORM.stride,
+      0
+    );
+    this.uploadRanges += ranges.length;
+    this.uploadBytes += bytes2;
     return ok(void 0);
   }
   rebuild(slots) {
@@ -18423,6 +18667,9 @@ var GpuScene = class _GpuScene {
     this.transforms.reset(1);
     this.draws.reset();
     this.materials.reset();
+    this.pendingTemporalTransforms.clear();
+    this.pendingTemporalUploads.clear();
+    for (const name of TABLE_NAMES) this.writesByTable[name].length = 0;
     const writesByTable = {
       primitive: [],
       instance: [],
@@ -18573,7 +18820,8 @@ var GpuScene = class _GpuScene {
         const localCurrentOffset = localOffset + offset(TRANSFORM, "currentWorld");
         const localPreviousOffset = localOffset + offset(TRANSFORM, "previousWorld");
         writeMat4(transform, localCurrentOffset, localWorld);
-        writeMat4(transform, localPreviousOffset, localWorld);
+        if (resetPrevious) writeMat4(transform, localPreviousOffset, localWorld);
+        else this.pendingTemporalTransforms.add(transformIndex);
         writes.transform.push(transformIndex);
       }
       writes.instance.push(instanceIndex);
@@ -18672,14 +18920,16 @@ var GpuScene = class _GpuScene {
     const allocation = this.allocations[record.slot];
     if (allocation === void 0) throw new RangeError("GPU Scene allocation unavailable");
     const transformOffset = allocation.transformStart * TRANSFORM.stride;
-    const currentOffset = transformOffset + offset(TRANSFORM, "currentWorld");
     const previousOffset = transformOffset + offset(TRANSFORM, "previousWorld");
     if (resetPrevious) {
       writeMat4(this.transformView, previousOffset, record.snapshot.transform.world);
-    } else {
-      this.transformBytes.copyWithin(previousOffset, currentOffset, currentOffset + 64);
     }
-    writeMat4(this.transformView, currentOffset, record.snapshot.transform.world);
+    writeMat4(
+      this.transformView,
+      transformOffset + offset(TRANSFORM, "currentWorld"),
+      record.snapshot.transform.world
+    );
+    if (!resetPrevious) this.pendingTemporalTransforms.add(allocation.transformStart);
     writes.transform.push(allocation.transformStart);
   }
   clearSlot(slot, writes) {
@@ -18758,6 +19008,8 @@ var GpuScene = class _GpuScene {
         TRANSFORM.stride
       ).fill(0);
       writes.transform.push(transformIndex);
+      this.pendingTemporalTransforms.delete(transformIndex);
+      this.pendingTemporalUploads.delete(transformIndex);
     }
     for (let ordinal = 0; ordinal < allocation.drawCount; ordinal += 1) {
       const drawIndex = allocation.drawStart + ordinal;
@@ -19214,7 +19466,8 @@ function ownSnapshot(snapshot) {
         regions: new Float32Array(snapshot.spriteInstances.regions)
       }
     },
-    ...snapshot.pointsLines === void 0 ? {} : { pointsLines: ownPointsLinesSnapshot(snapshot.pointsLines) }
+    ...snapshot.pointsLines === void 0 ? {} : { pointsLines: ownPointsLinesSnapshot(snapshot.pointsLines) },
+    ...snapshot.skinJointEntities === void 0 ? {} : { skinJointEntities: [...snapshot.skinJointEntities] }
   };
 }
 function ownPointsLinesSnapshot(snapshot) {
@@ -19327,7 +19580,8 @@ var RenderScene = class {
         entityKey,
         initial,
         current: initial?.snapshot,
-        removed: false
+        removed: false,
+        contentChanged: false
       };
       entities.set(entityKey, pending);
       pendingOrder.push(pending);
@@ -19338,6 +19592,7 @@ var RenderScene = class {
         const { worldId, entityKey } = operation.snapshot;
         const pending2 = pendingFor(worldId, entityKey);
         pending2.current = ownSnapshot(operation.snapshot);
+        pending2.contentChanged = true;
         continue;
       }
       const pending = pendingFor(operation.worldId, operation.entityKey);
@@ -19358,6 +19613,7 @@ var RenderScene = class {
     let recreated = 0;
     const createdSlots = [];
     const updatedSlots = [];
+    const contentUpdatedSlots = [];
     const removedSlots = [];
     const recreatedSlots = [];
     for (const pending of pendingOrder) {
@@ -19395,6 +19651,7 @@ var RenderScene = class {
       this.indexMaterials(updatedSlot);
       this.dirtySinceSubmitted.add(updatedSlot.slot);
       updatedSlots.push(updatedSlot);
+      if (pending.contentChanged) contentUpdatedSlots.push(updatedSlot);
       updated += 1;
     }
     const changed = created + updated + removed + recreated > 0;
@@ -19410,6 +19667,7 @@ var RenderScene = class {
       ignoredLateUpdates,
       createdSlots,
       updatedSlots,
+      contentUpdatedSlots,
       removedSlots,
       recreatedSlots,
       resynced: 0
@@ -19783,7 +20041,7 @@ var RenderScene = class {
         entityKey: snapshot.entityKey,
         meshGeneration: fingerprintNumericArray(snapshot.localAabb) ^ snapshot.assetHandle >>> 0,
         transformGeneration: fingerprintNumericArray(snapshot.transform.world),
-        matrixGeneration: snapshot.instances.archVersion,
+        matrixGeneration: snapshot.instances.revision ?? snapshot.instances.archVersion,
         meshAabb: snapshot.localAabb,
         entityWorld: snapshot.transform.world,
         transforms: snapshot.instances.transforms
@@ -19801,7 +20059,6 @@ var RenderScene = class {
   }
 };
 var RENDER_RELEVANT_COMPONENT_IDS = /* @__PURE__ */ new Set([
-  componentId(Transform),
   componentId(GlobalTransform),
   componentId(ChildOf),
   componentId(MeshFilter),
@@ -19812,6 +20069,10 @@ var RENDER_RELEVANT_COMPONENT_IDS = /* @__PURE__ */ new Set([
   componentId(Skin),
   componentId(Layer),
   componentId(Visibility),
+  componentId(MorphWeights),
+  componentId(Points),
+  componentId(Lines),
+  componentId(SortKey),
   componentId(Camera),
   componentId(MotionBlur),
   componentId(DirectionalLight),
@@ -19825,6 +20086,36 @@ var RENDER_RELEVANT_COMPONENT_IDS = /* @__PURE__ */ new Set([
   componentId(ReflectionProbe),
   componentId(VolumetricFog)
 ]);
+var RENDERABLE_SOURCE_COMPONENTS = [
+  GlobalTransform,
+  ChildOf,
+  MeshFilter,
+  MeshRenderer,
+  Instances,
+  SpriteInstances,
+  SpriteRegionOverride,
+  Skin,
+  Layer,
+  Visibility,
+  MorphWeights,
+  Points,
+  Lines,
+  SortKey
+];
+var RENDERABLE_SOURCE_COMPONENT_IDS = new Set(
+  RENDERABLE_SOURCE_COMPONENTS.map((component) => componentId(component))
+);
+var VISIBILITY_DEPENDENCY_COMPONENT_IDS = /* @__PURE__ */ new Set([
+  componentId(ChildOf),
+  componentId(Visibility)
+]);
+var STRUCTURAL_MEMBERSHIP_SCAN_COMPONENT_IDS = /* @__PURE__ */ new Set([
+  componentId(ChildOf),
+  componentId(Layer),
+  componentId(Visibility),
+  componentId(SpriteRegionOverride),
+  componentId(SortKey)
+]);
 function createGlobalTransformChangeQuery(world) {
   const result = world.query({ read: [GlobalTransform], changed: [GlobalTransform] });
   if (!result.ok) throw result.error;
@@ -19833,6 +20124,107 @@ function createGlobalTransformChangeQuery(world) {
   }
   return query;
 }
+function createRenderChangeQueries(world) {
+  const queries = /* @__PURE__ */ new Map();
+  for (const component of RENDERABLE_SOURCE_COMPONENTS) {
+    const result = world.query({ read: [component], changed: [component] });
+    if (!result.ok) throw result.error;
+    const query = result.value;
+    for (const _span of query.spans().unwrap()) {
+    }
+    queries.set(componentId(component), query);
+  }
+  return queries;
+}
+function collectRenderableEntities(world) {
+  const result = /* @__PURE__ */ new Set();
+  const query = world.query({ read: [MeshRenderer], with: [Transform, MeshFilter] }).unwrap();
+  for (const row of query) result.add(row.entity);
+  return result;
+}
+function sourceMembershipChanged(world, slot) {
+  const entity = slot.entityKey;
+  const snapshot = slot.snapshot;
+  return !world.hasComponent(entity, GlobalTransform) || snapshot.instances !== void 0 !== world.hasComponent(entity, Instances) || snapshot.spriteInstances !== void 0 !== world.hasComponent(entity, SpriteInstances) || snapshot.skin !== void 0 !== world.hasComponent(entity, Skin) || snapshot.morph !== void 0 !== world.hasComponent(entity, MorphWeights) || snapshot.pointsLines?.component === "Points" !== world.hasComponent(entity, Points) || snapshot.pointsLines?.component === "Lines" !== world.hasComponent(entity, Lines);
+}
+function skinJointKey(worldId, jointEntity) {
+  return `${worldId}:${jointEntity}`;
+}
+function addSkinConsumer(index, snapshot) {
+  for (const jointEntity of snapshot.skinJointEntities ?? []) {
+    const key = skinJointKey(snapshot.worldId, jointEntity);
+    let consumers = index.get(key);
+    if (consumers === void 0) {
+      consumers = /* @__PURE__ */ new Set();
+      index.set(key, consumers);
+    }
+    consumers.add(snapshot.entityKey);
+  }
+}
+function removeSkinConsumer(index, snapshot) {
+  for (const jointEntity of snapshot.skinJointEntities ?? []) {
+    const key = skinJointKey(snapshot.worldId, jointEntity);
+    const consumers = index.get(key);
+    consumers?.delete(snapshot.entityKey);
+    if (consumers?.size === 0) index.delete(key);
+  }
+}
+function dispatchEntriesBySlot(frame, projection) {
+  const bySlot = /* @__PURE__ */ new Map();
+  const byRenderable = /* @__PURE__ */ new Map();
+  for (const entry of frame.dispatch) {
+    const list = byRenderable.get(entry.renderableIndex);
+    if (list === void 0) byRenderable.set(entry.renderableIndex, [entry]);
+    else list.push(entry);
+  }
+  for (let index = 0; index < frame.renderables.length; index += 1) {
+    const renderable = frame.renderables[index];
+    if (renderable === void 0) continue;
+    const slot = projection.slot(renderable.worldId, renderable.entityKey);
+    if (slot === void 0) continue;
+    bySlot.set(slot.slot, byRenderable.get(index) ?? []);
+  }
+  return bySlot;
+}
+function dispatchForProjection(dispatchBySlot, projection, unavailableSlots) {
+  const dispatch = [];
+  const renderables = projection.materialize();
+  for (let renderableIndex = 0; renderableIndex < renderables.length; renderableIndex += 1) {
+    const renderable = renderables[renderableIndex];
+    if (renderable === void 0) continue;
+    const slot = projection.slot(renderable.worldId, renderable.entityKey);
+    if (slot === void 0) continue;
+    if (unavailableSlots.has(slot.slot)) continue;
+    for (const entry of dispatchBySlot.get(slot.slot) ?? []) {
+      dispatch.push({ ...entry, renderableIndex });
+    }
+  }
+  return dispatch;
+}
+function topologyDeltaForAvailable(delta, unavailableSlots, newlyUnavailable) {
+  const updatedSlots = delta.updatedSlots.filter((slot) => !unavailableSlots.has(slot.slot));
+  const contentUpdatedSlots = delta.contentUpdatedSlots?.filter(
+    (slot) => !unavailableSlots.has(slot.slot)
+  );
+  return {
+    ...delta,
+    updatedSlots: [
+      ...updatedSlots,
+      ...newlyUnavailable.map((slot) => ({
+        ...slot,
+        snapshot: { ...slot.snapshot, gpuDrivenDraws: [] }
+      }))
+    ],
+    ...contentUpdatedSlots === void 0 ? {} : { contentUpdatedSlots }
+  };
+}
+function addSharedRefConsumers(projection, worldId, handle, target4) {
+  for (const slot of projection.slotsSnapshot()) {
+    if (slot.worldId === worldId && (slot.snapshot.assetHandle === handle || slot.snapshot.materials.some((material) => material.materialHandle === handle))) {
+      target4.add(slot.entityKey);
+    }
+  }
+}
 function frameDemandsTemporal(frame) {
   const camera = frame.cameras[0];
   return camera?.antialias === "taa" || (camera?.motionBlur?.shutterAngle ?? 0) > 0;
@@ -19883,6 +20275,10 @@ function cullPersistentFrame(frame, candidates, boundsOf2 = (snapshot) => worldB
   for (let index = 0; index < candidates.length; index += 1) {
     const candidate = candidates[index];
     if (candidate === void 0) continue;
+    if (candidate.authorVisible === false) {
+      culled += 1;
+      continue;
+    }
     let isVisible = true;
     const candidateBounds = boundsOf2(candidate, index);
     if (candidateBounds !== void 0) {
@@ -20112,6 +20508,7 @@ var PersistentRenderScene = class {
         const bounds = renderable.localAabb;
         const validBounds = bounds !== void 0 && bounds.length >= 6 && [...bounds].every((value) => Number.isFinite(value));
         draw = decideVisibility({
+          authorVisible: renderable.authorVisible !== false,
           validBounds,
           occlusion: this.visibilityFacets.getConfidence(view, primitive)}).draw;
       }
@@ -20213,10 +20610,16 @@ var PersistentRenderScene = class {
         preserveVisibilityOnReorder
       );
     }
-    if (!entry.rigidOnly) {
-      return this.rebuildComposition(worlds, owner, catalogEpoch, buildCandidateFrame, leases);
-    }
     let requiresRebuild = false;
+    const changedEntitiesByWorld = worlds.map(
+      (_, worldId) => new Set(entry.pendingRenderableEntitiesByWorld[worldId] ?? [])
+    );
+    const nextReadVersions = entry.readVersions.slice();
+    const structureChangedWorlds = /* @__PURE__ */ new Set();
+    const structuralComponentIdsByWorld = worlds.map(() => /* @__PURE__ */ new Set());
+    let refreshStructureFacts = false;
+    let currentRenderableEntitiesByWorld;
+    const removedSlots = [];
     for (let worldId = 0; worldId < worlds.length; worldId += 1) {
       const world = worlds[worldId];
       if (world === void 0) continue;
@@ -20237,32 +20640,239 @@ var PersistentRenderScene = class {
         requiresRebuild = true;
         break;
       }
-      if (read.status !== "ok") {
-        requiresRebuild = true;
-        break;
+      if (read.status === "rebuild") {
+        structureChangedWorlds.add(worldId);
+        refreshStructureFacts = true;
       }
       const changes = read.world;
       const shared = read.sharedRefs;
       if (shared.records.length > 0) {
         for (const record of shared.records) {
           this.options.onSharedRefMutation?.(worldId, record.handle);
+          const changed = changedEntitiesByWorld[worldId];
+          if (changed !== void 0)
+            addSharedRefConsumers(entry.projection, worldId, record.handle, changed);
         }
-        requiresRebuild = true;
-        break;
       }
       for (const changedComponentId of changes.changedComponentIds) {
+        if (read.status === "rebuild") {
+          structuralComponentIdsByWorld[worldId]?.add(changedComponentId);
+        }
         if (!RENDER_RELEVANT_COMPONENT_IDS.has(changedComponentId)) continue;
-        if (changedComponentId !== componentId(Transform) && changedComponentId !== componentId(GlobalTransform)) {
+        if (!RENDERABLE_SOURCE_COMPONENT_IDS.has(changedComponentId)) {
           requiresRebuild = true;
           break;
         }
+        const changed = changedEntitiesByWorld[worldId];
+        if (changed === void 0) continue;
+        if (VISIBILITY_DEPENDENCY_COMPONENT_IDS.has(changedComponentId)) {
+          refreshStructureFacts = true;
+          for (const entity of collectRenderableEntities(world)) changed.add(entity);
+          continue;
+        }
+        if (changedComponentId === componentId(GlobalTransform)) {
+          const query2 = entry.renderChangeQueries[worldId]?.get(changedComponentId);
+          for (const row of query2 ?? []) {
+            const consumers = entry.skinConsumersByJoint.get(
+              skinJointKey(worldId, row.entity)
+            );
+            for (const consumer of consumers ?? []) changed.add(consumer);
+          }
+          continue;
+        }
+        const query = entry.renderChangeQueries[worldId]?.get(changedComponentId);
+        if (query !== void 0) {
+          for (const row of query) changed.add(row.entity);
+        }
       }
       if (requiresRebuild) break;
-      entry.readVersions[worldId] = read.version;
+      nextReadVersions[worldId] = read.version;
     }
     if (requiresRebuild) {
       return this.rebuildComposition(worlds, owner, catalogEpoch, buildCandidateFrame, leases);
     }
+    if (structureChangedWorlds.size > 0) {
+      this.visibilityFacets.clear();
+      this.invalidateActiveEntityRevision();
+      const currentByWorld = worlds.map((world) => collectRenderableEntities(world));
+      currentRenderableEntitiesByWorld = currentByWorld;
+      for (let worldId = 0; worldId < currentByWorld.length; worldId += 1) {
+        const world = worlds[worldId];
+        const current = currentByWorld[worldId];
+        if (world === void 0 || current === void 0) continue;
+        const changed = changedEntitiesByWorld[worldId];
+        if (changed !== void 0 && structureChangedWorlds.has(worldId)) {
+          for (const [jointKey, consumers] of entry.skinConsumersByJoint) {
+            const separator = jointKey.indexOf(":");
+            const indexedWorldId = Number(jointKey.slice(0, separator));
+            if (indexedWorldId !== worldId) continue;
+            const jointEntity = Number(jointKey.slice(separator + 1));
+            if (world.hasComponent(jointEntity, GlobalTransform)) continue;
+            for (const consumer of consumers) changed.add(consumer);
+          }
+          for (const entity of current) {
+            if (entry.projection.slot(worldId, entity) === void 0) changed.add(entity);
+          }
+          const structuralComponentIds = structuralComponentIdsByWorld[worldId];
+          const scanAllMembership = structuralComponentIds !== void 0 && [...structuralComponentIds].some(
+            (id) => STRUCTURAL_MEMBERSHIP_SCAN_COMPONENT_IDS.has(id)
+          );
+          for (const slot of entry.projection.slotsSnapshot()) {
+            if (slot.worldId !== worldId || !current.has(slot.entityKey)) continue;
+            const membershipChanged = sourceMembershipChanged(world, slot);
+            if (scanAllMembership || membershipChanged) {
+              changed.add(slot.entityKey);
+              if (slot.snapshot.instances !== void 0 && !world.hasComponent(slot.entityKey, Instances)) {
+                this.options.instanceCollections?.release(world, slot.entityKey);
+              }
+              if (slot.snapshot.skin !== void 0 && !world.hasComponent(slot.entityKey, Skin)) {
+                this.options.getSkinPaletteAllocator?.()?.releaseSliceFor(`${world.identity}:${slot.entityKey}`);
+              }
+            }
+          }
+        }
+        for (const slot of entry.projection.slotsSnapshot()) {
+          if (slot.worldId !== worldId || current.has(slot.entityKey)) continue;
+          removedSlots.push(slot);
+        }
+        this.worldEntitiesScanned += current.size;
+      }
+    }
+    for (let worldId = 0; worldId < changedEntitiesByWorld.length; worldId += 1) {
+      const pending = entry.pendingRenderableEntitiesByWorld[worldId];
+      if (pending === void 0) continue;
+      for (const entityKey of changedEntitiesByWorld[worldId] ?? []) pending.add(entityKey);
+    }
+    let changedDelta;
+    const hasChangedEntities = changedEntitiesByWorld.some((entities) => entities.size > 0);
+    if (hasChangedEntities || removedSlots.length > 0) {
+      const operations = [];
+      const removedDemand = [];
+      const replacedSkinSnapshots = [];
+      for (let worldId = 0; worldId < changedEntitiesByWorld.length; worldId += 1) {
+        for (const entityKey of changedEntitiesByWorld[worldId] ?? []) {
+          const slot = entry.projection.slot(worldId, entityKey);
+          if (slot !== void 0) replacedSkinSnapshots.push(slot.snapshot);
+        }
+      }
+      for (const slot of removedSlots) {
+        operations.push({ kind: "remove", worldId: slot.worldId, entityKey: slot.entityKey });
+        if (slot.snapshot.skinJointEntities !== void 0) {
+          removeSkinConsumer(entry.skinConsumersByJoint, slot.snapshot);
+        }
+        const world = worlds[slot.worldId];
+        if (world !== void 0) this.options.instanceCollections?.release(world, slot.entityKey);
+        this.options.getSkinPaletteAllocator?.()?.releaseSliceFor(`${world?.identity ?? slot.worldId}:${slot.entityKey}`);
+        for (let materialIndex = 0; materialIndex < slot.snapshot.materials.length; materialIndex += 1) {
+          removedDemand.push({
+            kind: "remove",
+            key: `${slot.worldId}:${slot.entityKey}:${materialIndex}`
+          });
+        }
+      }
+      for (let worldId = 0; worldId < changedEntitiesByWorld.length; worldId += 1) {
+        for (const entityKey of changedEntitiesByWorld[worldId] ?? []) {
+          const slot = entry.projection.slot(worldId, entityKey);
+          if (slot === void 0) continue;
+          for (let materialIndex = 0; materialIndex < slot.snapshot.materials.length; materialIndex += 1) {
+            removedDemand.push({ kind: "remove", key: `${worldId}:${entityKey}:${materialIndex}` });
+          }
+        }
+      }
+      const partial = hasChangedEntities ? buildCandidateFrame({ kind: "partial", entitiesByWorld: changedEntitiesByWorld }) : void 0;
+      const publishedEntitiesByWorld = worlds.map(() => /* @__PURE__ */ new Set());
+      for (const snapshot of partial?.renderables ?? []) {
+        operations.push({ kind: "create", snapshot });
+        publishedEntitiesByWorld[snapshot.worldId]?.add(snapshot.entityKey);
+      }
+      changedDelta = entry.projection.apply(operations);
+      const publishedSkinKeys = /* @__PURE__ */ new Set();
+      for (const snapshot of partial?.renderables ?? []) {
+        publishedSkinKeys.add(`${snapshot.worldId}:${snapshot.entityKey}`);
+      }
+      for (const snapshot of replacedSkinSnapshots) {
+        if (snapshot.skinJointEntities !== void 0 && publishedSkinKeys.has(`${snapshot.worldId}:${snapshot.entityKey}`)) {
+          removeSkinConsumer(entry.skinConsumersByJoint, snapshot);
+        }
+      }
+      for (const snapshot of partial?.renderables ?? []) {
+        if (snapshot.skinJointEntities !== void 0) {
+          addSkinConsumer(entry.skinConsumersByJoint, snapshot);
+        }
+      }
+      entry.transmissionDemand.apply([
+        ...removedDemand,
+        ...transmissionDemandOperations(partial?.renderables ?? [])
+      ]);
+      for (const removed of changedDelta.removedSlots) entry.dispatchBySlot.delete(removed.slot);
+      for (const recreated of changedDelta.recreatedSlots)
+        entry.dispatchBySlot.delete(recreated.slot);
+      if (partial !== void 0) {
+        if (refreshStructureFacts) {
+          entry.structure = {
+            ...entry.structure,
+            dispatch: partial.dispatch,
+            visibilityStats: partial.visibilityStats,
+            visibilitySnapshots: partial.visibilitySnapshots,
+            featureVisibilitySnapshots: partial.featureVisibilitySnapshots,
+            hiddenEntityReports: partial.hiddenEntityReports
+          };
+        }
+        const partialDispatch = dispatchEntriesBySlot(partial, entry.projection);
+        for (const [slot, dispatch] of partialDispatch) entry.dispatchBySlot.set(slot, dispatch);
+        for (const snapshot of partial.renderables) {
+          const slot = entry.projection.slot(snapshot.worldId, snapshot.entityKey);
+          if (slot !== void 0 && !partialDispatch.has(slot.slot))
+            entry.dispatchBySlot.set(slot.slot, []);
+        }
+      }
+      for (let worldId = 0; worldId < changedEntitiesByWorld.length; worldId += 1) {
+        const requested = changedEntitiesByWorld[worldId];
+        const published = publishedEntitiesByWorld[worldId];
+        if (requested === void 0 || published === void 0) continue;
+        const pending = entry.pendingRenderableEntitiesByWorld[worldId];
+        for (const entityKey of requested) {
+          const slot = entry.projection.slot(worldId, entityKey);
+          if (published.has(entityKey)) {
+            pending?.delete(entityKey);
+            continue;
+          }
+          if (slot === void 0) {
+            const current = currentRenderableEntitiesByWorld?.[worldId];
+            if (current !== void 0 && !current.has(entityKey)) pending?.delete(entityKey);
+            continue;
+          }
+          pending?.add(entityKey);
+          if (slot !== void 0) entry.dispatchBySlot.set(slot.slot, []);
+        }
+      }
+      const newlyUnavailable = [];
+      for (let worldId = 0; worldId < changedEntitiesByWorld.length; worldId += 1) {
+        const requested = changedEntitiesByWorld[worldId];
+        const published = publishedEntitiesByWorld[worldId];
+        if (requested === void 0 || published === void 0) continue;
+        for (const entityKey of requested) {
+          const slot = entry.projection.slot(worldId, entityKey);
+          if (slot === void 0 || published.has(entityKey)) {
+            if (slot !== void 0) entry.unavailableSlots.delete(slot.slot);
+            continue;
+          }
+          if (!entry.unavailableSlots.has(slot.slot)) newlyUnavailable.push(slot);
+          entry.unavailableSlots.add(slot.slot);
+        }
+      }
+      for (const removed of changedDelta.removedSlots) entry.unavailableSlots.delete(removed.slot);
+      for (const recreated of changedDelta.recreatedSlots)
+        entry.unavailableSlots.delete(recreated.slot);
+      entry.dispatchRevision += 1;
+      entry.dispatchCache = void 0;
+      entry.topology.apply(
+        topologyDeltaForAvailable(changedDelta, entry.unavailableSlots, newlyUnavailable)
+      );
+      this.syncGpuOwner(entry.token, entry.projection, changedDelta);
+      this.deltaFrames += changedDelta.created + changedDelta.updated + changedDelta.removed + changedDelta.recreated > 0 ? 1 : 0;
+      this.transformUpdates += changedDelta.updated;
+    }
     const transformSpans = [];
     for (let worldId = 0; worldId < entry.transformQueries.length; worldId += 1) {
       const query = entry.transformQueries[worldId];
@@ -20280,17 +20890,29 @@ var PersistentRenderScene = class {
     if (requiresRebuild) {
       return this.rebuildComposition(worlds, owner, catalogEpoch, buildCandidateFrame, leases);
     }
-    if (transformSpans.length === 0) {
+    if (transformSpans.length === 0 && changedDelta === void 0) {
       this.noChangeFrames += 1;
       this.syncGpuOwner(entry.token, entry.projection);
-      return this.deriveFramePlan(entry, buildCandidateFrame);
+      const result2 = this.deriveFramePlan(entry, buildCandidateFrame);
+      for (let worldId = 0; worldId < nextReadVersions.length; worldId += 1) {
+        const version = nextReadVersions[worldId];
+        if (version !== void 0) entry.readVersions[worldId] = version;
+      }
+      return result2;
     }
-    const delta = entry.projection.applyTransformSpans(transformSpans);
-    entry.topology.apply(delta);
-    this.syncGpuOwner(entry.token, entry.projection, delta);
-    this.deltaFrames += 1;
-    this.transformUpdates += delta.updated;
-    return this.deriveFramePlan(entry, buildCandidateFrame);
+    if (transformSpans.length > 0) {
+      const delta = entry.projection.applyTransformSpans(transformSpans);
+      entry.topology.apply(topologyDeltaForAvailable(delta, entry.unavailableSlots, []));
+      this.syncGpuOwner(entry.token, entry.projection, delta);
+      this.deltaFrames += 1;
+      this.transformUpdates += delta.updated;
+    }
+    const result = this.deriveFramePlan(entry, buildCandidateFrame);
+    for (let worldId = 0; worldId < nextReadVersions.length; worldId += 1) {
+      const version = nextReadVersions[worldId];
+      if (version !== void 0) entry.readVersions[worldId] = version;
+    }
+    return result;
   }
   invalidate() {
     this.composition = void 0;
@@ -20311,6 +20933,14 @@ var PersistentRenderScene = class {
     this.visibilityFacets.detachAttachment(world.identity);
     this.materialSnapshotCaches.delete(world);
     const detachedComposition = this.composition?.worlds.includes(world) ? this.composition : void 0;
+    if (detachedComposition !== void 0) {
+      for (const slot of detachedComposition.projection.slotsSnapshot()) {
+        if (detachedComposition.worlds[slot.worldId] !== world) continue;
+        this.options.instanceCollections?.release(world, slot.entityKey);
+        if (slot.snapshot.skin === void 0) continue;
+        this.options.getSkinPaletteAllocator?.()?.releaseSliceFor(`${world.identity}:${slot.entityKey}`);
+      }
+    }
     if (detachedComposition !== void 0) this.composition = void 0;
     if (detachedComposition !== void 0) this.temporalCapture = void 0;
     if (detachedComposition !== void 0) {
@@ -20592,6 +21222,10 @@ var PersistentRenderScene = class {
     transmissionDemand.apply(transmissionDemandOperations(candidateFrame.renderables));
     const topology = new BatchTopology();
     topology.rebuild(projection.slotsSnapshot());
+    const skinConsumersByJoint = /* @__PURE__ */ new Map();
+    for (const snapshot of stableCandidateFrame.renderables) {
+      if (snapshot.skinJointEntities !== void 0) addSkinConsumer(skinConsumersByJoint, snapshot);
+    }
     const token2 = {};
     const entry = {
       token: token2,
@@ -20612,8 +21246,14 @@ var PersistentRenderScene = class {
       readVersions: leases === void 0 || leases.length !== worlds.length ? [] : leases.map((lease) => lease.captureVersion()),
       leaseIdentities: leases === void 0 || leases.length !== worlds.length ? [] : leases.map((lease) => lease.worldIdentity),
       transformQueries: leases === void 0 || leases.length !== worlds.length ? [] : worlds.map(createGlobalTransformChangeQuery),
+      renderChangeQueries: leases === void 0 || leases.length !== worlds.length ? [] : worlds.map(createRenderChangeQueries),
+      dispatchBySlot: dispatchEntriesBySlot(stableCandidateFrame, projection),
+      dispatchRevision: 0,
+      dispatchCache: void 0,
+      skinConsumersByJoint,
+      pendingRenderableEntitiesByWorld: worlds.map(() => /* @__PURE__ */ new Set()),
+      unavailableSlots: /* @__PURE__ */ new Set(),
       catalogEpoch,
-      rigidOnly: candidateFrame.renderables.every((renderable) => renderable.skin === void 0),
       probeProjection: new ProbeBlendSceneProjection(),
       temporalDemanded: frameDemandsTemporal(candidateFrame),
       gpuDrivenSceneRequired: true
@@ -20660,16 +21300,31 @@ var PersistentRenderScene = class {
    */
   deriveFramePlan(entry, buildCandidateFrame) {
     const resourceFrame = buildCandidateFrame("none");
-    const candidateFrame = { ...resourceFrame, ...entry.structure };
+    const cachedDispatch = entry.dispatchCache;
+    const dispatch = [
+      ...cachedDispatch?.revision === entry.dispatchRevision ? cachedDispatch.value : dispatchForProjection(entry.dispatchBySlot, entry.projection, entry.unavailableSlots)
+    ];
+    if (cachedDispatch?.revision !== entry.dispatchRevision) {
+      entry.dispatchCache = { revision: entry.dispatchRevision, value: dispatch };
+    }
+    const candidateFrame = {
+      ...resourceFrame,
+      ...entry.structure,
+      dispatch
+    };
     entry.temporalDemanded = frameDemandsTemporal(candidateFrame);
     entry.projection.setTemporalTracking(entry.temporalDemanded);
     this.projectProbes(entry, candidateFrame);
     this.projectReflectionProbes(candidateFrame.reflectionProbes ?? []);
     const materialized = entry.projection.materialize();
     const candidates = entry.temporalDemanded ? materialized.map((snapshot) => entry.projection.withTemporal(snapshot)) : materialized;
+    const drawableCandidates = entry.unavailableSlots.size === 0 ? candidates : candidates.map((snapshot) => {
+      const slot = entry.projection.slot(snapshot.worldId, snapshot.entityKey);
+      return slot !== void 0 && entry.unavailableSlots.has(slot.slot) ? { ...snapshot, authorVisible: false } : snapshot;
+    });
     const frameWithProbes = attachProbeRecords(
-      { ...candidateFrame, renderables: candidates },
-      candidates,
+      { ...candidateFrame, renderables: drawableCandidates },
+      drawableCandidates,
       entry.projection.slotsSnapshot(),
       entry.probeProjection
     );
@@ -21314,6 +21969,7 @@ function createRenderSystem(internals) {
   let preparedWorlds = [];
   let latestCamera;
   const pointsLinesOwner = new StandardPointsLinesOwner(internals);
+  const instanceCollections = new InstanceProjectionStore();
   const reflectionProbeOwner = new ReflectionProbeRecordOwner(internals);
   let ssrFormatReceipt;
   let ssrFormatProbeGeneration = -1;
@@ -21345,7 +22001,9 @@ function createRenderSystem(internals) {
     onGpuError: (error) => internals.errorRegistry.fire(error),
     onSharedRefMutation: (worldId, handle) => {
       internals.gpuStore.invalidateMesh(handle, preparedWorlds[worldId] ?? worldId);
-    }
+    },
+    instanceCollections,
+    getSkinPaletteAllocator: () => internals.getPipelineState()?.skinPaletteAllocator ?? null
   });
   let environmentLifecycle = new EnvironmentLifecycle(internals.deviceScope);
   const transmissionAdmission = new TransmissionCandidateAdmission();
@@ -21559,6 +22217,8 @@ function createRenderSystem(internals) {
     currentDirectionalShadowView: null,
     currentSpotShadowView: null,
     instanceBuffers: /* @__PURE__ */ new Map(),
+    instanceResidency: /* @__PURE__ */ new Map(),
+    instanceBufferChunks: /* @__PURE__ */ new Map(),
     probeBlendBuffers: /* @__PURE__ */ new Map(),
     probeBlendRecordBufferCapacity: 0,
     morphBuffers: /* @__PURE__ */ new Map(),
@@ -22282,6 +22942,12 @@ function createRenderSystem(internals) {
     createPreparedResolverCaches
   });
   return {
+    get instanceCollectionsInspection() {
+      return instanceCollections._inspections(
+        frameState.instanceResidency,
+        frameState.frameNumber - 1
+      );
+    },
     releaseProfilerCatalog() {
       releaseProfilerCatalog?.();
       releaseProfilerCatalog = void 0;
@@ -22487,15 +23153,30 @@ function createRenderSystem(internals) {
             compositionWorlds,
             { cameraOwner, resourceOwner },
             internals.assets.catalogEpoch,
-            (renderables2) => extractFrames(
+            (request) => extractFrames(
               compositionWorlds,
               { cameraOwner, resourceOwner },
               internals.assets,
               internals.getPipelineState(),
               persistentRenderScene.materialSnapshotCacheStore(),
               {
+                ...internals.device.caps.backendKind === "null" ? {} : {
+                  materialContext: {
+                    backend: internals.device.caps.backendKind === "wgpu-webgl2" ? "webgl2" : internals.device.caps.backendKind,
+                    capability: internals.device.caps.storageBuffer ? "storage-buffer" : "uniform-fallback",
+                    pipeline: "forward",
+                    geometry: "mesh",
+                    pass: "forward",
+                    profile: "forgeax-material-wgsl-v1",
+                    toolchain: "naga-oil",
+                    instrumentation: "none"
+                  }
+                },
                 cull: "none",
-                renderables: renderables2,
+                renderables: request === "none" ? "none" : "full",
+                ...request === "none" || request === "full" ? {} : { renderableEntitiesByWorld: request.entitiesByWorld },
+                retainHidden: true,
+                instanceCollections,
                 ...internals.getMaterialShaderArtifact === void 0 ? {} : { getMaterialShaderArtifact: internals.getMaterialShaderArtifact }
               }
             ),
@@ -23281,6 +23962,7 @@ function createRenderSystem(internals) {
       internals.gpuPassTimingBeginReason = void 0;
       pointsLinesOwner.dispose();
       persistentRenderScene.dispose();
+      instanceCollections.dispose();
       gpuDrivenProduction.dispose();
       occlusionRuntime?.dispose();
       disposeFeatureGpuWork();
@@ -23337,6 +24019,10 @@ function createRenderSystem(internals) {
       }
       frameState.retiredCompiledFrameGraphs.clear();
       disposeInstanceBuffers(frameState.instanceBuffers, internals.errorRegistry);
+      frameState.instanceResidency?.clear();
+      if (frameState.instanceBufferChunks !== void 0) {
+        disposeInstanceBufferChunks(frameState.instanceBufferChunks, internals.errorRegistry);
+      }
       disposeTransientInstanceBuffers(frameState.transientInstanceBuffers, internals.errorRegistry);
       if (frameState.probeBlendRecordBuffer !== void 0) {
         if (!frameState.probeBlendRecordBuffer.isDestroyed) {
@@ -23439,6 +24125,8 @@ function createRenderSystem(internals) {
       }
       frameState.retiredCompiledFrameGraphs.clear();
       frameState.instanceBuffers.clear();
+      frameState.instanceBufferChunks?.clear();
+      frameState.instanceResidency?.clear();
       delete frameState.probeBlendRecordBuffer;
       frameState.probeBlendRecordBufferCapacity = 0;
       frameState.probeBlendBuffers.clear();
@@ -24577,11 +25265,10 @@ async function prepareMaterialShaders(rhiDevice, getShader, assets, materialShad
   ]);
   const capValue = rhiDevice.limits.maxStorageBuffersPerShaderStage;
   const webgl2Downlevel = rhiDevice.caps.backendKind === "wgpu-webgl2";
-  let storageBufferCapable = !webgl2Downlevel;
-  if (typeof capValue === "number") {
+  const storageBufferCapable = rhiDevice.caps.storageBuffer;
+  if (storageBufferCapable && typeof capValue === "number") {
     const capCheck = assertStorageBufferCap(capValue);
     if (!capCheck.ok) throw capCheck.error;
-    storageBufferCapable = !webgl2Downlevel && capCheck.value;
   }
   const extendedLightingShaderAvailable = deriveExtendedLightingCapability(rhiDevice).admitted;
   const projectorAvailable = (rhiDevice.limits.maxSampledTexturesPerShaderStage ?? 0) >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES2;
@@ -24593,9 +25280,10 @@ async function prepareMaterialShaders(rhiDevice, getShader, assets, materialShad
   const isHdrpActive = false;
   for (const msEntry of registry.materialShaderManifestEntries()) {
     if (msEntry.identifier.startsWith("forgeax::engine-")) continue;
-    const variantDefines = {
-      STORAGE_BUFFER_AVAILABLE: storageBufferCapable
-    };
+    const variantDefines = {};
+    if (msEntry.variants.some((variant) => "STORAGE_BUFFER_AVAILABLE" in variant.defines)) {
+      variantDefines.STORAGE_BUFFER_AVAILABLE = storageBufferCapable;
+    }
     if (msEntry.variants.some((v) => "WEBGL2_COMPAT" in v.defines)) {
       variantDefines.WEBGL2_COMPAT = webgl2Downlevel;
     }
@@ -24678,7 +25366,7 @@ async function prepareMaterialShaders(rhiDevice, getShader, assets, materialShad
     if (manifestEntry !== void 0) {
       registry.installMaterialArtifact(shadowCasterIdentifier, {
         source: manifestEntry.composedWgsl,
-        paramSchema: []
+        paramSchema: STANDARD_PIPELINE_PARAM_SCHEMA
       });
       const shaderGuid = ENGINE_SHADER_GUIDS.get(shadowCasterIdentifier);
       if (shaderGuid !== void 0) {
@@ -24686,7 +25374,7 @@ async function prepareMaterialShaders(rhiDevice, getShader, assets, materialShad
           kind: "shader",
           name: shadowCasterIdentifier,
           source: manifestEntry.composedWgsl,
-          paramSchema: []
+          paramSchema: STANDARD_PIPELINE_PARAM_SCHEMA
         };
         assets.catalog(shaderGuid, shaderAsset);
       }
@@ -24775,6 +25463,47 @@ function resolveMaterialShaderVertexInputContract(source) {
   }
   return /@vertex\s*fn[^{]*\([^)]*@location\s*\(/u.test(withoutComments) ? "render-material" : "none";
 }
+function resolveMaterialShaderUvSetCount(source, reflectedCount) {
+  if (reflectedCount !== void 0) return reflectedCount;
+  if (source === void 0) return void 0;
+  const withoutComments = source.replace(/\/\*[\s\S]*?\*\//gu, "").replace(/\/\/.*$/gmu, "");
+  const inputStructs = [
+    ...withoutComments.matchAll(/struct\s+([A-Za-z_]\w*)\s*\{([^}]*)\}/gu)
+  ].filter((match) => /@location\s*\(/u.test(match[2] ?? ""));
+  for (const inputStruct of inputStructs) {
+    const name = inputStruct[1];
+    const body = inputStruct[2];
+    if (name === void 0 || body === void 0) continue;
+    const firstParameter = new RegExp(
+      `@vertex\\s*fn\\s+\\w+\\s*\\(\\s*\\w+\\s*:\\s*${name}\\b`,
+      "u"
+    );
+    if (!firstParameter.test(withoutComments)) continue;
+    let uvSetCount = 0;
+    for (const location of body.matchAll(/@location\s*\(\s*(\d+)\s*\)\s+([A-Za-z_]\w*)/gu)) {
+      const field = location[2];
+      if (field === "uv") {
+        uvSetCount = Math.max(uvSetCount, 1);
+        continue;
+      }
+      const uvIndex = field?.match(/^uv(\d+)_?$/u)?.[1];
+      if (uvIndex !== void 0) uvSetCount = Math.max(uvSetCount, Number(uvIndex) + 1);
+    }
+    return uvSetCount > 0 ? uvSetCount : void 0;
+  }
+  return void 0;
+}
+function resolveMaterialShaderBackendArtifactKey(materialShaderId, backendKind, artifact) {
+  if (backendKind !== "wgpu-webgl2") return materialShaderId;
+  const variants = artifact?.metadata?.variants;
+  if (!Array.isArray(variants)) return materialShaderId;
+  const fallback = variants.find((variant) => {
+    if (typeof variant !== "object" || variant === null) return false;
+    const candidate = variant;
+    return candidate.backend === "webgl2" && candidate.capability === "uniform-fallback" && typeof candidate.specializationKey === "string" && candidate.specializationKey.length > 0;
+  });
+  return fallback?.specializationKey ?? materialShaderId;
+}
 function allowsUnlitPreparedFallback(depthFormatOverride, vertexLayout, materialShaderId) {
   return depthFormatOverride === null && (vertexLayout === void 0 || !materialShaderId?.startsWith("forgeax::"));
 }
@@ -26016,7 +26745,7 @@ function createRendererRecovery(deps) {
       releaseCandidate();
       return err(new RecoverError("recover-device-unavailable"));
     }
-    const graphPreparation = renderSystem.prepareRecoveryGraphCandidate({
+    const graphPreparation = await renderSystem.prepareRecoveryGraphCandidate({
       internals: candidateInternals,
       pipelineState: candidatePipelineState
     });
@@ -27283,6 +28012,11 @@ function createSkinPaletteAllocator(device, maxBindingSize, useStorageBuffer = t
   let storageBuffer = null;
   let storageCapacity = 0;
   let storageCursor = 0;
+  let stableStorageCursor = 0;
+  const stableSlices = /* @__PURE__ */ new Map();
+  const stableUniformBuffers = /* @__PURE__ */ new Map();
+  const storageBufferCapacities = /* @__PURE__ */ new WeakMap();
+  const stableFreeRanges = [];
   const pool = [];
   let poolCursor = 0;
   function ensureStorageCapacity(needed) {
@@ -27303,12 +28037,9 @@ function createSkinPaletteAllocator(device, maxBindingSize, useStorageBuffer = t
     if (!bufRes.ok) throw bufRes.error;
     storageBuffer = bufRes.value;
     storageCapacity = newCapacity;
+    storageBufferCapacities.set(storageBuffer, newCapacity);
   }
-  function acquirePoolBuffer() {
-    if (poolCursor < pool.length) {
-      const reused = pool[poolCursor];
-      return reused;
-    }
+  function createUniformBuffer() {
     if (BINDING_WINDOW_BYTES > maxBindingSize) {
       throw new SkinPaletteOverflowError(BINDING_WINDOW_BYTES, maxBindingSize);
     }
@@ -27319,9 +28050,17 @@ function createSkinPaletteAllocator(device, maxBindingSize, useStorageBuffer = t
       mappedAtCreation: false
     });
     if (!bufRes.ok) throw bufRes.error;
-    pool.push(bufRes.value);
     return bufRes.value;
   }
+  function acquirePoolBuffer() {
+    if (poolCursor < pool.length) {
+      const reused = pool[poolCursor];
+      return reused;
+    }
+    const buffer = createUniformBuffer();
+    pool.push(buffer);
+    return buffer;
+  }
   function allocateSlice(jointCount) {
     if (useStorageBuffer) {
       const offset2 = storageCursor;
@@ -27335,6 +28074,88 @@ function createSkinPaletteAllocator(device, maxBindingSize, useStorageBuffer = t
     poolCursor += 1;
     return { jointCount, byteOffset: 0, buffer };
   }
+  function allocateSliceFor(key, jointCount) {
+    const existing = stableSlices.get(key);
+    if (existing !== void 0 && existing.jointCount === jointCount) return existing;
+    if (existing !== void 0) releaseSliceFor(key);
+    if (useStorageBuffer) {
+      const span = jointCount * MAT4_BYTES + (PALETTE_OFFSET_ALIGN - 1) & -256;
+      const freeIndex = stableFreeRanges.findIndex(
+        (range) => range.buffer === storageBuffer && range.count >= span && range.start + BINDING_WINDOW_BYTES <= range.capacity
+      );
+      let offset2;
+      let buffer2;
+      if (freeIndex >= 0) {
+        const range = stableFreeRanges[freeIndex];
+        if (range === void 0) throw new Error("Skin palette free range disappeared.");
+        offset2 = range.start;
+        buffer2 = range.buffer;
+        if (range.count === span) stableFreeRanges.splice(freeIndex, 1);
+        else {
+          stableFreeRanges[freeIndex] = {
+            ...range,
+            start: range.start + span,
+            count: range.count - span
+          };
+        }
+      } else {
+        offset2 = stableStorageCursor;
+        ensureStorageCapacity(offset2 + BINDING_WINDOW_BYTES);
+        const currentBuffer = storageBuffer;
+        if (currentBuffer === null) throw new Error("Skin palette storage buffer was not created.");
+        buffer2 = currentBuffer;
+        stableStorageCursor = offset2 + span;
+      }
+      const slice2 = { jointCount, byteOffset: offset2, buffer: buffer2 };
+      stableSlices.set(key, slice2);
+      return slice2;
+    }
+    let buffer = stableUniformBuffers.get(key);
+    if (buffer === void 0) {
+      buffer = createUniformBuffer();
+      stableUniformBuffers.set(key, buffer);
+    }
+    const slice = { jointCount, byteOffset: 0, buffer };
+    stableSlices.set(key, slice);
+    return slice;
+  }
+  function releaseSliceFor(key) {
+    const slice = stableSlices.get(key);
+    if (slice === void 0) return;
+    stableSlices.delete(key);
+    if (!useStorageBuffer) {
+      stableUniformBuffers.delete(key);
+      device.destroyBuffer(slice.buffer);
+      return;
+    }
+    const count = slice.jointCount * MAT4_BYTES + (PALETTE_OFFSET_ALIGN - 1) & -256;
+    stableFreeRanges.push({
+      start: slice.byteOffset,
+      count,
+      buffer: slice.buffer,
+      capacity: storageBufferCapacities.get(slice.buffer) ?? storageCapacity
+    });
+    stableFreeRanges.sort((left, right) => left.start - right.start);
+    for (let index = stableFreeRanges.length - 1; index > 0; index -= 1) {
+      const current = stableFreeRanges[index];
+      const previous = stableFreeRanges[index - 1];
+      if (current === void 0 || previous === void 0 || current.buffer !== previous.buffer || previous.start + previous.count !== current.start) {
+        continue;
+      }
+      stableFreeRanges[index - 1] = {
+        start: previous.start,
+        count: previous.count + current.count,
+        buffer: previous.buffer,
+        capacity: previous.capacity
+      };
+      stableFreeRanges.splice(index, 1);
+    }
+  }
+  function retainSliceKeys(keys) {
+    for (const key of stableSlices.keys()) {
+      if (!keys.has(key)) releaseSliceFor(key);
+    }
+  }
   function writeJointPalette(slice, ibms, jointWorlds) {
     const count = Math.min(slice.jointCount, ibms.length, jointWorlds.length);
     if (count === 0) return;
@@ -27365,6 +28186,9 @@ function createSkinPaletteAllocator(device, maxBindingSize, useStorageBuffer = t
     bindingWindowBytes: BINDING_WINDOW_BYTES,
     useStorageBuffer,
     allocateSlice,
+    allocateSliceFor,
+    releaseSliceFor,
+    retainSliceKeys,
     writeJointPalette,
     resetForFrame
   };
@@ -27695,13 +28519,8 @@ var DEPTH_TEXTURE_FORMAT = "depth24plus-stencil8";
 // src/assembly/webgpu-ready.ts
 async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, asyncCreateShaderModule, errorRegistry, requiredMaterialShaders, requiredFullscreenPostProcesses, setGrowMeshSsboHook, seedShaderModule, seedMaterialShaderPipelineCache, registerBuiltinTonemap, registerBuiltinFxaa, registerBuiltinTemporalPostProcesses, setVolumetricFogShaderSources) {
   const extendedLightingShaderAvailable = deriveExtendedLightingCapability(rhiDevice).admitted;
-  const capValue = rhiDevice.limits.maxStorageBuffersPerShaderStage;
+  const storageBufferCapable = rhiDevice.caps.storageBuffer;
   const webgl2Downlevel = rhiDevice.caps.backendKind === "wgpu-webgl2";
-  let storageBufferCapable = !webgl2Downlevel;
-  if (typeof capValue === "number") {
-    const capCheck = assertStorageBufferCap(capValue);
-    storageBufferCapable = capCheck.ok ? !webgl2Downlevel && capCheck.value : !webgl2Downlevel;
-  }
   const directionalPcssAvailable = rhiDevice.caps.backendKind === "webgpu" || rhiDevice.caps.backendKind === "wgpu-native";
   const projectorAvailable = (rhiDevice.limits.maxSampledTexturesPerShaderStage ?? 0) >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES2;
   const surfaceViewFormats = rhiDevice.surfaceViewFormats ?? !webgl2Downlevel;
@@ -30333,11 +31152,7 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
   return pipelineState;
 }
 
-// src/assembly/webgpu-renderer.ts
-function adaptMipmapShaderModuleFactory(factory) {
-  if (factory === void 0) return void 0;
-  return (device, descriptor) => factory(device, descriptor);
-}
+// src/assembly/webgpu-vertex-layouts.ts
 var PBR_SKIN_SENTINEL_ATTR_BUFFER = new ArrayBuffer(0);
 var DEFAULT_VERTEX_ATTRS = {
   position: new Float32Array(0),
@@ -30448,6 +31263,12 @@ function toGpuVertexBufferLayouts(entries) {
     }))
   }));
 }
+
+// src/assembly/webgpu-renderer.ts
+function adaptMipmapShaderModuleFactory(factory) {
+  if (factory === void 0) return void 0;
+  return (device, descriptor) => factory(device, descriptor);
+}
 var nextDerivedSystemId = 0;
 async function tryCreateWebGPURenderer(canvas, options, pack, bundler) {
   const importTransport = bundler?.importTransport;
@@ -31333,14 +32154,17 @@ async function makeWebGPURenderer(internals) {
     const viewOnlyLayout = bindingContract === "view-only" ? getOrBuildViewOnlyMaterialPipelineLayout() : null;
     const viewAndSceneDepthLayout = bindingContract === "view-and-scene-depth" ? getOrBuildViewAndSceneDepthMaterialPipelineLayout() : null;
     const preparedMaterialLayout = bindingContract === "render-material" && materialShaderId !== void 0 && (vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInstance || vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInstance) ? getOrBuildPreparedMaterialPipelineLayout(materialShaderId) : null;
-    const vertexInputContract = materialShaderId === void 0 ? "render-material" : (() => {
-      const lookup = getShader().findMaterialArtifact(materialShaderId);
-      return lookup.ok ? resolveMaterialShaderVertexInputContract(lookup.value.source) : "render-material";
-    })();
+    const materialShaderLookup = materialShaderId === void 0 ? void 0 : getShader().findMaterialArtifact(materialShaderId);
+    const materialShaderSource = materialShaderLookup?.ok ? materialShaderLookup.value.source : void 0;
+    const vertexInputContract = materialShaderId === void 0 ? "render-material" : materialShaderSource !== void 0 ? resolveMaterialShaderVertexInputContract(materialShaderSource) : "render-material";
     const currentState = currentPipelineState();
     const pipelineLayout = group0Layout !== null ? group0Layout.pipelineLayout : group0ResourceLayout !== null ? group0ResourceLayout.pipelineLayout : viewOnlyLayout !== null ? viewOnlyLayout : viewAndSceneDepthLayout !== null ? viewAndSceneDepthLayout : preparedMaterialLayout !== null ? preparedMaterialLayout : perShaderLayout !== null ? perShaderLayout.pipelineLayout : selectPipelineLayoutForVariant(currentState, variantSet, layoutKind);
     if (pipelineLayout === null) return null;
-    const resolvedUvSetCount = materialShaderId !== void 0 ? currentMaterialShaderUvSetCounts().get(materialShaderId) : void 0;
+    const currentMaterialUvSetCounts = currentMaterialShaderUvSetCounts();
+    const resolvedUvSetCount = materialShaderId !== void 0 ? currentMaterialUvSetCounts.get(materialShaderId) ?? (materialShaderSource !== void 0 ? resolveMaterialShaderUvSetCount(
+      materialShaderSource,
+      currentMaterialUvSetCounts.get(materialShaderId)
+    ) : void 0) : void 0;
     const vertexBuffers = vertexInputContract === "none" ? [] : vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.positionSizeColorInstance ? POSITION_SIZE_COLOR_INSTANCE_VERTEX_BUFFERS : vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInstance ? BILLBOARD_MATERIAL_INSTANCE_VERTEX_BUFFERS : vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.topologySegmentInstance ? TOPOLOGY_SEGMENT_INSTANCE_VERTEX_BUFFERS : vertexLayout === RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInstance ? MESH_GEOMETRY_MATERIAL_INSTANCE_VERTEX_BUFFERS : vertexLayoutProjection !== void 0 ? toGpuVertexBufferLayouts(
       deriveVertexBufferLayoutFromProjection(
         vertexLayoutProjection,
@@ -31382,7 +32206,7 @@ async function makeWebGPURenderer(internals) {
       ...layoutKind === "pbr-skin" ? { layoutKind } : {}
     };
   };
-  const buildAndCachePipeline = (cacheKey, entry, label, moduleLabel, isHdr, renderState, topology, stripIndexFormat, variantSet, passKind = "forward", materialShaderId, meshAttributes, sampleCount = 1, colorFormatOverride, depthFormatOverride, vertexLayout, vertexLayoutProjection, shaderModuleMode, layoutKindOverride, additionalColorFormats) => {
+  const buildAndCachePipeline = (cacheKey, entry, label, moduleLabel, isHdr, renderState, topology, stripIndexFormat, variantSet, passKind = "forward", materialShaderId, meshAttributes, sampleCount = 1, colorFormatOverride, depthFormatOverride, vertexLayout, vertexLayoutProjection, shaderModuleMode, layoutKindOverride, additionalColorFormats, vertexEntry, authoredFragmentEntry) => {
     const group2Contract = resolvePipelineGroup2Contract(entry.source);
     const ctx = buildPipelineContext(
       variantSet,
@@ -31398,7 +32222,7 @@ async function makeWebGPURenderer(internals) {
     const currentState = currentPipelineState();
     if (currentState === null) return null;
     const ldrColorFormat = colorFormatOverride ?? currentState.colorAttachmentFormat;
-    const fragmentEntry = isHdr && (materialShaderId === "forgeax::sprite" || materialShaderId === "forgeax::sprite-lit") ? "fs_main_hdr" : void 0;
+    const fragmentEntry = authoredFragmentEntry ?? (isHdr && (materialShaderId === "forgeax::sprite" || materialShaderId === "forgeax::sprite-lit") ? "fs_main_hdr" : void 0);
     const built = buildPipelineForMaterialShader(
       cacheKey,
       // The catalog entry is projected into the material-shader entry shape.
@@ -31427,8 +32251,7 @@ async function makeWebGPURenderer(internals) {
         topology,
         ...topology === "line-strip" || topology === "triangle-strip" ? { stripIndexFormat: stripIndexFormat ?? "uint32" } : {}
       } : void 0,
-      void 0,
-      // vertexEntry — default vs_main
+      vertexEntry,
       fragmentEntry,
       void 0,
       // defines — none
@@ -31448,13 +32271,29 @@ async function makeWebGPURenderer(internals) {
     );
     return built.value;
   };
-  const getMaterialShaderPipeline = (materialShaderId, isHdr, renderState, topology, indexFormat, variantSet, passKind = "forward", meshAttributes, sampleCount = 1, colorFormatOverride, shaderUvSetCount, depthFormatOverride, vertexLayout, vertexLayoutProjection, shaderModuleMode = "validated", layoutKindOverride, additionalColorFormats) => {
+  const getMaterialShaderPipeline = (materialShaderId, isHdr, renderState, topology, indexFormat, variantSet, passKind = "forward", meshAttributes, sampleCount = 1, colorFormatOverride, shaderUvSetCount, depthFormatOverride, vertexLayout, vertexLayoutProjection, shaderModuleMode = "validated", layoutKindOverride, additionalColorFormats, vertexEntry, fragmentEntry) => {
     const currentState = currentPipelineState();
     const ldrColorFormat = colorFormatOverride ?? (currentState !== null ? currentState.colorAttachmentFormat : "bgra8unorm-srgb");
-    const resolvedUvSetCount = shaderUvSetCount ?? currentMaterialShaderUvSetCounts().get(materialShaderId);
-    const manifestEntry = findMaterialShaderManifestEntry(materialShaderId);
-    const resolvedVariantSet = variantSet === void 0 && (materialShaderId === "forgeax::sprite" || materialShaderId === "forgeax::sprite-lit") ? void 0 : resolveCachedMaterialShaderVariantSet(variantSet, manifestEntry);
+    const pipelineShaderId = resolveMaterialShaderBackendArtifactKey(
+      materialShaderId,
+      internals.device.caps.backendKind,
+      assets.getMaterialArtifact(materialShaderId)
+    );
+    const materialShaderLookup = getShader().findMaterialArtifact(pipelineShaderId);
+    const materialShaderSource = materialShaderLookup.ok ? materialShaderLookup.value.source : void 0;
+    const currentMaterialUvSetCounts = currentMaterialShaderUvSetCounts();
+    const materialUvSetCount = resolveMaterialShaderUvSetCount(
+      materialShaderSource,
+      currentMaterialUvSetCounts.get(pipelineShaderId)
+    );
+    if (materialUvSetCount !== void 0) {
+      currentMaterialUvSetCounts.set(pipelineShaderId, materialUvSetCount);
+    }
+    const resolvedUvSetCount = shaderUvSetCount ?? materialUvSetCount;
+    const manifestEntry = findMaterialShaderManifestEntry(pipelineShaderId);
+    const resolvedVariantSet = variantSet === void 0 && (pipelineShaderId === "forgeax::sprite" || pipelineShaderId === "forgeax::sprite-lit") ? void 0 : resolveCachedMaterialShaderVariantSet(variantSet, manifestEntry);
     let effectiveVariantSet = normalizeMaterialShaderVariantSet(resolvedVariantSet, manifestEntry);
+    if (manifestEntry === void 0) effectiveVariantSet = void 0;
     if (vertexLayoutProjection === void 0 && manifestEntry?.variants.some((variant) => "VERTEX_COLOR_AVAILABLE" in variant.defines)) {
       if (effectiveVariantSet === "") {
         const noColorVariant = manifestEntry.variants.find(
@@ -31470,7 +32309,7 @@ async function makeWebGPURenderer(internals) {
         );
       }
     }
-    if (manifestEntry !== void 0 && !materialShaderId.startsWith("forgeax::") && effectiveVariantSet !== void 0 && effectiveVariantSet !== "") {
+    if (manifestEntry !== void 0 && !pipelineShaderId.startsWith("forgeax::") && effectiveVariantSet !== void 0 && effectiveVariantSet !== "") {
       const declaredAxes = /* @__PURE__ */ new Set();
       for (const variant of manifestEntry.variants) {
         for (const axis of Object.keys(variant.defines)) declaredAxes.add(axis);
@@ -31481,7 +32320,13 @@ async function makeWebGPURenderer(internals) {
     const colorFormat = isHdr ? "rgba16float" : ldrColorFormat;
     const isDepthOnlyPass = passKindPolicyTable[passKind]?.shape === "depth-only";
     const spec = {
-      shader: { id: materialShaderId, passKind, variantSet: effectiveVariantSet },
+      shader: {
+        id: pipelineShaderId,
+        passKind,
+        variantSet: effectiveVariantSet,
+        ...vertexEntry === void 0 ? {} : { vertexEntry },
+        ...fragmentEntry === void 0 ? {} : { fragmentEntry }
+      },
       attachments: {
         colorFormats: additionalColorFormats === void 0 ? colorFormatsForPassKind(passKind, colorFormat) : [colorFormat, ...additionalColorFormats],
         depthFormat: isDepthOnlyPass ? "depth32float" : depthFormatOverride === null ? void 0 : depthFormatOverride ?? "depth24plus-stencil8",
@@ -31503,12 +32348,12 @@ async function makeWebGPURenderer(internals) {
     const cached = currentPipelineCacheState().materialShaderPipelineCache.get(cacheKey);
     if (cached !== void 0) return cached;
     if (pipelineState === null) return null;
-    const lookup = getShader().findMaterialArtifact(materialShaderId);
+    const lookup = getShader().findMaterialArtifact(pipelineShaderId);
     if (!lookup.ok) {
       if (shouldDeferMissingPreparedMaterialShader(vertexLayout)) {
         return null;
       }
-      if (renderState === void 0 && !allowsUnlitPreparedFallback(depthFormatOverride, vertexLayout, materialShaderId)) {
+      if (renderState === void 0 && !allowsUnlitPreparedFallback(depthFormatOverride, vertexLayout, pipelineShaderId)) {
         return null;
       }
       if (renderState === void 0) {
@@ -31517,7 +32362,7 @@ async function makeWebGPURenderer(internals) {
         return buildAndCachePipeline(
           cacheKey,
           unlitLookup.value,
-          `pbr-pipeline-prepared-${materialShaderId}`,
+          `pbr-pipeline-prepared-${pipelineShaderId}`,
           // Reuse the eagerly compiled engine unlit module. The adapter cache
           // is seeded under this label during renderer readiness; a new label
           // would keep color-only prepared passes in perpetual warm-up.
@@ -31545,7 +32390,7 @@ async function makeWebGPURenderer(internals) {
       return buildAndCachePipeline(
         cacheKey,
         { source: pbrEntry.wgsl},
-        `pbr-pipeline-fallback-${materialShaderId}${isHdr ? "-hdr" : ""}`,
+        `pbr-pipeline-fallback-${pipelineShaderId}${isHdr ? "-hdr" : ""}`,
         // w16-b: module identity is the fallback PBR source, stable across
         // topology / renderState / HDR (all baked into the PSO) so every
         // variant reuses one compiled module.
@@ -31579,7 +32424,7 @@ async function makeWebGPURenderer(internals) {
         // layout resolution so buildPipelineContext derives the layout that
         // matches the compiled module. Skin keeps its
         // own id so the pbr-skin fail-fast (null layout) is preserved.
-        materialShaderId === SKIN_MATERIAL_SHADER_ID ? materialShaderId : "forgeax::default-standard-pbr",
+        pipelineShaderId === SKIN_MATERIAL_SHADER_ID ? pipelineShaderId : "forgeax::default-standard-pbr",
         // feat-20260611-fox-skinning-vertex-attribute-chain M4 / w16 (D-4):
         // forward meshAttributes through the fallback path so the pbr-skin
         // layout chain reads from the deriveVertexBufferLayout SSOT here too.
@@ -31598,7 +32443,7 @@ async function makeWebGPURenderer(internals) {
     if (effectiveVariantSet !== void 0) {
       const registry = getShader();
       for (const msEntry of registry.materialShaderManifestEntries()) {
-        if (msEntry.identifier === materialShaderId) {
+        if (msEntry.identifier === pipelineShaderId) {
           const variant = findVariantByKey(msEntry, effectiveVariantSet);
           if (variant) {
             shaderEntry = {
@@ -31615,7 +32460,7 @@ async function makeWebGPURenderer(internals) {
     return buildAndCachePipeline(
       cacheKey,
       shaderEntry,
-      `pbr-pipeline-${materialShaderId}${isHdr ? "-hdr" : ""}${passKindLabelSegment}`,
+      `pbr-pipeline-${pipelineShaderId}${isHdr ? "-hdr" : ""}${passKindLabelSegment}`,
       // feat-20260609 M4 / w31: when variantSet is non-empty, the module identity
       // includes the variant key so URP (STORAGE_BUFFER_AVAILABLE=true) and HDRP
       // (CLUSTER_FORWARD_AVAILABLE=true+STORAGE_BUFFER_AVAILABLE=true) variants
@@ -31628,7 +32473,7 @@ async function makeWebGPURenderer(internals) {
       // case is intentional (parallel to the cache key's `:variant:`
       // empty-tail segment); module identity stays a function of the
       // exact variantSet string.
-      effectiveVariantSet !== void 0 ? `module-${materialShaderId}#${effectiveVariantSet}` : `module-${materialShaderId}`,
+      effectiveVariantSet !== void 0 ? `module-${pipelineShaderId}#${effectiveVariantSet}` : `module-${pipelineShaderId}`,
       isHdr,
       renderState,
       topology,
@@ -31644,7 +32489,7 @@ async function makeWebGPURenderer(internals) {
       // bug-20260611-skin-pipeline-layout: thread the registered materialShaderId
       // so buildPipelineContext can resolve LayoutKind='pbr-skin' for the skin
       // shader (2-entry mesh-array BGL).
-      materialShaderId,
+      pipelineShaderId,
       // feat-20260611-fox-skinning-vertex-attribute-chain M4 / w16 (D-4):
       // forward meshAttributes so the pbr-skin path's vertex buffer layout
       // is derived via the SSOT (deriveVertexBufferLayout). For URP/HDRP
@@ -31658,7 +32503,9 @@ async function makeWebGPURenderer(internals) {
       vertexLayoutProjection,
       shaderModuleMode,
       layoutKindOverride,
-      additionalColorFormats
+      additionalColorFormats,
+      vertexEntry,
+      fragmentEntry
     );
   };
   const getMaterialShaderPipelineEntry = (...args) => {
@@ -31989,6 +32836,22 @@ async function makeWebGPURenderer(internals) {
         featureDiagnostics: internals.featureHost?.diagnostics() ?? Object.freeze([]),
         frustumStats: Object.freeze({ ...renderSystem.frustumStats }),
         visibilityStats: Object.freeze({ ...renderSystem.visibilityStats }),
+        instanceCollections: Object.freeze(
+          renderSystem.instanceCollectionsInspection.map(
+            (collection) => Object.freeze({
+              ...collection,
+              uploadRanges: Object.freeze(
+                collection.uploadRanges.map((range) => Object.freeze({ ...range }))
+              ),
+              ...collection.error === void 0 ? {} : {
+                error: Object.freeze({
+                  ...collection.error,
+                  detail: Object.freeze({ ...collection.error.detail })
+                })
+              }
+            })
+          )
+        ),
         renderScene: renderSystem.renderScene,
         reflectionProbes: renderSystem.reflectionProbes,
         ssrDependencies: renderSystem.ssrDependencies,