@forgeax/engine-render 0.1.26 → 0.1.28

package/dist/construct-renderer.mjs

@@ -1,18 +1,18 @@
-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, 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, 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 { createDynamicGeometryLifecycle, inspectVolumetricFog, inspectLodOcclusion, resolveSsrAdmissionGeneration, projectSsrDependencies, inspectReflectionFallback, admitReflectionProbe, DEFAULT_REFLECTION_PROBE_LIMITS, buildReflectionProbeTable, advanceProbeFilter, buildCubeCameraFaceViews, commitProbeFilterStep, resolveReflectionFallbackSource, deriveReflectionFallbackProjection, reflectionFallbackCoverage, reflectionFallbackSourceKey, reflectionFallbackProjectionSignature, createProbeFilterState, ReflectionProbeProjection, admitPointsLines, inspectPointShadow, DynamicGeometryError, sameCandidateCredential } from './chunk-J52NMQKR.mjs';
+import { createExtendedLightingState, promoteExtendedLightingCandidate, OcclusionRenderRuntime, extractFrames, viewKey, primitiveKey, glyphTextLayoutSystem, projectExtendedLightingInspection, viewKeyId, primitiveKeyId, ProbeBlendSceneProjection, SKYLIGHT_RECOVERY_FALLBACK, InstanceBoundsCache, fingerprintNumericArray, createCookieProjectionMatrixData } from './chunk-VSL23LZE.mjs';
+import './chunk-ILQ5MEZF.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-JAASCMXA.mjs';
+import { SpriteInstances, SpriteRegionOverride, TileLayer, decodeSortScope, Tilemap } from './chunk-RBDBZ5R7.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-MBU4ZVE7.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-E34VL5VI.mjs';
+import { DEFAULT_STANDARD_PROFILE, DEFAULT_CLUSTER_GRID, createSceneDataCatalog, STANDARD_PIPELINE_ID, STANDARD_LIGHT_COUNTS, STANDARD_POST_STAGE_NAMES, resolveVolumetricFogProfile, isSceneDataTarget } from './chunk-MYJ5RPJO.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 { 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-IQMKJLNU.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-J6KACNOH.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 { Update, FixedTime } from '@forgeax/engine-ecs';
 import { createRenderReadLease } from '@forgeax/engine-ecs/projection';
 import { PROCEDURAL_FLOATS_PER_VERTEX, deriveVertexLayoutProjection, deriveVertexBufferLayoutFromProjection, deriveVertexBufferLayout } from '@forgeax/engine-geometry';
 import { GlobalTransform, ChildOf, MorphWeights, collectSubtree, Name, registerPropagateTransforms, Children, Transform } from '@forgeax/engine-scene';
@@ -284,6 +284,11 @@ function exposeRenderer(renderer) {
         })
       );
     },
+    prepareDynamicGeometry: (input) => renderer.prepareDynamicGeometry(input),
+    acceptDynamicGeometry: (candidate, ordering) => renderer.acceptDynamicGeometry(candidate, ordering),
+    dynamicGeometryReceipt: (candidate) => renderer.dynamicGeometryReceipt(candidate),
+    cancelDynamicGeometry: (candidate) => renderer.cancelDynamicGeometry(candidate),
+    retireDynamicGeometry: (candidate) => renderer.retireDynamicGeometry(candidate),
     createRenderTarget: (descriptor) => renderer.createRenderTarget(descriptor),
     resizeRenderTarget: (target4, descriptor) => renderer.resizeRenderTarget(target4, descriptor),
     createRenderTargetTextureSource: (target4, options) => renderer.createRenderTargetTextureSource(target4, options),
@@ -498,6 +503,68 @@ function freezeRenderProfile(profile) {
     postStages: Object.freeze([...profile.postStages])
   });
 }
+
+// src/device/mesh-residency-lifetime.ts
+var MeshResidencyLifetime = class {
+  constructor(destroy) {
+    this.destroy = destroy;
+  }
+  destroy;
+  leases = 0;
+  retired = false;
+  eviction;
+  submissions = /* @__PURE__ */ new Set();
+  waiters = /* @__PURE__ */ new Set();
+  get owners() {
+    return this.leases;
+  }
+  retain(evict) {
+    this.leases += 1;
+    this.eviction = void 0;
+    let released = false;
+    let completion;
+    return {
+      track: (submitted) => this.track(submitted),
+      release: (shouldEvict) => {
+        if (released) return completion;
+        released = true;
+        this.leases -= 1;
+        if (this.leases === 0 && shouldEvict) this.eviction = evict;
+        completion = this.submissions.size === 0 ? void 0 : new Promise((resolve) => this.waiters.add(resolve));
+        this.flush();
+        return completion;
+      }
+    };
+  }
+  track(completed) {
+    if (this.submissions.has(completed)) return;
+    this.submissions.add(completed);
+    const finish = () => {
+      this.submissions.delete(completed);
+      this.flush();
+    };
+    void completed.then(finish, finish);
+  }
+  retire() {
+    this.retired = true;
+    this.flush();
+  }
+  flush() {
+    if (this.submissions.size !== 0) return;
+    if (this.leases === 0 && this.eviction !== void 0) {
+      const evict = this.eviction;
+      this.eviction = void 0;
+      evict();
+    }
+    if (this.retired && this.leases === 0 && this.destroy !== void 0) {
+      const destroy = this.destroy;
+      this.destroy = void 0;
+      destroy();
+    }
+    for (const resolve of this.waiters) resolve();
+    this.waiters.clear();
+  }
+};
 var DYNAMIC_OFFSET_STRIDE = 256;
 var FACE_COUNT = 6;
 var PREFILTER_SUBPASS_COUNT = PREFILTER_MIP_LEVELS * FACE_COUNT;
