@remit/web-client 0.0.187 → 0.0.189

package/src/hooks/useIntelligenceSurface.ts

@@ -1,5 +1,5 @@
 import { useAppShellLayout } from "@remit/ui";
-import { useCallback } from "react";
+import { type RefObject, useCallback, useEffect } from "react";
 import { useIntelligenceDrawer } from "@/hooks/useIntelligenceDrawer";
 import { useMailContext } from "@/lib/mail-context";
 
@@ -10,15 +10,11 @@ import { useMailContext } from "@/lib/mail-context";
  * rail's own gate as the answer for both tiers and offered a disabled control
  * with nothing behind it between 1024 and 1280 (#817).
  */
-export interface IntelligenceSurface {
+export interface IntelligenceSurface extends IntelligenceCommands {
 	/** There is a thread to say anything about, so the toolbar's control acts. */
 	canToggle: boolean;
 	/** What the toolbar reports: the rail above 1280, the drawer below it. */
 	isShowing: boolean;
-	/** The toolbar's control, over whichever surface this width has. */
-	toggle: () => void;
-	/** The banner's "Why?" — an open, never a close. */
-	open: () => void;
 	drawerOpen: boolean;
 	closeDrawer: () => void;
 	/** Whether this width has room for the rail, so the rail is the surface. */
@@ -27,6 +23,19 @@ export interface IntelligenceSurface {
 	openRail: () => void;
 }
 
+/**
+ * What a mounted intelligence surface answers for. The width gate is the
+ * shell's own measurement, so only a component inside `AppShellSlotted` knows
+ * which surface this tier has; a pane provider wrapping the shell reaches it
+ * through a ref the mounted surface publishes into.
+ */
+export interface IntelligenceCommands {
+	/** The toolbar's control, over whichever surface this width has. */
+	toggle: () => void;
+	/** The banner's "Why?" — an open, never a close. */
+	open: () => void;
+}
+
 export const useIntelligenceSurface = (
 	openThreadId: string | undefined,
 ): IntelligenceSurface => {
@@ -50,15 +59,40 @@ export const useIntelligenceSurface = (
 		if (!railFits || intelligenceOpen) return;
 		onToggleIntelligence();
 	}, [railFits, intelligenceOpen, onToggleIntelligence]);
+	const open = useCallback(() => {
+		if (!railFits) {
+			openDrawer();
+			return;
+		}
+		openRail();
+	}, [railFits, openDrawer, openRail]);
 
 	return {
 		canToggle: threadId !== null,
 		isShowing: threadId !== null && (railFits ? intelligenceOpen : drawerOpen),
 		toggle,
-		open: railFits ? onToggleIntelligence : openDrawer,
+		open,
 		drawerOpen,
 		closeDrawer: drawer.close,
 		railFits,
 		openRail,
 	};
 };
+
+/**
+ * Publish the mounted surface for the pane provider's keyboard handlers. Null
+ * while nothing is mounted to serve them, so a shortcut fired with no surface
+ * reaches nothing rather than writing `#intelligence` at a width that cannot
+ * render it (`docs/architecture/url-state.md`, R6).
+ */
+export const usePublishIntelligenceCommands = (
+	ref: RefObject<IntelligenceCommands | null>,
+	{ toggle, open }: IntelligenceCommands,
+): void => {
+	useEffect(() => {
+		ref.current = { toggle, open };
+		return () => {
+			ref.current = null;
+		};
+	}, [ref, toggle, open]);
+};

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,
+		}));

package/src/test-support/intelligence-surface.ts

@@ -0,0 +1,42 @@
+/**
+ * What every intelligence-surface spec needs to poke one: the message the
+ * reading pane reads its headers from, the settle the router and the query
+ * client both need, and the drawer as the DOM names it.
+ *
+ * The thread row itself is each spec's own, because the DKIM mismatch that
+ * raises the authenticity banner also raises the rail wherever the rail fits.
+ */
+
+import type { DomHarness } from "@/test-support/dom";
+
+export const THREAD_ID = "thread-1";
+export const MESSAGE_ID = "msg-1";
+
+/** What the reading pane reads each message's own headers and body from. */
+export const describedMessage = {
+	messageId: MESSAGE_ID,
+	envelope: {
+		from: [
+			{
+				addressId: "addr-1",
+				name: "Mondial Relay",
+				email: "delivery.notice@gmail.example",
+			},
+		],
+		to: [],
+		cc: [],
+		bcc: [],
+	},
+	bodyParts: [],
+};
+
+/** Let the router commit, the queries land, and the render that follows run. */
+export const settle = async (mounted: DomHarness): Promise<void> => {
+	await mounted.flush();
+	await mounted.wait(20);
+	await mounted.flush();
+};
+
+/** The intelligence drawer, by the role and label it publishes. */
+export const intelligenceDrawer = (mounted: DomHarness): HTMLElement | null =>
+	mounted.query('[role="dialog"][aria-label="Message details"]');