@remit/web-client 0.0.324 → 0.0.326

package/dist/src/lib/starred-rows.js

@@ -0,0 +1,32 @@
+/**
+ * Collapse rows that are the same conversation.
+ *
+ * A message's identity includes its mailbox, so the same mail filed in two
+ * folders is two rows carrying the same server-side star. The starred scope
+ * already excludes the folder that causes this wholesale (Gmail's All Mail),
+ * but an ordinary copy in a user folder still produces a pair.
+ *
+ * Deduping over the accumulated pages rather than inside one keeps a
+ * conversation single even when its copies straddle a page boundary — a single
+ * page cannot know what earlier pages already showed. The first row wins: the
+ * newest under a plain listing, and under a search the one the server ranked
+ * highest, so a sender's own older message beats a newer reply that mentions
+ * them.
+ *
+ * Generic over anything naming its thread, so the same collapse runs over the
+ * API rows and over the merged display rows a text search produces — two
+ * definitions of "same conversation" is one too many. A row that names no
+ * thread is never merged: there is nothing to say it is the same conversation
+ * as any other.
+ */
+export const dedupeByThread = (items) => {
+    const seen = new Set();
+    return items.filter((item) => {
+        if (item.threadId === undefined)
+            return true;
+        if (seen.has(item.threadId))
+            return false;
+        seen.add(item.threadId);
+        return true;
+    });
+};

package/dist/src/lib/sync-warning-entries.d.ts

@@ -0,0 +1,4 @@
+import type { RemitImapSyncWarningResponse } from "@remit/api-http-client/types.gen.ts";
+import { type ResultFolder, type SyncWarningEntry } from "@remit/ui";
+export declare const UNLISTED_FOLDER_LABEL = "A folder no longer listed";
+export declare function toSyncWarningEntry(wire: RemitImapSyncWarningResponse, folder: ResultFolder | undefined): SyncWarningEntry;

package/dist/src/lib/sync-warning-entries.js

@@ -0,0 +1,22 @@
+import { syncWarningState } from "@remit/data-ports/sync-warning-state";
+import { canonicalRoleLabel, folderLeaf, } from "@remit/ui";
+export const UNLISTED_FOLDER_LABEL = "A folder no longer listed";
+function folderLabel(folder) {
+    if (folder?.role)
+        return canonicalRoleLabel(folder.role);
+    if (folder?.providerPath) {
+        return folderLeaf(folder.providerPath, folder.hierarchyDelimiter);
+    }
+    return UNLISTED_FOLDER_LABEL;
+}
+export function toSyncWarningEntry(wire, folder) {
+    return {
+        syncWarningId: wire.syncWarningId,
+        uid: wire.uid,
+        stage: wire.stage,
+        state: syncWarningState(wire.stage, wire.attempts),
+        attempts: wire.attempts,
+        createdAt: wire.createdAt,
+        folderLabel: folderLabel(folder),
+    };
+}

package/dist/src/lib/telemetry-context.d.ts

@@ -0,0 +1,3 @@
+import type { Telemetry } from "./telemetry";
+export declare const TelemetryContext: import("react").Context<Telemetry>;
+export declare function useTelemetry(): Telemetry;

package/dist/src/lib/telemetry-context.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from "react";
+import { noopTelemetry } from "./telemetry";
+export const TelemetryContext = createContext(noopTelemetry);
+export function useTelemetry() {
+    return useContext(TelemetryContext);
+}

package/dist/src/lib/telemetry.d.ts

@@ -0,0 +1,7 @@
+export interface Telemetry {
+    recordPageView(path: string): void;
+    recordError(error: Error, context?: Record<string, string>): void;
+    recordEvent(name: string, attributes?: Record<string, string>): void;
+    recordTiming(name: string, durationMs: number, attributes?: Record<string, string>): void;
+}
+export declare const noopTelemetry: Telemetry;

package/dist/src/lib/telemetry.js

@@ -0,0 +1,6 @@
+export const noopTelemetry = {
+    recordPageView: () => undefined,
+    recordError: () => undefined,
+    recordEvent: () => undefined,
+    recordTiming: () => undefined,
+};

package/dist/src/lib/theme-preference.d.ts

