@rapidmx/web-client 0.20.0 → 0.22.0

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;

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. */