import { AtomRegistry } from "effect/unstable/reactivity";import { afterEach, describe, expect, it, vi } from "vitest"; import {  EventId,  MessageId,  ProjectId,  ThreadId,  TurnId,  type OrchestrationThread,  type OrchestrationThreadStreamItem,} from "@t3tools/contracts"; import { createThreadDetailManager, type ThreadDetailClient } from "./threadDetailState"; let atomRegistry = AtomRegistry.make(); function resetAtomRegistry() {  atomRegistry.dispose();  atomRegistry = AtomRegistry.make();} function registerListener<T>(listeners: Set<(event: T) => void>, listener: (event: T) => void) {  listeners.add(listener);  return () => {    listeners.delete(listener);  };} const baseEventFields = {  eventId: EventId.make("event-1"),  commandId: null,  causationEventId: null,  correlationId: null,  metadata: {},} as const; const BASE_THREAD: OrchestrationThread = {  id: ThreadId.make("thread-1"),  projectId: ProjectId.make("project-1"),  title: "Test Thread",  modelSelection: { provider: "codex", model: "gpt-5.4" },  runtimeMode: "full-access",  interactionMode: "default",  branch: null,  worktreePath: null,  latestTurn: null,  createdAt: "2026-04-01T00:00:00.000Z",  updatedAt: "2026-04-01T00:00:00.000Z",  archivedAt: null,  deletedAt: null,  messages: [],  proposedPlans: [],  activities: [],  checkpoints: [],  session: null,}; const TARGET = { environmentId: "env-local", threadId: "thread-1" } as const; function createMockClient(): {  client: ThreadDetailClient;  listeners: Set<(event: OrchestrationThreadStreamItem) => void>;  emit: (event: OrchestrationThreadStreamItem) => void;} {  const listeners = new Set<(event: OrchestrationThreadStreamItem) => void>();  const client: ThreadDetailClient = {    subscribeThread: vi.fn((_input, listener: (event: OrchestrationThreadStreamItem) => void) =>      registerListener(listeners, listener),    ),  };   return {    client,    listeners,    emit: (event) => {      for (const listener of listeners) {        listener(event);      }    },  };} describe("createThreadDetailManager", () => {  afterEach(() => {    vi.useRealTimers();    resetAtomRegistry();  });   it("starts in a pending state when watching", () => {    const { client } = createMockClient();    const manager = createThreadDetailManager({      getRegistry: () => atomRegistry,      getClient: () => null,    });     manager.watch(TARGET, client);     expect(manager.getSnapshot(TARGET)).toEqual({      data: null,      error: null,      isPending: true,      isDeleted: false,    });  });   it("applies snapshots and incremental events", () => {    const { client, emit } = createMockClient();    const manager = createThreadDetailManager({      getRegistry: () => atomRegistry,      getClient: () => null,    });     const release = manager.watch(TARGET, client);     emit({      kind: "snapshot",      snapshot: {        snapshotSequence: 1,        thread: BASE_THREAD,      },    });     emit({      kind: "event",      event: {        ...baseEventFields,        sequence: 2,        occurredAt: "2026-04-01T01:00:00.000Z",        aggregateKind: "thread",        aggregateId: ThreadId.make("thread-1"),        type: "thread.message-sent",        payload: {          threadId: ThreadId.make("thread-1"),          turnId: TurnId.make("turn-1"),          messageId: MessageId.make("message-1"),          role: "assistant",          text: "hello",          streaming: false,          createdAt: "2026-04-01T01:00:00.000Z",          updatedAt: "2026-04-01T01:00:00.000Z",        },      } as any,    });     expect(manager.getSnapshot(TARGET)).toEqual({      data: {        ...BASE_THREAD,        updatedAt: "2026-04-01T01:00:00.000Z",        latestTurn: {          turnId: TurnId.make("turn-1"),          state: "completed",          requestedAt: "2026-04-01T01:00:00.000Z",          startedAt: "2026-04-01T01:00:00.000Z",          completedAt: "2026-04-01T01:00:00.000Z",          assistantMessageId: MessageId.make("message-1"),        },        messages: [          {            id: MessageId.make("message-1"),            role: "assistant",            text: "hello",            turnId: TurnId.make("turn-1"),            streaming: false,            createdAt: "2026-04-01T01:00:00.000Z",            updatedAt: "2026-04-01T01:00:00.000Z",          },        ],      },      error: null,      isPending: false,      isDeleted: false,    });     release();  });   it("marks threads as deleted when the stream deletes them", () => {    const { client, emit } = createMockClient();    const manager = createThreadDetailManager({      getRegistry: () => atomRegistry,      getClient: () => null,    });     const release = manager.watch(TARGET, client);     emit({      kind: "snapshot",      snapshot: {        snapshotSequence: 1,        thread: BASE_THREAD,      },    });    emit({      kind: "event",      event: {        ...baseEventFields,        sequence: 3,        occurredAt: "2026-04-01T01:10:00.000Z",        aggregateKind: "thread",        aggregateId: ThreadId.make("thread-1"),        type: "thread.deleted",        payload: {          threadId: ThreadId.make("thread-1"),          deletedAt: "2026-04-01T01:10:00.000Z",        },      } as any,    });     expect(manager.getSnapshot(TARGET)).toEqual({      data: null,      error: null,      isPending: false,      isDeleted: true,    });     release();  });   it("waits for delayed client registration when subscribeClientChanges is configured", () => {    const connectionListeners = new Set<() => void>();    const clients = new Map<string, ReturnType<typeof createMockClient>>();    const manager = createThreadDetailManager({      getRegistry: () => atomRegistry,      getClient: (environmentId) => clients.get(environmentId)?.client ?? null,      getClientIdentity: (environmentId) => (clients.has(environmentId) ? environmentId : null),      subscribeClientChanges: (listener) => {        connectionListeners.add(listener);        return () => connectionListeners.delete(listener);      },    });     const release = manager.watch(TARGET);    expect(manager.getSnapshot(TARGET).isPending).toBe(true);     const mock = createMockClient();    clients.set("env-local", mock);    for (const listener of connectionListeners) {      listener();    }     mock.emit({      kind: "snapshot",      snapshot: {        snapshotSequence: 1,        thread: BASE_THREAD,      },    });     expect(manager.getSnapshot(TARGET).data?.id).toBe(ThreadId.make("thread-1"));     release();  });   it("evicts idle subscriptions after the configured ttl", () => {    vi.useFakeTimers();    const mock = createMockClient();    const manager = createThreadDetailManager({      getRegistry: () => atomRegistry,      getClient: () => mock.client,      retention: {        idleTtlMs: 60_000,        maxRetainedEntries: 10,      },    });     const release = manager.watch(TARGET);    expect(mock.listeners.size).toBe(1);     release();    expect(mock.listeners.size).toBe(1);     vi.advanceTimersByTime(60_000);    expect(mock.listeners.size).toBe(0);  });   it("keeps non-idle threads warm when the retention policy says to", () => {    vi.useFakeTimers();    const mock = createMockClient();    const manager = createThreadDetailManager({      getRegistry: () => atomRegistry,      getClient: () => mock.client,      retention: {        idleTtlMs: 60_000,        maxRetainedEntries: 10,        shouldKeepWarm: (_target, state) => state.data?.session?.status === "running",      },    });     const release = manager.watch(TARGET);    mock.emit({      kind: "snapshot",      snapshot: {        snapshotSequence: 1,        thread: {          ...BASE_THREAD,          session: {            threadId: ThreadId.make("thread-1"),            status: "running",            providerName: "codex",            runtimeMode: "full-access",            activeTurnId: TurnId.make("turn-1"),            lastError: null,            updatedAt: "2026-04-01T00:10:00.000Z",          },        },      },    });     release();    vi.advanceTimersByTime(60_000);     expect(mock.listeners.size).toBe(1);    manager.reset();    expect(mock.listeners.size).toBe(0);  });});