@forgeax/engine-render 0.1.32 → 0.1.33

package/dist/construct-renderer.mjs

@@ -1,14 +1,14 @@
-import { inspectVolumetricFog, resolveSsrAdmissionGeneration, inspectLodOcclusion, zeroSsrAdmissionWork, projectSsrSpatialInspection, createDynamicGeometryLifecycle, inspectReflectionFallback, admitReflectionProbe, DEFAULT_REFLECTION_PROBE_LIMITS, buildReflectionProbeTable, advanceProbeFilter, commitProbeFilterStep, resolveReflectionFallbackSource, deriveReflectionFallbackProjection, reflectionFallbackCoverage, reflectionFallbackSourceKey, reflectionFallbackProjectionSignature, createProbeFilterState, ReflectionProbeProjection, admitPointsLines, projectSsrDependencies, admitSsrSpatial, inspectPointShadow, DynamicGeometryError, sameCandidateCredential } from './chunk-LULCA3OF.mjs';
-import { createExtendedLightingState, promoteExtendedLightingCandidate, glyphTextLayoutSystem, projectExtendedLightingInspection, OcclusionRenderRuntime, extractFrames, viewKey, primitiveKey, viewKeyId, primitiveKeyId, ProbeBlendSceneProjection, SKYLIGHT_RECOVERY_FALLBACK, InstanceBoundsCache, fingerprintNumericArray, buildShadowFrusta, createSsrHistoryOwner, createSsrSpatialResources, createCookieProjectionMatrixData } from './chunk-4NNZQCL3.mjs';
+import { inspectVolumetricFog, resolveSsrAdmissionGeneration, inspectLodOcclusion, zeroSsrAdmissionWork, projectSsrSpatialInspection, createDynamicGeometryLifecycle, inspectReflectionFallback, admitReflectionProbe, DEFAULT_REFLECTION_PROBE_LIMITS, buildReflectionProbeTable, advanceProbeFilter, commitProbeFilterStep, resolveReflectionFallbackSource, deriveReflectionFallbackProjection, reflectionFallbackCoverage, reflectionFallbackSourceKey, reflectionFallbackProjectionSignature, createProbeFilterState, ReflectionProbeProjection, admitPointsLines, projectSsrDependencies, admitSsrSpatial, inspectPointShadow, DynamicGeometryError, sameCandidateCredential } from './chunk-NNQL7CB3.mjs';
+import { createExtendedLightingState, promoteExtendedLightingCandidate, glyphTextLayoutSystem, emptyBloomInspection, projectExtendedLightingInspection, OcclusionRenderRuntime, extractFrames, viewKey, primitiveKey, viewKeyId, primitiveKeyId, ProbeBlendSceneProjection, InstanceBoundsCache, fingerprintNumericArray, buildShadowFrusta, createSsrHistoryOwner, createSsrSpatialResources, createCookieProjectionMatrixData } from './chunk-OO3DRYK7.mjs';
 import './chunk-ILQ5MEZF.mjs';
-import { DEFAULT_DEPTH_OF_FIELD_PARAMS, MeshFilter, MeshRenderer, Instances, Layer, Visibility, Points, Lines, SortKey, projectMeshMaterialBindingObservation, resolveDepthOfFieldFrameParams, buildCubeCameraFaceViews, hasVolumetricFogCapability, packDepthOfFieldParams, Camera, CAMERA_PROJECTION_ORTHOGRAPHIC, CUBE_CAMERA_FACE_ORDER } from './chunk-GWCEMDVR.mjs';
+import { DEFAULT_DEPTH_OF_FIELD_PARAMS, MeshFilter, MeshRenderer, Instances, Layer, Visibility, Points, Lines, SortKey, projectMeshMaterialBindingObservation, resolveDepthOfFieldFrameParams, buildCubeCameraFaceViews, SKYLIGHT_RECOVERY_FALLBACK, hasVolumetricFogCapability, packDepthOfFieldParams, Camera, CAMERA_PROJECTION_ORTHOGRAPHIC, CUBE_CAMERA_FACE_ORDER } from './chunk-PLAXOOX5.mjs';
 import { SpriteInstances, SpriteRegionOverride, TileLayer, decodeSortScope, Tilemap } from './chunk-PA5DRJNI.mjs';
-import { GPU_SCENE_LAYOUTS, deviceOptionsForAdapter, PipelineSpecError, assertStorageBufferCap, STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES, GpuBuffer, GpuTexture, deriveRenderDataTexture, deriveRenderDataMesh, deriveRenderDataCubemap, createIblPipelines, CUBEMAP_FACE_VERTICES, runIblPrecompute, createClusterBinScratch, resetHdrpBuffers, retireTemporalGpuState, PostProcessError, entryHasDepthRead, DEPTH_MIN_PARAMS_BYTE_SIZE, postProcessShaderModuleLabel, resolveSsaoParameters, buildPerFrameBindGroups, resolveMaterialSkylight, postProcessShaderEntrySignature, selectSwapChainFormat, setIblComposedShaders, POINTS_LINES_MATERIAL_SHADER_ID, selectStandardPbrTransmissionPrewarmVariants, selectHdrpPbrPrewarmVariants, prewarmMaterialShaderVariants, selectProbePrewarmVariants, createHdrpClusterMembershipBindGroupLayoutDescriptor, createSkylightFallback, buildSpecConstTable, buildLinearLdrMaterialSpecTable, getOrBuildPipeline, cacheKeyOf, configureSurface, CAPTURE_VIEW_PROJS, PREFILTER_MIP_LEVELS, REFLECTION_PROBE_VIEW_SLOT_BASE, VIEW_UNIFORM_SLOT_STRIDE, getOrCreateIblCache, decideVisibility, BatchTopology, postProcessShaderPipelineLabel, createPointsLinesLaneAdapter, computeViewMatrix, computeProjectionMatrix, prepareFrameLighting, warnMultiSkylight, warnMultiSkybox, selectLazyEquirectHandle, driveLazyEquirectProjection, warnZeroLightStandard, writeShadowParamsBuffer, deriveRenderExtent, writeSpotModifierTextures, writeHdrpClusterAndSsaoBuffers, resolveSkyboxActive, computeSplitLdrSprite, writeViewUbo, writePointsLinesViewUbo, writeShadowCasterUniforms, uploadMeshSsboBatch, passKindPolicyTable, colorFormatsForPassKind, GPU_DRIVEN_VIEW_WGSL, selectGpuDrivenSceneIndexVariant, selectSkinPrewarmVariants, transmissionBackdropAvailable, VIEW_UNIFORM_BUFFER_SIZE, POINTS_LINES_VIEW_BUFFER_SIZE, SHADOW_CASTER_BUFFER_SIZE, FALLBACK_BYTES_PER_ROW, getIblProbeBackgroundSource, OcclusionConfidenceScheduler, shouldIssueRetest, selectGpuLodLane, ShadowViewStatePool, GpuDrivenView, MATERIAL_PER_ENTITY_STRIDE, shadowViewIdentityKey, createPointsLinesLaneContract, foldDispatchBuckets, CUBE_CAPTURE_VIEW_SLOT_BASE, variantSetFromDefines, resolveReflectionProbeBinding, cleanPerEntityCache, ensureMeshSsboCapacity, buildFoldDispatchPlan, evaluateFoldBucketUniformCap, incrementFoldedDrawsMetric, writePbrMaterialUboPayload, applyParamSnapshotToUbo, applyMaterialTextureUvScales, residentTextureView, detectNineSliceScaleTooSmall, PREFILTER_SIZE, gpuSceneFieldOffset, projectedHeightForCandidate, geometryRenderStateForTopology, packInstanceStorageBuffer, MESH_SSBO_BYTES, buildFullscreenPostProcessPass, getTemporalGpuState, getTemporalParamsBuffer, getTemporalBindGroupResources, TEMPORAL_HISTORY_FORMATS, resolveSurfaceFormatPair, resolveSurfaceProfile, createRenderPipelineTarget, encodeMainPass, STANDARD_PBR_UBO_SIZE, abortTemporalGpuSubmit, commitTemporalGpuSubmit, retireTemporalGpuStateAfterFence, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, renderExtentSize, DEFERRED_COLOR_FORMATS, aggregateTemporalDemand, standardTemporalLaneAdmission, addTypedScenePass, addTypedSsaoPasses, addTypedSkyboxPass, createStandardSceneDataTarget, addStandardSceneDataPass, VIEW_UNIFORM_BYTES, addTypedFrameObservationPass, addReflectionFallbackObservationPass, selectLod, temporalReadIndex, temporalWriteIndex, prepareMaterialSkylight, BYTES_PER_DIRECT_LIGHT_SLOT, shadowViewRasterAccesses, encodeDirectionalShadowPass, encodePointShadowPass, encodeSpotShadowPass, getOrCreateFromChain, resolveOutputDither, addTypedTemporalResolvePass, addTypedBloomPasses, addTypedOutputTransformPass, addTypedFullscreenPass, addTypedCompositePostEffects, standardTopologyVariantSet, geometryRenderStateForPass, standardStorageVariantSet, getOrCreateHdrpBuffers, variantSetFromVertexLayoutProjection, createStandardSurfaceLightingBindGroup, isTemporalFullscreenBinding, createFullscreenBindGroup, applyParamSchemaDefaultsToUbo, defaultViewForUserRegionField, assembleMaterialWithSkylightEntries, TYPED_BLOOM_PASS_NAMES } from './chunk-JRIPCMYC.mjs';
+import { GPU_SCENE_LAYOUTS, deviceOptionsForAdapter, PipelineSpecError, assertStorageBufferCap, STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES, GpuBuffer, GpuTexture, deriveRenderDataTexture, deriveRenderDataMesh, deriveRenderDataCubemap, createIblPipelines, CUBEMAP_FACE_VERTICES, runIblPrecompute, createClusterBinScratch, resetHdrpBuffers, retireTemporalGpuState, PostProcessError, entryHasDepthRead, DEPTH_MIN_PARAMS_BYTE_SIZE, postProcessShaderModuleLabel, resolveSsaoParameters, buildPerFrameBindGroups, resolveMaterialSkylight, postProcessShaderEntrySignature, standardBloomAdmitted, selectSwapChainFormat, setIblComposedShaders, POINTS_LINES_MATERIAL_SHADER_ID, selectStandardPbrTransmissionPrewarmVariants, selectHdrpPbrPrewarmVariants, prewarmMaterialShaderVariants, selectProbePrewarmVariants, createHdrpClusterMembershipBindGroupLayoutDescriptor, createSkylightFallback, buildSpecConstTable, buildLinearLdrMaterialSpecTable, getOrBuildPipeline, cacheKeyOf, HDR_COLOR_ATTACHMENT_FORMAT, configureSurface, CAPTURE_VIEW_PROJS, PREFILTER_MIP_LEVELS, REFLECTION_PROBE_VIEW_SLOT_BASE, VIEW_UNIFORM_SLOT_STRIDE, getOrCreateIblCache, decideVisibility, BatchTopology, postProcessShaderPipelineLabel, createPointsLinesLaneAdapter, computeViewMatrix, computeProjectionMatrix, prepareFrameLighting, warnMultiSkylight, warnMultiSkybox, selectLazyEquirectHandle, driveLazyEquirectProjection, warnZeroLightStandard, writeShadowParamsBuffer, deriveRenderExtent, writeSpotModifierTextures, writeHdrpClusterAndSsaoBuffers, resolveSkyboxActive, computeSplitLdrSprite, writeViewUbo, writePointsLinesViewUbo, writeShadowCasterUniforms, uploadMeshSsboBatch, passKindPolicyTable, colorFormatsForPassKind, GPU_DRIVEN_VIEW_WGSL, selectGpuDrivenSceneIndexVariant, selectSkinPrewarmVariants, transmissionBackdropAvailable, VIEW_UBO_BYTES, POINTS_LINES_VIEW_BUFFER_SIZE, SHADOW_CASTER_BUFFER_SIZE, FALLBACK_BYTES_PER_ROW, MIPMAP_PREWARM_FORMATS, getIblProbeBackgroundSource, OcclusionConfidenceScheduler, shouldIssueRetest, selectGpuLodLane, ShadowViewStatePool, GpuDrivenView, MATERIAL_PER_ENTITY_STRIDE, shadowViewIdentityKey, createPointsLinesLaneContract, foldDispatchBuckets, CUBE_CAPTURE_VIEW_SLOT_BASE, variantSetFromDefines, resolveReflectionProbeBinding, cleanPerEntityCache, ensureMeshSsboCapacity, buildFoldDispatchPlan, evaluateFoldBucketUniformCap, incrementFoldedDrawsMetric, writePbrMaterialUboPayload, applyParamSnapshotToUbo, applyMaterialTextureUvScales, residentTextureView, detectNineSliceScaleTooSmall, DEPTH_TEXTURE_FORMAT, PREFILTER_SIZE, gpuSceneFieldOffset, projectedHeightForCandidate, geometryRenderStateForTopology, packInstanceStorageBuffer, MESH_SSBO_BYTES, buildFullscreenPostProcessPass, getTemporalGpuState, getTemporalParamsBuffer, getTemporalBindGroupResources, TEMPORAL_HISTORY_FORMATS, resolveSurfaceFormatPair, resolveSurfaceProfile, createRenderPipelineTarget, encodeMainPass, STANDARD_PBR_UBO_SIZE, abortTemporalGpuSubmit, commitTemporalGpuSubmit, retireTemporalGpuStateAfterFence, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, renderExtentSize, DEFERRED_COLOR_FORMATS, aggregateTemporalDemand, standardTemporalLaneAdmission, addTypedScenePass, addTypedSsaoPasses, addTypedSkyboxPass, createStandardSceneDataTarget, addStandardSceneDataPass, VIEW_UNIFORM_BYTES, addTypedFrameObservationPass, addReflectionFallbackObservationPass, selectLod, temporalReadIndex, temporalWriteIndex, prepareMaterialSkylight, BYTES_PER_DIRECT_LIGHT_SLOT, shadowViewRasterAccesses, encodeDirectionalShadowPass, encodePointShadowPass, encodeSpotShadowPass, getOrCreateFromChain, resolveOutputDither, addTypedFullscreenPass, addTypedTemporalResolvePass, addTypedBloomPasses, addTypedOutputTransformPass, addTypedCompositePostEffects, standardTopologyVariantSet, geometryRenderStateForPass, standardStorageVariantSet, getOrCreateHdrpBuffers, variantSetFromVertexLayoutProjection, createStandardSurfaceLightingBindGroup, BLOOM_DOWNSAMPLE_PARAMS_BYTES, BLOOM_UPSAMPLE_PARAMS_BYTES, BLOOM_COMPOSITE_PARAMS_BYTES, isTemporalFullscreenBinding, createFullscreenBindGroup, applyParamSchemaDefaultsToUbo, defaultViewForUserRegionField, assembleMaterialWithSkylightEntries, TYPED_BLOOM_PASS_NAMES } from './chunk-VOZWDM3L.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, STANDARD_PIPELINE_ID, STANDARD_LIGHT_COUNTS, STANDARD_POST_STAGE_NAMES, createSceneDataCatalog, resolveVolumetricFogProfile, isSceneDataTarget } from './chunk-S665NJNF.mjs';
+import { DEFAULT_STANDARD_PROFILE, DEFAULT_CLUSTER_GRID, STANDARD_PIPELINE_ID, STANDARD_LIGHT_COUNTS, STANDARD_POST_STAGE_NAMES, createSceneDataCatalog, isSceneDataTarget, resolveVolumetricFogProfile, SCENE_DATA_TEMPORAL_V1_SCHEMA } from './chunk-LEAXOMYJ.mjs';
 import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-BLXGONR2.mjs';