@@ -741,6 +808,33 @@ var GpuResidencyCache = class {
   // equirect source always resolves to the same cubemap (idempotent, A2).
   cubemapIdempotentMap = /* @__PURE__ */ new Map();
   meshGpuHandles = /* @__PURE__ */ new Map();
+  meshLifetimes = /* @__PURE__ */ new WeakMap();
+  retiredMeshes = /* @__PURE__ */ new Set();
+  meshLifetime(entry) {
+    let lifetime = this.meshLifetimes.get(entry);
+    if (lifetime === void 0) {
+      lifetime = new MeshResidencyLifetime(() => {
+        if (!entry.vertexBuffer.isDestroyed) entry.vertexBuffer.destroy();
+        if (entry.indexBuffer !== null && !entry.indexBuffer.isDestroyed)
+          entry.indexBuffer.destroy();
+        this.retiredMeshes.delete(entry);
+      });
+      this.meshLifetimes.set(entry, lifetime);
+    }
+    return lifetime;
+  }
+  /** All resident entries conservatively cover main, shadow and cached GPU-driven draws. */
+  trackMeshSubmission(completed) {
+    for (const entry of this.meshGpuHandles.values()) this.meshLifetime(entry).track(completed);
+  }
+  retireMeshEntry(key, entry) {
+    if (this.meshGpuHandles.get(key) === entry) {
+      this.meshGpuHandles.delete(key);
+      this.meshResidencyEpoch += 1;
+    }
+    this.retiredMeshes.add(entry);
+    this.meshLifetime(entry).retire();
+  }
   /**
    * Compose a cache key from the raw handle slot and its owning World. The
    * draw-time world index is only a position in one frame's `worlds[]`; it is
@@ -870,11 +964,12 @@ var GpuResidencyCache = class {
     }
     this.cubemapGpuHandles.clear();
     this.cubemapIdempotentMap.clear();
-    for (const entry of this.meshGpuHandles.values()) {
+    for (const entry of [...this.meshGpuHandles.values(), ...this.retiredMeshes]) {
       destroyBuf(entry.vertexBuffer);
       if (entry.indexBuffer !== null) destroyBuf(entry.indexBuffer);
     }
     this.meshGpuHandles.clear();
+    this.retiredMeshes.clear();
   }
   /** Number of candidate-owned GPU resources currently held by this cache. */
   recoveryResourceCount() {
@@ -886,7 +981,7 @@ var GpuResidencyCache = class {
         cubemapResources += 1;
       }
     }
-    return this.meshGpuHandles.size + this.textureGpuHandles.size + this.samplerGpuHandles.size + cubemapResources;
+    return this.meshGpuHandles.size + this.retiredMeshes.size + this.textureGpuHandles.size + this.samplerGpuHandles.size + cubemapResources;
   }
   /** Candidate root for the cache owner, not a scalar readiness marker. */
   createRecoveryRoot(scope) {
@@ -941,24 +1036,12 @@ var GpuResidencyCache = class {
     const id = this.worldKey(handleSlot(handle), worldId);
     const entry = this.meshGpuHandles.get(id);
     if (entry === void 0) return { freed: 0, errors: [] };
-    let freed = 0;
-    const errors = [];
-    const destroyBuf = (gpuBuf) => {
-      if (!gpuBuf.isDestroyed) {
-        const r = gpuBuf.destroy();
-        if (r.ok) {
-          freed += 1;
-        } else {
-          errors.push(r.error);
-          if (this.errorRegistry) this.errorRegistry.fire(r.error);
-        }
-      }
+    if (this.meshLifetime(entry).owners > 0) return { freed: 0, errors: [] };
+    this.retireMeshEntry(id, entry);
+    return {
+      freed: Number(entry.vertexBuffer.isDestroyed) + Number(entry.indexBuffer?.isDestroyed ?? false),
+      errors: []
     };
-    destroyBuf(entry.vertexBuffer);
-    if (entry.indexBuffer !== null) destroyBuf(entry.indexBuffer);
-    this.meshGpuHandles.delete(id);
-    this.meshResidencyEpoch += 1;
-    return { freed: freed > 0 ? 1 : 0, errors };
   }
   evictCubemap(id) {
     const entry = this.cubemapGpuHandles.get(id);
@@ -989,7 +1072,6 @@ var GpuResidencyCache = class {
   releaseUnreferenced(liveSet) {
     let freed = 0;
     const errors = [];
-    let meshResidencyChanged = false;
     let materialResidencyChanged = false;
     const liveSlots = new Set([...liveSet].map((slot) => String(slot)));
     const isLiveKey = (key) => {
@@ -1037,34 +1119,12 @@ var GpuResidencyCache = class {
         }
       }
     }
-    for (const key of this.meshGpuHandles.keys()) {
-      if (!isLiveKey(key)) {
-        const entry = this.meshGpuHandles.get(key);
-        if (entry !== void 0) {
-          if (!entry.vertexBuffer.isDestroyed) {
-            const r = entry.vertexBuffer.destroy();
-            if (r.ok) {
-              freed += 1;
-            } else {
-              errors.push(r.error);
-              if (this.errorRegistry) this.errorRegistry.fire(r.error);
-            }
-          }
-          if (entry.indexBuffer !== null && !entry.indexBuffer.isDestroyed) {
-            const r = entry.indexBuffer.destroy();
-            if (r.ok) {
-              freed += 1;
-            } else {
-              errors.push(r.error);
-              if (this.errorRegistry) this.errorRegistry.fire(r.error);
-            }
-          }
-          this.meshGpuHandles.delete(key);
-          meshResidencyChanged = true;
-        }
+    for (const [key, entry] of this.meshGpuHandles) {
+      if (!isLiveKey(key) && this.meshLifetime(entry).owners === 0) {
+        this.retireMeshEntry(key, entry);
+        freed += Number(entry.vertexBuffer.isDestroyed) + Number(entry.indexBuffer?.isDestroyed ?? false);
       }
     }
-    if (meshResidencyChanged) this.meshResidencyEpoch += 1;
     if (materialResidencyChanged) this.materialResourceEpoch += 1;
     return { freed, errors };
   }
@@ -1184,19 +1244,20 @@ var GpuResidencyCache = class {
   getMeshGpuHandles(handle, worldId = 0) {
     return this.meshGpuHandles.get(this.worldKey(handleSlot(handle), worldId));
   }
-  /**
-   * Drop one mutable shared mesh's GPU copy after ECS publishes `markChanged`.
-   * The next record pass resolves the same POD and rebuilds residency through
-   * the normal pull path, so ECS remains the payload authority.
-   */
+  /** Candidate leases retain the concrete allocation even after cache invalidation. */
+  retainMeshResidency(handle, worldId = 0) {
+    const key = this.worldKey(handleSlot(handle), worldId);
+    const entry = this.meshGpuHandles.get(key);
+    return entry === void 0 ? void 0 : this.meshLifetime(entry).retain(() => {
+      if (this.meshGpuHandles.get(key) === entry) this.invalidateMesh(handle, worldId);
+      else this.meshLifetime(entry).retire();
+    });
+  }
+  /** In-place author changes immediately miss the cache; old submissions keep their allocation. */
   invalidateMesh(handle, worldId = 0) {
     const key = this.worldKey(handleSlot(toShared(handle)), worldId);
     const entry = this.meshGpuHandles.get(key);
-    if (entry === void 0) return;
-    entry.vertexBuffer.destroy();
-    if (entry.indexBuffer !== null) entry.indexBuffer.destroy();
-    this.meshGpuHandles.delete(key);
-    this.meshResidencyEpoch += 1;
+    if (entry !== void 0) this.retireMeshEntry(key, entry);
   }
   ensureResident(handle, pod, worldId = 0, lodMeshes = []) {
     const id = handleSlot(handle);
@@ -13460,12 +13521,6 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
 }
 function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPass, frameHooks, readbackFaces, onSubmitted, timingCapture) {
   const graph = frameState.compiledFrameGraph;
-  const invalidatePostProcessModule = (id) => {
-    const entry = internals.lookupPostProcess?.(id);
-    if (entry !== void 0) {
-      internals.invalidateShaderModule?.(postProcessShaderModuleLabel(id, entry.source));
-    }
-  };
   const rejectTemporalFrame = () => {
     if (frameState.temporalFrameInput === void 0) return;
     frameState.temporalFrameTransaction.commit({ accepted: false });
@@ -13753,7 +13808,6 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
           frameState.activeTemporalGpuState = stagedGpuState;
           if (previousGpuState !== void 0 && previousGpuState !== stagedGpuState) {
             internals.clearPostProcessPipelineCache?.("forgeax.taa-resolve");
-            invalidatePostProcessModule("forgeax.taa-resolve");
             retireTemporalGpuStateAfterFence(
               previousGpuState,
               internals.device.queue,
@@ -13783,7 +13837,6 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
       }
       if (stagedTemporalCommit.kind === "off") {
         internals.clearPostProcessPipelineCache?.("forgeax.taa-resolve");
-        invalidatePostProcessModule("forgeax.taa-resolve");
         const activeGpuState = frameState.activeTemporalGpuState;
         if (activeGpuState !== void 0) {
           retireTemporalGpuStateAfterFence(
@@ -14678,7 +14731,7 @@ function updateVolumetricFogInspection(frameState, fog, lights, prepared, submit
     memoryBytes: 0
   });
 }
-function recordFrame(internals, world, cameras, lights, renderables, transparentDispatch, frameState, dispatchCounts, bindGroupCounts, skylight, skylightCount, skybox, skyboxCount, postProcessParams, worlds = [world], profilePhase, gpuDriven, renderReadLeases, featureGraphCandidate, pointsLinesOwner, cubeCapture, environmentSignature = "", fogSignature = "", environmentReady = true, transmissionDemand, volumetricFog, timingCapture) {
+function recordFrame(internals, world, cameras, lights, renderables, transparentDispatch, frameState, dispatchCounts, bindGroupCounts, skylight, skylightCount, skybox, skyboxCount, postProcessParams, worlds = [world], profilePhase, gpuDriven, renderReadLeases, featureGraphCandidate, pointsLinesOwner, cubeCapture, environmentSignature = "", fogSignature = "", environmentReady = true, transmissionDemand, volumetricFog, timingCapture, onRenderableDraw) {
   frameState.reflectionFallbackObservationSource = void 0;
   frameState.reflectionFallbackCompletion = void 0;
   let activeCameras = cameras;
@@ -15223,6 +15276,7 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
       ...cubeCapture?.reflectionProbes === void 0 ? {} : { reflectionProbes: cubeCapture.reflectionProbes },
       pointsLines: pointsLinesOwner,
       materialBgAssemblyCache: frameState.materialBgAssemblyCache,
+      ...onRenderableDraw === void 0 ? {} : { onRenderableDraw },
       directionalShadowCacheReuse: directionalShadowCache.reuse,
       ...profilePhase !== void 0 ? { profilePhase } : {}
     };
@@ -21967,6 +22021,7 @@ function createRenderSystem(internals) {
   );
   let releaseProfilerCatalog = phaseCatalogRegistration?.ok === true ? phaseCatalogRegistration.value : void 0;
   let preparedWorlds = [];
+  let lastSubmittedDynamicGeometryBindings = /* @__PURE__ */ new WeakMap();
   let latestCamera;
   const pointsLinesOwner = new StandardPointsLinesOwner(internals);
   const instanceCollections = new InstanceProjectionStore();
@@ -22952,6 +23007,14 @@ function createRenderSystem(internals) {
       releaseProfilerCatalog?.();
       releaseProfilerCatalog = void 0;
     },
+    invalidateGeometryHistory() {
+      frameState.temporalFrameTransaction.reset("signature-change");
+      frameState.temporalFrame = void 0;
+      frameState.temporalFrameInput = void 0;
+      frameState.lastSuccessfulTemporalView = void 0;
+      frameState.successfulTemporalFrameIndex = 0;
+      frameState.pendingTemporalCommit = { kind: "none" };
+    },
     get renderScene() {
       return {
         ...persistentRenderScene.inspect(),
@@ -23131,6 +23194,8 @@ function createRenderSystem(internals) {
       const profileSession = internals.profiler?.activeSession();
       let ownsProfileFrame = false;
       let submitted = false;
+      lastSubmittedDynamicGeometryBindings = /* @__PURE__ */ new WeakMap();
+      const frameConsumedDynamicGeometryBindings = /* @__PURE__ */ new WeakMap();
       if (profileSession !== void 0 && opts.profileFrame === void 0) {
         try {
           ownsProfileFrame = profileSession.beginFrame(++directFrameId).ok;
@@ -23655,9 +23720,23 @@ function createRenderSystem(internals) {
             environmentReady && environment !== void 0,
             persistentRenderScene.transmissionTopologyDemand(),
             volumetricFog,
-            timingCapture
+            timingCapture,
+            (entry) => {
+              const renderable = entry.source;
+              const world = compositionWorlds[renderable.worldId];
+              if (world === void 0) return;
+              let bindings = frameConsumedDynamicGeometryBindings.get(world);
+              if (bindings === void 0) {
+                bindings = /* @__PURE__ */ new Map();
+                frameConsumedDynamicGeometryBindings.set(world, bindings);
+              }
+              bindings.set(renderable.entityKey, renderable.assetHandle);
+            }
           )
         );
+        if (submitted) {
+          lastSubmittedDynamicGeometryBindings = frameConsumedDynamicGeometryBindings;
+        }
         if (submitted) {
           try {
             internals.recoveryColdWorkGuard?.finish();
@@ -23750,16 +23829,16 @@ function createRenderSystem(internals) {
             if (!retired.ok) internals.errorRegistry.fire(retired.error);
           }
         }
-      } catch (err41) {
+      } catch (err42) {
         if (!submitted) {
           internals.getPipelineState()?.perPassResources.discardBloomResources?.();
         }
-        const innerError = err41 instanceof PipelineSpecError ? {
-          name: err41.name,
-          code: err41.code,
-          message: err41.message,
-          detail: err41.detail
-        } : err41 instanceof RhiError ? err41 : { code: "unknown", message: String(err41), name: err41?.name };
+        const innerError = err42 instanceof PipelineSpecError ? {
+          name: err42.name,
+          code: err42.code,
+          message: err42.message,
+          detail: err42.detail
+        } : err42 instanceof RhiError ? err42 : { code: "unknown", message: String(err42), name: err42?.name };
         internals.errorRegistry.fire(
           new RhiError({
             code: "webgpu-runtime-error",
@@ -23778,6 +23857,10 @@ function createRenderSystem(internals) {
       }
       return submitted;
     },
+    isDynamicGeometryConsumed(world, entity, meshHandle) {
+      if (!Number.isInteger(entity) || meshHandle === void 0) return false;
+      return lastSubmittedDynamicGeometryBindings.get(world)?.get(entity) === meshHandle;
+    },
     pipelineDispatchCounts: dispatchCounts,
     observeCurrentFrame(options) {
       const currentFrameId = frameState.frameNumber - 1;
@@ -25085,6 +25168,641 @@ function deviceOptionsForAdapter(adapter, options) {
   const admission = deriveDeviceFeatureAdmission(adapter, options);
   return admission.requiredFeatures.length === 0 && admission.requiredLimits === void 0 ? void 0 : admission;
 }
+function fixedStepOf(world) {
+  try {
+    return world.getResource(FixedTime).tick;
+  } catch {
+    return void 0;
+  }
+}
+function hasRenderableBinding(world, entity) {
+  if (entity === void 0 || !Number.isInteger(entity)) return false;
+  const transform = world.get(entity, Transform);
+  const mesh = world.get(entity, MeshFilter);
+  const material = world.get(entity, MeshRenderer);
+  if (!transform.ok || !mesh.ok || !material.ok) return false;
+  return true;
+}
+function meshHandleOf(world, entity) {
+  if (entity === void 0 || !Number.isInteger(entity)) return void 0;
+  const mesh = world.get(entity, MeshFilter);
+  if (!mesh.ok) return void 0;
+  return mesh.value.assetHandle;
+}
+function hasMaterialIdentity(world, entity, mesh, identity) {
+  if (identity === void 0) return true;
+  const normalized = identity.trim();
+  if (normalized.length === 0 || entity === void 0) return false;
+  const material = world.get(entity, MeshRenderer);
+  if (!material.ok) return false;
+  const values = material.value.materials ?? [];
+  if (mesh.materialSlots.some((slot) => slot.sourceKey === normalized || slot.slotName === normalized))
+    return true;
+  if (mesh.materialSlots.some(
+    (slot) => slot.defaultMaterial !== void 0 && AssetGuid.format(slot.defaultMaterial).toLowerCase() === normalized.toLowerCase()
+  ))
+    return true;
+  return values.some((value) => {
+    if (String(value) === normalized) return true;
+    try {
+      const resolved2 = world.sharedRefs.resolve(value);
+      if (!resolved2.ok || typeof resolved2.value !== "object" || resolved2.value === null)
+        return false;
+      const payload = resolved2.value;
+      return payload.sourceKey === normalized || payload.guid === normalized;
+    } catch {
+      return false;
+    }
+  });
+}
+function hasMeshBinding(world, handle) {
+  try {
+    const query = world.query({ read: [MeshFilter] }).unwrap();
+    for (const row of query) {
+      if (Number(row.get(MeshFilter).assetHandle) === handle) return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function ownsMeshPayload(world, meshHandle, mesh) {
+  if (meshHandle === void 0) return false;
+  try {
+    const resolved2 = world.sharedRefs.resolve(meshHandle);
+    return resolved2.ok && resolved2.value === mesh;
+  } catch {
+    return false;
+  }
+}
+function physicsPublicationOf(world, entity, admitting = false) {
+  try {
+    const physics = world.getResource("PhysicsWorld");
+    return admitting ? physics.getDerivedAdmission?.(entity) : physics.getDerivedPublication?.(entity);
+  } catch {
+    return void 0;
+  }
+}
+function createDynamicGeometryHost(options) {
+  const { lifecycle, attachedWorlds, getGpuStore, currentGeneration, isConsumedByRenderFrame } = options;
+  const hostCandidates = /* @__PURE__ */ new Map();
+  let observedGeneration = -1;
+  const releaseMeshLease = (record) => {
+    if (!record.meshLeaseHeld) return void 0;
+    const released = record.world.sharedRefs.release(record.meshHandle);
+    if (!released.ok) {
+      return new DynamicGeometryError(
+        "dynamic-geometry-invalid",
+        "the Renderer candidate lease remains a live World shared reference",
+        "retain the MeshAsset handle until candidate cancellation or ECS acceptance completes",
+        { candidateId: record.candidate.candidateId, actual: released.error }
+      );
+    }
+    record.meshLeaseHeld = false;
+    return void 0;
+  };
+  const releasePreviousMeshLease = (record) => {
+    if (!record.previousMeshLeaseHeld) return void 0;
+    const released = record.world.sharedRefs.release(record.previousMeshHandle);
+    if (!released.ok) {
+      return new DynamicGeometryError(
+        "dynamic-geometry-invalid",
+        "the previous ECS MeshFilter binding remains a live World shared reference",
+        "retain the previous MeshAsset until candidate cancellation, retirement, or invalidation completes",
+        { candidateId: record.candidate.candidateId, actual: released.error }
+      );
+    }
+    record.previousMeshLeaseHeld = false;
+    return void 0;
+  };
+  const releaseMeshLeases = (record) => {
+    const candidateError = releaseMeshLease(record);
+    const previousError = releasePreviousMeshLease(record);
+    return candidateError ?? previousError;
+  };
+  const synchronizeGeneration = () => {
+    const generation = currentGeneration();
+    lifecycle.invalidateGeneration(generation);
+    if (observedGeneration !== generation) {
+      for (const [candidateId, record] of hostCandidates) {
+        if (record.generation !== generation) {
+          hostCandidates.delete(candidateId);
+          scheduleCandidateCleanup(record, true);
+        }
+      }
+      observedGeneration = generation;
+    }
+    return generation;
+  };
+  const candidateRecord2 = (candidate) => {
+    const record = hostCandidates.get(candidate.candidateId);
+    if (record === void 0 || !sameCandidateCredential(candidate, record.candidate))
+      return void 0;
+    return record;
+  };
+  const cleanupCandidateResidency = (record, force = false) => record.residency?.release(force || !hasMeshBinding(record.world, record.meshHandle));
+  const scheduleCandidateCleanup = (record, force = false) => {
+    hostCandidates.delete(record.candidate.candidateId);
+    const completion = cleanupCandidateResidency(record, force);
+    const finish = () => {
+      releaseMeshLeases(record);
+      lifecycle.finalizeRetirement(record.candidate);
+      if (hostCandidates.get(record.candidate.candidateId) === record)
+        hostCandidates.delete(record.candidate.candidateId);
+    };
+    if (completion === void 0) finish();
+    else void completion.then(finish, finish);
+    return completion;
+  };
+  return {
+    prepareDynamicGeometry(input) {
+      const generation = synchronizeGeneration();
+      const world = input.world;
+      if (!attachedWorlds.has(world))
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-world-not-attached",
+            "the candidate World is attached to this Renderer",
+            "call renderer.attach(world) before preparing dynamic geometry"
+          )
+        );
+      if (input.entity === void 0 || !hasRenderableBinding(world, input.entity)) {
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-invalid",
+            "the candidate entity and MeshAsset payload belong to the attached World",
+            "attach MeshFilter/MeshRenderer and pass the payload resolved by its World shared handle",
+            { actual: { entity: input.entity, meshHandle: input.meshHandle } }
+          )
+        );
+      }
+      if (input.meshHandle === void 0)
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-gpu-not-ready",
+            "the standard MeshAsset shared handle is present before Renderer admission",
+            "allocate the MeshAsset through world.allocSharedRef and retry after asset projection",
+            { actual: { entity: input.entity, meshHandle: input.meshHandle } }
+          )
+        );
+      const meshHandle = input.meshHandle;
+      if (!ownsMeshPayload(world, meshHandle, input.mesh) || !hasMaterialIdentity(world, input.entity, input.mesh, input.materialIdentity)) {
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-invalid",
+            "the candidate MeshAsset and material identity belong to the attached World",
+            "pass the payload resolved by its World shared handle and its live material slot identity",
+            { actual: { entity: input.entity, meshHandle } }
+          )
+        );
+      }
+      const fixedStep = fixedStepOf(world);
+      if (fixedStep === void 0) {
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-ordering-required",
+            "the attached World exposes its ECS FixedTime resource",
+            "prepare geometry from an initialized World fixed-step schedule"
+          )
+        );
+      }
+      const previousMeshHandle = meshHandleOf(world, input.entity);
+      if (previousMeshHandle === void 0) {
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-invalid",
+            "the prepared entity retains a live MeshFilter binding",
+            "keep the ECS render entity alive while staging geometry",
+            { actual: { entity: input.entity } }
+          )
+        );
+      }
+      const previousRetained = world.sharedRefs.retain(previousMeshHandle);
+      if (!previousRetained.ok)
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-invalid",
+            "the previous ECS MeshFilter binding remains live for Renderer preparation",
+            "retain the current MeshAsset handle before staging replacement geometry",
+            { actual: previousRetained.error }
+          )
+        );
+      const retained = world.sharedRefs.retain(meshHandle);
+      if (!retained.ok) {
+        const releasedPrevious = world.sharedRefs.release(previousMeshHandle);
+        return releasedPrevious.ok ? err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-invalid",
+            "the candidate MeshAsset shared reference remains live for Renderer preparation",
+            "retain the World-owned MeshAsset handle before staging a candidate",
+            { actual: retained.error }
+          )
+        ) : err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-invalid",
+            "candidate preparation leaves both MeshAsset leases recoverable",
+            "repair the World shared references before retrying geometry preparation",
+            { actual: { candidate: retained.error, previous: releasedPrevious.error } }
+          )
+        );
+      }
+      const releaseRetained = () => {
+        const releasedCandidate = world.sharedRefs.release(meshHandle);
+        const releasedPrevious = world.sharedRefs.release(previousMeshHandle);
+        if (!releasedCandidate.ok || !releasedPrevious.ok)
+          return new DynamicGeometryError(
+            "dynamic-geometry-invalid",
+            "failed candidate preparation releases both World shared-reference leases",
+            "repair the World shared references before retrying geometry preparation",
+            {
+              actual: {
+                candidate: releasedCandidate.ok ? void 0 : releasedCandidate.error,
+                previous: releasedPrevious.ok ? void 0 : releasedPrevious.error
+              }
+            }
+          );
+        return void 0;
+      };
+      const prepared = lifecycle.prepare({ ...input, fixedStep }, generation);
+      if (!prepared.ok) {
+        const released = releaseRetained();
+        return released === void 0 ? prepared : err$1(released);
+      }
+      const residencyStore = getGpuStore();
+      const resident = residencyStore.ensureResident(
+        meshHandle,
+        prepared.value.mesh,
+        input.world
+      );
+      if (!resident.ok) {
+        lifecycle.cancel(prepared.value);
+        cleanupCandidateResidency({
+          candidate: prepared.value,
+          world,
+          entity: input.entity,
+          meshHandle,
+          residency: void 0});
+        const released = releaseMeshLeases({
+          candidate: prepared.value,
+          world,
+          entity: input.entity,
+          previousMeshHandle,
+          meshHandle,
+          meshLeaseHeld: true,
+          previousMeshLeaseHeld: true
+        });
+        if (released !== void 0) return err$1(released);
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-gpu-failed",
+            "the standard MeshAsset has GPU residency for the active device generation",
+            "wait for Renderer.initialization or repair the RHI resource failure before retrying",
+            { candidateId: prepared.value.candidateId, actual: resident.error }
+          )
+        );
+      }
+      const residency = residencyStore.retainMeshResidency(meshHandle, world);
+      if (residency === void 0) {
+        lifecycle.cancel(prepared.value);
+        residencyStore.invalidateMesh(meshHandle, world);
+        const released = releaseRetained();
+        return released === void 0 ? err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-gpu-failed",
+            "the standard MeshAsset retains a shared GPU residency owner",
+            "repair the active GPU residency before retrying geometry preparation",
+            { candidateId: prepared.value.candidateId }
+          )
+        ) : err$1(released);
+      }
+      hostCandidates.set(prepared.value.candidateId, {
+        candidate: prepared.value,
+        world,
+        entity: input.entity,
+        previousMeshHandle,
+        meshHandle,
+        residency,
+        generation,
+        meshLeaseHeld: true,
+        previousMeshLeaseHeld: true,
+        accepted: false,
+        published: false
+      });
+      return prepared;
+    },
+    acceptDynamicGeometry(candidate, ordering) {
+      synchronizeGeneration();
+      const world = candidate.world;
+      const hostRecordById = hostCandidates.get(candidate.candidateId);
+      const hostRecord = candidateRecord2(candidate);
+      if (hostRecord === void 0 && hostRecordById !== void 0)
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-receipt-mismatch",
+            "admission uses the exact host candidate owner and lifecycle credential",
+            "discard the altered credential and use the value returned by preparation",
+            { candidateId: candidate.candidateId }
+          )
+        );
+      if (hostRecord !== void 0 && candidate.state !== "prepared")
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-candidate-state",
+            "admission consumes a prepared candidate exactly once",
+            "retain the accepted or published candidate receipt instead of admitting it again",
+            { candidateId: candidate.candidateId }
+          )
+        );
+      if (ordering === void 0 || !attachedWorlds.has(world) || ordering.world !== candidate.world)
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-world-not-attached",
+            "candidate and fixed-step ordering belong to the same attached World",
+            "attach the World and submit its PhysicsWorld ordering before accepting geometry",
+            { candidateId: candidate.candidateId }
+          )
+        );
+      if (!candidate.gpuReady)
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-gpu-not-ready",
+            "candidate has standard GPU residency before acceptance",
+            "prepare with an existing MeshAsset shared handle and repair residency failures",
+            { candidateId: candidate.candidateId }
+          )
+        );
+      if (hostRecord === void 0 || !hasRenderableBinding(world, candidate.entity) || !hasMaterialIdentity(world, candidate.entity, candidate.mesh, candidate.materialIdentity))
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-invalid",
+            "the candidate is bound to a live ECS MeshFilter and MeshRenderer",
+            "keep the candidate MeshFilter binding intact until the consuming draw",
+            { candidateId: candidate.candidateId }
+          )
+        );
+      if (meshHandleOf(world, candidate.entity) !== hostRecord.previousMeshHandle)
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-invalid",
+            "the old MeshFilter binding remains visible until candidate acceptance",
+            "do not replace the live ECS binding while geometry is prepared",
+            { candidateId: candidate.candidateId }
+          )
+        );
+      const currentFixedStep = fixedStepOf(world);
+      if (currentFixedStep === void 0 || candidate.fixedStep === void 0 || candidate.fixedStep > currentFixedStep || ordering.fixedStep !== currentFixedStep)
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-ordering-required",
+            "ordering matches the current World tick, no earlier than preparation",
+            "accept a prepared candidate during the current fixed-step admission",
+            {
+              candidateId: candidate.candidateId,
+              actual: {
+                candidate: candidate.fixedStep,
+                currentFixedStep,
+                ordering: ordering.fixedStep
+              }
+            }
+          )
+        );
+      if (candidate.physicsEntity !== void 0) {
+        const publication = physicsPublicationOf(world, candidate.physicsEntity, true);
+        if (publication === void 0 || publication.fixedStep !== currentFixedStep || publication.revision !== candidate.revision)
+          return err$1(
+            new DynamicGeometryError(
+              "dynamic-geometry-ordering-required",
+              "candidate physicsEntity has the active paired PhysicsWorld admission",
+              "accept geometry inside admitDerivedShapeCandidate commitGeometry, before physics step",
+              { candidateId: candidate.candidateId, actual: publication }
+            )
+          );
+      }
+      const superseded = [...hostCandidates.values()].filter(
+        (record) => record.candidate.candidateId !== candidate.candidateId && record.world === world && record.entity === candidate.entity && !record.published
+      );
+      const accepted = lifecycle.accept(candidate, ordering);
+      if (!accepted.ok) return accepted;
+      const swapped = world.set(candidate.entity, MeshFilter, {
+        assetHandle: hostRecord.meshHandle
+      });
+      if (!swapped.ok) {
+        lifecycle.cancel(accepted.value);
+        hostCandidates.delete(candidate.candidateId);
+        cleanupCandidateResidency(hostRecord);
+        const released = releaseMeshLeases(hostRecord);
+        if (released !== void 0) return err$1(released);
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-invalid",
+            "the candidate MeshFilter swap commits through the ECS write barrier",
+            "restore the live entity and retry from a fresh candidate",
+            { candidateId: candidate.candidateId, actual: swapped.error }
+          )
+        );
+      }
+      hostRecord.candidate = accepted.value;
+      hostRecord.accepted = true;
+      options.onTopologyChanged?.();
+      for (const record of superseded) {
+        const completion = cleanupCandidateResidency(record);
+        const cancelled = lifecycle.cancel(record.candidate, completion);
+        if (!cancelled.ok && cancelled.error.code !== "dynamic-geometry-candidate-not-found") {
+          const restored = world.set(candidate.entity, MeshFilter, {
+            assetHandle: hostRecord.previousMeshHandle
+          });
+          lifecycle.cancel(accepted.value);
+          hostCandidates.delete(candidate.candidateId);
+          cleanupCandidateResidency(hostRecord);
+          releasePreviousMeshLease(hostRecord);
+          return err$1(
+            new DynamicGeometryError(
+              "dynamic-geometry-invalid",
+              "candidate supersession cancels the prior credential atomically",
+              "keep the prior ECS binding and candidate lifecycle intact when supersession fails",
+              {
+                candidateId: candidate.candidateId,
+                actual: {
+                  cancelled: cancelled.error,
+                  restored: restored.ok ? void 0 : restored.error
+                }
+              }
+            )
+          );
+        }
+        hostCandidates.delete(record.candidate.candidateId);
+        scheduleCandidateCleanup(record);
+      }
+      return accepted;
+    },
+    dynamicGeometryReceipt(candidate) {
+      synchronizeGeneration();
+      return lifecycle.receipt(candidate);
+    },
+    cancelDynamicGeometry(candidate) {
+      synchronizeGeneration();
+      const record = candidateRecord2(candidate);
+      if (record === void 0) {
+        if (hostCandidates.has(candidate.candidateId))
+          return err$1(
+            new DynamicGeometryError(
+              "dynamic-geometry-receipt-mismatch",
+              "cancellation uses the exact host candidate owner and lifecycle credential",
+              "discard the altered credential and use the value returned by preparation",
+              { candidateId: candidate.candidateId }
+            )
+          );
+        return lifecycle.cancel(candidate);
+      }
+      if (!record.accepted && candidate.state !== "prepared" || record.accepted && !record.published && candidate.state !== "accepted" || record.published && candidate.state !== "accepted" && candidate.state !== "published")
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-receipt-mismatch",
+            "cancellation uses the candidate state issued by the host lifecycle",
+            "discard the altered credential and use the value returned by preparation or acceptance",
+            { candidateId: candidate.candidateId }
+          )
+        );
+      if (record.published)
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-candidate-state",
+            "published geometry remains until its receipt retires",
+            "retire the receipt-bound candidate instead of cancelling it",
+            { candidateId: candidate.candidateId }
+          )
+        );
+      if (record.accepted) {
+        const currentHandle = meshHandleOf(record.world, record.entity);
+        if (currentHandle !== record.meshHandle && currentHandle !== record.previousMeshHandle)
+          return err$1(
+            new DynamicGeometryError(
+              "dynamic-geometry-invalid",
+              "cancel does not overwrite a newer ECS MeshFilter binding",
+              "reconcile the live entity before cancelling this candidate",
+              { candidateId: candidate.candidateId }
+            )
+          );
+        if (currentHandle === record.meshHandle) {
+          const restored = record.world.set(record.entity, MeshFilter, {
+            assetHandle: record.previousMeshHandle
+          });
+          if (!restored.ok)
+            return err$1(
+              new DynamicGeometryError(
+                "dynamic-geometry-invalid",
+                "cancel restores the previous MeshFilter through the ECS write barrier",
+                "restore the entity before retrying cancellation",
+                { candidateId: candidate.candidateId, actual: restored.error }
+              )
+            );
+        }
+      }
+      const completion = cleanupCandidateResidency(record);
+      const cancelled = lifecycle.cancel(candidate, completion);
+      if (!cancelled.ok) return cancelled;
+      hostCandidates.delete(candidate.candidateId);
+      scheduleCandidateCleanup(record);
+      return cancelled;
+    },
+    invalidateDynamicGeometryWorld(world) {
+      const doomed = [...hostCandidates.values()].filter((record) => record.world === world);
+      const completions = doomed.map((record) => scheduleCandidateCleanup(record, true)).filter((completion) => completion !== void 0);
+      lifecycle.invalidateWorld(
+        world,
+        completions.length === 0 ? void 0 : Promise.allSettled(completions)
+      );
+    },
+    retireDynamicGeometry(candidate) {
+      synchronizeGeneration();
+      const record = candidateRecord2(candidate);
+      if (record === void 0) {
+        if (hostCandidates.has(candidate.candidateId))
+          return err$1(
+            new DynamicGeometryError(
+              "dynamic-geometry-receipt-mismatch",
+              "retirement uses the exact host candidate owner and lifecycle credential",
+              "discard the altered credential and use the value returned by acceptance",
+              { candidateId: candidate.candidateId }
+            )
+          );
+        return lifecycle.retire(candidate);
+      }
+      if (candidate.state !== "accepted" && candidate.state !== "published")
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-receipt-mismatch",
+            "retirement uses a candidate state issued by the host lifecycle",
+            "discard the altered credential and use the value returned by acceptance",
+            { candidateId: candidate.candidateId }
+          )
+        );
+      if (meshHandleOf(record.world, record.entity) === record.meshHandle)
+        return err$1(
+          new DynamicGeometryError(
+            "dynamic-geometry-invalid",
+            "retirement does not evict the MeshFilter that still consumes the candidate",
+            "swap the ECS MeshFilter through its write barrier before retiring this geometry",
+            { candidateId: candidate.candidateId }
+          )
+        );
+      const retired = lifecycle.retire(candidate);
+      if (!retired.ok) return retired;
+      record.candidate = Object.freeze({ ...record.candidate, state: "retired" });
+      const previousReleased = releasePreviousMeshLease(record);
+      if (previousReleased !== void 0) return err$1(previousReleased);
+      scheduleCandidateCleanup(record);
+      return retired;
+    },
+    publishDynamicGeometry(frame, worlds, fixedStep) {
+      synchronizeGeneration();
+      const targetWorlds = /* @__PURE__ */ new Set();
+      for (const candidateWorld of worlds ?? attachedWorlds) {
+        const world = candidateWorld;
+        if (attachedWorlds.has(world)) targetWorlds.add(world);
+      }
+      const receipts = [];
+      for (const world of targetWorlds) {
+        const worldFixedStep = fixedStepOf(world);
+        if (worldFixedStep === void 0) continue;
+        const publicationFixedStep = fixedStep ?? worldFixedStep;
+        receipts.push(
+          ...lifecycle.publishFrame(frame, [world], publicationFixedStep, (candidate) => {
+            const candidateWorld = candidate.world;
+            if (candidateWorld !== world || !attachedWorlds.has(candidateWorld)) return false;
+            const hostRecord = candidateRecord2(candidate);
+            if (hostRecord === void 0 || !hostRecord.accepted || !hasRenderableBinding(candidateWorld, candidate.entity) || meshHandleOf(candidateWorld, candidate.entity) !== candidate.meshHandle || !hasMaterialIdentity(
+              candidateWorld,
+              candidate.entity,
+              candidate.mesh,
+              candidate.materialIdentity
+            ))
+              return false;
+            if (!isConsumedByRenderFrame(candidate)) return false;
+            const actualFixedStep = fixedStep ?? worldFixedStep;
+            if (candidate.fixedStep === void 0 || actualFixedStep === void 0) return false;
+            if (worldFixedStep !== actualFixedStep || actualFixedStep < candidate.fixedStep)
+              return false;
+            if (candidate.physicsEntity !== void 0) {
+              const publication = physicsPublicationOf(candidateWorld, candidate.physicsEntity);
+              if (publication === void 0 || publication.fixedStep < candidate.fixedStep || publication.revision !== candidate.revision)
+                return false;
+            }
+            return true;
+          })
+        );
+      }
+      for (const receipt of receipts) {
+        const record = hostCandidates.get(receipt.candidateId);
+        if (record !== void 0) {
+          record.published = true;
+          if (receipt.frame.completed !== void 0)
+            record.residency?.track(receipt.frame.completed);
+        }
+      }
+      return receipts;
+    }
+  };
+}
 var STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES2 = 17;
 function selectHdrpPbrPrewarmVariants(manifestEntry, storageBufferCapable, extendedLightingShaderAvailableOrTransmissionCapable = true, transmissionCapable = true, directionalPcssAvailable = true, projectorAvailable = true) {
   const variants = manifestEntry?.variants ?? [];
@@ -29950,11 +30668,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
       }
       try {
         getOrBuildPipeline(spec, pipelineDeviceProvider, pipelineCache, modules);
-      } catch (err41) {
-        if (err41 instanceof PipelineSpecError) throw err41;
+      } catch (err42) {
+        if (err42 instanceof PipelineSpecError) throw err42;
         throw new PipelineSpecError({
           code: "pipeline-build-failed",
-          detail: { cause: err41 },
+          detail: { cause: err42 },
           hint: `Boot-time SPEC_CONST pre-warm failed for shader '${spec.shader.id}'; inspect gpuMessage on the cause`
         });
       }
