@rapidmx/web-client 0.9.0 → 0.11.0

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

@@ -0,0 +1,157 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { RecipientEncryptionStatus, decideMessageEncryption } from "@rapidmx/react-shared/crypto/composeSecurity.js";
+import type { EncryptionPolicy } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import { evaluateEncryptionRequirement } from "../../components/mail/compose/encryptionRequirement.js";
+
+/** Signed/encrypted bodies are built client-side from the editor's HTML verbatim, so an inline image (an uploaded attachment previewed via
+ * its content URL, or a `cid:` reference) would never be carried - only `assembleDraft()`'s server-side plaintext path rewrites those into
+ * real MIME parts. */
+export const INLINE_IMAGE_PATTERN = /<img\b[^>]*\bsrc\s*=\s*["']?(?:cid:|[^"'\s>]*\/mail\/attachments\/[^"'\s>]+\/content)/i;
+
+export const KEYS_LOCKED_SIGN_MESSAGE =
+    "This message can't be signed right now - your signing key is locked or your mailbox details couldn't be loaded. Unlock and send again, or send it without signing.";
+export const KEYS_LOCKED_ENCRYPT_MESSAGE =
+    "This message can't be encrypted right now - your encryption key is locked. Unlock and send again, or send it without encryption.";
+export const BCC_ENCRYPTED_MESSAGE = "Bcc recipients can't be used with encrypted messages. Remove Bcc recipients or turn off encryption.";
+export const LOOKUP_UNAVAILABLE_MESSAGE =
+    "Your recipients' encryption keys couldn't be checked, so this message can't be encrypted right now. Try again, or send it without encryption.";
+/** The plain sentence for recipients an encrypted message can't reach (no key on file, or the policy prohibits it). */
+export function recipientsBlockedMessage(blocked: RecipientEncryptionStatus[]): string {
+    const reason = blocked[0]?.prohibitedReason ? ` — ${blocked[0].prohibitedReason}` : " has no encryption key on file";
+    return `This message can’t be encrypted for everyone: ${blocked.map((r) => r.address).join(", ")}${reason}. Remove ${blocked.length > 1 ? "these recipients" : "this recipient"} from To/Cc/Bcc, or send the whole message in plaintext.`;
+}
+export const MAILBOX_UNAVAILABLE_MESSAGE =
+    "Your mailbox details couldn't be loaded, so this message can't be encrypted right now. Try again, or send it without encryption.";
+export const ATTACHMENTS_UNSUPPORTED_MESSAGE = "A signed or encrypted message cannot include file attachments yet - remove them before sending.";
+export const INLINE_IMAGES_UNSUPPORTED_MESSAGE = "A signed or encrypted message cannot include inline images yet - remove them before sending.";
+
+/** Why a send is refused *before* anything is sent: signing/encryption was asked for (or applies) but cannot happen right now. Never a silent
+ * downgrade to plaintext - the sender explicitly picks the override. */
+export interface SendBlock {
+    kind: "signing-locked" | "encryption-locked" | "lookup-failed" | "mailbox-unavailable" | "bcc" | "recipients";
+    message: string;
+    /** The button that sends it anyway, without encryption (and without signing when that is what was blocked). */
+    overrideLabel: string;
+    /** The cause is keys that are enrolled but not unlocked in this tab: an Unlock action helps. */
+    keysLocked: boolean;
+    /** `recipients`: who has no key (or is not allowed one). */
+    blockedRecipients?: RecipientEncryptionStatus[];
+}
+
+export type SendDecision =
+    | { action: "plain" }
+    | { action: "sign" }
+    | { action: "encrypt"; sign: boolean }
+    | { action: "blocked"; block: SendBlock }
+    /** Not sendable as composed, and no override helps: fix the message. */
+    | { action: "rejected"; message: string };
+
+export interface SendDecisionInput {
+    /** The sender's explicit choice to skip every encryption/signing check (an override button): it never encrypts, and still signs if it can. */
+    forcePlaintext: boolean;
+    /** The "sign" checkbox. */
+    signEnabled: boolean;
+    /** The signing option was shown at some point this compose session (the keys were unlocked): losing the keys then blocks, never silently unsigns. */
+    offeredSign: boolean;
+    encryptRequested: boolean;
+    policy: EncryptionPolicy | undefined;
+    mailboxLoaded: boolean;
+    hasEncryptionKey: boolean;
+    keys: {
+        /** Signing is possible now: enabled, mailbox loaded (for the protected headers), signing key unlocked. */
+        canSign: boolean;
+        /** The encryption key is unlocked. */
+        canEncryptSelf: boolean;
+        /** Any key material is unlocked in this tab. */
+        unlocked: boolean;
+    };
+    /** Every recipient (To, Cc and Bcc), resolved; `undefined` where the lookup failed - or, with `lookupsComplete: false`, was not made. */
+    recipients: (RecipientEncryptionStatus | undefined)[];
+    /** Whether the lookups were all *attempted*: `false` for the early check a compose window makes from what it already knows. */
+    lookupsComplete: boolean;
+    hasBcc: boolean;
+    hasAttachments: boolean;
+    hasInlineImages: boolean;
+}
+
+/**
+ * How a message may go out, decided from the facts alone (no requests, no React): plain, signed, encrypted, refused with an override the sender
+ * can choose, or rejected outright. Used twice with the same rules - by the compose window, from what it already knows, to catch a problem
+ * *before* it closes (`lookupsComplete: false`), and by the background send, once its recipient lookups are in.
+ *
+ * Encryption follows `evaluateEncryptionRequirement()` - fail open: only a message the user asked to encrypt, or one the loaded policy
+ * encrypts, is encrypted; everything unknown is plain and sends. The one place unknown blocks is a message the user *explicitly* asked to
+ * encrypt whose recipients' keys could not be looked up: they asked for encryption, and it cannot be delivered.
+ */
+export function decideSend(input: SendDecisionInput): SendDecision {
+    const { keys } = input;
+    const attachmentsAreAProblem = (encrypting: boolean) => (encrypting || keys.canSign) && input.hasAttachments;
+    const imagesAreAProblem = (encrypting: boolean) => (encrypting || keys.canSign) && input.hasInlineImages;
+
+    if (input.forcePlaintext) {
+        if (attachmentsAreAProblem(false)) {
+            return { action: "rejected", message: ATTACHMENTS_UNSUPPORTED_MESSAGE };
+        }
+        if (imagesAreAProblem(false)) {
+            return { action: "rejected", message: INLINE_IMAGES_UNSUPPORTED_MESSAGE };
+        }
+        return keys.canSign ? { action: "sign" } : { action: "plain" };
+    }
+
+    if (input.signEnabled && input.offeredSign && !keys.canSign) {
+        return {
+            action: "blocked",
+            block: { kind: "signing-locked", message: KEYS_LOCKED_SIGN_MESSAGE, overrideLabel: "Send without signing or encryption", keysLocked: !keys.unlocked },
+        };
+    }
+
+    if (input.encryptRequested && !input.mailboxLoaded) {
+        // Asked for explicitly, and there is nothing to encrypt with (the sender's address and keys come from the mailbox).
+        return { action: "blocked", block: { kind: "mailbox-unavailable", message: MAILBOX_UNAVAILABLE_MESSAGE, overrideLabel: "Send without encryption", keysLocked: false } };
+    }
+
+    const requirement = evaluateEncryptionRequirement({
+        encryptRequested: input.encryptRequested,
+        policy: input.policy,
+        mailboxLoaded: input.mailboxLoaded,
+        hasEncryptionKey: input.hasEncryptionKey,
+        recipients: input.recipients,
+    });
+    const encrypting = requirement.required;
+
+    if (encrypting) {
+        const statuses = input.recipients.filter((status): status is RecipientEncryptionStatus => !!status);
+        const allResolved = statuses.length === input.recipients.length;
+        if (!allResolved && input.lookupsComplete) {
+            // Only reachable for an explicit request (a policy requirement needs every status): the sender asked for encryption and the
+            // recipients' keys could not be checked.
+            return { action: "blocked", block: { kind: "lookup-failed", message: LOOKUP_UNAVAILABLE_MESSAGE, overrideLabel: "Send without encryption", keysLocked: false } };
+        }
+        if (!keys.canEncryptSelf) {
+            return { action: "blocked", block: { kind: "encryption-locked", message: KEYS_LOCKED_ENCRYPT_MESSAGE, overrideLabel: "Send without encryption", keysLocked: !keys.unlocked } };
+        }
+        if (allResolved) {
+            const decision = decideMessageEncryption(statuses);
+            if (!decision.canEncryptAll) {
+                return {
+                    action: "blocked",
+                    block: { kind: "recipients", message: recipientsBlockedMessage(decision.blockedRecipients), overrideLabel: "Send without encryption", keysLocked: false, blockedRecipients: decision.blockedRecipients },
+                };
+            }
+        }
+        if (input.hasBcc) {
+            return { action: "blocked", block: { kind: "bcc", message: BCC_ENCRYPTED_MESSAGE, overrideLabel: "Send without encryption", keysLocked: false } };
+        }
+    }
+
+    if (attachmentsAreAProblem(encrypting)) {
+        return { action: "rejected", message: ATTACHMENTS_UNSUPPORTED_MESSAGE };
+    }
+    if (imagesAreAProblem(encrypting)) {
+        return { action: "rejected", message: INLINE_IMAGES_UNSUPPORTED_MESSAGE };
+    }
+    return encrypting ? { action: "encrypt", sign: keys.canSign } : keys.canSign ? { action: "sign" } : { action: "plain" };
+}

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

