@rapidmx/web-client 0.35.0 → 0.37.0

package/dist/apps/shared/components/mail/invite/inviteStore.js

@@ -4,6 +4,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 import { useCallback, useEffect, useReducer } from "react";
 import { getMessageInvite } from "../../../../../lib/calendar/inviteApi.js";
+import { clearSealedInvites, onSealedInvitesForgotten, sealedInviteCalendar } from "../../../../../lib/calendar/sealedInvites.js";
+import { onSigningOut } from "../compose/composeFlushRegistry.js";
 import { useApiClient } from "../../../../../lib/util/apiClientContext.js";
 /**
  * A per-message cache of the calendar invitation the server reads out of a message, shared by everything that draws one: the reading pane's
@@ -37,7 +39,9 @@ function normalize(invite) {
  */
 export function loadInvite(uid, client) {
     const existing = entries.get(uid);
-    if (existing && (existing.value === undefined || Date.now() - existing.at < INVITE_TTL_MS)) {
+    // "No invitation" for a zero-access message is asked again once its calendar file has been decrypted here (the list asks before that).
+    const stale = existing?.value === null && sealedInviteCalendar(uid) !== undefined;
+    if (existing && !stale && (existing.value === undefined || Date.now() - existing.at < INVITE_TTL_MS)) {
         return existing.promise;
     }
     const entry = {
@@ -100,3 +104,14 @@ export function useMessageInvite(uid, enabled = true) {
     const value = enabled ? entries.get(uid)?.value : undefined;
     return { invite: value ?? null, settled: value !== undefined, setInvite };
 }
+onSigningOut(clearSealedInvites);
+onSigningOut(clearInviteCache);
+// What the server read from a zero-access message's decrypted calendar file (its summary, description) goes with the file when the mailbox
+// locks: mounted cards, chips and popovers draw nothing until it is read again.
+onSealedInvitesForgotten((uids) => {
+    for (const uid of uids) {
+        if (entries.delete(uid)) {
+            notify(uid);
+        }
+    }
+});

package/dist/apps/shared/components/mail/layout/MailShell.js

@@ -15,6 +15,7 @@ import KeyEnrollmentGate from "../../layout/KeyEnrollmentGate.js";
 import MailboxProvisioning from "../../layout/MailboxProvisioning.js";
 import { prefetchComposeWindow, useCompose } from "../compose/ComposeContext.js";
 import LocalIndexLifecycle from "../../../search/LocalIndexLifecycle.js";
+import SharedMailboxKeyManager from "../../layout/SharedMailboxKeyManager.js";
 import { NO_LIVE_UPDATES } from "../../../mail/useMailLiveUpdates.js";
 import { MAILBOX_LIST_LIMIT, MailConnectionContext, useMailConnection } from "../../../mail/useMailConnection.js";
 import { folderRows } from "../../../mail/folderTree.js";
@@ -264,7 +265,7 @@ export default function MailShell({ userUid, authServerUrl, impersonating, imper
         // A shared/delegated mailbox the caller doesn't own is never provisioned from here - its keys
         // belong to its owner (or its admins), not to whoever happens to open it first - and neither is
         // the impersonated user's own mailbox: an administrator must never choose its password/recovery codes.
-        canProvision: !impersonating && activeMailbox?.ownerUserUid === userUid, children: [_jsx(LocalIndexLifecycle, { mailboxUid: activeMailboxUid, mailboxKeys: activeMailbox?.keys, folders: mailboxFolders.find((mf) => mf.mailbox.uid === activeMailboxUid)?.folders ?? [], 
+        canProvision: !impersonating && activeMailbox?.ownerUserUid === userUid, children: [_jsx(SharedMailboxKeyManager, { mailboxes: mailboxes, userUid: userUid }), _jsx(LocalIndexLifecycle, { mailboxUid: activeMailboxUid, mailboxKeys: activeMailbox?.keys, folders: mailboxFolders.find((mf) => mf.mailbox.uid === activeMailboxUid)?.folders ?? [], 
                 // A full page may be truncated - pruning against it would delete indexes of accessible mailboxes
                 // beyond the limit, so it's only trusted as the complete list when it came back short.
                 accessibleMailboxUids: status === "ready" && mailboxes.length < MAILBOX_LIST_LIMIT ? mailboxes.map((mb) => mb.uid) : undefined }), _jsx(AppShell, { active: "mail", userUid: userUid, authServerUrl: authServerUrl, impersonating: impersonating, impersonationBaseUrl: impersonationBaseUrl, trusted: trusted, trustedRoles: trustedRoles, pluginNav: pluginNav, children: inner })] }));

package/dist/apps/shared/components/mail/pinnedSigners.d.ts

@@ -20,6 +20,7 @@
  */
 import { SignerKeyState } from "../../../../lib/contacts/contactsApi.js";
 import type { ApiClient } from "../../../../lib/util/api.js";
+import type { SignerPins } from "../../../../lib/crypto/messageSecurity.js";
 /** How long one mailbox's loaded contact list is reused before it is fetched again. */
 export declare const CONTACTS_CACHE_TTL_MS = 60000;
 /** Forgets every cached contact list for the default global path - on sign-out, a key-session lock, after the
@@ -28,12 +29,17 @@ export declare const CONTACTS_CACHE_TTL_MS = 60000;
 export declare function clearPinnedSignerCache(): void;
 /** The sender `address`'s pinned signing fingerprints from `mailboxUid`'s contacts. Rejects if they can't be loaded. */
 export declare function getPinnedSignerFingerprints(mailboxUid: string, address: string, client?: ApiClient): Promise<string[]>;
+/** The sender `address`'s pinned signing fingerprints and pinned OpenPGP certificates from `mailboxUid`'s contacts - what
+ * `evaluateMessageSecurity()` takes as `SignerPins`. Rejects if they can't be loaded. */
+export declare function getPinnedSigners(mailboxUid: string, address: string, client?: ApiClient): Promise<SignerPins>;
 /** A sender's signing-key state (`signerKeyStateFor()`) plus what a key-changed notice needs to show and link. */
 export interface SenderKeyState extends SignerKeyState {
     /** The contact holding the first pinned signing key, else the one holding the conflict, else the first match. */
     contactUid?: string;
     /** When the first pinned signing key started being trusted - see `keyPinnedSince()`. */
     pinnedSince?: number;
+    /** When the first pinned OpenPGP certificate (`openPgp[0]`) started being trusted. */
+    openPgpPinnedSince?: number;
 }
 /** The sender `address`'s signing-key state from `mailboxUid`'s (cached) contacts, for a "signing key changed" comparison
  * or to spot a recorded conflict. Reads stored contacts only. Rejects if they can't be loaded. */

package/dist/apps/shared/components/mail/pinnedSigners.js

@@ -22,7 +22,7 @@
  * `tauri-client` accounts must never answer each other's "who does this sender's key belong to" question from
  * one shared cache keyed only by `mailboxUid` (mailbox uids are not guaranteed unique across accounts/servers).
  */
-import { PINNED_FINGERPRINT_MAX_PAGES, PINNED_FINGERPRINT_PAGE_SIZE, listContacts, pinnedSigningFingerprintsFor, signerKeyStateFor, } from "../../../../lib/contacts/contactsApi.js";
+import { PINNED_FINGERPRINT_MAX_PAGES, PINNED_FINGERPRINT_PAGE_SIZE, listContacts, pinnedOpenPgpKeysFor, pinnedSigningFingerprintsFor, signerKeyStateFor, } from "../../../../lib/contacts/contactsApi.js";
 import { keyPinnedSince } from "../contacts/contactKeys.js";
 import { listFolders } from "../../../../lib/mail/mailApi.js";
 import { subscribeKeySession } from "../../../../lib/crypto/keySession.js";
@@ -96,6 +96,12 @@ function cachedMailboxContacts(mailboxUid, client) {
 export async function getPinnedSignerFingerprints(mailboxUid, address, client) {
     return pinnedSigningFingerprintsFor(await cachedMailboxContacts(mailboxUid, client), address);
 }
+/** The sender `address`'s pinned signing fingerprints and pinned OpenPGP certificates from `mailboxUid`'s contacts - what
+ * `evaluateMessageSecurity()` takes as `SignerPins`. Rejects if they can't be loaded. */
+export async function getPinnedSigners(mailboxUid, address, client) {
+    const contacts = await cachedMailboxContacts(mailboxUid, client);
+    return { fingerprints: pinnedSigningFingerprintsFor(contacts, address), openPgpKeys: pinnedOpenPgpKeysFor(contacts, address) };
+}
 /** The sender `address`'s signing-key state from `mailboxUid`'s (cached) contacts, for a "signing key changed" comparison
  * or to spot a recorded conflict. Reads stored contacts only. Rejects if they can't be loaded. */
 export async function getSignerKeyState(mailboxUid, address, client) {
@@ -109,9 +115,12 @@ export async function getSignerKeyState(mailboxUid, address, client) {
     const contact = holder ??
         matching.find((candidate) => (candidate.keyConflicts ?? []).some((conflict) => conflict.useType === "sign")) ??
         matching[0];
+    const openPgpKey = state.openPgp?.[0];
+    const openPgpHolder = openPgpKey && matching.find((candidate) => (candidate.keys ?? []).includes(openPgpKey));
     return {
         ...state,
         ...(contact ? { contactUid: contact.uid } : {}),
         ...(holder ? { pinnedSince: keyPinnedSince(holder, pinned) } : {}),
+        ...(openPgpHolder ? { openPgpPinnedSince: keyPinnedSince(openPgpHolder, openPgpKey) } : {}),
     };
 }

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

@@ -9,8 +9,8 @@ export declare function printHeaders(message: Message, from: string): PrintableM
  */
 export declare function olderConversationMessages(message: Message, client?: ApiClient): Promise<Message[]>;
 /**
- * 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. `client` is the explicit `ApiClient` every
+ * One earlier message of a conversation as it prints: the body the reading pane would show. An encrypted one - end to end, or sealed to its mailbox's
+ * zero-access key, whose subject and body the server doesn't hold readable - 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. `client` is the explicit `ApiClient` every
  * request goes through when given (see `useApiClient()`); without one they are the cookie requests they always were.
  */
 export declare function printableOlderMessage(message: Message, client?: ApiClient): Promise<PrintableMessage>;

package/dist/apps/shared/components/mail/reading/conversationPrint.js

@@ -33,13 +33,13 @@ export async function olderConversationMessages(message, client) {
         .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. `client` is the explicit `ApiClient` every
+ * One earlier message of a conversation as it prints: the body the reading pane would show. An encrypted one - end to end, or sealed to its mailbox's
+ * zero-access key, whose subject and body the server doesn't hold readable - 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. `client` is the explicit `ApiClient` every
  * request goes through when given (see `useApiClient()`); without one they are the cookie requests they always were.
  */
 export async function printableOlderMessage(message, client) {
     const attachments = await listAttachments(message.folderUid, message.uid, client).catch(() => []);
-    if (message.encrypted) {
+    if (message.encrypted || message.zeroAccess) {
         const unlocked = getUnlockedKeys(message.mailboxUid);
         if (unlocked) {
             const { evaluateMessageSecurity } = await import("../../../../../lib/crypto/messageSecurity.js");

package/dist/apps/shared/components/mail/reading/useMessageActions.js

@@ -11,6 +11,7 @@ import { resolveFolderOfType } from "../../../mail/folderOfType.js";
 import { setReadStateMany } from "../../../mail/messageReadState.js";
 import { usePermanentDelete } from "../../../mail/usePermanentDelete.js";
 import { reportFolderName, reportNotice, reportNoun, reportTitle, senderListsHref } from "../../../mail/reportNotices.js";
+import { zeroAccessSourceBase64 } from "../../../mail/zeroAccessSource.js";
 import { blockSender, neverBlockSender, normalizeAddresses, removeSenderRule } from "../../../mail/senderBlocking.js";
 import { notifyApiError } from "../../../notifications/apiErrors.js";
 import { notify } from "../../../notifications/store.js";
@@ -122,7 +123,9 @@ export function useMessageActions(params) {
         await exclusive(async () => {
             let result;
             try {
-                result = await reportMessage(message.uid, kind, { alwaysTrustSender }, client);
+                // The server holds only the sealed copy of a zero-access message: its spam filter learns from the source decrypted here.
+                const rawMessage = await zeroAccessSourceBase64(message, client);
+                result = await reportMessage(message.uid, kind, { alwaysTrustSender, ...(rawMessage ? { rawMessage } : {}) }, client);
             }
             catch (err) {
                 if (isNotFound(err)) {

package/dist/apps/shared/components/settings/KeyExportSetting.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import type { Mailbox } from "../../../../lib/mail/mailApi.js";
+export interface KeyExportSettingProps {
+    mailbox: Mailbox;
+    /** The caller owns the mailbox and isn't impersonating: restapi records an export only for the owner. */
+    canManage: boolean;
+}
+/**
+ * "Export keys for Outlook/phone" (`lib/crypto/keyExport.ts`): a passphrase-protected `.p12` with the mailbox's zero-access
+ * and end-to-end encryption keys - and its signing key, if the user ticks the box - so a mail app that isn't RapidMX can read
+ * mail stored encrypted. Asks for the master password again however long the mailbox has been unlocked.
+ */
+export default function KeyExportSetting({ mailbox, canManage }: KeyExportSettingProps): React.JSX.Element;

package/dist/apps/shared/components/settings/KeyExportSetting.js

@@ -0,0 +1,90 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { useState } from "react";
+import { exportKeysAsPkcs12, MIN_EXPORT_PASSPHRASE_LENGTH, NothingToExportError } from "../../../../lib/crypto/keyExport.js";
+import { ApiRequestError } from "../../../../lib/util/api.js";
+import { useApiClient } from "../../../../lib/util/apiClientContext.js";
+import Alert from "../../../../lib/components/feedback/Alert.js";
+import Button from "../../../../lib/components/buttons/Button.js";
+import { notifyApiError } from "../../notifications/apiErrors.js";
+import PolicyLockedNotice from "./PolicyLockedNotice.js";
+const INPUT_CLASS = "w-full text-sm border border-border rounded-sm py-1.5 px-2 bg-surface";
+/** How long the file's object URL is kept, since some browsers (WebKit, older Firefox) still read it after the click returns. */
+const DOWNLOAD_URL_LIFETIME_MS = 60000;
+/** Hands `bytes` to the browser as a file download. */
+function saveFile(bytes, filename) {
+    const url = URL.createObjectURL(new Blob([bytes], { type: "application/x-pkcs12" }));
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    link.remove();
+    setTimeout(() => URL.revokeObjectURL(url), DOWNLOAD_URL_LIFETIME_MS);
+}
+/**
+ * "Export keys for Outlook/phone" (`lib/crypto/keyExport.ts`): a passphrase-protected `.p12` with the mailbox's zero-access
+ * and end-to-end encryption keys - and its signing key, if the user ticks the box - so a mail app that isn't RapidMX can read
+ * mail stored encrypted. Asks for the master password again however long the mailbox has been unlocked.
+ */
+export default function KeyExportSetting({ mailbox, canManage }) {
+    const client = useApiClient();
+    const [open, setOpen] = useState(false);
+    const [password, setPassword] = useState("");
+    const [passphrase, setPassphrase] = useState("");
+    const [confirmPassphrase, setConfirmPassphrase] = useState("");
+    const [includeSigningKey, setIncludeSigningKey] = useState(false);
+    const [exporting, setExporting] = useState(false);
+    const [error, setError] = useState(null);
+    function reset() {
+        setOpen(false);
+        setPassword("");
+        setPassphrase("");
+        setConfirmPassphrase("");
+        setIncludeSigningKey(false);
+        setError(null);
+    }
+    async function handleExport(e) {
+        e.preventDefault();
+        if (passphrase.length < MIN_EXPORT_PASSPHRASE_LENGTH) {
+            setError(`The file's passphrase must be at least ${MIN_EXPORT_PASSPHRASE_LENGTH} characters.`);
+            return;
+        }
+        if (passphrase !== confirmPassphrase) {
+            setError("The passphrases don't match.");
+            return;
+        }
+        setExporting(true);
+        setError(null);
+        try {
+            const result = await exportKeysAsPkcs12({
+                mailboxUid: mailbox.uid,
+                mailboxAddress: mailbox.primarySmtpAddress,
+                mailboxKeys: mailbox.keys ?? [],
+                masterPassword: password,
+                exportPassphrase: passphrase,
+                includeSigningKey,
+            }, client);
+            saveFile(result.pkcs12, `${mailbox.primarySmtpAddress}-keys.p12`);
+            reset();
+        }
+        catch (err) {
+            if (err instanceof ApiRequestError) {
+                notifyApiError(err, "Couldn't export your keys");
+            }
+            else if (err instanceof NothingToExportError || (err instanceof Error && err.message.startsWith("This mailbox has no password"))) {
+                setError(err.message);
+            }
+            else {
+                setError("Incorrect password.");
+            }
+        }
+        finally {
+            setExporting(false);
+        }
+    }
+    return (_jsxs("div", { children: [_jsx("h2", { className: "text-sm font-semibold mb-2", children: "Export keys for Outlook or a phone" }), _jsx("p", { className: "text-sm text-text-muted mb-2", children: "Mail apps other than RapidMX need your keys to read encrypted mail. The exported file holds your zero-access and end-to-end encryption keys, protected by a passphrase you choose. Anyone with the file and its passphrase can read all of this mailbox\u2019s mail, so keep it safe and delete it once it\u2019s installed." }), !canManage ? (_jsx(PolicyLockedNotice, { children: "Only this mailbox\u2019s owner, signed in as themselves, can export its keys." })) : !open ? (_jsx(Button, { type: "button", variant: "secondary", className: "!w-auto", onClick: () => setOpen(true), children: "Export keys\u2026" })) : (_jsxs("form", { onSubmit: (e) => void handleExport(e), className: "flex flex-col gap-2", children: [_jsx("input", { type: "password", "aria-label": "Encryption password", placeholder: "Encryption password", className: INPUT_CLASS, value: password, onChange: (e) => setPassword(e.target.value), disabled: exporting, autoComplete: "current-password" }), _jsx("input", { type: "password", "aria-label": "File passphrase", placeholder: `File passphrase (at least ${MIN_EXPORT_PASSPHRASE_LENGTH} characters)`, className: INPUT_CLASS, value: passphrase, onChange: (e) => setPassphrase(e.target.value), disabled: exporting, autoComplete: "new-password" }), _jsx("input", { type: "password", "aria-label": "Confirm file passphrase", placeholder: "Confirm file passphrase", className: INPUT_CLASS, value: confirmPassphrase, onChange: (e) => setConfirmPassphrase(e.target.value), disabled: exporting, autoComplete: "new-password" }), _jsxs("label", { className: "flex items-start gap-2 text-sm", children: [_jsx("input", { type: "checkbox", className: "mt-1", checked: includeSigningKey, onChange: (e) => setIncludeSigningKey(e.target.checked), disabled: exporting }), _jsxs("span", { children: [_jsx("span", { className: "font-semibold block", children: "Include my signing key" }), _jsx("span", { className: "text-xs text-text-muted", children: "Only if that app will sign mail you send. Anyone with the file could sign as you." })] })] }), error && _jsx(Alert, { children: error }), _jsxs("div", { className: "flex gap-2", children: [_jsx(Button, { type: "submit", className: "!w-auto", disabled: exporting || !password || !passphrase, children: exporting ? "Exporting…" : "Export" }), _jsx(Button, { type: "button", variant: "secondary", className: "!w-auto", onClick: reset, disabled: exporting, children: "Cancel" })] })] }))] }));
+}

package/dist/apps/shared/components/settings/OpenPgpKeySetting.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { type Mailbox } from "../../../../lib/mail/mailApi.js";
+export interface OpenPgpKeySettingProps {
+    mailbox: Mailbox;
+    /** The caller owns the mailbox and isn't impersonating: only the owner may export its secret key. */
+    canManage: boolean;
+}
+/**
+ * The mailbox's OpenPGP key (restapi `specs/end-to-end_encryption.md` *OpenPGP Interoperability*): what it is for, its
+ * fingerprint, a download of its public key (to give a correspondent by hand), and an export of its secret key, protected by a
+ * passphrase, for reading this mailbox's OpenPGP mail in another app. Shows nothing while the mailbox has no OpenPGP key.
+ */
+export default function OpenPgpKeySetting({ mailbox, canManage }: OpenPgpKeySettingProps): React.JSX.Element | null;

package/dist/apps/shared/components/settings/OpenPgpKeySetting.js

@@ -0,0 +1,143 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { useState } from "react";
+import { findActivePublicKey } from "../../../../lib/crypto/keyvaultApi.js";
+import { MIN_EXPORT_PASSPHRASE_LENGTH } from "../../../../lib/crypto/keyExport.js";
+import { exportOpenPgpSecretKey } from "../../../../lib/crypto/openPgpKey.js";
+import { getMailbox, updateMailbox } from "../../../../lib/mail/mailApi.js";
+import { ApiRequestError } from "../../../../lib/util/api.js";
+import { useApiClient } from "../../../../lib/util/apiClientContext.js";
+import Alert from "../../../../lib/components/feedback/Alert.js";
+import Button from "../../../../lib/components/buttons/Button.js";
+import { notifyApiError } from "../../notifications/apiErrors.js";
+import PolicyLockedNotice from "./PolicyLockedNotice.js";
+import { useSettingsShell } from "./layout/SettingsShell.js";
+const INPUT_CLASS = "w-full text-sm border border-border rounded-sm py-1.5 px-2 bg-surface";
+/** How long a download's object URL is kept, since some browsers (WebKit, older Firefox) still read it after the click returns. */
+const DOWNLOAD_URL_LIFETIME_MS = 60000;
+/** Hands `text` to the browser as a file download. */
+function saveText(text, filename) {
+    const url = URL.createObjectURL(new Blob([text], { type: "application/pgp-keys" }));
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    link.remove();
+    setTimeout(() => URL.revokeObjectURL(url), DOWNLOAD_URL_LIFETIME_MS);
+}
+/** `preference` advertising `format` - S/MIME is the default, so it is advertised by saying nothing. */
+function withPreferredFormat(preference, format) {
+    const { preferFormat: _previous, ...rest } = preference ?? { preferEncrypt: "nopreference" };
+    return format === "openpgp" ? { ...rest, preferFormat: "openpgp" } : rest;
+}
+/** A fingerprint in groups of four, for reading aloud. */
+function groupFingerprint(fingerprint) {
+    return fingerprint.toUpperCase().replace(/(.{4})/g, "$1 ").trim();
+}
+/**
+ * The mailbox's OpenPGP key (restapi `specs/end-to-end_encryption.md` *OpenPGP Interoperability*): what it is for, its
+ * fingerprint, a download of its public key (to give a correspondent by hand), and an export of its secret key, protected by a
+ * passphrase, for reading this mailbox's OpenPGP mail in another app. Shows nothing while the mailbox has no OpenPGP key.
+ */
+export default function OpenPgpKeySetting({ mailbox, canManage }) {
+    const client = useApiClient();
+    const { patchMailbox } = useSettingsShell();
+    const [open, setOpen] = useState(false);
+    const [password, setPassword] = useState("");
+    const [passphrase, setPassphrase] = useState("");
+    const [confirmPassphrase, setConfirmPassphrase] = useState("");
+    const [exporting, setExporting] = useState(false);
+    const [error, setError] = useState(null);
+    const [format, setFormat] = useState(mailbox.encryptPreference?.preferFormat === "openpgp" ? "openpgp" : "smime");
+    const [savingFormat, setSavingFormat] = useState(false);
+    const key = findActivePublicKey(mailbox.keys ?? [], "encrypt", "openpgp");
+    if (!key) {
+        return null;
+    }
+    const address = mailbox.primarySmtpAddress;
+    function reset() {
+        setOpen(false);
+        setPassword("");
+        setPassphrase("");
+        setConfirmPassphrase("");
+        setError(null);
+    }
+    /** Advertises `next` as the format this mailbox would rather receive (restapi *Choosing the format*), to RapidMX servers through
+     * key discovery and the `RapidMX-Key` header. */
+    async function saveFormat(next) {
+        const previous = format;
+        setFormat(next);
+        setSavingFormat(true);
+        try {
+            const write = async (current) => {
+                const encryptPreference = withPreferredFormat(current.encryptPreference, next);
+                const saved = await updateMailbox({ uid: mailbox.uid, version: current.version, encryptPreference }, client);
+                return { version: saved.version, encryptPreference: saved.encryptPreference ?? encryptPreference };
+            };
+            let saved;
+            try {
+                saved = await write(mailbox);
+            }
+            catch (err) {
+                // Enrolling a key moves the mailbox's version on: read it again and retry once.
+                if (!(err instanceof ApiRequestError && err.status === 409)) {
+                    throw err;
+                }
+                saved = await write(await getMailbox(mailbox.uid, {}, client));
+            }
+            // Kept in the settings shell's copy of the mailbox, which this page is mounted from again on a switch back to it.
+            patchMailbox?.(mailbox.uid, saved);
+        }
+        catch (err) {
+            setFormat(previous);
+            notifyApiError(err, "Couldn't save your preferred encryption format");
+        }
+        finally {
+            setSavingFormat(false);
+        }
+    }
+    async function downloadPublicKey() {
+        const { armorPublicKey, readPublicKey } = await import("../../../../lib/crypto/openpgp.js");
+        const certificate = await readPublicKey(key.publicKey);
+        if (certificate) {
+            saveText(armorPublicKey(certificate), `${address}-openpgp-public.asc`);
+        }
+    }
+    async function handleExport(e) {
+        e.preventDefault();
+        if (passphrase.length < MIN_EXPORT_PASSPHRASE_LENGTH) {
+            setError(`The file's passphrase must be at least ${MIN_EXPORT_PASSPHRASE_LENGTH} characters.`);
+            return;
+        }
+        if (passphrase !== confirmPassphrase) {
+            setError("The passphrases don't match.");
+            return;
+        }
+        setExporting(true);
+        setError(null);
+        try {
+            const { armored } = await exportOpenPgpSecretKey(mailbox.uid, password, passphrase, client);
+            saveText(armored, `${address}-openpgp-secret.asc`);
+            reset();
+        }
+        catch (err) {
+            if (err instanceof ApiRequestError) {
+                notifyApiError(err, "Couldn't export your OpenPGP key");
+            }
+            else {
+                setError("Incorrect password.");
+            }
+        }
+        finally {
+            setExporting(false);
+        }
+    }
+    return (_jsxs("div", { children: [_jsx("h2", { className: "text-sm font-semibold mb-2", children: "OpenPGP key" }), _jsx("p", { className: "text-sm text-text-muted mb-2", children: "People who use Proton Mail, Thunderbird or another OpenPGP app can send you encrypted mail with this key, and you can send it to them. RapidMX publishes it for you; you can also give it to someone yourself. RapidMX uses S/MIME whenever a recipient can receive it." }), _jsxs("p", { className: "text-sm mb-2", children: ["Fingerprint: ", _jsx("code", { className: "text-xs break-all", children: groupFingerprint(key.fingerprint) })] }), _jsxs("fieldset", { className: "mb-3", disabled: !canManage || savingFormat, children: [_jsx("legend", { className: "text-sm font-semibold mb-1", children: "Preferred format" }), _jsx("p", { className: "text-xs text-text-muted mb-1", children: "What other RapidMX servers use to encrypt to you when they could use either. Choose OpenPGP if you mostly read this mailbox in an OpenPGP app." }), [
+                        ["smime", "S/MIME (recommended)"],
+                        ["openpgp", "OpenPGP"],
+                    ].map(([value, label]) => (_jsxs("label", { className: "flex items-center gap-2 text-sm", children: [_jsx("input", { type: "radio", name: `preferred-format-${mailbox.uid}`, checked: format === value, onChange: () => void saveFormat(value) }), label] }, value)))] }), _jsxs("div", { className: "flex flex-wrap gap-2 mb-2", children: [_jsx(Button, { type: "button", variant: "secondary", className: "!w-auto", onClick: () => void downloadPublicKey(), children: "Download public key" }), canManage && !open && (_jsx(Button, { type: "button", variant: "secondary", className: "!w-auto", onClick: () => setOpen(true), children: "Export secret key\u2026" }))] }), !canManage ? (_jsx(PolicyLockedNotice, { children: "Only this mailbox\u2019s owner, signed in as themselves, can export its secret key." })) : (open && (_jsxs("form", { onSubmit: (e) => void handleExport(e), className: "flex flex-col gap-2", children: [_jsx("p", { className: "text-sm text-text-muted", children: "Anyone with the exported file and its passphrase can read this mailbox\u2019s OpenPGP mail and sign as you." }), _jsx("input", { type: "password", "aria-label": "Encryption password", placeholder: "Encryption password", className: INPUT_CLASS, value: password, onChange: (e) => setPassword(e.target.value), disabled: exporting, autoComplete: "current-password" }), _jsx("input", { type: "password", "aria-label": "Key passphrase", placeholder: `Key passphrase (at least ${MIN_EXPORT_PASSPHRASE_LENGTH} characters)`, className: INPUT_CLASS, value: passphrase, onChange: (e) => setPassphrase(e.target.value), disabled: exporting, autoComplete: "new-password" }), _jsx("input", { type: "password", "aria-label": "Confirm key passphrase", placeholder: "Confirm key passphrase", className: INPUT_CLASS, value: confirmPassphrase, onChange: (e) => setConfirmPassphrase(e.target.value), disabled: exporting, autoComplete: "new-password" }), error && _jsx(Alert, { children: error }), _jsxs("div", { className: "flex gap-2", children: [_jsx(Button, { type: "submit", className: "!w-auto", loading: exporting, disabled: exporting || !password, children: "Export" }), _jsx(Button, { type: "button", variant: "secondary", className: "!w-auto", onClick: reset, disabled: exporting, children: "Cancel" })] })] })))] }));
+}

package/dist/apps/shared/components/settings/PolicyLockedNotice.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export interface PolicyLockedNoticeProps {
+    /** Why the setting next to this notice can't be changed - e.g. that an administrator turned it off for the server. */
+    children: React.ReactNode;
+}
+/**
+ * Explains why a settings control is disabled by a policy the user can't change themselves (an administrator's server-wide
+ * setting, say), shown right under that control. A disabled control with no reason reads as a defect; this says who decided
+ * and that the user isn't the one who can undo it.
+ */
+export default function PolicyLockedNotice({ children }: PolicyLockedNoticeProps): React.JSX.Element;

package/dist/apps/shared/components/settings/PolicyLockedNotice.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Explains why a settings control is disabled by a policy the user can't change themselves (an administrator's server-wide
+ * setting, say), shown right under that control. A disabled control with no reason reads as a defect; this says who decided
+ * and that the user isn't the one who can undo it.
+ */
+export default function PolicyLockedNotice({ children }) {
+    return (_jsx("p", { role: "note", className: "mt-1.5 text-xs text-text-muted border-l-2 border-border pl-2", children: children }));
+}

package/dist/apps/shared/components/settings/ZeroAccessSetting.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import { type Mailbox } from "../../../../lib/mail/mailApi.js";
+/** The data types this client can protect with zero-access encryption - each joins as its protection is implemented end to end. */
+export declare const ZERO_ACCESS_SUPPORTED_TYPES: readonly ["mail", "calendar", "contacts", "tasks"];
+export interface ZeroAccessSettingProps {
+    mailbox: Mailbox;
+    /** The caller owns the mailbox and isn't impersonating: only then can the setting be changed (restapi drops anybody else's value). */
+    canManage: boolean;
+}
+/**
+ * "Enable zero-access encryption" for one mailbox (restapi `specs/search.md` §3): unencrypted mail is encrypted to the
+ * mailbox's zero-access key as it arrives and the server keeps no readable copy. On by default. Shown disabled, with the
+ * reason, when the administrator has turned "Allow zero-access encryption" off for the server, or when the server doesn't
+ * support it. A shared mailbox is covered too: its members read it through member key wraps (`sharedMailboxKeys.ts`).
+ */
+export default function ZeroAccessSetting({ mailbox, canManage }: ZeroAccessSettingProps): React.JSX.Element;

package/dist/apps/shared/components/settings/ZeroAccessSetting.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { useEffect, useState } from "react";
+import { getEncryptionPolicy } from "../../../../lib/crypto/keyvaultApi.js";
+import { getMailbox, updateMailbox } from "../../../../lib/mail/mailApi.js";
+import { ApiRequestError } from "../../../../lib/util/api.js";
+import { useApiClient } from "../../../../lib/util/apiClientContext.js";
+import { notifyApiError } from "../../notifications/apiErrors.js";
+import { useSettingsShell } from "./layout/SettingsShell.js";
+import PolicyLockedNotice from "./PolicyLockedNotice.js";
+import ZeroAccessTypes from "./ZeroAccessTypes.js";
+/** The data types this client can protect with zero-access encryption - each joins as its protection is implemented end to end. */
+export const ZERO_ACCESS_SUPPORTED_TYPES = ["mail", "calendar", "contacts", "tasks"];
+/**
+ * "Enable zero-access encryption" for one mailbox (restapi `specs/search.md` §3): unencrypted mail is encrypted to the
+ * mailbox's zero-access key as it arrives and the server keeps no readable copy. On by default. Shown disabled, with the
+ * reason, when the administrator has turned "Allow zero-access encryption" off for the server, or when the server doesn't
+ * support it. A shared mailbox is covered too: its members read it through member key wraps (`sharedMailboxKeys.ts`).
+ */
+export default function ZeroAccessSetting({ mailbox, canManage }) {
+    const client = useApiClient();
+    const { patchMailbox } = useSettingsShell();
+    const [enabled, setEnabled] = useState(mailbox.zeroAccessEnabled !== false);
+    const [blocker, setBlocker] = useState(undefined);
+    const [saving, setSaving] = useState(false);
+    useEffect(() => {
+        let cancelled = false;
+        void (async () => {
+            const policy = await getEncryptionPolicy(client).catch(() => undefined);
+            let next = null;
+            if (policy?.allowZeroAccess === undefined) {
+                next = "unsupported";
+            }
+            else if (!policy.allowZeroAccess) {
+                next = "disabled_by_admin";
+            }
+            if (!cancelled) {
+                setBlocker(next);
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [mailbox.uid, client]);
+    async function save(next) {
+        setSaving(true);
+        const previous = enabled;
+        setEnabled(next);
+        try {
+            const write = (version) => updateMailbox({ uid: mailbox.uid, version, zeroAccessEnabled: next }, client);
+            let saved;
+            try {
+                saved = await write(mailbox.version);
+            }
+            catch (err) {
+                // Enrolling a key (which happens on unlock) moves the mailbox's version on, so the copy this page was given may be
+                // behind: read it again and retry once.
+                if (!(err instanceof ApiRequestError && err.status === 409)) {
+                    throw err;
+                }
+                saved = await write((await getMailbox(mailbox.uid, {}, client)).version);
+            }
+            // The server's answer: turning it on decides every type the owner left undecided (restapi `settleZeroAccessTypes()`), which
+            // "What to protect" then shows.
+            patchMailbox?.(mailbox.uid, { zeroAccessEnabled: next, zeroAccessTypes: saved.zeroAccessTypes ?? mailbox.zeroAccessTypes, version: saved.version });
+        }
+        catch (err) {
+            setEnabled(previous);
+            notifyApiError(err, "Couldn't save the zero-access encryption setting");
+        }
+        finally {
+            setSaving(false);
+        }
+    }
+    const locked = blocker !== null;
+    return (_jsxs("div", { children: [_jsx("h2", { className: "text-sm font-semibold mb-2", children: "Zero-access encryption" }), _jsxs("label", { className: "flex items-start gap-2 text-sm", children: [_jsx("input", { type: "checkbox", className: "mt-1", checked: !locked && enabled, disabled: !canManage || locked || saving, onChange: (e) => void save(e.target.checked) }), _jsxs("span", { children: [_jsx("span", { className: "font-semibold block", children: "Enable zero-access encryption" }), _jsx("span", { className: "text-xs text-text-muted", children: "Mail that arrives unencrypted is encrypted the moment it is received, and the server keeps no copy it can read - nobody else, administrators included, can read it. You unlock it with your encryption password, and search of message contents happens on your device. Outlook and phone mail apps need your exported keys to read it. Turning this off only affects mail that arrives afterwards." })] })] }), !locked && enabled && _jsx(ZeroAccessTypes, { mailbox: mailbox, types: ZERO_ACCESS_SUPPORTED_TYPES, canManage: canManage, disabled: saving }), blocker === "disabled_by_admin" && (_jsx(PolicyLockedNotice, { children: "Your administrator has turned off zero-access encryption for this server, so new mail is stored without it. Mail already encrypted stays encrypted." })), blocker === "unsupported" && _jsx(PolicyLockedNotice, { children: "This server doesn\u2019t offer zero-access encryption." }), !mailbox.ownerUserUid && !locked && (_jsx(PolicyLockedNotice, { children: "This shared mailbox has no owner: it is protected for its members, whose apps share its key with each other." })), !canManage && !locked && mailbox.ownerUserUid && (_jsx(PolicyLockedNotice, { children: "Only this mailbox\u2019s owner, signed in as themselves, can change this." }))] }));
+}

package/dist/apps/shared/components/settings/ZeroAccessTypes.d.ts

@@ -0,0 +1,29 @@
+import React from "react";
+import { type Mailbox, type ZeroAccessDataType, type ZeroAccessTypes as ChosenTypes } from "../../../../lib/mail/mailApi.js";
+/** What each data type's protection covers, what stays readable and why, and what it breaks on a phone or Outlook - the copy restapi
+ * `specs/search.md` §3 *What It Covers* requires settings to state plainly. */
+export declare const ZERO_ACCESS_TYPE_INFO: Record<ZeroAccessDataType, {
+    label: string;
+    encrypted: string;
+    readable: string;
+    onDevices: string;
+}>;
+/** Whether `type` is included: the owner's choice, else (undecided) mail on and the rest off - restapi's `zeroAccessTypeIncluded()`. */
+export declare function typeIncluded(types: ChosenTypes | undefined, type: ZeroAccessDataType): boolean;
+/** The names of the owner's ActiveSync devices that sync `type`, and Outlook when it syncs the mailbox. */
+export declare function devicesSyncing(mailbox: Pick<Mailbox, "syncClients">, type: ZeroAccessDataType): string[];
+export interface ZeroAccessTypesProps {
+    mailbox: Mailbox;
+    /** The data types this client can protect, in order - each one's switch appears once its protection is implemented. */
+    types: readonly ZeroAccessDataType[];
+    /** The owner, not impersonating: only they change it. */
+    canManage: boolean;
+    /** Zero-access is being turned on: the server is still deciding the undecided types, so nothing is changed before it has. */
+    disabled?: boolean;
+}
+/**
+ * "What to protect": one switch per data type zero-access encryption covers, each saying what it encrypts and - for a type one of the
+ * owner's ActiveSync devices or Outlook syncs - plainly what that device will no longer show (restapi `specs/search.md` §3 *What It
+ * Covers*). Then the table of what stays readable to the server and why.
+ */
+export default function ZeroAccessTypes({ mailbox, types, canManage, disabled }: ZeroAccessTypesProps): React.JSX.Element;