@remit/web-client 0.0.33 → 0.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "type": "module",
   "description": "Remit web client, published as composable primitives — the app shell, auth shells, and runtime config. A distributor imports what it composes and bundles it.",
   "exports": {

package/src/hooks/useDeleteMessages.ts

@@ -2,15 +2,21 @@ import {
 	mailboxOperationsListMailboxesQueryKey,
 	messageBulkOperationsDeleteMessagesMutation,
 	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 { useCallback } from "react";
 import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
 import { formatErrorDetail } from "@/components/ui/error-banners";
-import { patchThreadListCache, type ThreadListCache } from "@/lib/thread-cache";
+import {
+	cancelThreadListQueries,
+	invalidateThreadListQueries,
+	patchThreadListQueries,
+	restoreThreadListQueries,
+	snapshotThreadListQueries,
+	type ThreadListSnapshotEntry,
+	threadListCacheKeys,
+} from "@/lib/thread-list-cache";
 
 interface UseDeleteMessagesOptions {
 	mailboxId: string;
@@ -29,13 +35,6 @@ interface ThreadMessagesData {
 	[key: string]: unknown;
 }
 
-/**
- * Either shape a thread list/search query caches — the infinite mailbox list
- * or a single-shot page. `setQueriesData` matches by key prefix, so the
- * optimistic updater sees both.
- */
-type ThreadsListData = ThreadListCache;
-
 interface SnapshotEntry<T> {
 	queryKey: readonly unknown[];
 	data: T;
@@ -43,10 +42,9 @@ interface SnapshotEntry<T> {
 
 interface DeleteContext {
 	threadMessagesPrefix: readonly unknown[];
-	threadsListPrefix: readonly unknown[];
-	threadsSearchPrefix: readonly unknown[];
+	listPrefixes: ReadonlyArray<readonly unknown[]>;
 	previousThreadMessages: SnapshotEntry<ThreadMessagesData>[];
-	previousThreadsList: SnapshotEntry<ThreadsListData>[];
+	previousThreadsList: ThreadListSnapshotEntry[];
 }
 
 /**
@@ -94,17 +92,14 @@ export const useDeleteMessages = ({
 						path: { threadId },
 					})
 				: [];
-			const threadsListPrefix = threadOperationsListThreadsQueryKey({
-				path: { mailboxId },
-			});
-			const threadsSearchPrefix = threadOperationsSearchThreadsQueryKey({
-				path: { mailboxId },
-			});
+			// The browsed mailbox's lists plus the unified cross-account listing
+			// that backs the daily brief — deleting from the brief has to remove the
+			// row there too, not only from the per-mailbox lists (#140, part of #149).
+			const listPrefixes = threadListCacheKeys([mailboxId]);
 
 			await Promise.all([
 				queryClient.cancelQueries({ queryKey: threadMessagesPrefix }),
-				queryClient.cancelQueries({ queryKey: threadsListPrefix }),
-				queryClient.cancelQueries({ queryKey: threadsSearchPrefix }),
+				cancelThreadListQueries(queryClient, listPrefixes),
 			]);
 
 			const previousThreadMessages = threadId
@@ -119,18 +114,10 @@ export const useDeleteMessages = ({
 						.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 }));
+			const previousThreadsList = snapshotThreadListQueries(
+				queryClient,
+				listPrefixes,
+			);
 
 			if (threadId) {
 				queryClient.setQueriesData<ThreadMessagesData>(
@@ -145,26 +132,15 @@ export const useDeleteMessages = ({
 				);
 			}
 
-			const patchListData = (old: unknown) =>
-				patchThreadListCache(old, (items) =>
-					removeMessagesFromItems(items, messageIds),
-				);
-
-			queryClient.setQueriesData(
-				{ queryKey: threadsListPrefix },
-				patchListData,
-			);
-			queryClient.setQueriesData(
-				{ queryKey: threadsSearchPrefix },
-				patchListData,
+			patchThreadListQueries(queryClient, listPrefixes, (items) =>
+				removeMessagesFromItems(items, messageIds),
 			);
 
 			onAfterOptimisticRemove?.(Array.from(messageIds));
 
 			return {
 				threadMessagesPrefix,
-				threadsListPrefix,
-				threadsSearchPrefix,
+				listPrefixes,
 				previousThreadMessages,
 				previousThreadsList,
 			};
@@ -174,9 +150,7 @@ export const useDeleteMessages = ({
 				for (const entry of context.previousThreadMessages) {
 					queryClient.setQueryData(entry.queryKey, entry.data);
 				}
-				for (const entry of context.previousThreadsList) {
-					queryClient.setQueryData(entry.queryKey, entry.data);
-				}
+				restoreThreadListQueries(queryClient, context.previousThreadsList);
 			}
 			const count = vars.body.messageIds?.length ?? 0;
 			pushError({
@@ -195,8 +169,7 @@ export const useDeleteMessages = ({
 					queryKey: context.threadMessagesPrefix,
 				});
 			}
-			queryClient.invalidateQueries({ queryKey: context.threadsListPrefix });
-			queryClient.invalidateQueries({ queryKey: context.threadsSearchPrefix });
+			invalidateThreadListQueries(queryClient, context.listPrefixes);
 			if (accountId) {
 				queryClient.invalidateQueries({
 					queryKey: mailboxOperationsListMailboxesQueryKey({

package/src/hooks/useMarkAsRead.test.ts

@@ -1,9 +1,13 @@
 import assert from "node:assert";
-import { describe, test } from "node:test";
+import { afterEach, beforeEach, describe, mock, test } from "node:test";
 import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import { patchThreadListCache } from "../lib/thread-cache.js";
 import {
+	MARK_READ_DELAY_MS,
 	resolveMailboxesForMessages,
+	scheduleMarkRead,
 	selectMessagesToMarkRead,
+	setReadOnItems,
 } from "./useMarkAsRead.js";
 
 const make = (
@@ -167,6 +171,92 @@ describe("selectMessagesToMarkRead", () => {
 	});
 });
 
+describe("marking read across the unified-threads cache shapes", () => {
+	// The daily brief reads from the unified cross-account listing, a different
+	// cache than the per-mailbox lists the regular inboxes render. Marking a
+	// message read has to patch that cache too, or the brief keeps its unread
+	// dot until reload (#140). The unified prefix carries both cache shapes — the
+	// brief's single page and the Flagged view's infinite query — so the patch
+	// has to survive whichever it is handed.
+	const patch = (old: unknown) =>
+		patchThreadListCache(old, (items) =>
+			setReadOnItems(items, new Set(["m1"]), true),
+		);
+
+	test("patches the brief's single-shot page", () => {
+		const patched = patch({
+			items: [
+				make({ messageId: "m1", threadMessageId: "tm1", isRead: false }),
+				make({ messageId: "m2", threadMessageId: "tm2", isRead: false }),
+			],
+		}) as { items: RemitImapThreadMessageResponse[] };
+		assert.equal(patched.items[0].isRead, true);
+		assert.equal(patched.items[1].isRead, false);
+	});
+
+	test("patches the Flagged view's infinite query instead of throwing", () => {
+		const patched = patch({
+			pages: [
+				{
+					items: [
+						make({ messageId: "m1", threadMessageId: "tm1", isRead: false }),
+					],
+				},
+				{
+					items: [
+						make({ messageId: "m2", threadMessageId: "tm2", isRead: false }),
+					],
+				},
+			],
+			pageParams: [undefined, "next"],
+		}) as { pages: Array<{ items: RemitImapThreadMessageResponse[] }> };
+		assert.equal(patched.pages[0].items[0].isRead, true);
+		assert.equal(patched.pages[1].items[0].isRead, false);
+	});
+});
+
+describe("scheduleMarkRead", () => {
+	beforeEach(() => {
+		mock.timers.enable({ apis: ["setTimeout"] });
+	});
+	afterEach(() => {
+		mock.timers.reset();
+	});
+
+	test("marks read once the dwell elapses", () => {
+		const marked: string[][] = [];
+		scheduleMarkRead(["m1"], MARK_READ_DELAY_MS, (ids) => marked.push(ids));
+		mock.timers.tick(MARK_READ_DELAY_MS - 1);
+		assert.deepStrictEqual(marked, []);
+		mock.timers.tick(1);
+		assert.deepStrictEqual(marked, [["m1"]]);
+	});
+
+	test("does not mark when the selection changes before the dwell", () => {
+		const marked: string[][] = [];
+		const cancel = scheduleMarkRead(["m1"], MARK_READ_DELAY_MS, (ids) =>
+			marked.push(ids),
+		);
+		mock.timers.tick(2000);
+		cancel();
+		mock.timers.tick(MARK_READ_DELAY_MS);
+		assert.deepStrictEqual(marked, []);
+	});
+
+	test("schedules nothing for an already-read (empty) selection", () => {
+		const marked: string[][] = [];
+		scheduleMarkRead([], MARK_READ_DELAY_MS, (ids) => marked.push(ids));
+		mock.timers.tick(MARK_READ_DELAY_MS);
+		assert.deepStrictEqual(marked, []);
+	});
+
+	test("marks at once when the delay is not positive", () => {
+		const marked: string[][] = [];
+		scheduleMarkRead(["m1"], 0, (ids) => marked.push(ids));
+		assert.deepStrictEqual(marked, [["m1"]]);
+	});
+});
+
 describe("resolveMailboxesForMessages", () => {
 	const messages = [
 		make({

package/src/hooks/useMarkAsRead.ts

@@ -2,15 +2,21 @@ import {
 	mailboxOperationsListMailboxesQueryKey,
 	messageBulkOperationsUpdateFlagsMutation,
 	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 { useCallback, useEffect, useMemo, useRef } from "react";
 import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
 import { formatErrorDetail } from "@/components/ui/error-banners";
-import { patchThreadListCache, type ThreadListCache } from "@/lib/thread-cache";
+import {
+	cancelThreadListQueries,
+	invalidateThreadListQueries,
+	patchThreadListQueries,
+	restoreThreadListQueries,
+	snapshotThreadListQueries,
+	type ThreadListSnapshotEntry,
+	threadListCacheKeys,
+} from "@/lib/thread-list-cache";
 
 interface UseMarkAsReadOptions {
 	messages: RemitImapThreadMessageResponse[];
@@ -25,13 +31,6 @@ interface ThreadMessagesData {
 	[key: string]: unknown;
 }
 
-/**
- * Either shape a thread list/search query caches — the infinite mailbox list
- * or a single-shot page. `setQueriesData` matches by key prefix, so the
- * optimistic updater sees both.
- */
-type ThreadsListData = ThreadListCache;
-
 interface SnapshotEntry<T> {
 	queryKey: readonly unknown[];
 	data: T;
@@ -39,12 +38,38 @@ interface SnapshotEntry<T> {
 
 interface MarkAsReadContext {
 	threadMessagesPrefix: readonly unknown[];
-	threadsListPrefixes: ReadonlyArray<readonly unknown[]>;
-	threadsSearchPrefixes: ReadonlyArray<readonly unknown[]>;
+	listPrefixes: ReadonlyArray<readonly unknown[]>;
 	previousThreadMessages: SnapshotEntry<ThreadMessagesData>[];
-	previousThreadsList: SnapshotEntry<ThreadsListData>[];
+	previousThreadsList: ThreadListSnapshotEntry[];
 }
 
+/**
+ * Dwell before a message the user is viewing is marked read. A glance closed
+ * within this window leaves it unread (#140). Applied by the single shared
+ * trigger below, so the daily brief and the mailbox thread views agree.
+ */
+export const MARK_READ_DELAY_MS = 3000;
+
+/**
+ * Fire `markRead` for `messageIds` after `delayMs`. Returns a canceller the
+ * caller runs on unmount or when the selection changes before the dwell
+ * elapses; an empty list schedules nothing, and a non-positive delay fires at
+ * once. Framework-agnostic so the timing can be exercised with fake timers.
+ */
+export const scheduleMarkRead = (
+	messageIds: string[],
+	delayMs: number,
+	markRead: (ids: string[]) => void,
+): (() => void) => {
+	if (messageIds.length === 0) return () => {};
+	if (delayMs <= 0) {
+		markRead(messageIds);
+		return () => {};
+	}
+	const timer = setTimeout(() => markRead(messageIds), delayMs);
+	return () => clearTimeout(timer);
+};
+
 /**
  * The mailboxes whose cached listings a batch of message mutations affects.
  *
@@ -68,7 +93,7 @@ export const resolveMailboxesForMessages = (
 	return [...mailboxIds];
 };
 
-const setReadOnItems = (
+export const setReadOnItems = (
 	items: RemitImapThreadMessageResponse[],
 	messageIds: Set<string>,
 	isRead: boolean,
@@ -122,26 +147,13 @@ export const useMarkAsRead = ({
 				threadDetailOperationsListThreadMessagesQueryKey({
 					path: { threadId },
 				});
-			const affectedMailboxIds = resolveMailboxesForMessages(
-				messageIds,
-				messages,
-				mailboxId,
-			);
-			const threadsListPrefixes = affectedMailboxIds.map((id) =>
-				threadOperationsListThreadsQueryKey({ path: { mailboxId: id } }),
-			);
-			const threadsSearchPrefixes = affectedMailboxIds.map((id) =>
-				threadOperationsSearchThreadsQueryKey({ path: { mailboxId: id } }),
+			const listPrefixes = threadListCacheKeys(
+				resolveMailboxesForMessages(messageIds, messages, mailboxId),
 			);
 
 			await Promise.all([
 				queryClient.cancelQueries({ queryKey: threadMessagesPrefix }),
-				...threadsListPrefixes.map((queryKey) =>
-					queryClient.cancelQueries({ queryKey }),
-				),
-				...threadsSearchPrefixes.map((queryKey) =>
-					queryClient.cancelQueries({ queryKey }),
-				),
+				cancelThreadListQueries(queryClient, listPrefixes),
 			]);
 
 			const previousThreadMessages = queryClient
@@ -152,18 +164,10 @@ export const useMarkAsRead = ({
 				)
 				.map(([queryKey, data]) => ({ queryKey, data }));
 
-			const previousThreadsList = [
-				...threadsListPrefixes,
-				...threadsSearchPrefixes,
-			]
-				.flatMap((queryKey) =>
-					queryClient.getQueriesData<ThreadsListData>({ queryKey }),
-				)
-				.filter(
-					(entry): entry is [readonly unknown[], ThreadsListData] =>
-						entry[1] !== undefined,
-				)
-				.map(([queryKey, data]) => ({ queryKey, data }));
+			const previousThreadsList = snapshotThreadListQueries(
+				queryClient,
+				listPrefixes,
+			);
 
 			queryClient.setQueriesData<ThreadMessagesData>(
 				{ queryKey: threadMessagesPrefix },
@@ -176,22 +180,13 @@ export const useMarkAsRead = ({
 				},
 			);
 
-			const patchListData = (old: unknown) =>
-				patchThreadListCache(old, (items) =>
-					setReadOnItems(items, messageIds, isRead),
-				);
-
-			for (const queryKey of [
-				...threadsListPrefixes,
-				...threadsSearchPrefixes,
-			]) {
-				queryClient.setQueriesData({ queryKey }, patchListData);
-			}
+			patchThreadListQueries(queryClient, listPrefixes, (items) =>
+				setReadOnItems(items, messageIds, isRead),
+			);
 
 			return {
 				threadMessagesPrefix,
-				threadsListPrefixes,
-				threadsSearchPrefixes,
+				listPrefixes,
 				previousThreadMessages,
 				previousThreadsList,
 			};
@@ -212,9 +207,7 @@ export const useMarkAsRead = ({
 				for (const entry of context.previousThreadMessages) {
 					queryClient.setQueryData(entry.queryKey, entry.data);
 				}
-				for (const entry of context.previousThreadsList) {
-					queryClient.setQueryData(entry.queryKey, entry.data);
-				}
+				restoreThreadListQueries(queryClient, context.previousThreadsList);
 			}
 			const isRead = variables.body.isRead ?? true;
 			pushError({
@@ -226,12 +219,7 @@ export const useMarkAsRead = ({
 		onSettled: (_data, _err, _vars, context) => {
 			if (!context) return;
 			queryClient.invalidateQueries({ queryKey: context.threadMessagesPrefix });
-			for (const queryKey of [
-				...context.threadsListPrefixes,
-				...context.threadsSearchPrefixes,
-			]) {
-				queryClient.invalidateQueries({ queryKey });
-			}
+			invalidateThreadListQueries(queryClient, context.listPrefixes);
 			// Refresh the sidebar mailbox list so the unread badge picks up the
 			// next backend `unseenCount` (which is owned by IMAP sync).
 			if (accountId) {
@@ -276,13 +264,13 @@ export const useMarkAsRead = ({
 		[messages, expandedIds],
 	);
 
-	// Mark as read immediately when a message is expanded — match Gmail
-	// behaviour. The previous implementation used a 10s delay plus an
-	// "all expanded" gate that meant most reads silently never fired.
-	useEffect(() => {
-		if (eligibleIds.length === 0) return;
-		markMessagesRead(eligibleIds);
-	}, [eligibleIds, markMessagesRead]);
+	// Mark as read after a short dwell on the open message. Changing the
+	// selection or leaving the view before the dwell elapses cancels the pending
+	// mark, so a glance stays unread (#140).
+	useEffect(
+		() => scheduleMarkRead(eligibleIds, MARK_READ_DELAY_MS, markMessagesRead),
+		[eligibleIds, markMessagesRead],
+	);
 
 	// biome-ignore lint/correctness/useExhaustiveDependencies: intentionally clears state on threadId change; adding threadId to deps causes stale closure issues
 	useEffect(() => {
@@ -315,16 +303,10 @@ export const useToggleReadFor = (options: {
 			});
 		},
 		onSettled: () => {
-			queryClient.invalidateQueries({
-				queryKey: threadOperationsListThreadsQueryKey({
-					path: { mailboxId },
-				}),
-			});
-			queryClient.invalidateQueries({
-				queryKey: threadOperationsSearchThreadsQueryKey({
-					path: { mailboxId },
-				}),
-			});
+			invalidateThreadListQueries(
+				queryClient,
+				threadListCacheKeys([mailboxId]),
+			);
 			if (accountId) {
 				queryClient.invalidateQueries({
 					queryKey: mailboxOperationsListMailboxesQueryKey({

package/src/hooks/useMoveMessages.ts

@@ -2,15 +2,21 @@ import {
 	mailboxOperationsListMailboxesQueryKey,
 	messageBulkOperationsMoveMessagesMutation,
 	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 { useCallback } from "react";
 import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
 import { formatErrorDetail } from "@/components/ui/error-banners";
-import { patchThreadListCache, type ThreadListCache } from "@/lib/thread-cache";
+import {
+	cancelThreadListQueries,
+	invalidateThreadListQueries,
+	patchThreadListQueries,
+	restoreThreadListQueries,
+	snapshotThreadListQueries,
+	type ThreadListSnapshotEntry,
+	threadListCacheKeys,
+} from "@/lib/thread-list-cache";
 
 interface UseMoveMessagesOptions {
 	mailboxId: string;
@@ -29,13 +35,6 @@ interface ThreadMessagesData {
 	[key: string]: unknown;
 }
 
-/**
- * Either shape a thread list/search query caches — the infinite mailbox list
- * or a single-shot page. `setQueriesData` matches by key prefix, so the
- * optimistic updater sees both.
- */
-type ThreadsListData = ThreadListCache;
-
 interface SnapshotEntry<T> {
 	queryKey: readonly unknown[];
 	data: T;
@@ -43,10 +42,9 @@ interface SnapshotEntry<T> {
 
 interface MoveContext {
 	threadMessagesPrefix: readonly unknown[];
-	threadsListPrefix: readonly unknown[];
-	threadsSearchPrefix: readonly unknown[];
+	listPrefixes: ReadonlyArray<readonly unknown[]>;
 	previousThreadMessages: SnapshotEntry<ThreadMessagesData>[];
-	previousThreadsList: SnapshotEntry<ThreadsListData>[];
+	previousThreadsList: ThreadListSnapshotEntry[];
 }
 
 /**
@@ -82,24 +80,20 @@ export const useMoveMessages = ({
 						path: { threadId },
 					})
 				: [];
-			const threadsListPrefix = threadOperationsListThreadsQueryKey({
-				path: { mailboxId },
-			});
-			const threadsSearchPrefix = threadOperationsSearchThreadsQueryKey({
-				path: { mailboxId },
-			});
+			// The source mailbox's lists plus the unified cross-account listing that
+			// backs the daily brief — moving from the brief has to remove the row
+			// there too, not only from the per-mailbox lists (#140, part of #149).
+			const listPrefixes = threadListCacheKeys([mailboxId]);
 
 			// Only cancel the thread-messages query when we actually have a
 			// threadId — passing an empty queryKey here would match every
 			// query in the cache and cancel unrelated work (Copilot review,
-			// PR #287). The list/search prefixes are always scoped to the
-			// current mailbox so they're safe to cancel as-is.
+			// PR #287). The list prefixes are always scoped so they're safe.
 			await Promise.all([
 				...(threadId
 					? [queryClient.cancelQueries({ queryKey: threadMessagesPrefix })]
 					: []),
-				queryClient.cancelQueries({ queryKey: threadsListPrefix }),
-				queryClient.cancelQueries({ queryKey: threadsSearchPrefix }),
+				cancelThreadListQueries(queryClient, listPrefixes),
 			]);
 
 			const previousThreadMessages = threadId
@@ -114,18 +108,10 @@ export const useMoveMessages = ({
 						.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 }));
+			const previousThreadsList = snapshotThreadListQueries(
+				queryClient,
+				listPrefixes,
+			);
 
 			if (threadId) {
 				queryClient.setQueriesData<ThreadMessagesData>(
@@ -140,26 +126,15 @@ export const useMoveMessages = ({
 				);
 			}
 
-			const patchListData = (old: unknown) =>
-				patchThreadListCache(old, (items) =>
-					removeMovedMessagesFromItems(items, messageIds),
-				);
-
-			queryClient.setQueriesData(
-				{ queryKey: threadsListPrefix },
-				patchListData,
-			);
-			queryClient.setQueriesData(
-				{ queryKey: threadsSearchPrefix },
-				patchListData,
+			patchThreadListQueries(queryClient, listPrefixes, (items) =>
+				removeMovedMessagesFromItems(items, messageIds),
 			);
 
 			onAfterOptimisticRemove?.(Array.from(messageIds));
 
 			return {
 				threadMessagesPrefix,
-				threadsListPrefix,
-				threadsSearchPrefix,
+				listPrefixes,
 				previousThreadMessages,
 				previousThreadsList,
 			};
@@ -169,9 +144,7 @@ export const useMoveMessages = ({
 				for (const entry of context.previousThreadMessages) {
 					queryClient.setQueryData(entry.queryKey, entry.data);
 				}
-				for (const entry of context.previousThreadsList) {
-					queryClient.setQueryData(entry.queryKey, entry.data);
-				}
+				restoreThreadListQueries(queryClient, context.previousThreadsList);
 			}
 			const count = vars.body.messageIds?.length ?? 0;
 			pushError({
@@ -190,8 +163,7 @@ export const useMoveMessages = ({
 					queryKey: context.threadMessagesPrefix,
 				});
 			}
-			queryClient.invalidateQueries({ queryKey: context.threadsListPrefix });
-			queryClient.invalidateQueries({ queryKey: context.threadsSearchPrefix });
+			invalidateThreadListQueries(queryClient, context.listPrefixes);
 			if (accountId) {
 				queryClient.invalidateQueries({
 					queryKey: mailboxOperationsListMailboxesQueryKey({

package/src/hooks/useToggleStar.ts

@@ -1,15 +1,21 @@
 import {
 	messageOperationsUpdateMessageFlagsMutation,
 	threadDetailOperationsListThreadMessagesQueryKey,
-	threadOperationsListThreadsQueryKey,
-	threadOperationsSearchThreadsQueryKey,
-	unifiedThreadOperationsListAllThreadsQueryKey,
 } 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";
-import { patchThreadListCache, type ThreadListCache } from "@/lib/thread-cache";
+import { patchThreadListCache } from "@/lib/thread-cache";
+import {
+	cancelThreadListQueries,
+	invalidateThreadListQueries,
+	patchThreadListQueries,
+	restoreThreadListQueries,
+	snapshotThreadListQueries,
+	type ThreadListSnapshotEntry,
+	threadListCacheKeys,
+} from "@/lib/thread-list-cache";
 
 interface UseToggleStarOptions {
 	threadId: string;
@@ -47,13 +53,6 @@ interface ThreadMessagesData {
 	[key: string]: unknown;
 }
 
-/**
- * Either shape a thread list/search query caches — the infinite mailbox list
- * or a single-shot page. `setQueriesData` matches by key prefix, so the
- * optimistic updater sees both.
- */
-type ThreadsListData = ThreadListCache;
-
 interface SnapshotEntry<T> {
 	queryKey: readonly unknown[];
 	data: T;
@@ -61,12 +60,9 @@ interface SnapshotEntry<T> {
 
 interface ToggleStarContext {
 	threadMessagesPrefix: readonly unknown[];
-	threadsListPrefix: readonly unknown[];
-	threadsSearchPrefix: readonly unknown[];
-	unifiedThreadsPrefix: readonly unknown[];
+	listPrefixes: ReadonlyArray<readonly unknown[]>;
 	previousThreadMessages: SnapshotEntry<ThreadMessagesData>[];
-	previousThreadsList: SnapshotEntry<ThreadsListData>[];
-	previousUnifiedThreads: SnapshotEntry<ThreadMessagesData>[];
+	previousThreadsList: ThreadListSnapshotEntry[];
 }
 
 export const toggleStarsInItems = (
@@ -100,29 +96,17 @@ export const useToggleStar = ({
 				threadDetailOperationsListThreadMessagesQueryKey({
 					path: { threadId },
 				});
-			const affectedMailboxId = resolveMailboxForMessage(
-				messageId,
-				messages,
-				mailboxId,
-			);
-			const threadsListPrefix = threadOperationsListThreadsQueryKey({
-				path: { mailboxId: affectedMailboxId },
-			});
-			const threadsSearchPrefix = threadOperationsSearchThreadsQueryKey({
-				path: { mailboxId: affectedMailboxId },
-			});
-			// The unified cross-account listing backs the daily brief and the
-			// Starred mailbox, so a star toggled from an inbox has to land there
-			// too — without this the starred view keeps serving a stale page for
-			// its whole staleTime and the message never appears.
-			const unifiedThreadsPrefix =
-				unifiedThreadOperationsListAllThreadsQueryKey();
+			// The list caches to patch: the message's own mailbox plus the unified
+			// cross-account listing that backs the daily brief and the Flagged view.
+			// Resolved from the shared source so this hook can never fall behind the
+			// others on which listings exist (#149).
+			const listPrefixes = threadListCacheKeys([
+				resolveMailboxForMessage(messageId, messages, mailboxId),
+			]);
 
 			await Promise.all([
 				queryClient.cancelQueries({ queryKey: threadMessagesPrefix }),
-				queryClient.cancelQueries({ queryKey: threadsListPrefix }),
-				queryClient.cancelQueries({ queryKey: threadsSearchPrefix }),
-				queryClient.cancelQueries({ queryKey: unifiedThreadsPrefix }),
+				cancelThreadListQueries(queryClient, listPrefixes),
 			]);
 
 			const previousThreadMessages = queryClient
@@ -133,69 +117,27 @@ export const useToggleStar = ({
 				)
 				.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 }));
-
-			const previousUnifiedThreads = queryClient
-				.getQueriesData<ThreadMessagesData>({ queryKey: unifiedThreadsPrefix })
-				.filter(
-					(entry): entry is [readonly unknown[], ThreadMessagesData] =>
-						entry[1] !== undefined,
-				)
-				.map(([queryKey, data]) => ({ queryKey, data }));
-
-			// The unified-threads prefix carries both shapes too: the Flagged view
-			// runs an infinite query on `listAllThreads({ starred: true })`, which
-			// sits under the same prefix as the single-shot readers. Patching it as
-			// a plain `{ items }` threw on that entry and failed the star before it
-			// was sent — the same defect as the mailbox list (issues #51, #55), so
-			// it goes through the same helper.
-			const patchItemsData = (old: unknown) =>
-				patchThreadListCache(old, (items) =>
-					toggleStarsInItems(items, messageId, nextStarred),
-				);
-
-			queryClient.setQueriesData(
-				{ queryKey: threadMessagesPrefix },
-				patchItemsData,
-			);
-			queryClient.setQueriesData(
-				{ queryKey: unifiedThreadsPrefix },
-				patchItemsData,
+			const previousThreadsList = snapshotThreadListQueries(
+				queryClient,
+				listPrefixes,
 			);
 
-			const patchListData = (old: unknown) =>
+			// The thread-detail cache carries the `{ items }` shape too, so it goes
+			// through the same shape-tolerant helper as the listings.
+			queryClient.setQueriesData({ queryKey: threadMessagesPrefix }, (old) =>
 				patchThreadListCache(old, (items) =>
 					toggleStarsInItems(items, messageId, nextStarred),
-				);
-
-			queryClient.setQueriesData(
-				{ queryKey: threadsListPrefix },
-				patchListData,
+				),
 			);
-			queryClient.setQueriesData(
-				{ queryKey: threadsSearchPrefix },
-				patchListData,
+			patchThreadListQueries(queryClient, listPrefixes, (items) =>
+				toggleStarsInItems(items, messageId, nextStarred),
 			);
 
 			return {
 				threadMessagesPrefix,
-				threadsListPrefix,
-				threadsSearchPrefix,
-				unifiedThreadsPrefix,
+				listPrefixes,
 				previousThreadMessages,
 				previousThreadsList,
-				previousUnifiedThreads,
 			};
 		},
 		onError: (err, vars, context) => {
@@ -203,12 +145,7 @@ export const useToggleStar = ({
 				for (const entry of context.previousThreadMessages) {
 					queryClient.setQueryData(entry.queryKey, entry.data);
 				}
-				for (const entry of context.previousThreadsList) {
-					queryClient.setQueryData(entry.queryKey, entry.data);
-				}
-				for (const entry of context.previousUnifiedThreads) {
-					queryClient.setQueryData(entry.queryKey, entry.data);
-				}
+				restoreThreadListQueries(queryClient, context.previousThreadsList);
 			}
 			const nextStarred = vars.body.isStarred ?? false;
 			pushError({
@@ -222,9 +159,7 @@ export const useToggleStar = ({
 		onSettled: (_data, _err, _vars, context) => {
 			if (!context) return;
 			queryClient.invalidateQueries({ queryKey: context.threadMessagesPrefix });
-			queryClient.invalidateQueries({ queryKey: context.threadsListPrefix });
-			queryClient.invalidateQueries({ queryKey: context.threadsSearchPrefix });
-			queryClient.invalidateQueries({ queryKey: context.unifiedThreadsPrefix });
+			invalidateThreadListQueries(queryClient, context.listPrefixes);
 		},
 	});
 

package/src/lib/bulk-delete.test.ts

@@ -4,7 +4,6 @@ import {
 	BULK_DELETE_CHUNK_SIZE,
 	chunkIds,
 	countMatches,
-	type DeleteBatchResult,
 	type FetchIdsPageResult,
 	honestProgress,
 	resolveSelectionAfterDelete,
@@ -90,36 +89,16 @@ describe("runChunkedDelete", () => {
 		assert.deepEqual(outcome.failedIds, []);
 	});
 
-	test("the count deleted matches exactly what the batches reported succeeded", async () => {
+	test("a returned batch counts every id in it as accepted", async () => {
 		const input = ids(5);
 		const outcome = await runChunkedDelete(
 			input,
-			async (chunk) => ({
-				successCount: chunk.length - 2,
-				failureCount: 2,
-				failedIds: chunk.slice(0, 2),
-			}),
-			noopProgress,
-			neverCancelled,
-		);
-		assert.equal(outcome.done, 3);
-		assert.deepEqual(outcome.failedIds, input.slice(0, 2));
-	});
-
-	test("partial failure: failed ids are reported, not rolled into done", async () => {
-		const input = ids(3);
-		const outcome = await runChunkedDelete(
-			input,
-			async (chunk) => ({
-				successCount: 2,
-				failureCount: 1,
-				failedIds: [chunk[1]],
-			}),
+			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			noopProgress,
 			neverCancelled,
 		);
-		assert.equal(outcome.done, 2);
-		assert.deepEqual(outcome.failedIds, [input[1]]);
+		assert.equal(outcome.done, input.length);
+		assert.deepEqual(outcome.failedIds, []);
 	});
 
 	test("cancelling mid-run folds every unreached chunk into failedIds", async () => {
@@ -264,27 +243,6 @@ describe("runPredicateDelete", () => {
 		assert.equal(outcome.done, 4);
 	});
 
-	test("partial failure across pages accumulates failedIds without rolling into done", async () => {
-		const fetch = pagedFetcher([
-			{ ids: ["a", "b"], continuationToken: "t1" },
-			{ ids: ["c"] },
-		]);
-		const outcome = await runPredicateDelete(
-			fetch,
-			3,
-			async (chunk): Promise<DeleteBatchResult> => {
-				if (chunk.includes("b")) {
-					return { successCount: 1, failureCount: 1, failedIds: ["b"] };
-				}
-				return { successCount: chunk.length, failureCount: 0 };
-			},
-			noopProgress,
-			neverCancelled,
-		);
-		assert.equal(outcome.done, 2);
-		assert.deepEqual(outcome.failedIds, ["b"]);
-	});
-
 	test("cancelling mid-delete stops paging without inventing failedIds for unfetched pages", async () => {
 		let fetchCalls = 0;
 		let cancelled = false;
@@ -409,7 +367,7 @@ describe("resolveSelectionAfterDelete", () => {
 		);
 	});
 
-	test("explicit failures stay selected for a precise retry, even alongside a clean stop", () => {
+	test("unreached ids stay selected for a precise retry, even alongside a clean stop", () => {
 		assert.deepEqual(
 			resolveSelectionAfterDelete({
 				done: 3072,
@@ -431,7 +389,7 @@ describe("resolveSelectionAfterDelete", () => {
 		);
 	});
 
-	test("an infra failure with no explicit per-item failures still keeps selection mode open", () => {
+	test("an infra failure with nothing left unreached still keeps selection mode open", () => {
 		assert.deepEqual(
 			resolveSelectionAfterDelete({
 				done: 0,

package/src/lib/bulk-delete.ts

@@ -3,9 +3,16 @@
  *
  * The bulk endpoint caps a call at 100 ids (`BulkMessageInput.messageIds`,
  * `@maxItems(100)`); a delete over a search result can run to thousands. These
- * helpers sequence the calls and tally what actually happened rather than what
- * was requested, so a caller can always ask "what's still not deleted" instead
- * of trusting the request it sent.
+ * helpers sequence the calls and tally which ids the run actually reached, so a
+ * caller can always ask "what's still not deleted" instead of trusting the
+ * request it sent.
+ *
+ * The endpoint enqueues the IMAP delete and returns; it does not apply it. So a
+ * returned call means every id in it was accepted for deletion, not that the
+ * mail server removed it — there is no per-id success/failure in the response
+ * to read. The only failure this layer can observe is a thrown call: an
+ * infrastructure failure (auth, the write, or the enqueue) that takes out the
+ * whole batch and stops the run.
  *
  * Pure, framework-agnostic, and independently testable — no React, no fetch.
  * `useEscalatedDelete.ts` supplies the real `DeleteBatch`/`FetchIdsPage`
@@ -46,7 +53,6 @@ export const chunkIds = (
 export interface DeleteBatchResult {
 	successCount: number;
 	failureCount: number;
-	failedIds?: string[];
 }
 
 /** Sends one bulk-delete call for the given ids (≤100). */
@@ -64,9 +70,12 @@ export interface BulkDeleteOutcome {
 	/** Ids confirmed deleted (server-reported success, not merely "sent"). */
 	done: number;
 	/**
-	 * Ids not confirmed deleted: explicit per-batch failures. Does NOT include
-	 * ids from chunks the run never reached (cancelled or stopped by an
-	 * error) — see the per-function doc for how each source handles that.
+	 * Ids the run did not reach and are therefore not confirmed deleted: on
+	 * cancellation or a thrown error, the chunks the bounded run never attempted
+	 * (see `runChunkedDelete`). Empty in the predicate case, which re-resolves on
+	 * every run rather than handing back a remainder (see `runPredicateDelete`).
+	 * There is no per-id failure source: a returned batch call counts every id in
+	 * it as accepted (see the module header).
 	 */
 	failedIds: string[];
 	cancelled: boolean;
@@ -106,9 +115,7 @@ export const runChunkedDelete = async (
 			onProgress({ done, total });
 			return { done, failedIds, cancelled: false, error: attempted.error };
 		}
-		const failedInChunk = new Set(attempted.value.failedIds ?? []);
-		done += chunk.length - failedInChunk.size;
-		failedIds.push(...chunk.filter((id) => failedInChunk.has(id)));
+		done += chunk.length;
 		onProgress({ done, total });
 	}
 
@@ -165,9 +172,7 @@ export const runPredicateDelete = async (
 			if (!attempted.ok) {
 				return { done, failedIds, cancelled: false, error: attempted.error };
 			}
-			const failedInPage = new Set(attempted.value.failedIds ?? []);
-			done += page.ids.length - failedInPage.size;
-			failedIds.push(...page.ids.filter((id) => failedInPage.has(id)));
+			done += page.ids.length;
 			onProgress({ done, total });
 		}
 
@@ -250,11 +255,10 @@ export interface SelectionAfterDelete {
 
 /**
  * What a caller does with selection once a run ends, for any reason. Every id
- * not confirmed deleted — an explicit failure, or a chunk the run never
- * reached because it was stopped or errored — belongs in `retryIds`: it is
- * exactly what Retry should resend, and it is what stays selected so the
- * count on screen never claims more was deleted than actually was (#92
- * requirement 8).
+ * not confirmed deleted — a chunk the bounded run never reached because it was
+ * stopped or errored — belongs in `retryIds`: it is exactly what Retry should
+ * resend, and it is what stays selected so the count on screen never claims
+ * more was deleted than actually was (#92 requirement 8).
  */
 export const resolveSelectionAfterDelete = (
 	outcome: DeleteRunOutcome,

package/src/lib/thread-list-cache.test.ts

@@ -0,0 +1,44 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import {
+	threadOperationsListThreadsQueryKey,
+	threadOperationsSearchThreadsQueryKey,
+	unifiedThreadOperationsListAllThreadsQueryKey,
+} from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { threadListCacheKeys } from "./thread-list-cache.js";
+
+describe("threadListCacheKeys", () => {
+	test("resolves each mailbox's list and search caches plus the unified one", () => {
+		const keys = threadListCacheKeys(["mb1"]);
+		assert.deepStrictEqual(keys, [
+			threadOperationsListThreadsQueryKey({ path: { mailboxId: "mb1" } }),
+			threadOperationsSearchThreadsQueryKey({ path: { mailboxId: "mb1" } }),
+			unifiedThreadOperationsListAllThreadsQueryKey(),
+		]);
+	});
+
+	test("always includes the unified cross-account listing the daily brief reads", () => {
+		// #140: the brief kept its unread dot because the read mutation never
+		// reached this key. Every caller of the shared source now does.
+		const keys = threadListCacheKeys(["mb1", "mb2"]);
+		assert.ok(
+			keys.some(
+				(key) =>
+					JSON.stringify(key) ===
+					JSON.stringify(unifiedThreadOperationsListAllThreadsQueryKey()),
+			),
+		);
+	});
+
+	test("emits one list and one search key per distinct mailbox", () => {
+		const keys = threadListCacheKeys(["mb1", "mb2"]);
+		// two mailboxes -> two list + two search + one unified
+		assert.strictEqual(keys.length, 5);
+	});
+
+	test("dedupes repeated mailbox ids", () => {
+		const keys = threadListCacheKeys(["mb1", "mb1"]);
+		// one mailbox -> one list + one search + one unified
+		assert.strictEqual(keys.length, 3);
+	});
+});

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

@@ -0,0 +1,97 @@
+import {
+	threadOperationsListThreadsQueryKey,
+	threadOperationsSearchThreadsQueryKey,
+	unifiedThreadOperationsListAllThreadsQueryKey,
+} from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import type { QueryClient } from "@tanstack/react-query";
+import { patchThreadListCache, type ThreadListCache } from "./thread-cache.js";
+
+export interface ThreadListSnapshotEntry {
+	queryKey: readonly unknown[];
+	data: ThreadListCache;
+}
+
+/**
+ * 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: Iterable<string>,
+): ReadonlyArray<readonly unknown[]> => {
+	const keys: Array<readonly unknown[]> = [];
+	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: QueryClient,
+	prefixes: ReadonlyArray<readonly unknown[]>,
+): Promise<unknown> =>
+	Promise.all(
+		prefixes.map((queryKey) => queryClient.cancelQueries({ queryKey })),
+	);
+
+export const snapshotThreadListQueries = (
+	queryClient: QueryClient,
+	prefixes: ReadonlyArray<readonly unknown[]>,
+): ThreadListSnapshotEntry[] =>
+	prefixes
+		.flatMap((queryKey) =>
+			queryClient.getQueriesData<ThreadListCache>({ queryKey }),
+		)
+		.filter(
+			(entry): entry is [readonly unknown[], ThreadListCache] =>
+				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: QueryClient,
+	prefixes: ReadonlyArray<readonly unknown[]>,
+	patchItems: (
+		items: RemitImapThreadMessageResponse[],
+	) => RemitImapThreadMessageResponse[],
+): void => {
+	const updater = (old: unknown) => patchThreadListCache(old, patchItems);
+	for (const queryKey of prefixes) {
+		queryClient.setQueriesData({ queryKey }, updater);
+	}
+};
+
+export const restoreThreadListQueries = (
+	queryClient: QueryClient,
+	snapshot: ThreadListSnapshotEntry[],
+): void => {
+	for (const entry of snapshot) {
+		queryClient.setQueryData(entry.queryKey, entry.data);
+	}
+};
+
+export const invalidateThreadListQueries = (
+	queryClient: QueryClient,
+	prefixes: ReadonlyArray<readonly unknown[]>,
+): void => {
+	for (const queryKey of prefixes) {
+		queryClient.invalidateQueries({ queryKey });
+	}
+};