@remit/web-client 0.0.324 → 0.0.326

package/dist/src/lib/request-breadcrumbs.d.ts

@@ -0,0 +1,59 @@
+/**
+ * A constant-size ring of the last few API calls, captured at the one fetch
+ * choke point (`taggedFetch` in network-error.ts). It gives a bug report the
+ * request context that a minified stack cannot: which endpoints were hit, in
+ * what order, and what they returned — plus the correlation id that ties a
+ * failing request to its server-side log line.
+ *
+ * PRIVACY — the issue tracker is public, so a breadcrumb is METADATA ONLY.
+ * Capture records the request method, the URL PATHNAME, the HTTP status, the
+ * duration, and a correlation id. It never records a request or response body,
+ * and never the query string — a search's `?q=` carries the user's query text,
+ * a message fetch's params can carry a subject. `requestPath` strips the query
+ * and hash precisely so none of that can reach the report even when the fetch
+ * layer has the full URL in hand. Opaque path ids (a message id in the path)
+ * are acceptable: they already appear in the report's URL section.
+ *
+ * Capture is cheap by construction — a fixed-size array of small records, no
+ * serialization until a report is assembled.
+ */
+export interface RequestBreadcrumb {
+    method: string;
+    /** URL pathname only — never the query string or hash (see file header). */
+    path: string;
+    /** HTTP status, or 0 when the request never reached a server (transport failure). */
+    status: number;
+    durationMs: number;
+    /** Server correlation id from a response header, when the response carried one. */
+    correlationId?: string;
+    timestamp: string;
+}
+/**
+ * The pathname of a request, with the query string and hash discarded. This is
+ * the redaction boundary: it is the only thing that reads the request URL, and
+ * it deliberately keeps nothing but the path so no query text can leak into a
+ * breadcrumb.
+ */
+export declare function requestPath(input: RequestInfo | URL): string;
+/**
+ * Record the outcome of one fetch. Called from `taggedFetch` for both a
+ * completed response and a transport failure (no response, status 0). Only the
+ * metadata listed in `RequestBreadcrumb` is read — never `init.body` or the
+ * response body.
+ */
+export declare function recordRequest(args: {
+    input: RequestInfo | URL;
+    init?: RequestInit;
+    response?: Response;
+    durationMs: number;
+}): void;
+/** The captured breadcrumbs, oldest first. A copy — callers cannot mutate the ring. */
+export declare function getRecentRequests(): readonly RequestBreadcrumb[];
+/**
+ * The most recent request that failed — a transport failure (status 0) or an
+ * HTTP error (>= 400). This is the request a report should call out explicitly,
+ * so nobody has to decode a minified stack to learn what broke.
+ */
+export declare function getFailingRequest(): RequestBreadcrumb | undefined;
+/** Test-only: clear the ring. */
+export declare function __resetRequestBreadcrumbs(): void;

package/dist/src/lib/request-breadcrumbs.js

