@forgeax/engine-render 0.1.6 → 0.1.19

package/src/pipeline/standard-forward-lane.ts

@@ -3,8 +3,8 @@ import type {
   RenderGraphBuilder,
   RenderGraphError,
 } from '@forgeax/engine-render-graph';
-import { ok, type Result } from '@forgeax/engine-types';
-import { addTypedDebugOverlayPass } from '../debug-draw-glue';
+import { err, ok, type Result } from '@forgeax/engine-types';
+import { SceneDataUnavailableError } from '../errors/render';
 import type {
   RenderPipeline,
   RenderPipelineBuildContext,
@@ -17,15 +17,24 @@ import {
   type RenderPipelineTarget,
 } from '../render-pipeline';
 import {
-  addTypedBloomPasses,
-  addTypedCompositePostEffects,
+  addStandardSceneDataPass,
+  aggregateTemporalDemand,
+  createStandardSceneDataTarget,
+  standardTemporalLaneAdmission,
+} from '../temporal/standard-scene-data';
+import {
+  addTransmissionBackdropPasses,
+  addTransmissionBackdropTemporalPass,
+  resolveTransmissionBackdropTopology,
+  transmissionDemandForTopology,
+} from '../transmission/backdrop';
+import {
   addTypedFrameObservationPass,
-  addTypedFullscreenPass,
   addTypedScenePass,
   addTypedSkyboxPass,
-  addTypedTonemapPass,
 } from '../typed-render-graph-primitives';
 import { addTypedShadowPasses } from '../typed-shadow-passes';
+import { addStandardPost } from './standard-post';
 
 function target(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
@@ -43,11 +52,32 @@ function buildUrp(
   const surface = importRenderPipelineSurface(graph, topology);
   if (!surface.ok) return surface;
 
-  const msaa = topology.camera.antialias === 'msaa' && topology.lane.multisample;
-  const hdr = topology.camera.tonemap !== 'none';
-  const fxaa = topology.camera.antialias === 'fxaa';
-  const linearLdr = !hdr && topology.lane.storageBuffer;
-  const sceneFormat = hdr || linearLdr ? 'rgba16float' : topology.surface.storageFormat;
+  const clearOnly = topology.clearOnly === true;
+  const msaa = !clearOnly && topology.camera.antialias === 'msaa' && topology.lane.multisample;
+  const hdr =
+    !clearOnly && (topology.camera.tonemap !== 'none' || topology.camera.antialias === 'taa');
+  const fxaa = !clearOnly && topology.camera.antialias === 'fxaa';
+  const taa = !clearOnly && topology.camera.antialias === 'taa';
+  const rawOnly = !clearOnly && topology.surface.profile?.kind === 'raw-only';
+  // A direct no-tone/no-FXAA lane writes the final display view directly;
+  // keeping a linear-LDR intermediate would add a redundant fullscreen pass.
+  // FXAA samples the scene before the Output Transform, so its input must
+  // remain float even when tone mapping is disabled. This prevents an
+  // eight-bit quantization before the OETF/display-encoded boundary.
+  // MSAA resolves into a separate linear target before presentation. Treat
+  // that resolved target like linear LDR so the shared Output Transform owns
+  // its write into the surface storage view; without this, the resolve is
+  // never presented and MSAA is indistinguishable from the no-AA path.
+  const linearLdr = !clearOnly && ((!hdr && topology.lane.storageBuffer) || fxaa || msaa);
+  const temporalDemand = aggregateTemporalDemand({
+    taa,
+    motionBlur: !clearOnly && topology.temporal?.motionBlur === true,
+  });
+  const needsTemporalIntermediate = temporalDemand.targetCount === 1;
+  const sceneFormat =
+    hdr || linearLdr || rawOnly || needsTemporalIntermediate
+      ? 'rgba16float'
+      : topology.surface.storageFormat;
 
   const depth = target(graph, 'scene-depth', {
     format: 'depth24plus-stencil8',
@@ -56,24 +86,34 @@ function buildUrp(
   });
   if (!depth.ok) return depth;
 
-  const sceneResolved =
-    hdr || fxaa || linearLdr || msaa
+  const sceneResolved = clearOnly
+    ? ok(surface.value.display ?? surface.value.storage)
+    : hdr || fxaa || linearLdr || msaa || rawOnly || needsTemporalIntermediate
       ? target(graph, 'scene-color', {
           format: sceneFormat,
           size: 'surface',
           sampleCount: 1,
+          domain: 'linear-ldr',
           ...(sceneFormat === topology.surface.storageFormat &&
           topology.surface.storageFormat !== topology.surface.viewFormat
             ? { viewFormats: [topology.surface.viewFormat] }
             : {}),
         })
-      : ok(surface.value.display);
+      : surface.value.display === undefined
+        ? target(graph, 'scene-color', {
+            format: topology.surface.storageFormat,
+            size: 'surface',
+            sampleCount: 1,
+            domain: 'display-encoded',
+          })
+        : ok(surface.value.display);
   if (!sceneResolved.ok) return sceneResolved;
   const scene = msaa
     ? target(graph, 'scene-color-msaa', {
         format: sceneFormat,
         size: 'surface',
         sampleCount: 4,
+        domain: 'linear-ldr',
         ...(sceneFormat === topology.surface.storageFormat &&
         topology.surface.storageFormat !== topology.surface.viewFormat
           ? { viewFormats: [topology.surface.viewFormat] }
@@ -92,6 +132,11 @@ function buildUrp(
     sampleCount: scene.value.sampleCount,
   });
   if (!gpuDriven.ok) return gpuDriven;
+  const transmissionDemand = transmissionDemandForTopology(topology);
+  const transmissionActive = resolveTransmissionBackdropTopology({
+    demand: transmissionDemand,
+    sourceSampleCount: scene.value.sampleCount,
+  }).active;
   const main = addTypedScenePass(graph, {
     name: 'main',
     color: scene.value,
@@ -106,10 +151,100 @@ function buildUrp(
     spotShadow: shadows.value.spot,
     selector: { LightMode: ['Forward'] },
     colorLoadOp: 'load',
+    ...(transmissionActive ? { recordMode: 'opaque' as const } : {}),
     ...(gpuDriven.value === undefined ? {} : { gpuDriven: gpuDriven.value }),
   });
   if (!main.ok) return main;
 
+  const temporalLane = topology.lane.compute
+    ? (topology.standardProfile?.lighting ?? 'direct')
+    : 'cpu-webgl2';
+  const temporalAdmission = standardTemporalLaneAdmission({
+    lane: temporalLane,
+    demand: temporalDemand,
+    capabilities: {
+      compute: topology.lane.compute,
+      storageBuffer: topology.lane.storageBuffer,
+      // Capability probes are the sole authority. A surface/storage format is
+      // not evidence that rgba16float render targets are actually renderable.
+      rgba16floatRenderable: context.capabilities?.rgba16floatRenderable ?? false,
+    },
+  });
+  if (temporalAdmission.status === 'unavailable' && temporalAdmission.reason !== 'no-demand') {
+    return err(
+      new SceneDataUnavailableError({
+        featureIdentity: 'forgeax::standard',
+        schema: 'forgeax::scene-data::temporal-v1',
+        lane: temporalLane,
+        reason: temporalAdmission.reason,
+        missingContributorIds: [],
+        omittedMissingContributorCount: 0,
+        recovery: 'enable-capability',
+      }),
+    );
+  }
+  const temporal =
+    temporalDemand.targetCount === 1 ? createStandardSceneDataTarget(graph) : ok(undefined);
+  if (!temporal.ok) return temporal;
+  if (temporal.value !== undefined) {
+    const producer = addStandardSceneDataPass(graph, temporal.value.temporal, depth.value);
+    if (!producer.ok) return producer;
+  }
+  const transmission = addTransmissionBackdropPasses({
+    graph,
+    source: sceneResolved.value,
+    demand: transmissionDemand,
+    copySize: { width: topology.surface.width, height: topology.surface.height },
+    encodeRoughMip: context.encodeTransmissionMip,
+    includeConsumerPasses: false,
+  });
+  if (!transmission.ok) return transmission;
+  if (transmission.value.topology.active) {
+    const transmissionPass = addTypedScenePass(graph, {
+      name: 'transmission-forward',
+      color: scene.value,
+      depth: depth.value,
+      ...(msaa ? { resolve: sceneResolved.value } : {}),
+      sampled: [
+        shadows.value.directional,
+        shadows.value.spot,
+        ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
+      ],
+      directionalShadow: shadows.value.directional,
+      spotShadow: shadows.value.spot,
+      selector: { LightMode: ['Forward'] },
+      colorLoadOp: 'load',
+      depthLoadOp: 'load',
+      recordMode: 'transmission',
+      // Inject the complete backdrop view so the Standard shader can select
+      // the producer's optional roughness mip level. mipViews[0] is only the
+      // copy destination view and intentionally exposes one level.
+      transmissionBackdrop: transmission.value.backdrop?.view,
+    });
+    if (!transmissionPass.ok) return transmissionPass;
+
+    const transparentPass = addTypedScenePass(graph, {
+      name: 'transparent',
+      color: scene.value,
+      depth: depth.value,
+      ...(msaa ? { resolve: sceneResolved.value } : {}),
+      sampled: [
+        shadows.value.directional,
+        shadows.value.spot,
+        ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
+      ],
+      directionalShadow: shadows.value.directional,
+      spotShadow: shadows.value.spot,
+      selector: { LightMode: ['Forward'] },
+      colorLoadOp: 'load',
+      depthLoadOp: 'load',
+      recordMode: 'transparent',
+    });
+    if (!transparentPass.ok) return transparentPass;
+    const temporal = addTransmissionBackdropTemporalPass(graph, sceneResolved.value);
+    if (!temporal.ok) return temporal;
+  }
+
   const features = context.contributeFeatures([
     {
       kind: 'scene-color',
@@ -129,7 +264,7 @@ function buildUrp(
   ]);
   if (!features.ok) return features;
 
-  if (hdr || linearLdr) {
+  if (hdr || linearLdr || rawOnly) {
     const observation = addTypedFrameObservationPass(
       graph,
       sceneResolved.value,
@@ -138,92 +273,14 @@ function buildUrp(
     if (!observation.ok) return observation;
   }
 
-  let postInput = sceneResolved.value;
-  if (hdr) {
-    const composited = target(graph, 'bloom-composited', {
-      format: 'rgba16float',
-      size: 'surface',
-    });
-    if (!composited.ok) return composited;
-    const bright = target(graph, 'bloom-bright', {
-      format: 'rgba16float',
-      size: 'half-surface',
-    });
-    if (!bright.ok) return bright;
-    const blurH = target(graph, 'bloom-blur-h', {
-      format: 'rgba16float',
-      size: 'half-surface',
-    });
-    if (!blurH.ok) return blurH;
-    const blurV = target(graph, 'bloom-blur-v', {
-      format: 'rgba16float',
-      size: 'half-surface',
-    });
-    if (!blurV.ok) return blurV;
-    const bloom = addTypedBloomPasses(graph, {
-      scene: sceneResolved.value,
-      composited: composited.value,
-      bright: bright.value,
-      blurH: blurH.value,
-      blurV: blurV.value,
-    });
-    if (!bloom.ok) return bloom;
-    postInput = topology.camera.bloom === 'on' ? composited.value : sceneResolved.value;
-  }
-
-  if (hdr) {
-    if (fxaa) {
-      const ldr = target(graph, 'ldr-color', {
-        format: topology.surface.storageFormat,
-        size: 'surface',
-        ...(topology.surface.storageFormat === topology.surface.viewFormat
-          ? {}
-          : { viewFormats: [topology.surface.viewFormat] }),
-      });
-      if (!ldr.ok) return ldr;
-      const tonemap = addTypedTonemapPass(graph, postInput, ldr.value);
-      if (!tonemap.ok) return tonemap;
-      const aa = addTypedFullscreenPass(graph, {
-        name: 'fxaa',
-        shader: 'fxaa',
-        input: ldr.value,
-        output: surface.value.storage,
-      });
-      if (!aa.ok) return aa;
-    } else {
-      const tonemap = addTypedTonemapPass(graph, postInput, surface.value.display);
-      if (!tonemap.ok) return tonemap;
-    }
-  } else if (fxaa) {
-    const aa = addTypedFullscreenPass(graph, {
-      name: 'fxaa',
-      shader: 'fxaa',
-      input: sceneResolved.value,
-      output: surface.value.storage,
-    });
-    if (!aa.ok) return aa;
-  } else if (linearLdr) {
-    const output = addTypedTonemapPass(graph, sceneResolved.value, surface.value.storage, true);
-    if (!output.ok) return output;
-  }
-
-  const postEffects = topology.config?.postEffects ?? [];
-  if (topology.lane.storageBuffer && postEffects.length > 0) {
-    const effects = addTypedCompositePostEffects(
-      graph,
-      postEffects,
-      surface.value.display,
-      surface.value.storage,
-      depth.value,
-      topology.surface,
-    );
-    if (!effects.ok) return effects;
-  }
-
-  const debug = addTypedDebugOverlayPass(graph, surface.value.display);
-  if (!debug.ok) return debug;
-
-  return ok(undefined);
+  return addStandardPost(
+    context,
+    topology,
+    sceneResolved.value,
+    depth.value,
+    surface.value,
+    temporal.value?.temporal,
+  );
 }
 
 export const buildStandardForwardLane = buildUrp;

package/src/pipeline/standard-pipeline.ts

@@ -6,8 +6,8 @@ import type {
   RenderGraphError,
 } from '@forgeax/engine-render-graph';
 import { err, ok, type Result } from '@forgeax/engine-types';
-import { addTypedDebugOverlayPass } from '../debug-draw-glue';
-import { HdrpDeferredCapsInsufficientError } from '../errors/render';
+import { HdrpDeferredCapsInsufficientError, SceneDataUnavailableError } from '../errors/render';
+import type { FramePlan } from '../extract/environment';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_STORAGE,
@@ -28,19 +28,28 @@ import {
   type RenderPipelineTarget,
 } from '../render-pipeline';
 import {
-  addTypedBloomPasses,
-  addTypedCompositePostEffects,
+  addStandardSceneDataPass,
+  aggregateTemporalDemand,
+  createStandardSceneDataTarget,
+  standardTemporalLaneAdmission,
+} from '../temporal/standard-scene-data';
+import {
+  addTransmissionBackdropPasses,
+  addTransmissionBackdropTemporalPass,
+  resolveTransmissionBackdropTopology,
+  transmissionDemandForTopology,
+} from '../transmission/backdrop';
+import {
   addTypedFrameObservationPass,
-  addTypedFullscreenPass,
   addTypedScenePass,
   addTypedSkyboxPass,
   addTypedSsaoPasses,
-  addTypedTonemapPass,
   typedFrameClearColor,
 } from '../typed-render-graph-primitives';
 import { addTypedShadowPasses } from '../typed-shadow-passes';
 
 import { buildStandardForwardLane } from './standard-forward-lane';
+import { addStandardPost } from './standard-post';
 import {
   CLUSTER_GRID_STRIDE_U32,
   DEFAULT_CLUSTER_GRID,
@@ -291,6 +300,35 @@ function buildHdrp(
   if (!gbuffer2.ok) return gbuffer2;
   const scene = target(graph, 'hdrp-scene-color', { format: 'rgba16float', size: 'surface' });
   if (!scene.ok) return scene;
+  const temporalDemand = aggregateTemporalDemand({
+    taa: topology.camera.antialias === 'taa',
+    motionBlur: topology.temporal?.motionBlur === true,
+  });
+  const temporalLane = topology.lane.compute
+    ? (topology.standardProfile?.lighting ?? 'direct')
+    : 'cpu-webgl2';
+  const temporalAdmission = standardTemporalLaneAdmission({
+    lane: temporalLane,
+    demand: temporalDemand,
+    capabilities: {
+      compute: topology.lane.compute,
+      storageBuffer: topology.lane.storageBuffer,
+      rgba16floatRenderable: context.capabilities?.rgba16floatRenderable ?? false,
+    },
+  });
+  if (temporalAdmission.status === 'unavailable' && temporalAdmission.reason !== 'no-demand') {
+    return err(
+      new SceneDataUnavailableError({
+        featureIdentity: 'forgeax::standard',
+        schema: 'forgeax::scene-data::temporal-v1',
+        lane: temporalLane,
+        reason: temporalAdmission.reason,
+        missingContributorIds: [],
+        omittedMissingContributorCount: 0,
+        recovery: 'enable-capability',
+      }),
+    );
+  }
 
   const gbuffer = addTypedScenePass(graph, {
     name: 'g-buffer',
@@ -359,6 +397,27 @@ function buildHdrp(
   const skybox = addTypedSkyboxPass(graph, scene.value);
   if (!skybox.ok) return skybox;
 
+  const transmissionDemand = transmissionDemandForTopology(topology);
+  const transmissionActive = resolveTransmissionBackdropTopology({
+    demand: transmissionDemand,
+    sourceSampleCount: scene.value.sampleCount,
+  }).active;
+  const forwardExtraAccesses: GraphAccess[] = [
+    {
+      resource: buffers.value.lightData,
+      usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
+    },
+    {
+      resource: buffers.value.clusterGrid,
+      usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
+    },
+    {
+      resource: buffers.value.lightIndexList,
+      usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
+    },
+    { resource: buffers.value.clusterUniform, usage: 'uniform-read' },
+  ];
+
   const forward = addTypedScenePass(graph, {
     name: 'forward',
     color: scene.value,
@@ -379,24 +438,85 @@ function buildHdrp(
     spotShadow: shadows.value.spot,
     ...(ssao === undefined ? {} : { ssao }),
     passKind: 'forward',
-    extraAccesses: [
-      {
-        resource: buffers.value.lightData,
-        usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
-      },
-      {
-        resource: buffers.value.clusterGrid,
-        usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
-      },
-      {
-        resource: buffers.value.lightIndexList,
-        usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
-      },
-      { resource: buffers.value.clusterUniform, usage: 'uniform-read' },
-    ],
+    ...(transmissionActive ? { recordMode: 'opaque' as const } : {}),
+    extraAccesses: forwardExtraAccesses,
   });
   if (!forward.ok) return forward;
 
+  const temporal =
+    temporalDemand.targetCount === 1 ? createStandardSceneDataTarget(graph) : ok(undefined);
+  if (!temporal.ok) return temporal;
+  if (temporal.value !== undefined) {
+    const producer = addStandardSceneDataPass(graph, temporal.value.temporal, depth.value);
+    if (!producer.ok) return producer;
+  }
+  const transmission = addTransmissionBackdropPasses({
+    graph,
+    source: scene.value,
+    demand: transmissionDemand,
+    copySize: { width: topology.surface.width, height: topology.surface.height },
+    encodeRoughMip: context.encodeTransmissionMip,
+    includeConsumerPasses: false,
+  });
+  if (!transmission.ok) return transmission;
+  if (transmission.value.topology.active) {
+    const transmissionPass = addTypedScenePass(graph, {
+      name: 'transmission-forward',
+      color: scene.value,
+      depth: depth.value,
+      selector: { LightMode: ['Forward'] },
+      colorLoadOp: 'load',
+      depthLoadOp: 'load',
+      sampled: [
+        gbuffer0.value,
+        gbuffer1.value,
+        gbuffer2.value,
+        shadows.value.directional,
+        shadows.value.spot,
+        ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
+        ...(ssao === undefined ? [] : [ssao]),
+      ],
+      directionalShadow: shadows.value.directional,
+      spotShadow: shadows.value.spot,
+      ...(ssao === undefined ? {} : { ssao }),
+      passKind: 'forward',
+      recordMode: 'transmission',
+      // Inject the complete backdrop view so the Standard shader can select
+      // the producer's optional roughness mip level. mipViews[0] is only the
+      // copy destination view and intentionally exposes one level.
+      transmissionBackdrop: transmission.value.backdrop?.view,
+      extraAccesses: forwardExtraAccesses,
+    });
+    if (!transmissionPass.ok) return transmissionPass;
+
+    const transparentPass = addTypedScenePass(graph, {
+      name: 'transparent',
+      color: scene.value,
+      depth: depth.value,
+      selector: { LightMode: ['Forward'] },
+      colorLoadOp: 'load',
+      depthLoadOp: 'load',
+      sampled: [
+        gbuffer0.value,
+        gbuffer1.value,
+        gbuffer2.value,
+        shadows.value.directional,
+        shadows.value.spot,
+        ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
+        ...(ssao === undefined ? [] : [ssao]),
+      ],
+      directionalShadow: shadows.value.directional,
+      spotShadow: shadows.value.spot,
+      ...(ssao === undefined ? {} : { ssao }),
+      passKind: 'forward',
+      recordMode: 'transparent',
+      extraAccesses: forwardExtraAccesses,
+    });
+    if (!transparentPass.ok) return transparentPass;
+    const temporal = addTransmissionBackdropTemporalPass(graph, scene.value);
+    if (!temporal.ok) return temporal;
+  }
+
   const features = context.contributeFeatures([
     {
       kind: 'scene-color',
@@ -417,90 +537,14 @@ function buildHdrp(
   const observation = addTypedFrameObservationPass(graph, scene.value, 'forgeax::standard');
   if (!observation.ok) return observation;
 
-  const hdr = topology.camera.tonemap !== 'none';
-  const fxaa = topology.camera.antialias === 'fxaa';
-  let postInput = scene.value;
-  if (hdr) {
-    const composited = target(graph, 'bloom-composited', {
-      format: 'rgba16float',
-      size: 'surface',
-    });
-    if (!composited.ok) return composited;
-    const bright = target(graph, 'bloom-bright', {
-      format: 'rgba16float',
-      size: 'half-surface',
-    });
-    if (!bright.ok) return bright;
-    const blurH = target(graph, 'bloom-blur-h', {
-      format: 'rgba16float',
-      size: 'half-surface',
-    });
-    if (!blurH.ok) return blurH;
-    const blurV = target(graph, 'bloom-blur-v', {
-      format: 'rgba16float',
-      size: 'half-surface',
-    });
-    if (!blurV.ok) return blurV;
-    const bloom = addTypedBloomPasses(graph, {
-      scene: scene.value,
-      composited: composited.value,
-      bright: bright.value,
-      blurH: blurH.value,
-      blurV: blurV.value,
-    });
-    if (!bloom.ok) return bloom;
-    postInput = topology.camera.bloom === 'on' ? composited.value : scene.value;
-  }
-
-  if (hdr && fxaa) {
-    const ldr = target(graph, 'ldr-color', {
-      format: topology.surface.storageFormat,
-      size: 'surface',
-      ...(topology.surface.storageFormat === topology.surface.viewFormat
-        ? {}
-        : { viewFormats: [topology.surface.viewFormat] }),
-    });
-    if (!ldr.ok) return ldr;
-    const tonemap = addTypedTonemapPass(graph, postInput, ldr.value);
-    if (!tonemap.ok) return tonemap;
-    const aa = addTypedFullscreenPass(graph, {
-      name: 'fxaa',
-      shader: 'fxaa',
-      input: ldr.value,
-      output: surface.value.storage,
-    });
-    if (!aa.ok) return aa;
-  } else if (hdr) {
-    const tonemap = addTypedTonemapPass(graph, postInput, surface.value.display);
-    if (!tonemap.ok) return tonemap;
-  } else if (fxaa) {
-    const aa = addTypedFullscreenPass(graph, {
-      name: 'fxaa',
-      shader: 'fxaa',
-      input: scene.value,
-      output: surface.value.storage,
-    });
-    if (!aa.ok) return aa;
-  } else {
-    const output = addTypedTonemapPass(graph, scene.value, surface.value.storage, true);
-    if (!output.ok) return output;
-  }
-
-  const postEffects = topology.config?.postEffects ?? [];
-  if (topology.lane.storageBuffer && postEffects.length > 0) {
-    const effects = addTypedCompositePostEffects(
-      graph,
-      postEffects,
-      surface.value.display,
-      surface.value.storage,
-      depth.value,
-      topology.surface,
-    );
-    if (!effects.ok) return effects;
-  }
-  const debug = addTypedDebugOverlayPass(graph, surface.value.display);
-  if (!debug.ok) return debug;
-  return ok(undefined);
+  return addStandardPost(
+    context,
+    topology,
+    scene.value,
+    depth.value,
+    surface.value,
+    temporal.value?.temporal,
+  );
 }
 const buildStandardClusteredLane = buildHdrp;
 
@@ -508,6 +552,9 @@ export interface StandardPipeline extends RenderPipeline {
   readonly identity: typeof STANDARD_PIPELINE_ID;
 }
 
+/** Standard graph inputs are derived once from the immutable frame plan. */
+export type StandardFramePlan = FramePlan;
+
 function profileFor(topology: RenderPipelineTopology): StandardProfile {
   return topology.standardProfile ?? DEFAULT_STANDARD_PROFILE;
 }
@@ -543,6 +590,10 @@ function buildStandard(
     storageBuffer: topology.lane.storageBuffer,
   });
   const effective = standardTopology(topology, profile);
+  // A missing Camera is an intentional clear-only frame.  Keep it on the
+  // direct raster lane so clustered/HDRP resources cannot introduce work or
+  // a post-process lookup into this minimal submit contract.
+  if (effective.clearOnly === true) return buildStandardForwardLane(context, effective);
   if (lane === 'clustered') return buildStandardClusteredLane(context, effective);
   return buildStandardForwardLane(context, effective);
 }