@forgeax/engine-render 0.1.4 → 0.1.6

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

@@ -1,537 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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);
-  });
-});