import { CommandId, EnvironmentId, MessageId, ProjectId, ThreadId } from "@t3tools/contracts";import { afterEach, describe, expect, it, vi } from "vite-plus/test"; const harness = vi.hoisted(() => ({  cleanup: vi.fn(),  clearDraft: vi.fn<typeof import("./use-composer-drafts").clearComposerDraft>(),  flushDrafts: vi.fn<typeof import("./use-composer-drafts").flushComposerDrafts>(async () => {}),  waitForDrafts: vi.fn<typeof import("./use-composer-drafts").waitForComposerDraftsLoaded>(    async () => {},  ),  manager: null as unknown as ReturnType<    typeof import("./thread-outbox-manager").createThreadOutboxManager  >,})); vi.mock("./thread-outbox", async () => {  const { createThreadOutboxManager } = await import("./thread-outbox-manager");  const { appAtomRegistry } = await import("./atom-registry");  harness.manager = createThreadOutboxManager({    registry: appAtomRegistry,    storage: {      load: async () => ({ messages: [], errors: [] }),      write: async () => undefined,      remove: async () => undefined,    },  });  return { threadOutboxManager: harness.manager };}); vi.mock("./use-composer-drafts", async (importOriginal) => {  const original = await importOriginal<typeof import("./use-composer-drafts")>();  return {    ...original,    clearComposerDraft: harness.clearDraft,    flushComposerDrafts: harness.flushDrafts,    scheduleUnusedComposerAttachmentCleanup: harness.cleanup,    waitForComposerDraftsLoaded: harness.waitForDrafts,  };}); import { appAtomRegistry } from "./atom-registry";import { clearThreadOutboxEnvironment, removeThreadOutboxMessage } from "./thread-outbox-removal";import type { QueuedThreadMessage } from "./thread-outbox-model";import { composerDraftsAtom } from "./use-composer-drafts"; function queuedMessage(input: {  readonly environmentId: string;  readonly messageId: string;  readonly fileUri: string;  readonly creation?: true;}): QueuedThreadMessage {  return {    environmentId: EnvironmentId.make(input.environmentId),    threadId: ThreadId.make(`thread-${input.messageId}`),    messageId: MessageId.make(input.messageId),    commandId: CommandId.make(`command-${input.messageId}`),    text: "Review the report",    attachments: [      {        id: `file-${input.messageId}`,        type: "file",        name: "report.pdf",        mimeType: "application/pdf",        sizeBytes: 42,        fileUri: input.fileUri,      },    ],    ...(input.creation      ? {          creation: {            projectId: ProjectId.make(`project-${input.messageId}`),            workspaceMode: "local" as const,            branch: null,            worktreePath: null,          },        }      : {}),    createdAt: "2026-08-24T12:00:00.000Z",  };} afterEach(() => {  appAtomRegistry.set(harness.manager.queuedMessagesByThreadKeyAtom, {});  appAtomRegistry.set(composerDraftsAtom, {});  harness.cleanup.mockClear();  harness.clearDraft.mockClear();  harness.flushDrafts.mockReset();  harness.flushDrafts.mockResolvedValue(undefined);  harness.waitForDrafts.mockReset();  harness.waitForDrafts.mockResolvedValue(undefined);}); describe("thread outbox removal", () => {  it("releases a removed message's attachment files with the removal itself", async () => {    const message = queuedMessage({      environmentId: "environment-1",      messageId: "message-1",      fileUri: "file:///documents/t3-composer-attachments/report.pdf",    });    await harness.manager.enqueue(message);     await removeThreadOutboxMessage(message);     expect(appAtomRegistry.get(harness.manager.queuedMessagesByThreadKeyAtom)).toEqual({});    expect(harness.cleanup).toHaveBeenCalledExactlyOnceWith(message.attachments);  });   it("keeps an edited message and its files when a revision-checked removal loses", async () => {    const message = queuedMessage({      environmentId: "environment-1",      messageId: "message-edited",      fileUri: "file:///documents/t3-composer-attachments/report.pdf",      creation: true,    });    await harness.manager.enqueue(message);    const revision = harness.manager.revisionOf(message.messageId);    const edited = { ...message, text: "edited while restoring" };    await harness.manager.update(edited);     await expect(removeThreadOutboxMessage(message, revision)).resolves.toBe(false);     expect(harness.cleanup).not.toHaveBeenCalled();    expect(harness.waitForDrafts).not.toHaveBeenCalled();    expect(harness.clearDraft).not.toHaveBeenCalled();    expect(harness.flushDrafts).not.toHaveBeenCalled();    const remaining = Object.values(      appAtomRegistry.get(harness.manager.queuedMessagesByThreadKeyAtom),    ).flat();    expect(remaining).toEqual([edited]);  });   it("clears a removed pending task draft and includes its editor-only files", async () => {    const message = queuedMessage({      environmentId: "environment-1",      messageId: "message-pending",      fileUri: "file:///documents/t3-composer-attachments/queued.pdf",      creation: true,    });    const editorOnlyFile = {      id: "file-editor-only",      type: "file" as const,      name: "editor-only.pdf",      mimeType: "application/pdf",      sizeBytes: 84,      fileUri: "file:///documents/t3-composer-attachments/editor-only.pdf",    };    const draftKey = `pending-task:${message.messageId}`;    appAtomRegistry.set(composerDraftsAtom, {      [draftKey]: { text: "edited", attachments: [editorOnlyFile] },    });    await harness.manager.enqueue(message);     await expect(removeThreadOutboxMessage(message)).resolves.toBe(true);     expect(harness.waitForDrafts).toHaveBeenCalledOnce();    expect(harness.clearDraft).toHaveBeenCalledExactlyOnceWith(draftKey, {      deferAttachmentCleanup: true,    });    expect(harness.flushDrafts).toHaveBeenCalledOnce();    expect(harness.cleanup).toHaveBeenCalledExactlyOnceWith([      ...message.attachments,      editorOnlyFile,    ]);    expect(harness.flushDrafts.mock.invocationCallOrder[0]).toBeLessThan(      harness.cleanup.mock.invocationCallOrder[0]!,    );  });   it("does not flush composer drafts when a removed creation has no editor draft", async () => {    const message = queuedMessage({      environmentId: "environment-1",      messageId: "message-without-editor-draft",      fileUri: "file:///documents/t3-composer-attachments/queued.pdf",      creation: true,    });    await harness.manager.enqueue(message);     await expect(removeThreadOutboxMessage(message)).resolves.toBe(true);     expect(harness.waitForDrafts).toHaveBeenCalledOnce();    expect(harness.clearDraft).not.toHaveBeenCalled();    expect(harness.flushDrafts).not.toHaveBeenCalled();    expect(harness.cleanup).toHaveBeenCalledExactlyOnceWith(message.attachments);  });   it("releases only the cleared environment's queued attachment files", async () => {    const cleared = queuedMessage({      environmentId: "environment-1",      messageId: "message-cleared",      fileUri: "file:///documents/t3-composer-attachments/cleared.pdf",    });    const kept = queuedMessage({      environmentId: "environment-2",      messageId: "message-kept",      fileUri: "file:///documents/t3-composer-attachments/kept.pdf",    });    await harness.manager.enqueue(cleared);    await harness.manager.enqueue(kept);     await clearThreadOutboxEnvironment(cleared.environmentId);     expect(harness.cleanup).toHaveBeenCalledExactlyOnceWith(cleared.attachments);    const remaining = Object.values(      appAtomRegistry.get(harness.manager.queuedMessagesByThreadKeyAtom),    ).flat();    expect(remaining.map((message) => message.messageId)).toEqual([kept.messageId]);  });   it("clears only removed pending drafts and keeps drafts for live messages", async () => {    const cleared = queuedMessage({      environmentId: "environment-1",      messageId: "message-cleared-pending",      fileUri: "file:///documents/t3-composer-attachments/cleared-pending.pdf",      creation: true,    });    const replaced = queuedMessage({      environmentId: "environment-1",      messageId: "message-replaced-pending",      fileUri: "file:///documents/t3-composer-attachments/replaced-pending.pdf",      creation: true,    });    const kept = queuedMessage({      environmentId: "environment-2",      messageId: "message-kept-pending",      fileUri: "file:///documents/t3-composer-attachments/kept-pending.pdf",      creation: true,    });    const replacement = { ...replaced, text: "replacement queued while drafts hydrate" };    const editorOnlyFile = {      id: "file-cleared-editor",      type: "file" as const,      name: "cleared-editor.pdf",      mimeType: "application/pdf",      sizeBytes: 84,      fileUri: "file:///documents/t3-composer-attachments/cleared-editor.pdf",    };    const hydrationStarted = Promise.withResolvers<void>();    const hydrationBarrier = Promise.withResolvers<void>();    harness.waitForDrafts.mockImplementationOnce(async () => {      hydrationStarted.resolve();      await hydrationBarrier.promise;    });    const clearedDraftKey = `pending-task:${cleared.messageId}`;    appAtomRegistry.set(composerDraftsAtom, {      [clearedDraftKey]: { text: "edited", attachments: [editorOnlyFile] },      [`pending-task:${replaced.messageId}`]: { text: "replacement", attachments: [] },      [`pending-task:${kept.messageId}`]: { text: "other environment", attachments: [] },    });    await Promise.all([      harness.manager.enqueue(cleared),      harness.manager.enqueue(replaced),      harness.manager.enqueue(kept),    ]);     const clearing = clearThreadOutboxEnvironment(cleared.environmentId);    await hydrationStarted.promise;    const replacing = harness.manager.enqueue(replacement);    hydrationBarrier.resolve();    await clearing;    await replacing;     expect(harness.clearDraft).toHaveBeenCalledExactlyOnceWith(clearedDraftKey, {      deferAttachmentCleanup: true,    });    expect(harness.cleanup).toHaveBeenCalledExactlyOnceWith([      ...cleared.attachments,      ...replaced.attachments,      editorOnlyFile,    ]);    const remaining = Object.values(      appAtomRegistry.get(harness.manager.queuedMessagesByThreadKeyAtom),    ).flat();    expect(remaining).toEqual(expect.arrayContaining([replacement, kept]));  });   it("keeps removal successful when pending draft persistence fails", async () => {    const message = queuedMessage({      environmentId: "environment-1",      messageId: "message-draft-flush-fails",      fileUri: "file:///documents/t3-composer-attachments/queued.pdf",      creation: true,    });    const flushError = new Error("composer storage unavailable");    const warning = vi.spyOn(console, "warn").mockImplementation(() => {});    harness.flushDrafts.mockRejectedValueOnce(flushError);    appAtomRegistry.set(composerDraftsAtom, {      [`pending-task:${message.messageId}`]: { text: "edited", attachments: [] },    });    await harness.manager.enqueue(message);     try {      await expect(removeThreadOutboxMessage(message)).resolves.toBe(true);       expect(harness.clearDraft).toHaveBeenCalledOnce();      expect(harness.cleanup).not.toHaveBeenCalled();      expect(warning).toHaveBeenCalledWith(        "[thread-outbox] failed to clean up removed pending task drafts",        flushError,      );      expect(appAtomRegistry.get(harness.manager.queuedMessagesByThreadKeyAtom)).toEqual({});    } finally {      warning.mockRestore();    }  });});