@rapidmx/web-client 0.21.0 → 0.22.0

package/dist/apps/shared/mail/findWellKnownFolderUid.js

@@ -2,11 +2,12 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { listFolders } from "@rapidmx/react-shared/mail/mailApi.js";
+import { listFolders } from "../../../lib/mail/mailApi.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, type) {
-    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, type, client) {
+    const folders = await listFolders(mailboxUid, client);
     return folders.find((folder) => folder.type === type)?.uid;
 }

package/dist/apps/shared/mail/folderCounts.d.ts

@@ -1,4 +1,4 @@
-import { Folder, FolderType, Mailbox, Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import { Folder, FolderType, Mailbox, Message } from "../../../lib/mail/mailApi.js";
 /**
  * The folder badges' numbers, kept right without a reload.
  *

package/dist/apps/shared/mail/folderCounts.js

@@ -3,7 +3,8 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useCallback, useEffect, useRef, useState } from "react";
-import { listFolders } from "@rapidmx/react-shared/mail/mailApi.js";
+import { listFolders } from "../../../lib/mail/mailApi.js";
+import { useApiClient } from "../../../lib/util/apiClientContext.js";
 /** What one message change - a new message (`previous` absent), a deletion (`next` absent), a read/unread flip, a move - does to the folders' counts. */
 export function countDeltas(previous, next) {
     const byFolder = new Map();
@@ -75,9 +76,10 @@ const SEEN_LIMIT = 500;
  * each was loaded with); `mailboxes` is whose folders to read back. The overlay starts again whenever `mailboxes` does.
  */
 export function useFolderCounts(mailboxes, folders, onFoldersListed) {
+    const client = useApiClient();
     const [counts, setCounts] = useState({});
-    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);
@@ -124,7 +126,7 @@ export function useFolderCounts(mailboxes, folders, onFoldersListed) {
         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/dist/apps/shared/mail/folderOfType.d.ts

@@ -1,4 +1,5 @@
-import { Folder } from "@rapidmx/react-shared/mail/mailApi.js";
+import { Folder } from "../../../lib/mail/mailApi.js";
+import type { ApiClient } from "../../../lib/util/api.js";
 /** Forgets every remembered folder - for the tests. */
 export declare function clearResolvedFolders(): void;
 /**
@@ -10,4 +11,4 @@ export declare function clearResolvedFolders(): void;
  * lacks is asked for - the tree may only be out of date - and used, never created twice; only a server that really has none is asked to
  * make it. `onFound` is told about a folder the tree did not have, so the sidebar picks it up.
  */
-export declare function resolveFolderOfType(mailboxUid: string, type: Folder["type"], name: string, known?: Folder[], onFound?: (folder: Folder) => void): Promise<string>;
+export declare function resolveFolderOfType(mailboxUid: string, type: Folder["type"], name: string, known?: Folder[], onFound?: (folder: Folder) => void, client?: ApiClient): Promise<string>;

package/dist/apps/shared/mail/folderOfType.js

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { createFolder, listFolders } from "@rapidmx/react-shared/mail/mailApi.js";
+import { createFolder, listFolders } from "../../../lib/mail/mailApi.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();
 /** Forgets every remembered folder - for the tests. */
@@ -18,7 +18,7 @@ export function clearResolvedFolders() {
  * lacks is asked for - the tree may only be out of date - and used, never created twice; only a server that really has none is asked to
  * make it. `onFound` is told about a folder the tree did not have, so the sidebar picks it up.
  */
-export async function resolveFolderOfType(mailboxUid, type, name, known = [], onFound) {
+export async function resolveFolderOfType(mailboxUid, type, name, known = [], onFound, client) {
     const inTree = known.find((folder) => folder.mailboxUid === mailboxUid && folder.type === type);
     if (inTree) {
         return inTree.uid;
@@ -28,13 +28,13 @@ export async function resolveFolderOfType(mailboxUid, type, name, known = [], on
     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/dist/apps/shared/mail/folderTree.d.ts

@@ -1,4 +1,4 @@
-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";
 /**
  * The sidebar's order of a mailbox's well-known folders; anything else (`user`) follows, alphabetically. Also the order push channels are asked

package/dist/apps/shared/mail/listSnapshots.d.ts

@@ -1,5 +1,5 @@
-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
  * to Mail from another app) shows its rows on the very frame of the click and revalidates behind them (stale-while-revalidate),

package/dist/apps/shared/mail/messageReadState.d.ts

@@ -1,4 +1,5 @@
-import { Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import { Message } from "../../../lib/mail/mailApi.js";
+import type { ApiClient } from "../../../lib/util/api.js";
 import type { CountTracker } from "./folderCounts.js";
 /**
  * The one way a message's read state changes in the webmail, so that every place that shows it moves together: the row in
@@ -23,10 +24,10 @@ export interface ReadStateSink {
  * 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 declare function setReadState(message: Message, read: boolean, sink: ReadStateSink): Promise<Message | undefined>;
+export declare function setReadState(message: Message, read: boolean, sink: ReadStateSink, client?: ApiClient): Promise<Message | undefined>;
 /**
  * The same for a whole selection, in one request. Resolves the updated messages, in request order. Unlike `setReadState()`
  * 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 declare function setReadStateMany(messages: Message[], read: boolean, sink: ReadStateSink): Promise<Message[]>;
+export declare function setReadStateMany(messages: Message[], read: boolean, sink: ReadStateSink, client?: ApiClient): Promise<Message[]>;

package/dist/apps/shared/mail/messageReadState.js

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { setMessageRead, setMessagesRead } from "@rapidmx/react-shared/mail/mailApi.js";
+import { setMessageRead, setMessagesRead } from "../../../lib/mail/mailApi.js";
 function withRead(message, read) {
     return { ...message, flags: { ...message.flags, read } };
 }
@@ -15,7 +15,7 @@ function needsChange(message, read) {
  * 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, read, sink) {
+export async function setReadState(message, read, sink, client) {
     if (!needsChange(message, read)) {
         return undefined;
     }
@@ -23,7 +23,7 @@ export async function setReadState(message, read, sink) {
     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;
@@ -39,14 +39,14 @@ export async function setReadState(message, read, sink) {
  * 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, read, sink) {
+export async function setReadStateMany(messages, read, sink, client) {
     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/dist/apps/shared/mail/newMailNotifications.d.ts

@@ -1,4 +1,4 @@
-import type { Folder, Mailbox, Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Folder, Mailbox, Message } from "../../../lib/mail/mailApi.js";
 /**
  * What decides whether a new message is announced, what the announcement says, and the setting behind it (per browser, in
  * `localStorage`): what the user told the "turn on desktop notifications" offer. Whether pop-ups are on at all is the

package/dist/apps/shared/mail/newMailNotifications.js

@@ -1,4 +1,4 @@
-import { formatMailAddress, splitMailAddress } from "@rapidmx/react-shared/mail/mailAddress.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
  * `localStorage`): what the user told the "turn on desktop notifications" offer. Whether pop-ups are on at all is the

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

@@ -1,5 +1,5 @@
-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
  * server draft it was assembled into - and everything the sender had typed comes back exactly as it was, including what could not have

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

@@ -1,4 +1,4 @@
-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/dist/apps/shared/mail/outbox/outgoingReplies.d.ts

@@ -1,5 +1,5 @@
-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/dist/apps/shared/mail/outbox/sendDecision.d.ts

@@ -1,5 +1,5 @@
-import { RecipientEncryptionStatus } from "@rapidmx/react-shared/crypto/composeSecurity.js";
-import type { EncryptionPolicy } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import { RecipientEncryptionStatus } from "../../../../lib/crypto/composeSecurity.js";
+import type { EncryptionPolicy } from "../../../../lib/crypto/keyvaultApi.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. */

package/dist/apps/shared/mail/outbox/sendDecision.js

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { decideMessageEncryption } from "@rapidmx/react-shared/crypto/composeSecurity.js";
+import { decideMessageEncryption } from "../../../../lib/crypto/composeSecurity.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

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

@@ -1,6 +1,7 @@
-import { Attachment, ComposeRecipientInput, DraftThreading, Mailbox, Message } from "@rapidmx/react-shared/mail/mailApi.js";
-import { RecipientEncryptionStatus } from "@rapidmx/react-shared/crypto/composeSecurity.js";
-import { EncryptionPolicy } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import { type ApiClient } from "../../../../lib/util/api.js";
+import { Attachment, ComposeRecipientInput, DraftThreading, Mailbox, Message } from "../../../../lib/mail/mailApi.js";
+import { RecipientEncryptionStatus } from "../../../../lib/crypto/composeSecurity.js";
+import { EncryptionPolicy } from "../../../../lib/crypto/keyvaultApi.js";
 import { SendDecisionInput } from "./sendDecision.js";
 import { OutboxCountTracker } 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. */
@@ -47,7 +48,7 @@ export declare function retainedRequest(draftUid: string): SendRequest | undefin
 export declare function forgetRetainedRequest(draftUid: string): void;
 /** The sender's signing/encryption key state right now, read from the tab's key session (they can lock mid-send). */
 export declare function readSendKeys(mailboxUid: string, signEnabled: boolean, mailbox: Mailbox | undefined): {
-    unlocked: import("@rapidmx/react-shared/crypto/keySession.js").UnlockedKeys | undefined;
+    unlocked: import("../../../../lib/crypto/keySession.js").UnlockedKeys | undefined;
     canSign: boolean;
     canEncryptSelf: boolean;
 };
@@ -66,7 +67,10 @@ export declare function notifySent(message?: string): 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 declare function startSend(request: SendRequest): boolean;
+export declare function startSend(request: SendRequest, client?: ApiClient): 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 declare function retrySend(request: SendRequest): Promise<void>;
+export declare function retrySend(request: SendRequest, client?: ApiClient): Promise<void>;

package/dist/apps/shared/mail/outbox/sendJob.js

@@ -2,13 +2,13 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
-import { assembleDraft, assembleDraftRaw, getMailbox, getMessage, queueMessageSend, sendMessage, setMessageRequestReceipt, } from "@rapidmx/react-shared/mail/mailApi.js";
-import { describeSendFailure } from "@rapidmx/react-shared/mail/sendFailure.js";
-import { resolveRecipientEncryption } from "@rapidmx/react-shared/crypto/composeSecurity.js";
-import { getUnlockedKeys } from "@rapidmx/react-shared/crypto/keySession.js";
-import { findActivePublicKey, getEncryptionPolicy, lookupKeys } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
-import { fromBase64 } from "@rapidmx/react-shared/crypto/encoding.js";
+import { ApiRequestError } from "../../../../lib/util/api.js";
+import { assembleDraft, assembleDraftRaw, getMailbox, getMessage, queueMessageSend, sendMessage, setMessageRequestReceipt, } from "../../../../lib/mail/mailApi.js";
+import { describeSendFailure } from "../../../../lib/mail/sendFailure.js";
+import { resolveRecipientEncryption } from "../../../../lib/crypto/composeSecurity.js";
+import { getUnlockedKeys } from "../../../../lib/crypto/keySession.js";
+import { findActivePublicKey, getEncryptionPolicy, lookupKeys } from "../../../../lib/crypto/keyvaultApi.js";
+import { fromBase64 } from "../../../../lib/crypto/encoding.js";
 import { policyCanAutoEncrypt } from "../../components/mail/compose/encryptionRequirement.js";
 import { dismiss, notify } from "../../notifications/store.js";
 import { INLINE_IMAGE_PATTERN, decideSend } from "./sendDecision.js";
@@ -79,16 +79,16 @@ export function sendDecisionInput(request, mailbox, policy, recipients, lookupsC
 }
 const OPEN_POLICY = { 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) {
+async function completeContext(request, client) {
     let mailbox = request.mailbox;
     let policy = request.policy;
     const keysNow = readSendKeys(request.mailboxUid, request.signEnabled, mailbox);
     const loads = [];
     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;
@@ -101,10 +101,10 @@ async function completeContext(request) {
     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, mailbox, mode, statuses, withSignature) {
+async function assemble(request, mailbox, mode, statuses, withSignature, client) {
     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;
@@ -122,31 +122,32 @@ async function assemble(request, mailbox, mode, statuses, withSignature) {
     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 { applyBaselineOuterHeaders, assembleOutboundMime, buildEncryptedMessage, buildSignedOnlyMessage } = await import("../../../../lib/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 });
+    return assembleDraftRaw(draft.uid, { to, cc, bcc, subject: outerHeaders.subject, rawMime }, client);
 }
 function failureOf(err, fallback) {
     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) {
+async function alreadyAccepted(request, client) {
     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) {
+/** 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, client) {
     try {
         await request.saved?.catch(() => undefined);
         const all = [...request.to, ...request.cc, ...request.bcc];
@@ -155,14 +156,14 @@ async function attempt(request) {
         let statuses = all.map(() => undefined);
         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.
             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)));
+                const lookups = await Promise.all(all.map((recipient) => lookupKeys(request.mailboxUid, recipient.address, client).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;
@@ -177,20 +178,20 @@ async function attempt(request) {
         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;
+        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;
@@ -236,7 +237,7 @@ function failureNotificationId(draftUid) {
     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, failure) {
+function notifyFailure(request, failure, client) {
     const uid = request.draft.uid;
     const actions = [];
     const { block } = failure;
@@ -244,15 +245,15 @@ function notifyFailure(request, failure) {
         actions.push({
             label: "Unlock",
             onClick: () => {
-                void requestUnlockFromOutside(request.mailboxUid, request.mailbox.keys).then(() => void retrySend(request), () => undefined);
+                void requestUnlockFromOutside(request.mailboxUid, request.mailbox.keys).then(() => 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({
@@ -279,8 +280,11 @@ export function notifySent(message = "Message sent") {
  * 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) {
+export function startSend(request, client) {
     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 })) {
@@ -291,11 +295,11 @@ export function startSend(request) {
     // 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();
@@ -321,12 +325,12 @@ export function startSend(request) {
     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) {
-    if (await alreadyAccepted(request)) {
+export async function retrySend(request, client) {
+    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: 5000 });
         return;
     }
-    startSend({ ...request, saved: undefined });
+    startSend({ ...request, saved: undefined }, client);
 }

package/dist/apps/shared/mail/outbox/sendOutcomes.d.ts

@@ -1,3 +1,6 @@
-import { SendEvent } from "@rapidmx/react-shared/mail/sendEvents.js";
-/** Shows what a send event means to the user. */
-export declare function handleSendEvent(event: SendEvent): void;
+import { SendEvent } from "../../../../lib/mail/sendEvents.js";
+import type { ApiClient } from "../../../../lib/util/api.js";
+/** Shows what a send event means to the user. `client` is the explicit `ApiClient` (from `useApiClient()`) whichever code observed this push
+ * event was rendered under - `undefined` (the default) for every existing caller, which keeps using the default global cookie-based session
+ * exactly as before. */
+export declare function handleSendEvent(event: SendEvent, client?: ApiClient): void;

package/dist/apps/shared/mail/outbox/sendOutcomes.js

@@ -2,8 +2,8 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { cancelScheduledSend, getMessage, listAttachments, listFolders, queueMessageSend } from "@rapidmx/react-shared/mail/mailApi.js";
-import { describeSendEventError } from "@rapidmx/react-shared/mail/sendEvents.js";
+import { cancelScheduledSend, getMessage, listAttachments, listFolders, queueMessageSend } from "../../../../lib/mail/mailApi.js";
+import { describeSendEventError } from "../../../../lib/mail/sendEvents.js";
 import { formatRecipient } from "../../components/mail/compose/recipients.js";
 import { loadOriginalMessage } from "../../components/mail/compose/quotedBody.js";
 import { notifyApiError } from "../../notifications/apiErrors.js";
@@ -25,21 +25,21 @@ function summary(recipients) {
     return recipients.length <= 2 ? recipients.join(" and ") : `${recipients[0]} and ${recipients.length - 1} others`;
 }
 /** Moves a message the server failed to relay back into Drafts (the only place it can be edited or sent again), and returns it as it is there. */
-async function moveBackToDrafts(uid, mailboxUid) {
-    const message = await getMessage(uid);
-    const drafts = (await listFolders(mailboxUid)).find((folder) => folder.type === "drafts");
+async function moveBackToDrafts(uid, mailboxUid, client) {
+    const message = await getMessage(uid, client);
+    const drafts = (await listFolders(mailboxUid, client)).find((folder) => folder.type === "drafts");
     if (!drafts || message.folderUid === drafts.uid) {
         return message;
     }
-    return cancelScheduledSend(message, drafts.uid);
+    return cancelScheduledSend(message, drafts.uid, client);
 }
 function escapeHtml(text) {
     return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 /** "Open draft" for a message the server failed to relay: back into Drafts, and into a compose window with what was written. */
-async function openFailedDraft(event) {
+async function openFailedDraft(event, client) {
     try {
-        const moved = await moveBackToDrafts(event.uid, event.mailboxUid ?? "");
+        const moved = await moveBackToDrafts(event.uid, event.mailboxUid ?? "", client);
         // Back in Drafts it is no longer a message on its way in its conversation.
         forgetOutgoing(event.uid);
         const request = retainedRequest(event.uid);
@@ -57,8 +57,10 @@ async function openFailedDraft(event) {
             });
             return;
         }
+        // loadOriginalMessage() (quotedBody.ts) does not yet accept an explicit ApiClient itself - out of scope here (that module is not one of
+        // this task's files); it still falls back to the default global session even under an ApiClientContext.Provider.
         const original = await loadOriginalMessage(moved, null);
-        const attachments = await listAttachments(moved.folderUid, moved.uid).catch(() => []);
+        const attachments = await listAttachments(moved.folderUid, moved.uid, client).catch(() => []);
         const byType = (type) => moved.recipients.filter((recipient) => recipient.type === type).map(formatRecipient).join(", ");
         openComposeFromOutside({
             mailboxUid: moved.mailboxUid,
@@ -82,7 +84,7 @@ async function openFailedDraft(event) {
     }
 }
 /** "Retry" for a message the server failed to relay: the same send call again - a failed message stays in Outbox and the server queues it afresh (with a new retry budget). */
-async function retryFailed(event) {
+async function retryFailed(event, client) {
     if (!beginPendingSend({ draftUid: event.uid, mailboxUid: event.mailboxUid ?? "", subject: event.subject, recipients: event.recipients, scheduled: false })) {
         return;
     }
@@ -90,7 +92,7 @@ async function retryFailed(event) {
     markOutgoingSending(event.uid);
     try {
         setPendingStage(event.uid, "queuing");
-        const result = await queueMessageSend(event.uid);
+        const result = await queueMessageSend(event.uid, client);
         if (!result.queued) {
             notifySent();
         }
@@ -102,8 +104,10 @@ async function retryFailed(event) {
         finishPendingSend(event.uid);
     }
 }
-/** Shows what a send event means to the user. */
-export function handleSendEvent(event) {
+/** Shows what a send event means to the user. `client` is the explicit `ApiClient` (from `useApiClient()`) whichever code observed this push
+ * event was rendered under - `undefined` (the default) for every existing caller, which keeps using the default global cookie-based session
+ * exactly as before. */
+export function handleSendEvent(event, client) {
     if (event.action === "send-succeeded") {
         dismiss(retryId(event.uid));
         dismiss(failedId(event.uid));
@@ -134,8 +138,8 @@ export function handleSendEvent(event) {
     }
     dismiss(retryId(event.uid));
     const actions = [
-        { label: "Retry", onClick: () => void retryFailed(event) },
-        { label: "Open draft", onClick: () => void openFailedDraft(event) },
+        { label: "Retry", onClick: () => void retryFailed(event, client) },
+        { label: "Open draft", onClick: () => void openFailedDraft(event, client) },
     ];
     notify({
         id: failedId(event.uid),