@rapidmx/web-client 0.5.0 → 0.7.0

package/dist/apps/shared/components/calendar/EventModal.d.ts

@@ -0,0 +1,46 @@
+import React from "react";
+import { Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
+import { CalendarOccurrence } from "@rapidmx/react-shared/calendar/recurrence.js";
+export interface EventModalProps {
+    open: boolean;
+    onClose: () => void;
+    mailboxUid: string;
+    /** The calendar folder a new event is created into (ignored when editing — an existing event keeps
+     * its own `folderUid`). When `calendars` names more than one option, a "Calendar" selector lets the
+     * user override this default before saving. */
+    folderUid: string;
+    /** Every calendar the caller could create this event into. Omitted, or a single entry, means "only
+     * one calendar exists" — no selector is shown and `folderUid` is used as-is, matching this
+     * component's original single-calendar behavior exactly. */
+    calendars?: {
+        uid: string;
+        name: string;
+    }[];
+    /** Every mailbox a new event could be created in, each with its own calendars. With more than one, a
+     * "Mailbox" selector (create mode only) chooses the mailbox, which in turn drives the Calendar selector
+     * and the organizer address; `mailboxUid`/`folderUid` are the initial selection. */
+    mailboxOptions?: {
+        mailbox: Mailbox;
+        calendars: {
+            uid: string;
+            name: string;
+        }[];
+    }[];
+    organizerAddress: string;
+    /** The viewing mailbox's alias addresses - an event it organizes (or an invitation to it) may name any of
+     * them instead of `organizerAddress`. Defaults to that mailbox's `aliasAddresses` from `mailboxOptions`. */
+    organizerAliases?: string[];
+    /** `null` when creating a new event. */
+    occurrence: CalendarOccurrence | null;
+    /** Prefilled start/end for create mode (e.g. the day/slot the user clicked). */
+    initialStart?: Date;
+    initialEnd?: Date;
+    onSaved: () => void;
+    onDeleted: () => void;
+}
+/**
+ * Create/view/edit/delete for a single calendar event. Editing or deleting a recurring event's
+ * occurrence offers a choice between "this event" and "the entire series" (see
+ * `calendarMutations.ts`) — Outlook's own convention for the same ambiguity.
+ */
+export default function EventModal({ open, onClose, mailboxUid, folderUid, calendars, mailboxOptions, organizerAddress, organizerAliases, occurrence, initialStart, initialEnd, onSaved, onDeleted, }: EventModalProps): React.JSX.Element;

package/dist/apps/shared/components/calendar/MonthView.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import { CalendarOccurrence } from "@rapidmx/react-shared/calendar/recurrence.js";
+export interface MonthViewProps {
+    /** Any date within the month to display. */
+    viewDate: Date;
+    /** Already expanded for the visible grid range — see `recurrence.ts`'s `expandAllOccurrences`. */
+    occurrences: CalendarOccurrence[];
+    /** Each occurrence's own calendar color, keyed by `folderUid` — see `calendarColors.ts`. */
+    folderColors: Record<string, string>;
+    onSelectDay: (date: Date) => void;
+    onSelectEvent: (occurrence: CalendarOccurrence) => void;
+}
+/** A real 6-week month grid (Mon-start), matching Outlook/Gmail's month view. Multi-day and all-day
+ * events are shown on every day they cover (see `allDay.ts`'s `occursOnDay`). */
+export default function MonthView({ viewDate, occurrences, folderColors, onSelectDay, onSelectEvent }: MonthViewProps): React.JSX.Element;

package/dist/apps/shared/components/calendar/RecurrenceEditor.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import { RecurrenceRule, WeekdayCode } from "@rapidmx/react-shared/calendar/calendarApi.js";
+export interface RecurrenceEditorProps {
+    /** `null` means "does not repeat". */
+    value: RecurrenceRule | null;
+    onChange: (value: RecurrenceRule | null) => void;
+    /** Whether the event is all-day - its series expands in UTC, so the inclusive "Ends on" date is stored as
+     * the end of that UTC day rather than the local one (see `allDay.ts`'s `recurrenceUntilInstant()`). */
+    allDay?: boolean;
+    /** The weekday the event starts on (in the frame its series expands in - see `allDay.ts`'s
+     * `startWeekdayCode()`): the day a new weekly rule, or one switched to Weekly, repeats on. Defaults to Monday. */
+    startWeekday?: WeekdayCode;
+}
+/**
+ * A recurring-event editor: frequency + interval, a weekday picker (weekly only), and an end
+ * condition (never / after N occurrences / on a date) — everything `RecurrenceRule` can express. The
+ * live "every ... until/for ..." summary comes from `describeRecurrence()` (built on `rrule`'s own
+ * `.toText()`), so it never drifts out of sync with what will actually be submitted.
+ */
+export default function RecurrenceEditor({ value, onChange, allDay, startWeekday }: RecurrenceEditorProps): React.JSX.Element;

package/dist/apps/shared/components/calendar/ResourcePicker.d.ts

@@ -0,0 +1,19 @@
+import React, { RefObject } from "react";
+import { Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
+export interface ResourcePickerProps {
+    anchorRef: RefObject<HTMLElement | null>;
+    onClose: () => void;
+    onSelect: (mailbox: Mailbox) => void;
+    /** Addresses already added as attendees (lowercased by the caller) — excluded from the list so the
+     * same room/equipment mailbox can't be picked twice. */
+    excludeAddresses: string[];
+}
+/**
+ * A searchable dropdown of bookable resource mailboxes (rooms/equipment), for adding one as a `"resource"`
+ * attendee in `EventModal` without typing its raw address. Fetches the caller's full visible resource-mailbox
+ * list once on open and filters it client-side by name/address as the reader types — the same
+ * "fetch-flat-list, filter-client-side" contract every other list endpoint in this codebase already uses
+ * (see `calendarApi.ts`'s `listCalendarEvents` doc comment), since there is no dedicated server-side search
+ * endpoint for mailboxes and the resource-mailbox count in any one org is expected to be small.
+ */
+export default function ResourcePicker({ anchorRef, onClose, onSelect, excludeAddresses }: ResourcePickerProps): React.JSX.Element;

package/dist/apps/shared/components/calendar/SplitDayView.d.ts

@@ -0,0 +1,28 @@
+import React from "react";
+import { CalendarOccurrence } from "@rapidmx/react-shared/calendar/recurrence.js";
+export interface SplitDayColumn {
+    folderUid: string;
+    name: string;
+    color: string;
+}
+export interface SplitDayViewProps {
+    day: Date;
+    columns: SplitDayColumn[];
+    /** Already expanded for `day` — see `recurrence.ts`'s `expandAllOccurrences`. Not pre-filtered by
+     * calendar; this component splits them into columns itself by `occurrence.folderUid`. */
+    occurrences: CalendarOccurrence[];
+    onSelectEvent: (occurrence: CalendarOccurrence) => void;
+    /** Click on an empty slot in one calendar's column — the calendar it belongs to is `folderUid`. */
+    onSelectSlot: (start: Date, end: Date, folderUid: string) => void;
+}
+/**
+ * Outlook's "Split" view: one column per checked calendar, all showing the same single day, so
+ * events across calendars can be compared side by side. A deliberately separate component from
+ * `TimeGridView` rather than a generalization of it — it shares that component's visual language
+ * (same hour rail, same slot height) but is genuinely simpler in one respect: no drag-to-move/resize.
+ * Dragging an event between calendar columns would mean reassigning its `folderUid`, a real feature
+ * `moveOccurrence`/`resolveDragAction` don't support today; rather than bolt that on, this view is
+ * click-only (select an event, or click a slot to create one already targeted at that column's
+ * calendar) — a practical scope cut, not an oversight.
+ */
+export default function SplitDayView({ day, columns, occurrences, onSelectEvent, onSelectSlot }: SplitDayViewProps): React.JSX.Element;

package/dist/apps/shared/components/calendar/TimeGridView.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import { CalendarOccurrence } from "@rapidmx/react-shared/calendar/recurrence.js";
+export interface TimeGridViewProps {
+    /** One day for the Day view, seven for the Week view, five for the Work Week view. */
+    days: Date[];
+    /** Already expanded for the visible range — see `recurrence.ts`'s `expandAllOccurrences`. */
+    occurrences: CalendarOccurrence[];
+    /** Each occurrence's own calendar color, keyed by `folderUid` — see `calendarColors.ts`. */
+    folderColors: Record<string, string>;
+    onSelectEvent: (occurrence: CalendarOccurrence) => void;
+    /** Click on an empty slot — start/end default to a 30-minute block there, for the "New event" flow. */
+    onSelectSlot: (start: Date, end: Date) => void;
+}
+/** An hourly time grid (Week, Work Week, or Day view — they share all their rendering/drag logic and
+ * differ only in how many day columns are shown), with a day-header row and all-day events in a
+ * header strip above it. */
+export default function TimeGridView({ days, occurrences, folderColors, onSelectEvent, onSelectSlot }: TimeGridViewProps): React.JSX.Element;

package/dist/apps/shared/components/calendar/allDay.d.ts

@@ -0,0 +1,51 @@
+import { WeekdayCode } from "@rapidmx/react-shared/calendar/calendarApi.js";
+import { CalendarOccurrence } from "@rapidmx/react-shared/calendar/recurrence.js";
+/**
+ * All-day events are stored date-only: `startDate` is UTC midnight of the first day and `endDate` is UTC
+ * midnight of the day *after* the last day (exclusive, like iCalendar's `DTEND;VALUE=DATE`). That keeps
+ * an all-day event on the same calendar date for every viewer, whatever their timezone.
+ *
+ * Older events were saved as the creator's *local* midnight converted to UTC (e.g. `...T22:00Z` for a
+ * UTC+2 creator), so reading one rounds the instant to the nearest UTC midnight rather than slicing the
+ * ISO string — which gives the intended date for both formats.
+ */
+export declare function allDayDateKey(iso: string): string;
+/** `YYYY-MM-DD` -> the stored UTC-midnight instant for that date. */
+export declare function allDayInstant(dateKey: string): string;
+/** Adds `days` to a `YYYY-MM-DD` date key. */
+export declare function addDaysToKey(dateKey: string, days: number): string;
+/** The local calendar date `day` (a local-midnight `Date` from a grid view) as a `YYYY-MM-DD` key. */
+export declare function localDateKey(day: Date): string;
+/**
+ * A recurrence rule's inclusive "Ends on" date -> its stored `until` instant: the end of that day in the
+ * frame the series expands in. A timed series expands in its own (normally the viewer's) timezone, so that's
+ * the end of the local day - `new Date("YYYY-MM-DD")` would be UTC midnight, the previous day west of UTC.
+ * An all-day series expands in UTC (react-shared's `expandOccurrences`), so it's the end of the UTC day: the
+ * local end of day is already the next UTC day west of UTC and would add one more occurrence.
+ */
+export declare function recurrenceUntilInstant(dateKey: string, allDay: boolean): string;
+/**
+ * Inverse of `recurrenceUntilInstant()`. An all-day series' value is recognized explicitly in its stored
+ * `T23:59:59.999Z` form (and as a bare UTC midnight, the oldest form). Anything else is a legacy value stored
+ * as the creator's *local* end of day, which can land anywhere from just before 10:00Z on the chosen date (UTC+14)
+ * to just before 12:00Z the day after (UTC-12) - a 26-hour spread no UTC-only rounding can resolve (UTC+14 and UTC-10
+ * creators' values are exactly 24h apart for the same date), so it reads back on the local calendar, the
+ * frame it was written in.
+ */
+export declare function recurrenceUntilDateKey(until: string, allDay: boolean): string;
+/** The weekday an event starts on, in the frame its series expands in: the UTC date for an all-day event
+ * (`start`'s date part), the event's own timezone otherwise (`start` being a local `datetime-local` value).
+ * `undefined` while the start input is empty/invalid. */
+export declare function startWeekdayCode(start: string, allDay: boolean, timezone: string | undefined): WeekdayCode | undefined;
+/**
+ * Whether `occurrence` should be shown on the grid's local calendar day `day`. All-day events cover every
+ * date from their start date up to (not including) their exclusive end date — at least their start date.
+ * Timed events cover every local day their [start, end) interval overlaps, so a multi-day event shows on
+ * each day rather than only on its start day.
+ */
+export declare function occursOnDay(occurrence: CalendarOccurrence, day: Date): boolean;
+/**
+ * Whether `day` is the first day `occurrence` covers. Grid views only make that day's chip/block
+ * draggable — a drag id must be unique, so the continuation copies on later days are display-only.
+ */
+export declare function startsOnDay(occurrence: CalendarOccurrence, day: Date): boolean;

package/dist/apps/shared/components/calendar/layout/CalendarShell.d.ts

@@ -0,0 +1,40 @@
+import React, { PropsWithChildren } from "react";
+import { Folder, Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
+import { AppShellProps } from "../../layout/AppShell.js";
+export type CalendarShellProps = Omit<AppShellProps, "active">;
+/** One mailbox's own `calendar`-type folders. `error` is set (and `calendarFolders` left empty) when that
+ * mailbox's own `listFolders()` failed - one mailbox's failure never hides every other mailbox's calendars. */
+export interface MailboxCalendars {
+    mailbox: Mailbox;
+    calendarFolders: Folder[];
+    error?: string;
+}
+export interface CalendarShellContextValue {
+    /** The default mailbox for "+ New event" (`?mailboxUid=` if accessible, else the caller's own mailbox,
+     * else the first accessible one) - every accessible mailbox's calendars are shown regardless. */
+    mailboxUid?: string;
+    /** `mailboxUid`'s first `calendar`-type folder - the default target for "+ New event". */
+    folderUid?: string;
+    /** Every accessible mailbox's `calendar`-type folders, flattened - the set of calendars that can be
+     * checked/shown (see `CalendarListSidebar`). Each folder's own `mailboxUid` says which mailbox it's in. */
+    calendarFolders: Folder[];
+    /** The same folders, grouped per mailbox, for the sidebar's per-mailbox sections. */
+    mailboxCalendars: MailboxCalendars[];
+    mailboxes: Mailbox[];
+    /** Re-fetches every mailbox's folders (e.g. after creating a new calendar) without a full reload. */
+    reloadFolders: () => void;
+    /** The display color for a calendar folder: its own `color`, else the default for the caller's own
+     * mailbox, else its mailbox's `accentColorForMailbox()` - so a shared mailbox's calendar is visually
+     * distinct from the caller's own even when neither has a color set. */
+    colorFor: (folder: Folder) => string;
+}
+/** Reads the calendars the Calendar is currently showing, as resolved by the enclosing `CalendarShell`. */
+export declare function useCalendarShell(): CalendarShellContextValue;
+/**
+ * The Calendar app's shell. Fetches every accessible mailbox's calendar folders in parallel so shared
+ * mailboxes' calendars show alongside the caller's own, each mailbox color-coded (see `colorFor`) - there
+ * is no mailbox switcher. The actual view being looked at (month/week/day, and which one) is *not* shell
+ * state — it lives in `apps/www/calendar/index.tsx`'s own local state, since navigating between
+ * views/dates must be instant (no full page reload) and this framework has no client-side router.
+ */
+export default function CalendarShell({ userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, pluginNav, children, }: PropsWithChildren<CalendarShellProps>): React.JSX.Element;

package/dist/apps/shared/components/calendar/layout/CalendarShell.js

@@ -29,7 +29,7 @@ export function useCalendarShell() {
  * state — it lives in `apps/www/calendar/index.tsx`'s own local state, since navigating between
  * views/dates must be instant (no full page reload) and this framework has no client-side router.
  */
-export default function CalendarShell({ userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, children, }) {
+export default function CalendarShell({ userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, pluginNav, children, }) {
     const [status, setStatus] = useState("checking");
     const [error, setError] = useState(null);
     const [mailboxes, setMailboxes] = useState([]);
@@ -100,5 +100,5 @@ export default function CalendarShell({ userUid, authServerUrl, impersonating, i
     else if (userUid && status === "ready") {
         inner = (_jsx("div", { className: "flex-1 min-w-0 flex flex-col", children: _jsx(CalendarShellContext.Provider, { value: contextValue, children: children }) }));
     }
-    return (_jsx(AppShell, { active: "calendar", userUid: userUid, authServerUrl: authServerUrl, impersonating: impersonating, impersonationBaseUrl: impersonationBaseUrl, trusted: trusted, children: inner }));
+    return (_jsx(AppShell, { active: "calendar", userUid: userUid, authServerUrl: authServerUrl, impersonating: impersonating, impersonationBaseUrl: impersonationBaseUrl, trusted: trusted, pluginNav: pluginNav, children: inner }));
 }

package/dist/apps/shared/components/contacts/ContactDetailPane.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import { Contact } from "@rapidmx/react-shared/contacts/contactsApi.js";
+export interface ContactDetailPaneProps {
+    contact: Contact;
+    onEdit: () => void;
+    onDelete: () => void;
+    /** Present only on the mobile detail route — renders a "back to contacts" link above the header. Absent
+     * on the desktop inline pane, which never navigates away (selecting a different contact just swaps
+     * `contact` in place). */
+    backHref?: string;
+    /** Called after one of the contact's key changes was accepted or kept, or turned out to be stale - the caller
+     * re-reads the contact. */
+    onKeysChanged?: () => void;
+    /** `false` when the reader is known not to be able to change this contact's keys (the actions are hidden); `undefined`
+     * when unknown (they're hidden after a 403). */
+    canResolveKeys?: boolean;
+}
+/**
+ * A contact's read-only detail view. Shared by the desktop inline pane (`apps/www/contacts/index.tsx`,
+ * always visible alongside the contact list) and the mobile detail route
+ * (`apps/www/contacts/[uid].tsx`, a full page on its own reached by tapping a contact row).
+ */
+export default function ContactDetailPane({ contact, onEdit, onDelete, backHref, onKeysChanged, canResolveKeys }: ContactDetailPaneProps): React.JSX.Element;

package/dist/apps/shared/components/contacts/ContactForm.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import { Contact } from "@rapidmx/react-shared/contacts/contactsApi.js";
+import { Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
+export interface ContactFormProps {
+    contact?: Contact;
+    /** Create mode: the default mailbox (and its Contacts folder) to create in. */
+    mailboxUid?: string;
+    folderUid?: string;
+    /** Create mode: every mailbox the contact could be created in - with more than one, a Mailbox selector
+     * is shown. Choosing a mailbox other than `mailboxUid` looks up that mailbox's own Contacts folder. */
+    mailboxes?: Mailbox[];
+    onSaved: (contact: Contact) => void;
+    onCancel: () => void;
+}
+/**
+ * A contact's create/edit form. Shared by the desktop inline pane (`apps/www/contacts/index.tsx`) and the
+ * mobile detail route's own edit mode (`apps/www/contacts/[uid].tsx`) — creation itself stays
+ * desktop-and-mobile-inline (see that route's own doc comment on why "new" never gets a dedicated route).
+ */
+export default function ContactForm({ contact, mailboxUid, folderUid, mailboxes, onSaved, onCancel }: ContactFormProps): React.JSX.Element;

package/dist/apps/shared/components/contacts/ContactsSidebar.d.ts

@@ -0,0 +1,40 @@
+import React from "react";
+import { Contact } from "@rapidmx/react-shared/contacts/contactsApi.js";
+export type ContactsView = {
+    type: "all";
+} | {
+    type: "favorites";
+} | {
+    type: "list";
+    uid: string;
+    name: string;
+} | {
+    type: "deleted";
+} | {
+    type: "category";
+    name: string;
+};
+export declare function contactsViewKey(view: ContactsView): string;
+export interface ContactsSidebarProps {
+    mailboxUid?: string;
+    /** The caller's own (non-deleted) contacts — used to compute counts and the distinct category list.
+     * Deliberately not fetched again here; the parent already has this loaded for the main table. */
+    contacts: Contact[];
+    active: ContactsView;
+    onSelect: (view: ContactsView) => void;
+    /** Whether to offer the "Deleted" view - restapi only honors `deleted=true` for a caller with delete and
+     * update rights on the mailbox (anyone else silently gets the live contacts), so the parent hides it
+     * otherwise. Defaults to `true`. */
+    showDeleted?: boolean;
+    /** Bumped by the parent whenever a contact-list membership changes, so a newly-created/renamed list
+     * shows up without a full page reload. */
+    refreshToken?: number;
+}
+/**
+ * Contacts' Outlook-style left sidebar: "Your contacts" (all, with count), "Favorites", "Your contact
+ * lists" (real `ContactList` records, fetched here), "Deleted", and "Categories" (derived from the
+ * distinct `categories` values across the loaded contacts — no separate category registry exists
+ * server-side). Owns its own contact-list data-fetching, per this app's convention of keeping
+ * `ContactsShellContext` itself minimal (mailbox/folder resolution only).
+ */
+export default function ContactsSidebar({ mailboxUid, contacts, active, onSelect, refreshToken, showDeleted }: ContactsSidebarProps): React.JSX.Element;

package/dist/apps/shared/components/contacts/ContactsToolbar.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+export interface ContactsToolbarProps {
+    selectedCount: number;
+    /** `true` only when every currently-selected contact is already favorited — flips the "favorite" button
+     * to act (and read) as a removal instead of an addition. */
+    allSelectedFavorited: boolean;
+    onNewContact: () => void;
+    onEdit: () => void;
+    onDelete: () => void;
+    onEmail: () => void;
+    onToggleFavorite: () => void;
+    onAddCategory: () => void;
+    onExportVCard: () => void;
+    /** A `.vcf` file the user picked via the toolbar's own hidden file input — parsing/import is the
+     * page's responsibility (it has the mailbox/folder context and the actual `createContact` calls). */
+    onImportFile: (file: File) => void;
+}
+/**
+ * Contacts' Outlook-style ribbon toolbar. Deliberately presentational — every action is a callback the
+ * page (`apps/www/contacts/index.tsx`) implements, since it owns the actual contact data, the current
+ * selection, and the mailbox/folder context every real action (create/delete/email/favorite/category)
+ * needs. "New contact list" isn't duplicated here — `ContactsSidebar` already has its own inline
+ * "+ New list" affordance next to the "Your contact lists" heading.
+ */
+export default function ContactsToolbar({ selectedCount, allSelectedFavorited, onNewContact, onEdit, onDelete, onEmail, onToggleFavorite, onAddCategory, onExportVCard, onImportFile, }: ContactsToolbarProps): React.JSX.Element;

package/dist/apps/shared/components/contacts/KeyChangeReview.d.ts

@@ -0,0 +1,40 @@
+import React from "react";
+import { type KeyConflict } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+export interface KeyChangeReviewProps {
+    /** The mailbox whose contact holds the pinned key. */
+    mailboxUid: string;
+    /** The contact's address `resolveKeyConflict()` looks the contact up by; absent hides the actions. */
+    address?: string;
+    useType: "sign" | "encrypt";
+    /** Who the key belongs to, for the advice ("confirm with <name>"). */
+    ownerName: string;
+    /** The currently pinned key and when it was first trusted; absent (couldn't be loaded) hides the actions. */
+    current?: {
+        fingerprint: string;
+        since: number;
+    };
+    /** The new key: its fingerprint, the addresses its certificate names, and when and how it was recorded (absent when
+     * it's only known from the message being read). */
+    proposed: {
+        fingerprint: string;
+        emails?: string[];
+        observedAt?: number;
+        source?: KeyConflict["source"];
+    };
+    /** For accepting a key seen in a message: its certificate. Omitted, accepting pins the recorded conflict's key. */
+    certificate?: string;
+    /** Whether "Keep current key" applies - only when a conflict for this exact key is recorded. */
+    canReject: boolean;
+    /** `false` when the reader is known to lack the rights to change the contact's keys. */
+    canResolve?: boolean;
+    /** After a successful accept or reject - the caller refreshes what it shows. */
+    onResolved: (action: "accept" | "reject") => void;
+    /** After a 409: the pinned key changed meanwhile. The caller reloads and says so (`KEY_CHANGE_STALE_MESSAGE`). */
+    onPinnedKeyChanged: () => void;
+}
+/**
+ * The old-versus-new comparison for a changed contact key, with Accept new key (confirmed in a dialog) and Keep current
+ * key, calling `resolveKeyConflict()` against the pinned fingerprint shown. Shared by a message's "signing key changed"
+ * notice and a contact's recorded key conflicts.
+ */
+export default function KeyChangeReview({ mailboxUid, address, useType, ownerName, current, proposed, certificate, canReject, canResolve, onResolved, onPinnedKeyChanged, }: KeyChangeReviewProps): React.JSX.Element;

package/dist/apps/shared/components/contacts/contactKeys.d.ts

@@ -0,0 +1,29 @@
+import type { Contact } from "@rapidmx/react-shared/contacts/contactsApi.js";
+import { type KeyConflict, type PublicKey } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+export declare const KEY_CHANGE_STALE_MESSAGE = "This contact's keys changed while you were looking; reload to see the latest.";
+export declare const KEY_CHANGE_INVALID_MESSAGE = "The new key isn't a valid, current certificate for this address, so it can't be accepted. Nothing was changed.";
+export declare const KEY_CHANGE_FORBIDDEN_MESSAGE = "You don't have permission to change this contact's keys.";
+export declare const KEY_CHANGE_NOT_FOUND_MESSAGE = "There's no key change to resolve for this address any more. It may already have been resolved, or the contact was removed.";
+export declare const KEY_CHANGE_GENERIC_MESSAGE = "Couldn't update this contact's keys. Try again.";
+/** The error text for a failed `resolveKeyConflict()` other than `PinnedKeyChangedError` (which the caller reloads
+ * on and reports with `KEY_CHANGE_STALE_MESSAGE`). */
+export declare function keyChangeErrorMessage(err: unknown): string;
+/** Groups a fingerprint into 4-character blocks (`ab12 cd34 ...`), ignoring any separators it came with, so it can be
+ * read out and compared over another channel. */
+export declare function groupFingerprint(fingerprint: string): string;
+/** Whether two fingerprints name the same key (case and separators ignored). */
+export declare function sameFingerprint(a: string | undefined, b: string | undefined): boolean;
+/** A revoked key's label: `"superseded"` for a routine replacement, `"revoked"` for a compromised key or one revoked
+ * with no reason; `undefined` when the key isn't revoked. */
+export declare function revocationLabel(key: PublicKey): "superseded" | "revoked" | undefined;
+/** Where a key conflict was observed, for display. */
+export declare function conflictSourceLabel(source: KeyConflict["source"]): string;
+/** restapi records `keysFirstSeen` on a contact but react-shared's `Contact` type doesn't carry it. */
+type ContactWithFirstSeen = Pick<Contact, "previousKeys"> & {
+    keysFirstSeen?: number;
+};
+/** When `key` (one of `contact`'s pinned keys) started being trusted: when it replaced the newest previous key of its
+ * use, else the contact's `keysFirstSeen`, else the key's own `notBefore`. */
+export declare function keyPinnedSince(contact: ContactWithFirstSeen, key: PublicKey): number;
+export declare function formatDate(ms: number): string;
+export {};

package/dist/apps/shared/components/contacts/layout/ContactsShell.d.ts

@@ -0,0 +1,21 @@
+import React, { PropsWithChildren } from "react";
+import { Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
+import { AppShellProps } from "../../layout/AppShell.js";
+export type ContactsShellProps = Omit<AppShellProps, "active">;
+export interface ContactsShellContextValue {
+    /** The mailbox currently selected (`?mailboxUid=`, or the caller's first accessible mailbox). */
+    mailboxUid?: string;
+    /** The selected mailbox's single `contacts`-type folder. */
+    folderUid?: string;
+    mailboxes: Mailbox[];
+}
+/** Reads the mailbox/folder Contacts is currently showing, as resolved by the enclosing `ContactsShell`. */
+export declare function useContactsShell(): ContactsShellContextValue;
+/**
+ * The Contacts app's shell: unlike `MailShell` (a folder tree, since a mailbox has many mail folders),
+ * a mailbox has exactly one well-known `contacts` folder — see `BaseMailboxRoute.create()`'s eager
+ * provisioning in `@rapidmx/restapi`, which guarantees it exists for every mailbox. This shell's own
+ * sidebar is therefore just a mailbox switcher (when the caller has more than one); the actual contact
+ * list/detail UI is `apps/www/contacts/index.tsx`'s own content, rendered as `children` here.
+ */
+export default function ContactsShell({ userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, pluginNav, children, }: PropsWithChildren<ContactsShellProps>): React.JSX.Element;

package/dist/apps/shared/components/contacts/layout/ContactsShell.js

@@ -24,7 +24,7 @@ export function useContactsShell() {
  * sidebar is therefore just a mailbox switcher (when the caller has more than one); the actual contact
  * list/detail UI is `apps/www/contacts/index.tsx`'s own content, rendered as `children` here.
  */
-export default function ContactsShell({ userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, children, }) {
+export default function ContactsShell({ userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, pluginNav, children, }) {
     const [status, setStatus] = useState("checking");
     const [error, setError] = useState(null);
     const [mailboxes, setMailboxes] = useState([]);
@@ -89,5 +89,5 @@ export default function ContactsShell({ userUid, authServerUrl, impersonating, i
                             }, children: mailboxes.map((mb) => (_jsxs("option", { value: mb.uid, children: [mb.displayName, mb.ownerUserUid ? "" : " (shared)"] }, mb.uid))) })] })), folderError && _jsx(Alert, { children: folderError })] }));
         inner = (_jsxs(_Fragment, { children: [_jsx("aside", { className: "hidden md:flex w-56 shrink-0 bg-surface border-r border-border flex-col p-3 gap-3", children: sidebarContent("desktop") }), _jsx(Drawer, { open: drawerOpen, onClose: () => setDrawerOpen(false), title: "Mailbox", children: _jsx("div", { className: "flex flex-col gap-3", children: sidebarContent("mobile") }) }), _jsxs("main", { className: "flex-1 min-w-0 flex flex-col", children: [(mailboxes.length > 1 || folderError) && (_jsx("button", { type: "button", className: "md:hidden m-3 w-9 h-9 flex items-center justify-center rounded-sm text-text-muted hover:bg-surface-alt hover:text-text", "aria-label": "Open mailbox switcher", onClick: () => setDrawerOpen(true), children: _jsx(HiOutlineBars3, { size: 20, "aria-hidden": "true" }) })), _jsx(ContactsShellContext.Provider, { value: contextValue, children: children })] })] }));
     }
-    return (_jsx(AppShell, { active: "contacts", userUid: userUid, authServerUrl: authServerUrl, impersonating: impersonating, impersonationBaseUrl: impersonationBaseUrl, trusted: trusted, children: inner }));
+    return (_jsx(AppShell, { active: "contacts", userUid: userUid, authServerUrl: authServerUrl, impersonating: impersonating, impersonationBaseUrl: impersonationBaseUrl, trusted: trusted, pluginNav: pluginNav, children: inner }));
 }

package/dist/apps/shared/components/escrow/layout/EscrowShell.d.ts

@@ -0,0 +1,25 @@
+import "../../../styles/app.css";
+import React, { PropsWithChildren } from "react";
+export type EscrowSection = "matters" | "auditLog";
+export interface EscrowShellProps {
+    active: EscrowSection;
+    userUid?: string;
+    authServerUrl?: string;
+}
+/**
+ * Gates every `apps/escrow` page behind "is this an authenticated caller at all" — deliberately **not**
+ * the same "does a canary endpoint 403 me" pattern `AdminShell` uses for the trusted `admin` role.
+ * `specs/end-to-end_encryption.md`'s "Separation of duties" makes holder-ness a per-`EscrowScope` grant
+ * (`EscrowScope.holderUserUids`), checked directly against `holderUserUids` in every restapi route that
+ * needs it (`requireEscrowHolder()`) — never a role, and never global. There is no canary endpoint a
+ * non-holder gets a clean 403 from: `GET /escrow/matters` (`BaseMatterRoute.find()`) returns `200 []` for
+ * *any* authenticated caller who holds no scope at all, the same as it would for a holder of zero matters
+ * — so unlike `AdminShell`, this shell cannot distinguish "holds nothing" from "holds no scope at all" up
+ * front, and does not try to. It only confirms the caller is signed in and the API is reachable; every
+ * actual holder-gated action (create a Matter, approve/deny a request, read material) is enforced
+ * server-side and surfaces its own 403 `ApiRequestError` on the specific page that attempted it, same as
+ * any other gated action elsewhere in this codebase. A non-holder who reaches `/escrow` simply sees an
+ * empty Matters list and gets a real error if they try to act on something they don't hold — this is a
+ * deliberate, documented scope trim rather than an oversight (see this session's own report on it).
+ */
+export default function EscrowShell({ active, userUid, authServerUrl, children }: PropsWithChildren<EscrowShellProps>): React.JSX.Element;

package/dist/apps/shared/components/forms/StringListField.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+export interface StringListFieldProps {
+    label: string;
+    /** Associates the label with the add-input via `htmlFor`/`id`, same as `FormField` — required so the
+     * field is reachable via `getByLabelText()` in tests and by assistive tech, not just visually. */
+    id: string;
+    values: string[];
+    onChange: (values: string[]) => void;
+    placeholder?: string;
+    emptyMessage?: string;
+    disabled?: boolean;
+}
+/**
+ * A plain, controlled add/remove list-of-strings editor — the same visual add-row/per-item-remove shape
+ * `MemberListCard` already established for a `DistributionList`'s `memberAddresses`, but operating on a
+ * local `value`/`onChange` pair rather than persisting itself via its own API call. `MemberListCard`
+ * isn't reusable here as-is: `EscrowScope.holderUserUids` (at least one required) and
+ * `Matter.custodianMailboxUids` (also non-empty) are both required *at creation time*, before there's any
+ * uid yet to `PUT` against — this needs to compose into an ordinary create/edit form's own local state
+ * instead, same as every other field on those forms.
+ */
+export default function StringListField({ label, id, values, onChange, placeholder, emptyMessage, disabled, }: StringListFieldProps): React.JSX.Element;

package/dist/apps/shared/components/layout/AppShell.d.ts

@@ -0,0 +1,49 @@
+import "../../styles/app.css";
+import React, { PropsWithChildren } from "react";
+import type { IconType } from "react-icons";
+import { NavItem } from "@rapidmx/react-shared/components/navigation/BottomTabBar.js";
+import { PluginNav, PluginNavProps } from "../../plugins/pluginNav.js";
+/** How long sign-out waits for auth-server's logout before navigating anyway. */
+export declare const LOGOUT_TIMEOUT_MS = 3000;
+export type AppShellApp = "mail" | "calendar" | "contacts" | "tasks";
+/** `"settings"` is a valid `active` value but deliberately has no entry in `APPS` below — Settings is
+ * reached via a `UserMenu` item, not a 5th rail icon (see `SettingsShell.tsx`), so it highlights no
+ * rail/tab icon at all; only the header title needs to account for it. Any other string is a plugin's
+ * `appRail` item id (see `PluginNav`). */
+export type AppShellActive = AppShellApp | "settings" | (string & {});
+export interface AppShellProps extends PluginNavProps {
+    /** Which icon in the rail is highlighted as the current app — `"settings"` highlights none, and a plugin
+     * app page passes its own `appRail` item id. */
+    active: AppShellActive;
+    /** Populated automatically by the framework from an authenticated request (e.g. a valid `jwt` cookie). */
+    userUid?: string;
+    /** auth-server's base URL, injected via the route's `fetchProps`. */
+    authServerUrl?: string;
+    /**
+     * `true` when this session is an admin "log in as user" impersonation (a `jwt_impersonator` cookie is
+     * present) — see `MailShell`'s original doc comment, unchanged now that this lives here. Drives the
+     * "you are viewing as this user — stop impersonating" banner below.
+     */
+    impersonating?: boolean;
+    /** Where `mailApi.ts`'s `stopImpersonating()` should call — see `MailShell`'s original doc comment. */
+    impersonationBaseUrl?: string;
+    /** `true` when the caller's JWT carries a trusted role — shows an "Admin" item in the user menu below. */
+    trusted?: boolean;
+}
+export interface AppDef {
+    id: AppShellApp;
+    href: string;
+    label: string;
+    icon: IconType;
+}
+export declare const APPS: AppDef[];
+/** `APPS` followed by the plugins' `appRail` items (generic icon), core ids winning - see `mergePluginNavItems`. */
+export declare function appRailItems(pluginNav?: PluginNav): NavItem[];
+/**
+ * The persistent chrome shared by every webmail app (Mail, Calendar, Contacts, Tasks): a left icon rail for
+ * switching apps (full page loads — see `MailShell`'s original doc comment on this framework having no
+ * client-side router), a header with the current app's name and `UserMenu`, and the impersonation banner.
+ * Each app's own shell (e.g. `MailShell`) renders its own contextual sidebar + content as `children`, inside
+ * the area to the right of the icon rail and below the header.
+ */
+export default function AppShell({ active, userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, pluginNav, children, }: PropsWithChildren<AppShellProps>): React.JSX.Element;