@remit/web-client 0.0.325 → 0.0.327

package/dist/src/lib/brief.js

@@ -0,0 +1,164 @@
+/**
+ * Daily brief section assembly.
+ *
+ * Pure function: takes one complete per-category server response and returns one
+ * section per message category, in a fixed display order:
+ *
+ *  1. Personal
+ *  2. Transactional
+ *  3. Newsletter
+ *  4. Marketing
+ *  5. Social
+ *  6. Automated
+ *  7. Unclassified
+ *
+ * Each section is its own server query, scoped to its category and carrying
+ * every criterion on screen the request can express, plus one count for the
+ * whole category. Nothing here groups a page: a category whose mail is entirely
+ * older than the newest unified page still has a section, and the section's
+ * header states the category's real size rather than how many of a shared window
+ * happened to fall in it (#312). `uncategorized` is its own section rather than
+ * being folded into Personal — unclassified mail is missing work, not a decision
+ * (issue #45). Starred mail is not a section — the star is a per-row marker, so
+ * a starred message stays in its category.
+ *
+ * Sender trust (vip/wellknown) no longer sections the brief — the signal is
+ * still carried on each row (see `toThreadRowData`) for future use, but it does
+ * not decide where a row lands. Read state is likewise not a routing signal: in
+ * a high-volume mailbox read≠handled and unread≠important; unread is a
+ * user-selectable filter chip instead.
+ *
+ * Muted senders and categories the scope holds none of are excluded. Mute is
+ * `muted=false` on each section's request, so the rows and the count answer the
+ * same predicate — dropping muted rows here instead left a header stating a
+ * number larger than the list under it, and a "Show all" that opened mail the
+ * brief would not render (#1137).
+ */
+import { CATEGORY_SECTION_ORDER, categoryLabels, } from "@remit/ui";
+import { toDisplayCategory } from "./display-category.js";
+import { formatEmailDate } from "./format.js";
+import { rowSettlement } from "./row-settlement.js";
+/**
+ * Map a `RemitImapThreadMessageResponse` to the `ThreadRowData` shape used by
+ * remit-ui row body components. Mirrors the logic in MessageListItem so the
+ * brief rows render identically to per-mailbox rows.
+ */
+export function toThreadRowData(thread) {
+    const suspicious = thread.authenticity?.dkimMismatch === true;
+    return {
+        id: thread.messageId,
+        accountId: thread.accountId,
+        mailboxId: thread.mailboxId,
+        threadId: thread.threadId,
+        fromName: thread.fromName ?? thread.fromEmail ?? "Unknown",
+        fromEmail: thread.fromEmail ?? "",
+        subject: thread.subject ?? "(No subject)",
+        snippet: thread.snippet ?? "",
+        timeLabel: formatEmailDate(thread.sentDate),
+        sentDate: thread.sentDate,
+        isRead: thread.isRead,
+        hasAttachment: thread.hasAttachment,
+        starred: thread.hasStars === true,
+        trust: thread.senderTrust,
+        category: toDisplayCategory(thread.category),
+        suspicious,
+        ...rowSettlement(thread),
+    };
+}
+/**
+ * The categories the brief asks for, in the order it renders them. A category
+ * is both the section's own scope and the query parameter its request carries;
+ * the order and the label come from the kit's category table.
+ */
+export const BRIEF_CATEGORIES = CATEGORY_SECTION_ORDER;
+/**
+ * The per-category server answers as brief sections, in display order.
+ *
+ * A regrouping of complete responses, never of a page: each result already is
+ * its whole category as far as the request was concerned, so no further page can
+ * move a section's membership or its total.
+ *
+ * A category the scope holds none of has no section — a header stating zero is
+ * noise, not information. A category still being fetched, or whose own request
+ * failed, keeps its section so the loading and error treatments have somewhere
+ * to render, and a category with a real total keeps its section even with no
+ * rows left after the chips, so the reader sees which filter emptied it.
+ */
+export function briefSections(results) {
+    const byCategory = new Map(results.map((result) => [result.category, result]));
+    const sections = [];
+    for (const category of BRIEF_CATEGORIES) {
+        const result = byCategory.get(category);
+        if (!result)
+            continue;
+        const holdsMail = result.loading ||
+            result.failed ||
+            result.rows.length > 0 ||
+            (result.total.kind === "exact" && result.total.value > 0);
+        if (!holdsMail)
+            continue;
+        sections.push({
+            id: category,
+            label: categoryLabels[category],
+            threads: result.rows,
+            total: result.total,
+            atCap: result.atCap,
+            loading: result.loading,
+            error: result.failed,
+        });
+    }
+    return sections;
+}
+/**
+ * Returns true when `t` satisfies every token handed to it.
+ *
+ * The residue applier: callers pass the tokens their request could not carry —
+ * `threadSearchTokens` decides which those are by reading the request back — and
+ * this narrows the rows that came back by them. A token the request did carry
+ * must not be passed here; the server already answered it over the whole scope,
+ * and re-answering it over one page is how a criterion ends up meaning "among
+ * the rows fetched so far" (#312).
+ *
+ * Every token is implemented so that a request carrying fewer parameters still
+ * has somewhere to put the rest: no endpoint has `before:`, `after:`, `in:` or
+ * `account:` in the set these tokens are split against, and each takes one
+ * `from` and one `subject`, so a second of either — or one a chip overruled —
+ * lands here. A row without the data a token needs (no `sentDate` for
+ * `before:`/`after:`) never matches it, so it drops out rather than showing
+ * under an unverifiable filter.
+ */
+export function matchesSearchTokens(t, tokens) {
+    return tokens.every((token) => {
+        switch (token.type) {
+            case "from": {
+                const needle = token.value.toLowerCase();
+                return (t.fromEmail.toLowerCase().includes(needle) ||
+                    t.fromName.toLowerCase().includes(needle));
+            }
+            case "subject":
+                return t.subject.toLowerCase().includes(token.value.toLowerCase());
+            // A row with no category is `uncategorized` — the pending state has a
+            // name (issue #45), so `category:unclassified` finds it.
+            case "category":
+                return (t.category ?? "uncategorized") === token.category;
+            case "hasAttachment":
+                return t.hasAttachment === true;
+            case "isUnread":
+                return !t.isRead;
+            case "isRead":
+                return t.isRead === true;
+            case "isStarred":
+                return t.starred === true;
+            case "after":
+                return t.sentDate != null && t.sentDate >= token.epochSeconds * 1000;
+            case "before":
+                return t.sentDate != null && t.sentDate < token.epochSeconds * 1000;
+            case "in":
+                return t.mailboxId === token.mailboxId;
+            case "account":
+                return t.accountId === token.accountId;
+            default:
+                return false;
+        }
+    });
+}

