import { EnvironmentId, ThreadId, type OrchestrationGetTurnDiffResult } from "@t3tools/contracts";import { AtomRegistry } from "effect/unstable/reactivity";import { afterEach, describe, expect, it, vi } from "vite-plus/test"; import {  type CheckpointDiffClient,  createCheckpointDiffManager,  EMPTY_CHECKPOINT_DIFF_STATE,  getCheckpointDiffTargetKey,} from "./checkpointDiffState.ts"; let registry = AtomRegistry.make(); function resetAtomRegistry() {  registry.dispose();  registry = AtomRegistry.make();} const TARGET = {  environmentId: EnvironmentId.make("env-local"),  threadId: ThreadId.make("thread-1"),  fromTurnCount: 1,  toTurnCount: 2,  ignoreWhitespace: false,}; const PATCH_RESULT: OrchestrationGetTurnDiffResult = {  threadId: TARGET.threadId,  diff: "patch",  fromTurnCount: 1,  toTurnCount: 2,}; function createClient() {  return {    getTurnDiff: vi.fn(async () => PATCH_RESULT),    getFullThreadDiff: vi.fn(async () => PATCH_RESULT),  } satisfies CheckpointDiffClient;} describe("createCheckpointDiffManager", () => {  afterEach(() => {    resetAtomRegistry();  });   it("loads a turn checkpoint diff into atom state", async () => {    const client = createClient();    const manager = createCheckpointDiffManager({      getRegistry: () => registry,      getClient: () => client,    });     await expect(manager.load(TARGET)).resolves.toEqual(PATCH_RESULT);     expect(client.getTurnDiff).toHaveBeenCalledWith({      threadId: TARGET.threadId,      fromTurnCount: 1,      toTurnCount: 2,      ignoreWhitespace: false,    });    expect(client.getFullThreadDiff).not.toHaveBeenCalled();    expect(manager.getSnapshot(TARGET)).toEqual({      data: PATCH_RESULT,      error: null,      isPending: false,    });  });   it("loads a full thread diff when the range starts at zero", async () => {    const client = createClient();    const manager = createCheckpointDiffManager({      getRegistry: () => registry,      getClient: () => client,    });     await manager.load({ ...TARGET, fromTurnCount: 0 });     expect(client.getFullThreadDiff).toHaveBeenCalledWith({      threadId: TARGET.threadId,      toTurnCount: 2,      ignoreWhitespace: false,    });    expect(client.getTurnDiff).not.toHaveBeenCalled();  });   it("returns empty state for invalid targets", () => {    const manager = createCheckpointDiffManager({      getRegistry: () => registry,      getClient: () => createClient(),    });     expect(manager.getSnapshot({ ...TARGET, threadId: null })).toBe(EMPTY_CHECKPOINT_DIFF_STATE);    expect(getCheckpointDiffTargetKey({ ...TARGET, threadId: null })).toBeNull();  });   it("deduplicates in-flight requests and reuses successful cached data", async () => {    const client = createClient();    const manager = createCheckpointDiffManager({      getRegistry: () => registry,      getClient: () => client,    });     const first = manager.load(TARGET);    const second = manager.load(TARGET);     expect(first).toBe(second);    await first;    await manager.load(TARGET);     expect(client.getTurnDiff).toHaveBeenCalledTimes(1);  });   it("retries temporarily unavailable checkpoint diffs", async () => {    let attempts = 0;    const client = {      getFullThreadDiff: vi.fn(async () => PATCH_RESULT),      getTurnDiff: vi.fn(async () => {        attempts += 1;        if (attempts < 3) {          throw new Error("checkpoint is unavailable for turn");        }        return PATCH_RESULT;      }),    } satisfies CheckpointDiffClient;    const manager = createCheckpointDiffManager({      getRegistry: () => registry,      getClient: () => client,      retryDelay: async () => undefined,    });     await expect(manager.load(TARGET)).resolves.toEqual(PATCH_RESULT);     expect(client.getTurnDiff).toHaveBeenCalledTimes(3);  });});