@forgeax/engine-render 0.1.7 → 0.1.19

package/src/record/view-ubo.ts

@@ -8,6 +8,7 @@
 
 import { mat4 } from '@forgeax/engine-math';
 import type { Buffer, RhiQueue } from '@forgeax/engine-rhi';
+import type { FogFrame } from '../extract/environment';
 import type { PointsLinesStyle } from '../points-lines/snapshot';
 import type { CameraSnapshot } from '../render-contract';
 import type {
@@ -15,6 +16,8 @@ import type {
   ExtractedLights,
   SpotLightSnapshot,
 } from '../render-system-extract';
+import type { TemporalView as LegacyTemporalView } from '../temporal/temporal-view';
+import type { TemporalView } from '../temporal/view';
 import { clampPcfKernelSize } from './frame-snapshot';
 import { computeProjectionMatrix, computeViewMatrix } from './helpers';
 
@@ -110,16 +113,34 @@ export function writeViewUbo(
   light: DirectionalLightSnapshot,
   lights: ExtractedLights,
   spotShadowSnapshots: readonly SpotLightSnapshot[],
+  fogOrTemporal?: FogFrame | TemporalView | LegacyTemporalView,
+  temporal?: TemporalView,
 ): void {
+  const isTemporal =
+    fogOrTemporal !== undefined &&
+    ('currentJitterUv' in fogOrTemporal || 'currentUnjitteredViewProjection' in fogOrTemporal);
+  const fog = isTemporal ? undefined : fogOrTemporal;
+  const resolvedTemporal = temporal ?? (isTemporal ? fogOrTemporal : undefined);
   // Compose worldViewProj once per frame (view * proj).
   const projMatrix = computeProjectionMatrix(camera);
   const viewMatrix = computeViewMatrix(camera);
-  const worldViewProj = mat4.create();
-  mat4.multiply(worldViewProj, projMatrix, viewMatrix);
+  const unjitteredViewProjection = mat4.create();
+  mat4.multiply(unjitteredViewProjection, projMatrix, viewMatrix);
+  const jitteredProjection = mat4.create();
+  if (resolvedTemporal?.currentJitterUv !== undefined) {
+    const jitter = mat4.identity(mat4.create());
+    jitter[12] = resolvedTemporal.currentJitterUv[0] * 2;
+    jitter[13] = resolvedTemporal.currentJitterUv[1] * -2;
+    mat4.multiply(jitteredProjection, jitter, projMatrix);
+  } else {
+    for (let i = 0; i < 16; i += 1) jitteredProjection[i] = projMatrix[i] ?? 0;
+  }
+  const mainProjection = mat4.create();
+  mat4.multiply(mainProjection, jitteredProjection, viewMatrix);
 
   const VIEW_PAYLOAD_FLOATS = 240;
   const viewPayload = new Float32Array(VIEW_PAYLOAD_FLOATS);
-  for (let i = 0; i < 16; i++) viewPayload[i] = worldViewProj[i] ?? 0;
+  for (let i = 0; i < 16; i++) viewPayload[i] = mainProjection[i] ?? 0;
   viewPayload[16] = (light.direction[0] ?? 0) * light.intensity;
   viewPayload[17] = (light.direction[1] ?? -1) * light.intensity;
   viewPayload[18] = (light.direction[2] ?? 0) * light.intensity;
@@ -137,7 +158,7 @@ export function writeViewUbo(
   // Host pre-computes mat4.invert so the skybox fragment shader avoids
   // per-pixel matrix inversion (charter P4 consistent abstraction).
   const inverseViewProj = mat4.create();
-  mat4.invert(inverseViewProj, worldViewProj);
+  mat4.invert(inverseViewProj, mainProjection);
   for (let i = 0; i < 16; i++) viewPayload[44 + i] = inverseViewProj[i] ?? 0;
   // lightViewProj[1..3] at [60..107].
   if (lights.lightViewProj !== undefined) {
@@ -149,6 +170,21 @@ export function writeViewUbo(
       }
     }
   }
+
+  // Temporal ABI tail: current and last-successful unjittered projections
+  // stay separate from the jittered main projection and never advance on a
+  // failed submission. The fixed 240-float payload already reserves these
+  // 36 slots at byte offsets 784..920.
+  const previous = resolvedTemporal?.previousUnjitteredViewProjection;
+  for (let i = 0; i < 16; i += 1) {
+    viewPayload[196 + i] = unjitteredViewProjection[i] ?? 0;
+    // No previous successful frame exists on first frame/reset. Keep this
+    // lane zeroed instead of copying current state into a history slot.
+    viewPayload[212 + i] = previous?.[i] ?? 0;
+  }
+  viewPayload[228] = camera.near;
+  viewPayload[229] = camera.far;
+  viewPayload[230] = camera.projection === 'orthographic' ? 1 : 0;
   // splitPlanes at [108], [112], [116], [120] (vec4 stride = 4 floats).
   if (lights.splitPlanes !== undefined) {
     for (let s = 0; s < 4; s++) {
@@ -202,6 +238,18 @@ export function writeViewUbo(
     }
   }
 
+  // Fog is a resource-owner semantic carried by the shared View ABI. Keep the
+  // disabled payload zeroed and write only the selected frame facts so both
+  // direct and clustered lanes consume the same owner projection.
+  if (fog !== undefined) {
+    viewPayload[232] = fog.color[0] ?? 0;
+    viewPayload[233] = fog.color[1] ?? 0;
+    viewPayload[234] = fog.color[2] ?? 0;
+    viewPayload[235] = fog.density;
+    viewPayload[236] = fog.heightFalloff;
+    viewPayload[237] = fog.maxOpacity;
+  }
+
   const viewUploadResult = queue.writeBuffer(viewUniformBuffer, 0, viewPayload);
   if (!viewUploadResult.ok) throw viewUploadResult.error;
 

package/src/render-contract.ts

@@ -3,11 +3,12 @@ import type { World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
 import type { Vec3 } from '@forgeax/engine-math';
 import type { ProfileFrameToken, Profiler } from '@forgeax/engine-profiler';
-import type { RenderGraphError } from '@forgeax/engine-render-graph';
+import type { ColorValueDomain, RenderGraphError } from '@forgeax/engine-render-graph';
 import type {
   BindGroupLayout,
   Buffer,
   Result,
+  RhiCanvasSurfacePresentationProof,
   RhiCaps,
   RhiCommandEncoder,
   RhiDevice,
@@ -23,16 +24,26 @@ import type { SkinError } from '@forgeax/engine-skinning';
 import type { ImageError } from '@forgeax/engine-types';
 import type { RhiBackendInstrumentation } from './assembly/backend-contract';
 import type { Antialias, BloomEnabled, Tonemap } from './components/camera';
+import type { EnvironmentInspection } from './environment/inspection';
 import type { RenderError } from './errors/render';
 import type { RenderFeature, RenderFeatureDiagnostics } from './features/types';
 import type { PostProcessShaderEntry } from './fullscreen-post-process-pass';
-import type { RenderSceneInspection } from './inspection-types';
-
+import type {
+  BloomInspection,
+  MotionBlurInspection,
+  RenderSceneInspection,
+  TemporalTargetInspection,
+  TransmissionInspection,
+} from './inspection-types';
+import type { TemporalInspection } from './temporal/inspection';
+
+export type { TransmissionInspection } from './inspection-types';
 export type { PointsLinesInspection } from './points-lines/inspection';
 
 import type { MeshMaterialBindingObservation } from './mesh-material-bindings';
 import type { StandardProfile } from './pipeline/standard-profile';
 import type { PostProcessError } from './post-process-errors';
+import type { TemporalView } from './temporal/view';
 
 export type RenderResult<T, E> =
   | { readonly ok: true; readonly value: T }
@@ -51,6 +62,10 @@ export type RenderWorldLease = RenderReadLease;
 export interface CameraSnapshot {
   /** Stable ECS identity used by the frame plan's camera authority fact. */
   readonly entityKey?: number;
+  /** World index supplied by the multi-world extract merge. */
+  readonly worldId?: number;
+  /** Camera-owned history generation forwarded into the frame plan. */
+  readonly historyVersion?: number;
   /** World-space camera translation (mat4.getTranslation of Transform.world). */
   readonly position: Vec3;
   /** Resolved world-space camera mat4, copied from Transform.world. */
@@ -74,10 +89,26 @@ export interface CameraSnapshot {
   readonly bloomIntensity: number;
   readonly bloomBlurRadius: number;
   readonly clearColor: readonly [number, number, number, number];
+  /** Renderer-owned temporal projection used by Standard's TAA producer. */
+  readonly temporal?: TemporalView;
+  /** Active-camera motion blur parameters, present only when demanded. */
+  readonly motionBlur?: {
+    readonly shutterAngle: number;
+    readonly maxRadiusPixels: number;
+    readonly sampleCount: number;
+  };
 }
 
-/** Stable identity owned by the Standard feature host for built-in tonemap. */
-export const STANDARD_TONEMAP_FEATURE_ID = 'forgeax::standard::tonemap';
+/** Stable identity owned by the Standard feature host for output transform. */
+export const STANDARD_OUTPUT_TRANSFORM_FEATURE_ID = 'forgeax::standard::output-transform';
+
+export type {
+  EnvironmentFrame,
+  EnvironmentSource,
+  FogFrame,
+  FramePlan,
+} from './extract/environment';
+export type { TemporalView } from './temporal/view';
 
 /**
  * Render-graph state exposed to pipeline declarations. Concrete pipeline
@@ -245,6 +276,57 @@ export interface FrameReceiptObservation {
   readonly include: readonly ('timings' | 'draws' | 'bindings')[];
 }
 
+/** Stable backend facts for the Standard output transform projection. */
+export interface RenderOutputInspection {
+  readonly outputTransform?: typeof STANDARD_OUTPUT_TRANSFORM_FEATURE_ID;
+  readonly displayEncoded: boolean;
+  readonly intermediateFormat?: TextureFormat;
+  /** Concrete surface route committed by configureSurface. */
+  readonly surfaceProfile?: 'dual-view' | 'raw-only';
+  /** Pass names from the same committed graph as the output facts. */
+  readonly graphPassNames: readonly string[];
+  /** Detached descriptor for the graph-owned output target, when present. */
+  readonly standardOutputColor?: RenderStandardOutputColorInspection;
+  readonly surfaceStorage: TextureFormat;
+  readonly surfaceDisplay: TextureFormat;
+  readonly endpoint: 'surface.storage.raw';
+  readonly capability: 'rgba16float-renderable' | 'surface-raw-endpoint' | 'unavailable';
+  readonly presentationProof?: RhiCanvasSurfacePresentationProof;
+  readonly error:
+    | {
+        readonly code: string;
+        readonly expected: string;
+        readonly hint: string;
+        readonly detail?: unknown;
+      }
+    | undefined;
+}
+
+/** Detached descriptor for the graph-owned display-encoded intermediate. */
+export interface RenderStandardOutputColorInspection {
+  readonly format: TextureFormat;
+  readonly domain?: ColorValueDomain;
+  readonly width: number;
+  readonly height: number;
+  readonly sampleCount: number;
+  readonly usage: number;
+}
+
+/** Stable identity refs for a renderer-owned frame observation. */
+export interface RenderObservationInspection {
+  readonly observationId: string;
+  readonly frameId: number;
+  /** Camera antialias mode used by the frame carrying this observation. */
+  readonly antialias?: Antialias;
+  /** Surface route committed for the same frame graph. */
+  readonly surfaceProfile?: 'dual-view' | 'raw-only';
+  /** Capability fact used when resolving a raw-only float target. */
+  readonly rgba16floatRenderable?: boolean;
+  /** Exact pass names and target descriptor from the committed graph. */
+  readonly passNames: readonly string[];
+  readonly standardOutputColor?: RenderStandardOutputColorInspection;
+}
+
 /**
  * Detached renderer facts for host diagnostics and capability selection.
  *
@@ -266,12 +348,32 @@ export interface RenderInspection {
   readonly frustumStats: { readonly culled: number; readonly total: number };
   readonly visibilityStats: { readonly explicitlyHidden: number };
   readonly renderScene: RenderSceneInspection;
+  /** Last completed transmission candidate facts, detached from GPU handles. */
+  readonly transmission?: TransmissionInspection;
   readonly meshMaterialBindings: readonly MeshMaterialBindingObservation[];
   readonly perFramePassNames: readonly string[];
   readonly bindGroupCounts: {
     readonly createBindGroup: number;
     readonly keys: readonly string[];
   };
+  /** Output transform facts; never includes fixture metrics or pixel bytes. */
+  readonly outputTransform?: typeof STANDARD_OUTPUT_TRANSFORM_FEATURE_ID;
+  readonly displayEncoded: boolean;
+  readonly intermediateFormat?: TextureFormat;
+  readonly surfaceStorage: TextureFormat;
+  readonly surfaceDisplay: TextureFormat;
+  readonly endpoint: 'surface.storage.raw';
+  readonly capability: RenderOutputInspection['capability'];
+  readonly presentationProof?: RhiCanvasSurfacePresentationProof;
+  readonly error: RenderOutputInspection['error'];
+  readonly observation: RenderObservationInspection;
+  readonly environment: EnvironmentInspection;
+  readonly temporal: TemporalInspection;
+  readonly bloom: BloomInspection;
+  /** Semantic Standard temporal target metadata; no graph or RHI handles. */
+  readonly temporalTarget?: TemporalTargetInspection;
+  /** Renderer-owned Motion Blur facts; absent when no component is active. */
+  readonly motionBlur?: MotionBlurInspection;
 }
 
 /** Backend marker — single-element union preserved for future extensibility (D-2). */
@@ -379,7 +481,8 @@ export const RENDER_GRAPH_EXECUTION_PHASE_CATALOG = [
   'record/graph-execute/forward/material-bind-groups',
   'record/graph-execute/forward/pipeline-selection',
   'record/graph-execute/forward/draw-submit',
-  'record/graph-execute/tonemap',
+  'record/graph-execute/output-transform',
+  'record/graph-execute/present',
   'record/graph-execute/debug-overlay',
   'record/graph-execute/shadow',
   'record/graph-execute/spot-shadow',

package/src/render-graph-primitives.ts

@@ -665,7 +665,10 @@ function dispatchFullscreenPass(
   // the swap-chain path uses the backend-selected surface view format.
   let writeFormat = ctx.pipelineState?.colorAttachmentFormat ?? 'rgba8unorm-srgb';
   if (graphPass !== undefined) {
-    writeView = ctx.view;
+    // Typed graph passes must write their declared output target. The frame
+    // surface view is only the fallback for legacy passes; using it here
+    // leaves a typed output target cleared while the next pass samples it.
+    writeView = (resolveCtx?.resolve(color) as TextureView | undefined) ?? ctx.view;
     writeFormat = graphOutputFormat ?? writeFormat;
   } else if (rawSwapchainOutput && color === 'swapchain') {
     const rawViewRes = ctx.runtime.device.createTextureView(ctx.currentTexture, {});
@@ -733,6 +736,20 @@ function dispatchFullscreenPass(
     paramsBuffer,
     depthTexView,
     depthSampler,
+    built.extraColorBindings.map((binding, index) => {
+      const read = entry.reads?.filter(
+        (candidate) => typeof candidate === 'string' || candidate.sampleType !== 'depth',
+      )[index + 1];
+      const key = typeof read === 'string' ? read : read?.key;
+      const view = key === undefined ? undefined : resolveCtx?.resolve(key);
+      if (view === undefined) {
+        throw new PostProcessError({
+          code: 'fullscreen-input-not-found',
+          detail: { readsKey: key ?? 'additional-read', passName: name },
+        });
+      }
+      return { binding, view: view as TextureView };
+    }),
   );
   if (bindGroup === null) return;
 

package/src/render-pipeline.ts

@@ -26,7 +26,13 @@ import type {
   RenderGraphError,
   RenderGraphFrame,
 } from '@forgeax/engine-render-graph';
-import type { BindGroup, RhiError, RhiRenderPassEncoder, TextureFormat } from '@forgeax/engine-rhi';
+import type {
+  BindGroup,
+  RhiCaps,
+  RhiError,
+  RhiRenderPassEncoder,
+  TextureFormat,
+} from '@forgeax/engine-rhi';
 import { ok, type Result } from '@forgeax/engine-types';
 import type { Tonemap } from './components/camera';
 import type { RenderError } from './errors/render';
@@ -35,8 +41,10 @@ import {
   GPU_TEXTURE_USAGE_COPY_SRC,
   GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
 } from './gpu-texture-usage';
-import type { StandardProfile } from './pipeline/standard-profile';
+import { STANDARD_POST_STAGE_NAMES, type StandardProfile } from './pipeline/standard-profile';
+import type { SurfaceProfile } from './record/render-context';
 import type { RenderPipelineContext } from './render-contract';
+import type { TransmissionDemand } from './transmission/projection';
 
 export type { RenderPipelineContext } from './render-contract';
 
@@ -50,7 +58,7 @@ export interface ToneOutputContract {
   readonly exposureStage: 'linearHdr' | 'none';
 }
 
-export type RenderPostStageName = 'transparent-blend' | 'bloom' | 'tone' | 'fxaa' | 'output';
+export type RenderPostStageName = (typeof STANDARD_POST_STAGE_NAMES)[number];
 export type RenderPostDomainStage = readonly [
   RenderPostStageName,
   ColorValueDomain,
@@ -60,18 +68,21 @@ export type RenderPostDomainStage = readonly [
 /**
  * Single post-stage domain contract shared by the Standard lighting lanes.
  * The selected scene domain for transparent geometry is explicit; every later
- * stage follows the same linear blend, tone, anti-alias, and output sequence.
+ * stage follows the same linear blend, output-transform, anti-alias, post-effect, and present sequence.
  */
 export function resolvePostColorDomainContract(
   sceneDomain: 'linear-ldr' | 'linear-hdr',
 ): readonly RenderPostDomainStage[] {
   const scene: ColorValueDomain = sceneDomain;
+  const [transparentBlend, bloom, outputTransform, fxaa, postEffect, present] =
+    STANDARD_POST_STAGE_NAMES;
   return [
-    ['transparent-blend', scene, scene],
-    ['bloom', 'linear-hdr', 'linear-hdr'],
-    ['tone', 'linear-hdr', 'linear-ldr'],
-    ['fxaa', 'linear-ldr', 'linear-ldr'],
-    ['output', 'linear-ldr', 'display-encoded'],
+    [transparentBlend, scene, scene],
+    [bloom, 'linear-hdr', 'linear-hdr'],
+    [outputTransform, scene, 'display-encoded'],
+    [fxaa, 'display-encoded', 'display-encoded'],
+    [postEffect, 'display-encoded', 'display-encoded'],
+    [present, 'display-encoded', 'display-encoded'],
   ];
 }
 
@@ -104,13 +115,25 @@ export interface RenderPipelineTopology {
   readonly pipelineId: string;
   readonly standardProfile?: StandardProfile | undefined;
   readonly config: import('@forgeax/engine-types').RenderPipelineAsset['config'];
+  /**
+   * The record stage had no Camera and injected the synthetic clear-only
+   * snapshot.  Keep that fact explicit so a normal no-tone Camera still uses
+   * the float Output Transform while the empty-scene contract can write its
+   * clear directly to the surface.
+   */
+  readonly clearOnly?: boolean | undefined;
   readonly surface: {
     readonly width: number;
     readonly height: number;
     readonly storageFormat: import('@forgeax/engine-rhi').TextureFormat;
     readonly viewFormat: import('@forgeax/engine-rhi').TextureFormat;
+    readonly profile?: SurfaceProfile | undefined;
   };
   readonly camera: Pick<RenderPipelineContext['camera'], 'tonemap' | 'antialias' | 'bloom'>;
+  readonly temporal?: {
+    readonly taa: boolean;
+    readonly motionBlur: boolean;
+  };
   readonly shadow: {
     readonly mapSize: number;
     readonly cascadeCount: 1 | 2 | 3 | 4;
@@ -126,6 +149,8 @@ export interface RenderPipelineTopology {
   };
   readonly featureTopologySignature: string;
   readonly gpuDrivenTopologySignature: string;
+  /** Internal graph fact; renderer callers do not configure transmission demand. */
+  readonly transmissionDemand?: TransmissionDemand | undefined;
 }
 
 export interface RenderPipelineFrame extends RenderPipelineContext, RenderGraphFrame {}
@@ -135,6 +160,7 @@ export interface RenderPipelineTarget {
   readonly view: GraphTextureView;
   readonly format: TextureFormat;
   readonly sampleCount: 1 | 4;
+  readonly domain?: ColorValueDomain | undefined;
   readonly resolveTarget?: GraphTextureView | undefined;
 }
 
@@ -153,6 +179,7 @@ export function createRenderPipelineTarget(
     view: view.value,
     format: viewDescriptor.format ?? descriptor.format,
     sampleCount: descriptor.sampleCount === 4 ? 4 : 1,
+    ...(descriptor.domain === undefined ? {} : { domain: descriptor.domain }),
   });
 }
 
@@ -160,7 +187,7 @@ export function importRenderPipelineSurface(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
   topology: RenderPipelineTopology,
 ): Result<
-  { readonly display: RenderPipelineTarget; readonly storage: RenderPipelineTarget },
+  { readonly display?: RenderPipelineTarget; readonly storage: RenderPipelineTarget },
   RenderGraphError
 > {
   const texture = graph.importTexture(
@@ -168,21 +195,32 @@ export function importRenderPipelineSurface(
     {
       format: topology.surface.storageFormat,
       size: 'surface',
-      usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT | GPU_TEXTURE_USAGE_COPY_SRC,
-      viewFormats:
-        topology.surface.storageFormat === topology.surface.viewFormat
-          ? []
-          : [topology.surface.viewFormat],
+      // The imported surface is the final encoded endpoint.  Keeping this
+      // semantic fact on the graph resource lets detached inspection project
+      // from the compiled graph instead of re-inferring it from format names.
+      domain: 'display-encoded',
+      usage:
+        GPU_TEXTURE_USAGE_RENDER_ATTACHMENT |
+        (topology.surface.profile?.kind === 'raw-only' ? 0 : GPU_TEXTURE_USAGE_COPY_SRC),
+      viewFormats: [
+        ...(topology.surface.profile?.viewFormats ??
+          (topology.surface.storageFormat === topology.surface.viewFormat
+            ? []
+            : [topology.surface.viewFormat])),
+      ],
     },
     (frame) => frame.currentTexture,
   );
   if (!texture.ok) return texture;
-  const display = graph.importView(
-    texture.value,
-    { label: 'surface.display', format: topology.surface.viewFormat },
-    (frame) => frame.view,
-  );
-  if (!display.ok) return display;
+  const display =
+    topology.surface.profile?.hasDisplayEndpoint === false
+      ? undefined
+      : graph.importView(
+          texture.value,
+          { label: 'surface.display', format: topology.surface.viewFormat },
+          (frame) => frame.view,
+        );
+  if (display !== undefined && !display.ok) return display;
   const storage = graph.importView(
     texture.value,
     { label: 'surface.storage', format: topology.surface.storageFormat },
@@ -197,17 +235,23 @@ export function importRenderPipelineSurface(
   );
   if (!storage.ok) return storage;
   return ok({
-    display: {
-      texture: texture.value,
-      view: display.value,
-      format: topology.surface.viewFormat,
-      sampleCount: 1,
-    },
+    ...(display === undefined
+      ? {}
+      : {
+          display: {
+            texture: texture.value,
+            view: display.value,
+            format: topology.surface.viewFormat,
+            sampleCount: 1 as const,
+            domain: 'display-encoded' as const,
+          },
+        }),
     storage: {
       texture: texture.value,
       view: storage.value,
       format: topology.surface.storageFormat,
       sampleCount: 1,
+      domain: 'display-encoded',
     },
   });
 }
@@ -232,13 +276,42 @@ export interface RenderPipelineGpuDrivenProjection {
 
 export interface RenderPipelineBuildContext<FrameCtx extends RenderPipelineFrame> {
   readonly graph: RenderGraphBuilder<FrameCtx>;
+  /**
+   * Renderer-owned capability facts needed for admission decisions. The
+   * Standard temporal producer must use the live device probe rather than
+   * inferring rgba16float support from the selected surface format.
+   */
+  readonly capabilities?: Pick<RhiCaps, 'rgba16floatRenderable'>;
+  /**
+   * Renderer-owned TAA history targets. The graph sees only imported typed
+   * targets; opaque RHI handles remain inside RenderFrameState.
+   */
+  readonly taaHistory?: {
+    readonly currentColor: RenderPipelineTarget;
+    readonly previousColor: RenderPipelineTarget;
+    readonly currentTemporal: RenderPipelineTarget;
+    readonly previousTemporal: RenderPipelineTarget;
+  };
+  /** Renderer-owned, prewarmed encoder for one graph mip level. */
+  readonly encodeTransmissionMip?: (input: {
+    readonly pass: RhiRenderPassEncoder;
+    readonly frame: FrameCtx;
+    readonly resources: GraphResourceResolver;
+    readonly source: GraphTextureView;
+    readonly destination: GraphTextureView;
+    readonly level: number;
+  }) => void;
   projectGpuDriven(target: {
     readonly format: TextureFormat;
     readonly sampleCount: 1 | 4;
   }): Result<RenderPipelineGpuDrivenProjection | undefined, RenderPipelineBuildError>;
   contributeFeatures(
     targets: readonly RenderPipelineFeatureTarget[],
+    semanticTargets?: readonly RenderPipelineTarget[],
+    namedTargets?: Readonly<Record<string, RenderPipelineTarget>>,
   ): Result<void, RenderPipelineBuildError>;
+  /** Whether a producer-owned feature is installed for this graph build. */
+  hasFeature?(identity: string): boolean;
 }
 
 export type RenderPipelineBuildError = RenderGraphError | RenderError | RhiError;