@remit/web-client 0.0.324 → 0.0.326

package/dist/src/lib/message-attachments.d.ts

@@ -0,0 +1,20 @@
+import type { RemitImapBodyPartResponse } from "@remit/api-http-client/types.gen.ts";
+import { type AttachmentKind } from "@remit/ui";
+/**
+ * The attachment-disposition body parts of a message, in the order the message
+ * declares them. `pickRenderablePart` (message-body-source.ts) drops exactly
+ * these parts so the renderer never treats a PDF as a body; this is the other
+ * half of that split. A forwarded message is listed whatever its disposition,
+ * and the parts inside it are its own, not the carrying message's.
+ */
+export interface MessageAttachment {
+    bodyPartId: string;
+    partPath: string;
+    kind: AttachmentKind;
+    /** Display and save name — sanitized once, used for both. */
+    filename: string;
+    typeLabel: string;
+    sizeOctets: number;
+    contentUrl: string;
+}
+export declare const selectMessageAttachments: (parts: readonly RemitImapBodyPartResponse[]) => MessageAttachment[];

package/dist/src/lib/message-attachments.js

@@ -0,0 +1,37 @@
+import { isEncapsulatedMessage, ownParts, } from "@remit/data-ports/message-parts";
+import { ContentDisposition } from "@remit/domain-enums";
+import { sanitizeAttachmentFilename } from "@remit/ui";
+const typeLabelFor = (kind, mediaSubtype) => {
+    if (kind === "message")
+        return "MESSAGE";
+    const label = mediaSubtype.toUpperCase();
+    return label === "OCTET-STREAM" ? "FILE" : label;
+};
+/**
+ * `application/pdf` → `attachment.pdf`. Only used when the sender declared no
+ * filename; a subtype with nothing alphanumeric in it yields a bare
+ * `attachment`.
+ */
+const fallbackFilenameFor = (mediaSubtype) => {
+    const extension = mediaSubtype.toLowerCase().replace(/[^a-z0-9]/g, "");
+    return extension.length > 0 ? `attachment.${extension}` : "attachment";
+};
+export const selectMessageAttachments = (parts) => ownParts(parts)
+    .filter((part) => !part.isMultipart &&
+    (part.disposition === ContentDisposition.Attachment ||
+        isEncapsulatedMessage(part)) &&
+    part.contentUrl.length > 0)
+    .map((part) => {
+    const kind = isEncapsulatedMessage(part)
+        ? "message"
+        : "file";
+    return {
+        bodyPartId: part.bodyPartId,
+        partPath: part.partPath,
+        kind,
+        filename: sanitizeAttachmentFilename(part.dispositionFilename ?? "", fallbackFilenameFor(part.mediaSubtype)),
+        typeLabel: typeLabelFor(kind, part.mediaSubtype),
+        sizeOctets: part.sizeOctets,
+        contentUrl: part.contentUrl,
+    };
+});

package/dist/src/lib/message-body-source.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pick the renderable body part from a `describeMessage` BodyPartResponse list
+ * and fetch its content via CloudFront. The legacy inlined `bodyText` /
+ * `bodyHtml` fields were removed in #224 PR 3 — body content lives at the
+ * per-part `contentUrl`, JWT-authorized at the edge.
+ *
+ * Pure helpers (no React) so they can be unit-tested against the generated
+ * type without standing up jsdom or DOMPurify.
+ */
+export type BodyContentKind = "html" | "text";
+export interface RenderableBodyPart {
+    partPath: string;
+    mediaType: string;
+    mediaSubtype: string;
+    disposition?: string;
+    contentUrl: string;
+    isMultipart: boolean;
+}
+export interface PickedBodyPart {
+    kind: BodyContentKind;
+    contentUrl: string;
+}
+/**
+ * Pick the best body part to render: prefer the first inline `text/html`,
+ * fall back to the first inline `text/plain`. Multipart container rows and
+ * attachment-disposition parts are ignored — they carry no renderable
+ * payload at this position — and so are the parts of a forwarded message. Returns `null` when nothing renderable is
+ * available so callers can show an empty-body affordance.
+ */
+export declare const pickRenderablePart: (parts: readonly RenderableBodyPart[]) => PickedBodyPart | null;

package/dist/src/lib/message-body-source.js

