@remit/web-client 0.0.43 → 0.0.45

package/src/lib/{bulk-delete.test.ts → bulk-actions.test.ts}

@@ -1,15 +1,15 @@
 import assert from "node:assert/strict";
 import { describe, test } from "node:test";
 import {
-	BULK_DELETE_CHUNK_SIZE,
+	BULK_ACTION_CHUNK_SIZE,
 	chunkIds,
 	countMatches,
 	type FetchIdsPageResult,
 	honestProgress,
-	resolveSelectionAfterDelete,
-	runChunkedDelete,
-	runPredicateDelete,
-} from "./bulk-delete.js";
+	resolveSelectionAfterRun,
+	runChunkedAction,
+	runPredicateAction,
+} from "./bulk-actions.js";
 
 const ids = (count: number, prefix = "m"): string[] =>
 	Array.from({ length: count }, (_, i) => `${prefix}${i}`);
@@ -20,20 +20,20 @@ describe("chunkIds", () => {
 	});
 
 	test("exactly one chunk's worth stays a single chunk", () => {
-		const got = chunkIds(ids(BULK_DELETE_CHUNK_SIZE));
+		const got = chunkIds(ids(BULK_ACTION_CHUNK_SIZE));
 		assert.equal(got.length, 1);
-		assert.equal(got[0].length, BULK_DELETE_CHUNK_SIZE);
+		assert.equal(got[0].length, BULK_ACTION_CHUNK_SIZE);
 	});
 
 	test("one over the boundary spills a second chunk of one", () => {
-		const got = chunkIds(ids(BULK_DELETE_CHUNK_SIZE + 1));
+		const got = chunkIds(ids(BULK_ACTION_CHUNK_SIZE + 1));
 		assert.equal(got.length, 2);
-		assert.equal(got[0].length, BULK_DELETE_CHUNK_SIZE);
+		assert.equal(got[0].length, BULK_ACTION_CHUNK_SIZE);
 		assert.equal(got[1].length, 1);
 	});
 
 	test("preserves order across chunk boundaries", () => {
-		const input = ids(BULK_DELETE_CHUNK_SIZE + 5);
+		const input = ids(BULK_ACTION_CHUNK_SIZE + 5);
 		const got = chunkIds(input).flat();
 		assert.deepEqual(got, input);
 	});
@@ -47,13 +47,13 @@ describe("chunkIds", () => {
 	});
 });
 