-import { DeviceScope, SKIN_MATERIAL_SHADER_ID, EXTENDED_LIGHTING_TOPOLOGY, getTextureIdentity, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_MAP_READ, resolveRenderTargetMaterialSource, createRenderTargetMaterialSource, deriveExtendedLightingCapability, GPU_BUFFER_USAGE_VERTEX, GPU_BUFFER_USAGE_INDEX, IES_SLICE_WIDTH, IES_SLICE_HEIGHT, COOKIE_SLICE_SIZE, COOKIE_MATRIX_BYTES, GPU_BUFFER_USAGE_UNIFORM, worldEntityKey, createHdrpBindGroupLayoutDescriptor, createHdrpSkinBindGroupLayoutDescriptor, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_COPY_SRC, gpuDrivenShadowDrawKey, makeZeroCameraFallbackSnapshot, buildPbrPipelineLayouts, buildPbrSkinLayouts, buildGpuDrivenPbrInstancesBindGroupLayout, buildGpuDrivenPbrPipelineLayout, buildGpuDrivenPbrSkinPipelineLayout, GPU_BUFFER_USAGE_STORAGE, resolvePipelineGroup2Contract, GPU_SHADER_STAGE_FRAGMENT, gpuDrivenDrawKey, gpuDrivenSourceDrawItemIndex, instanceCollectionCacheKey, validateGraphTargetCaptureReadback, createTemporalCoverage, isCanonicalStandardPbrMaterialShader, isStandardPbrMaterialShader, buildBindGroupLayoutDescriptor, gpuDrivenMaterialArtifactKey, buildPbrMaterialUserRegionEntries, extendedLightingSampledTextureCapacityAvailable, GPU_SHADER_STAGE_VERTEX, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, GPU_SHADER_STAGE_COMPUTE, LifecycleTransaction } from './chunk-DRR7D3KX.mjs';
-import { RendererContractFailureError, RendererOperationError, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, FrameReceiptStaleError, RenderFeatureStageFailedError, RenderFeatureCapabilityMissingError, RenderTargetStateInvalidError, RenderTargetOperationFailedError, RenderTargetCapabilityMissingError, RenderTargetDescriptorInvalidError, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, RENDER_PHASE_CATALOG, InstanceCollectionStore, createAutoExposureInspection, RenderFeatureRegistrationConflictError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_SRC, createVisibilityBudget, EnvironmentGenerationFailedError, PointsLinesMaterialUnsupportedError, StandardProfileInvalidError, TransmissionCapabilityMissingError, SHADOW_ATLAS_DEFAULT_LAYERS, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GpuDrivenPreparationError, TemporalFrameSubmitError, ObservationUnavailableError, RenderFeaturePreparationFailedError, AutoExposureInvalidParameterError, PointsLinesPrepareFailedError, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SceneDataUnavailableError, SkinPaletteOverflowError, GPU_TEXTURE_USAGE_STORAGE_BINDING, RenderFeatureDrawRecordingFailedError, PointShadowAtlasUninitializedError, RenderFeaturePreparedStateMismatchError, FXAA_POST_PROCESS_ID } from './chunk-6TFBXLRJ.mjs';
+import { DeviceScope, SKIN_MATERIAL_SHADER_ID, EXTENDED_LIGHTING_TOPOLOGY, getTextureIdentity, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_MAP_READ, resolveRenderTargetMaterialSource, createRenderTargetMaterialSource, deriveExtendedLightingCapability, GPU_BUFFER_USAGE_VERTEX, GPU_BUFFER_USAGE_INDEX, IES_SLICE_WIDTH, IES_SLICE_HEIGHT, COOKIE_SLICE_SIZE, COOKIE_MATRIX_BYTES, GPU_BUFFER_USAGE_UNIFORM, worldEntityKey, createHdrpBindGroupLayoutDescriptor, createHdrpSkinBindGroupLayoutDescriptor, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_COPY_SRC, gpuDrivenShadowDrawKey, makeZeroCameraFallbackSnapshot, buildPbrPipelineLayouts, buildPbrSkinLayouts, buildGpuDrivenPbrInstancesBindGroupLayout, buildGpuDrivenPbrPipelineLayout, buildGpuDrivenPbrSkinPipelineLayout, GPU_BUFFER_USAGE_STORAGE, resolvePipelineGroup2Contract, GPU_SHADER_STAGE_FRAGMENT, gpuDrivenDrawKey, gpuDrivenSourceDrawItemIndex, instanceCollectionCacheKey, validateGraphTargetCaptureReadback, createTemporalCoverage, isCanonicalStandardPbrMaterialShader, isStandardPbrMaterialShader, buildBindGroupLayoutDescriptor, gpuDrivenMaterialArtifactKey, hasRequiredVertexInputs, buildPbrMaterialUserRegionEntries, extendedLightingSampledTextureCapacityAvailable, GPU_SHADER_STAGE_VERTEX, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, GPU_SHADER_STAGE_COMPUTE, LifecycleTransaction } from './chunk-3RTCJTH4.mjs';
+import { RendererContractFailureError, RendererOperationError, MotionBlurValidationError, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, FrameReceiptStaleError, RenderFeatureStageFailedError, RenderFeatureCapabilityMissingError, RenderTargetStateInvalidError, RenderTargetOperationFailedError, RenderTargetCapabilityMissingError, RenderTargetDescriptorInvalidError, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, RENDER_PHASE_CATALOG, InstanceCollectionStore, motionBlurTemporalDemand, createAutoExposureInspection, RenderFeatureRegistrationConflictError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_SRC, createVisibilityBudget, EnvironmentGenerationFailedError, PointsLinesMaterialUnsupportedError, StandardProfileInvalidError, TransmissionCapabilityMissingError, motionBlurSampleDelta, isMotionBlurIntervalValid, MOTION_BLUR_PARAMS_BYTE_SIZE, effectiveMotionBlurSampleCount, motionBlurExposureScale, SHADOW_ATLAS_DEFAULT_LAYERS, DEFAULT_MOTION_BLUR_PARAMS, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GpuDrivenPreparationError, TemporalFrameSubmitError, ObservationUnavailableError, RenderFeaturePreparationFailedError, AutoExposureInvalidParameterError, PointsLinesPrepareFailedError, validateMotionBlurParams, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SceneDataUnavailableError, SkinPaletteOverflowError, GPU_TEXTURE_USAGE_STORAGE_BINDING, RenderFeatureDrawRecordingFailedError, PointShadowAtlasUninitializedError, RenderFeaturePreparedStateMismatchError, FXAA_POST_PROCESS_ID } from './chunk-NB2S7ZRX.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';
@@ -18,7 +18,7 @@ import { buildMeshAttributeMapForUvSets, deriveVertexBufferLayout, DEFAULT_VERTE
 import { GlobalTransform, ChildOf, MorphWeights, registerPropagateTransforms, collectSubtree, Name, Children, Transform } from '@forgeax/engine-scene';
 import { STANDARD_PIPELINE_PARAM_SCHEMA, createStandardPbrArtifactReceipt, ShaderCatalog, findVariantByKey, LTC_TABLES, standardPhysicalTextureFields, LTC_TABLE_HEIGHT, LTC_TABLE_WIDTH, DEFAULT_STANDARD_PBR_PARAM_SCHEMA, AUTO_EXPOSURE_METER_WGSL } from '@forgeax/engine-shader';
 import { halfFloat, frustum, mat4, vec3, box3, mat3 } from '@forgeax/engine-math';
-import { derive, err as err$1, ok as ok$1, handleSlot, toShared, deriveTextureLayout, ASSET_ERROR_HINTS, countExtraUvSets, RenderQueue, IMAGE_ERROR_HINTS, BUILTIN_BASE, unwrapHandle, materialValuesToLinearRuntime } from '@forgeax/engine-types';
+import { derive, err as err$1, ok as ok$1, handleSlot, deriveTextureLayout, ASSET_ERROR_HINTS, countExtraUvSets, toShared, RenderQueue, IMAGE_ERROR_HINTS, BUILTIN_BASE, unwrapHandle, materialValuesToLinearRuntime } from '@forgeax/engine-types';
 import { createCurrentFrameObservationLease, RenderGraphBuilder, RenderGraphError } from '@forgeax/engine-render-graph';
 import { componentId } from '@forgeax/engine-ecs/internal';
 import { Skin } from '@forgeax/engine-skinning';
@@ -254,6 +254,7 @@ function exposeRenderer(renderer) {
     cause: structuredRendererCause(cause, "renderer-event")
   });
   const drawError = (cause) => {
+    if (cause instanceof MotionBlurValidationError) return cause;
     if (cause instanceof RendererOperationError) return cause;
     if (cause instanceof RendererContractFailureError) {
       return new RendererOperationError("device-operation-failed", {
@@ -849,6 +850,12 @@ var GpuResidencyCache = class {
   // equirect source always resolves to the same cubemap (idempotent, A2).
   cubemapIdempotentMap = /* @__PURE__ */ new Map();
   meshGpuHandles = /* @__PURE__ */ new Map();
+  /**
+   * Lower-detail POD identities packed into each resident mesh entry. The
+   * GPU entry only carries byte ranges; keeping the source identities beside
+   * it lets a later draw upgrade a root-only upload without hashing vertices.
+   */
+  meshLodAssets = /* @__PURE__ */ new WeakMap();
   meshLifetimes = /* @__PURE__ */ new WeakMap();
   retiredMeshes = /* @__PURE__ */ new Set();
   meshLifetime(entry) {
@@ -1063,7 +1070,7 @@ var GpuResidencyCache = class {
     return { freed, errors };
   }
   evictMesh(handle, worldId = 0) {
-    const id = this.worldKey(handleSlot(handle), worldId);
+    const id = this.worldKey(Number(handle), worldId);
     const entry = this.meshGpuHandles.get(id);
     if (entry === void 0) return { freed: 0, errors: [] };
     if (this.meshLifetime(entry).owners > 0) return { freed: 0, errors: [] };
@@ -1271,11 +1278,11 @@ var GpuResidencyCache = class {
    * as the canonical "mesh asset has GPU residency" probe.
    */
   getMeshGpuHandles(handle, worldId = 0) {
-    return this.meshGpuHandles.get(this.worldKey(handleSlot(handle), worldId));
+    return this.meshGpuHandles.get(this.worldKey(Number(handle), worldId));
   }
   /** Candidate leases retain the concrete allocation even after cache invalidation. */
   retainMeshResidency(handle, worldId = 0) {
-    const key = this.worldKey(handleSlot(handle), worldId);
+    const key = this.worldKey(Number(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);
@@ -1284,7 +1291,7 @@ var GpuResidencyCache = class {
   }
   /** 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 key = this.worldKey(handle, worldId);
     const entry = this.meshGpuHandles.get(key);
     if (entry !== void 0) this.retireMeshEntry(key, entry);
   }
@@ -1292,9 +1299,20 @@ var GpuResidencyCache = class {
     const id = handleSlot(handle);
     switch (pod.kind) {
       case "mesh": {
-        const key = this.worldKey(id, worldId);
+        const key = this.worldKey(Number(handle), worldId);
         const existing = this.meshGpuHandles.get(key);
-        if (existing !== void 0) return ok(existing);
+        if (existing !== void 0) {
+          if (lodMeshes.length === 0) return ok(existing);
+          const previousLodAssets = this.meshLodAssets.get(existing);
+          const sameLodChain = previousLodAssets !== void 0 && previousLodAssets.length === lodMeshes.length && previousLodAssets.every((asset, index) => asset === lodMeshes[index]);
+          if (sameLodChain) return ok(existing);
+          const projected2 = deriveRenderDataMesh(pod);
+          if (!projected2.ok) return projected2;
+          const upgraded = this.uploadMeshById(key, pod, projected2.value, lodMeshes);
+          if (!upgraded.ok) return upgraded;
+          this.retireMeshEntry(key, existing);
+          return upgraded;
+        }
         const projected = deriveRenderDataMesh(pod);
         if (!projected.ok) return projected;
         return this.uploadMeshById(key, pod, projected.value, lodMeshes);
@@ -1319,7 +1337,7 @@ var GpuResidencyCache = class {
   prepareResidentForRecovery(handle, pod, worldId = 0) {
     const id = handleSlot(handle);
     if (pod.kind === "mesh") {
-      const key = this.worldKey(id, worldId);
+      const key = this.worldKey(Number(handle), worldId);
       if (this.meshGpuHandles.has(key)) return ok({});
       const projected2 = deriveRenderDataMesh(pod);
       if (!projected2.ok) return projected2;
@@ -1965,6 +1983,10 @@ var GpuResidencyCache = class {
     if (!vboResult.ok) return vboResult;
     const vbo = vboResult.value;
     let ibo = null;
+    const cleanupUpload = () => {
+      if (ibo !== null) device.destroyBuffer(ibo);
+      device.destroyBuffer(vbo);
+    };
     if (indices !== void 0) {
       const iboResult = device.createBuffer({
         label: `mesh-${id}-ibo`,
@@ -1972,15 +1994,22 @@ var GpuResidencyCache = class {
         usage: renderData.indexUsage,
         mappedAtCreation: false
       });
-      if (!iboResult.ok) return iboResult;
+      if (!iboResult.ok) {
+        cleanupUpload();
+        return iboResult;
+      }
       ibo = iboResult.value;
     }
     const vboWriteResult = device.queue.writeBuffer(vbo, 0, vertices);
-    if (!vboWriteResult.ok) return err(vboWriteResult.error);
+    if (!vboWriteResult.ok) {
+      cleanupUpload();
+      return err(vboWriteResult.error);
+    }
     if (indices !== void 0) {
       const indexSrc = new Uint8Array(indexBytes);
       indexSrc.set(new Uint8Array(indices.buffer, indices.byteOffset, indexBytesUnpadded));
-      if (ibo === null)
+      if (ibo === null) {
+        cleanupUpload();
         return err(
           new RhiError({
             code: "webgpu-runtime-error",
@@ -1988,8 +2017,12 @@ var GpuResidencyCache = class {
             hint: "the indexed mesh upload lost its RHI index-buffer owner"
           })
         );
+      }
       const iboWriteResult = device.queue.writeBuffer(ibo, 0, indexSrc);
-      if (!iboWriteResult.ok) return err(iboWriteResult.error);
+      if (!iboWriteResult.ok) {
+        cleanupUpload();
+        return err(iboWriteResult.error);
+      }
     }
     const extraUvSets = countExtraUvSets(mesh.attributes);
     const entry = {
@@ -2008,6 +2041,7 @@ var GpuResidencyCache = class {
       ...lodRanges === void 0 ? {} : { lodRanges }
     };
     this.meshGpuHandles.set(id, entry);
+    this.meshLodAssets.set(entry, lodMeshes);
     this.meshResidencyEpoch += 1;
     return ok(entry);
   }
@@ -2739,7 +2773,7 @@ function freezeRenderFeaturePlan(identity, plan, logicalTargets2 = []) {
   for (const resource of plan.resources) {
     if (!validName(resource.name) || resources.has(resource.name))
       return err$1(stageFailure(identity));
-    if (resource.kind === "prepared-gpu-resource" && resource.logicalTarget !== void 0 && !targets.has(resource.logicalTarget)) {
+    if (resource.kind === "prepared-gpu-resource" && resource.logicalTarget !== void 0 && !(typeof resource.logicalTarget === "string" ? targets.has(resource.logicalTarget) : isSceneDataTarget(resource.logicalTarget))) {
       return err$1(stageFailure(identity));
     }
     resources.set(resource.name, resource);
@@ -2761,7 +2795,7 @@ function freezeRenderFeaturePlan(identity, plan, logicalTargets2 = []) {
         );
         const resource = resources.get(entry.resource);
         const validBuffer = resource?.kind === "buffer" && layout?.buffer !== void 0;
-        const validPrepared = resource?.kind === "prepared-gpu-resource" && (resource.resource.kind === "buffer" && layout?.buffer !== void 0 || resource.resource.kind === "texture-view" && layout?.texture !== void 0 || resource.resource.kind === "sampler" && layout?.sampler !== void 0);
+        const validPrepared = resource?.kind === "prepared-gpu-resource" && (resource.resource.kind === "buffer" && layout?.buffer !== void 0 || resource.resource.kind === "texture-view" && (layout?.texture !== void 0 || layout?.storageTexture !== void 0) || resource.resource.kind === "sampler" && layout?.sampler !== void 0);
         if (!validBuffer && !validPrepared) {
           return err$1(stageFailure(identity));
         }
@@ -3394,7 +3428,7 @@ function asFeatureError(error, identity, order, stage) {
   if (error instanceof Error && typeof error.code === "string") {
     return error;
   }
-  return new RenderFeatureStageFailedError(identity, order, stage, "next-frame");
+  return new RenderFeatureStageFailedError(identity, order, stage, "next-frame", error);
 }
 function featureErrorForSlot(slot, error) {
   switch (error.code) {
@@ -3409,14 +3443,16 @@ function featureErrorForSlot(slot, error) {
         slot.feature.identity,
         slot.order,
         "plan",
-        "next-frame"
+        "next-frame",
+        error
       );
     default:
       return new RenderFeatureStageFailedError(
         slot.feature.identity,
         slot.order,
         "plan",
-        "next-frame"
+        "next-frame",
+        error
       );
   }
 }
@@ -3444,7 +3480,8 @@ function errorDescriptor(error) {
           featureIdentity: "unknown",
           order: -1,
           stage: "plan",
-          recovery: "next-frame"
+          recovery: "next-frame",
+          cause: error
         }
       };
   }
@@ -3532,13 +3569,13 @@ function preparePlanResources(slot, plan, graphics, gpu, targets) {
     }
     if (resource.resource.kind === "texture-view") {
       const logical = resource.logicalTarget === void 0 ? void 0 : targetHandle(resource.logicalTarget, targets);
-      if (resource.logicalTarget !== void 0 && (logical === void 0 || !isRenderFeatureTargetHandle(logical))) {
+      if (resource.logicalTarget !== void 0 && (logical === void 0 || typeof logical !== "string" && !isRenderFeatureTargetHandle(logical) && !isSceneDataTarget(logical))) {
         return err$1(planFailure(slot));
       }
       const prepared2 = gpu.prepareTextureView(
         resource.name,
         resource.resource.value,
-        logical === void 0 || !isRenderFeatureTargetHandle(logical) ? void 0 : logical
+        logical === void 0 ? void 0 : logical
       );
       if (!prepared2.ok) return prepared2;
       preparedGpuResources.set(resource.name, {
@@ -4184,7 +4221,10 @@ function runRenderFeatureFrame(host, input) {
       "plan",
       () => feature.plan(extracted.value, {
         caps: input.caps,
-        frame: { frameNumber: input.frameNumber },
+        frame: {
+          frameNumber: input.frameNumber,
+          ...input.frameSize === void 0 ? {} : input.frameSize
+        },
         generation: transaction.generation,
         targets,
         sceneData,
@@ -4241,9 +4281,7 @@ function runRenderFeatureFrame(host, input) {
     };
     const resolver = input.createPreparedGraphicsResolver?.(resolverInput);
     const resolveGraphics = resolver === void 0 ? void 0 : (descriptor) => {
-      const resolved2 = resolveGraphicsSnapshot(resolver, descriptor, transaction.generation);
-      if (!resolved2.ok) resolver.release();
-      return resolved2;
+      return resolveGraphicsSnapshot(resolver, descriptor, transaction.generation);
     };
     const releaseResolver = () => {
       if (resolver !== void 0) resolver.release();
@@ -4271,9 +4309,7 @@ function runRenderFeatureFrame(host, input) {
       host.setStatus(identity, "failed", slot.latestError);
       continue;
     }
-    const graphicsLeases = projected.value.passes.flatMap(
-      (pass) => pass.resolvedGraphics?.leases ?? []
-    );
+    const graphicsLeases = resolver?.leases ?? projected.value.passes.flatMap((pass) => pass.resolvedGraphics?.leases ?? []);
     if (graphicsLeases.length > 0) requiresPreparedResourceKey = true;
     const leases = [...new Set(graphicsLeases), ...gpu?.retireUntouched() ?? []];
     const retained = host.retainPreparedGraphics(identity, leases);
@@ -4357,6 +4393,66 @@ function createRenderFeatureHost(features, _caps) {
   return ok$1(new FeatureHostImpl(slots));
 }
 
+// src/features/motion-blur/motion-blur-runtime.ts
+function motionBlurDrawOptions(input) {
+  return {
+    ...input.sampleTimeSeconds === void 0 ? {} : { sampleTimeSeconds: input.sampleTimeSeconds },
+    ...input.temporalReset === true ? { temporalReset: true } : {}
+  };
+}
+function planMotionBlurFrame(input) {
+  const rawSampleDelta = motionBlurSampleDelta(
+    input.sampleTimeSeconds,
+    input.acceptedSampleTimeSeconds,
+    input.fallbackDeltaSeconds
+  );
+  const accepted = input.acceptedTemporal;
+  const reset = input.temporalReset || accepted === void 0 || accepted.historyValid === false && accepted.resetReason === void 0 || !isMotionBlurIntervalValid(rawSampleDelta) || accepted.input.width !== input.width || accepted.input.height !== input.height || accepted.input.viewIdentity !== input.cameraViewIdentity || accepted.input.historyVersion !== input.historyVersion || accepted.input.environmentSignature !== input.environmentSignature || accepted.input.fogSignature !== input.fogSignature || accepted.input.deviceGeneration !== input.deviceGeneration;
+  const params = input.params === void 0 ? void 0 : { ...input.params, targetFps: input.params.targetFps ?? 60 };
+  const demanded = motionBlurTemporalDemand(params);
+  return {
+    rawSampleDelta,
+    demanded,
+    featureInput: params === void 0 ? void 0 : {
+      params,
+      frameDeltaSeconds: rawSampleDelta,
+      reset: demanded && reset
+    }
+  };
+}
+function projectMotionBlurInspection(input) {
+  if (input.camera?.motionBlur === void 0 && input.invalidParams === void 0) {
+    return void 0;
+  }
+  const motionBlur = input.camera?.motionBlur === void 0 ? DEFAULT_MOTION_BLUR_PARAMS : { ...input.camera.motionBlur, targetFps: input.camera.motionBlur.targetFps ?? 60 };
+  const demanded = motionBlurTemporalDemand(motionBlur);
+  const unavailable3 = demanded && !input.capabilities.rgba16floatRenderable;
+  const lane = input.capabilities.compute && input.capabilities.storageBuffer && input.capabilities.storageTexture && input.capabilities.rgba16floatRenderable ? "compute" : "raster-limited";
+  const accepted = input.acceptedTemporal;
+  const submitFailure = input.transaction.lastFailure === "queue-submit-failed" || accepted?.resetReason === "submit-failure";
+  const execution = input.execution;
+  const executionAccepted = execution !== void 0 && input.temporalFrameId === execution.frameId && execution.deviceGeneration === input.deviceGeneration && execution.graphGeneration === input.graphGeneration;
+  const active = demanded && !unavailable3 && lane === "compute" && executionAccepted && accepted?.historyValid === true && accepted.resetReason === void 0;
+  return {
+    enabled: demanded,
+    status: input.invalidParams !== void 0 ? "invalid" : !demanded ? "off" : active ? "active" : !unavailable3 && lane === "raster-limited" ? "limited" : "reset",
+    lane,
+    shutterAngle: motionBlur.shutterAngle,
+    maxRadiusPixels: motionBlur.maxRadiusPixels,
+    sampleCount: motionBlur.sampleCount,
+    targetFps: motionBlur.targetFps ?? 60,
+    effectiveSampleCount: !demanded ? 0 : effectiveMotionBlurSampleCount(motionBlur.sampleCount),
+    temporalDemand: demanded ? "scene-data-temporal-v1" : "none",
+    passName: "motion-blur",
+    historyWrites: 0,
+    passCount: !demanded ? 0 : executionAccepted ? 2 : lane === "raster-limited" ? 1 : 0,
+    tapBudget: !demanded ? 0 : effectiveMotionBlurSampleCount(motionBlur.sampleCount),
+    ...executionAccepted ? { execution } : {},
+    ...accepted?.resetReason === void 0 ? {} : { resetReason: accepted.resetReason },
+    ...input.invalidParams !== void 0 ? { lastFailure: "invalid-params" } : unavailable3 ? { lastFailure: "scene-data-unavailable" } : submitFailure ? { lastFailure: "submit-failure" } : {}
+  };
+}
+
 // src/lifecycle.ts
 var LostListenerRegistry = class {
   listeners = /* @__PURE__ */ new Set();
@@ -4715,8 +4811,8 @@ function addAtmosphereBackground(graph, color) {
         settings.mieDirectionalG,
         settings.sunAngularRadius,
         settings.sunAngularRadius > 0 ? 1 : 0,
-        0,
-        0
+        settings.circumsolarStrength,
+        settings.circumsolarWidth
       ]);
       frame.runtime.device.queue.writeBuffer(resources.buffer(params.value).unwrap(), 0, values).unwrap();
       const triangles = new Float32Array(6 * 9);
@@ -6185,7 +6281,7 @@ var VOLUME_FROXEL_FORMAT = "rgba8unorm";
 var VOLUME_HISTORY_FORMAT = "rgba16float";
 var VOLUME_RESOLVED_FORMAT = "rgba16float";
 var VOLUME_PACKING_Z = 4;
-var VOLUMETRIC_FOG_PARAMS_BYTES = 8 * 16;
+var VOLUMETRIC_FOG_PARAMS_BYTES = 9 * 16;
 function deriveVolumetricFogExtent(surface, depth = 64, tileSize = 4) {
   const physicalTileSize = Math.max(2, Math.floor(tileSize / 2));
   return {
@@ -6404,7 +6500,10 @@ function importVolumeInputs(graph, topology, linearHdr, sceneDepth, directionalS
   if (!density.ok) return density;
   const params = graph.importBuffer(
     "volume-params",
-    { size: 128, usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST },
+    {
+      size: VOLUMETRIC_FOG_PARAMS_BYTES,
+      usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST
+    },
     (frame) => {
       const context = frame.volumetricFog;
       if (context === void 0) throw pipelineError2("parameter residency");
@@ -6640,9 +6739,9 @@ function addVolumetricFogPasses(graph, inputs) {
       const densitySampler = frame.runtime.device.createSampler({
         minFilter: "linear",
         magFilter: "linear",
-        addressModeU: "clamp-to-edge",
-        addressModeV: "clamp-to-edge",
-        addressModeW: "clamp-to-edge"
+        addressModeU: "repeat",
+        addressModeV: "repeat",
+        addressModeW: "repeat"
       });
       if (!densitySampler.ok) throw densitySampler.error;
       const bindings = volumeBindGroup(frame, integrate.layout, [
@@ -6973,6 +7072,1546 @@ function addMotionBlurPass(graph, input, temporal, output) {
     output
   });
 }
+var MOTION_BLUR_COMPUTE_WGSL = `struct MotionBlurComputeParams {
+  shutterAngle : f32,
+  maxRadiusPixels : f32,
+  sampleCount : u32,
+  reset : u32,
+  targetFps : f32,
+  exposureScale : f32,
+  frameDeltaSeconds : f32,
+  flags : u32,
+};
+
+struct MotionBlurTileSummary {
+  // The two motion lanes retain the source pixel that supplied the direction.
+  // Those anchors let a bounded midpoint tap hit a sparse source without
+  // adding a color read or growing the 32-byte per-tile summary.
+  maxMotionAndLength : vec4<f32>,
+  secondaryMotionAndDepth : vec4<f32>,
+};
+
+struct TemporalSample {
+  motion : vec2<f32>,
+  depth : f32,
+  reactive : f32,
+  validDepth : bool,
+  motionValid : bool,
+};
+
+struct MotionBlurSupport {
+  primaryMotion : vec2<f32>,
+  secondaryMotion : vec2<f32>,
+  primaryAnchor : vec2<i32>,
+  secondaryAnchor : vec2<i32>,
+  primaryRadius : f32,
+  secondaryRadius : f32,
+  valid : bool,
+  longVector : bool,
+};
+
+struct MotionBlurTap {
+  pixel : vec2<i32>,
+  fallbackPixel : vec2<i32>,
+  valid : bool,
+  fallbackValid : bool,
+};
+
+struct MotionBlurFilter {
+  color0 : vec4<f32>,
+  color1 : vec4<f32>,
+  color2 : vec4<f32>,
+  color3 : vec4<f32>,
+  depth0 : f32,
+  depth1 : f32,
+  depth2 : f32,
+  depth3 : f32,
+  coverage0 : f32,
+  coverage1 : f32,
+  coverage2 : f32,
+  coverage3 : f32,
+  receiver : vec2<i32>,
+  motion : vec2<f32>,
+  radius : f32,
+  receiverMask : u32,
+  validMask : u32,
+  valid : bool,
+};
+
+struct MotionBlurCacheSample {
+  color : vec4<f32>,
+  coverage : f32,
+  valid : bool,
+};
+
+struct MotionBlurSource {
+  pixel : vec2<i32>,
+  motion : vec2<f32>,
+  depth : f32,
+  radius : f32,
+  coverage0 : f32,
+  coverage1 : f32,
+  coverage2 : f32,
+  coverage3 : f32,
+  receiverMask : u32,
+  valid : bool,
+};
+
+@group(0) @binding(0) var currentColor : texture_2d<f32>;
+@group(0) @binding(1) var sceneTemporal : texture_2d<f32>;
+@group(0) @binding(2) var<storage, read_write> tileSummary : array<MotionBlurTileSummary>;
+@group(0) @binding(3) var outputColor : texture_storage_2d<rgba16float, write>;
+@group(0) @binding(4) var<uniform> params : MotionBlurComputeParams;
+
+// Reconstruct a bounded part of a partially covered opaque edge and fund it
+// by attenuating the matching empty-background trail. The fixed factor keeps
+// the work and the energy adjustment independent of the blur radius.
+const EDGE_FILL_FACTOR : f32 = 0.99;
+
+// One 8x8 workgroup covers a 16x16 tile. Each invocation reads a 2x2
+// footprint, then the workgroup reduction combines the values without
+// write contention or a serial 256-pixel loop.
+var<workgroup> tileMotionScratch : array<vec2<f32>, 64>;
+var<workgroup> tileLengthScratch : array<f32, 64>;
+var<workgroup> tileSourceScratch : array<vec2<i32>, 64>;
+var<workgroup> tileSecondaryMotionScratch : array<vec2<f32>, 64>;
+var<workgroup> tileSecondaryLengthScratch : array<f32, 64>;
+var<workgroup> tileSecondarySourceScratch : array<vec2<i32>, 64>;
+// The reconstruction workgroup owns a 4x4 half-resolution result cache for
+// its 8x8 output footprint. Each owner computes the complete bounded support
+// filter once. Full-resolution lanes only select a depth-compatible cached
+// result after the uniform barrier, with no cross-workgroup dependency.
+// Four quadrants are kept per half-cell. Each owner pays four receiver
+// center-color reads and at most supportCount (<=15) accepted source-color
+// reads; midpoint anchor recovery reuses an existing slot and adds no read
+// budget. The shared result retains odd/even coverage instead of spreading an
+// odd row across both rows.
+var<workgroup> halfFilteredColor : array<vec4<f32>, 64>;
+var<workgroup> halfFilteredDepth : array<f32, 64>;
+var<workgroup> halfFilteredCoverage : array<f32, 64>;
+var<workgroup> halfFilteredReceiver : array<vec2<i32>, 16>;
+var<workgroup> halfFilteredMotion : array<vec2<f32>, 16>;
+var<workgroup> halfFilteredRadius : array<f32, 16>;
+var<workgroup> halfFilteredValid : array<u32, 64>;
+var<workgroup> longVectorScratch : array<u32, 64>;
+// A reconstruct workgroup covers one 8x8 output footprint. Its first lane
+// derives the complete bounded tile neighbourhood once and publishes the top
+// two source directions for all lanes and all designated half-resolution
+// owners. This keeps summary work O(P/T^2), rather than repeating a tile walk
+// per output pixel.
+var<workgroup> neighbourhoodPrimaryMotion : vec2<f32>;
+var<workgroup> neighbourhoodPrimaryLength : f32;
+var<workgroup> neighbourhoodPrimaryAnchor : vec2<i32>;
+var<workgroup> neighbourhoodSecondaryMotion : vec2<f32>;
+var<workgroup> neighbourhoodSecondaryLength : f32;
+var<workgroup> neighbourhoodSecondaryAnchor : vec2<i32>;
+
+// maxRadiusPixels is authored at [0,64], so a 16-pixel tile support reaches
+// at most four tiles. The fixed 9x9 lattice is geometrically derived from its
+// index, then intersected with the circular/AABB support. It is a constant
+// bounded metadata walk: no loop scales with the requested radius and no
+// radius-squared per-pixel storage or write path is introduced.
+const MAX_TILE_REACH : i32 = 4;
+const TILE_NEIGHBORHOOD_SIDE : u32 = 9u;
+const TILE_NEIGHBORHOOD_COUNT : u32 = 81u;
+
+fn finite(value : f32) -> bool {
+  return value == value && abs(value) < 3.402823e+38;
+}
+
+fn pixelInBounds(pixel : vec2<i32>, dimensions : vec2<i32>) -> bool {
+  return pixel.x >= 0 && pixel.y >= 0 && pixel.x < dimensions.x && pixel.y < dimensions.y;
+}
+
+fn decodeDepth(packed : f32) -> f32 {
+  if (packed < 0.0) { return 0.0; }
+  return exp2(packed) - 1.0;
+}
+
+fn temporalAt(pixel : vec2<i32>, dimensions : vec2<i32>) -> TemporalSample {
+  let samplePixel = clamp(pixel, vec2<i32>(0), dimensions - vec2<i32>(1));
+  let packed = textureLoad(sceneTemporal, samplePixel, 0);
+  let invalidMotion = packed.w >= 2.0;
+  return TemporalSample(
+    packed.xy,
+    decodeDepth(packed.z),
+    clamp(packed.w - select(0.0, 2.0, invalidMotion), 0.0, 1.0),
+    packed.z >= 0.0,
+    !invalidMotion,
+  );
+}
+
+fn depthReject(center : f32, sample : f32) -> bool {
+  return sample > center + max(0.01, center * 0.01);
+}
+
+fn distinctDirection(a : vec2<f32>, b : vec2<f32>) -> bool {
+  let aLength = length(a);
+  let bLength = length(b);
+  if (aLength <= 1e-5 || bLength <= 1e-5) { return false; }
+  // Keep only genuinely different directions. Opposite signs still carry
+  // separate source segments, while nearly parallel candidates do not spend
+  // the bounded second-direction slot.
+  return abs(dot(a / aLength, b / bLength)) < 0.94;
+}
+
+fn sourceVelocitySegmentCovers(
+  receiverPixel : vec2<i32>,
+  sourcePixel : vec2<i32>,
+  motionPixels : vec2<f32>,
+  radius : f32,
+) -> bool {
+  let delta = vec2<f32>(receiverPixel - sourcePixel);
+  let motionLength = length(motionPixels);
+  if (motionLength <= 1e-5 || radius <= 1e-5) { return false; }
+  let direction = motionPixels / motionLength;
+  let along = dot(delta, direction);
+  let perpendicular = abs(delta.x * direction.y - delta.y * direction.x);
+  // A source segment owns a one-pixel coverage tube. This is a bounded
+  // geometric test, not a radius-sized source scan, and lets a sparse mover
+  // cover a static receiver without accepting a far/orthogonal source.
+  return abs(along) <= radius + 0.75 && perpendicular <= 0.75;
+}
+
+fn symmetricOffset(index : u32, count : u32, motion : vec2<f32>) -> vec2<f32> {
+  let denominator = max(f32(count), 1.0);
+  return motion * (2.0 * (f32(index) + 0.5) / denominator - 1.0);
+}
+
+fn tileNeighborhoodOffset(index : u32) -> vec2<i32> {
+  let x = i32(index % TILE_NEIGHBORHOOD_SIDE) - MAX_TILE_REACH;
+  let y = i32(index / TILE_NEIGHBORHOOD_SIDE) - MAX_TILE_REACH;
+  return vec2<i32>(x, y);
+}
+
+fn tileOffsetWithinSupport(offset : vec2<i32>, tileReach : i32) -> bool {
+  if (offset.x == 0 && offset.y == 0) { return false; }
+  let boundedReach = min(max(tileReach, 1), MAX_TILE_REACH);
+  // The bounded lattice is a square around the receiver tile. The precise
+  // AABB/circle intersection below decides whether a diagonal tile really
+  // intersects the support; a circular pre-filter here would drop the
+  // (\xB12,\xB12) and boundary cases before that exact test can run.
+  return abs(offset.x) <= boundedReach && abs(offset.y) <= boundedReach;
+}
+
+fn tileIntersectsSupport(
+  receiverPixel : vec2<i32>,
+  candidateTile : vec2<i32>,
+  dimensions : vec2<i32>,
+  supportRadius : f32,
+) -> bool {
+  // Use the receiver-to-tile-AABB lower bound. This includes every tile whose
+  // contents can intersect the support, including signs and diagonals, while
+  // rejecting an outside-support tile before loading its summary.
+  let tileMin = vec2<f32>(candidateTile * 16);
+  let tileMax = min(tileMin + vec2<f32>(16.0), vec2<f32>(dimensions));
+  let receiver = vec2<f32>(receiverPixel) + vec2<f32>(0.5);
+  let dx = max(max(tileMin.x - receiver.x, 0.0), receiver.x - tileMax.x);
+  let dy = max(max(tileMin.y - receiver.y, 0.0), receiver.y - tileMax.y);
+  let distance = vec2<f32>(dx, dy);
+  return dot(distance, distance) <= supportRadius * supportRadius + 1.0;
+}
+
+fn tileIntersectsWorkgroupSupport(
+  workgroupBase : vec2<i32>,
+  candidateTile : vec2<i32>,
+  dimensions : vec2<i32>,
+  supportRadius : f32,
+) -> bool {
+  // A workgroup's 8x8 rectangle is the conservative receiver domain for one
+  // shared metadata walk. The AABB lower bound includes every pixel in that
+  // rectangle that can reach the candidate tile, including diagonal/sign
+  // variants, while rejecting a tile fully outside the support.
+  let tileMin = vec2<f32>(candidateTile * 16);
+  let tileMax = min(tileMin + vec2<f32>(16.0), vec2<f32>(dimensions));
+  let groupMin = vec2<f32>(workgroupBase) + vec2<f32>(0.5);
+  let groupMax = min(groupMin + vec2<f32>(8.0), vec2<f32>(dimensions));
+  let dx = max(max(tileMin.x - groupMax.x, 0.0), groupMin.x - tileMax.x);
+  let dy = max(max(tileMin.y - groupMax.y, 0.0), groupMin.y - tileMax.y);
+  let distance = vec2<f32>(dx, dy);
+  return dot(distance, distance) <= supportRadius * supportRadius + 1.0;
+}
+
+fn scanTileNeighbourhood(
+  workgroupBase : vec2<i32>,
+  dimensions : vec2<i32>,
+) {
+  let tiles = (vec2<u32>(dimensions) + vec2<u32>(15)) / vec2<u32>(16);
+  let tileCoordinate = workgroupBase / vec2<i32>(16);
+  let currentIndex = u32(tileCoordinate.y) * tiles.x + u32(tileCoordinate.x);
+  let current = tileSummary[currentIndex];
+  var primary = current.maxMotionAndLength.xy * vec2<f32>(dimensions) * params.exposureScale;
+  var primaryLength = length(primary);
+  var primaryAnchor = vec2<i32>(
+    i32(current.maxMotionAndLength.z),
+    i32(current.maxMotionAndLength.w),
+  );
+  var secondary = current.secondaryMotionAndDepth.xy * vec2<f32>(dimensions) * params.exposureScale;
+  var secondaryLength = length(secondary);
+  var secondaryAnchor = vec2<i32>(
+    i32(current.secondaryMotionAndDepth.z),
+    i32(current.secondaryMotionAndDepth.w),
+  );
+  let supportRadius = min(max(params.maxRadiusPixels, 1.0), 64.0);
+  let tileReach = min(MAX_TILE_REACH, max(1, i32(ceil(supportRadius / 16.0))));
+  for (var tileCandidateIndex = 0u; tileCandidateIndex < TILE_NEIGHBORHOOD_COUNT; tileCandidateIndex += 1u) {
+    let offset = tileNeighborhoodOffset(tileCandidateIndex);
+    if (!tileOffsetWithinSupport(offset, tileReach)) { continue; }
+    let candidateTile = tileCoordinate + offset;
+    if (
+      candidateTile.x < 0 ||
+      candidateTile.y < 0 ||
+      candidateTile.x >= i32(tiles.x) ||
+      candidateTile.y >= i32(tiles.y) ||
+      !tileIntersectsWorkgroupSupport(workgroupBase, candidateTile, dimensions, supportRadius)
+    ) { continue; }
+    let candidate = tileSummary[u32(candidateTile.y) * tiles.x + u32(candidateTile.x)];
+    let candidatePrimary = candidate.maxMotionAndLength.xy * vec2<f32>(dimensions) * params.exposureScale;
+    let candidatePrimaryLength = length(candidatePrimary);
+    let candidatePrimaryAnchor = vec2<i32>(
+      i32(candidate.maxMotionAndLength.z),
+      i32(candidate.maxMotionAndLength.w),
+    );
+    if (candidatePrimaryLength > primaryLength) {
+      let previousPrimary = primary;
+      let previousLength = primaryLength;
+      let previousAnchor = primaryAnchor;
+      primary = candidatePrimary;
+      primaryLength = candidatePrimaryLength;
+      primaryAnchor = candidatePrimaryAnchor;
+      if (previousLength > 1e-5 && distinctDirection(primary, previousPrimary) && previousLength > secondaryLength) {
+        secondary = previousPrimary;
+        secondaryLength = previousLength;
+        secondaryAnchor = previousAnchor;
+      }
+    } else if (
+      candidatePrimaryLength > secondaryLength &&
+      distinctDirection(primary, candidatePrimary)
+    ) {
+      secondary = candidatePrimary;
+      secondaryLength = candidatePrimaryLength;
+      secondaryAnchor = candidatePrimaryAnchor;
+    }
+    let candidateSecondary = candidate.secondaryMotionAndDepth.xy * vec2<f32>(dimensions) * params.exposureScale;
+    let candidateSecondaryLength = length(candidateSecondary);
+    let candidateSecondaryAnchor = vec2<i32>(
+      i32(candidate.secondaryMotionAndDepth.z),
+      i32(candidate.secondaryMotionAndDepth.w),
+    );
+    if (candidateSecondaryLength > secondaryLength && distinctDirection(primary, candidateSecondary)) {
+      secondary = candidateSecondary;
+      secondaryLength = candidateSecondaryLength;
+      secondaryAnchor = candidateSecondaryAnchor;
+    }
+  }
+  neighbourhoodPrimaryMotion = primary;
+  neighbourhoodPrimaryLength = primaryLength;
+  neighbourhoodPrimaryAnchor = primaryAnchor;
+  neighbourhoodSecondaryMotion = secondary;
+  neighbourhoodSecondaryLength = secondaryLength;
+  neighbourhoodSecondaryAnchor = secondaryAnchor;
+}
+
+fn validMotionParameters() -> bool {
+  return
+    finite(params.frameDeltaSeconds) &&
+    params.frameDeltaSeconds > 0.0 &&
+    params.frameDeltaSeconds <= 0.1 &&
+    finite(params.exposureScale) &&
+    params.exposureScale > 0.0 &&
+    finite(params.targetFps) &&
+    params.targetFps >= 0.0 &&
+    params.targetFps <= 240.0 &&
+    params.targetFps == floor(params.targetFps) &&
+    params.sampleCount >= 4u &&
+    params.maxRadiusPixels > 0.0 &&
+    finite(params.maxRadiusPixels) &&
+    params.shutterAngle > 0.0;
+}
+
+fn sourceMotionPixels(sample : TemporalSample, dimensions : vec2<i32>) -> vec2<f32> {
+  return sample.motion * vec2<f32>(dimensions) * params.exposureScale;
+}
+
+fn sourceRadius(motionPixels : vec2<f32>, shutter : f32) -> f32 {
+  return min(length(motionPixels) * shutter * 0.5, params.maxRadiusPixels);
+}
+
+fn resolveMotionBlurSupport(
+  pixel : vec2<i32>,
+  dimensions : vec2<i32>,
+) -> MotionBlurSupport {
+  var empty = MotionBlurSupport(
+    vec2<f32>(0.0),
+    vec2<f32>(0.0),
+    vec2<i32>(0),
+    vec2<i32>(0),
+    0.0,
+    0.0,
+    false,
+    false,
+  );
+  if (!pixelInBounds(pixel, dimensions) || !validMotionParameters() || params.reset != 0u) {
+    return empty;
+  }
+  let center = temporalAt(pixel, dimensions);
+  if (!center.validDepth || !center.motionValid) { return empty; }
+  let shutter = clamp(params.shutterAngle / 360.0, 0.0, 1.0);
+  let centerMotion = sourceMotionPixels(center, dimensions);
+  let centerLength = length(centerMotion);
+  var primaryMotion = centerMotion;
+  var primaryLength = centerLength;
+  var primaryAnchor = pixel;
+  var secondaryMotion = neighbourhoodSecondaryMotion;
+  var secondaryLength = neighbourhoodSecondaryLength;
+  var secondaryAnchor = neighbourhoodSecondaryAnchor;
+  if (neighbourhoodPrimaryLength > primaryLength) {
+    if (distinctDirection(primaryMotion, neighbourhoodPrimaryMotion)) {
+      secondaryMotion = primaryMotion;
+      secondaryLength = primaryLength;
+      secondaryAnchor = pixel;
+    }
+    primaryMotion = neighbourhoodPrimaryMotion;
+    primaryLength = neighbourhoodPrimaryLength;
+    primaryAnchor = neighbourhoodPrimaryAnchor;
+  } else if (
+    neighbourhoodPrimaryLength > secondaryLength &&
+    distinctDirection(primaryMotion, neighbourhoodPrimaryMotion)
+  ) {
+    secondaryMotion = neighbourhoodPrimaryMotion;
+    secondaryLength = neighbourhoodPrimaryLength;
+    secondaryAnchor = neighbourhoodPrimaryAnchor;
+  }
+  if (
+    secondaryLength <= 1e-5 ||
+    !distinctDirection(primaryMotion, secondaryMotion)
+  ) {
+    secondaryMotion = vec2<f32>(0.0);
+    secondaryLength = 0.0;
+  }
+  empty.primaryMotion = primaryMotion;
+  empty.secondaryMotion = secondaryMotion;
+  empty.primaryAnchor = primaryAnchor;
+  empty.secondaryAnchor = secondaryAnchor;
+  empty.primaryRadius = sourceRadius(primaryMotion, shutter);
+  empty.secondaryRadius = sourceRadius(secondaryMotion, shutter);
+  empty.valid = empty.primaryRadius > 1e-5 || empty.secondaryRadius > 1e-5;
+  empty.longVector = max(empty.primaryRadius, empty.secondaryRadius) > 8.0;
+  return empty;
+}
+
+fn sourceAnchorForReceiver(
+  receiverPixel : vec2<i32>,
+  anchor : vec2<i32>,
+  motion : vec2<f32>,
+  dimensions : vec2<i32>,
+) -> vec2<i32> {
+  // A tile summary has one source anchor, while a horizontal source may span
+  // the tile's perpendicular axis. Project that anchor onto the receiver's
+  // motion line before the midpoint read. The following source footprint
+  // validates the projected pixel, so a thin or off-axis source cannot be
+  // invented by the projection.
+  let motionLength = length(motion);
+  if (motionLength <= 1e-5) { return anchor; }
+  let direction = motion / motionLength;
+  let delta = vec2<f32>(receiverPixel - anchor);
+  let perpendicular = delta - direction * dot(delta, direction);
+  let projected = vec2<f32>(anchor) + perpendicular;
+  let candidate = vec2<i32>(floor(projected + vec2<f32>(0.5)));
+  return clamp(candidate, vec2<i32>(0), dimensions - vec2<i32>(1));
+}
+
+fn supportTap(
+  receiverPixel : vec2<i32>,
+  index : u32,
+  count : u32,
+  motion : vec2<f32>,
+  radius : f32,
+  anchor : vec2<i32>,
+  dimensions : vec2<i32>,
+) -> MotionBlurTap {
+  // Preserve the geometric midpoint as the primary sample. The source anchor
+  // is a recovery coordinate for a sparse tile summary, not a replacement for
+  // the receiver's authored support. It is tried only when this midpoint has
+  // no valid source, and therefore never adds a color read or a tap.
+  var fallbackPixel = vec2<i32>(0);
+  var fallbackValid = false;
+  if (index == count / 2u) {
+    fallbackPixel = sourceAnchorForReceiver(receiverPixel, anchor, motion, dimensions);
+    fallbackValid = pixelInBounds(fallbackPixel, dimensions);
+  }
+  let direction = motion / max(length(motion), 1e-5);
+  let offset = symmetricOffset(index, count, direction * radius);
+  let dimensionsF = vec2<f32>(dimensions);
+  let uv = (vec2<f32>(receiverPixel) + vec2<f32>(0.5) + offset) / dimensionsF;
+  if (uv.x < 0.0 || uv.y < 0.0 || uv.x >= 1.0 || uv.y >= 1.0) {
+    return MotionBlurTap(vec2<i32>(0), fallbackPixel, false, fallbackValid);
+  }
+  let candidate = vec2<i32>(floor(uv * dimensionsF));
+  return MotionBlurTap(candidate, fallbackPixel, pixelInBounds(candidate, dimensions), fallbackValid);
+}
+
+fn sourceAt(
+  receiverPixel : vec2<i32>,
+  sourcePixel : vec2<i32>,
+  centerDepth : f32,
+  shutter : f32,
+  dimensions : vec2<i32>,
+) -> MotionBlurSource {
+  let empty = MotionBlurSource(
+    vec2<i32>(0),
+    vec2<f32>(0.0),
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0u,
+    false,
+  );
+  if (!pixelInBounds(sourcePixel, dimensions)) { return empty; }
+  let source = temporalAt(sourcePixel, dimensions);
+  if (!source.validDepth || !source.motionValid || depthReject(centerDepth, source.depth)) {
+    return empty;
+  }
+  let motionPixels = sourceMotionPixels(source, dimensions);
+  let radius = sourceRadius(motionPixels, shutter);
+  if (!sourceVelocitySegmentCovers(receiverPixel, sourcePixel, motionPixels, radius)) {
+    return empty;
+  }
+  return MotionBlurSource(
+    sourcePixel,
+    motionPixels,
+    source.depth,
+    radius,
+    1.0,
+    1.0,
+    1.0,
+    1.0,
+    0u,
+    true,
+  );
+}
+
+// A half-resolution owner represents a complete 2x2 receiving footprint. The
+// source motion test is evaluated against every receiving pixel in that
+// footprint, so odd/even rows and columns remain visible without a second
+// filter pass or an unbounded neighbourhood walk.
+fn sourceAtFootprint(
+  receiverPixel : vec2<i32>,
+  sourcePixel : vec2<i32>,
+  centerDepth : f32,
+  shutter : f32,
+  dimensions : vec2<i32>,
+) -> MotionBlurSource {
+  var selected = MotionBlurSource(
+    vec2<i32>(0),
+    vec2<f32>(0.0),
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0u,
+    false,
+  );
+  var selectedDepth = 3.402823e+38;
+  var coverage0 = 0.0;
+  var coverage1 = 0.0;
+  var coverage2 = 0.0;
+  var coverage3 = 0.0;
+  var selectedReceiverMask = 0u;
+  for (var y = 0u; y < 2u; y += 1u) {
+    for (var x = 0u; x < 2u; x += 1u) {
+      let candidatePixel = sourcePixel + vec2<i32>(i32(x), i32(y));
+      if (!pixelInBounds(candidatePixel, dimensions)) { continue; }
+      let temporal = temporalAt(candidatePixel, dimensions);
+      if (!temporal.validDepth || !temporal.motionValid || depthReject(centerDepth, temporal.depth)) {
+        continue;
+      }
+      let motionPixels = sourceMotionPixels(temporal, dimensions);
+      let radius = sourceRadius(motionPixels, shutter);
+      var receiverMask = 0u;
+      // A source half-cell and a receiver half-cell share the same integer
+      // displacement. This one-to-one correspondence keeps a diagonal source
+      // from being counted for all four receiver quadrants just because its
+      // tube crosses the quadrant. The segment test still supplies the motion
+      // support and depth/validity checks remain source-owned.
+      let receiver = receiverPixel + vec2<i32>(i32(x), i32(y));
+      if (
+        pixelInBounds(receiver, dimensions) &&
+        sourceVelocitySegmentCovers(receiver, candidatePixel, motionPixels, radius)
+      ) {
+        receiverMask = receiverMask | (1u << (y * 2u + x));
+      }
+      if (receiverMask == 0u) { continue; }
+      if (!selected.valid || temporal.depth < selectedDepth) {
+        selected = MotionBlurSource(
+          candidatePixel,
+          motionPixels,
+          temporal.depth,
+          radius,
+          0.0,
+          0.0,
+          0.0,
+          0.0,
+          receiverMask,
+          true,
+        );
+        selectedDepth = temporal.depth;
+        coverage0 = 0.0;
+        coverage1 = 0.0;
+        coverage2 = 0.0;
+        coverage3 = 0.0;
+        selectedReceiverMask = receiverMask;
+      }
+      if (abs(temporal.depth - selectedDepth) <= 1e-4) {
+        // The common integer displacement above gives each source cell one
+        // receiver quadrant. The matching footprint therefore contributes its
+        // full unit overlap to that one owner.
+        if ((receiverMask & 1u) != 0u) { coverage0 += 1.0; }
+        if ((receiverMask & 2u) != 0u) { coverage1 += 1.0; }
+        if ((receiverMask & 4u) != 0u) { coverage2 += 1.0; }
+        if ((receiverMask & 8u) != 0u) { coverage3 += 1.0; }
+        selectedReceiverMask = selectedReceiverMask | receiverMask;
+      }
+    }
+  }
+  if (selected.valid) {
+    // The owner samples a 2x2 source footprint but pays for one color read.
+    // Each receiving quadrant keeps the fraction of that footprint that is
+    // covered at the selected depth. This preserves energy at boundaries and
+    // carries a one-pixel odd-row feature into its real row only.
+    selected.coverage0 = min(coverage0, 1.0) * select(0.0, 1.0, (selectedReceiverMask & 1u) != 0u);
+    selected.coverage1 = min(coverage1, 1.0) * select(0.0, 1.0, (selectedReceiverMask & 2u) != 0u);
+    selected.coverage2 = min(coverage2, 1.0) * select(0.0, 1.0, (selectedReceiverMask & 4u) != 0u);
+    selected.coverage3 = min(coverage3, 1.0) * select(0.0, 1.0, (selectedReceiverMask & 8u) != 0u);
+    selected.receiverMask = selectedReceiverMask;
+  }
+  return selected;
+}
+
+fn midpointTileOwnership(
+  receiverPixel : vec2<i32>,
+  source : MotionBlurSource,
+) -> f32 {
+  // A recovered tile anchor represents one two-pixel source footprint. The
+  // footprint is split across the finite, geometrically derived tile bands of
+  // the support segment. One half-cell owner per band claims the represented
+  // midpoint slot, rather than painting every receiver in the interval.
+  let sourcePixel = source.pixel;
+  let motionLength = length(source.motion);
+  if (motionLength <= 1e-5 || source.radius <= 1e-5) { return 0.0; }
+  let receiverTile = receiverPixel / vec2<i32>(16);
+  let sourceTile = sourcePixel / vec2<i32>(16);
+  let tileDelta = vec2<f32>(sourceTile - receiverTile);
+  let direction = source.motion / motionLength;
+  let along = abs(dot(tileDelta, direction));
+  let perpendicular = abs(tileDelta.x * direction.y - tileDelta.y * direction.x);
+  let tileReach = min(4, max(1, i32(ceil(source.radius / 16.0))));
+  if (along < 1.0 || ceil(along) > f32(tileReach) || perpendicular > 1.0) { return 0.0; }
+  let groupBase = (receiverPixel / vec2<i32>(8)) * vec2<i32>(8);
+  let local = receiverPixel - groupBase;
+  let ownerX = select(
+    clamp(((sourcePixel.x - groupBase.x) / 2) * 2, 0, 6),
+    select(0, 6, sourcePixel.x > receiverPixel.x),
+    sourcePixel.x != receiverPixel.x,
+  );
+  let ownerY = select(
+    clamp(((sourcePixel.y - groupBase.y) / 2) * 2, 0, 6),
+    select(0, 6, sourcePixel.y > receiverPixel.y),
+    sourcePixel.y != receiverPixel.y,
+  );
+  if (local.x != ownerX || local.y != ownerY) { return 0.0; }
+  let sourceFootprintLength = 2.0;
+  let supportLength = max(2.0 * source.radius, sourceFootprintLength);
+  // Divide the finite footprint ownership over every reachable tile band.
+  // This keeps the total recovery mass bounded when the support grows from
+  // 32 to 64 pixels while retaining a nonzero owner at any in-view band.
+  return min(1.0, sourceFootprintLength / (supportLength * f32(tileReach)));
+}
+
+fn integrateLongColor(
+  filtered : vec4<f32>,
+  validCount : f32,
+  hasAcceptedSource : bool,
+  uncovered : f32,
+  count : u32,
+  supportCount : u32,
+  centerColor : vec4<f32>,
+  centerMoving : bool,
+) -> vec4<f32> {
+  // Uncovered ownership is decremented at the same time as validCount is incremented
+  // for both geometric and midpoint-recovered samples. Keep the derived cap
+  // as a guard against floating point accumulation and make the ownership
+  // transfer explicit instead of adding an independent brightness term.
+  let conservedUncovered = min(
+    max(uncovered, 0.0),
+    max(f32(supportCount) - validCount, 0.0),
+  );
+  // A moving receiver can be partially covered at a silhouette edge. Use the
+  // accepted foreground only for the receiver's missing current coverage; a
+  // fully covered receiver keeps the original center contribution and the
+  // Dawn energy contract remains unchanged for uniform opaque surfaces.
+  let acceptedColor = select(
+    vec3<f32>(0.0),
+    filtered.rgb / max(validCount, 1.0),
+    hasAcceptedSource && validCount > 0.0,
+  );
+  // Preserve the color target's authored alpha as the output floor. It is
+  // separate from the RGB test below, which identifies an empty background
+  // receiver without treating alpha as a scene-coverage attachment.
+  let missingForeground = 1.0 - clamp(centerColor.a, 0.0, 1.0);
+  let edgeCoverage = select(missingForeground, 1.0, centerMoving);
+  let edgeFill = acceptedColor * edgeCoverage * EDGE_FILL_FACTOR;
+  let movingFallback = select(centerColor.rgb, edgeFill, hasAcceptedSource && validCount > 0.0);
+  let background = select(vec3<f32>(0.0), movingFallback, centerMoving);
+  // The accepted colour can come from a transparent receiver's moving
+  // foreground. Carry the same bounded support coverage into alpha so that
+  // RGB written outside the current silhouette is not composited as black.
+  // Preserve the receiver's authored coverage as a floor: blur must not make
+  // an already visible pixel disappear.
+  let acceptedAlpha = select(
+    0.0,
+    filtered.a / max(validCount, 1.0),
+    validCount > 0.0,
+  );
+  let acceptedCoverage = validCount + missingForeground * conservedUncovered;
+  let reconstructedAlpha = acceptedAlpha * acceptedCoverage / max(f32(count), 1.0);
+  let outputAlpha = clamp(max(centerColor.a, reconstructedAlpha), 0.0, 1.0);
+  let emptyReceiver =
+    !centerMoving &&
+    hasAcceptedSource &&
+    max(max(abs(centerColor.r), abs(centerColor.g)), abs(centerColor.b)) < 1e-4;
+  let sourceScale = select(1.0, 1.0 - EDGE_FILL_FACTOR, emptyReceiver);
+  let sourceContribution = filtered.rgb * sourceScale;
+  let trailScale = select(1.0, 1.0 - EDGE_FILL_FACTOR, emptyReceiver);
+  let trailContribution = background * conservedUncovered * trailScale;
+  return vec4<f32>(
+    (sourceContribution + centerColor.rgb + trailContribution) / max(f32(count), 1.0),
+    outputAlpha,
+  );
+}
+
+fn longSupportFilter(
+  receiverPixel : vec2<i32>,
+  support : MotionBlurSupport,
+  centerDepth : f32,
+  dimensions : vec2<i32>,
+) -> MotionBlurFilter {
+  var empty = MotionBlurFilter(
+    vec4<f32>(0.0),
+    vec4<f32>(0.0),
+    vec4<f32>(0.0),
+    vec4<f32>(0.0),
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    receiverPixel,
+    vec2<f32>(0.0),
+    0.0,
+    0u,
+    0u,
+    false,
+  );
+  if (!support.valid) { return empty; }
+  let count = min(params.sampleCount, 16u);
+  // The authored tier is the total source colour-read budget. Reserve one slot
+  // for the receiver/background contribution; the remaining bounded taps
+  // (at most 15) are split between the two source directions when needed.
+  let supportCount = max(count - 1u, 1u);
+  let useSecondDirection = support.secondaryRadius > 1e-5 && distinctDirection(support.primaryMotion, support.secondaryMotion);
+  let primaryCount = select(supportCount, max(supportCount / 2u, 1u), useSecondDirection);
+  let secondaryCount = max(supportCount - primaryCount, 1u);
+  let shutter = clamp(params.shutterAngle / 360.0, 0.0, 1.0);
+  let center = temporalAt(receiverPixel, dimensions);
+  // Keep each receiving quadrant's own center color. Reusing the owner
+  // pixel for all four quadrants causes a one-pixel parity shift to duplicate
+  // a bright source (or erase a bright receiver) in the half-resolution cache.
+  var centerColor0 = colorAt(receiverPixel, dimensions);
+  var centerColor1 = colorAt(receiverPixel + vec2<i32>(1, 0), dimensions);
+  var centerColor2 = colorAt(receiverPixel + vec2<i32>(0, 1), dimensions);
+  var centerColor3 = colorAt(receiverPixel + vec2<i32>(1, 1), dimensions);
+  var filtered0 = vec4<f32>(0.0);
+  var filtered1 = vec4<f32>(0.0);
+  var filtered2 = vec4<f32>(0.0);
+  var filtered3 = vec4<f32>(0.0);
+  var validCount0 = 0.0;
+  var validCount1 = 0.0;
+  var validCount2 = 0.0;
+  var validCount3 = 0.0;
+  var hasAcceptedSource0 = false;
+  var hasAcceptedSource1 = false;
+  var hasAcceptedSource2 = false;
+  var hasAcceptedSource3 = false;
+  var uncovered0 = f32(supportCount);
+  var uncovered1 = f32(supportCount);
+  var uncovered2 = f32(supportCount);
+  var uncovered3 = f32(supportCount);
+  var midpointFallbackPixel = vec2<i32>(0);
+  var midpointFallbackValid = false;
+  var midpointFallbackRadius = 0.0;
+  var nearestDepth0 = 3.402823e+38;
+  var nearestDepth1 = 3.402823e+38;
+  var nearestDepth2 = 3.402823e+38;
+  var nearestDepth3 = 3.402823e+38;
+  for (var index = 0u; index < 16u; index += 1u) {
+    if (index >= supportCount) { break; }
+    let secondDirection = useSecondDirection && index >= primaryCount;
+    let localIndex = select(index, index - primaryCount, secondDirection);
+    let localCount = select(primaryCount, secondaryCount, secondDirection);
+    let selectedMotion = select(support.primaryMotion, support.secondaryMotion, secondDirection);
+    let selectedRadius = select(support.primaryRadius, support.secondaryRadius, secondDirection);
+    let tap = supportTap(
+      receiverPixel,
+      localIndex,
+      localCount,
+      selectedMotion,
+      selectedRadius,
+      select(support.primaryAnchor, support.secondaryAnchor, secondDirection),
+      dimensions,
+    );
+    if (!tap.valid) {
+      if (tap.fallbackValid && selectedRadius > midpointFallbackRadius) {
+        midpointFallbackPixel = tap.fallbackPixel;
+        midpointFallbackValid = true;
+        midpointFallbackRadius = selectedRadius;
+      }
+      continue;
+    }
+    let source = sourceAtFootprint(
+      receiverPixel,
+      tap.pixel,
+      centerDepth,
+      shutter,
+      dimensions,
+    );
+    if (!source.valid) {
+      if (tap.fallbackValid && selectedRadius > midpointFallbackRadius) {
+        midpointFallbackPixel = tap.fallbackPixel;
+        midpointFallbackValid = true;
+        midpointFallbackRadius = selectedRadius;
+      }
+      continue;
+    }
+    let sampleColor = colorAt(source.pixel, dimensions);
+    // Keep the receiver's own color as the center contribution. A source
+    // footprint may cover an adjacent receiver quadrant without being the
+    // receiver itself; substituting its color here creates odd/even-alignment
+    // brightening at thin-object boundaries.
+    if ((source.receiverMask & 1u) != 0u) {
+      filtered0 += sampleColor * source.coverage0;
+      validCount0 += source.coverage0;
+      hasAcceptedSource0 = true;
+      uncovered0 = max(uncovered0 - source.coverage0, 0.0);
+      nearestDepth0 = min(nearestDepth0, source.depth);
+    }
+    if ((source.receiverMask & 2u) != 0u) {
+      filtered1 += sampleColor * source.coverage1;
+      validCount1 += source.coverage1;
+      hasAcceptedSource1 = true;
+      uncovered1 = max(uncovered1 - source.coverage1, 0.0);
+      nearestDepth1 = min(nearestDepth1, source.depth);
+    }
+    if ((source.receiverMask & 4u) != 0u) {
+      filtered2 += sampleColor * source.coverage2;
+      validCount2 += source.coverage2;
+      hasAcceptedSource2 = true;
+      uncovered2 = max(uncovered2 - source.coverage2, 0.0);
+      nearestDepth2 = min(nearestDepth2, source.depth);
+    }
+    if ((source.receiverMask & 8u) != 0u) {
+      filtered3 += sampleColor * source.coverage3;
+      validCount3 += source.coverage3;
+      hasAcceptedSource3 = true;
+      uncovered3 = max(uncovered3 - source.coverage3, 0.0);
+      nearestDepth3 = min(nearestDepth3, source.depth);
+    }
+  }
+  // A tile anchor recovers a sparse source only for the widest support tier,
+  // where the fixed geometric lattice can leave a source between taps. It
+  // spends the represented midpoint ownership of the finite support segment;
+  // every accepted colour, coverage and depth contribution uses that same
+  // bounded ownership, so the fallback cannot create an opaque stripe. The
+  // shorter tiers keep their exact geometric energy and do not need recovery.
+  if (midpointFallbackValid && max(support.primaryRadius, support.secondaryRadius) > 32.0) {
+    let fallbackSource = sourceAtFootprint(
+      receiverPixel,
+      midpointFallbackPixel,
+      centerDepth,
+      shutter,
+      dimensions,
+    );
+    if (fallbackSource.valid) {
+      let midpointWeight = midpointTileOwnership(receiverPixel, fallbackSource);
+      if (
+        midpointWeight > 0.0
+      ) {
+        let fallbackColor = colorAt(fallbackSource.pixel, dimensions);
+        let fallbackWeight0 = fallbackSource.coverage0 * midpointWeight;
+        let fallbackWeight1 = fallbackSource.coverage1 * midpointWeight;
+        let fallbackWeight2 = fallbackSource.coverage2 * midpointWeight;
+        let fallbackWeight3 = fallbackSource.coverage3 * midpointWeight;
+        if (validCount0 <= 0.0 && (fallbackSource.receiverMask & 1u) != 0u) {
+          let ownedWeight0 = min(fallbackWeight0, uncovered0);
+          if (ownedWeight0 > 0.0) {
+            filtered0 += fallbackColor * ownedWeight0;
+            validCount0 += ownedWeight0;
+            hasAcceptedSource0 = true;
+            uncovered0 = max(uncovered0 - ownedWeight0, 0.0);
+            nearestDepth0 = min(nearestDepth0, fallbackSource.depth);
+          }
+        }
+        if (validCount1 <= 0.0 && (fallbackSource.receiverMask & 2u) != 0u) {
+          let ownedWeight1 = min(fallbackWeight1, uncovered1);
+          if (ownedWeight1 > 0.0) {
+            filtered1 += fallbackColor * ownedWeight1;
+            validCount1 += ownedWeight1;
+            hasAcceptedSource1 = true;
+            uncovered1 = max(uncovered1 - ownedWeight1, 0.0);
+            nearestDepth1 = min(nearestDepth1, fallbackSource.depth);
+          }
+        }
+        if (validCount2 <= 0.0 && (fallbackSource.receiverMask & 4u) != 0u) {
+          let ownedWeight2 = min(fallbackWeight2, uncovered2);
+          if (ownedWeight2 > 0.0) {
+            filtered2 += fallbackColor * ownedWeight2;
+            validCount2 += ownedWeight2;
+            hasAcceptedSource2 = true;
+            uncovered2 = max(uncovered2 - ownedWeight2, 0.0);
+            nearestDepth2 = min(nearestDepth2, fallbackSource.depth);
+          }
+        }
+        if (validCount3 <= 0.0 && (fallbackSource.receiverMask & 8u) != 0u) {
+          let ownedWeight3 = min(fallbackWeight3, uncovered3);
+          if (ownedWeight3 > 0.0) {
+            filtered3 += fallbackColor * ownedWeight3;
+            validCount3 += ownedWeight3;
+            hasAcceptedSource3 = true;
+            uncovered3 = max(uncovered3 - ownedWeight3, 0.0);
+            nearestDepth3 = min(nearestDepth3, fallbackSource.depth);
+          }
+        }
+      }
+    }
+  }
+  let moving0 = temporalAt(receiverPixel, dimensions);
+  let moving1 = temporalAt(receiverPixel + vec2<i32>(1, 0), dimensions);
+  let moving2 = temporalAt(receiverPixel + vec2<i32>(0, 1), dimensions);
+  let moving3 = temporalAt(receiverPixel + vec2<i32>(1, 1), dimensions);
+  let motion0 = sourceMotionPixels(moving0, dimensions);
+  let motion1 = sourceMotionPixels(moving1, dimensions);
+  let motion2 = sourceMotionPixels(moving2, dimensions);
+  let motion3 = sourceMotionPixels(moving3, dimensions);
+  let centerMoving0 = moving0.validDepth && moving0.motionValid && sourceRadius(motion0, shutter) > 1e-5;
+  let centerMoving1 = moving1.validDepth && moving1.motionValid && sourceRadius(motion1, shutter) > 1e-5;
+  let centerMoving2 = moving2.validDepth && moving2.motionValid && sourceRadius(motion2, shutter) > 1e-5;
+  let centerMoving3 = moving3.validDepth && moving3.motionValid && sourceRadius(motion3, shutter) > 1e-5;
+  empty.color0 = integrateLongColor(filtered0, validCount0, hasAcceptedSource0, uncovered0, count, supportCount, centerColor0, centerMoving0);
+  empty.color1 = integrateLongColor(filtered1, validCount1, hasAcceptedSource1, uncovered1, count, supportCount, centerColor1, centerMoving1);
+  empty.color2 = integrateLongColor(filtered2, validCount2, hasAcceptedSource2, uncovered2, count, supportCount, centerColor2, centerMoving2);
+  empty.color3 = integrateLongColor(filtered3, validCount3, hasAcceptedSource3, uncovered3, count, supportCount, centerColor3, centerMoving3);
+  empty.depth0 = select(centerDepth, nearestDepth0, validCount0 > 0.0);
+  empty.depth1 = select(centerDepth, nearestDepth1, validCount1 > 0.0);
+  empty.depth2 = select(centerDepth, nearestDepth2, validCount2 > 0.0);
+  empty.depth3 = select(centerDepth, nearestDepth3, validCount3 > 0.0);
+  empty.coverage0 = validCount0 / max(f32(supportCount), 1.0);
+  empty.coverage1 = validCount1 / max(f32(supportCount), 1.0);
+  empty.coverage2 = validCount2 / max(f32(supportCount), 1.0);
+  empty.coverage3 = validCount3 / max(f32(supportCount), 1.0);
+  empty.motion = select(support.primaryMotion, support.secondaryMotion, support.primaryRadius <= 1e-5);
+  empty.radius = max(support.primaryRadius, support.secondaryRadius);
+  empty.receiverMask =
+    select(0u, 1u, validCount0 > 0.0 || centerMoving0) |
+    select(0u, 2u, validCount1 > 0.0 || centerMoving1) |
+    select(0u, 4u, validCount2 > 0.0 || centerMoving2) |
+    select(0u, 8u, validCount3 > 0.0 || centerMoving3);
+  empty.validMask =
+    select(0u, 1u, validCount0 > 0.0 || centerMoving0) |
+    select(0u, 2u, validCount1 > 0.0 || centerMoving1) |
+    select(0u, 4u, validCount2 > 0.0 || centerMoving2) |
+    select(0u, 8u, validCount3 > 0.0 || centerMoving3);
+  empty.valid = empty.validMask != 0u;
+  return empty;
+}
+
+fn colorAt(pixel : vec2<i32>, dimensions : vec2<i32>) -> vec4<f32> {
+  return textureLoad(currentColor, clamp(pixel, vec2<i32>(0), dimensions - vec2<i32>(1)), 0);
+}
+
+fn cacheFootprintContains(receiverPixel : vec2<i32>, ownerPixel : vec2<i32>) -> bool {
+  return
+    receiverPixel.x >= ownerPixel.x && receiverPixel.x <= ownerPixel.x + 1 &&
+    receiverPixel.y >= ownerPixel.y && receiverPixel.y <= ownerPixel.y + 1;
+}
+
+fn cachedSupportCovers(
+  receiverPixel : vec2<i32>,
+  ownerPixel : vec2<i32>,
+  motion : vec2<f32>,
+  radius : f32,
+) -> bool {
+  if (!cacheFootprintContains(receiverPixel, ownerPixel)) { return false; }
+  let motionLength = length(motion);
+  if (motionLength <= 1e-5 || radius <= 1e-5) { return false; }
+  let direction = motion / motionLength;
+  let delta = vec2<f32>(receiverPixel - ownerPixel);
+  let along = dot(delta, direction);
+  let perpendicular = abs(delta.x * direction.y - delta.y * direction.x);
+  return abs(along) <= radius + 1.0 && perpendicular <= 1.0;
+}
+
+fn cachedDirectionMatches(support : MotionBlurSupport, motion : vec2<f32>) -> bool {
+  let motionLength = length(motion);
+  if (motionLength <= 1e-5) { return false; }
+  let direction = motion / motionLength;
+  if (support.primaryRadius > 1e-5 && abs(dot(normalize(support.primaryMotion), direction)) >= 0.94) {
+    return true;
+  }
+  return support.secondaryRadius > 1e-5 && abs(dot(normalize(support.secondaryMotion), direction)) >= 0.94;
+}
+
+fn depthGuidedHalfResolutionColor(
+  localId : vec3<u32>,
+  receiverPixel : vec2<i32>,
+  support : MotionBlurSupport,
+  centerDepth : f32,
+) -> MotionBlurCacheSample {
+  let cell = vec2<i32>(localId.xy / vec2<u32>(2));
+  let quadrant = (localId.y % 2u) * 2u + (localId.x % 2u);
+  var selected = MotionBlurCacheSample(vec4<f32>(0.0), 0.0, false);
+  var selectedDelta = 3.402823e+38;
+  // Search the bounded adjacent cache cells, but accept only a cell whose
+  // authored 2x2 footprint and direction actually cover this receiver.
+  for (var y = -1; y <= 1; y += 1) {
+    for (var x = -1; x <= 1; x += 1) {
+      let candidateCell = cell + vec2<i32>(x, y);
+      if (candidateCell.x < 0 || candidateCell.y < 0 || candidateCell.x >= 4 || candidateCell.y >= 4) { continue; }
+      let cacheCellIndex = u32(candidateCell.y * 4 + candidateCell.x);
+      let index = cacheCellIndex * 4u + quadrant;
+      if (
+        halfFilteredValid[index] == 0u ||
+        depthReject(centerDepth, halfFilteredDepth[index]) ||
+        !cachedDirectionMatches(support, halfFilteredMotion[cacheCellIndex]) ||
+        !cachedSupportCovers(
+          receiverPixel,
+          halfFilteredReceiver[cacheCellIndex],
+          halfFilteredMotion[cacheCellIndex],
+          halfFilteredRadius[cacheCellIndex],
+        )
+      ) { continue; }
+      let delta = abs(halfFilteredDepth[index] - centerDepth);
+      if (!selected.valid || delta < selectedDelta) {
+        selected.color = halfFilteredColor[index];
+        selected.coverage = halfFilteredCoverage[index];
+        selectedDelta = delta;
+        selected.valid = true;
+      }
+    }
+  }
+  return selected;
+}
+
+@compute @workgroup_size(8, 8)
+fn tile_summary(
+  @builtin(global_invocation_id) id : vec3<u32>,
+  @builtin(local_invocation_id) localId : vec3<u32>,
+  @builtin(local_invocation_index) localIndex : u32,
+  @builtin(workgroup_id) workgroupId : vec3<u32>,
+) {
+  let dimensions = textureDimensions(sceneTemporal);
+  let tiles = (dimensions + vec2<u32>(15)) / vec2<u32>(16);
+  let tile = workgroupId.xy;
+  let inTile = tile.x < tiles.x && tile.y < tiles.y;
+  var maxMotion = vec2<f32>(0.0);
+  var maxLength = 0.0;
+  var maxSource = vec2<i32>(0);
+  var secondaryMotion = vec2<f32>(0.0);
+  var secondaryLength = 0.0;
+  var secondarySource = vec2<i32>(0);
+  for (var localY = 0u; localY < 2u; localY += 1u) {
+    for (var localX = 0u; localX < 2u; localX += 1u) {
+      let pixel = tile * vec2<u32>(16) + localId.xy * vec2<u32>(2) + vec2<u32>(localX, localY);
+      if (!inTile || pixel.x >= dimensions.x || pixel.y >= dimensions.y) { continue; }
+      let sample = temporalAt(vec2<i32>(pixel), vec2<i32>(dimensions));
+      if (!sample.validDepth || !sample.motionValid) { continue; }
+      let motionLength = length(sample.motion * vec2<f32>(dimensions));
+      if (motionLength > maxLength) {
+        if (distinctDirection(maxMotion, sample.motion)) {
+          secondaryMotion = maxMotion;
+          secondaryLength = maxLength;
+          secondarySource = maxSource;
+        }
+        maxLength = motionLength;
+        maxMotion = sample.motion;
+        maxSource = vec2<i32>(pixel);
+      } else if (
+        motionLength > secondaryLength &&
+        distinctDirection(maxMotion, sample.motion)
+      ) {
+        secondaryLength = motionLength;
+        secondaryMotion = sample.motion;
+        secondarySource = vec2<i32>(pixel);
+      }
+    }
+  }
+  tileMotionScratch[localIndex] = maxMotion;
+  tileLengthScratch[localIndex] = maxLength;
+  tileSourceScratch[localIndex] = maxSource;
+  tileSecondaryMotionScratch[localIndex] = secondaryMotion;
+  tileSecondaryLengthScratch[localIndex] = secondaryLength;
+  tileSecondarySourceScratch[localIndex] = secondarySource;
+  workgroupBarrier();
+  for (var stride = 32u; stride > 0u; stride = stride / 2u) {
+    if (localIndex < stride) {
+      let otherIndex = localIndex + stride;
+      let otherLength = tileLengthScratch[otherIndex];
+      if (otherLength > tileLengthScratch[localIndex]) {
+        let oldMotion = tileMotionScratch[localIndex];
+        let oldLength = tileLengthScratch[localIndex];
+        let oldSource = tileSourceScratch[localIndex];
+        tileLengthScratch[localIndex] = otherLength;
+        tileMotionScratch[localIndex] = tileMotionScratch[otherIndex];
+        tileSourceScratch[localIndex] = tileSourceScratch[otherIndex];
+        if (
+          oldLength > 1e-5 &&
+          distinctDirection(tileMotionScratch[localIndex], oldMotion) &&
+          oldLength > tileSecondaryLengthScratch[localIndex]
+        ) {
+          tileSecondaryLengthScratch[localIndex] = oldLength;
+          tileSecondaryMotionScratch[localIndex] = oldMotion;
+          tileSecondarySourceScratch[localIndex] = oldSource;
+        }
+      }
+      if (
+        tileSecondaryLengthScratch[otherIndex] > tileSecondaryLengthScratch[localIndex] &&
+        distinctDirection(
+          tileMotionScratch[localIndex],
+          tileSecondaryMotionScratch[otherIndex],
+        )
+      ) {
+        tileSecondaryLengthScratch[localIndex] = tileSecondaryLengthScratch[otherIndex];
+        tileSecondaryMotionScratch[localIndex] = tileSecondaryMotionScratch[otherIndex];
+        tileSecondarySourceScratch[localIndex] = tileSecondarySourceScratch[otherIndex];
+      }
+      if (
+        tileLengthScratch[otherIndex] > tileSecondaryLengthScratch[localIndex] &&
+        distinctDirection(tileMotionScratch[localIndex], tileMotionScratch[otherIndex])
+      ) {
+        tileSecondaryLengthScratch[localIndex] = tileLengthScratch[otherIndex];
+        tileSecondaryMotionScratch[localIndex] = tileMotionScratch[otherIndex];
+        tileSecondarySourceScratch[localIndex] = tileSourceScratch[otherIndex];
+      }
+    }
+    workgroupBarrier();
+  }
+  if (localIndex == 0u && inTile) {
+    let tileIndex = tile.y * tiles.x + tile.x;
+    tileSummary[tileIndex] = MotionBlurTileSummary(
+      vec4<f32>(
+        tileMotionScratch[0],
+        f32(tileSourceScratch[0].x),
+        f32(tileSourceScratch[0].y),
+      ),
+      vec4<f32>(
+        tileSecondaryMotionScratch[0],
+        f32(tileSecondarySourceScratch[0].x),
+        f32(tileSecondarySourceScratch[0].y),
+      ),
+    );
+  }
+}
+
+@compute @workgroup_size(8, 8)
+fn reconstruct(
+  @builtin(global_invocation_id) id : vec3<u32>,
+  @builtin(local_invocation_id) localId : vec3<u32>,
+  @builtin(workgroup_id) workgroupId : vec3<u32>,
+) {
+  let dimensions = textureDimensions(currentColor);
+  let colorDimensions = vec2<i32>(dimensions);
+  let pixel = vec2<i32>(id.xy);
+  let inBounds = id.x < dimensions.x && id.y < dimensions.y;
+  let workgroupBase = vec2<i32>(workgroupId.xy * vec2<u32>(8));
+  let ownsHalfCell = (localId.x % 2u == 0u) && (localId.y % 2u == 0u);
+  let halfIndex = (localId.y / 2u) * 4u + (localId.x / 2u);
+  let localIndex = localId.y * 8u + localId.x;
+  if (localIndex == 0u) {
+    scanTileNeighbourhood(workgroupBase, colorDimensions);
+  }
+  workgroupBarrier();
+  let support = resolveMotionBlurSupport(pixel, colorDimensions);
+  let longVector = support.valid && support.longVector;
+
+  longVectorScratch[localId.y * 8u + localId.x] = select(0u, 1u, longVector);
+  workgroupBarrier();
+  for (var longStride = 32u; longStride > 0u; longStride = longStride / 2u) {
+    let localIndex = localId.y * 8u + localId.x;
+    if (localIndex < longStride) {
+      longVectorScratch[localIndex] = max(
+        longVectorScratch[localIndex],
+        longVectorScratch[localIndex + longStride],
+      );
+    }
+    workgroupBarrier();
+  }
+  let anyLongVector = longVectorScratch[0] != 0u;
+  if (anyLongVector && ownsHalfCell) {
+    // Every designated owner evaluates the full support exactly once. The
+    // cached result includes filtered color, nearest accepted depth, and
+    // coverage; no 2x2 prefilter is substituted for the long gather.
+    let sourcePixel = workgroupBase + vec2<i32>(localId.xy);
+    let sourceSupport = resolveMotionBlurSupport(sourcePixel, colorDimensions);
+    let filtered = longSupportFilter(
+      sourcePixel,
+      sourceSupport,
+      temporalAt(sourcePixel, colorDimensions).depth,
+      colorDimensions,
+    );
+    halfFilteredReceiver[halfIndex] = sourcePixel;
+    halfFilteredMotion[halfIndex] = filtered.motion;
+    halfFilteredRadius[halfIndex] = filtered.radius;
+    let cacheBase = halfIndex * 4u;
+    halfFilteredColor[cacheBase] = filtered.color0;
+    halfFilteredColor[cacheBase + 1u] = filtered.color1;
+    halfFilteredColor[cacheBase + 2u] = filtered.color2;
+    halfFilteredColor[cacheBase + 3u] = filtered.color3;
+    halfFilteredDepth[cacheBase] = filtered.depth0;
+    halfFilteredDepth[cacheBase + 1u] = filtered.depth1;
+    halfFilteredDepth[cacheBase + 2u] = filtered.depth2;
+    halfFilteredDepth[cacheBase + 3u] = filtered.depth3;
+    halfFilteredCoverage[cacheBase] = filtered.coverage0;
+    halfFilteredCoverage[cacheBase + 1u] = filtered.coverage1;
+    halfFilteredCoverage[cacheBase + 2u] = filtered.coverage2;
+    halfFilteredCoverage[cacheBase + 3u] = filtered.coverage3;
+    halfFilteredValid[cacheBase] = select(0u, 1u, (filtered.validMask & 1u) != 0u);
+    halfFilteredValid[cacheBase + 1u] = select(0u, 1u, (filtered.validMask & 2u) != 0u);
+    halfFilteredValid[cacheBase + 2u] = select(0u, 1u, (filtered.validMask & 4u) != 0u);
+    halfFilteredValid[cacheBase + 3u] = select(0u, 1u, (filtered.validMask & 8u) != 0u);
+  }
+  workgroupBarrier();
+  // No invocation can return before both uniform barriers above. This keeps
+  // odd extents and out-of-bounds lanes from allowing a long source to read a
+  // cache entry that another invocation has not published yet.
+  if (!inBounds) {
+    return;
+  }
+  if (!support.valid) {
+    textureStore(outputColor, pixel, colorAt(pixel, colorDimensions));
+    return;
+  }
+  if (longVector) {
+    let cached = depthGuidedHalfResolutionColor(
+      localId,
+      pixel,
+      support,
+      temporalAt(pixel, colorDimensions).depth,
+    );
+    if (cached.valid) {
+      textureStore(outputColor, pixel, cached.color);
+    } else {
+      textureStore(outputColor, pixel, colorAt(pixel, colorDimensions));
+    }
+    return;
+  }
+  let useSecondDirection = support.secondaryRadius > 1e-5 && distinctDirection(support.primaryMotion, support.secondaryMotion);
+  let count = min(params.sampleCount, 16u);
+  let supportCount = max(count - 1u, 1u);
+  let primaryCount = select(supportCount, max(supportCount / 2u, 1u), useSecondDirection);
+  let secondaryCount = max(supportCount - primaryCount, 1u);
+  let shutter = clamp(params.shutterAngle / 360.0, 0.0, 1.0);
+  let center = temporalAt(pixel, colorDimensions);
+  let centerMotion = sourceMotionPixels(center, colorDimensions);
+  let centerMoving = center.validDepth && center.motionValid && sourceRadius(centerMotion, shutter) > 1e-5;
+  let centerColor = colorAt(pixel, colorDimensions);
+  var accum = vec4<f32>(0.0);
+  var weight = 0.0;
+  for (var index = 0u; index < 16u; index += 1u) {
+    if (index >= supportCount) { break; }
+    let secondDirection = useSecondDirection && index >= primaryCount;
+    let localIndex = select(index, index - primaryCount, secondDirection);
+    let localCount = select(primaryCount, secondaryCount, secondDirection);
+    let selectedMotion = select(support.primaryMotion, support.secondaryMotion, secondDirection);
+    let selectedRadius = select(support.primaryRadius, support.secondaryRadius, secondDirection);
+    let tap = supportTap(
+      pixel,
+      localIndex,
+      localCount,
+      selectedMotion,
+      selectedRadius,
+      select(support.primaryAnchor, support.secondaryAnchor, secondDirection),
+      colorDimensions,
+    );
+    if (!tap.valid) { continue; }
+    let source = sourceAt(pixel, tap.pixel, center.depth, shutter, colorDimensions);
+    if (!source.valid) { continue; }
+    let sampleColor = colorAt(source.pixel, colorDimensions);
+    accum += sampleColor;
+    weight += 1.0;
+  }
+  let uncovered = max(f32(supportCount) - weight, 0.0);
+  let acceptedColor = select(vec3<f32>(0.0), accum.rgb / max(weight, 1.0), weight > 0.0);
+  let missingForeground = 1.0 - clamp(centerColor.a, 0.0, 1.0);
+  let edgeCoverage = select(missingForeground, 1.0, centerMoving);
+  let edgeFill = acceptedColor * edgeCoverage * EDGE_FILL_FACTOR;
+  let movingFallback = select(centerColor.rgb, edgeFill, weight > 0.0);
+  let uncoveredColor = select(vec3<f32>(0.0), movingFallback, centerMoving);
+  let acceptedAlpha = select(0.0, accum.a / max(weight, 1.0), weight > 0.0);
+  let acceptedCoverage = weight + missingForeground * uncovered;
+  let reconstructedAlpha = acceptedAlpha * acceptedCoverage / max(f32(count), 1.0);
+  let outputAlpha = clamp(max(centerColor.a, reconstructedAlpha), 0.0, 1.0);
+  let emptyReceiver =
+    !centerMoving &&
+    weight > 0.0 &&
+    max(max(abs(centerColor.r), abs(centerColor.g)), abs(centerColor.b)) < 1e-4;
+  let sourceScale = select(1.0, 1.0 - EDGE_FILL_FACTOR, emptyReceiver);
+  let sourceContribution = accum.rgb * sourceScale;
+  let trailScale = select(1.0, 1.0 - EDGE_FILL_FACTOR, emptyReceiver);
+  let trailContribution = uncoveredColor * uncovered * trailScale;
+  textureStore(
+    outputColor,
+    pixel,
+    vec4<f32>((sourceContribution + centerColor.rgb + trailContribution) / max(f32(count), 1.0), outputAlpha),
+  );
+}
+`;
+function encodeMotionBlurComputeParams(params, frameDeltaSeconds = 1 / 60, reset = false) {
+  const bytes2 = new Uint8Array(MOTION_BLUR_PARAMS_BYTE_SIZE);
+  const view = new DataView(bytes2.buffer);
+  const uniformDeltaSeconds = Number.isFinite(frameDeltaSeconds) ? frameDeltaSeconds : 0;
+  view.setFloat32(0, params.shutterAngle, true);
+  view.setFloat32(4, params.maxRadiusPixels, true);
+  view.setUint32(8, effectiveMotionBlurSampleCount(params.sampleCount), true);
+  view.setUint32(12, reset ? 1 : 0, true);
+  view.setFloat32(16, params.targetFps, true);
+  view.setFloat32(20, motionBlurExposureScale(uniformDeltaSeconds, params.targetFps), true);
+  view.setFloat32(24, uniformDeltaSeconds, true);
+  view.setUint32(28, 0, true);
+  return bytes2;
+}
+function positiveDimension(value) {
+  return Number.isFinite(value) && value > 0 ? Math.ceil(value) : 1;
+}
+function planMotionBlur(params, context, temporal = {
+  frameDeltaSeconds: 1 / 60,
+  reset: false
+}) {
+  if (!motionBlurTemporalDemand(params)) return ok$1({ resources: [], passes: [] });
+  try {
+    const sceneTemporal = context.sceneData.require(SCENE_DATA_TEMPORAL_V1_SCHEMA);
+    const outputFormat = context.targets.find((target5) => target5.name === "motion-output")?.format ?? "rgba16float";
+    const fullscreen = {
+      kind: "fullscreen-program",
+      name: "motion-blur",
+      source: "forgeax::shader::motion-blur",
+      reads: ["scene-color", "scene-temporal"],
+      params: {
+        byteSize: MOTION_BLUR_PARAMS_BYTE_SIZE,
+        defaultValue: new Uint8Array(MOTION_BLUR_PARAMS_BYTE_SIZE)
+      }
+    };
+    const computeCapable = context.caps.compute === true && context.caps.storageBuffer === true && context.caps.storageTexture === true && context.caps.rgba16floatRenderable === true && outputFormat === "rgba16float";
+    if (computeCapable) {
+      const width = positiveDimension(context.frame.width);
+      const height = positiveDimension(context.frame.height);
+      const tileWidth = Math.max(1, Math.ceil(width / 16));
+      const tileHeight = Math.max(1, Math.ceil(height / 16));
+      return ok$1({
+        resources: [
+          {
+            kind: "compute-program",
+            name: "motion-blur-compute",
+            program: {
+              wgsl: MOTION_BLUR_COMPUTE_WGSL,
+              entryPoints: ["tile_summary", "reconstruct"],
+              bindings: [
+                {
+                  entries: [
+                    {
+                      binding: 0,
+                      visibility: 4,
+                      texture: { sampleType: "float", viewDimension: "2d" }
+                    },
+                    {
+                      binding: 1,
+                      visibility: 4,
+                      texture: { sampleType: "float", viewDimension: "2d" }
+                    },
+                    { binding: 2, visibility: 4, buffer: { type: "storage" } },
+                    {
+                      binding: 3,
+                      visibility: 4,
+                      storageTexture: {
+                        access: "write-only",
+                        format: "rgba16float",
+                        viewDimension: "2d"
+                      }
+                    },
+                    { binding: 4, visibility: 4, buffer: { type: "uniform" } }
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            kind: "buffer",
+            name: "motion-blur-tile-summary",
+            size: tileWidth * tileHeight * 32,
+            usage: ["storage"]
+          },
+          {
+            kind: "buffer",
+            name: "motion-blur-compute-params",
+            size: MOTION_BLUR_PARAMS_BYTE_SIZE,
+            usage: ["uniform"],
+            data: encodeMotionBlurComputeParams(params, temporal.frameDeltaSeconds, temporal.reset)
+          },
+          {
+            kind: "prepared-gpu-resource",
+            name: "motion-blur-input",
+            resource: { kind: "texture-view", value: void 0 },
+            logicalTarget: "motion-input"
+          },
+          {
+            kind: "prepared-gpu-resource",
+            name: "motion-blur-temporal",
+            resource: { kind: "texture-view", value: void 0 },
+            logicalTarget: sceneTemporal
+          },
+          {
+            kind: "prepared-gpu-resource",
+            name: "motion-blur-output",
+            resource: { kind: "texture-view", value: void 0 },
+            logicalTarget: "motion-output"
+          },
+          {
+            kind: "compute-bindings",
+            name: "motion-blur-compute-bindings",
+            program: "motion-blur-compute",
+            entries: [
+              { binding: 0, resource: "motion-blur-input" },
+              { binding: 1, resource: "motion-blur-temporal" },
+              { binding: 2, resource: "motion-blur-tile-summary" },
+              { binding: 3, resource: "motion-blur-output" },
+              { binding: 4, resource: "motion-blur-compute-params" }
+            ]
+          }
+        ],
+        passes: [
+          {
+            kind: "compute",
+            name: "motion-blur-tile-summary",
+            program: "motion-blur-compute",
+            bindings: "motion-blur-compute-bindings",
+            dispatches: [
+              {
+                kind: "direct",
+                entryPoint: "tile_summary",
+                workgroups: [tileWidth, tileHeight, 1]
+              }
+            ]
+          },
+          {
+            kind: "compute",
+            // Keep the public post-process identity stable while the compute
+            // lane adds its private tile-summary producer before it.
+            name: "motion-blur",
+            program: "motion-blur-compute",
+            bindings: "motion-blur-compute-bindings",
+            dispatches: [
+              {
+                kind: "direct",
+                entryPoint: "reconstruct",
+                workgroups: [
+                  Math.max(1, Math.ceil(width / 8)),
+                  Math.max(1, Math.ceil(height / 8)),
+                  1
+                ]
+              }
+            ]
+          }
+        ]
+      });
+    }
+    return ok$1({
+      resources: [
+        fullscreen,
+        {
+          kind: "graphics-program",
+          name: "motion-blur-pipeline",
+          program: {
+            shader: MOTION_BLUR_FEATURE_IDENTITY,
+            vertexLayout: "none",
+            colorFormats: [outputFormat],
+            sampleCount: 1
+          }
+        },
+        {
+          kind: "graphics-bindings",
+          name: "motion-blur-bindings",
+          program: "motion-blur-pipeline",
+          values: {
+            group: 1,
+            fullscreen: true,
+            shader: MOTION_BLUR_FEATURE_IDENTITY,
+            input: "motion-input",
+            temporal: sceneTemporal
+          },
+          logicalTargets: { input: "motion-input" }
+        }
+      ],
+      passes: [
+        {
+          kind: "raster",
+          name: "motion-blur",
+          colorAttachments: [{ target: "motion-output", loadOp: "clear", storeOp: "store" }],
+          sampledTargets: ["motion-input", sceneTemporal],
+          draws: [
+            {
+              program: "motion-blur-pipeline",
+              bindings: ["motion-blur-bindings"],
+              vertexData: [],
+              vertexLayout: "none",
+              draw: { kind: "draw", vertexCount: 3, instanceCount: 1 }
+            }
+          ]
+        }
+      ]
+    });
+  } catch (cause) {
+    return err$1(cause);
+  }
+}
+function createMotionBlurFeature(read) {
+  return Object.freeze({
+    identity: MOTION_BLUR_FEATURE_IDENTITY,
+    // The program is an Engine-owned static WGSL source. Immediate creation
+    // lets a newly admitted frame use the same graph/dispatch receipt instead
+    // of silently falling back to the raster post effect while the validated
+    // manifest adapter is still warming.
+    shaderModuleMode: "immediate",
+    extract: (_context) => {
+      const input = read();
+      const validated = validateMotionBlurParams(input?.params);
+      if (!validated.ok) return err$1(validated.error);
+      const params = input?.params === void 0 ? void 0 : validated.value;
+      return ok$1({
+        params,
+        demanded: motionBlurTemporalDemand(params),
+        frameDeltaSeconds: input?.frameDeltaSeconds === void 0 ? 1 / 60 : input.frameDeltaSeconds,
+        reset: input?.reset === true
+      });
+    },
+    plan: (frame, context) => frame.params === void 0 ? ok$1({ resources: [], passes: [] }) : planMotionBlur(frame.params, context, frame)
+  });
+}
 var AUTO_EXPOSURE_FUSED_GRAPH_PASS = "auto-exposure-meter";
 var AUTO_EXPOSURE_HISTOGRAM_DISPATCH = Object.freeze({
   x: 4,
@@ -7834,60 +9473,183 @@ function addStandardColorLutPass(graph, input, output, lut) {
 }
 
 // src/pipeline/standard-post.ts
+var STANDARD_BLOOM_MAX_LEVELS = 5;
 var STANDARD_BLOOM_TARGET_SPEC = {
-  composited: { label: "bloom-composited", format: "rgba16float", size: "surface" },
-  bright: { label: "bloom-bright", format: "rgba16float", size: "half-surface" },
-  blurH: { label: "bloom-blur-h", format: "rgba16float", size: "half-surface" },
-  blurV: { label: "bloom-blur-v", format: "rgba16float", size: "half-surface" }
+  composited: { label: "bloom-composited", format: "rgba16float" },
+  downsamplePrefix: "bloom-downsample-",
+  upsamplePrefix: "bloom-upsample-"
 };
+function deriveStandardBloomLevels(outputWidth, outputHeight) {
+  const levels = [];
+  let width = Math.max(1, Math.ceil(outputWidth / 2));
+  let height = Math.max(1, Math.ceil(outputHeight / 2));
+  for (let level = 0; level < STANDARD_BLOOM_MAX_LEVELS; level += 1) {
+    levels.push({ width, height });
+    if (width === 1 && height === 1) break;
+    width = Math.max(1, Math.ceil(width / 2));
+    height = Math.max(1, Math.ceil(height / 2));
+  }
+  return levels;
+}
+function standardBloomTargetSpecs(outputWidth, outputHeight) {
+  const levels = deriveStandardBloomLevels(outputWidth, outputHeight);
+  return {
+    composited: {
+      label: STANDARD_BLOOM_TARGET_SPEC.composited.label,
+      format: STANDARD_BLOOM_TARGET_SPEC.composited.format,
+      size: { width: outputWidth, height: outputHeight },
+      domain: "linear-hdr"
+    },
+    downsample: levels.map((size, level) => ({
+      label: `${STANDARD_BLOOM_TARGET_SPEC.downsamplePrefix}${level}`,
+      format: "rgba16float",
+      size,
+      domain: "linear-hdr"
+    })),
+    upsample: levels.slice(0, -1).map((size, level) => ({
+      label: `${STANDARD_BLOOM_TARGET_SPEC.upsamplePrefix}${level}`,
+      format: "rgba16float",
+      size,
+      domain: "linear-hdr"
+    })),
+    levels
+  };
+}
 var emptyBloomGraphInspection = () => ({
   status: "empty",
   targetCount: 0,
   targetBytes: 0,
-  passCount: 0
+  passCount: 0,
+  levelCount: 0,
+  levelDimensions: [],
+  downsamplePassCount: 0,
+  upsamplePassCount: 0
 });
 var invalidBloomGraphInspection = () => ({
   status: "invalid",
   targetCount: 0,
   targetBytes: 0,
-  passCount: 0
+  passCount: 0,
+  levelCount: 0,
+  levelDimensions: [],
+  downsamplePassCount: 0,
+  upsamplePassCount: 0
 });
-function textureBytes(resource, expected) {
+function textureBytes(resource) {
   const descriptor = resource.descriptor;
-  if (descriptor === void 0 || descriptor.kind !== "texture" || descriptor.format !== expected.format || !("size" in descriptor) || descriptor.size !== expected.size)
-    return 0;
+  if (resource.kind !== "texture" || descriptor === void 0 || descriptor.kind !== "texture" || descriptor.format !== "rgba16float")
+    return void 0;
   const texelBytes = 8;
   let bytes2 = 0;
   for (let level = 0; level < descriptor.mipLevelCount; level += 1) {
     bytes2 += Math.max(1, descriptor.width >> level) * Math.max(1, descriptor.height >> level) * descriptor.depthOrArrayLayers * texelBytes;
   }
-  return bytes2 * descriptor.sampleCount;
+  const descriptorBytes = bytes2 * descriptor.sampleCount;
+  return resource.byteSize === descriptorBytes && descriptorBytes > 0 ? descriptorBytes : void 0;
+}
+function resourceSize(resource) {
+  const descriptor = resource.descriptor;
+  if (resource.kind !== "texture" || descriptor.kind !== "texture") return void 0;
+  if (typeof descriptor.size === "string") return void 0;
+  if (resource.extent === void 0 || resource.extent.width !== descriptor.width || resource.extent.height !== descriptor.height || resource.extent.depthOrArrayLayers !== descriptor.depthOrArrayLayers) {
+    return void 0;
+  }
+  if (descriptor.format !== "rgba16float" || descriptor.domain !== "linear-hdr" || descriptor.width <= 0 || descriptor.height <= 0 || descriptor.depthOrArrayLayers !== 1 || descriptor.mipLevelCount !== 1 || descriptor.sampleCount !== 1 || resource.dimension !== "2d" || descriptor.size.width !== descriptor.width || descriptor.size.height !== descriptor.height || textureBytes(resource) === void 0) {
+    return void 0;
+  }
+  return { width: descriptor.width, height: descriptor.height };
+}
+function hasPassAccesses(pass, accesses) {
+  return pass !== void 0 && pass.kind === "raster" && pass.accesses.length === accesses.length && accesses.every(
+    (access, index) => pass.accesses[index]?.resource === access.resource && pass.accesses[index]?.usage === access.usage
+  );
 }
 function inspectStandardBloomGraph(graph) {
   if (graph === void 0) return emptyBloomGraphInspection();
-  const targetSpec = new Map(
-    Object.values(STANDARD_BLOOM_TARGET_SPEC).map((entry) => [entry.label, entry])
+  const composited = graph.resources.filter(
+    (resource) => resource.label === STANDARD_BLOOM_TARGET_SPEC.composited.label
   );
-  const targets = graph.resources.flatMap((resource) => {
-    const expected = targetSpec.get(resource.label);
-    return expected === void 0 ? [] : [{ resource, expected }];
-  });
-  const passNames = new Set(Object.values(TYPED_BLOOM_PASS_NAMES));
-  const passes = graph.passes.filter((pass) => passNames.has(pass.name));
+  const downsample = graph.resources.filter((resource) => resource.label.startsWith(STANDARD_BLOOM_TARGET_SPEC.downsamplePrefix)).sort((a, b) => a.label.localeCompare(b.label, void 0, { numeric: true }));
+  const upsample = graph.resources.filter((resource) => resource.label.startsWith(STANDARD_BLOOM_TARGET_SPEC.upsamplePrefix)).sort((a, b) => a.label.localeCompare(b.label, void 0, { numeric: true }));
+  const targets = [...composited, ...downsample, ...upsample];
+  const passes = graph.passes.filter(
+    (pass) => pass.name === TYPED_BLOOM_PASS_NAMES.composite || pass.name.startsWith(`${TYPED_BLOOM_PASS_NAMES.downsample}-`) || pass.name.startsWith(`${TYPED_BLOOM_PASS_NAMES.upsample}-`)
+  ).sort((left, right) => left.executionIndex - right.executionIndex);
   if (targets.length === 0 && passes.length === 0) return emptyBloomGraphInspection();
-  const completeTargetSet = targets.length === Object.values(STANDARD_BLOOM_TARGET_SPEC).length && targets.every(({ resource, expected }) => textureBytes(resource, expected) > 0);
-  const completePassSet = passes.length === Object.values(TYPED_BLOOM_PASS_NAMES).length;
-  if (!completeTargetSet || !completePassSet) {
+  if (composited.length !== 1) return invalidBloomGraphInspection();
+  const compositedResource = composited[0];
+  if (compositedResource === void 0) return invalidBloomGraphInspection();
+  const compositedSize = resourceSize(compositedResource);
+  if (compositedSize === void 0) return invalidBloomGraphInspection();
+  const expected = standardBloomTargetSpecs(compositedSize.width, compositedSize.height);
+  const expectedDownsampleLabels = expected.downsample.map((entry) => entry.label);
+  const expectedUpsampleLabels = expected.upsample.map((entry) => entry.label);
+  const orderedDownsample = downsample.sort(
+    (left, right) => left.label.localeCompare(right.label, void 0, { numeric: true })
+  );
+  const orderedUpsample = upsample.sort(
+    (left, right) => left.label.localeCompare(right.label, void 0, { numeric: true })
+  );
+  const completeTargetSet = targets.length === 1 + expectedDownsampleLabels.length + expectedUpsampleLabels.length && orderedDownsample.length === expectedDownsampleLabels.length && orderedUpsample.length === expectedUpsampleLabels.length && orderedDownsample.every(
+    (resource, level) => resource.label === expectedDownsampleLabels[level]
+  ) && orderedUpsample.every((resource, level) => resource.label === expectedUpsampleLabels[level]) && orderedDownsample.every(
+    (resource, level) => resourceSize(resource)?.width === expected.levels[level]?.width && resourceSize(resource)?.height === expected.levels[level]?.height
+  ) && orderedUpsample.every(
+    (resource, level) => resourceSize(resource)?.width === expected.levels[level]?.width && resourceSize(resource)?.height === expected.levels[level]?.height
+  );
+  const expectedPassNames = [
+    ...expectedDownsampleLabels,
+    ...[...expectedUpsampleLabels].reverse(),
+    TYPED_BLOOM_PASS_NAMES.composite
+  ];
+  const completePassSet = passes.length === expected.levels.length + expected.upsample.length + 1 && passes.every((pass, index) => pass.name === expectedPassNames[index]);
+  const sceneLabel = passes[0]?.accesses[0]?.resource;
+  const passTopology = completePassSet && sceneLabel !== void 0 && !sceneLabel.startsWith(STANDARD_BLOOM_TARGET_SPEC.downsamplePrefix) && !sceneLabel.startsWith(STANDARD_BLOOM_TARGET_SPEC.upsamplePrefix) && sceneLabel !== STANDARD_BLOOM_TARGET_SPEC.composited.label && graph.resources.some((resource) => resource.label === sceneLabel) && orderedDownsample.every(
+    (_, level) => hasPassAccesses(passes[level], [
+      {
+        resource: level === 0 ? sceneLabel : `bloom-downsample-${level - 1}`,
+        usage: "sampled-read"
+      },
+      { resource: `bloom-downsample-${level}`, usage: "color-attachment" }
+    ])
+  ) && orderedUpsample.every((_, level) => {
+    const passIndex = expected.levels.length + expected.upsample.length - 1 - level;
+    return hasPassAccesses(passes[passIndex], [
+      { resource: `bloom-downsample-${level}`, usage: "sampled-read" },
+      {
+        resource: level === expected.levels.length - 2 ? `bloom-downsample-${level + 1}` : `bloom-upsample-${level + 1}`,
+        usage: "sampled-read"
+      },
+      { resource: `bloom-upsample-${level}`, usage: "color-attachment" }
+    ]);
+  }) && hasPassAccesses(passes.at(-1), [
+    { resource: sceneLabel, usage: "sampled-read" },
+    {
+      resource: expected.levels.length === 1 ? "bloom-downsample-0" : "bloom-upsample-0",
+      usage: "sampled-read"
+    },
+    { resource: STANDARD_BLOOM_TARGET_SPEC.composited.label, usage: "color-attachment" }
+  ]);
+  if (!completeTargetSet || !passTopology) {
     return invalidBloomGraphInspection();
   }
+  const levelDimensions = orderedDownsample.flatMap((resource) => {
+    const size = resourceSize(resource);
+    return size === void 0 ? [] : [size];
+  });
+  if (levelDimensions.length !== orderedDownsample.length) {
+    return invalidBloomGraphInspection();
+  }
+  const targetBytes = targets.reduce((bytes2, resource) => bytes2 + (textureBytes(resource) ?? 0), 0);
   return {
     status: "valid",
     targetCount: targets.length,
-    targetBytes: targets.reduce(
-      (bytes2, target5) => bytes2 + textureBytes(target5.resource, target5.expected),
-      0
-    ),
-    passCount: passes.length
+    targetBytes,
+    passCount: passes.length,
+    levelCount: orderedDownsample.length,
+    levelDimensions,
+    downsamplePassCount: orderedDownsample.length,
+    upsamplePassCount: orderedUpsample.length
   };
 }
 function target2(context, label, descriptor) {
@@ -7910,7 +9672,7 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
     lane: topology.standardProfile?.renderPath === "deferred" ? "clustered" : "direct",
     temporal: !clearOnly && topology.camera.antialias === "taa",
     meter: topology.output?.autoExposure === true,
-    bloom: !clearOnly && topology.camera.bloom === "on" && topology.camera.tonemap !== "none",
+    bloom: !clearOnly && standardBloomAdmitted(topology.camera),
     dof: !clearOnly && topology.camera.depthOfField !== void 0,
     exposure: topology.output?.autoExposure === true,
     whiteBalance: topology.output?.whiteBalance === true,
@@ -7936,6 +9698,32 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
   const finalPresent = surface.storage;
   let postInput = scene;
   let postTemporal = sceneTemporal;
+  if (!clearOnly && topology.analyticFog === true) {
+    if (depth.sampleCount !== 1)
+      return err$1(
+        new RenderGraphError({
+          code: "resource-resolution-failed",
+          expected: "analytic fog receives single-sample scene depth",
+          hint: "select FXAA, TAA or no AA for analytic fog",
+          detail: { resourceLabel: "scene-depth" }
+        })
+      );
+    const fogged = target2(context, "analytic-fog-color", {
+      format: "rgba16float",
+      size: topology.extent === void 0 ? "surface" : renderExtentSize(topology.extent, "internal"),
+      domain: hdr ? "linear-hdr" : "linear-ldr"
+    });
+    if (!fogged.ok) return fogged;
+    const fog = addTypedFullscreenPass(context.graph, {
+      name: "analytic-fog",
+      shader: "forgeax.analytic-fog",
+      input: postInput,
+      depth,
+      output: fogged.value
+    });
+    if (!fog.ok) return fog;
+    postInput = fogged.value;
+  }
   const autoExposure = context.standardOutput?.autoExposure;
   if (outputPlan.features.exposure && autoExposure === void 0) {
     return err$1(
@@ -7956,7 +9744,7 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
       return err$1(missingTemporalContributor(topology, "forgeax::standard::taa-history"));
     }
     const resolveTargets = {
-      scene,
+      scene: postInput,
       depth,
       currentTemporal: sceneTemporal,
       ...coverage === void 0 ? {} : { coverage },
@@ -7974,6 +9762,15 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
     postInput = history.currentColor;
     postTemporal = history.currentTemporal;
   }
+  if (outputPlan.features.exposure && autoExposure !== void 0) {
+    const added = addAutoExposureGraphPasses(context, {
+      source: postInput,
+      resources: autoExposure,
+      width: topology.surface.width,
+      height: topology.surface.height
+    });
+    if (!added.ok) return added;
+  }
   if (!clearOnly) {
     const featureTargets = [
       {
@@ -8023,15 +9820,6 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
       if (!features.ok) return features;
     }
   }
-  if (outputPlan.features.exposure && autoExposure !== void 0) {
-    const added = addAutoExposureGraphPasses(context, {
-      source: postInput,
-      resources: autoExposure,
-      width: topology.surface.width,
-      height: topology.surface.height
-    });
-    if (!added.ok) return added;
-  }
   if (outputPlan.features.dof) {
     const dof = addDepthOfFieldPasses(
       {
@@ -8049,36 +9837,29 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
     postInput = dof.value;
   }
   if (bloomActive) {
-    const composited = target2(
-      context,
-      STANDARD_BLOOM_TARGET_SPEC.composited.label,
-      STANDARD_BLOOM_TARGET_SPEC.composited
-    );
+    const outputWidth = topology.extent?.outputWidth ?? topology.surface.width;
+    const outputHeight = topology.extent?.outputHeight ?? topology.surface.height;
+    const bloomSpecs = standardBloomTargetSpecs(outputWidth, outputHeight);
+    const composited = target2(context, bloomSpecs.composited.label, bloomSpecs.composited);
     if (!composited.ok) return composited;
-    const bright = target2(
-      context,
-      STANDARD_BLOOM_TARGET_SPEC.bright.label,
-      STANDARD_BLOOM_TARGET_SPEC.bright
-    );
-    if (!bright.ok) return bright;
-    const blurH = target2(
-      context,
-      STANDARD_BLOOM_TARGET_SPEC.blurH.label,
-      STANDARD_BLOOM_TARGET_SPEC.blurH
-    );
-    if (!blurH.ok) return blurH;
-    const blurV = target2(
-      context,
-      STANDARD_BLOOM_TARGET_SPEC.blurV.label,
-      STANDARD_BLOOM_TARGET_SPEC.blurV
-    );
-    if (!blurV.ok) return blurV;
+    const downsample = [];
+    for (const spec of bloomSpecs.downsample) {
+      const level = target2(context, spec.label, spec);
+      if (!level.ok) return level;
+      downsample.push(level.value);
+    }
+    const upsample = [];
+    for (const spec of bloomSpecs.upsample) {
+      const level = target2(context, spec.label, spec);
+      if (!level.ok) return level;
+      upsample.push(level.value);
+    }
     const bloom = addTypedBloomPasses(context.graph, {
       scene: postInput,
       composited: composited.value,
-      bright: bright.value,
-      blurH: blurH.value,
-      blurV: blurV.value
+      downsample,
+      upsample,
+      levelDimensions: bloomSpecs.levels
     });
     if (!bloom.ok) return bloom;
     postInput = composited.value;
@@ -12082,6 +13863,7 @@ var GpuDrivenProduction = class _GpuDrivenProduction {
     }
     const updated = this.view.update(filtered.plan, scene.scene, activeFrustum(input.camera));
     if (!updated.ok) return updated;
+    this.view.setTelemetrySubmit(input.telemetrySubmit);
     this.telemetryPrepared = true;
     const view = this.view;
     const visibleBuffer = view.visibleBuffer;
@@ -12999,15 +14781,53 @@ var GpuDrivenProduction = class _GpuDrivenProduction {
           this.laneReason = "overflow";
         }
       }
-      if (selection === void 0 || telemetryCandidateCount <= 0) return selection;
+      if (selection === void 0) return selection;
       if (filtered === void 0) return selection;
       const preparedByBatchId = new Map(
-        filtered.batches.map((prepared) => [prepared.batch.batchId, prepared])
+        filtered.batches.map((prepared) => [
+          prepared.batch.batchId,
+          {
+            batch: prepared.batch,
+            worldKey: prepared.worldKey,
+            primitiveSlot: prepared.primitiveSlot,
+            slotGeneration: prepared.slotGeneration
+          }
+        ])
       );
+      const filteredSlots = this.filteredCache?.slots;
+      const filteredWorldKeys = this.filteredCache?.worldKeys;
+      if (filteredSlots !== void 0) {
+        const slotByPrimitive = new Map(filteredSlots.map((slot) => [slot.slot, slot]));
+        for (const batch of filtered.plan.batches) {
+          if (preparedByBatchId.has(batch.batchId)) continue;
+          const candidate = batch.candidates[0];
+          const slot = candidate === void 0 ? void 0 : slotByPrimitive.get(candidate.primitiveIndex);
+          if (slot === void 0) continue;
+          preparedByBatchId.set(batch.batchId, {
+            batch,
+            worldKey: filteredWorldKeys?.[slot.snapshot.worldId] ?? slot.snapshot.worldId,
+            primitiveSlot: slot.slot,
+            slotGeneration: slot.generation
+          });
+        }
+      }
       const worldSelections = /* @__PURE__ */ new Map();
+      const lodHistogram = /* @__PURE__ */ new Map();
+      let lodCandidateCount = 0;
+      let lodVisible = 0;
       for (const batchSelection of selection.batches) {
         const prepared = preparedByBatchId.get(batchSelection.batchId);
-        if (prepared === void 0) return selection;
+        if (prepared === void 0) return void 0;
+        const lodCandidateRows = prepared.batch.candidates.filter(
+          (candidate) => (candidate.lodCoverages?.length ?? 0) > 1
+        );
+        if (lodCandidateRows.length === 0) continue;
+        if (lodCandidateRows.length !== batchSelection.candidateCount) return void 0;
+        lodCandidateCount += batchSelection.candidateCount;
+        lodVisible += batchSelection.visible;
+        for (const row of batchSelection.lodHistogram) {
+          lodHistogram.set(row.level, (lodHistogram.get(row.level) ?? 0) + row.count);
+        }
         let aggregate = worldSelections.get(prepared.worldKey);
         if (aggregate === void 0) {
           aggregate = {
@@ -13033,8 +14853,12 @@ var GpuDrivenProduction = class _GpuDrivenProduction {
       }
       return {
         ...selection,
-        candidateCount: telemetryCandidateCount,
-        occluded: Math.max(0, telemetryCandidateCount - selection.visible),
+        candidateCount: lodCandidateCount,
+        visible: lodVisible,
+        occluded: Math.max(0, lodCandidateCount - lodVisible),
+        lodHistogram: Object.freeze(
+          [...lodHistogram.entries()].sort(([left], [right]) => left - right).map(([level, count]) => Object.freeze({ level, count }))
+        ),
         worldSelections: Object.freeze(
           [...worldSelections.values()].map(
             (aggregate) => Object.freeze({
@@ -13594,6 +15418,49 @@ function projectDepthOfFieldInspection(input) {
 function requestedEqual(requested, params) {
   return requested.focusDistance === params.focusDistance && requested.fStop === params.fStop && requested.sensorHeight === params.sensorHeight && requested.maxRadiusPixels === params.maxRadiusPixels && requested.quality === params.quality && requested.blurSide === params.blurSide;
 }
+
+// src/features/error-reporting.ts
+var PENDING_RENDER_FEATURE_ERROR_REPORT_INTERVAL_FRAMES = 60;
+function shouldReportPendingRenderFeatureError(lastReportedFrame, key, frameNumber, intervalFrames = PENDING_RENDER_FEATURE_ERROR_REPORT_INTERVAL_FRAMES) {
+  const lastReported = lastReportedFrame.get(key);
+  if (lastReported !== void 0 && frameNumber - lastReported < intervalFrames) return false;
+  lastReportedFrame.set(key, frameNumber);
+  return true;
+}
+function reportPendingRenderFeatureErrors(errors, frameNumber, lastReportedFrame, errorRegistry) {
+  for (const error of errors) {
+    if (!isPendingRenderFeaturePreparation(error)) {
+      errorRegistry.fire(error);
+      continue;
+    }
+    if (isSilentRenderFeatureWarmup(error)) continue;
+    const key = pendingRenderFeatureErrorKey(error);
+    if (shouldReportPendingRenderFeatureError(lastReportedFrame, key, frameNumber)) {
+      errorRegistry.fire(error);
+    }
+  }
+}
+function isPendingRenderFeaturePreparation(error) {
+  if (!("detail" in error)) return false;
+  switch (error.code) {
+    case "render-feature-stage-failed":
+    case "render-feature-preparation-failed":
+    case "render-feature-prepared-state-mismatch":
+    case "render-feature-draw-recording-failed":
+      return error.detail.recovery === "next-frame";
+    default:
+      return false;
+  }
+}
+function isSilentRenderFeatureWarmup(error) {
+  return error.code === "render-feature-preparation-failed" && error.detail.reason.startsWith("rhi-not-available:");
+}
+function pendingRenderFeatureErrorKey(error) {
+  const detail = "detail" in error ? error.detail : void 0;
+  const featureIdentity = detail !== void 0 && "featureIdentity" in detail && typeof detail.featureIdentity === "string" ? detail.featureIdentity : "";
+  const order = detail !== void 0 && "order" in detail && typeof detail.order === "number" ? detail.order : -1;
+  return `${error.code}\0${featureIdentity}\0${order}\0${error.expected}\0${error.hint}`;
+}
 function createFeatureNoisePixels() {
   const pixels = new Uint8Array(64 * 64 * 4);
   let state = 1831565813;
@@ -13969,6 +15836,17 @@ function createRenderFeatureGpuWorkSession(input) {
       pipelineMap.set(entryPoint, pipeline.value);
     }
     const reference = Object.freeze({ generation: input.generation });
+    const textureBindings = /* @__PURE__ */ new Map();
+    for (const entry of descriptor.bindings?.[0]?.entries ?? []) {
+      if (entry.texture !== void 0) {
+        textureBindings.set(entry.binding, "sampled");
+      } else if (entry.storageTexture !== void 0) {
+        textureBindings.set(
+          entry.binding,
+          entry.storageTexture.access === "write-only" ? "storage-write" : entry.storageTexture.access === "read-only" ? "storage-read" : "storage-read-write"
+        );
+      }
+    }
     const item = {
       name,
       descriptor: cloneProgramDescriptor(descriptor),
@@ -13980,6 +15858,7 @@ function createRenderFeatureGpuWorkSession(input) {
           (entry) => entry.buffer === void 0 ? [] : [[entry.binding, entry.buffer.type ?? "uniform"]]
         )
       ),
+      textureBindings,
       ...bindGroupLayout === void 0 ? {} : { bindGroupLayout }
     };
     programs.set(name, item);
@@ -14277,7 +16156,7 @@ function createRenderFeatureGpuWorkSession(input) {
         }
         entryItems.push({
           binding: entry.binding,
-          resource: { kind: "textureView", value: item3.resource },
+          ...item3.resource === void 0 ? {} : { resource: { kind: "textureView", value: item3.resource } },
           textureView: item3
         });
         continue;
@@ -14305,7 +16184,7 @@ function createRenderFeatureGpuWorkSession(input) {
       entries: entryItems.map((entry) => [
         entry.binding,
         entry.buffer?.name ?? entry.textureView?.name ?? entry.sampler?.name,
-        entry.resource.kind
+        entry.resource?.kind ?? "late-texture"
       ])
     });
     const prior = bindings.get(name) ?? parkedBindings.get(name)?.item;
@@ -14335,7 +16214,22 @@ function createRenderFeatureGpuWorkSession(input) {
         )
       );
     }
-    const created = input.device.createBindGroup({
+    const hasLateTextures = entryItems.some(
+      (entry) => entry.textureView?.logicalTarget !== void 0
+    );
+    const hasMissingResource = entryItems.some((entry) => entry.resource === void 0);
+    if (hasMissingResource && !hasLateTextures) {
+      return err$1(
+        failure4(
+          input.featureIdentity,
+          "prepare-gpu-bindings",
+          "bindings",
+          name,
+          "texture-view-unavailable"
+        )
+      );
+    }
+    const created = hasLateTextures ? void 0 : input.device.createBindGroup({
       label: name,
       layout,
       entries: entryItems.map((entry) => ({
@@ -14343,7 +16237,7 @@ function createRenderFeatureGpuWorkSession(input) {
         resource: entry.resource
       }))
     });
-    if (!created.ok) {
+    if (created !== void 0 && !created.ok) {
       return err$1(
         failure4(
           input.featureIdentity,
@@ -14366,7 +16260,10 @@ function createRenderFeatureGpuWorkSession(input) {
       buffers: entryItems.flatMap(
         (entry) => entry.buffer === void 0 ? [] : [{ binding: entry.binding, item: entry.buffer }]
       ),
-      bindGroup: created.value
+      // A bind group with semantic targets is created once the graph resolves
+      // the current generation's physical views. The placeholder is never
+      // encoded because resolveComputePass installs resolveBindGroup.
+      bindGroup: created?.value
     };
     bindings.set(name, item);
     bindingRefs.set(reference, item);
@@ -14552,16 +16449,20 @@ function createRenderFeatureGpuWorkSession(input) {
         accesses.add("indirect-read");
         resolvedBuffers.set(item, accesses);
       }
+      const sampledTargets = /* @__PURE__ */ new Set();
+      const storageTargets = /* @__PURE__ */ new Set();
+      for (const item of dispatchBindings) {
+        for (const entry of item?.entries ?? []) {
+          const target5 = entry.textureView?.logicalTarget;
+          if (target5 === void 0) continue;
+          const role = program.textureBindings.get(entry.binding) ?? "sampled";
+          if (role === "sampled") sampledTargets.add(target5);
+          else storageTargets.add(target5);
+        }
+      }
       return ok$1({
-        sampledTargets: [
-          ...new Set(
-            dispatchBindings.flatMap(
-              (item) => item?.entries.flatMap(
-                (entry) => entry.textureView?.logicalTarget === void 0 ? [] : [entry.textureView.logicalTarget]
-              ) ?? []
-            )
-          )
-        ],
+        sampledTargets: [...sampledTargets],
+        storageTargets: [...storageTargets],
         buffers: [...resolvedBuffers].flatMap(
           ([item, accesses]) => [...accesses].map((access) => ({
             name: item.name,
@@ -15782,9 +17683,7 @@ function collectGpuDrivenMaterialArtifacts({
           specializationKey: sceneIndexProgramKey
         };
         const receipt = selectedIdentityArtifact?.receipt;
-        const shadowVertexInputsMatch = pass !== "shadow" || receipt !== void 0 && receipt.vertexInputs.length === prepared.vertexInputs.length && receipt.vertexInputs.every(
-          (input, index) => input.semantic === prepared.vertexInputs[index]?.semantic && input.location === prepared.vertexInputs[index]?.location && input.format === prepared.vertexInputs[index]?.format
-        );
+        const shadowVertexInputsMatch = pass !== "shadow" || receipt !== void 0 && hasRequiredVertexInputs(receipt.vertexInputs, prepared.vertexInputs);
         if (selectedIdentityArtifact === void 0 || receipt === void 0 || !shadowVertexInputsMatch || pass !== "shadow" && (receipt.receiptIdentity !== prepared.receiptIdentity || receipt.generation !== prepared.receiptGeneration)) {
           continue;
         }
@@ -15853,6 +17752,29 @@ function inspectStandardLighting(input) {
   }
   return inspectStandardClusterTransport(input.transport, input.prepared);
 }
+function encodeAnalyticFogParams(fog, camera) {
+  const projection = computeProjectionMatrix(camera);
+  const jitter = camera.temporal?.currentJitterUv;
+  if (jitter !== void 0) {
+    for (let column = 0; column < 4; column++) {
+      projection[column * 4] = (projection[column * 4] ?? 0) + jitter[0] * 2 * (projection[column * 4 + 3] ?? 0);
+      projection[column * 4 + 1] = (projection[column * 4 + 1] ?? 0) - jitter[1] * 2 * (projection[column * 4 + 3] ?? 0);
+    }
+  }
+  const inverse = mat4.invert(
+    mat4.create(),
+    mat4.multiply(mat4.create(), projection, computeViewMatrix(camera))
+  );
+  const data = new Float32Array(28);
+  data.set(inverse, 0);
+  data.set(camera.position, 16);
+  data.set([...fog.color, fog.density], 20);
+  data.set(
+    [fog.heightFalloff, fog.maxOpacity, camera.near, camera.projection === "orthographic" ? 1 : 0],
+    24
+  );
+  return new Uint8Array(data.buffer);
+}
 function uploadMaterialUniforms(c) {
   const {
     runtime,
@@ -16015,6 +17937,12 @@ function resolveVolumeTemporalReset(previous, next, options = {}) {
   if (previous.lightShadowRevision !== next.lightShadowRevision) {
     return { reset: true, reason: "light-revision" };
   }
+  if (previous.worldTimeSeconds !== next.worldTimeSeconds) {
+    const delta = (next.worldTimeSeconds ?? NaN) - (previous.worldTimeSeconds ?? NaN);
+    if (!Number.isFinite(delta) || delta < 0 || delta > 0.1) {
+      return { reset: true, reason: "simulation-time" };
+    }
+  }
   if (previous.densityGeneration !== next.densityGeneration) {
     return { reset: true, reason: "density-generation" };
   }
@@ -16073,6 +18001,7 @@ function createTemporalView(input) {
     previousUnjitteredViewProjection: input.previousUnjitteredViewProjection,
     currentCameraPosition: input.currentCameraPosition,
     previousCameraPosition: input.previousCameraPosition,
+    sampleTimeSeconds: input.sampleTimeSeconds,
     resetReason: input.resetReason
   });
   const taa = input.antialias === "taa";
@@ -16090,6 +18019,7 @@ function createTemporalView(input) {
     previousUnjitteredViewProjection: input.previousUnjitteredViewProjection,
     currentCameraPosition: input.currentCameraPosition,
     previousCameraPosition: input.previousCameraPosition,
+    sampleTimeSeconds: input.sampleTimeSeconds,
     currentProjection: taa ? "jittered" : "unjittered",
     previousProjection: "unjittered",
     historyRequired: taa,
@@ -16097,8 +18027,8 @@ function createTemporalView(input) {
   });
 }
 function resolveTemporalReset(previous, next) {
-  if (next.mode !== "taa") return void 0;
-  if (previous === void 0 || previous.mode !== "taa") return "first-frame";
+  if (previous === void 0) return "first-frame";
+  if (next.mode === "taa" && previous.mode !== "taa") return "first-frame";
   const before = previous.input;
   const after = next.input;
   if (before.width !== after.width || before.height !== after.height) return "resize";
@@ -16125,6 +18055,12 @@ function graphExecutionPhase(passName) {
     return "record/graph-execute/ssr-reflection-mip";
   }
   if (passName === "ssr-compose") return "record/graph-execute/ssr-compose";
+  if (passName.startsWith("bloom-downsample-")) {
+    return "record/graph-execute/bloom-downsample";
+  }
+  if (passName.startsWith("bloom-upsample-")) {
+    return "record/graph-execute/bloom-upsample";
+  }
   switch (passName) {
     case "cluster-binner-upload":
     case "cluster-membership-producer":
@@ -16154,12 +18090,10 @@ function graphExecutionPhase(passName) {
       return "record/graph-execute/main";
     case "fxaa":
       return "record/graph-execute/fxaa";
-    case "bloom-bright":
-      return "record/graph-execute/bloom-bright";
-    case "bloom-blur-h":
-      return "record/graph-execute/bloom-blur-h";
-    case "bloom-blur-v":
-      return "record/graph-execute/bloom-blur-v";
+    case "bloom-downsample":
+      return "record/graph-execute/bloom-downsample";
+    case "bloom-upsample":
+      return "record/graph-execute/bloom-upsample";
     case "bloom-composite":
       return "record/graph-execute/bloom-composite";
     default:
@@ -16331,19 +18265,27 @@ var RenderFeatureComputeGraphProjection = class {
   addPass(name, featureIdentity, order, work) {
     const accesses = [];
     const targets = /* @__PURE__ */ new Map();
-    for (const handle of work.sampledTargets ?? []) {
+    const sampledTargets = new Set(work.sampledTargets ?? []);
+    const storageTargets = new Set(work.storageTargets ?? []);
+    for (const handle of [...sampledTargets, ...storageTargets]) {
       let target5 = this.resolveTarget?.(handle);
       if (target5 === void 0)
         return err$1(
           new RenderFeatureStageFailedError(featureIdentity, order, "record", "renderer-recover")
         );
-      if (handle.kind === "scene-depth") {
+      if (typeof handle !== "string" && handle.kind === "scene-depth") {
         const view = this.builder.view(target5.texture, { aspect: "depth-only" });
         if (!view.ok) return view;
         target5 = { ...target5, view: view.value };
       }
       targets.set(handle, target5);
-      accesses.push({ resource: target5.view, usage: "sampled-read" });
+      if (sampledTargets.has(handle) && storageTargets.has(handle)) {
+        accesses.push({ resource: target5.view, usage: "sampled-storage-read-write" });
+      } else if (storageTargets.has(handle)) {
+        accesses.push({ resource: target5.view, usage: "storage-write" });
+      } else {
+        accesses.push({ resource: target5.view, usage: "sampled-read" });
+      }
     }
     for (const resource of work.buffers) {
       const imported = importRenderFeatureGraphBuffer(
@@ -16796,6 +18738,7 @@ function projectRenderFeaturePlans(builder, executions, options) {
           pass.resolvedGpuCompute
         );
         if (!added.ok) return added;
+        state.projected.add(pass);
         continue;
       }
       if (pass.graphics !== void 0 && pass.graphicsState !== void 0 && pass.resolvedGraphics !== void 0) {
@@ -16808,6 +18751,7 @@ function projectRenderFeaturePlans(builder, executions, options) {
           pass.resolvedGraphics
         );
         if (!added.ok) return added;
+        state.projected.add(pass);
         continue;
       }
       return err$1(
@@ -17073,7 +19017,12 @@ function importSsrHistoryTargets(graph) {
   };
 }
 function isMotionBlurTemporalDemand(motionBlur) {
-  return motionBlur?.shutterAngle !== void 0 && motionBlur.shutterAngle > 0;
+  return motionBlur !== void 0 && motionBlurTemporalDemand({
+    shutterAngle: motionBlur.shutterAngle,
+    maxRadiusPixels: motionBlur.maxRadiusPixels,
+    sampleCount: motionBlur.sampleCount,
+    targetFps: motionBlur.targetFps ?? 60
+  });
 }
 function renderTargetMipCount(work) {
   const { descriptor } = work.physical;
@@ -17644,7 +19593,7 @@ function commitFeatureCandidate(internals, candidate) {
   state.plans = candidate.plans;
   state.fullscreenEffects = candidate.fullscreenEffects;
 }
-function topologyOf(internals, frameState, pipelineState, camera, clearOnly, lights, width, height, shadowMapSize, gpuDriven, featureGraphCandidate, featurePlanRevision, cubeCaptureState, transmissionDemand, volumetricFog, standardLighting, ssr, renderExtent) {
+function topologyOf(internals, frameState, pipelineState, camera, clearOnly, lights, width, height, shadowMapSize, gpuDriven, featureGraphCandidate, featurePlanRevision, cubeCaptureState, transmissionDemand, volumetricFog, standardLighting, ssr, renderExtent, analyticFog) {
   const cascadeCount = Math.max(1, Math.min(4, Math.round(lights.cascadeCount ?? 1)));
   const surfaceFormats = resolveSurfaceFormatPair(
     internals.device.caps.backendKind,
@@ -17688,6 +19637,7 @@ function topologyOf(internals, frameState, pipelineState, camera, clearOnly, lig
     reflectionFallback: { enabled: frameState.reflectionFallbackDemand === true },
     ssr,
     ...renderExtent === void 0 ? {} : { extent: renderExtent },
+    analyticFog: !clearOnly && analyticFog,
     surface: {
       width,
       height,
@@ -17698,7 +19648,11 @@ function topologyOf(internals, frameState, pipelineState, camera, clearOnly, lig
     camera: {
       tonemap: camera.tonemap,
       antialias: camera.antialias,
-      bloom: camera.bloom,
+      // Bloom intensity is a frame parameter, not a graph identity. Fold
+      // only its zero/non-zero admission into the closed topology switch so
+      // positive intensity changes update the recorder UBO in place.
+      bloom: standardBloomAdmitted(camera) ? "on" : "off",
+      bloomIntensity: camera.bloomIntensity,
       ...depthOfField === void 0 ? {} : { depthOfField }
     },
     atmosphere: !clearOnly && frameState.environmentFrame?.source.kind === "atmosphere",
@@ -17976,7 +19930,7 @@ function settleDepthOfFieldGraphCandidate(frameState, submitted) {
   frameState.depthOfFieldPreviousStandardLightingGraphSignature = "";
   frameState.depthOfFieldCandidateGraph = null;
 }
-function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera, lights, width, height, shadowMapSize, gpuDriven, featureGraphCandidate, cubeCaptureState, clearOnly = false, transmissionDemand, occlusion, volumetricFog, volumeTopologyCandidate = false, standardLighting, onRecoveryError, ssr, renderExtent) {
+function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera, lights, width, height, shadowMapSize, gpuDriven, featureGraphCandidate, cubeCaptureState, clearOnly = false, transmissionDemand, occlusion, volumetricFog, volumeTopologyCandidate = false, standardLighting, onRecoveryError, ssr, renderExtent, analyticFog = false) {
   const featureMetrics = mutableFeatureGraphInspection(internals);
   featureMetrics.ensureCalls += 1;
   const requestedStandardLightingSignature = standardLightingTopologySignature(standardLighting);
@@ -18027,7 +19981,8 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
     volumetricFog,
     standardLighting,
     ssr,
-    renderExtent
+    renderExtent,
+    analyticFog
   );
   if (!topologyResult.ok) {
     featureMetrics.buildFailures += 1;
@@ -18040,6 +19995,10 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
   }
   const requestedPostEffects = topologyResult.value.config?.postEffects ?? [];
   const featurePostProcessEntries = featureGraphCandidate?.fullscreenEffects ?? getRenderFeatureGraphState(internals).fullscreenEffects;
+  const fullscreenFeatureIds = /* @__PURE__ */ new Set([
+    ...featurePostProcessEntries.keys(),
+    "forgeax.motion-blur"
+  ]);
   const postProcessAdmission = resolvePostProcessChainAdmission(
     requestedPostEffects,
     (identity) => {
@@ -18076,8 +20035,15 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
       postEffects: []
     }
   } : topologyResult.value;
+  const topologyIdentity = {
+    ...topology,
+    camera: {
+      ...topology.camera,
+      bloomIntensity: void 0
+    }
+  };
   const key = JSON.stringify({
-    topology,
+    topology: topologyIdentity,
     // Observation domains are an explicit per-frame graph demand.  They are
     // part of the cache identity so a request made after the ordinary graph
     // was compiled can admit the matching tone/output capture boundaries on
@@ -18174,7 +20140,6 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
     return lastKnownGood();
   }
   const ssrHistory = ssr?.status === "admitted" ? importSsrHistoryTargets(builder) : void 0;
-  let projectedFeatures = false;
   const featureProjection = createRenderFeatureProjectionState();
   let featureShadows;
   let projectedGpuDriven = false;
@@ -18227,11 +20192,12 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
         featureProjection
       ),
       contributeFeatures: (targets, semanticTargets = [], namedTargets = {}, standardSurfaceAccesses = []) => {
-        if (projectedFeatures) return ok$1(void 0);
-        projectedFeatures = true;
-        if (projectedFeaturePlans.value.length === 0) return ok$1(void 0);
+        const plans = Object.keys(namedTargets).length === 0 ? projectedFeaturePlans.value.filter(
+          (execution) => !fullscreenFeatureIds.has(execution.featureIdentity)
+        ) : projectedFeaturePlans.value;
+        if (plans.length === 0) return ok$1(void 0);
         const resolveTarget = targetResolver(targets, semanticTargets, namedTargets);
-        const projected = projectRenderFeaturePlans(builder, projectedFeaturePlans.value, {
+        const projected = projectRenderFeaturePlans(builder, plans, {
           state: featureProjection,
           resolveTarget,
           standardSurfaceAccesses,
@@ -18348,6 +20314,70 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
   }
   return compiled.value;
 }
+function deriveMotionBlurExecutionReceipt(internals, frameState) {
+  const graph = frameState.compiledFrameGraph;
+  const deviceGeneration = internals.deviceScope?.generation;
+  if (graph === null || deviceGeneration === void 0) return void 0;
+  const info = graph.inspect();
+  const graphPasses = new Map(info.passes.map((pass) => [pass.name, pass]));
+  const summaryGraphPass = graphPasses.get("motion-blur-tile-summary");
+  const reconstructGraphPass = graphPasses.get("motion-blur");
+  if (summaryGraphPass?.kind !== "compute" || reconstructGraphPass?.kind !== "compute") {
+    return void 0;
+  }
+  const planned = getRenderFeatureGraphState(internals).plans.find(
+    (candidate) => candidate.featureIdentity === "forgeax.motion-blur"
+  );
+  const execution = planned === void 0 ? void 0 : getRenderFeaturePlanExecutionProjection(planned);
+  if (execution === void 0 || execution.featureIdentity !== "forgeax.motion-blur") {
+    return void 0;
+  }
+  const executionPass = (name) => execution.passes.find((pass) => pass.name === name);
+  const summary = executionPass("motion-blur-tile-summary");
+  const reconstruct = executionPass("motion-blur");
+  if (summary?.gpuCompute === void 0 || reconstruct?.gpuCompute === void 0 || summary.resolvedGpuCompute === void 0 || reconstruct.resolvedGpuCompute === void 0) {
+    return void 0;
+  }
+  const directWorkgroups = (pass) => {
+    const dispatch = pass.dispatches[0];
+    if (dispatch === void 0 || !("workgroups" in dispatch)) return void 0;
+    return dispatch.workgroups;
+  };
+  const summaryWorkgroups = directWorkgroups(summary.resolvedGpuCompute);
+  const reconstructWorkgroups = directWorkgroups(reconstruct.resolvedGpuCompute);
+  if (summaryWorkgroups === void 0 || reconstructWorkgroups === void 0) return void 0;
+  const outputResource = info.resources.find(
+    (resource) => resource.label === "motion-blurred-color" || reconstructGraphPass.accesses.some(
+      (access) => access.resource === resource.label && access.usage === "storage-write"
+    )
+  );
+  if (outputResource?.descriptor.kind !== "texture" || outputResource.descriptor.format !== "rgba16float") {
+    return void 0;
+  }
+  const summaryReceipt = {
+    name: "motion-blur-tile-summary",
+    kind: "compute",
+    entryPoint: "tile_summary",
+    workgroups: summaryWorkgroups
+  };
+  const reconstructReceipt = {
+    name: "motion-blur",
+    kind: "compute",
+    entryPoint: "reconstruct",
+    workgroups: reconstructWorkgroups
+  };
+  return Object.freeze({
+    frameId: frameState.frameNumber,
+    deviceGeneration,
+    // RenderGraphBuilder generations are process-global. The renderer's
+    // frame-state generation is the identity used by inspection and by the
+    // same-frame admission check below, so retain that owner-scoped value.
+    graphGeneration: frameState.graphGeneration,
+    program: "motion-blur-compute",
+    outputFormat: "rgba16float",
+    passes: [summaryReceipt, reconstructReceipt]
+  });
+}
 function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPass, frameHooks, readbackFaces, onSubmitted, timingCapture) {
   const legacySubmitCommit = typeof frameHooks === "function" ? frameHooks : void 0;
   const resolvedFrameHooks = typeof frameHooks === "function" ? void 0 : frameHooks;
@@ -18366,6 +20396,7 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
     rejectTemporalFrame();
     return false;
   }
+  const motionBlurExecution = deriveMotionBlurExecutionReceipt(internals, frameState);
   const legacyTimingInstrumentation = timingCapture === void 0 ? void 0 : createTimingInstrumentation(timingCapture);
   const timingHost = internals;
   timingHost.gpuPassTimingCapture = void 0;
@@ -18894,6 +20925,11 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
     commit: () => {
       resolvedFrameHooks?.onSubmitted?.();
       legacySubmitCommit?.();
+      if (motionBlurExecution === void 0) {
+        delete frameState.motionBlurExecution;
+      } else {
+        frameState.motionBlurExecution = motionBlurExecution;
+      }
       if (frameState.temporalFrameInput !== void 0) {
         const temporal = frameState.temporalFrameTransaction.commit({ accepted: true });
         if (temporal.ok) {
@@ -19663,6 +21699,7 @@ function volumeTemporalSignature(fog, prepared, camera, lights, width, height) {
     densityGeneration: prepared.densityGeneration,
     width,
     height,
+    ...fog.worldTimeSeconds === void 0 ? {} : { worldTimeSeconds: fog.worldTimeSeconds },
     ...fog.lightKind === void 0 ? {} : { lightKind: fog.lightKind },
     ...fog.lightEntity === void 0 ? {} : { lightEntity: fog.lightEntity },
     ...fog.pointLightEntity === void 0 ? {} : { pointLightEntity: fog.pointLightEntity },
@@ -19721,7 +21758,7 @@ function prepareVolumetricFogFrame(internals, frameState, world, worlds, fog, li
     }
     return void 0;
   }
-  const params = new Float32Array(32);
+  const params = new Float32Array(36);
   params.set(fog.fog.bounds.min, 0);
   params.set(fog.fog.bounds.max, 4);
   params.set(fog.fog.extinction, 8);
@@ -19733,7 +21770,7 @@ function prepareVolumetricFogFrame(internals, frameState, world, worlds, fog, li
   const lightColor = selectedSpot?.color ?? lights.directional?.color ?? vec3.create(0, 0, 0);
   if (lightDirection === void 0 || lightColor === void 0) return void 0;
   params.set(lightDirection, 20);
-  params[23] = frameState.frameNumber % 1024;
+  params[23] = 0;
   const selectedPointIndex = selectedPoint === void 0 ? -1 : lights.point.findIndex((light) => light.entity === selectedPoint.entity);
   const selectedSpotIndex = selectedSpot === void 0 ? -1 : lights.spot.findIndex((light) => light.entity === selectedSpot.entity);
   const selectedSpotClusterIndex = selectedSpotIndex < 0 ? -1 : lights.point.length + selectedSpotIndex;
@@ -19744,6 +21781,7 @@ function prepareVolumetricFogFrame(internals, frameState, world, worlds, fog, li
   params[29] = fog.fog.anisotropy;
   params[30] = selectedPoint !== void 0 && selectedSpot !== void 0 ? 3 : selectedPoint !== void 0 ? 1 : selectedSpot !== void 0 ? 2 : 0;
   params[31] = frameState.temporalFrame !== void 0 && frameState.temporalFrame.resetReason === "none" ? 1 : 0;
+  params[32] = fog.worldTimeSeconds ?? 0;
   const paramsBuffer = stageVolumetricFogParams(internals, frameState, params);
   if (paramsBuffer === void 0) return void 0;
   return {
@@ -19847,6 +21885,8 @@ function mapSsrHistoryResetReason(reason2) {
     case "environment-change":
     case "fog-change":
       return "reflection-generation";
+    case "time-discontinuity":
+      return "camera-cut";
     case "device-recover":
       return "device-recovery";
     case "submit-failure":
@@ -19854,6 +21894,27 @@ function mapSsrHistoryResetReason(reason2) {
       return void 0;
   }
 }
+function frameClockSample(world, worlds, camera, sampleTimeSeconds) {
+  const owner = worlds[camera.worldId ?? 0] ?? world;
+  const invalidSampleTime = sampleTimeSeconds !== void 0 && !Number.isFinite(sampleTimeSeconds);
+  try {
+    const clock = owner.getResource(Time);
+    return {
+      deltaSeconds: Number.isFinite(clock.delta) ? Math.max(0, clock.delta) : 0,
+      // Keep the raw host sample even when ECS accepted only a clamped
+      // simulation delta. Temporal admission compares this value with the
+      // last successfully submitted sample and therefore sees real hitches.
+      elapsedSeconds: sampleTimeSeconds === void 0 ? Number.isFinite(clock.elapsed) ? clock.elapsed : void 0 : Number.isFinite(sampleTimeSeconds) ? sampleTimeSeconds : void 0,
+      invalidSampleTime
+    };
+  } catch {
+    return {
+      deltaSeconds: 0,
+      elapsedSeconds: Number.isFinite(sampleTimeSeconds) ? sampleTimeSeconds : void 0,
+      invalidSampleTime
+    };
+  }
+}
 function stageSsrHistoryCandidate(internals, frameState, camera, width, height, admission, temporalView) {
   const previousAdmission = frameState.ssrSpatialAdmission;
   frameState.ssrSpatialAdmission = admission;
@@ -20081,7 +22142,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, shadowCasterEntityKeys = EMPTY_ENTITY_KEYS, shadowCasterDrawKeys = void 0, volumetricFog, timingCapture, shadowCasterMembership, shadowCasterProjection, shadowCasterWorldKeys, preparedLighting, ssrDependencies, onRenderableDraw) {
+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, shadowCasterEntityKeys = EMPTY_ENTITY_KEYS, shadowCasterDrawKeys = void 0, volumetricFog, timingCapture, shadowCasterMembership, shadowCasterProjection, shadowCasterWorldKeys, preparedLighting, ssrDependencies, onRenderableDraw, analyticFog, sampleTimeSeconds, temporalReset = false) {
   frameState.reflectionFallbackObservationSource = void 0;
   frameState.reflectionFallbackCompletion = void 0;
   let activeCameras = cameras;
@@ -20321,6 +22382,7 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
         ...frameGpuDriven.activeEntityKeys === void 0 ? {} : { activeEntityKeys: frameGpuDriven.activeEntityKeys },
         ...frameGpuDriven.activeEntityRevision === void 0 ? {} : { activeEntityRevision: frameGpuDriven.activeEntityRevision },
         ...frameGpuDriven.telemetryCandidateCount === void 0 ? {} : { telemetryCandidateCount: frameGpuDriven.telemetryCandidateCount },
+        ...frameGpuDriven.telemetrySubmit === void 0 ? {} : { telemetrySubmit: frameGpuDriven.telemetrySubmit },
         ...frameGpuDriven.occlusion === void 0 ? {} : { occlusion: frameGpuDriven.occlusion },
         ...frameGpuDriven.scene?.structureMetrics === void 0 ? {} : {
           structureMetrics: {
@@ -20424,7 +22486,8 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
         standard,
         void 0,
         ssrAdmission,
-        renderExtent
+        renderExtent,
+        analyticFog !== void 0 && analyticFog.density > 0 && analyticFog.maxOpacity > 0
       )
     );
     if (preflightGraph === null) {
@@ -20487,6 +22550,21 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
     const targetW = swapTarget.targetW;
     const targetH = swapTarget.targetH;
     const previousTemporalView = frameState.lastSuccessfulTemporalView;
+    const motionBlurDemand = camera.motionBlur === void 0 ? false : motionBlurTemporalDemand({
+      shutterAngle: camera.motionBlur.shutterAngle,
+      maxRadiusPixels: camera.motionBlur.maxRadiusPixels,
+      sampleCount: camera.motionBlur.sampleCount,
+      targetFps: camera.motionBlur.targetFps ?? 60
+    });
+    const temporalDemand = camera.antialias === "taa" || motionBlurDemand;
+    const clock = frameClockSample(world, worlds, camera, sampleTimeSeconds);
+    const deltaSeconds = temporalReset || clock.invalidSampleTime ? Number.NaN : motionBlurSampleDelta(
+      clock.elapsedSeconds,
+      previousTemporalView?.sampleTimeSeconds,
+      clock.deltaSeconds
+    );
+    const intervalValid = isMotionBlurIntervalValid(deltaSeconds);
+    const motionBlurFirstFrame = motionBlurDemand && camera.antialias !== "taa" && (previousTemporalView === void 0 || previousTemporalView.mode === "off" && !previousTemporalView.historyValid && previousTemporalView.resetReason === void 0);
     const currentUnjitteredViewProjection = mat4.multiply(
       mat4.create(),
       computeProjectionMatrix(camera),
@@ -20511,16 +22589,20 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
         internalHeight: renderExtent.internalHeight
       },
       ...camera.historyVersion === void 0 ? {} : { historyVersion: camera.historyVersion },
+      ...clock.elapsedSeconds === void 0 ? {} : { sampleTimeSeconds: clock.elapsedSeconds },
       historyValid: false,
       currentUnjitteredViewProjection,
       currentCameraPosition
     });
-    const resetReason = camera.antialias === "taa" && environmentReady ? resolveTemporalReset(previousTemporalView, temporalCandidate) : void 0;
+    const resetReason = temporalDemand && environmentReady ? resolveTemporalReset(previousTemporalView, temporalCandidate) ?? (temporalReset || motionBlurDemand && !intervalValid ? "time-discontinuity" : motionBlurFirstFrame ? "first-frame" : void 0) : void 0;
     const canReusePrevious = previousTemporalView !== void 0 && resetReason === void 0;
     const temporalView = createTemporalView({
       ...temporalCandidate.input,
       frameIndex: resetReason === void 0 ? temporalCandidate.input.frameIndex : 0,
-      historyValid: camera.antialias === "taa" && environmentReady && canReusePrevious,
+      // Motion Blur needs a finite positive pair before it can read the
+      // baseline. TAA-only frames retain their existing temporal contract and
+      // do not depend on the simulation clock being present in a test host.
+      historyValid: temporalDemand && environmentReady && canReusePrevious && (!motionBlurDemand || intervalValid),
       resetReason,
       ...canReusePrevious && previousTemporalView.currentUnjitteredViewProjection !== void 0 ? {
         previousUnjitteredViewProjection: previousTemporalView.currentUnjitteredViewProjection
@@ -20559,17 +22641,23 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
       );
       activeVolumetricFogContext = resolvedHistory.context;
       activeVolumetricFogSignature = resolvedHistory.signature;
-      const historyFlag = new Float32Array([activeVolumetricFogContext.historyValid ? 1 : 0]);
+      const previousTime = frameState.volumetricFogHistorySignature?.worldTimeSeconds;
+      const currentTime = resolvedHistory.signature.worldTimeSeconds;
+      const historyParams = new Float32Array([
+        activeVolumetricFogContext.historyValid ? 1 : 0,
+        currentTime ?? 0,
+        previousTime === void 0 || currentTime === void 0 ? 0 : Math.max(0, currentTime - previousTime)
+      ]);
       if (frameState.volumetricFogPendingParams !== void 0) {
-        frameState.volumetricFogPendingParams[31] = historyFlag[0] ?? 0;
+        frameState.volumetricFogPendingParams.set(historyParams, 31);
       }
-      const historyFlagWritten = internals.device.queue.writeBuffer(
+      const historyParamsWritten = internals.device.queue.writeBuffer(
         activeVolumetricFogContext.paramsBuffer,
         31 * Float32Array.BYTES_PER_ELEMENT,
-        historyFlag
+        historyParams
       );
-      if (!historyFlagWritten.ok) {
-        internals.errorRegistry.fire(historyFlagWritten.error);
+      if (!historyParamsWritten.ok) {
+        internals.errorRegistry.fire(historyParamsWritten.error);
         abortPreparedGpuDriven();
         return false;
       }
@@ -20759,14 +22847,33 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
       );
     }
     const framePostProcessParams = new Map(postProcessParams);
+    if (analyticFog !== void 0)
+      framePostProcessParams.set(
+        "forgeax.analytic-fog",
+        encodeAnalyticFogParams(analyticFog, recordCamera)
+      );
     if (camera.motionBlur !== void 0) {
-      const motionBlurParams = new Uint8Array(16);
-      const motionBlurView = new DataView(motionBlurParams.buffer);
-      motionBlurView.setFloat32(0, camera.motionBlur.shutterAngle, true);
-      motionBlurView.setFloat32(4, camera.motionBlur.maxRadiusPixels, true);
-      motionBlurView.setUint32(8, camera.motionBlur.sampleCount, true);
-      motionBlurView.setUint32(12, temporalView?.historyValid === true ? 0 : 1, true);
-      framePostProcessParams.set("forgeax.motion-blur", motionBlurParams);
+      if (motionBlurDemand) {
+        const motionBlurParams = new Uint8Array(MOTION_BLUR_PARAMS_BYTE_SIZE);
+        const motionBlurView = new DataView(motionBlurParams.buffer);
+        const uniformDeltaSeconds = Number.isFinite(deltaSeconds) ? deltaSeconds : 0;
+        motionBlurView.setFloat32(0, camera.motionBlur.shutterAngle, true);
+        motionBlurView.setFloat32(4, camera.motionBlur.maxRadiusPixels, true);
+        motionBlurView.setUint32(
+          8,
+          effectiveMotionBlurSampleCount(camera.motionBlur.sampleCount),
+          true
+        );
+        motionBlurView.setUint32(12, temporalView?.historyValid === true ? 0 : 1, true);
+        motionBlurView.setFloat32(16, camera.motionBlur.targetFps ?? 60, true);
+        motionBlurView.setFloat32(
+          20,
+          motionBlurExposureScale(uniformDeltaSeconds, camera.motionBlur.targetFps ?? 60),
+          true
+        );
+        motionBlurView.setFloat32(24, uniformDeltaSeconds, true);
+        framePostProcessParams.set("forgeax.motion-blur", motionBlurParams);
+      }
     }
     if (camera.depthOfField !== void 0) {
       const dofParams = packDepthOfFieldParams(camera.depthOfField, {
@@ -21939,6 +24046,7 @@ function createTemporalFrameTransaction(options) {
   let staged;
   let historyEpoch = 0;
   let pendingResetReason;
+  let lastFailure;
   return {
     stage(input) {
       staged = copyInput(input);
@@ -21946,9 +24054,11 @@ function createTemporalFrameTransaction(options) {
     commit(submit) {
       if (!submit.accepted) {
         staged = void 0;
+        lastFailure = submit.reason ?? "queue-submit-failed";
         return err$1(new TemporalFrameSubmitError(submit.reason ?? "queue-submit-failed"));
       }
       if (staged === void 0) {
+        lastFailure = "queue-submit-failed";
         return err$1(new TemporalFrameSubmitError("queue-submit-failed"));
       }
       const resetReason = submit.resetReason ?? staged.resetReason ?? pendingResetReason ?? "none";
@@ -21969,6 +24079,7 @@ function createTemporalFrameTransaction(options) {
       accepted = next;
       staged = void 0;
       pendingResetReason = void 0;
+      lastFailure = void 0;
       return ok$1(copyFrame(next));
     },
     snapshot() {
@@ -21976,11 +24087,19 @@ function createTemporalFrameTransaction(options) {
         throw new Error("TemporalFrame snapshot is unavailable before commit");
       return copyFrame(accepted);
     },
+    inspect() {
+      return {
+        accepted: accepted !== void 0,
+        staged: staged !== void 0,
+        ...lastFailure === void 0 ? {} : { lastFailure }
+      };
+    },
     reset(reason2 = "signature-change") {
       accepted = void 0;
       staged = void 0;
       historyEpoch += 1;
       pendingResetReason = reason2;
+      lastFailure = void 0;
     }
   };
 }
@@ -22311,6 +24430,10 @@ function createRenderSystemRecovery(deps) {
           worlds: seed.worlds,
           owner: seed.resourceOwner,
           frameNumber: candidateFrameState.frameNumber,
+          frameSize: {
+            width: runtime.internals.canvas.width,
+            height: runtime.internals.canvas.height
+          },
           visibilitySnapshots: seed.frame.featureVisibilitySnapshots,
           hiddenEntityReports: seed.frame.hiddenEntityReports,
           targets: featureTargets,
@@ -22538,16 +24661,21 @@ function createRenderSystemRecovery(deps) {
           throw new Error("recovery TAA pipeline is unavailable");
         }
       }
-      if (camera.motionBlur?.shutterAngle !== void 0 && camera.motionBlur.shutterAngle > 0) {
+      if (camera.motionBlur !== void 0 && motionBlurTemporalDemand({
+        shutterAngle: camera.motionBlur.shutterAngle,
+        maxRadiusPixels: camera.motionBlur.maxRadiusPixels,
+        sampleCount: camera.motionBlur.sampleCount,
+        targetFps: camera.motionBlur.targetFps ?? 60
+      })) {
         warmPostProcessPipeline("forgeax.motion-blur", "rgba16float");
       }
       for (const id of candidatePostProcessIds) {
         warmPostProcessPipeline(id, runtime.pipelineState.format);
       }
-      if (camera.bloom === "on" && camera.tonemap !== "none") {
+      if (standardBloomAdmitted(camera)) {
         runtime.pipelineState.perPassResources.ensureBloomResources?.();
         const bloom = runtime.pipelineState.perPassResources.getBloomResources?.();
-        if (bloom === null || bloom === void 0 || bloom.bloomBrightPipeline === null || bloom.bloomBlurHPipeline === null || bloom.bloomBlurVPipeline === null || bloom.bloomCompositePipeline === null || bloom.bloomBrightBindGroupLayout === null || bloom.bloomBlurBindGroupLayout === null || bloom.bloomCompositeBindGroupLayout === null || bloom.bloomSampler === null || bloom.bloomBrightParamsBuffer === null || bloom.bloomBlurHParamsBuffer === null || bloom.bloomBlurVParamsBuffer === null || bloom.bloomCompositeParamsBuffer === null) {
+        if (bloom === null || bloom === void 0 || bloom.bloomDownsamplePipeline === null || bloom.bloomUpsamplePipeline === null || bloom.bloomCompositePipeline === null || bloom.bloomDownsampleBindGroupLayout === null || bloom.bloomUpsampleBindGroupLayout === null || bloom.bloomCompositeBindGroupLayout === null || bloom.bloomSampler === null || bloom.bloomDownsampleParamsBuffer === null || bloom.bloomUpsampleParamsBuffer === null || bloom.bloomCompositeParamsBuffer === null) {
           throw new Error("recovery Bloom resources are incomplete");
         }
       }
@@ -24819,6 +26947,30 @@ function coalesceSlots(slots) {
   }
   return ranges;
 }
+function previousInstanceOrdinals(current, temporal) {
+  const previous = temporal?.previousInstances;
+  const currentGenerations = current?.generations;
+  const previousGenerations = previous?.generations;
+  if (temporal?.motionValid !== true || current === void 0 || previous === void 0 || currentGenerations === void 0 || previousGenerations === void 0 || currentGenerations.length !== current.instanceCount || previousGenerations.length !== previous.instanceCount || current.transforms.length < current.instanceCount * 16 || previous.transforms.length < previous.instanceCount * 16) {
+    return void 0;
+  }
+  const currentSet = /* @__PURE__ */ new Set();
+  for (const generation of currentGenerations) {
+    if (generation === 0 || currentSet.has(generation)) return void 0;
+    currentSet.add(generation);
+  }
+  const ordinals = /* @__PURE__ */ new Map();
+  for (let ordinal = 0; ordinal < previousGenerations.length; ordinal += 1) {
+    const generation = previousGenerations[ordinal] ?? 0;
+    if (generation === 0 || ordinals.has(generation)) return void 0;
+    ordinals.set(generation, ordinal);
+  }
+  return ordinals;
+}
+function instanceIdentityChanged(resident, current, ordinal) {
+  if (resident === void 0 || current === void 0) return resident !== current;
+  return resident[ordinal] !== current[ordinal];
+}
 var GpuScene = class _GpuScene {
   constructor(device, capacity, buffers) {
     this.device = device;
@@ -24849,6 +27001,8 @@ var GpuScene = class _GpuScene {
   sceneContentRevision = 0;
   identityUploaded = false;
   allocations = /* @__PURE__ */ new Map();
+  /** Current stable instance identities retained beside compact GPU rows. */
+  instanceGenerations = /* @__PURE__ */ new Map();
   instances = new StableRangeAllocator();
   transforms = new StableRangeAllocator();
   draws = new StableRangeAllocator();
@@ -24904,7 +27058,7 @@ var GpuScene = class _GpuScene {
     }
     return allocation.materialStart + materialSlot;
   }
-  sync(delta) {
+  sync(delta, temporalResolver) {
     for (const transformIndex of this.pendingTemporalUploads) {
       this.writesByTable.transform.push(transformIndex);
     }
@@ -24962,11 +27116,11 @@ var GpuScene = class _GpuScene {
     for (const record of publications) {
       const reset = newSlots.has(record.slot) || allocationResets.has(record.slot);
       if (reset || contentUpdatedSlotIds.has(record.slot)) {
-        this.writeSlot(record, reset, writesByTable);
+        this.writeSlot(record, reset, writesByTable, temporalResolver?.(record));
         continue;
       }
       if (instanceUpdatedSlotIds.has(record.slot))
-        this.writeInstanceTransforms(record, writesByTable);
+        this.writeInstanceTransforms(record, writesByTable, temporalResolver?.(record));
       this.writeRootTransform(record, false, writesByTable);
     }
     const uploaded = this.uploadRows(writesByTable);
@@ -25026,6 +27180,7 @@ var GpuScene = class _GpuScene {
   }
   rebuild(slots) {
     this.allocations.clear();
+    this.instanceGenerations.clear();
     this.instances.reset();
     this.transforms.reset(1);
     this.draws.reset();
@@ -25111,7 +27266,7 @@ var GpuScene = class _GpuScene {
     for (const buffer of this.retiredBuffers) this.device.destroyBuffer(buffer);
     for (const buffer of Object.values(this.buffers)) this.device.destroyBuffer(buffer);
   }
-  writeSlot(record, resetPrevious, writes) {
+  writeSlot(record, resetPrevious, writes, temporal) {
     const allocation = this.allocations.get(record.slot);
     if (allocation === void 0) throw new RangeError("GPU Scene allocation unavailable");
     const primitiveOffset = record.slot * PRIMITIVE.stride;
@@ -25167,6 +27322,11 @@ var GpuScene = class _GpuScene {
     ]);
     const instance = new DataView(this.tableBytes.instance);
     const transform = this.transformView;
+    const instances = record.snapshot.instances;
+    const previousInstances = temporal?.previousInstances;
+    const previousOrdinals = previousInstanceOrdinals(instances, temporal);
+    const currentGenerations = instances?.generations;
+    const residentGenerations = this.instanceGenerations.get(record.slot);
     for (let ordinal = 0; ordinal < allocation.instanceCount; ordinal += 1) {
       const instanceIndex = allocation.instanceStart + ordinal;
       const instanceOffset = instanceIndex * INSTANCE.stride;
@@ -25188,7 +27348,7 @@ var GpuScene = class _GpuScene {
       ) || metadataChanged;
       metadataChanged = writeChangedU32(instance, instanceOffset + offset(INSTANCE, "flags"), PRIMITIVE_ACTIVE) || metadataChanged;
       if (allocation.instanceTransformCount > 0) {
-        const transforms = record.snapshot.instances?.transforms;
+        const transforms = instances?.transforms;
         const hasLocal = transforms !== void 0 && transforms.length >= (ordinal + 1) * 16;
         const local = hasLocal ? transforms : IDENTITY_MATRIX;
         const sourceOffset = hasLocal ? ordinal * 16 : 0;
@@ -25199,18 +27359,55 @@ var GpuScene = class _GpuScene {
           local,
           sourceOffset
         );
-        if (resetPrevious)
-          writeChangedMat4(
-            transform,
-            localOffset + offset(TRANSFORM, "previousWorld"),
-            local,
-            sourceOffset
-          );
-        else if (changed) this.pendingTemporalTransforms.add(transformIndex);
-        if (changed || resetPrevious) writes.transform.push(transformIndex);
+        const identityChanged = instanceIdentityChanged(
+          residentGenerations,
+          currentGenerations,
+          ordinal
+        );
+        if (resetPrevious) {
+          const previousOrdinal = previousOrdinals?.get(currentGenerations?.[ordinal] ?? 0);
+          const previousSource = previousOrdinal === void 0 || previousInstances === void 0 ? void 0 : previousInstances.transforms;
+          if (previousSource === void 0 || previousOrdinal === void 0) {
+            writeChangedMat4(
+              transform,
+              localOffset + offset(TRANSFORM, "previousWorld"),
+              local,
+              sourceOffset
+            );
+          } else {
+            writeChangedMat4(
+              transform,
+              localOffset + offset(TRANSFORM, "previousWorld"),
+              previousSource,
+              previousOrdinal * 16
+            );
+            this.pendingTemporalTransforms.add(transformIndex);
+          }
+        } else if (changed || identityChanged) {
+          const previousOrdinal = previousOrdinals?.get(currentGenerations?.[ordinal] ?? 0);
+          const previousSource = previousOrdinal === void 0 || previousInstances === void 0 ? void 0 : previousInstances.transforms;
+          if (previousSource === void 0 || previousOrdinal === void 0) {
+            writeChangedMat4(
+              transform,
+              localOffset + offset(TRANSFORM, "previousWorld"),
+              local,
+              sourceOffset
+            );
+          } else {
+            writeChangedMat4(
+              transform,
+              localOffset + offset(TRANSFORM, "previousWorld"),
+              previousSource,
+              previousOrdinal * 16
+            );
+          }
+          this.pendingTemporalTransforms.add(transformIndex);
+        }
+        if (changed || identityChanged || resetPrevious) writes.transform.push(transformIndex);
       }
       if (metadataChanged || resetPrevious) writes.instance.push(instanceIndex);
     }
+    this.rememberInstanceGenerations(record.slot, currentGenerations, allocation.instanceCount);
     this.writeRootTransform(record, resetPrevious, writes);
     writes.primitive.push(record.slot);
     const draw = new DataView(this.tableBytes.drawTemplate);
@@ -25270,7 +27467,7 @@ var GpuScene = class _GpuScene {
     }
   }
   /** Consume changed instance fields independently of root or material changes. */
-  writeInstanceTransforms(record, writes) {
+  writeInstanceTransforms(record, writes, temporal) {
     const allocation = this.allocations.get(record.slot);
     const instances = record.snapshot.instances;
     if (allocation === void 0 || instances === void 0) {
@@ -25279,19 +27476,62 @@ var GpuScene = class _GpuScene {
     if (allocation.instanceTransformCount !== instances.instanceCount) {
       throw new RangeError("GPU Scene instance update changed instance count");
     }
+    const previousOrdinals = previousInstanceOrdinals(instances, temporal);
+    const previousInstances = temporal?.previousInstances;
+    const currentGenerations = instances.generations;
+    const residentGenerations = this.instanceGenerations.get(record.slot);
     for (let ordinal = 0; ordinal < allocation.instanceTransformCount; ordinal += 1) {
       const transformIndex = allocation.instanceTransformStart + ordinal;
       const transformOffset = transformIndex * TRANSFORM.stride;
-      if (writeChangedMat4(
+      const changed = writeChangedMat4(
         this.transformView,
         transformOffset + offset(TRANSFORM, "currentWorld"),
         instances.transforms,
         ordinal * 16
-      )) {
+      );
+      const identityChanged = instanceIdentityChanged(
+        residentGenerations,
+        currentGenerations,
+        ordinal
+      );
+      if (changed || identityChanged) {
+        const previousOrdinal = previousOrdinals?.get(currentGenerations?.[ordinal] ?? 0);
+        const previousSource = previousOrdinal === void 0 || previousInstances === void 0 ? void 0 : previousInstances.transforms;
+        if (previousSource === void 0 || previousOrdinal === void 0) {
+          writeChangedMat4(
+            this.transformView,
+            transformOffset + offset(TRANSFORM, "previousWorld"),
+            instances.transforms,
+            ordinal * 16
+          );
+        } else {
+          writeChangedMat4(
+            this.transformView,
+            transformOffset + offset(TRANSFORM, "previousWorld"),
+            previousSource,
+            previousOrdinal * 16
+          );
+        }
         this.pendingTemporalTransforms.add(transformIndex);
         writes.transform.push(transformIndex);
       }
     }
+    this.rememberInstanceGenerations(
+      record.slot,
+      currentGenerations,
+      allocation.instanceTransformCount
+    );
+  }
+  rememberInstanceGenerations(slot, generations2, instanceCount) {
+    if (generations2 === void 0 || generations2.length !== instanceCount) {
+      this.instanceGenerations.delete(slot);
+      return;
+    }
+    const resident = this.instanceGenerations.get(slot);
+    if (resident !== void 0 && resident.length === generations2.length && resident.every((generation, ordinal) => generation === generations2[ordinal])) {
+      return;
+    }
+    this.instanceGenerations.set(slot, generations2.slice());
   }
   writeRootTransform(record, resetPrevious, writes) {
     const allocation = this.allocations.get(record.slot);
@@ -25317,6 +27557,7 @@ var GpuScene = class _GpuScene {
     }
     const allocation = this.allocations.get(slot);
     if (allocation === void 0) return;
+    this.instanceGenerations.delete(slot);
     this.clearAllocation(allocation, writes);
     this.allocations.delete(slot);
   }
@@ -25798,6 +28039,25 @@ var VisibilityFacetStore = class {
 };
 
 // src/scene/render-scene.ts
+function sameInstanceIdentitySet(current, previous) {
+  if (current === void 0 || previous === void 0) return false;
+  const currentSet = new Set(current);
+  const previousSet = new Set(previous);
+  if (currentSet.size !== current.length || previousSet.size !== previous.length || current.some((identity) => identity === 0) || previous.some((identity) => identity === 0)) {
+    return false;
+  }
+  if (current.length === previous.length) {
+    let sameOrder = true;
+    for (let index = 0; index < current.length; index += 1) {
+      if (current[index] !== previous[index]) {
+        sameOrder = false;
+        break;
+      }
+    }
+    if (sameOrder) return true;
+  }
+  return current.every((identity) => previousSet.has(identity));
+}
 function identityKey(worldId, entityKey) {
   return `${worldId}:${entityKey}`;
 }
@@ -25837,7 +28097,8 @@ function ownSnapshot(snapshot) {
     ...snapshot.instances === void 0 ? {} : {
       instances: {
         ...snapshot.instances,
-        transforms: new Float32Array(snapshot.instances.transforms)
+        transforms: new Float32Array(snapshot.instances.transforms),
+        ...snapshot.instances.generations === void 0 ? {} : { generations: new Uint32Array(snapshot.instances.generations) }
       }
     },
     ...snapshot.spriteInstances === void 0 ? {} : {
@@ -26002,7 +28263,8 @@ var RenderScene = class {
           ...pending.current,
           instances: {
             ...operation.instances,
-            transforms: new Float32Array(operation.instances.transforms)
+            transforms: new Float32Array(operation.instances.transforms),
+            ...operation.instances.generations === void 0 ? {} : { generations: new Uint32Array(operation.instances.generations) }
           }
         };
         pending.instanceChanged = true;
@@ -26424,13 +28686,23 @@ var RenderScene = class {
     const seedCurrent = !sameGeneration || !wasVisible || reasons.includes("geometry-revision") || reasons.includes("material-revision");
     const previous = seedCurrent || submitted === void 0 ? slot.snapshot : submitted.snapshot;
     const previousWorld = this.previousWorldBySlot[slot.slot];
+    const currentInstances = slot.snapshot.instances;
+    const submittedInstances = submitted?.snapshot.instances;
+    const instancesCompatible = currentInstances === void 0 && submittedInstances === void 0 ? true : currentInstances !== void 0 && submittedInstances !== void 0 && (currentInstances.collectionId === void 0 || submittedInstances.collectionId === void 0 || currentInstances.collectionId === submittedInstances.collectionId) && currentInstances.transforms.length >= currentInstances.instanceCount * 16 && submittedInstances.transforms.length >= submittedInstances.instanceCount * 16 && sameInstanceIdentitySet(currentInstances.generations, submittedInstances.generations);
+    const motionValid = !seedCurrent && previousWorld !== void 0 && instancesCompatible;
     return {
       previousEpoch: seedCurrent ? void 0 : this.submittedEpoch,
       previousSource: seedCurrent ? "current-seed" : "last-submitted",
+      motionValid,
       reactive: reasons.length > 0,
       reactiveReasons: reasons,
       previousTransform: seedCurrent || previousWorld === void 0 ? previous.transform : { ...previous.transform, world: previousWorld },
-      previousInstances: previous.instances,
+      // A collection identity/count break is a temporal cut for that
+      // renderable. The record stage receives the current snapshot as its
+      // baseline, while stable collections retain the submitted column and
+      // use identity generations to map reordered entries and seed replaced
+      // entries.
+      previousInstances: seedCurrent ? slot.snapshot.instances : previous.instances,
       previousSkin: previous.skin,
       previousMorphWeights: previous.morph?.weights
     };
@@ -26618,7 +28890,13 @@ function topologyDeltaForAvailable(delta, unavailableSlots, newlyUnavailable) {
 }
 function frameDemandsTemporal(frame) {
   const camera = frame.cameras[0];
-  return camera?.antialias === "taa" || (camera?.motionBlur?.shutterAngle ?? 0) > 0;
+  const motionBlur = camera?.motionBlur;
+  return camera?.antialias === "taa" || motionBlur !== void 0 && motionBlurTemporalDemand({
+    shutterAngle: motionBlur.shutterAngle,
+    maxRadiusPixels: motionBlur.maxRadiusPixels,
+    sampleCount: motionBlur.sampleCount,
+    targetFps: motionBlur.targetFps ?? 60
+  });
 }
 function cameraFrusta(cameras) {
   const planes = [];
@@ -27625,12 +29903,16 @@ var PersistentRenderScene = class {
   /** Publish renderer-owned previous transforms after queue submission. */
   commitTemporalFrame() {
     const gpuCommit = this.gpuScene?.commitTemporalFrame(this.temporalCapture !== void 0);
-    if (gpuCommit !== void 0 && !gpuCommit.ok) return gpuCommit;
+    if (gpuCommit !== void 0 && !gpuCommit.ok) {
+      this.temporalCapture = void 0;
+      return gpuCommit;
+    }
     const temporalCapture = this.temporalCapture;
     if (temporalCapture !== void 0) {
       try {
         temporalCapture.projection.commitSubmission(temporalCapture.capture);
       } catch (cause) {
+        this.temporalCapture = void 0;
         return err$1(
           new RhiError({
             code: "internal-error",
@@ -27643,6 +29925,10 @@ var PersistentRenderScene = class {
     }
     return ok$1(void 0);
   }
+  /** Drop a staged temporal capture when the owning frame did not submit. */
+  discardTemporalFrame() {
+    this.temporalCapture = void 0;
+  }
   /** Capture current CPU scene facts; commitTemporalFrame publishes them only after submit. */
   prepareTemporalFrame(visible) {
     const projection = this.composition?.projection;
@@ -27934,7 +30220,7 @@ var PersistentRenderScene = class {
       removedSlots: [],
       recreatedSlots: [],
       resynced: 0
-    }) : acquired.scene.sync(delta);
+    }) : acquired.scene.sync(delta, (slot) => projection.temporalSnapshotBySlot(slot.slot));
     if (!result.ok) {
       this.sceneTableUploadBytes = 0;
       this.failGpu(result.error);
@@ -28344,9 +30630,6 @@ function reportPreparedGraphicsCompletionError(internals, error) {
     })
   );
 }
-function isPendingRenderFeaturePreparation(error) {
-  return error.code === "render-feature-preparation-failed" && error.detail.reason.startsWith("rhi-not-available:");
-}
 function makePreparedPipelinePendingError() {
   return new RhiError({
     code: "rhi-not-available",
@@ -28471,6 +30754,19 @@ function createRenderSystem(internals) {
   let preparedFeatureSkylightResources;
   const dynamicGeometryFrames = createDynamicGeometryFrameBindings();
   let latestCamera;
+  let lastMotionBlurInvalidParams;
+  let motionBlurFeatureInput;
+  const motionBlurFeature = createMotionBlurFeature(() => motionBlurFeatureInput);
+  const ensureMotionBlurFeature = () => {
+    const host = internals.featureHost;
+    if (host === void 0 || host.features.some((feature) => feature.identity === "forgeax.motion-blur")) {
+      return;
+    }
+    const installed = host.install(
+      motionBlurFeature
+    );
+    if (!installed.ok) internals.errorRegistry.fire(installed.error);
+  };
   const pointsLinesOwner = new StandardPointsLinesOwner(internals);
   const instanceCollections = new InstanceCollectionStore();
   const reflectionProbeOwner = new ReflectionProbeRecordOwner(internals);
@@ -28818,6 +31114,7 @@ function createRenderSystem(internals) {
     // tiles until the first frame with a castShadow spot (AC-03).
     spotShadowSnapshots: []
   };
+  const pendingFeatureErrorLastReportedFrame = /* @__PURE__ */ new Map();
   const resolveSsrDependencies = (requested) => {
     const owner = reflectionProbeOwner.inspect();
     const temporal = frameState.lastSuccessfulTemporalView === void 0 ? void 0 : {
@@ -29162,16 +31459,16 @@ function createRenderSystem(internals) {
   let lodCandidateCountCache;
   let lodInspectionRenderablesCache;
   let orderedDispatchCache;
-  const applyLodSelectionTelemetry = (selection) => {
-    if (selection === void 0 || lastLodOcclusionInspection === void 0) return;
-    const inspection = lastLodOcclusionInspection;
+  const applyLodSelectionTelemetry = (selection, targetInspection = lastLodOcclusionInspection, targetWorldAttachments = lastLodWorldAttachments) => {
+    if (selection === void 0 || targetInspection === void 0) return;
+    const inspection = targetInspection;
     let worlds = inspection.worlds;
     const worldSelections = selection.worldSelections;
     if (worldSelections !== void 0 && worldSelections.length > 0) {
       const selectionsByAttachment = /* @__PURE__ */ new Map();
       let attributionValid = true;
       for (const selected of worldSelections) {
-        const attachmentId = lastLodWorldAttachments.get(selected.worldKey);
+        const attachmentId = targetWorldAttachments.get(selected.worldKey);
         if (attachmentId === void 0) {
           attributionValid = false;
           break;
@@ -29184,15 +31481,7 @@ function createRenderSystem(internals) {
         const nextWorlds = worlds.map((world) => {
           const selected = selectionsByAttachment.get(world.attachmentId);
           const baseRow = world.rows[0];
-          if (selected === void 0 || baseRow === void 0) {
-            if (world.rows.length > 0) attributionValid = false;
-            return world;
-          }
-          const candidateCount = selected.reduce((sum, row) => sum + row.candidateCount, 0);
-          if (candidateCount !== baseRow.count.candidates) {
-            attributionValid = false;
-            return world;
-          }
+          if (selected === void 0 || baseRow === void 0) return world;
           return Object.freeze({
             ...world,
             attribution: Object.freeze({
@@ -29222,7 +31511,7 @@ function createRenderSystem(internals) {
     lastLodOcclusionInspection = inspectLodOcclusion({
       ...inspection,
       count: {
-        ...lastLodOcclusionInspection.count,
+        ...inspection.count,
         candidates: selection.candidateCount,
         visible: selection.visible,
         occluded: selection.occluded
@@ -29562,22 +31851,20 @@ function createRenderSystem(internals) {
       });
     },
     get motionBlurInspection() {
-      const camera = latestCamera;
-      if (camera?.motionBlur === void 0) return void 0;
-      const demanded = camera.motionBlur.shutterAngle > 0;
-      const unavailable3 = demanded && !internals.device.caps.rgba16floatRenderable;
-      const admitted = frameState.activeTemporalGpuState !== void 0 || frameState.temporalGpuState !== void 0;
-      return {
-        enabled: demanded,
-        status: !demanded ? "off" : unavailable3 || !admitted ? "reset" : "active",
-        shutterAngle: camera.motionBlur.shutterAngle,
-        maxRadiusPixels: camera.motionBlur.maxRadiusPixels,
-        sampleCount: camera.motionBlur.sampleCount,
-        temporalDemand: demanded ? "scene-data-temporal-v1" : "none",
-        passName: "motion-blur",
-        historyWrites: 0,
-        ...unavailable3 ? { lastFailure: "scene-data-unavailable" } : {}
-      };
+      return projectMotionBlurInspection({
+        camera: latestCamera,
+        invalidParams: lastMotionBlurInvalidParams,
+        capabilities: internals.device.caps,
+        acceptedTemporal: frameState.lastSuccessfulTemporalView,
+        transaction: frameState.temporalFrameTransaction.inspect(),
+        execution: frameState.motionBlurExecution,
+        temporalFrameId: frameState.temporalFrame?.frameId,
+        deviceGeneration: internals.deviceScope.generation,
+        graphGeneration: frameState.graphGeneration
+      });
+    },
+    get motionBlurInvalidParams() {
+      return lastMotionBlurInvalidParams;
     },
     get depthOfFieldInspection() {
       const camera = latestCamera;
@@ -29635,22 +31922,7 @@ function createRenderSystem(internals) {
       const lifecycle = resources?.inspectBloomResources?.(
         frameState.compiledFrameGraph?.inspect()
       );
-      return Object.freeze(
-        lifecycle ?? {
-          graphStatus: "empty",
-          enabled: false,
-          targetCount: 0,
-          targetBytes: 0,
-          resourceCount: 0,
-          passCount: 0,
-          encodeCount: 0,
-          bindGroupCount: 0,
-          uploadCount: 0,
-          residentChildBytes: 0,
-          generation: 0,
-          state: "off"
-        }
-      );
+      return Object.freeze(lifecycle ?? emptyBloomInspection());
     },
     get transmission() {
       return lastTransmissionInspection;
@@ -29714,6 +31986,7 @@ function createRenderSystem(internals) {
       const profileSession = internals.profiler?.activeSession();
       let ownsProfileFrame = false;
       let submitted = false;
+      persistentRenderScene.discardTemporalFrame();
       dynamicGeometryFrames.begin();
       if (profileSession !== void 0 && opts.profileFrame === void 0) {
         try {
@@ -29733,44 +32006,56 @@ function createRenderSystem(internals) {
         }
         dispatchCounts.unlit = 0;
         const resourceWorld = compositionWorlds[resourceOwner];
-        const frame = runProfiledRenderPhase(profileSession, "extract", () => {
-          return persistentRenderScene.extractComposition(
-            compositionWorlds,
-            { cameraOwner, resourceOwner },
-            internals.assets.catalogEpoch,
-            (renderables2) => extractFrames(
+        let frame;
+        try {
+          frame = runProfiledRenderPhase(profileSession, "extract", () => {
+            return persistentRenderScene.extractComposition(
               compositionWorlds,
-              {
-                cameraOwner,
-                resourceOwner,
-                ...cameraEntityKey === void 0 ? {} : { cameraEntityKey }
-              },
-              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"
-                  }
+              { cameraOwner, resourceOwner },
+              internals.assets.catalogEpoch,
+              (renderables2) => extractFrames(
+                compositionWorlds,
+                {
+                  cameraOwner,
+                  resourceOwner,
+                  ...cameraEntityKey === void 0 ? {} : { cameraEntityKey }
                 },
-                cull: "none",
-                retainHidden: true,
-                renderables: renderables2,
-                instanceCollections,
-                ...!internals.device.caps.storageBuffer || internals.getMaterialShaderArtifact === void 0 ? {} : { getMaterialShaderArtifact: internals.getMaterialShaderArtifact }
-              }
-            ),
-            compositionLeases
-          );
-        });
+                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",
+                  retainHidden: true,
+                  renderables: renderables2,
+                  instanceCollections,
+                  ...!internals.device.caps.storageBuffer || internals.getMaterialShaderArtifact === void 0 ? {} : { getMaterialShaderArtifact: internals.getMaterialShaderArtifact }
+                }
+              ),
+              compositionLeases
+            );
+          });
+        } catch (cause) {
+          if (cause instanceof MotionBlurValidationError) {
+            lastMotionBlurInvalidParams = cause;
+            latestCamera = void 0;
+            internals.errorRegistry.fire(cause);
+            return false;
+          }
+          throw cause;
+        }
+        lastMotionBlurInvalidParams = void 0;
         const {
           cameras: extractedCameras,
           cubeCameras,
@@ -29976,6 +32261,7 @@ function createRenderSystem(internals) {
         const submissionRenderables = visibilityProjection.renderables;
         const submissionDispatch = visibilityProjection.dispatch;
         const inspectionCamera = latestCamera;
+        const lodSubmitFrameId = internals.observationFrameId ?? frameState.frameNumber;
         let lodCandidateCountForFrame = 0;
         if (inspectionCamera !== void 0) {
           const firstRenderable = renderables[0];
@@ -30007,7 +32293,7 @@ function createRenderSystem(internals) {
             renderables,
             submissionRenderables,
             inspectionCamera,
-            frameState.frameNumber,
+            lodSubmitFrameId,
             worldKeys,
             slotByEntity,
             {
@@ -30032,7 +32318,7 @@ function createRenderSystem(internals) {
           lastLodOcclusionInspection = inspectLodOcclusion({
             root: {
               guid: firstRenderable === void 0 ? "none" : `asset-handle:${firstRenderable.assetHandle}`,
-              sourceKey: `render-frame:${frameState.frameNumber}`
+              sourceKey: `render-frame:${lodSubmitFrameId}`
             },
             view: {
               attachmentId: compositionWorlds[inspectionCamera.worldId ?? cameraOwner]?.identity ?? "none",
@@ -30044,7 +32330,7 @@ function createRenderSystem(internals) {
               primitiveSlot: 0,
               slotGeneration: persistentRenderScene.inspect().topology.revision
             },
-            generation: frameState.frameNumber,
+            generation: lodSubmitFrameId,
             count: {
               candidates: candidateCount,
               visible: inspectionRenderables.length,
@@ -30061,7 +32347,7 @@ function createRenderSystem(internals) {
               visible: true
             })),
             submit: {
-              frameId: frameState.frameNumber,
+              frameId: lodSubmitFrameId,
               build: resolveInspectionBuild(internals),
               deviceGeneration: internals.deviceScope.generation
             },
@@ -30072,7 +32358,12 @@ function createRenderSystem(internals) {
           lastLodOcclusionInspection = void 0;
           lastLodWorldAttachments = /* @__PURE__ */ new Map();
         }
-        const temporalDemanded = cameras[0]?.antialias === "taa" || (cameras[0]?.motionBlur?.shutterAngle ?? 0) > 0;
+        const temporalDemanded = cameras[0]?.antialias === "taa" || cameras[0]?.motionBlur !== void 0 && motionBlurTemporalDemand({
+          shutterAngle: cameras[0].motionBlur.shutterAngle,
+          maxRadiusPixels: cameras[0].motionBlur.maxRadiusPixels,
+          sampleCount: cameras[0].motionBlur.sampleCount,
+          targetFps: cameras[0].motionBlur.targetFps ?? 60
+        });
         if (temporalDemanded) {
           persistentRenderScene.prepareTemporalFrame(submissionRenderables);
         }
@@ -30163,6 +32454,38 @@ function createRenderSystem(internals) {
           storageBuffer: internals.device.caps.storageBuffer,
           multisample: internals.device.caps.backendKind !== "wgpu-webgl2"
         });
+        const motionBlurParams = cameras[0]?.motionBlur;
+        let motionBlurDelta = 0;
+        try {
+          const delta = compositionWorlds[cameraOwner].getResource(Time).delta;
+          motionBlurDelta = Number.isFinite(delta) ? Math.max(0, delta) : 0;
+        } catch {
+          motionBlurDelta = 0;
+        }
+        const acceptedSampleTime = frameState.lastSuccessfulTemporalView?.sampleTimeSeconds;
+        const cameraViewIdentity = `camera:${cameras[0]?.entityKey ?? 0}`;
+        const canvasWidth = Math.max(1, internals.canvas.width);
+        const canvasHeight = Math.max(1, internals.canvas.height);
+        const motionBlurPlan = planMotionBlurFrame({
+          params: motionBlurParams,
+          sampleTimeSeconds: opts.sampleTimeSeconds,
+          acceptedSampleTimeSeconds: acceptedSampleTime,
+          fallbackDeltaSeconds: motionBlurDelta,
+          acceptedTemporal: frameState.lastSuccessfulTemporalView,
+          temporalReset: opts.temporalReset === true,
+          width: canvasWidth,
+          height: canvasHeight,
+          cameraViewIdentity,
+          historyVersion: cameras[0]?.historyVersion ?? 0,
+          environmentSignature: environment?.environmentSignature ?? "",
+          fogSignature: environment?.fogSignature ?? "",
+          deviceGeneration: internals.deviceScope?.generation ?? 0
+        });
+        const demandedMotionBlur = motionBlurPlan.demanded;
+        motionBlurFeatureInput = motionBlurPlan.featureInput;
+        if (demandedMotionBlur && internals.device.caps.compute === true && internals.device.caps.storageBuffer === true && internals.device.caps.storageTexture === true && internals.device.caps.rgba16floatRenderable === true) {
+          ensureMotionBlurFeature();
+        }
         preparedFeatureSkylightResources = preparedPipelineState === null ? void 0 : resolveMaterialSkylight(internals, preparedPipelineState, skylight, skylightCount).skylightResources;
         let featureGraphCandidate;
         const preparedResourceBatches = runProfiledRenderPhase(profileSession, "features", () => {
@@ -30171,6 +32494,7 @@ function createRenderSystem(internals) {
             worlds: compositionWorlds,
             owner: resourceOwner,
             frameNumber: frameState.frameNumber,
+            frameSize: { width: internals.canvas.width, height: internals.canvas.height },
             visibilitySnapshots: frame.featureVisibilitySnapshots,
             hiddenEntityReports: frame.hiddenEntityReports,
             targets: featureTargets,
@@ -30199,11 +32523,12 @@ function createRenderSystem(internals) {
             gpuWork: featureGpuWork
           });
           lastVisibilityStats.explicitlyHidden = featureFrame.hiddenEntityReports.length;
-          for (const featureError of featureFrame.errors) {
-            if (!isPendingRenderFeaturePreparation(featureError)) {
-              internals.errorRegistry.fire(featureError);
-            }
-          }
+          reportPendingRenderFeatureErrors(
+            featureFrame.errors,
+            frameState.frameNumber,
+            pendingFeatureErrorLastReportedFrame,
+            internals.errorRegistry
+          );
           const postProcessParamsCandidate = preparePostProcessParamsResources(
             featureFrame.fullscreenEffects
           );
@@ -30287,7 +32612,8 @@ function createRenderSystem(internals) {
           }
           return runProfiledRenderPhase(profileSession, phase, action);
         };
-        if (cameras[0]?.bloom === "on") {
+        const bloomAdmitted = standardBloomAdmitted(cameras[0]);
+        if (bloomAdmitted) {
           internals.getPipelineState()?.perPassResources.ensureBloomResources?.();
         }
         const liveOutput = cameras[0]?.output;
@@ -30330,6 +32656,10 @@ function createRenderSystem(internals) {
               activeEntityKeys: visibilityProjection.activeEntityKeys,
               activeEntityRevision: visibilityProjection.activeEntityRevision,
               telemetryCandidateCount: lodCandidateCountForFrame,
+              telemetrySubmit: {
+                frameId: lodSubmitFrameId,
+                deviceGeneration: internals.deviceScope.generation
+              },
               ...occlusionProjection === void 0 ? {} : { occlusion: occlusionProjection }
             },
             compositionLeases,
@@ -30355,7 +32685,10 @@ function createRenderSystem(internals) {
             worldKeys,
             void 0,
             ssrDependencies,
-            dynamicGeometryFrames.onRenderableDraw(compositionWorlds)
+            dynamicGeometryFrames.onRenderableDraw(compositionWorlds),
+            environment?.fog,
+            opts.sampleTimeSeconds,
+            opts.temporalReset === true
           )
         );
         dynamicGeometryFrames.commit(submitted);
@@ -30433,7 +32766,7 @@ function createRenderSystem(internals) {
             frameState.depthOfFieldLastSubmitFailed = true;
           }
           internals.getPipelineState()?.perPassResources.commitBloomResources?.();
-          const nextBloom = cameras[0]?.bloom ?? "off";
+          const nextBloom = bloomAdmitted ? "on" : "off";
           if (frameState.lastSuccessfulBloom === "on" && nextBloom !== "on") {
             internals.getPipelineState()?.perPassResources.retireBloomResources?.(
               internals.device.queue.onSubmittedWorkDone()
@@ -30491,6 +32824,7 @@ function createRenderSystem(internals) {
           })
         );
       } finally {
+        if (!submitted) persistentRenderScene.discardTemporalFrame();
         internals.recoveryColdWorkGuard?.endFrame();
         if (ownsProfileFrame) {
           try {
@@ -30507,13 +32841,26 @@ function createRenderSystem(internals) {
       const currentFrameId = frameState.frameNumber - 1;
       return observeCurrentFrame(options, frameState.currentFrameObservationSource, currentFrameId);
     },
-    async observeLodOcclusion() {
+    async observeLodOcclusion(receipt) {
+      const capturedInspection = lastLodOcclusionInspection;
+      const capturedWorldAttachments = lastLodWorldAttachments;
+      if (capturedInspection === void 0) return;
+      if (receipt !== void 0 && (capturedInspection.submit.frameId !== receipt.frameId || capturedInspection.submit.deviceGeneration !== receipt.deviceGeneration))
+        return;
       await ensureOcclusionRuntime().waitForCompletions();
-      applyLodSelectionTelemetry(await gpuDrivenProduction.readLodSelection());
-      if (lastLodOcclusionInspection !== void 0) {
+      if (lastLodOcclusionInspection !== capturedInspection) return;
+      const selection = await gpuDrivenProduction.readLodSelection();
+      if (lastLodOcclusionInspection !== capturedInspection || selection === void 0) return;
+      if (selection.submit !== void 0 && (selection.submit.frameId !== capturedInspection.submit.frameId || selection.submit.deviceGeneration !== capturedInspection.submit.deviceGeneration))
+        return;
+      if (receipt !== void 0 && (selection.submit === void 0 || selection.submit.frameId !== receipt.frameId || selection.submit.deviceGeneration !== receipt.deviceGeneration))
+        return;
+      applyLodSelectionTelemetry(selection, capturedInspection, capturedWorldAttachments);
+      const published = lastLodOcclusionInspection;
+      if (published !== void 0 && published.submit.frameId === capturedInspection.submit.frameId && published.submit.deviceGeneration === capturedInspection.submit.deviceGeneration) {
         const queryLatency = ensureOcclusionRuntime().inspectQueryLatency();
         lastLodOcclusionInspection = inspectLodOcclusion({
-          ...lastLodOcclusionInspection,
+          ...published,
           queryLatencyUs: {
             median: queryLatency.median,
             p95: queryLatency.p95,
@@ -31727,6 +34074,16 @@ function tilemapChunkExtractSystem(world, lookup = () => void 0) {
     }
   }
 }
+
+// src/assembly/analytic-fog-registration.ts
+function registerAnalyticFogPostProcess(renderSystem, source, candidate) {
+  if (candidate) return;
+  renderSystem.registerBuiltinPostProcess("forgeax.analytic-fog", {
+    source,
+    params: { byteSize: 112, defaultValue: new Uint8Array(112) },
+    reads: ["scene-color", { key: "scene-depth", sampleType: "depth" }]
+  });
+}
 function fixedStepOf(world) {
   try {
     return world.getResource(FixedTime).tick;
@@ -32433,6 +34790,25 @@ function createRendererDynamicGeometryController(options) {
     host: createRendererDynamicGeometryHost({ ...options, lifecycle })
   };
 }
+
+// src/assembly/fxaa-registration.ts
+function registerFxaaPostProcess(renderSystem, source, registered) {
+  if (registered) return true;
+  renderSystem.registerBuiltinPostProcess(FXAA_POST_PROCESS_ID, {
+    source,
+    params: { byteSize: 16, defaultValue: new Uint8Array(16) },
+    reads: ["ldrColor"]
+  });
+  return true;
+}
+
+// src/assembly/lod-observation.ts
+function observeLodOcclusionForReceipt(renderSystem, receipt) {
+  return renderSystem.observeLodOcclusion({
+    frameId: receipt.frameId,
+    deviceGeneration: receipt.deviceGeneration
+  });
+}
 function makeShaderDeviceAdapter(rhiDevice, _errorRegistry, asyncCreateShaderModule, immediateCreateShaderModule, mode = "validated") {
   const moduleCache = /* @__PURE__ */ new Map();
   const errorCache = /* @__PURE__ */ new Map();
@@ -33076,6 +35452,18 @@ function resolveMaterialPipelineBindGroups(layoutKind, state, clustered = false)
 function isEngineOwnedMaterialShader(materialShaderId) {
   return materialShaderId === "forgeax::default-unlit" || materialShaderId === "forgeax::default-shadow-caster" || materialShaderId === "forgeax::sprite" || materialShaderId === "forgeax::sprite-lit" || materialShaderId === "forgeax::default-sprite" || materialShaderId === "forgeax::msdf-text" || materialShaderId === "forgeax::default-standard-pbr" || materialShaderId === "forgeax::pbr-skin" || materialShaderId === "forgeax::default-standard-pbr-skin";
 }
+
+// src/assembly/motion-blur-registration.ts
+function registerMotionBlurPostProcess(renderSystem, source) {
+  renderSystem.registerBuiltinPostProcess("forgeax.motion-blur", {
+    source,
+    params: {
+      byteSize: MOTION_BLUR_PARAMS_BYTE_SIZE,
+      defaultValue: new Uint8Array(MOTION_BLUR_PARAMS_BYTE_SIZE)
+    },
+    reads: ["scene-color", "scene-temporal"]
+  });
+}
 var ROOT_ORDER = /* @__PURE__ */ new Map([
   ["listener", 0],
   ["surface", 1],
@@ -36384,6 +38772,27 @@ function createMeshSsboGrowController(init) {
   };
   return { state, initialBuild, growMeshSsbo };
 }
+
+// src/assembly/temporal-post-process-prewarm.ts
+function createTemporalShaderPrewarmer(input) {
+  return async (entry, id) => {
+    if (entry === void 0) return;
+    const prewarm = await runShimStep(
+      () => input.asyncCreateShaderModule ? input.asyncCreateShaderModule(input.device, {
+        code: entry.wgsl,
+        label: postProcessShaderModuleLabel(id, entry.wgsl)
+      }) : invokeDeviceCreateShaderModule(input.device, {
+        code: entry.wgsl,
+        label: postProcessShaderModuleLabel(id, entry.wgsl)
+      }),
+      "shader-compile-failed",
+      `${id} shader module compiled (unified post-process prewarm)`,
+      `inspect manifest ${id} entry composed wgsl; check device.features`
+    );
+    if (!prewarm.ok) throw prewarm.error;
+    input.seedShaderModule(postProcessShaderModuleLabel(id, entry.wgsl), prewarm.value);
+  };
+}
 function createShader(input, code, label) {
   return input.asyncCreateShaderModule ? input.asyncCreateShaderModule(input.device, { code, label }) : Promise.resolve(invokeDeviceCreateShaderModule(input.device, { code, label }));
 }
@@ -36516,19 +38925,6 @@ function buildGpuDrivenPbrReadyLayouts(device, storageBufferCapable, pbrLayouts)
   };
 }
 
-// src/assembly/webgpu-ready-contract.ts
-var VIEW_UBO_BYTES = VIEW_UNIFORM_BUFFER_SIZE;
-var MIPMAP_PREWARM_FORMATS = [
-  "rgba8unorm-srgb",
-  "rgba8unorm",
-  "rgba16float"
-];
-var BRIGHT_PARAMS_BYTES = 16;
-var BLUR_PARAMS_BYTES = 16;
-var COMPOSITE_PARAMS_BYTES = 16;
-var HDR_COLOR_ATTACHMENT_FORMAT = "rgba16float";
-var DEPTH_TEXTURE_FORMAT = "depth24plus-stencil8";
-
 // src/assembly/webgpu-ready-mipmap.ts
 function adaptMipmapShaderModuleFactory(factory) {
   if (factory === void 0) return void 0;
@@ -36541,7 +38937,7 @@ async function prewarmMipmapPipeline(rhiDevice, gpuStore, hasMaterialManifest) {
 }
 
 // src/assembly/webgpu-ready.ts
-async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, asyncCreateShaderModule, errorRegistry, requiredMaterialShaders, standardPbrShaderUvSetCount, requiredFullscreenPostProcesses, setGrowMeshSsboHook, seedShaderModule, seedMaterialShaderPipelineCache, registerBuiltinTonemap, registerBuiltinFxaa, registerBuiltinTemporalPostProcesses, registerBuiltinDepthOfField, setVolumetricFogShaderSources, setSsrShaderSources, setAtmosphereShaderSources) {
+async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, asyncCreateShaderModule, errorRegistry, requiredMaterialShaders, standardPbrShaderUvSetCount, requiredFullscreenPostProcesses, setGrowMeshSsboHook, seedShaderModule, seedMaterialShaderPipelineCache, registerBuiltinTonemap, registerBuiltinFxaa, registerBuiltinAnalyticFog, registerBuiltinTemporalPostProcesses, registerBuiltinDepthOfField, setVolumetricFogShaderSources, setSsrShaderSources, setAtmosphereShaderSources) {
   const extendedLightingShaderAvailable = deriveExtendedLightingCapability(rhiDevice).admitted;
   const capValue = rhiDevice.limits.maxStorageBuffersPerShaderStage;
   const webgl2Downlevel = rhiDevice.caps.backendKind === "wgpu-webgl2";
@@ -36576,8 +38972,8 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
   let spriteLitModule = null;
   let fxaaModule = null;
   let skyboxModule = null;
-  let bloomBrightModule = null;
-  let bloomBlurModule = null;
+  let bloomDownsampleModule = null;
+  let bloomUpsampleModule = null;
   let bloomCompositeModule = null;
   let ssaoModule = null;
   const findEngineManifestEntry = (identifier) => {
@@ -36608,8 +39004,8 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
     let probeBackgroundEntry;
     let fxaaEntry;
     let skyboxEntry;
-    let bloomBrightEntry;
-    let bloomBlurEntry;
+    let bloomDownsampleEntry;
+    let bloomUpsampleEntry;
     let bloomCompositeEntry;
     let ssaoEntry;
     let shadowCasterEntry = findEngineManifestEntry("forgeax::default-shadow-caster");
@@ -36666,12 +39062,12 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
         skyboxEntry ??= entry;
         continue;
       }
-      if (entry.wgsl.includes("BloomBrightParams")) {
-        bloomBrightEntry ??= entry;
+      if (entry.wgsl.includes("BloomDownsampleParams")) {
+        bloomDownsampleEntry ??= entry;
         continue;
       }
-      if (entry.wgsl.includes("BloomBlurParams")) {
-        bloomBlurEntry ??= entry;
+      if (entry.wgsl.includes("BloomUpsampleParams")) {
+        bloomUpsampleEntry ??= entry;
         continue;
       }
       if (entry.wgsl.includes("BloomCompositeParams")) {
@@ -37127,23 +39523,14 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
       tonemapPrewarm.value
     );
     registerBuiltinTonemap(tonemapEntry.wgsl);
-    const prewarmTemporal = async (entry, id) => {
-      if (entry === void 0) return;
-      const prewarm = await runShimStep(
-        () => asyncCreateShaderModule ? asyncCreateShaderModule(rhiDevice, {
-          code: entry.wgsl,
-          label: postProcessShaderModuleLabel(id, entry.wgsl)
-        }) : invokeDeviceCreateShaderModule(rhiDevice, {
-          code: entry.wgsl,
-          label: postProcessShaderModuleLabel(id, entry.wgsl)
-        }),
-        "shader-compile-failed",
-        `${id} shader module compiled (unified post-process prewarm)`,
-        `inspect manifest ${id} entry composed wgsl; check device.features`
-      );
-      if (!prewarm.ok) throw prewarm.error;
-      seedShaderModule(postProcessShaderModuleLabel(id, entry.wgsl), prewarm.value);
-    };
+    const prewarmTemporal = createTemporalShaderPrewarmer({
+      device: rhiDevice,
+      asyncCreateShaderModule,
+      seedShaderModule
+    });
+    const analyticFogEntry = findEngineManifestEntry("forgeax::analytic-fog");
+    await prewarmTemporal(analyticFogEntry, "forgeax.analytic-fog");
+    if (analyticFogEntry !== void 0) registerBuiltinAnalyticFog(analyticFogEntry.wgsl);
     await prewarmTemporal(motionBlurEntry, "forgeax.motion-blur");
     await prewarmTemporal(taaResolveEntry, "forgeax.taa-resolve");
     await prewarmDepthOfField(manifestEntries, prewarmTemporal, registerBuiltinDepthOfField);
@@ -37264,34 +39651,37 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
       if (!skyboxShaderResult.ok) throw skyboxShaderResult.error;
       skyboxModule = skyboxShaderResult.value;
     }
-    if (bloomBrightEntry !== void 0) {
+    if (bloomDownsampleEntry !== void 0) {
       const result = await runShimStep(
         () => asyncCreateShaderModule ? asyncCreateShaderModule(rhiDevice, {
-          code: bloomBrightEntry.wgsl,
-          label: "bloom-bright"
+          code: bloomDownsampleEntry.wgsl,
+          label: "bloom-downsample"
         }) : invokeDeviceCreateShaderModule(rhiDevice, {
-          code: bloomBrightEntry.wgsl,
-          label: "bloom-bright"
+          code: bloomDownsampleEntry.wgsl,
+          label: "bloom-downsample"
         }),
         "shader-compile-failed",
-        "bloom-bright shader module compiled",
-        "inspect manifest bloom-bright entry composed wgsl; check device.features"
+        "bloom-downsample shader module compiled",
+        "inspect manifest bloom-downsample entry composed wgsl; check device.features"
       );
       if (!result.ok) throw result.error;
-      bloomBrightModule = result.value;
+      bloomDownsampleModule = result.value;
     }
-    if (bloomBlurEntry !== void 0) {
+    if (bloomUpsampleEntry !== void 0) {
       const result = await runShimStep(
-        () => asyncCreateShaderModule ? asyncCreateShaderModule(rhiDevice, { code: bloomBlurEntry.wgsl, label: "bloom-blur" }) : invokeDeviceCreateShaderModule(rhiDevice, {
-          code: bloomBlurEntry.wgsl,
-          label: "bloom-blur"
+        () => asyncCreateShaderModule ? asyncCreateShaderModule(rhiDevice, {
+          code: bloomUpsampleEntry.wgsl,
+          label: "bloom-upsample"
+        }) : invokeDeviceCreateShaderModule(rhiDevice, {
+          code: bloomUpsampleEntry.wgsl,
+          label: "bloom-upsample"
         }),
         "shader-compile-failed",
-        "bloom-blur shader module compiled",
-        "inspect manifest bloom-blur entry composed wgsl; check device.features"
+        "bloom-upsample shader module compiled",
+        "inspect manifest bloom-upsample entry composed wgsl; check device.features"
       );
       if (!result.ok) throw result.error;
-      bloomBlurModule = result.value;
+      bloomUpsampleModule = result.value;
     }
     if (bloomCompositeEntry !== void 0) {
       const result = await runShimStep(
@@ -37979,10 +40369,10 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
         } else if (fragModule === skyboxModule) {
           const msaa = d.multisample;
           label = msaa !== void 0 ? "skybox-pipeline-msaa" : "skybox-pipeline";
-        } else if (fragModule === bloomBrightModule) {
-          label = "bloom-bright-pipeline";
-        } else if (fragModule === bloomBlurModule) {
-          label = d.label ?? "bloom-blur-h-pipeline";
+        } else if (fragModule === bloomDownsampleModule) {
+          label = "bloom-downsample-pipeline";
+        } else if (fragModule === bloomUpsampleModule) {
+          label = "bloom-upsample-pipeline";
         } else if (fragModule === bloomCompositeModule) {
           label = "bloom-composite-pipeline";
         } else if (fragModule === ssaoModule) {
@@ -38065,17 +40455,15 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
   let skyboxSamplerHandle = null;
   let skyboxRotationBufferHandle = null;
   let skyboxPipelineMsaaHandle = null;
-  let bloomBrightPipelineHandle = null;
-  let bloomBlurHPipelineHandle = null;
-  let bloomBlurVPipelineHandle = null;
+  let bloomDownsamplePipelineHandle = null;
+  let bloomUpsamplePipelineHandle = null;
   let bloomCompositePipelineHandle = null;
-  let bloomBrightBglHandle = null;
-  let bloomBlurBglHandle = null;
+  let bloomDownsampleBglHandle = null;
+  let bloomUpsampleBglHandle = null;
   let bloomCompositeBglHandle = null;
   let bloomSamplerHandle = null;
-  let bloomBrightParamsBufferHandle = null;
-  let bloomBlurHParamsBufferHandle = null;
-  let bloomBlurVParamsBufferHandle = null;
+  let bloomDownsampleParamsBufferHandle = null;
+  let bloomUpsampleParamsBufferHandle = null;
   let bloomCompositeParamsBufferHandle = null;
   let bloomResourcesReady = false;
   let ensureBloomResources;
@@ -38106,20 +40494,7 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
     drainBloomResources?.();
   };
   const inspectBloomResourcesStable = (graph) => {
-    return inspectBloomResources?.(graph) ?? {
-      graphStatus: "empty",
-      enabled: false,
-      targetCount: 0,
-      targetBytes: 0,
-      resourceCount: 0,
-      passCount: 0,
-      encodeCount: 0,
-      bindGroupCount: 0,
-      uploadCount: 0,
-      residentChildBytes: 0,
-      generation: 0,
-      state: "off"
-    };
+    return inspectBloomResources?.(graph) ?? emptyBloomInspection();
   };
   let ssaoCalcPipelineHandle = null;
   let ssaoBlurPipelineHandle = null;
@@ -38356,7 +40731,7 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
         return value;
       };
       try {
-        if (bloomBrightModule !== null || bloomBlurModule !== null || bloomCompositeModule !== null) {
+        if (bloomDownsampleModule !== null || bloomUpsampleModule !== null || bloomCompositeModule !== null) {
           const bloomSamplerResult = runShimSyncStep(
             () => rhiDevice.createSampler({
               label: "bloom-sampler",
@@ -38373,10 +40748,10 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
           if (!bloomSamplerResult.ok) throw bloomSamplerResult.error;
           bloomSamplerHandle = adopt("binding", bloomSamplerResult.value, () => void 0);
         }
-        if (bloomBrightModule !== null && bloomSamplerHandle !== null) {
-          const brightBglResult = runShimSyncStep(
+        if (bloomDownsampleModule !== null && bloomSamplerHandle !== null) {
+          const downsampleBglResult = runShimSyncStep(
             () => rhiDevice.createBindGroupLayout({
-              label: "bloom-bright-bgl",
+              label: "bloom-downsample-bgl",
               entries: [
                 {
                   binding: 0,
@@ -38396,26 +40771,26 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               ]
             }),
             "webgpu-runtime-error",
-            "createBindGroupLayout(bloom-bright) succeeded",
+            "createBindGroupLayout(bloom-downsample) succeeded",
             "check device.limits.maxBindGroupsPerPipelineLayout"
           );
-          if (!brightBglResult.ok) throw brightBglResult.error;
-          bloomBrightBglHandle = adopt("binding", brightBglResult.value, () => void 0);
-          const brightPlResult = runShimSyncStep(
+          if (!downsampleBglResult.ok) throw downsampleBglResult.error;
+          bloomDownsampleBglHandle = adopt("binding", downsampleBglResult.value, () => void 0);
+          const downsamplePlResult = runShimSyncStep(
             () => rhiDevice.createPipelineLayout({
-              label: "bloom-bright-pl",
-              bindGroupLayouts: [brightBglResult.value]
+              label: "bloom-downsample-pl",
+              bindGroupLayouts: [downsampleBglResult.value]
             }),
             "webgpu-runtime-error",
-            "createPipelineLayout(bloom-bright) succeeded",
-            "verify bloom-bright BindGroupLayout matches shader @group(0) bindings"
+            "createPipelineLayout(bloom-downsample) succeeded",
+            "verify bloom-downsample BindGroupLayout matches shader @group(0) bindings"
           );
-          if (!brightPlResult.ok) throw brightPlResult.error;
-          adopt("binding", brightPlResult.value, () => void 0);
+          if (!downsamplePlResult.ok) throw downsamplePlResult.error;
+          adopt("binding", downsamplePlResult.value, () => void 0);
           {
-            const brightSpec = {
+            const downsampleSpec = {
               shader: {
-                id: "forgeax::post::bloom-bright",
+                id: "forgeax::post::bloom-downsample",
                 passKind: "post-process",
                 variantSet: void 0
               },
@@ -38432,20 +40807,21 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               renderState: { cullMode: "none" }
             };
             const modules = {
-              vertex: bloomBrightModule,
-              fragment: bloomBrightModule,
-              layout: brightPlResult.value
+              vertex: bloomDownsampleModule,
+              fragment: bloomDownsampleModule,
+              layout: downsamplePlResult.value,
+              label: "bloom-downsample-pipeline"
             };
             try {
-              bloomBrightPipelineHandle = getOrBuildPipeline(
-                brightSpec,
+              bloomDownsamplePipelineHandle = getOrBuildPipeline(
+                downsampleSpec,
                 pipelineDeviceProvider,
                 pipelineCache,
                 modules
               );
-              bloomBrightPipelineHandle = adopt(
+              bloomDownsamplePipelineHandle = adopt(
                 "pipeline",
-                bloomBrightPipelineHandle,
+                bloomDownsamplePipelineHandle,
                 () => void 0
               );
             } catch (err54) {
@@ -38453,30 +40829,34 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
                 detail: { cause: err54 },
-                hint: "createRenderPipeline (bloom-bright fullscreen) failed; inspect gpuMessage"
+                hint: "createRenderPipeline (bloom-downsample fullscreen) failed; inspect gpuMessage"
               });
             }
           }
-          const brightParamsResult = runShimSyncStep(
+          const downsampleParamsResult = runShimSyncStep(
             () => rhiDevice.createBuffer({
-              label: "bloom-bright-params-ubo",
-              size: BRIGHT_PARAMS_BYTES,
+              label: "bloom-downsample-params-ubo",
+              size: BLOOM_DOWNSAMPLE_PARAMS_BYTES,
               usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
               mappedAtCreation: false
             }),
             "webgpu-runtime-error",
-            "createBuffer (bloom-bright params UBO) succeeded",
+            "createBuffer (bloom-downsample params UBO) succeeded",
             "check device.limits.maxUniformBufferBindingSize"
           );
-          if (!brightParamsResult.ok) throw brightParamsResult.error;
-          bloomBrightParamsBufferHandle = adopt("buffer", brightParamsResult.value, (value) => {
-            rhiDevice.destroyBuffer(value);
-          });
+          if (!downsampleParamsResult.ok) throw downsampleParamsResult.error;
+          bloomDownsampleParamsBufferHandle = adopt(
+            "buffer",
+            downsampleParamsResult.value,
+            (value) => {
+              rhiDevice.destroyBuffer(value);
+            }
+          );
         }
-        if (bloomBlurModule !== null && bloomSamplerHandle !== null) {
-          const blurBglResult = runShimSyncStep(
+        if (bloomUpsampleModule !== null && bloomSamplerHandle !== null) {
+          const upsampleBglResult = runShimSyncStep(
             () => rhiDevice.createBindGroupLayout({
-              label: "bloom-blur-bgl",
+              label: "bloom-upsample-bgl",
               entries: [
                 {
                   binding: 0,
@@ -38486,36 +40866,41 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 {
                   binding: 1,
                   visibility: GPU_SHADER_STAGE_FRAGMENT,
-                  sampler: { type: "filtering" }
+                  texture: { sampleType: "float", viewDimension: "2d" }
                 },
                 {
                   binding: 2,
                   visibility: GPU_SHADER_STAGE_FRAGMENT,
+                  sampler: { type: "filtering" }
+                },
+                {
+                  binding: 3,
+                  visibility: GPU_SHADER_STAGE_FRAGMENT,
                   buffer: { type: "uniform" }
                 }
               ]
             }),
             "webgpu-runtime-error",
-            "createBindGroupLayout(bloom-blur) succeeded",
+            "createBindGroupLayout(bloom-upsample) succeeded",
             "check device.limits.maxBindGroupsPerPipelineLayout"
           );
-          if (!blurBglResult.ok) throw blurBglResult.error;
-          bloomBlurBglHandle = adopt("binding", blurBglResult.value, () => void 0);
-          const blurPlResult = runShimSyncStep(
+          if (!upsampleBglResult.ok) throw upsampleBglResult.error;
+          bloomUpsampleBglHandle = adopt("binding", upsampleBglResult.value, () => void 0);
+          const upsamplePlResult = runShimSyncStep(
             () => rhiDevice.createPipelineLayout({
-              label: "bloom-blur-pl",
-              bindGroupLayouts: [blurBglResult.value]
+              label: "bloom-upsample-pl",
+              bindGroupLayouts: [upsampleBglResult.value]
             }),
             "webgpu-runtime-error",
-            "createPipelineLayout(bloom-blur) succeeded",
-            "verify bloom-blur BindGroupLayout matches shader @group(0) bindings"
+            "createPipelineLayout(bloom-upsample) succeeded",
+            "verify bloom-upsample BindGroupLayout matches shader @group(0) bindings"
           );
-          if (!blurPlResult.ok) throw blurPlResult.error;
-          adopt("binding", blurPlResult.value, () => void 0);
+          if (!upsamplePlResult.ok) throw upsamplePlResult.error;
+          adopt("binding", upsamplePlResult.value, () => void 0);
           {
-            const blurSpec = {
+            const upsampleSpec = {
               shader: {
-                id: "forgeax::post::bloom-blur",
+                id: "forgeax::post::bloom-upsample",
                 passKind: "post-process",
                 variantSet: void 0
               },
@@ -38532,21 +40917,21 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               renderState: { cullMode: "none" }
             };
             const modules = {
-              vertex: bloomBlurModule,
-              fragment: bloomBlurModule,
-              layout: blurPlResult.value,
-              label: "bloom-blur-h-pipeline"
+              vertex: bloomUpsampleModule,
+              fragment: bloomUpsampleModule,
+              layout: upsamplePlResult.value,
+              label: "bloom-upsample-pipeline"
             };
             try {
-              bloomBlurHPipelineHandle = getOrBuildPipeline(
-                blurSpec,
+              bloomUpsamplePipelineHandle = getOrBuildPipeline(
+                upsampleSpec,
                 pipelineDeviceProvider,
                 pipelineCache,
                 modules
               );
-              bloomBlurHPipelineHandle = adopt(
+              bloomUpsamplePipelineHandle = adopt(
                 "pipeline",
-                bloomBlurHPipelineHandle,
+                bloomUpsamplePipelineHandle,
                 () => void 0
               );
             } catch (err54) {
@@ -38554,39 +40939,23 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
                 detail: { cause: err54 },
-                hint: "createRenderPipeline (bloom-blur-h fullscreen) failed; inspect gpuMessage"
+                hint: "createRenderPipeline (bloom-upsample fullscreen) failed; inspect gpuMessage"
               });
             }
-            bloomBlurVPipelineHandle = bloomBlurHPipelineHandle;
           }
-          const blurHParamsResult = runShimSyncStep(
-            () => rhiDevice.createBuffer({
-              label: "bloom-blur-h-params-ubo",
-              size: BLUR_PARAMS_BYTES,
-              usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-              mappedAtCreation: false
-            }),
-            "webgpu-runtime-error",
-            "createBuffer (bloom-blur-h params UBO) succeeded",
-            "check device.limits.maxUniformBufferBindingSize"
-          );
-          if (!blurHParamsResult.ok) throw blurHParamsResult.error;
-          bloomBlurHParamsBufferHandle = adopt("buffer", blurHParamsResult.value, (value) => {
-            rhiDevice.destroyBuffer(value);
-          });
-          const blurVParamsResult = runShimSyncStep(
+          const upsampleParamsResult = runShimSyncStep(
             () => rhiDevice.createBuffer({
-              label: "bloom-blur-v-params-ubo",
-              size: BLUR_PARAMS_BYTES,
+              label: "bloom-upsample-params-ubo",
+              size: BLOOM_UPSAMPLE_PARAMS_BYTES,
               usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
               mappedAtCreation: false
             }),
             "webgpu-runtime-error",
-            "createBuffer (bloom-blur-v params UBO) succeeded",
+            "createBuffer (bloom-upsample params UBO) succeeded",
             "check device.limits.maxUniformBufferBindingSize"
           );
-          if (!blurVParamsResult.ok) throw blurVParamsResult.error;
-          bloomBlurVParamsBufferHandle = adopt("buffer", blurVParamsResult.value, (value) => {
+          if (!upsampleParamsResult.ok) throw upsampleParamsResult.error;
+          bloomUpsampleParamsBufferHandle = adopt("buffer", upsampleParamsResult.value, (value) => {
             rhiDevice.destroyBuffer(value);
           });
         }
@@ -38682,7 +41051,7 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
           const compositeParamsResult = runShimSyncStep(
             () => rhiDevice.createBuffer({
               label: "bloom-composite-params-ubo",
-              size: COMPOSITE_PARAMS_BYTES,
+              size: BLOOM_COMPOSITE_PARAMS_BYTES,
               usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
               mappedAtCreation: false
             }),
@@ -38702,17 +41071,15 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
         bloomCandidateBundle = {
           scope: candidateScope,
           generation: bloomGeneration + 1,
-          bloomBrightPipeline: bloomBrightPipelineHandle,
-          bloomBlurHPipeline: bloomBlurHPipelineHandle,
-          bloomBlurVPipeline: bloomBlurVPipelineHandle,
+          bloomDownsamplePipeline: bloomDownsamplePipelineHandle,
+          bloomUpsamplePipeline: bloomUpsamplePipelineHandle,
           bloomCompositePipeline: bloomCompositePipelineHandle,
-          bloomBrightBindGroupLayout: bloomBrightBglHandle,
-          bloomBlurBindGroupLayout: bloomBlurBglHandle,
+          bloomDownsampleBindGroupLayout: bloomDownsampleBglHandle,
+          bloomUpsampleBindGroupLayout: bloomUpsampleBglHandle,
           bloomCompositeBindGroupLayout: bloomCompositeBglHandle,
           bloomSampler: bloomSamplerHandle,
-          bloomBrightParamsBuffer: bloomBrightParamsBufferHandle,
-          bloomBlurHParamsBuffer: bloomBlurHParamsBufferHandle,
-          bloomBlurVParamsBuffer: bloomBlurVParamsBufferHandle,
+          bloomDownsampleParamsBuffer: bloomDownsampleParamsBufferHandle,
+          bloomUpsampleParamsBuffer: bloomUpsampleParamsBufferHandle,
           bloomCompositeParamsBuffer: bloomCompositeParamsBufferHandle
         };
         inspectBloomResources = (graph) => {
@@ -38726,6 +41093,10 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
             return {
               graphStatus: "empty",
               enabled: false,
+              levelCount: 0,
+              levelDimensions: [],
+              downsamplePassCount: 0,
+              upsamplePassCount: 0,
               targetCount: 0,
               targetBytes: 0,
               resourceCount: 0,
@@ -38749,6 +41120,10 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
           return {
             graphStatus: active === void 0 ? "empty" : graphInspection.status,
             enabled: active !== void 0,
+            levelCount: active === void 0 ? 0 : graphInspection.levelCount,
+            levelDimensions: active === void 0 ? [] : graphInspection.levelDimensions,
+            downsamplePassCount: active === void 0 ? 0 : graphInspection.downsamplePassCount,
+            upsamplePassCount: active === void 0 ? 0 : graphInspection.upsamplePassCount,
             targetCount: active === void 0 ? 0 : graphInspection.targetCount,
             targetBytes: active === void 0 ? 0 : graphInspection.targetBytes,
             resourceCount: ownedBundles.reduce(
@@ -38759,7 +41134,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
             encodeCount: active === void 0 ? 0 : receipts.encodeCount,
             bindGroupCount: active === void 0 ? 0 : receipts.bindGroupCount,
             uploadCount: active === void 0 ? 0 : receipts.uploadCount,
-            residentChildBytes: 0,
+            // The graph owns the target allocations.  Use its validated
+            // descriptor byte sum for the active child; zero is reserved for
+            // an absent/invalid current graph, never a placeholder for a
+            // live Bloom allocation.
+            residentChildBytes: active === void 0 || graphInspection.status !== "valid" ? 0 : graphInspection.targetBytes,
             generation: selected?.generation ?? 0,
             state
           };
@@ -38836,17 +41215,15 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
         commitBloomResources = void 0;
         discardBloomResources = void 0;
         drainBloomResources = void 0;
-        bloomBrightPipelineHandle = null;
-        bloomBlurHPipelineHandle = null;
-        bloomBlurVPipelineHandle = null;
+        bloomDownsamplePipelineHandle = null;
+        bloomUpsamplePipelineHandle = null;
         bloomCompositePipelineHandle = null;
-        bloomBrightBglHandle = null;
-        bloomBlurBglHandle = null;
+        bloomDownsampleBglHandle = null;
+        bloomUpsampleBglHandle = null;
         bloomCompositeBglHandle = null;
         bloomSamplerHandle = null;
-        bloomBrightParamsBufferHandle = null;
-        bloomBlurHParamsBufferHandle = null;
-        bloomBlurVParamsBufferHandle = null;
+        bloomDownsampleParamsBufferHandle = null;
+        bloomUpsampleParamsBufferHandle = null;
         bloomCompositeParamsBufferHandle = null;
         throw cause;
       }
@@ -39160,24 +41537,17 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
       shadowLightSpaceMatrix: null,
       shadowCsmLightViewProj: null,
       shadowCsmSelection: null,
-      // feat-20260531-bloom-first-declarative-render-graph-pass / w13 + w16:
-      // bloom per-pass resource slots. Pipeline handles assembled during
-      // buildReadyWebGPU (marker-triage + compile + createRenderPipeline).
-      // Intermediate textures are allocate in the execute closures at 1/2-res
-      // (ensureLazyTexture, slot width/height tracking for size-drift rebuild).
-      // BindGroup caches survive until the intermediate view is invalidated
-      // by a resize (width/height drift forces null).
-      bloomBrightPipeline: null,
-      bloomBlurHPipeline: null,
-      bloomBlurVPipeline: null,
+      // Multiscale Bloom pipeline handles are generation-owned by the ready
+      // builder; graph targets are frame-owned and are not stored here.
+      bloomDownsamplePipeline: null,
+      bloomUpsamplePipeline: null,
       bloomCompositePipeline: null,
-      bloomBrightBindGroupLayout: null,
-      bloomBlurBindGroupLayout: null,
+      bloomDownsampleBindGroupLayout: null,
+      bloomUpsampleBindGroupLayout: null,
       bloomCompositeBindGroupLayout: null,
       bloomSampler: null,
-      bloomBrightParamsBuffer: null,
-      bloomBlurHParamsBuffer: null,
-      bloomBlurVParamsBuffer: null,
+      bloomDownsampleParamsBuffer: null,
+      bloomUpsampleParamsBuffer: null,
       bloomCompositeParamsBuffer: null,
       ensureBloomResources: ensureBloomResourcesStable,
       getBloomResources: getBloomResourcesStable,
@@ -39189,18 +41559,6 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
       retireBloomResources: retireBloomResourcesStable,
       drainBloomResources: drainBloomResourcesStable,
       inspectBloomResources: inspectBloomResourcesStable,
-      bloomBrightTexture: null,
-      bloomBrightView: null,
-      bloomBrightWidth: 0,
-      bloomBrightHeight: 0,
-      bloomBlurHTexture: null,
-      bloomBlurHView: null,
-      bloomBlurHWidth: 0,
-      bloomBlurHHeight: 0,
-      bloomBlurVTexture: null,
-      bloomBlurVView: null,
-      bloomBlurVWidth: 0,
-      bloomBlurVHeight: 0,
       // feat-20260612-hdrp-ssao M6 / w26 + M8 / w38: SSAO pipeline slots.
       ssaoCalcPipeline: ssaoCalcPipelineHandle,
       ssaoBlurPipeline: ssaoBlurPipelineHandle,
@@ -40246,22 +42604,13 @@ async function makeWebGPURenderer(internals) {
       tonemapRegistered = true;
     },
     (source) => {
-      if (fxaaRegistered) return;
-      renderSystem.registerBuiltinPostProcess(FXAA_POST_PROCESS_ID, {
-        source,
-        params: { byteSize: 16, defaultValue: new Uint8Array(16) },
-        reads: ["ldrColor"]
-      });
-      fxaaRegistered = true;
+      fxaaRegistered = registerFxaaPostProcess(renderSystem, source, fxaaRegistered);
     },
+    (source) => registerAnalyticFogPostProcess(renderSystem, source, candidateBuildState !== void 0),
     (entries) => {
       if (candidateBuildState !== void 0 || temporalPostProcessesRegistered) return;
       if (entries.motionBlur !== void 0) {
-        renderSystem.registerBuiltinPostProcess("forgeax.motion-blur", {
-          source: entries.motionBlur,
-          params: { byteSize: 16, defaultValue: new Uint8Array(16) },
-          reads: ["scene-color", "scene-temporal"]
-        });
+        registerMotionBlurPostProcess(renderSystem, entries.motionBlur);
       }
       if (entries.taaResolve !== void 0) {
         renderSystem.registerBuiltinPostProcess("forgeax.taa-resolve", {
@@ -41168,20 +43517,7 @@ async function makeWebGPURenderer(internals) {
       const state = disposed ? "disposed" : deviceLost ? "device-lost" : health.reason === "internal-fault" || !readySettled ? "faulted" : "alive";
       const graph = deviceLost ? void 0 : renderSystem.perFrameGraphInfo;
       const standardLighting = deviceLost ? void 0 : renderSystem.standardLightingInspection;
-      const bloom = deviceLost ? {
-        graphStatus: "empty",
-        enabled: false,
-        targetCount: 0,
-        targetBytes: 0,
-        resourceCount: 0,
-        passCount: 0,
-        encodeCount: 0,
-        bindGroupCount: 0,
-        uploadCount: 0,
-        residentChildBytes: 0,
-        generation: 0,
-        state: "off"
-      } : renderSystem.bloom;
+      const bloom = deviceLost ? emptyBloomInspection() : renderSystem.bloom;
       const surfaceStorage = pipelineState?.format ?? "rgba8unorm";
       const surfaceDisplay = pipelineState?.colorAttachmentFormat ?? "rgba8unorm";
       const observationId = `${STANDARD_OUTPUT_TRANSFORM_FEATURE_ID}:frame-${frameId}`;
@@ -41600,6 +43936,7 @@ async function makeWebGPURenderer(internals) {
         cameraOwner,
         resourceOwner,
         ...frameRequest.camera.entityKey === void 0 ? {} : { cameraEntityKey: frameRequest.camera.entityKey },
+        ...motionBlurDrawOptions(frameRequest),
         ...frameRequest.profileFrame === void 0 ? {} : { profileFrame: frameRequest.profileFrame }
       } : options ?? { cameraOwner: 0, resourceOwner: 0 };
       if (disposed) {
@@ -41691,6 +44028,8 @@ async function makeWebGPURenderer(internals) {
           const cleanupFailure = disposeOwnedObservationCaptures(observationCaptureOwner.drain());
           volumeTimingCapture?.discard();
           if (cleanupFailure !== void 0) return err(cleanupFailure);
+          const invalidMotionBlur = renderSystem.motionBlurInvalidParams;
+          if (invalidMotionBlur !== void 0) return err(invalidMotionBlur);
           return err(
             new RendererContractFailureError(
               "draw",
@@ -41981,7 +44320,7 @@ async function makeWebGPURenderer(internals) {
           receiptObservationBuffers.delete(receipt);
         }
       }
-      await renderSystem.observeLodOcclusion();
+      await observeLodOcclusionForReceipt(renderSystem, receipt);
       const targetReadbacks = request.targetReadbacks === void 0 || request.targetReadbacks.length === 0 ? void 0 : await renderTargetHost.observeTargetReadbacks(receipt, request.targetReadbacks);
       if (targetReadbacks !== void 0 && !targetReadbacks.ok) return targetReadbacks;
       const volumeTimings = request.include.includes("timings") ? await (receiptTimings.get(receipt) ?? Promise.resolve({