@rapidmx/web-client 0.21.0 → 0.23.0

package/apps/shared/components/mail/reading/conversationPrint.ts

@@ -0,0 +1,76 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { getUnlockedKeys } from "../../../../../lib/crypto/keySession.js";
+import { listConversationMessages } from "../../../../../lib/mail/conversationsApi.js";
+import { formatMailAddress } from "../../../../../lib/mail/mailAddress.js";
+import { getMessageRawContent, listAttachments, type Message, type Recipient } from "../../../../../lib/mail/mailApi.js";
+import type { ApiClient } from "../../../../../lib/util/api.js";
+import { fetchBodyContent } from "./bodyContent.js";
+import { ENCRYPTED_SUBJECT_PLACEHOLDER, displaySubject } from "./EncryptedPreview.js";
+import type { PrintableMessage } from "./printMessage.js";
+
+const format = (list: Recipient[]) => list.map((r) => formatMailAddress(r)).join(", ");
+
+/** The header lines printed above a message's body. */
+export function printHeaders(message: Message, from: string): PrintableMessage["headers"] {
+    return [
+        { name: "From", value: from },
+        { name: "To", value: format(message.recipients.filter((r) => r.type !== "cc" && r.type !== "bcc")) },
+        { name: "Cc", value: format(message.recipients.filter((r) => r.type === "cc")) },
+        { name: "Date", value: new Date(message.receivedDate).toLocaleString() },
+    ];
+}
+
+/**
+ * The messages of `message`'s conversation that came before it, newest first - the order they follow it in a printed conversation. A conversation
+ * the server has no id for (or one that can't be read) has none: the message prints alone.
+ */
+export async function olderConversationMessages(message: Message, client?: ApiClient): Promise<Message[]> {
+    if (!message.conversationId) {
+        return [];
+    }
+    const thread = await listConversationMessages(message.mailboxUid, message.conversationId, { limit: 500 }, client);
+    const sent = new Date(message.receivedDate).getTime();
+    return thread
+        .filter((other) => other.uid !== message.uid && new Date(other.receivedDate).getTime() <= sent)
+        .sort((a, b) => new Date(b.receivedDate).getTime() - new Date(a.receivedDate).getTime());
+}
+
+/**
+ * One earlier message of a conversation as it prints: the body the reading pane would show. An encrypted one is decrypted here when this device has
+ * its mailbox's keys unlocked; when it can't be, it prints a line saying so rather than the ciphertext.
+ */
+export async function printableOlderMessage(message: Message): Promise<PrintableMessage> {
+    const attachments = await listAttachments(message.folderUid, message.uid).catch(() => []);
+    if (message.encrypted) {
+        const unlocked = getUnlockedKeys(message.mailboxUid);
+        if (unlocked) {
+            const { evaluateMessageSecurity } = await import("../../../../../lib/crypto/messageSecurity.js");
+            const security = await evaluateMessageSecurity(await getMessageRawContent(message.uid), unlocked);
+            const content =
+                security.text !== undefined ? ({ kind: "text", text: security.text } as const) : security.html !== undefined ? ({ kind: "html", html: security.html } as const) : undefined;
+            if (content) {
+                return {
+                    subject: (message.subject === ENCRYPTED_SUBJECT_PLACEHOLDER ? security.subject : undefined) || displaySubject(message.subject) || "(no subject)",
+                    headers: printHeaders(message, formatMailAddress(message.from)),
+                    content,
+                    attachments,
+                    inlineParts: security.attachments,
+                };
+            }
+        }
+        return {
+            subject: displaySubject(message.subject) || "(no subject)",
+            headers: printHeaders(message, formatMailAddress(message.from)),
+            content: { kind: "text", text: "This message is encrypted and could not be decrypted, so it is not printed." },
+        };
+    }
+    return {
+        subject: message.subject || "(no subject)",
+        headers: printHeaders(message, formatMailAddress(message.from)),
+        content: await fetchBodyContent(message.uid, message.version),
+        attachments,
+    };
+}