@@ -0,0 +1,16 @@
+/**
+ * User theme preference — persistent, immediate-apply.
+ *
+ * "system" (default) follows the OS prefers-color-scheme media query.
+ * "light" / "dark" override it and survive page reloads via localStorage.
+ */
+export type ThemePreference = "system" | "light" | "dark";
+/** Read the stored preference; defaults to "system" if not set. */
+export declare function getThemePreference(): ThemePreference;
+/** Apply a preference to <html> immediately, without persisting. */
+export declare function applyPreference(pref: ThemePreference): void;
+/**
+ * Persist the preference and apply it immediately.
+ * Passing "system" removes the key so the default kicks in.
+ */
+export declare function setThemePreference(pref: ThemePreference): void;

package/dist/src/lib/theme-preference.js

@@ -0,0 +1,40 @@
+/**
+ * User theme preference — persistent, immediate-apply.
+ *
+ * "system" (default) follows the OS prefers-color-scheme media query.
+ * "light" / "dark" override it and survive page reloads via localStorage.
+ */
+const STORAGE_KEY = "remit.theme";
+const DARK_CLASS = "dark";
+/** Read the stored preference; defaults to "system" if not set. */
+export function getThemePreference() {
+    if (typeof localStorage === "undefined")
+        return "system";
+    return (localStorage.getItem(STORAGE_KEY) ?? "system");
+}
+/** Apply a preference to <html> immediately, without persisting. */
+export function applyPreference(pref) {
+    if (typeof document === "undefined")
+        return;
+    const isDark = pref === "dark" ||
+        (pref === "system" &&
+            typeof window !== "undefined" &&
+            typeof window.matchMedia === "function" &&
+            window.matchMedia("(prefers-color-scheme: dark)").matches);
+    document.documentElement.classList.toggle(DARK_CLASS, isDark);
+}
+/**
+ * Persist the preference and apply it immediately.
+ * Passing "system" removes the key so the default kicks in.
+ */
+export function setThemePreference(pref) {
+    if (typeof localStorage !== "undefined") {
+        if (pref === "system") {
+            localStorage.removeItem(STORAGE_KEY);
+        }
+        else {
+            localStorage.setItem(STORAGE_KEY, pref);
+        }
+    }
+    applyPreference(pref);
+}

package/dist/src/lib/theme.d.ts

@@ -0,0 +1,11 @@
+/**
+ * installThemeSync — call once at app startup (before first paint).
+ *
+ * Reads the stored preference (see theme-preference.ts) and applies it.
+ * The matchMedia listener stays attached for the whole session and re-reads
+ * the *live* preference on each OS change: while "system" it follows the OS,
+ * while "light"/"dark" it is a no-op. This means switching System → explicit
+ * → System within one session resumes OS-following immediately, with no
+ * reload required (the listener is never detached).
+ */
+export declare const installThemeSync: () => void;

package/dist/src/lib/theme.js

@@ -0,0 +1,31 @@
+import { applyPreference, getThemePreference } from "./theme-preference.js";
+/**
+ * installThemeSync — call once at app startup (before first paint).
+ *
+ * Reads the stored preference (see theme-preference.ts) and applies it.
+ * The matchMedia listener stays attached for the whole session and re-reads
+ * the *live* preference on each OS change: while "system" it follows the OS,
+ * while "light"/"dark" it is a no-op. This means switching System → explicit
+ * → System within one session resumes OS-following immediately, with no
+ * reload required (the listener is never detached).
+ */
+export const installThemeSync = () => {
+    if (typeof window === "undefined")
+        return;
+    applyPreference(getThemePreference());
+    if (typeof window.matchMedia !== "function")
+        return;
+    const media = window.matchMedia("(prefers-color-scheme: dark)");
+    const handler = () => {
+        // applyPreference only reacts to the OS when the live preference is
+        // "system"; an explicit light/dark choice makes this a no-op.
+        applyPreference(getThemePreference());
+    };
+    if (typeof media.addEventListener === "function") {
+        media.addEventListener("change", handler);
+    }
+    else {
+        // Safari <14 fallback
+        media.addListener(handler);
+    }
+};

package/dist/src/lib/thread-cache.d.ts

