import { describe, expect, it } from "@effect/vitest";import {  EnvironmentId,  PROVIDER_SEND_TURN_MAX_FILE_BYTES,  type AttachmentCreateUploadUrlInput,  type AttachmentCreateUploadUrlResult,  type AttachmentDeleteInput,} from "@t3tools/contracts";import * as Effect from "effect/Effect";import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity"; import type { AtomCommand } from "./runtime.ts";import {  clampFileAttachmentUploadBytes,  fileAttachmentTooLargeMessage,  formatAttachmentSize,  runAttachmentUploadCycle,  verifyPersistedAttachmentUpload,} from "./attachments.ts"; const environmentId = EnvironmentId.make("environment-1");// The cycle threads the registry through to the commands untouched, so the// fakes below can ignore it.const registry = {} as AtomRegistry.AtomRegistry; type CreateUploadUrlCommand = AtomCommand<  { readonly environmentId: EnvironmentId; readonly input: AttachmentCreateUploadUrlInput },  AttachmentCreateUploadUrlResult,  never>; type RemoveCommand = AtomCommand<  { readonly environmentId: EnvironmentId; readonly input: AttachmentDeleteInput },  unknown,  never>; function makeCreateUploadUrl(attachmentId: string): CreateUploadUrlCommand {  return {    label: "test:create-upload-url",    run: async () =>      AsyncResult.success<AttachmentCreateUploadUrlResult, never>({        attachmentId,        relativeUrl: `/api/attachments/upload/${attachmentId}`,        expiresAt: 1,      }),  };} const removeCalls: string[] = [];const remove: RemoveCommand = {  label: "test:remove",  run: async (_registry, input) => {    removeCalls.push(input.input.attachmentId);    return AsyncResult.success(undefined);  },}; const uploadInput: AttachmentCreateUploadUrlInput = {  type: "file",  name: "report.pdf",  mimeType: "application/pdf",  sizeBytes: 3,}; describe("runAttachmentUploadCycle", () => {  it("mints, transfers, and reports the attachment id", async () => {    const transferred: string[] = [];    const result = await runAttachmentUploadCycle({      registry,      createUploadUrl: makeCreateUploadUrl("pending-1"),      remove,      environmentId,      upload: uploadInput,      resolveUploadUrl: (relativeUrl) => `https://environment.test${relativeUrl}`,      transport: (url) => {        transferred.push(url);        return { done: Promise.resolve(), abort: () => {} };      },    });     expect(result).toEqual({ status: "uploaded", attachmentId: "pending-1" });    expect(transferred).toEqual(["https://environment.test/api/attachments/upload/pending-1"]);  });   it("deletes the fresh mint when the caller cancels at onMinted", async () => {    removeCalls.length = 0;    const result = await runAttachmentUploadCycle({      registry,      createUploadUrl: makeCreateUploadUrl("pending-cancelled"),      remove,      environmentId,      upload: uploadInput,      resolveUploadUrl: () => "https://environment.test/upload",      transport: () => {        throw new Error("transport must not run after cancel");      },      onMinted: () => "cancel",    });     expect(result).toEqual({ status: "cancelled", attachmentId: "pending-cancelled" });    expect(removeCalls).toEqual(["pending-cancelled"]);  });   it("keeps the minted id on transfer failure so the caller can retry or release", async () => {    removeCalls.length = 0;    const result = await runAttachmentUploadCycle({      registry,      createUploadUrl: makeCreateUploadUrl("pending-failed"),      remove,      environmentId,      upload: uploadInput,      resolveUploadUrl: () => "https://environment.test/upload",      transport: () => ({        done: Promise.reject(new Error("Upload rejected (413)")),        abort: () => {},      }),    });     expect(result).toMatchObject({      status: "failed",      step: "transfer",      attachmentId: "pending-failed",    });    expect(removeCalls).toEqual([]);  });}); describe("verifyPersistedAttachmentUpload", () => {  it("hits the server on every verification instead of reusing a cached failure", async () => {    // Mirrors the app's asset URL query atom: SWR-cached with a long stale    // window and kept alive across calls. Without a forced refresh, the    // second verification would read the cached failure and never retry.    let lookups = 0;    const assetUrlAtom = Atom.make(      // Async like the real RPC, so the first read is still in flight when      // the query decides whether a refresh is needed.      Effect.promise(() => Promise.resolve()).pipe(        Effect.flatMap(() => {          lookups += 1;          return lookups === 1            ? Effect.fail({ _tag: "TransportError" } as const)            : Effect.succeed({ url: "/api/assets/pending-1" });        }),      ),    ).pipe(Atom.swr({ staleTime: 60_000 }), Atom.keepAlive);    const liveRegistry = AtomRegistry.make();     const verify = () =>      verifyPersistedAttachmentUpload({        registry: liveRegistry,        createAssetUrl: () => assetUrlAtom,        environmentId,        attachmentId: "pending-1",      });     const first = await verify();    expect(first).toMatchObject({ status: "failed" });     const second = await verify();    expect(second).toEqual({ status: "verified" });    expect(lookups).toBe(2);  });}); describe("file attachment limits", () => {  it("clamps the advertised limit to the turn contract cap", () => {    expect(clampFileAttachmentUploadBytes(1024)).toBe(1024);    expect(clampFileAttachmentUploadBytes(PROVIDER_SEND_TURN_MAX_FILE_BYTES * 2)).toBe(      PROVIDER_SEND_TURN_MAX_FILE_BYTES,    );  });   it("formats attachment row sizes", () => {    expect(formatAttachmentSize(3 * 1024 * 1024)).toBe("3.0 MB");    expect(formatAttachmentSize(1)).toBe("1 KB");  });   it("formats small upload limits without rounding them to zero MB", () => {    expect(fileAttachmentTooLargeMessage("tiny.txt", 1)).toBe(      "'tiny.txt' exceeds the 1 byte attachment limit.",    );    expect(fileAttachmentTooLargeMessage("small.txt", 1024)).toBe(      "'small.txt' exceeds the 1 KB attachment limit.",    );    expect(fileAttachmentTooLargeMessage("exact.txt", 1025)).toBe(      "'exact.txt' exceeds the 1025 bytes attachment limit.",    );    expect(fileAttachmentTooLargeMessage("medium.zip", 512 * 1024)).toBe(      "'medium.zip' exceeds the 512 KB attachment limit.",    );  });   it("keeps whole-MB upload limits for standard server caps", () => {    expect(fileAttachmentTooLargeMessage("one.bin", 1024 * 1024)).toBe(      "'one.bin' exceeds the 1 MB attachment limit.",    );    expect(fileAttachmentTooLargeMessage("big.zip", 50 * 1024 * 1024)).toBe(      "'big.zip' exceeds the 50 MB attachment limit.",    );  });});