package/apps/shared/components/mail/reading/messageExport.ts

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { binaryStringToBytes, extractAddresses, parseMimeEntity } from "@rapidmx/react-shared/crypto/mime.js";
+import { binaryStringToBytes, extractAddresses, parseMimeEntity } from "../../../../../lib/crypto/mime.js";
 
 /**
  * What the reading pane does with a message's raw RFC 5322 source (`getMessageRawContent()`, a binary string): show it, save it as a

package/apps/shared/components/mail/reading/printMessage.ts

@@ -2,14 +2,14 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import type { Attachment } from "@rapidmx/react-shared/mail/mailApi.js";
-import type { MimeAttachment } from "@rapidmx/react-shared/crypto/mime.js";
+import type { Attachment } from "../../../../../lib/mail/mailApi.js";
+import type { MimeAttachment } from "../../../../../lib/crypto/mime.js";
 import { BodyContent, attachmentSource, makeCidResolver } from "./bodyContent.js";
 import { prepareBodyHtml } from "./bodyHtml.js";
 import { frameCsp } from "./frameDocument.js";
 
 /**
- * Printing one message: a document of its own - the message's header lines, and under them the same sanitized body the reading pane draws -
+ * Printing a message, and the conversation it belongs to: a document of its own - each message's header lines, and under them the same sanitized body the reading pane draws -
  * shown in a frame that nobody sees and printed from there, so the print is the message and not the app around it.
  *
  * The frame is as isolated as the reading pane's own (`frameDocument.ts`): the body has been through `prepareBodyHtml()`, the document
@@ -35,6 +35,8 @@ dl{margin:0 0 12px;display:grid;grid-template-columns:max-content 1fr;gap:2px 12
 dt{font-weight:600;color:#444}
 dd{margin:0;overflow-wrap:anywhere}
 hr{border:0;border-top:1px solid #999;margin:0 0 16px}
+h2{font-size:16px;margin:0 0 12px}
+.rr-older{margin-top:28px;padding-top:20px;border-top:2px solid #000;break-inside:auto}
 #rr-body{overflow-wrap:break-word}
 #rr-body img{max-width:100%;height:auto}
 #rr-body pre,pre.rr-text{white-space:pre-wrap;font:inherit;margin:0}
@@ -44,10 +46,14 @@ export function escapeHtml(text: string): string {
     return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 
-/**
- * The document to print, or `undefined` for a body too large to prepare (the pane does not draw it either).
- */
-export function buildPrintDocument(message: PrintableMessage): string | undefined {
+interface PrintSection {
+    /** The `<dl>`, rule and body of one message. */
+    html: string;
+    imageSource?: string;
+}
+
+/** One message's header lines and body, or `undefined` for a body too large to prepare (the pane does not draw it either). */
+function renderSection(message: PrintableMessage): PrintSection | undefined {
     let body: string;
     let imageSource: string | undefined;
     if (message.content.kind === "html") {
@@ -65,13 +71,44 @@ export function buildPrintDocument(message: PrintableMessage): string | undefine
         .filter((header) => header.value !== "")
         .map((header) => `<dt>${escapeHtml(header.name)}</dt><dd>${escapeHtml(header.value)}</dd>`)
         .join("");
+    return { html: `<dl>${lines}</dl><hr>${body}`, imageSource };
+}
+
+/**
+ * The document to print, or `undefined` for a body too large to prepare (the pane does not draw it either).
+ */
+export function buildPrintDocument(message: PrintableMessage): string | undefined {
+    return buildConversationPrintDocument(message.subject, [message]);
+}
+
+/**
+ * The document to print for a conversation: `subject` as the title, then each of `messages` in the order given (the message that was asked for
+ * first, then the ones before it), each under its own header lines and set apart from the last. A message whose subject differs from the title
+ * says so under its rule. Only the first message is required to be printable: a later one too large to prepare is replaced by a note saying so.
+ */
+export function buildConversationPrintDocument(subject: string, messages: PrintableMessage[]): string | undefined {
+    const sections: string[] = [];
+    let imageSource: string | undefined;
+    for (const [index, message] of messages.entries()) {
+        const section = renderSection(message);
+        if (section === undefined && index === 0) {
+            return undefined;
+        }
+        imageSource ??= section?.imageSource;
+        const html = section?.html ?? `<p>${escapeHtml(`"${message.subject}" is too large to print here.`)}</p>`;
+        sections.push(
+            index === 0
+                ? html
+                : `<div class="rr-older">${message.subject !== subject ? `<h2>${escapeHtml(message.subject)}</h2>` : ""}${html}</div>`,
+        );
+    }
     return [
         "<!doctype html>",
         '<html lang="en"><head><meta charset="utf-8">',
         `<meta http-equiv="Content-Security-Policy" content="${frameCsp(imageSource)}">`,
-        `<title>${escapeHtml(message.subject)}</title>`,
+        `<title>${escapeHtml(subject)}</title>`,
         `<style>${PRINT_CSS}</style></head>`,
-        `<body><h1>${escapeHtml(message.subject)}</h1><dl>${lines}</dl><hr>${body}</body></html>`,
+        `<body><h1>${escapeHtml(subject)}</h1>${sections.join("")}</body></html>`,
     ].join("");
 }
 

package/apps/shared/components/mail/reading/useMessageActions.ts

@@ -12,7 +12,7 @@ import {
     moveMessage,
     reportMessage,
     setMessageFlagged,
-} from "@rapidmx/react-shared/mail/mailApi.js";
+} from "../../../../../lib/mail/mailApi.js";
 import {
     SenderListsChange,
     addBlockedSender,
@@ -20,8 +20,9 @@ import {
     checkSenderEntry,
     removeBlockedSender,
     removeSafeSender,
-} from "@rapidmx/react-shared/mail/senderListsApi.js";
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
+} from "../../../../../lib/mail/senderListsApi.js";
+import { ApiRequestError } from "../../../../../lib/util/api.js";
+import { useApiClient } from "../../../../../lib/util/apiClientContext.js";
 import type { CountTracker } from "../../../mail/folderCounts.js";
 import { resolveFolderOfType } from "../../../mail/folderOfType.js";
 import { setReadStateMany } from "../../../mail/messageReadState.js";
@@ -100,6 +101,7 @@ function isNotFound(err: unknown): boolean {
 export function useMessageActions(params: MessageActionsParams): MessageActions {
     const { message, newest, remember, folders, inJunk, inDeletedItems, ownAddresses = [], trackMessageChange, onMoved, onChanged, onFolderCreated } = params;
     const [busy, setBusy] = useState(false);
+    const client = useApiClient();
     const permanent = usePermanentDelete();
 
     /** Runs one action with the card's other actions held meanwhile. */
@@ -113,7 +115,7 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
     }
 
     function folderOf(type: Folder["type"], name: string): Promise<string> {
-        return resolveFolderOfType(message.mailboxUid, type, name, folders, onFolderCreated);
+        return resolveFolderOfType(message.mailboxUid, type, name, folders, onFolderCreated, client);
     }
 
     /** The card's part of a message having left its folder for `updated`'s: the folder badges and the local search index. */
@@ -126,7 +128,7 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
     /** Moves the message into its mailbox's folder of `type`, and tells the folder badges and the local search index. */
     async function moveToType(type: Folder["type"], name: string): Promise<Message> {
         const before = newest();
-        const updated = await moveMessage(before, await folderOf(type, name));
+        const updated = await moveMessage(before, await folderOf(type, name), client);
         relocated(before, updated);
         return updated;
     }
@@ -154,7 +156,7 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
                       {
                           label: "Undo",
                           onClick: () => {
-                              removeSafeSender(message.mailboxUid, safeSender).then(
+                              removeSafeSender(message.mailboxUid, safeSender, client).then(
                                   () => notify({ kind: "info", title: `${safeSender} is no longer a safe sender`, message: "This message stays in the Inbox." }),
                                   (err) => notifyApiError(err, "Couldn't undo trusting this sender"),
                               );
@@ -188,7 +190,7 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
         await exclusive(async () => {
             let result: MessageReportResult;
             try {
-                result = await reportMessage(message.uid, kind, { alwaysTrustSender });
+                result = await reportMessage(message.uid, kind, { alwaysTrustSender }, client);
             } catch (err) {
                 if (isNotFound(err)) {
                     await reportByMoving(kind, alwaysTrustSender);
@@ -225,13 +227,18 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
         await exclusive(async () => {
             const before = newest();
             try {
-                await setReadStateMany([before], before.flags.read !== true, {
-                    patch: (updated, previous) => {
-                        remember(updated);
-                        onChanged?.(updated, previous);
+                await setReadStateMany(
+                    [before],
+                    before.flags.read !== true,
+                    {
+                        patch: (updated, previous) => {
+                            remember(updated);
+                            onChanged?.(updated, previous);
+                        },
+                        track: trackMessageChange,
                     },
-                    track: trackMessageChange,
-                });
+                    client,
+                );
             } catch (err) {
                 notifyApiError(err, "Couldn't update the message");
             }
@@ -242,7 +249,7 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
         await exclusive(async () => {
             const before = newest();
             try {
-                const updated = await setMessageFlagged(before, before.flags.flagged !== true);
+                const updated = await setMessageFlagged(before, before.flags.flagged !== true, client);
                 remember(updated);
                 onChanged?.(updated, before);
             } catch (err) {
@@ -289,7 +296,7 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
         let result: Awaited<ReturnType<typeof blockSender>>;
         try {
             const [junkUid, inboxUid] = await Promise.all([folderOf("junk", "Junk Email"), folderOf("inbox", "Inbox")]);
-            result = await blockSender(message.mailboxUid, addresses, junkUid, inboxUid);
+            result = await blockSender(message.mailboxUid, addresses, junkUid, inboxUid, client);
         } catch (err) {
             notifyApiError(err, "Couldn't block this sender");
             return;
@@ -306,7 +313,7 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
                           {
                               label: "Undo",
                               onClick: () => {
-                                  removeSenderRule(result.rule).then(
+                                  removeSenderRule(result.rule, client).then(
                                       () => notify({ kind: "info", title: `Unblocked ${address}`, message: "The block was removed. This message stays where it is." }),
                                       (err) => notifyApiError(err, "Couldn't undo the block"),
                                   );
@@ -331,7 +338,7 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
             }
             let added: SenderListsChange;
             try {
-                added = await addBlockedSender(message.mailboxUid, listed);
+                added = await addBlockedSender(message.mailboxUid, listed, client);
             } catch (err) {
                 if (isNotFound(err)) {
                     await blockWithRules(all, message.from.address);
@@ -351,7 +358,7 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
                               {
                                   label: "Undo",
                                   onClick: () => {
-                                      removeBlockedSender(message.mailboxUid, listed).then(
+                                      removeBlockedSender(message.mailboxUid, listed, client).then(
                                           () => notify({ kind: "info", title: `Unblocked ${listed}`, message: "The block was removed. This message stays where it is." }),
                                           (err) => notifyApiError(err, "Couldn't undo the block"),
                                       );
@@ -370,7 +377,7 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
         let result: Awaited<ReturnType<typeof neverBlockSender>>;
         try {
             const [junkUid, inboxUid] = await Promise.all([folderOf("junk", "Junk Email"), folderOf("inbox", "Inbox")]);
-            result = await neverBlockSender(message.mailboxUid, addresses, junkUid, inboxUid);
+            result = await neverBlockSender(message.mailboxUid, addresses, junkUid, inboxUid, client);
         } catch (err) {
             notifyApiError(err, "Couldn't stop blocking this sender");
             return;
@@ -392,7 +399,7 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
             }
             let added: SenderListsChange;
             try {
-                added = await addSafeSender(message.mailboxUid, listed);
+                added = await addSafeSender(message.mailboxUid, listed, client);
             } catch (err) {
                 if (isNotFound(err)) {
                     await neverBlockWithRules(all, message.from.address);
@@ -413,7 +420,7 @@ export function useMessageActions(params: MessageActionsParams): MessageActions
                               {
                                   label: "Undo",
                                   onClick: () => {
-                                      removeSafeSender(message.mailboxUid, listed).then(
+                                      removeSafeSender(message.mailboxUid, listed, client).then(
                                           () => notify({ kind: "info", title: `${listed} is no longer a safe sender`, message: "Its mail is filtered as usual again." }),
                                           (err) => notifyApiError(err, "Couldn't undo the change"),
                                       );

package/apps/shared/components/mail/unreadStyle.tsx

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import React from "react";
-import type { Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Message } from "../../../../lib/mail/mailApi.js";
 
 /**
  * How an unread message looks in every list of mail (the message list, the conversation list and its child rows, the

package/apps/shared/components/mail/verificationSeals.ts

@@ -18,11 +18,11 @@
  * evaluation try again, never a retry loop. A stored seal is remembered (`currentVerificationSeal()`) so a message
  * reopened before its list copy is refreshed opens that seal instead of building another.
  */
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
-import { getKeyVault } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
-import { subscribeKeySession } from "@rapidmx/react-shared/crypto/keySession.js";
-import { type Message, setMessageVerificationSeal } from "@rapidmx/react-shared/mail/mailApi.js";
-import type { SealToWrite } from "@rapidmx/react-shared/crypto/messageSecurity.js";
+import { ApiClient, ApiRequestError } from "../../../../lib/util/api.js";
+import { getKeyVault } from "../../../../lib/crypto/keyvaultApi.js";
+import { subscribeKeySession } from "../../../../lib/crypto/keySession.js";
+import { type Message, setMessageVerificationSeal } from "../../../../lib/mail/mailApi.js";
+import type { SealToWrite } from "../../../../lib/crypto/messageSecurity.js";
 
 /** How long one mailbox's vault generation is reused before it is read again. */
 export const VAULT_GENERATION_TTL_MS = 60_000;
@@ -59,23 +59,27 @@ function subscribeToLocksOnce(): void {
 
 /** Reads `mailboxUid`'s current vault `masterKeyGeneration`, uncached: `undefined` when the vault can't be read or
  * reports none. Never rejects. */
-export async function readVaultGeneration(mailboxUid: string): Promise<number | undefined> {
+export async function readVaultGeneration(mailboxUid: string, client?: ApiClient): Promise<number | undefined> {
     try {
-        const { masterKeyGeneration } = await getKeyVault(mailboxUid);
+        const { masterKeyGeneration } = await getKeyVault(mailboxUid, client);
         return Number.isSafeInteger(masterKeyGeneration) && masterKeyGeneration! >= 0 ? masterKeyGeneration : undefined;
     } catch {
         return undefined;
     }
 }
 
-/** `mailboxUid`'s current vault `masterKeyGeneration`, or `undefined` when it can't be read. Never rejects. */
-export function getVaultGeneration(mailboxUid: string): Promise<number | undefined> {
+/** `mailboxUid`'s current vault `masterKeyGeneration`, or `undefined` when it can't be read. Never rejects.
+ *
+ * The cache below is keyed by `mailboxUid` alone, not by `client` - fine for every caller today (a
+ * `mailboxUid` belongs to one account's own `ApiClient`), but worth knowing if a future caller ever reused
+ * the same `mailboxUid` string across two different `ApiClient`s. */
+export function getVaultGeneration(mailboxUid: string, client?: ApiClient): Promise<number | undefined> {
     subscribeToLocksOnce();
     const entry = generationCache.get(mailboxUid);
     if (entry && Date.now() - entry.loadedAt <= VAULT_GENERATION_TTL_MS) {
         return entry.generation;
     }
-    const created = { loadedAt: Date.now(), generation: readVaultGeneration(mailboxUid) };
+    const created = { loadedAt: Date.now(), generation: readVaultGeneration(mailboxUid, client) };
     generationCache.set(mailboxUid, created);
     void created.generation.then((generation) => {
         // Only a readable generation is reused; an unavailable one is read again next time.
@@ -106,14 +110,14 @@ export function verificationSealPending(messageUid: string, generation: number):
 
 /** Stores `sealToWrite` on `messageUid`, best effort - see this module's doc comment. Resolves `true` when a request was
  * sent, `false` when the write was skipped as already attempted. Never rejects. */
-export async function sendVerificationSeal(messageUid: string, sealToWrite: SealToWrite): Promise<boolean> {
+export async function sendVerificationSeal(messageUid: string, sealToWrite: SealToWrite, client?: ApiClient): Promise<boolean> {
     const key = `${messageUid}:${sealToWrite.masterKeyGeneration}`;
     if (attemptedWrites.has(key)) {
         return false;
     }
     attemptedWrites.add(key);
     try {
-        await setMessageVerificationSeal(messageUid, sealToWrite.seal, sealToWrite.masterKeyGeneration);
+        await setMessageVerificationSeal(messageUid, sealToWrite.seal, sealToWrite.masterKeyGeneration, client);
         storedSeals.set(messageUid, sealToWrite);
     } catch (err) {
         // `VerificationSealConflictError` is an `ApiRequestError` with status 409.

package/apps/shared/components/mail/writableMailboxes.ts

@@ -18,8 +18,10 @@
  * answer arrives.
  */
 import { useEffect, useMemo, useState } from "react";
-import type { Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
-import { getMyMailboxAccess } from "@rapidmx/react-shared/mail/mailboxAccessApi.js";
+import type { Mailbox } from "../../../../lib/mail/mailApi.js";
+import { getMyMailboxAccess } from "../../../../lib/mail/mailboxAccessApi.js";
+import type { ApiClient } from "../../../../lib/util/api.js";
+import { useApiClient } from "../../../../lib/util/apiClientContext.js";
 
 /** `true` writable, `false` known view-only, `undefined` couldn't tell (treated as writable). */
 export type MailboxWritability = boolean | undefined;
@@ -42,15 +44,19 @@ export function peekMailboxWritability(mailbox: Mailbox, userUid: string | undef
     return isImplicitlyWritable(mailbox, userUid, trusted) ? true : settled.get(mailbox.uid);
 }
 
-/** Whether the caller can create items in `mailbox`. Never rejects. */
-export function getMailboxWritability(mailbox: Mailbox, userUid: string | undefined, trusted?: boolean): Promise<MailboxWritability> {
+/** Whether the caller can create items in `mailbox`. Never rejects.
+ *
+ * `inFlight`/`settled` are keyed by `mailbox.uid` alone, not by `client` - fine for every caller today (a
+ * mailbox uid belongs to one account's own `ApiClient`), but worth knowing if a future caller ever reused
+ * the same mailbox uid across two different `ApiClient`s. */
+export function getMailboxWritability(mailbox: Mailbox, userUid: string | undefined, trusted?: boolean, client?: ApiClient): Promise<MailboxWritability> {
     const known = peekMailboxWritability(mailbox, userUid, trusted);
     if (known !== undefined) {
         return Promise.resolve(known);
     }
     let request = inFlight.get(mailbox.uid);
     if (!request) {
-        request = getMyMailboxAccess(mailbox.uid).then(
+        request = getMyMailboxAccess(mailbox.uid, client).then(
             (access) => {
                 settled.set(mailbox.uid, access.canCreate);
                 inFlight.delete(mailbox.uid);
@@ -70,11 +76,12 @@ export function getMailboxWritability(mailbox: Mailbox, userUid: string | undefi
 /** Per-mailbox writability answers for `mailboxes`, filled in as each one arrives (already-known answers are
  * present from the first render). */
 export function useMailboxWritability(mailboxes: Mailbox[], userUid: string | undefined, trusted?: boolean): Record<string, MailboxWritability> {
+    const client = useApiClient();
     const [answers, setAnswers] = useState<Record<string, MailboxWritability>>({});
     useEffect(() => {
         let cancelled = false;
         for (const mailbox of mailboxes) {
-            void getMailboxWritability(mailbox, userUid, trusted).then((writable) => {
+            void getMailboxWritability(mailbox, userUid, trusted, client).then((writable) => {
                 if (!cancelled) {
                     setAnswers((prev) => ({ ...prev, [mailbox.uid]: writable }));
                 }
@@ -83,7 +90,7 @@ export function useMailboxWritability(mailboxes: Mailbox[], userUid: string | un
         return () => {
             cancelled = true;
         };
-    }, [mailboxes, userUid, trusted]);
+    }, [mailboxes, userUid, trusted, client]);
     return useMemo(() => {
         const merged: Record<string, MailboxWritability> = {};
         for (const mailbox of mailboxes) {

package/apps/shared/components/rules/RuleBuilder.tsx

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import React, { ReactNode, useState } from "react";
-import Button from "@rapidmx/react-shared/components/buttons/Button.js";
+import Button from "../../../../lib/components/buttons/Button.js";
 
 const INPUT_CLASS =
     "flex-1 text-sm py-2 px-3 border border-border rounded-sm bg-surface text-text focus:outline-none focus:border-primary";

package/apps/shared/components/settings/SigningCertificateCard.tsx

@@ -4,10 +4,10 @@
 ///////////////////////////////////////////////////////////////////////////////
 import React from "react";
 import { HiOutlineCheckCircle, HiOutlineExclamationTriangle, HiOutlineXCircle } from "react-icons/hi2";
-import Alert from "@rapidmx/react-shared/components/feedback/Alert.js";
-import Button from "@rapidmx/react-shared/components/buttons/Button.js";
-import CopyButton from "@rapidmx/react-shared/components/buttons/CopyButton.js";
-import type { EnrollmentResult, SignEnrollmentStep } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import Alert from "../../../../lib/components/feedback/Alert.js";
+import Button from "../../../../lib/components/buttons/Button.js";
+import CopyButton from "../../../../lib/components/buttons/CopyButton.js";
+import type { EnrollmentResult, SignEnrollmentStep } from "../../../../lib/crypto/keyvaultApi.js";
 import type { EnrollmentSnapshot } from "../../signing/enrollmentTracker.js";
 import type { SigningEnrollmentInfo } from "../../signing/signingInfo.js";
 import {

package/apps/shared/components/settings/layout/SettingsShell.tsx

@@ -4,11 +4,12 @@
 ///////////////////////////////////////////////////////////////////////////////
 import React, { createContext, PropsWithChildren, ReactNode, useContext, useEffect, useMemo, useState } from "react";
 import { HiOutlineBars3 } from "react-icons/hi2";
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
-import Drawer from "@rapidmx/react-shared/components/overlays/Drawer.js";
-import { Mailbox, listMailboxes } from "@rapidmx/react-shared/mail/mailApi.js";
-import Alert from "@rapidmx/react-shared/components/feedback/Alert.js";
-import Skeleton, { SkeletonList } from "@rapidmx/react-shared/components/feedback/Skeleton.js";
+import { ApiRequestError } from "../../../../../lib/util/api.js";
+import Drawer from "../../../../../lib/components/overlays/Drawer.js";
+import { Mailbox, listMailboxes } from "../../../../../lib/mail/mailApi.js";
+import { useApiClient } from "../../../../../lib/util/apiClientContext.js";
+import Alert from "../../../../../lib/components/feedback/Alert.js";
+import Skeleton, { SkeletonList } from "../../../../../lib/components/feedback/Skeleton.js";
 import AppShell, { AppShellProps } from "../../layout/AppShell.js";
 import { useLocation, useNavigate } from "../../../navigation/index.js";
 import MailboxProvisioning from "../../layout/MailboxProvisioning.js";
@@ -93,6 +94,7 @@ export default function SettingsShell({
     pluginNav,
     children,
 }: PropsWithChildren<SettingsShellProps>) {
+    const client = useApiClient();
     const [status, setStatus] = useState<Status>("checking");
     const [error, setError] = useState<string | null>(null);
     const [mailboxes, setMailboxes] = useState<Mailbox[]>([]);
@@ -116,7 +118,7 @@ export default function SettingsShell({
         if (!userUid) {
             return;
         }
-        listMailboxes({ limit: 100 })
+        listMailboxes({ limit: 100 }, client)
             .then((result) => {
                 setMailboxes(orderMailboxes(result, userUid));
                 setStatus("ready");

package/apps/shared/components/sharing/PrincipalListField.tsx

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import React from "react";
-import { ResolvedPrincipal } from "@rapidmx/react-shared/mail/mailboxAccessApi.js";
+import { ResolvedPrincipal } from "../../../../lib/mail/mailboxAccessApi.js";
 import PrincipalResolver, { describePerson } from "./PrincipalResolver.js";
 
 export interface PrincipalListFieldProps {

package/apps/shared/components/sharing/PrincipalPicker.tsx

@@ -8,7 +8,7 @@ import {
     ResolvedPrincipal,
     resolveMailboxPrincipal,
     setMailboxAccess,
-} from "@rapidmx/react-shared/mail/mailboxAccessApi.js";
+} from "../../../../lib/mail/mailboxAccessApi.js";
 import PrincipalResolver, { describePerson } from "./PrincipalResolver.js";
 
 export { describePerson };

package/apps/shared/components/sharing/PrincipalResolver.tsx

@@ -3,10 +3,10 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import React, { KeyboardEvent, ReactNode, useEffect, useState } from "react";
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
-import { ResolvedPrincipal } from "@rapidmx/react-shared/mail/mailboxAccessApi.js";
-import Alert from "@rapidmx/react-shared/components/feedback/Alert.js";
-import Button from "@rapidmx/react-shared/components/buttons/Button.js";
+import { ApiRequestError } from "../../../../lib/util/api.js";
+import { ResolvedPrincipal } from "../../../../lib/mail/mailboxAccessApi.js";
+import Alert from "../../../../lib/components/feedback/Alert.js";
+import Button from "../../../../lib/components/buttons/Button.js";
 
 export interface PrincipalResolverProps {
     /** Resolves what was typed - a mailbox address, an auth-server username or e-mail alias, or a user uid - to

package/apps/shared/components/tasks/TasksSidebar.tsx

@@ -4,9 +4,10 @@
 ///////////////////////////////////////////////////////////////////////////////
 import React, { FormEvent, useEffect, useMemo, useState } from "react";
 import { HiOutlineBars3 } from "react-icons/hi2";
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
-import { Task, TaskList, createTaskList, listTaskLists } from "@rapidmx/react-shared/tasks/tasksApi.js";
-import Drawer from "@rapidmx/react-shared/components/overlays/Drawer.js";
+import { ApiRequestError } from "../../../../lib/util/api.js";
+import { Task, TaskList, createTaskList, listTaskLists } from "../../../../lib/tasks/tasksApi.js";
+import Drawer from "../../../../lib/components/overlays/Drawer.js";
+import { useApiClient } from "../../../../lib/util/apiClientContext.js";
 import { notifyApiError } from "../../notifications/apiErrors.js";
 
 export type TasksView =
@@ -61,6 +62,7 @@ function NavItem({ label, count, active, onClick }: { label: string; count?: num
  * lists are real `TaskList` records, fetched here (same pattern as `ContactsSidebar`'s contact lists).
  */
 export default function TasksSidebar({ mailboxUid, tasks, userUid, active, onSelect, refreshToken }: TasksSidebarProps) {
+    const client = useApiClient();
     const [lists, setLists] = useState<TaskList[]>([]);
     const [listsError, setListsError] = useState<string | null>(null);
     const [addingList, setAddingList] = useState(false);
@@ -73,7 +75,7 @@ export default function TasksSidebar({ mailboxUid, tasks, userUid, active, onSel
             return;
         }
         setListsError(null);
-        listTaskLists(mailboxUid, { limit: 200 })
+        listTaskLists(mailboxUid, { limit: 200 }, client)
             .then(setLists)
             .catch((err) => setListsError(err instanceof ApiRequestError ? err.message : "Could not load task lists."));
     }, [mailboxUid, refreshToken]);
@@ -98,7 +100,7 @@ export default function TasksSidebar({ mailboxUid, tasks, userUid, active, onSel
             return;
         }
         try {
-            const created = await createTaskList({ mailboxUid, name: newListName.trim() });
+            const created = await createTaskList({ mailboxUid, name: newListName.trim() }, client);
             setLists((prev) => [...prev, created].sort((a, b) => a.name.localeCompare(b.name)));
             setNewListName("");
             setAddingList(false);