import { describe, expect, it } from "vite-plus/test"; import {  createOrchestrationRecoveryCoordinator,  deriveReplayRetryDecision,} from "./orchestrationRecovery"; describe("createOrchestrationRecoveryCoordinator", () => {  it("defers live events until bootstrap completes and then requests replay", () => {    const coordinator = createOrchestrationRecoveryCoordinator();     expect(coordinator.beginSnapshotRecovery("bootstrap")).toBe(true);    expect(coordinator.classifyDomainEvent(4)).toBe("defer");     expect(coordinator.completeSnapshotRecovery(2)).toBe(true);    expect(coordinator.getState()).toMatchObject({      latestSequence: 2,      highestObservedSequence: 4,      bootstrapped: true,      pendingReplay: false,      inFlight: null,    });  });   it("classifies sequence gaps as recovery-only replay work", () => {    const coordinator = createOrchestrationRecoveryCoordinator();     coordinator.beginSnapshotRecovery("bootstrap");    coordinator.completeSnapshotRecovery(3);     expect(coordinator.classifyDomainEvent(5)).toBe("recover");    expect(coordinator.beginReplayRecovery("sequence-gap")).toBe(true);    expect(coordinator.getState().inFlight).toEqual({      kind: "replay",      reason: "sequence-gap",    });  });   it("tracks live event batches without entering recovery", () => {    const coordinator = createOrchestrationRecoveryCoordinator();     coordinator.beginSnapshotRecovery("bootstrap");    coordinator.completeSnapshotRecovery(3);     expect(coordinator.classifyDomainEvent(4)).toBe("apply");    expect(coordinator.markEventBatchApplied([{ sequence: 4 }])).toEqual([{ sequence: 4 }]);    expect(coordinator.getState()).toMatchObject({      latestSequence: 4,      highestObservedSequence: 4,      bootstrapped: true,      inFlight: null,    });  });   it("requests another replay when deferred events arrive during replay recovery", () => {    const coordinator = createOrchestrationRecoveryCoordinator();     coordinator.beginSnapshotRecovery("bootstrap");    coordinator.completeSnapshotRecovery(3);    coordinator.classifyDomainEvent(5);    coordinator.beginReplayRecovery("sequence-gap");    coordinator.classifyDomainEvent(7);    coordinator.markEventBatchApplied([{ sequence: 4 }, { sequence: 5 }, { sequence: 6 }]);     expect(coordinator.completeReplayRecovery()).toEqual({      replayMadeProgress: true,      shouldReplay: true,    });  });   it("retries replay when no progress was made but higher live sequences were observed", () => {    const coordinator = createOrchestrationRecoveryCoordinator();     coordinator.beginSnapshotRecovery("bootstrap");    coordinator.completeSnapshotRecovery(3);    coordinator.classifyDomainEvent(5);    coordinator.beginReplayRecovery("sequence-gap");     expect(coordinator.completeReplayRecovery()).toEqual({      replayMadeProgress: false,      shouldReplay: true,    });    expect(coordinator.getState()).toMatchObject({      latestSequence: 3,      highestObservedSequence: 5,      pendingReplay: false,      inFlight: null,    });  });   it("does not request another replay when a replay made no progress and nothing newer was observed", () => {    const coordinator = createOrchestrationRecoveryCoordinator();     coordinator.beginSnapshotRecovery("bootstrap");    coordinator.completeSnapshotRecovery(3);    coordinator.beginReplayRecovery("sequence-gap");     expect(coordinator.completeReplayRecovery()).toEqual({      replayMadeProgress: false,      shouldReplay: false,    });  });   it("marks replay failure as unbootstrapped so snapshot fallback is recovery-only", () => {    const coordinator = createOrchestrationRecoveryCoordinator();     coordinator.beginSnapshotRecovery("bootstrap");    coordinator.completeSnapshotRecovery(3);    coordinator.beginReplayRecovery("sequence-gap");    coordinator.failReplayRecovery();     expect(coordinator.getState()).toMatchObject({      bootstrapped: false,      inFlight: null,    });    expect(coordinator.beginSnapshotRecovery("replay-failed")).toBe(true);    expect(coordinator.getState().inFlight).toEqual({      kind: "snapshot",      reason: "replay-failed",    });  });   it("keeps enough state to explain why bootstrap snapshot recovery requests replay", () => {    const coordinator = createOrchestrationRecoveryCoordinator();     expect(coordinator.beginSnapshotRecovery("bootstrap")).toBe(true);    expect(coordinator.classifyDomainEvent(4)).toBe("defer");    expect(coordinator.completeSnapshotRecovery(2)).toBe(true);     expect(coordinator.getState()).toMatchObject({      latestSequence: 2,      highestObservedSequence: 4,      bootstrapped: true,      pendingReplay: false,      inFlight: null,    });  });   it("reports skip state when snapshot recovery is requested while replay is in flight", () => {    const coordinator = createOrchestrationRecoveryCoordinator();     coordinator.beginSnapshotRecovery("bootstrap");    coordinator.completeSnapshotRecovery(3);    expect(coordinator.beginReplayRecovery("sequence-gap")).toBe(true);     expect(coordinator.beginSnapshotRecovery("bootstrap")).toBe(false);    expect(coordinator.getState()).toMatchObject({      pendingReplay: true,      inFlight: {        kind: "replay",        reason: "sequence-gap",      },    });  });}); describe("deriveReplayRetryDecision", () => {  it("retries immediately when replay made progress", () => {    expect(      deriveReplayRetryDecision({        previousTracker: {          attempts: 2,          latestSequence: 3,          highestObservedSequence: 5,        },        completion: {          replayMadeProgress: true,          shouldReplay: true,        },        recoveryState: {          latestSequence: 5,          highestObservedSequence: 5,        },        baseDelayMs: 100,        maxNoProgressRetries: 3,      }),    ).toEqual({      shouldRetry: true,      delayMs: 0,      tracker: null,    });  });   it("caps no-progress retries for the same frontier", () => {    const first = deriveReplayRetryDecision({      previousTracker: null,      completion: {        replayMadeProgress: false,        shouldReplay: true,      },      recoveryState: {        latestSequence: 3,        highestObservedSequence: 5,      },      baseDelayMs: 100,      maxNoProgressRetries: 3,    });     const second = deriveReplayRetryDecision({      previousTracker: first.tracker,      completion: {        replayMadeProgress: false,        shouldReplay: true,      },      recoveryState: {        latestSequence: 3,        highestObservedSequence: 5,      },      baseDelayMs: 100,      maxNoProgressRetries: 3,    });     const third = deriveReplayRetryDecision({      previousTracker: second.tracker,      completion: {        replayMadeProgress: false,        shouldReplay: true,      },      recoveryState: {        latestSequence: 3,        highestObservedSequence: 5,      },      baseDelayMs: 100,      maxNoProgressRetries: 3,    });     const fourth = deriveReplayRetryDecision({      previousTracker: third.tracker,      completion: {        replayMadeProgress: false,        shouldReplay: true,      },      recoveryState: {        latestSequence: 3,        highestObservedSequence: 5,      },      baseDelayMs: 100,      maxNoProgressRetries: 3,    });     expect(first).toEqual({      shouldRetry: true,      delayMs: 100,      tracker: {        attempts: 1,        latestSequence: 3,        highestObservedSequence: 5,      },    });    expect(second).toEqual({      shouldRetry: true,      delayMs: 200,      tracker: {        attempts: 2,        latestSequence: 3,        highestObservedSequence: 5,      },    });    expect(third).toEqual({      shouldRetry: true,      delayMs: 400,      tracker: {        attempts: 3,        latestSequence: 3,        highestObservedSequence: 5,      },    });    expect(fourth).toEqual({      shouldRetry: false,      delayMs: 0,      tracker: null,    });  });   it("resets the retry budget when the replay frontier changes", () => {    const exhausted = {      attempts: 3,      latestSequence: 3,      highestObservedSequence: 5,    };     expect(      deriveReplayRetryDecision({        previousTracker: exhausted,        completion: {          replayMadeProgress: false,          shouldReplay: true,        },        recoveryState: {          latestSequence: 3,          highestObservedSequence: 6,        },        baseDelayMs: 100,        maxNoProgressRetries: 3,      }),    ).toEqual({      shouldRetry: true,      delayMs: 100,      tracker: {        attempts: 1,        latestSequence: 3,        highestObservedSequence: 6,      },    });  });});