@rapidmx/web-client 0.36.0 → 0.37.0

package/apps/shared/mail/outbox/sendJob.ts

@@ -11,6 +11,8 @@ import {
     Message,
     assembleDraft,
     assembleDraftRaw,
+    createDraft,
+    deleteMessage,
     forgetDraftImages,
     getMailbox,
     getMessage,
@@ -20,7 +22,7 @@ import {
 } from "../../../../lib/mail/mailApi.js";
 import { describeSendFailure } from "../../../../lib/mail/sendFailure.js";
 import { RecipientEncryptionStatus, resolveRecipientEncryption } from "../../../../lib/crypto/composeSecurity.js";
-import { getUnlockedKeys } from "../../../../lib/crypto/keySession.js";
+import { getUnlockedKeys, type UnlockedKeys } from "../../../../lib/crypto/keySession.js";
 import { EncryptionPolicy, findActivePublicKey, getEncryptionPolicy, lookupKeys } from "../../../../lib/crypto/keyvaultApi.js";
 import { fromBase64 } from "../../../../lib/crypto/encoding.js";
 import type { ProtectedHeaders } from "../../../../lib/crypto/smimeMessage.js";
@@ -31,6 +33,7 @@ import { beginPendingSend, finishPendingSend, setPendingStage } from "./pendingS
 import { failOutgoing, forgetOutgoing, markOutgoingSending, markOutgoingSent, trackOutgoing } from "./outgoingReplies.js";
 import { openComposeFromOutside, requestUnlockFromOutside } from "./composeBridge.js";
 import { OutboxCountTracker, sendState } from "./sendState.js";
+import { notifySendFailure } from "./sendOutcomes.js";
 
 /** Everything the background send needs, captured when Send is clicked: the window it came from is gone by the time it runs. */
 export interface SendRequest {
@@ -67,8 +70,25 @@ export interface SendRequest {
      * show the message as soon as it is sent (see `outgoingReplies.ts`). Absent for a new message, and for a draft opened again, which the draft's own
      * `inReplyTo`/`references` stand in for. */
     threading?: DraftThreading;
+    /** The copies of this message (`assemble()`: one per encryption format) already built but not handed over yet, after an attempt that
+     * failed part-way: a retry hands over just these - never one that already went, and without building them again. */
+    pendingCopies?: Message[];
+    /** Some copies already went (`pendingCopies` holds only the rest): every later failure says so, and never offers "Open draft", which
+     * would send those recipients a second copy - kept across any number of retries. */
+    partial?: boolean;
+    /** The uids of every copy of this message, when it is more than one (one per encryption format, each delivered only to its own
+     * recipients): the request is retained under each, and a failure the server reports later for one of them offers no "Open draft",
+     * which would send the other copy's recipients a second message. */
+    copyUids?: string[];
+    /** What has become of each of those copies, by uid: one map shared by every request made from this one (a retry's, the one retained), so
+     * how any copy went is known to all of them. */
+    copyFates?: Map<string, CopyFate>;
 }
 
+/** One copy of a message sent as several (`SendRequest.copyFates`): `unsent` - not handed over (or its hand-over failed), `pending` - handed
+ * over, how it went still to be reported, `sent`, or `failed` - the server reported it couldn't relay it. */
+export type CopyFate = "unsent" | "pending" | "sent" | "failed";
+
 /** How long a background send waits for the mailbox / encryption policy it did not have, before it goes ahead treating them as unknown. Nobody waits for it. */
 export const CONTEXT_GRACE_MS = 4_000;
 
@@ -85,21 +105,77 @@ export function registerOutboxCounter(tracker: (mailboxUid: string) => OutboxCou
 
 const RETAINED_LIMIT = 25;
 
-/** The request a message was queued from, while this tab still holds it: what lets "Open draft" and "Retry" work on a failure the server reports later. */
+/** The request a message was queued from, while this tab still holds it: what lets "Open draft" and "Retry" work on a failure the server
+ * reports later. A message sent as several copies (`SendRequest.copyUids`) is held under each copy still to go, from just before it is handed
+ * over - how the first went can be reported while the next is still being handed over. */
 export function retainedRequest(draftUid: string): SendRequest | undefined {
     return sendState.retained.get(draftUid);
 }
 
-/** Drops the request a message was queued from, and the pictures remembered as attached to its draft: it has gone, so neither is wanted again. */
-export function forgetRetainedRequest(draftUid: string): void {
+/** Stops holding the request of a message sent as several copies under copy `uid` - never another message's request held there since. */
+function release(fates: Map<string, CopyFate>, uid: string): void {
+    if (sendState.retained.get(uid)?.copyFates === fates) {
+        sendState.retained.delete(uid);
+    }
+}
+
+/** Records that copy `uid` of a message sent as several (`fates`) has gone. Whether it was the last of them to go, each counted once, so the
+ * message is confirmed now - always, for a message sent as one. */
+function copyWent(fates: Map<string, CopyFate> | undefined, uid: string): boolean {
+    if (!fates) {
+        return true;
+    }
+    release(fates, uid);
+    if (fates.get(uid) === "sent") {
+        return false;
+    }
+    fates.set(uid, "sent");
+    return [...fates.values()].every((fate) => fate === "sent");
+}
+
+/** Drops the request a message (or one of its copies) was queued from, and the pictures remembered as attached to its draft: it has gone, so
+ * neither is wanted again. Whether the message has now gone in full - the last of its copies to go. */
+export function forgetRetainedRequest(draftUid: string): boolean {
+    const request = sendState.retained.get(draftUid);
     sendState.retained.delete(draftUid);
     forgetDraftImages(draftUid);
+    return copyWent(request?.copyFates, draftUid);
+}
+
+/** Records that the server couldn't relay copy `uid` of the message `request` sent as several copies (nothing for a message sent as one). */
+export function copyFailed(request: SendRequest | undefined, uid: string): void {
+    request?.copyFates?.set(uid, "failed");
+}
+
+/** Copy `uid` of the message `request` sent as several copies is handed over again (a Retry): how it goes is to be reported once more, and
+ * finds the request held under it. Nothing for a message sent as one. */
+export function copyRetried(request: SendRequest | undefined, uid: string): void {
+    if (request?.copyFates) {
+        request.copyFates.set(uid, "pending");
+        retain(request, [uid]);
+    }
+}
+
+/** Every copy of the message `request` sent as several, when none of them has gone nor may still go - each failed, or was never handed over:
+ * nobody has the message. `undefined` while one has gone or may, and for a message sent as one. */
+export function unsentCopies(request: SendRequest | undefined): string[] | undefined {
+    const fates = request?.copyFates;
+    return fates && [...fates.values()].every((fate) => fate === "failed" || fate === "unsent") ? [...fates.keys()] : undefined;
+}
+
+/** Stops holding a message sent as several copies under any of them: it is being written again. */
+export function forgetCopies(fates: Map<string, CopyFate>): void {
+    for (const uid of fates.keys()) {
+        release(fates, uid);
+    }
 }
 
-function retain(request: SendRequest): void {
-    sendState.retained.delete(request.draft.uid);
-    sendState.retained.set(request.draft.uid, request);
-    if (sendState.retained.size > RETAINED_LIMIT) {
+function retain(request: SendRequest, uids: string[]): void {
+    for (const uid of uids) {
+        sendState.retained.delete(uid);
+        sendState.retained.set(uid, request);
+    }
+    while (sendState.retained.size > RETAINED_LIMIT) {
         sendState.retained.delete(sendState.retained.keys().next().value!);
     }
 }
@@ -117,6 +193,12 @@ export function readSendKeys(mailboxUid: string, signEnabled: boolean, mailbox:
     };
 }
 
+/** Whether the sender can make an OpenPGP copy (it is encrypted to them too, with their own OpenPGP key) - or can't be told yet, the
+ * mailbox being locked: `decideSend()` then asks for the unlock rather than settling for another format, or none. */
+export function senderCanUseOpenPgp(unlocked: UnlockedKeys | undefined): boolean {
+    return !unlocked || !!unlocked.openPgpKeys?.length;
+}
+
 /** Whether this sender could encrypt at all: an encryption key unlocked here, enrolled on the mailbox, or offered earlier this session. */
 export function senderHasEncryptionKey(request: Pick<SendRequest, "mailbox" | "offeredEncrypt">, canEncryptSelf: boolean): boolean {
     return canEncryptSelf || request.offeredEncrypt || !!findActivePublicKey(request.mailbox?.keys ?? [], "encrypt");
@@ -153,9 +235,14 @@ interface Failure {
     message: string;
     details: string[];
     block?: SendBlock;
+    /** Some copies went (their recipients have it); the others are the attempt's `pendingCopies`. */
+    partial?: boolean;
 }
 
-type Outcome = { kind: "queued" | "sent" | "scheduled" } | { kind: "failed"; failure: Failure };
+/** `copyUids`, `copyFates`: every copy of the message and what became of each, when there is more than one (`SendRequest.copyUids`). "sent"
+ * for a message sent as several copies: the last of them went in this attempt, with nothing else to confirm it. */
+type Copies = { copyUids?: string[]; copyFates?: Map<string, CopyFate> };
+type Outcome = ({ kind: "queued" | "sent" | "scheduled" } & Copies) | ({ kind: "failed"; failure: Failure; pendingCopies?: Message[] } & Copies);
 
 const OPEN_POLICY: EncryptionPolicy = { encryptSameOrg: "optional", encryptFederated: "optional", encryptExternal: "optional" };
 
@@ -182,7 +269,11 @@ async function completeContext(request: SendRequest, client: ApiClient | undefin
     return { mailbox, policy };
 }
 
-/** Builds the message's final content into the draft (plain, signed, or signed and encrypted in this browser) and returns the stored message. */
+/** Builds the message's final content into the draft (plain, signed, or signed and encrypted in this browser) and returns the stored
+ * message(s) to send: one, or - for an encrypted message whose recipients need both formats (restapi `specs/end-to-end_encryption.md`
+ * *OpenPGP Interoperability*) - an S/MIME copy (this draft) and an OpenPGP copy (a second draft), each listing every recipient but
+ * delivered only to the recipients of its own format (`deliverTo`). Never a plaintext copy. The second draft is added to `created` as soon as
+ * it exists, so an attempt that fails before handing it over can remove it. */
 async function assemble(
     request: SendRequest,
     mailbox: Mailbox | undefined,
@@ -190,10 +281,11 @@ async function assemble(
     statuses: (RecipientEncryptionStatus | undefined)[],
     withSignature: boolean,
     client: ApiClient | undefined,
-): Promise<Message> {
+    created: Message[],
+): Promise<Message[]> {
     const { draft, to, cc, bcc, subject, html } = request;
     if (mode === "plain") {
-        return assembleDraft(draft.uid, { to, cc, bcc, subject, html, intent: "send" }, client);
+        return [await assembleDraft(draft.uid, { to, cc, bcc, subject, html, intent: "send" }, client)];
     }
     const keys = readSendKeys(request.mailboxUid, request.signEnabled, mailbox);
     const own = mailbox!;
@@ -216,18 +308,57 @@ async function assemble(
     );
     const encrypt = mode === "encrypt";
     const outerHeaders = encrypt ? applyBaselineOuterHeaders(protectedHeaders) : protectedHeaders;
-    const mimePart = encrypt
-        ? await buildEncryptedMessage(
-              bodyContentType,
-              html,
-              protectedHeaders,
-              outerHeaders,
-              [keys.unlocked!.encryptionCertDer!, ...statuses.map((status) => fromBase64(status!.encryptCert!.publicKey))],
-              signing,
-          )
-        : await buildSignedOnlyMessage(bodyContentType, html, protectedHeaders, signing!.certDer, signing!.privateKey);
-    const rawMime = assembleOutboundMime(outerHeaders, mimePart);
-    return assembleDraftRaw(draft.uid, { to, cc, bcc, subject: outerHeaders.subject, rawMime, intent: "send" }, client);
+    if (!encrypt) {
+        const signedPart = await buildSignedOnlyMessage(bodyContentType, html, protectedHeaders, signing!.certDer, signing!.privateKey);
+        return [await assembleDraftRaw(draft.uid, { to, cc, bcc, subject: outerHeaders.subject, rawMime: assembleOutboundMime(outerHeaders, signedPart), intent: "send" }, client)];
+    }
+    const smime = statuses.filter((status) => status!.format !== "openpgp");
+    const pgp = statuses.filter((status) => status!.format === "openpgp");
+    const deliverTo = (group: (RecipientEncryptionStatus | undefined)[]) => (smime.length > 0 && pgp.length > 0 ? { deliverTo: group.map((status) => status!.address) } : {});
+    const sent: Message[] = [];
+    if (smime.length > 0) {
+        const part = await buildEncryptedMessage(
+            bodyContentType,
+            html,
+            protectedHeaders,
+            outerHeaders,
+            [keys.unlocked!.encryptionCertDer!, ...smime.map((status) => fromBase64(status!.encryptCert!.publicKey))],
+            signing,
+        );
+        const rawMime = assembleOutboundMime(outerHeaders, part);
+        sent.push(await assembleDraftRaw(draft.uid, { to, cc, bcc, subject: outerHeaders.subject, rawMime, intent: "send", ...deliverTo(smime) }, client));
+    }
+    if (pgp.length > 0) {
+        // OpenPGP.js and the PGP/MIME builder load only for a message that has OpenPGP recipients.
+        const [{ buildPgpEncryptedMessage, readKeysBase64 }, { armorPublicKey }] = await Promise.all([
+            import("../../../../lib/crypto/pgpMessage.js"),
+            import("../../../../lib/crypto/openpgp.js"),
+        ]);
+        const ownKey = keys.unlocked!.openPgpKeys![0].privateKey;
+        const recipientKeys = await readKeysBase64(pgp.map((status) => status!.openPgpKey!.publicKey));
+        // Its own Message-ID: a second message, even though it is the same one for its readers.
+        const pgpHeaders: ProtectedHeaders = { ...protectedHeaders, messageId: `<${crypto.randomUUID()}@${domain}>` };
+        const pgpOuter = applyBaselineOuterHeaders(pgpHeaders);
+        // Signed with the sender's OpenPGP key (what an OpenPGP reader can check) whenever the message is signed, and carrying the
+        // sender's public key, so a correspondent without it can verify and reply encrypted.
+        const part = await buildPgpEncryptedMessage(
+            bodyContentType,
+            html,
+            pgpHeaders,
+            pgpOuter,
+            [ownKey.toPublic(), ...recipientKeys],
+            withSignature ? ownKey : undefined,
+            armorPublicKey(ownKey.toPublic()),
+        );
+        const rawMime = assembleOutboundMime(pgpOuter, part);
+        let target = draft;
+        if (smime.length > 0) {
+            target = await createDraft(request.mailboxUid, draft.folderUid, undefined, client);
+            created.push(target);
+        }
+        sent.push(await assembleDraftRaw(target.uid, { to, cc, bcc, subject: pgpOuter.subject, rawMime, intent: "send", ...deliverTo(pgp) }, client));
+    }
+    return sent;
 }
 
 function failureOf(err: unknown, fallback: string): Failure {
@@ -235,21 +366,144 @@ function failureOf(err: unknown, fallback: string): Failure {
     return { message: failure.message, details: failure.lines };
 }
 
-/** Whether the server already holds `request`'s message as accepted (out of Drafts, or leased) - the answer to "did that request that never returned actually land?". */
-async function alreadyAccepted(request: SendRequest, client: ApiClient | undefined): Promise<boolean> {
+/** Whether `fresh`, `copy` as the server holds it now, was accepted (out of Drafts, or leased). */
+function isAccepted(copy: Message, fresh: Message): boolean {
+    return fresh.folderUid !== copy.folderUid || !!fresh.scheduledSendLeaseExpiresAt || !!fresh.scheduledSendRelayedAt;
+}
+
+/** Whether the server already holds `copy` as accepted - the answer to "did that request that never returned actually land?". */
+async function accepted(copy: Message, client: ApiClient | undefined): Promise<boolean> {
     try {
-        const fresh = await getMessage(request.draft.uid, client);
-        return fresh.folderUid !== request.draft.folderUid || !!fresh.scheduledSendLeaseExpiresAt || !!fresh.scheduledSendRelayedAt;
+        return isAccepted(copy, await getMessage(copy.uid, client));
     } catch {
         return false;
     }
 }
 
+/** Deletes the draft of a copy of a message sent as several (the OpenPGP one's) that is not to be handed over any more - unless the server
+ * holds it as accepted after all. Best effort: never rejects. */
+async function discardCopy(copy: Message, client: ApiClient | undefined): Promise<void> {
+    try {
+        const fresh = await getMessage(copy.uid, client);
+        if (!isAccepted(copy, fresh)) {
+            await deleteMessage(fresh.uid, fresh.version, client);
+        }
+    } catch {
+        // Left in Drafts, where it can be deleted by hand.
+    }
+}
+
+/** Whether the server already holds every copy of `request`'s message still to go (its draft, when none was built yet) as accepted. */
+async function alreadyAccepted(request: SendRequest, client: ApiClient | undefined): Promise<boolean> {
+    for (const copy of request.pendingCopies ?? [request.draft]) {
+        if (!(await accepted(copy, client))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/** Hands `copies` over to the server - queued, or scheduled - one after the other. One that fails stops the rest: the failure carries the
+ * copies still to go, so a retry never sends one twice (an encrypted message's other copy may already be on its way to its recipients). */
+async function handOver(request: SendRequest, copies: Message[], client: ApiClient | undefined): Promise<Outcome> {
+    // A retry hands over only what was left: the request already names every copy.
+    const copyUids: string[] | undefined = request.copyUids ?? (copies.length > 1 ? copies.map((copy) => copy.uid) : undefined);
+    const copyFates = request.copyFates ?? (copyUids && new Map(copyUids.map((uid): [string, CopyFate] => [uid, "unsent"])));
+    // An immediate send of several copies is held under each before any is handed over: how the first went can be reported while the next
+    // is still on its way to the server, and must find the others - a failure that offered "Open draft" would send their recipients the
+    // message again, a success not counted would leave the message never confirmed.
+    if (copyFates && !request.scheduledSendTime) {
+        for (const copy of copies) {
+            copyFates.set(copy.uid, "pending");
+        }
+        retain({ ...request, copyUids, copyFates }, copies.map((copy) => copy.uid));
+    }
+    let queued = false;
+    let completed = false;
+    for (let index = 0; index < copies.length; index++) {
+        const copy = copies[index];
+        try {
+            if (request.scheduledSendTime) {
+                await sendMessage(copy.uid, { scheduledSendTime: request.scheduledSendTime }, client);
+            } else {
+                const handed = await queueMessageSend(copy.uid, client);
+                queued = handed.queued || queued;
+                // A server with no queue relayed it before answering: one of several copies has gone already.
+                if (!handed.queued && copyFates) {
+                    completed = copyWent(copyFates, copy.uid) || completed;
+                }
+            }
+        } catch (err) {
+            // A request that never came back may still have landed: never offer to send it twice if it did.
+            if (!(err instanceof ApiRequestError) && (await accepted(copy, client))) {
+                queued = true;
+                continue;
+            }
+            const failure = failureOf(err, request.scheduledSendTime ? "Could not schedule this message." : "Could not send this message.");
+            // This copy and the ones after it weren't handed over: nothing of them is to be reported.
+            if (copyFates) {
+                for (const left of copies.slice(index)) {
+                    copyFates.set(left.uid, "unsent");
+                    release(copyFates, left.uid);
+                }
+            }
+            // The server has failed a copy handed over earlier (its report came while this one was on its way), and none is sent or on its
+            // way: nobody has the message - the whole message's failure, not some recipients'.
+            const fates = [...(copyFates?.values() ?? [])];
+            const nobodyHasIt = fates.includes("failed") && fates.every((fate) => fate === "failed" || fate === "unsent");
+            // A copy that went in this attempt, or in an earlier one this retries.
+            const partial = !nobodyHasIt && (index > 0 || !!request.partial);
+            return {
+                kind: "failed",
+                failure: partial
+                    ? { ...failure, partial, message: `Only some of its recipients ${request.scheduledSendTime ? "will get it" : "were sent it"} - the copy for the others didn't go. ${failure.message}` }
+                    : failure,
+                // Nothing went of a single copy: a retry decides and assembles again from the request, like the first attempt (the stored
+                // draft may have been opened and autosaved plain since). Several copies are kept even when none went, so a mixed-format
+                // retry doesn't create another OpenPGP draft.
+                pendingCopies: partial || copies.length > 1 ? copies.slice(index) : undefined,
+                copyUids,
+                copyFates,
+            };
+        }
+    }
+    if (request.scheduledSendTime) {
+        return { kind: "scheduled", copyUids, copyFates };
+    }
+    // Several copies: the message has gone only when this hand-over saw the last of them go - otherwise the server's report for the last copy
+    // to go confirms it.
+    return { kind: (copyFates ? completed : !queued) ? "sent" : "queued", copyUids, copyFates };
+}
+
 /** The whole client-side path of one send: settle, decide, assemble, hand over. Never rejects. `client` is the explicit `ApiClient` (from
  * `useApiClient()`) the window that built `request` was rendered under, `undefined` for the default global cookie-based session. */
 async function attempt(request: SendRequest, client: ApiClient | undefined): Promise<Outcome> {
+    // The copies' drafts `assemble()` created (the OpenPGP one's): an attempt that fails before handing them over deletes them - its Retry
+    // assembles the message again, creating its own, and one left behind would reach its recipients a second time if sent from Drafts.
+    const created: Message[] = [];
     try {
         await request.saved?.catch(() => undefined);
+        // Built already by the attempt that failed part-way: only what didn't go is handed over. A copy whose request seemed to fail but
+        // landed (its answer was lost, and so was the check after it) has gone since: handed over again it is refused, and the copies after
+        // it would never go - it is left out, and what fails now is a failure of only some of the recipients.
+        if (request.pendingCopies?.length) {
+            setPendingStage(request.draft.uid, "queuing");
+            const remaining: Message[] = [];
+            let completed = false;
+            for (const copy of request.pendingCopies) {
+                if (!(await accepted(copy, client))) {
+                    remaining.push(copy);
+                } else {
+                    // How it went has most likely been reported already, to nothing waiting for it: it isn't waited for now.
+                    completed = copyWent(request.copyFates, copy.uid) || completed;
+                }
+            }
+            if (remaining.length === 0) {
+                const { copyUids, copyFates } = request;
+                return { kind: request.scheduledSendTime ? "scheduled" : completed ? "sent" : "queued", copyUids, copyFates };
+            }
+            return await handOver(remaining.length < request.pendingCopies.length ? { ...request, partial: true } : request, remaining, client);
+        }
         const all = [...request.to, ...request.cc, ...request.bcc];
         let mailbox = request.mailbox;
         let policy = request.policy;
@@ -272,9 +526,16 @@ async function attempt(request: SendRequest, client: ApiClient | undefined): Pro
                         ),
                     ),
                 );
+                const ownOpenPgp = senderCanUseOpenPgp(keys.unlocked);
                 statuses = all.map((recipient, index) => {
                     const found = lookups[index];
-                    return found ? resolveRecipientEncryption(own.primarySmtpAddress, ownPrefersMutual, policy ?? OPEN_POLICY, recipient.address, found.lookup) : undefined;
+                    // Without an OpenPGP key of the sender's, a recipient with both formats gets S/MIME, whatever they prefer.
+                    const status = found
+                        ? resolveRecipientEncryption(own.primarySmtpAddress, ownPrefersMutual, policy ?? OPEN_POLICY, recipient.address, found.lookup, ownOpenPgp)
+                        : undefined;
+                    // An OpenPGP copy is encrypted to the sender too, with their own OpenPGP key: a recipient with only an OpenPGP key can't
+                    // be encrypted to while the unlocked session has none.
+                    return status?.format === "openpgp" && !ownOpenPgp ? { ...status, canEncrypt: false, autoEncrypt: false } : status;
                 });
             }
             lookupsComplete = true;
@@ -288,24 +549,24 @@ async function attempt(request: SendRequest, client: ApiClient | undefined): Pro
             return { kind: "failed", failure: { message: decision.message, details: [] } };
         }
 
-        const assembled = await assemble(request, mailbox, decision.action, statuses, decision.action === "sign" || (decision.action === "encrypt" && decision.sign), client);
-        const withReceipt = request.requestReceipt ? await setMessageRequestReceipt(assembled, true, client) : assembled;
+        const assembled = await assemble(
+            request,
+            mailbox,
+            decision.action,
+            statuses,
+            decision.action === "sign" || (decision.action === "encrypt" && decision.sign),
+            client,
+            created,
+        );
+        const copies = request.requestReceipt ? await Promise.all(assembled.map((copy) => setMessageRequestReceipt(copy, true, client))) : assembled;
         setPendingStage(request.draft.uid, "queuing");
-        try {
-            if (request.scheduledSendTime) {
-                await sendMessage(withReceipt.uid, { scheduledSendTime: request.scheduledSendTime }, client);
-                return { kind: "scheduled" };
-            }
-            const result = await queueMessageSend(withReceipt.uid, client);
-            return { kind: result.queued ? "queued" : "sent" };
-        } catch (err) {
-            // A request that never came back may still have landed: never offer to send it twice if it did.
-            if (!(err instanceof ApiRequestError) && (await alreadyAccepted(request, client))) {
-                return { kind: request.scheduledSendTime ? "scheduled" : "queued" };
-            }
-            throw err;
-        }
+        // Handed over from here: a copy the hand-over doesn't deliver is its failure's to retry.
+        created.length = 0;
+        return await handOver(request, copies, client);
     } catch (err) {
+        for (const copy of created) {
+            await discardCopy(copy, client);
+        }
         return { kind: "failed", failure: failureOf(err, request.scheduledSendTime ? "Could not schedule this message." : "Could not send this message.") };
     }
 }
@@ -338,9 +599,11 @@ export function openDraftFromRequest(request: SendRequest): boolean {
             encryptRequested: request.encryptRequested,
         },
     });
-    // Being edited again, it is no longer a message on its way in the conversation.
+    // Being edited again, it is no longer a message on its way in the conversation - and the failure's Retry, wherever it was clicked
+    // from, must not hand over the draft the window is now editing (and autosaving).
     if (opened) {
         forgetOutgoing(request.draft.uid);
+        dismiss(failureNotificationId(request.draft.uid));
     }
     return opened;
 }
@@ -349,9 +612,32 @@ function failureNotificationId(draftUid: string): string {
     return `send-failed:${draftUid}`;
 }
 
+/** "Open draft" for a message sent as several copies none of which went, each still a draft (`unsentCopies()`): the message is written again in
+ * its own draft, and the other copies' drafts (the OpenPGP one's) are deleted, best effort - it is encrypted afresh when it is sent again,
+ * and a copy left in Drafts would reach its recipients a second time if ever sent from there. */
+function openDraftDroppingCopies(request: SendRequest, client: ApiClient | undefined): void {
+    if (!openDraftFromRequest(request)) {
+        return;
+    }
+    forgetCopies(request.copyFates!);
+    for (const copy of request.pendingCopies!.filter((copy) => copy.uid !== request.draft.uid)) {
+        forgetOutgoing(copy.uid);
+        void discardCopy(copy, client);
+    }
+}
+
 /** The sticky "This message wasn't sent" pop-up for a send that failed on this side, with what can be done about it. */
 function notifyFailure(request: SendRequest, failure: Failure, client: ApiClient | undefined): void {
     const uid = request.draft.uid;
+    // A message sent as several copies, none of which went: each was never handed over, or the server failed it (its report came while the
+    // next was being handed over). Then it is the whole message's failure as the server reports one: one pop-up, replacing the one its report
+    // showed, whose Retry hands every copy over again - the failed one from Outbox too - and whose "Open draft" writes the message again.
+    const copies = unsentCopies(request);
+    if (copies && [...request.copyFates!.values()].includes("failed")) {
+        const recipients = [...request.to, ...request.cc, ...request.bcc].map((recipient) => recipient.address);
+        notifySendFailure({ uid, mailboxUid: request.mailboxUid, subject: request.subject, recipients }, { message: failure.message, lines: failure.details }, request, client);
+        return;
+    }
     const actions: NotificationAction[] = [];
     const { block } = failure;
     if (block?.keysLocked && request.mailbox?.keys?.length) {
@@ -370,7 +656,10 @@ function notifyFailure(request: SendRequest, failure: Failure, client: ApiClient
     } else {
         actions.push({ label: "Retry", onClick: () => void retrySend(request, client) });
     }
-    actions.push({ label: "Open draft", onClick: () => void openDraftFromRequest(request) });
+    // Part of it went: editing and sending the draft again would send those recipients a second copy.
+    if (!failure.partial) {
+        actions.push({ label: "Open draft", onClick: () => void (copies ? openDraftDroppingCopies(request, client) : openDraftFromRequest(request)) });
+    }
     notify({
         id: failureNotificationId(uid),
         kind: "error",
@@ -417,15 +706,25 @@ export function startSend(request: SendRequest, client?: ApiClient): boolean {
         finishPendingSend(uid);
         if (outcome.kind === "failed") {
             tracker?.revert();
-            notifyFailure(request, outcome.failure, client);
+            notifyFailure(
+                outcome.pendingCopies
+                    ? { ...request, pendingCopies: outcome.pendingCopies, partial: outcome.failure.partial, copyUids: outcome.copyUids, copyFates: outcome.copyFates }
+                    : request,
+                outcome.failure,
+                client,
+            );
             return;
         }
         tracker?.settle();
         if (outcome.kind === "queued") {
-            retain(request);
+            // A message sent as several copies is held under each already, from before it was handed over.
+            if (!outcome.copyFates) {
+                retain(request, [uid]);
+            }
             sendState.queuedListener?.(request.mailboxUid);
         } else if (outcome.kind === "sent") {
-            // A server with no queue relayed it before answering: the Sent Items copy exists already.
+            // A server with no queue relayed it before answering (or, of several copies, the last of them went in this attempt): the Sent
+            // Items copy exists already.
             markOutgoingSent(uid);
             forgetDraftImages(uid);
             notifySent();