@remit/web-client 0.0.324 → 0.0.326

package/dist/src/components/settings/account-form-helpers.js

@@ -0,0 +1,78 @@
+/**
+ * Default SMTP defaults applied when auto-filling from IMAP at save time.
+ *
+ * STARTTLS on port 587 is the standard for almost every provider that
+ * exposes both IMAP and SMTP under the same domain (Gmail, Fastmail,
+ * Outlook, generic IMAP+SMTP hosts). Users with a different setup can
+ * still override before saving — auto-fill never overwrites a value the
+ * user already typed.
+ */
+const DEFAULT_SMTP_PORT = 587;
+const DEFAULT_SMTP_TLS = false;
+const DEFAULT_SMTP_STARTTLS = true;
+/**
+ * Derive an SMTP hostname from an IMAP hostname using the convention
+ * `imap.example.com` -> `smtp.example.com`. If the host does not start
+ * with the `imap.` prefix it is returned as-is so the caller can decide
+ * whether to use it.
+ */
+export const deriveSmtpHostFromImap = (imapHost) => imapHost.replace(/^imap\./i, "smtp.");
+/**
+ * Compute the SMTP fields that should replace the user's current values
+ * when the SMTP host is blank but IMAP is filled. Returns `null` when
+ * no auto-fill should happen — either because the user already provided
+ * an SMTP host (we never overwrite explicit input) or because IMAP is
+ * also blank (nothing to derive from).
+ */
+export const computeSmtpAutoFill = (values) => {
+    const smtpHostTrimmed = values.smtpHost?.trim() ?? "";
+    if (smtpHostTrimmed.length > 0)
+        return null;
+    const imapHostTrimmed = values.imapHost.trim();
+    if (imapHostTrimmed.length === 0)
+        return null;
+    return {
+        smtpHost: deriveSmtpHostFromImap(imapHostTrimmed),
+        smtpPort: DEFAULT_SMTP_PORT,
+        smtpTls: DEFAULT_SMTP_TLS,
+        smtpStartTls: DEFAULT_SMTP_STARTTLS,
+    };
+};
+/**
+ * `true` when a connection-test error message reads as an authentication
+ * failure rather than a network/configuration problem. Mirrors the
+ * keyword detection in the onboarding wizard so both surfaces agree on
+ * what counts as "wrong credentials".
+ */
+export const isAuthError = (message) => {
+    const m = message?.toLowerCase() ?? "";
+    return (m.includes("auth") ||
+        m.includes("login") ||
+        m.includes("535") ||
+        m.includes("credential"));
+};
+/**
+ * Append the per-provider app-password hint to an auth-failure error.
+ * Preset providers reject the normal account password, which surfaces as
+ * "wrong password"; the hint tells the user they need an app password.
+ * Returns the original message unchanged when it is not an auth error.
+ */
+export const appendAppPasswordHint = (message, hint) => {
+    if (!message)
+        return message;
+    if (!hint)
+        return message;
+    if (!isAuthError(message))
+        return message;
+    return `${message} — ${hint}`;
+};
+/**
+ * `true` when an account row should display the "Can't send mail —
+ * configure SMTP" warning. RFC 032 Tier 2: send capability is the explicit
+ * `smtpEnabled` marker, not inferred from `smtpHost` presence. Rows written
+ * before this field existed coalesce to `false` (treated as missing), so
+ * legacy accounts surface the same affordance as new ones.
+ */
+export const accountIsMissingSmtp = (account) => {
+    return account.smtpEnabled !== true;
+};

package/dist/src/components/ui/AppVersion.d.ts

@@ -0,0 +1,12 @@
+export interface AppVersionProps {
+    /** Override SHA for testing/Storybook. Defaults to the build-time constant. */
+    sha?: string;
+    /**
+     * Override commit URL. Defaults to the GitHub commit link, which is undefined
+     * for a local "dev" build with no real SHA — the version renders unlinked then.
+     */
+    commitUrl?: string;
+    /** Override build time ISO string. Defaults to the build-time constant. */
+    buildTime?: string;
+}
+export declare function AppVersion({ sha, commitUrl, buildTime, }: AppVersionProps): import("react").JSX.Element;

