@remit/web-client 0.0.273 → 0.0.274

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.273",
+  "version": "0.0.274",
   "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/BulkRunProvider.tsx

@@ -149,7 +149,7 @@ export const BulkRunProvider = ({ children }: { children: ReactNode }) => {
 	// itself that does not make `start` its own dependency.
 	const startRef = useRef<BulkRunContextValue["start"]>(async () => ({
 		kind: "ran",
-		outcome: { done: 0, failedIds: [], cancelled: false },
+		outcome: { done: 0, failedIds: [], refused: 0, cancelled: false },
 	}));
 
 	/**
@@ -282,6 +282,19 @@ export const BulkRunProvider = ({ children }: { children: ReactNode }) => {
 						outcome.error,
 					),
 				);
+			} else if (outcome.refused > 0) {
+				// One banner for the run, not one per chunk: a select-all is walked a
+				// hundred ids at a time, and a refusal in each would stack banners
+				// until the surface caps them. The count is the run's own total.
+				pushError({
+					severity: "warning",
+					title:
+						outcome.refused > 1
+							? `Couldn't delete ${outcome.refused} of ${request.matched} messages yet`
+							: "Couldn't delete this message yet",
+					detail:
+						"Something else moved them while the delete was being prepared. They are back where they now sit — try again.",
+				});
 			}
 			// Nobody is left showing this run, so the ending is said where the user
 			// now is. A screen still reporting on it says it in place instead.

package/src/components/mail/MessageCard.blocked-sender.test.ts

@@ -160,6 +160,13 @@ const mount = async (flags: RemitImapAddressFlags): Promise<DomHarness> => {
 		if (call.path.endsWith(`/messages/${MESSAGE_ID}`)) {
 			return describeMessage(flags);
 		}
+		// `/config` answers its own shape. `accounts` is required by the contract,
+		// so a mock that hands back `{items: []}` for it is a body the API cannot
+		// produce, and anything reading it faithfully throws on a fixture rather
+		// than on a fault.
+		if (call.path.endsWith("/config")) {
+			return { accountConfig: {}, accounts: [] };
+		}
 		return { items: [] };
 	});
 

package/src/components/mail/MessageList.run-reporting.test.ts

@@ -34,6 +34,7 @@ const expunging: DeleteOutcome[] = ["permanent", "unconfirmed"];
 const ended = (over: Partial<BulkRunOutcome> = {}): BulkRunOutcome => ({
 	done: 100,
 	failedIds: [],
+	refused: 0,
 	cancelled: false,
 	...over,
 });

package/src/components/mail/MessageListItem.test.ts

@@ -21,6 +21,7 @@ const baseThread = (
 		star: "None",
 		isDeleted: false,
 		senderTrust: "unknown",
+		abandonedMutation: "none",
 		createdAt: 0,
 		updatedAt: 0,
 		...overrides,
@@ -47,11 +48,58 @@ describe("threadToRowData — labels", () => {
 describe("threadToRowData — settlement (issue #1002)", () => {
 	it("marks a row whose delete gave up and came back", () => {
 		const row = threadToRowData(
-			baseThread({ status: "active", syncStatus: "failed" }),
+			baseThread({
+				status: "active",
+				syncStatus: "abandoned",
+				abandonedMutation: "delete",
+			}),
 		);
 		assert.equal(row.settlement, "delete_failed");
 	});
 
+	// Issue #1229. Both give-ups hand the row back the same way, so before the
+	// row named the mutation this rendered "Not deleted" over a move.
+	it("marks a row whose move gave up as a move, not a delete", () => {
+		const row = threadToRowData(
+			baseThread({
+				status: "active",
+				syncStatus: "abandoned",
+				abandonedMutation: "move",
+			}),
+		);
+		assert.equal(row.settlement, "move_failed");
+	});
+
+	it("says nothing about a copy that gave up, whose row no listing carries", () => {
+		const row = threadToRowData(
+			baseThread({
+				status: "deleted",
+				syncStatus: "abandoned",
+				abandonedMutation: "copy",
+			}),
+		);
+		assert.equal(row.settlement, undefined);
+	});
+
+	// `syncStatus` is the gate: a marker a later settle left behind says nothing.
+	it("says nothing about a settled row still carrying a stale marker", () => {
+		const row = threadToRowData(
+			baseThread({
+				status: "active",
+				syncStatus: "synced",
+				abandonedMutation: "delete",
+			}),
+		);
+		assert.equal(row.settlement, undefined);
+	});
+
+	it("says nothing about a transient attempt on an active row", () => {
+		const row = threadToRowData(
+			baseThread({ status: "active", syncStatus: "failed" }),
+		);
+		assert.equal(row.settlement, undefined);
+	});
+
 	it("says nothing about a move mid-retry, which writes the same failed flag", () => {
 		const row = threadToRowData(
 			baseThread({ status: "moving", syncStatus: "failed" }),
@@ -77,14 +125,22 @@ describe("threadToRowData — settlement (issue #1002)", () => {
 describe("the mobile and drafts rows carry the same mark", () => {
 	it("marks the swipeable mobile row", () => {
 		const row = swipeableRowData(
-			baseThread({ status: "active", syncStatus: "failed" }),
+			baseThread({
+				status: "active",
+				syncStatus: "abandoned",
+				abandonedMutation: "delete",
+			}),
 		);
 		assert.equal(row.settlement, "delete_failed");
 	});
 
 	it("marks the drafts row", () => {
 		const row = toImapDraftRowData(
-			baseThread({ status: "active", syncStatus: "failed" }),
+			baseThread({
+				status: "active",
+				syncStatus: "abandoned",
+				abandonedMutation: "delete",
+			}),
 		);
 		assert.equal(row.settlement, "delete_failed");
 	});

package/src/components/mail/MessageSettlementAlert.render.test.ts

@@ -0,0 +1,182 @@
+/**
+ * The reading-pane notice names the mutation that gave up and offers the way
+ * out for that one (#1229).
+ *
+ * A delete retries through the ordinary delete endpoint. A move cannot — the
+ * destination the give-up discarded is on no row — so its retry is the folder
+ * picker, which needs an account to scope its list to. The caller's `accountId`
+ * is absent on rows from per-mailbox endpoints and for as long as the
+ * conversation's own lookup is in flight, and a notice that names a failure and
+ * then offers nothing is the same dead end as one that offers the wrong thing.
+ */
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { createElement } from "react";
+import { createDomHarness, type DomHarness } from "../../test-support/dom";
+import { type HttpMock, mockFetch } from "../../test-support/http";
+import { ErrorBannerProvider } from "../ui/ErrorBannerProvider";
+import { MessageSettlementAlert } from "./MessageSettlementAlert";
+import { RoleAppointmentPromptProvider } from "./RoleAppointmentPromptProvider";
+
+const ACCOUNT = "acc-1";
+const MAILBOX = "mbx-inbox";
+
+let harness: DomHarness | undefined;
+let http: HttpMock;
+
+const CONFIG = {
+	accounts: [{ accountId: ACCOUNT, email: "a@example.com" }],
+};
+
+const MAILBOXES = {
+	items: [
+		{
+			mailboxId: MAILBOX,
+			accountId: ACCOUNT,
+			fullPath: "INBOX",
+			hierarchyDelimiter: "/",
+			messageCount: 1,
+		},
+	],
+};
+
+const respond = (path: string): unknown => {
+	if (path.endsWith("/config")) return CONFIG;
+	if (path.endsWith("/mailboxes")) return MAILBOXES;
+	return {};
+};
+
+const thread = (
+	over: Partial<RemitImapThreadMessageResponse>,
+): RemitImapThreadMessageResponse =>
+	({
+		threadMessageId: "tm-1",
+		threadId: "th-1",
+		messageId: "msg-1",
+		accountConfigId: "cfg-1",
+		mailboxId: MAILBOX,
+		sentDate: 0,
+		isRead: true,
+		hasAttachment: false,
+		hasStars: false,
+		star: "None",
+		isDeleted: false,
+		senderTrust: "unknown",
+		category: "uncategorized",
+		status: "active",
+		syncStatus: "abandoned",
+		abandonedMutation: "none",
+		createdAt: 0,
+		updatedAt: 0,
+		...over,
+	}) as RemitImapThreadMessageResponse;
+
+const mount = (
+	threadMessage: RemitImapThreadMessageResponse,
+	accountId: string | undefined,
+): void => {
+	harness = createDomHarness();
+	harness.render(
+		createElement(
+			QueryClientProvider,
+			{ client: harness.queryClient },
+			createElement(
+				ErrorBannerProvider,
+				null,
+				createElement(
+					RoleAppointmentPromptProvider,
+					null,
+					createElement(MessageSettlementAlert, { threadMessage, accountId }),
+				),
+			),
+		),
+	);
+};
+
+const settle = async (done: () => boolean = () => false): Promise<void> => {
+	if (!harness) throw new Error("nothing mounted");
+	for (let round = 0; round < 40; round += 1) {
+		await harness.flush();
+		await harness.wait(0);
+		if (done()) return;
+	}
+};
+
+const labels = (): string[] =>
+	(harness?.queryAll("button") ?? []).map(
+		(button) => button.getAttribute("aria-label") ?? button.textContent ?? "",
+	);
+
+const notice = (): string => harness?.text() ?? "";
+
+beforeEach(() => {
+	http = mockFetch((call) => respond(call.path));
+});
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http.restore();
+});
+
+describe("MessageSettlementAlert", () => {
+	it("says nothing about a row no mutation gave up on", async () => {
+		mount(
+			thread({ syncStatus: "synced", abandonedMutation: "delete" }),
+			ACCOUNT,
+		);
+		await settle();
+
+		assert.equal(notice(), "");
+	});
+
+	it("offers Delete again for a delete that gave up", async () => {
+		mount(thread({ abandonedMutation: "delete" }), ACCOUNT);
+		await settle();
+
+		assert.match(notice(), /was not deleted/i);
+		assert.ok(labels().some((label) => /delete again/i.test(label)));
+	});
+
+	/**
+	 * The account lookup fans out to `/config` and then to every account's
+	 * mailbox list. Asking for it from each expanded message put that behind
+	 * every open row in the product — and it did, until it was scoped to the one
+	 * case that needs it. Pinned on the wire, because the cost is a request and
+	 * only the request proves it is not being made.
+	 */
+	it("asks for no configuration at all unless a move gave up", async () => {
+		mount(thread({ abandonedMutation: "delete" }), ACCOUNT);
+		await settle();
+
+		assert.deepEqual(http.to("/config"), []);
+	});
+
+	it("asks for none on a healthy row either", async () => {
+		mount(thread({ syncStatus: "synced" }), undefined);
+		await settle();
+
+		assert.deepEqual(http.to("/config"), []);
+	});
+
+	it("offers a folder picker for a move that gave up, never Delete again", async () => {
+		mount(thread({ abandonedMutation: "move" }), ACCOUNT);
+		await settle(() => labels().some((label) => /move again/i.test(label)));
+
+		assert.match(notice(), /was not moved/i);
+		assert.ok(labels().some((label) => /move again/i.test(label)));
+		assert.ok(!labels().some((label) => /delete again/i.test(label)));
+	});
+
+	it("resolves the account from the row's mailbox when the caller has none", async () => {
+		mount(thread({ abandonedMutation: "move" }), undefined);
+		await settle(() => labels().some((label) => /move again/i.test(label)));
+
+		assert.ok(
+			labels().some((label) => /move again/i.test(label)),
+			"a notice that names a failure always carries its way out",
+		);
+	});
+});