@@ -0,0 +1,41 @@
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+/**
+ * Optimistic patching of the thread caches.
+ *
+ * `queryClient.setQueriesData({ queryKey: prefix }, …)` matches by key *prefix*,
+ * so an updater written for the mailbox list also runs against every other
+ * cached query sharing that prefix. Those do not all have the same shape: the
+ * mailbox list is an infinite query (`{ pages: [{ items }] }`) while
+ * single-shot readers of the same endpoint — the rescue-candidate search, for
+ * one — cache a plain page (`{ items }`). An updater that assumed the infinite
+ * shape threw `pages is undefined` inside `onMutate`, which React Query reports
+ * as a failed mutation: the move never fired and the user got an error toast
+ * for an action that was never attempted (issues #51, #55).
+ *
+ * `patchThreadListCache` handles both shapes and leaves anything else it does
+ * not recognise untouched.
+ */
+export interface ThreadItemsPage {
+    items: RemitImapThreadMessageResponse[];
+    [key: string]: unknown;
+}
+export interface InfiniteThreadData {
+    pages: ThreadItemsPage[];
+    pageParams: Array<string | undefined>;
+}
+/** Either cached shape served by the thread list/search endpoints. */
+export type ThreadListCache = InfiniteThreadData | ThreadItemsPage;
+export declare const isInfiniteThreadData: (data: unknown) => data is InfiniteThreadData;
+export declare const isThreadItemsPage: (data: unknown) => data is ThreadItemsPage;
+/**
+ * Apply `patchItems` to every list of thread messages inside a cache entry,
+ * whichever shape it holds.
+ *
+ * `old` is `unknown` because that is the truth: a prefix match hands this
+ * whatever happens to be cached under that prefix, and the two shapes below are
+ * the ones we know about today, not the ones we are guaranteed. Declaring a
+ * narrower parameter type is what produced the original bug — the type asserted
+ * a shape the runtime never promised, and the first entry that disagreed threw.
+ * Anything unrecognised is returned untouched.
+ */
+export declare const patchThreadListCache: (old: unknown, patchItems: (items: RemitImapThreadMessageResponse[]) => RemitImapThreadMessageResponse[]) => unknown;

package/dist/src/lib/thread-cache.js

@@ -0,0 +1,34 @@
+export const isInfiniteThreadData = (data) => typeof data === "object" &&
+    data !== null &&
+    Array.isArray(data.pages);
+export const isThreadItemsPage = (data) => typeof data === "object" &&
+    data !== null &&
+    Array.isArray(data.items);
+/**
+ * Apply `patchItems` to every list of thread messages inside a cache entry,
+ * whichever shape it holds.
+ *
+ * `old` is `unknown` because that is the truth: a prefix match hands this
+ * whatever happens to be cached under that prefix, and the two shapes below are
+ * the ones we know about today, not the ones we are guaranteed. Declaring a
+ * narrower parameter type is what produced the original bug — the type asserted
+ * a shape the runtime never promised, and the first entry that disagreed threw.
+ * Anything unrecognised is returned untouched.
+ */
+export const patchThreadListCache = (old, patchItems) => {
+    if (old === undefined)
+        return old;
+    if (isInfiniteThreadData(old)) {
+        return {
+            ...old,
+            pages: old.pages.map((page) => ({
+                ...page,
+                items: patchItems(page.items),
+            })),
+        };
+    }
+    if (isThreadItemsPage(old)) {
+        return { ...old, items: patchItems(old.items) };
+    }
+    return old;
+};

package/dist/src/lib/thread-list-cache.d.ts