package/dist/src/lib/bug-report.d.ts

@@ -0,0 +1,67 @@
+import type { QuarantineReportSections } from "@remit/ui";
+import { type RequestBreadcrumb } from "./request-breadcrumbs";
+import { type RouteBreadcrumb } from "./route-breadcrumbs";
+export interface BugReportContext {
+    appShortSha: string;
+    /** Commit URL for the build, or undefined for a local "dev" build (no link). */
+    appCommitUrl?: string;
+    appBuildTime: string;
+    userAgent: string;
+    viewport: string;
+    timestamp: string;
+    timezone: string;
+    href: string;
+    recentErrors: readonly string[];
+    /** Recent API calls, metadata only — method/path/status/duration/correlation. */
+    requests: readonly RequestBreadcrumb[];
+    /** Recent in-app navigations, oldest first. */
+    routes: readonly RouteBreadcrumb[];
+    /** The request that most likely triggered the report (transport or >= 400). */
+    failingRequest?: RequestBreadcrumb;
+    /** The message of the error that triggered the report, when seeded from one. */
+    errorMessage?: string;
+    /** The error's stacktrace, when available. */
+    stack?: string;
+    /** React component stack from the error boundary, when available. */
+    componentStack?: string;
+    /**
+     * A quarantined message's diagnostics, when the report is filed from the
+     * quarantine surface. Split into sections by `quarantineReportSections` in
+     * @remit/ui so the MIME tree is fenced after truncation, never before.
+     */
+    quarantine?: QuarantineReportSections;
+    syncWarning?: string;
+    /** Overrides the derived title, e.g. for a quarantine report. */
+    title?: string;
+}
+/** Fields callers can seed from a caught error. */
+export interface BugReportSeed {
+    errorMessage?: string;
+    stack?: string;
+    componentStack?: string;
+    quarantine?: QuarantineReportSections;
+    syncWarning?: string;
+    /** Overrides the derived title, e.g. for a quarantine report. */
+    title?: string;
+}
+export declare function buildBugReportContext(seed?: BugReportSeed): BugReportContext;
+/**
+ * The full, untruncated report — every field including the complete stacktrace
+ * and component stack. Backs the overlay's "Copy full details" action so
+ * nothing is lost when the URL-bound report has to truncate the stack.
+ */
+export declare function buildBugReportDetails(ctx: BugReportContext): string;
+/**
+ * Build a prefilled GitHub new-issue URL. When the full body would exceed the
+ * URL budget, the longest truncatable section — a stacktrace, or a quarantine
+ * report's MIME tree — is binary-searched to the longest prefix that fits and
+ * marked; everything else is preserved. The component stack is dropped from
+ * the URL when truncation kicks in — it survives in the copy-details report.
+ *
+ * The quarantine MIME tree is handed over unfenced and fenced by
+ * `buildIssueBody` afterwards, so a cut can never land inside a code fence.
+ * The disclaimer is appended by the builder rather than carried in the
+ * truncated text, so a truncated report still states what was withheld.
+ */
+export declare function buildGitHubIssueUrl(ctx: BugReportContext): string;
+export declare function openBugReport(): void;

