@rapidmx/web-client 0.21.0 → 0.22.0

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

@@ -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 { countOfFolder } from "../folderCounts.js";
 import { summarizeOutbox } from "./outboxState.js";
 /** The most Outbox messages read to say what state they are in; beyond this the pill still shows the folder's own total. */
@@ -14,6 +15,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, counts, liveTick, enabled) {
+    const client = useApiClient();
     const [statuses, setStatuses] = useState({});
     const outboxes = useMemo(() => mailboxFolders.flatMap((entry) => entry.folders.filter((folder) => folder.type === "outbox")).map((folder) => ({ uid: folder.uid, total: countOfFolder(folder, counts).total })), [mailboxFolders, counts]);
     const key = outboxes.map((outbox) => `${outbox.uid}:${outbox.total}`).join("|");
@@ -35,7 +37,7 @@ export function useOutboxStatus(mailboxFolders, counts, liveTick, enabled) {
         });
         let cancelled = false;
         for (const outbox of occupied) {
-            listMessages(outbox.uid, { limit: OUTBOX_STATUS_LIMIT }).then((messages) => {
+            listMessages(outbox.uid, { limit: OUTBOX_STATUS_LIMIT }, client).then((messages) => {
                 if (!cancelled) {
                     setStatuses((previous) => ({ ...previous, [outbox.uid]: summarizeOutbox(messages) }));
                 }
@@ -44,6 +46,6 @@ export function useOutboxStatus(mailboxFolders, counts, liveTick, enabled) {
         return () => {
             cancelled = true;
         };
-    }, [enabled, key, liveTick]);
+    }, [enabled, key, liveTick, client]);
     return statuses;
 }

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

@@ -1,4 +1,5 @@
-import { Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import { Message } from "../../../lib/mail/mailApi.js";
+import { ApiClient } from "../../../lib/util/api.js";
 /**
  * Permanent delete: what "Delete" does to a message that is already in Deleted Items (and what "Empty folder" does to Deleted Items and
  * Junk Email). Unlike a move into Deleted Items it cannot be undone, so it is never reached without a confirmation (see
@@ -38,7 +39,7 @@ export declare 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 declare function purgeMessages(messages: Message[]): Promise<PurgeOutcome>;
+export declare function purgeMessages(messages: Message[], client?: ApiClient): Promise<PurgeOutcome>;
 /**
  * Permanently deletes everything in `folderUid`: one request for the whole folder, which is all or nothing. The server refuses it as a whole
  * when a message in it is under a legal hold (`409`) or when the caller may delete messages but not empty a folder (`403`, a delegate) - and
@@ -48,7 +49,7 @@ export declare function purgeMessages(messages: Message[]): Promise<PurgeOutcome
 export declare function purgeFolder(folderUid: string, paging?: {
     pageSize: number;
     maxPages: number;
-}): Promise<EmptyFolderOutcome>;
+}, client?: ApiClient): Promise<EmptyFolderOutcome>;
 /**
  * Tells the reader what a delete of several messages came to: "3 messages permanently deleted" (no Undo - there is none), or "2 deleted, 1
  * could not be deleted" with the server's reasons.

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

@@ -2,8 +2,8 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { emptyFolder, listMessages, purgeMessage } from "@rapidmx/react-shared/mail/mailApi.js";
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
+import { emptyFolder, listMessages, purgeMessage } from "../../../lib/mail/mailApi.js";
+import { 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";
@@ -37,14 +37,14 @@ export function messageCount(count) {
  * 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) {
+export async function purgeMessages(messages, client) {
     const failures = new Array(messages.length).fill(null);
     let next = 0;
     async function worker() {
         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) };
@@ -63,9 +63,9 @@ export async function purgeMessages(messages) {
  * then this lists the folder and deletes message by message instead, so what may go does and each refusal is reported. Any other failure
  * (the server is down) rejects, and the caller says so.
  */
-export async function purgeFolder(folderUid, paging = { pageSize: LIST_PAGE_SIZE, maxPages: MAX_LIST_PAGES }) {
+export async function purgeFolder(folderUid, paging = { pageSize: LIST_PAGE_SIZE, maxPages: MAX_LIST_PAGES }, client) {
     try {
-        await emptyFolder(folderUid);
+        await emptyFolder(folderUid, client);
         return { emptied: true, deleted: [], failed: [] };
     }
     catch (err) {
@@ -73,8 +73,8 @@ export async function purgeFolder(folderUid, paging = { pageSize: LIST_PAGE_SIZE
             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 };
 }
 /** The line for one refusal, in the notification's details. */

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

@@ -13,7 +13,7 @@
  *
  * `orderMailboxes()` puts the primary mailbox first, then the caller's other mailboxes, then the shared ones, each group alphabetical.
  */
-import { type Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
+import { type Mailbox } from "../../../lib/mail/mailApi.js";
 /** Whether `mailbox` is the signed-in user's own. */
 export declare function isOwnMailbox(mailbox: Mailbox, userUid: string | undefined): boolean;
 /** Whether `mailbox` is one the caller only has access to (an ownerless one, or somebody else's shared with them). */

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

@@ -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 } from "@rapidmx/react-shared/mail/mailApi.js";
+import { isSharedWithMe } from "../../../lib/mail/mailApi.js";
 /** Whether `mailbox` is the signed-in user's own. */
 export function isOwnMailbox(mailbox, userUid) {
     return !!userUid && mailbox.ownerUserUid === userUid;

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

@@ -1,4 +1,4 @@
-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 declare function senderListsHref(mailboxUid: string): string;
 /** The noun of `kind` for a failure's title ("Couldn't report this message as phishing"). */

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

@@ -1,4 +1,5 @@
-import { MailFilterRule } from "@rapidmx/react-shared/mail/mailFilterRulesApi.js";
+import { MailFilterRule } from "../../../lib/mail/mailFilterRulesApi.js";
+import type { ApiClient } from "../../../lib/util/api.js";
 export declare const BLOCK_RULE_PREFIX = "Block ";
 export declare const NEVER_BLOCK_RULE_PREFIX = "Never block ";
 /** `addresses` trimmed, lowercased and without repeats, keeping only what has an `@`. */
@@ -19,8 +20,8 @@ export interface NeverBlockResult {
  * 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 declare function blockSender(mailboxUid: string, addresses: string[], junkFolderUid: string, inboxFolderUid: string): Promise<BlockResult>;
+export declare function blockSender(mailboxUid: string, addresses: string[], junkFolderUid: string, inboxFolderUid: string, client?: ApiClient): Promise<BlockResult>;
 /** Never blocks a sender: takes away the block rule for `addresses` and makes (once) the rule that keeps their mail in the Inbox. */
-export declare function neverBlockSender(mailboxUid: string, addresses: string[], junkFolderUid: string, inboxFolderUid: string): Promise<NeverBlockResult>;
+export declare function neverBlockSender(mailboxUid: string, addresses: string[], junkFolderUid: string, inboxFolderUid: string, client?: ApiClient): Promise<NeverBlockResult>;
 /** Takes back a rule this module made (the notification's Undo). */
-export declare function removeSenderRule(rule: MailFilterRule): Promise<void>;
+export declare function removeSenderRule(rule: MailFilterRule, client?: ApiClient): Promise<void>;

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

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { createMailFilterRule, deleteMailFilterRule, listMailFilterRules, updateMailFilterRule, } from "@rapidmx/react-shared/mail/mailFilterRulesApi.js";
+import { createMailFilterRule, deleteMailFilterRule, listMailFilterRules, updateMailFilterRule, } from "../../../lib/mail/mailFilterRulesApi.js";
 /**
  * "Block sender" and "Never block sender", expressed as the mailbox's own mail filter rules - the server has no blocked-senders list.
  * A rule's "From contains" is a case-insensitive substring match on the From header (restapi's `matchesConditions()`), which is the
@@ -41,7 +41,7 @@ function firstSequence(rules) {
     return Math.min(0, ...rules.map((rule) => rule.sequence)) - 1;
 }
 /** Finds the rule that does `folderUid` for `addresses`, makes one (named `${prefix}${addresses[0]}`) if there is none, and turns a found one on. */
-async function ensureRule(rules, mailboxUid, addresses, folderUid, prefix) {
+async function ensureRule(rules, mailboxUid, addresses, folderUid, prefix, client) {
     const found = rules.find((rule) => isSenderRule(rule, addresses, folderUid));
     if (found) {
         if (found.enabled) {
@@ -49,7 +49,10 @@ async function ensureRule(rules, mailboxUid, addresses, folderUid, prefix) {
         }
         // 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,
@@ -58,14 +61,14 @@ async function ensureRule(rules, mailboxUid, addresses, folderUid, prefix) {
         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, addresses, folderUid) {
+async function removeRules(rules, addresses, folderUid, client) {
     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;
 }
@@ -74,19 +77,19 @@ async function removeRules(rules, addresses, folderUid) {
  * 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, addresses, junkFolderUid, inboxFolderUid) {
-    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, addresses, junkFolderUid, inboxFolderUid, client) {
+    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. */
-export async function neverBlockSender(mailboxUid, addresses, junkFolderUid, inboxFolderUid) {
-    const rules = await listMailFilterRules(mailboxUid, { limit: RULE_LIMIT });
-    const removed = await removeRules(rules, addresses, junkFolderUid);
-    const kept = await ensureRule(rules.filter((rule) => !removed.includes(rule)), mailboxUid, addresses, inboxFolderUid, NEVER_BLOCK_RULE_PREFIX);
+export async function neverBlockSender(mailboxUid, addresses, junkFolderUid, inboxFolderUid, client) {
+    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) {
-    return deleteMailFilterRule(rule.uid, rule.version);
+export function removeSenderRule(rule, client) {
+    return deleteMailFilterRule(rule.uid, rule.version, client);
 }

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

@@ -1,4 +1,4 @@
-import { Folder, Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
+import { Folder, Mailbox } from "../../../lib/mail/mailApi.js";
 import { FOLDER_ORDER, MAIL_FOLDER_TYPES } from "./folderTree.js";
 import type { MailboxFolders } from "../components/mail/layout/MailShell.js";
 import { LiveUpdates } from "./useMailLiveUpdates.js";

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

@@ -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 { listFolders, listMailboxes } from "@rapidmx/react-shared/mail/mailApi.js";
+import { ApiRequestError } from "../../../lib/util/api.js";
+import { useApiClient } from "../../../lib/util/apiClientContext.js";
+import { listFolders, listMailboxes } from "../../../lib/mail/mailApi.js";
 import { FOLDER_ORDER, MAIL_FOLDER_TYPES, isMailFolder, knownFolderUids, reconcileFolders, removeFolder, upsertFolder } from "./folderTree.js";
 import { orderMailboxes } from "./primaryMailbox.js";
 import { useMailLiveUpdates } from "./useMailLiveUpdates.js";
@@ -28,6 +29,7 @@ export const MailConnectionContext = createContext(null);
  * 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 }) {
+    const client = useApiClient();
     const [status, setStatus] = useState("checking");
     const [error, setError] = useState(null);
     const [mailboxes, setMailboxes] = useState([]);
@@ -37,7 +39,7 @@ export function useMailConnection({ userUid, enabled, open }) {
         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));
@@ -47,7 +49,7 @@ export function useMailConnection({ userUid, enabled, open }) {
             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
     // every other mailbox's folder tree.
@@ -60,7 +62,7 @@ export function useMailConnection({ userUid, enabled, open }) {
             return;
         }
         setFoldersLoading(true);
-        void Promise.all(mailboxes.map((mailbox) => listFolders(mailbox.uid)
+        void Promise.all(mailboxes.map((mailbox) => listFolders(mailbox.uid, client)
             .then((result) => ({ mailbox, folders: result.filter(isMailFolder) }))
             .catch((err) => ({
             mailbox,
@@ -69,7 +71,7 @@ export function useMailConnection({ userUid, enabled, open }) {
         }))))
             .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
      * after, or twice, or alongside our own) is not added again - see `upsertFolder()`. */
@@ -97,7 +99,7 @@ export function useMailConnection({ userUid, enabled, open }) {
         onFolderDeleted,
         onFoldersListed,
         onMessageCreated: notifications.announce,
-        onSendEvent: handleSendEvent,
+        onSendEvent: (event) => handleSendEvent(event, client),
     });
     const noteFolderUids = useCallback((folderUids) => {
         const known = knownFolderUids(foldersRef.current);
@@ -118,8 +120,8 @@ export function useMailConnection({ userUid, enabled, open }) {
     usePushConnectionNotice(!!userUid && enabled);
     // 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;
@@ -132,7 +134,7 @@ export function useMailConnection({ userUid, enabled, open }) {
             // 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]);
     const outbox = useOutboxStatus(mailboxFolders, folderCounts.counts, live.tick, !!userUid && enabled);

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

@@ -1,5 +1,5 @@
-import { Folder, Mailbox, Message } from "@rapidmx/react-shared/mail/mailApi.js";
-import { SendEvent } from "@rapidmx/react-shared/mail/sendEvents.js";
+import { Folder, Mailbox, Message } from "../../../lib/mail/mailApi.js";
+import { SendEvent } from "../../../lib/mail/sendEvents.js";
 import type { MailboxFolders } from "../components/mail/layout/MailShell.js";
 import { FolderCounts } from "./folderCounts.js";
 import { FolderChange } from "./folderTree.js";

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

@@ -3,8 +3,8 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useEffect, useMemo, useRef, useState } from "react";
-import { getPushClient } from "@rapidmx/react-shared/mail/pushClient.js";
-import { parseSendEvent } from "@rapidmx/react-shared/mail/sendEvents.js";
+import { getPushClient } from "../../../lib/mail/pushClient.js";
+import { parseSendEvent } from "../../../lib/mail/sendEvents.js";
 import { SIGN_OUT_CHANNEL } from "../search/localIndexRpcClient.js";
 import { useFolderCounts } from "./folderCounts.js";
 import { sortFolders } from "./folderTree.js";

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

@@ -1,5 +1,6 @@
-import type { Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
-/** Forgets every remembered answer - for the tests, and anything that changes the caller's access mid-session. */
+import type { Mailbox } from "../../../lib/mail/mailApi.js";
+/** 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 declare function clearMailboxUpdateAccessCache(): void;
 /**
  * Whether the reader may change the messages of `mailbox`: `false` only for a mailbox shared with them (`accessRole: "delegate"`) that

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

@@ -3,22 +3,42 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useEffect, useState } from "react";
-import { getMyMailboxAccess } from "@rapidmx/react-shared/mail/mailboxAccessApi.js";
-/** What the server said about the caller's update access to a mailbox, remembered per mailbox for the page load. */
+import { getMyMailboxAccess } from "../../../lib/mail/mailboxAccessApi.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 - for the
+ * default global client (no `ApiClientContext.Provider` above the caller). */
 const answers = new Map();
-/** 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();
+/** The cache to use for `client` (`answers` itself for the default, undefined case). */
+function cacheFor(client) {
+    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() {
     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) {
-    let answer = answers.get(mailboxUid);
+function fetchUpdateAccess(mailboxUid, client) {
+    const cache = cacheFor(client);
+    let answer = cache.get(mailboxUid);
     if (!answer) {
-        answer = getMyMailboxAccess(mailboxUid).then((access) => access.canUpdate, () => {
-            answers.delete(mailboxUid);
+        answer = getMyMailboxAccess(mailboxUid, client).then((access) => access.canUpdate, () => {
+            cache.delete(mailboxUid);
             return undefined;
         });
-        answers.set(mailboxUid, answer);
+        cache.set(mailboxUid, answer);
     }
     return answer;
 }
@@ -30,6 +50,7 @@ function fetchUpdateAccess(mailboxUid) {
  * that then says why it failed.
  */
 export function useMailboxUpdateAccess(mailbox) {
+    const client = useApiClient();
     const uid = mailbox?.uid;
     const delegated = mailbox?.accessRole === "delegate";
     const [writable, setWritable] = useState(true);
@@ -39,7 +60,7 @@ export function useMailboxUpdateAccess(mailbox) {
             return;
         }
         let cancelled = false;
-        void fetchUpdateAccess(uid).then((canUpdate) => {
+        void fetchUpdateAccess(uid, client).then((canUpdate) => {
             if (!cancelled && canUpdate === false) {
                 setWritable(false);
             }
@@ -47,6 +68,6 @@ export function useMailboxUpdateAccess(mailbox) {
         return () => {
             cancelled = true;
         };
-    }, [uid, delegated]);
+    }, [uid, delegated, client]);
     return writable;
 }

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

@@ -1,4 +1,4 @@
-import type { Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Message } from "../../../lib/mail/mailApi.js";
 /**
  * Marks a message read when it is opened in a reading pane, through `setReadState()`: the row and the folder badge change at
  * once. `onPatched` is handed each copy of the message as it changes (the optimistic one, then the server's, or the original

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

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useEffect, useRef } from "react";
+import { useApiClient } from "../../../lib/util/apiClientContext.js";
 import { useMailShell } from "../components/mail/layout/MailShell.js";
 import { setReadState } from "./messageReadState.js";
 /**
@@ -17,10 +18,11 @@ import { setReadState } from "./messageReadState.js";
  */
 export function useMarkMessageRead(message, onPatched) {
     const { trackMessageChange } = useMailShell();
+    const client = useApiClient();
     const openUidRef = useRef(undefined);
     const requestedRef = useRef(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) {
             // Another message (or none) is open now: whatever was asked about the last one is over.
@@ -39,6 +41,6 @@ export function useMarkMessageRead(message, onPatched) {
         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/dist/apps/shared/mail/useNewMailNotifications.d.ts

@@ -1,4 +1,4 @@
-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";
 /** How long a new-mail pop-up stays before it goes by itself (while it is neither hovered nor focused, and the tab is in view). */
 export declare const TOAST_DURATION_MS = 8000;

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

@@ -1,5 +1,5 @@
 import { ReactElement } from "react";
-import type { Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Message } from "../../../lib/mail/mailApi.js";
 import { EmptyFolderOutcome, PurgeOutcome } from "./permanentDelete.js";
 /** The folder "Empty folder" is about. */
 export interface EmptiableFolder {

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

@@ -4,6 +4,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useRef, useState } from "react";
+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";
@@ -18,6 +19,7 @@ import { messageCount, notifyFolderEmptied, notifyPurged, purgeFolder, purgeMess
  */
 export function usePermanentDelete() {
     const { trackMessageChange, refreshFolderCounts } = useMailShell();
+    const client = useApiClient();
     const [pending, setPending] = useState(null);
     const [running, setRunning] = useState(false);
     // Set at once (state is a render later), so a key pressed twice does not open two dialogs.
@@ -57,7 +59,7 @@ export function usePermanentDelete() {
         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);
@@ -65,7 +67,7 @@ export function usePermanentDelete() {
         }
         let outcome;
         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}`);

package/dist/apps/shared/navigation/pageTitle.d.ts

@@ -1,4 +1,4 @@
-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 declare function brandName(branding?: Pick<Branding, "title" | "companyName"> | null): string;
 /**

package/dist/apps/shared/notifications/NotificationCenter.js

@@ -5,7 +5,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 ///////////////////////////////////////////////////////////////////////////////
 import { useEffect } from "react";
 import { HiOutlineBell, HiOutlineCheckCircle, HiOutlineEnvelope, HiOutlineExclamationCircle, HiOutlineExclamationTriangle, 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 { dismiss, setAllPaused, setPaused } from "./store.js";
 import { useNotifications } from "./useNotifications.js";
 import { useSystemErrorNotifications } from "./systemErrors.js";

package/dist/apps/shared/notifications/NotificationHistoryDialog.js

@@ -4,8 +4,8 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { 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 { useNotifications } from "./useNotifications.js";
 const KIND_LABEL = {
     mail: "New message",

package/dist/apps/shared/notifications/apiErrors.js

@@ -2,8 +2,8 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
-import { describeSendFailure } from "@rapidmx/react-shared/mail/sendFailure.js";
+import { ApiRequestError } from "../../../lib/util/api.js";
+import { describeSendFailure } from "../../../lib/mail/sendFailure.js";
 import { notify } from "./store.js";
 /** Whether `err` is a request that was cancelled (`AbortError`) - by name, since a `DOMException` is not always an `Error` (jsdom's is not). */
 export function isAbortError(err) {

package/dist/apps/shared/notifications/pushStatus.js

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useEffect } from "react";
-import { getPushClient } from "@rapidmx/react-shared/mail/pushClient.js";
+import { getPushClient } from "../../../lib/mail/pushClient.js";
 import { dismiss, notify } from "./store.js";
 /** How long the live connection has to be down before anyone is told: a reconnect within a few seconds is not worth a word. */
 export const PUSH_OFFLINE_NOTICE_MS = 10000;

package/dist/apps/shared/notifications/systemErrors.js

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useEffect } from "react";
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
+import { ApiRequestError } from "../../../lib/util/api.js";
 import { isAbortError } from "./apiErrors.js";
 import { notify } from "./store.js";
 /** The one key every unexpected failure shares: a page that throws in a loop is one pop-up with a count, never a flood. */

package/dist/apps/shared/search/LocalIndexLifecycle.d.ts

@@ -1,5 +1,5 @@
-import type { PublicKey } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
-import type { Folder } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { PublicKey } from "../../../lib/crypto/keyvaultApi.js";
+import type { Folder } from "../../../lib/mail/mailApi.js";
 export declare const POLL_INTERVAL_MS = 5000;
 export interface LocalIndexLifecycleProps {
     mailboxUid?: string;