@@ -0,0 +1,30 @@
+/**
+ * Pick the renderable body part from a `describeMessage` BodyPartResponse list
+ * and fetch its content via CloudFront. The legacy inlined `bodyText` /
+ * `bodyHtml` fields were removed in #224 PR 3 — body content lives at the
+ * per-part `contentUrl`, JWT-authorized at the edge.
+ *
+ * Pure helpers (no React) so they can be unit-tested against the generated
+ * type without standing up jsdom or DOMPurify.
+ */
+import { ownParts } from "@remit/data-ports/message-parts";
+/**
+ * Pick the best body part to render: prefer the first inline `text/html`,
+ * fall back to the first inline `text/plain`. Multipart container rows and
+ * attachment-disposition parts are ignored — they carry no renderable
+ * payload at this position — and so are the parts of a forwarded message. Returns `null` when nothing renderable is
+ * available so callers can show an empty-body affordance.
+ */
+export const pickRenderablePart = (parts) => {
+    const renderable = ownParts(parts).filter((p) => !p.isMultipart &&
+        p.disposition !== "attachment" &&
+        p.mediaType === "TEXT" &&
+        p.contentUrl.length > 0);
+    const html = renderable.find((p) => p.mediaSubtype.toUpperCase() === "HTML");
+    if (html)
+        return { kind: "html", contentUrl: html.contentUrl };
+    const text = renderable.find((p) => p.mediaSubtype.toUpperCase() === "PLAIN");
+    if (text)
+        return { kind: "text", contentUrl: text.contentUrl };
+    return null;
+};

package/dist/src/lib/move-options.d.ts

@@ -0,0 +1,30 @@
+import type { RemitImapFolderAppointment, RemitImapMailboxResponse } from "@remit/api-http-client/types.gen.ts";
+import type { FolderTreeNode } from "@remit/ui";
+type Translator = (key: string, fallback: string) => string;
+interface MoveOptionsInput {
+    mailboxes: readonly RemitImapMailboxResponse[];
+    folderAppointments: readonly RemitImapFolderAppointment[];
+    /** Rendered as a non-selectable row, so the user sees where mail lives now. */
+    currentMailboxId?: string;
+    /** Dropped entirely — the folder being deleted is not its own destination. */
+    excludeMailboxId?: string;
+    translator?: Translator;
+}
+/**
+ * The account's hierarchy separator, which the tree splits paths on. Every
+ * mailbox of an account reports the same one, so the first is the account's.
+ */
+export declare const folderDelimiter: (mailboxes: readonly RemitImapMailboxResponse[]) => string;
+/**
+ * The single shaping of a mailbox list into Move-to picker options. Labels
+ * follow the account's role appointments (RFC 032, #976) and any
+ * `displayNameOverride`, so a picker reads `Inbox`/`Trash` rather than the
+ * provider's leaf, while the provider path it nests and filters under stays
+ * untouched.
+ *
+ * The message count travels with every option (#887): a folder named `Trash`
+ * may be an empty look-alike beside the real one, and the count is the only
+ * thing that tells them apart. The Move-to picker shows it for the same reason.
+ */
+export declare const buildMoveOptions: ({ mailboxes, folderAppointments, currentMailboxId, excludeMailboxId, translator, }: MoveOptionsInput) => FolderTreeNode[];
+export {};

package/dist/src/lib/move-options.js

@@ -0,0 +1,33 @@
+import { excludeFolder } from "./delete-folder.js";
+import { buildMailboxRoleMap, labelForMailbox } from "./folder-roles.js";
+import { buildMoveTargets } from "./move-targets.js";
+/**
+ * The account's hierarchy separator, which the tree splits paths on. Every
+ * mailbox of an account reports the same one, so the first is the account's.
+ */
+export const folderDelimiter = (mailboxes) => mailboxes[0]?.hierarchyDelimiter ?? "/";
+/**
+ * The single shaping of a mailbox list into Move-to picker options. Labels
+ * follow the account's role appointments (RFC 032, #976) and any
+ * `displayNameOverride`, so a picker reads `Inbox`/`Trash` rather than the
+ * provider's leaf, while the provider path it nests and filters under stays
+ * untouched.
+ *
+ * The message count travels with every option (#887): a folder named `Trash`
+ * may be an empty look-alike beside the real one, and the count is the only
+ * thing that tells them apart. The Move-to picker shows it for the same reason.
+ */
+export const buildMoveOptions = ({ mailboxes, folderAppointments, currentMailboxId, excludeMailboxId, translator, }) => {
+    const targets = buildMoveTargets(mailboxes, folderAppointments);
+    const roleMap = buildMailboxRoleMap(folderAppointments);
+    const destinations = excludeMailboxId
+        ? excludeFolder(targets, excludeMailboxId)
+        : targets;
+    return destinations.map((mailbox) => ({
+        id: mailbox.mailboxId,
+        label: labelForMailbox(mailbox, roleMap.get(mailbox.mailboxId), translator),
+        path: mailbox.fullPath,
+        isCurrent: mailbox.mailboxId === currentMailboxId,
+        messageCount: mailbox.messageCount,
+    }));
+};