@@ -0,0 +1,51 @@
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import type { QueryClient } from "@tanstack/react-query";
+import { type ThreadListCache } from "./thread-cache.js";
+export interface SnapshotEntry<T> {
+    queryKey: readonly unknown[];
+    data: T;
+}
+export type ThreadListSnapshotEntry = SnapshotEntry<ThreadListCache>;
+/** A cached page of one thread's messages, as the thread-detail endpoint serves it. */
+export interface ThreadMessagesData {
+    items: RemitImapThreadMessageResponse[];
+    [key: string]: unknown;
+}
+/**
+ * The rollback state an optimistic thread mutation captures in `onMutate`.
+ *
+ * The shape belongs to the snapshot/restore helpers below rather than to any
+ * one mutation, so mark-read, star, delete and move all carry the same one
+ * (#868).
+ */
+export interface ThreadMutationContext {
+    threadMessagesPrefix: readonly unknown[];
+    listPrefixes: ReadonlyArray<readonly unknown[]>;
+    previousThreadMessages: SnapshotEntry<ThreadMessagesData>[];
+    previousThreadsList: ThreadListSnapshotEntry[];
+}
+/**
+ * Every cached thread listing the given mailboxes feed, as query-key prefixes:
+ * each mailbox's list and search caches, plus the unified cross-account listing
+ * that backs the daily brief and the Flagged view.
+ *
+ * A thread-list mutation (mark read, star, delete, move) has to reach all of
+ * them. When a hook hand-copies a subset, a view reading from a listing it
+ * forgot serves a stale page until reload: the daily brief kept its unread dot
+ * after a message was read because the read mutation patched the per-mailbox
+ * caches but not the unified one (#140). This is the single source every
+ * mutation hook resolves its keys from, so the set can never drift between them
+ * (part of #149). React Query matches by prefix, so each key also covers its
+ * option variants (order, pagination) without enumerating them.
+ */
+export declare const threadListCacheKeys: (mailboxIds: Iterable<string>) => ReadonlyArray<readonly unknown[]>;
+export declare const cancelThreadListQueries: (queryClient: QueryClient, prefixes: ReadonlyArray<readonly unknown[]>) => Promise<unknown>;
+export declare const snapshotThreadListQueries: (queryClient: QueryClient, prefixes: ReadonlyArray<readonly unknown[]>) => ThreadListSnapshotEntry[];
+/**
+ * Run `patchItems` over every cached listing under `prefixes`, whichever shape
+ * each holds — the shape-tolerant `patchThreadListCache` covers both the
+ * single-shot page (brief) and the infinite query (Flagged, mailbox list).
+ */
+export declare const patchThreadListQueries: (queryClient: QueryClient, prefixes: ReadonlyArray<readonly unknown[]>, patchItems: (items: RemitImapThreadMessageResponse[]) => RemitImapThreadMessageResponse[]) => void;
+export declare const restoreThreadListQueries: (queryClient: QueryClient, snapshot: ThreadListSnapshotEntry[]) => void;
+export declare const invalidateThreadListQueries: (queryClient: QueryClient, prefixes: ReadonlyArray<readonly unknown[]>) => void;

package/dist/src/lib/thread-list-cache.js

@@ -0,0 +1,51 @@
+import { threadOperationsListThreadsQueryKey, threadOperationsSearchThreadsQueryKey, unifiedThreadOperationsListAllThreadsQueryKey, } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { patchThreadListCache } from "./thread-cache.js";
+/**
+ * Every cached thread listing the given mailboxes feed, as query-key prefixes:
+ * each mailbox's list and search caches, plus the unified cross-account listing
+ * that backs the daily brief and the Flagged view.
+ *
+ * A thread-list mutation (mark read, star, delete, move) has to reach all of
+ * them. When a hook hand-copies a subset, a view reading from a listing it
+ * forgot serves a stale page until reload: the daily brief kept its unread dot
+ * after a message was read because the read mutation patched the per-mailbox
+ * caches but not the unified one (#140). This is the single source every
+ * mutation hook resolves its keys from, so the set can never drift between them
+ * (part of #149). React Query matches by prefix, so each key also covers its
+ * option variants (order, pagination) without enumerating them.
+ */
+export const threadListCacheKeys = (mailboxIds) => {
+    const keys = [];
+    for (const mailboxId of new Set(mailboxIds)) {
+        keys.push(threadOperationsListThreadsQueryKey({ path: { mailboxId } }));
+        keys.push(threadOperationsSearchThreadsQueryKey({ path: { mailboxId } }));
+    }
+    keys.push(unifiedThreadOperationsListAllThreadsQueryKey());
+    return keys;
+};
+export const cancelThreadListQueries = (queryClient, prefixes) => Promise.all(prefixes.map((queryKey) => queryClient.cancelQueries({ queryKey })));
+export const snapshotThreadListQueries = (queryClient, prefixes) => prefixes
+    .flatMap((queryKey) => queryClient.getQueriesData({ queryKey }))
+    .filter((entry) => entry[1] !== undefined)
+    .map(([queryKey, data]) => ({ queryKey, data }));
+/**
+ * Run `patchItems` over every cached listing under `prefixes`, whichever shape
+ * each holds — the shape-tolerant `patchThreadListCache` covers both the
+ * single-shot page (brief) and the infinite query (Flagged, mailbox list).
+ */
+export const patchThreadListQueries = (queryClient, prefixes, patchItems) => {
+    const updater = (old) => patchThreadListCache(old, patchItems);
+    for (const queryKey of prefixes) {
+        queryClient.setQueriesData({ queryKey }, updater);
+    }
+};
+export const restoreThreadListQueries = (queryClient, snapshot) => {
+    for (const entry of snapshot) {
+        queryClient.setQueryData(entry.queryKey, entry.data);
+    }
+};
+export const invalidateThreadListQueries = (queryClient, prefixes) => {
+    for (const queryKey of prefixes) {
+        queryClient.invalidateQueries({ queryKey });
+    }
+};

