@remit/web-client 0.0.188 → 0.0.189

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.188",
+  "version": "0.0.189",
   "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/components/mail/DailyBrief.tsx

@@ -106,15 +106,13 @@ import {
 	type SelectionWizardControl,
 	useSelectionWizard,
 } from "@/lib/wizard-history";
+import { wizardSelectionFrom } from "@/lib/wizard-selection";
 import type { OpenThreadTarget } from "@/routing";
 import { LabelApplyTrigger } from "./LabelApplyTrigger";
 import { MailListHeader, type MailListHeaderProps } from "./MailListHeader";
 import type { MessageListCommands } from "./MessageList";
 import { MessageRow } from "./MessageRow";
-import {
-	SelectionWizardHost,
-	type WizardSelectionMessage,
-} from "./SelectionWizardHost";
+import { SelectionWizardHost } from "./SelectionWizardHost";
 import {
 	type OpenMessageOptions,
 	ThreadListInteraction,
@@ -283,17 +281,8 @@ function BriefSelectionChrome({
 	);
 	// The ticked rows as the wizard reads them — the sample under every screen
 	// that names a match, and the senders its widen falls back to.
-	const wizardSelection = useMemo<WizardSelectionMessage[]>(
-		() =>
-			rows
-				.filter((row) => selectedIds.has(row.id))
-				.map((row) => ({
-					id: row.id,
-					sender: row.fromName,
-					email: row.fromEmail,
-					subject: row.subject,
-					date: row.timeLabel,
-				})),
+	const wizardSelection = useMemo(
+		() => wizardSelectionFrom(rows, selectedIds),
 		[rows, selectedIds],
 	);
 

package/src/components/mail/FlaggedList.tsx

@@ -38,14 +38,12 @@ import { rowToSearchResult } from "@/lib/search-result";
 import { parseSearchTokens } from "@/lib/search-tokens";
 import { dedupeByThread } from "@/lib/starred-rows";
 import { useSelectionWizard } from "@/lib/wizard-history";
+import { wizardSelectionFrom } from "@/lib/wizard-selection";
 import type { OpenThreadTarget } from "@/routing";
 import { MailViewChrome } from "./MailViewChrome";
 import type { MessageListCommands } from "./MessageList";
 import { MessageRow } from "./MessageRow";
-import {
-	SelectionWizardHost,
-	type WizardSelectionMessage,
-} from "./SelectionWizardHost";
+import { SelectionWizardHost } from "./SelectionWizardHost";
 import {
 	type OpenMessageOptions,
 	ThreadListInteraction,
@@ -78,17 +76,8 @@ function StarredWizardHost({
 	verb: Verb;
 }) {
 	const { selectedIds, exitSelection } = useThreadListSelection();
-	const selection = useMemo<WizardSelectionMessage[]>(
-		() =>
-			rows
-				.filter((row) => selectedIds.has(row.id))
-				.map((row) => ({
-					id: row.id,
-					sender: row.fromName,
-					email: row.fromEmail,
-					subject: row.subject,
-					date: row.timeLabel,
-				})),
+	const selection = useMemo(
+		() => wizardSelectionFrom(rows, selectedIds),
 		[rows, selectedIds],
 	);
 	return (

package/src/components/mail/MessageList.tsx

@@ -52,13 +52,13 @@ import { useListHeaderChrome } from "@/lib/list-header-chrome";
 import { listVerbRequest } from "@/lib/list-verb-request";
 import { shouldExitSelectionOnNavigate } from "@/lib/selection-mode";
 import { useSelectionWizard, useWizardStepValue } from "@/lib/wizard-history";
+import type { WizardSelectionMessage } from "@/lib/wizard-selection";
 import { useRetainOpenPanels } from "@/routing";
 import { DeleteConfirmDialog } from "./DeleteConfirmDialog";
 import { LabelApplyTrigger } from "./LabelApplyTrigger";
 import {
 	type EscalatedSelection,
 	SelectionWizardHost,
-	type WizardSelectionMessage,
 } from "./SelectionWizardHost";
 import { SwipeableMessageRow } from "./SwipeableMessageRow";
 
@@ -497,10 +497,11 @@ export const MessageList = ({
 				email: thread.fromEmail ?? "",
 				subject: thread.subject ?? "(No subject)",
 				date: formatEmailDate(thread.sentDate),
+				accountId,
 			});
 		}
 		return rows;
-	}, [threads, selectedIds]);
+	}, [threads, selectedIds, accountId]);
 	const handleRowSelect = useCallback(
 		(messageId: string, modifiers: SelectionModifiers): boolean => {
 			if (modifiers.shiftKey) {

package/src/components/mail/SelectionWizardHost.tsx

@@ -47,7 +47,11 @@ import { useOrganizeJob } from "@/hooks/useOrganizeJob";
 import { useOrganizeWiden } from "@/hooks/useOrganizeWiden";
 import { useRulePreview } from "@/hooks/useRulePreview";
 import { useSelectedSubjects } from "@/hooks/useSelectedSubjects";
-import type { BulkActionProgress, BulkRunOutcome } from "@/lib/bulk-actions";
+import type {
+	BulkActionProgress,
+	BulkActionTarget,
+	BulkRunOutcome,
+} from "@/lib/bulk-actions";
 import { NO_JUNK_FOLDER_REASON } from "@/lib/junk-destination";
 import { useListHeaderChrome } from "@/lib/list-header-chrome";
 import { useMailContext } from "@/lib/mail-context";
@@ -66,16 +70,11 @@ import {
 import { searchRuleAccountId } from "@/lib/organize/search-to-rule";
 import type { OrganizeMatchPredicate } from "@/lib/organize/sender-fallback";
 import { useWizardEntryValue, useWizardStep } from "@/lib/wizard-history";
+import type { WizardSelectionMessage } from "@/lib/wizard-selection";
 import { organizeRunState } from "./organize-run-state";
 
 const EMPTY_DRAFT: WizardDraft = { clauses: [], matchOperator: "any" };
 
-/** A ticked row, as the wizard's samples and its clause prefill read it. */
-export interface WizardSelectionMessage extends WizardMessage {
-	/** Sender address — the widen's literal fallback and the prefill match on it. */
-	email: string;
-}
-
 interface SelectionWizardSessionProps extends SelectionWizardHostProps {
 	/** The step the URL holds. The session is mounted only while there is one. */
 	step: StepId;
@@ -307,7 +306,14 @@ function SelectionWizardSession({
 		OrganizeScope | undefined
 	>(undefined);
 	const [bulkRun, setBulkRun] = useState<
-		| { matched: number; outcome?: BulkRunOutcome; failureReason?: string }
+		| {
+				matched: number;
+				/** What the run was sent, so a retry of what it missed keeps each
+				 *  id's account. Empty for an escalated run, which has no id list. */
+				sent: readonly BulkActionTarget[];
+				outcome?: BulkRunOutcome;
+				failureReason?: string;
+		  }
 		| undefined
 	>(undefined);
 	// The predicate the create chains its pass to. Undefined when the rule cannot
@@ -326,6 +332,16 @@ function SelectionWizardSession({
 		() => selection.map((message) => message.id),
 		[selection],
 	);
+	// What a bulk run over the ticked rows covers, each row still naming its
+	// account so the run can batch per account.
+	const bulkTargets = useMemo<BulkActionTarget[]>(
+		() =>
+			selection.map((message) => ({
+				id: message.id,
+				accountId: message.accountId,
+			})),
+		[selection],
+	);
 	const senders = useMemo(
 		() => selection.map((message) => message.email).filter(Boolean),
 		[selection],
@@ -586,19 +602,22 @@ function SelectionWizardSession({
 	}, [blockedReason, current, steps, goToStep]);
 
 	const runBulk = useCallback(
-		async (ids: readonly string[]) => {
+		async (targets: readonly BulkActionTarget[]) => {
 			const action = bulkActionFor(verb, named.moveMailboxId, junkMailboxId);
 			if (!action) {
 				setBulkRun({
-					matched: ids.length,
+					matched: targets.length,
+					sent: targets,
 					failureReason: noDestinationReason(verb),
 				});
 				return;
 			}
-			setBulkRun({ matched: ids.length });
-			const outcome = await runAction(action, [...ids]);
-			setBulkRun({ matched: ids.length, outcome });
-			if (walkedAway.current) onRunEnded?.(action.kind, ids.length, outcome);
+			setBulkRun({ matched: targets.length, sent: targets });
+			const outcome = await runAction(action, targets);
+			setBulkRun({ matched: targets.length, sent: targets, outcome });
+			if (walkedAway.current) {
+				onRunEnded?.(action.kind, targets.length, outcome);
+			}
 		},
 		[verb, named.moveMailboxId, junkMailboxId, runAction, onRunEnded],
 	);
@@ -612,13 +631,14 @@ function SelectionWizardSession({
 		if (!action) {
 			setBulkRun({
 				matched: escalated.total,
+				sent: [],
 				failureReason: noDestinationReason(verb),
 			});
 			return;
 		}
-		setBulkRun({ matched: escalated.total });
+		setBulkRun({ matched: escalated.total, sent: [] });
 		const outcome = await escalated.run(action);
-		setBulkRun({ matched: escalated.total, outcome });
+		setBulkRun({ matched: escalated.total, sent: [], outcome });
 		if (walkedAway.current) {
 			onRunEnded?.(action.kind, escalated.total, outcome);
 		}
@@ -670,7 +690,13 @@ function SelectionWizardSession({
 			startJob(organizeDraft);
 			return;
 		}
-		void runBulk(scope === "just-these" ? messageIds : matchedIds);
+		// A widened match is resolved by the account's own preview, so every id it
+		// returned belongs to the account the wizard is scoped to.
+		void runBulk(
+			scope === "just-these"
+				? bulkTargets
+				: matchedIds.map((id) => ({ id, accountId })),
+		);
 	}, [
 		escalated,
 		runEscalated,
@@ -678,7 +704,8 @@ function SelectionWizardSession({
 		named,
 		anchorMessageId,
 		verb,
-		messageIds,
+		accountId,
+		bulkTargets,
 		matchedIds,
 		createFilterAsync,
 		startJob,
@@ -850,8 +877,16 @@ function SelectionWizardSession({
 			sendCommit();
 			return;
 		}
-		const outstanding = bulkRun?.outcome?.failedIds ?? [];
-		void runBulk(outstanding.length > 0 ? outstanding : messageIds);
+		const outstanding = new Set(bulkRun?.outcome?.failedIds ?? []);
+		// A run hands back ids, and each one's account came from the batch it was
+		// sent in — so a retry re-sends the targets the run was given, filtered to
+		// what it never reached.
+		const sent = bulkRun?.sent ?? bulkTargets;
+		void runBulk(
+			outstanding.size > 0
+				? sent.filter((target) => outstanding.has(target.id))
+				: sent,
+		);
 	};
 
 	// Cancel rewinds the entries the wizard owns and leaves the selection where

package/src/hooks/cross-account-bulk.render.test.ts

@@ -0,0 +1,164 @@
+/**
+ * The brief and Flagged are the two cross-account lists, and both offer Delete
+ * and Mark read over whatever is ticked (#872).
+ *
+ * The bulk endpoints refuse a batch spanning accounts before applying any of
+ * it, so a selection with one row from each account deleted nothing at all and
+ * marked nothing read — the user got "Couldn't delete these messages" and no
+ * mail moved. The split has to happen where the call is made, so this mounts
+ * the real hook against the real fetch seam and reads the requests that
+ * actually left: every batch carries one account, and between them they carry
+ * every ticked row.
+ *
+ * Which account each ticked row belongs to is the surfaces' half of the same
+ * fix, and it is pinned in `../lib/wizard-selection.test.ts`. How the run
+ * sequences the batches it splits into — progress over the whole selection,
+ * cancellation at whichever boundary comes next — is `../lib/bulk-actions.test.ts`,
+ * where a batch is a value rather than a request in flight.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { act, createElement } from "react";
+import type { BulkActionTarget } from "../lib/bulk-actions";
+import { createDomHarness, type DomHarness } from "../test-support/dom";
+import { type HttpMock, httpError, mockFetch } from "../test-support/http";
+import {
+	type EscalatedAction,
+	type UseEscalatedActionsResult,
+	useEscalatedActions,
+} from "./useEscalatedActions";
+
+const ACCOUNT_A = "acc-work";
+const ACCOUNT_B = "acc-personal";
+
+/** A brief selection: two rows from one account, one from another. */
+const MIXED: BulkActionTarget[] = [
+	{ id: "msg-work-1", accountId: ACCOUNT_A },
+	{ id: "msg-personal-1", accountId: ACCOUNT_B },
+	{ id: "msg-work-2", accountId: ACCOUNT_A },
+];
+
+let harness: DomHarness | undefined;
+let http: HttpMock;
+
+const mountRunner = (): (() => UseEscalatedActionsResult) => {
+	let value: UseEscalatedActionsResult | undefined;
+	const Probe = () => {
+		value = useEscalatedActions({
+			// The brief's selection belongs to no single mailbox, which is how the
+			// wizard mounts this hook over a cross-account list.
+			mailboxId: "",
+			enabled: false,
+			predicateKey: "selection-wizard",
+			searchQuery: {},
+		});
+		return null;
+	};
+	harness = createDomHarness();
+	harness.renderApp(createElement(Probe));
+	return () => {
+		if (!value) throw new Error("hook did not render");
+		return value;
+	};
+};
+
+/** Enough turns for a run of sequential batches to finish. */
+const settle = async (): Promise<void> => {
+	if (!harness) throw new Error("nothing mounted");
+	for (let round = 0; round < 10; round += 1) await harness.flush();
+};
+
+const run = async (
+	hook: () => UseEscalatedActionsResult,
+	action: EscalatedAction,
+	targets: readonly BulkActionTarget[],
+) => {
+	let started: ReturnType<UseEscalatedActionsResult["runAction"]> | undefined;
+	act(() => {
+		started = hook().runAction(action, targets);
+	});
+	await settle();
+	if (!started) throw new Error("the run never started");
+	return started;
+};
+
+/** The message-id list of every bulk request that left, in order. */
+const batches = (suffix: string): string[][] =>
+	http
+		.to(suffix)
+		.map((call) => (call.body as { messageIds?: string[] })?.messageIds ?? []);
+
+const accountOf = (id: string): string | undefined =>
+	MIXED.find((target) => target.id === id)?.accountId;
+
+const assertOneBatchPerAccount = (sent: string[][]): void => {
+	assert.equal(sent.length, 2, "the selection was not split by account");
+	for (const batch of sent) {
+		assert.equal(
+			new Set(batch.map(accountOf)).size,
+			1,
+			"a batch spanned accounts, which the endpoint refuses whole",
+		);
+	}
+	assert.deepEqual(
+		[...sent.flat()].sort(),
+		MIXED.map((target) => target.id).sort(),
+		"a ticked row was never sent",
+	);
+};
+
+beforeEach(() => {
+	http = mockFetch(() => ({ successCount: 1, failureCount: 0 }));
+});
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http.restore();
+});
+
+describe("a selection spanning accounts", () => {
+	it("deletes every ticked row, one batch per account", async () => {
+		const hook = mountRunner();
+
+		const outcome = await run(hook, { kind: "delete" }, MIXED);
+
+		assertOneBatchPerAccount(batches("/messages/delete"));
+		assert.equal(outcome.done, MIXED.length);
+		assert.deepEqual(outcome.failedIds, []);
+	});
+
+	it("marks every ticked row read, one batch per account", async () => {
+		const hook = mountRunner();
+
+		const outcome = await run(hook, { kind: "markRead" }, MIXED);
+
+		assertOneBatchPerAccount(batches("/messages/flags"));
+		for (const call of http.calls) {
+			assert.equal((call.body as { isRead?: boolean })?.isRead, true);
+		}
+		assert.equal(outcome.done, MIXED.length);
+	});
+
+	it("reports how far it got when one account's batch fails", async () => {
+		http.restore();
+		http = mockFetch((call) =>
+			(call.body as { messageIds?: string[] })?.messageIds?.[0] ===
+			"msg-personal-1"
+				? httpError(409, "mailbox is locked")
+				: { successCount: 1, failureCount: 0 },
+		);
+		const hook = mountRunner();
+
+		const outcome = await run(hook, { kind: "delete" }, MIXED);
+
+		assert.equal(outcome.done, 2, "the account that succeeded is not counted");
+		assert.deepEqual(
+			outcome.failedIds,
+			["msg-personal-1"],
+			"the untouched rows are not handed back to retry",
+		);
+		assert.notEqual(outcome.error, undefined);
+	});
+});

package/src/hooks/useEscalatedActions.ts

@@ -17,6 +17,7 @@ import {
 import {
 	type ApplyBatch,
 	type BulkActionProgress,
+	type BulkActionTarget,
 	type BulkRunOutcome,
 	type FetchIdsPage,
 	honestProgress,
@@ -100,18 +101,21 @@ export interface UseEscalatedActionsResult {
 	runningAction: EscalatedAction | undefined;
 	progress: BulkActionProgress | undefined;
 	/**
-	 * Runs `action` in chunks. Pass `ids` for a materialized (bounded)
-	 * selection; omit it to run against the escalated predicate (`phase` must
-	 * be "escalated"). Resolves once the run ends for any reason — cancelled,
-	 * errored, or complete — with a `done`/`failedIds` outcome the caller reads
-	 * to decide what is still outstanding.
+	 * Runs `action` in chunks. Pass `targets` for a materialized (bounded)
+	 * selection; omit them to run against the escalated predicate (`phase` must
+	 * be "escalated"). Each target names the account that owns it, so a
+	 * selection spanning accounts is sent as one batch per account rather than
+	 * as one batch the endpoint refuses whole (#872). Resolves once the run ends
+	 * for any reason — cancelled, errored, or complete — with a
+	 * `done`/`failedIds` outcome the caller reads to decide what is still
+	 * outstanding.
 	 * Infrastructure failures are reported through the app's existing
 	 * escalation seam (`pushError`, which itself escalates a 5xx/exception to
 	 * the fatal overlay) — not swallowed here.
 	 */
 	runAction: (
 		action: EscalatedAction,
-		ids?: string[],
+		targets?: readonly BulkActionTarget[],
 	) => Promise<BulkRunOutcome>;
 }
 
@@ -225,16 +229,26 @@ export const useEscalatedActions = ({
 		[],
 	);
 
+	/**
+	 * The unseen counts a run moved, per account. A cross-account selection has
+	 * no single owning account — the surface leaves the option undefined exactly
+	 * then — so the run's own targets are what name the accounts to refresh.
+	 */
 	const invalidateAfterRun = useCallback(
-		(action: EscalatedAction) => {
+		(action: EscalatedAction, targets: readonly BulkActionTarget[]) => {
 			invalidateThreadListQueries(
 				queryClient,
 				threadListCacheKeys(mailboxesTouchedBy(action, mailboxId)),
 			);
-			if (accountId) {
+			const touched = new Set<string>();
+			if (accountId) touched.add(accountId);
+			for (const target of targets) {
+				if (target.accountId) touched.add(target.accountId);
+			}
+			for (const touchedAccountId of touched) {
 				queryClient.invalidateQueries({
 					queryKey: mailboxOperationsListMailboxesQueryKey({
-						path: { accountId },
+						path: { accountId: touchedAccountId },
 					}),
 				});
 			}
@@ -279,7 +293,7 @@ export const useEscalatedActions = ({
 	const runAction = useCallback(
 		async (
 			action: EscalatedAction,
-			ids?: string[],
+			targets?: readonly BulkActionTarget[],
 		): Promise<BulkRunOutcome> => {
 			cancelRef.current = false;
 			runningRef.current = true;
@@ -301,9 +315,9 @@ export const useEscalatedActions = ({
 			let outcome: BulkRunOutcome;
 			try {
 				outcome =
-					ids !== undefined
+					targets !== undefined
 						? await runChunkedAction(
-								ids,
+								targets,
 								applyBatch,
 								onProgress,
 								() => cancelRef.current,
@@ -333,7 +347,7 @@ export const useEscalatedActions = ({
 				);
 			}
 			if (outcome.done > 0) {
-				invalidateAfterRun(action);
+				invalidateAfterRun(action, targets ?? []);
 			}
 			return outcome;
 		},

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

@@ -2,7 +2,9 @@ import assert from "node:assert/strict";
 import { describe, test } from "node:test";
 import {
 	BULK_ACTION_CHUNK_SIZE,
+	type BulkActionTarget,
 	chunkIds,
+	chunkTargets,
 	type FetchIdsPageResult,
 	honestProgress,
 	runChunkedAction,
@@ -12,6 +14,13 @@ import {
 const ids = (count: number, prefix = "m"): string[] =>
 	Array.from({ length: count }, (_, i) => `${prefix}${i}`);
 
+/** Ids from one account, as a materialized selection hands them over. */
+const targets = (
+	count: number,
+	accountId: string | undefined = undefined,
+	prefix = "m",
+): BulkActionTarget[] => ids(count, prefix).map((id) => ({ id, accountId }));
+
 describe("chunkIds", () => {
 	test("empty input yields no chunks", () => {
 		assert.deepEqual(chunkIds([]), []);
@@ -45,6 +54,63 @@ describe("chunkIds", () => {
 	});
 });
 
+describe("chunkTargets", () => {
+	// Regression for #872: the bulk endpoints reject a batch spanning accounts
+	// before applying any of it, and the brief and Flagged both span accounts.
+	test("never puts two accounts in one chunk", () => {
+		assert.deepEqual(
+			chunkTargets(
+				[
+					{ id: "a1", accountId: "acct-a" },
+					{ id: "b1", accountId: "acct-b" },
+					{ id: "a2", accountId: "acct-a" },
+				],
+				100,
+			),
+			[["a1", "a2"], ["b1"]],
+		);
+	});
+
+	test("chunks each account by size on its own", () => {
+		assert.deepEqual(
+			chunkTargets(
+				[
+					{ id: "a1", accountId: "acct-a" },
+					{ id: "a2", accountId: "acct-a" },
+					{ id: "a3", accountId: "acct-a" },
+					{ id: "b1", accountId: "acct-b" },
+				],
+				2,
+			),
+			[["a1", "a2"], ["a3"], ["b1"]],
+		);
+	});
+
+	test("targets with no account keep their place in the run as a group of their own", () => {
+		assert.deepEqual(
+			chunkTargets(
+				[
+					{ id: "u1", accountId: undefined },
+					{ id: "a1", accountId: "acct-a" },
+					{ id: "u2", accountId: undefined },
+				],
+				100,
+			),
+			[["u1", "u2"], ["a1"]],
+		);
+	});
+
+	test("a single-account selection is one run of chunks, as before", () => {
+		const got = chunkTargets(targets(BULK_ACTION_CHUNK_SIZE + 1, "acct-a"));
+		assert.equal(got.length, 2);
+		assert.equal(got[0].length, BULK_ACTION_CHUNK_SIZE);
+	});
+
+	test("empty input yields no chunks", () => {
+		assert.deepEqual(chunkTargets([]), []);
+	});
+});
+
 describe("runChunkedAction", () => {
 	const neverCancelled = () => false;
 	const noopProgress = () => undefined;
@@ -69,7 +135,7 @@ describe("runChunkedAction", () => {
 	});
 
 	test("sequences one call per 100-id chunk, in order", async () => {
-		const input = ids(BULK_ACTION_CHUNK_SIZE + 1);
+		const input = targets(BULK_ACTION_CHUNK_SIZE + 1);
 		const calls: string[][] = [];
 		const outcome = await runChunkedAction(
 			input,
@@ -88,7 +154,7 @@ describe("runChunkedAction", () => {
 	});
 
 	test("a returned batch counts every id in it as accepted", async () => {
-		const input = ids(5);
+		const input = targets(5);
 		const outcome = await runChunkedAction(
 			input,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
@@ -100,7 +166,7 @@ describe("runChunkedAction", () => {
 	});
 
 	test("cancelling mid-run folds every unreached chunk into failedIds", async () => {
-		const input = ids(BULK_ACTION_CHUNK_SIZE * 3);
+		const input = targets(BULK_ACTION_CHUNK_SIZE * 3);
 		let calls = 0;
 		let cancelled = false;
 		const outcome = await runChunkedAction(
@@ -121,7 +187,7 @@ describe("runChunkedAction", () => {
 	});
 
 	test("an infra failure mid-run stops the run and reports the error", async () => {
-		const input = ids(BULK_ACTION_CHUNK_SIZE * 2);
+		const input = targets(BULK_ACTION_CHUNK_SIZE * 2);
 		const boom = new Error("network blip");
 		const outcome = await runChunkedAction(
 			input,
@@ -136,8 +202,107 @@ describe("runChunkedAction", () => {
 		assert.equal(outcome.failedIds.length, input.length);
 	});
 
+	test("a selection spanning accounts is sent as one batch per account", async () => {
+		const calls: string[][] = [];
+		const outcome = await runChunkedAction(
+			[
+				{ id: "a1", accountId: "acct-a" },
+				{ id: "b1", accountId: "acct-b" },
+				{ id: "a2", accountId: "acct-a" },
+			],
+			async (chunk) => {
+				calls.push(chunk);
+				return { successCount: chunk.length, failureCount: 0 };
+			},
+			noopProgress,
+			neverCancelled,
+		);
+		assert.deepEqual(calls, [["a1", "a2"], ["b1"]]);
+		assert.equal(outcome.done, 3);
+		assert.deepEqual(outcome.failedIds, []);
+	});
+
+	test("progress counts toward the whole selection, not toward each account", async () => {
+		const seen: { done: number; total: number }[] = [];
+		await runChunkedAction(
+			[
+				{ id: "a1", accountId: "acct-a" },
+				{ id: "b1", accountId: "acct-b" },
+			],
+			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
+			(p) => seen.push(p),
+			neverCancelled,
+		);
+		assert.deepEqual(seen, [
+			{ done: 1, total: 2 },
+			{ done: 2, total: 2 },
+		]);
+	});
+
+	test("cancelling at an account boundary hands back the accounts never reached", async () => {
+		let cancelled = false;
+		const outcome = await runChunkedAction(
+			[
+				{ id: "a1", accountId: "acct-a" },
+				{ id: "b1", accountId: "acct-b" },
+				{ id: "c1", accountId: "acct-c" },
+			],
+			async (chunk) => {
+				cancelled = true;
+				return { successCount: chunk.length, failureCount: 0 };
+			},
+			() => undefined,
+			() => cancelled,
+		);
+		assert.equal(outcome.cancelled, true);
+		assert.equal(outcome.done, 1);
+		assert.deepEqual(outcome.failedIds, ["b1", "c1"]);
+	});
+
+	test("one account's batch failing leaves the rest unsent and says how far it got", async () => {
+		const boom = new Error("500");
+		const outcome = await runChunkedAction(
+			[
+				{ id: "a1", accountId: "acct-a" },
+				{ id: "b1", accountId: "acct-b" },
+			],
+			async (chunk) => {
+				if (chunk[0] === "b1") throw boom;
+				return { successCount: chunk.length, failureCount: 0 };
+			},
+			() => undefined,
+			neverCancelled,
+		);
+		assert.equal(outcome.error, boom);
+		assert.equal(outcome.done, 1);
+		assert.deepEqual(outcome.failedIds, ["b1"]);
+	});
+
+	test("the accounts behind a failed one are handed back whole, never half-sent", async () => {
+		const calls: string[][] = [];
+		const outcome = await runChunkedAction(
+			[
+				{ id: "a1", accountId: "acct-a" },
+				{ id: "b1", accountId: "acct-b" },
+				{ id: "c1", accountId: "acct-c" },
+			],
+			async (chunk) => {
+				calls.push(chunk);
+				throw new Error("auth expired");
+			},
+			() => undefined,
+			neverCancelled,
+		);
+		// The run stops where it threw rather than trying the accounts behind it:
+		// what it hands back is exactly what is still untouched, which is what a
+		// retry re-sends.
+		assert.deepEqual(calls, [["a1"]]);
+		assert.equal(outcome.done, 0);
+		assert.deepEqual(outcome.failedIds, ["a1", "b1", "c1"]);
+	});
+
 	test("reports progress after each chunk", async () => {
-		const input = ids(BULK_ACTION_CHUNK_SIZE + 1);
+		const input = targets(BULK_ACTION_CHUNK_SIZE + 1);
 		const progressCalls: { done: number; total: number }[] = [];
 		await runChunkedAction(
 			input,

package/src/lib/bulk-actions.ts

@@ -51,6 +51,53 @@ export const chunkIds = (
 	return chunks;
 };
 
+/** One message a run covers, as the surface that selected it knows it. */
+export interface BulkActionTarget {
+	id: string;
+	/**
+	 * Owning IMAP account — the `accountId` of the account API, never the
+	 * caller's `accountConfigId` (#456). Undefined on a row from a per-mailbox
+	 * listing, which does not carry one because every row in it shares the same
+	 * account.
+	 */
+	accountId: string | undefined;
+}
+
+/**
+ * Split `targets` into chunks of at most `size` that each carry exactly one
+ * account (#872).
+ *
+ * The bulk endpoints reject a batch spanning accounts outright, before applying
+ * any of it, and the daily brief and Flagged are both cross-account lists — so
+ * a selection ticked across two accounts sent as one batch deleted nothing.
+ * Account is a property of the batch, not of the verb: delete and mark-read
+ * cover whatever was ticked, and this is where that becomes one call per
+ * account.
+ *
+ * Targets with no account form a group of their own, which keeps the id in the
+ * run rather than dropping a message the user asked to be acted on. A surface
+ * that carries no account is single-account by construction; one that carries
+ * it for some rows and not others sends the unattributed ones together, and if
+ * the server refuses that batch the run reports it like any other failure.
+ *
+ * Accounts and ids keep the order they were selected in.
+ */
+export const chunkTargets = (
+	targets: readonly BulkActionTarget[],
+	size = BULK_ACTION_CHUNK_SIZE,
+): string[][] => {
+	const byAccount = new Map<string | undefined, string[]>();
+	for (const target of targets) {
+		const held = byAccount.get(target.accountId);
+		if (held) {
+			held.push(target.id);
+			continue;
+		}
+		byAccount.set(target.accountId, [target.id]);
+	}
+	return [...byAccount.values()].flatMap((ids) => chunkIds(ids, size));
+};
+
 export interface BatchResult {
 	successCount: number;
 	failureCount: number;
@@ -93,15 +140,20 @@ export interface BulkActionOutcome {
  * 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).
+ *
+ * Chunks never mix accounts (see `chunkTargets`), and the run walks them as one
+ * sequence: cancellation lands at whichever boundary comes next, whether or not
+ * that is an account boundary, and progress counts toward the whole selection
+ * rather than restarting per account.
  */
 export const runChunkedAction = async (
-	ids: readonly string[],
+	targets: readonly BulkActionTarget[],
 	applyBatch: ApplyBatch,
 	onProgress: (progress: BulkActionProgress) => void,
 	isCancelled: () => boolean,
 ): Promise<BulkActionOutcome> => {
-	const chunks = chunkIds(ids);
-	const total = ids.length;
+	const chunks = chunkTargets(targets);
+	const total = targets.length;
 	let done = 0;
 	const failedIds: string[] = [];
 
@@ -137,13 +189,18 @@ export const runChunkedAction = async (
  * Each chunk is a full mutation of its own, so it keeps that hook's optimistic
  * patch, rollback and error banner. The run stops at the first rejected chunk
  * and reports nothing itself: the hook that owns the call has already raised it.
+ *
+ * Every call site on this path hands over ids from a single account — a
+ * focused row, or a selection the surface already scoped — so nothing here
+ * carries an account to split by. A caller with a cross-account selection
+ * belongs on `runChunkedAction`, whose targets name one (#872).
  */
 export const runChunkedMutation = async (
 	ids: readonly string[],
 	send: (chunk: string[]) => Promise<unknown>,
 ): Promise<void> => {
 	await runChunkedAction(
-		ids,
+		ids.map((id) => ({ id, accountId: undefined })),
 		async (chunk) => {
 			await send(chunk);
 			return { successCount: chunk.length, failureCount: 0 };

package/src/lib/wizard-selection.test.ts

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { ThreadRowData } from "@remit/ui";
+import { wizardSelectionFrom } from "./wizard-selection.js";
+
+const row = (over: Partial<ThreadRowData> & { id: string }): ThreadRowData => ({
+	fromName: "Alice",
+	fromEmail: "alice@example.com",
+	subject: "Quarterly report",
+	snippet: "",
+	timeLabel: "Jan 1",
+	...over,
+});
+
+describe("the ticked rows the wizard is handed", () => {
+	// Regression for #872: a bulk run batches per account, and a row that
+	// arrives without its own account is one the run cannot place.
+	it("carries each row's own account, not the first one it saw", () => {
+		const got = wizardSelectionFrom(
+			[
+				row({ id: "m1", accountId: "acc-work" }),
+				row({ id: "m2", accountId: "acc-personal" }),
+			],
+			new Set(["m1", "m2"]),
+		);
+		assert.deepEqual(
+			got.map((message) => message.accountId),
+			["acc-work", "acc-personal"],
+		);
+	});
+
+	it("keeps a row whose list carries no account rather than dropping it", () => {
+		const got = wizardSelectionFrom([row({ id: "m1" })], new Set(["m1"]));
+		assert.deepEqual(
+			got.map((message) => ({ id: message.id, accountId: message.accountId })),
+			[{ id: "m1", accountId: undefined }],
+		);
+	});
+
+	it("takes only the ticked rows", () => {
+		const got = wizardSelectionFrom(
+			[row({ id: "m1" }), row({ id: "m2" })],
+			new Set(["m2"]),
+		);
+		assert.deepEqual(
+			got.map((message) => message.id),
+			["m2"],
+		);
+	});
+});

package/src/lib/wizard-selection.ts

@@ -0,0 +1,37 @@
+import type { ThreadRowData, WizardMessage } from "@remit/ui";
+
+/** A ticked row, as the wizard's samples and its clause prefill read it. */
+export interface WizardSelectionMessage extends WizardMessage {
+	/** Sender address — the widen's literal fallback and the prefill match on it. */
+	email: string;
+	/**
+	 * Owning account, which a bulk run splits its batches by (#872) — the bulk
+	 * endpoints refuse a batch spanning accounts before applying any of it.
+	 * Stated by every surface rather than inferred: a per-mailbox list has one
+	 * account for all its rows and carries none on the row, while the brief and
+	 * Flagged span accounts and carry each row's own. Never `accountConfigId`,
+	 * which every account of one user shares (#456).
+	 */
+	accountId: string | undefined;
+}
+
+/**
+ * The ticked rows of a thread list, as the wizard reads them. The brief and
+ * Flagged both list rows from every account and hand their selection over the
+ * same way, so they read it from here rather than each keeping a copy that has
+ * to learn about a new field twice.
+ */
+export const wizardSelectionFrom = (
+	rows: readonly ThreadRowData[],
+	selectedIds: ReadonlySet<string>,
+): WizardSelectionMessage[] =>
+	rows
+		.filter((row) => selectedIds.has(row.id))
+		.map((row) => ({
+			id: row.id,
+			sender: row.fromName,
+			email: row.fromEmail,
+			subject: row.subject,
+			date: row.timeLabel,
+			accountId: row.accountId,
+		}));