package/dist/src/components/ui/AppVersion.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { APP_BUILD_TIME, APP_SHORT_SHA, GITHUB_COMMIT_URL, } from "../../lib/app-info";
+function formatBuildTime(iso) {
+    try {
+        return new Date(iso).toLocaleString(undefined, {
+            year: "numeric",
+            month: "short",
+            day: "numeric",
+            hour: "2-digit",
+            minute: "2-digit",
+        });
+    }
+    catch {
+        return iso;
+    }
+}
+export function AppVersion({ sha = APP_SHORT_SHA, commitUrl = GITHUB_COMMIT_URL, buildTime = APP_BUILD_TIME, }) {
+    return (_jsxs("p", { className: "text-xs text-fg-subtle", children: ["Version", " ", commitUrl ? (_jsx("a", { href: commitUrl, target: "_blank", rel: "noopener noreferrer", className: "font-mono hover:text-fg-muted hover:underline", children: sha })) : (_jsx("span", { className: "font-mono", children: sha })), " · ", _jsxs("span", { children: ["Built ", formatBuildTime(buildTime)] })] }));
+}

package/dist/src/components/ui/BugReportButton.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The mobile drawer's bug-report row — a full-width labeled control beside
+ * Settings, where an icon-only button would be unreachable and ambiguous
+ * (#685). Above the drawer, the shell's top bar carries this action.
+ */
+export declare function BugReportButton(): import("react").JSX.Element;

package/dist/src/components/ui/BugReportButton.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Bug } from "lucide-react";
+import { openBugReport } from "../../lib/bug-report";
+/**
+ * The mobile drawer's bug-report row — a full-width labeled control beside
+ * Settings, where an icon-only button would be unreachable and ambiguous
+ * (#685). Above the drawer, the shell's top bar carries this action.
+ */
+export function BugReportButton() {
+    return (_jsxs("button", { type: "button", onClick: openBugReport, className: "flex w-full items-center gap-2 rounded-md px-2 py-1 text-sm text-fg-muted transition-colors hover:bg-surface hover:text-fg", children: [_jsx(Bug, { className: "size-4 shrink-0" }), _jsx("span", { className: "flex-1 truncate text-left", children: "Report a bug" })] }));
+}

package/dist/src/components/ui/ErrorBannerProvider.d.ts

@@ -0,0 +1,27 @@
+import { type ErrorBannerAction, type ErrorBannerEntry } from "@remit/ui";
+import { type ReactNode } from "react";
+import { type PushErrorInput } from "./error-banners.js";
+interface ErrorBannerContextValue {
+    errors: ErrorBannerEntry[];
+    pushError: (input: PushErrorInput) => string;
+    dismissError: (id: string) => void;
+    clearAll: () => void;
+}
+/**
+ * A way out of every failure banner. A soft failure is still a failure the
+ * user could not prevent and cannot diagnose, and a banner offering only
+ * "Dismiss" is a dead end — the fatal screen has carried a prefilled report
+ * since issue #55 and the soft surface never did. The report is seeded from
+ * the banner it belongs to, so it names the failure instead of asking the
+ * user to describe it, and it carries the same breadcrumbs — failing request,
+ * navigation, console — the fatal report does.
+ *
+ * A caller that already has a better way out keeps it, and a warning or an
+ * informational banner gets none: those are not failures to report.
+ */
+export declare const bannerWayOut: (input: PushErrorInput) => ErrorBannerAction | undefined;
+export declare const ErrorBannerProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react").JSX.Element;
+export declare const useErrorBanners: () => ErrorBannerContextValue;
+export {};

package/dist/src/components/ui/ErrorBannerProvider.js