package/dist/src/lib/move-targets.d.ts

@@ -0,0 +1,16 @@
+import type { RemitImapFolderAppointment, RemitImapMailboxResponse } from "@remit/api-http-client/types.gen.ts";
+/**
+ * Filter and order a flat mailbox list for the Move-to picker (RFC 032
+ * exclusive-folder-appointment, #976).
+ *
+ * Drops the account's appointed Drafts and Sent mailboxes (issue #236) —
+ * compose/SMTP flows manage those, moving an arbitrary message into them
+ * would break the invariant that they only hold messages the user authored —
+ * and Outbox by locale name. Everything else, including a Drafts/Sent
+ * look-alike the user hasn't actually appointed (e.g. an empty `INBOX/Drafts`
+ * twin next to the real `INBOX/Concepten`), is a perfectly valid destination:
+ * the exclusion follows the account's role appointment, not folder-name or
+ * SPECIAL-USE guessing. Sorts by the same role priority the sidebar pins by,
+ * then alphabetically.
+ */
+export declare const buildMoveTargets: (mailboxes: readonly RemitImapMailboxResponse[], folderAppointments: readonly RemitImapFolderAppointment[]) => RemitImapMailboxResponse[];

package/dist/src/lib/move-targets.js

@@ -0,0 +1,61 @@
+import { mailboxLeafName } from "@remit/data-ports/mailbox-name";
+import { buildMailboxRoleMap, ROLE_PRIORITY } from "./folder-roles.js";
+// Outbox has no IMAP special-use flag (RFC 6154 doesn't define one) and isn't
+// a canonical role (RFC 032 exclusive-folder-appointment) either — it's
+// Remit's own concept, so it isn't in the account's role map. KISS: covers the
+// languages we expect to encounter; extend as needed. Stored lowercased and
+// trimmed; comparisons normalize the input the same way.
+const OUTBOX_LOCALE_NAMES = new Set([
+    "outbox",
+    "postvak uit",
+    "boîte d'envoi",
+    "postausgang",
+    "buzón de salida",
+    "posta in uscita",
+    "送信トレイ",
+    "送件匣",
+    "发件箱",
+    "skrzynka nadawcza",
+]);
+const isOutboxDestination = (mailbox) => {
+    const leaf = mailboxLeafName(mailbox).trim().toLowerCase();
+    return OUTBOX_LOCALE_NAMES.has(leaf);
+};
+const NON_SYSTEM_PRIORITY = ROLE_PRIORITY.length;
+/**
+ * Filter and order a flat mailbox list for the Move-to picker (RFC 032
+ * exclusive-folder-appointment, #976).
+ *
+ * Drops the account's appointed Drafts and Sent mailboxes (issue #236) —
+ * compose/SMTP flows manage those, moving an arbitrary message into them
+ * would break the invariant that they only hold messages the user authored —
+ * and Outbox by locale name. Everything else, including a Drafts/Sent
+ * look-alike the user hasn't actually appointed (e.g. an empty `INBOX/Drafts`
+ * twin next to the real `INBOX/Concepten`), is a perfectly valid destination:
+ * the exclusion follows the account's role appointment, not folder-name or
+ * SPECIAL-USE guessing. Sorts by the same role priority the sidebar pins by,
+ * then alphabetically.
+ */
+export const buildMoveTargets = (mailboxes, folderAppointments) => {
+    const roleMap = buildMailboxRoleMap(folderAppointments);
+    const filtered = mailboxes.filter((mailbox) => {
+        const role = roleMap.get(mailbox.mailboxId);
+        if (role === "drafts" || role === "sent")
+            return false;
+        return !isOutboxDestination(mailbox);
+    });
+    return [...filtered].sort((a, b) => {
+        const aPriority = roleMap.has(a.mailboxId)
+            ? ROLE_PRIORITY.indexOf(roleMap.get(a.mailboxId) ?? "inbox")
+            : NON_SYSTEM_PRIORITY;
+        const bPriority = roleMap.has(b.mailboxId)
+            ? ROLE_PRIORITY.indexOf(roleMap.get(b.mailboxId) ?? "inbox")
+            : NON_SYSTEM_PRIORITY;
+        if (aPriority !== bPriority)
+            return aPriority - bPriority;
+        return mailboxLeafName(a).localeCompare(mailboxLeafName(b), undefined, {
+            sensitivity: "base",
+            numeric: true,
+        });
+    });
+};