package/src/components/mail/MessageSettlementAlert.tsx

@@ -1,19 +1,34 @@
 import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
-import { hasAbandonedDelete } from "@remit/data-ports/message-settlement";
+import { abandonedMutationOf } from "@remit/data-ports/message-settlement";
+import { MessageMutation } from "@remit/domain-enums";
 import { MessageSettlementNotice, messageSettlementCopy } from "@remit/ui";
 import { useCallback, useMemo } from "react";
 import { useDeleteMessages } from "@/hooks/useDeleteMessages";
+import { useMailboxAccount } from "@/hooks/useMailboxAccount";
+import { useMoveMessages } from "@/hooks/useMoveMessages";
 import { buildBugReportContext, buildGitHubIssueUrl } from "@/lib/bug-report";
+import { MoveToTrigger } from "./MoveToTrigger";
 
 /**
- * States, on the open message, that Remit abandoned its delete (issue #1002) —
- * the failure the list can only chip.
+ * States, on the open message, that Remit gave up on a mutation (issue #1002) —
+ * the failure the list can only chip — and offers the way out for THAT
+ * mutation, never a different one (issue #1229).
  *
- * The retry is the ordinary delete endpoint, not a new one: abandoning put
- * `status` back to `active`, so `settledPlacement` passes the row through and
+ * A delete retries through the ordinary delete endpoint: giving up put `status`
+ * back to `active`, so `settledPlacement` passes the row through and
  * `POST /messages/delete` re-drives it against the folder the server actually
- * holds it in. Every other give-up gets no treatment — see `hasAbandonedDelete`
- * for the three the two fields cannot tell from a healthy row.
+ * holds it in. A move cannot retry that way — the destination the give-up
+ * discarded is on no row — so its retry is the same folder picker every other
+ * move goes through, which asks for one. Every other give-up gets no treatment;
+ * `abandonedMutationOf` says which and why.
+ *
+ * The picker needs an account to scope its folder list to, and the caller's
+ * `accountId` is absent on every row that came from a per-mailbox endpoint and
+ * for as long as the conversation's own lookup is in flight. It is resolved
+ * from the row's mailbox here rather than left out, because a notice that names
+ * a failure and offers no way to undo it is the same defect as one that offers
+ * the wrong way (#1229) — the resolver is the one `MessageActionMenu` already
+ * uses for exactly this.
  */
 export function MessageSettlementAlert({
 	threadMessage,
@@ -24,43 +39,86 @@ export function MessageSettlementAlert({
 	accountId: string | undefined;
 	className?: string;
 }) {
-	const abandoned = hasAbandonedDelete(threadMessage);
-	const { deleteMessages, isPending } = useDeleteMessages({
+	const abandoned = abandonedMutationOf(threadMessage);
+	const settlement =
+		abandoned === MessageMutation.delete
+			? ("delete_failed" as const)
+			: abandoned === MessageMutation.move
+				? ("move_failed" as const)
+				: undefined;
+
+	// Only a move that gave up, and only where the caller has no account of its
+	// own, has anything to resolve — so every other row subscribes to nothing.
+	// Asking unconditionally would pull `/config` and every account's mailbox
+	// list into each expanded message, for a case almost none of them are.
+	const { accountId: mailboxAccountId } = useMailboxAccount(
+		settlement === "move_failed" && !accountId
+			? threadMessage.mailboxId
+			: undefined,
+	);
+	const scopedAccountId = accountId ?? mailboxAccountId;
+
+	const { deleteMessages, isPending: isDeleting } = useDeleteMessages({
 		mailboxId: threadMessage.mailboxId,
 		threadId: threadMessage.threadId,
-		accountId,
+		accountId: scopedAccountId,
 		messages: [threadMessage],
 	});
+	const { moveMessages, isPending: isMoving } = useMoveMessages({
+		mailboxId: threadMessage.mailboxId,
+		threadId: threadMessage.threadId,
+		accountId: scopedAccountId,
+	});
 
-	const onRetry = useCallback(() => {
+	const onDeleteAgain = useCallback(() => {
 		deleteMessages([threadMessage.messageId]);
 	}, [deleteMessages, threadMessage.messageId]);
 
+	const onMoveAgain = useCallback(
+		(destinationMailboxId: string) => {
+			moveMessages([threadMessage.messageId], destinationMailboxId);
+		},
+		[moveMessages, threadMessage.messageId],
+	);
+
 	const reportHref = useMemo(
 		() =>
-			abandoned
+			settlement
 				? buildGitHubIssueUrl(
 						buildBugReportContext({
-							title: messageSettlementCopy.delete_failed.title,
-							errorMessage: `Message ${threadMessage.messageId}: status=${threadMessage.status} syncStatus=${threadMessage.syncStatus}`,
+							title: messageSettlementCopy[settlement].title,
+							errorMessage: `Message ${threadMessage.messageId}: status=${threadMessage.status} syncStatus=${threadMessage.syncStatus} abandonedMutation=${threadMessage.abandonedMutation}`,
 						}),
 					)
 				: undefined,
 		[
-			abandoned,
+			settlement,
 			threadMessage.messageId,
 			threadMessage.status,
 			threadMessage.syncStatus,
+			threadMessage.abandonedMutation,
 		],
 	);
 
-	if (!abandoned) return null;
+	if (!settlement) return null;
 
 	return (
 		<MessageSettlementNotice
-			settlement="delete_failed"
-			onRetry={onRetry}
-			retryPending={isPending}
+			settlement={settlement}
+			onRetry={settlement === "delete_failed" ? onDeleteAgain : undefined}
+			action={
+				settlement === "move_failed" && scopedAccountId ? (
+					<MoveToTrigger
+						accountId={scopedAccountId}
+						currentMailboxId={threadMessage.mailboxId}
+						onMove={onMoveAgain}
+						disabled={isMoving}
+						variant="compact"
+						label={messageSettlementCopy.move_failed.retryLabel}
+					/>
+				) : undefined
+			}
+			retryPending={settlement === "delete_failed" ? isDeleting : isMoving}
 			reportHref={reportHref}
 			className={className}
 		/>

package/src/components/mail/bulk-run-state.test.ts

@@ -6,6 +6,7 @@ import { bulkRunReport } from "./bulk-run-state";
 const ended = (over: Partial<BulkRunOutcome> = {}): BulkRunOutcome => ({
 	done: 0,
 	failedIds: [],
+	refused: 0,
 	cancelled: false,
 	...over,
 });

package/src/components/mail/conversation-reply-identity.render.test.ts

@@ -97,6 +97,7 @@ const describeMessage: RemitImapDescribeMessageResponse = {
 		internalDate: 1_767_225_600_000,
 		status: "active",
 		syncStatus: "pending",
+		abandonedMutation: "none",
 	},
 	envelope: {
 		messageId: MESSAGE_ID,

package/src/components/mail/conversation-reply-reach.render.test.ts

@@ -80,6 +80,7 @@ const describeMessage: RemitImapDescribeMessageResponse = {
 		internalDate: 1_767_225_600_000,
 		status: "active",
 		syncStatus: "pending",
+		abandonedMutation: "none",
 	},
 	envelope: {
 		messageId: MESSAGE_ID,

package/src/components/mail/selection-wizard-run-controls.test.ts

@@ -145,6 +145,7 @@ describe("whether the run screen offers a way to end the run", () => {
 	const outcome: BulkRunOutcome = {
 		done: 2,
 		failedIds: [],
+		refused: 0,
 		cancelled: false,
 	};
 

package/src/components/mail/two-window-listeners-one-key.render.test.ts

@@ -94,6 +94,7 @@ const describeMessage: RemitImapDescribeMessageResponse = {
 		internalDate: LATEST_SENT,
 		status: "active",
 		syncStatus: "pending",
+		abandonedMutation: "none",
 	},
 	envelope: {
 		messageId: MESSAGE_ID,

package/src/components/ui/placement-refusal.test.ts

@@ -56,16 +56,6 @@ describe("placementRefusalBanner", () => {
 		assert.match(banner.detail ?? "", /try again in a moment/i);
 	});
 
-	it("tells an abandoned move to resync, not to wait", () => {
-		const banner = placementRefusalBanner(
-			{ reason: "unverified", messageId: "msg-1" },
-			1,
-			"delete",
-		);
-		assert.match(banner.detail ?? "", /sync the folder/i);
-		assert.doesNotMatch(banner.detail ?? "", /try again in a moment/i);
-	});
-
 	it("counts the selection in the title", () => {
 		assert.match(
 			placementRefusalBanner(
@@ -90,22 +80,19 @@ describe("placementRefusalBanner", () => {
 
 		const detail =
 			placementRefusalBanner(
-				{ reason: "unverified", messageId: "msg-1" },
+				{ reason: "in_flight", messageId: "msg-1" },
 				1,
 				"move",
 			).detail ?? "";
-		assert.match(detail, /move it again/i);
 		assert.doesNotMatch(detail, /delete/i);
 	});
 
 	it("never repeats the server's uuid at the user", () => {
-		for (const reason of ["in_flight", "unverified"] as const) {
-			const banner = placementRefusalBanner(
-				{ reason, messageId: "msg-1" },
-				1,
-				"delete",
-			);
-			assert.doesNotMatch(`${banner.title} ${banner.detail}`, /msg-1/);
-		}
+		const banner = placementRefusalBanner(
+			{ reason: "in_flight", messageId: "msg-1" },
+			1,
+			"delete",
+		);
+		assert.doesNotMatch(`${banner.title} ${banner.detail}`, /msg-1/);
 	});
 });

package/src/components/ui/placement-refusal.ts

@@ -9,11 +9,13 @@ import type { PushErrorInput } from "@/components/ui/error-banners";
 import { type CodedApiErrorBody, codedApiErrorBody } from "@/lib/api";
 
 /**
- * `in_flight` clears on its own once the mail server confirms the move;
- * `unverified` does not, because the move gave up without confirming and
- * nothing routine repairs the row.
+ * One reason, because one state produces the refusal: a mutation is still in
+ * flight and the pair clears on its own, so the copy words a wait. A mutation
+ * that gave up hands the row back to a placement the mail server confirmed
+ * before it stops (imap-mutations R3), and that row is acted on rather than
+ * refused — there is no second reason left to word.
  */
-export type PlacementRefusalReason = "in_flight" | "unverified";
+export type PlacementRefusalReason = "in_flight";
 
 export interface PlacementRefusal {
 	reason: PlacementRefusalReason;
@@ -22,7 +24,6 @@ export interface PlacementRefusal {
 
 const REASONS: ReadonlySet<string> = new Set<PlacementRefusalReason>([
 	"in_flight",
-	"unverified",
 ]);
 
 const stringAt = (
@@ -53,11 +54,11 @@ export const isPlacementRefusal = (
 export type PlacementRefusalAction = "delete" | "move";
 
 /**
- * The banner copy. Both reasons say what happened and what to do; neither is a
- * dead end, and neither repeats the server's uuid at the user.
+ * The banner copy. It says what happened and what to do, is not a dead end, and
+ * does not repeat the server's uuid at the user.
  */
 export const placementRefusalBanner = (
-	refusal: PlacementRefusal,
+	_refusal: PlacementRefusal,
 	count: number,
 	action: PlacementRefusalAction,
 ): PushErrorInput => ({
@@ -66,8 +67,5 @@ export const placementRefusalBanner = (
 		count > 1
 			? `Couldn't ${action} ${count} messages yet`
 			: `Couldn't ${action} this message yet`,
-	detail:
-		refusal.reason === "in_flight"
-			? "It is still being moved on the mail server. Try again in a moment."
-			: `An earlier move never finished, so where this message sits is unknown. Sync the folder, then ${action} it again.`,
+	detail: "It is still being moved on the mail server. Try again in a moment.",
 });

package/src/hooks/useDeleteMessages.ts

@@ -161,6 +161,25 @@ export const useDeleteMessages = ({
 				previousThreadsList,
 			};
 		},
+		// A batch that partly applied answers 200 with a non-zero `failureCount`:
+		// the rows whose placement changed under it were never claimed
+		// (imap-mutations R3). `onSettled` invalidates, so those rows come back on
+		// their own — this is what stops them coming back unexplained, which is
+		// the dead-button failure wearing a different face (#1229).
+		onSuccess: (data, vars) => {
+			const refused = data?.failureCount ?? 0;
+			if (refused === 0) return;
+			const asked = vars.body.messageIds?.length ?? 0;
+			pushError({
+				severity: "warning",
+				title:
+					refused > 1
+						? `Couldn't delete ${refused} of ${asked} messages yet`
+						: "Couldn't delete this message yet",
+				detail:
+					"Something else moved it while the delete was being prepared. It is back where it now sits — try again.",
+			});
+		},
 		onError: (err, vars, context) => {
 			if (context) {
 				for (const entry of context.previousThreadMessages) {

package/src/hooks/useMailboxAccount.ts

@@ -25,9 +25,14 @@ interface MailboxAccountResolution {
 export const useMailboxAccount = (
 	mailboxId: string | undefined,
 ): MailboxAccountResolution => {
+	// Disabled where there is no mailbox to resolve, the way the fan-out below
+	// already is. A caller that already knows its account passes `undefined` and
+	// this subscribes to nothing — which keeps the hook from pulling `/config`
+	// into trees that never asked for it.
 	const { data: config, isLoading: isConfigLoading } = useQuery({
 		...configOperationsGetConfigOptions(),
 		staleTime: Infinity,
+		enabled: !!mailboxId,
 	});
 
 	const accountIds = useMemo(

package/src/hooks/useToggleStar.test.ts

@@ -14,6 +14,7 @@ const make = (
 	senderTrust: "unknown",
 	status: "active",
 	syncStatus: "pending",
+	abandonedMutation: "none",
 	category: "uncategorized",
 	threadId: "t1",
 	threadMessageId: `tm-${messageId}`,

package/src/hooks/useToggleTrusted.test.ts

@@ -70,6 +70,7 @@ describe("patchDescribeMessage", () => {
 				internalDate: 1,
 				status: "active",
 				syncStatus: "pending",
+				abandonedMutation: "none",
 			},
 			envelope: {
 				messageId: "m",

package/src/lib/brief.test.ts

@@ -43,6 +43,7 @@ function threadResponse(
 		senderTrust: "unknown",
 		status: "active",
 		syncStatus: "pending",
+		abandonedMutation: "none",
 		muted: false,
 		createdAt: 0,
 		updatedAt: 0,

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

@@ -132,6 +132,28 @@ describe("chunkTargets", () => {
 describe("runChunkedAction", () => {
 	const noopProgress = () => undefined;
 
+	// A select-all is walked a hundred ids at a time. Summed here so the caller
+	// states the refusals once for the run, rather than pushing a banner per
+	// chunk until the surface caps them.
+	test("sums the rows the server refused across every chunk", async () => {
+		const outcome = await runChunkedAction(
+			Array.from({ length: 250 }, (_, i) => ({
+				id: `m${i}`,
+				accountId: "acc-1",
+			})),
+			async (chunk) => ({
+				successCount: chunk.length - 1,
+				failureCount: 1,
+			}),
+			noopProgress,
+			neverAborted(),
+		);
+
+		assert.equal(outcome.refused, 3, "one per chunk, over three chunks");
+		assert.equal(outcome.done, 250, "every id was reached");
+		assert.deepEqual(outcome.failedIds, [], "and none was left unattempted");
+	});
+
 	test("zero ids does nothing and reports done=0", async () => {
 		const calls: string[][] = [];
 		const outcome = await runChunkedAction(
@@ -146,6 +168,7 @@ describe("runChunkedAction", () => {
 		assert.deepEqual(outcome, {
 			done: 0,
 			failedIds: [],
+			refused: 0,
 			cancelled: false,
 		});
 		assert.equal(calls.length, 0);
@@ -356,7 +379,12 @@ describe("runPredicateAction", () => {
 			noopProgress,
 			neverAborted(),
 		);
-		assert.deepEqual(outcome, { done: 0, failedIds: [], cancelled: false });
+		assert.deepEqual(outcome, {
+			done: 0,
+			failedIds: [],
+			refused: 0,
+			cancelled: false,
+		});
 	});
 
 	test("exactly 100 matches — a page size's worth — resolves in a single page with no continuation", async () => {

package/src/lib/bulk-actions.ts

@@ -10,10 +10,13 @@
  *
  * 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.
+ * applied it. Delete is the one action that can accept some of a batch and not
+ * the rest — a row whose placement changed under it is refused and counted in
+ * the response (imap-mutations R3) — and it reports that itself, on the call,
+ * rather than here: this layer only ever hands ids back, and an id this run did
+ * reach is not one it should re-offer. The only failure it observes is a thrown
+ * call: an infrastructure failure (auth, the write, or the enqueue) that takes
+ * out the whole batch and stops the run.
  *
  * Cancellation is an `AbortSignal` the caller owns, handed to every call the run
  * makes (#113). Aborting ends the request in flight rather than waiting for it,
@@ -165,10 +168,19 @@ export interface BulkActionOutcome {
 	 * An aborted batch is counted here too: aborting the request does not
 	 * un-send what the server already accepted, so its ids are "may not have
 	 * landed" rather than "did not", and every action here is idempotent.
-	 * There is no per-id failure source: a returned batch call counts every id in
-	 * it as accepted (see the module header).
+	 * A returned batch call counts every id in it as reached. Delete's own
+	 * per-row refusals ride its response and are surfaced by the caller, not
+	 * folded in here (see the module header).
 	 */
 	failedIds: string[];
+	/**
+	 * Rows the server reached and refused: their placement changed under the
+	 * run, so the action never claimed them (imap-mutations R3). Summed across
+	 * every chunk so the caller states it once for the whole run rather than
+	 * once per hundred ids. Not folded into `failedIds` — those were never
+	 * reached, and these were.
+	 */
+	refused: number;
 	cancelled: boolean;
 	/** Set when a batch call threw — an infrastructure failure, not a
 	 *  per-item failure. The run stops at the point it was raised. */
@@ -198,26 +210,34 @@ export const runChunkedAction = async (
 	const chunks = chunkTargets(targets);
 	const total = targets.length;
 	let done = 0;
+	let refused = 0;
 	const failedIds: string[] = [];
 
 	for (let i = 0; i < chunks.length; i++) {
 		if (signal.aborted) {
 			failedIds.push(...chunks.slice(i).flat());
-			return { done, failedIds, cancelled: true };
+			return { done, failedIds, refused, cancelled: true };
 		}
 		const chunk = chunks[i];
 		const attempted = await attempt(applyBatch(chunk, signal));
 		if (!attempted.ok) {
 			failedIds.push(...chunks.slice(i).flat());
-			if (signal.aborted) return { done, failedIds, cancelled: true };
+			if (signal.aborted) return { done, failedIds, refused, cancelled: true };
 			onProgress({ done, total });
-			return { done, failedIds, cancelled: false, error: attempted.error };
+			return {
+				done,
+				failedIds,
+				refused,
+				cancelled: false,
+				error: attempted.error,
+			};
 		}
+		refused += attempted.value?.failureCount ?? 0;
 		done += chunk.length;
 		onProgress({ done, total });
 	}
 
-	return { done, failedIds, cancelled: false };
+	return { done, failedIds, refused, cancelled: false };
 };
 
 /**
@@ -290,27 +310,42 @@ export const runPredicateAction = async (
 	signal: AbortSignal,
 ): Promise<BulkActionOutcome> => {
 	let done = 0;
+	let refused = 0;
 	const failedIds: string[] = [];
 	let token: string | undefined;
 
 	do {
 		if (signal.aborted) {
-			return { done, failedIds, cancelled: true };
+			return { done, failedIds, refused, cancelled: true };
 		}
 
 		const fetched = await attempt(fetchIdsPage(token, signal));
 		if (!fetched.ok) {
-			if (signal.aborted) return { done, failedIds, cancelled: true };
-			return { done, failedIds, cancelled: false, error: fetched.error };
+			if (signal.aborted) return { done, failedIds, refused, cancelled: true };
+			return {
+				done,
+				failedIds,
+				refused,
+				cancelled: false,
+				error: fetched.error,
+			};
 		}
 		const page = fetched.value;
 
 		if (page.ids.length > 0) {
 			const attempted = await attempt(applyBatch(page.ids, signal));
 			if (!attempted.ok) {
-				if (signal.aborted) return { done, failedIds, cancelled: true };
-				return { done, failedIds, cancelled: false, error: attempted.error };
+				if (signal.aborted)
+					return { done, failedIds, refused, cancelled: true };
+				return {
+					done,
+					failedIds,
+					refused,
+					cancelled: false,
+					error: attempted.error,
+				};
 			}
+			refused += attempted.value?.failureCount ?? 0;
 			done += page.ids.length;
 			onProgress({ done, total });
 		}
@@ -318,7 +353,7 @@ export const runPredicateAction = async (
 		token = page.continuationToken;
 	} while (token);
 
-	return { done, failedIds, cancelled: false };
+	return { done, failedIds, refused, cancelled: false };
 };
 
 /**
@@ -342,6 +377,14 @@ export const honestProgress = (
 export interface BulkRunOutcome {
 	done: number;
 	failedIds: string[];
+	/**
+	 * Rows the server reached and refused: their placement changed under the
+	 * run, so the action never claimed them (imap-mutations R3). Summed across
+	 * every chunk so the caller states it once for the whole run rather than
+	 * once per hundred ids. Not folded into `failedIds` — those were never
+	 * reached, and these were.
+	 */
+	refused: number;
 	cancelled: boolean;
 	error?: unknown;
 }

package/src/lib/dedupe-thread-messages.test.ts

@@ -26,6 +26,7 @@ function threadMessage(
 		senderTrust: "unknown",
 		status: "active",
 		syncStatus: "pending",
+		abandonedMutation: "none",
 		muted: false,
 		createdAt: 0,
 		updatedAt: 0,

package/src/lib/row-settlement.ts

@@ -1,15 +1,28 @@
 import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
-import { hasAbandonedDelete } from "@remit/data-ports/message-settlement";
+import { abandonedMutationOf } from "@remit/data-ports/message-settlement";
+import { MessageMutation } from "@remit/domain-enums";
 import type { ThreadRowData } from "@remit/ui";
 
 /**
- * The row treatment for a message whose delete Remit abandoned (issue #1002). The
- * client decides nothing: `hasAbandonedDelete` owns which `status`/`syncStatus`
- * pair proves a terminal give-up, and why no other pair does. Any other row —
- * settled, mid-retry, or an undecidable move — carries no key at all and
+ * The row treatment for a message whose mutation Remit gave up on (issue
+ * #1002). The client decides nothing: `abandonedMutationOf` owns which values
+ * prove a terminal give-up and which operation it was. A copy that gave up
+ * leaves a `deleted` row no listing carries, so it reaches no row here; any
+ * other row — settled, mid-retry, or in flight — carries no key at all and
  * renders exactly as it always has.
  */
 export const rowSettlement = (
-	thread: Pick<RemitImapThreadMessageResponse, "status" | "syncStatus">,
-): Pick<ThreadRowData, "settlement"> =>
-	hasAbandonedDelete(thread) ? { settlement: "delete_failed" } : {};
+	thread: Pick<
+		RemitImapThreadMessageResponse,
+		"status" | "syncStatus" | "abandonedMutation"
+	>,
+): Pick<ThreadRowData, "settlement"> => {
+	switch (abandonedMutationOf(thread)) {
+		case MessageMutation.delete:
+			return { settlement: "delete_failed" };
+		case MessageMutation.move:
+			return { settlement: "move_failed" };
+		default:
+			return {};
+	}
+};

package/src/lib/thread-search-tokens.test.ts

@@ -43,6 +43,7 @@ const thread = (
 	senderTrust: "unknown",
 	status: "active",
 	syncStatus: "pending",
+	abandonedMutation: "none",
 	muted: false,
 	createdAt: 0,
 	updatedAt: 0,

package/src/test-support/fixtures.ts

@@ -80,6 +80,7 @@ export const makeThreadMessage = (
 	isDeleted: false,
 	status: "active",
 	syncStatus: "pending",
+	abandonedMutation: "none",
 	senderTrust: "unknown",
 	muted: false,
 	createdAt: 0,