@@ -30123,11 +30841,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
             pipelineCache,
             modules
           );
-        } catch (err41) {
-          if (err41 instanceof PipelineSpecError) throw err41;
+        } catch (err42) {
+          if (err42 instanceof PipelineSpecError) throw err42;
           throw new PipelineSpecError({
             code: "pipeline-build-failed",
-            detail: { cause: err41 },
+            detail: { cause: err42 },
             hint: "createRenderPipeline (fxaa fullscreen) failed; inspect gpuMessage"
           });
         }
@@ -30381,11 +31099,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 bloomBrightPipelineHandle,
                 () => void 0
               );
-            } catch (err41) {
-              if (err41 instanceof PipelineSpecError) throw err41;
+            } catch (err42) {
+              if (err42 instanceof PipelineSpecError) throw err42;
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
-                detail: { cause: err41 },
+                detail: { cause: err42 },
                 hint: "createRenderPipeline (bloom-bright fullscreen) failed; inspect gpuMessage"
               });
             }
@@ -30482,11 +31200,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 bloomBlurHPipelineHandle,
                 () => void 0
               );
-            } catch (err41) {
-              if (err41 instanceof PipelineSpecError) throw err41;
+            } catch (err42) {
+              if (err42 instanceof PipelineSpecError) throw err42;
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
-                detail: { cause: err41 },
+                detail: { cause: err42 },
                 hint: "createRenderPipeline (bloom-blur-h fullscreen) failed; inspect gpuMessage"
               });
             }
