@forgeax/engine-render 0.1.20 → 0.1.23

package/src/pipeline/standard-lighting/topology.ts

@@ -0,0 +1,120 @@
+import { err, ok, type Result } from '@forgeax/engine-types';
+import type { PreparedStandardLighting } from './prepare';
+import type { StandardClusterTransport } from './transport';
+
+/** A prepared frame with no local lights on a non-storage backend. */
+export interface StandardNoLocalTopologyInput {
+  readonly kind: 'no-local-lights';
+  readonly prepared: PreparedStandardLighting;
+}
+
+/** A prepared frame whose Standard surface uses one proven Cluster transport. */
+export interface StandardClusteredTopologyInput {
+  readonly kind: 'clustered';
+  readonly prepared: PreparedStandardLighting;
+  readonly transport: StandardClusterTransport;
+}
+
+/**
+ * The only lighting value accepted by a Standard topology adapter. It is a
+ * projection of one prepared frame, not a second light/config/capability
+ * input. Both Forward and Deferred keep the same object identity for a frame.
+ */
+export type StandardTopologyInput = StandardNoLocalTopologyInput | StandardClusteredTopologyInput;
+
+export type StandardTopologyInputValue = StandardTopologyInput;
+
+/**
+ * Stable identity for the graph-facing Standard lighting declaration.
+ *
+ * The prepared light payload itself is frame-local and must never be retained
+ * by a compiled graph. These are the only facts that affect the Cluster graph
+ * shape and persistent buffer contract, so the record owner can reject an old
+ * graph before uploading a payload derived from a different declaration.
+ */
+export function standardLightingTopologySignature(
+  input: StandardTopologyInputValue | undefined,
+): string {
+  if (input === undefined) return 'missing';
+  if (input.kind === 'no-local-lights') return 'no-local-lights';
+  return JSON.stringify({
+    kind: input.kind,
+    transport: input.transport.kind,
+    producer: input.transport.producer,
+    grid: input.prepared.layout.grid,
+    clusterGridU32Length: input.prepared.layout.clusterGridU32Length,
+    lightIndexListCapacity: input.prepared.layout.lightIndexListCapacity,
+    lightDataSlotCount: input.prepared.layout.lightDataSlotCount,
+    lightBoundsInt32Length: input.prepared.layout.lightBoundsInt32Length,
+  });
+}
+
+export interface StandardTopologyInputError {
+  readonly code: 'topology-input-invalid';
+  readonly expected: 'prepared Standard lighting topology input';
+  readonly hint: 'derive topology from prepared Standard lighting';
+  readonly detail: {
+    readonly field: 'kind' | 'prepared' | 'transport' | 'lights' | 'capabilities';
+  };
+}
+
+function invalid(
+  field: StandardTopologyInputError['detail']['field'],
+): Result<never, StandardTopologyInputError> {
+  return err({
+    code: 'topology-input-invalid',
+    expected: 'prepared Standard lighting topology input',
+    hint: 'derive topology from prepared Standard lighting',
+    detail: { field },
+  });
+}
+
+/**
+ * Validate that transport and prepared membership are the same derivation.
+ * The identity checks make it impossible for an adapter to silently combine
+ * one path's layout/counts with another path's prepared light corpus.
+ */
+export function deriveStandardTopologyInput(
+  input: StandardTopologyInput,
+): Result<StandardTopologyInputValue, StandardTopologyInputError> {
+  const candidate = input as StandardTopologyInput & {
+    readonly kind?: unknown;
+    readonly lights?: unknown;
+    readonly capabilities?: unknown;
+    readonly transport?: unknown;
+  };
+  if ('lights' in candidate) return invalid('lights');
+  if ('capabilities' in candidate) return invalid('capabilities');
+  if (input === null || typeof input !== 'object') return invalid('kind');
+  if (input.prepared === null || typeof input.prepared !== 'object') {
+    return invalid('prepared');
+  }
+
+  const prepared = input.prepared;
+  if (input.kind === 'no-local-lights') {
+    if (prepared.local.length !== 0 || 'transport' in candidate) return invalid('transport');
+    return ok(input);
+  }
+  if (input.kind !== 'clustered') return invalid('kind');
+  if (
+    !('transport' in candidate) ||
+    candidate.transport === null ||
+    typeof candidate.transport !== 'object'
+  ) {
+    return invalid('transport');
+  }
+
+  const transport = input.transport;
+  const requested = prepared.local.length;
+  const transportMatchesPrepared =
+    transport.layout === prepared.layout &&
+    transport.requestedLightCount === requested &&
+    transport.admittedLightCount === requested &&
+    transport.membershipEntryCount === prepared.membershipEntryCount &&
+    transport.lightBoundsBytes === prepared.lightBounds.byteLength;
+  const producerMatchesKind =
+    (transport.producer === 'gpu' && transport.kind === 'compute-storage') ||
+    (transport.producer === 'cpu' && transport.kind === 'cpu-storage');
+  if (!transportMatchesPrepared || !producerMatchesKind) return invalid('transport');
+  return ok(input);
+}

