@rapidmx/web-client 0.15.1 → 0.16.0

package/apps/shared/components/mail/layout/MailShell.tsx

@@ -9,6 +9,7 @@ import { Folder, Mailbox, Message } 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 AppShell, { AppShellProps } from "../../layout/AppShell.js";
+import FloatingActionButton from "../../layout/FloatingActionButton.js";
 import { useLocationSearch, useNavigate } from "../../../navigation/AppRouter.js";
 import KeyEnrollmentGate from "../../layout/KeyEnrollmentGate.js";
 import MailboxProvisioning from "../../layout/MailboxProvisioning.js";
@@ -17,15 +18,19 @@ import LocalIndexLifecycle from "../../../search/LocalIndexLifecycle.js";
 import { LiveUpdates, NO_LIVE_UPDATES } from "../../../mail/useMailLiveUpdates.js";
 import { MAILBOX_LIST_LIMIT, MailConnectionContext, useMailConnection } from "../../../mail/useMailConnection.js";
 import { folderRows } from "../../../mail/folderTree.js";
+import { primaryMailboxUid } from "../../../mail/primaryMailbox.js";
 import {
     CountTracker,
     FolderBadge,
     FolderCount,
     badgeFor,
-    badgeLabel,
     countOfFolder,
     inboxUnreadTotal,
+    unreadBadgeTotal,
 } from "../../../mail/folderCounts.js";
+import { ALL_MAILBOXES_SECTION, useSidebarSections } from "../../../mail/useCollapsedSections.js";
+import FolderBadgeChip from "./FolderBadgeChip.js";
+import SidebarSection from "./SidebarSection.js";
 import { useUnreadTitle } from "../../../mail/useUnreadTitle.js";
 import { pendingCountFor, usePendingSends } from "../../../mail/outbox/pendingSends.js";
 import OutboxBadge from "../OutboxBadge.js";
@@ -143,21 +148,6 @@ function aggregateBadge(mailboxFolders: MailboxFolders[], type: AggregateFolderT
     return badgeFor(type, sum);
 }
 
-/** A folder's badge: an accent pill with the unread count, or - for the folders that show how many they hold - plain muted text. */
-function FolderBadgeChip({ badge }: { badge: FolderBadge }) {
-    return (
-        <span
-            className={[
-                "text-xs rounded-pill py-0.5 px-1.5",
-                badge.kind === "unread" ? "font-bold bg-primary/15 text-primary-dark" : "font-medium text-text-muted",
-            ].join(" ")}
-        >
-            <span aria-hidden="true">{badge.value}</span>
-            <span className="sr-only"> {badgeLabel(badge)}</span>
-        </span>
-    );
-}
-
 type Status = "checking" | "error" | "ready";
 
 export { MAILBOX_LIST_LIMIT };
