@forgeax/engine-render 0.1.7 → 0.1.20

package/src/render-system.ts

@@ -16,10 +16,11 @@
 // .invert` (charter proposition 5: no math reinvention; render-system.test.ts
 // asserts `/@forgeax\/engine-math/` shows up in render-system.ts source).
 
-import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
+import { numMipLevels, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import type { World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
 import type { RecorderSession } from '@forgeax/engine-profiler';
+import type { CompiledRenderGraphInfo } from '@forgeax/engine-render-graph';
 import type { BindGroupEntry, BindGroupLayout, Buffer, RenderPipeline } from '@forgeax/engine-rhi';
 import { err, ok, type Result, RhiError } from '@forgeax/engine-rhi';
 import {
@@ -34,10 +35,12 @@ import {
   toShared,
 } from '@forgeax/engine-types';
 import { createClusterBinScratch } from './cluster-binner';
+import { EnvironmentLifecycle } from './environment/lifecycle';
 import {
   type ObservationUnavailableError,
   PointsLinesMaterialUnsupportedError,
   type RenderError,
+  TransmissionCapabilityMissingError,
 } from './errors/render';
 import {
   type RenderFeaturePreparedGraphicsResolverInput,
@@ -56,7 +59,13 @@ import {
   type PostProcessShaderEntry,
 } from './fullscreen-post-process-pass';
 import { GpuDrivenProduction } from './gpu-driven/production-raster';
-import type { RenderSceneInspection } from './inspection-types';
+import type {
+  BloomInspection,
+  MotionBlurInspection,
+  RenderSceneInspection,
+  TemporalTargetInspection,
+  TransmissionInspection,
+} from './inspection-types';
 import { admitPointsLines } from './points-lines/admission';
 import { PointsLinesExpansionCache } from './points-lines/expansion-cache';
 import {
@@ -71,10 +80,12 @@ import {
 import { createPointsLinesLaneAdapter, type PointsLinesBackend } from './points-lines/record';
 import type { PointsLinesRetainedSnapshot } from './points-lines/snapshot';
 import type { PointsLinesRecordOwner, PointsLinesRecordSubmission } from './record/render-context';
+import { inspectVolumetricFog } from './volume/inspection';
 
 export type { RenderSceneInspection } from './inspection-types';
 
 import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
+import type { EnvironmentInspection } from './environment/inspection';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_INDEX,
@@ -85,7 +96,12 @@ import { assembleMaterialWithSkylightEntries } from './ibl/skylight-bind-group';
 import { disposeInstanceBuffers, disposeTransientInstanceBuffers } from './instance-buffer-cache';
 import type { MeshMaterialBindingObservation } from './mesh-material-bindings';
 import { validateClusterGrid } from './pipeline/standard-pipeline';
-import { DEFAULT_CLUSTER_GRID } from './pipeline/standard-profile';
+import {
+  DEFAULT_CLUSTER_GRID,
+  DEFAULT_STANDARD_PROFILE,
+  resolveStandardLane,
+} from './pipeline/standard-profile';
+import { PipelineSpecError } from './pipeline-spec';
 import { PostProcessError } from './post-process-errors';
 import {
   createPreparedGraphicsResolver,
@@ -99,12 +115,19 @@ import {
   recordFrame,
 } from './record/frame';
 import { buildPerFrameBindGroups } from './record/frame-lighting';
-import type { RenderFrameState } from './record/frame-snapshot';
+import type {
+  CurrentGraphTarget,
+  GraphTargetCaptureRequest,
+  RenderFrameState,
+} from './record/frame-snapshot';
+import { getTextureIdentity } from './record/frame-snapshot';
+import type { GpuTimingCapture } from './record/gpu-timing';
 import { applyParamSnapshotToUbo, residentTextureView } from './record/main-pass-material';
 import type { RenderSystemInternals } from './record/render-context';
 import {
   type RenderFeatureGraphCandidate,
   resetRenderFeatureGraphState,
+  settleVolumetricFogGraphCandidate,
 } from './record/typed-frame-graph';
 import {
   type CameraSnapshot,
@@ -125,6 +148,20 @@ import {
   TRANSPARENT_SORT_MODE_LAYER_YZ,
   TRANSPARENT_SORT_MODE_LAYER_Z,
 } from './systems/transparent-sort-config';
+import { createTemporalFrameTransaction, type TemporalFrame } from './temporal/frame';
+import { retireTemporalGpuState } from './temporal/gpu';
+import { inspectTemporal, type TemporalInspection } from './temporal/inspection';
+import {
+  evaluateTransmissionCapability,
+  probeTransmissionCapability,
+  resolveTransmissionBackdropTopology,
+  TransmissionCandidateAdmission,
+} from './transmission/backdrop';
+import {
+  estimateTransmissionBackdropBytes,
+  inspectTransmission,
+  inspectTransmissionFromAdmission,
+} from './transmission/inspection';
 
 export type {
   _InternalRenderPipelineContext,
@@ -134,12 +171,15 @@ export type {
   RenderSystemInternals,
   RenderSystemRuntime,
   SurfaceBackendKind,
+  SurfaceCapabilityFacts,
+  SurfaceProfile,
   SwapChainFormatPair,
 } from './record/render-context';
 export {
   configureSurface,
   MATERIAL_PER_ENTITY_STRIDE,
   resolveSurfaceFormatPair,
+  resolveSurfaceProfile,
   STANDARD_PBR_UBO_SIZE,
   selectSwapChainFormat,
 } from './record/render-context';
@@ -289,6 +329,7 @@ export interface RenderSystem {
     worlds: readonly World[],
     opts: DrawOwnerOptions,
     renderReadLeases?: readonly RenderReadLease[],
+    timingCapture?: GpuTimingCapture,
   ): boolean;
   /** Release renderer-owned persistent state for one detached World. */
   detachScene(world: World): void;
@@ -297,6 +338,10 @@ export interface RenderSystem {
   observeCurrentFrame(
     options: FrameObservationOptions,
   ): Promise<Result<FrameObservation, ObservationUnavailableError>>;
+  /** Internal same-frame graph target access for backend diagnostics. */
+  getCurrentGraphTarget(name: string): CurrentGraphTarget | undefined;
+  /** Internal test capture copied into the draw's command submission. */
+  requestGraphTargetCapture(request: GraphTargetCaptureRequest): void;
   readonly pipelineDispatchCounts: {
     readonly unlit: number;
   };
@@ -309,6 +354,13 @@ export interface RenderSystem {
   readonly visibilityStats: { explicitlyHidden: number };
   /** Persistent scene maintenance evidence from the ordinary single-World path. */
   readonly renderScene: RenderSceneInspection;
+  readonly environment: EnvironmentInspection;
+  readonly temporal: TemporalInspection;
+  readonly bloom: BloomInspection;
+  readonly motionBlurInspection: MotionBlurInspection | undefined;
+  readonly temporalTargetInspection: TemporalTargetInspection | undefined;
+  /** Last completed transmission candidate facts, detached from GPU handles. */
+  readonly transmission: TransmissionInspection | undefined;
   /** Retained Points/Lines authoring facts from the single scene projection. */
   readonly pointsLinesSnapshots: readonly PointsLinesRetainedSnapshot[];
   /** Current mesh-slot provenance and active diagnostics from the last frame. */
@@ -322,6 +374,10 @@ export interface RenderSystem {
    * reaching into engine internals.
    */
   readonly perFramePassNames: readonly string[];
+  /** Camera antialias mode for the last successfully submitted frame. */
+  readonly lastSuccessfulCameraAntialias: CameraSnapshot['antialias'] | undefined;
+  /** Detached compiled-graph facts used by the renderer inspection owner. */
+  readonly perFrameGraphInfo: CompiledRenderGraphInfo | undefined;
   /**
    * feat-20260531-per-frame-bind-group-cache M1 / w4: per-frame
    * createBindGroup counter. Reset to 0 on every `draw([world], { cameraOwner: 0, resourceOwner: 0 })` entry,
@@ -341,6 +397,10 @@ export interface RenderSystem {
     readonly createBindGroup: number;
     readonly keys: readonly string[];
   };
+  /** Latest accepted-submit temporal POD; absent until the first accepted frame. */
+  readonly temporalFrame: TemporalFrame | undefined;
+  /** Current renderer-owned volumetric fog inspection snapshot. */
+  readonly volumetricFog: import('./volume/inspection').VolumetricFogInspection;
   /** Configure the sole Standard graph owner before the first frame. */
   configureStandard(config: RenderPipelineAsset['config']): void;
   /** Register one engine-owned post-process shader used by the Standard lane. */
@@ -701,6 +761,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   let releaseProfilerCatalog =
     phaseCatalogRegistration?.ok === true ? phaseCatalogRegistration.value : undefined;
   let preparedWorlds: readonly World[] = [];
+  let latestCamera: CameraSnapshot | undefined;
   const pointsLinesOwner = new StandardPointsLinesOwner(internals);
   const persistentRenderScene = new PersistentRenderScene({
     getDevice: () => internals.device,
@@ -709,6 +770,131 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       internals.gpuStore.invalidateMesh(handle, preparedWorlds[worldId] ?? worldId);
     },
   });
+  const environmentLifecycle = new EnvironmentLifecycle(internals.deviceScope);
+  const transmissionAdmission = new TransmissionCandidateAdmission();
+  let lastTransmissionInspection: TransmissionInspection | undefined;
+  let lastTransmissionKey = '';
+  let lastTransmissionAntialias: CameraSnapshot['antialias'] = 'none';
+  let transmissionCapabilityGeneration = -1;
+  let transmissionCapability:
+    | import('./transmission/backdrop').TransmissionCapabilityFacts
+    | undefined;
+  const prepareTransmissionCandidate = (antialias: CameraSnapshot['antialias']): boolean => {
+    const demand = persistentRenderScene.transmissionTopologyDemand();
+    if (demand.activeCount === 0) return true;
+    const topology = resolveTransmissionBackdropTopology({
+      demand,
+      sourceSampleCount: antialias === 'msaa' ? 4 : 1,
+    });
+    if (transmissionCapabilityGeneration !== internals.deviceScope.generation) {
+      transmissionCapability = probeTransmissionCapability(internals.device);
+      transmissionCapabilityGeneration = internals.deviceScope.generation;
+    }
+    if (transmissionCapability === undefined) {
+      throw new Error('transmission capability probe did not produce a result');
+    }
+    const capability = {
+      ...transmissionCapability,
+      msaaResolve: antialias === 'msaa' || topology.sourceSampleCount === 1,
+    } as const;
+    const verdict = evaluateTransmissionCapability(capability);
+    if (verdict.ok) return true;
+
+    const extent = {
+      width: Math.max(1, internals.canvas.width),
+      height: Math.max(1, internals.canvas.height),
+    };
+    const resource = {
+      extent,
+      format: capability.format,
+      mipCount: topology.mipCount === 0 ? 1 : numMipLevels(extent),
+      bytes: estimateTransmissionBackdropBytes(
+        extent,
+        topology.mipCount === 0 ? 1 : numMipLevels(extent),
+        capability.format,
+      ),
+      deviceGeneration: internals.deviceScope.generation,
+    } as const;
+    transmissionAdmission.admit(demand, capability, resource);
+    internals.errorRegistry.fire(
+      new TransmissionCapabilityMissingError('standard transmission', 'prepare', {
+        lane: 'standard-forward',
+        format: capability.format,
+        missing: verdict.missing,
+      }),
+    );
+    return false;
+  };
+  const updateTransmissionInspection = (
+    antialias: CameraSnapshot['antialias'],
+    submitted: boolean,
+  ): void => {
+    lastTransmissionAntialias = antialias;
+    const demand = persistentRenderScene.transmissionTopologyDemand();
+    if (demand.activeCount === 0) {
+      lastTransmissionInspection = undefined;
+      lastTransmissionKey = '';
+      return;
+    }
+    const extent = {
+      width: Math.max(1, internals.canvas.width),
+      height: Math.max(1, internals.canvas.height),
+    };
+    const topology = resolveTransmissionBackdropTopology({
+      demand,
+      sourceSampleCount: antialias === 'msaa' ? 4 : 1,
+    });
+    if (transmissionCapabilityGeneration !== internals.deviceScope.generation) {
+      transmissionCapability = probeTransmissionCapability(internals.device);
+      transmissionCapabilityGeneration = internals.deviceScope.generation;
+    }
+    if (transmissionCapability === undefined) {
+      throw new Error('transmission capability probe did not produce a result');
+    }
+    const resource = {
+      extent,
+      format: 'rgba16float',
+      mipCount: topology.mipCount === 0 ? 1 : numMipLevels(extent),
+      bytes: estimateTransmissionBackdropBytes(
+        extent,
+        topology.mipCount === 0 ? 1 : numMipLevels(extent),
+      ),
+      deviceGeneration: internals.deviceScope.generation,
+    } as const;
+    const key = `${demand.activeCount}:${demand.needsRoughMips}:${extent.width}:${extent.height}:${resource.deviceGeneration}:${antialias}:${submitted}`;
+    if (key === lastTransmissionKey && lastTransmissionInspection !== undefined) return;
+    if (submitted) {
+      transmissionAdmission.admit(
+        demand,
+        {
+          ...transmissionCapability,
+          msaaResolve: antialias === 'msaa' || topology.sourceSampleCount === 1,
+        },
+        resource,
+      );
+    }
+    const admission = transmissionAdmission.inspectLifecycle();
+    lastTransmissionInspection = submitted
+      ? inspectTransmissionFromAdmission({
+          admission,
+          topology,
+          extent,
+          transmissionDrawCount: demand.activeCount,
+        })
+      : inspectTransmission({
+          demand,
+          topology,
+          extent,
+          generation: admission.generation,
+          lastKnownGood: admission.lastKnownGood,
+          lifecycle: admission.lifecycle,
+          recovery: admission.recovery,
+          capability: admission.capability,
+          resourcePresent: admission.resource !== undefined,
+          transmissionDrawCount: demand.activeCount,
+        });
+    lastTransmissionKey = key;
+  };
   const gpuDrivenShaderFactory =
     internals.shaderModuleFactory ??
     ({
@@ -736,6 +922,19 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             }),
           ),
       } satisfies import('./pipeline-builder').PipelineBuilderShaderModuleFactory),
+    getImmediateShaderModuleFactory: () =>
+      internals.immediateShaderModuleFactory ??
+      internals.shaderModuleFactory ??
+      ({
+        createShaderModule: () =>
+          err(
+            new RhiError({
+              code: 'rhi-not-available',
+              expected: 'the renderer backend exposes shader module creation',
+              hint: 'construct the renderer through the backend pack before activating GPU features',
+            }),
+          ),
+      } satisfies import('./pipeline-builder').PipelineBuilderShaderModuleFactory),
   });
   const disposeFeatureGpuWork = (): void => {
     const disposed = featureGpuWork.dispose();
@@ -756,12 +955,39 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
   // raw (material-handle-based, cross-world collision semantically correct).
   const frameState: RenderFrameState = {
     frameNumber: 0,
+    graphGeneration: 0,
+    successfulTemporalFrameIndex: 0,
+    lastSuccessfulBloom: 'off',
+    temporalFrameTransaction: createTemporalFrameTransaction({ deviceEpoch: 0 }),
+    temporalFrameInput: undefined,
     directionalShadowCache: null,
     directionalShadowCacheRecorded: false,
     compiledFrameGraph: null,
     compiledFrameGraphTopologyKey: null,
+    volumetricFogPreviousGraph: null,
+    volumetricFogPreviousGraphKey: null,
+    volumetricFogCandidateGraph: null,
+    volumetricFogParamsBuffers: [null, null],
+    volumetricFogParamsPendingSlot: null,
+    volumetricFogParamsAcceptedSlot: null,
+    volumetricFogAcceptedParams: undefined,
+    volumetricFogPendingParams: undefined,
+    volumetricFogInspection: inspectVolumetricFog({ authored: false, capability: 'available' }),
+    volumetricFogAccepted: undefined,
+    volumetricFogAcceptedContext: undefined,
+    volumetricFogHistoryGraph: null,
+    volumetricFogHistorySlot: null,
+    volumetricFogHistorySignature: null,
     retiredCompiledFrameGraphs: new Set(),
     currentFrameObservationSource: undefined,
+    lastSuccessfulCameraAntialias: undefined,
+    temporalGpuState: undefined,
+    activeTemporalGpuState: undefined,
+    retiringTemporalGpuStates: new Set(),
+    lastSuccessfulTemporalView: undefined,
+    pendingTemporalCommit: { kind: 'none' },
+    environmentGeneration: undefined,
+    environmentLifecycle,
     currentDirectionalShadowView: null,
     currentSpotShadowView: null,
     instanceBuffers: new Map(),
@@ -920,6 +1146,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       ...featureEntries.entries(),
     ]);
     for (const [id, entry] of declarations) {
+      if (id === 'forgeax.taa-resolve') continue;
       const byteSize =
         entry.params?.byteSize ?? (entryHasDepthRead(entry) ? DEPTH_MIN_PARAMS_BYTE_SIZE : 0);
       if (byteSize === 0 || postProcessParamsBuffers.has(id)) continue;
@@ -970,10 +1197,16 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     postProcessPipelineCache.set(key, built);
     return built;
   };
+  const clearPostProcessPipelineCache = (id: string): void => {
+    for (const key of postProcessPipelineCache.keys()) {
+      if (key.startsWith(`${id}|`)) postProcessPipelineCache.delete(key);
+    }
+  };
   Object.assign(internals, {
     lookupPostProcess,
     getPostProcessParamsBuffer,
     getPostProcessPipeline,
+    clearPostProcessPipelineCache,
   });
   // w15 M5 (plan-strategy D-P4 / AC-07): per-frame dispatch counters. Reset
   // on every `draw([world], { cameraOwner: 0, resourceOwner: 0 })` entry; bumped once per actual `pass.setPipeline`
@@ -1121,42 +1354,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       if (buffer !== undefined) internals.device.destroyBuffer(buffer);
       return err(new Error('prepared material schema contains unsupported binding kinds'));
     }
-    for (let index = fields.length; index < 4; index += 1) {
-      const binding = derived.userRegionBindingEnd + (index - fields.length) * 2;
-      entries.push(
-        {
-          binding,
-          resource: { kind: 'sampler', value: pipelineState.defaultSampler },
-        },
-        {
-          binding: binding + 1,
-          resource: { kind: 'textureView', value: pipelineState.defaultWhiteTextureView },
-        },
-      );
-    }
     const fallback = pipelineState.skylightFallback;
     if (fallback === null) {
       if (buffer !== undefined) internals.device.destroyBuffer(buffer);
       return err(new Error('prepared material skylight fallback is unavailable'));
     }
-    const completeEntries = assembleMaterialWithSkylightEntries(
-      entries,
-      {
-        irradianceView: fallback.irradianceView,
-        irradianceSampler: fallback.sampler,
-        prefilterView: fallback.prefilterView,
-        prefilterSampler: fallback.sampler,
-        brdfLutView: fallback.brdfLutView,
-        brdfLutSampler: fallback.sampler,
-        intensityBuffer: fallback.intensityBuffer,
-      },
-      {
-        emissiveSampler: pipelineState.defaultSampler,
-        emissiveView: pipelineState.defaultWhiteTextureView,
-        occlusionSampler: pipelineState.defaultSampler,
-        occlusionView: pipelineState.defaultWhiteTextureView,
-      },
-    );
+    const completeEntries = assembleMaterialWithSkylightEntries(entries, {
+      irradianceView: fallback.irradianceView,
+      irradianceSampler: fallback.sampler,
+      prefilterView: fallback.prefilterView,
+      prefilterSampler: fallback.sampler,
+      brdfLutView: fallback.brdfLutView,
+      brdfLutSampler: fallback.sampler,
+      intensityBuffer: fallback.intensityBuffer,
+    });
     const group = internals.device.createBindGroup({ layout, entries: completeEntries });
     if (!group.ok) {
       if (buffer !== undefined) internals.device.destroyBuffer(buffer);
@@ -1232,6 +1443,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             ? null
             : (descriptor.depthFormat as GPUTextureFormat),
           descriptor.vertexLayout,
+          undefined,
+          input.shaderModuleMode,
         );
         // A requested material shader is an exact pipeline contract. During
         // async shader warmup, substituting the generic unlit pipeline can
@@ -1367,6 +1580,98 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         gpuDriven: gpuDrivenProduction.inspect(),
       };
     },
+    get environment(): EnvironmentInspection {
+      return environmentLifecycle.inspect();
+    },
+    get temporal(): TemporalInspection {
+      return inspectTemporal(frameState.lastSuccessfulTemporalView, undefined, {
+        ...(frameState.activeTemporalGpuState === undefined
+          ? {}
+          : { active: frameState.activeTemporalGpuState }),
+        ...(frameState.temporalGpuState === undefined
+          ? {}
+          : { candidate: frameState.temporalGpuState }),
+        retiring: [...frameState.retiringTemporalGpuStates],
+        deviceGeneration: internals.deviceScope.generation,
+      });
+    },
+    get motionBlurInspection(): MotionBlurInspection | undefined {
+      const camera = latestCamera;
+      if (camera?.motionBlur === undefined) return undefined;
+      const demanded = camera.motionBlur.shutterAngle > 0;
+      const unavailable = demanded && !internals.device.caps.rgba16floatRenderable;
+      const admitted =
+        frameState.activeTemporalGpuState !== undefined ||
+        frameState.temporalGpuState !== undefined;
+      return {
+        enabled: demanded,
+        status: !demanded ? 'off' : unavailable || !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,
+        ...(unavailable ? { lastFailure: 'scene-data-unavailable' as const } : {}),
+      };
+    },
+    get temporalTargetInspection(): TemporalTargetInspection | undefined {
+      const graph = frameState.compiledFrameGraph?.inspect();
+      if (graph === undefined) return undefined;
+      const producer = graph.passes.find((pass) => pass.name === 'standard-scene-data');
+      // The producer's semantic target is the graph-owned
+      // `standard-scene-temporal` resource. Resolve it from the compiled
+      // resource table rather than the pass access projection: a backend may
+      // retain a view alias in the access list while the resource owner still
+      // carries the canonical semantic label.
+      const target = graph.resources.find(
+        (resource) => resource.kind === 'texture' && resource.label === 'standard-scene-temporal',
+      );
+      if (producer === undefined || target === undefined) {
+        return undefined;
+      }
+      const width = Math.max(1, internals.canvas.width);
+      const height = Math.max(1, internals.canvas.height);
+      return Object.freeze({
+        identity: 'standard-scene-temporal',
+        producerId: 'forgeax::standard::scene-data',
+        schema: 'forgeax::scene-data::temporal-v1',
+        targetCount: 1,
+        descriptor: Object.freeze({
+          format: 'rgba16float',
+          width,
+          height,
+          sampleCount: 1,
+          bytes: width * height * 8,
+        }),
+      });
+    },
+    get bloom(): BloomInspection {
+      const pipelineState = internals.getPipelineState();
+      const resources = pipelineState?.perPassResources;
+      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',
+        },
+      );
+    },
+    get transmission(): TransmissionInspection | undefined {
+      return lastTransmissionInspection;
+    },
     get pointsLinesSnapshots(): readonly PointsLinesRetainedSnapshot[] {
       return persistentRenderScene.pointsLinesSnapshots();
     },
@@ -1377,6 +1682,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       worlds: readonly World[],
       opts: DrawOwnerOptions,
       renderReadLeases?: readonly RenderReadLease[],
+      timingCapture?: GpuTimingCapture,
     ): boolean {
       preparedWorlds = worlds;
       const profileSession = internals.profiler?.activeSession();
@@ -1450,16 +1756,53 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         const {
           cameras,
           lights,
+          environment,
+          environmentReady,
+          volumetricFog,
           renderables,
           dispatch,
           skylight,
           skylightCount,
           skybox,
           skyboxCount,
+          fog,
           frustumStats,
           visibilityStats,
           postProcessParams,
         } = frame;
+        latestCamera = cameras[0];
+        const temporalDemanded =
+          cameras[0]?.antialias === 'taa' || (cameras[0]?.motionBlur?.shutterAngle ?? 0) > 0;
+        if (temporalDemanded) {
+          persistentRenderScene.prepareTemporalFrame(renderables);
+        }
+        environmentLifecycle.bindScope(internals.deviceScope);
+        if (!environmentReady || environment === undefined) {
+          frameState.pendingTemporalCommit = { kind: 'none' };
+          // A world with no camera still has a valid clear-only render path.
+          // It has no environment candidate and therefore must not publish an
+          // off/taa temporal state; camera-bearing rejected extraction remains
+          // an atomic render failure.
+          if (cameras.length > 0) return false;
+        } else {
+          const environmentCandidate = environmentLifecycle.ensure(environment);
+          if (!environmentCandidate.ok) {
+            environmentLifecycle.recordCandidateFailure(environmentCandidate.error);
+            internals.errorRegistry.fire(environmentCandidate.error);
+            return false;
+          }
+          if (!environmentLifecycle.isActive(environmentCandidate.value)) {
+            frameState.environmentGeneration = environmentCandidate.value;
+          }
+        }
+        const transmissionAntialias = frame.cameras[0]?.antialias ?? 'none';
+        if (!prepareTransmissionCandidate(transmissionAntialias)) {
+          // The candidate gate runs before bind-group preparation, graph
+          // construction, and record/submit. A missing capability therefore
+          // cannot publish or execute a transmission graph.
+          updateTransmissionInspection(transmissionAntialias, false);
+          return false;
+        }
         if (lastMeshMaterialBindingFrame !== frame) {
           lastMeshMaterialBindingFrame = frame;
           lastMeshMaterialBindings = renderables.map((renderable) => ({
@@ -1530,6 +1873,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             targets: featureTargets,
             generation: internals.featureHost?.preparedGeneration ?? 0,
             caps: internals.device.caps,
+            ...(internals.getMaterialShaderBindingContract === undefined
+              ? {}
+              : { materialShaderBindingContract: internals.getMaterialShaderBindingContract }),
             createPreparedGraphicsResolver: preparedResolverFactory,
             gpuWork: featureGpuWork,
           });
@@ -1605,6 +1951,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
                 }
                 return runProfiledRenderPhase(profileSession, phase, action);
               };
+        if (cameras[0]?.bloom === 'on') {
+          internals.getPipelineState()?.perPassResources.ensureBloomResources?.();
+        }
         submitted = runProfiledRenderPhase(profileSession, 'record', () =>
           recordFrame(
             internals,
@@ -1621,6 +1970,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             skybox,
             skyboxCount,
             postProcessParams,
+            fog,
             worlds,
             recordProfilePhase,
             {
@@ -1634,8 +1984,38 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             renderReadLeases,
             featureGraphCandidate,
             pointsLinesOwner,
+            environment?.environmentSignature ?? '',
+            environment?.fogSignature ?? '',
+            environmentReady && environment !== undefined,
+            persistentRenderScene.transmissionTopologyDemand(),
+            volumetricFog,
+            timingCapture,
           ),
         );
+        if (submitted) {
+          const temporalCommit = persistentRenderScene.commitTemporalFrame();
+          if (!temporalCommit.ok) {
+            internals.errorRegistry.fire(temporalCommit.error);
+          }
+          frameState.lastSuccessfulCameraAntialias = cameras[0]?.antialias;
+          internals.getPipelineState()?.perPassResources.commitBloomResources?.();
+          const nextBloom = cameras[0]?.bloom ?? 'off';
+          if (frameState.lastSuccessfulBloom === 'on' && nextBloom !== 'on') {
+            internals
+              .getPipelineState()
+              ?.perPassResources.retireBloomResources?.(
+                internals.device.queue.onSubmittedWorkDone(),
+              );
+          }
+          frameState.lastSuccessfulBloom = nextBloom;
+        } else {
+          internals.getPipelineState()?.perPassResources.discardBloomResources?.();
+        }
+        if (!submitted && frameState.environmentGeneration !== undefined) {
+          environmentLifecycle.discard(frameState.environmentGeneration);
+          frameState.environmentGeneration = undefined;
+        }
+        updateTransmissionInspection(transmissionAntialias, submitted);
         persistentRenderScene.setPointsLinesInspections(pointsLinesOwner.inspections());
         if (internals.featureHost !== undefined && preparedResourceBatches.length > 0) {
           const batches = preparedResourceBatches;
@@ -1653,10 +2033,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           }
         }
       } catch (err) {
+        if (!submitted) {
+          internals.getPipelineState()?.perPassResources.discardBloomResources?.();
+        }
         const innerError =
-          err instanceof RhiError
-            ? err
-            : { code: 'unknown' as const, message: String(err), name: (err as Error)?.name };
+          err instanceof PipelineSpecError
+            ? {
+                name: err.name,
+                code: err.code,
+                message: err.message,
+                detail: err.detail,
+              }
+            : err instanceof RhiError
+              ? err
+              : { code: 'unknown' as const, message: String(err), name: (err as Error)?.name };
         internals.errorRegistry.fire(
           new RhiError({
             code: 'webgpu-runtime-error',
@@ -1681,7 +2071,39 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       const currentFrameId = frameState.frameNumber - 1;
       return observeCurrentFrame(options, frameState.currentFrameObservationSource, currentFrameId);
     },
+    getCurrentGraphTarget(name: string) {
+      const graph = frameState.perFrameGraph;
+      if (graph === undefined || graph === null) return undefined;
+      const descriptor = graph.getColorTargetDescriptor(name);
+      const texture = graph.getColorTargetTexture(name);
+      if (descriptor === undefined || texture === undefined) return undefined;
+      return {
+        name,
+        texture,
+        textureIdentity: getTextureIdentity(texture),
+        descriptor,
+        frameId: frameState.frameNumber - 1,
+        graphGeneration: graph.graphGeneration,
+      };
+    },
+    requestGraphTargetCapture(request: GraphTargetCaptureRequest) {
+      frameState.graphTargetCapture = request;
+    },
     bindGroupCounts: bindGroupCounts,
+    get temporalFrame(): TemporalFrame | undefined {
+      const accepted = frameState.temporalFrame;
+      if (accepted === undefined) return undefined;
+      return {
+        ...accepted,
+        currentViewProjection: new Float32Array(accepted.currentViewProjection),
+        previousViewProjection:
+          accepted.previousViewProjection === undefined
+            ? undefined
+            : new Float32Array(accepted.previousViewProjection),
+        jitter: [accepted.jitter[0], accepted.jitter[1]],
+        viewport: { ...accepted.viewport },
+      };
+    },
     frustumStats: lastFrustumStats,
     visibilityStats: lastVisibilityStats,
     get meshMaterialBindings(): readonly MeshMaterialBindingObservation[] {
@@ -1690,6 +2112,15 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     get perFramePassNames(): readonly string[] {
       return frameState.compiledFrameGraph?.inspect().passes.map((pass) => pass.name) ?? [];
     },
+    get lastSuccessfulCameraAntialias(): CameraSnapshot['antialias'] | undefined {
+      return frameState.lastSuccessfulCameraAntialias;
+    },
+    get perFrameGraphInfo(): CompiledRenderGraphInfo | undefined {
+      return frameState.compiledFrameGraph?.inspect();
+    },
+    get volumetricFog(): import('./volume/inspection').VolumetricFogInspection {
+      return frameState.volumetricFogInspection;
+    },
     configureStandard(config: RenderPipelineAsset['config']): void {
       const profileConfig = internals.standardProfile;
       const resolvedConfig =
@@ -1723,7 +2154,16 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // is a rare boot/swap event, never a per-frame cost.
       installEpoch += 1;
       frameState.installedPipelineHandle = installEpoch;
-      frameState.isHdrpActive = resolvedConfig?.clusterGrid !== undefined;
+      // The installed profile may request clustered lighting, but the actual
+      // graph lane is capability-gated.  On WebGL2 (including WebKit's wgpu
+      // fallback) the forward lane is selected when compute/storage buffers
+      // are unavailable; keep the frame bindings on that same lane instead of
+      // advertising HDRP's clustered bind-group layout to URP pipelines.
+      frameState.isHdrpActive =
+        resolveStandardLane(internals.standardProfile ?? DEFAULT_STANDARD_PROFILE, {
+          compute: internals.device.caps.compute,
+          storageBuffer: internals.device.caps.storageBuffer,
+        }) === 'clustered';
       frameState.installedPipelineConfig = resolvedConfig;
     },
     registerBuiltinPostProcess(id: string, entry: PostProcessShaderEntry): () => void {
@@ -1731,7 +2171,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // byteSize / defaultValue validation (q5=A).
       let paramsBuffer: Buffer | undefined;
       try {
-        if (entry.params !== undefined) {
+        if (id !== 'forgeax.taa-resolve' && entry.params !== undefined) {
           const { byteSize, defaultValue } = entry.params;
           if (byteSize < 16 || defaultValue.length !== byteSize) {
             throw new PostProcessError({
@@ -1749,7 +2189,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           paramsBuffer = paramsBufferResult.value;
           const writeResult = internals.device.queue.writeBuffer(paramsBuffer, 0, defaultValue);
           if (!writeResult.ok) throw writeResult.error;
-        } else if (entryHasDepthRead(entry)) {
+        } else if (id !== 'forgeax.taa-resolve' && entryHasDepthRead(entry)) {
           const paramsBufferResult = internals.device.createBuffer({
             label: `post-process-params-${id}`,
             size: DEPTH_MIN_PARAMS_BYTE_SIZE,
@@ -1789,6 +2229,13 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       persistentRenderScene.dispose();
       gpuDrivenProduction.dispose();
       disposeFeatureGpuWork();
+      // Bloom generations are renderer-owned rather than graph-owned. Drain
+      // candidate, active, and fence-retiring bundles before the rest of the
+      // frame state is torn down; the owner callback is idempotent so the
+      // outer Renderer.dispose cascade can safely call this once only.
+      internals.getPipelineState()?.perPassResources.drainBloomResources?.();
+      internals.clearPostProcessPipelineCache?.('forgeax.taa-resolve');
+      internals.invalidateShaderModule?.('post-process-forgeax.taa-resolve-module');
       // Retire graph-owned resources and dispose instance-buffer caches.
       // Both calls are idempotent + tolerate per-handle errors silently;
       // the Renderer.dispose() cascade owns the surrounding try/catch
@@ -1798,8 +2245,37 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       frameState.directionalShadowCache = null;
       frameState.directionalShadowCacheRecorded = false;
       frameState.currentFrameObservationSource = undefined;
+      frameState.lastSuccessfulCameraAntialias = undefined;
       frameState.currentDirectionalShadowView = null;
       frameState.currentSpotShadowView = null;
+      if (frameState.temporalGpuState !== undefined) {
+        retireTemporalGpuState(frameState.temporalGpuState);
+        frameState.temporalGpuState = undefined;
+      }
+      if (frameState.activeTemporalGpuState !== undefined) {
+        retireTemporalGpuState(frameState.activeTemporalGpuState);
+        frameState.activeTemporalGpuState = undefined;
+      }
+      for (const retiring of frameState.retiringTemporalGpuStates) {
+        retireTemporalGpuState(retiring);
+      }
+      frameState.retiringTemporalGpuStates.clear();
+      settleVolumetricFogGraphCandidate(frameState, false);
+      for (const buffer of frameState.volumetricFogParamsBuffers) {
+        if (buffer === null) continue;
+        const destroyed = internals.device.destroyBuffer(buffer);
+        if (!destroyed.ok) internals.errorRegistry.fire(destroyed.error);
+      }
+      frameState.volumetricFogParamsBuffers = [null, null];
+      frameState.volumetricFogParamsPendingSlot = null;
+      frameState.volumetricFogParamsAcceptedSlot = null;
+      frameState.volumetricFogAcceptedParams = undefined;
+      frameState.volumetricFogPendingParams = undefined;
+      frameState.volumetricFogAccepted = undefined;
+      frameState.volumetricFogAcceptedContext = undefined;
+      frameState.volumetricFogHistoryGraph = null;
+      frameState.volumetricFogHistorySlot = null;
+      frameState.volumetricFogHistorySignature = null;
       const compiled = frameState.compiledFrameGraph;
       frameState.compiledFrameGraph = null;
       frameState.compiledFrameGraphTopologyKey = null;
@@ -1833,23 +2309,66 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       }
     },
     resetForRecover(): void {
+      transmissionAdmission.markDeviceLost();
+      lastTransmissionKey = '';
+      transmissionCapabilityGeneration = -1;
+      transmissionCapability = undefined;
+      // Keep the persistent material demand observable across device loss.
+      // The physical resource has already been fenced by markDeviceLost(); the
+      // detached inspection now exposes the rebuild-required lifecycle until a
+      // completed frame admits the replacement resource.
+      updateTransmissionInspection(lastTransmissionAntialias, false);
       persistentRenderScene.resetGpuForRecover();
       gpuDrivenProduction.dispose();
       gpuDrivenProduction = new GpuDrivenProduction(internals.device, gpuDrivenShaderFactory);
       disposeFeatureGpuWork();
+      // A recovered device cannot retain handles from the lost device. The
+      // Bloom owner abandons candidates and retires every committed generation
+      // before the new PipelineState is rebuilt.
+      internals.getPipelineState()?.perPassResources.drainBloomResources?.();
       // feat-20260622-s5 M3 / B-2 / w18: recover() rebuild drops device-bound
       // state minted by the lost device. The active graph and per-entity caches
       // must be discarded, not merely marked for destruction: their opaque
       // handles cannot be used on the fresh device and the next draw must
       // lazily build a new graph from the preserved ECS / asset POD caches.
+      settleVolumetricFogGraphCandidate(frameState, false);
       frameState.compiledFrameGraph?.retire().catch(() => undefined);
       frameState.compiledFrameGraph = null;
       frameState.compiledFrameGraphTopologyKey = null;
+      frameState.volumetricFogPreviousGraph = null;
+      frameState.volumetricFogPreviousGraphKey = null;
+      frameState.volumetricFogCandidateGraph = null;
+      frameState.volumetricFogAccepted = undefined;
+      frameState.volumetricFogAcceptedContext = undefined;
+      frameState.volumetricFogHistoryGraph = null;
+      frameState.volumetricFogHistorySlot = null;
+      frameState.volumetricFogHistorySignature = null;
+      // The old device owns these transient params buffers. Discard their
+      // handles without calling destroy() on the lost device; the next frame
+      // must allocate fresh buffers on the replacement device.
+      frameState.volumetricFogParamsBuffers = [null, null];
+      frameState.volumetricFogParamsPendingSlot = null;
+      frameState.volumetricFogParamsAcceptedSlot = null;
+      frameState.volumetricFogAcceptedParams = undefined;
+      frameState.volumetricFogPendingParams = undefined;
       frameState.directionalShadowCache = null;
       frameState.directionalShadowCacheRecorded = false;
       frameState.currentFrameObservationSource = undefined;
+      frameState.lastSuccessfulCameraAntialias = undefined;
       frameState.currentDirectionalShadowView = null;
       frameState.currentSpotShadowView = null;
+      if (frameState.temporalGpuState !== undefined) {
+        retireTemporalGpuState(frameState.temporalGpuState);
+        frameState.temporalGpuState = undefined;
+      }
+      if (frameState.activeTemporalGpuState !== undefined) {
+        retireTemporalGpuState(frameState.activeTemporalGpuState);
+        frameState.activeTemporalGpuState = undefined;
+      }
+      for (const retiring of frameState.retiringTemporalGpuStates) {
+        retireTemporalGpuState(retiring);
+      }
+      frameState.retiringTemporalGpuStates.clear();
       for (const retired of frameState.retiredCompiledFrameGraphs) {
         retired.retire().catch(() => undefined);
       }
@@ -1886,6 +2405,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         ...activeFeaturePostProcessEntries.entries(),
       ];
       for (const [id, entry] of declarations) {
+        if (id === 'forgeax.taa-resolve') continue;
         let buffer: Buffer | undefined;
         if (entry.params !== undefined) {
           const created = internals.device.createBuffer({