package/dist/src/lib/bug-report.js

@@ -0,0 +1,212 @@
+import { getRuntimeConfig } from "../runtime-config";
+import { APP_BUILD_TIME, APP_SHORT_SHA, GITHUB_COMMIT_URL } from "./app-info";
+import { getRecentErrors } from "./console-errors";
+import { getFailingRequest, getRecentRequests, } from "./request-breadcrumbs";
+import { getRecentRoutes } from "./route-breadcrumbs";
+/**
+ * A GitHub new-issue URL is capped (~8 KB). We budget below that so the stack
+ * is truncated to fit rather than producing a URL GitHub silently rejects. The
+ * untruncated report is always available via `buildBugReportDetails` (the
+ * overlay's "Copy full details" action).
+ */
+const MAX_ISSUE_URL_LENGTH = 7500;
+const TRUNCATION_MARKER = "\n… (truncated — the copy action on this screen has the full report)";
+export function buildBugReportContext(seed) {
+    return {
+        appShortSha: APP_SHORT_SHA,
+        appCommitUrl: GITHUB_COMMIT_URL,
+        appBuildTime: APP_BUILD_TIME,
+        userAgent: navigator.userAgent,
+        viewport: `${window.innerWidth}×${window.innerHeight}`,
+        timestamp: new Date().toISOString(),
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        href: window.location.href,
+        recentErrors: getRecentErrors(),
+        requests: getRecentRequests(),
+        routes: getRecentRoutes(),
+        failingRequest: getFailingRequest(),
+        errorMessage: seed?.errorMessage,
+        stack: seed?.stack,
+        componentStack: seed?.componentStack,
+        quarantine: seed?.quarantine,
+        syncWarning: seed?.syncWarning,
+        title: seed?.title,
+    };
+}
+function fencedBlock(content) {
+    return ["```", content, "```"].join("\n");
+}
+/** `2024-06-12T08:00:01.234Z` → `08:00:01` — the wall-clock time, compact. */
+function clockTime(iso) {
+    const match = /T(\d{2}:\d{2}:\d{2})/.exec(iso);
+    return match ? match[1] : iso;
+}
+function versionLine(ctx) {
+    const version = ctx.appCommitUrl
+        ? `[\`${ctx.appShortSha}\`](${ctx.appCommitUrl})`
+        : `\`${ctx.appShortSha}\``;
+    return `- **Version**: ${version} built ${ctx.appBuildTime}`;
+}
+function failingRequestSection(request) {
+    const status = request.status === 0
+        ? "no response (transport failure)"
+        : `${request.status}`;
+    return [
+        "## Failing request",
+        `- **Endpoint**: \`${request.path}\``,
+        `- **Method**: ${request.method}`,
+        `- **Status**: ${status}`,
+        `- **Correlation id**: ${request.correlationId ?? "(none)"}`,
+        "",
+    ];
+}
+function requestsSection(requests) {
+    if (requests.length === 0) {
+        return ["## Recent API requests", "(none)", ""];
+    }
+    const rows = requests.map((r) => {
+        const status = r.status === 0 ? "ERR" : `${r.status}`;
+        return `| ${clockTime(r.timestamp)} | ${r.method} | \`${r.path}\` | ${status} | ${r.durationMs}ms | ${r.correlationId ?? ""} |`;
+    });
+    return [
+        "## Recent API requests",
+        "| Time | Method | Path | Status | Duration | Correlation |",
+        "| --- | --- | --- | --- | --- | --- |",
+        ...rows,
+        "",
+    ];
+}
+function navigationSection(routes) {
+    if (routes.length === 0) {
+        return ["## Navigation trail", "(none)", ""];
+    }
+    const rows = routes.map((r) => `- ${clockTime(r.timestamp)} \`${r.path}\``);
+    return ["## Navigation trail", ...rows, ""];
+}
+function buildIssueBody(ctx, overrides) {
+    const errorSection = ctx.recentErrors.length > 0
+        ? ctx.recentErrors.map((e) => `  - ${e}`).join("\n")
+        : "  (none)";
+    const lines = [
+        "## Environment",
+        versionLine(ctx),
+        `- **Browser**: ${ctx.userAgent}`,
+        `- **Viewport**: ${ctx.viewport}`,
+        `- **Time**: ${ctx.timestamp} (${ctx.timezone})`,
+        "",
+        "## URL",
+        ctx.href,
+        "",
+    ];
+    if (ctx.errorMessage) {
+        lines.push("## Error", ctx.errorMessage, "");
+    }
+    if (ctx.failingRequest) {
+        lines.push(...failingRequestSection(ctx.failingRequest));
+    }
+    if (ctx.quarantine) {
+        const structure = overrides?.quarantineStructure ?? ctx.quarantine.structure;
+        lines.push(ctx.quarantine.head, "", fencedBlock(structure), "", ctx.quarantine.disclaimer, "");
+    }
+    if (ctx.syncWarning) {
+        lines.push(ctx.syncWarning, "");
+    }
+    const resolvedStack = overrides?.stack ?? ctx.stack;
+    if (resolvedStack) {
+        lines.push("## Stacktrace", fencedBlock(resolvedStack), "");
+    }
+    if (ctx.componentStack) {
+        lines.push("## Component stack", fencedBlock(ctx.componentStack), "");
+    }
+    lines.push(...requestsSection(ctx.requests));
+    lines.push(...navigationSection(ctx.routes));
+    lines.push("## Recent console errors", errorSection, "", "## Steps to reproduce", "1. ", "", "## Expected behaviour", "", "## Actual behaviour", "");
+    return lines.join("\n");
+}
+function buildIssueTitle(ctx) {
+    if (ctx.title)
+        return ctx.title;
+    if (!ctx.errorMessage)
+        return "Bug: ";
+    const firstLine = ctx.errorMessage.split("\n")[0].trim();
+    const clipped = firstLine.length > 120 ? `${firstLine.slice(0, 117)}…` : firstLine;
+    return `Bug: ${clipped}`;
+}
+function issueUrl(ctx, overrides) {
+    const params = new URLSearchParams({
+        title: buildIssueTitle(ctx),
+        body: buildIssueBody(ctx, overrides),
+    });
+    return `${getRuntimeConfig().issuesUrl}?${params.toString()}`;
+}
+/**
+ * The full, untruncated report — every field including the complete stacktrace
+ * and component stack. Backs the overlay's "Copy full details" action so
+ * nothing is lost when the URL-bound report has to truncate the stack.
+ */
+export function buildBugReportDetails(ctx) {
+    return buildIssueBody(ctx);
+}
+/**
+ * Build a prefilled GitHub new-issue URL. When the full body would exceed the
+ * URL budget, the longest truncatable section — a stacktrace, or a quarantine
+ * report's MIME tree — is binary-searched to the longest prefix that fits and
+ * marked; everything else is preserved. The component stack is dropped from
+ * the URL when truncation kicks in — it survives in the copy-details report.
+ *
+ * The quarantine MIME tree is handed over unfenced and fenced by
+ * `buildIssueBody` afterwards, so a cut can never land inside a code fence.
+ * The disclaimer is appended by the builder rather than carried in the
+ * truncated text, so a truncated report still states what was withheld.
+ */
+export function buildGitHubIssueUrl(ctx) {
+    const full = issueUrl(ctx);
+    if (full.length <= MAX_ISSUE_URL_LENGTH)
+        return full;
+    const withoutComponentStack = {
+        ...ctx,
+        componentStack: undefined,
+    };
+    // Both sections can be present — a seed is not discriminated — and cutting
+    // one to nothing does not necessarily fit the other. Truncate the longest
+    // first and keep going while the budget is still exceeded.
+    const sections = [];
+    if (ctx.stack)
+        sections.push(["stack", ctx.stack]);
+    if (ctx.quarantine?.structure) {
+        sections.push(["quarantineStructure", ctx.quarantine.structure]);
+    }
+    sections.sort((a, b) => b[1].length - a[1].length);
+    let overrides = {};
+    for (const [field, text] of sections) {
+        if (issueUrl(withoutComponentStack, overrides).length <= MAX_ISSUE_URL_LENGTH) {
+            break;
+        }
+        let lo = 0;
+        let hi = text.length;
+        let best = 0;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            const candidate = issueUrl(withoutComponentStack, {
+                ...overrides,
+                [field]: text.slice(0, mid) + TRUNCATION_MARKER,
+            });
+            if (candidate.length <= MAX_ISSUE_URL_LENGTH) {
+                best = mid;
+                lo = mid + 1;
+            }
+            else {
+                hi = mid - 1;
+            }
+        }
+        overrides = {
+            ...overrides,
+            [field]: text.slice(0, best) + TRUNCATION_MARKER,
+        };
+    }
+    return issueUrl(withoutComponentStack, overrides);
+}
+export function openBugReport() {
+    const url = buildGitHubIssueUrl(buildBugReportContext());
+    window.open(url, "_blank", "noopener,noreferrer");
+}

