@forgeax/engine-render 0.1.27 → 0.1.29

package/src/record/__tests__/material-slot-plan.unit.test.ts

@@ -1,10 +1,35 @@
 import { describe, expect, it } from 'vitest';
 import {
+  buildDispatchPlan,
   buildMaterialSlotPlan,
   findRenderablePrefixForSlotCapacity,
   materialSlotCountForPrefix,
 } from '../frame';
 
+function validatedRow(renderableIndex: number) {
+  return {
+    source: {
+      material: { materialShaderId: 'forgeax::default-unlit' },
+      materials: [{ materialShaderId: 'forgeax::default-unlit' }],
+    },
+    mesh: {},
+    renderableIndex,
+    renderState: undefined,
+    stencilReference: undefined,
+  } as never;
+}
+
+function ceilingInternals(slotCount: number) {
+  return {
+    growMeshSsbo: () => ({
+      ok: false as const,
+      code: 'mesh-ssbo-ceiling-reached' as const,
+      degradedToSlotCount: slotCount,
+    }),
+    meshSsboState: { slotCount },
+  } as never;
+}
+
 describe('material slot plan', () => {
   it('interns repeated snapshot identities across renderables', () => {
     const a = {};
@@ -41,4 +66,27 @@ describe('material slot plan', () => {
     expect(findRenderablePrefixForSlotCapacity(indices, 5)).toBe(3);
     expect(materialSlotCountForPrefix(indices, 3)).toBe(5);
   });
+
+  it('keeps retained shadow rows inside the ceiling when the primary view is empty', () => {
+    const shadowRows = [validatedRow(0), validatedRow(1), validatedRow(2)];
+    const plan = buildDispatchPlan(ceilingInternals(2), [], [], [], shadowRows);
+
+    expect(plan.validatedOrdered).toHaveLength(0);
+    expect(plan.shadowValidatedOrdered).toEqual(shadowRows.slice(0, 2));
+    expect(plan.validatedOrdered.length + plan.shadowValidatedOrdered.length).toBeLessThanOrEqual(
+      2,
+    );
+  });
+
+  it('reserves the primary rows before retained shadow rows on a mixed ceiling', () => {
+    const primaryRows = [validatedRow(0), validatedRow(1)];
+    const shadowRows = [validatedRow(2), validatedRow(3)];
+    const plan = buildDispatchPlan(ceilingInternals(3), primaryRows, [], [], shadowRows);
+
+    expect(plan.validatedOrdered).toEqual(primaryRows);
+    expect(plan.shadowValidatedOrdered).toEqual(shadowRows.slice(0, 1));
+    expect(plan.validatedOrdered.length + plan.shadowValidatedOrdered.length).toBeLessThanOrEqual(
+      3,
+    );
+  });
 });

package/src/record/__tests__/mesh-ssbo.unit.test.ts

@@ -1,5 +1,6 @@
+import { err, ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { getOrCreateFromChain } from '../mesh-ssbo';
+import { getOrCreateFromChain, getOrCreateFromChainResult } from '../mesh-ssbo';
 
 describe('mesh bind-group cache chains', () => {
   it('keeps variable-depth material resource chains isolated', () => {
@@ -35,4 +36,42 @@ describe('mesh bind-group cache chains', () => {
     expect(long).not.toBe(short);
     expect(counts.createBindGroup).toBe(2);
   });
+
+  it('propagates bind-group creation failures without poisoning the cache', () => {
+    const root = new WeakMap<object, unknown>();
+    const resource = {};
+    const counts = { createBindGroup: 0, keys: [] as string[] };
+    const failure = { code: 'rhi-device-lost' };
+    const failed = getOrCreateFromChainResult(
+      root,
+      [resource],
+      'retryable',
+      () => err(failure),
+      counts,
+    );
+    expect(failed).toEqual({ ok: false, error: failure });
+    expect(counts.createBindGroup).toBe(0);
+
+    const created = { id: 'created' } as never;
+    const recovered = getOrCreateFromChainResult(
+      root,
+      [resource],
+      'retryable',
+      () => ok(created),
+      counts,
+    );
+    expect(recovered).toEqual({ ok: true, value: created });
+    expect(counts.createBindGroup).toBe(1);
+    expect(
+      getOrCreateFromChainResult(
+        root,
+        [resource],
+        'retryable',
+        () => {
+          throw new Error('cache miss after recovery');
+        },
+        counts,
+      ),
+    ).toEqual({ ok: true, value: created });
+  });
 });

package/src/record/__tests__/recovery-pipeline.unit.test.ts

@@ -1,10 +1,7 @@
 import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
 import { describe, expect, it } from 'vitest';
 import { makeZeroCameraFallbackSnapshot, type ValidatedRenderable } from '../frame-snapshot';
-import {
-  createRecoveryColdWorkGuard,
-  prepareRecoveryPipelineReadiness,
-} from '../recovery-pipeline';
+import { prepareRecoveryPipelineReadiness } from '../recovery-pipeline';
 import type { PipelineState, RenderSystemInternals } from '../render-context';
 
 function probeRenderable(probe: boolean): ValidatedRenderable {
@@ -69,7 +66,7 @@ function recoveryReadinessFor(
   });
 }
 
-describe('recovery first-frame cold-work guard', () => {
+describe('recovery prepared pipeline cache', () => {
   it('prepares the probe-enabled Standard PBR variant used by the live record path', () => {
     const readiness = recoveryReadinessFor(probeRenderable(true));
     const standardPbr = readiness.pipelineSpecs.find(
@@ -97,28 +94,4 @@ describe('recovery first-frame cold-work guard', () => {
     expect(standardPbr?.shader.variantSet).toContain('REFLECTION_FALLBACK_AVAILABLE=true');
     expect(standardPbr?.attachments.colorFormats).toEqual(['rgba16float', 'rgba16float']);
   });
-
-  it('accepts a prepared candidate with no first-frame cold work', () => {
-    const guard = createRecoveryColdWorkGuard();
-
-    guard.arm();
-    expect(() => guard.finish()).not.toThrow();
-    expect(() => guard.finish()).not.toThrow();
-  });
-
-  it.each([
-    [
-      'pipeline',
-      (guard: ReturnType<typeof createRecoveryColdWorkGuard>) => guard.notePipelineColdWork(),
-    ],
-    [
-      'upload',
-      (guard: ReturnType<typeof createRecoveryColdWorkGuard>) => guard.noteUploadColdWork(),
-    ],
-  ] as const)('hard-fails a first-frame %s miss before submission', (_kind, note) => {
-    const guard = createRecoveryColdWorkGuard();
-
-    guard.arm();
-    expect(() => note(guard)).toThrow(/recovery first frame performed cold/);
-  });
 });

package/src/record/__tests__/sprite-material-abi.unit.test.ts

@@ -1,8 +1,10 @@
-import type { Buffer, Sampler, TextureView } from '@forgeax/engine-rhi';
+import type { BindGroupEntry, Buffer, Sampler, TextureView } from '@forgeax/engine-rhi';
 import { describe, expect, it } from 'vitest';
 import { assembleMaterialWithSkylightEntries } from '../../ibl/skylight-bind-group';
-import { defaultViewForUserRegionField } from '../main-pass-material';
-import { buildSpritePassBaseMaterialEntries } from '../main-pass-sprite-draws';
+import {
+  BUILTIN_USER_REGION_TEXTURE_FIELDS,
+  defaultViewForUserRegionField,
+} from '../main-pass-material';
 import type { PipelineState } from '../render-context';
 
 describe('sprite Standard material ABI', () => {
@@ -27,7 +29,6 @@ describe('sprite Standard material ABI', () => {
     const white = {} as TextureView;
     const pipelineState = {
       materialUniformBuffer: { buffer: {} },
-      nearestSampler: sampler,
       defaultSampler: sampler,
       defaultWhiteTextureView: white,
       defaultNormalTextureView: {} as TextureView,
@@ -35,7 +36,27 @@ describe('sprite Standard material ABI', () => {
     } as PipelineState;
     const spriteTexture = {} as TextureView;
 
-    const entries = buildSpritePassBaseMaterialEntries(pipelineState, spriteTexture);
+    // Sprite no longer owns a parallel material-entry builder. Preserve the
+    // shared user-region/IBL layout gate; actual sampler selection is covered
+    // by the source-derived 300-frame Sprite raster smoke in both tone lanes.
+    const entries: BindGroupEntry[] = [
+      { binding: 0, resource: { kind: 'buffer', value: { buffer: {} as Buffer } } },
+    ];
+    for (const [index, field] of BUILTIN_USER_REGION_TEXTURE_FIELDS.entries()) {
+      entries.push(
+        { binding: 1 + index * 2, resource: { kind: 'sampler', value: sampler } },
+        {
+          binding: 2 + index * 2,
+          resource: {
+            kind: 'textureView',
+            value:
+              field === 'baseColorTexture'
+                ? spriteTexture
+                : defaultViewForUserRegionField(field, pipelineState),
+          },
+        },
+      );
+    }
 
     expect(entries.map((entry) => entry.binding)).toEqual([
       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
@@ -68,6 +89,16 @@ describe('sprite Standard material ABI', () => {
     });
     expect(merged).toHaveLength(24);
 
+    const complete = [
+      ...merged,
+      {
+        binding: 46,
+        resource: { kind: 'buffer' as const, value: { buffer: {} as Buffer } },
+      },
+    ];
+    expect(complete).toHaveLength(25);
+    expect(complete[24]).toMatchObject({ binding: 46, resource: { kind: 'buffer' } });
+
     const backdrop = {} as TextureView;
     const active = assembleMaterialWithSkylightEntries(
       entries,

package/src/record/__tests__/typed-frame-graph-plan.unit.test.ts

@@ -2,11 +2,13 @@ import { ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import type { RenderFeaturePlannedFrame } from '../../features/plan';
 import { GPU_TEXTURE_USAGE_COPY_SRC } from '../../gpu-texture-usage';
+import { createAutoExposureGraphPlan } from '../../pipeline/standard-output/auto-exposure/graph';
 import { getTextureIdentity, validateGraphTargetCaptureReadback } from '../frame-snapshot';
 import {
   executeCompiledFrameGraph,
   type RenderFeatureGraphCandidate,
   renderFeatureGraphPlanSignature,
+  updateRenderFeaturePlanRevision,
 } from '../typed-frame-graph';
 
 const captureDescriptor = {
@@ -101,6 +103,13 @@ function planned(generation: number, signature: string): RenderFeaturePlannedFra
 }
 
 describe('typed frame graph feature plan authority', () => {
+  it('carries auto exposure as one frame-local candidate plan', () => {
+    const plan = createAutoExposureGraphPlan({ width: 17, height: 9 });
+    expect(plan.candidateAvailableSameFrame).toBe(true);
+    expect(plan.cpuReadbackCount).toBe(0);
+    expect(plan.cpuUploadCount).toBe(0);
+  });
+
   it('keys topology and last-known-good candidates by stable plan signature and generation', () => {
     const first = renderFeatureGraphPlanSignature([planned(1, 'plan-a')]);
     expect(renderFeatureGraphPlanSignature([planned(1, 'plan-a')])).toBe(first);
@@ -116,6 +125,42 @@ describe('typed frame graph feature plan authority', () => {
     expect(candidate.plans).toHaveLength(1);
   });
 
+  it('keeps the compact revision stable for equivalent plan objects', () => {
+    const first = updateRenderFeaturePlanRevision(
+      { revision: 0, entries: [] },
+      [planned(1, 'plan-a')],
+      [{ featureIdentity: 'synthetic.feature', order: 0, passes: [] }],
+    );
+    const equivalent = updateRenderFeaturePlanRevision(
+      first,
+      [planned(1, 'plan-a')],
+      [{ featureIdentity: 'synthetic.feature', order: 0, passes: [] }],
+    );
+    expect(equivalent).toBe(first);
+    expect(equivalent.revision).toBe(1);
+
+    const changedSignature = updateRenderFeaturePlanRevision(
+      equivalent,
+      [planned(1, 'plan-b')],
+      [{ featureIdentity: 'synthetic.feature', order: 0, passes: [] }],
+    );
+    expect(changedSignature.revision).toBe(2);
+    expect(
+      updateRenderFeaturePlanRevision(
+        changedSignature,
+        [planned(2, 'plan-b')],
+        [{ featureIdentity: 'synthetic.feature', order: 0, passes: [] }],
+      ).revision,
+    ).toBe(3);
+    expect(
+      updateRenderFeaturePlanRevision(
+        changedSignature,
+        [planned(1, 'plan-b')],
+        [{ featureIdentity: 'synthetic.feature', order: 1, passes: [] }],
+      ).revision,
+    ).toBe(3);
+  });
+
   it('keeps execution projection out of the public planned-frame vocabulary', () => {
     const invalid: RenderFeaturePlannedFrame = {
       ...planned(1, 'plan-a'),

package/src/record/__tests__/view-ubo-layout.unit.test.ts

@@ -34,6 +34,11 @@ describe('View UBO directional shadow ABI', () => {
   it('declares one shared View binding with a vec4 directional filter carrier', () => {
     const viewStruct = commonWgslSrc.match(/struct View \{[\s\S]*?\n\};/)?.[0] ?? '';
     expect(viewStruct).toMatch(/directionalShadowFilter\s*:\s*vec4<f32>/);
+    expect(viewStruct).toMatch(/ssrParams\s*:\s*vec4<f32>/);
+    expect(viewUboSrc).toMatch(/viewPayload\[236\]\s*=\s*ssr\.maxDistance/);
+    expect(viewUboSrc).toMatch(/viewPayload\[237\]\s*=\s*ssr\.thickness/);
+    expect(viewUboSrc).toMatch(/viewPayload\[238\]\s*=\s*ssr\.maxRoughness/);
+    expect(viewUboSrc).toMatch(/viewPayload\[239\]\s*=\s*1/);
     expect(viewStruct).not.toMatch(/pcfKernelSize/);
     expect(commonWgslSrc.match(/@group\(0\) @binding\(0\) var<uniform> view/g)).toHaveLength(1);
   });

package/src/record/dynamic-geometry-consumption.ts

@@ -0,0 +1,59 @@
+import type { World } from '@forgeax/engine-ecs';
+import type { RenderFrameState, ValidatedRenderable } from './frame-snapshot';
+
+/** Capture the render-stage mesh binding used by the current submitted frame. */
+export function createDynamicGeometryConsumptionRecorder(
+  worlds: readonly World[],
+  bindings: WeakMap<World, Map<number, number>>,
+): (entry: ValidatedRenderable) => void {
+  return (entry) => {
+    const renderable = entry.source;
+    const world = worlds[renderable.worldId];
+    if (world === undefined) return;
+    let worldBindings = bindings.get(world);
+    if (worldBindings === undefined) {
+      worldBindings = new Map();
+      bindings.set(world, worldBindings);
+    }
+    worldBindings.set(renderable.entityKey, renderable.assetHandle);
+  };
+}
+
+export interface DynamicGeometryFrameBindings {
+  begin(): void;
+  onRenderableDraw(worlds: readonly World[]): (entry: ValidatedRenderable) => void;
+  commit(submitted: boolean): void;
+  isConsumed(world: World, entity: number, meshHandle: number | undefined): boolean;
+}
+
+/** Own the submitted-frame receipt used by dynamic-geometry publication. */
+export function createDynamicGeometryFrameBindings(): DynamicGeometryFrameBindings {
+  let submitted = new WeakMap<World, ReadonlyMap<number, number>>();
+  let pending = new WeakMap<World, Map<number, number>>();
+  return {
+    begin(): void {
+      submitted = new WeakMap();
+      pending = new WeakMap();
+    },
+    onRenderableDraw(worlds): (entry: ValidatedRenderable) => void {
+      return createDynamicGeometryConsumptionRecorder(worlds, pending);
+    },
+    commit(didSubmit): void {
+      if (didSubmit) submitted = pending;
+    },
+    isConsumed(world, entity, meshHandle): boolean {
+      if (!Number.isInteger(entity) || meshHandle === undefined) return false;
+      return submitted.get(world)?.get(entity) === meshHandle;
+    },
+  };
+}
+
+/** Drop temporal history after a dynamic-geometry topology replacement. */
+export function resetDynamicGeometryTemporalHistory(frameState: RenderFrameState): void {
+  frameState.temporalFrameTransaction.reset('signature-change');
+  frameState.temporalFrame = undefined;
+  frameState.temporalFrameInput = undefined;
+  frameState.lastSuccessfulTemporalView = undefined;
+  frameState.successfulTemporalFrameIndex = 0;
+  frameState.pendingTemporalCommit = { kind: 'none' };
+}

package/src/record/frame-lighting.ts

@@ -137,8 +137,8 @@ function mapClusterUploadFailure(
  * verbatim from `recordFrame`. Walks the handle-identity WeakMap caches
  * (feat-20260531 M2 + feat-20260622 M3) to resolve or lazily create the view
  * (@group 0), mesh (@group 2), and — when HDRP is active — HDRP-unified cluster
- * bind groups. Returns all three (null when `hasValidated` is false, the Case E
- * clear-pass-only path). No new mutable state: `bindGroupCounts` accounting +
+ * bind groups. Raster groups may be null with no validated meshes; the Cluster
+ * producer follows the accepted lighting topology independently. `bindGroupCounts` accounting +
  * cache maps are threaded through explicitly.
  *
  * @internal
@@ -181,10 +181,12 @@ export function buildPerFrameBindGroups(
   const clusteredLighting = standardLighting?.kind === 'clustered';
   const membershipLayout = pipelineState.hdrpClusterMembershipBindGroupLayout;
   const membership = frameState.hdrpClusterMembership;
-  const expectedHdrpBuffers =
-    hasValidated && clusteredLighting
-      ? getOrCreateHdrpBuffers(internals, frameState.installedPipelineConfig?.clusterGrid)
-      : null;
+  // The graph's Cluster producer also serves RenderFeature consumers and
+  // warmup frames with no ordinary meshes. Its lifetime follows the accepted
+  // lighting topology, not the ordinary raster validation count.
+  const expectedHdrpBuffers = clusteredLighting
+    ? getOrCreateHdrpBuffers(internals, frameState.installedPipelineConfig?.clusterGrid)
+    : null;
   const currentMembership =
     expectedHdrpBuffers !== null &&
     membership?.clusterGridBuffer === expectedHdrpBuffers.clusterGridBuffer
@@ -332,7 +334,7 @@ export function buildPerFrameBindGroups(
             },
             // feat-20260612-point-light-shadows-urp-hdrp Round-2 F-1:
             // shadowParams UBO (`array<vec4<f32>, 4>` = 64 B). Lane N
-            // stores `(near, far, 1/(far-near), 0)` for the point light
+            // stores `(near, far, depthBias, normalBias)` for the point light
             // with shadowAtlasLayer === N. Updated per frame from
             // `pointShadowSnapshots` below.
             {
@@ -829,7 +831,7 @@ export function writeSpotModifierTextures(
  * binding 6), extracted verbatim from `recordFrame`.
  *
  * feat-20260612-point-light-shadows-urp-hdrp Round-2 F-1: 4 lanes x vec4<f32>;
- * lane[shadowAtlasLayer] = (near, far, 1/(far-near), 0). Lanes for non-shadow
+ * lane[shadowAtlasLayer] = (near, far, depthBias, normalBias). Lanes for non-shadow
  * slots stay zero (the WGSL sample path is gated by PointLight.shadowAtlasLayer
  * >= 0). Always writes the full 64 B so stale non-zero lanes from a previous
  * frame's allocation cannot poison the current frame.
@@ -854,11 +856,10 @@ export function writeShadowParamsBuffer(
     const base = layer * SHADOW_PARAMS_FLOATS_PER_LANE;
     const near = ps.nearPlane;
     const far = ps.farPlane;
-    const invSpan = far > near ? 1 / (far - near) : 0;
     shadowParamsArr[base] = near;
     shadowParamsArr[base + 1] = far;
-    shadowParamsArr[base + 2] = invSpan;
-    shadowParamsArr[base + 3] = 0;
+    shadowParamsArr[base + 2] = ps.depthBias;
+    shadowParamsArr[base + 3] = ps.normalBias;
   }
   const shadowParamsWriteRes = internals.device.queue.writeBuffer(
     pipelineState.shadowParamsBuffer,

package/src/record/frame-snapshot.ts

@@ -18,10 +18,16 @@ import type { DirectionalShadowQuality } from '../components/directional-shadow-
 import type { EnvironmentGeneration } from '../environment/generation';
 import type { EnvironmentLifecycle } from '../environment/lifecycle';
 import type { GpuBuffer } from '../gpu-resource';
-import type { InstanceCollectionId, InstanceResidency } from '../instances';
+import type { InstanceCollectionStore } from '../instances';
 import type { IblBindingInspection } from '../mesh-material-bindings';
 import type { StandardLightingInspection } from '../pipeline/standard-lighting/inspection';
+import type { AutoExposureGpuResources } from '../pipeline/standard-output/auto-exposure/gpu';
+import type { AutoExposureState } from '../pipeline/standard-output/auto-exposure/state';
+import type { StandardLutGpuResources } from '../pipeline/standard-output/lut-gpu';
+import type { StandardLutCandidate, StandardLutState } from '../pipeline/standard-output/lut-state';
 import type { PointShadowInspection } from '../point-shadow-inspection';
+import type { SsrSpatialAdmission } from '../ssr/admission';
+import type { SsrHistoryCandidate, SsrHistoryOwner } from '../ssr/history';
 import type { TemporalGpuState } from '../temporal/gpu';
 import type { TemporalView } from '../temporal/view';
 
@@ -30,6 +36,23 @@ export type TemporalCommitOutcome =
   | { readonly kind: 'off'; readonly view: TemporalView }
   | { readonly kind: 'taa'; readonly view: TemporalView };
 
+/** CPU transaction metadata staged beside the renderer-owned GPU candidate. */
+export interface PendingAutoExposureState {
+  readonly state: AutoExposureState;
+  readonly generation: number;
+  readonly deviceEpoch: number;
+  readonly frameId: number;
+}
+
+/** CPU POD staged beside the renderer-owned LUT resources until submit. */
+export interface PendingStandardLutState {
+  readonly state: StandardLutState;
+  readonly candidate?: StandardLutCandidate;
+  readonly remove: boolean;
+  readonly targetGeneration: number;
+  readonly deviceEpoch: number;
+}
+
 /**
  * feat-20260708-composited-multi-world-rendering M1 / D-1 / D-9:
  * worldId-entityKey composite key helper. Formula: `worldId * 2^32 + entityKey`.
@@ -53,7 +76,14 @@ export function worldEntityKey(worldId: number, entityKey: number): number {
   return worldId * 4294967296 + entityKey; // 2^32 = 4294967296
 }
 
-/** Per-renderer projection identity, with entity keys for sprite/fold snapshots. */
+/**
+ * Cache identity for a renderer-owned instance collection.
+ *
+ * A collection can be rebound from one entity to another while retaining the
+ * same count, revision, and extraction archetype. The collection id is the
+ * owner identity in that case; the entity cache key is only the compatibility
+ * fallback for legacy snapshots that predate the collection field.
+ */
 export function instanceCollectionCacheKey(
   worldId: number,
   instance: { readonly cacheKey: number; readonly collectionId?: number },
@@ -211,27 +241,78 @@ export function validateGraphTargetCaptureReadback(input: {
   return { ok: true };
 }
 
+/**
+ * Receipt delivered after a selected pass-replay raster pass has encoded.
+ * The depth view and target handles are the frame-resolved objects used by
+ * the graph; the numeric texture identity is derived by getTextureIdentity.
+ */
+export interface GraphTargetPassReplayReceipt {
+  readonly passName: string;
+  readonly executionIndex: number;
+  readonly resolvedDepthStencilAttachmentView: TextureView;
+  readonly graphGeneration: number;
+  readonly targetName: string;
+  readonly targetView: TextureView;
+  readonly targetTexture: Texture;
+  readonly targetTextureIdentity: number;
+}
+
+export type GraphTargetPassReplayCallback = (receipt: GraphTargetPassReplayReceipt) => void;
+
+/** Receipt delivered once after a complete selected prefix reaches its boundary pass. */
+export interface GraphTargetPassReplayPrefixReceipt extends GraphTargetPassReplayReceipt {
+  /** The compiled-order prefix that was replayed. */
+  readonly replayPassNames: readonly string[];
+  /** The unique depth-bearing raster pass used as the observation anchor. */
+  readonly depthAttachmentPassName: string;
+  /** The final pass in the selected prefix. */
+  readonly observeAfterPassName: string;
+  readonly depthAttachmentExecutionIndex: number;
+}
+
+export type GraphTargetPassReplayPrefixCallback = (
+  receipt: GraphTargetPassReplayPrefixReceipt,
+) => void;
+
 /** 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;
+export type GraphTargetCaptureRequest =
+  | {
+      /** The default preserves the original target-copy request shape. */
+      readonly kind?: 'target-copy';
+      readonly name: string;
+      /** Optional one-shot pass selection for internal graph-target diagnostics. */
+      readonly replayPassNames?: readonly 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;
+        };
+      };
+    }
+  | {
+      /** Execute selected compiled passes without requesting a target copy. */
+      readonly kind: 'pass-replay';
+      readonly replayPassNames: readonly string[];
+      /** Optional graph target used to validate the selected pass attachment. */
+      readonly targetName?: string;
+      /** Optional callback invoked after each selected pass encodes. */
+      readonly onPassEncoded?: GraphTargetPassReplayCallback;
+      /** Optional one-shot callback invoked after the selected prefix boundary encodes. */
+      readonly depthAttachmentPassName?: string;
+      readonly observeAfterPassName?: string;
+      readonly onPrefixEncoded?: GraphTargetPassReplayPrefixCallback;
     };
-  };
-}
 
 /** Renderer-private readback request for the Standard fallback MRT. */
 export interface ReflectionFallbackReadbackRequest {
@@ -251,7 +332,6 @@ export interface ReflectionFallbackReadbackRequest {
   };
   encoded: boolean;
 }
-
 /**
  * Build a synthetic CameraSnapshot the record stage uses when the world
  * carries no Camera entity. Identity-shaped projection / view inputs
@@ -319,6 +399,18 @@ export interface RenderFrameState {
   iblBindingInspection?: IblBindingInspection;
   /** Demand for the frame-local Standard fallback MRT. */
   reflectionFallbackDemand?: boolean;
+  /** Whether the active camera explicitly requested SSR this frame. */
+  ssrRequested?: boolean | undefined;
+  /** Current renderer-owned SSR spatial admission projection. */
+  ssrSpatialAdmission?: SsrSpatialAdmission | undefined;
+  /** Persistent SSR history owner; candidate is promoted only after submit. */
+  ssrHistoryOwner?: SsrHistoryOwner | undefined;
+  ssrHistoryCandidate?: SsrHistoryCandidate | undefined;
+  /** Reused CPU parameter payload for the SSR temporal resolve. */
+  ssrTemporalParamsPayload?: Uint8Array | undefined;
+  /** Last camera identity used by the SSR history reset seam. */
+  ssrLastCameraEntity?: number | undefined;
+  ssrLastHistoryVersion?: number | undefined;
   /** Monotonic compiled-graph identity used by diagnostic readbacks. */
   graphGeneration: number;
   /** Number of successfully submitted TAA frames; failed attempts do not advance it. */
@@ -390,6 +482,22 @@ export interface RenderFrameState {
   lastSuccessfulCameraAntialias: CameraSnapshot['antialias'] | undefined;
   /** Staged TAA GPU state is promoted only after queue.submit succeeds. */
   temporalGpuState: TemporalGpuState | undefined;
+  /** Device-scoped auto-exposure buffers imported by the Standard graph. */
+  autoExposureGpuResources?: AutoExposureGpuResources | undefined;
+  /** Candidate auto-exposure buffers; promoted only after queue.submit succeeds. */
+  pendingAutoExposureGpuResources?: AutoExposureGpuResources | undefined;
+  /** Accepted auto-exposure inspection state; promoted only after submit. */
+  autoExposureState?: AutoExposureState | undefined;
+  /** Candidate auto-exposure inspection state; cleared on any failed frame. */
+  pendingAutoExposureState?: PendingAutoExposureState | undefined;
+  /** Prepared ordinary TextureAsset LUT candidate for the Standard graph. */
+  standardLutGpuResources?: StandardLutGpuResources | undefined;
+  /** Candidate LUT resources; promoted only after queue.submit succeeds. */
+  pendingStandardLutGpuResources?: StandardLutGpuResources | undefined;
+  /** Accepted LUT inspection state; promoted only after submit. */
+  standardLutState: StandardLutState;
+  /** Candidate LUT inspection state; cleared on any failed frame. */
+  pendingStandardLutState?: PendingStandardLutState | undefined;
   /** Last successful TAA GPU state; candidate replacement stays staged until submit. */
   activeTemporalGpuState: TemporalGpuState | undefined;
   /** Submitted temporal generations retained until their queue fence resolves. */
@@ -399,12 +507,14 @@ export interface RenderFrameState {
   pendingTemporalCommit: TemporalCommitOutcome;
   /** Staged environment generation is promoted only after queue.submit succeeds. */
   environmentGeneration: EnvironmentGeneration | undefined;
+  environmentFrame?: import('../environment/frame').SelectedEnvironmentFrame | undefined;
+  pendingAtmospherePublish?: (() => void) | undefined;
   readonly environmentLifecycle: EnvironmentLifecycle | undefined;
   currentDirectionalShadowView: TextureView | null;
   currentSpotShadowView: TextureView | null;
   readonly instanceBuffers: Map<number, InstanceBufferCacheEntry>;
   /** Renderer-owned collection owner used for record-stage residency facts. */
-  readonly instanceResidency?: Map<InstanceCollectionId, InstanceResidency>;
+  readonly instanceCollections?: InstanceCollectionStore;
   /** Stable buffers for renderer-owned collections split by device cap. */
   readonly instanceBufferChunks?: Map<string, InstanceBufferCacheEntry>;
   /** Per-object ProbeBlendRecord buffers; upload is one atomic 160B write. */