@@ -30603,11 +31321,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 bloomCompositePipelineHandle,
                 () => void 0
               );
-            } catch (err41) {
-              if (err41 instanceof PipelineSpecError) throw err41;
+            } catch (err42) {
+              if (err42 instanceof PipelineSpecError) throw err42;
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
-                detail: { cause: err41 },
+                detail: { cause: err42 },
                 hint: "createRenderPipeline (bloom-composite fullscreen) failed; inspect gpuMessage"
               });
             }
@@ -30897,11 +31615,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               pipelineCache,
               { ...baseModules, fragmentEntryPoint: "fs_ssao_calc" }
             );
-          } catch (err41) {
-            if (err41 instanceof PipelineSpecError) throw err41;
+          } catch (err42) {
+            if (err42 instanceof PipelineSpecError) throw err42;
             throw new PipelineSpecError({
               code: "pipeline-build-failed",
-              detail: { cause: err41 },
+              detail: { cause: err42 },
               hint: "createRenderPipeline (ssao-calc fullscreen) failed; inspect gpuMessage"
             });
           }
@@ -30932,11 +31650,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               pipelineCache,
               { ...baseModules, fragmentEntryPoint: "fs_ssao_blur" }
             );
-          } catch (err41) {
-            if (err41 instanceof PipelineSpecError) throw err41;
+          } catch (err42) {
+            if (err42 instanceof PipelineSpecError) throw err42;
             throw new PipelineSpecError({
               code: "pipeline-build-failed",
-              detail: { cause: err41 },
+              detail: { cause: err42 },
               hint: "createRenderPipeline (ssao-blur fullscreen) failed; inspect gpuMessage"
             });
           }
