@rapidmx/web-client 0.21.0 → 0.23.0

package/apps/shared/components/tasks/layout/TasksShell.tsx

@@ -4,11 +4,12 @@
 ///////////////////////////////////////////////////////////////////////////////
 import React, { createContext, PropsWithChildren, ReactNode, useContext, useEffect, useMemo, useState } from "react";
 import { HiOutlineBars3 } from "react-icons/hi2";
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
-import Drawer from "@rapidmx/react-shared/components/overlays/Drawer.js";
-import { Folder, Mailbox, listFolders, listMailboxes } from "@rapidmx/react-shared/mail/mailApi.js";
-import Alert from "@rapidmx/react-shared/components/feedback/Alert.js";
-import Skeleton, { SkeletonList } from "@rapidmx/react-shared/components/feedback/Skeleton.js";
+import { ApiRequestError } from "../../../../../lib/util/api.js";
+import Drawer from "../../../../../lib/components/overlays/Drawer.js";
+import { Folder, Mailbox, listFolders, listMailboxes } from "../../../../../lib/mail/mailApi.js";
+import { useApiClient } from "../../../../../lib/util/apiClientContext.js";
+import Alert from "../../../../../lib/components/feedback/Alert.js";
+import Skeleton, { SkeletonList } from "../../../../../lib/components/feedback/Skeleton.js";
 import AppShell, { AppShellProps } from "../../layout/AppShell.js";
 import { useLocation, useNavigate } from "../../../navigation/index.js";
 import MailboxProvisioning from "../../layout/MailboxProvisioning.js";
