@remit/web-client 0.0.98 → 0.0.100

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.98",
+  "version": "0.0.100",
   "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/MessageList.run-reporting.test.ts

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+
+/**
+ * A run states how it ended, to whoever is still there to read it (#521). The
+ * run screen invites the user to close it and keep the run going, which leaves
+ * the run with no screen of its own — so the list says what it reached, whether
+ * that was everything or a hundred out of three thousand.
+ *
+ * The list wires the virtualizer, routing and several data hooks together, so
+ * — as with this package's other component-level rules (see
+ * `MessageList.selection.test.ts`) — the wiring is read off the source. The
+ * sentences themselves are unit-tested in `../../lib/bulk-action-copy.test.ts`,
+ * and which runs reach this seam in `SelectionWizardHost.run-exit.test.ts`.
+ */
+
+const here = dirname(fileURLToPath(import.meta.url));
+const source = readFileSync(resolve(here, "MessageList.tsx"), "utf8");
+
+const reportBody = source.match(
+	/const reportRunOutcome = useCallback\(([\s\S]*?)\n\t\t\[pushError\],/,
+)?.[1];
+
+describe("reporting how a run ended", () => {
+	it("hands the wizard somewhere to report an ending it can no longer show", () => {
+		assert.ok(reportBody, "the list reports no run outcome");
+		const host = source.match(/<SelectionWizardHost[\s\S]*?\/>/)?.[0] ?? "";
+		assert.match(host, /onRunEnded=\{reportRunOutcome\}/);
+	});
+
+	it("names both endings: what it covered, and what it stopped short of", () => {
+		assert.match(reportBody ?? "", /bulkActionStoppedTitle\(outcome\.done\)/);
+		assert.match(
+			reportBody ?? "",
+			/bulkActionCompletionText\(kind, outcome\.done\)/,
+		);
+	});
+
+	it("raises a stopped run as a warning rather than a passing note", () => {
+		assert.match(reportBody ?? "", /severity: "warning"/);
+	});
+});
+
+describe("the run the wizard leaves behind", () => {
+	it("is stoppable from the wizard, which is not the same as closing it", () => {
+		assert.match(source, /stop: escalation\.stop,/);
+	});
+
+	it("keeps reporting on the bar from the moment it starts", () => {
+		assert.match(
+			source,
+			/escalation\.progress\?\.total \?\? selectionCount/,
+			"a run with no batch finished yet has no denominator to show",
+		);
+	});
+});

package/src/components/mail/MessageList.tsx

@@ -14,6 +14,7 @@ import { Search } from "lucide-react";
 import type { RefObject } from "react";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { ConfirmDialog } from "@/components/ui/ConfirmDialog";
+import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
 import { formatErrorMessage } from "@/components/ui/ErrorState";
 import { useJunkMailbox } from "@/hooks/useArchiveMailbox";
 import {
@@ -32,10 +33,14 @@ import {
 } from "@/hooks/useSelection";
 import { buildBugReportContext, buildGitHubIssueUrl } from "@/lib/bug-report";
 import {
+	type BulkActionKind,
 	bulkActionCompletionText,
 	bulkActionProgressLabel,
 	bulkActionProgressTone,
+	bulkActionStoppedDetail,
+	bulkActionStoppedTitle,
 } from "@/lib/bulk-action-copy";
+import type { BulkRunOutcome } from "@/lib/bulk-actions";
 import {
 	describeSearchScope,
 	escalatedStatusLabel,
@@ -241,6 +246,7 @@ export const MessageList = ({
 	const isSearching = !!searchQuery?.trim();
 	const listHeaderChrome = useListHeaderChrome();
 	const { labels } = useLabelList(accountId);
+	const { pushError } = useErrorBanners();
 
 	// Roving focus cursor (#429): the keyboard "where am I" pointer, distinct
 	// from the open thread (`selectedMessageId` in the URL). j/k move this
@@ -336,6 +342,31 @@ export const MessageList = ({
 		searchQuery: searchPredicate ?? {},
 	});
 
+	// How a run ended, for the user who is no longer looking at the run screen.
+	// Closing the wizard mid-run is a movement the screen invites, and the run
+	// keeps going past it — so the list is what states the ending, whether the
+	// run covered everything or stopped short of it. The wizard calls this only
+	// once the user has left it, so an ending is never said twice.
+	const reportRunOutcome = useCallback(
+		(kind: BulkActionKind, matched: number, outcome: BulkRunOutcome) => {
+			// A run stopped by a thrown batch is already banner-ed where it threw.
+			if (outcome.error !== undefined) return;
+			if (outcome.cancelled) {
+				pushError({
+					severity: "warning",
+					title: bulkActionStoppedTitle(outcome.done),
+					detail: bulkActionStoppedDetail(kind, outcome.done, matched),
+				});
+				return;
+			}
+			pushError({
+				severity: "info",
+				title: bulkActionCompletionText(kind, outcome.done),
+			});
+		},
+		[pushError],
+	);
+
 	// The one way selection mode ends (#115): cancel, a completed delete or
 	// move, a plain click that collapses a range, switching mailboxes, the back
 	// gesture. Nothing calls the selection hook's `clearSelection` directly, so
@@ -625,9 +656,7 @@ export const MessageList = ({
 
 	// The escalated selection as the wizard walks it (#508): the words the bar
 	// already names the predicate with, the count it was escalated to, and the
-	// chunked runner that re-resolves it. The wizard's review screen stands in
-	// front of that runner and its run screen drives it, so nothing here reports
-	// an outcome of its own.
+	// chunked runner that re-resolves it.
 	const escalatedSelection: EscalatedSelection | undefined =
 		escalation.phase.kind === "escalated"
 			? {
@@ -635,6 +664,7 @@ export const MessageList = ({
 					total: escalation.phase.total,
 					searchQuery: searchPredicate ?? {},
 					run: (action: EscalatedAction) => escalation.runAction(action),
+					stop: escalation.stop,
 				}
 			: undefined;
 
@@ -1062,11 +1092,15 @@ export const MessageList = ({
 			? escalation.phase.total
 			: selectedCount;
 
+	// A run reports on the bar from the moment it starts, not from its first
+	// finished batch: the wizard invites the user back here mid-run, and a run
+	// with no reading yet is still a run — it is counted against what it was
+	// started with until it has covered something of its own.
 	const selectionStatusLabel = escalation.runningAction
 		? bulkActionProgressLabel(
 				escalation.runningAction.kind,
 				escalation.progress?.done ?? 0,
-				escalation.progress?.total ?? 0,
+				escalation.progress?.total ?? selectionCount,
 			)
 		: escalation.phase.kind === "counting"
 			? escalation.phase.countSoFar >= 5000
@@ -1088,14 +1122,13 @@ export const MessageList = ({
 				}
 			: undefined;
 
-	const selectionProgress =
-		escalation.runningAction && escalation.progress
-			? {
-					value: escalation.progress.done,
-					max: escalation.progress.total,
-					tone: bulkActionProgressTone(escalation.runningAction.kind),
-				}
-			: undefined;
+	const selectionProgress = escalation.runningAction
+		? {
+				value: escalation.progress?.done ?? 0,
+				max: escalation.progress?.total ?? selectionCount,
+				tone: bulkActionProgressTone(escalation.runningAction.kind),
+			}
+		: undefined;
 
 	// At most one escalation notice at a time, ranked by how actionable it is:
 	// an in-progress counting/escalated state and its own action always wins;
@@ -1325,6 +1358,7 @@ export const MessageList = ({
 				escalated={escalatedSelection}
 				escalatedProgress={escalation.progress}
 				onFinished={exitSelection}
+				onRunEnded={reportRunOutcome}
 			/>
 		</>
 	);

package/src/components/mail/MoveToTrigger.tsx

@@ -15,9 +15,9 @@ import { Drawer } from "vaul";
 import { ErrorState } from "@/components/ui/ErrorState";
 import { useFolderAppointments } from "@/hooks/useArchiveMailbox";
 import { useCreateMailbox } from "@/hooks/useCreateMailbox";
+import { useFolderLabelTranslator } from "@/hooks/useFolderLabelTranslator";
 import { useIsDesktop } from "@/hooks/useMediaQuery";
-import { buildMailboxRoleMap, labelForMailbox } from "@/lib/folder-roles";
-import { buildMoveTargets } from "@/lib/move-targets";
+import { buildMoveOptions } from "@/lib/move-options";
 import { cn } from "@/lib/utils";
 
 interface MoveToTriggerProps {
@@ -71,15 +71,7 @@ export const MoveToTrigger = ({
 	const triggerLabel = label ?? "Move to folder";
 	const popoverId = useId();
 	const { t } = useTranslation("mail", { useSuspense: false });
-	// `labelForMailbox` expects a translator with a positional `(key,
-	// fallback)` shape; i18next's `t` treats the second argument as an options
-	// object — passing it raw breaks fallback behavior. Wrap it the same way
-	// the sidebar adapter does, memoized so it's a stable `useMemo` dependency.
-	const translator = useCallback(
-		(key: string, fallback: string): string =>
-			t(key, { defaultValue: fallback }),
-		[t],
-	);
+	const translator = useFolderLabelTranslator();
 
 	const {
 		data: mailboxesResponse,
@@ -98,28 +90,21 @@ export const MoveToTrigger = ({
 	const folderAppointments = useFolderAppointments(accountId);
 	const { createFolder } = useCreateMailbox(accountId);
 
-	const options = useMemo<MoveMailboxOption[]>(() => {
-		const targets = buildMoveTargets(
-			mailboxesResponse?.items ?? [],
-			folderAppointments,
-		);
-		const roleMap = buildMailboxRoleMap(folderAppointments);
-		return targets.map((mailbox) => ({
-			id: mailbox.mailboxId,
-			label: labelForMailbox(
-				mailbox,
-				roleMap.get(mailbox.mailboxId),
+	const options = useMemo<MoveMailboxOption[]>(
+		() =>
+			buildMoveOptions({
+				mailboxes: mailboxesResponse?.items ?? [],
+				folderAppointments,
+				currentMailboxId,
 				translator,
-			),
-			searchValue: mailbox.fullPath,
-			isCurrent: mailbox.mailboxId === currentMailboxId,
-		}));
-	}, [
-		mailboxesResponse?.items,
-		folderAppointments,
-		currentMailboxId,
-		translator,
-	]);
+			}),
+		[
+			mailboxesResponse?.items,
+			folderAppointments,
+			currentMailboxId,
+			translator,
+		],
+	);
 
 	const handleSelect = useCallback(
 		(destinationMailboxId: string) => {

package/src/components/mail/SelectionWizardHost.run-exit.test.ts

@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+
+/**
+ * Every way off the run screen is the same movement, and none of them ends the
+ * run the screen promised would keep going (#521). Ending it is a control of
+ * its own, and whichever way the user leaves, the run reports where it got to.
+ *
+ * The host wires routing, history and several data hooks together, so — as with
+ * this package's other component-level rules (see `MessageList.selection.test.ts`)
+ * — the wiring is read off the source. What the exits then do is proven where it
+ * can be run: `../../hooks/escalated-run-lifetime.render.test.ts` for the run's
+ * lifetime, and `@remit/ui`'s `selection-wizard.render.test.ts` for the controls.
+ */
+
+const here = dirname(fileURLToPath(import.meta.url));
+const source = readFileSync(resolve(here, "SelectionWizardHost.tsx"), "utf8");
+
+describe("leaving the run screen", () => {
+	it("routes the header's X and back arrow through the same dismiss the footer uses", () => {
+		assert.match(source, /onExit=\{current === "run" \? dismiss : cancel\}/);
+	});
+
+	it("routes hardware back through that dismiss too", () => {
+		assert.match(
+			source,
+			/if \(action !== "BACK"\) return false;\s*\n\s*dismiss\(\);/,
+		);
+	});
+
+	it("leaves the run alone on the way out", () => {
+		const dismissBody = source.match(
+			/const dismiss = useCallback\(\(\) => \{([\s\S]*?)\}, \[/,
+		)?.[1];
+		assert.ok(dismissBody, "the run screen has no dismiss");
+		assert.doesNotMatch(dismissBody, /stop/i);
+	});
+});
+
+describe("ending the run", () => {
+	it("is a control of its own, offered only while a run is in flight", () => {
+		assert.match(source, /onCancelRun: runInFlight \? stopRun : undefined/);
+		assert.match(
+			source,
+			/const runInFlight =\s*bulkRun !== undefined && bulkRun\.outcome === undefined;/,
+		);
+	});
+
+	it("stops whichever runner is paging — the list's or the wizard's own", () => {
+		const stopBody = source.match(
+			/const stopRun = useCallback\(\(\) => \{([\s\S]*?)\}, \[/,
+		)?.[1];
+		assert.ok(stopBody, "there is no way to stop a run");
+		assert.match(stopBody, /escalated\.stop\(\)/);
+		assert.match(stopBody, /stopBulk\(\)/);
+	});
+});
+
+/**
+ * Both runners report, not just the predicate one: a ticked select-all runs on
+ * the wizard's own runner, and the same screen makes the same promise over it.
+ */
+describe("stating how a run ended once the screen is gone", () => {
+	it("marks the walk-away where it happens rather than reading it back off the URL", () => {
+		assert.match(source, /walkedAway\.current = true;\s*\n\s*closeWizard\(/);
+	});
+
+	for (const runner of ["runBulk", "runEscalated"]) {
+		it(`reports the run ${runner} drove`, () => {
+			const body =
+				source.match(
+					new RegExp(
+						`const ${runner} = useCallback\\(([\\s\\S]*?)\\n\\t\\}, \\[`,
+					),
+				)?.[1] ?? "";
+			assert.match(body, /if \(walkedAway\.current\)/);
+			assert.match(body, /onRunEnded\?\.\(action\.kind, /);
+		});
+	}
+});

package/src/components/mail/SelectionWizardHost.tsx

@@ -41,16 +41,16 @@ import {
 	useEscalatedActions,
 } from "@/hooks/useEscalatedActions";
 import { useCreateFilter } from "@/hooks/useFilters";
+import { useFolderLabelTranslator } from "@/hooks/useFolderLabelTranslator";
 import { useMatchSample, useSearchMatchSample } from "@/hooks/useMatchSample";
 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 { getMailboxDisplayName } from "@/lib/folder-roles";
 import { useListHeaderChrome } from "@/lib/list-header-chrome";
 import { useMailContext } from "@/lib/mail-context";
-import { buildMoveTargets } from "@/lib/move-targets";
+import { buildMoveOptions } from "@/lib/move-options";
 import {
 	buildWizardDraft,
 	canBackApplyDraft,
@@ -106,9 +106,12 @@ export interface EscalatedSelection {
 	/**
 	 * Runs one verb over the whole predicate, paging it server-side. The chunked
 	 * runner the list already owns: the run screen drives it, and the review
-	 * screen is what now stands in front of it.
+	 * screen is what now stands in front of it. The run belongs to the list, so
+	 * it survives the wizard closing over it — as the run screen promises.
 	 */
 	run: (action: EscalatedAction) => Promise<BulkRunOutcome>;
+	/** Ends that run at the next page boundary, which leaving the wizard does not. */
+	stop: () => void;
 }
 
 export interface SelectionWizardHostProps {
@@ -133,6 +136,17 @@ export interface SelectionWizardHostProps {
 	escalatedProgress?: BulkActionProgress;
 	/** The wizard is done with the selection, and the list drops it. */
 	onFinished: () => void;
+	/**
+	 * How a run ended, once the screen that was reporting on it is gone. The run
+	 * screen invites the user to close it and keep the run going, so the surface
+	 * that outlives the wizard is what states the ending. Called only for a run
+	 * the user walked away from; a run screen still up reports in place.
+	 */
+	onRunEnded?: (
+		kind: EscalatedAction["kind"],
+		matched: number,
+		outcome: BulkRunOutcome,
+	) => void;
 }
 
 /**
@@ -248,6 +262,7 @@ function SelectionWizardSession({
 	escalatedProgress,
 	searchConversion,
 	onFinished,
+	onRunEnded,
 	step,
 	goToStep,
 	goBack,
@@ -296,6 +311,11 @@ function SelectionWizardSession({
 	// cleared, so a failed start can be retried.
 	const [backApplyDraft, setBackApplyDraft] = useState<OrganizeDraft>();
 	const commitSent = useRef(false);
+	// The user left the run screen while it was still reporting. Held here rather
+	// than read back off the URL: the rewind the exit starts lands a frame or two
+	// later, and an outcome arriving in between would find a screen that is on
+	// its way out and say nothing.
+	const walkedAway = useRef(false);
 
 	const messageIds = useMemo(
 		() => selection.map((message) => message.id),
@@ -367,17 +387,16 @@ function SelectionWizardSession({
 		staleTime: Number.POSITIVE_INFINITY,
 	});
 	const folderAppointments = useFolderAppointments(accountId);
+	const translator = useFolderLabelTranslator();
 	const mailboxes = useMemo<MoveMailboxOption[]>(
 		() =>
-			buildMoveTargets(mailboxesData?.items ?? [], folderAppointments).map(
-				(mailbox) => ({
-					id: mailbox.mailboxId,
-					label: getMailboxDisplayName(mailbox.fullPath),
-					searchValue: mailbox.fullPath,
-					isCurrent: mailbox.mailboxId === mailboxId,
-				}),
-			),
-		[mailboxesData?.items, folderAppointments, mailboxId],
+			buildMoveOptions({
+				mailboxes: mailboxesData?.items ?? [],
+				folderAppointments,
+				currentMailboxId: mailboxId,
+				translator,
+			}),
+		[mailboxesData?.items, folderAppointments, mailboxId, translator],
 	);
 	const { createFolder } = useCreateMailbox(accountId);
 
@@ -575,8 +594,9 @@ function SelectionWizardSession({
 			setBulkRun({ matched: ids.length });
 			const outcome = await runAction(action, [...ids]);
 			setBulkRun({ matched: ids.length, outcome });
+			if (walkedAway.current) onRunEnded?.(action.kind, ids.length, outcome);
 		},
-		[verb, named.moveMailboxId, junkMailboxId, runAction],
+		[verb, named.moveMailboxId, junkMailboxId, runAction, onRunEnded],
 	);
 
 	// The escalated predicate, run by the chunked runner the list already owns.
@@ -595,7 +615,10 @@ function SelectionWizardSession({
 		setBulkRun({ matched: escalated.total });
 		const outcome = await escalated.run(action);
 		setBulkRun({ matched: escalated.total, outcome });
-	}, [escalated, verb, named.moveMailboxId, junkMailboxId]);
+		if (walkedAway.current) {
+			onRunEnded?.(action.kind, escalated.total, outcome);
+		}
+	}, [escalated, verb, named.moveMailboxId, junkMailboxId, onRunEnded]);
 
 	const { start: startJob } = organizeJob;
 	const { createFilterAsync } = createFilter;
@@ -815,12 +838,28 @@ function SelectionWizardSession({
 	}, [closeWizard, steps, current]);
 
 	// The run screen's way out. The action has happened, so the rows it was
-	// aimed at are no longer a selection waiting to be acted on.
+	// aimed at are no longer a selection waiting to be acted on. It leaves the
+	// run alone: the screen says so in as many words, and stopping it is a
+	// control of its own.
 	const dismiss = useCallback(() => {
+		walkedAway.current = true;
 		closeWizard(steps, current);
 		onFinished();
 	}, [closeWizard, steps, current, onFinished]);
 
+	// Ends the run rather than leaving it. The escalated predicate is run by the
+	// list's runner and a bounded selection by this wizard's own, so the stop
+	// follows whichever one is paging.
+	const { stop: stopBulk } = bulk;
+	const runInFlight = bulkRun !== undefined && bulkRun.outcome === undefined;
+	const stopRun = useCallback(() => {
+		if (escalated) {
+			escalated.stop();
+			return;
+		}
+		stopBulk();
+	}, [escalated, stopBulk]);
+
 	// Hardware back on the run screen leaves the wizard, the movement the header
 	// arrow and the footer already make there (`backExits`). Run is an ordinary
 	// pushed entry, so without this the button pops back to Review, where the
@@ -868,7 +907,10 @@ function SelectionWizardSession({
 			blockedReason={blockedReason}
 			nudged={nudgedStep === current}
 			onBack={goBack}
-			onExit={cancel}
+			// Every exit from the run screen is the same movement: the header's X,
+			// the header arrow, the footer and hardware Back all leave a run that
+			// has already been sent, and all of them drop the selection with it.
+			onExit={current === "run" ? dismiss : cancel}
 			onContinue={advance}
 			onCommit={commit}
 			match={{
@@ -945,6 +987,7 @@ function SelectionWizardSession({
 				failures: run.failures,
 				onRetry: retry,
 				onDismiss: dismiss,
+				onCancelRun: runInFlight ? stopRun : undefined,
 			}}
 		/>
 	);

package/src/components/mail/SpamRescue.tsx

@@ -14,13 +14,12 @@ import {
 	useRef,
 	useState,
 } from "react";
-import { useTranslation } from "react-i18next";
 import {
 	useFolderAppointments,
 	useInboxMailbox,
 } from "@/hooks/useArchiveMailbox";
-import { buildMailboxRoleMap, labelForMailbox } from "@/lib/folder-roles";
-import { buildMoveTargets } from "@/lib/move-targets";
+import { useFolderLabelTranslator } from "@/hooks/useFolderLabelTranslator";
+import { buildMoveOptions } from "@/lib/move-options";
 import {
 	recordRescueCandidatesSurfaced,
 	recordRescueCommitted,
@@ -51,12 +50,7 @@ export function SpamRescue({
 }: SpamRescueProps) {
 	const [open, setOpen] = useState(false);
 	const telemetry = useTelemetry();
-	const { t } = useTranslation("mail", { useSuspense: false });
-	const translator = useCallback(
-		(key: string, fallback: string): string =>
-			t(key, { defaultValue: fallback }),
-		[t],
-	);
+	const translator = useFolderLabelTranslator();
 
 	const { inboxMailboxId } = useInboxMailbox(accountId);
 	const folderAppointments = useFolderAppointments(accountId);
@@ -66,28 +60,21 @@ export function SpamRescue({
 		staleTime: Infinity,
 	});
 
-	const folders = useMemo<MoveMailboxOption[]>(() => {
-		const targets = buildMoveTargets(
-			mailboxesResponse?.items ?? [],
-			folderAppointments,
-		);
-		const roleMap = buildMailboxRoleMap(folderAppointments);
-		return targets.map((mailbox) => ({
-			id: mailbox.mailboxId,
-			label: labelForMailbox(
-				mailbox,
-				roleMap.get(mailbox.mailboxId),
+	const folders = useMemo<MoveMailboxOption[]>(
+		() =>
+			buildMoveOptions({
+				mailboxes: mailboxesResponse?.items ?? [],
+				folderAppointments,
+				currentMailboxId,
 				translator,
-			),
-			searchValue: mailbox.fullPath,
-			isCurrent: mailbox.mailboxId === currentMailboxId,
-		}));
-	}, [
-		mailboxesResponse?.items,
-		folderAppointments,
-		currentMailboxId,
-		translator,
-	]);
+			}),
+		[
+			mailboxesResponse?.items,
+			folderAppointments,
+			currentMailboxId,
+			translator,
+		],
+	);
 
 	const defaultDestinationId = useMemo(() => {
 		if (inboxMailboxId) return inboxMailboxId;

package/src/components/settings/DeleteFolderDialog.tsx

@@ -13,13 +13,10 @@ import { AlertTriangle, FolderInput, Loader2, Trash2, X } from "lucide-react";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { useCreateMailbox } from "@/hooks/useCreateMailbox";
 import { useDeleteFolder } from "@/hooks/useDeleteFolder";
-import {
-	excludeFolder,
-	initialStage,
-	moveProgressLabel,
-} from "@/lib/delete-folder";
+import { useFolderLabelTranslator } from "@/hooks/useFolderLabelTranslator";
+import { initialStage, moveProgressLabel } from "@/lib/delete-folder";
 import { getMailboxDisplayName } from "@/lib/folder-roles";
-import { buildMoveTargets } from "@/lib/move-targets";
+import { buildMoveOptions } from "@/lib/move-options";
 
 interface DeleteFolderDialogProps {
 	open: boolean;
@@ -61,6 +58,7 @@ export function DeleteFolderDialog({
 		initialStage(folder.messageCount),
 	);
 	const { createFolder } = useCreateMailbox(accountId);
+	const translator = useFolderLabelTranslator();
 	const {
 		phase,
 		progress,
@@ -90,15 +88,13 @@ export function DeleteFolderDialog({
 
 	const destinations = useMemo<MoveMailboxOption[]>(
 		() =>
-			excludeFolder(
-				buildMoveTargets(mailboxes, appointments),
-				folder.mailboxId,
-			).map((mailbox) => ({
-				id: mailbox.mailboxId,
-				label: getMailboxDisplayName(mailbox.fullPath),
-				searchValue: mailbox.fullPath,
-			})),
-		[mailboxes, appointments, folder.mailboxId],
+			buildMoveOptions({
+				mailboxes,
+				folderAppointments: appointments,
+				excludeMailboxId: folder.mailboxId,
+				translator,
+			}),
+		[mailboxes, appointments, folder.mailboxId, translator],
 	);
 
 	const handleCreateFolder = async (

package/src/hooks/escalated-run-lifetime.render.test.ts

@@ -0,0 +1,265 @@
+/**
+ * A run outlives the selection it came from (#521). The run screen tells the
+ * user "This keeps running if you close the wizard", and closing the wizard
+ * drops the escalated selection on the way out — so leaving the selection and
+ * ending the run have to be two things.
+ *
+ * These mount the real hook against the real fetch seam and count the batches
+ * that actually left, so what is pinned is the run's own lifetime rather than
+ * the wording of whichever screen started it. Every run is parked at a page
+ * boundary before the test acts on it: that is where the run reads whether it
+ * has been told to stop, and so the only place the difference shows.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { act, createElement } from "react";
+import { createDomHarness, type DomHarness } from "../test-support/dom";
+import {
+	type EscalationSearchQuery,
+	type UseEscalatedActionsResult,
+	useEscalatedActions,
+} from "./useEscalatedActions";
+
+const INBOX = "mbx-inbox";
+const PAGE_SIZE = 100;
+/** Three full pages and a short one — page boundaries to park a run at. */
+const TOTAL = PAGE_SIZE * 3 + 12;
+
+let harness: DomHarness | undefined;
+let server: MailServer | undefined;
+
+interface MailServer {
+	/** Every message id a delete call carried, in the order they were sent. */
+	deleted: () => string[];
+	/** Deletes queued at the boundary rather than answered. */
+	held: () => number;
+	/** Answer everything held, and stop holding. */
+	release: () => void;
+	restore: () => void;
+}
+
+/**
+ * A search that pages `TOTAL` ids at the hook's own page size, keyed by the
+ * query, so a run started against one predicate is distinguishable from a run
+ * that followed the list onto a later one.
+ */
+const searchPage = (url: URL): unknown => {
+	const query = url.searchParams.get("query") ?? "";
+	const served = Number(url.searchParams.get("continuationToken") ?? "0");
+	const size = Math.min(PAGE_SIZE, Math.max(TOTAL - served, 0));
+	return {
+		items: Array.from({ length: size }, (_, i) => ({
+			messageId: `${query}-${served + i}`,
+		})),
+		continuationToken:
+			served + size < TOTAL ? String(served + size) : undefined,
+	};
+};
+
+/**
+ * Answers the search and the bulk delete, holding every delete after the first
+ * so a run can be caught mid-flight with real progress behind it.
+ */
+const startMailServer = (): MailServer => {
+	const original = globalThis.fetch;
+	const deleted: string[] = [];
+	let waiting: Array<() => void> = [];
+	let holding = true;
+	let served = 0;
+
+	globalThis.fetch = (async (input: RequestInfo | URL): Promise<Response> => {
+		const request = input instanceof Request ? input : undefined;
+		const raw = request ? await request.clone().text() : undefined;
+		const url = new URL(request ? request.url : String(input), "http://x");
+
+		if (url.pathname.endsWith("/threads/search")) {
+			return Response.json(searchPage(url));
+		}
+
+		const body = raw
+			? (JSON.parse(raw) as { messageIds: string[] })
+			: undefined;
+		served += 1;
+		if (holding && served > 1) {
+			await new Promise<void>((resolve) => waiting.push(resolve));
+		}
+		deleted.push(...(body?.messageIds ?? []));
+		return Response.json({ successCount: 0, failureCount: 0 });
+	}) as typeof globalThis.fetch;
+
+	return {
+		deleted: () => deleted,
+		held: () => waiting.length,
+		release: () => {
+			holding = false;
+			const queued = waiting;
+			waiting = [];
+			for (const resolve of queued) resolve();
+		},
+		restore: () => {
+			globalThis.fetch = original;
+		},
+	};
+};
+
+const mountEscalation = (
+	initialQuery: EscalationSearchQuery,
+): {
+	hook: () => UseEscalatedActionsResult;
+	setQuery: (next: EscalationSearchQuery) => void;
+} => {
+	let value: UseEscalatedActionsResult | undefined;
+	const Probe = ({ search }: { search: EscalationSearchQuery }) => {
+		value = useEscalatedActions({
+			mailboxId: INBOX,
+			enabled: true,
+			predicateKey: JSON.stringify(search),
+			searchQuery: search,
+		});
+		return null;
+	};
+	harness = createDomHarness();
+	harness.renderApp(createElement(Probe, { search: initialQuery }));
+	return {
+		hook: () => {
+			if (!value) throw new Error("hook did not render");
+			return value;
+		},
+		setQuery: (next) => {
+			harness?.renderApp(createElement(Probe, { search: next }));
+		},
+	};
+};
+
+/** A press: the state it sets belongs to the same commit React would batch. */
+const press = <T>(action: () => T): T => {
+	let result: T | undefined;
+	act(() => {
+		result = action();
+	});
+	return result as T;
+};
+
+/** Enough turns for a sequential page-and-apply run to reach its end. */
+const settle = async (): Promise<void> => {
+	if (!harness) throw new Error("nothing mounted");
+	for (let round = 0; round < 40; round += 1) await harness.flush();
+};
+
+/** Park the run at the page boundary the second batch is waiting on. */
+const parkAtBoundary = async (): Promise<void> => {
+	if (!harness || !server) throw new Error("nothing mounted");
+	for (let round = 0; round < 20; round += 1) {
+		if (server.held() > 0) return;
+		await harness.flush();
+	}
+	throw new Error("the run never reached a page boundary");
+};
+
+const escalateTo = async (
+	hook: () => UseEscalatedActionsResult,
+): Promise<void> => {
+	press(() => hook().escalate());
+	await settle();
+	assert.deepEqual(hook().phase, { kind: "escalated", total: TOTAL });
+};
+
+beforeEach(() => {
+	server = startMailServer();
+});
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	server?.release();
+	server?.restore();
+	server = undefined;
+});
+
+describe("an escalated run the user walks away from", () => {
+	it("keeps paging after the selection it came from is dropped", async () => {
+		const { hook } = mountEscalation({ query: "npm" });
+		await escalateTo(hook);
+
+		const run = press(() => hook().runAction({ kind: "delete" }));
+		await parkAtBoundary();
+		// What closing the wizard does on the way out: the list drops the escalated
+		// selection. The run is not the selection.
+		press(() => hook().clear());
+		press(() => server?.release());
+		await settle();
+		const outcome = await run;
+
+		assert.equal(outcome.cancelled, false);
+		assert.equal(outcome.done, TOTAL);
+		assert.equal(server?.deleted().length, TOTAL);
+	});
+
+	it("keeps paging the predicate it was started against when the search moves on", async () => {
+		const { hook, setQuery } = mountEscalation({ query: "npm" });
+		await escalateTo(hook);
+
+		const run = press(() => hook().runAction({ kind: "delete" }));
+		await parkAtBoundary();
+		setQuery({ query: "invoices" });
+		press(() => server?.release());
+		await settle();
+		const outcome = await run;
+
+		assert.equal(outcome.done, TOTAL);
+		assert.deepEqual(
+			(server?.deleted() ?? []).filter((id) => !id.startsWith("npm-")),
+			[],
+			"the run followed the query typed after it started",
+		);
+	});
+
+	it("returns the phase to idle only once the run it owns has ended", async () => {
+		const { hook } = mountEscalation({ query: "npm" });
+		await escalateTo(hook);
+
+		const run = press(() => hook().runAction({ kind: "delete" }));
+		await parkAtBoundary();
+		press(() => hook().clear());
+		assert.equal(hook().isRunning, true);
+
+		press(() => server?.release());
+		await settle();
+		await run;
+
+		assert.deepEqual(hook().phase, { kind: "idle" });
+		assert.equal(hook().isRunning, false);
+	});
+});
+
+describe("stopping the run, which is a different press", () => {
+	it("ends it at the next page boundary and says what it reached", async () => {
+		const { hook } = mountEscalation({ query: "npm" });
+		await escalateTo(hook);
+
+		const run = press(() => hook().runAction({ kind: "delete" }));
+		await parkAtBoundary();
+		press(() => hook().stop());
+		press(() => server?.release());
+		await settle();
+		const outcome = await run;
+
+		assert.equal(outcome.cancelled, true);
+		assert.ok(outcome.done > 0, "the batches already sent still count");
+		assert.ok(outcome.done < TOTAL, "the run carried on past the stop");
+		assert.equal(server?.deleted().length, outcome.done);
+	});
+});
+
+describe("clearing an escalated selection with nothing running", () => {
+	it("drops it back to bounded", async () => {
+		const { hook } = mountEscalation({ query: "npm" });
+		await escalateTo(hook);
+
+		press(() => hook().clear());
+		await settle();
+
+		assert.deepEqual(hook().phase, { kind: "idle" });
+	});
+});

package/src/hooks/useEscalatedActions.ts

@@ -82,10 +82,18 @@ export interface UseEscalatedActionsResult {
 	phase: EscalationPhase;
 	/** Begin paging the predicate's full match set to find its total. */
 	escalate: () => void;
-	/** Stop whatever's running — counting or an action — at the next page
-	 *  boundary. A no-op when nothing is running. */
+	/**
+	 * Stop whatever's running — counting or an action — at the next page
+	 * boundary. A no-op when nothing is running. The only thing that ends a run
+	 * in flight: leaving the selection, the wizard or the search does not.
+	 */
 	stop: () => void;
-	/** Drop an escalated selection back to bounded without confirming anything. */
+	/**
+	 * Drop an escalated selection back to bounded without confirming anything.
+	 * A run in flight owns the phase and holds it until it ends, so this is a
+	 * no-op then — the selection the user is leaving and the run they started
+	 * from it are two different things.
+	 */
 	clear: () => void;
 	/** True while a chunked run (bounded->100 ids, or the escalated predicate)
 	 *  is in flight. */
@@ -136,40 +144,49 @@ export const useEscalatedActions = ({
 		undefined,
 	);
 	const cancelRef = useRef(false);
+	// True from the moment a run starts until its outcome is in hand. A run is
+	// mail already leaving the mailbox, so nothing that merely changes what the
+	// list is showing gets to end it — only `stop`.
+	const runningRef = useRef(false);
 	const queryClient = useQueryClient();
 	const { pushError } = useErrorBanners();
 
 	// A different search (or leaving search/desktop) makes any in-flight
 	// escalation meaningless — it would otherwise keep counting or offering to
-	// act on a predicate the visible list no longer reflects.
-	// biome-ignore lint/correctness/useExhaustiveDependencies: enabled/predicateKey are trigger-only — the reset itself is unconditional, not a value read from either.
+	// act on a predicate the visible list no longer reflects. The selection goes;
+	// a run already going does not. It pages the predicate it was started
+	// against and reports what it reached, wherever the list moved on to.
+	// biome-ignore lint/correctness/useExhaustiveDependencies: enabled/predicateKey are trigger-only — the reset itself reads neither.
 	useEffect(() => {
-		cancelRef.current = true;
+		if (!runningRef.current) cancelRef.current = true;
 		setPhase({ kind: "idle" });
 	}, [enabled, predicateKey]);
 
 	const searchQueryRef = useRef(searchQuery);
 	searchQueryRef.current = searchQuery;
 
-	const fetchIdsPage = useCallback<FetchIdsPage>(
-		async (continuationToken) => {
-			const { data } = await threadOperationsSearchThreads({
-				path: { mailboxId },
-				query: {
-					...searchQueryRef.current,
-					continuationToken,
-					limit: PAGE_SIZE,
-				},
-				throwOnError: true,
-			});
-			return {
-				ids: (data.items ?? []).map((item) => item.messageId),
-				continuationToken: data.continuationToken,
-			};
-		},
+	const fetchPagesOf = useCallback(
+		(query: EscalationSearchQuery): FetchIdsPage =>
+			async (continuationToken) => {
+				const { data } = await threadOperationsSearchThreads({
+					path: { mailboxId },
+					query: { ...query, continuationToken, limit: PAGE_SIZE },
+					throwOnError: true,
+				});
+				return {
+					ids: (data.items ?? []).map((item) => item.messageId),
+					continuationToken: data.continuationToken,
+				};
+			},
 		[mailboxId],
 	);
 
+	const fetchIdsPage = useCallback<FetchIdsPage>(
+		(continuationToken) =>
+			fetchPagesOf(searchQueryRef.current)(continuationToken),
+		[fetchPagesOf],
+	);
+
 	const applyBatchFor = useCallback(
 		(action: EscalatedAction): ApplyBatch =>
 			async (ids: string[]) => {
@@ -248,6 +265,7 @@ export const useEscalatedActions = ({
 	}, []);
 
 	const clear = useCallback(() => {
+		if (runningRef.current) return;
 		cancelRef.current = true;
 		setPhase({ kind: "idle" });
 	}, []);
@@ -258,6 +276,7 @@ export const useEscalatedActions = ({
 			ids?: string[],
 		): Promise<BulkRunOutcome> => {
 			cancelRef.current = false;
+			runningRef.current = true;
 			setRunningAction(action);
 			// `honestProgress` widens `total` if `done` overtakes it (#109) — the
 			// predicate can match more by the time the run re-pages it than
@@ -265,22 +284,34 @@ export const useEscalatedActions = ({
 			const onProgress = (next: BulkActionProgress) =>
 				setProgress(honestProgress(next));
 			const applyBatch = applyBatchFor(action);
+			// The predicate as it read when the run was confirmed. The run outlives
+			// the screen that started it, so reading the live query on every page
+			// would let a search typed afterwards redirect what is being deleted.
+			const runPages = fetchPagesOf(searchQueryRef.current);
 
-			const outcome =
-				ids !== undefined
-					? await runChunkedAction(
-							ids,
-							applyBatch,
-							onProgress,
-							() => cancelRef.current,
-						)
-					: await runPredicateAction(
-							fetchIdsPage,
-							phase.kind === "escalated" ? phase.total : 0,
-							applyBatch,
-							onProgress,
-							() => cancelRef.current,
-						);
+			// The one invariant nothing may lose: while `runningRef` is up, both
+			// `clear` and the reset effect stand down, so a run that never marked
+			// itself finished would leave an escalated selection nobody can leave.
+			let outcome: BulkRunOutcome;
+			try {
+				outcome =
+					ids !== undefined
+						? await runChunkedAction(
+								ids,
+								applyBatch,
+								onProgress,
+								() => cancelRef.current,
+							)
+						: await runPredicateAction(
+								runPages,
+								phase.kind === "escalated" ? phase.total : 0,
+								applyBatch,
+								onProgress,
+								() => cancelRef.current,
+							);
+			} finally {
+				runningRef.current = false;
+			}
 
 			setRunningAction(undefined);
 			setProgress(undefined);
@@ -300,7 +331,7 @@ export const useEscalatedActions = ({
 			}
 			return outcome;
 		},
-		[applyBatchFor, fetchIdsPage, phase, pushError, invalidateAfterRun],
+		[applyBatchFor, fetchPagesOf, phase, pushError, invalidateAfterRun],
 	);
 
 	return {

package/src/hooks/useFolderLabelTranslator.ts

@@ -0,0 +1,19 @@
+import { useCallback } from "react";
+import { useTranslation } from "react-i18next";
+
+/**
+ * `labelForMailbox` expects a positional `(key, fallback)` translator; i18next's
+ * `t` reads its second argument as an options object, which drops the fallback.
+ * Memoized so callers can hold it as a `useMemo` dependency.
+ */
+export const useFolderLabelTranslator = (): ((
+	key: string,
+	fallback: string,
+) => string) => {
+	const { t } = useTranslation("mail", { useSuspense: false });
+	return useCallback(
+		(key: string, fallback: string): string =>
+			t(key, { defaultValue: fallback }),
+		[t],
+	);
+};

package/src/lib/bulk-action-copy.test.ts

@@ -7,6 +7,8 @@ import {
 	bulkActionFailureTitle,
 	bulkActionProgressLabel,
 	bulkActionProgressTone,
+	bulkActionStoppedDetail,
+	bulkActionStoppedTitle,
 } from "./bulk-action-copy.js";
 
 const kinds: BulkActionKind[] = ["delete", "move", "markRead"];
@@ -65,6 +67,27 @@ describe("bulkActionFailureTitle", () => {
 	});
 });
 
+describe("a run that stopped short of its match", () => {
+	test("states what it reached and that the rest is untouched", () => {
+		assert.equal(bulkActionStoppedTitle(1200), "Stopped after 1,200");
+		assert.equal(
+			bulkActionStoppedDetail("delete", 1200, 3412),
+			"1,200 of 3,412 moved to Trash. Nothing was sent for the rest, so they are untouched.",
+		);
+		assert.equal(
+			bulkActionStoppedDetail("markRead", 1200, 3412),
+			"1,200 of 3,412 marked as read. Nothing was sent for the rest, so they are untouched.",
+		);
+	});
+
+	test("never reads as a rejection — nothing was sent", () => {
+		assert.doesNotMatch(
+			bulkActionStoppedDetail("move", 1, 2),
+			/rejected|couldn't/i,
+		);
+	});
+});
+
 describe("every action carries its own wording", () => {
 	test("no two actions share a sentence", () => {
 		const sentences: Array<(kind: BulkActionKind) => string> = [
@@ -73,6 +96,7 @@ describe("every action carries its own wording", () => {
 			(kind) => bulkActionFailureTitle(kind, 5),
 			bulkActionFailureDetail,
 			(kind) => bulkActionProgressLabel(kind, 1, 2),
+			(kind) => bulkActionStoppedDetail(kind, 1, 2),
 		];
 		for (const render of sentences) {
 			assert.equal(new Set(kinds.map(render)).size, kinds.length);

package/src/lib/bulk-action-copy.ts

@@ -59,6 +59,22 @@ export const bulkActionCompletionText = (
 ): string =>
 	`${formatNumber(done)} ${pastTense[kind]}. Your mail server is still catching up.`;
 
+/**
+ * Shown when a run ended before it covered what it was started against. The
+ * remainder was never sent, so the mail is where it was and only the user can
+ * decide to run it again — which is why this is stated rather than left to a
+ * list that quietly stops changing.
+ */
+export const bulkActionStoppedTitle = (done: number): string =>
+	`Stopped after ${formatNumber(done)}`;
+
+export const bulkActionStoppedDetail = (
+	kind: BulkActionKind,
+	done: number,
+	total: number,
+): string =>
+	`${formatNumber(done)} of ${formatNumber(total)} ${pastTense[kind]}. Nothing was sent for the rest, so they are untouched.`;
+
 /** Error-banner title for a run stopped by an infrastructure failure. */
 export const bulkActionFailureTitle = (
 	kind: BulkActionKind,

package/src/lib/move-options.test.ts

@@ -0,0 +1,140 @@
+import assert from "node:assert";
+import { readFileSync } from "node:fs";
+import { describe, test } from "node:test";
+import { fileURLToPath } from "node:url";
+import type {
+	RemitImapFolderAppointment,
+	RemitImapMailboxResponse,
+} from "@remit/api-http-client/types.gen.ts";
+import { buildMoveOptions } from "./move-options.js";
+
+const englishBundle = JSON.parse(
+	readFileSync(
+		fileURLToPath(
+			new URL("../../public/locales/en/mail.json", import.meta.url),
+		),
+		"utf8",
+	),
+) as { sidebar: Record<string, string> };
+
+// The picker is handed the same shipped English bundle the app loads, so the
+// expected labels are the product's own, not strings restated by the test.
+const translate = (key: string, fallback: string): string =>
+	englishBundle.sidebar[key.replace("sidebar.", "")] ?? fallback;
+
+const make = (
+	overrides: Partial<RemitImapMailboxResponse> & {
+		mailboxId: string;
+		fullPath: string;
+	},
+): RemitImapMailboxResponse =>
+	({
+		accountId: "acct-1",
+		namespaceType: "personal",
+		namespacePrefix: "",
+		hierarchyDelimiter: "/",
+		messageCount: 0,
+		unseenCount: 0,
+		deletedCount: 0,
+		createdAt: 0,
+		updatedAt: 0,
+		...overrides,
+	}) as RemitImapMailboxResponse;
+
+const appoint = (
+	role: RemitImapFolderAppointment["role"],
+	mailboxId: string,
+): RemitImapFolderAppointment => ({ role, mailboxId });
+
+const applePaths = [
+	make({ mailboxId: "mb-inbox", fullPath: "INBOX" }),
+	make({ mailboxId: "mb-trash", fullPath: "INBOX/Deleted Messages" }),
+	make({ mailboxId: "mb-junk", fullPath: "INBOX/Junk" }),
+	make({ mailboxId: "mb-receipts", fullPath: "INBOX/Receipts" }),
+];
+
+const appleAppointments = [
+	appoint("Inbox", "mb-inbox"),
+	appoint("Trash", "mb-trash"),
+	appoint("Junk", "mb-junk"),
+];
+
+const labelOf = (
+	options: ReturnType<typeof buildMoveOptions>,
+	id: string,
+): string | undefined => options.find((option) => option.id === id)?.label;
+
+describe("buildMoveOptions", () => {
+	test("labels appointed folders by role, not by the provider's leaf", () => {
+		const options = buildMoveOptions({
+			mailboxes: applePaths,
+			folderAppointments: appleAppointments,
+			translator: translate,
+		});
+		assert.equal(labelOf(options, "mb-inbox"), "Inbox");
+		assert.equal(labelOf(options, "mb-trash"), "Trash");
+		assert.equal(labelOf(options, "mb-junk"), "Spam");
+	});
+
+	test("a displayNameOverride wins over the role label", () => {
+		const options = buildMoveOptions({
+			mailboxes: [
+				make({
+					mailboxId: "mb-trash",
+					fullPath: "INBOX/Deleted Messages",
+					displayNameOverride: "Bin",
+				}),
+			],
+			folderAppointments: [appoint("Trash", "mb-trash")],
+			translator: translate,
+		});
+		assert.equal(labelOf(options, "mb-trash"), "Bin");
+	});
+
+	test("an unappointed folder keeps its own name", () => {
+		const options = buildMoveOptions({
+			mailboxes: applePaths,
+			folderAppointments: appleAppointments,
+			translator: translate,
+		});
+		assert.equal(labelOf(options, "mb-receipts"), "Receipts");
+	});
+
+	test("the full provider path stays searchable", () => {
+		const options = buildMoveOptions({
+			mailboxes: applePaths,
+			folderAppointments: appleAppointments,
+			translator: translate,
+		});
+		assert.equal(
+			options.find((option) => option.id === "mb-trash")?.searchValue,
+			"INBOX/Deleted Messages",
+		);
+	});
+
+	test("the current mailbox is marked and nothing else is", () => {
+		const options = buildMoveOptions({
+			mailboxes: applePaths,
+			folderAppointments: appleAppointments,
+			currentMailboxId: "mb-junk",
+			translator: translate,
+		});
+		assert.deepStrictEqual(
+			options.filter((option) => option.isCurrent).map((option) => option.id),
+			["mb-junk"],
+		);
+	});
+
+	test("an excluded mailbox is not offered as a destination", () => {
+		const options = buildMoveOptions({
+			mailboxes: applePaths,
+			folderAppointments: appleAppointments,
+			excludeMailboxId: "mb-receipts",
+			translator: translate,
+		});
+		assert.equal(
+			options.some((option) => option.id === "mb-receipts"),
+			false,
+		);
+	});
+});

package/src/lib/move-options.ts

@@ -0,0 +1,46 @@
+import type {
+	RemitImapFolderAppointment,
+	RemitImapMailboxResponse,
+} from "@remit/api-http-client/types.gen.ts";
+import type { MoveMailboxOption } from "@remit/ui";
+import { excludeFolder } from "./delete-folder.js";
+import { buildMailboxRoleMap, labelForMailbox } from "./folder-roles.js";
+import { buildMoveTargets } from "./move-targets.js";
+
+type Translator = (key: string, fallback: string) => string;
+
+interface MoveOptionsInput {
+	mailboxes: readonly RemitImapMailboxResponse[];
+	folderAppointments: readonly RemitImapFolderAppointment[];
+	/** Rendered as a non-selectable row, so the user sees where mail lives now. */
+	currentMailboxId?: string;
+	/** Dropped entirely — the folder being deleted is not its own destination. */
+	excludeMailboxId?: string;
+	translator?: Translator;
+}
+
+/**
+ * The single shaping of a mailbox list into Move-to picker options. Labels
+ * follow the account's role appointments (RFC 032, #976) and any
+ * `displayNameOverride`, so a picker reads `Inbox`/`Trash` rather than the
+ * provider's leaf; the full path stays searchable.
+ */
+export const buildMoveOptions = ({
+	mailboxes,
+	folderAppointments,
+	currentMailboxId,
+	excludeMailboxId,
+	translator,
+}: MoveOptionsInput): MoveMailboxOption[] => {
+	const targets = buildMoveTargets(mailboxes, folderAppointments);
+	const roleMap = buildMailboxRoleMap(folderAppointments);
+	const destinations = excludeMailboxId
+		? excludeFolder(targets, excludeMailboxId)
+		: targets;
+	return destinations.map((mailbox) => ({
+		id: mailbox.mailboxId,
+		label: labelForMailbox(mailbox, roleMap.get(mailbox.mailboxId), translator),
+		searchValue: mailbox.fullPath,
+		isCurrent: mailbox.mailboxId === currentMailboxId,
+	}));
+};