package/dist/src/lib/network-error.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Transport failures are identified where they happen, not guessed at later.
+ *
+ * `fetch()` rejects for exactly two reasons: the request never completed at the
+ * transport level (DNS, TLS, connection lost, captive portal, timeout), or it
+ * was aborted. It never rejects for an HTTP status. So the one place that knows
+ * for certain that an error is a network error is the call site that wrapped
+ * `fetch` — everywhere downstream is guessing.
+ *
+ * Guessing is what the classifier used to do, first by treating every error
+ * without an HTTP status as a network blip (which swallowed our own exceptions),
+ * then by matching browser failure strings (which is unbounded: WebKit alone
+ * says "Failed to fetch", "Load failed", "The network connection was lost." and
+ * "The request timed out.", and undici says "fetch failed"). Tagging at the
+ * boundary makes the question decidable and the browser's wording irrelevant.
+ */
+/** A request that never reached a server. Always soft — never escalated. */
+export declare class NetworkError extends Error {
+    constructor(cause: unknown);
+}
+/**
+ * `fetch`, with transport failures tagged. Every app-owned request goes through
+ * this — the generated client is configured with it, and the hand-written
+ * wrapper calls it — so a `NetworkError` downstream is a fact, not an inference.
+ *
+ * It is also the one place every request is seen, so it records a metadata-only
+ * breadcrumb (method, path, status, duration, correlation id) for bug reports.
+ * A deliberate abort is not a request outcome worth reporting, so it is
+ * re-thrown before any breadcrumb is written.
+ */
+export declare const taggedFetch: typeof fetch;

package/dist/src/lib/network-error.js

@@ -0,0 +1,68 @@
+/**
+ * Transport failures are identified where they happen, not guessed at later.
+ *
+ * `fetch()` rejects for exactly two reasons: the request never completed at the
+ * transport level (DNS, TLS, connection lost, captive portal, timeout), or it
+ * was aborted. It never rejects for an HTTP status. So the one place that knows
+ * for certain that an error is a network error is the call site that wrapped
+ * `fetch` — everywhere downstream is guessing.
+ *
+ * Guessing is what the classifier used to do, first by treating every error
+ * without an HTTP status as a network blip (which swallowed our own exceptions),
+ * then by matching browser failure strings (which is unbounded: WebKit alone
+ * says "Failed to fetch", "Load failed", "The network connection was lost." and
+ * "The request timed out.", and undici says "fetch failed"). Tagging at the
+ * boundary makes the question decidable and the browser's wording irrelevant.
+ */
+import { recordRequest } from "./request-breadcrumbs";
+/** A request that never reached a server. Always soft — never escalated. */
+export class NetworkError extends Error {
+    constructor(cause) {
+        super(cause instanceof Error && cause.message
+            ? cause.message
+            : "The request could not be completed.", { cause });
+        this.name = "NetworkError";
+    }
+}
+/**
+ * A deliberate cancellation — a route change, a React Query cancellation, a
+ * caller's own `AbortController`. Its own category: not a failure at all, so it
+ * passes through untagged.
+ *
+ * `AbortSignal.timeout()` rejects with a `TimeoutError` rather than an
+ * `AbortError`, and a timeout IS a transport failure, so it is deliberately not
+ * matched here and gets tagged like any other.
+ */
+const isDeliberateAbort = (error) => typeof error === "object" &&
+    error !== null &&
+    "name" in error &&
+    error.name === "AbortError";
+/**
+ * `fetch`, with transport failures tagged. Every app-owned request goes through
+ * this — the generated client is configured with it, and the hand-written
+ * wrapper calls it — so a `NetworkError` downstream is a fact, not an inference.
+ *
+ * It is also the one place every request is seen, so it records a metadata-only
+ * breadcrumb (method, path, status, duration, correlation id) for bug reports.
+ * A deliberate abort is not a request outcome worth reporting, so it is
+ * re-thrown before any breadcrumb is written.
+ */
+export const taggedFetch = async (input, init) => {
+    const startedAt = performance.now();
+    try {
+        const response = await fetch(input, init);
+        recordRequest({
+            input,
+            init,
+            response,
+            durationMs: performance.now() - startedAt,
+        });
+        return response;
+    }
+    catch (error) {
+        if (isDeliberateAbort(error))
+            throw error;
+        recordRequest({ input, init, durationMs: performance.now() - startedAt });
+        throw new NetworkError(error);
+    }
+};

