@forgeax/engine-render 0.1.32 → 0.1.33

package/src/record/typed-frame-graph.ts

@@ -22,6 +22,7 @@ import type {
 import { RhiError } from '@forgeax/engine-rhi';
 import { err, ok, type Result } from '@forgeax/engine-types';
 import { executeRendererFrameTransaction } from '../assembly/renderer-frame-transaction';
+import { standardBloomAdmitted } from '../bloom-admission';
 import { type RenderError, RenderFeatureStageFailedError } from '../errors/render';
 import { depthOfFieldTopology } from '../features/depth-of-field/depth-of-field-feature';
 import { resolveDepthOfFieldFrameParams } from '../features/depth-of-field/depth-of-field-params';
@@ -30,6 +31,7 @@ import {
   hasSubmissionSensitiveFeatures,
   type RenderFeaturePlanExecution,
 } from '../features/host';
+import { motionBlurTemporalDemand } from '../features/motion-blur/motion-blur-params';
 import {
   type RenderFeaturePlannedFrame,
   renderFeaturePlanSignature,
@@ -62,7 +64,11 @@ import {
 } from '../gpu-texture-usage';
 import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM } from '../gpu-usage';
 import { createStandardSurfaceLightingBindGroup } from '../hdrp-buffers';
-import type { RenderFeatureGraphInspection } from '../inspection-types';
+import type {
+  MotionBlurExecutionPass,
+  MotionBlurExecutionReceipt,
+  RenderFeatureGraphInspection,
+} from '../inspection-types';
 import type { RenderExtent } from '../pipeline/render-extent';
 import {
   type StandardTopologyInputValue,
@@ -435,7 +441,15 @@ export function shouldUseTemporalFrameTransaction(
 export function isMotionBlurTemporalDemand(
   motionBlur: CameraSnapshot['motionBlur'] | undefined,
 ): boolean {
-  return motionBlur?.shutterAngle !== undefined && motionBlur.shutterAngle > 0;
+  return (
+    motionBlur !== undefined &&
+    motionBlurTemporalDemand({
+      shutterAngle: motionBlur.shutterAngle,
+      maxRadiusPixels: motionBlur.maxRadiusPixels,
+      sampleCount: motionBlur.sampleCount,
+      targetFps: motionBlur.targetFps ?? 60,
+    })
+  );
 }
 
 /**
@@ -1364,6 +1378,7 @@ function topologyOf(
   standardLighting: StandardTopologyInputValue | undefined,
   ssr: SsrSpatialAdmission | undefined,
   renderExtent: RenderExtent | undefined,
+  analyticFog: boolean,
 ): Result<RenderPipelineTopology, RhiError> {
   const cascadeCount = Math.max(1, Math.min(4, Math.round(lights.cascadeCount ?? 1))) as
     | 1
@@ -1430,6 +1445,7 @@ function topologyOf(
     reflectionFallback: { enabled: frameState.reflectionFallbackDemand === true },
     ssr,
     ...(renderExtent === undefined ? {} : { extent: renderExtent }),
+    analyticFog: !clearOnly && analyticFog,
     surface: {
       width,
       height,
@@ -1440,7 +1456,11 @@ function topologyOf(
     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 === undefined ? {} : { depthOfField }),
     },
     atmosphere: !clearOnly && frameState.environmentFrame?.source.kind === 'atmosphere',
@@ -1839,6 +1859,7 @@ export function ensureCompiledFrameGraph(
   onRecoveryError?: (error: unknown) => void,
   ssr?: SsrSpatialAdmission,
   renderExtent?: RenderExtent,
+  analyticFog = false,
 ): CompiledRenderGraph<RenderPipelineFrame> | null {
   const featureMetrics = mutableFeatureGraphInspection(internals);
   featureMetrics.ensureCalls += 1;
@@ -1904,6 +1925,7 @@ export function ensureCompiledFrameGraph(
     standardLighting,
     ssr,
     renderExtent,
+    analyticFog,
   );
   if (!topologyResult.ok) {
     featureMetrics.buildFailures += 1;
@@ -1918,6 +1940,16 @@ export function ensureCompiledFrameGraph(
   const featurePostProcessEntries =
     featureGraphCandidate?.fullscreenEffects ??
     getRenderFeatureGraphState(internals).fullscreenEffects;
+  // Motion Blur's compute plan intentionally has no raster fullscreen shader
+  // declaration, but it is still a post chain consumer: Standard Post owns
+  // the named `motion-input`/`motion-output` targets and must project it after
+  // TAA. Keep the identity in this deferred set alongside declared fullscreen
+  // effects so an early forward/deferred contribution cannot resolve its
+  // scene-data target against an incomplete target map.
+  const fullscreenFeatureIds = new Set([
+    ...featurePostProcessEntries.keys(),
+    'forgeax.motion-blur',
+  ]);
   const postProcessAdmission = resolvePostProcessChainAdmission(
     requestedPostEffects,
     (identity) => {
@@ -1965,8 +1997,19 @@ export function ensureCompiledFrameGraph(
         },
       }
     : topologyResult.value;
+  // Keep Bloom's positive parameter values out of the compiled identity. A
+  // crossing of zero has already changed topology.camera.bloom above; the
+  // remaining values are uploaded by the active recorder without rebuilding
+  // targets or pipelines.
+  const topologyIdentity = {
+    ...topology,
+    camera: {
+      ...topology.camera,
+      bloomIntensity: undefined,
+    },
+  };
   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
@@ -2087,7 +2130,6 @@ export function ensureCompiledFrameGraph(
     return lastKnownGood();
   }
   const ssrHistory = ssr?.status === 'admitted' ? importSsrHistoryTargets(builder) : undefined;
-  let projectedFeatures = false;
   const featureProjection = createRenderFeatureProjectionState();
   let featureShadows:
     | ReturnType<typeof projectRenderFeatureShadows<RenderPipelineFrame>>
@@ -2157,11 +2199,20 @@ export function ensureCompiledFrameGraph(
         namedTargets = {},
         standardSurfaceAccesses = [],
       ) => {
-        if (projectedFeatures) return ok(undefined);
-        projectedFeatures = true;
-        if (projectedFeaturePlans.value.length === 0) return ok(undefined);
+        // Forward/deferred scene lanes contribute feature plans before the
+        // Standard post chain has created its named input/output targets.
+        // Fullscreen effects (Motion Blur included) must wait for that later
+        // call so their temporal input is resolved after TAA. Other feature
+        // plans can still be projected at the forward contribution point.
+        const plans =
+          Object.keys(namedTargets).length === 0
+            ? projectedFeaturePlans.value.filter(
+                (execution) => !fullscreenFeatureIds.has(execution.featureIdentity),
+              )
+            : projectedFeaturePlans.value;
+        if (plans.length === 0) return ok(undefined);
         const resolveTarget = targetResolver(targets, semanticTargets, namedTargets);
-        const projected = projectPlanExecutions(builder, projectedFeaturePlans.value, {
+        const projected = projectPlanExecutions(builder, plans, {
           state: featureProjection,
           resolveTarget,
           standardSurfaceAccesses,
@@ -2302,6 +2353,93 @@ export function ensureCompiledFrameGraph(
   return compiled.value;
 }
 
+/**
+ * Project one accepted Motion Blur compute execution from the same graph and
+ * resolved dispatch objects used by the encoder. A plan/capability candidate
+ * without both executed passes deliberately returns no receipt.
+ */
+function deriveMotionBlurExecutionReceipt(
+  internals: RenderSystemInternals,
+  frameState: RenderFrameState,
+): MotionBlurExecutionReceipt | undefined {
+  const graph = frameState.compiledFrameGraph;
+  const deviceGeneration = internals.deviceScope?.generation;
+  if (graph === null || deviceGeneration === undefined) return undefined;
+  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 undefined;
+  }
+  const planned = getRenderFeatureGraphState(internals).plans.find(
+    (candidate) => candidate.featureIdentity === 'forgeax.motion-blur',
+  );
+  const execution =
+    planned === undefined ? undefined : getRenderFeaturePlanExecutionProjection(planned);
+  if (execution === undefined || execution.featureIdentity !== 'forgeax.motion-blur') {
+    return undefined;
+  }
+  const executionPass = (name: 'motion-blur-tile-summary' | 'motion-blur') =>
+    execution.passes.find((pass) => pass.name === name);
+  const summary = executionPass('motion-blur-tile-summary');
+  const reconstruct = executionPass('motion-blur');
+  if (
+    summary?.gpuCompute === undefined ||
+    reconstruct?.gpuCompute === undefined ||
+    summary.resolvedGpuCompute === undefined ||
+    reconstruct.resolvedGpuCompute === undefined
+  ) {
+    return undefined;
+  }
+  const directWorkgroups = (
+    pass: NonNullable<typeof summary.resolvedGpuCompute>,
+  ): readonly [number, number, number] | undefined => {
+    const dispatch = pass.dispatches[0];
+    if (dispatch === undefined || !('workgroups' in dispatch)) return undefined;
+    return dispatch.workgroups;
+  };
+  const summaryWorkgroups = directWorkgroups(summary.resolvedGpuCompute);
+  const reconstructWorkgroups = directWorkgroups(reconstruct.resolvedGpuCompute);
+  if (summaryWorkgroups === undefined || reconstructWorkgroups === undefined) return undefined;
+  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 undefined;
+  }
+  const summaryReceipt: MotionBlurExecutionPass = {
+    name: 'motion-blur-tile-summary',
+    kind: 'compute',
+    entryPoint: 'tile_summary',
+    workgroups: summaryWorkgroups,
+  };
+  const reconstructReceipt: MotionBlurExecutionPass = {
+    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' as const,
+    outputFormat: 'rgba16float' as const,
+    passes: [summaryReceipt, reconstructReceipt] as const,
+  });
+}
+
 export function executeCompiledFrameGraph(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
@@ -2338,6 +2476,7 @@ export function executeCompiledFrameGraph(
     rejectTemporalFrame();
     return false;
   }
+  const motionBlurExecution = deriveMotionBlurExecutionReceipt(internals, frameState);
   const legacyTimingInstrumentation =
     timingCapture === undefined ? undefined : createTimingInstrumentation(timingCapture);
   const timingHost = internals as RenderSystemInternals & {
@@ -2960,6 +3099,11 @@ export function executeCompiledFrameGraph(
     commit: () => {
       resolvedFrameHooks?.onSubmitted?.();
       legacySubmitCommit?.();
+      if (motionBlurExecution === undefined) {
+        delete frameState.motionBlurExecution;
+      } else {
+        frameState.motionBlurExecution = motionBlurExecution;
+      }
       if (frameState.temporalFrameInput !== undefined) {
         const temporal = frameState.temporalFrameTransaction.commit({ accepted: true });
         if (temporal.ok) {

package/src/recovery/render-system-candidate.ts

@@ -11,6 +11,7 @@ import {
 } from '@forgeax/engine-rhi';
 import type { Handle, MeshAsset, SamplerAsset, TextureAsset } from '@forgeax/engine-types';
 import { toShared } from '@forgeax/engine-types';
+import { standardBloomAdmitted } from '../bloom-admission';
 import { createClusterBinScratch } from '../cluster-binner';
 import type { EnvironmentLifecycle } from '../environment/lifecycle';
 import {
@@ -19,6 +20,7 @@ import {
   type RenderFeaturePreparedGraphicsResolverInput,
   runRenderFeatureFrame,
 } from '../features/host';
+import { motionBlurTemporalDemand } from '../features/motion-blur/motion-blur-params';
 import type { RenderFeatureGpuWorkOwner } from '../features/prepared-gpu-work';
 import { resolveStandardRenderFeatureTargets } from '../features/targets';
 import {
@@ -532,6 +534,10 @@ export function createRenderSystemRecovery(
           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,
@@ -794,29 +800,35 @@ export function createRenderSystemRecovery(
           throw new Error('recovery TAA pipeline is unavailable');
         }
       }
-      if (camera.motionBlur?.shutterAngle !== undefined && camera.motionBlur.shutterAngle > 0) {
+      if (
+        camera.motionBlur !== undefined &&
+        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 as GPUTextureFormat);
       }
-      if (camera.bloom === 'on' && camera.tonemap !== 'none') {
+      if (standardBloomAdmitted(camera)) {
         runtime.pipelineState.perPassResources.ensureBloomResources?.();
         const bloom = runtime.pipelineState.perPassResources.getBloomResources?.();
         if (
           bloom === null ||
           bloom === undefined ||
-          bloom.bloomBrightPipeline === null ||
-          bloom.bloomBlurHPipeline === null ||
-          bloom.bloomBlurVPipeline === null ||
+          bloom.bloomDownsamplePipeline === null ||
+          bloom.bloomUpsamplePipeline === null ||
           bloom.bloomCompositePipeline === null ||
-          bloom.bloomBrightBindGroupLayout === null ||
-          bloom.bloomBlurBindGroupLayout === null ||
+          bloom.bloomDownsampleBindGroupLayout === null ||
+          bloom.bloomUpsampleBindGroupLayout === null ||
           bloom.bloomCompositeBindGroupLayout === null ||
           bloom.bloomSampler === null ||
-          bloom.bloomBrightParamsBuffer === null ||
-          bloom.bloomBlurHParamsBuffer === null ||
-          bloom.bloomBlurVParamsBuffer === null ||
+          bloom.bloomDownsampleParamsBuffer === null ||
+          bloom.bloomUpsampleParamsBuffer === null ||
           bloom.bloomCompositeParamsBuffer === null
         ) {
           throw new Error('recovery Bloom resources are incomplete');

package/src/render-contract.ts

@@ -170,7 +170,8 @@ export interface CameraSnapshot {
   readonly bloom: BloomEnabled;
   readonly bloomThreshold: number;
   readonly bloomIntensity: number;
-  readonly bloomBlurRadius: number;
+  readonly bloomSoftKnee: number;
+  readonly bloomScatter: number;
   readonly clearColor: readonly [number, number, number, number];
   /** Optional active-camera SSR authoring fact, copied from the ECS schema. */
   readonly screenSpaceReflection?: ScreenSpaceReflectionData;
@@ -185,6 +186,8 @@ export interface CameraSnapshot {
     readonly shutterAngle: number;
     readonly maxRadiusPixels: number;
     readonly sampleCount: number;
+    /** Target presentation rate; zero follows the accepted frame interval. */
+    readonly targetFps?: number;
   };
 }
 
@@ -566,6 +569,19 @@ export interface RenderFrameInput {
   readonly leases: readonly RenderWorldLease[];
   readonly camera: FrameCamera;
   readonly environment: FrameEnvironment;
+  /**
+   * Monotonic host render-sample time in seconds. This is captured before ECS
+   * applies its simulation delta clamp, then accepted with frame submission.
+   * Omitting it keeps direct renderer callers on the ECS-clock fallback.
+   */
+  readonly sampleTimeSeconds?: number;
+  /**
+   * Mark the next submitted frame as a fresh temporal baseline. App sets this
+   * on resume so a short wall-clock pause cannot be mistaken for a valid
+   * motion pair; direct replay callers may use the same explicit lifecycle
+   * boundary.
+   */
+  readonly temporalReset?: boolean;
   /** Fixed-step publication consumed by dynamic geometry candidates. */
   readonly fixedStep?: number;
   /** Optional profiler correlation token owned by App and consumed by Render. */
@@ -811,6 +827,10 @@ export type DrawOwnerOptions = {
   readonly resourceOwner: number;
   /** Optional FrameCamera entity selection; absent preserves ActiveCamera semantics. */
   readonly cameraEntityKey?: number;
+  /** Monotonic host render-sample time in seconds, before the ECS delta clamp. */
+  readonly sampleTimeSeconds?: number;
+  /** Explicit pause/resume or replay lifecycle boundary for temporal owners. */
+  readonly temporalReset?: boolean;
   readonly profileFrame?: ProfileFrameToken;
 };
 
@@ -909,9 +929,8 @@ export const RENDER_GRAPH_EXECUTION_PHASE_CATALOG = [
   'record/graph-execute/skybox',
   'record/graph-execute/main',
   'record/graph-execute/fxaa',
-  'record/graph-execute/bloom-bright',
-  'record/graph-execute/bloom-blur-h',
-  'record/graph-execute/bloom-blur-v',
+  'record/graph-execute/bloom-downsample',
+  'record/graph-execute/bloom-upsample',
   'record/graph-execute/bloom-composite',
   'record/graph-execute/ssr-hiz',
   'record/graph-execute/ssr-trace',

package/src/render-pipeline.ts

@@ -224,6 +224,8 @@ export interface RenderPipelineTopology {
   readonly clearOnly?: boolean | undefined;
   /** Selected atmosphere requires the graph-owned sky producer and background. */
   readonly atmosphere?: boolean | undefined;
+  /** Finite-depth distance / exponential-height fog; no volume history. */
+  readonly analyticFog?: boolean | undefined;
   /** Whether Standard main draws carry the producer-owned fallback MRT. */
   readonly reflectionFallback?: { readonly enabled: boolean } | undefined;
   readonly surface: {
@@ -235,7 +237,10 @@ export interface RenderPipelineTopology {
   };
   /** Renderer-owned immutable dimensions for Standard graph consumers. */
   readonly extent?: RenderExtent;
-  readonly camera: Pick<RenderPipelineContext['camera'], 'tonemap' | 'antialias' | 'bloom'> & {
+  readonly camera: Pick<
+    RenderPipelineContext['camera'],
+    'tonemap' | 'antialias' | 'bloom' | 'bloomIntensity'
+  > & {
     /** Shape-only DoF admission; optical values remain per-frame UBO data. */
     readonly depthOfField?:
       | {

package/src/render-system-extract-tail.ts

@@ -86,6 +86,7 @@ import {
   gpuDrivenSourceDrawItemIndex,
 } from './extract/gpu-driven';
 import type { VisibilitySnapshot } from './extract/visibility';
+import { MotionBlurValidationError } from './features/motion-blur/motion-blur-params';
 import type {
   RenderFeatureHiddenEntityReport,
   RenderFeatureWorldVisibilitySnapshot,
@@ -350,6 +351,11 @@ export function extractFrames(
 
       framesByWorld.set(wi, frame);
     } catch (err) {
+      // Camera effect parameters are part of the public render contract. Keep
+      // their typed validation error on the renderer path so draw() can return
+      // a RenderError and publish the invalid inspection state; ordinary
+      // per-world extraction failures retain the existing world-local route.
+      if (err instanceof MotionBlurValidationError) throw err;
       // Per-world failure: route to world's own error handler, skip contribution.
       try {
         createWorldInternalView(world)._routeError(err, {
@@ -1571,6 +1577,8 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       mieCoefficient: value.mieCoefficient,
       mieDirectionalG: value.mieDirectionalG,
       sunAngularRadius: value.sunAngularRadius,
+      circumsolarStrength: value.circumsolarStrength,
+      circumsolarWidth: value.circumsolarWidth,
     } as const;
     environmentCandidates.push({
       kind: 'atmosphere',
@@ -1881,6 +1889,13 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       if (!authorVisible && !retainHidden) {
         continue;
       }
+      // A scalar shared<T> field uses slot 0 as the schema-level unbound
+      // sentinel. An entity carrying an unbound MeshFilter is not a
+      // renderable yet; keep it out of frame validation. Non-zero handles
+      // still follow the normal resolve/error path below.
+      if (isRenderable && fAssetHandle === 0) {
+        continue;
+      }
       const layerVal = fLayerValue ?? 0;
       // bug-20260709-builtin-quad-withoutaabb-disables-sprite-frustum-cu M2.5
       // (carries PR #598 feat-20260703 D-7): dispatch entries for this entity
@@ -3091,6 +3106,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           }
           instancesSnap = {
             transforms: collectionResult.value.transforms,
+            generations: collectionResult.value.generations,
             instanceCount: collectionResult.value.count,
             collectionId: collectionResult.value.collectionId,
             revision: collectionResult.value.revision,

package/src/render-system-extract.ts

@@ -27,7 +27,7 @@ import type { MaterialCookProgramContext } from '@forgeax/engine-pack/material-c
 //                                   fire; no renderable; no dispatch.
 //     - case B (material === 0)   : missing-spec sentinel; defaultMaterial
 //                                   Snapshot fills the slot. No fire.
-//     - case C (handle unresolved): assets.get(handle).err with the entity
+//     - case C (non-zero handle unresolved): assets.get(handle).err with the entity
 //                                   carrying the full T+MF+MR renderable
 //                                   archetype -> structured RhiError(
 //                                   `asset-not-registered`) routed through
@@ -61,8 +61,8 @@ import type { MaterialCookProgramContext } from '@forgeax/engine-pack/material-c
 //                               material; hint literal: `'pass
 //                               undefined or omit field to request
 //                               default material'` (AC-10).
-//   - case C dangling-ref     : `assets.get(handle).err` (strict path,
-//                               isRenderable === true) ->
+//   - case C dangling-ref     : `assets.get(handle).err` for a non-zero
+//                               handle (strict path, isRenderable === true) ->
 //                               `RhiError({ code: 'asset-not-
 //                               registered', detail: { assetHandle },
 //                               hint: 'register material via
@@ -73,7 +73,9 @@ import type { MaterialCookProgramContext } from '@forgeax/engine-pack/material-c
 //                               entity skipped from
 //                               RenderableSnapshot[] +
 //                               MaterialDispatchSnapshot[]; mirrors
-//                               `MeshFilter.assetHandle` dangling path
+//                               `MeshFilter.assetHandle` dangling path. A
+//                               scalar shared<T> slot 0 is the unbound,
+//                               non-renderable state and is skipped
 //                               (charter proposition 5; AC-11).
 //
 // Renderer-owned Large Instances:
@@ -96,7 +98,14 @@ import {
   selectMaterialPassProgram,
   walkMaterialPassesOverSharedRefs,
 } from '@forgeax/engine-assets-runtime';
-import type { Component, ComponentSchema, EntityHandle, Query, World } from '@forgeax/engine-ecs';
+import {
+  type Component,
+  type ComponentSchema,
+  type EntityHandle,
+  type Query,
+  Time,
+  type World,
+} from '@forgeax/engine-ecs';
 import { readRenderArrayView, routeWorldError } from '@forgeax/engine-ecs/projection';
 import { type Mat4, mat4, type Vec3, vec3 } from '@forgeax/engine-math';
 import { AssetGuid, type AssetGuid as AssetGuidBytes } from '@forgeax/engine-pack/guid';
@@ -133,7 +142,6 @@ import {
 import { buildCubeCameraFaceViews } from './capture/cube-views';
 import {
   antialiasFromF32,
-  bloomEnabledFromF32,
   CAMERA_EXPOSURE_MODE_MANUAL,
   Camera,
   CubeCamera,
@@ -148,6 +156,7 @@ import {
   ScreenSpaceReflection,
   tonemapFromF32,
   tonemapToU32,
+  validateCameraBloom,
   validateDynamicResolutionCamera,
 } from './components';
 import { DepthOfField } from './components/depth-of-field';
@@ -171,6 +180,7 @@ import {
   depthOfFieldRequestFailure,
   resolveDepthOfFieldParams,
 } from './features/depth-of-field/depth-of-field-params';
+import { resolveMotionBlurParams } from './features/motion-blur/motion-blur-params';
 import type {
   RenderFeatureHiddenEntityReport,
   RenderFeatureWorldVisibilitySnapshot,
@@ -665,6 +675,8 @@ export interface ExtractedVolumetricFog {
   readonly generation?: number;
   readonly digest?: string;
   readonly worldId?: number;
+  /** Canonical simulation time projected from this World for authored medium motion. */
+  readonly worldTimeSeconds?: number;
   /** Required same-World light selected by the authoring component. */
   readonly lightEntity?: EntityHandle;
   readonly lightKind?: 'directional' | 'point' | 'spot';
@@ -816,6 +828,9 @@ export type RenderableReactiveReason =
 export interface RenderableTemporalSnapshot {
   readonly previousEpoch: number | undefined;
   readonly previousSource: RenderablePreviousSource;
+  /** True only when current and previous geometry belong to one stable source identity. */
+  readonly motionValid: boolean;
+  /** Color-history invalidation is independent from motion validity. */
   readonly reactive: boolean;
   readonly reactiveReasons: readonly RenderableReactiveReason[];
   readonly previousTransform: TransformSnapshot;
@@ -836,6 +851,8 @@ export interface InstancesSnapshot {
   readonly collectionId?: InstanceCollectionId;
   /** Packed column-major mat4 transforms (16 f32 per instance). */
   readonly transforms: Float32Array;
+  /** Monotonic per-ordinal identity generations, when the collection owns them. */
+  readonly generations?: Uint32Array;
   /** Number of instances (transforms.length / 16). */
   readonly instanceCount: number;
   /** Collection revision captured by this detached frame snapshot. */
@@ -2994,6 +3011,9 @@ function collectCameraSnapshots(world: World): CameraSnapshot[] {
   for (const row of cameraQuery) {
     const cam = row.get(Camera);
     const motionBlur = row.get(MotionBlur);
+    const motionBlurResult = resolveMotionBlurParams(motionBlur);
+    if (!motionBlurResult.ok) throw motionBlurResult.error;
+    const motionBlurParams = motionBlurResult.value;
     const depthOfField = row.get(DepthOfField);
     const dynamicResolution = row.get(DynamicResolution);
     const screenSpaceReflection = row.get(ScreenSpaceReflection);
@@ -3054,10 +3074,17 @@ function collectCameraSnapshots(world: World): CameraSnapshot[] {
       ...(dynamicResolutionResult.value === undefined
         ? {}
         : { dynamicResolution: dynamicResolutionResult.value }),
-      bloom: bloomEnabledFromF32(cam.bloom),
+      bloom: validateCameraBloom(
+        cam.bloom,
+        cam.bloomThreshold,
+        cam.bloomIntensity,
+        cam.bloomSoftKnee,
+        cam.bloomScatter,
+      ),
       bloomThreshold: cam.bloomThreshold,
       bloomIntensity: cam.bloomIntensity,
-      bloomBlurRadius: cam.bloomBlurRadius,
+      bloomSoftKnee: cam.bloomSoftKnee,
+      bloomScatter: cam.bloomScatter,
       clearColor: [
         cam.clearColor[0] ?? 0,
         cam.clearColor[1] ?? 0,
@@ -3068,13 +3095,14 @@ function collectCameraSnapshots(world: World): CameraSnapshot[] {
         ? { depthOfField: depthOfFieldResult.value }
         : {}),
       ...(depthOfFieldError === undefined ? {} : { depthOfFieldError }),
-      ...(motionBlur === undefined
+      ...(motionBlurParams === undefined
         ? {}
         : {
             motionBlur: {
-              shutterAngle: motionBlur.shutterAngle,
-              maxRadiusPixels: motionBlur.maxRadiusPixels,
-              sampleCount: motionBlur.sampleCount,
+              shutterAngle: motionBlurParams.shutterAngle,
+              maxRadiusPixels: motionBlurParams.maxRadiusPixels,
+              sampleCount: motionBlurParams.sampleCount,
+              targetFps: motionBlurParams.targetFps,
             },
           }),
       ...(screenSpaceReflection === undefined
@@ -3332,6 +3360,8 @@ export function extractVolumeSnapshot(
   assets: AssetRegistry | null | undefined,
   worldInternal: WorldInternalView,
 ): ExtractedVolumetricFog | undefined {
+  const elapsed = world.getResource(Time).elapsed;
+  const worldTimeSeconds = Number.isFinite(elapsed) ? Math.max(0, elapsed) : 0;
   const query = world.query({ read: [VolumetricFog] }).unwrap();
   const authorings: VolumetricFogAuthoring[] = [];
   let selectedLight:
@@ -3377,7 +3407,7 @@ export function extractVolumeSnapshot(
           : resolved.error,
         { severity: Severity.Error, systemName: 'RenderSystem.extract (volumetric-density)' },
       );
-      return { status: 'degraded' };
+      return { status: 'degraded', worldTimeSeconds };
     }
     const densityAsset = resolved.value;
     const guid = assets?.guidOf(densityAsset) ?? `handle:${Number(densityHandle)}`;
@@ -3441,6 +3471,7 @@ export function extractVolumeSnapshot(
     });
     return {
       status: 'degraded',
+      worldTimeSeconds,
       ...(first === undefined
         ? {}
         : {
@@ -3480,6 +3511,7 @@ export function extractVolumeSnapshot(
         };
   return {
     status: 'available',
+    worldTimeSeconds,
     fog: extracted.value.fog,
     densityHandle: first.densityHandle,
     densityAsset: first.densityAsset,