@forgeax/engine-render 0.1.7 → 0.1.19

package/src/record/frame-snapshot.ts

@@ -6,7 +6,16 @@ import { vec3 } from '@forgeax/engine-math';
 import type { ResolvedColorTargetDescriptor } from '@forgeax/engine-render-graph';
 import type { Texture } from '@forgeax/engine-rhi';
 import type { ClusterBinScratch } from '../cluster-binner';
+import type { EnvironmentGeneration } from '../environment/generation';
+import type { EnvironmentLifecycle } from '../environment/lifecycle';
 import type { GpuBuffer } from '../gpu-resource';
+import type { TemporalGpuState } from '../temporal/gpu';
+import type { TemporalView } from '../temporal/view';
+
+export type TemporalCommitOutcome =
+  | { readonly kind: 'none' }
+  | { readonly kind: 'off'; readonly view: TemporalView }
+  | { readonly kind: 'taa'; readonly view: TemporalView };
 
 /**
  * feat-20260708-composited-multi-world-rendering M1 / D-1 / D-9:
@@ -84,6 +93,88 @@ export interface FrameObservationSource {
   readonly backendId: string;
 }
 
+/** Internal test/diagnostic view of one compiled graph color target. */
+export interface CurrentGraphTarget {
+  readonly name: string;
+  readonly texture: Texture;
+  /** Stable opaque identity for this RHI handle during the renderer lifetime. */
+  readonly textureIdentity: number;
+  readonly descriptor: ResolvedColorTargetDescriptor;
+  readonly frameId: number;
+  /** Monotonic identity of the compiled graph that owns this texture. */
+  readonly graphGeneration: number;
+}
+
+const textureIdentities = new WeakMap<object, number>();
+let nextTextureIdentity = 1;
+
+/**
+ * Project an opaque RHI texture handle to a stable diagnostic identity.
+ * RHI handles intentionally expose no serializable fields; object identity is
+ * the only valid comparison boundary for a copy-time capture.
+ */
+export function getTextureIdentity(texture: Texture): number {
+  const object = texture as object;
+  const existing = textureIdentities.get(object);
+  if (existing !== undefined) return existing;
+  const identity = nextTextureIdentity++;
+  textureIdentities.set(object, identity);
+  return identity;
+}
+
+export type GraphTargetCaptureReadbackValidation =
+  | { readonly ok: true }
+  | {
+      readonly ok: false;
+      readonly code:
+        | 'capture-readback-length'
+        | 'capture-readback-untouched-sentinel'
+        | 'capture-readback-empty'
+        | 'capture-readback-non-finite';
+    };
+
+/** Validate a mapped rgba16float capture before a consumer decodes its values. */
+export function validateGraphTargetCaptureReadback(input: {
+  readonly bytes: Uint8Array;
+  readonly expectedByteLength: number;
+  readonly sentinel?: Uint8Array;
+}): GraphTargetCaptureReadbackValidation {
+  const { bytes, expectedByteLength, sentinel } = input;
+  if (bytes.byteLength !== expectedByteLength)
+    return { ok: false, code: 'capture-readback-length' };
+  if (sentinel?.every((value, index) => bytes[index] === value)) {
+    return { ok: false, code: 'capture-readback-untouched-sentinel' };
+  }
+  if (bytes.every((value) => value === 0)) return { ok: false, code: 'capture-readback-empty' };
+  for (let index = 0; index + 1 < bytes.length; index += 2) {
+    const exponent = ((bytes[index + 1] ?? 0) >>> 2) & 0x1f;
+    if (exponent === 0x1f) return { ok: false, code: 'capture-readback-non-finite' };
+  }
+  return { ok: true };
+}
+
+/** Internal readback request consumed by the record encoder in the same submit. */
+export interface GraphTargetCaptureRequest {
+  readonly name: string;
+  readonly buffer: Buffer;
+  readonly bytesPerRow: number;
+  readonly width: number;
+  readonly height: number;
+  /** Descriptor contract checked against the resolved target at copy time. */
+  readonly expected: {
+    readonly format: ResolvedColorTargetDescriptor['format'];
+    readonly width: number;
+    readonly height: number;
+    readonly usage: number;
+    /** Optional caller binding; when present it is checked at copy time. */
+    readonly identity?: {
+      readonly graphGeneration: number;
+      readonly frameId: number;
+      readonly textureIdentity: number;
+    };
+  };
+}
+
 /**
  * Build a synthetic CameraSnapshot the record stage uses when the world
  * carries no Camera entity. Identity-shaped projection / view inputs
@@ -160,14 +251,24 @@ export function clampPcfKernelSize(value: number | undefined): number {
  */
 export interface RenderFrameState {
   frameNumber: number;
+  /** Monotonic compiled-graph identity used by diagnostic readbacks. */
+  graphGeneration: number;
+  /** Number of successfully submitted TAA frames; failed attempts do not advance it. */
+  successfulTemporalFrameIndex?: number;
   /** Optional graph resource lookup used by low-level record helpers and tests. */
-  readonly perFrameGraph?: {
+  perFrameGraph?: {
     readonly getColorTargetDescriptor: (key: string) => ResolvedColorTargetDescriptor | undefined;
     readonly getColorTargetView: (key: string) => TextureView | undefined;
     readonly getColorTargetTexture: (key: string) => Texture | undefined;
+    readonly graphGeneration: number;
   } | null;
+  graphTargetCapture?: GraphTargetCaptureRequest | undefined;
   /** Last successfully rendered static directional shadow atlas token. */
   directionalShadowCache: DirectionalShadowCache | null;
+  /** Last successfully submitted camera post-process mode. */
+  lastSuccessfulBloom: 'off' | 'on';
+  /** Bloom record receipts staged by this frame; cleared on abort. */
+  bloomFrameReceipts?: BloomFrameReceipts | undefined;
   /** Set by a directional shadow pass when this frame refreshed the atlas. */
   directionalShadowCacheRecorded: boolean;
   /** The sole compiled owner for compute, copy, feature, and raster work. */
@@ -176,6 +277,20 @@ export interface RenderFrameState {
   readonly retiredCompiledFrameGraphs: Set<CompiledRenderGraph<RenderPipelineFrame>>;
   /** Physical outputs projected by typed graph passes for downstream observers. */
   currentFrameObservationSource: FrameObservationSource | undefined;
+  /** Camera antialias mode for the last successfully submitted graph. */
+  lastSuccessfulCameraAntialias: CameraSnapshot['antialias'] | undefined;
+  /** Staged TAA GPU state is promoted only after queue.submit succeeds. */
+  temporalGpuState: TemporalGpuState | undefined;
+  /** Last successful TAA GPU state; candidate replacement stays staged until submit. */
+  activeTemporalGpuState: TemporalGpuState | undefined;
+  /** Submitted temporal generations retained until their queue fence resolves. */
+  readonly retiringTemporalGpuStates: Set<TemporalGpuState>;
+  /** Last successful projection; candidate frames never overwrite it. */
+  lastSuccessfulTemporalView: TemporalView | undefined;
+  pendingTemporalCommit: TemporalCommitOutcome;
+  /** Staged environment generation is promoted only after queue.submit succeeds. */
+  environmentGeneration: EnvironmentGeneration | undefined;
+  readonly environmentLifecycle: EnvironmentLifecycle | undefined;
   currentDirectionalShadowView: TextureView | null;
   currentSpotShadowView: TextureView | null;
   readonly instanceBuffers: Map<number, InstanceBufferCacheEntry>;
@@ -342,10 +457,9 @@ export interface RenderFrameState {
    */
   installedPipelineConfig: RenderPipelineAsset['config'];
   /**
-   * feat-20260608-cluster-lighting M2 / w10: HDRP active flag.
-   * True iff the currently installed RenderPipelineAsset has
-   * `pipelineId === 'forgeax::hdrp'`. URP-only code paths gate on
-   * `!isHdrpActive` so HDRP demos do not double-count light contributions.
+   * Whether the configured standard graph resolved to the clustered lane.
+   * Capability gating keeps URP forward bindings on WebGL2 fallback even
+   * when a clustered profile was requested.
    */
   isHdrpActive: boolean;
   /**
@@ -432,6 +546,16 @@ export interface BindGroupCounts {
   keys: string[];
 }
 
+/**
+ * Successful Bloom record operations staged for the current frame. These
+ * counters are promoted only after the shared renderer queue submission.
+ */
+export interface BloomFrameReceipts {
+  readonly uploadCount: number;
+  readonly bindGroupCount: number;
+  readonly encodeCount: number;
+}
+
 /**
  * A renderable resolved against the AssetRegistry for the current frame:
  * its source snapshot, the GPU mesh handles, the row index used to correlate

package/src/record/frame-targets.ts

@@ -20,9 +20,12 @@ export function graphExecutionPhase(passName: string): RenderGraphExecutionPhase
     case 'lighting':
       return 'record/graph-execute/lighting';
     case 'forward':
+    case 'transmission-forward':
       return 'record/graph-execute/forward';
-    case 'tonemap':
-      return 'record/graph-execute/tonemap';
+    case 'output-transform':
+      return 'record/graph-execute/output-transform';
+    case 'present':
+      return 'record/graph-execute/present';
     case 'debug-overlay':
       return 'record/graph-execute/debug-overlay';
     case 'shadow':
@@ -55,17 +58,23 @@ export function acquireSwapChainTarget(
 
   let currentTextureResult = canvasContext.getCurrentTexture();
   if (!currentTextureResult.ok) {
-    pipelineState.perPassResources.configured = false;
     const configured = configureSurface(
       canvasContext,
       internals.device,
       pipelineState.format,
       pipelineState.colorAttachmentFormat,
     );
-    if (configured.ok) {
-      pipelineState.perPassResources.configured = true;
-      (globalThis as Record<string, unknown>).__forgeaxSwapChainFormat = pipelineState.format;
+    if (!configured.ok) {
+      internals.errorRegistry.fire(configured.error);
+      internals.healthRegistry.fire({
+        reason: 'internal-fault',
+        detail: { message: 'surface configure candidate failed; current frame skipped' },
+        recoverable: true,
+      });
+      return null;
     }
+    pipelineState.perPassResources.configured = true;
+    (globalThis as Record<string, unknown>).__forgeaxSwapChainFormat = pipelineState.format;
     const retry = canvasContext.getCurrentTexture();
     if (!retry.ok) {
       internals.errorRegistry.fire(retry.error);

package/src/record/frame.ts

@@ -4,6 +4,7 @@
 import { HANDLE_NINESLICE_QUAD, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import type { World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
+import { mat4 } from '@forgeax/engine-math';
 import {
   type CurrentFrameObservationLease,
   createCurrentFrameObservationLease,
@@ -21,6 +22,7 @@ import type { MaterialRenderState, MeshAsset } from '@forgeax/engine-types';
 import { handleSlot, toShared } from '@forgeax/engine-types';
 import type { MeshGpuHandles } from '../device/gpu-residency';
 import { ObservationUnavailableError, type ObservationUnavailableReason } from '../errors/render';
+import type { FogFrame } from '../extract/environment';
 import type { GpuDrivenProduction, PreparedGpuDrivenFrame } from '../gpu-driven/production-raster';
 import { GpuBuffer } from '../gpu-resource';
 import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_VERTEX } from '../gpu-usage';
@@ -40,6 +42,7 @@ import {
   TRANSPARENT_SORT_MODE_LAYER_Y,
   TRANSPARENT_SORT_MODE_LAYER_Z,
 } from '../systems/transparent-sort-config';
+import type { TransmissionDemand } from '../transmission/projection';
 import {
   buildPerFrameBindGroups,
   prepareFrameLighting,
@@ -184,6 +187,7 @@ export async function observeCurrentFrame(
   });
 }
 
+import { createTemporalView, resolveTemporalReset } from '../temporal/view';
 import {
   acquireSwapChainTarget,
   graphExecutionPhase,
@@ -191,6 +195,7 @@ import {
   resolveSpotShadowMapSize,
 } from './frame-targets';
 import {
+  computeProjectionMatrix,
   computeViewMatrix,
   driveLazyEquirectProjection,
   selectLazyEquirectHandle,
@@ -304,6 +309,7 @@ export function recordFrame(
   skybox: SkyboxSnapshot | undefined,
   skyboxCount: number,
   postProcessParams: ReadonlyMap<string, Uint8Array>,
+  fog: FogFrame | undefined,
   // feat-20260709-editor-world-partition ENGINE-fix-round2 (defect 2): the
   // full worlds[] list passed to `renderer.draw`, indexed by
   // RenderableSnapshot.worldId so the record stage resolves each renderable's
@@ -321,6 +327,10 @@ export function recordFrame(
   renderReadLeases?: readonly RenderReadLease[],
   featureGraphCandidate?: RenderFeatureGraphCandidate,
   pointsLinesOwner?: import('./render-context').PointsLinesRecordOwner,
+  environmentSignature = '',
+  fogSignature = '',
+  environmentReady = true,
+  transmissionDemand?: TransmissionDemand,
 ): boolean {
   // The `try / finally` wrapper advances `frameState.frameNumber` exactly
   // once per `recordFrame` invocation regardless of which early-return
@@ -521,6 +531,8 @@ export function recordFrame(
         graphShadowMapSize,
         preparedGpuDriven,
         featureGraphCandidate,
+        cameras.length === 0,
+        transmissionDemand,
       ),
     );
     if (preflightGraph === null) return false;
@@ -539,6 +551,79 @@ export function recordFrame(
     const targetW = swapTarget.targetW;
     const targetH = swapTarget.targetH;
 
+    const temporalView =
+      camera.antialias === 'taa' && environmentReady
+        ? (() => {
+            const created = createTemporalView({
+              antialias: camera.antialias,
+              width: targetW,
+              height: targetH,
+              frameIndex: frameState.successfulTemporalFrameIndex ?? 0,
+              viewIdentity: `camera:${camera.entityKey ?? 0}`,
+              environmentSignature,
+              fogSignature,
+              deviceGeneration: internals.deviceScope.generation,
+              ...(camera.historyVersion === undefined
+                ? {}
+                : { historyVersion: camera.historyVersion }),
+            });
+            const previous = frameState.lastSuccessfulTemporalView;
+            const currentUnjitteredViewProjection = mat4.multiply(
+              mat4.create(),
+              computeProjectionMatrix(camera),
+              computeViewMatrix(camera),
+            );
+            const resetCandidate = createTemporalView({
+              antialias: created.input.antialias,
+              width: created.input.width,
+              height: created.input.height,
+              frameIndex: created.input.frameIndex,
+              historyVersion: created.input.historyVersion,
+              viewIdentity: created.input.viewIdentity,
+              environmentSignature,
+              fogSignature,
+              deviceGeneration: internals.deviceScope.generation,
+              cameraCut: created.input.cameraCut,
+              historyValid: false,
+              currentUnjitteredViewProjection,
+            });
+            const resetReason = resolveTemporalReset(previous, resetCandidate);
+            return createTemporalView({
+              ...resetCandidate.input,
+              frameIndex: resetReason === undefined ? resetCandidate.input.frameIndex : 0,
+              historyValid: previous !== undefined && resetReason === undefined,
+              currentUnjitteredViewProjection,
+              resetReason,
+              ...(resetReason !== undefined ||
+              previous?.currentUnjitteredViewProjection === undefined
+                ? {}
+                : {
+                    previousUnjitteredViewProjection: previous.currentUnjitteredViewProjection,
+                  }),
+            });
+          })()
+        : undefined;
+    frameState.pendingTemporalCommit =
+      cameras.length === 0 || !environmentReady || internals.deviceScope === undefined
+        ? { kind: 'none' }
+        : temporalView === undefined
+          ? {
+              kind: 'off',
+              view: createTemporalView({
+                antialias: camera.antialias,
+                width: targetW,
+                height: targetH,
+                frameIndex: frameState.successfulTemporalFrameIndex ?? 0,
+                viewIdentity: `camera:${camera.entityKey ?? 0}`,
+                environmentSignature,
+                fogSignature,
+                deviceGeneration: internals.deviceScope.generation,
+              }),
+            }
+          : { kind: 'taa', view: temporalView };
+    const recordCamera: CameraSnapshot =
+      temporalView === undefined ? camera : { ...camera, temporal: temporalView };
+
     const depthView: TextureView | null = null;
     // feat-20260709 M3 / D-3: clear-color read from the active CameraSnapshot's
     // single `clearColor` array field (first-archetype-hit per OOS-2). When the
@@ -583,7 +668,7 @@ export function recordFrame(
     const { tonemapActive, skyboxActive } = resolveSkyboxActive(
       internals,
       frameState,
-      camera,
+      recordCamera,
       skybox,
     );
 
@@ -699,6 +784,8 @@ export function recordFrame(
           light,
           lights,
           frameState.spotShadowSnapshots,
+          fog,
+          temporalView,
         );
         if (pipelineState.pointsLinesViewBuffer !== undefined) {
           writePointsLinesViewUbo(
@@ -783,12 +870,29 @@ export function recordFrame(
     // errorRegistry + shader-cache lookups) surfaces (`internals` itself satisfies
     // `RenderSystemRuntime` so `runtime: internals` is a zero-cost reference). The
     // 0-consumed `skyboxCount` residual is dropped.
+    // Camera-owned temporal controls are projected into the per-frame
+    // post-process parameter map at record time. The extracted ECS map only
+    // carries explicit PostProcessParams components; without this bridge the
+    // builtin motion-blur pass receives its all-zero registration default and
+    // becomes a no-op even though the temporal scene target is populated.
+    const framePostProcessParams = new Map(postProcessParams);
+    if (camera.motionBlur !== undefined) {
+      const motionBlurParams = new Uint8Array(16);
+      const motionBlurView = new DataView(motionBlurParams.buffer);
+      motionBlurView.setFloat32(0, camera.motionBlur.shutterAngle, true);
+      motionBlurView.setFloat32(4, camera.motionBlur.maxRadiusPixels, true);
+      motionBlurView.setUint32(8, camera.motionBlur.sampleCount, true);
+      motionBlurView.setUint32(12, temporalView?.historyValid === true ? 0 : 1, true);
+      framePostProcessParams.set('forgeax.motion-blur', motionBlurParams);
+    }
+
     const passCtx: _InternalRenderPipelineContext = {
       assets: internals.assets,
       world,
       gpuDrivenEntityKeys: gpuOwnedEntityKeys,
       store: internals.gpuStore,
       pipelineState,
+      bloomResources: pipelineState.perPassResources.getBloomResources?.() ?? null,
       runtime: internals,
       encoder,
       view,
@@ -796,7 +900,7 @@ export function recordFrame(
       targetW,
       targetH,
       currentTexture,
-      camera,
+      camera: recordCamera,
       tonemapActive,
       geometryColorView,
       geometryDepthView,
@@ -817,7 +921,7 @@ export function recordFrame(
       msaaActive,
       geometryColorResolveView,
       ldrSpriteColorView,
-      postProcessParams,
+      postProcessParams: framePostProcessParams,
       dispatch: transparentDispatch,
       hdrpClusterBindGroup,
       hdrpClusterMembershipBindGroup,

package/src/record/main-pass-geometry.ts

@@ -57,7 +57,7 @@ type GeometryBindingState = {
 
 type MaterialPipelineLookup = {
   readonly materialShaderId: string;
-  readonly tonemapActive: boolean;
+  readonly isHdrTarget: boolean;
   readonly renderStateKey: string;
   readonly topology: PrimitiveTopology;
   readonly indexFormat: 'uint16' | 'uint32';
@@ -71,6 +71,27 @@ type MaterialPipelineLookup = {
 
 type GeometryRecordProfileSegment = 'material-bind-groups' | 'pipeline-selection' | 'draw-submit';
 
+type GeometryRenderState = ReturnType<typeof geometryRenderStateForTopology>;
+
+/**
+ * Resolve the depth contract for a geometry pass without changing the base
+ * material state. Temporal scene-data shares the main pass depth attachment:
+ * it is read-only and accepts the equal depth produced by the unjittered
+ * temporal projection, while still rejecting fragments behind the visible
+ * surface.
+ */
+export function geometryRenderStateForPass(
+  base: GeometryRenderState,
+  passKind: PassKind,
+): GeometryRenderState {
+  if (passKind !== 'temporal') return base;
+  return {
+    ...base,
+    depthWriteEnabled: false,
+    depthCompare: 'less-equal' as const,
+  };
+}
+
 function geometryRecordPhase(
   passKind: PassKind,
   segment: GeometryRecordProfileSegment,
@@ -178,6 +199,12 @@ export function recordGeometryDraws(
     viewBindGroup,
   } = c;
   const colorFormatOverride = c.transparentColorFormat as GPUTextureFormat | undefined;
+  // A no-tone frame may still render into the graph-owned rgba16float target
+  // (the linear-LDR route). Shader variants must follow the attachment's
+  // numeric domain rather than the camera's tone-map switch, otherwise the
+  // LDR/OETF fragment entry point is encoded once here and again by the
+  // output transform.
+  const isHdrTarget = tonemapActive || colorFormatOverride === 'rgba16float';
   let lastVertexBuffer: GpuBuffer | null = null;
   let lastIndexBuffer: GpuBuffer | null = null;
   const bindingState: GeometryBindingState = {
@@ -226,7 +253,7 @@ export function recordGeometryDraws(
     if (cachedLookups !== undefined) {
       for (const cached of cachedLookups) {
         if (
-          cached.tonemapActive === tonemapActive &&
+          cached.isHdrTarget === isHdrTarget &&
           cached.renderStateKey === renderStateKey &&
           cached.topology === topology &&
           cached.indexFormat === indexFormat &&
@@ -240,10 +267,11 @@ export function recordGeometryDraws(
         }
       }
     }
-    const resolvedVariantSetResult = variantSetFromVertexLayoutProjection(
-      layoutProjection,
-      variantSet,
-    );
+    const resolvedVariantSetResult =
+      variantSet === undefined &&
+      (materialShaderId === 'forgeax::sprite' || materialShaderId === 'forgeax::sprite-lit')
+        ? ({ ok: true, value: undefined } as const)
+        : variantSetFromVertexLayoutProjection(layoutProjection, variantSet);
     if (!resolvedVariantSetResult.ok) {
       runtime.errorRegistry.fire(resolvedVariantSetResult.error);
       return null;
@@ -252,7 +280,7 @@ export function recordGeometryDraws(
     const resolvePipeline = () =>
       runtime.getMaterialShaderPipeline?.(
         materialShaderId,
-        tonemapActive,
+        isHdrTarget,
         renderState,
         topology,
         indexFormat,
@@ -270,25 +298,37 @@ export function recordGeometryDraws(
       profilePhase === undefined
         ? resolvePipeline()
         : profileGeometrySegment(c, passKind, 'pipeline-selection', resolvePipeline);
-    const nextLookup: MaterialPipelineLookup = {
-      materialShaderId,
-      tonemapActive,
-      renderStateKey,
-      topology,
-      indexFormat,
-      variantSet,
-      passKind,
-      layoutProjection,
-      sampleCount,
-      colorFormatOverride: colorFormat,
-      handle,
-    };
-    if (shaderLookupCache === undefined) {
-      materialPipelineLookupCache.set(materialShaderId, new Map([[renderStateKey, [nextLookup]]]));
-    } else if (cachedLookups === undefined) {
-      shaderLookupCache.set(renderStateKey, [nextLookup]);
-    } else {
-      cachedLookups.push(nextLookup);
+    // A null handle is a transient async-build signal (`rhi-not-available`),
+    // not a stable pipeline result. Do not memoize it in this frame's lookup:
+    // caching the first pending lookup would turn a one-frame shader warm-up
+    // into a permanent skip for every later frame in a tight smoke loop. The
+    // owning runtime cache remains the SSOT; retrying here is bounded by the
+    // existing per-frame draw path and preserves the explicit skip-draw
+    // recovery while the pipeline becomes ready.
+    if (handle !== null) {
+      const nextLookup: MaterialPipelineLookup = {
+        materialShaderId,
+        isHdrTarget,
+        renderStateKey,
+        topology,
+        indexFormat,
+        variantSet,
+        passKind,
+        layoutProjection,
+        sampleCount,
+        colorFormatOverride: colorFormat,
+        handle,
+      };
+      if (shaderLookupCache === undefined) {
+        materialPipelineLookupCache.set(
+          materialShaderId,
+          new Map([[renderStateKey, [nextLookup]]]),
+        );
+      } else if (cachedLookups === undefined) {
+        shaderLookupCache.set(renderStateKey, [nextLookup]);
+      } else {
+        cachedLookups.push(nextLookup);
+      }
     }
     return handle;
   };
@@ -506,7 +546,7 @@ export function recordGeometryDraws(
       skinResources !== null && skinVariantSetResult.ok
         ? (runtime.getMaterialShaderPipeline?.(
             SKIN_MATERIAL_SHADER_ID,
-            tonemapActive,
+            isHdrTarget,
             entry.source.material.renderState,
             entry.mesh.submeshes[0]?.topology ?? 'triangle-list',
             entry.mesh.indexFormat,
@@ -727,7 +767,7 @@ export function recordGeometryDraws(
       // Preserve the dedicated sprite-pass state when the linear-LDR graph
       // routes a sprite through this generic geometry path. Negative scale
       // flips winding, so back-face culling would erase the quad.
-      const pipelineRenderState = isSpriteShader
+      const basePipelineRenderState = isSpriteShader
         ? {
             ...submeshMaterial.renderState,
             depthWriteEnabled: false,
@@ -736,6 +776,7 @@ export function recordGeometryDraws(
             blend: submeshMaterial.renderState?.blend ?? SPRITE_PREMULTIPLIED_ALPHA_BLEND,
           }
         : geometryRenderStateForTopology(smTopology, submeshMaterial.renderState);
+      const pipelineRenderState = geometryRenderStateForPass(basePipelineRenderState, passKind);
       let smPipelineHandle: typeof pipelineState.unlitPipeline;
       if (smMaterialShaderId === undefined || smMaterialShaderId === 'forgeax::default-unlit') {
         const unlitShaderId = smMaterialShaderId ?? 'forgeax::default-unlit';
@@ -763,7 +804,7 @@ export function recordGeometryDraws(
         smPipelineHandle =
           unlitRsp ??
           (colorFormatOverride === undefined
-            ? selectGeometryPipeline(pipelineState, tonemapActive, msaaActive)
+            ? selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive)
             : null);
       } else if (smMaterialShaderId !== undefined) {
         // feat-20260609 M4.5 / w38 (D-11): the variantSet handed to
@@ -793,18 +834,23 @@ export function recordGeometryDraws(
             ? ''
             : 'CLUSTER_FORWARD_AVAILABLE=true+STORAGE_BUFFER_AVAILABLE=true'
           : 'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true';
-        const authoredVariantSet =
-          isSpriteShader && entry.source.spriteInstances !== undefined ? '' : entry.variantSet;
-        const variantSet =
-          authoredVariantSet === undefined
+        // Sprite's base request must retain the boot-selected artifact. Only
+        // SpriteInstances uses the explicit empty key for the
+        // PER_INSTANCE_REGION=true variant; synthesizing the generic PBR
+        // capability axes for a base sprite would invent a lazy module label
+        // that has no boot seed and skip the first HDR draw.
+        const variantSet = isSpriteShader
+          ? smMaterialShaderId === 'forgeax::sprite' && entry.source.spriteInstances !== undefined
+            ? ''
+            : undefined
+          : entry.variantSet === undefined
             ? capabilityVariantSet
             : capabilityVariantSet === ''
-              ? authoredVariantSet
-              : `${capabilityVariantSet}+${authoredVariantSet}`;
-        const projectionVariantSetResult = variantSetFromVertexLayoutProjection(
-          entry.mesh.layoutProjection,
-          variantSet,
-        );
+              ? entry.variantSet
+              : `${capabilityVariantSet}+${entry.variantSet}`;
+        const projectionVariantSetResult = isSpriteShader
+          ? ({ ok: true, value: variantSet } as const)
+          : variantSetFromVertexLayoutProjection(entry.mesh.layoutProjection, variantSet);
         if (!projectionVariantSetResult.ok) {
           runtime.errorRegistry.fire(projectionVariantSetResult.error);
           continue;
@@ -833,7 +879,7 @@ export function recordGeometryDraws(
         // fires on per-submesh topology variance miss.
         smPipelineHandle = cachedPipeline ?? null;
       } else {
-        smPipelineHandle = selectGeometryPipeline(pipelineState, tonemapActive, msaaActive);
+        smPipelineHandle = selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive);
       }
 
       if (smPipelineHandle === null) {