@@ -0,0 +1,82 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ErrorBannerStack, } from "@remit/ui";
+import { createContext, useCallback, useContext, useMemo, useState, } from "react";
+import { buildBugReportContext, buildGitHubIssueUrl, } from "../../lib/bug-report";
+import { isAlwaysFatal } from "../../lib/error-classifier";
+import { reportFatalError } from "../../lib/fatal-error";
+import { appendBanner, buildEntry, dismissBanner, } from "./error-banners.js";
+const ErrorBannerContext = createContext(undefined);
+/**
+ * A way out of every failure banner. A soft failure is still a failure the
+ * user could not prevent and cannot diagnose, and a banner offering only
+ * "Dismiss" is a dead end — the fatal screen has carried a prefilled report
+ * since issue #55 and the soft surface never did. The report is seeded from
+ * the banner it belongs to, so it names the failure instead of asking the
+ * user to describe it, and it carries the same breadcrumbs — failing request,
+ * navigation, console — the fatal report does.
+ *
+ * A caller that already has a better way out keeps it, and a warning or an
+ * informational banner gets none: those are not failures to report.
+ */
+export const bannerWayOut = (input) => {
+    if (input.action)
+        return input.action;
+    if ((input.severity ?? "error") !== "error")
+        return undefined;
+    return {
+        label: "Report an issue",
+        href: buildGitHubIssueUrl(buildBugReportContext({
+            title: `Bug: ${input.title}`,
+            errorMessage: input.detail
+                ? `${input.title} — ${input.detail}`
+                : input.title,
+            stack: input.error instanceof Error ? input.error.stack : undefined,
+        })),
+    };
+};
+const generateId = () => {
+    if (typeof globalThis.crypto !== "undefined" &&
+        typeof globalThis.crypto.randomUUID === "function") {
+        return globalThis.crypto.randomUUID();
+    }
+    return `banner-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+};
+export const ErrorBannerProvider = ({ children }) => {
+    const [errors, setErrors] = useState([]);
+    /**
+     * Show a soft, dismissible banner — and only that. A fatal error is not a
+     * notification: when the caller hands us a 5xx or an exception from our own
+     * code, it goes to the fatal seam instead, so the user gets the full-screen
+     * page with a way forward and a bug report rather than a toast they can only
+     * dismiss (issue #55). Those two classes are fatal with no opt-out; anything
+     * a call site can legitimately own — a 404 empty state, a 4xx the user can
+     * act on — still banners here.
+     *
+     * The guard is on the error being present, not on the key being present:
+     * `error` is optional, so a caller forwarding one it does not have passes
+     * `undefined`, and "no error at all" must not be classified as a bug.
+     */
+    const pushError = useCallback((input) => {
+        if (input.error != null && isAlwaysFatal(input.error)) {
+            return reportFatalError(input.error).correlationId;
+        }
+        const entry = buildEntry({ ...input, action: bannerWayOut(input) }, generateId(), Date.now());
+        setErrors((current) => appendBanner(current, entry));
+        return entry.id;
+    }, []);
+    const dismissError = useCallback((id) => {
+        setErrors((current) => dismissBanner(current, id));
+    }, []);
+    const clearAll = useCallback(() => {
+        setErrors([]);
+    }, []);
+    const value = useMemo(() => ({ errors, pushError, dismissError, clearAll }), [errors, pushError, dismissError, clearAll]);
+    return (_jsxs(ErrorBannerContext.Provider, { value: value, children: [children, _jsx(ErrorBannerStack, { errors: errors, onDismiss: dismissError })] }));
+};
+export const useErrorBanners = () => {
+    const context = useContext(ErrorBannerContext);
+    if (!context) {
+        throw new Error("useErrorBanners must be used within an ErrorBannerProvider");
+    }
+    return context;
+};

package/dist/src/components/ui/FatalErrorOverlay.d.ts

@@ -0,0 +1,31 @@
+import { type FatalError } from "../../lib/fatal-error";
+/**
+ * The full-screen red escalation page. A first-party fatal — an escalated 5xx,
+ * or a render exception caught by the route error boundary — takes over the
+ * entire viewport here: loud, red, impossible to miss. Never a benign grey
+ * label.
+ *
+ * It is intentionally NOT dismissible: a fatal means the app is in an unknown
+ * state. The affordances depend on whether the error is recoverable:
+ *  - recoverable (transient 5xx / network / abort) → Retry the same action.
+ *  - fatal (deterministic render exception) → NO Retry (it re-crashes); offer a
+ *    way out to a safe route instead.
+ * Both states can Report a bug (prefilled with the stacktrace) and Copy full
+ * details.
+ */
+export declare const FatalErrorOverlay: () => import("react").JSX.Element | null;
+interface FatalErrorScreenProps {
+    fatal: FatalError;
+    /**
+     * What Retry does for a recoverable error. The route error boundary passes
+     * TanStack's `reset`; without it, Retry reloads the page. Ignored for a
+     * non-recoverable fatal (no Retry is shown).
+     */
+    onRetry?: () => void;
+}
+/**
+ * Presentational screen — exported so it can be rendered directly in tests and
+ * by the route-level error boundary without going through the subscription.
+ */
+export declare const FatalErrorScreen: ({ fatal, onRetry }: FatalErrorScreenProps) => import("react").JSX.Element;
+export {};

package/dist/src/components/ui/FatalErrorOverlay.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useOverlayScope } from "@remit/ui";
+import { AlertOctagon } from "lucide-react";
+import { useEffect, useState } from "react";
+import { buildBugReportContext, buildBugReportDetails, buildGitHubIssueUrl, } from "../../lib/bug-report";
+import { getCurrentFatalError, subscribeFatalError, } from "../../lib/fatal-error";
+/**
+ * Safe route to escape a deterministically-crashing page. It names no list, so
+ * it redirects on to the brief.
+ */
+const SAFE_ROUTE = "/mail";
+/**
+ * The full-screen red escalation page. A first-party fatal — an escalated 5xx,
+ * or a render exception caught by the route error boundary — takes over the
+ * entire viewport here: loud, red, impossible to miss. Never a benign grey
+ * label.
+ *
+ * It is intentionally NOT dismissible: a fatal means the app is in an unknown
+ * state. The affordances depend on whether the error is recoverable:
+ *  - recoverable (transient 5xx / network / abort) → Retry the same action.
+ *  - fatal (deterministic render exception) → NO Retry (it re-crashes); offer a
+ *    way out to a safe route instead.
+ * Both states can Report a bug (prefilled with the stacktrace) and Copy full
+ * details.
+ */
+export const FatalErrorOverlay = () => {
+    const [fatal, setFatal] = useState(() => getCurrentFatalError());
+    useEffect(() => subscribeFatalError(setFatal), []);
+    if (!fatal)
+        return null;
+    return _jsx(FatalErrorScreen, { fatal: fatal });
+};
+const seedFromFatal = (fatal) => ({
+    errorMessage: fatal.message,
+    stack: fatal.stack,
+    componentStack: fatal.componentStack,
+});
+/**
+ * Presentational screen — exported so it can be rendered directly in tests and
+ * by the route-level error boundary without going through the subscription.
+ */
+export const FatalErrorScreen = ({ fatal, onRetry }) => {
+    // Nothing under it is in a state to act, and there is no dismissal to offer:
+    // the screen's own controls are the only way out.
+    useOverlayScope({ id: "fatal-error", open: true });
+    const [copied, setCopied] = useState(false);
+    const handleReload = () => {
+        window.location.reload();
+    };
+    const handleRetry = () => {
+        if (onRetry) {
+            onRetry();
+            return;
+        }
+        handleReload();
+    };
+    const handleReportBug = () => {
+        const url = buildGitHubIssueUrl(buildBugReportContext(seedFromFatal(fatal)));
+        window.open(url, "_blank", "noopener,noreferrer");
+    };
+    const handleCopyDetails = async () => {
+        const details = buildBugReportDetails(buildBugReportContext(seedFromFatal(fatal)));
+        await navigator.clipboard.writeText(details);
+        setCopied(true);
+        window.setTimeout(() => setCopied(false), 2000);
+    };
+    const description = fatal.recoverable
+        ? "The server returned an unexpected error. This is not your fault — nothing was saved or sent. Retry, or report a bug so we can fix it."
+        : "Something went wrong and this page can't recover. This is not your fault — nothing was saved or sent. Go to your inbox, or report a bug so we can fix it.";
+    return (_jsxs("div", { role: "alert", "aria-live": "assertive", "data-testid": "fatal-error-overlay", className: "fixed inset-0 z-[1000] flex flex-col items-center justify-center gap-6 bg-red-700 p-6 text-center text-white", children: [_jsx(AlertOctagon, { className: "size-16 shrink-0", "aria-hidden": "true" }), _jsxs("div", { className: "max-w-lg space-y-3", children: [_jsx("h1", { className: "text-2xl font-bold tracking-tight", children: "Something broke" }), _jsx("p", { className: "text-base text-red-50", children: description }), _jsx("p", { className: "break-words font-mono text-sm text-red-100", children: fatal.message }), _jsxs("p", { className: "font-mono text-xs text-red-200", children: ["Reference: ", fatal.correlationId] })] }), _jsxs("div", { className: "flex flex-wrap items-center justify-center gap-3", children: [fatal.recoverable ? (_jsx("button", { type: "button", onClick: handleRetry, className: "inline-flex min-h-11 items-center rounded-md bg-white px-5 text-sm font-semibold text-red-700 transition-colors hover:bg-red-50", children: "Retry" })) : (_jsx("a", { href: SAFE_ROUTE, className: "inline-flex min-h-11 items-center rounded-md bg-white px-5 text-sm font-semibold text-red-700 transition-colors hover:bg-red-50", children: "Go to inbox" })), _jsx("button", { type: "button", onClick: handleReportBug, className: "inline-flex min-h-11 items-center rounded-md border border-white/70 px-5 text-sm font-semibold text-white transition-colors hover:bg-white/10", children: "Report a bug" }), _jsx("button", { type: "button", onClick: handleCopyDetails, className: "inline-flex min-h-11 items-center rounded-md border border-white/70 px-5 text-sm font-semibold text-white transition-colors hover:bg-white/10", children: copied ? "Copied" : "Copy full details" })] })] }));
+};

package/dist/src/components/ui/error-banners.d.ts

@@ -0,0 +1,43 @@
+import type { ErrorBannerAction, ErrorBannerEntry, ErrorBannerSeverity } from "@remit/ui";
+export interface PushErrorInput {
+    severity?: ErrorBannerSeverity;
+    title: string;
+    detail?: string;
+    action?: ErrorBannerAction;
+    /**
+     * The error being reported, when there is one. Pass it: a banner is a soft
+     * surface, and `pushError` uses this to refuse errors that are not soft —
+     * a 5xx or a client-side exception is escalated to the full-screen fatal
+     * page (which offers Retry, a way out, and a bug report) instead of being
+     * reduced to a dismissible toast.
+     */
+    error?: unknown;
+}
+/**
+ * Build the banner input for a mutation failure: the error's own message when
+ * it has one, otherwise a human fallback. Shared by the previously-silent
+ * mutation `onError` handlers (signature save, outbox retry/delete, draft
+ * discard) so they surface a real detail instead of nothing. A fatal 5xx is
+ * additionally escalated globally; this only governs the soft banner copy.
+ */
+export declare const buildMutationErrorBanner: (title: string, fallback: string, error: unknown) => PushErrorInput;
+export declare const formatErrorDetail: (error: unknown) => string | undefined;
+export declare const isMessageGoneFromServerError: (error: unknown) => boolean;
+/**
+ * Detect a "describeMessage hit a deleted/missing row" error.
+ *
+ * Soft-deleted ThreadMessage rows used to leak into the inbox list (#212);
+ * clicking one fired `describeMessage` against an already-hard-deleted
+ * Message and the backend's `NotFoundError` ("Message not found: <id>")
+ * surfaced verbatim. We now filter those rows server-side, but the UI still
+ * needs a graceful empty state when the cache is mid-refresh or the row
+ * was just deleted in another tab.
+ *
+ * The backend serializes 404s as `{ message: "Message not found: <id>" }`
+ * (see `packages/backend/src/error.ts`). The hey-api fetch client
+ * throws the parsed JSON body as the error, so we match by message prefix.
+ */
+export declare const isMessageNotFoundError: (error: unknown) => boolean;
+export declare const appendBanner: (current: ErrorBannerEntry[], entry: ErrorBannerEntry) => ErrorBannerEntry[];
+export declare const dismissBanner: (current: ErrorBannerEntry[], id: string) => ErrorBannerEntry[];
+export declare const buildEntry: (input: PushErrorInput, id: string, now: number) => ErrorBannerEntry;

package/dist/src/components/ui/error-banners.js

@@ -0,0 +1,69 @@
+import { codedApiErrorBody } from "../../lib/api";
+const MAX_BANNERS = 5;
+/**
+ * Build the banner input for a mutation failure: the error's own message when
+ * it has one, otherwise a human fallback. Shared by the previously-silent
+ * mutation `onError` handlers (signature save, outbox retry/delete, draft
+ * discard) so they surface a real detail instead of nothing. A fatal 5xx is
+ * additionally escalated globally; this only governs the soft banner copy.
+ */
+export const buildMutationErrorBanner = (title, fallback, error) => ({
+    title,
+    detail: formatErrorDetail(error) ?? fallback,
+    error,
+});
+export const formatErrorDetail = (error) => {
+    if (error === undefined || error === null)
+        return undefined;
+    if (error instanceof Error)
+        return error.message || undefined;
+    if (typeof error === "string")
+        return error || undefined;
+    if (typeof error === "object" &&
+        "message" in error &&
+        typeof error.message === "string") {
+        const message = error.message;
+        return message || undefined;
+    }
+    return undefined;
+};
+export const isMessageGoneFromServerError = (error) => codedApiErrorBody(error)?.code === "message_gone_from_server";
+/**
+ * Detect a "describeMessage hit a deleted/missing row" error.
+ *
+ * Soft-deleted ThreadMessage rows used to leak into the inbox list (#212);
+ * clicking one fired `describeMessage` against an already-hard-deleted
+ * Message and the backend's `NotFoundError` ("Message not found: <id>")
+ * surfaced verbatim. We now filter those rows server-side, but the UI still
+ * needs a graceful empty state when the cache is mid-refresh or the row
+ * was just deleted in another tab.
+ *
+ * The backend serializes 404s as `{ message: "Message not found: <id>" }`
+ * (see `packages/backend/src/error.ts`). The hey-api fetch client
+ * throws the parsed JSON body as the error, so we match by message prefix.
+ */
+export const isMessageNotFoundError = (error) => {
+    const detail = formatErrorDetail(error);
+    if (!detail)
+        return false;
+    return detail.startsWith("Message not found");
+};
+const sameInput = (entry, input, severity) => entry.severity === severity &&
+    entry.title === input.title &&
+    entry.detail === input.detail;
+export const appendBanner = (current, entry) => {
+    const filtered = current.filter((existing) => !sameInput(existing, { title: entry.title, detail: entry.detail, severity: entry.severity }, entry.severity));
+    const next = [...filtered, entry];
+    if (next.length <= MAX_BANNERS)
+        return next;
+    return next.slice(next.length - MAX_BANNERS);
+};
+export const dismissBanner = (current, id) => current.filter((entry) => entry.id !== id);
+export const buildEntry = (input, id, now) => ({
+    id,
+    severity: input.severity ?? "error",
+    title: input.title,
+    detail: input.detail,
+    action: input.action,
+    createdAt: now,
+});

package/dist/src/components/ui/folder-role-refusal.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The coded 409 a destructive action is refused with when the folder role it
+ * needs is unsettled (#887). Read the `code`, never the message: the copy is
+ * free to change and a message-string match would silently start opening the
+ * appointment prompt over an unrelated conflict. A 409 without one of these
+ * codes is somebody else's error and keeps today's banner.
+ */
+import type { RemitImapCanonicalMailboxRole } from "@remit/api-http-client/types.gen.ts";
+/** Why the role is unresolved, as the API's `details.reason` spells it. */
+export type FolderRoleRefusalReason = "none" | "stale" | "unconfirmed";
+/** `FolderRoleConflict`'s `details`, narrowed to the values the prompt needs. */
+export interface FolderRoleRefusal {
+    reason: FolderRoleRefusalReason;
+    role: RemitImapCanonicalMailboxRole;
+    accountId: string;
+}
+/**
+ * The refusal, or `undefined` for every other failure. Every fact the prompt
+ * needs travels with it: the account to appoint on (the delete endpoint's body
+ * carries none), the role, and the reason, which decides the framing.
+ */
+export declare const isFolderRoleRefusal: (error: unknown) => FolderRoleRefusal | undefined;
+/**
+ * The appointment write's own refusal: the mailbox is still being created or
+ * deleted on the mail server, so it cannot hold a role yet. A different
+ * sentence with a different remedy from a network failure — waiting fixes this
+ * one, retrying does not.
+ */
+export declare const isMailboxNotSettledRefusal: (error: unknown) => boolean;

package/dist/src/components/ui/folder-role-refusal.js

@@ -0,0 +1,44 @@
+import { CanonicalMailboxRole } from "@remit/domain-enums";
+import { codedApiErrorBody } from "../../lib/api";
+const REASONS = new Set([
+    "none",
+    "stale",
+    "unconfirmed",
+]);
+const ROLES = new Set(Object.values(CanonicalMailboxRole));
+const stringAt = (details, key) => {
+    const value = details?.[key];
+    return typeof value === "string" ? value : undefined;
+};
+/**
+ * The refusal, or `undefined` for every other failure. Every fact the prompt
+ * needs travels with it: the account to appoint on (the delete endpoint's body
+ * carries none), the role, and the reason, which decides the framing.
+ */
+export const isFolderRoleRefusal = (error) => {
+    const body = codedApiErrorBody(error);
+    if (body?.code !== "folder_role_unresolved")
+        return undefined;
+    const { details } = body;
+    if (!details)
+        return undefined;
+    const reason = stringAt(details, "reason");
+    const role = stringAt(details, "role");
+    const accountId = stringAt(details, "accountId");
+    if (!reason || !REASONS.has(reason))
+        return undefined;
+    if (!role || !ROLES.has(role) || !accountId)
+        return undefined;
+    return {
+        reason: reason,
+        role: role,
+        accountId,
+    };
+};
+/**
+ * The appointment write's own refusal: the mailbox is still being created or
+ * deleted on the mail server, so it cannot hold a role yet. A different
+ * sentence with a different remedy from a network failure — waiting fixes this
+ * one, retrying does not.
+ */
+export const isMailboxNotSettledRefusal = (error) => codedApiErrorBody(error)?.code === "mailbox_not_settled";

package/dist/src/components/ui/placement-refusal.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The coded 409 a delete or a move is refused with when the message's folder
+ * and uid do not name the same message (#845). Read the `code`, never the
+ * message: the server's sentence names a uuid and no remedy, and a
+ * message-string match
+ * would start firing on an unrelated conflict the moment the copy changes.
+ */
+import type { PushErrorInput } from "./error-banners";
+/**
+ * One reason, because one state produces the refusal: a mutation is still in
+ * flight and the pair clears on its own, so the copy words a wait. A mutation
+ * that gave up hands the row back to a placement the mail server confirmed
+ * before it stops (imap-mutations R3), and that row is acted on rather than
+ * refused — there is no second reason left to word.
+ */
+export type PlacementRefusalReason = "in_flight";
+export interface PlacementRefusal {
+    reason: PlacementRefusalReason;
+    messageId: string;
+}
+export declare const isPlacementRefusal: (error: unknown) => PlacementRefusal | undefined;
+/**
+ * What the user pressed. The same refusal answers a delete and a move, and the
+ * banner names the action they took rather than one they never asked for.
+ */
+export type PlacementRefusalAction = "delete" | "move";
+/**
+ * The banner copy. It says what happened and what to do, is not a dead end, and
+ * does not repeat the server's uuid at the user.
+ */
+export declare const placementRefusalBanner: (_refusal: PlacementRefusal, count: number, action: PlacementRefusalAction) => PushErrorInput;

package/dist/src/components/ui/placement-refusal.js

@@ -0,0 +1,39 @@
+/**
+ * The coded 409 a delete or a move is refused with when the message's folder
+ * and uid do not name the same message (#845). Read the `code`, never the
+ * message: the server's sentence names a uuid and no remedy, and a
+ * message-string match
+ * would start firing on an unrelated conflict the moment the copy changes.
+ */
+import { codedApiErrorBody } from "../../lib/api";
+const REASONS = new Set([
+    "in_flight",
+]);
+const stringAt = (details, key) => {
+    const value = details?.[key];
+    return typeof value === "string" ? value : undefined;
+};
+export const isPlacementRefusal = (error) => {
+    const body = codedApiErrorBody(error);
+    if (body?.code !== "message_placement_unsettled")
+        return undefined;
+    const { details } = body;
+    if (!details)
+        return undefined;
+    const reason = stringAt(details, "reason");
+    const messageId = stringAt(details, "messageId");
+    if (!reason || !REASONS.has(reason) || !messageId)
+        return undefined;
+    return { reason: reason, messageId };
+};
+/**
+ * The banner copy. It says what happened and what to do, is not a dead end, and
+ * does not repeat the server's uuid at the user.
+ */
+export const placementRefusalBanner = (_refusal, count, action) => ({
+    severity: "warning",
+    title: count > 1
+        ? `Couldn't ${action} ${count} messages yet`
+        : `Couldn't ${action} this message yet`,
+    detail: "It is still being moved on the mail server. Try again in a moment.",
+});