@remit/web-client 0.0.1

package/src/hooks/useStaleAccountSync.ts

@@ -0,0 +1,246 @@
+import { mailboxOperationsListMailboxesQueryKey } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { syncOperationsTriggerSync } from "@remit/api-http-client/sdk.gen.ts";
+import type { RemitImapAccountResponse } from "@remit/api-http-client/types.gen.ts";
+import { type QueryClient, useQueryClient } from "@tanstack/react-query";
+import pMap from "p-map";
+import { useEffect, useRef } from "react";
+import { shouldEscalate } from "@/lib/error-classifier";
+import { reportFatalError } from "@/lib/fatal-error";
+import { getRuntimeConfig } from "@/runtime-config";
+
+/**
+ * Mailboxes are considered stale 15 minutes after the last successful sync.
+ * Exposed for unit tests and possible future tuning.
+ */
+export const STALENESS_THRESHOLD_MS = 15 * 60 * 1000;
+
+const DEFAULT_POLL_INTERVAL_SECONDS = 5 * 60;
+
+const parsePositiveIntSeconds = (
+	raw: string | undefined,
+	fallback: number,
+): number => {
+	if (!raw) return fallback;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+
+/**
+ * Client-side online-poll interval (#1251): while an account's mail is open,
+ * the tab re-triggers the same sync the pull-to-refresh path uses on this
+ * cadence — the replacement for the server's removed "online tier".
+ */
+export const POLL_INTERVAL_MS =
+	parsePositiveIntSeconds(
+		getRuntimeConfig().mailboxPollIntervalSeconds,
+		DEFAULT_POLL_INTERVAL_SECONDS,
+	) * 1000;
+
+/**
+ * Bounded concurrency for the per-poll fan-out across open accounts —
+ * mirrors `SCHEDULER_ENQUEUE_CONCURRENCY` in
+ * remit-imap-worker/src/scheduler/config.ts (never an unbounded
+ * `Promise.all`, see doc/rules/coding-standards.md). A browser tab realistically
+ * has a handful of accounts open at once, so this is a ceiling, not a tuned
+ * throughput target.
+ */
+export const POLL_CONCURRENCY = 5;
+
+/**
+ * Module-level guard: which accounts have already had a background sync
+ * fired in this browser tab's session. Survives layout re-mounts (route
+ * changes) so re-mounting MailLayout does not spam SQS.
+ */
+const triggeredAccountIds = new Set<string>();
+
+interface AccountLike {
+	accountId: string;
+	lastSyncAt?: number;
+}
+
+/**
+ * Pure selector: given a list of accounts and the current time, return
+ * the accountIds whose mailbox-list is stale and should be refreshed.
+ * `null`/`undefined` `lastSyncAt` is treated as stale unconditionally.
+ */
+export const selectStaleAccountIds = (
+	accounts: AccountLike[],
+	now: number,
+	thresholdMs: number = STALENESS_THRESHOLD_MS,
+): string[] =>
+	accounts
+		.filter((account) => {
+			const last = account.lastSyncAt;
+			if (last === undefined || last === null) return true;
+			return now - last > thresholdMs;
+		})
+		.map((account) => account.accountId);
+
+/**
+ * Pure predicate: has at least one full poll interval elapsed since the last
+ * poll? Shared by the recurring timer and the visibility-regain catch-up
+ * check so both use the exact same due-ness rule.
+ */
+export const hasPollIntervalElapsed = (
+	now: number,
+	lastPollAt: number,
+	intervalMs: number = POLL_INTERVAL_MS,
+): boolean => now - lastPollAt >= intervalMs;
+
+/**
+ * Pure selector: drop any accountId already mid-flight so a poll tick never
+ * stacks a second request onto one still in progress.
+ */
+export const selectPollableAccountIds = (
+	accountIds: string[],
+	inFlight: ReadonlySet<string>,
+): string[] => accountIds.filter((id) => !inFlight.has(id));
+
+/**
+ * Test-only helpers. Not exported from the public hook surface; consumers
+ * should never reach into the module-level Set directly.
+ */
+export const __resetStaleAccountSyncGuard = (): void => {
+	triggeredAccountIds.clear();
+};
+export const __peekStaleAccountSyncGuard = (): ReadonlySet<string> =>
+	triggeredAccountIds;
+
+/**
+ * Handle a failed background mailbox-sync trigger. This is a best-effort, direct
+ * SDK probe (not a React Query call), so we apply the same fail-fast decision by
+ * hand with the `softError` meta the call site owns: its non-5xx failures (the
+ * account's own 4xx, a statusless connectivity blip) stay soft — we drop the
+ * per-account guard so a later remount can retry, then log and move on. But a
+ * 5xx is OUR API broken, and per the contract (#1059) that always escalates to
+ * the full-screen overlay — even from a background trigger.
+ */
+export const handleBackgroundSyncFailure = (
+	accountId: string,
+	error: unknown,
+): void => {
+	triggeredAccountIds.delete(accountId);
+	if (shouldEscalate(error, { softError: true })) {
+		reportFatalError(error);
+		return;
+	}
+	console.warn("[remit] background mailbox sync failed", {
+		accountId,
+		error,
+	});
+};
+
+/**
+ * Trigger the same sync the pull-to-refresh path uses and invalidate the
+ * mailbox-list query on success. `throwOnError: true` so a server failure
+ * rejects instead of silently resolving with `{ error }` (the default),
+ * which would let a 500 look like a successful sync and invalidate queries
+ * anyway.
+ */
+const runBackgroundSync = (
+	accountId: string,
+	queryClient: QueryClient,
+): Promise<void> =>
+	syncOperationsTriggerSync({ path: { accountId }, throwOnError: true }).then(
+		() => {
+			queryClient.invalidateQueries({
+				queryKey: mailboxOperationsListMailboxesQueryKey({
+					path: { accountId },
+				}),
+			});
+		},
+	);
+
+/**
+ * Auto-trigger a background mailbox-list sync for every stale account the
+ * first time MailLayout mounts in a session, then keep it fresh with a
+ * recurring online poll for as long as the mail app stays open (#1251) —
+ * the client-side replacement for the server's removed "online" sync tier.
+ * Fire-and-forget: does not block render, and silently logs failures (this
+ * is a best-effort background refresh — the user-visible UI for triggering
+ * is the "Refresh mailboxes" button in Settings).
+ */
+export const useStaleAccountSync = (
+	accounts: RemitImapAccountResponse[],
+): void => {
+	const queryClient = useQueryClient();
+	// Hold the latest accounts in a ref so both effects can read them without
+	// re-running on every render; they re-run only when the joined accountId
+	// list actually changes (account added / removed).
+	const accountsRef = useRef(accounts);
+	accountsRef.current = accounts;
+	const stableKey = accounts.map((a) => a.accountId).join(",");
+
+	// biome-ignore lint/correctness/useExhaustiveDependencies: stableKey is a serialized account list used to trigger re-sync on account changes; adding it would cause issues without also referencing accountsRef
+	useEffect(() => {
+		const now = Date.now();
+		const stale = selectStaleAccountIds(accountsRef.current, now);
+		const fresh = stale.filter((id) => !triggeredAccountIds.has(id));
+		if (fresh.length === 0) return;
+
+		for (const accountId of fresh) {
+			triggeredAccountIds.add(accountId);
+			runBackgroundSync(accountId, queryClient).catch((err: unknown) => {
+				handleBackgroundSyncFailure(accountId, err);
+			});
+		}
+	}, [stableKey, queryClient]);
+
+	// biome-ignore lint/correctness/useExhaustiveDependencies: stableKey re-runs the poll loop when the account list changes; accountsRef supplies the live list each tick
+	useEffect(() => {
+		let lastPollAt = Date.now();
+		let timeoutId: ReturnType<typeof setTimeout> | undefined;
+		const inFlight = new Set<string>();
+
+		const poll = () => {
+			lastPollAt = Date.now();
+			const ids = selectPollableAccountIds(
+				accountsRef.current.map((a) => a.accountId),
+				inFlight,
+			);
+			// Mark every selected id in flight before dispatch (not as pMap
+			// starts each one) so a concurrency-queued id still counts as
+			// "already polling" for the next tick's `selectPollableAccountIds`
+			// check — no stacked requests even while waiting for a free slot.
+			for (const accountId of ids) inFlight.add(accountId);
+			void pMap(
+				ids,
+				(accountId) =>
+					runBackgroundSync(accountId, queryClient)
+						.catch((err: unknown) => {
+							handleBackgroundSyncFailure(accountId, err);
+						})
+						.finally(() => {
+							inFlight.delete(accountId);
+						}),
+				{ concurrency: POLL_CONCURRENCY },
+			);
+		};
+
+		const tick = () => {
+			if (document.visibilityState === "visible") {
+				poll();
+				timeoutId = setTimeout(tick, POLL_INTERVAL_MS);
+				return;
+			}
+			// Hidden: don't reschedule. `handleVisibilityChange` resumes the loop
+			// (with an immediate catch-up poll) once the tab is visible again.
+		};
+
+		const handleVisibilityChange = () => {
+			if (document.visibilityState !== "visible") return;
+			if (!hasPollIntervalElapsed(Date.now(), lastPollAt)) return;
+			if (timeoutId !== undefined) clearTimeout(timeoutId);
+			poll();
+			timeoutId = setTimeout(tick, POLL_INTERVAL_MS);
+		};
+
+		timeoutId = setTimeout(tick, POLL_INTERVAL_MS);
+		document.addEventListener("visibilitychange", handleVisibilityChange);
+
+		return () => {
+			if (timeoutId !== undefined) clearTimeout(timeoutId);
+			document.removeEventListener("visibilitychange", handleVisibilityChange);
+		};
+	}, [stableKey, queryClient]);
+};

package/src/hooks/useSwipeNavigation.test.ts

@@ -0,0 +1,35 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { resolveSwipe } from "./useSwipeNavigation.js";
+
+const THRESHOLD = 60;
+
+describe("resolveSwipe", () => {
+	test("classifies a left swipe (next) when dragging right→left", () => {
+		assert.strictEqual(resolveSwipe(-80, 0, THRESHOLD).direction, "left");
+	});
+
+	test("classifies a right swipe (previous) when dragging left→right", () => {
+		assert.strictEqual(resolveSwipe(80, 0, THRESHOLD).direction, "right");
+	});
+
+	test("ignores a gesture shorter than the threshold", () => {
+		assert.strictEqual(resolveSwipe(-40, 0, THRESHOLD).direction, null);
+		assert.strictEqual(resolveSwipe(59, 0, THRESHOLD).direction, null);
+	});
+
+	test("ignores a mostly-vertical gesture so it never hijacks scroll", () => {
+		// Long horizontal travel but even longer vertical travel: this is a scroll.
+		assert.strictEqual(resolveSwipe(70, 200, THRESHOLD).direction, null);
+		assert.strictEqual(resolveSwipe(-70, -200, THRESHOLD).direction, null);
+	});
+
+	test("accepts a horizontal swipe with mild vertical drift", () => {
+		assert.strictEqual(resolveSwipe(-100, 20, THRESHOLD).direction, "left");
+	});
+
+	test("rejects a diagonal gesture that is not horizontally dominant", () => {
+		// dx 70, dy 60: not 1.5x dominant, so treated as ambiguous → no swipe.
+		assert.strictEqual(resolveSwipe(70, 60, THRESHOLD).direction, null);
+	});
+});

package/src/hooks/useSwipeNavigation.ts

@@ -0,0 +1,99 @@
+import { useCallback, useRef } from "react";
+
+export type SwipeDirection = "left" | "right";
+
+interface UseSwipeNavigationOptions {
+	/**
+	 * Swipe left (content advances, finger moves right→left): go to the NEXT
+	 * item — the platform convention for paging through content (photos, mail).
+	 */
+	onSwipeLeft?: () => void;
+	/** Swipe right: go to the PREVIOUS item. */
+	onSwipeRight?: () => void;
+	/** Minimum horizontal travel (px) before a swipe registers. */
+	thresholdPx?: number;
+}
+
+interface SwipeHandlers {
+	onPointerDown: (e: React.PointerEvent) => void;
+	onPointerMove: (e: React.PointerEvent) => void;
+	onPointerUp: (e: React.PointerEvent) => void;
+	onPointerCancel: () => void;
+}
+
+const DEFAULT_THRESHOLD = 60;
+/**
+ * A gesture only counts as a horizontal swipe when its horizontal travel
+ * dominates the vertical. Anything more vertical than this is the user
+ * scrolling the message body, and we leave it alone.
+ */
+const HORIZONTAL_DOMINANCE = 1.5;
+
+export interface SwipeResolution {
+	direction: SwipeDirection | null;
+}
+
+/**
+ * Pure swipe classifier. Returns the swipe direction, or `null` when the
+ * gesture is too short or too vertical to count as a horizontal swipe (so it
+ * never hijacks vertical scrolling).
+ */
+export const resolveSwipe = (
+	dx: number,
+	dy: number,
+	thresholdPx: number,
+): SwipeResolution => {
+	const absX = Math.abs(dx);
+	const absY = Math.abs(dy);
+	if (absX < thresholdPx) return { direction: null };
+	if (absX < absY * HORIZONTAL_DOMINANCE) return { direction: null };
+	return { direction: dx < 0 ? "left" : "right" };
+};
+
+/**
+ * Detects horizontal swipe gestures from pointer events and routes them to
+ * next/previous callbacks. Only reacts to touch/pen pointers so mouse drags on
+ * desktop never trigger navigation. Vertical scroll is left untouched: a
+ * gesture must travel mostly sideways to register.
+ */
+export const useSwipeNavigation = ({
+	onSwipeLeft,
+	onSwipeRight,
+	thresholdPx = DEFAULT_THRESHOLD,
+}: UseSwipeNavigationOptions): { handlers: SwipeHandlers } => {
+	const startRef = useRef<{ x: number; y: number } | null>(null);
+
+	const onPointerDown = useCallback((e: React.PointerEvent) => {
+		if (e.pointerType === "mouse") {
+			startRef.current = null;
+			return;
+		}
+		startRef.current = { x: e.clientX, y: e.clientY };
+	}, []);
+
+	const onPointerMove = useCallback(() => {}, []);
+
+	const onPointerUp = useCallback(
+		(e: React.PointerEvent) => {
+			const start = startRef.current;
+			startRef.current = null;
+			if (!start) return;
+			const { direction } = resolveSwipe(
+				e.clientX - start.x,
+				e.clientY - start.y,
+				thresholdPx,
+			);
+			if (direction === "left") onSwipeLeft?.();
+			if (direction === "right") onSwipeRight?.();
+		},
+		[onSwipeLeft, onSwipeRight, thresholdPx],
+	);
+
+	const onPointerCancel = useCallback(() => {
+		startRef.current = null;
+	}, []);
+
+	return {
+		handlers: { onPointerDown, onPointerMove, onPointerUp, onPointerCancel },
+	};
+};

package/src/hooks/useToggleStar.ts

@@ -0,0 +1,187 @@
+import {
+	messageOperationsUpdateMessageFlagsMutation,
+	threadDetailOperationsListThreadMessagesQueryKey,
+	threadOperationsListThreadsQueryKey,
+	threadOperationsSearchThreadsQueryKey,
+} from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
+import { formatErrorDetail } from "@/components/ui/error-banners";
+
+interface UseToggleStarOptions {
+	threadId: string;
+	mailboxId: string;
+}
+
+interface ThreadMessagesData {
+	items: RemitImapThreadMessageResponse[];
+	[key: string]: unknown;
+}
+
+interface ThreadsListPage {
+	items: RemitImapThreadMessageResponse[];
+	[key: string]: unknown;
+}
+
+interface ThreadsListData {
+	pages: ThreadsListPage[];
+	pageParams: Array<string | undefined>;
+}
+
+interface SnapshotEntry<T> {
+	queryKey: readonly unknown[];
+	data: T;
+}
+
+interface ToggleStarContext {
+	threadMessagesPrefix: readonly unknown[];
+	threadsListPrefix: readonly unknown[];
+	threadsSearchPrefix: readonly unknown[];
+	previousThreadMessages: SnapshotEntry<ThreadMessagesData>[];
+	previousThreadsList: SnapshotEntry<ThreadsListData>[];
+}
+
+const toggleStarsInItems = (
+	items: RemitImapThreadMessageResponse[],
+	messageId: string,
+	nextStarred: boolean,
+): RemitImapThreadMessageResponse[] =>
+	items.map((item) =>
+		item.messageId === messageId ? { ...item, hasStars: nextStarred } : item,
+	);
+
+export const useToggleStar = ({
+	threadId,
+	mailboxId,
+}: UseToggleStarOptions) => {
+	const queryClient = useQueryClient();
+	const { pushError } = useErrorBanners();
+
+	const { mutate, isPending, variables } = useMutation({
+		...messageOperationsUpdateMessageFlagsMutation(),
+		onMutate: async (vars): Promise<ToggleStarContext> => {
+			const messageId = vars.path.messageId;
+			const nextStarred = vars.body.isStarred ?? false;
+
+			// Use partial-key prefixes so the cancel/snapshot/patch covers the
+			// full key (which includes query options like { order: "desc",
+			// mailboxId }) without us having to enumerate every variant. React
+			// Query matches by prefix on the first key element.
+			const threadMessagesPrefix =
+				threadDetailOperationsListThreadMessagesQueryKey({
+					path: { threadId },
+				});
+			const threadsListPrefix = threadOperationsListThreadsQueryKey({
+				path: { mailboxId },
+			});
+			const threadsSearchPrefix = threadOperationsSearchThreadsQueryKey({
+				path: { mailboxId },
+			});
+
+			await Promise.all([
+				queryClient.cancelQueries({ queryKey: threadMessagesPrefix }),
+				queryClient.cancelQueries({ queryKey: threadsListPrefix }),
+				queryClient.cancelQueries({ queryKey: threadsSearchPrefix }),
+			]);
+
+			const previousThreadMessages = queryClient
+				.getQueriesData<ThreadMessagesData>({ queryKey: threadMessagesPrefix })
+				.filter(
+					(entry): entry is [readonly unknown[], ThreadMessagesData] =>
+						entry[1] !== undefined,
+				)
+				.map(([queryKey, data]) => ({ queryKey, data }));
+
+			const previousThreadsList = queryClient
+				.getQueriesData<ThreadsListData>({ queryKey: threadsListPrefix })
+				.concat(
+					queryClient.getQueriesData<ThreadsListData>({
+						queryKey: threadsSearchPrefix,
+					}),
+				)
+				.filter(
+					(entry): entry is [readonly unknown[], ThreadsListData] =>
+						entry[1] !== undefined,
+				)
+				.map(([queryKey, data]) => ({ queryKey, data }));
+
+			queryClient.setQueriesData<ThreadMessagesData>(
+				{ queryKey: threadMessagesPrefix },
+				(old) => {
+					if (!old) return old;
+					return {
+						...old,
+						items: toggleStarsInItems(old.items, messageId, nextStarred),
+					};
+				},
+			);
+
+			const patchListData = (old: ThreadsListData | undefined) => {
+				if (!old) return old;
+				return {
+					...old,
+					pages: old.pages.map((page) => ({
+						...page,
+						items: toggleStarsInItems(page.items, messageId, nextStarred),
+					})),
+				};
+			};
+
+			queryClient.setQueriesData<ThreadsListData>(
+				{ queryKey: threadsListPrefix },
+				patchListData,
+			);
+			queryClient.setQueriesData<ThreadsListData>(
+				{ queryKey: threadsSearchPrefix },
+				patchListData,
+			);
+
+			return {
+				threadMessagesPrefix,
+				threadsListPrefix,
+				threadsSearchPrefix,
+				previousThreadMessages,
+				previousThreadsList,
+			};
+		},
+		onError: (err, vars, context) => {
+			if (context) {
+				for (const entry of context.previousThreadMessages) {
+					queryClient.setQueryData(entry.queryKey, entry.data);
+				}
+				for (const entry of context.previousThreadsList) {
+					queryClient.setQueryData(entry.queryKey, entry.data);
+				}
+			}
+			const nextStarred = vars.body.isStarred ?? false;
+			pushError({
+				title: nextStarred
+					? "Couldn't star message"
+					: "Couldn't unstar message",
+				detail: formatErrorDetail(err),
+			});
+		},
+		onSettled: (_data, _err, _vars, context) => {
+			if (!context) return;
+			queryClient.invalidateQueries({ queryKey: context.threadMessagesPrefix });
+			queryClient.invalidateQueries({ queryKey: context.threadsListPrefix });
+			queryClient.invalidateQueries({ queryKey: context.threadsSearchPrefix });
+		},
+	});
+
+	const toggleStar = (messageId: string, currentlyStarred: boolean) => {
+		mutate({
+			path: { messageId },
+			body: {
+				isStarred: !currentlyStarred,
+			},
+		});
+	};
+
+	return {
+		toggleStar,
+		isPending,
+		pendingMessageId: isPending ? variables?.path.messageId : undefined,
+	};
+};

package/src/hooks/useToggleTrusted.test.ts

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import type {
+	RemitImapDescribeMessageResponse,
+	RemitImapEnvelopeAddressResponse,
+} from "@remit/api-http-client/types.gen.ts";
+import { patchDescribeMessage, patchEnvelopeAddress } from "./useToggleTrusted";
+
+const NOW = 1_700_000_000_000;
+
+const makeAddr = (
+	overrides: Partial<RemitImapEnvelopeAddressResponse> & {
+		addressId: string;
+	},
+): RemitImapEnvelopeAddressResponse =>
+	({
+		normalizedEmail: "x@example.com",
+		addressRole: "from",
+		addressOrder: 0,
+		...overrides,
+	}) as RemitImapEnvelopeAddressResponse;
+
+describe("patchEnvelopeAddress", () => {
+	test("ignores addresses with non-matching addressId", () => {
+		const addr = makeAddr({ addressId: "addr-other" });
+		const result = patchEnvelopeAddress(addr, "addr-target", true, NOW);
+		assert.equal(result, addr);
+	});
+
+	test("sets trusted flag when toggled on", () => {
+		const addr = makeAddr({ addressId: "addr-1" });
+		const result = patchEnvelopeAddress(addr, "addr-1", true, NOW);
+		assert.equal(result.flags?.trusted?.value, true);
+		assert.equal(result.flags?.trusted?.setAt, NOW);
+	});
+
+	test("removes trusted flag when toggled off", () => {
+		const addr = makeAddr({
+			addressId: "addr-1",
+			flags: { trusted: { value: true, setAt: 1 } },
+		});
+		const result = patchEnvelopeAddress(addr, "addr-1", false, NOW);
+		assert.equal(result.flags?.trusted, undefined);
+	});
+
+	test("preserves other flags when toggling trust off", () => {
+		const addr = makeAddr({
+			addressId: "addr-1",
+			flags: {
+				trusted: { value: true, setAt: 1 },
+				vip: { value: true, setAt: 2 },
+			},
+		});
+		const result = patchEnvelopeAddress(addr, "addr-1", false, NOW);
+		assert.equal(result.flags?.vip?.value, true);
+		assert.equal(result.flags?.trusted, undefined);
+	});
+});
+
+describe("patchDescribeMessage", () => {
+	const baseDescribe = (
+		from: RemitImapEnvelopeAddressResponse[],
+	): RemitImapDescribeMessageResponse =>
+		({
+			message: {
+				messageId: "m",
+				mailboxId: "mb",
+				uid: 1,
+				rfc822Size: 1,
+				internalDate: 1,
+			},
+			envelope: {
+				messageId: "m",
+				date: 1,
+				from,
+				to: [],
+				cc: [],
+				bcc: [],
+				replyTo: [],
+				senderTrust: "unknown",
+			},
+			flags: [],
+			bodyParts: [],
+			references: [],
+		}) as RemitImapDescribeMessageResponse;
+
+	test("flips only the matching address across all roles", () => {
+		const target = makeAddr({ addressId: "a-1" });
+		const other = makeAddr({ addressId: "a-2" });
+		const data = baseDescribe([target, other]);
+		const result = patchDescribeMessage(data, "a-1", true, NOW);
+		assert.equal(result.envelope.from[0].flags?.trusted?.value, true);
+		assert.equal(result.envelope.from[1].flags?.trusted, undefined);
+	});
+
+	test("rollback semantics: original data is unchanged (immutable patch)", () => {
+		const target = makeAddr({ addressId: "a-1" });
+		const data = baseDescribe([target]);
+		patchDescribeMessage(data, "a-1", true, NOW);
+		assert.equal(data.envelope.from[0].flags, undefined);
+	});
+});