@forgeax/engine-render 0.1.6 → 0.1.19

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 {
@@ -27,12 +28,20 @@ import {
   type Handle,
   type MaterialAsset,
   type MaterialTextureValue,
+  type MeshAsset,
   type RenderPipelineAsset,
   RenderQueue,
   type SamplerAsset,
+  toShared,
 } from '@forgeax/engine-types';
 import { createClusterBinScratch } from './cluster-binner';
-import type { ObservationUnavailableError, RenderError } from './errors/render';
+import { EnvironmentLifecycle } from './environment/lifecycle';
+import {
+  type ObservationUnavailableError,
+  PointsLinesMaterialUnsupportedError,
+  type RenderError,
+  TransmissionCapabilityMissingError,
+} from './errors/render';
 import {
   type RenderFeaturePreparedGraphicsResolverInput,
   runRenderFeatureFrame,
@@ -50,16 +59,48 @@ 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 {
+  inspectPointsLines,
+  type PointsLinesInspection,
+  type PointsLinesSourceError,
+} from './points-lines/inspection';
+import {
+  createPointsLinesLanePreparationAdapter,
+  type PointsLinesLanePreparationAdapter,
+} from './points-lines/prepare';
+import { createPointsLinesLaneAdapter, type PointsLinesBackend } from './points-lines/record';
+import type { PointsLinesRetainedSnapshot } from './points-lines/snapshot';
+import type { PointsLinesRecordOwner, PointsLinesRecordSubmission } from './record/render-context';
 
 export type { RenderSceneInspection } from './inspection-types';
 
-import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM } from './gpu-usage';
+import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
+import type { EnvironmentInspection } from './environment/inspection';
+import {
+  GPU_BUFFER_USAGE_COPY_DST,
+  GPU_BUFFER_USAGE_INDEX,
+  GPU_BUFFER_USAGE_UNIFORM,
+  GPU_BUFFER_USAGE_VERTEX,
+} from './gpu-usage';
 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,
@@ -73,7 +114,12 @@ 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 { applyParamSnapshotToUbo, residentTextureView } from './record/main-pass-material';
 import type { RenderSystemInternals } from './record/render-context';
 import {
@@ -99,6 +145,19 @@ import {
   TRANSPARENT_SORT_MODE_LAYER_YZ,
   TRANSPARENT_SORT_MODE_LAYER_Z,
 } from './systems/transparent-sort-config';
+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,
@@ -108,12 +167,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';
@@ -271,6 +333,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;
   };
@@ -283,6 +349,15 @@ 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. */
   readonly meshMaterialBindings: readonly MeshMaterialBindingObservation[];
   /**
@@ -294,6 +369,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,
@@ -398,6 +477,273 @@ function makePreparedPipelinePendingError(): RhiError {
   });
 }
 
+type PointsLinesGpuResources = {
+  readonly vertexBuffer: Buffer;
+  readonly indexBuffer: Buffer;
+};
+type PointsLinesPreparationAdapter = PointsLinesLanePreparationAdapter<PointsLinesGpuResources>;
+
+/**
+ * The Standard renderer's single Points/Lines prepare owner.
+ *
+ * The retained snapshot is the identity boundary; this owner only resolves
+ * the source assets, runs admission, and publishes the existing preparation
+ * and record contracts to the main geometry loop. The expansion cache is
+ * shared across lanes and this owner keeps the one prepared vertex/index
+ * resource pair for each retained identity.
+ */
+class StandardPointsLinesOwner implements PointsLinesRecordOwner {
+  private readonly cache = new PointsLinesExpansionCache();
+  private readonly preparations = new Map<string, PointsLinesPreparationAdapter>();
+  private readonly active = new Map<string, PointsLinesInspection>();
+  private readonly layoutProjection = deriveVertexLayoutProjection({
+    position: new Float32Array(0),
+    normal: new Float32Array(0),
+    uv: new Float32Array(0),
+    tangent: new Float32Array(0),
+  });
+
+  constructor(private readonly internals: RenderSystemInternals) {}
+
+  beginFrame(): void {
+    this.active.clear();
+  }
+
+  prepare(
+    entry: import('./record/frame-snapshot').ValidatedRenderable,
+    clustered: boolean,
+  ): PointsLinesRecordSubmission | undefined {
+    const snapshot = entry.source.pointsLines;
+    if (snapshot === undefined || snapshot.component === undefined || entry.world === undefined) {
+      return undefined;
+    }
+    const key = `${snapshot.worldId}:${snapshot.entityKey}`;
+    const topology = snapshot.component === 'Points' ? 'point-list' : 'line-list';
+    const backend = this.backend();
+    const lane = backend === 'wgpu-webgl2' ? 'cpu-webgl2' : clustered ? 'clustered' : 'direct';
+    const meshResult = resolveAssetHandle<MeshAsset>(
+      entry.world,
+      toShared<'MeshAsset'>(entry.source.assetHandle),
+    );
+    const materialResult = resolveAssetHandle<MaterialAsset>(
+      entry.world,
+      toShared<'MaterialAsset'>(snapshot.materialHandle),
+    );
+    if (!meshResult.ok || !materialResult.ok) {
+      this.publishRefusal(
+        snapshot,
+        new PointsLinesMaterialUnsupportedError({
+          entity: snapshot.entityKey,
+          material: 'unresolved',
+          pass: 'forward',
+          module: 'asset-resolution',
+          reason: 'source MeshAsset or MaterialAsset could not be resolved',
+        }),
+      );
+      return undefined;
+    }
+    const admission = admitPointsLines({
+      entity: snapshot.entityKey,
+      mesh: meshResult.value,
+      material: materialResult.value,
+      ...(snapshot.style?.kind === 'points'
+        ? {
+            points: {
+              sizePx: snapshot.style.sizePx,
+              shape: snapshot.style.shape === 'circle' ? 1 : 0,
+            },
+          }
+        : { lines: { widthPx: snapshot.style?.widthPx ?? 1 } }),
+    });
+    if (!admission.ok) {
+      this.publishRefusal(snapshot, admission.error);
+      return undefined;
+    }
+    const geometryKey = this.cache.getOrCreate(snapshot, meshResult.value).key;
+    const prepKey = `${geometryKey}:${lane}:${backend}`;
+    let preparation = this.preparations.get(prepKey);
+    if (preparation === undefined) {
+      preparation = createPointsLinesLanePreparationAdapter(lane, backend, {
+        cache: this.cache,
+        adapter: {
+          create: (geometry) => {
+            const vertex = this.internals.device.createBuffer({
+              label: `points-lines-vertices:${geometryKey}`,
+              size: Math.max(4, geometry.vertices.byteLength),
+              usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST,
+              mappedAtCreation: false,
+            });
+            if (!vertex.ok) return err(vertex.error);
+            const index = this.internals.device.createBuffer({
+              label: `points-lines-indices:${geometryKey}`,
+              size: Math.max(4, geometry.indices.byteLength),
+              usage: GPU_BUFFER_USAGE_INDEX | GPU_BUFFER_USAGE_COPY_DST,
+              mappedAtCreation: false,
+            });
+            if (!index.ok) {
+              this.internals.device.destroyBuffer(vertex.value);
+              return err(index.error);
+            }
+            return ok({ vertexBuffer: vertex.value, indexBuffer: index.value });
+          },
+          upload: (resource, geometry) => {
+            if (geometry.vertices.byteLength > 0) {
+              const vertexWrite = this.internals.device.queue.writeBuffer(
+                resource.vertexBuffer,
+                0,
+                geometry.vertices,
+              );
+              if (!vertexWrite.ok) return err(vertexWrite.error);
+            }
+            if (geometry.indices.byteLength > 0) {
+              const indexWrite = this.internals.device.queue.writeBuffer(
+                resource.indexBuffer,
+                0,
+                geometry.indices,
+              );
+              if (!indexWrite.ok) return err(indexWrite.error);
+            }
+            return ok(geometry.derivedBytes);
+          },
+          validate: (_resource, geometry) =>
+            geometry.expandedVertexCount > 0 && geometry.expandedIndexCount > 0
+              ? ok(undefined)
+              : err(new Error('Points/Lines expansion contains no drawable triangles')),
+          destroy: (resource) => {
+            this.internals.device.destroyBuffer(resource.vertexBuffer);
+            this.internals.device.destroyBuffer(resource.indexBuffer);
+          },
+        },
+      });
+      this.preparations.set(prepKey, preparation);
+    }
+    const prepared = preparation.prepare(snapshot, meshResult.value);
+    if (!prepared.ok) {
+      const lkg = preparation.lastKnownGood();
+      if (lkg !== undefined) {
+        const lkgPlan = createPointsLinesLaneAdapter(lane, backend).createRecordPlan(
+          lkg.snapshot,
+          lkg.geometry,
+        );
+        const state = preparation.inspect();
+        this.active.set(
+          key,
+          inspectPointsLines({
+            snapshot,
+            topology,
+            lane,
+            pointCount: lkg.geometry.pointCount,
+            segmentCount: lkg.geometry.segmentCount,
+            sourceBytes: lkg.geometry.sourceBytes,
+            derivedBytes: lkg.geometry.derivedBytes,
+            cache: { hit: true, rebuilds: state.rebuilds, evictions: 0 },
+            drawCount: lkgPlan.drawCount,
+            uploadBytes: 0,
+            lastKnownGood: true,
+            refusal: {
+              code: prepared.error.code,
+              expected: prepared.error.expected,
+              hint: prepared.error.hint,
+              detail: prepared.error.detail,
+              generation: prepared.error.detail.generation,
+              lastKnownGood: true,
+            },
+          }),
+        );
+        return {
+          plan: lkgPlan,
+          vertexBuffer: lkg.resource.vertexBuffer,
+          indexBuffer: lkg.resource.indexBuffer,
+          layoutProjection: this.layoutProjection,
+        };
+      }
+      this.publishRefusal(snapshot, prepared.error);
+      return undefined;
+    }
+    const plan = createPointsLinesLaneAdapter(lane, backend).createRecordPlan(
+      snapshot,
+      prepared.value.geometry,
+    );
+    const state = preparation.inspect();
+    this.active.set(
+      key,
+      inspectPointsLines({
+        snapshot,
+        topology,
+        lane,
+        pointCount: prepared.value.geometry.pointCount,
+        segmentCount: prepared.value.geometry.segmentCount,
+        sourceBytes: prepared.value.geometry.sourceBytes,
+        derivedBytes: prepared.value.geometry.derivedBytes,
+        cache: {
+          hit: prepared.value.uploadedBytes === 0,
+          rebuilds: state.rebuilds,
+          evictions: 0,
+        },
+        drawCount: plan.drawCount,
+        uploadBytes: prepared.value.uploadedBytes,
+        lastKnownGood: prepared.value.lastKnownGood,
+      }),
+    );
+    return {
+      plan,
+      vertexBuffer: prepared.value.resource.vertexBuffer,
+      indexBuffer: prepared.value.resource.indexBuffer,
+      layoutProjection: this.layoutProjection,
+    };
+  }
+
+  resetForDeviceLoss(): void {
+    for (const preparation of this.preparations.values()) preparation.resetForDeviceLoss();
+    this.active.clear();
+  }
+
+  inspections(): readonly PointsLinesInspection[] {
+    return [...this.active.values()];
+  }
+
+  private backend(): PointsLinesBackend {
+    switch (this.internals.device.caps.backendKind) {
+      case 'wgpu-webgl2':
+        return 'wgpu-webgl2';
+      case 'null':
+        return 'null';
+      default:
+        return 'webgpu';
+    }
+  }
+
+  private publishRefusal(
+    snapshot: PointsLinesRetainedSnapshot,
+    error: PointsLinesSourceError,
+  ): void {
+    this.active.set(
+      `${snapshot.worldId}:${snapshot.entityKey}`,
+      inspectPointsLines({
+        snapshot,
+        topology: snapshot.component === 'Points' ? 'point-list' : 'line-list',
+        lane: 'refused',
+        pointCount: 0,
+        segmentCount: 0,
+        sourceBytes: 0,
+        derivedBytes: 0,
+        cache: { hit: false, rebuilds: 0, evictions: 0 },
+        drawCount: 0,
+        uploadBytes: 0,
+        lastKnownGood: false,
+        refusal: {
+          code: error.code,
+          expected: error.expected,
+          hint: error.hint,
+          detail: error.detail,
+          generation: snapshot.meshGeneration,
+          lastKnownGood: false,
+        },
+      }),
+    );
+  }
+}
+
 export function createRenderSystem(internals: RenderSystemInternals): RenderSystem {
   const phaseCatalogRegistration = internals.profiler?.registerPhaseCatalog(
     'render',
@@ -406,6 +752,8 @@ 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,
     onGpuError: (error) => internals.errorRegistry.fire(error),
@@ -413,6 +761,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 ??
     ({
@@ -440,6 +913,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();
@@ -460,12 +946,23 @@ 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',
     directionalShadowCache: null,
     directionalShadowCacheRecorded: false,
     compiledFrameGraph: null,
     compiledFrameGraphTopologyKey: 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(),
@@ -624,6 +1121,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;
@@ -674,10 +1172,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`
@@ -825,42 +1329,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);
@@ -936,6 +1418,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
@@ -1071,6 +1555,101 @@ 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();
+    },
     detachScene(world: World): void {
       persistentRenderScene.detach(world);
     },
@@ -1091,6 +1670,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         }
       }
       try {
+        pointsLinesOwner.beginFrame();
         // cameraOwner drives the surfaced cameras + frustum
         // cull; resourceOwner drives skylight/skybox/postProcess + per-world
         // record config.
@@ -1150,16 +1730,52 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         const {
           cameras,
           lights,
+          environment,
+          environmentReady,
           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) => ({
@@ -1230,6 +1846,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,
           });
@@ -1305,6 +1924,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,
@@ -1321,6 +1943,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             skybox,
             skyboxCount,
             postProcessParams,
+            fog,
             worlds,
             recordProfilePhase,
             {
@@ -1333,8 +1956,38 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             },
             renderReadLeases,
             featureGraphCandidate,
+            pointsLinesOwner,
+            environment?.environmentSignature ?? '',
+            environment?.fogSignature ?? '',
+            environmentReady && environment !== undefined,
+            persistentRenderScene.transmissionTopologyDemand(),
           ),
         );
+        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;
           if (submitted) {
@@ -1351,10 +2004,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',
@@ -1379,6 +2042,24 @@ 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,
     frustumStats: lastFrustumStats,
     visibilityStats: lastVisibilityStats,
@@ -1388,6 +2069,12 @@ 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();
+    },
     configureStandard(config: RenderPipelineAsset['config']): void {
       const profileConfig = internals.standardProfile;
       const resolvedConfig =
@@ -1421,7 +2108,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 {
@@ -1429,7 +2125,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({
@@ -1447,7 +2143,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,
@@ -1487,6 +2183,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
@@ -1496,8 +2199,21 @@ 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();
       const compiled = frameState.compiledFrameGraph;
       frameState.compiledFrameGraph = null;
       frameState.compiledFrameGraphTopologyKey = null;
@@ -1531,10 +2247,23 @@ 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
@@ -1546,8 +2275,21 @@ 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();
       for (const retired of frameState.retiredCompiledFrameGraphs) {
         retired.retire().catch(() => undefined);
       }
@@ -1584,6 +2326,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({