package/dist/src/lib/bulk-action-copy.d.ts

@@ -0,0 +1,67 @@
+import type { ErrorBannerSeverity } from "@remit/ui";
+import type { BulkRunOutcome } from "./bulk-actions";
+import { type DeleteOutcome } from "./format";
+/** A run ending, as the list banners it. */
+export interface RunEndingBanner {
+    severity: ErrorBannerSeverity;
+    title: string;
+    detail?: string;
+}
+/**
+ * Wording for the three bulk actions a selection can run (#114). One place
+ * per sentence the selection bar, the completion banner and the error banner
+ * can say, so a new action is a row in these tables rather than a branch in
+ * every caller.
+ */
+export type BulkActionKind = "delete" | "move" | "markRead";
+/** Running status while a chunked or escalated run is in flight. */
+export declare const bulkActionProgressLabel: (kind: BulkActionKind, done: number, total: number) => string;
+/**
+ * Shown once a run finishes with nothing left over. The second sentence is
+ * the honest part: the bulk endpoints enqueue the IMAP write, so the mail
+ * server is still applying it when this appears.
+ *
+ * A delete inside Trash expunges rather than moves (#855), so the run that just
+ * finished is named by its outcome — telling a reader their mail is "moved to
+ * Trash" after it was erased is the same lie the confirmation stopped telling,
+ * one screen later.
+ */
+export declare const bulkActionCompletionText: (kind: BulkActionKind, done: number, outcome?: DeleteOutcome) => string;
+/**
+ * Shown when a run ended before it covered what it was started against. The
+ * remainder was never sent, so that mail is where it was and only the user can
+ * decide to run it again — which is why this is stated rather than left to a
+ * list that quietly stops changing. Stopping aborts the request already on the
+ * wire rather than un-sending it (#113), so what the copy can promise about the
+ * remainder stops short of the batch that was in flight.
+ */
+export declare const bulkActionStoppedTitle: (done: number) => string;
+export declare const bulkActionStoppedDetail: (kind: BulkActionKind, done: number, total: number, outcome?: DeleteOutcome) => string;
+/** Error-banner title for a run stopped by an infrastructure failure. */
+export declare const bulkActionFailureTitle: (kind: BulkActionKind, done: number) => string;
+export declare const bulkActionFailureDetail: (kind: BulkActionKind) => string;
+/**
+ * The commit that could not start, because the one still going owns the bar and
+ * the Stop it would need. It names the run in flight and where it is, so the
+ * user knows which screen to end it from rather than pressing a commit that
+ * silently does nothing.
+ */
+export declare const bulkRunBusyRefusal: (kind: BulkActionKind, matched: number, mailboxLabel: string | undefined) => string;
+/** Progress-bar tone: only delete is destructive. */
+export declare const bulkActionProgressTone: (kind: BulkActionKind) => "danger" | "info";
+/**
+ * How a run that has already ended is announced, or `null` when it announces
+ * itself elsewhere.
+ *
+ * The run screen invites the user to close it and keeps going past that, so by
+ * the time a run ends there is often no screen of its own left to say how it
+ * went (#521) — the list says it instead. Three endings, and they are not the
+ * same news: a run stopped short is a warning, because mail the user asked to
+ * be acted on was left untouched; a run that covered everything is a passing
+ * note; and a run stopped by a thrown batch already bannered where it threw, so
+ * saying it twice is the one wrong answer.
+ *
+ * Pure, so the severity of each ending is pinned by its result rather than by
+ * the shape of the caller that produces it.
+ */
+export declare const runEndingBanner: (kind: BulkActionKind, matched: number, outcome: BulkRunOutcome, deleteOutcome: DeleteOutcome) => RunEndingBanner | null;

