@rapidmx/web-client 0.21.0 → 0.22.0

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

@@ -2,8 +2,9 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { Message, cancelScheduledSend, getMessage, listAttachments, listFolders, queueMessageSend } from "@rapidmx/react-shared/mail/mailApi.js";
-import { SendEvent, describeSendEventError } from "@rapidmx/react-shared/mail/sendEvents.js";
+import { Message, cancelScheduledSend, getMessage, listAttachments, listFolders, queueMessageSend } from "../../../../lib/mail/mailApi.js";
+import { SendEvent, describeSendEventError } from "../../../../lib/mail/sendEvents.js";
+import type { ApiClient } from "../../../../lib/util/api.js";
 import { formatRecipient } from "../../components/mail/compose/recipients.js";
 import { loadOriginalMessage } from "../../components/mail/compose/quotedBody.js";
 import { notifyApiError } from "../../notifications/apiErrors.js";
@@ -29,13 +30,13 @@ function summary(recipients: string[]): string {
 }
 
 /** 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: string, mailboxUid: string): Promise<Message> {
-    const message = await getMessage(uid);
-    const drafts = (await listFolders(mailboxUid)).find((folder) => folder.type === "drafts");
+async function moveBackToDrafts(uid: string, mailboxUid: string, client: ApiClient | undefined): Promise<Message> {
+    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: string): string {
@@ -43,9 +44,9 @@ function escapeHtml(text: string): string {
 }
 
 /** "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: SendEvent): Promise<void> {
+async function openFailedDraft(event: SendEvent, client: ApiClient | undefined): Promise<void> {
     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);
@@ -63,8 +64,10 @@ async function openFailedDraft(event: SendEvent): Promise<void> {
             });
             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: "to" | "cc" | "bcc") => moved.recipients.filter((recipient) => recipient.type === type).map(formatRecipient).join(", ");
         openComposeFromOutside({
             mailboxUid: moved.mailboxUid,
@@ -88,7 +91,7 @@ async function openFailedDraft(event: SendEvent): Promise<void> {
 }
 
 /** "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: SendEvent): Promise<void> {
+async function retryFailed(event: SendEvent, client: ApiClient | undefined): Promise<void> {
     if (!beginPendingSend({ draftUid: event.uid, mailboxUid: event.mailboxUid ?? "", subject: event.subject, recipients: event.recipients, scheduled: false })) {
         return;
     }
@@ -96,7 +99,7 @@ async function retryFailed(event: SendEvent): Promise<void> {
     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();
         }
@@ -107,8 +110,10 @@ async function retryFailed(event: SendEvent): Promise<void> {
     }
 }
 
-/** Shows what a send event means to the user. */
-export function handleSendEvent(event: SendEvent): void {
+/** 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: SendEvent, client?: ApiClient): void {
     if (event.action === "send-succeeded") {
         dismiss(retryId(event.uid));
         dismiss(failedId(event.uid));
@@ -139,8 +144,8 @@ export function handleSendEvent(event: SendEvent): void {
     }
     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),

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

@@ -3,7 +3,8 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useEffect, useMemo, useState } from "react";
-import { listMessages } from "@rapidmx/react-shared/mail/mailApi.js";
+import { listMessages } from "../../../../lib/mail/mailApi.js";
+import { useApiClient } from "../../../../lib/util/apiClientContext.js";
 import type { MailboxFolders } from "../../components/mail/layout/MailShell.js";
 import { FolderCount, countOfFolder } from "../folderCounts.js";
 import { OutboxFolderStatus, summarizeOutbox } from "./outboxState.js";
@@ -17,6 +18,7 @@ export const OUTBOX_STATUS_LIMIT = 50;
  * whenever that count or the live updates change, so an empty Outbox - almost always - is free. A failed read keeps what was known.
  */
 export function useOutboxStatus(mailboxFolders: MailboxFolders[], counts: Record<string, FolderCount>, liveTick: number, enabled: boolean): Record<string, OutboxFolderStatus> {
+    const client = useApiClient();
     const [statuses, setStatuses] = useState<Record<string, OutboxFolderStatus>>({});
     const outboxes = useMemo(
         () =>
@@ -43,7 +45,7 @@ export function useOutboxStatus(mailboxFolders: MailboxFolders[], counts: Record
         });
         let cancelled = false;
         for (const outbox of occupied) {
-            listMessages(outbox.uid, { limit: OUTBOX_STATUS_LIMIT }).then(
+            listMessages(outbox.uid, { limit: OUTBOX_STATUS_LIMIT }, client).then(
                 (messages) => {
                     if (!cancelled) {
                         setStatuses((previous) => ({ ...previous, [outbox.uid]: summarizeOutbox(messages) }));
@@ -55,7 +57,7 @@ export function useOutboxStatus(mailboxFolders: MailboxFolders[], counts: Record
         return () => {
             cancelled = true;
         };
-    }, [enabled, key, liveTick]);
+    }, [enabled, key, liveTick, client]);
 
     return statuses;
 }

package/apps/shared/mail/permanentDelete.ts

@@ -2,8 +2,8 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { Message, emptyFolder, listMessages, purgeMessage } from "@rapidmx/react-shared/mail/mailApi.js";
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
+import { Message, emptyFolder, listMessages, purgeMessage } from "../../../lib/mail/mailApi.js";
+import { ApiClient, ApiRequestError } from "../../../lib/util/api.js";
 import { displaySubject } from "../components/mail/reading/EncryptedPreview.js";
 import { notifySessionExpired } from "../notifications/apiErrors.js";
 import { notify } from "../notifications/store.js";
@@ -64,14 +64,14 @@ export function messageCount(count: number): string {
  * to delete, a message that is already gone) is recorded against its message and the rest carry on. `deleted` and `failed` keep the order of
  * `messages`.
  */
-export async function purgeMessages(messages: Message[]): Promise<PurgeOutcome> {
+export async function purgeMessages(messages: Message[], client?: ApiClient): Promise<PurgeOutcome> {
     const failures: (PurgeFailure | null)[] = new Array(messages.length).fill(null);
     let next = 0;
     async function worker(): Promise<void> {
         while (next < messages.length) {
             const index = next++;
             try {
-                await purgeMessage(messages[index].uid);
+                await purgeMessage(messages[index].uid, client);
             } catch (err) {
                 failures[index] = { message: messages[index], ...describeFailure(err) };
             }
@@ -93,17 +93,18 @@ export async function purgeMessages(messages: Message[]): Promise<PurgeOutcome>
 export async function purgeFolder(
     folderUid: string,
     paging: { pageSize: number; maxPages: number } = { pageSize: LIST_PAGE_SIZE, maxPages: MAX_LIST_PAGES },
+    client?: ApiClient,
 ): Promise<EmptyFolderOutcome> {
     try {
-        await emptyFolder(folderUid);
+        await emptyFolder(folderUid, client);
         return { emptied: true, deleted: [], failed: [] };
     } catch (err) {
         if (!(err instanceof ApiRequestError) || (err.status !== 403 && err.status !== 409)) {
             throw err;
         }
     }
-    const listed = await listAllPages((page) => listMessages(folderUid, { limit: paging.pageSize, page }), paging.pageSize, paging.maxPages);
-    const outcome = await purgeMessages(listed.items);
+    const listed = await listAllPages((page) => listMessages(folderUid, { limit: paging.pageSize, page }, client), paging.pageSize, paging.maxPages);
+    const outcome = await purgeMessages(listed.items, client);
     return { ...outcome, emptied: outcome.failed.length === 0 && !listed.truncated };
 }
 

package/apps/shared/mail/primaryMailbox.ts

@@ -17,7 +17,7 @@
  *
  * `orderMailboxes()` puts the primary mailbox first, then the caller's other mailboxes, then the shared ones, each group alphabetical.
  */
-import { isSharedWithMe, type Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
+import { isSharedWithMe, type Mailbox } from "../../../lib/mail/mailApi.js";
 
 /** Whether `mailbox` is the signed-in user's own. */
 export function isOwnMailbox(mailbox: Mailbox, userUid: string | undefined): boolean {

package/apps/shared/mail/reportNotices.ts

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import type { MessageReportKind, MessageReportResult } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { MessageReportKind, MessageReportResult } from "../../../lib/mail/mailApi.js";
 
 /** Where a notification's "Manage blocked senders" goes: the Blocked and safe senders page of the mailbox. */
 export function senderListsHref(mailboxUid: string): string {

package/apps/shared/mail/senderBlocking.ts

@@ -8,7 +8,8 @@ import {
     deleteMailFilterRule,
     listMailFilterRules,
     updateMailFilterRule,
-} from "@rapidmx/react-shared/mail/mailFilterRulesApi.js";
+} from "../../../lib/mail/mailFilterRulesApi.js";
+import type { ApiClient } from "../../../lib/util/api.js";
 
 /**
  * "Block sender" and "Never block sender", expressed as the mailbox's own mail filter rules - the server has no blocked-senders list.
@@ -75,6 +76,7 @@ async function ensureRule(
     addresses: string[],
     folderUid: string,
     prefix: string,
+    client?: ApiClient,
 ): Promise<{ outcome: "created" | "existing" | "enabled"; rule: MailFilterRule }> {
     const found = rules.find((rule) => isSenderRule(rule, addresses, folderUid));
     if (found) {
@@ -83,24 +85,30 @@ async function ensureRule(
         }
         // The whole rule, as the filters page saves one: the update replaces the record.
         const { uid, version, name, sequence, stopProcessingRules, conditions, actions } = found;
-        return { outcome: "enabled", rule: await updateMailFilterRule({ uid, version, name, enabled: true, sequence, stopProcessingRules, conditions, actions }) };
+        return {
+            outcome: "enabled",
+            rule: await updateMailFilterRule({ uid, version, name, enabled: true, sequence, stopProcessingRules, conditions, actions }, client),
+        };
     }
-    const rule = await createMailFilterRule({
-        mailboxUid,
-        name: `${prefix}${addresses[0]}`,
-        sequence: firstSequence(rules),
-        stopProcessingRules: true,
-        conditions: { fromContains: addresses },
-        actions: [{ type: "move_to_folder", folderUid }],
-    });
+    const rule = await createMailFilterRule(
+        {
+            mailboxUid,
+            name: `${prefix}${addresses[0]}`,
+            sequence: firstSequence(rules),
+            stopProcessingRules: true,
+            conditions: { fromContains: addresses },
+            actions: [{ type: "move_to_folder", folderUid }],
+        },
+        client,
+    );
     return { outcome: "created", rule };
 }
 
 /** Takes away every rule that is `folderUid` for `addresses`. */
-async function removeRules(rules: MailFilterRule[], addresses: string[], folderUid: string): Promise<MailFilterRule[]> {
+async function removeRules(rules: MailFilterRule[], addresses: string[], folderUid: string, client?: ApiClient): Promise<MailFilterRule[]> {
     const doomed = rules.filter((rule) => isSenderRule(rule, addresses, folderUid));
     for (const rule of doomed) {
-        await deleteMailFilterRule(rule.uid, rule.version);
+        await deleteMailFilterRule(rule.uid, rule.version, client);
     }
     return doomed;
 }
@@ -110,10 +118,16 @@ async function removeRules(rules: MailFilterRule[], addresses: string[], folderU
  * usually has both) goes to `junkFolderUid` from now on. Idempotent: the rule is made once, and a rule that was turned off is turned on.
  * A "Never block" rule for the same sender is taken away, since the two would fight.
  */
-export async function blockSender(mailboxUid: string, addresses: string[], junkFolderUid: string, inboxFolderUid: string): Promise<BlockResult> {
-    const rules = await listMailFilterRules(mailboxUid, { limit: RULE_LIMIT });
-    await removeRules(rules, addresses, inboxFolderUid);
-    return ensureRule(rules, mailboxUid, addresses, junkFolderUid, BLOCK_RULE_PREFIX);
+export async function blockSender(
+    mailboxUid: string,
+    addresses: string[],
+    junkFolderUid: string,
+    inboxFolderUid: string,
+    client?: ApiClient,
+): Promise<BlockResult> {
+    const rules = await listMailFilterRules(mailboxUid, { limit: RULE_LIMIT }, client);
+    await removeRules(rules, addresses, inboxFolderUid, client);
+    return ensureRule(rules, mailboxUid, addresses, junkFolderUid, BLOCK_RULE_PREFIX, client);
 }
 
 /** Never blocks a sender: takes away the block rule for `addresses` and makes (once) the rule that keeps their mail in the Inbox. */
@@ -122,20 +136,22 @@ export async function neverBlockSender(
     addresses: string[],
     junkFolderUid: string,
     inboxFolderUid: string,
+    client?: ApiClient,
 ): Promise<NeverBlockResult> {
-    const rules = await listMailFilterRules(mailboxUid, { limit: RULE_LIMIT });
-    const removed = await removeRules(rules, addresses, junkFolderUid);
+    const rules = await listMailFilterRules(mailboxUid, { limit: RULE_LIMIT }, client);
+    const removed = await removeRules(rules, addresses, junkFolderUid, client);
     const kept = await ensureRule(
         rules.filter((rule) => !removed.includes(rule)),
         mailboxUid,
         addresses,
         inboxFolderUid,
         NEVER_BLOCK_RULE_PREFIX,
+        client,
     );
     return { removed, ...kept };
 }
 
 /** Takes back a rule this module made (the notification's Undo). */
-export function removeSenderRule(rule: MailFilterRule): Promise<void> {
-    return deleteMailFilterRule(rule.uid, rule.version);
+export function removeSenderRule(rule: MailFilterRule, client?: ApiClient): Promise<void> {
+    return deleteMailFilterRule(rule.uid, rule.version, client);
 }

package/apps/shared/mail/useMailConnection.ts

@@ -3,8 +3,9 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { createContext, useCallback, useEffect, useRef, useState } from "react";
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
-import { Folder, Mailbox, Message, listFolders, listMailboxes } from "@rapidmx/react-shared/mail/mailApi.js";
+import { ApiRequestError } from "../../../lib/util/api.js";
+import { useApiClient } from "../../../lib/util/apiClientContext.js";
+import { Folder, Mailbox, Message, listFolders, listMailboxes } from "../../../lib/mail/mailApi.js";
 import { FOLDER_ORDER, FolderChange, MAIL_FOLDER_TYPES, isMailFolder, knownFolderUids, reconcileFolders, removeFolder, upsertFolder } from "./folderTree.js";
 import type { MailboxFolders } from "../components/mail/layout/MailShell.js";
 import { orderMailboxes } from "./primaryMailbox.js";
@@ -75,6 +76,7 @@ export interface UseMailConnectionOptions {
  * state from `MailConnectionContext` when there is a frame, and runs this hook itself when there isn't (a page rendered outside the router).
  */
 export function useMailConnection({ userUid, enabled, open }: UseMailConnectionOptions): MailConnection {
+    const client = useApiClient();
     const [status, setStatus] = useState<MailConnectionStatus>("checking");
     const [error, setError] = useState<string | null>(null);
     const [mailboxes, setMailboxes] = useState<Mailbox[]>([]);
@@ -85,7 +87,7 @@ export function useMailConnection({ userUid, enabled, open }: UseMailConnectionO
         if (!userUid || !enabled) {
             return;
         }
-        listMailboxes({ limit: MAILBOX_LIST_LIMIT })
+        listMailboxes({ limit: MAILBOX_LIST_LIMIT }, client)
             .then((result) => {
                 // The caller's own mailbox first, then the others: every sidebar, picker and default below follows this order.
                 setMailboxes(orderMailboxes(result, userUid));
@@ -95,7 +97,7 @@ export function useMailConnection({ userUid, enabled, open }: UseMailConnectionO
                 setError(err instanceof ApiRequestError ? err.message : "Could not load your mailboxes.");
                 setStatus("error");
             });
-    }, [userUid, enabled]);
+    }, [userUid, enabled, client]);
 
     // Fans out one listFolders() call per accessible mailbox in parallel - each call catches its own failure into a MailboxFolders.error
     // rather than letting Promise.all reject, so one mailbox's fetch failure renders that section's own inline Alert instead of blanking out
@@ -111,7 +113,7 @@ export function useMailConnection({ userUid, enabled, open }: UseMailConnectionO
         setFoldersLoading(true);
         void Promise.all(
             mailboxes.map((mailbox) =>
-                listFolders(mailbox.uid)
+                listFolders(mailbox.uid, client)
                     .then((result): MailboxFolders => ({ mailbox, folders: result.filter(isMailFolder) }))
                     .catch(
                         (err): MailboxFolders => ({
@@ -124,7 +126,7 @@ export function useMailConnection({ userUid, enabled, open }: UseMailConnectionO
         )
             .then(setMailboxFolders)
             .finally(() => setFoldersLoading(false));
-    }, [mailboxes]);
+    }, [mailboxes, client]);
 
     /** Files a newly created folder under its own mailbox, leaving every other mailbox's list untouched - and ignoring a type the
      * sidebar doesn't list at all, the same filter the fetch above applies. One already there (another client's create event can arrive
@@ -154,7 +156,7 @@ export function useMailConnection({ userUid, enabled, open }: UseMailConnectionO
         onFolderDeleted,
         onFoldersListed,
         onMessageCreated: notifications.announce,
-        onSendEvent: handleSendEvent,
+        onSendEvent: (event) => handleSendEvent(event, client),
     });
     const noteFolderUids = useCallback(
         (folderUids: Iterable<string>) => {
@@ -179,8 +181,8 @@ export function useMailConnection({ userUid, enabled, open }: UseMailConnectionO
 
     // The Outbox indicator: a message being sent from this tab counts at once (before the server has heard of it), settled - or taken back - when
     // the server answers (see `sendJob.ts`); once it accepted one, the folders are read again, since the Outbox may not have existed yet.
-    const latestRef = useRef({ mailboxFolders, folderCounts });
-    latestRef.current = { mailboxFolders, folderCounts };
+    const latestRef = useRef({ mailboxFolders, folderCounts, client });
+    latestRef.current = { mailboxFolders, folderCounts, client };
     useEffect(() => {
         if (!userUid || !enabled) {
             return;
@@ -195,7 +197,7 @@ export function useMailConnection({ userUid, enabled, open }: UseMailConnectionO
                 // The server accepted a message: the Outbox (and, on an older server, Sent Items) may just have been made. The counts' read-back lists
                 // every mailbox's folders and files the new ones (`onFoldersListed`); this reads the one mailbox at once.
                 latestRef.current.folderCounts.refresh(0);
-                listFolders(mailboxUid).then(onFoldersListed, () => undefined);
+                listFolders(mailboxUid, latestRef.current.client).then(onFoldersListed, () => undefined);
             },
         );
     }, [userUid, enabled, onFoldersListed]);

package/apps/shared/mail/useMailLiveUpdates.ts

@@ -3,9 +3,9 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useEffect, useMemo, useRef, useState } from "react";
-import { Folder, Mailbox, Message } from "@rapidmx/react-shared/mail/mailApi.js";
-import { getPushClient, PushEvent } from "@rapidmx/react-shared/mail/pushClient.js";
-import { SendEvent, parseSendEvent } from "@rapidmx/react-shared/mail/sendEvents.js";
+import { Folder, Mailbox, Message } from "../../../lib/mail/mailApi.js";
+import { getPushClient, PushEvent } from "../../../lib/mail/pushClient.js";
+import { SendEvent, parseSendEvent } from "../../../lib/mail/sendEvents.js";
 import type { MailboxFolders } from "../components/mail/layout/MailShell.js";
 import { SIGN_OUT_CHANNEL } from "../search/localIndexRpcClient.js";
 import { FolderCounts, useFolderCounts } from "./folderCounts.js";

package/apps/shared/mail/useMailboxUpdateAccess.ts

@@ -3,29 +3,52 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useEffect, useState } from "react";
-import type { Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
-import { getMyMailboxAccess } from "@rapidmx/react-shared/mail/mailboxAccessApi.js";
+import type { Mailbox } from "../../../lib/mail/mailApi.js";
+import { getMyMailboxAccess } from "../../../lib/mail/mailboxAccessApi.js";
+import type { ApiClient } from "../../../lib/util/api.js";
+import { useApiClient } from "../../../lib/util/apiClientContext.js";
 
-/** What the server said about the caller's update access to a mailbox, remembered per mailbox for the page load. */
+/** What the server said about the caller's update access to a mailbox, remembered per mailbox for the page load - for the
+ * default global client (no `ApiClientContext.Provider` above the caller). */
 const answers = new Map<string, Promise<boolean | undefined>>();
 
-/** Forgets every remembered answer - for the tests, and anything that changes the caller's access mid-session. */
+/** The same, per explicit `ApiClient` instance (each of `tauri-client`'s accounts has its own), so two accounts never
+ * answer each other's question even if their mailbox uids ever collided. A `WeakMap` so an account's cache is dropped
+ * with its `ApiClient` rather than growing forever. */
+const clientAnswers = new WeakMap<ApiClient, Map<string, Promise<boolean | undefined>>>();
+
+/** The cache to use for `client` (`answers` itself for the default, undefined case). */
+function cacheFor(client: ApiClient | undefined): Map<string, Promise<boolean | undefined>> {
+    if (!client) {
+        return answers;
+    }
+    let cache = clientAnswers.get(client);
+    if (!cache) {
+        cache = new Map();
+        clientAnswers.set(client, cache);
+    }
+    return cache;
+}
+
+/** Forgets every remembered answer of the default global client - for the tests, and anything that changes the caller's
+ * access mid-session. An explicit `ApiClient`'s own cache is scoped to that instance and needs no separate clearing. */
 export function clearMailboxUpdateAccessCache(): void {
     answers.clear();
 }
 
 /** Whether the caller may change things in `mailboxUid` (move, mark and flag its messages, add its filters): the server's own ACL check. Never rejects; `undefined` when it could not be asked (which is not cached). */
-function fetchUpdateAccess(mailboxUid: string): Promise<boolean | undefined> {
-    let answer = answers.get(mailboxUid);
+function fetchUpdateAccess(mailboxUid: string, client: ApiClient | undefined): Promise<boolean | undefined> {
+    const cache = cacheFor(client);
+    let answer = cache.get(mailboxUid);
     if (!answer) {
-        answer = getMyMailboxAccess(mailboxUid).then(
+        answer = getMyMailboxAccess(mailboxUid, client).then(
             (access) => access.canUpdate,
             () => {
-                answers.delete(mailboxUid);
+                cache.delete(mailboxUid);
                 return undefined;
             },
         );
-        answers.set(mailboxUid, answer);
+        cache.set(mailboxUid, answer);
     }
     return answer;
 }
@@ -38,6 +61,7 @@ function fetchUpdateAccess(mailboxUid: string): Promise<boolean | undefined> {
  * that then says why it failed.
  */
 export function useMailboxUpdateAccess(mailbox: Mailbox | undefined): boolean {
+    const client = useApiClient();
     const uid = mailbox?.uid;
     const delegated = mailbox?.accessRole === "delegate";
     const [writable, setWritable] = useState(true);
@@ -47,7 +71,7 @@ export function useMailboxUpdateAccess(mailbox: Mailbox | undefined): boolean {
             return;
         }
         let cancelled = false;
-        void fetchUpdateAccess(uid).then((canUpdate) => {
+        void fetchUpdateAccess(uid, client).then((canUpdate) => {
             if (!cancelled && canUpdate === false) {
                 setWritable(false);
             }
@@ -55,6 +79,6 @@ export function useMailboxUpdateAccess(mailbox: Mailbox | undefined): boolean {
         return () => {
             cancelled = true;
         };
-    }, [uid, delegated]);
+    }, [uid, delegated, client]);
     return writable;
 }

package/apps/shared/mail/useMarkMessageRead.ts

@@ -3,7 +3,8 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useEffect, useRef } from "react";
-import type { Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Message } from "../../../lib/mail/mailApi.js";
+import { useApiClient } from "../../../lib/util/apiClientContext.js";
 import { useMailShell } from "../components/mail/layout/MailShell.js";
 import { setReadState } from "./messageReadState.js";
 
@@ -19,10 +20,11 @@ import { setReadState } from "./messageReadState.js";
  */
 export function useMarkMessageRead(message: Message | null, onPatched: (updated: Message, previous?: Message) => void): void {
     const { trackMessageChange } = useMailShell();
+    const client = useApiClient();
     const openUidRef = useRef<string | undefined>(undefined);
     const requestedRef = useRef<Set<string>>(new Set());
-    const latestRef = useRef({ onPatched, trackMessageChange });
-    latestRef.current = { onPatched, trackMessageChange };
+    const latestRef = useRef({ onPatched, trackMessageChange, client });
+    latestRef.current = { onPatched, trackMessageChange, client };
 
     useEffect(() => {
         if (message?.uid !== openUidRef.current) {
@@ -39,9 +41,14 @@ export function useMarkMessageRead(message: Message | null, onPatched: (updated:
         if (message.flags.read === true) {
             return;
         }
-        void setReadState(message, true, {
-            patch: (updated, previous) => latestRef.current.onPatched(updated, previous),
-            track: (previous, next) => latestRef.current.trackMessageChange(previous, next),
-        });
+        void setReadState(
+            message,
+            true,
+            {
+                patch: (updated, previous) => latestRef.current.onPatched(updated, previous),
+                track: (previous, next) => latestRef.current.trackMessageChange(previous, next),
+            },
+            latestRef.current.client,
+        );
     }, [message]);
 }

package/apps/shared/mail/useNewMailNotifications.ts

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import type { Mailbox, Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Mailbox, Message } from "../../../lib/mail/mailApi.js";
 import type { MailboxFolders } from "../components/mail/layout/MailShell.js";
 import {
     DesktopPermission,

package/apps/shared/mail/usePermanentDelete.tsx

@@ -3,7 +3,8 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import React, { ReactElement, useRef, useState } from "react";
-import type { Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Message } from "../../../lib/mail/mailApi.js";
+import { useApiClient } from "../../../lib/util/apiClientContext.js";
 import PermanentDeleteDialog from "../components/mail/PermanentDeleteDialog.js";
 import { useMailShell } from "../components/mail/layout/MailShell.js";
 import { notifyApiError } from "../notifications/apiErrors.js";
@@ -60,6 +61,7 @@ interface Pending {
  */
 export function usePermanentDelete(): PermanentDelete {
     const { trackMessageChange, refreshFolderCounts } = useMailShell();
+    const client = useApiClient();
     const [pending, setPending] = useState<Pending | null>(null);
     const [running, setRunning] = useState(false);
     // Set at once (state is a render later), so a key pressed twice does not open two dialogs.
@@ -105,7 +107,7 @@ export function usePermanentDelete(): PermanentDelete {
         const { request } = pendingRef.current!;
         setRunning(true);
         if (request.kind === "messages") {
-            const outcome = await purgeMessages(request.messages);
+            const outcome = await purgeMessages(request.messages, client);
             afterDeleted(outcome.deleted);
             notifyPurged(outcome);
             finish(outcome);
@@ -113,7 +115,7 @@ export function usePermanentDelete(): PermanentDelete {
         }
         let outcome: EmptyFolderOutcome;
         try {
-            outcome = await purgeFolder(request.folder.uid);
+            outcome = await purgeFolder(request.folder.uid, undefined, client);
         } catch (err) {
             notifyApiError(err, `Couldn't empty ${request.folder.name}`);
             // Part of it may have gone before the failure: the caller reloads rather than assume nothing did.

package/apps/shared/navigation/pageTitle.ts

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import type { Branding } from "@rapidmx/react-shared/branding/brandingApi.js";
+import type { Branding } from "../../../lib/branding/brandingApi.js";
 
 /** The name the deployment goes by in the browser tab: its branding title, else its company name, else RapidMX. */
 export function brandName(branding?: Pick<Branding, "title" | "companyName"> | null): string {

package/apps/shared/notifications/NotificationCenter.tsx

@@ -13,7 +13,7 @@ import {
     HiOutlineInformationCircle,
     HiOutlineXMark,
 } from "react-icons/hi2";
-import CopyButton from "@rapidmx/react-shared/components/buttons/CopyButton.js";
+import CopyButton from "../../../lib/components/buttons/CopyButton.js";
 import { NotificationAction, NotificationKind, NotificationView, dismiss, setAllPaused, setPaused } from "./store.js";
 import { useNotifications } from "./useNotifications.js";
 import { useSystemErrorNotifications } from "./systemErrors.js";

package/apps/shared/notifications/NotificationHistoryDialog.tsx

@@ -3,8 +3,8 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import React, { useEffect, useRef } from "react";
-import Modal from "@rapidmx/react-shared/components/overlays/Modal.js";
-import CopyButton from "@rapidmx/react-shared/components/buttons/CopyButton.js";
+import Modal from "../../../lib/components/overlays/Modal.js";
+import CopyButton from "../../../lib/components/buttons/CopyButton.js";
 import { HistoryEntry, NotificationKind } from "./store.js";
 import { useNotifications } from "./useNotifications.js";