@@ -31683,6 +32401,7 @@ async function makeWebGPURenderer(internals) {
   const publishRendererGeneration = (candidate) => {
     publishGeneration(generationPublication, candidate, (value) => value.scope.isAlive());
     activeDeviceScope = candidate.scope;
+    dynamicGeometry.invalidateGeneration(activeDeviceScope.generation);
     internals.generationState.current = activeDeviceScope.generation;
     pipelineState = candidate.pipeline;
     const bindings = candidate.producerBindings;
@@ -32222,7 +32941,7 @@ async function makeWebGPURenderer(internals) {
     const currentState = currentPipelineState();
     if (currentState === null) return null;
     const ldrColorFormat = colorFormatOverride ?? currentState.colorAttachmentFormat;
-    const fragmentEntry = authoredFragmentEntry ?? (isHdr && (materialShaderId === "forgeax::sprite" || materialShaderId === "forgeax::sprite-lit") ? "fs_main_hdr" : void 0);
+    const fragmentEntry = authoredFragmentEntry ?? (isHdr && passKind === "forward" && (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.
@@ -32729,6 +33448,19 @@ async function makeWebGPURenderer(internals) {
   const attachedWorlds = /* @__PURE__ */ new Set();
   const attachedLeases = /* @__PURE__ */ new Map();
   const leasesByWorld = /* @__PURE__ */ new Map();
+  const dynamicGeometry = createDynamicGeometryLifecycle();
+  const dynamicGeometryHost = createDynamicGeometryHost({
+    lifecycle: dynamicGeometry,
+    attachedWorlds,
+    getGpuStore: () => gpuStore,
+    currentGeneration: () => activeDeviceScope.generation,
+    onTopologyChanged: () => renderSystem.invalidateGeometryHistory(),
+    isConsumedByRenderFrame: (candidate) => renderSystem.isDynamicGeometryConsumed(
+      candidate.world,
+      candidate.entity ?? -1,
+      candidate.meshHandle
+    )
+  });
   const derivedSystemNames = /* @__PURE__ */ new Map();
   const transformReleases = /* @__PURE__ */ new Map();
   const attachmentOwner = {};
@@ -32749,6 +33481,7 @@ async function makeWebGPURenderer(internals) {
       leasesByWorld.set(world, lease);
       return ok(lease);
     },
+    ...dynamicGeometryHost,
     createRenderTarget: (descriptor) => renderTargetHost.createRenderTarget(descriptor),
     resizeRenderTarget: (target4, descriptor) => renderTargetHost.resizeRenderTarget(target4, descriptor),
     createRenderTargetTextureSource: (target4, options) => renderTargetHost.createRenderTargetTextureSource(target4, options),
@@ -32852,6 +33585,7 @@ async function makeWebGPURenderer(internals) {
             })
           )
         ),
+        dynamicGeometry: dynamicGeometry.inspect(),
         renderScene: renderSystem.renderScene,
         reflectionProbes: renderSystem.reflectionProbes,
         ssrDependencies: renderSystem.ssrDependencies,
@@ -32973,6 +33707,7 @@ async function makeWebGPURenderer(internals) {
     },
     detachScene(world) {
       if (!attachedWorlds.delete(world)) return;
+      dynamicGeometryHost.invalidateDynamicGeometryWorld(world);
       for (const [lease, leaseWorld] of attachedLeases) {
         if (leaseWorld === world) {
           lease.dispose();
@@ -33147,6 +33882,21 @@ async function makeWebGPURenderer(internals) {
       const frameRequest = isFrameRequest ? worldsOrRequest : void 0;
       const worlds = frameRequest !== void 0 ? frameRequest.leases.map((lease) => attachedLeases.get(lease)).filter((world) => world !== void 0) : worldsOrRequest;
       const readLeases = frameRequest !== void 0 ? frameRequest.leases : worlds.map((world) => leasesByWorld.get(world)).every((lease) => lease !== void 0) ? worlds.map((world) => leasesByWorld.get(world)) : void 0;
+      for (const world of worlds) {
+        if (!world.hasResource("PhysicsWorld")) continue;
+        const physics = world.getResource("PhysicsWorld");
+        if (physics?.getDerivedAdmission?.() !== void 0 || physics?.getDerivedRecoveryState?.() === "rebuild-required") {
+          return err(
+            new RendererOperationError("frame-input-invalid", {
+              operation: "draw",
+              cause: new RendererContractFailureError(
+                "draw",
+                "paired geometry admission must finish physics step and writeback in a healthy World before draw"
+              )
+            })
+          );
+        }
+      }
       if (frameRequest !== void 0 && worlds.length !== frameRequest.leases.length) {
         return err(
           new RendererOperationError("world-lease-invalid", {
@@ -33268,6 +34018,8 @@ async function makeWebGPURenderer(internals) {
         const timingCompletion = timingHost.gpuPassTimingSubmittedWork;
         timingHost.gpuPassTimingSubmittedWork = void 0;
         const reflectionFallbackCompletion = renderSystem.reflectionFallbackCompletion;
+        const queueCompletion = timingCompletion ?? internals.device.queue.onSubmittedWorkDone();
+        gpuStore.trackMeshSubmission(queueCompletion);
         internals.pack.instrumentation?.onFrameBoundary?.();
         if (!isFrameRequest) {
           renderTargetHost.onFrameSubmitted();
@@ -33275,7 +34027,6 @@ async function makeWebGPURenderer(internals) {
         }
         const receiptFrameId = ++frameId;
         const receiptGeneration = activeDeviceScope.generation;
-        const queueCompletion = timingCompletion ?? internals.device.queue.onSubmittedWorkDone();
         const completion = Promise.all([
           queueCompletion,
           reflectionFallbackCompletion ?? Promise.resolve()
@@ -33383,6 +34134,7 @@ async function makeWebGPURenderer(internals) {
           );
         }
         issuedReceipts.add(receipt);
+        dynamicGeometryHost.publishDynamicGeometry(receipt, worlds, frameRequest?.fixedStep);
         return ok(receipt);
       } catch (cause) {
         const error = cause instanceof Error ? { code: "unknown", message: cause.message, name: cause.name } : { code: "unknown", message: String(cause) };
@@ -33510,6 +34262,10 @@ async function makeWebGPURenderer(internals) {
     dispose() {
       if (disposed) return ok(void 0);
       disposed = true;
+      for (const world of attachedWorlds) {
+        dynamicGeometryHost.invalidateDynamicGeometryWorld(world);
+      }
+      dynamicGeometry.dispose();
       for (const continuation of frameContinuations) {
         continuation.terminate({ code: "disposed" });
       }