package/dist/src/lib/bulk-action-copy.js

@@ -0,0 +1,106 @@
+import { deleteExpunges, formatNumber } from "./format";
+const progressPhrase = {
+    delete: (done, total) => `Deleting ${done} of ${total}…`,
+    move: (done, total) => `Moving ${done} of ${total}…`,
+    markRead: (done, total) => `Marking ${done} of ${total} as read…`,
+};
+const pastTense = {
+    delete: "moved to Trash",
+    move: "moved",
+    markRead: "marked as read",
+};
+/**
+ * What the run did, in the past tense. A delete inside Trash expunges rather
+ * than moves (#855), and that holds for a run that stopped halfway exactly as
+ * it does for one that finished — the half that ran is still erased.
+ */
+const pastTenseFor = (kind, outcome) => kind === "delete" && deleteExpunges(outcome)
+    ? "permanently deleted"
+    : pastTense[kind];
+const negated = {
+    delete: "couldn't be deleted",
+    move: "couldn't be moved",
+    markRead: "couldn't be marked as read",
+};
+const failureTitle = {
+    delete: "Couldn't delete these messages",
+    move: "Couldn't move these messages",
+    markRead: "Couldn't mark these messages as read",
+};
+const failureDetail = {
+    delete: "The delete didn't finish.",
+    move: "The move didn't finish.",
+    markRead: "The update didn't finish.",
+};
+/** Running status while a chunked or escalated run is in flight. */
+export const bulkActionProgressLabel = (kind, done, total) => progressPhrase[kind](formatNumber(done), formatNumber(total));
+/**
+ * Shown once a run finishes with nothing left over. The second sentence is
+ * the honest part: the bulk endpoints enqueue the IMAP write, so the mail
+ * server is still applying it when this appears.
+ *
+ * A delete inside Trash expunges rather than moves (#855), so the run that just
+ * finished is named by its outcome — telling a reader their mail is "moved to
+ * Trash" after it was erased is the same lie the confirmation stopped telling,
+ * one screen later.
+ */
+export const bulkActionCompletionText = (kind, done, outcome = "trash") => `${formatNumber(done)} ${pastTenseFor(kind, outcome)}. Your mail server is still catching up.`;
+/**
+ * Shown when a run ended before it covered what it was started against. The
+ * remainder was never sent, so that mail is where it was and only the user can
+ * decide to run it again — which is why this is stated rather than left to a
+ * list that quietly stops changing. Stopping aborts the request already on the
+ * wire rather than un-sending it (#113), so what the copy can promise about the
+ * remainder stops short of the batch that was in flight.
+ */
+export const bulkActionStoppedTitle = (done) => `Stopped after ${formatNumber(done)}`;
+export const bulkActionStoppedDetail = (kind, done, total, outcome = "trash") => `${formatNumber(done)} of ${formatNumber(total)} ${pastTenseFor(kind, outcome)}. The rest were not sent, apart from the ones already on their way when you stopped — those may still have gone through.`;
+/** Error-banner title for a run stopped by an infrastructure failure. */
+export const bulkActionFailureTitle = (kind, done) => done > 0
+    ? `Stopped after ${formatNumber(done)} — some messages ${negated[kind]}`
+    : failureTitle[kind];
+export const bulkActionFailureDetail = (kind) => failureDetail[kind];
+const busyPhrase = {
+    delete: (count) => `A delete of ${count} messages`,
+    move: (count) => `A move of ${count} messages`,
+    markRead: (count) => `Marking ${count} messages as read`,
+};
+/**
+ * The commit that could not start, because the one still going owns the bar and
+ * the Stop it would need. It names the run in flight and where it is, so the
+ * user knows which screen to end it from rather than pressing a commit that
+ * silently does nothing.
+ */
+export const bulkRunBusyRefusal = (kind, matched, mailboxLabel) => `${busyPhrase[kind](formatNumber(matched))}${mailboxLabel ? ` in ${mailboxLabel}` : ""} is still running — stop it first.`;
+/** Progress-bar tone: only delete is destructive. */
+export const bulkActionProgressTone = (kind) => (kind === "delete" ? "danger" : "info");
+/**
+ * How a run that has already ended is announced, or `null` when it announces
+ * itself elsewhere.
+ *
+ * The run screen invites the user to close it and keeps going past that, so by
+ * the time a run ends there is often no screen of its own left to say how it
+ * went (#521) — the list says it instead. Three endings, and they are not the
+ * same news: a run stopped short is a warning, because mail the user asked to
+ * be acted on was left untouched; a run that covered everything is a passing
+ * note; and a run stopped by a thrown batch already bannered where it threw, so
+ * saying it twice is the one wrong answer.
+ *
+ * Pure, so the severity of each ending is pinned by its result rather than by
+ * the shape of the caller that produces it.
+ */
+export const runEndingBanner = (kind, matched, outcome, deleteOutcome) => {
+    if (outcome.error !== undefined)
+        return null;
+    if (outcome.cancelled) {
+        return {
+            severity: "warning",
+            title: bulkActionStoppedTitle(outcome.done),
+            detail: bulkActionStoppedDetail(kind, outcome.done, matched, deleteOutcome),
+        };
+    }
+    return {
+        severity: "info",
+        title: bulkActionCompletionText(kind, outcome.done, deleteOutcome),
+    };
+};