package/dist/src/lib/new-folder.d.ts

@@ -0,0 +1,23 @@
+export interface FolderTarget {
+    fullPath: string;
+    hierarchyDelimiter: string;
+}
+/**
+ * The full path of a new folder: the leaf name on its own for a root folder, or
+ * the parent's path joined to the name by the parent's hierarchy delimiter.
+ */
+export declare function composeFolderPath(name: string, parent?: FolderTarget): string;
+/**
+ * Why the folder can't be created, or `undefined` when the name is valid. A
+ * name must be non-empty, must not contain the hierarchy delimiter (nesting is
+ * expressed by the parent select, not by typing a path), and must not collide
+ * with an existing folder — INBOX compared case-insensitively, everything else
+ * exactly. A server that reports no delimiter has a flat namespace, so there is
+ * no separator to forbid and every name would otherwise contain it.
+ */
+export declare function validateNewFolderName({ name, delimiter, parent, existingPaths, }: {
+    name: string;
+    delimiter: string;
+    parent?: FolderTarget;
+    existingPaths: readonly string[];
+}): string | undefined;

package/dist/src/lib/new-folder.js

@@ -0,0 +1,41 @@
+/**
+ * The full path of a new folder: the leaf name on its own for a root folder, or
+ * the parent's path joined to the name by the parent's hierarchy delimiter.
+ */
+export function composeFolderPath(name, parent) {
+    const trimmed = name.trim();
+    if (!parent)
+        return trimmed;
+    return `${parent.fullPath}${parent.hierarchyDelimiter}${trimmed}`;
+}
+/**
+ * IMAP treats the INBOX root case-insensitively; every other path segment is
+ * exact. Canonicalizing only a leading `inbox` segment lets the collision check
+ * match `inbox/x` against `INBOX/x` without folding case anywhere else.
+ */
+const canonicalizePath = (path, delimiter) => {
+    const parts = delimiter.length === 0 ? [path] : path.split(delimiter);
+    if (parts[0]?.toLowerCase() === "inbox")
+        parts[0] = "INBOX";
+    return parts.join(delimiter);
+};
+/**
+ * Why the folder can't be created, or `undefined` when the name is valid. A
+ * name must be non-empty, must not contain the hierarchy delimiter (nesting is
+ * expressed by the parent select, not by typing a path), and must not collide
+ * with an existing folder — INBOX compared case-insensitively, everything else
+ * exactly. A server that reports no delimiter has a flat namespace, so there is
+ * no separator to forbid and every name would otherwise contain it.
+ */
+export function validateNewFolderName({ name, delimiter, parent, existingPaths, }) {
+    const trimmed = name.trim();
+    if (trimmed === "")
+        return "Enter a folder name.";
+    if (delimiter.length > 0 && trimmed.includes(delimiter))
+        return `A folder name can't contain "${delimiter}".`;
+    const candidate = canonicalizePath(composeFolderPath(trimmed, parent), delimiter);
+    const collides = existingPaths.some((path) => canonicalizePath(path, delimiter) === candidate);
+    if (collides)
+        return "A folder with that name already exists.";
+    return undefined;
+}

package/dist/src/lib/onboarding-completion.d.ts