package/src/pipeline/standard-lighting/transport.ts

@@ -0,0 +1,78 @@
+import { err, ok, type Result } from '@forgeax/engine-types';
+import { type RenderError, StandardClusterTransportUnavailableError } from '../../errors/render';
+import { BYTES_PER_DIRECT_LIGHT_SLOT } from '../../light-buffer-layout';
+import type { PreparedStandardLighting } from './prepare';
+
+export interface StandardClusterCapabilities {
+  readonly compute: boolean;
+  readonly storageBuffer: boolean;
+  /**
+   * The graph producer is ready to encode the selected compute lane. The
+   * renderer supplies this from the actual pipeline + bind-group layout; it is
+   * required so capability admission cannot forge a GPU producer from
+   * `compute` alone.
+   */
+  readonly membershipPipelineReady: boolean;
+}
+
+/** Only transports with storage-backed membership representation exist. */
+export type StandardClusterTransportKind = 'compute-storage' | 'cpu-storage';
+export type StandardClusterMembershipProducer = 'cpu' | 'gpu';
+
+export interface StandardClusterTransport {
+  readonly kind: StandardClusterTransportKind;
+  readonly producer: StandardClusterMembershipProducer;
+  readonly layout: PreparedStandardLighting['layout'];
+  readonly requestedLightCount: number;
+  readonly admittedLightCount: number;
+  readonly membershipEntryCount: number;
+  readonly occupiedClusterCount: number;
+  readonly clusterGridBytes: number;
+  readonly lightIndexListBytes: number;
+  readonly lightDataBytes: number;
+  readonly lightBoundsBytes: number;
+}
+
+function occupiedClusterCount(prepared: PreparedStandardLighting): number {
+  let occupied = 0;
+  for (let index = 1; index < prepared.clusterGrid.length; index += 2) {
+    if ((prepared.clusterGrid[index] ?? 0) > 0) occupied += 1;
+  }
+  return occupied;
+}
+
+/**
+ * Select a transport from one prepared frame. Capability facts choose only a
+ * producer/storage pair; all counts and byte sizes come from that frame.
+ */
+export function selectStandardClusterTransport(
+  capabilities: StandardClusterCapabilities,
+  prepared: PreparedStandardLighting,
+): Result<StandardClusterTransport, RenderError> {
+  const requested = prepared.local.length;
+  if (!capabilities.storageBuffer) {
+    return err(
+      new StandardClusterTransportUnavailableError(
+        requested,
+        'enable a proven storage-buffer Cluster transport; compute without storage is not a membership path',
+      ),
+    );
+  }
+
+  const producer: StandardClusterMembershipProducer =
+    capabilities.compute && capabilities.membershipPipelineReady ? 'gpu' : 'cpu';
+  const kind: StandardClusterTransportKind = producer === 'gpu' ? 'compute-storage' : 'cpu-storage';
+  return ok({
+    kind,
+    producer,
+    layout: prepared.layout,
+    requestedLightCount: requested,
+    admittedLightCount: requested,
+    membershipEntryCount: prepared.membershipEntryCount,
+    occupiedClusterCount: occupiedClusterCount(prepared),
+    clusterGridBytes: prepared.layout.clusterGridU32Length * Uint32Array.BYTES_PER_ELEMENT,
+    lightIndexListBytes: prepared.membershipEntryCount * Uint32Array.BYTES_PER_ELEMENT,
+    lightDataBytes: requested * BYTES_PER_DIRECT_LIGHT_SLOT,
+    lightBoundsBytes: prepared.lightBounds.byteLength,
+  });
+}