@@ -200,16 +190,13 @@ function ComposeButton({ mailboxUid }: { mailboxUid?: string }) {
 function MobileComposeButton({ mailboxUid }: { mailboxUid?: string }) {
     const { openCompose } = useCompose();
     return (
-        <button
-            type="button"
-            aria-label="New message"
+        <FloatingActionButton
+            label="New message"
+            icon={HiOutlinePencilSquare}
             onClick={() => openCompose({ mailboxUid })}
             onPointerEnter={prefetchComposeWindow}
             onFocus={prefetchComposeWindow}
-            className="md:hidden fixed right-4 bottom-[4.5rem] z-30 w-12 h-12 flex items-center justify-center rounded-full bg-primary text-white shadow-lg hover:bg-primary-dark"
-        >
-            <HiOutlinePencilSquare size={22} aria-hidden="true" />
-        </button>
+        />
     );
 }
 
@@ -239,6 +226,11 @@ function MailShortcuts({ mailboxUid }: { mailboxUid?: string }) {
  * behavior change from before this, and a multi-mailbox user sees every mailbox's folders (and the new
  * aggregate section) simultaneously, matching the shared-mailbox feature's own "display as a separate set
  * of folders" requirement.
+ *
+ * An address that names nothing opens "All Mailboxes > Inbox" when there is more than one mailbox (that is when the section exists), and
+ * the one mailbox's own Inbox otherwise; a `?mailboxUid=`, `?folderUid=` or `?aggregate=` always wins. Nothing is selected until the address
+ * has been read. What needs a single mailbox while an all-mailboxes view is open (Compose, the new-message shortcut, key unlocking) uses the
+ * primary mailbox.
  */
 export default function MailShell({
     userUid,
@@ -263,6 +255,8 @@ export default function MailShell({
     const [requestedFolderUid, setRequestedFolderUid] = useState<string | null>(null);
     const [requestedAggregateType, setRequestedAggregateType] = useState<string | null>(null);
     const [drawerOpen, setDrawerOpen] = useState(false);
+    // Whether the URL has been read yet (see below): until then the selection is not known, and the sidebar sections have nothing to open for.
+    const [selectionRead, setSelectionRead] = useState(false);
 
     // The selection lives in the URL, and the router (`AppRouter`) changes the URL without a page load when a folder link is
     // clicked - so it is read from the router's location, which updates, rather than once from `window.location`. Still read
@@ -273,6 +267,7 @@ export default function MailShell({
         setRequestedMailboxUid(params.get("mailboxUid"));
         setRequestedFolderUid(params.get("folderUid"));
         setRequestedAggregateType(params.get("aggregate"));
+        setSelectionRead(true);
     }, [search]);
     // Choosing a folder (or mailbox) changes the URL without a page load now, so the drawer that held the choice - which used to go
     // with the page - is closed here.
@@ -280,14 +275,23 @@ export default function MailShell({
         setDrawerOpen(false);
     }, [search]);
 
-    const aggregateFolderType: AggregateFolderType | undefined = isAggregateFolderType(requestedAggregateType)
-        ? requestedAggregateType
-        : undefined;
+    // What the address asks for. Nothing is selected until it has been read (the first render, before the effect above): choosing a
+    // default then would list a folder - the most expensive being every mailbox's - only to throw it away for the one the address names.
+    const requestedAggregate: AggregateFolderType | undefined =
+        selectionRead && isAggregateFolderType(requestedAggregateType) ? requestedAggregateType : undefined;
+    const requestedMailbox: string | undefined =
+        selectionRead && requestedMailboxUid && mailboxes.some((mb) => mb.uid === requestedMailboxUid) ? requestedMailboxUid : undefined;
 
-    const mailboxUid: string | undefined = aggregateFolderType
-        ? undefined
-        : (requestedMailboxUid && mailboxes.some((mb) => mb.uid === requestedMailboxUid) ? requestedMailboxUid : undefined) ??
-          mailboxes[0]?.uid;
+    // The mailbox the caller has not chosen: their own, never a shared one that merely sorts first. It is what compose, the new-message
+    // shortcut and everything else that needs a single mailbox use while an all-mailboxes view (which has none) is open.
+    const defaultMailboxUid = primaryMailboxUid(mailboxes, userUid);
+
+    // With several mailboxes the address that names nothing opens "All Mailboxes > Inbox", the merged Inbox; with one there is no such
+    // section, so it opens that mailbox's own Inbox. A mailbox, a folder or an all-mailboxes view in the address wins over either.
+    const aggregateByDefault =
+        selectionRead && !requestedAggregate && !requestedMailbox && requestedFolderUid === null && mailboxes.length > 1;
+    const aggregateFolderType: AggregateFolderType | undefined = requestedAggregate ?? (aggregateByDefault ? "inbox" : undefined);
+    const mailboxUid: string | undefined = aggregateFolderType || !selectionRead ? undefined : (requestedMailbox ?? defaultMailboxUid);
 
     const selectedMailboxFolders = mailboxFolders.find((mf) => mf.mailbox.uid === mailboxUid)?.folders ?? [];
     const folderUid: string | undefined = aggregateFolderType
@@ -296,13 +300,21 @@ export default function MailShell({
           selectedMailboxFolders.find((f) => f.type === "inbox")?.uid;
 
     // The mailbox `KeyEnrollmentGate`/`LocalIndexLifecycle`/`ComposeButton` treat as "the" mailbox when
-    // there's no single selected one to use (aggregate mode) - the caller's own owned mailbox if they
-    // have one, else whichever accessible mailbox happens to be first. See MailShell's own doc comment on
+    // there's no single selected one to use (aggregate mode) - the caller's primary mailbox (`primaryMailbox()`). See MailShell's own doc comment on
     // this being an accepted limitation: an aggregate-view message from a *different*, not-yet-visited
     // mailbox may still need that mailbox's own folder view opened directly to unlock/decrypt it.
-    const defaultMailboxUid = mailboxes.find((mb) => mb.ownerUserUid === userUid)?.uid ?? mailboxes[0]?.uid;
     const activeMailboxUid = mailboxUid ?? defaultMailboxUid;
 
+    // Which sidebar sections are open: "All mailboxes" and the primary mailbox unless the reader chose otherwise. Any of them can be collapsed;
+    // a change of the open folder into another section opens that one (see `useSidebarSections()`); the first selection, once the address has been read
+    // and the mailboxes are here, is where a load lands, not a navigation. A lone mailbox has nothing to collapse, so its section is never a toggle.
+    const sections = useSidebarSections({
+        userUid,
+        primaryUid: defaultMailboxUid,
+        activeId: aggregateFolderType ? ALL_MAILBOXES_SECTION : mailboxUid,
+    });
+    const collapsible = mailboxes.length > 1;
+
     const counts = folderCounts.counts;
     const trackMessageChange = folderCounts.track;
     // `(3) Acme: Mail` in the tab strip while there is unread mail in an Inbox - kept by the frame when there is one.
@@ -345,7 +357,8 @@ export default function MailShell({
         // A function, not a plain JSX constant — it's rendered twice (desktop `<aside>` + mobile
         // `Drawer`), possibly *simultaneously* mounted (the aside is only CSS-hidden below `md`, not
         // unmounted).
-        const sidebarContent = () => (
+        // `idPrefix` keeps each section's folder list's id (which its heading's `aria-controls` names) unique between the two.
+        const sidebarContent = (idPrefix: string) => (
             <>
                 <div className="p-3">
                     <ComposeButton mailboxUid={defaultMailboxUid} />
@@ -357,91 +370,102 @@ export default function MailShell({
                 ) : (
                     <nav className="flex-1 overflow-y-auto px-3 pb-3 flex flex-col gap-3">
                         {mailboxes.length > 1 && (
-                            <div>
-                                <div className="text-xs font-bold uppercase tracking-wide text-text-muted mb-1 px-2.5">
-                                    All Mailboxes
-                                </div>
-                                <div className="flex flex-col gap-0.5">
-                                    {AGGREGATE_FOLDER_TYPES.map((type) => {
-                                        const badge = aggregateBadge(mailboxFolders, type, counts);
-                                        return (
-                                            <a
-                                                key={type}
-                                                href={`/?aggregate=${encodeURIComponent(type)}`}
-                                                className={[
-                                                    "flex items-center justify-between text-sm rounded-sm py-1.5 px-2.5",
-                                                    aggregateFolderType === type
-                                                        ? "bg-primary/10 text-primary-dark font-semibold"
-                                                        : "text-text hover:bg-surface-alt",
-                                                ].join(" ")}
-                                            >
-                                                <span className={badge?.kind === "unread" ? "font-semibold" : undefined}>{FOLDER_LABELS[type]}</span>
-                                                {badge && <FolderBadgeChip badge={badge} />}
-                                            </a>
-                                        );
-                                    })}
-                                </div>
-                            </div>
-                        )}
-                        {mailboxFolders.map(({ mailbox, folders, error: mailboxError }) => (
-                            <div key={mailbox.uid}>
-                                <div className="text-xs font-bold uppercase tracking-wide text-text-muted mb-1 px-2.5 truncate">
-                                    {mailbox.displayName}
-                                    {mailbox.ownerUserUid ? "" : " (shared)"}
-                                </div>
-                                {mailboxError && (
-                                    <div className="px-2.5 pb-1">
-                                        <Alert>{mailboxError}</Alert>
-                                    </div>
-                                )}
-                                <div className="flex flex-col gap-0.5">
-                                    {folderRows(folders, pendingCountFor(mailbox.uid, pendingSends)).map((row) => {
-                                        if (row.kind === "placeholder") {
-                                            // A folder the server has not made (or told us about) yet - the Outbox and Sent Items are made with the first message
-                                            // sent - shown the moment a message is on its way. Nothing to open; the real folder replaces it when it arrives.
-                                            const sending = pendingCountFor(mailbox.uid, pendingSends);
-                                            return (
-                                                <div
-                                                    key={`placeholder-${row.type}`}
-                                                    data-folder-placeholder={row.type}
-                                                    className="flex items-center justify-between text-sm rounded-sm py-1.5 px-2.5 text-text-muted"
-                                                >
-                                                    <span>{FOLDER_LABELS[row.type]}</span>
-                                                    {row.type === "outbox" && <OutboxBadge total={sending} pendingHere={sending} />}
-                                                </div>
-                                            );
-                                        }
-                                        const folder = row.folder;
-                                        const badge = badgeFor(folder.type, countOfFolder(folder, counts));
-                                        return (
+                            <SidebarSection
+                                domId={`${idPrefix}-mail-section-${ALL_MAILBOXES_SECTION}`}
+                                label="All Mailboxes"
+                                collapsible={collapsible}
+                                expanded={sections.isExpanded(ALL_MAILBOXES_SECTION)}
+                                onToggle={() => sections.toggle(ALL_MAILBOXES_SECTION)}
+                                unread={unreadBadgeTotal(mailboxFolders.flatMap((mf) => mf.folders), counts)}
+                            >
+                                {AGGREGATE_FOLDER_TYPES.map((type) => {
+                                    const badge = aggregateBadge(mailboxFolders, type, counts);
+                                    return (
                                         <a
-                                            key={folder.uid}
-                                            href={`/?mailboxUid=${encodeURIComponent(mailbox.uid)}&folderUid=${encodeURIComponent(folder.uid)}`}
+                                            key={type}
+                                            href={`/?aggregate=${encodeURIComponent(type)}`}
                                             className={[
                                                 "flex items-center justify-between text-sm rounded-sm py-1.5 px-2.5",
-                                                folder.uid === folderUid
+                                                aggregateFolderType === type
                                                     ? "bg-primary/10 text-primary-dark font-semibold"
                                                     : "text-text hover:bg-surface-alt",
                                             ].join(" ")}
                                         >
-                                            <span className={badge?.kind === "unread" ? "font-semibold" : undefined}>
-                                                {FOLDER_LABELS[folder.type] ?? folder.name}
-                                            </span>
-                                            {badge &&
-                                                (folder.type === "outbox" ? (
-                                                    <OutboxBadge
-                                                        total={badge.value}
-                                                        status={outboxStatuses[folder.uid]}
-                                                        pendingHere={pendingCountFor(mailbox.uid, pendingSends)}
-                                                    />
-                                                ) : (
-                                                    <FolderBadgeChip badge={badge} />
-                                                ))}
+                                            <span className={badge?.kind === "unread" ? "font-semibold" : undefined}>{FOLDER_LABELS[type]}</span>
+                                            {badge && <FolderBadgeChip badge={badge} />}
                                         </a>
+                                    );
+                                })}
+                            </SidebarSection>
+                        )}
+                        {mailboxFolders.map(({ mailbox, folders, error: mailboxError }) => (
+                            <SidebarSection
+                                key={mailbox.uid}
+                                domId={`${idPrefix}-mail-section-${mailbox.uid}`}
+                                label={
+                                    <>
+                                        {mailbox.displayName}
+                                        {mailbox.ownerUserUid ? "" : " (shared)"}
+                                    </>
+                                }
+                                collapsible={collapsible}
+                                expanded={sections.isExpanded(mailbox.uid)}
+                                onToggle={() => sections.toggle(mailbox.uid)}
+                                unread={unreadBadgeTotal(folders, counts)}
+                                notice={
+                                    mailboxError && (
+                                        <div className="px-2.5 pb-1">
+                                            <Alert>{mailboxError}</Alert>
+                                        </div>
+                                    )
+                                }
+                            >
+                                {folderRows(folders, pendingCountFor(mailbox.uid, pendingSends)).map((row) => {
+                                    if (row.kind === "placeholder") {
+                                        // A folder the server has not made (or told us about) yet - the Outbox and Sent Items are made with the first message
+                                        // sent - shown the moment a message is on its way. Nothing to open; the real folder replaces it when it arrives.
+                                        const sending = pendingCountFor(mailbox.uid, pendingSends);
+                                        return (
+                                            <div
+                                                key={`placeholder-${row.type}`}
+                                                data-folder-placeholder={row.type}
+                                                className="flex items-center justify-between text-sm rounded-sm py-1.5 px-2.5 text-text-muted"
+                                            >
+                                                <span>{FOLDER_LABELS[row.type]}</span>
+                                                {row.type === "outbox" && <OutboxBadge total={sending} pendingHere={sending} />}
+                                            </div>
                                         );
-                                    })}
-                                </div>
-                            </div>
+                                    }
+                                    const folder = row.folder;
+                                    const badge = badgeFor(folder.type, countOfFolder(folder, counts));
+                                    return (
+                                    <a
+                                        key={folder.uid}
+                                        href={`/?mailboxUid=${encodeURIComponent(mailbox.uid)}&folderUid=${encodeURIComponent(folder.uid)}`}
+                                        className={[
+                                            "flex items-center justify-between text-sm rounded-sm py-1.5 px-2.5",
+                                            folder.uid === folderUid
+                                                ? "bg-primary/10 text-primary-dark font-semibold"
+                                                : "text-text hover:bg-surface-alt",
+                                        ].join(" ")}
+                                    >
+                                        <span className={badge?.kind === "unread" ? "font-semibold" : undefined}>
+                                            {FOLDER_LABELS[folder.type] ?? folder.name}
+                                        </span>
+                                        {badge &&
+                                            (folder.type === "outbox" ? (
+                                                <OutboxBadge
+                                                    total={badge.value}
+                                                    status={outboxStatuses[folder.uid]}
+                                                    pendingHere={pendingCountFor(mailbox.uid, pendingSends)}
+                                                />
+                                            ) : (
+                                                <FolderBadgeChip badge={badge} />
+                                            ))}
+                                    </a>
+                                    );
+                                })}
+                            </SidebarSection>
                         ))}
                     </nav>
                 )}
@@ -451,9 +475,9 @@ export default function MailShell({
         inner = (
             <>
                 <MailShortcuts mailboxUid={defaultMailboxUid} />
-                <aside className="hidden md:flex w-64 shrink-0 bg-surface border-r border-border flex-col">{sidebarContent()}</aside>
-                <Drawer open={drawerOpen} onClose={() => setDrawerOpen(false)} title="Folders">
-                    <div className="flex flex-col">{sidebarContent()}</div>
+                <aside className="hidden md:flex w-64 shrink-0 bg-surface border-r border-border flex-col">{sidebarContent("desktop")}</aside>
+                <Drawer open={drawerOpen} onClose={() => setDrawerOpen(false)} title="Folders" fullScreen>
+                    <div className="flex flex-col">{sidebarContent("mobile")}</div>
                 </Drawer>
                 <main className="flex-1 min-w-0 overflow-y-auto">
                     <div className="md:hidden flex items-center gap-2 p-3">

package/apps/shared/components/mail/layout/SidebarSection.tsx

@@ -0,0 +1,66 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import React, { ReactNode } from "react";
+import { HiChevronDown } from "react-icons/hi2";
+import FolderBadgeChip from "./FolderBadgeChip.js";
+
+export interface SidebarSectionProps {
+    /** Unique per rendering of the sidebar (it is on screen twice on a phone: beside the list and in the drawer): names the folder list the heading controls. */
+    domId: string;
+    /** The heading's text. */
+    label: ReactNode;
+    /** Whether the heading is a toggle at all. Not for a lone mailbox, whose section has nothing to be hidden for. */
+    collapsible: boolean;
+    expanded: boolean;
+    onToggle: () => void;
+    /** The unread mail in the section's folders that carry an unread count (see `unreadBadgeTotal()`), shown on the heading while it is collapsed (and only when there is some) so new mail in a hidden section is still noticed. */
+    unread?: number;
+    /** Shown between the heading and the folders, collapsed or not: a failure to load the section's folders is not something to hide. */
+    notice?: ReactNode;
+    /** The section's folder rows. */
+    children: ReactNode;
+}
+
+/**
+ * One section of Mail's sidebar ("All mailboxes", or one mailbox): a heading over a list of folders. When `collapsible` the heading is a
+ * disclosure button (`aria-expanded`, `aria-controls` the list, a chevron that turns) and the list is `hidden` while it is collapsed -
+ * kept in the document, so the button's `aria-controls` always names something and nothing is fetched or rebuilt on opening it.
+ */
+export default function SidebarSection({ domId, label, collapsible, expanded, onToggle, unread = 0, notice, children }: SidebarSectionProps) {
+    const shown = !collapsible || expanded;
+    return (
+        <div>
+            {collapsible ? (
+                <h2 className="mb-1">
+                    <button
+                        type="button"
+                        aria-expanded={expanded}
+                        aria-controls={domId}
+                        onClick={onToggle}
+                        className={[
+                            "flex w-full items-center gap-1 rounded-sm px-2.5 py-0.5 text-left text-xs font-bold uppercase tracking-wide text-text-muted",
+                            "focus-visible:outline-2 focus-visible:outline-primary",
+                            "hover:bg-surface-alt hover:text-text",
+                        ].join(" ")}
+                    >
+                        <HiChevronDown
+                            size={14}
+                            aria-hidden="true"
+                            className={["shrink-0 transition-transform", expanded ? "" : "-rotate-90"].join(" ")}
+                        />
+                        <span className="min-w-0 flex-1 truncate">{label}</span>
+                        {!expanded && unread > 0 && <FolderBadgeChip badge={{ kind: "unread", value: unread }} />}
+                    </button>
+                </h2>
+            ) : (
+                <div className="text-xs font-bold uppercase tracking-wide text-text-muted mb-1 px-2.5 truncate">{label}</div>
+            )}
+            {notice}
+            <div id={domId} hidden={!shown} className={shown ? "flex flex-col gap-0.5" : "hidden"}>
+                {children}
+            </div>
+        </div>
+    );
+}

package/apps/shared/components/mail/reading/PendingMessageCard.tsx

@@ -0,0 +1,68 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import React from "react";
+import Button from "@rapidmx/react-shared/components/buttons/Button.js";
+import type { OutgoingReply } from "../../../mail/outbox/outgoingReplies.js";
+import MailAddress, { RecipientLine } from "../MailAddress.js";
+import MessageBody from "./MessageBody.js";
+import { BODY_FONT_STYLE, CardShell, SenderAvatar } from "./MessageCard.js";
+
+/**
+ * A reply or forward that has just been sent, drawn where its message will be once the server has filed it: the sender, who it went to, its body as
+ * it was composed, and one line saying where it is - "Sending...", "Sent", or, when it did not go, "Not sent: <why>" with the same ways out the
+ * pop-up offers (Retry, Open draft ...). It reads like the message's own card, so the real message replaces it without the thread rearranging.
+ *
+ * The body goes through the reading pane's own sanitizing frame (`MessageBody`), exactly as a received message's does.
+ */
+export default function PendingMessageCard({
+    reply,
+    headerRef,
+}: {
+    reply: OutgoingReply;
+    /** Registered so the pane can put the focus here when the message first appears. Focusable, but not in the tab order. */
+    headerRef: (node: HTMLHeadingElement | null) => void;
+}) {
+    const failed = reply.state === "failed";
+    return (
+        <CardShell>
+            <div className="flex items-center gap-3 px-4 py-3">
+                <SenderAvatar from={reply.sender} />
+                <div className="flex-1 min-w-0">
+                    <div className="flex flex-wrap items-baseline justify-between gap-x-2 text-sm">
+                        <h2 ref={headerRef} tabIndex={-1} style={BODY_FONT_STYLE} className="flex-1 min-w-[13rem] font-semibold outline-none focus-visible:outline-2 focus-visible:outline-primary">
+                            <MailAddress recipient={reply.sender} />
+                        </h2>
+                        <div
+                            // Its own element for each: an alert is announced when it appears, which a status that changed its role would not be.
+                            key={failed ? "failed" : "progress"}
+                            role={failed ? "alert" : "status"}
+                            data-testid="pending-message-status"
+                            data-state={reply.state}
+                            className={["flex items-center gap-1.5 text-xs shrink-0", failed ? "font-semibold text-danger" : "text-text-muted"].join(" ")}
+                        >
+                            {reply.state === "sending" && <span aria-hidden="true" className="rr-sending-dot h-1.5 w-1.5 shrink-0 rounded-full bg-primary" />}
+                            <span>{failed ? `Not sent: ${reply.failure}` : reply.state === "sending" ? "Sending…" : "Sent"}</span>
+                        </div>
+                    </div>
+                    <RecipientLine label="To" recipients={reply.to} />
+                    <RecipientLine label="Cc" recipients={reply.cc} />
+                    <RecipientLine label="Bcc" recipients={reply.bcc} />
+                </div>
+            </div>
+            {failed && (
+                <div className="flex flex-wrap gap-2 px-4 pb-3">
+                    {reply.actions.map((action) => (
+                        <Button key={action.label} type="button" variant="secondary" className="!w-auto" onClick={action.onClick}>
+                            {action.label}
+                        </Button>
+                    ))}
+                </div>
+            )}
+            <div className="px-4 pb-4">
+                <MessageBody messageUid={reply.uid} messageVersion={0} title={`Message: ${reply.subject}`} content={{ kind: "html", html: reply.html }} />
+            </div>
+        </CardShell>
+    );
+}