package/dist/src/lib/thread-search-tokens.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The parsed search tokens as `threadOperationsSearchThreads` parameters, plus
+ * the tokens that request cannot carry.
+ *
+ * A token the request drops does not narrow anything, so the mailbox answers a
+ * weaker question than the one that was asked and returns mail the user
+ * excluded — `is:starred` handing back unstarred mail. Every token is therefore
+ * accounted for exactly once: either the request carries it, or it comes back
+ * as residue for the caller to apply over the returned rows
+ * (`matchesSearchTokens`).
+ *
+ * Membership is decided by reading the request back rather than by tracking
+ * which branch set what: a token is carried when the request that will be sent
+ * asks for exactly what the token asks for. That covers the cases where one
+ * parameter has to answer for several tokens — the endpoint takes a single
+ * `from`, a single `subject` and one boolean per state, so a second `from:` or
+ * a contradicting `is:read` cannot be expressed and becomes residue.
+ *
+ * The inbox chips own the parameters they set: a chip is a control on screen,
+ * a token is text in a field, and where they disagree the visible control wins
+ * and the token drops to residue (where, contradicting the chip, it matches
+ * nothing — which is the honest answer to a contradiction).
+ */
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import type { InboxFilterParams, ThreadSearchQuery } from "./inbox-filters.js";
+import type { SearchToken } from "./search-tokens.js";
+/** The search parameters the tokens themselves set. */
+export type ThreadSearchTokenParams = Pick<ThreadSearchQuery, "from" | "subject" | "category" | "unread" | "starred" | "attachments">;
+/** A parameter name a listing endpoint accepts. */
+export type ThreadSearchTokenParamName = keyof ThreadSearchTokenParams;
+/**
+ * Every parameter `searchThreads` takes, the default set.
+ *
+ * `listAllThreads` takes all six as well (#1128), so both callers carry the
+ * same tokens. A caller still names its own set rather than inheriting this
+ * one: the set is what decides which tokens come back as residue, and an
+ * endpoint that grows or loses a parameter has to say so where it is called.
+ */
+export declare const THREAD_SEARCH_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[];
+export interface ThreadSearchTokens {
+    /** What the tokens add to the request. */
+    params: ThreadSearchTokenParams;
+    /** The tokens the request does not carry; apply these over the rows. */
+    residual: SearchToken[];
+}
+/**
+ * Split the tokens into the parameters the thread listing takes and the residue
+ * the caller has to apply itself. `chipParams` are the parameters already set
+ * by the filter chips, which win where they overlap; `carries` names the
+ * parameters the endpoint being called actually accepts.
+ */
+export declare function threadSearchTokens(tokens: readonly SearchToken[], chipParams?: InboxFilterParams, carries?: readonly ThreadSearchTokenParamName[]): ThreadSearchTokens;
+/**
+ * The rows that satisfy every residual token. Identity when there is none.
+ *
+ * `accountId` names the account the rows belong to. A per-mailbox listing does
+ * not carry one on the row — the mailbox already answers it — and a row whose
+ * account is unknown cannot satisfy `account:`, so it drops rather than showing
+ * under a filter nothing verified.
+ */
+export declare function applyResidualTokens(threads: RemitImapThreadMessageResponse[], residual: readonly SearchToken[], accountId?: string): RemitImapThreadMessageResponse[];