@@ -53,6 +54,7 @@ export default function TasksShell({
     pluginNav,
     children,
 }: PropsWithChildren<TasksShellProps>) {
+    const client = useApiClient();
     const [status, setStatus] = useState<Status>("checking");
     const [error, setError] = useState<string | null>(null);
     const [mailboxes, setMailboxes] = useState<Mailbox[]>([]);
@@ -78,7 +80,7 @@ export default function TasksShell({
         if (!userUid) {
             return;
         }
-        listMailboxes({ limit: 100 })
+        listMailboxes({ limit: 100 }, client)
             .then((result) => {
                 setMailboxes(orderMailboxes(result, userUid));
                 setStatus("ready");
@@ -99,7 +101,7 @@ export default function TasksShell({
             return;
         }
         setFolderError(null);
-        listFolders(mailboxUid)
+        listFolders(mailboxUid, client)
             .then(setFolders)
             .catch((err) => setFolderError(err instanceof ApiRequestError ? err.message : "Could not load this mailbox's tasks folder."));
     }, [mailboxUid]);

package/apps/shared/keyboard/ShortcutsDialog.tsx

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import React from "react";
-import Modal from "@rapidmx/react-shared/components/overlays/Modal.js";
+import Modal from "../../../lib/components/overlays/Modal.js";
 import { formatSpec, specsFor } from "./format.js";
 import { HELP_SCOPES, SCOPE_LABELS, SHORTCUTS, ShortcutDef, shortcutRank } from "./keymap.js";
 import { useKeyEnvironment, useRegisteredShortcuts } from "./ShortcutProvider.js";

package/apps/shared/keyboard/keymap.ts

@@ -66,6 +66,7 @@ export const SHORTCUTS = {
         replyAll: def({ id: "mail.replyAll", keys: ["mod+shift+r"], label: "Reply all", scope: "mail" }),
         forward: def({ id: "mail.forward", keys: ["mod+shift+f"], label: "Forward", scope: "mail" }),
         delete: def({ id: "mail.delete", keys: ["mod+d", "delete"], label: "Delete", scope: "mail" }),
+        permanentDelete: def({ id: "mail.permanentDelete", keys: ["shift+delete"], label: "Delete permanently", scope: "mail" }),
         archive: def({ id: "mail.archive", keys: ["e", "backspace"], label: "Archive", scope: "mail" }),
         move: def({ id: "mail.move", keys: ["mod+shift+v"], label: "Move to folder", scope: "mail" }),
         markRead: def({ id: "mail.markRead", keys: ["ctrl+q"], label: "Mark as read", scope: "mail" }),

package/apps/shared/mail/decryptedMessages.ts

@@ -0,0 +1,116 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { useSyncExternalStore } from "react";
+import { getUnlockedKeys, subscribeKeySession } from "../../../lib/crypto/keySession.js";
+import { getMessageRawContent } from "../../../lib/mail/mailApi.js";
+
+/**
+ * What this device has recovered of encrypted messages by decrypting them: the real subject (the server only ever holds RFC 9788's `[...]`
+ * placeholder) and a short preview. Shared by every view that draws a message - the message list, the conversation list and the reading pane -
+ * so a message decrypted in one shows its subject in all of them. Held in memory only, keyed by message uid, and dropped for a mailbox the moment
+ * its keys are locked, exactly like the decrypted content it came from.
+ */
+export interface DecryptedMessage {
+    mailboxUid: string;
+    subject?: string;
+    preview?: string;
+}
+
+const PREVIEW_MAX_LENGTH = 160;
+
+let entries: Record<string, DecryptedMessage> = {};
+/** Bumped whenever a mailbox's keys are unlocked, so a view can retry decrypting what it couldn't before. */
+let unlockEpoch = 0;
+const listeners = new Set<() => void>();
+const inFlight = new Set<string>();
+
+function emit(): void {
+    for (const listener of [...listeners]) {
+        listener();
+    }
+}
+
+subscribeKeySession(({ mailboxUid, state }) => {
+    if (state === "locked") {
+        const kept = Object.fromEntries(Object.entries(entries).filter(([, entry]) => entry.mailboxUid !== mailboxUid));
+        if (Object.keys(kept).length !== Object.keys(entries).length) {
+            entries = kept;
+        }
+    } else {
+        unlockEpoch++;
+    }
+    emit();
+});
+
+function subscribe(listener: () => void): () => void {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+
+/** Plain text of decrypted HTML for a one-line preview. Only ever feeds text display, never markup. */
+export function previewOf(html: string): string {
+    return html
+        .replace(/<(script|style)[^>]*>[\s\S]*?<\/\1>/gi, " ")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/gi, " ")
+        .replace(/&amp;/gi, "&")
+        .replace(/&lt;/gi, "<")
+        .replace(/&gt;/gi, ">")
+        .replace(/&quot;/gi, '"')
+        .replace(/&#0*39;/gi, "'")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, PREVIEW_MAX_LENGTH);
+}
+
+/** Remembers what was recovered of one message. Ignored when there is nothing new to show. */
+export function rememberDecrypted(uid: string, mailboxUid: string, found: { subject?: string; preview?: string }): void {
+    if (!found.subject && !found.preview) {
+        return;
+    }
+    const current = entries[uid];
+    if (current && current.subject === found.subject && current.preview === found.preview) {
+        return;
+    }
+    entries = { ...entries, [uid]: { mailboxUid, subject: found.subject, preview: found.preview } };
+    emit();
+}
+
+/** Every message decrypted so far, by uid; a new object whenever any changes. */
+export function useDecryptedMessages(): Record<string, DecryptedMessage> {
+    return useSyncExternalStore(subscribe, () => entries);
+}
+
+/** A number that changes whenever a mailbox is unlocked - a dependency for effects that decrypt what they can. */
+export function useUnlockEpoch(): number {
+    return useSyncExternalStore(subscribe, () => unlockEpoch);
+}
+
+/**
+ * Decrypts one message to recover its subject and preview, when its mailbox's keys are unlocked and it isn't already known. Best effort: a
+ * message that can't be fetched or opened is simply left as it was. Never prompts.
+ */
+export async function decryptForDisplay(uid: string, mailboxUid: string): Promise<void> {
+    const unlocked = getUnlockedKeys(mailboxUid);
+    if (!unlocked || entries[uid] || inFlight.has(uid)) {
+        return;
+    }
+    inFlight.add(uid);
+    try {
+        const rawMime = await getMessageRawContent(uid);
+        const { evaluateMessageSecurity } = await import("../../../lib/crypto/messageSecurity.js");
+        const security = await evaluateMessageSecurity(rawMime, unlocked);
+        // A lock while this ran: the result must not go back on screen.
+        if (getUnlockedKeys(mailboxUid) === unlocked) {
+            rememberDecrypted(uid, mailboxUid, { subject: security.subject, preview: security.html ? previewOf(security.html) : security.text?.slice(0, PREVIEW_MAX_LENGTH) });
+        }
+    } catch {
+        // Left as the placeholder.
+    } finally {
+        inFlight.delete(uid);
+    }
+}

package/apps/shared/mail/findWellKnownFolderUid.ts

@@ -2,12 +2,14 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { FolderType, listFolders } from "@rapidmx/react-shared/mail/mailApi.js";
+import { FolderType, listFolders } from "../../../lib/mail/mailApi.js";
+import { ApiClient } from "../../../lib/util/api.js";
 
 /** The uid of a mailbox's well-known folder of `type` (e.g. its Contacts or Tasks folder), for creating an
  * item in a mailbox other than the one an app currently has loaded. Resolves `undefined` if the mailbox has
- * no such folder; rejects if the folder list can't be fetched. */
-export async function findWellKnownFolderUid(mailboxUid: string, type: FolderType): Promise<string | undefined> {
-    const folders = await listFolders(mailboxUid);
+ * no such folder; rejects if the folder list can't be fetched. `client`, when given, is threaded through to
+ * `listFolders()` (see `useApiClient()`'s own doc comment) - omitted, this behaves exactly as before. */
+export async function findWellKnownFolderUid(mailboxUid: string, type: FolderType, client?: ApiClient): Promise<string | undefined> {
+    const folders = await listFolders(mailboxUid, client);
     return folders.find((folder) => folder.type === type)?.uid;
 }

package/apps/shared/mail/folderCounts.ts

@@ -3,7 +3,8 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useCallback, useEffect, useRef, useState } from "react";
-import { Folder, FolderType, Mailbox, Message, listFolders } from "@rapidmx/react-shared/mail/mailApi.js";
+import { Folder, FolderType, Mailbox, Message, listFolders } from "../../../lib/mail/mailApi.js";
+import { useApiClient } from "../../../lib/util/apiClientContext.js";
 
 /**
  * The folder badges' numbers, kept right without a reload.
@@ -150,9 +151,10 @@ export interface FolderCounts {
  * each was loaded with); `mailboxes` is whose folders to read back. The overlay starts again whenever `mailboxes` does.
  */
 export function useFolderCounts(mailboxes: Mailbox[], folders: Folder[], onFoldersListed?: (folders: Folder[]) => void): FolderCounts {
+    const client = useApiClient();
     const [counts, setCounts] = useState<Record<string, FolderCount>>({});
-    const latestRef = useRef({ mailboxes, folders, onFoldersListed });
-    latestRef.current = { mailboxes, folders, onFoldersListed };
+    const latestRef = useRef({ mailboxes, folders, onFoldersListed, client });
+    latestRef.current = { mailboxes, folders, onFoldersListed, client };
     // Bumped by every change of the overlay this page makes, so a read that started before one can tell it is out of date.
     const changesRef = useRef(0);
     const inFlightRef = useRef(0);
@@ -202,7 +204,9 @@ export function useFolderCounts(mailboxes: Mailbox[], folders: Folder[], onFolde
         timerRef.current = undefined;
         const run = ++runRef.current;
         const startedAt = changesRef.current;
-        const results = await Promise.all(latestRef.current.mailboxes.map((mailbox) => listFolders(mailbox.uid).catch(() => undefined)));
+        const results = await Promise.all(
+            latestRef.current.mailboxes.map((mailbox) => listFolders(mailbox.uid, latestRef.current.client).catch(() => undefined)),
+        );
         if (stoppedRef.current || run !== runRef.current) {
             return;
         }

package/apps/shared/mail/folderOfType.ts

@@ -2,7 +2,8 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { Folder, createFolder, listFolders } from "@rapidmx/react-shared/mail/mailApi.js";
+import { Folder, createFolder, listFolders } from "../../../lib/mail/mailApi.js";
+import type { ApiClient } from "../../../lib/util/api.js";
 
 /** The folders this page load has had to look up or make for a mailbox, so a second Report junk does not ask again. */
 const resolved = new Map<string, string>();
@@ -27,6 +28,7 @@ export async function resolveFolderOfType(
     name: string,
     known: Folder[] = [],
     onFound?: (folder: Folder) => void,
+    client?: ApiClient,
 ): Promise<string> {
     const inTree = known.find((folder) => folder.mailboxUid === mailboxUid && folder.type === type);
     if (inTree) {
@@ -37,13 +39,13 @@ export async function resolveFolderOfType(
     if (remembered) {
         return remembered;
     }
-    const listed = (await listFolders(mailboxUid)).find((folder) => folder.type === type);
+    const listed = (await listFolders(mailboxUid, client)).find((folder) => folder.type === type);
     if (listed) {
         onFound?.(listed);
         resolved.set(key, listed.uid);
         return listed.uid;
     }
-    const created = await createFolder({ mailboxUid, name, type });
+    const created = await createFolder({ mailboxUid, name, type }, client);
     resolved.set(key, created.uid);
     return created.uid;
 }

package/apps/shared/mail/folderTree.ts

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import type { Folder } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Folder } from "../../../lib/mail/mailApi.js";
 import type { MailboxFolders } from "../components/mail/layout/MailShell.js";
 
 /**

package/apps/shared/mail/listSnapshots.ts

@@ -2,8 +2,8 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import type { ConversationSummary } from "@rapidmx/react-shared/mail/conversationsApi.js";
-import type { Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { ConversationSummary } from "../../../lib/mail/conversationsApi.js";
+import type { Message } from "../../../lib/mail/mailApi.js";
 
 /**
  * A short-lived, in-memory copy of a folder's listing, so that switching to a folder that was shown a moment ago (or coming back

package/apps/shared/mail/messageReadState.ts

@@ -2,7 +2,8 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { Message, setMessageRead, setMessagesRead } from "@rapidmx/react-shared/mail/mailApi.js";
+import { Message, setMessageRead, setMessagesRead } from "../../../lib/mail/mailApi.js";
+import type { ApiClient } from "../../../lib/util/api.js";
 import type { CountTracker } from "./folderCounts.js";
 
 /**
@@ -38,7 +39,7 @@ function needsChange(message: Message, read: boolean): boolean {
  * doing (it already was that way) or the server refused - in which case everything has already been put back as it was.
  * Never rejects: like the old mark-as-read, a failure must not get in the way of reading the message.
  */
-export async function setReadState(message: Message, read: boolean, sink: ReadStateSink): Promise<Message | undefined> {
+export async function setReadState(message: Message, read: boolean, sink: ReadStateSink, client?: ApiClient): Promise<Message | undefined> {
     if (!needsChange(message, read)) {
         return undefined;
     }
@@ -46,7 +47,7 @@ export async function setReadState(message: Message, read: boolean, sink: ReadSt
     sink.patch(optimistic, message);
     const tracker = sink.track(message, optimistic);
     try {
-        const updated = await setMessageRead(message, read);
+        const updated = await setMessageRead(message, read, client);
         sink.patch(updated);
         tracker.settle();
         return updated;
@@ -62,14 +63,14 @@ export async function setReadState(message: Message, read: boolean, sink: ReadSt
  * it rejects when the server refuses (after putting everything back), because a bulk update is not atomic - some of it may
  * have landed - and the caller's own handling reloads the list and says so (see `bulkUpdateMessages()`).
  */
-export async function setReadStateMany(messages: Message[], read: boolean, sink: ReadStateSink): Promise<Message[]> {
+export async function setReadStateMany(messages: Message[], read: boolean, sink: ReadStateSink, client?: ApiClient): Promise<Message[]> {
     const changes = messages.filter((message) => needsChange(message, read)).map((message) => ({ message, optimistic: withRead(message, read) }));
     const trackers = changes.map(({ message, optimistic }) => {
         sink.patch(optimistic, message);
         return sink.track(message, optimistic);
     });
     try {
-        const updated = await setMessagesRead(messages, read);
+        const updated = await setMessagesRead(messages, read, client);
         for (const message of updated) {
             sink.patch(message);
         }

package/apps/shared/mail/newMailNotifications.ts

@@ -2,8 +2,8 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import type { Folder, Mailbox, Message } from "@rapidmx/react-shared/mail/mailApi.js";
-import { formatMailAddress, splitMailAddress } from "@rapidmx/react-shared/mail/mailAddress.js";
+import type { Folder, Mailbox, Message } from "../../../lib/mail/mailApi.js";
+import { formatMailAddress, splitMailAddress } from "../../../lib/mail/mailAddress.js";
 
 /**
  * What decides whether a new message is announced, what the announcement says, and the setting behind it (per browser, in

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

@@ -2,8 +2,8 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import type { Attachment, Message } from "@rapidmx/react-shared/mail/mailApi.js";
-import type { PublicKey } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import type { Attachment, Message } from "../../../../lib/mail/mailApi.js";
+import type { PublicKey } from "../../../../lib/crypto/keyvaultApi.js";
 
 /**
  * A compose window to re-open around a message that was already composed: a failed send's "Open draft". The message keeps its uid - the

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

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import type { Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Message } from "../../../../lib/mail/mailApi.js";
 
 /**
  * What a message in Outbox is doing, read from the fields the server keeps on it (`scheduledSend*`):

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

@@ -3,8 +3,8 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useSyncExternalStore } from "react";
-import type { Message } from "@rapidmx/react-shared/mail/mailApi.js";
-import type { MailAddressLike } from "@rapidmx/react-shared/mail/mailAddress.js";
+import type { Message } from "../../../../lib/mail/mailApi.js";
+import type { MailAddressLike } from "../../../../lib/mail/mailAddress.js";
 import type { NotificationAction } from "../../notifications/store.js";
 import type { SendRequest } from "./sendJob.js";
 

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

@@ -2,8 +2,8 @@
 // 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 { RecipientEncryptionStatus, decideMessageEncryption } from "../../../../lib/crypto/composeSecurity.js";
+import type { EncryptionPolicy } from "../../../../lib/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

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

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
+import { ApiRequestError, type ApiClient } from "../../../../lib/util/api.js";
 import {
     Attachment,
     ComposeRecipientInput,
@@ -16,13 +16,13 @@ import {
     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";
+} 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 { EncryptionPolicy, findActivePublicKey, getEncryptionPolicy, lookupKeys } from "../../../../lib/crypto/keyvaultApi.js";
+import { fromBase64 } from "../../../../lib/crypto/encoding.js";
+import type { ProtectedHeaders } from "../../../../lib/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";
@@ -157,16 +157,16 @@ type Outcome = { kind: "queued" | "sent" | "scheduled" } | { kind: "failed"; fai
 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 }> {
+async function completeContext(request: SendRequest, client: ApiClient | undefined): 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)));
+        loads.push(getMailbox(request.mailboxUid, undefined, client).then((loaded) => void (mailbox = loaded)));
     }
     if (!policy && (!mailbox || senderHasEncryptionKey({ mailbox, offeredEncrypt: request.offeredEncrypt }, keysNow.canEncryptSelf))) {
-        loads.push(getEncryptionPolicy().then((loaded) => void (policy = loaded)));
+        loads.push(getEncryptionPolicy(client).then((loaded) => void (policy = loaded)));
     }
     if (loads.length > 0) {
         let timer: ReturnType<typeof setTimeout> | undefined;
@@ -186,10 +186,11 @@ async function assemble(
     mode: "plain" | "sign" | "encrypt",
     statuses: (RecipientEncryptionStatus | undefined)[],
     withSignature: boolean,
+    client: ApiClient | undefined,
 ): Promise<Message> {
     const { draft, to, cc, bcc, subject, html } = request;
     if (mode === "plain") {
-        return assembleDraft(draft.uid, { to, cc, bcc, subject, html });
+        return assembleDraft(draft.uid, { to, cc, bcc, subject, html }, client);
     }
     const keys = readSendKeys(request.mailboxUid, request.signEnabled, mailbox);
     const own = mailbox!;
@@ -208,7 +209,7 @@ async function assemble(
     // 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"
+        "../../../../lib/crypto/smimeMessage.js"
     );
     const encrypt = mode === "encrypt";
     const outerHeaders = encrypt ? applyBaselineOuterHeaders(protectedHeaders) : protectedHeaders;
@@ -223,7 +224,7 @@ async function assemble(
           )
         : 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 });
+    return assembleDraftRaw(draft.uid, { to, cc, bcc, subject: outerHeaders.subject, rawMime }, client);
 }
 
 function failureOf(err: unknown, fallback: string): Failure {
@@ -232,17 +233,18 @@ function failureOf(err: unknown, fallback: string): Failure {
 }
 
 /** 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> {
+async function alreadyAccepted(request: SendRequest, client: ApiClient | undefined): Promise<boolean> {
     try {
-        const fresh = await getMessage(request.draft.uid);
+        const fresh = await getMessage(request.draft.uid, client);
         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> {
+/** 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> {
     try {
         await request.saved?.catch(() => undefined);
         const all = [...request.to, ...request.cc, ...request.bcc];
@@ -252,7 +254,7 @@ async function attempt(request: SendRequest): Promise<Outcome> {
         let lookupsComplete = false;
 
         if (!request.forcePlaintext) {
-            ({ mailbox, policy } = await completeContext(request));
+            ({ mailbox, policy } = await completeContext(request, client));
             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.
@@ -261,7 +263,7 @@ async function attempt(request: SendRequest): Promise<Outcome> {
                 const ownPrefersMutual = own.encryptPreference?.preferEncrypt === "mutual";
                 const lookups = await Promise.all(
                     all.map((recipient) =>
-                        lookupKeys(request.mailboxUid, recipient.address).then(
+                        lookupKeys(request.mailboxUid, recipient.address, client).then(
                             (lookup) => ({ lookup }),
                             () => null,
                         ),
@@ -283,19 +285,19 @@ async function attempt(request: SendRequest): Promise<Outcome> {
             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;
+        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;
         setPendingStage(request.draft.uid, "queuing");
         try {
             if (request.scheduledSendTime) {
-                await sendMessage(withReceipt.uid, { scheduledSendTime: request.scheduledSendTime });
+                await sendMessage(withReceipt.uid, { scheduledSendTime: request.scheduledSendTime }, client);
                 return { kind: "scheduled" };
             }
-            const result = await queueMessageSend(withReceipt.uid);
+            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))) {
+            if (!(err instanceof ApiRequestError) && (await alreadyAccepted(request, client))) {
                 return { kind: request.scheduledSendTime ? "scheduled" : "queued" };
             }
             throw err;
@@ -345,7 +347,7 @@ function failureNotificationId(draftUid: string): string {
 }
 
 /** 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 {
+function notifyFailure(request: SendRequest, failure: Failure, client: ApiClient | undefined): void {
     const uid = request.draft.uid;
     const actions: NotificationAction[] = [];
     const { block } = failure;
@@ -354,16 +356,16 @@ function notifyFailure(request: SendRequest, failure: Failure): void {
             label: "Unlock",
             onClick: () => {
                 void requestUnlockFromOutside(request.mailboxUid, request.mailbox!.keys!).then(
-                    () => void retrySend(request),
+                    () => void retrySend(request, client),
                     () => undefined,
                 );
             },
         });
     }
     if (block) {
-        actions.push({ label: block.overrideLabel, onClick: () => void retrySend({ ...request, forcePlaintext: true }) });
+        actions.push({ label: block.overrideLabel, onClick: () => void retrySend({ ...request, forcePlaintext: true }, client) });
     } else {
-        actions.push({ label: "Retry", onClick: () => void retrySend(request) });
+        actions.push({ label: "Retry", onClick: () => void retrySend(request, client) });
     }
     actions.push({ label: "Open draft", onClick: () => void openDraftFromRequest(request) });
     notify({
@@ -393,8 +395,11 @@ export function notifySent(message = "Message sent"): void {
  * 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.
+ *
+ * `client` is the explicit `ApiClient` (from `useApiClient()`) the compose window that built `request` was rendered under - `undefined` (the
+ * default) for every existing caller, which keeps using the default global cookie-based session exactly as before.
  */
-export function startSend(request: SendRequest): boolean {
+export function startSend(request: SendRequest, client?: ApiClient): 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 })) {
@@ -405,11 +410,11 @@ export function startSend(request: SendRequest): boolean {
     // A reply or forward is on screen in its conversation from this moment, before any of the work below.
     trackOutgoing(request);
     const tracker = sendState.countTracker?.(request.mailboxUid);
-    void attempt(request).then((outcome) => {
+    void attempt(request, client).then((outcome) => {
         finishPendingSend(uid);
         if (outcome.kind === "failed") {
             tracker?.revert();
-            notifyFailure(request, outcome.failure);
+            notifyFailure(request, outcome.failure, client);
             return;
         }
         tracker?.settle();
@@ -434,12 +439,12 @@ export function startSend(request: SendRequest): boolean {
 }
 
 /** 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)) {
+export async function retrySend(request: SendRequest, client?: ApiClient): Promise<void> {
+    if (await alreadyAccepted(request, client)) {
         dismiss(failureNotificationId(request.draft.uid));
         markOutgoingSending(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 });
+    startSend({ ...request, saved: undefined }, client);
 }