@@ -0,0 +1,15 @@
+import type { QueryClient } from "@tanstack/react-query";
+/**
+ * Finishing onboarding creates the account server-side, but the cached config
+ * still reports zero accounts. The /mail route's first-run guard redirects to
+ * /onboarding whenever config reports no accounts, so navigating to the inbox
+ * before the cache is refreshed bounces the user straight back into the wizard.
+ *
+ * Refresh config and wait for it to settle before navigating, so the guard sees
+ * the freshly created account.
+ */
+export declare function completeOnboarding(deps: {
+    queryClient: Pick<QueryClient, "refetchQueries">;
+    recordCompleted: () => void;
+    navigateToInbox: () => void;
+}): Promise<void>;

package/dist/src/lib/onboarding-completion.js

@@ -0,0 +1,17 @@
+import { configOperationsGetConfigQueryKey } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+/**
+ * Finishing onboarding creates the account server-side, but the cached config
+ * still reports zero accounts. The /mail route's first-run guard redirects to
+ * /onboarding whenever config reports no accounts, so navigating to the inbox
+ * before the cache is refreshed bounces the user straight back into the wizard.
+ *
+ * Refresh config and wait for it to settle before navigating, so the guard sees
+ * the freshly created account.
+ */
+export async function completeOnboarding(deps) {
+    deps.recordCompleted();
+    await deps.queryClient.refetchQueries({
+        queryKey: configOperationsGetConfigQueryKey(),
+    });
+    deps.navigateToInbox();
+}

package/dist/src/lib/organize/clause-suggestions.d.ts

@@ -0,0 +1,40 @@
+import { type ClauseField, type Suggestion } from "@remit/ui";
+/**
+ * Values worth offering while a clause is being typed. The rule editor's value
+ * field used to be bare text entry, so a `From` clause meant recalling an
+ * address exactly and a `FromDomain` clause meant knowing what the matcher
+ * considers a registrable domain.
+ *
+ * The offer is a shortcut and never a constraint: nothing here can reject or
+ * rewrite what the user typed, and a field with no matches is the plain text box
+ * it always was.
+ */
+/** An address a suggestion can be built from. */
+export interface KnownAddress {
+    email: string;
+    displayName?: string;
+    /**
+     * The address came off the messages the user selected, rather than a lookup.
+     * These are the likeliest answers, so they lead the list and say where they
+     * came from.
+     */
+    fromSelection?: boolean;
+}
+/** How many suggestions the list shows at most. */
+export declare const CLAUSE_SUGGESTION_LIMIT = 8;
+/**
+ * Whether a clause field takes values that come from addresses. `Subject`,
+ * `HasWords`, and `ListId` are free text with nothing to draw on, and stay so.
+ */
+export declare const fieldTakesAddressSuggestions: (field: ClauseField) => boolean;
+/**
+ * The suggestions for one clause draft. `addresses` is given in priority order —
+ * the selection's own senders first — and duplicates collapse onto the first
+ * occurrence, so a selected address keeps its "selected" marking even when a
+ * lookup returns it too.
+ *
+ * An empty query offers the lot, which is what makes the selection's addresses
+ * available before a single key is pressed. A query that exactly matches an
+ * offer drops it: there is nothing left to shortcut.
+ */
+export declare const buildClauseSuggestions: (field: ClauseField, query: string, addresses: readonly KnownAddress[]) => Suggestion[];

package/dist/src/lib/organize/clause-suggestions.js

