import { resolveAssetUrl } from "@t3tools/client-runtime/state/assets";import {  clampFileAttachmentUploadBytes,  fileAttachmentTooLargeMessage,  isAssetAttachmentNotFoundFailure,  runAttachmentUploadCycle,  verifyPersistedAttachmentUpload,} from "@t3tools/client-runtime/state/attachments";import { runAtomCommand, squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";import type {  ChatFileAttachment,  EnvironmentId,  UploadChatImageAttachment,} from "@t3tools/contracts";import * as Option from "effect/Option"; import { appAtomRegistry } from "../state/atom-registry";import { assetEnvironment } from "../state/assets";import { attachmentEnvironment } from "../state/attachments";import { environmentSession } from "../state/session";import { resolveOwnedComposerAttachmentFileUri } from "./composerAttachmentFiles";import { toUploadChatImageAttachments, type DraftComposerAttachment } from "./composerImages"; /** * This module owns the server side of a composer attachment's lifecycle. * `prepareTurnAttachments` acquires pending uploads (verifying and reusing * persisted ones), hands the uploaded ids back to the attachment's durable * owner (queued outbox message or composer draft), and returns a release * handle for after the turn consumed the bytes. Nothing outside this module * mints or deletes pending uploads. The local-file side of the lifecycle is * owned by `removeThreadOutboxMessage` / the composer draft mutators, which * release files through `releaseUnusedComposerAttachmentFiles`. */export type UploadedMobileAttachment = UploadChatImageAttachment | ChatFileAttachment; export function validateDraftFileAttachments(input: {  readonly attachments: ReadonlyArray<DraftComposerAttachment>;  readonly serverConfig: {    readonly environment: {      readonly capabilities: {        readonly attachmentUploads?: boolean;        readonly fileAttachments?: { readonly maxUploadBytes: number };      };    };  } | null;}): string | null {  const files = input.attachments.filter((attachment) => attachment.type === "file");  if (files.length === 0) return null;  if (input.serverConfig === null) return "Server attachment support is still loading.";  const capabilities = input.serverConfig.environment.capabilities;  if (capabilities.attachmentUploads !== true || capabilities.fileAttachments === undefined) {    return "This server does not support file attachments.";  }  const maxBytes = clampFileAttachmentUploadBytes(capabilities.fileAttachments.maxUploadBytes);  const oversized = files.find((attachment) => attachment.sizeBytes > maxBytes);  return oversized ? fileAttachmentTooLargeMessage(oversized.name, maxBytes) : null;} /** Keep uploaded file ids on durable drafts so a later send can reuse their bytes. */export function withUploadedMobileAttachmentReferences(input: {  readonly environmentId: EnvironmentId;  readonly attachments: ReadonlyArray<DraftComposerAttachment>;  readonly uploadedAttachments: ReadonlyArray<UploadedMobileAttachment>;}): ReadonlyArray<DraftComposerAttachment> {  return input.attachments.map((attachment, index) => {    const uploaded = input.uploadedAttachments[index];    if (      attachment.type !== "file" ||      uploaded?.type !== "file" ||      (attachment.uploadedAttachmentId === uploaded.id &&        attachment.uploadEnvironmentId === input.environmentId)    ) {      return attachment;    }    return {      ...attachment,      uploadedAttachmentId: uploaded.id,      uploadEnvironmentId: input.environmentId,    };  });} /** * Deletes pending uploads the client no longer references. Every delete result * is inspected; failed deletes are retried once and a persistent failure * throws, so a caller can never silently leak the outcome. (The server also * expires pending uploads, so a leaked id self-heals eventually.) */export async function releasePendingAttachmentUploads(  environmentId: EnvironmentId,  attachmentIds: ReadonlyArray<string>,): Promise<void> {  const deleteOnce = async (attachmentId: string): Promise<boolean> => {    const result = await runAtomCommand(      appAtomRegistry,      attachmentEnvironment.remove,      { environmentId, input: { attachmentId } },      { reportFailure: false, reportDefect: false },    );    return (      result._tag === "Success" ||      isAssetAttachmentNotFoundFailure(squashAtomCommandFailure(result))    );  };   const failedAttachmentIds: string[] = [];  for (const attachmentId of attachmentIds) {    if (!(await deleteOnce(attachmentId)) && !(await deleteOnce(attachmentId))) {      failedAttachmentIds.push(attachmentId);    }  }  if (failedAttachmentIds.length > 0) {    throw new Error(      `Could not delete ${failedAttachmentIds.length} pending attachment upload(s): ${failedAttachmentIds.join(", ")}.`,    );  }} async function releaseCreatedUploadsQuietly(  environmentId: EnvironmentId,  attachmentIds: ReadonlyArray<string>,): Promise<void> {  try {    await releasePendingAttachmentUploads(environmentId, attachmentIds);  } catch (error) {    // The original failure must propagate; the leaked pending uploads expire    // on the server.    console.warn("[attachments] could not delete abandoned pending uploads", error);  }} export interface PreparedTurnAttachments {  readonly status: "ready";  /** Wire attachments for `startTurn`, in the original composer order. */  readonly attachments: ReadonlyArray<UploadedMobileAttachment>;  /** Composer attachments annotated with the uploaded pending ids. */  readonly draftAttachments: ReadonlyArray<DraftComposerAttachment>;  /** Every pending upload backing this turn (reused and newly minted). */  readonly pendingAttachmentIds: ReadonlyArray<string>;  /** Deletes all pending uploads once the delivered turn holds the bytes. */  readonly releaseUploads: () => Promise<void>;} export type PrepareTurnAttachmentsResult =  | PreparedTurnAttachments  | { readonly status: "abandoned" }; async function uploadFileBytes(  attachment: Extract<DraftComposerAttachment, { readonly type: "file" }>,  url: string,): Promise<void> {  const { File, Paths, UploadType } = await import("expo-file-system");  const fileUri =    resolveOwnedComposerAttachmentFileUri(attachment.fileUri, Paths.document.uri) ??    attachment.fileUri;  const result = await new File(fileUri).upload(url, {    httpMethod: "POST",    uploadType: UploadType.BINARY_CONTENT,    headers: { "Content-Type": attachment.mimeType },  });  if (result.status < 200 || result.status >= 300) {    throw new Error(`Upload failed for '${attachment.name}' (${result.status}).`);  }} /** * Acquires server-side uploads for one turn's attachments and persists the * uploaded ids into the attachments' durable owner. * * `persistUploadedReferences` runs once the bytes are on the server and only * when new ids appeared. It must write the annotated attachments into the * owner (queued message or draft) so a retry after a crash reuses the bytes. * Returning `"abandon"` (owner no longer wants the send) or throwing deletes * the pending uploads this call minted, so the owner cannot leak them. */export async function prepareTurnAttachments(input: {  readonly environmentId: EnvironmentId;  readonly attachments: ReadonlyArray<DraftComposerAttachment>;  readonly persistUploadedReferences?: (    draftAttachments: ReadonlyArray<DraftComposerAttachment>,  ) => Promise<"persisted" | "abandon">;}): Promise<PrepareTurnAttachmentsResult> {  const { environmentId } = input;  const files = input.attachments.filter((attachment) => attachment.type === "file");  const ready = (    attachments: ReadonlyArray<UploadedMobileAttachment>,    pendingAttachmentIds: ReadonlyArray<string>,    draftAttachments: ReadonlyArray<DraftComposerAttachment>,  ): PreparedTurnAttachments => ({    status: "ready",    attachments,    draftAttachments,    pendingAttachmentIds,    releaseUploads: () => releasePendingAttachmentUploads(environmentId, pendingAttachmentIds),  });   if (files.length === 0) {    return ready(      toUploadChatImageAttachments(        input.attachments.filter((attachment) => attachment.type === "image"),      ),      [],      input.attachments,    );  }   const connection = appAtomRegistry.get(    environmentSession.preparedConnectionValueAtom(environmentId),  );  if (Option.isNone(connection)) {    throw new Error("The environment is not connected.");  }   const uploadedAttachments: UploadedMobileAttachment[] = [];  const pendingAttachmentIds: string[] = [];  const createdAttachmentIds: string[] = [];  try {    for (const attachment of input.attachments) {      if (attachment.type === "image") {        uploadedAttachments.push(...toUploadChatImageAttachments([attachment]));        continue;      }       // Reuse the bytes from a previous attempt when their pending upload is      // still alive on this environment.      if (        attachment.uploadEnvironmentId === environmentId &&        attachment.uploadedAttachmentId !== undefined      ) {        const verification = await verifyPersistedAttachmentUpload({          registry: appAtomRegistry,          createAssetUrl: assetEnvironment.createUrl,          environmentId,          attachmentId: attachment.uploadedAttachmentId,        });        if (verification.status === "failed") {          throw verification.error;        }        if (verification.status === "verified") {          pendingAttachmentIds.push(attachment.uploadedAttachmentId);          uploadedAttachments.push({            type: "file",            id: attachment.uploadedAttachmentId,            name: attachment.name,            mimeType: attachment.mimeType,            sizeBytes: attachment.sizeBytes,          });          continue;        }        // "missing": the pending upload expired, upload the bytes again.      }       const result = await runAttachmentUploadCycle({        registry: appAtomRegistry,        createUploadUrl: attachmentEnvironment.createUploadUrl,        remove: attachmentEnvironment.remove,        environmentId,        upload: {          type: "file",          name: attachment.name,          mimeType: attachment.mimeType,          sizeBytes: attachment.sizeBytes,        },        // Read the connection at transfer time: the environment may have        // reconnected on a new base URL since this cycle started.        resolveUploadUrl: (relativeUrl) => {          const currentConnection = appAtomRegistry.get(            environmentSession.preparedConnectionValueAtom(environmentId),          );          return Option.isNone(currentConnection)            ? null            : resolveAssetUrl(currentConnection.value.httpBaseUrl, relativeUrl);        },        transport: (url) => ({          done: uploadFileBytes(attachment, url),          // expo-file-system uploads cannot abort mid-flight.          abort: () => {},        }),        onMinted: (attachmentId) => {          pendingAttachmentIds.push(attachmentId);          createdAttachmentIds.push(attachmentId);          return "continue";        },      });      if (result.status !== "uploaded") {        throw result.status === "failed" && result.error !== undefined          ? result.error          : new Error(`Upload failed for '${attachment.name}'.`);      }      uploadedAttachments.push({        type: "file",        id: result.attachmentId,        name: attachment.name,        mimeType: attachment.mimeType,        sizeBytes: attachment.sizeBytes,      });    }     const draftAttachments = withUploadedMobileAttachmentReferences({      environmentId,      attachments: input.attachments,      uploadedAttachments,    });    const referencesChanged = draftAttachments.some(      (attachment, index) => attachment !== input.attachments[index],    );    if (referencesChanged && input.persistUploadedReferences) {      if ((await input.persistUploadedReferences(draftAttachments)) === "abandon") {        await releaseCreatedUploadsQuietly(environmentId, createdAttachmentIds);        return { status: "abandoned" };      }    }    return ready(uploadedAttachments, pendingAttachmentIds, draftAttachments);  } catch (error) {    await releaseCreatedUploadsQuietly(environmentId, createdAttachmentIds);    throw error;  }}