package/dist/src/lib/thread-search-tokens.js

@@ -0,0 +1,116 @@
+/**
+ * The parsed search tokens as `threadOperationsSearchThreads` parameters, plus
+ * the tokens that request cannot carry.
+ *
+ * A token the request drops does not narrow anything, so the mailbox answers a
+ * weaker question than the one that was asked and returns mail the user
+ * excluded — `is:starred` handing back unstarred mail. Every token is therefore
+ * accounted for exactly once: either the request carries it, or it comes back
+ * as residue for the caller to apply over the returned rows
+ * (`matchesSearchTokens`).
+ *
+ * Membership is decided by reading the request back rather than by tracking
+ * which branch set what: a token is carried when the request that will be sent
+ * asks for exactly what the token asks for. That covers the cases where one
+ * parameter has to answer for several tokens — the endpoint takes a single
+ * `from`, a single `subject` and one boolean per state, so a second `from:` or
+ * a contradicting `is:read` cannot be expressed and becomes residue.
+ *
+ * The inbox chips own the parameters they set: a chip is a control on screen,
+ * a token is text in a field, and where they disagree the visible control wins
+ * and the token drops to residue (where, contradicting the chip, it matches
+ * nothing — which is the honest answer to a contradiction).
+ */
+import { matchesSearchTokens, toThreadRowData } from "./brief.js";
+/**
+ * Every parameter `searchThreads` takes, the default set.
+ *
+ * `listAllThreads` takes all six as well (#1128), so both callers carry the
+ * same tokens. A caller still names its own set rather than inheriting this
+ * one: the set is what decides which tokens come back as residue, and an
+ * endpoint that grows or loses a parameter has to say so where it is called.
+ */
+export const THREAD_SEARCH_TOKEN_PARAMS = ["from", "subject", "category", "unread", "starred", "attachments"];
+/** The first value wins: the endpoint takes one value per parameter. */
+const firstValue = (values) => values[0];
+const paramsFromTokens = (tokens) => {
+    const from = firstValue(tokens.filter((t) => t.type === "from").map((t) => t.value));
+    const subject = firstValue(tokens.filter((t) => t.type === "subject").map((t) => t.value));
+    const category = firstValue(tokens.filter((t) => t.type === "category").map((t) => t.category));
+    const unread = firstValue(tokens
+        .filter((t) => t.type === "isUnread" || t.type === "isRead")
+        .map((t) => t.type === "isUnread"));
+    const starred = tokens.some((t) => t.type === "isStarred") ? true : undefined;
+    const attachments = tokens.some((t) => t.type === "hasAttachment")
+        ? true
+        : undefined;
+    return {
+        ...(from !== undefined ? { from } : {}),
+        ...(subject !== undefined ? { subject } : {}),
+        ...(category !== undefined ? { category: [category] } : {}),
+        ...(unread !== undefined ? { unread } : {}),
+        ...(starred !== undefined ? { starred } : {}),
+        ...(attachments !== undefined ? { attachments } : {}),
+    };
+};
+/** Whether the request being sent asks for exactly what this token asks for. */
+const isCarried = (request, token) => {
+    switch (token.type) {
+        case "from":
+            return request.from?.toLowerCase() === token.value.toLowerCase();
+        case "subject":
+            return request.subject?.toLowerCase() === token.value.toLowerCase();
+        case "category":
+            return (request.category?.length === 1 && request.category[0] === token.category);
+        case "isUnread":
+            return request.unread === true;
+        case "isRead":
+            return request.unread === false;
+        case "isStarred":
+            return request.starred === true;
+        case "hasAttachment":
+            return request.attachments === true;
+        // No parameter on this endpoint at all: dates, the account and the
+        // mailbox are the caller's to apply.
+        case "before":
+        case "after":
+        case "in":
+        case "account":
+            return false;
+    }
+};
+const narrowTo = (params, carries) => Object.fromEntries(Object.entries(params).filter(([name]) => carries.includes(name)));
+/**
+ * Split the tokens into the parameters the thread listing takes and the residue
+ * the caller has to apply itself. `chipParams` are the parameters already set
+ * by the filter chips, which win where they overlap; `carries` names the
+ * parameters the endpoint being called actually accepts.
+ */
+export function threadSearchTokens(tokens, chipParams = {}, carries = THREAD_SEARCH_TOKEN_PARAMS) {
+    const params = narrowTo(paramsFromTokens(tokens), carries);
+    const request = {
+        ...params,
+        ...narrowTo(chipParams, carries),
+    };
+    return {
+        params,
+        residual: tokens.filter((token) => !isCarried(request, token)),
+    };
+}
+/**
+ * The rows that satisfy every residual token. Identity when there is none.
+ *
+ * `accountId` names the account the rows belong to. A per-mailbox listing does
+ * not carry one on the row — the mailbox already answers it — and a row whose
+ * account is unknown cannot satisfy `account:`, so it drops rather than showing
+ * under a filter nothing verified.
+ */
+export function applyResidualTokens(threads, residual, accountId) {
+    if (residual.length === 0)
+        return threads;
+    const tokens = [...residual];
+    return threads.filter((thread) => {
+        const row = toThreadRowData(thread);
+        return matchesSearchTokens({ ...row, accountId: row.accountId ?? accountId }, tokens);
+    });
+}

