@rapidmx/web-client 0.21.0 → 0.23.0

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;

package/dist/apps/shared/search/LocalIndexLifecycle.js

@@ -21,7 +21,8 @@
  * handles that case itself via `destroyAllLocalIndexes()`.
  */
 import { useEffect, useRef } from "react";
-import { getUnlockedKeys } from "@rapidmx/react-shared/crypto/keySession.js";
+import { getUnlockedKeys } from "../../../lib/crypto/keySession.js";
+import { useApiClient } from "../../../lib/util/apiClientContext.js";
 /**
  * The index builder (with the message security code it decrypts through - PKI.js and the ASN.1/X.509 libraries, over half a
  * megabyte) is loaded only once a mailbox is actually unlocked and a build is due, so an inbox that never unlocks - the
@@ -37,14 +38,18 @@ import { destroyLocalIndex, pruneInaccessibleLocalIndexes } from "./localIndexRp
 export const POLL_INTERVAL_MS = 5000;
 /** Renders nothing - pure side-effect component, mounted by `MailShell.tsx`. */
 export default function LocalIndexLifecycle({ mailboxUid, folders, accessibleMailboxUids }) {
+    // The explicit ApiClient (from useApiClient()) this component is rendered under - undefined for every existing caller (the SSR web/admin
+    // apps, Electron), which keeps building the index against the default global cookie-based session exactly as before. A native,
+    // multi-account host that renders this under an ApiClientContext.Provider gets its own account's client threaded through instead.
+    const client = useApiClient();
     // mailboxUid -> whether it was unlocked at the last check. An entry exists for every mailbox whose
     // build this component started; only ever changed by a real observed transition, never reset by an
     // effect re-run.
     const trackedRef = useRef(new Map());
-    // The latest props, for the long-lived polling interval below.
-    const latestRef = useRef({ mailboxUid, folders });
-    latestRef.current = { mailboxUid, folders };
-    function startBuildIfUnlocked(targetMailboxUid, targetFolders) {
+    // The latest props (and client), for the long-lived polling interval below.
+    const latestRef = useRef({ mailboxUid, folders, client });
+    latestRef.current = { mailboxUid, folders, client };
+    function startBuildIfUnlocked(targetMailboxUid, targetFolders, targetClient) {
         const unlocked = getUnlockedKeys(targetMailboxUid);
         if (!unlocked || targetFolders.length === 0 || trackedRef.current.get(targetMailboxUid)) {
             return;
@@ -53,14 +58,14 @@ export default function LocalIndexLifecycle({ mailboxUid, folders, accessibleMai
         // Never an unhandled rejection - a broken local index is best-effort infrastructure, not a build
         // the rest of the app depends on.
         loadBuilder()
-            .then(({ buildLocalIndex }) => buildLocalIndex(targetMailboxUid, unlocked, targetFolders))
+            .then(({ buildLocalIndex }) => buildLocalIndex(targetMailboxUid, unlocked, targetFolders, undefined, targetClient))
             .catch(() => undefined);
     }
     useEffect(() => {
         if (mailboxUid) {
-            startBuildIfUnlocked(mailboxUid, folders);
+            startBuildIfUnlocked(mailboxUid, folders, client);
         }
-    }, [mailboxUid, folders]);
+    }, [mailboxUid, folders, client]);
     useEffect(() => {
         const interval = setInterval(() => {
             for (const [trackedUid, wasUnlocked] of trackedRef.current) {
@@ -76,9 +81,9 @@ export default function LocalIndexLifecycle({ mailboxUid, folders, accessibleMai
                 }
             }
             // The active mailbox was (re-)unlocked since the last check, e.g. via an on-demand unlock prompt.
-            const { mailboxUid: activeUid, folders: activeFolders } = latestRef.current;
+            const { mailboxUid: activeUid, folders: activeFolders, client: activeClient } = latestRef.current;
             if (activeUid) {
-                startBuildIfUnlocked(activeUid, activeFolders);
+                startBuildIfUnlocked(activeUid, activeFolders, activeClient);
             }
         }, POLL_INTERVAL_MS);
         return () => clearInterval(interval);

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

@@ -1,4 +1,4 @@
-import type { SearchResult } from "@rapidmx/react-shared/search/searchApi.js";
+import type { SearchResult } from "../../../lib/search/searchApi.js";
 /**
  * How far a cross-mailbox search fans out. Exported (and mutable) so a test can shrink them instead of building 26 mailboxes or waiting a
  * minute for a timeout; nothing else writes to it.

package/dist/apps/shared/search/crossMailboxSearch.js

@@ -10,8 +10,8 @@
  *
  * A search of one mailbox is the same code with a list of one: nothing here changes what that returns.
  */
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
-import { normalizeServerScores } from "@rapidmx/react-shared/search/searchScoring.js";
+import { ApiRequestError } from "../../../lib/util/api.js";
+import { normalizeServerScores } from "../../../lib/search/searchScoring.js";
 /**
  * How far a cross-mailbox search fans out. Exported (and mutable) so a test can shrink them instead of building 26 mailboxes or waiting a
  * minute for a timeout; nothing else writes to it.

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

@@ -31,8 +31,9 @@
  * seals nothing. Signed-only (unencrypted) messages aren't sealed here: this pass never fetches their raw MIME (see
  * above), and fetching it only to seal would cost a download per message; they are sealed when opened.
  */
-import { type Folder } from "@rapidmx/react-shared/mail/mailApi.js";
-import type { UnlockedKeys } from "@rapidmx/react-shared/crypto/keySession.js";
+import { type Folder } from "../../../lib/mail/mailApi.js";
+import type { UnlockedKeys } from "../../../lib/crypto/keySession.js";
+import type { ApiClient } from "../../../lib/util/api.js";
 /** §11's Window Sizing table's time-floor column - explicitly unvalidated starting-point default per the
  * spec's own §16 "Measurement Task" ("cannot be supplied by design work... MUST NOT be treated as
  * validated"). Used as-is rather than invented/adjusted here. Not user-adjustable today (unlike the byte
@@ -78,7 +79,7 @@ export declare const MAX_SEAL_WRITES_PER_PASS = 200;
  * preference change in Settings takes effect starting with this mailbox's next build pass (its next
  * unlock), without requiring a reload.
  */
-export declare function buildLocalIndex(mailboxUid: string, unlocked: UnlockedKeys, folders: Folder[], windowConfig?: LocalIndexWindowConfig): Promise<void>;
+export declare function buildLocalIndex(mailboxUid: string, unlocked: UnlockedKeys, folders: Folder[], windowConfig?: LocalIndexWindowConfig, client?: ApiClient): Promise<void>;
 /** Stops a mailbox's running build pass, if any (e.g. its keys were just destroyed), resolving once it has
  * wound down. The Worker independently rejects the pass's later calls once the index is destroyed (see
  * `GenerationParams`); this just stops the fetching and decrypting too. Never rejects. */

package/dist/apps/shared/search/localIndexBuilder.js

@@ -35,8 +35,8 @@
  * seals nothing. Signed-only (unencrypted) messages aren't sealed here: this pass never fetches their raw MIME (see
  * above), and fetching it only to seal would cost a download per message; they are sealed when opened.
  */
-import { getMessageRawContent, listFolders, listMessages } from "@rapidmx/react-shared/mail/mailApi.js";
-import { evaluateMessageSecurity, evaluateMessageSecurityWithSeal } from "@rapidmx/react-shared/crypto/messageSecurity.js";
+import { getMessageRawContent, listFolders, listMessages } from "../../../lib/mail/mailApi.js";
+import { evaluateMessageSecurity, evaluateMessageSecurityWithSeal } from "../../../lib/crypto/messageSecurity.js";
 import { getPinnedSignerFingerprints } from "../components/mail/pinnedSigners.js";
 import { currentVerificationSeal, readVaultGeneration, sendVerificationSeal, verificationSealPending } from "../components/mail/verificationSeals.js";
 import { getIndexedVersions, indexLocalEntities, initLocalIndex, nextLocalIndexGeneration, pruneLocalEntities, setLocalIndexBuilding, setLocalIndexWindow, } from "./localIndexRpcClient.js";
@@ -75,7 +75,7 @@ export const FETCH_CONCURRENCY = 6;
 export const SEAL_WRITE_CONCURRENCY = 2;
 /** The most verification seals one pass writes. */
 export const MAX_SEAL_WRITES_PER_PASS = 200;
-function createPassSealer(mailboxUid, unlocked, signal) {
+function createPassSealer(mailboxUid, unlocked, signal, client) {
     let generation;
     const pins = new Map();
     const queue = [];
@@ -83,12 +83,12 @@ function createPassSealer(mailboxUid, unlocked, signal) {
     let active = 0;
     let idle;
     const stopped = () => signal.aborted || !!unlocked.destroyed;
-    const vaultGeneration = () => (generation ?? (generation = readVaultGeneration(mailboxUid)));
+    const vaultGeneration = () => (generation ?? (generation = readVaultGeneration(mailboxUid, client)));
     const pinsFor = (address) => {
         const key = address.toLowerCase();
         let entry = pins.get(key);
         if (!entry) {
-            entry = getPinnedSignerFingerprints(mailboxUid, address).then((fingerprints) => (fingerprints.length > 0 ? fingerprints : undefined), () => undefined);
+            entry = getPinnedSignerFingerprints(mailboxUid, address, client).then((fingerprints) => (fingerprints.length > 0 ? fingerprints : undefined), () => undefined);
             pins.set(key, entry);
         }
         return entry;
@@ -126,7 +126,7 @@ function createPassSealer(mailboxUid, unlocked, signal) {
             const sealToWrite = result.sealToWrite;
             if (sealToWrite && queued < MAX_SEAL_WRITES_PER_PASS) {
                 queued++;
-                queue.push(() => sendVerificationSeal(message.uid, sealToWrite));
+                queue.push(() => sendVerificationSeal(message.uid, sealToWrite, client));
                 pump();
             }
             return result;
@@ -178,6 +178,9 @@ async function mapWithConcurrency(items, limit, fn) {
 async function buildEntity(message, sealer) {
     let rawMime;
     try {
+        // getMessageRawContent() bypasses apiFetch() entirely (it streams message/rfc822, not JSON - see its own doc comment) and does not
+        // yet accept an explicit ApiClient at all; threading a per-account client through it is out of scope here (mailApi.ts is not one of
+        // this task's files). It still falls back to the default global session even under an ApiClientContext.Provider.
         rawMime = await getMessageRawContent(message.uid);
     }
     catch {
@@ -241,7 +244,7 @@ async function buildEntity(message, sealer) {
  * preference change in Settings takes effect starting with this mailbox's next build pass (its next
  * unlock), without requiring a reload.
  */
-export async function buildLocalIndex(mailboxUid, unlocked, folders, windowConfig = { timeFloorMonths: WEB_TIME_FLOOR_MONTHS, byteBudgetBytes: getLocalIndexByteBudget() }) {
+export async function buildLocalIndex(mailboxUid, unlocked, folders, windowConfig = { timeFloorMonths: WEB_TIME_FLOOR_MONTHS, byteBudgetBytes: getLocalIndexByteBudget() }, client) {
     // At most one pass per mailbox: a newer one cancels the older and waits for it to wind down first.
     const previous = activeBuilds.get(mailboxUid);
     const controller = new AbortController();
@@ -250,7 +253,7 @@ export async function buildLocalIndex(mailboxUid, unlocked, folders, windowConfi
             previous.controller.abort();
             await previous.settled;
         }
-        await runBuildPass(mailboxUid, unlocked, folders, windowConfig, controller.signal);
+        await runBuildPass(mailboxUid, unlocked, folders, windowConfig, controller.signal, client);
     })();
     const entry = { controller, settled: run.catch(() => undefined) };
     activeBuilds.set(mailboxUid, entry);
@@ -277,7 +280,7 @@ export async function cancelLocalIndexBuild(mailboxUid) {
 function isOlderThan(date, watermark) {
     return !!watermark && new Date(date).getTime() < new Date(watermark).getTime();
 }
-async function runBuildPass(mailboxUid, unlocked, folders, windowConfig, signal) {
+async function runBuildPass(mailboxUid, unlocked, folders, windowConfig, signal, client) {
     const generation = nextLocalIndexGeneration();
     const indexKey = await deriveLocalIndexKey(unlocked.masterKey, mailboxUid);
     signal.throwIfAborted();
@@ -295,7 +298,7 @@ async function runBuildPass(mailboxUid, unlocked, folders, windowConfig, signal)
     // count, no listing/fetch failure and no budget cut-off - the only case where coverage can be used to
     // narrow Tier 3.
     let complete = true;
-    const sealer = createPassSealer(mailboxUid, unlocked, signal);
+    const sealer = createPassSealer(mailboxUid, unlocked, signal, client);
     try {
         if (folders.some((f) => !MESSAGE_FOLDER_TYPES.has(f.type) && !NON_MESSAGE_FOLDER_TYPES.has(f.type))) {
             complete = false;
@@ -309,7 +312,7 @@ async function runBuildPass(mailboxUid, unlocked, folders, windowConfig, signal)
                 signal.throwIfAborted();
                 let messages;
                 try {
-                    messages = await listMessages(folder.uid, { page, limit: PAGE_SIZE });
+                    messages = await listMessages(folder.uid, { page, limit: PAGE_SIZE }, client);
                 }
                 catch {
                     return "failed";
@@ -350,7 +353,7 @@ async function runBuildPass(mailboxUid, unlocked, folders, windowConfig, signal)
         /** Each folder's current total, or `undefined` if the listing failed. */
         async function folderTotals() {
             try {
-                return new Map((await listFolders(mailboxUid)).map((f) => [f.uid, f.totalCount]));
+                return new Map((await listFolders(mailboxUid, client)).map((f) => [f.uid, f.totalCount]));
             }
             catch {
                 return undefined;

package/dist/apps/shared/search/localIndexKey.js

@@ -14,7 +14,7 @@
  * already uniformly random) and avoids needing to persist, transmit, or ever lose a random salt just to
  * re-derive the same key on the next unlock.
  */
-import { hkdfDerive } from "@rapidmx/react-shared/crypto/masterKey.js";
+import { hkdfDerive } from "../../../lib/crypto/masterKey.js";
 /** Fixed, non-secret HKDF salt - see this module's own doc comment for why a fixed salt is fine here. */
 const FIXED_SALT = new TextEncoder().encode("rapidmx-local-search-index-v1");
 /** Derives this mailbox's local-index page-encryption key from its already-unlocked master key. Every