@@ -0,0 +1,61 @@
+import { senderDomain } from "@remit/ui";
+/** How many suggestions the list shows at most. */
+export const CLAUSE_SUGGESTION_LIMIT = 8;
+/**
+ * Whether a clause field takes values that come from addresses. `Subject`,
+ * `HasWords`, and `ListId` are free text with nothing to draw on, and stay so.
+ */
+export const fieldTakesAddressSuggestions = (field) => field === "From" || field === "FromDomain";
+const addressSuggestion = (address) => ({
+    value: address.email,
+    label: address.displayName ?? address.email,
+    ...(address.displayName ? { hint: address.email } : {}),
+    ...(address.fromSelection ? { source: "selected" } : {}),
+});
+const domainSuggestion = (address) => {
+    const domain = senderDomain(address.email);
+    if (domain === null)
+        return undefined;
+    return {
+        value: domain,
+        ...(address.fromSelection ? { source: "selected" } : {}),
+    };
+};
+const matches = (suggestion, query) => suggestion.value.toLowerCase().includes(query) ||
+    (suggestion.label ?? "").toLowerCase().includes(query);
+/**
+ * The suggestions for one clause draft. `addresses` is given in priority order —
+ * the selection's own senders first — and duplicates collapse onto the first
+ * occurrence, so a selected address keeps its "selected" marking even when a
+ * lookup returns it too.
+ *
+ * An empty query offers the lot, which is what makes the selection's addresses
+ * available before a single key is pressed. A query that exactly matches an
+ * offer drops it: there is nothing left to shortcut.
+ */
+export const buildClauseSuggestions = (field, query, addresses) => {
+    if (!fieldTakesAddressSuggestions(field))
+        return [];
+    const needle = query.trim().toLowerCase();
+    const seen = new Set();
+    const out = [];
+    for (const address of addresses) {
+        if (address.email.trim() === "")
+            continue;
+        const suggestion = field === "From" ? addressSuggestion(address) : domainSuggestion(address);
+        if (!suggestion)
+            continue;
+        const key = suggestion.value.toLowerCase();
+        if (key === "" || seen.has(key))
+            continue;
+        seen.add(key);
+        if (key === needle)
+            continue;
+        if (needle !== "" && !matches(suggestion, needle))
+            continue;
+        out.push(suggestion);
+        if (out.length === CLAUSE_SUGGESTION_LIMIT)
+            break;
+    }
+    return out;
+};

package/dist/src/lib/organize/filter-edit-model.d.ts

@@ -0,0 +1,47 @@
+import type { RemitImapFilterResponse, RemitImapUpdateFilterInput } from "@remit/api-http-client/types.gen.ts";
+import type { FilterRule } from "@remit/ui";
+/**
+ * The persisted filter as the chip editor's rule (RFC 038 D6). Loads the whole
+ * rule the user edits: literal clauses, the match operator, the move action, and
+ * the scope (and, for a Temporary filter, the date it stops on).
+ *
+ * The scope maps `Standing` → "standing" and `Temporary` → "until"; a persisted
+ * filter is never the one-time "once" scope. `moveMailboxId` and `labelId` both
+ * drop the `"None"` sentinel to `undefined` so an empty select reads as "no
+ * action" (issue #26).
+ */
+export declare const filterToRule: (filter: RemitImapFilterResponse) => FilterRule;
+/**
+ * The `YYYY-MM-DD` the date input shows for a stored `expiresAt`. The inverse of
+ * {@link pickedDateToExpiresAt}: it reads the local calendar day the timestamp
+ * falls on, so a date picked, saved, and reopened comes back unchanged. Empty
+ * or unparseable input yields an empty string — the picker's "no date" state.
+ */
+export declare const expiresAtToPickedDate: (expiresAt: string | undefined) => string;
+/**
+ * Whether the edited rule changes the predicate or the action versus the one it
+ * was loaded from — the clauses, the match operator, the move target, the
+ * or the label target. A change here is what bumps
+ * `ruleChangedAt` and offers the re-back-apply (RFC 034 Decision 3.2); the name
+ * is deliberately excluded, so a cosmetic rename is not a rule change.
+ */
+export declare const ruleChangesPredicateOrAction: (rule: FilterRule, original: FilterRule) => boolean;
+/**
+ * Whether the edited rule changes scope (standing ↔ until-a-date) or the date
+ * itself, versus the one it was loaded from (reader #266). Scope and expiry
+ * are mutable on an existing filter, and a change here
+ * bumps `ruleChangedAt` the same way a predicate/action change does — moving a
+ * lapsed filter back to Standing (or extending its date) is the same kind of
+ * "the user just reasserted this rule" moment, and re-offers the back-apply so
+ * mail delivered while the filter sat inactive can be caught up.
+ */
+export declare const ruleChangesScopeOrExpiry: (rule: FilterRule, original: FilterRule) => boolean;
+/**
+ * The PATCH body for an edited filter. A cosmetic rename sends `{ name }` only,
+ * so the server's `changesRuleAssertion` guard leaves `ruleChangedAt`
+ * untouched (RFC 034 Decision 3.2). A predicate or action change sends the
+ * operator, clauses, move target, and label target; a scope or expiry change
+ * sends `scope` and, for the `until` scope, `expiresAt` (reader #266) —
+ * either bumps `ruleChangedAt`.
+ */
+export declare const buildUpdateFilterInput: (rule: FilterRule, original: FilterRule) => RemitImapUpdateFilterInput;