package/src/pipeline/standard-pipeline.ts

@@ -1,21 +1,13 @@
-import type {
-  GraphAccess,
-  GraphBuffer,
-  GraphTextureDescriptor,
-  RenderGraphBuilder,
+import {
+  type GraphAccess,
+  type GraphTextureDescriptor,
+  type RenderGraphBuilder,
   RenderGraphError,
 } from '@forgeax/engine-render-graph';
 import { err, ok, type Result } from '@forgeax/engine-types';
-import { HdrpDeferredCapsInsufficientError, SceneDataUnavailableError } from '../errors/render';
+import { SceneDataUnavailableError, StandardProfileInvalidError } from '../errors/render';
 import type { FramePlan } from '../extract/environment';
-import {
-  GPU_BUFFER_USAGE_COPY_DST,
-  GPU_BUFFER_USAGE_STORAGE,
-  GPU_BUFFER_USAGE_UNIFORM,
-} from '../gpu-usage';
-import { getOrCreateHdrpBuffers, type HdrpBuffers } from '../hdrp-buffers';
 import { DEFERRED_COLOR_FORMATS } from '../pipeline-spec';
-import type { _InternalRenderPipelineContext } from '../record/render-context';
 import type {
   RenderPipeline,
   RenderPipelineBuildContext,
@@ -48,16 +40,20 @@ import {
 } from '../typed-render-graph-primitives';
 import { addTypedShadowPasses } from '../typed-shadow-passes';
 import { addAuthoredVolumetricFogPasses } from '../volume/passes';
-
 import { buildStandardForwardLane } from './standard-forward-lane';
+import {
+  addStandardClusterMembershipPass,
+  importStandardClusterBuffers,
+  standardClusterReadAccesses,
+} from './standard-lighting/graph';
+import {
+  deriveStandardTopologyInput,
+  type StandardTopologyInputValue,
+} from './standard-lighting/topology';
 import { addStandardPost } from './standard-post';
 import {
-  CLUSTER_GRID_STRIDE_U32,
-  DEFAULT_CLUSTER_GRID,
   DEFAULT_STANDARD_PROFILE,
-  LIGHT_INDEX_LIST_CAPACITY,
-  MAX_LIGHTS,
-  resolveStandardLane,
+  STANDARD_LIGHT_COUNTS,
   STANDARD_PIPELINE_ID,
   type StandardProfile,
 } from './standard-profile';
@@ -125,26 +121,11 @@ fn cs_cluster_membership(@builtin(global_invocation_id) global_id : vec3<u32>) {
   }
 }
 `;
-export class HdrpInstallError extends Error {
-  readonly code = 'hdrp-grid-invalid' as const;
-  readonly expected = 'clusterGrid.{x,y,z} each integer in [1, 64]';
-  readonly hint: string;
-  readonly detail: { readonly x: number; readonly y: number; readonly z: number };
-
-  constructor(x: number, y: number, z: number) {
-    const hint = `clusterGrid {x:${x}, y:${y}, z:${z}} is invalid; set {x,y,z} to positive integers in [1, 64]`;
-    super(`hdrp-grid-invalid: ${hint}`);
-    this.name = 'HdrpInstallError';
-    this.hint = hint;
-    this.detail = { x, y, z };
-  }
-}
-
 export function validateClusterGrid(grid: {
   x: number;
   y: number;
   z: number;
-}): Result<{ x: number; y: number; z: number }, HdrpInstallError> {
+}): Result<{ x: number; y: number; z: number }, StandardProfileInvalidError> {
   const { x, y, z } = grid;
   return Number.isInteger(x) &&
     Number.isInteger(y) &&
@@ -156,7 +137,12 @@ export function validateClusterGrid(grid: {
     z >= 1 &&
     z <= 64
     ? ok({ x, y, z })
-    : err(new HdrpInstallError(x, y, z));
+    : err(
+        new StandardProfileInvalidError(
+          `clusterGrid {x:${x}, y:${y}, z:${z}} is invalid; set x, y, and z to positive integers in [1, 64]`,
+          { field: 'clusterGrid', actual: { x, y, z } },
+        ),
+      );
 }
 
 function target(
@@ -167,114 +153,20 @@ function target(
   return createRenderPipelineTarget(graph, label, descriptor);
 }
 
-interface HdrpGraphBuffers {
-  readonly lightData: GraphBuffer;
-  readonly clusterGrid: GraphBuffer;
-  readonly lightIndexList: GraphBuffer;
-  readonly clusterUniform: GraphBuffer;
-  readonly lightBounds: GraphBuffer;
-}
-
-function importBuffers(
-  graph: RenderGraphBuilder<RenderPipelineFrame>,
-  topology: RenderPipelineTopology,
-): Result<HdrpGraphBuffers, RenderGraphError> {
-  const grid = topology.config?.clusterGrid ?? DEFAULT_CLUSTER_GRID;
-  const cells = grid.x * grid.y * grid.z;
-  const storage = topology.lane.storageBuffer;
-  const usage =
-    (storage ? GPU_BUFFER_USAGE_STORAGE : GPU_BUFFER_USAGE_UNIFORM) | GPU_BUFFER_USAGE_COPY_DST;
-  const resolve = (frame: RenderPipelineFrame): HdrpBuffers => {
-    const internal = frame as _InternalRenderPipelineContext;
-    const buffers = getOrCreateHdrpBuffers(internal.runtime, grid);
-    if (buffers === null) throw new Error('HDRP persistent buffer allocation failed');
-    return buffers;
-  };
-  const lightData = graph.importBuffer(
-    'hdrp-light-data',
-    { size: (storage ? MAX_LIGHTS : 128) * 64, usage },
-    (frame) => resolve(frame).lightDataBuffer,
-  );
-  if (!lightData.ok) return lightData;
-  const clusterGrid = graph.importBuffer(
-    'hdrp-cluster-grid',
-    { size: storage ? cells * CLUSTER_GRID_STRIDE_U32 * 4 : 32, usage },
-    (frame) => resolve(frame).clusterGridBuffer,
-  );
-  if (!clusterGrid.ok) return clusterGrid;
-  const lightIndexList = graph.importBuffer(
-    'hdrp-light-index-list',
-    { size: storage ? LIGHT_INDEX_LIST_CAPACITY * 4 : 32, usage },
-    (frame) => resolve(frame).lightIndexListBuffer,
-  );
-  if (!lightIndexList.ok) return lightIndexList;
-  const clusterUniform = graph.importBuffer(
-    'hdrp-cluster-uniform',
-    { size: 32, usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST },
-    (frame) => resolve(frame).clusterUniformBuffer,
-  );
-  if (!clusterUniform.ok) return clusterUniform;
-  const lightBounds = graph.importBuffer(
-    'hdrp-light-bounds',
-    { size: MAX_LIGHTS * 6 * 4, usage },
-    (frame) => resolve(frame).lightBoundsBuffer,
-  );
-  if (!lightBounds.ok) return lightBounds;
-  return ok({
-    lightData: lightData.value,
-    clusterGrid: clusterGrid.value,
-    lightIndexList: lightIndexList.value,
-    clusterUniform: clusterUniform.value,
-    lightBounds: lightBounds.value,
-  });
-}
-
-function addMembershipPass(
-  graph: RenderGraphBuilder<RenderPipelineFrame>,
-  topology: RenderPipelineTopology,
-  buffers: HdrpGraphBuffers,
-): Result<void, RenderGraphError> {
-  if (!topology.lane.compute || !topology.lane.storageBuffer) return ok(undefined);
-  return graph.addComputePass('cluster-membership-producer', {
-    accesses: [
-      { resource: buffers.clusterGrid, usage: 'storage-read' },
-      { resource: buffers.clusterUniform, usage: 'uniform-read' },
-      { resource: buffers.lightBounds, usage: 'storage-read' },
-      { resource: buffers.lightIndexList, usage: 'storage-write' },
-    ],
-    executeIf: (frame) => {
-      const internal = frame as _InternalRenderPipelineContext;
-      return (
-        internal.pipelineState.hdrpClusterMembershipPipeline !== null &&
-        internal.hdrpClusterMembershipBindGroup !== null
-      );
-    },
-    encode: ({ pass, frame }) => {
-      const internal = frame as _InternalRenderPipelineContext;
-      const pipeline = internal.pipelineState.hdrpClusterMembershipPipeline;
-      const bindings = internal.hdrpClusterMembershipBindGroup;
-      if (pipeline === null || bindings === null) return;
-      const grid = topology.config?.clusterGrid ?? DEFAULT_CLUSTER_GRID;
-      pass.setPipeline(pipeline);
-      pass.setBindGroup(0, bindings);
-      pass.dispatchWorkgroups(Math.ceil((grid.x * grid.y * grid.z) / 64));
-    },
-  });
-}
-
-function buildHdrp(
+function buildStandardDeferredLane(
   context: RenderPipelineBuildContext<RenderPipelineFrame>,
   topology: RenderPipelineTopology,
+  lighting: StandardTopologyInputValue,
 ): ReturnType<RenderPipeline['build']> {
-  if (topology.lane.maxColorAttachments < 4) {
-    return err(new HdrpDeferredCapsInsufficientError(topology.lane.maxColorAttachments));
-  }
   const graph = context.graph;
   const surface = importRenderPipelineSurface(graph, topology);
   if (!surface.ok) return surface;
-  const buffers = importBuffers(graph, topology);
+  const buffers = importStandardClusterBuffers(graph, lighting);
   if (!buffers.ok) return buffers;
-  const membership = addMembershipPass(graph, topology, buffers.value);
+  const membership =
+    buffers.value === null
+      ? ok(undefined)
+      : addStandardClusterMembershipPass(graph, lighting, buffers.value);
   if (!membership.ok) return membership;
   const shadows = addTypedShadowPasses(graph, topology);
   if (!shadows.ok) return shadows;
@@ -305,9 +197,7 @@ function buildHdrp(
     taa: topology.camera.antialias === 'taa',
     motionBlur: topology.temporal?.motionBlur === true,
   });
-  const temporalLane = topology.lane.compute
-    ? (topology.standardProfile?.lighting ?? 'direct')
-    : 'cpu-webgl2';
+  const temporalLane = topology.lane.compute ? 'clustered' : 'cpu-webgl2';
   const temporalAdmission = standardTemporalLaneAdmission({
     lane: temporalLane,
     demand: temporalDemand,
@@ -330,7 +220,11 @@ function buildHdrp(
       }),
     );
   }
-
+  const gpuDriven = context.projectGpuDriven({
+    format: scene.value.format,
+    sampleCount: scene.value.sampleCount,
+  });
+  if (!gpuDriven.ok) return gpuDriven;
   const gbuffer = addTypedScenePass(graph, {
     name: 'g-buffer',
     color: gbuffer0.value,
@@ -363,25 +257,13 @@ function buildHdrp(
     { resource: gbuffer1.value.view, usage: 'sampled-read' },
     { resource: gbuffer2.value.view, usage: 'sampled-read' },
     { resource: depth.value.view, usage: 'depth-stencil-read' },
-    {
-      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' },
+    ...(buffers.value === null ? [] : standardClusterReadAccesses(buffers.value)),
     ...(ssao === undefined
       ? []
       : ([{ resource: ssao.view, usage: 'sampled-read' }] satisfies GraphAccess[])),
     { resource: scene.value.view, usage: 'color-attachment' },
   ];
-  const lighting = graph.addRasterPass('lighting', {
+  const lightingPass = graph.addRasterPass('lighting', {
     accesses: lightingAccesses,
     colorAttachments: [
       {
@@ -393,7 +275,7 @@ function buildHdrp(
     ],
     encode: () => undefined,
   });
-  if (!lighting.ok) return lighting;
+  if (!lightingPass.ok) return lightingPass;
 
   const skybox = addTypedSkyboxPass(graph, scene.value);
   if (!skybox.ok) return skybox;
@@ -403,21 +285,8 @@ function buildHdrp(
     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 forwardExtraAccesses: GraphAccess[] =
+    buffers.value === null ? [] : [...standardClusterReadAccesses(buffers.value)];
 
   const forward = addTypedScenePass(graph, {
     name: 'forward',
@@ -430,16 +299,20 @@ function buildHdrp(
       gbuffer0.value,
       gbuffer1.value,
       gbuffer2.value,
-      shadows.value.directional,
+      ...(shadows.value.directional === undefined ? [] : [shadows.value.directional]),
       shadows.value.spot,
       ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
       ...(ssao === undefined ? [] : [ssao]),
     ],
-    directionalShadow: shadows.value.directional,
+    ...(shadows.value.directional === undefined
+      ? {}
+      : { directionalShadow: shadows.value.directional }),
     spotShadow: shadows.value.spot,
     ...(ssao === undefined ? {} : { ssao }),
+    ...(gpuDriven.value === undefined ? {} : { gpuDriven: gpuDriven.value }),
     passKind: 'forward',
     ...(transmissionActive ? { recordMode: 'opaque' as const } : {}),
+    ...(context.occlusion === undefined ? {} : { occlusion: context.occlusion }),
     extraAccesses: forwardExtraAccesses,
   });
   if (!forward.ok) return forward;
@@ -472,7 +345,7 @@ function buildHdrp(
         gbuffer0.value,
         gbuffer1.value,
         gbuffer2.value,
-        shadows.value.directional,
+        ...(shadows.value.directional === undefined ? [] : [shadows.value.directional]),
         shadows.value.spot,
         ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
         ...(ssao === undefined ? [] : [ssao]),
@@ -501,7 +374,7 @@ function buildHdrp(
         gbuffer0.value,
         gbuffer1.value,
         gbuffer2.value,
-        shadows.value.directional,
+        ...(shadows.value.directional === undefined ? [] : [shadows.value.directional]),
         shadows.value.spot,
         ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
         ...(ssao === undefined ? [] : [ssao]),
@@ -529,8 +402,9 @@ function buildHdrp(
       topology,
       scene.value,
       depthSample.value,
-      shadows.value.directional.view,
+      shadows.value.directional?.view,
       shadows.value.spot.view,
+      buffers.value,
     );
     if (!volume.ok) return volume;
   }
@@ -556,8 +430,7 @@ function buildHdrp(
   if (!features.ok) return features;
   const observation = addTypedFrameObservationPass(graph, scene.value, 'forgeax::standard');
   if (!observation.ok) return observation;
-
-  return addStandardPost(
+  const post = addStandardPost(
     context,
     topology,
     scene.value,
@@ -565,13 +438,19 @@ function buildHdrp(
     surface.value,
     temporal.value?.temporal,
   );
+  if (!post.ok) return post;
+  const cubeCaptures = context.contributeCubeCaptures?.();
+  if (cubeCaptures !== undefined && !cubeCaptures.ok) return cubeCaptures;
+  return ok(undefined);
 }
-const buildStandardClusteredLane = buildHdrp;
-
 export interface StandardPipeline extends RenderPipeline {
   readonly identity: typeof STANDARD_PIPELINE_ID;
 }
 
+export function standardProfileSupportsReflectionProbes(_profile: StandardProfile): boolean {
+  return true;
+}
+
 /** Standard graph inputs are derived once from the immutable frame plan. */
 export type StandardFramePlan = FramePlan;
 
@@ -579,6 +458,43 @@ function profileFor(topology: RenderPipelineTopology): StandardProfile {
   return topology.standardProfile ?? DEFAULT_STANDARD_PROFILE;
 }
 
+function resolveStandardTopologyInput(
+  context: RenderPipelineBuildContext<RenderPipelineFrame>,
+): Result<StandardTopologyInputValue, RenderGraphError> {
+  const supplied = context.standardLighting;
+  if (supplied !== undefined) {
+    const derived = deriveStandardTopologyInput(supplied);
+    if (derived.ok) return derived;
+    return err(
+      new RenderGraphError({
+        code: 'resource-descriptor-invalid',
+        expected: 'Forward/Deferred consume one prepared Standard topology input',
+        hint: derived.error.hint,
+        detail: {
+          resourceLabel: 'forgeax::standard',
+          field: `standardLighting.${derived.error.detail.field}`,
+          expected: derived.error.expected,
+          actual: 'invalid',
+        },
+      }),
+    );
+  }
+
+  return err(
+    new RenderGraphError({
+      code: 'resource-descriptor-invalid',
+      expected: 'RenderPipelineBuildContext.standardLighting from frame preparation',
+      hint: 'prepare Standard lighting once, select a proven Cluster transport, and pass it to both lanes',
+      detail: {
+        resourceLabel: 'forgeax::standard',
+        field: 'standardLighting',
+        expected: 'prepared Standard lighting topology input',
+        actual: 'invalid',
+      },
+    }),
+  );
+}
+
 function standardTopology(
   topology: RenderPipelineTopology,
   profile: StandardProfile,
@@ -596,26 +512,41 @@ function standardTopology(
 }
 
 /**
- * The sole built-in pipeline entry point. Direct and clustered lighting are
- * execution lanes selected from the same profile and graph owner; callers do
- * not install a second topology or submit authority.
+ * The sole built-in pipeline entry point. All local lights use the same
+ * prepared Cluster topology; the profile chooses only Forward or Deferred
+ * graph shape and never a second lighting authority.
  */
 function buildStandard(
   context: RenderPipelineBuildContext<RenderPipelineFrame>,
   topology: RenderPipelineTopology,
 ): ReturnType<RenderPipeline['build']> {
   const profile = profileFor(topology);
-  const lane = resolveStandardLane(profile, {
-    compute: topology.lane.compute,
-    storageBuffer: topology.lane.storageBuffer,
-  });
+  if (!STANDARD_LIGHT_COUNTS.some((count) => count === profile.lightCount)) {
+    return err(
+      new RenderGraphError({
+        code: 'resource-descriptor-invalid',
+        expected: 'StandardProfile.lightCount is one of 1, 32, or 256',
+        hint: 'set StandardProfile.lightCount to 1, 32, or 256',
+        detail: {
+          resourceLabel: 'forgeax::standard',
+          field: 'lightCount',
+          expected: '1 | 32 | 256',
+          actual: profile.lightCount,
+        },
+      }),
+    );
+  }
   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);
+  const lighting = resolveStandardTopologyInput(context);
+  if (!lighting.ok) return lighting;
+  // A missing Camera is an intentional clear-only frame. Keep it on the
+  // forward raster lane so clustered resources cannot introduce work.
+  if (effective.clearOnly === true) {
+    return buildStandardForwardLane(context, effective, lighting.value);
+  }
+  return profile.renderPath === 'forward'
+    ? buildStandardForwardLane(context, effective, lighting.value)
+    : buildStandardDeferredLane(context, effective, lighting.value);
 }
 
 export const standardPipeline: StandardPipeline = Object.freeze({