package/dist/src/lib/wizard-selection.d.ts

@@ -0,0 +1,27 @@
+import type { ThreadRowData, WizardMessage } from "@remit/ui";
+/** A ticked row, as the wizard's samples and its clause prefill read it. */
+export interface WizardSelectionMessage extends WizardMessage {
+    /** Sender address — the properties prefill matches on it. */
+    email: string;
+    /**
+     * Owning account, which a bulk run splits its batches by (#872) — the bulk
+     * endpoints refuse a batch spanning accounts before applying any of it.
+     * Stated by every surface rather than inferred: a per-mailbox list has one
+     * account for all its rows and carries none on the row, while the brief and
+     * Flagged span accounts and carry each row's own. Never `accountConfigId`,
+     * which every account of one user shares (#456).
+     */
+    accountId: string | undefined;
+    /**
+     * The folder the row sits in, when the listing says. A saved rule's first
+     * pass runs over the inbox, so a row elsewhere takes the action directly.
+     */
+    mailboxId: string | undefined;
+}
+/**
+ * The ticked rows of a thread list, as the wizard reads them. The brief and
+ * Flagged both list rows from every account and hand their selection over the
+ * same way, so they read it from here rather than each keeping a copy that has
+ * to learn about a new field twice.
+ */
+export declare const wizardSelectionFrom: (rows: readonly ThreadRowData[], selectedIds: ReadonlySet<string>) => WizardSelectionMessage[];

package/dist/src/lib/wizard-selection.js

@@ -0,0 +1,17 @@
+/**
+ * The ticked rows of a thread list, as the wizard reads them. The brief and
+ * Flagged both list rows from every account and hand their selection over the
+ * same way, so they read it from here rather than each keeping a copy that has
+ * to learn about a new field twice.
+ */
+export const wizardSelectionFrom = (rows, selectedIds) => rows
+    .filter((row) => selectedIds.has(row.id))
+    .map((row) => ({
+    id: row.id,
+    sender: row.fromName,
+    email: row.fromEmail,
+    subject: row.subject,
+    date: row.timeLabel,
+    accountId: row.accountId,
+    mailboxId: row.mailboxId,
+}));

package/dist/src/main.d.ts

@@ -0,0 +1 @@
+import "./auth/cognito/cognito.css";

package/dist/src/main.js

@@ -0,0 +1,9 @@
+// Default distributor entry: composes the app shell with the combined auth
+// provider (Cognito + better-auth, selected at runtime by `config.js`). This is
+// what `@remit/web-client-dist` ships — one artifact for every deployment. A
+// single-provider deployment writes its own entry against the primitives and
+// omits the shell it does not use.
+import "./auth/cognito/cognito.css";
+import { combinedAuthProvider } from "./auth/combined-provider";
+import { mountApp } from "./shell";
+mountApp({ authProvider: combinedAuthProvider });