@forgeax/engine-render 0.1.2

package/src/__tests__/temporal-frame-transaction.integration.test.ts

@@ -0,0 +1,537 @@
+import { vec3 } from '@forgeax/engine-math';
+import type { Buffer, CommandBuffer, Result, RhiError as RhiErrorType } from '@forgeax/engine-rhi';
+import { RhiError } from '@forgeax/engine-rhi';
+import { RhiNullCommandEncoder, RhiNullDevice, RhiNullQueue } from '@forgeax/engine-rhi-null';
+import { err, ok } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { GpuScene } from '../gpu-scene';
+import { GPU_SCENE_LAYOUTS, gpuSceneFieldOffset } from '../gpu-scene-schema';
+import { makeZeroCameraFallbackSnapshot, type RenderFrameState } from '../record/frame-snapshot';
+import { createShadowSubmitModeState } from '../record/shadow-submit-mode';
+import { executeCompiledFrameGraph } from '../record/typed-frame-graph';
+import type { RenderPipelineFrame } from '../render-pipeline';
+import type { RenderSceneSubmissionDelta } from '../render-scene-projection';
+import { RenderSceneProjection } from '../render-scene-projection';
+import type { RenderSystemInternals } from '../render-system';
+import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
+import { TaaHistoryStore } from '../taa-history-store';
+import { summarizeTemporalCoverage, type TemporalCoverageSummary } from '../temporal-coverage';
+import { TemporalFrameTransaction } from '../temporal-frame-transaction';
+import { temporalViewId } from '../temporal-view';
+
+interface WriteRecord {
+  readonly buffer: Buffer;
+  readonly offset: number;
+  readonly bytes: Uint8Array;
+}
+
+class TransactionQueue extends RhiNullQueue {
+  readonly writes: WriteRecord[] = [];
+  failSubmit = false;
+
+  override writeBuffer(
+    buffer: Buffer,
+    bufferOffset: number,
+    data: ArrayBufferView | ArrayBuffer,
+    dataOffset?: number,
+    size?: number,
+  ): Result<void, RhiErrorType> {
+    const source =
+      data instanceof ArrayBuffer
+        ? new Uint8Array(data)
+        : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    const start = dataOffset ?? 0;
+    const length = size ?? source.byteLength - start;
+    this.writes.push({ buffer, offset: bufferOffset, bytes: source.slice(start, start + length) });
+    return super.writeBuffer(buffer, bufferOffset, data, dataOffset, size);
+  }
+
+  override submit(_commandBuffers: readonly CommandBuffer[]): Result<void, RhiErrorType> {
+    if (!this.failSubmit) return ok(undefined);
+    this.failSubmit = false;
+    return err(failure('queue submit failed'));
+  }
+}
+
+function failure(hint: string): RhiError {
+  return new RhiError({
+    code: 'webgpu-runtime-error',
+    expected: 'the temporal frame stage succeeds',
+    hint,
+  });
+}
+
+function material(emissive = 0): MaterialSnapshot {
+  return {
+    baseColor: vec3.create(0.25, 0.5, 0.75),
+    metallic: 0.2,
+    roughness: 0.8,
+    emissive: [emissive, 0, 0],
+    emissiveIntensity: 1,
+    materialHandle: 17,
+  };
+}
+
+function matrix(translationX: number): Float32Array {
+  const world = new Float32Array(16);
+  world[0] = 1;
+  world[5] = 1;
+  world[10] = 1;
+  world[15] = 1;
+  world[12] = translationX;
+  return world;
+}
+
+function snapshot(
+  entityKey: number,
+  translationX: number,
+  options: {
+    readonly material?: MaterialSnapshot;
+    readonly instanceTranslationX?: number;
+    readonly skinBuffer?: Buffer;
+    readonly jointMatrixTranslationX?: number;
+    readonly morphWeights?: readonly number[];
+  } = {},
+): RenderableSnapshot {
+  const snapshotMaterial = options.material ?? material();
+  return {
+    assetHandle: 9,
+    transform: { world: matrix(translationX) },
+    localAabb: new Float32Array([-1, -1, -1, 1, 1, 1]),
+    material: snapshotMaterial,
+    materials: [snapshotMaterial],
+    materialBindingSources: ['engine-default'],
+    worldId: 0,
+    entityKey,
+    ...(options.instanceTranslationX === undefined
+      ? {}
+      : {
+          instances: {
+            transforms: matrix(options.instanceTranslationX),
+            instanceCount: 1,
+            cacheKey: entityKey,
+            archVersion: 1,
+          },
+        }),
+    ...(options.skinBuffer === undefined
+      ? {}
+      : {
+          skin: {
+            jointCount: 1,
+            jointMatrices: matrix(options.jointMatrixTranslationX ?? 0),
+            byteOffset: 0,
+            buffer: options.skinBuffer,
+          },
+        }),
+    ...(options.morphWeights === undefined
+      ? {}
+      : { morphWeights: new Float32Array(options.morphWeights) }),
+  };
+}
+
+function camera() {
+  return { ...makeZeroCameraFallbackSnapshot(), entityKey: 1, antialias: 'taa' as const };
+}
+
+function renderInternals(device: RhiNullDevice): RenderSystemInternals {
+  return {
+    device,
+    errorRegistry: { fire: () => undefined },
+  } as unknown as RenderSystemInternals;
+}
+
+function temporalTransaction(device: RhiNullDevice): TemporalFrameTransaction {
+  const historyStore = new TaaHistoryStore(device);
+  const prepared = historyStore
+    .prepare({
+      enabled: true,
+      width: 1280,
+      height: 720,
+      viewId: temporalViewId(camera().worldId, camera().entityKey),
+      pipelineOwnerGeneration: 1,
+      surfaceFormat: 'bgra8unorm',
+    })
+    .unwrap();
+  const graph = {
+    retire: () => Promise.resolve(ok(undefined)),
+  } as unknown as Parameters<TaaHistoryStore['commitGraph']>[0];
+  historyStore.commitGraph(graph, prepared);
+  return new TemporalFrameTransaction(historyStore);
+}
+
+function frameState(
+  execute: () => Result<void, RhiErrorType> = () => ok(undefined),
+): RenderFrameState {
+  return {
+    compiledFrameGraph: { execute } as unknown as RenderFrameState['compiledFrameGraph'],
+    shadowSubmitModeState: createShadowSubmitModeState(),
+    pendingShadowCommandBuffers: [],
+  } as unknown as RenderFrameState;
+}
+
+function submit(
+  transaction: TemporalFrameTransaction,
+  projection: RenderSceneProjection,
+  visible: readonly RenderableSnapshot[],
+  device: RhiNullDevice,
+  options: {
+    readonly graph?: 'fail';
+    readonly finish?: 'fail';
+    readonly submit?: 'fail';
+    readonly onSceneSubmitted?: (delta: RenderSceneSubmissionDelta) => void;
+    readonly coverage?: TemporalCoverageSummary;
+    readonly environmentSignature?: string;
+  } = {},
+) {
+  const attempt = transaction.begin({
+    camera: camera(),
+    surfaceWidth: 1280,
+    surfaceHeight: 720,
+    projection,
+    visible,
+    ...(options.coverage === undefined ? {} : { coverage: options.coverage }),
+    ...(options.onSceneSubmitted === undefined
+      ? {}
+      : { onSceneSubmitted: options.onSceneSubmitted }),
+    ...(options.environmentSignature === undefined
+      ? {}
+      : { environmentSignature: options.environmentSignature }),
+  });
+  const encoder =
+    options.finish === 'fail'
+      ? ({ finish: () => err(failure('encoder finish failed')) } as RhiNullCommandEncoder)
+      : device.createCommandEncoder({ label: 'temporal-transaction-test' }).unwrap();
+  const queue = device.queue as TransactionQueue;
+  queue.failSubmit = options.submit === 'fail';
+  const submitted = executeCompiledFrameGraph(
+    renderInternals(device),
+    frameState(options.graph === 'fail' ? () => err(failure('graph execute failed')) : undefined),
+    {} as RenderPipelineFrame,
+    encoder,
+    undefined,
+    attempt,
+  );
+  return { attempt, submitted };
+}
+
+function latestTransform(
+  queue: TransactionQueue,
+  buffer: Buffer,
+  field: 'currentWorld' | 'previousWorld',
+): number {
+  const write = [...queue.writes].reverse().find((candidate) => candidate.buffer === buffer);
+  if (write === undefined) throw new Error('transform upload unavailable');
+  const absolute = gpuSceneFieldOffset(GPU_SCENE_LAYOUTS.transform, field) + 12 * 4;
+  return new DataView(write.bytes.buffer).getFloat32(absolute - write.offset, true);
+}
+
+describe('TemporalFrameTransaction', () => {
+  it('resets once for a successful active environment publish, not for a LKG retry', () => {
+    const queue = new TransactionQueue();
+    const device = new RhiNullDevice(
+      queue,
+      (bookkeeper, owner) => new RhiNullCommandEncoder(bookkeeper, owner),
+    );
+    const projection = new RenderSceneProjection();
+    const transaction = temporalTransaction(device);
+    const first = snapshot(20, 1);
+    projection.apply([{ kind: 'create', snapshot: first }]);
+
+    transaction.noteEnvironmentPublished('environment-first');
+    expect(transaction.inspect()).toMatchObject({
+      environmentSignature: 'environment-first',
+      environmentPublishCount: 1,
+      environmentResetCount: 1,
+    });
+    submit(transaction, projection, [first], device, {
+      environmentSignature: 'environment-first',
+    });
+    transaction.noteEnvironmentPublished('environment-first');
+    expect(transaction.inspect().environmentResetCount).toBe(1);
+
+    const replacement = snapshot(20, 2);
+    projection.apply([{ kind: 'create', snapshot: replacement }]);
+    const failed = submit(transaction, projection, [replacement], device, {
+      environmentSignature: 'environment-replacement',
+      submit: 'fail',
+    });
+    expect(failed.submitted).toBe(false);
+    expect(transaction.inspect()).toMatchObject({
+      environmentSignature: 'environment-first',
+      environmentPublishCount: 1,
+      environmentResetCount: 1,
+    });
+
+    transaction.noteEnvironmentPublished('environment-replacement');
+    expect(transaction.inspect()).toMatchObject({
+      environmentSignature: 'environment-replacement',
+      environmentPublishCount: 2,
+      environmentResetCount: 2,
+    });
+  });
+
+  it('disables old history on the publishing frame and preserves it on a failed replacement', () => {
+    const queue = new TransactionQueue();
+    const device = new RhiNullDevice(
+      queue,
+      (bookkeeper, owner) => new RhiNullCommandEncoder(bookkeeper, owner),
+    );
+    const projection = new RenderSceneProjection();
+    const transaction = temporalTransaction(device);
+    const initial = snapshot(21, 1);
+    projection.apply([{ kind: 'create', snapshot: initial }]);
+
+    transaction.noteEnvironmentPublished('environment-first');
+    const first = submit(transaction, projection, [initial], device, {
+      environmentSignature: 'environment-first',
+    });
+    expect(first.attempt.historyValid).toBe(false);
+    expect(transaction.inspect().historyValid).toBe(true);
+
+    const replacement = snapshot(21, 2);
+    projection.apply([{ kind: 'create', snapshot: replacement }]);
+    const published = submit(transaction, projection, [replacement], device, {
+      environmentSignature: 'environment-replacement',
+    });
+    expect(published).toMatchObject({ submitted: true, attempt: { status: 'committed' } });
+    expect(published.attempt.historyValid).toBe(false);
+    expect(transaction.inspect()).toMatchObject({
+      environmentSignature: 'environment-replacement',
+      environmentPublishCount: 2,
+      environmentResetCount: 2,
+      historyValid: true,
+      lastResetReason: 'environment-published',
+    });
+
+    const failedReplacement = snapshot(21, 3);
+    projection.apply([{ kind: 'create', snapshot: failedReplacement }]);
+    const failed = submit(transaction, projection, [failedReplacement], device, {
+      environmentSignature: 'environment-next',
+      submit: 'fail',
+    });
+    expect(failed.attempt.historyValid).toBe(false);
+    expect(failed.submitted).toBe(false);
+    expect(transaction.inspect()).toMatchObject({
+      environmentSignature: 'environment-replacement',
+      environmentPublishCount: 2,
+      environmentResetCount: 2,
+      historyValid: true,
+    });
+
+    const stable = submit(transaction, projection, [failedReplacement], device, {
+      environmentSignature: 'environment-replacement',
+    });
+    expect(stable.attempt.historyValid).toBe(true);
+  });
+
+  it('commits scene, view, direction, validity, and index only after successful submit', () => {
+    const queue = new TransactionQueue();
+    const device = new RhiNullDevice(
+      queue,
+      (bookkeeper, owner) => new RhiNullCommandEncoder(bookkeeper, owner),
+    );
+    const projection = new RenderSceneProjection();
+    const initial = snapshot(7, 1);
+    const initialDelta = projection.apply([{ kind: 'create', snapshot: initial }]);
+    const gpu = GpuScene.create(device, 1).unwrap();
+    if (gpu.status !== 'available') throw new Error(gpu.reason);
+    gpu.scene.sync(projection, initialDelta).unwrap();
+    const transaction = temporalTransaction(device);
+
+    const stageGpu = (delta: RenderSceneSubmissionDelta) => gpu.scene.stageSubmitted(delta);
+    const first = submit(transaction, projection, [initial], device, {
+      onSceneSubmitted: stageGpu,
+    });
+    expect(first).toMatchObject({ submitted: true, attempt: { status: 'committed' } });
+    expect(transaction.inspect()).toMatchObject({
+      active: false,
+      temporalFrameIndex: 1,
+      historyDirection: 'b-to-a',
+      historyValid: true,
+    });
+    expect(projection.inspect().lastSubmitted).toMatchObject({ epoch: 1, records: [{ slot: 0 }] });
+
+    for (const stage of ['graph', 'finish', 'submit'] as const) {
+      const current = snapshot(7, stage === 'graph' ? 2 : stage === 'finish' ? 3 : 4);
+      const delta = projection.apply([{ kind: 'create', snapshot: current }]);
+      gpu.scene.sync(projection, delta).unwrap();
+      expect(projection.withTemporal(current).temporal).toMatchObject({
+        previousEpoch: 1,
+        previousSource: 'last-submitted',
+        reactive: false,
+      });
+      expect(latestTransform(queue, gpu.scene.transformBuffer, 'previousWorld')).toBe(1);
+      const failed = submit(transaction, projection, [current], device, {
+        [stage]: 'fail',
+        onSceneSubmitted: stageGpu,
+      });
+      expect(failed).toMatchObject({ submitted: false, attempt: { status: 'aborted' } });
+      expect(transaction.inspect()).toMatchObject({
+        active: false,
+        temporalFrameIndex: 1,
+        historyDirection: 'b-to-a',
+        historyValid: true,
+        lastFailure: {
+          kind: 'submit-abort',
+          stage:
+            stage === 'graph'
+              ? 'graph-execute'
+              : stage === 'finish'
+                ? 'encoder-finish'
+                : 'queue-submit',
+        },
+      });
+      expect(projection.inspect().lastSubmitted).toMatchObject({ epoch: 1 });
+      expect(projection.lastSubmittedSlotByIndex(0)?.snapshot.transform.world[12]).toBe(1);
+    }
+
+    const recovered = snapshot(7, 5);
+    gpu.scene
+      .sync(projection, projection.apply([{ kind: 'create', snapshot: recovered }]))
+      .unwrap();
+    const success = submit(transaction, projection, [recovered], device, {
+      onSceneSubmitted: stageGpu,
+    });
+    expect(success).toMatchObject({ submitted: true, attempt: { status: 'committed' } });
+    expect(transaction.inspect()).toMatchObject({
+      temporalFrameIndex: 2,
+      historyDirection: 'a-to-b',
+      lastFailure: undefined,
+    });
+    expect(projection.inspect().lastSubmitted.epoch).toBe(2);
+    gpu.scene.sync(projection, projection.apply([])).unwrap();
+    expect(latestTransform(queue, gpu.scene.transformBuffer, 'previousWorld')).toBe(5);
+
+    const incomplete = summarizeTemporalCoverage([
+      {
+        identity: 'feature:missing',
+        lane: 'render-feature',
+        coverage: 'missing',
+        reason: 'feature-coverage-undeclared',
+      },
+    ]);
+    const currentOnly = submit(transaction, projection, [recovered], device, {
+      coverage: incomplete,
+      onSceneSubmitted: stageGpu,
+    });
+    expect(currentOnly).toMatchObject({ submitted: true, attempt: { status: 'committed' } });
+    expect(transaction.inspect()).toMatchObject({
+      temporalFrameIndex: 3,
+      historyValid: false,
+      coverage: { complete: false, missing: 1 },
+      history: { resetReason: 'coverage-incomplete' },
+    });
+  });
+
+  it('seeds unstable producers and clears material reactivity after a successful epoch', () => {
+    const queue = new TransactionQueue();
+    const device = new RhiNullDevice(
+      queue,
+      (bookkeeper, owner) => new RhiNullCommandEncoder(bookkeeper, owner),
+    );
+    const projection = new RenderSceneProjection();
+    const transaction = temporalTransaction(device);
+    const initial = snapshot(11, 1, { instanceTranslationX: 10 });
+    projection.apply([{ kind: 'create', snapshot: initial }]);
+    submit(transaction, projection, [initial], device);
+
+    const emissive = snapshot(11, 2, {
+      material: material(1),
+      instanceTranslationX: 20,
+    });
+    projection.apply([{ kind: 'create', snapshot: emissive }]);
+    expect(projection.withTemporal(emissive).temporal).toMatchObject({
+      previousSource: 'current-seed',
+      reactive: true,
+      reactiveReasons: ['material-revision'],
+      previousTransform: { world: emissive.transform.world },
+      previousInstances: { transforms: emissive.instances?.transforms },
+    });
+    submit(transaction, projection, [emissive], device);
+    expect(projection.withTemporal(emissive).temporal).toMatchObject({
+      previousSource: 'last-submitted',
+      reactive: false,
+    });
+
+    const revisedEmissive = snapshot(11, 2, {
+      material: material(2),
+      instanceTranslationX: 20,
+    });
+    projection.apply([{ kind: 'create', snapshot: revisedEmissive }]);
+    expect(projection.withTemporal(revisedEmissive).temporal).toMatchObject({
+      previousSource: 'current-seed',
+      reactive: true,
+      reactiveReasons: ['material-revision'],
+      previousTransform: { world: revisedEmissive.transform.world },
+    });
+    submit(transaction, projection, [revisedEmissive], device);
+    expect(projection.withTemporal(revisedEmissive).temporal).toMatchObject({
+      previousSource: 'last-submitted',
+      reactive: false,
+    });
+
+    const movedInstance = snapshot(11, 2, {
+      material: material(2),
+      instanceTranslationX: 30,
+    });
+    projection.apply([{ kind: 'create', snapshot: movedInstance }]);
+    expect(projection.withTemporal(movedInstance).temporal).toMatchObject({
+      previousSource: 'last-submitted',
+      reactive: false,
+      previousInstances: { transforms: revisedEmissive.instances?.transforms },
+    });
+    submit(transaction, projection, [movedInstance], device);
+
+    submit(transaction, projection, [], device);
+    expect(projection.withTemporal(revisedEmissive).temporal).toMatchObject({
+      previousSource: 'current-seed',
+      reactive: true,
+      reactiveReasons: ['reentered'],
+    });
+
+    projection.apply([{ kind: 'remove', worldId: 0, entityKey: 11 }]);
+    const reused = snapshot(12, 9);
+    projection.apply([{ kind: 'create', snapshot: reused }]);
+    expect(projection.withTemporal(reused).temporal).toMatchObject({
+      previousSource: 'current-seed',
+      reactive: true,
+      reactiveReasons: ['generation-reuse'],
+    });
+
+    const skinned = snapshot(13, 4, { skinBuffer: {} as Buffer });
+    projection.apply([{ kind: 'create', snapshot: skinned }]);
+    expect(projection.withTemporal(skinned).temporal).toMatchObject({
+      previousSource: 'current-seed',
+      reactive: true,
+      reactiveReasons: expect.arrayContaining(['new-slot', 'skinning-deformation']),
+    });
+    submit(transaction, projection, [skinned], device);
+    const posed = snapshot(13, 4, {
+      skinBuffer: {} as Buffer,
+      jointMatrixTranslationX: 2,
+    });
+    projection.apply([{ kind: 'create', snapshot: posed }]);
+    expect(projection.withTemporal(posed).temporal).toMatchObject({
+      previousSource: 'last-submitted',
+      reactive: false,
+      previousSkin: { jointMatrices: skinned.skin?.jointMatrices },
+    });
+
+    const morphed = snapshot(14, 6, { morphWeights: [0.25, 0.75] });
+    projection.apply([{ kind: 'create', snapshot: morphed }]);
+    expect(projection.withTemporal(morphed).temporal).toMatchObject({
+      previousSource: 'current-seed',
+      reactive: true,
+      reactiveReasons: expect.arrayContaining(['new-slot', 'morph-deformation']),
+      previousMorphWeights: morphed.morphWeights,
+    });
+    submit(transaction, projection, [morphed], device);
+    const morphedAgain = snapshot(14, 6, { morphWeights: [0.5, 0.5] });
+    projection.apply([{ kind: 'create', snapshot: morphedAgain }]);
+    expect(projection.withTemporal(morphedAgain).temporal).toMatchObject({
+      previousSource: 'last-submitted',
+      reactive: false,
+      previousMorphWeights: morphed.morphWeights,
+    });
+  });
+});

