@forgeax/engine-render 0.1.27 → 0.1.29

package/src/pipeline/standard-post.ts

@@ -1,4 +1,8 @@
-import type { CompiledRenderGraphInfo, GraphTextureDescriptor } from '@forgeax/engine-render-graph';
+import type {
+  CompiledRenderGraphInfo,
+  GraphTextureDescriptor,
+  GraphTextureView,
+} from '@forgeax/engine-render-graph';
 import { RenderGraphError } from '@forgeax/engine-render-graph';
 import { err, ok, type Result } from '@forgeax/engine-types';
 import { addTypedDebugOverlayPass } from '../debug-draw-glue';
@@ -25,6 +29,12 @@ import {
   TYPED_BLOOM_PASS_NAMES,
   type TypedTemporalResolveTargets,
 } from '../typed-render-graph-primitives';
+import {
+  addAutoExposureExposurePass,
+  addAutoExposureGraphPasses,
+} from './standard-output/auto-exposure/gpu';
+import { createStandardOutputPlan } from './standard-output/graph';
+import { addStandardColorLutPass } from './standard-output/lut-gpu';
 
 interface StandardPostSurface {
   readonly display?: RenderPipelineTarget;
@@ -159,20 +169,31 @@ export function addStandardPost(
   depth: RenderPipelineTarget,
   surface: StandardPostSurface,
   sceneTemporal?: RenderPipelineTarget,
+  secondaryReactivity?: GraphTextureView,
 ): Result<void, RenderPipelineBuildError> {
   const clearOnly = topology.clearOnly === true;
+  const outputPlan = createStandardOutputPlan({
+    lane: topology.standardProfile?.renderPath === 'deferred' ? 'clustered' : 'direct',
+    temporal: !clearOnly && topology.camera.antialias === 'taa',
+    meter: topology.output?.autoExposure === true,
+    bloom: !clearOnly && topology.camera.bloom === 'on' && topology.camera.tonemap !== 'none',
+    exposure: topology.output?.autoExposure === true,
+    whiteBalance: topology.output?.whiteBalance === true,
+    lut: topology.output?.colorLut === true,
+    fxaa: !clearOnly && topology.camera.antialias === 'fxaa',
+    outputEncoding: 'explicit-oetf',
+  });
   const hdr =
     !clearOnly && (topology.camera.tonemap !== 'none' || topology.camera.antialias === 'taa');
   // Bloom is an HDR-domain effect and its recorders intentionally no-op when
   // tone mapping is disabled. Keep the graph in the same no-op state for the
   // TAA + tonemap:none combination; otherwise the declared Bloom composite is
   // left clear and the following Output Transform presents a black frame.
-  const bloomActive = hdr && topology.camera.bloom === 'on' && topology.camera.tonemap !== 'none';
-  const fxaa = !clearOnly && topology.camera.antialias === 'fxaa';
-  // All non-clear Standard frames use the graph-owned float scene target and
-  // the shared Output Transform, even when AA is disabled or the backend has
-  // no storage buffers.  This keeps the final dither at one owner-level
-  // surface boundary instead of making no-AA/WebGL2 a silent bypass.
+  const bloomActive = hdr && outputPlan.features.bloom;
+  const fxaa = outputPlan.features.fxaa;
+  // Keep the graph-owned output transform on every non-HDR frame, including
+  // structural lanes without storage buffers; the final writer remains the
+  // single display-encoding owner.
   const linearLdr = !clearOnly && !hdr;
   const rawOnly = !clearOnly && topology.surface.profile?.kind === 'raw-only';
   const outputDither = resolveOutputDither(topology.config);
@@ -194,7 +215,19 @@ export function addStandardPost(
   // single Output Transform performs the first 8-bit quantization.
   const finalPresent = surface.storage;
   let postInput = scene;
+  let postTemporal = sceneTemporal;
 
+  const autoExposure = context.standardOutput?.autoExposure;
+  if (outputPlan.features.exposure && autoExposure === undefined) {
+    return err(
+      new RenderGraphError({
+        code: 'resource-resolution-failed',
+        expected: 'a prepared same-frame auto-exposure producer projection',
+        hint: 'prepare device-scoped auto-exposure resources before compiling Standard output',
+        detail: { resourceLabel: 'standard-auto-exposure' },
+      }),
+    );
+  }
   if (topology.camera.antialias === 'taa') {
     if (sceneTemporal === undefined) {
       return err(missingTemporalContributor(topology, 'forgeax::standard::scene-data'));
@@ -207,14 +240,20 @@ export function addStandardPost(
       scene,
       depth,
       currentTemporal: sceneTemporal,
+      ...(secondaryReactivity === undefined ? {} : { secondaryReactivity }),
       historyColor: history.previousColor,
       historyTemporal: history.previousTemporal,
+      historyStability: history.previousStability,
       writeColor: history.currentColor,
       writeTemporal: history.currentTemporal,
+      writeStability: history.currentStability,
     };
     const resolve = addTypedTemporalResolvePass(context.graph, resolveTargets);
     if (!resolve.ok) return resolve;
     postInput = history.currentColor;
+    // TAA resolves both outputs to the unjittered lattice. Later effects must
+    // consume its matching temporal attachment, not raw jittered coverage.
+    postTemporal = history.currentTemporal;
   }
 
   // Feature projection and the built-in fallback share one target contract.
@@ -238,7 +277,7 @@ export function addStandardPost(
       },
     ];
     if (motionBlur) {
-      if (sceneTemporal === undefined) {
+      if (postTemporal === undefined) {
         return err(
           new Error('Motion Blur requires the Standard scene-data producer') as RenderGraphError,
         );
@@ -249,7 +288,7 @@ export function addStandardPost(
         domain: hdr ? 'linear-hdr' : 'linear-ldr',
       });
       if (!blurred.ok) return blurred;
-      const features = context.contributeFeatures(featureTargets, [sceneTemporal], {
+      const features = context.contributeFeatures(featureTargets, [postTemporal], {
         'motion-input': postInput,
         'motion-output': blurred.value,
       });
@@ -257,7 +296,7 @@ export function addStandardPost(
       if (context.hasFeature?.('forgeax.motion-blur') === true) {
         postInput = blurred.value;
       } else {
-        const fallback = addMotionBlurPass(context.graph, postInput, sceneTemporal, blurred.value);
+        const fallback = addMotionBlurPass(context.graph, postInput, postTemporal, blurred.value);
         if (!fallback.ok) return fallback;
         postInput = blurred.value;
       }
@@ -270,6 +309,18 @@ export function addStandardPost(
     }
   }
 
+  // Meter the temporally resolved color before Bloom. This preserves the
+  // Standard order: temporal -> meter -> bloom -> exposure/WB -> tone -> LUT.
+  if (outputPlan.features.exposure && autoExposure !== undefined) {
+    const added = addAutoExposureGraphPasses(context, {
+      source: postInput,
+      resources: autoExposure,
+      width: topology.surface.width,
+      height: topology.surface.height,
+    });
+    if (!added.ok) return added;
+  }
+
   if (bloomActive) {
     const composited = target(
       context,
@@ -306,6 +357,86 @@ export function addStandardPost(
     postInput = composited.value;
   }
 
+  if (outputPlan.features.exposure || outputPlan.features.whiteBalance) {
+    const exposureOutput = target(context, 'standard-exposure-white-balance', {
+      format: 'rgba16float',
+      size: 'surface',
+      domain: 'linear-hdr',
+    });
+    if (!exposureOutput.ok) return exposureOutput;
+    const exposurePass = addAutoExposureExposurePass(
+      context,
+      postInput,
+      exposureOutput.value,
+      outputPlan.features.exposure ? autoExposure : undefined,
+      {
+        temperature: topology.output?.temperature ?? 6504,
+        tint: topology.output?.tint ?? 0,
+      },
+    );
+    if (!exposurePass.ok) return exposurePass;
+    postInput = exposureOutput.value;
+  }
+
+  // Auto exposure changes the HDR source before tone mapping, so it needs the
+  // same explicit linear-LDR boundary as the LUT route even when no LUT is
+  // bound. Keep the manual/LUT0 route combined so disabling auto exposure
+  // remains exact-zero.
+  const splitOutput =
+    outputPlan.features.lut ||
+    outputPlan.features.exposure ||
+    outputPlan.features.whiteBalance ||
+    // A receipt-bound observation request is an explicit producer demand, not
+    // a new authored color feature.  When a caller asks for the linear-LDR
+    // domain on the ordinary ACES path, retain the same tone/output boundary
+    // that the LUT and auto-exposure routes already use so the graph can
+    // capture it without changing unobserved frames.
+    context.observationCaptureDomains?.includes('linear-ldr') === true;
+
+  // Tone mapping and output encoding are separate entry points when a LUT is
+  // enabled or auto exposure is active: the LUT must sample linear LDR, and
+  // the single OETF writer runs only after LUT and optional FXAA.
+  const toneOutput = splitOutput
+    ? target(context, 'standard-tone-output', {
+        format: 'rgba16float',
+        size: 'surface',
+        domain: 'linear-ldr',
+      })
+    : undefined;
+  if (toneOutput !== undefined) {
+    if (!toneOutput.ok) return toneOutput;
+    const transformed = addTypedOutputTransformPass(context.graph, postInput, toneOutput.value, {
+      dither: false,
+      name: 'standard-tone',
+      fragmentEntryPoint: 'fs_tone_only',
+    });
+    if (!transformed.ok) return transformed;
+    postInput = toneOutput.value;
+  }
+
+  if (outputPlan.features.lut) {
+    const colorLut = context.standardOutput?.colorLut;
+    if (colorLut === undefined) {
+      return err(
+        new RenderGraphError({
+          code: 'resource-resolution-failed',
+          expected: 'a prepared resident Standard color LUT projection',
+          hint: 'resolve and admit the TextureAsset LUT before compiling Standard output',
+          detail: { resourceLabel: 'standard-color-lut' },
+        }),
+      );
+    }
+    const lutOutput = target(context, 'standard-color-lut', {
+      format: 'rgba16float',
+      size: 'surface',
+      domain: 'linear-ldr',
+    });
+    if (!lutOutput.ok) return lutOutput;
+    const lutPass = addStandardColorLutPass(context.graph, postInput, lutOutput.value, colorLut);
+    if (!lutPass.ok) return lutPass;
+    postInput = lutOutput.value;
+  }
+
   if (rawOnly) {
     const overlay = addTypedDebugOverlayPass(context.graph, postInput);
     if (!overlay.ok) return overlay;
@@ -313,27 +444,44 @@ export function addStandardPost(
 
   if (hdr || linearLdr || fxaa || rawOnly || motionBlur) {
     if (fxaa) {
-      const output = target(context, 'standard-output-color', {
-        format: 'rgba16float',
-        size: 'surface',
-        usage: GPU_TEXTURE_USAGE_COPY_SRC,
-        domain: 'display-encoded',
-      });
+      const output = splitOutput
+        ? target(context, 'standard-fxaa-output', {
+            format: 'rgba16float',
+            size: 'surface',
+            domain: 'linear-ldr',
+          })
+        : target(context, 'standard-output-color', {
+            format: 'rgba16float',
+            size: 'surface',
+            usage: GPU_TEXTURE_USAGE_COPY_SRC,
+            domain: 'display-encoded',
+          });
       if (!output.ok) return output;
-      // FXAA samples this display-encoded intermediate; leave dither to the
-      // final FXAA writer so the same pixel is not dithered twice.
-      const outputTransform = addTypedOutputTransformPass(context.graph, postInput, output.value, {
-        dither: false,
-      });
-      if (!outputTransform.ok) return outputTransform;
+      if (!splitOutput) {
+        // FXAA samples this display-encoded intermediate; leave dither to the
+        // final FXAA writer so the same pixel is not dithered twice.
+        const outputTransform = addTypedOutputTransformPass(
+          context.graph,
+          postInput,
+          output.value,
+          { dither: false },
+        );
+        if (!outputTransform.ok) return outputTransform;
+      }
       const aa = addTypedFullscreenPass(context.graph, {
         name: 'fxaa',
         shader: 'fxaa',
-        input: output.value,
-        output: rawOnlyPostInput !== undefined ? rawOnlyPostInput.value : finalPresent,
+        input: splitOutput ? postInput : output.value,
+        output: splitOutput ? output.value : (rawOnlyPostInput?.value ?? finalPresent),
+        ...(splitOutput
+          ? {
+              paramsTransform: (): Uint8Array => new Uint8Array(16),
+            }
+          : {}),
       });
       if (!aa.ok) return aa;
-    } else if (rawOnlyPostInput !== undefined) {
+      if (splitOutput) postInput = output.value;
+    } else if (rawOnlyPostInput !== undefined && !splitOutput) {
       const transformed = addTypedOutputTransformPass(
         context.graph,
         postInput,
@@ -343,12 +491,12 @@ export function addStandardPost(
         },
       );
       if (!transformed.ok) return transformed;
-    } else if (rawOnly || linearLdr) {
+    } else if ((rawOnly || linearLdr) && !splitOutput) {
       const transformed = addTypedOutputTransformPass(context.graph, postInput, finalPresent, {
         dither: outputDither,
       });
       if (!transformed.ok) return transformed;
-    } else {
+    } else if (!splitOutput) {
       const outputTransform = addTypedOutputTransformPass(context.graph, postInput, finalPresent, {
         dither: outputDither,
       });
@@ -356,6 +504,17 @@ export function addStandardPost(
     }
   }
 
+  if (splitOutput) {
+    const encodedOutput = rawOnlyPostInput?.value ?? finalPresent;
+    const outputTransform = addTypedOutputTransformPass(context.graph, postInput, encodedOutput, {
+      dither: outputDither,
+      name: 'standard-output-encoding',
+      fragmentEntryPoint: 'fs_encode_only',
+    });
+    if (!outputTransform.ok) return outputTransform;
+    postInput = encodedOutput;
+  }
+
   if (topology.lane.storageBuffer && postEffects.length > 0) {
     const postInputTarget = rawOnly
       ? rawOnlyPostInput?.value

package/src/pipeline-builder.ts

@@ -124,6 +124,7 @@ export interface PipelineBuilderContext {
   readonly colorFormat: GPUTextureFormat;
   /** Additional color targets for an MRT pass; the first target is colorFormat. */
   readonly colorFormats?: readonly GPUTextureFormat[] | undefined;
+  readonly fragmentConstants?: Readonly<Record<string, number>> | undefined;
   /** Depth attachment format, or `undefined` for a color-only pass. */
   readonly depthFormat: GPUTextureFormat | undefined;
   /**
@@ -134,7 +135,7 @@ export interface PipelineBuilderContext {
    */
   readonly vertexBuffers: readonly GPUVertexBufferLayout[];
   /** Explicit layout family selected by the renderer assembly. */
-  readonly layoutKind?: 'pbr-skin' | undefined;
+  readonly layoutKind?: 'pbr-skin' | 'gpu-driven-skin' | undefined;
   /** Pipeline label (for GPU debug captures); defaults to `pbr-pipeline-${id}`. */
   readonly label?: string | undefined;
   /**
@@ -367,6 +368,7 @@ export function buildPipelineForMaterialShader(
         ? {
             module: shaderModule,
             entryPoint: fsEntry,
+            ...(ctx.fragmentConstants === undefined ? {} : { constants: ctx.fragmentConstants }),
             targets: [],
           }
         : undefined,
@@ -376,11 +378,18 @@ export function buildPipelineForMaterialShader(
         frontFace: renderState?.frontFace ?? 'ccw',
       },
       depthStencil: {
-        // depth32float (matches shadow RT format), NOT ctx.depthFormat
-        // (which is depth24plus-stencil8 for the main pass).
-        format: 'depth32float',
-        depthWriteEnabled: true,
-        depthCompare: 'less',
+        // Shadow passes default to depth32float, while prepared depth-only
+        // feature passes may target the renderer's depth24plus-stencil8
+        // attachment. The pipeline context carries the resolved format so
+        // the PSO and render pass cannot drift.
+        format: ctx.depthFormat ?? 'depth32float',
+        // Shadow-caster remains the default policy for the legacy depth pass,
+        // while an explicit prepared depth-only feature is allowed to carry
+        // its own compare/write contract (for example an occlusion prepass
+        // using `always` + write-off). Do not infer policy from the absence of
+        // color targets alone.
+        depthWriteEnabled: renderState?.depthWriteEnabled ?? true,
+        depthCompare: renderState?.depthCompare ?? 'less',
       },
       multisample: sampleCount > 1 ? { count: sampleCount } : undefined,
     });
@@ -430,6 +439,7 @@ export function buildPipelineForMaterialShader(
     fragment: {
       module: shaderModule,
       entryPoint: fsEntry,
+      ...(ctx.fragmentConstants === undefined ? {} : { constants: ctx.fragmentConstants }),
       targets: forwardSpec.attachments.colorFormats.map((format) => ({
         format,
         ...(renderState?.blend === undefined ? {} : { blend: renderState.blend }),

package/src/pipeline-spec-types.ts

@@ -12,6 +12,8 @@ export interface PipelineSpec {
     readonly variantSet: string | undefined;
     readonly vertexEntry?: string;
     readonly fragmentEntry?: string;
+    /** Pipeline-time fragment overrides; not runtime WGSL feature defines. */
+    readonly fragmentConstants?: Readonly<Record<string, number>> | undefined;
   };
   readonly attachments: {
     readonly colorFormats: readonly GPUTextureFormat[];
@@ -24,6 +26,8 @@ export interface PipelineSpec {
     readonly vertexLayout: VertexAttributeMap;
     /** Geometry-owned immutable descriptor projection, when already derived. */
     readonly vertexLayoutProjection?: VertexLayoutProjection | undefined;
+    /** Explicit multi-stream layout supplied by the prepared-graphics owner. */
+    readonly vertexBuffers?: readonly GPUVertexBufferLayout[];
     readonly shaderUvSetCount?: number | undefined;
   };
   readonly renderState: MaterialRenderState | undefined;

package/src/pipeline-spec.ts

@@ -18,6 +18,7 @@
 //   P4: consistent abstraction — 4-axis aligns with wgpu/Bevy/Three.js
 
 import {
+  DEFAULT_VERTEX_ATTRIBUTE_MAP,
   deriveVertexBufferLayout,
   deriveVertexBufferLayoutFromProjection,
   deriveVertexLayoutProjection,
@@ -30,7 +31,6 @@ import {
   ok,
   type PrimitiveTopology,
   type Result,
-  type VertexAttributeMap,
 } from '@forgeax/engine-types';
 import { VertexColorVariantConflictError } from './errors/render';
 
@@ -226,6 +226,24 @@ export function cacheKeyOf(spec: PipelineSpec): string {
 
   const uvSetCountSegment =
     geometry.shaderUvSetCount !== undefined ? `:uvsc${geometry.shaderUvSetCount}` : '';
+  // Prepared graphics may publish an explicit multi-stream layout (particle
+  // material-input lanes are the canonical example). The attribute map alone
+  // cannot describe those streams or their lane stride, so include the
+  // normalized descriptors in the cache identity as well.
+  const vertexBuffersSegment =
+    geometry.vertexBuffers === undefined
+      ? ''
+      : `:vbs:${JSON.stringify(
+          geometry.vertexBuffers.map((buffer) => ({
+            arrayStride: buffer.arrayStride,
+            stepMode: buffer.stepMode ?? 'vertex',
+            attributes: [...buffer.attributes].map((attribute) => ({
+              shaderLocation: attribute.shaderLocation,
+              offset: attribute.offset,
+              format: attribute.format,
+            })),
+          })),
+        )}`;
 
   // bug-20260708 M2 (b): sentinel `~` distinguishes `variantSet=undefined`
   // (no-variant / default-variant request) from canonical all-true key `''`
@@ -249,7 +267,15 @@ export function cacheKeyOf(spec: PipelineSpec): string {
       `vl:${vlDigest}`,
       renderStateHash(renderState),
     ].join(':') +
+    vertexBuffersSegment +
     uvSetCountSegment +
+    (shader.fragmentConstants === undefined
+      ? ''
+      : `:fragment-constants:${JSON.stringify(
+          Object.entries(shader.fragmentConstants).sort(([left], [right]) =>
+            left.localeCompare(right),
+          ),
+        )}`) +
     (shader.vertexEntry === undefined && shader.fragmentEntry === undefined
       ? ''
       : `:entries:${JSON.stringify([shader.vertexEntry ?? null, shader.fragmentEntry ?? null])}`)
@@ -292,22 +318,13 @@ export function variantSetFromVertexLayoutProjection(
   return ok(parts.join('+'));
 }
 
-/**
- * Derive the capability axes shared by every Standard PBR draw owner.
- *
- * The all-true key is the canonical empty key used by the shader manifest;
- * every other capability pair stays explicit so a no-local-light frame on a
- * device without storage buffers cannot accidentally select a storage-backed
- * PSO. Vertex-color is supplied here because the empty-key rule is only valid
- * when that geometry-owned axis is also true.
- */
+/** Explicit geometry and lighting facts survive composition before manifest key canonicalization. */
 export function standardCapabilityVariantSet(
   clustered: boolean,
   storageBuffer: boolean,
   vertexColorAvailable: boolean,
 ): string {
-  if (clustered && storageBuffer && vertexColorAvailable) return '';
-  return `CLUSTER_FORWARD_AVAILABLE=${clustered}+STORAGE_BUFFER_AVAILABLE=${storageBuffer}`;
+  return `CLUSTER_FORWARD_AVAILABLE=${clustered}+STORAGE_BUFFER_AVAILABLE=${storageBuffer}+VERTEX_COLOR_AVAILABLE=${vertexColorAvailable}`;
 }
 
 /**
@@ -332,15 +349,7 @@ export function standardTopologyVariantSet(
     vertexColorAvailable,
   );
   if (!probeBlendAvailable || !storageBuffer) return capabilityVariantSet;
-  // The canonical empty key cannot carry the clustered=true fact through
-  // resolveMaterialShaderVariantSet (an omitted cluster axis means false).
-  // Expand that base before adding the object-level Probe ABI axis so shader,
-  // group(3) bind group, and pipeline layout remain one exact variant.
-  const explicitCapabilityVariantSet =
-    capabilityVariantSet === ''
-      ? 'CLUSTER_FORWARD_AVAILABLE=true+STORAGE_BUFFER_AVAILABLE=true'
-      : capabilityVariantSet;
-  return `${explicitCapabilityVariantSet}+PROBE_BLEND_AVAILABLE=true`;
+  return `${capabilityVariantSet}+PROBE_BLEND_AVAILABLE=true`;
 }
 
 /**
@@ -406,7 +415,8 @@ export function buildPipelineDescriptor(
   // A supplied projection is the geometry owner's immutable GPU descriptor.
   // Do not re-derive it from a possibly stale attribute map.
   const vertexBuffers =
-    geometry.vertexLayoutProjection === undefined
+    geometry.vertexBuffers ??
+    (geometry.vertexLayoutProjection === undefined
       ? deriveVertexBufferLayout(geometry.vertexLayout, {
           ...(geometry.shaderUvSetCount !== undefined
             ? { shaderUvSetCount: geometry.shaderUvSetCount }
@@ -416,7 +426,7 @@ export function buildPipelineDescriptor(
           ...(geometry.shaderUvSetCount !== undefined
             ? { shaderUvSetCount: geometry.shaderUvSetCount }
             : {}),
-        });
+        }));
 
   const descriptor: Record<string, unknown> = {
     vertex: {
@@ -431,6 +441,9 @@ export function buildPipelineDescriptor(
     descriptor.fragment = {
       module: modules.fragment,
       entryPoint: spec.shader.fragmentEntry ?? modules.fragmentEntryPoint ?? 'fs_main',
+      ...(spec.shader.fragmentConstants === undefined
+        ? {}
+        : { constants: spec.shader.fragmentConstants }),
       targets: attachments.colorFormats.map((fmt) => {
         const target: Record<string, unknown> = { format: fmt };
         if (renderState?.blend !== undefined) {
@@ -952,12 +965,7 @@ export function getOrBuildPipeline(
 // SPEC_CONST_TABLE — 12 boot-time pre-warm variants (M1-T5)
 // ══════════════════════════════════════════════════════════════════════════════
 
-const PROCEDURAL_ATTR_LAYOUT: VertexAttributeMap = {
-  position: new Float32Array(0),
-  normal: new Float32Array(0),
-  uv: new Float32Array(0),
-  tangent: new Float32Array(0),
-};
+const PROCEDURAL_ATTR_LAYOUT = DEFAULT_VERTEX_ATTRIBUTE_MAP;
 
 const HDR_FORMAT: GPUTextureFormat = 'rgba16float';
 const DEPTH_DS: GPUTextureFormat = 'depth24plus-stencil8';

package/src/points-lines/standard-owner.ts

@@ -1,5 +1,8 @@
 import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
-import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
+import {
+  DEFAULT_VERTEX_ATTRIBUTE_MAP,
+  deriveVertexLayoutProjection,
+} from '@forgeax/engine-geometry';
 import { err, ok } from '@forgeax/engine-rhi';
 import type { MaterialAsset, MeshAsset } from '@forgeax/engine-types';
 import { toShared } from '@forgeax/engine-types';
@@ -15,7 +18,7 @@ import type {
   PointsLinesRecordSubmission,
   RenderSystemInternals,
 } from '../record/render-context';
-import type { RecoveryPointsLinesCandidate } from '../render-system';
+import type { RecoveryPointsLinesCandidate } from '../recovery/types';
 import { admitPointsLines } from './admission';
 import { PointsLinesExpansionCache } from './expansion-cache';
 import type { PointsLinesInspection, PointsLinesSourceError } from './inspection';
@@ -50,12 +53,7 @@ export 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),
-  });
+  private readonly layoutProjection = deriveVertexLayoutProjection(DEFAULT_VERTEX_ATTRIBUTE_MAP);
 
   constructor(private readonly internals: RenderSystemInternals) {}
 
@@ -193,14 +191,8 @@ export class StandardPointsLinesOwner implements PointsLinesRecordOwner {
     const prepKey = `${geometryKey}:${lane}:${backend}`;
     let preparation = preparations.get(prepKey);
     if (preparation === undefined) {
-      // A new expansion is visible cold upload work. Candidate preparation
-      // uses an unarmed runtime and stages the result; the published runtime
-      // is armed, so a missing staged resource fails before any RHI create.
-      runtime.recoveryColdWorkGuard?.noteUploadColdWork();
       preparation = this.createPreparation(runtime, geometryKey, lane, backend);
       preparations.set(prepKey, preparation);
-    } else if (preparation.lastKnownGood()?.geometry.key !== geometryKey) {
-      runtime.recoveryColdWorkGuard?.noteUploadColdWork();
     }
     const prepared = preparation.prepare(snapshot, meshResult.value);
     if (!prepared.ok) {

package/src/prepare/prepared-graphics-resolver.ts

@@ -44,6 +44,8 @@ export type PreparedGraphicsResolvedResource =
       readonly kind: 'pipeline';
       readonly reference: RenderFeaturePreparedRef;
       readonly handle: RenderPipeline;
+      /** Renderer-selected context; never authored by a RenderFeature. */
+      readonly standardLighting?: boolean;
     }
   | {
       readonly kind: 'bindings';
@@ -70,7 +72,10 @@ export interface PreparedGraphicsResolverInput {
   readonly lookup: (reference: RenderFeaturePreparedRef) => PreparedGraphicsItem | undefined;
   readonly resolvePipeline: (
     descriptor: PreparedGraphicsNormalizedDescriptor & { readonly kind: 'pipeline' },
-  ) => Result<RenderPipeline, unknown>;
+  ) => Result<
+    RenderPipeline | { readonly handle: RenderPipeline; readonly standardLighting: boolean },
+    unknown
+  >;
   readonly resolveBindings: (
     descriptor: RenderFeatureBindingsDescriptor,
     pipeline: RenderPipeline,
@@ -304,7 +309,9 @@ export function createPreparedGraphicsResolver(
     const resource: PreparedGraphicsResolvedResource = {
       kind: 'pipeline',
       reference,
-      handle: created.value,
+      ...('handle' in created.value
+        ? { handle: created.value.handle, standardLighting: created.value.standardLighting }
+        : { handle: created.value }),
     };
     resolved.set(reference, resource);
     return ok(resource);