@@ -0,0 +1,114 @@
+/**
+ * A constant-size ring of the last few API calls, captured at the one fetch
+ * choke point (`taggedFetch` in network-error.ts). It gives a bug report the
+ * request context that a minified stack cannot: which endpoints were hit, in
+ * what order, and what they returned — plus the correlation id that ties a
+ * failing request to its server-side log line.
+ *
+ * PRIVACY — the issue tracker is public, so a breadcrumb is METADATA ONLY.
+ * Capture records the request method, the URL PATHNAME, the HTTP status, the
+ * duration, and a correlation id. It never records a request or response body,
+ * and never the query string — a search's `?q=` carries the user's query text,
+ * a message fetch's params can carry a subject. `requestPath` strips the query
+ * and hash precisely so none of that can reach the report even when the fetch
+ * layer has the full URL in hand. Opaque path ids (a message id in the path)
+ * are acceptable: they already appear in the report's URL section.
+ *
+ * Capture is cheap by construction — a fixed-size array of small records, no
+ * serialization until a report is assembled.
+ */
+const MAX_ENTRIES = 10;
+const ring = [];
+/**
+ * Response headers that carry a request/trace correlation id, in preference
+ * order. `Headers.get` is case-insensitive, so the lowercase form matches
+ * whatever casing the server sent.
+ */
+const CORRELATION_HEADERS = [
+    "x-correlation-id",
+    "x-request-id",
+    "x-amzn-requestid",
+    "x-amzn-trace-id",
+    "apigw-requestid",
+    "x-trace-id",
+];
+/**
+ * The pathname of a request, with the query string and hash discarded. This is
+ * the redaction boundary: it is the only thing that reads the request URL, and
+ * it deliberately keeps nothing but the path so no query text can leak into a
+ * breadcrumb.
+ */
+export function requestPath(input) {
+    const raw = typeof input === "string"
+        ? input
+        : input instanceof URL
+            ? input.href
+            : input.url;
+    try {
+        return new URL(raw, window.location.origin).pathname;
+    }
+    catch {
+        // A non-URL input (rare) still must not leak a query — cut at the first
+        // `?` or `#` and return what precedes it.
+        return raw.split(/[?#]/)[0];
+    }
+}
+function requestMethod(input, init) {
+    if (init?.method)
+        return init.method.toUpperCase();
+    if (typeof input !== "string" && !(input instanceof URL) && input.method) {
+        return input.method.toUpperCase();
+    }
+    return "GET";
+}
+function correlationIdFrom(response) {
+    for (const header of CORRELATION_HEADERS) {
+        const value = response.headers.get(header);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function push(entry) {
+    ring.push(entry);
+    if (ring.length > MAX_ENTRIES)
+        ring.shift();
+}
+/**
+ * Record the outcome of one fetch. Called from `taggedFetch` for both a
+ * completed response and a transport failure (no response, status 0). Only the
+ * metadata listed in `RequestBreadcrumb` is read — never `init.body` or the
+ * response body.
+ */
+export function recordRequest(args) {
+    const { input, init, response, durationMs } = args;
+    push({
+        method: requestMethod(input, init),
+        path: requestPath(input),
+        status: response?.status ?? 0,
+        durationMs: Math.round(durationMs),
+        correlationId: response ? correlationIdFrom(response) : undefined,
+        timestamp: new Date().toISOString(),
+    });
+}
+/** The captured breadcrumbs, oldest first. A copy — callers cannot mutate the ring. */
+export function getRecentRequests() {
+    return ring.slice();
+}
+/**
+ * The most recent request that failed — a transport failure (status 0) or an
+ * HTTP error (>= 400). This is the request a report should call out explicitly,
+ * so nobody has to decode a minified stack to learn what broke.
+ */
+export function getFailingRequest() {
+    for (let i = ring.length - 1; i >= 0; i--) {
+        const entry = ring[i];
+        if (entry.status === 0 || entry.status >= 400)
+            return entry;
+    }
+    return undefined;
+}
+/** Test-only: clear the ring. */
+export function __resetRequestBreadcrumbs() {
+    ring.length = 0;
+}

package/dist/src/lib/rescue-candidates.d.ts

@@ -0,0 +1,17 @@
+import type { RemitImapSenderTrust, RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+/**
+ * Plain-language reason a message is safe to rescue, derived from the sender's
+ * trust tier. Never DKIM/SPF jargon — the user only sees why we trust them.
+ */
+export declare const rescueCandidateReason: (senderTrust: RemitImapSenderTrust) => string;
+/**
+ * Returns true when a thread's sender is VIP or well-known with no confirmed
+ * DKIM mismatch. Used only for telemetry (wasRescuable) when marking a message
+ * as junk — it records whether the user moved a message that was previously
+ * eligible for rescue under the client-side rule.
+ *
+ * Note: the backend rescue query uses dkimMismatch=false which also excludes
+ * senders with no authenticity signal (undefined), unlike this predicate which
+ * treats absent authenticity as eligible. The backend is stricter by design.
+ */
+export declare const isRescueCandidate: (thread: RemitImapThreadMessageResponse) => boolean;

package/dist/src/lib/rescue-candidates.js

@@ -0,0 +1,27 @@
+/**
+ * Plain-language reason a message is safe to rescue, derived from the sender's
+ * trust tier. Never DKIM/SPF jargon — the user only sees why we trust them.
+ */
+export const rescueCandidateReason = (senderTrust) => {
+    if (senderTrust === "vip")
+        return "A sender you know";
+    if (senderTrust === "wellknown")
+        return "You've emailed them before";
+    return "Passed authentication";
+};
+/**
+ * Returns true when a thread's sender is VIP or well-known with no confirmed
+ * DKIM mismatch. Used only for telemetry (wasRescuable) when marking a message
+ * as junk — it records whether the user moved a message that was previously
+ * eligible for rescue under the client-side rule.
+ *
+ * Note: the backend rescue query uses dkimMismatch=false which also excludes
+ * senders with no authenticity signal (undefined), unlike this predicate which
+ * treats absent authenticity as eligible. The backend is stricter by design.
+ */
+export const isRescueCandidate = (thread) => {
+    if (thread.senderTrust !== "vip" && thread.senderTrust !== "wellknown") {
+        return false;
+    }
+    return thread.authenticity?.dkimMismatch !== true;
+};

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

@@ -0,0 +1,26 @@
+import type { RemitImapSenderTrust } from "@remit/api-http-client/types.gen.ts";
+import type { Telemetry } from "./telemetry";
+/**
+ * Rescue-from-Spam telemetry. Shapes the small, privacy-safe payloads (counts,
+ * folder roles, booleans — never bodies or addresses) and emits them through the
+ * shared `recordEvent` channel, matching the `domain.action` event-name
+ * convention used across the client.
+ */
+export declare function recordRescueCandidatesSurfaced(telemetry: Telemetry, count: number): void;
+export declare function recordRescueFlowOpened(telemetry: Telemetry, count: number): void;
+export declare function recordRescueCommitted(telemetry: Telemetry, input: {
+    selected: number;
+    total: number;
+    toInbox: boolean;
+}): void;
+/**
+ * The reverse signal: a message moved back into Junk. `wasRescuable` is the best
+ * cheaply-available prior-rescue proxy — the sender is one we can verify, so the
+ * user is overriding our trust. There is no per-message "was previously rescued"
+ * flag in the client, so we do not claim one.
+ */
+export declare function recordRescueSentToJunk(telemetry: Telemetry, input: {
+    count: number;
+    senderTrust: RemitImapSenderTrust;
+    wasRescuable: boolean;
+}): void;

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

@@ -0,0 +1,32 @@
+/**
+ * Rescue-from-Spam telemetry. Shapes the small, privacy-safe payloads (counts,
+ * folder roles, booleans — never bodies or addresses) and emits them through the
+ * shared `recordEvent` channel, matching the `domain.action` event-name
+ * convention used across the client.
+ */
+export function recordRescueCandidatesSurfaced(telemetry, count) {
+    telemetry.recordEvent("rescue.candidates_surfaced", { count: String(count) });
+}
+export function recordRescueFlowOpened(telemetry, count) {
+    telemetry.recordEvent("rescue.flow_opened", { count: String(count) });
+}
+export function recordRescueCommitted(telemetry, input) {
+    telemetry.recordEvent("rescue.committed", {
+        selected: String(input.selected),
+        total: String(input.total),
+        destination: input.toInbox ? "inbox" : "other",
+    });
+}
+/**
+ * The reverse signal: a message moved back into Junk. `wasRescuable` is the best
+ * cheaply-available prior-rescue proxy — the sender is one we can verify, so the
+ * user is overriding our trust. There is no per-message "was previously rescued"
+ * flag in the client, so we do not claim one.
+ */
+export function recordRescueSentToJunk(telemetry, input) {
+    telemetry.recordEvent("rescue.sent_to_junk", {
+        count: String(input.count),
+        senderTrust: input.senderTrust,
+        wasRescuable: String(input.wasRescuable),
+    });
+}

package/dist/src/lib/result-count.d.ts

@@ -0,0 +1,43 @@
+import type { ResultCount } from "@remit/ui";
+/**
+ * Shortest free text a count is asked for. A one- or two-character prefix
+ * matches most words in the search index, so counting one walks most of the
+ * mailbox per typed character. The list itself still pages — only the count
+ * waits.
+ */
+export declare const MIN_COUNTED_QUERY_LENGTH = 3;
+export interface ResultCountRequestInput {
+    /** True while the list is answering a search rather than plain browsing. */
+    hasSearchQuery: boolean;
+    /** The literal text of the search, with its filter tokens already taken out. */
+    freeText: string;
+    /**
+     * Tokens the request could not carry — `before:`, `after:`, `account:`, and
+     * any second value for a parameter that takes one — applied over the rows
+     * after they arrive.
+     */
+    residualTokenCount: number;
+}
+/**
+ * Whether the exact match count is worth one request against these criteria.
+ *
+ * Chip- and token-driven criteria are counted straight away: they change once
+ * per click, and the predicate is one the index answers. Free text is counted
+ * only once it is long enough to be indexed, which is what keeps a per-character
+ * query from paying for a count it will throw away on the next keystroke.
+ *
+ * A residual token stops the count outright. The server never saw that term, so
+ * it would count a wider set than the list shows — and two searches differing
+ * only by one reach the request as the same criteria, so the answer would also
+ * be the one the previous search left in the cache.
+ */
+export declare const shouldRequestResultCount: ({ hasSearchQuery, freeText, residualTokenCount, }: ResultCountRequestInput) => boolean;
+/**
+ * The server's answer, or no number.
+ *
+ * The only input is `ThreadSearchResponse.count`, which is the whole match set
+ * or absent (#305) — never a page length. Absent stays absent: a count the
+ * server declined to compute is not zero, and the surface renders nothing
+ * rather than a figure it made up.
+ */
+export declare const toResultCount: (count: number | undefined) => ResultCount;

package/dist/src/lib/result-count.js

@@ -0,0 +1,37 @@
+/**
+ * Shortest free text a count is asked for. A one- or two-character prefix
+ * matches most words in the search index, so counting one walks most of the
+ * mailbox per typed character. The list itself still pages — only the count
+ * waits.
+ */
+export const MIN_COUNTED_QUERY_LENGTH = 3;
+/**
+ * Whether the exact match count is worth one request against these criteria.
+ *
+ * Chip- and token-driven criteria are counted straight away: they change once
+ * per click, and the predicate is one the index answers. Free text is counted
+ * only once it is long enough to be indexed, which is what keeps a per-character
+ * query from paying for a count it will throw away on the next keystroke.
+ *
+ * A residual token stops the count outright. The server never saw that term, so
+ * it would count a wider set than the list shows — and two searches differing
+ * only by one reach the request as the same criteria, so the answer would also
+ * be the one the previous search left in the cache.
+ */
+export const shouldRequestResultCount = ({ hasSearchQuery, freeText, residualTokenCount, }) => {
+    if (!hasSearchQuery)
+        return false;
+    if (residualTokenCount > 0)
+        return false;
+    const typed = freeText.trim();
+    return typed.length === 0 || typed.length >= MIN_COUNTED_QUERY_LENGTH;
+};
+/**
+ * The server's answer, or no number.
+ *
+ * The only input is `ThreadSearchResponse.count`, which is the whole match set
+ * or absent (#305) — never a page length. Absent stays absent: a count the
+ * server declined to compute is not zero, and the surface renders nothing
+ * rather than a figure it made up.
+ */
+export const toResultCount = (count) => count === undefined ? { kind: "unknown" } : { kind: "exact", value: count };

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

@@ -0,0 +1,57 @@
+/**
+ * Where a search result was read from.
+ *
+ * A global search returns rows from every folder of every account, so each row
+ * says where it came from and spam is held out of the list. Both questions are
+ * answered by joining the row's mailbox ids against the mailbox lists the
+ * sidebar already loads: the id → folder map here is the only thing either
+ * needs, so the search API does not have to carry a folder.
+ *
+ * The mailbox row carries the hierarchy delimiter its own server reports, and it
+ * is kept alongside the path: a chip labelled by path shows the folder's own
+ * name, which on a `.`-delimited account cannot be cut on a slash.
+ *
+ * The role comes from the account's `folderAppointments` map (RFC 032), which
+ * the server resolves from the IMAP SPECIAL-USE attributes — so `junk` means the
+ * folder the account advertises as `\Junk`, whatever it is called. Names are
+ * never consulted.
+ */
+import type { RemitImapFolderAppointment, RemitImapMailboxResponse } from "@remit/api-http-client/types.gen.ts";
+import { type ResultFolder } from "@remit/ui";
+export type ResultFolderIndex = ReadonlyMap<string, ResultFolder>;
+export declare const EMPTY_RESULT_FOLDER_INDEX: ResultFolderIndex;
+export interface AccountMailboxes {
+    folderAppointments: readonly RemitImapFolderAppointment[];
+    mailboxes: readonly Pick<RemitImapMailboxResponse, "mailboxId" | "fullPath" | "hierarchyDelimiter">[];
+}
+/**
+ * The appointments and the mailbox list arrive from two different queries, so
+ * the roles are seeded first and the provider paths laid over them. A role on
+ * its own is enough to hold spam out of a global search, which means the list
+ * loading late cannot let a Spam row through into the results.
+ */
+export declare function buildResultFolderIndex(accounts: readonly AccountMailboxes[]): ResultFolderIndex;
+/**
+ * Every junk folder the index knows, in index order.
+ *
+ * The same `\Junk` appointment that holds a row out of a global search, read
+ * the other way round: these are the folders whose contents the Spam offer
+ * counts. Order is the accounts' own, so the offer's destination does not move
+ * between renders (#313).
+ */
+export declare function junkMailboxIds(folders: ResultFolderIndex): string[];
+export interface ResolvedResultFolder {
+    mailboxId?: string;
+    folder?: ResultFolder;
+}
+/**
+ * The mailbox a result should be attributed to, and its folder.
+ *
+ * A message can sit in several mailboxes at once — Gmail files a copy of most
+ * mail in All Mail — and the order the ids arrive in carries no meaning, so the
+ * first id that names a real place wins. `provenanceFolderLabel` is the test:
+ * it is undefined exactly for the folders that are views rather than places.
+ * With nothing resolvable the first id is still returned, because opening the
+ * result needs a mailbox even when labelling it does not.
+ */
+export declare function resolveResultFolder(folders: ResultFolderIndex | undefined, mailboxIds: readonly string[]): ResolvedResultFolder;

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

@@ -0,0 +1,67 @@
+import { provenanceFolderLabel } from "@remit/ui";
+import { buildMailboxRoleMap } from "./folder-roles.js";
+export const EMPTY_RESULT_FOLDER_INDEX = new Map();
+/**
+ * The appointments and the mailbox list arrive from two different queries, so
+ * the roles are seeded first and the provider paths laid over them. A role on
+ * its own is enough to hold spam out of a global search, which means the list
+ * loading late cannot let a Spam row through into the results.
+ */
+export function buildResultFolderIndex(accounts) {
+    const index = new Map();
+    for (const account of accounts) {
+        const roles = buildMailboxRoleMap(account.folderAppointments);
+        for (const [mailboxId, role] of roles)
+            index.set(mailboxId, { role });
+        for (const mailbox of account.mailboxes) {
+            const role = roles.get(mailbox.mailboxId);
+            const path = {
+                providerPath: mailbox.fullPath,
+                hierarchyDelimiter: mailbox.hierarchyDelimiter,
+            };
+            index.set(mailbox.mailboxId, role ? { role, ...path } : path);
+        }
+    }
+    return index;
+}
+/**
+ * Every junk folder the index knows, in index order.
+ *
+ * The same `\Junk` appointment that holds a row out of a global search, read
+ * the other way round: these are the folders whose contents the Spam offer
+ * counts. Order is the accounts' own, so the offer's destination does not move
+ * between renders (#313).
+ */
+export function junkMailboxIds(folders) {
+    const ids = [];
+    for (const [mailboxId, folder] of folders) {
+        if (folder.role === "junk")
+            ids.push(mailboxId);
+    }
+    return ids;
+}
+/**
+ * The mailbox a result should be attributed to, and its folder.
+ *
+ * A message can sit in several mailboxes at once — Gmail files a copy of most
+ * mail in All Mail — and the order the ids arrive in carries no meaning, so the
+ * first id that names a real place wins. `provenanceFolderLabel` is the test:
+ * it is undefined exactly for the folders that are views rather than places.
+ * With nothing resolvable the first id is still returned, because opening the
+ * result needs a mailbox even when labelling it does not.
+ */
+export function resolveResultFolder(folders, mailboxIds) {
+    const first = mailboxIds[0];
+    if (!folders)
+        return first ? { mailboxId: first } : {};
+    for (const mailboxId of mailboxIds) {
+        const folder = folders.get(mailboxId);
+        if (folder && provenanceFolderLabel(folder) !== undefined) {
+            return { mailboxId, folder };
+        }
+    }
+    if (!first)
+        return {};
+    const folder = folders.get(first);
+    return { mailboxId: first, ...(folder ? { folder } : {}) };
+}

package/dist/src/lib/route-breadcrumbs.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A constant-size ring of the last few in-app navigations, captured from the
+ * router's `onResolved` event (see router.tsx). It gives a bug report a
+ * navigation trail, so "Steps to reproduce" has something concrete even when
+ * the reporter leaves the template blank.
+ *
+ * PRIVACY — like request breadcrumbs, this is METADATA ONLY and the tracker is
+ * public. A route entry is the resolved PATHNAME and a timestamp. The query
+ * string is dropped: a search route's `?q=` carries the user's query text.
+ * Opaque path ids (a message id in the path) are acceptable — they already
+ * appear in the report's URL section.
+ */
+export interface RouteBreadcrumb {
+    /** Resolved pathname only — never the query string (see file header). */
+    path: string;
+    timestamp: string;
+}
+/**
+ * Record a navigation. `path` is expected to be a pathname; any query or hash
+ * is stripped defensively so a caller passing a full location cannot leak query
+ * text into a breadcrumb.
+ */
+export declare function recordRoute(path: string): void;
+/** The captured navigations, oldest first. A copy — callers cannot mutate the ring. */
+export declare function getRecentRoutes(): readonly RouteBreadcrumb[];
+/** Test-only: clear the ring. */
+export declare function __resetRouteBreadcrumbs(): void;

package/dist/src/lib/route-breadcrumbs.js

@@ -0,0 +1,36 @@
+/**
+ * A constant-size ring of the last few in-app navigations, captured from the
+ * router's `onResolved` event (see router.tsx). It gives a bug report a
+ * navigation trail, so "Steps to reproduce" has something concrete even when
+ * the reporter leaves the template blank.
+ *
+ * PRIVACY — like request breadcrumbs, this is METADATA ONLY and the tracker is
+ * public. A route entry is the resolved PATHNAME and a timestamp. The query
+ * string is dropped: a search route's `?q=` carries the user's query text.
+ * Opaque path ids (a message id in the path) are acceptable — they already
+ * appear in the report's URL section.
+ */
+const MAX_ENTRIES = 8;
+const ring = [];
+/**
+ * Record a navigation. `path` is expected to be a pathname; any query or hash
+ * is stripped defensively so a caller passing a full location cannot leak query
+ * text into a breadcrumb.
+ */
+export function recordRoute(path) {
+    const clean = path.split(/[?#]/)[0];
+    const last = ring[ring.length - 1];
+    if (last && last.path === clean)
+        return;
+    ring.push({ path: clean, timestamp: new Date().toISOString() });
+    if (ring.length > MAX_ENTRIES)
+        ring.shift();
+}
+/** The captured navigations, oldest first. A copy — callers cannot mutate the ring. */
+export function getRecentRoutes() {
+    return ring.slice();
+}
+/** Test-only: clear the ring. */
+export function __resetRouteBreadcrumbs() {
+    ring.length = 0;
+}

package/dist/src/lib/row-settlement.d.ts

@@ -0,0 +1,11 @@
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import type { ThreadRowData } from "@remit/ui";
+/**
+ * The row treatment for a message whose mutation Remit gave up on (issue
+ * #1002). The client decides nothing: `abandonedMutationOf` owns which values
+ * prove a terminal give-up and which operation it was. A copy that gave up
+ * leaves a `deleted` row no listing carries, so it reaches no row here; any
+ * other row — settled, mid-retry, or in flight — carries no key at all and
+ * renders exactly as it always has.
+ */
+export declare const rowSettlement: (thread: Pick<RemitImapThreadMessageResponse, "status" | "syncStatus" | "abandonedMutation">) => Pick<ThreadRowData, "settlement">;

package/dist/src/lib/row-settlement.js

@@ -0,0 +1,20 @@
+import { abandonedMutationOf } from "@remit/data-ports/message-settlement";
+import { MessageMutation } from "@remit/domain-enums";
+/**
+ * The row treatment for a message whose mutation Remit gave up on (issue
+ * #1002). The client decides nothing: `abandonedMutationOf` owns which values
+ * prove a terminal give-up and which operation it was. A copy that gave up
+ * leaves a `deleted` row no listing carries, so it reaches no row here; any
+ * other row — settled, mid-retry, or in flight — carries no key at all and
+ * renders exactly as it always has.
+ */
+export const rowSettlement = (thread) => {
+    switch (abandonedMutationOf(thread)) {
+        case MessageMutation.delete:
+            return { settlement: "delete_failed" };
+        case MessageMutation.move:
+            return { settlement: "move_failed" };
+        default:
+            return {};
+    }
+};

package/dist/src/lib/rum-adapter.d.ts

@@ -0,0 +1,4 @@
+import { AwsRum } from "aws-rum-web";
+import type { Telemetry } from "./telemetry";
+export declare function createRumTelemetry(rum: AwsRum): Telemetry;
+export declare function initRum(): Telemetry;