package/src/__tests__/temporal-inspection.unit.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'vitest';
+import type { TemporalFrameTransactionInspection } from '../temporal-frame-transaction';
+import {
+  projectTemporalInspection,
+  TEMPORAL_INSPECTION_MISSING_ID_LIMIT,
+} from '../temporal-inspection';
+
+function inspection(
+  overrides: Partial<TemporalFrameTransactionInspection> = {},
+): TemporalFrameTransactionInspection {
+  return {
+    active: false,
+    temporalFrameIndex: 0,
+    historyDirection: 'a-to-b',
+    historyValid: false,
+    lastSubmittedView: undefined,
+    history: {
+      enabled: false,
+      ownerGeneration: 0,
+      viewId: undefined,
+      width: 0,
+      height: 0,
+      format: undefined,
+      direction: 'a-to-b',
+      valid: false,
+      resetReason: undefined,
+      historyBytes: 0,
+      retiringGenerations: 0,
+    },
+    coverage: {
+      complete: true,
+      exact: 0,
+      reactive: 0,
+      missing: 0,
+      missingContributors: [],
+      contributors: [],
+    },
+    lastResetReason: undefined,
+    lastJitter: undefined,
+    lastFailure: undefined,
+    ...overrides,
+  };
+}
+
+describe('temporal inspection projection', () => {
+  it('projects the disabled path as bounded handle-free POD', () => {
+    expect(projectTemporalInspection(inspection())).toMatchObject({
+      enabled: false,
+      status: 'off',
+      recovery: 'none',
+      historyBytes: 0,
+      failure: undefined,
+    });
+  });
+
+  it('bounds missing contributor identities and preserves the omitted count', () => {
+    const missing = Array.from(
+      { length: TEMPORAL_INSPECTION_MISSING_ID_LIMIT + 5 },
+      (_, index) => `producer-${index}`,
+    );
+    const projected = projectTemporalInspection(
+      inspection({
+        history: {
+          ...inspection().history,
+          enabled: true,
+          ownerGeneration: 3,
+          historyBytes: 4096,
+        },
+        coverage: {
+          complete: false,
+          exact: 2,
+          reactive: 1,
+          missing: missing.length,
+          missingContributors: missing,
+          contributors: [],
+        },
+      }),
+    );
+    expect(projected).toMatchObject({
+      status: 'coverage-incomplete',
+      recovery: 'complete-temporal-coverage',
+      historyOwnerGeneration: 3,
+      historyBytes: 4096,
+    });
+    expect(projected.coverage.missingContributorIds).toHaveLength(
+      TEMPORAL_INSPECTION_MISSING_ID_LIMIT,
+    );
+    expect(projected.coverage.omittedMissingContributorIds).toBe(5);
+    expect(JSON.stringify(projected)).not.toContain('contributors');
+    expect(projected.coverage.lanes).toHaveLength(10);
+    expect(
+      projected.coverage.lanes.every((lane) => lane.exact + lane.reactive + lane.missing === 0),
+    ).toBe(true);
+  });
+
+  it('projects the closed producer roster without contributor identities', () => {
+    const projected = projectTemporalInspection(
+      inspection({
+        coverage: {
+          complete: true,
+          exact: 1,
+          reactive: 1,
+          missing: 0,
+          missingContributors: [],
+          contributors: [
+            { identity: 'scene:1', lane: 'rigid', coverage: 'exact', previous: 'last-submitted' },
+            {
+              identity: 'feature:vfx',
+              lane: 'vfx',
+              coverage: 'reactive',
+              reason: 'producer-reactive-fallback',
+            },
+          ],
+        },
+      }),
+    );
+    expect(projected.coverage.lanes.find((lane) => lane.lane === 'rigid')).toMatchObject({
+      exact: 1,
+      reactive: 0,
+      missing: 0,
+    });
+    expect(projected.coverage.lanes.find((lane) => lane.lane === 'vfx')).toMatchObject({
+      exact: 0,
+      reactive: 1,
+      missing: 0,
+    });
+    expect(JSON.stringify(projected)).not.toContain('scene:1');
+  });
+
+  it.each([
+    [{ kind: 'capability', code: 'taa-caps-insufficient' }, 'capability-failure'],
+    [{ kind: 'pipeline', code: 'temporal-unsupported' }, 'pipeline-failure'],
+    [{ kind: 'submit-abort', stage: 'queue-submit' }, 'submit-abort'],
+    [{ kind: 'device-recovery', code: 'device-recovery' }, 'device-recovery'],
+  ] as const)('projects %o as %s', (failure, status) => {
+    expect(projectTemporalInspection(inspection({ lastFailure: failure })).status).toBe(status);
+  });
+});