-describe("runChunkedDelete", () => {
+describe("runChunkedAction", () => {
 	const neverCancelled = () => false;
 	const noopProgress = () => undefined;
 
 	test("zero ids does nothing and reports done=0", async () => {
 		const calls: string[][] = [];
-		const outcome = await runChunkedDelete(
+		const outcome = await runChunkedAction(
 			[],
 			async (chunk) => {
 				calls.push(chunk);
@@ -71,9 +71,9 @@ describe("runChunkedDelete", () => {
 	});
 
 	test("sequences one call per 100-id chunk, in order", async () => {
-		const input = ids(BULK_DELETE_CHUNK_SIZE + 1);
+		const input = ids(BULK_ACTION_CHUNK_SIZE + 1);
 		const calls: string[][] = [];
-		const outcome = await runChunkedDelete(
+		const outcome = await runChunkedAction(
 			input,
 			async (chunk) => {
 				calls.push(chunk);
@@ -83,7 +83,7 @@ describe("runChunkedDelete", () => {
 			neverCancelled,
 		);
 		assert.equal(calls.length, 2);
-		assert.equal(calls[0].length, BULK_DELETE_CHUNK_SIZE);
+		assert.equal(calls[0].length, BULK_ACTION_CHUNK_SIZE);
 		assert.equal(calls[1].length, 1);
 		assert.equal(outcome.done, input.length);
 		assert.deepEqual(outcome.failedIds, []);
@@ -91,7 +91,7 @@ describe("runChunkedDelete", () => {
 
 	test("a returned batch counts every id in it as accepted", async () => {
 		const input = ids(5);
-		const outcome = await runChunkedDelete(
+		const outcome = await runChunkedAction(
 			input,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			noopProgress,
@@ -102,10 +102,10 @@ describe("runChunkedDelete", () => {
 	});
 
 	test("cancelling mid-run folds every unreached chunk into failedIds", async () => {
-		const input = ids(BULK_DELETE_CHUNK_SIZE * 3);
+		const input = ids(BULK_ACTION_CHUNK_SIZE * 3);
 		let calls = 0;
 		let cancelled = false;
-		const outcome = await runChunkedDelete(
+		const outcome = await runChunkedAction(
 			input,
 			async (chunk) => {
 				calls++;
@@ -117,15 +117,15 @@ describe("runChunkedDelete", () => {
 		);
 		assert.equal(outcome.cancelled, true);
 		assert.equal(calls, 1);
-		assert.equal(outcome.done, BULK_DELETE_CHUNK_SIZE);
+		assert.equal(outcome.done, BULK_ACTION_CHUNK_SIZE);
 		// The two chunks never attempted come back as not-yet-deleted.
-		assert.equal(outcome.failedIds.length, BULK_DELETE_CHUNK_SIZE * 2);
+		assert.equal(outcome.failedIds.length, BULK_ACTION_CHUNK_SIZE * 2);
 	});
 
 	test("an infra failure mid-run stops the run and reports the error", async () => {
-		const input = ids(BULK_DELETE_CHUNK_SIZE * 2);
+		const input = ids(BULK_ACTION_CHUNK_SIZE * 2);
 		const boom = new Error("network blip");
-		const outcome = await runChunkedDelete(
+		const outcome = await runChunkedAction(
 			input,
 			async () => {
 				throw boom;
@@ -139,22 +139,22 @@ describe("runChunkedDelete", () => {
 	});
 
 	test("reports progress after each chunk", async () => {
-		const input = ids(BULK_DELETE_CHUNK_SIZE + 1);
+		const input = ids(BULK_ACTION_CHUNK_SIZE + 1);
 		const progressCalls: { done: number; total: number }[] = [];
-		await runChunkedDelete(
+		await runChunkedAction(
 			input,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			(p) => progressCalls.push(p),
 			neverCancelled,
 		);
 		assert.deepEqual(progressCalls, [
-			{ done: BULK_DELETE_CHUNK_SIZE, total: input.length },
+			{ done: BULK_ACTION_CHUNK_SIZE, total: input.length },
 			{ done: input.length, total: input.length },
 		]);
 	});
 });
 
-describe("runPredicateDelete", () => {
+describe("runPredicateAction", () => {
 	const neverCancelled = () => false;
 	const noopProgress = () => undefined;
 
@@ -170,7 +170,7 @@ describe("runPredicateDelete", () => {
 
 	test("zero matches deletes nothing", async () => {
 		const fetch = pagedFetcher([{ ids: [] }]);
-		const outcome = await runPredicateDelete(
+		const outcome = await runPredicateAction(
 			fetch,
 			0,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
@@ -181,11 +181,11 @@ describe("runPredicateDelete", () => {
 	});
 
 	test("exactly 100 matches — a page size's worth — resolves in a single page with no continuation", async () => {
-		const fetch = pagedFetcher([{ ids: ids(BULK_DELETE_CHUNK_SIZE) }]);
+		const fetch = pagedFetcher([{ ids: ids(BULK_ACTION_CHUNK_SIZE) }]);
 		const deleteCalls: string[][] = [];
-		const outcome = await runPredicateDelete(
+		const outcome = await runPredicateAction(
 			fetch,
-			BULK_DELETE_CHUNK_SIZE,
+			BULK_ACTION_CHUNK_SIZE,
 			async (chunk) => {
 				deleteCalls.push(chunk);
 				return { successCount: chunk.length, failureCount: 0 };
@@ -194,7 +194,7 @@ describe("runPredicateDelete", () => {
 			neverCancelled,
 		);
 		assert.equal(deleteCalls.length, 1);
-		assert.equal(outcome.done, BULK_DELETE_CHUNK_SIZE);
+		assert.equal(outcome.done, BULK_ACTION_CHUNK_SIZE);
 	});
 
 	test("pages until the continuation token is exhausted, one delete call per page", async () => {
@@ -203,7 +203,7 @@ describe("runPredicateDelete", () => {
 			{ ids: ids(50, "b") },
 		]);
 		const deleteCalls: string[][] = [];
-		const outcome = await runPredicateDelete(
+		const outcome = await runPredicateAction(
 			fetch,
 			150,
 			async (chunk) => {
@@ -226,7 +226,7 @@ describe("runPredicateDelete", () => {
 			{ ids: ["new-c", "d"] }, // "b" is gone (filed away), "new-c" just arrived
 		]);
 		const deleteCalls: string[][] = [];
-		const outcome = await runPredicateDelete(
+		const outcome = await runPredicateAction(
 			fetch,
 			4,
 			async (chunk) => {
@@ -250,7 +250,7 @@ describe("runPredicateDelete", () => {
 			fetchCalls++;
 			return { ids: ["a", "b"], continuationToken: "more" };
 		};
-		const outcome = await runPredicateDelete(
+		const outcome = await runPredicateAction(
 			fetch,
 			1000,
 			async (chunk) => {
@@ -271,7 +271,7 @@ describe("runPredicateDelete", () => {
 		const fetch = async (): Promise<FetchIdsPageResult> => {
 			throw boom;
 		};
-		const outcome = await runPredicateDelete(
+		const outcome = await runPredicateAction(
 			fetch,
 			100,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
@@ -285,7 +285,7 @@ describe("runPredicateDelete", () => {
 	test("an infra failure from the delete call itself stops the run and reports the error", async () => {
 		const boom = new Error("500");
 		const fetch = pagedFetcher([{ ids: ["a"] }]);
-		const outcome = await runPredicateDelete(
+		const outcome = await runPredicateAction(
 			fetch,
 			1,
 			async () => {
@@ -355,10 +355,10 @@ describe("countMatches", () => {
 	});
 });
 
-describe("resolveSelectionAfterDelete", () => {
+describe("resolveSelectionAfterRun", () => {
 	test("a clean run with nothing failed exits selection mode", () => {
 		assert.deepEqual(
-			resolveSelectionAfterDelete({
+			resolveSelectionAfterRun({
 				done: 3412,
 				failedIds: [],
 				cancelled: false,
@@ -369,7 +369,7 @@ describe("resolveSelectionAfterDelete", () => {
 
 	test("unreached ids stay selected for a precise retry, even alongside a clean stop", () => {
 		assert.deepEqual(
-			resolveSelectionAfterDelete({
+			resolveSelectionAfterRun({
 				done: 3072,
 				failedIds: ["a", "b"],
 				cancelled: false,
@@ -380,7 +380,7 @@ describe("resolveSelectionAfterDelete", () => {
 
 	test("a clean cancel with nothing yet confirmed failed leaves nothing to retry, but does not exit", () => {
 		assert.deepEqual(
-			resolveSelectionAfterDelete({
+			resolveSelectionAfterRun({
 				done: 100,
 				failedIds: [],
 				cancelled: true,
@@ -391,7 +391,7 @@ describe("resolveSelectionAfterDelete", () => {
 
 	test("an infra failure with nothing left unreached still keeps selection mode open", () => {
 		assert.deepEqual(
-			resolveSelectionAfterDelete({
+			resolveSelectionAfterRun({
 				done: 0,
 				failedIds: [],
 				cancelled: false,
@@ -403,7 +403,7 @@ describe("resolveSelectionAfterDelete", () => {
 
 	test("failedIds wins over cancelled/error when both are present", () => {
 		assert.deepEqual(
-			resolveSelectionAfterDelete({
+			resolveSelectionAfterRun({
 				done: 10,
 				failedIds: ["x"],
 				cancelled: true,
@@ -415,7 +415,7 @@ describe("resolveSelectionAfterDelete", () => {
 });
 
 describe("honestProgress", () => {
-	// Regression for #109: `countMatches` and `runPredicateDelete` page the
+	// Regression for #109: `countMatches` and `runPredicateAction` page the
 	// same predicate independently, so the delete can outrun the frozen
 	// `total` it started with when the result set grows in between.
 	test("leaves an on-track progress reading untouched", () => {

package/src/lib/{bulk-delete.ts → bulk-actions.ts}

@@ -1,25 +1,26 @@
 /**
- * Chunked bulk-delete orchestration (issue #92).
+ * Chunked bulk-action orchestration (issues #92, #114).
  *
- * The bulk endpoint caps a call at 100 ids (`BulkMessageInput.messageIds`,
- * `@maxItems(100)`); a delete over a search result can run to thousands. These
+ * The bulk endpoints cap a call at 100 ids (`BulkMessageInput.messageIds`,
+ * `@maxItems(100)`); an action over a search result can run to thousands. These
  * 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.
+ * caller can always ask "what's still not done" instead of trusting the request
+ * it sent. Delete, move and mark-read all take this path — the action itself is
+ * the `ApplyBatch` the caller supplies.
  *
- * 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.
+ * The endpoints enqueue the IMAP write and return; they do not apply it. So a
+ * returned call means every id in it was accepted, not that the mail server
+ * applied 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`
+ * `useEscalatedActions.ts` supplies the real `ApplyBatch`/`FetchIdsPage`
  * implementations (the generated SDK client) and owns the React state.
  */
 
-export const BULK_DELETE_CHUNK_SIZE = 100;
+export const BULK_ACTION_CHUNK_SIZE = 100;
 
 /**
  * Resolves a promise to a discriminated result instead of throwing, so a
@@ -40,7 +41,7 @@ const attempt = async <T>(
 /** Split `ids` into chunks of at most `size`. Empty input yields no chunks. */
 export const chunkIds = (
 	ids: readonly string[],
-	size = BULK_DELETE_CHUNK_SIZE,
+	size = BULK_ACTION_CHUNK_SIZE,
 ): string[][] => {
 	if (ids.length === 0) return [];
 	const chunks: string[][] = [];
@@ -50,30 +51,30 @@ export const chunkIds = (
 	return chunks;
 };
 
-export interface DeleteBatchResult {
+export interface BatchResult {
 	successCount: number;
 	failureCount: number;
 }
 
-/** Sends one bulk-delete call for the given ids (≤100). */
-export type DeleteBatch = (ids: string[]) => Promise<DeleteBatchResult>;
+/** Applies the action to one batch of ids (≤100) with a single bulk call. */
+export type ApplyBatch = (ids: string[]) => Promise<BatchResult>;
 
-export interface BulkDeleteProgress {
-	/** Ids confirmed deleted so far. */
+export interface BulkActionProgress {
+	/** Ids the action has been applied to so far. */
 	done: number;
 	/** The total the run was started against (may be an estimate for the
-	 *  predicate case — see `runPredicateDelete`). */
+	 *  predicate case — see `runPredicateAction`). */
 	total: number;
 }
 
-export interface BulkDeleteOutcome {
-	/** Ids confirmed deleted (server-reported success, not merely "sent"). */
+export interface BulkActionOutcome {
+	/** Ids the action was applied to (server-accepted, not merely "sent"). */
 	done: number;
 	/**
-	 * Ids the run did not reach and are therefore not confirmed deleted: on
+	 * Ids the run did not reach, so the action was never applied to them: 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`).
+	 * (see `runChunkedAction`). Empty in the predicate case, which re-resolves on
+	 * every run rather than handing back a remainder (see `runPredicateAction`).
 	 * There is no per-id failure source: a returned batch call counts every id in
 	 * it as accepted (see the module header).
 	 */
@@ -89,15 +90,16 @@ export interface BulkDeleteOutcome {
  * or a "select all loaded" that grew past 100 rows). Chunked synchronously, so
  * on cancellation or a thrown error every chunk not yet attempted — including
  * the one in flight when an error was thrown — is folded into `failedIds`. The
- * caller always gets back exactly the ids still not confirmed deleted, ready
- * to retry as-is (deleting an already-trashed message is a safe no-op).
+ * caller always gets back exactly the ids the action never reached, ready to
+ * retry as-is: every action here is idempotent (re-trashing, re-moving or
+ * re-marking a message it already applied to is a no-op).
  */
-export const runChunkedDelete = async (
+export const runChunkedAction = async (
 	ids: readonly string[],
-	deleteBatch: DeleteBatch,
-	onProgress: (progress: BulkDeleteProgress) => void,
+	applyBatch: ApplyBatch,
+	onProgress: (progress: BulkActionProgress) => void,
 	isCancelled: () => boolean,
-): Promise<BulkDeleteOutcome> => {
+): Promise<BulkActionOutcome> => {
 	const chunks = chunkIds(ids);
 	const total = ids.length;
 	let done = 0;
@@ -109,7 +111,7 @@ export const runChunkedDelete = async (
 			return { done, failedIds, cancelled: true };
 		}
 		const chunk = chunks[i];
-		const attempted = await attempt(deleteBatch(chunk));
+		const attempted = await attempt(applyBatch(chunk));
 		if (!attempted.ok) {
 			failedIds.push(...chunks.slice(i).flat());
 			onProgress({ done, total });
@@ -134,7 +136,7 @@ export type FetchIdsPage = (
 
 /**
  * Escalated case: the selection is a predicate (D2), not a materialized list.
- * Each page is fetched immediately before the chunk it feeds is deleted — a
+ * Each page is fetched immediately before the chunk it feeds is acted on — a
  * page IS a chunk, sized to the same 100-id cap the write side enforces — so
  * ids are never held in memory beyond the batch in flight.
  *
@@ -142,16 +144,15 @@ export type FetchIdsPage = (
  * `failedIds` for the unreached remainder, because those ids were never
  * fetched — there is nothing to hand back. A predicate resolves fresh on
  * every run (D2), so resuming is re-invoking this same function with the same
- * predicate: already-deleted matches drop out of the search on their own and
- * are not re-sent.
+ * predicate.
  */
-export const runPredicateDelete = async (
+export const runPredicateAction = async (
 	fetchIdsPage: FetchIdsPage,
 	total: number,
-	deleteBatch: DeleteBatch,
-	onProgress: (progress: BulkDeleteProgress) => void,
+	applyBatch: ApplyBatch,
+	onProgress: (progress: BulkActionProgress) => void,
 	isCancelled: () => boolean,
-): Promise<BulkDeleteOutcome> => {
+): Promise<BulkActionOutcome> => {
 	let done = 0;
 	const failedIds: string[] = [];
 	let token: string | undefined;
@@ -168,7 +169,7 @@ export const runPredicateDelete = async (
 		const page = fetched.value;
 
 		if (page.ids.length > 0) {
-			const attempted = await attempt(deleteBatch(page.ids));
+			const attempted = await attempt(applyBatch(page.ids));
 			if (!attempted.ok) {
 				return { done, failedIds, cancelled: false, error: attempted.error };
 			}
@@ -184,8 +185,8 @@ export const runPredicateDelete = async (
 
 /**
  * Corrects a progress reading so its `total` can never read as less than
- * `done` (#109). `runPredicateDelete`'s `total` is `countMatches`'s frozen
- * page-through, taken before the delete re-pages the same predicate a second,
+ * `done` (#109). `runPredicateAction`'s `total` is `countMatches`'s frozen
+ * page-through, taken before the run re-pages the same predicate a second,
  * independent time; if more matches arrived in between, `done` can overtake
  * it mid-run and a raw "Deleting 1,340 of 1,284" would follow. Widening the
  * denominator to match keeps the bar's ratio sane (never past 100%) without
@@ -194,8 +195,8 @@ export const runPredicateDelete = async (
  * second count taken any later is no less stale than the first).
  */
 export const honestProgress = (
-	progress: BulkDeleteProgress,
-): BulkDeleteProgress => ({
+	progress: BulkActionProgress,
+): BulkActionProgress => ({
 	done: progress.done,
 	total: Math.max(progress.total, progress.done),
 });
@@ -239,15 +240,15 @@ export const countMatches = async (
 	return { total, cancelled: false };
 };
 
-export interface DeleteRunOutcome {
+export interface BulkRunOutcome {
 	done: number;
 	failedIds: string[];
 	cancelled: boolean;
 	error?: unknown;
 }
 
-export interface SelectionAfterDelete {
-	/** Everything targeted was confirmed deleted — selection mode should exit. */
+export interface SelectionAfterRun {
+	/** The action reached everything targeted — selection mode should exit. */
 	exit: boolean;
 	/** The bounded selection to leave in place, empty when exiting. */
 	retryIds: string[];
@@ -255,14 +256,14 @@ export interface SelectionAfterDelete {
 
 /**
  * What a caller does with selection once a run ends, for any reason. Every id
- * not confirmed deleted — a chunk the bounded run never reached because it was
+ * the action never reached — a chunk the bounded run skipped 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).
+ * more was done than actually was (#92 requirement 8).
  */
-export const resolveSelectionAfterDelete = (
-	outcome: DeleteRunOutcome,
-): SelectionAfterDelete => {
+export const resolveSelectionAfterRun = (
+	outcome: BulkRunOutcome,
+): SelectionAfterRun => {
 	if (outcome.failedIds.length > 0) {
 		return { exit: false, retryIds: outcome.failedIds };
 	}

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

@@ -5,7 +5,15 @@ import {
 	threadOperationsSearchThreadsQueryKey,
 	unifiedThreadOperationsListAllThreadsQueryKey,
 } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import { threadListCacheKeys } from "./thread-list-cache.js";
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import { QueryClient } from "@tanstack/react-query";
+import {
+	invalidateThreadListQueries,
+	patchThreadListQueries,
+	restoreThreadListQueries,
+	snapshotThreadListQueries,
+	threadListCacheKeys,
+} from "./thread-list-cache.js";
 
 describe("threadListCacheKeys", () => {
 	test("resolves each mailbox's list and search caches plus the unified one", () => {
@@ -42,3 +50,98 @@ describe("threadListCacheKeys", () => {
 		assert.strictEqual(keys.length, 3);
 	});
 });
+
+const thread = (
+	overrides: Partial<RemitImapThreadMessageResponse> & { messageId: string },
+): RemitImapThreadMessageResponse =>
+	({
+		threadId: "t1",
+		threadMessageId: `tm-${overrides.messageId}`,
+		mailboxId: "mb1",
+		subject: "s",
+		fromName: "n",
+		fromEmail: "e",
+		sentDate: "2025-01-01T00:00:00Z",
+		snippet: "",
+		hasAttachment: false,
+		hasStars: false,
+		isRead: false,
+		...overrides,
+	}) as RemitImapThreadMessageResponse;
+
+/** The single-shot page the daily brief and Flagged cache under the unified key. */
+const briefKey = unifiedThreadOperationsListAllThreadsQueryKey();
+
+/** The brief's search variant caches under the same key plus query options. */
+const briefSearchKey = unifiedThreadOperationsListAllThreadsQueryKey({
+	query: { query: "invoice", limit: 50 },
+});
+
+/** The infinite shape a mailbox list caches. */
+const mailboxKey = threadOperationsListThreadsQueryKey({
+	path: { mailboxId: "mb1" },
+	query: { order: "desc" },
+});
+
+const seed = () => {
+	const queryClient = new QueryClient();
+	queryClient.setQueryData(briefKey, { items: [thread({ messageId: "m1" })] });
+	queryClient.setQueryData(briefSearchKey, {
+		items: [thread({ messageId: "m1" })],
+	});
+	queryClient.setQueryData(mailboxKey, {
+		pages: [{ items: [thread({ messageId: "m1" })] }],
+		pageParams: [undefined],
+	});
+	return queryClient;
+};
+
+const briefItems = (queryClient: QueryClient, key: readonly unknown[]) =>
+	queryClient.getQueryData<{ items: RemitImapThreadMessageResponse[] }>(key)
+		?.items ?? [];
+
+describe("mutating from the daily brief", () => {
+	test("patches the unified listing the brief reads, not only the mailbox list", () => {
+		const queryClient = seed();
+		patchThreadListQueries(queryClient, threadListCacheKeys(["mb1"]), (items) =>
+			items.map((item) => ({ ...item, isRead: true })),
+		);
+		assert.strictEqual(briefItems(queryClient, briefKey)[0].isRead, true);
+		assert.strictEqual(briefItems(queryClient, briefSearchKey)[0].isRead, true);
+		const pages = queryClient.getQueryData<{
+			pages: Array<{ items: RemitImapThreadMessageResponse[] }>;
+		}>(mailboxKey);
+		assert.strictEqual(pages?.pages[0].items[0].isRead, true);
+	});
+
+	test("removes a deleted row from the brief's page", () => {
+		const queryClient = seed();
+		patchThreadListQueries(queryClient, threadListCacheKeys(["mb1"]), (items) =>
+			items.filter((item) => item.messageId !== "m1"),
+		);
+		assert.deepStrictEqual(briefItems(queryClient, briefKey), []);
+	});
+
+	test("restores the brief's page when the mutation fails", () => {
+		const queryClient = seed();
+		const prefixes = threadListCacheKeys(["mb1"]);
+		const snapshot = snapshotThreadListQueries(queryClient, prefixes);
+		patchThreadListQueries(queryClient, prefixes, () => []);
+		restoreThreadListQueries(queryClient, snapshot);
+		assert.strictEqual(briefItems(queryClient, briefKey).length, 1);
+		assert.strictEqual(briefItems(queryClient, briefSearchKey).length, 1);
+	});
+
+	test("invalidates the brief's listing so the next read refetches", () => {
+		const queryClient = seed();
+		invalidateThreadListQueries(queryClient, threadListCacheKeys(["mb1"]));
+		assert.strictEqual(
+			queryClient.getQueryState(briefKey)?.isInvalidated,
+			true,
+		);
+		assert.strictEqual(
+			queryClient.getQueryState(mailboxKey)?.isInvalidated,
+			true,
+		);
+	});
+});