@@ -0,0 +1,427 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
+import {
+    Attachment,
+    ComposeRecipientInput,
+    Mailbox,
+    Message,
+    assembleDraft,
+    assembleDraftRaw,
+    getMailbox,
+    getMessage,
+    queueMessageSend,
+    sendMessage,
+    setMessageRequestReceipt,
+} from "@rapidmx/react-shared/mail/mailApi.js";
+import { describeSendFailure } from "@rapidmx/react-shared/mail/sendFailure.js";
+import { RecipientEncryptionStatus, resolveRecipientEncryption } from "@rapidmx/react-shared/crypto/composeSecurity.js";
+import { getUnlockedKeys } from "@rapidmx/react-shared/crypto/keySession.js";
+import { EncryptionPolicy, findActivePublicKey, getEncryptionPolicy, lookupKeys } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import { fromBase64 } from "@rapidmx/react-shared/crypto/encoding.js";
+import type { ProtectedHeaders } from "@rapidmx/react-shared/crypto/smimeMessage.js";
+import { policyCanAutoEncrypt } from "../../components/mail/compose/encryptionRequirement.js";
+import { NotificationAction, dismiss, notify } from "../../notifications/store.js";
+import { INLINE_IMAGE_PATTERN, SendBlock, SendDecisionInput, decideSend } from "./sendDecision.js";
+import { beginPendingSend, finishPendingSend, setPendingStage } from "./pendingSends.js";
+import { openComposeFromOutside, requestUnlockFromOutside } from "./composeBridge.js";
+import { OutboxCountTracker, sendState } from "./sendState.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 {
+    /** The window's server draft. */
+    draft: Message;
+    mailboxUid: string;
+    /** The sender's mailbox as the window had loaded it - `undefined` when that load had not succeeded (the send then tries again itself). */
+    mailbox: Mailbox | undefined;
+    /** The encryption policy as the window had loaded it, `undefined` likewise. */
+    policy: EncryptionPolicy | undefined;
+    /** The window's To/Cc/Bcc field text, kept so "Open draft" restores them exactly. */
+    toText: string;
+    ccText: string;
+    bccText: string;
+    to: ComposeRecipientInput[];
+    cc: ComposeRecipientInput[];
+    bcc: ComposeRecipientInput[];
+    subject: string;
+    html: string;
+    attachments: Attachment[];
+    requestReceipt: boolean;
+    /** Send later: an ISO time in the future. Absent for an immediate send. */
+    scheduledSendTime?: string;
+    signEnabled: boolean;
+    /** The sign / encrypt options were shown to the sender at some point this compose session (their keys were unlocked). */
+    offeredSign: boolean;
+    offeredEncrypt: boolean;
+    encryptRequested: boolean;
+    /** The sender's explicit choice to send without encryption/signing checks (an override). */
+    forcePlaintext: boolean;
+    /** Settles when the window's own autosaves have landed, so none can overwrite the assembly below. */
+    saved?: Promise<unknown>;
+}
+
+/** 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;
+
+export function registerOutboxCounter(tracker: (mailboxUid: string) => OutboxCountTracker, onQueued: (mailboxUid: string) => void): () => void {
+    sendState.countTracker = tracker;
+    sendState.queuedListener = onQueued;
+    return () => {
+        if (sendState.countTracker === tracker) {
+            sendState.countTracker = undefined;
+            sendState.queuedListener = undefined;
+        }
+    };
+}
+
+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. */
+export function retainedRequest(draftUid: string): SendRequest | undefined {
+    return sendState.retained.get(draftUid);
+}
+
+export function forgetRetainedRequest(draftUid: string): void {
+    sendState.retained.delete(draftUid);
+}
+
+function retain(request: SendRequest): void {
+    sendState.retained.delete(request.draft.uid);
+    sendState.retained.set(request.draft.uid, request);
+    if (sendState.retained.size > RETAINED_LIMIT) {
+        sendState.retained.delete(sendState.retained.keys().next().value!);
+    }
+}
+
+const UNSAFE_DISPLAY_NAME_PATTERN = /[@＠﹫\r\n]/;
+
+/** The sender's signing/encryption key state right now, read from the tab's key session (they can lock mid-send). */
+export function readSendKeys(mailboxUid: string, signEnabled: boolean, mailbox: Mailbox | undefined) {
+    const stored = getUnlockedKeys(mailboxUid);
+    const unlocked = stored?.destroyed ? undefined : stored;
+    return {
+        unlocked,
+        canSign: signEnabled && !!mailbox && !!unlocked?.signingPrivateKey && !!unlocked.signingCertDer,
+        canEncryptSelf: !!unlocked?.encryptionPrivateKey && !!unlocked.encryptionCertDer,
+    };
+}
+
+/** 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");
+}
+
+/** The input `decideSend()` reads, from a request and what has been looked up. */
+export function sendDecisionInput(
+    request: SendRequest,
+    mailbox: Mailbox | undefined,
+    policy: EncryptionPolicy | undefined,
+    recipients: (RecipientEncryptionStatus | undefined)[],
+    lookupsComplete: boolean,
+): SendDecisionInput {
+    const keys = readSendKeys(request.mailboxUid, request.signEnabled, mailbox);
+    return {
+        forcePlaintext: request.forcePlaintext,
+        signEnabled: request.signEnabled,
+        offeredSign: request.offeredSign,
+        encryptRequested: request.encryptRequested,
+        policy,
+        mailboxLoaded: !!mailbox,
+        hasEncryptionKey: senderHasEncryptionKey({ mailbox, offeredEncrypt: request.offeredEncrypt }, keys.canEncryptSelf),
+        keys: { canSign: keys.canSign, canEncryptSelf: keys.canEncryptSelf, unlocked: !!keys.unlocked },
+        recipients,
+        lookupsComplete,
+        hasBcc: request.bcc.length > 0,
+        hasAttachments: request.attachments.length > 0,
+        hasInlineImages: INLINE_IMAGE_PATTERN.test(request.html),
+    };
+}
+
+/** A send that did not go: the plain reason, the technical lines, and - for a refusal the sender can override - which. */
+interface Failure {
+    message: string;
+    details: string[];
+    block?: SendBlock;
+}
+
+type Outcome = { kind: "queued" | "sent" | "scheduled" } | { kind: "failed"; failure: Failure };
+
+const OPEN_POLICY: EncryptionPolicy = { encryptSameOrg: "optional", encryptFederated: "optional", encryptExternal: "optional" };
+
+/** The mailbox and policy this send is missing, loaded now: the sender is not waiting, so a slow answer costs nothing - but it is not waited on for ever. */
+async function completeContext(request: SendRequest): Promise<{ mailbox: Mailbox | undefined; policy: EncryptionPolicy | undefined }> {
+    let mailbox = request.mailbox;
+    let policy = request.policy;
+    const keysNow = readSendKeys(request.mailboxUid, request.signEnabled, mailbox);
+    const loads: Promise<unknown>[] = [];
+    if (!mailbox) {
+        loads.push(getMailbox(request.mailboxUid).then((loaded) => void (mailbox = loaded)));
+    }
+    if (!policy && (!mailbox || senderHasEncryptionKey({ mailbox, offeredEncrypt: request.offeredEncrypt }, keysNow.canEncryptSelf))) {
+        loads.push(getEncryptionPolicy().then((loaded) => void (policy = loaded)));
+    }
+    if (loads.length > 0) {
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        const grace = new Promise<void>((resolve) => {
+            timer = setTimeout(resolve, CONTEXT_GRACE_MS);
+        });
+        await Promise.race([Promise.allSettled(loads), grace]);
+        clearTimeout(timer);
+    }
+    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. */
+async function assemble(
+    request: SendRequest,
+    mailbox: Mailbox | undefined,
+    mode: "plain" | "sign" | "encrypt",
+    statuses: (RecipientEncryptionStatus | undefined)[],
+    withSignature: boolean,
+): Promise<Message> {
+    const { draft, to, cc, bcc, subject, html } = request;
+    if (mode === "plain") {
+        return assembleDraft(draft.uid, { to, cc, bcc, subject, html });
+    }
+    const keys = readSendKeys(request.mailboxUid, request.signEnabled, mailbox);
+    const own = mailbox!;
+    const domain = own.primarySmtpAddress.split("@")[1] ?? "localhost";
+    const displayName = own.displayName && !UNSAFE_DISPLAY_NAME_PATTERN.test(own.displayName) ? own.displayName : "";
+    const protectedHeaders: ProtectedHeaders = {
+        from: displayName ? `"${displayName.replace(/"/g, '\\"')}" <${own.primarySmtpAddress}>` : own.primarySmtpAddress,
+        to: to.map((r) => r.address).join(", "),
+        cc: cc.length > 0 ? cc.map((r) => r.address).join(", ") : undefined,
+        date: new Date().toUTCString(),
+        subject,
+        messageId: `<${crypto.randomUUID()}@${domain}>`,
+    };
+    const bodyContentType = 'text/html; charset="utf-8"';
+    const signing = withSignature ? { certDer: keys.unlocked!.signingCertDer!, privateKey: keys.unlocked!.signingPrivateKey! } : undefined;
+    // The S/MIME code (PKI.js and the ASN.1/X.509 libraries, over half a megabyte) is only needed here, to sign or encrypt - a plain message
+    // never loads it, and it is kept out of the compose window's own chunk.
+    const { applyBaselineOuterHeaders, assembleOutboundMime, buildEncryptedMessage, buildSignedOnlyMessage } = await import(
+        "@rapidmx/react-shared/crypto/smimeMessage.js"
+    );
+    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 });
+}
+
+function failureOf(err: unknown, fallback: string): Failure {
+    const failure = describeSendFailure(err, fallback);
+    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): Promise<boolean> {
+    try {
+        const fresh = await getMessage(request.draft.uid);
+        return fresh.folderUid !== request.draft.folderUid || !!fresh.scheduledSendLeaseExpiresAt || !!fresh.scheduledSendRelayedAt;
+    } catch {
+        return false;
+    }
+}
+
+/** The whole client-side path of one send: settle, decide, assemble, hand over. Never rejects. */
+async function attempt(request: SendRequest): Promise<Outcome> {
+    try {
+        await request.saved?.catch(() => undefined);
+        const all = [...request.to, ...request.cc, ...request.bcc];
+        let mailbox = request.mailbox;
+        let policy = request.policy;
+        let statuses: (RecipientEncryptionStatus | undefined)[] = all.map(() => undefined);
+        let lookupsComplete = false;
+
+        if (!request.forcePlaintext) {
+            ({ mailbox, policy } = await completeContext(request));
+            const keys = readSendKeys(request.mailboxUid, request.signEnabled, mailbox);
+            const hasKey = senderHasEncryptionKey({ mailbox, offeredEncrypt: request.offeredEncrypt }, keys.canEncryptSelf);
+            // Recipients' keys are only looked up when the answer can matter: encryption was asked for, or the loaded policy auto-applies.
+            if (mailbox && hasKey && (request.encryptRequested || (policy && policyCanAutoEncrypt(policy)))) {
+                const own = mailbox;
+                const ownPrefersMutual = own.encryptPreference?.preferEncrypt === "mutual";
+                const lookups = await Promise.all(
+                    all.map((recipient) =>
+                        lookupKeys(request.mailboxUid, recipient.address).then(
+                            (lookup) => ({ lookup }),
+                            () => null,
+                        ),
+                    ),
+                );
+                statuses = all.map((recipient, index) => {
+                    const found = lookups[index];
+                    return found ? resolveRecipientEncryption(own.primarySmtpAddress, ownPrefersMutual, policy ?? OPEN_POLICY, recipient.address, found.lookup) : undefined;
+                });
+            }
+            lookupsComplete = true;
+        }
+
+        const decision = decideSend(sendDecisionInput(request, mailbox, policy, statuses, lookupsComplete));
+        if (decision.action === "blocked") {
+            return { kind: "failed", failure: { message: decision.block.message, details: [], block: decision.block } };
+        }
+        if (decision.action === "rejected") {
+            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));
+        const withReceipt = request.requestReceipt ? await setMessageRequestReceipt(assembled, true) : assembled;
+        setPendingStage(request.draft.uid, "queuing");
+        try {
+            if (request.scheduledSendTime) {
+                await sendMessage(withReceipt.uid, { scheduledSendTime: request.scheduledSendTime });
+                return { kind: "scheduled" };
+            }
+            const result = await queueMessageSend(withReceipt.uid);
+            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))) {
+                return { kind: request.scheduledSendTime ? "scheduled" : "queued" };
+            }
+            throw err;
+        }
+    } catch (err) {
+        return { kind: "failed", failure: failureOf(err, request.scheduledSendTime ? "Could not schedule this message." : "Could not send this message.") };
+    }
+}
+
+function recipientSummary(request: SendRequest): string {
+    const all = [...request.to, ...request.cc, ...request.bcc].map((recipient) => recipient.address);
+    return all.length <= 2 ? all.join(" and ") : `${all[0]} and ${all.length - 1} others`;
+}
+
+/** "Message to a@b.c and 2 others (\"Subject\")" - which message a pop-up is about. */
+export function describeMessage(subject: string, recipients: string): string {
+    return `${recipients ? `To ${recipients}` : "Message"}${subject ? ` - "${subject}"` : ""}`;
+}
+
+/** Re-opens the compose window around a request's message, with everything as it was typed. */
+export function openDraftFromRequest(request: SendRequest): boolean {
+    return openComposeFromOutside({
+        mailboxUid: request.mailboxUid,
+        resume: {
+            draft: request.draft,
+            mailboxUid: request.mailboxUid,
+            to: request.toText,
+            cc: request.ccText,
+            bcc: request.bccText,
+            subject: request.subject,
+            html: request.html,
+            attachments: request.attachments,
+            requestReceipt: request.requestReceipt,
+            signEnabled: request.signEnabled,
+            encryptRequested: request.encryptRequested,
+        },
+    });
+}
+
+function failureNotificationId(draftUid: string): string {
+    return `send-failed:${draftUid}`;
+}
+
+/** 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): void {
+    const uid = request.draft.uid;
+    const actions: NotificationAction[] = [];
+    const { block } = failure;
+    if (block?.keysLocked && request.mailbox?.keys?.length) {
+        actions.push({
+            label: "Unlock",
+            onClick: () => {
+                void requestUnlockFromOutside(request.mailboxUid, request.mailbox!.keys!).then(
+                    () => void retrySend(request),
+                    () => undefined,
+                );
+            },
+        });
+    }
+    if (block) {
+        actions.push({ label: block.overrideLabel, onClick: () => void retrySend({ ...request, forcePlaintext: true }) });
+    } else {
+        actions.push({ label: "Retry", onClick: () => void retrySend(request) });
+    }
+    actions.push({ label: "Open draft", onClick: () => void openDraftFromRequest(request) });
+    notify({
+        id: failureNotificationId(uid),
+        kind: "error",
+        title: "This message wasn't sent",
+        message: `${describeMessage(request.subject, recipientSummary(request))}: ${failure.message}`,
+        details: failure.details,
+        actions,
+    });
+}
+
+const SENT_BURST_MS = 6_000;
+
+/** The short "Message sent" confirmation - several sent close together are one pop-up counting up, never a stack of them. */
+export function notifySent(message = "Message sent"): void {
+    const now = Date.now();
+    const { sentBurst } = sendState;
+    sendState.sentBurst = { count: now - sentBurst.at > SENT_BURST_MS ? 1 : sentBurst.count + 1, at: now };
+    notify({ id: "message-sent", kind: "success", title: sendState.sentBurst.count > 1 ? `${sendState.sentBurst.count} messages sent` : message, timeoutMs: 4_000 });
+}
+
+/**
+ * Sends `request`'s draft in the background and returns at once, `true` - or `false` (doing nothing) when a send of this draft is already
+ * under way here. The outcome is shown as pop-ups and the Outbox indicator, never as a window that waits: a failure at any stage (assembling,
+ * encrypting, the request) is a sticky "This message wasn't sent" with the reason, and Retry / Open draft; the server's own later outcome
+ * (`send-succeeded`, `send-failed`, `send-retrying`) is `handleSendEvent()`'s.
+ */
+export function startSend(request: SendRequest): boolean {
+    const uid = request.draft.uid;
+    const recipients = [...request.to, ...request.cc, ...request.bcc].map((recipient) => recipient.address);
+    if (!beginPendingSend({ draftUid: uid, mailboxUid: request.mailboxUid, subject: request.subject, recipients, scheduled: !!request.scheduledSendTime })) {
+        return false;
+    }
+    // The failure of an earlier attempt is resolved by trying again.
+    dismiss(failureNotificationId(uid));
+    const tracker = sendState.countTracker?.(request.mailboxUid);
+    void attempt(request).then((outcome) => {
+        finishPendingSend(uid);
+        if (outcome.kind === "failed") {
+            tracker?.revert();
+            notifyFailure(request, outcome.failure);
+            return;
+        }
+        tracker?.settle();
+        if (outcome.kind === "queued") {
+            retain(request);
+            sendState.queuedListener?.(request.mailboxUid);
+        } else if (outcome.kind === "sent") {
+            notifySent();
+        } else {
+            notify({
+                id: `scheduled:${uid}`,
+                kind: "success",
+                title: "Message scheduled",
+                message: `It will be sent ${new Date(request.scheduledSendTime!).toLocaleString()}.`,
+                timeoutMs: 5_000,
+            });
+        }
+    });
+    return true;
+}
+
+/** Tries a failed send again - unless the server already has the message (an earlier request that seemed to fail did land), which it must not send twice. */
+export async function retrySend(request: SendRequest): Promise<void> {
+    if (await alreadyAccepted(request)) {
+        dismiss(failureNotificationId(request.draft.uid));
+        notify({ id: `already-sent:${request.draft.uid}`, kind: "info", title: "This message is already on its way", timeoutMs: 5_000 });
+        return;
+    }
+    startSend({ ...request, saved: undefined });
+}