@remit/web-client 0.0.270 → 0.0.272

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.270",
+  "version": "0.0.272",
   "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

@@ -0,0 +1,331 @@
+import { mailboxOperationsListMailboxesQueryKey } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { useQueryClient } from "@tanstack/react-query";
+import {
+	createContext,
+	type ReactNode,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
+import { buildMutationErrorBanner } from "@/components/ui/error-banners";
+import { isFolderRoleRefusal } from "@/components/ui/folder-role-refusal";
+import {
+	bulkActionFailureDetail,
+	bulkActionFailureTitle,
+	bulkRunBusyRefusal,
+} from "@/lib/bulk-action-copy";
+import {
+	type ApplyBatch,
+	type BulkActionProgress,
+	type BulkActionTarget,
+	type BulkRunOutcome,
+	type BulkRunStart,
+	type EscalatedAction,
+	type FetchIdsPage,
+	honestProgress,
+	mailboxesTouchedBy,
+	runChunkedAction,
+	runPredicateAction,
+} from "@/lib/bulk-actions";
+import {
+	invalidateThreadListQueries,
+	threadListCacheKeys,
+} from "@/lib/thread-list-cache";
+import { useRoleAppointmentPrompt } from "./RoleAppointmentPromptProvider";
+
+/**
+ * What the run pages, which is the one thing a bounded and an escalated run do
+ * differently: a ticked selection is a list of ids the surface already holds,
+ * an escalated one is a predicate the server re-resolves page by page.
+ */
+export type BulkRunSource =
+	| { kind: "targets"; targets: readonly BulkActionTarget[] }
+	| { kind: "predicate"; fetchPage: FetchIdsPage };
+
+export interface BulkRunRequest {
+	action: EscalatedAction;
+	/** The mailbox the run belongs to — where its progress shows on return. */
+	mailboxId: string;
+	/** That mailbox in the user's words, for a refusal that names this run. */
+	mailboxLabel?: string;
+	/** Owning account, for the unseen-count invalidation on completion. */
+	accountId: string | undefined;
+	/** The count the run was offered against, for the bar and for the ending. */
+	matched: number;
+	source: BulkRunSource;
+	/** Issues one batch of the action. Closed over the SDK, never over a screen. */
+	applyBatch: ApplyBatch;
+	/**
+	 * States how the run ended, once no screen is left reporting on it in place.
+	 * Called by the provider rather than by the caller, so an ending that lands
+	 * after the surface unmounted is still said out loud (#112). Absent on a
+	 * surface with nowhere to say it.
+	 */
+	reportEnding?: (
+		kind: EscalatedAction["kind"],
+		matched: number,
+		outcome: BulkRunOutcome,
+	) => void;
+	/**
+	 * Handed the release for this run's ending, for a screen that is showing the
+	 * ending itself. The claim is made inside `start`, for the run it starts, so
+	 * a commit that starts no run holds nothing over the ending of one that is
+	 * already going (#112). Released when that screen goes.
+	 */
+	claimEnding?: (release: () => void) => void;
+}
+
+/** A run in flight, as any screen reads it. */
+export interface ActiveBulkRun {
+	action: EscalatedAction;
+	mailboxId: string;
+	/** Seeded from the count the run was offered against, so the bar has a
+	 *  denominator before the first batch comes back. */
+	progress: BulkActionProgress;
+}
+
+interface BulkRunContextValue {
+	run: ActiveBulkRun | undefined;
+	/**
+	 * Runs `request`, or refuses it because one is already going. There is one
+	 * slot: a second run would page behind the first's bar and answer to the
+	 * first's Stop, so it is refused with the run in flight named rather than
+	 * queued or started alongside.
+	 */
+	start: (request: BulkRunRequest) => Promise<BulkRunStart>;
+	/**
+	 * Ends the run `mailboxId` owns: the request on the wire is aborted and
+	 * nothing more leaves. A stop aimed at any other mailbox is not this run's,
+	 * and reaches nothing.
+	 */
+	stop: (mailboxId: string) => void;
+}
+
+const BulkRunContext = createContext<BulkRunContextValue | undefined>(
+	undefined,
+);
+
+/**
+ * The owner of a chunked bulk run (#112).
+ *
+ * A run is mail leaving the mailbox, and it outlives every screen that can show
+ * it: the wizard invites the user to close it mid-run, and nothing stops them
+ * navigating to another mailbox on top of that. Held in the surface that started
+ * it, the progress, the count and the cancellation all unmounted with the route,
+ * so returning showed nothing, Stop reached nothing, and an ending that landed
+ * after the move was dropped in silence.
+ *
+ * Mounted at the root beside the other app-lifetime providers, this holds the
+ * run instead: its progress, its `AbortController`, the caches it invalidates,
+ * the refusal it replays and the ending it states. A screen reads the run and
+ * offers Stop; it never owns either.
+ *
+ * In memory and per tab. A run is a sequence of requests this tab is making, so
+ * a reload ends it — persisting the reading would show a bar for a run nothing
+ * is driving.
+ */
+export const BulkRunProvider = ({ children }: { children: ReactNode }) => {
+	const [run, setRun] = useState<ActiveBulkRun | undefined>(undefined);
+	// The signal every call of the live run is issued under, so a stop ends the
+	// request on the wire instead of waiting for it to come back (#113).
+	const controllerRef = useRef<AbortController | undefined>(undefined);
+	// Identifies the live run across the awaits below, so a run that ended after
+	// the slot was taken from it — by a sign-out — writes nothing back.
+	const liveRunRef = useRef<symbol | undefined>(undefined);
+	// What is in the slot, read synchronously: two commits landing in one frame
+	// both have to see the first of them.
+	const liveRequestRef = useRef<BulkRunRequest | undefined>(undefined);
+	// The runs a screen is reporting on in place, by token — never a count of
+	// claims over runs in general, which any commit could hold against any run.
+	const claimsRef = useRef(new Set<symbol>());
+	const queryClient = useQueryClient();
+	const { pushError } = useErrorBanners();
+	const { requestAppointment } = useRoleAppointmentPrompt();
+	// The run replays itself once a folder is appointed, so it needs a handle on
+	// itself that does not make `start` its own dependency.
+	const startRef = useRef<BulkRunContextValue["start"]>(async () => ({
+		kind: "ran",
+		outcome: { done: 0, failedIds: [], cancelled: false },
+	}));
+
+	/**
+	 * The listings a run changed, and the unseen counts it moved. A cross-account
+	 * selection has no single owning account, so the run's own targets name the
+	 * accounts to refresh alongside the one the surface named.
+	 */
+	const invalidateAfterRun = useCallback(
+		(request: BulkRunRequest) => {
+			invalidateThreadListQueries(
+				queryClient,
+				threadListCacheKeys(
+					mailboxesTouchedBy(request.action, request.mailboxId),
+				),
+			);
+			const touched = new Set<string>();
+			if (request.accountId) touched.add(request.accountId);
+			if (request.source.kind === "targets") {
+				for (const target of request.source.targets) {
+					if (target.accountId) touched.add(target.accountId);
+				}
+			}
+			for (const accountId of touched) {
+				queryClient.invalidateQueries({
+					queryKey: mailboxOperationsListMailboxesQueryKey({
+						path: { accountId },
+					}),
+				});
+			}
+		},
+		[queryClient],
+	);
+
+	const start = useCallback(
+		async (request: BulkRunRequest): Promise<BulkRunStart> => {
+			const inFlight = liveRequestRef.current;
+			if (inFlight) {
+				return {
+					kind: "refused",
+					reason: bulkRunBusyRefusal(
+						inFlight.action.kind,
+						inFlight.matched,
+						inFlight.mailboxLabel,
+					),
+				};
+			}
+			const token = Symbol("bulk-run");
+			const controller = new AbortController();
+			controllerRef.current = controller;
+			liveRunRef.current = token;
+			liveRequestRef.current = request;
+			if (request.claimEnding) {
+				claimsRef.current.add(token);
+				request.claimEnding(() => claimsRef.current.delete(token));
+			}
+			setRun({
+				action: request.action,
+				mailboxId: request.mailboxId,
+				progress: { done: 0, total: request.matched },
+			});
+			// `honestProgress` widens `total` if `done` overtakes it (#109) — the
+			// predicate can match more by the time the run pages it than the count
+			// saw, and the bar must never show more done than out of.
+			const onProgress = (next: BulkActionProgress) => {
+				if (liveRunRef.current !== token) return;
+				setRun((held) =>
+					held ? { ...held, progress: honestProgress(next) } : held,
+				);
+			};
+
+			const outcome =
+				request.source.kind === "targets"
+					? await runChunkedAction(
+							request.source.targets,
+							request.applyBatch,
+							onProgress,
+							controller.signal,
+						)
+					: await runPredicateAction(
+							request.source.fetchPage,
+							request.matched,
+							request.applyBatch,
+							onProgress,
+							controller.signal,
+						);
+
+			const reportedInPlace = claimsRef.current.delete(token);
+			if (liveRunRef.current === token) {
+				liveRunRef.current = undefined;
+				liveRequestRef.current = undefined;
+				setRun(undefined);
+			}
+
+			// A provenance refusal is answered by the appointment prompt exactly as
+			// it is on the single-row path (#887, #876). Left to the banner it
+			// arrives as the API's own sentence — "Appoint one under Settings ›
+			// Folder roles" — which asks the user to reassemble a select-all they
+			// have already made.
+			const refusal = outcome.error
+				? isFolderRoleRefusal(outcome.error)
+				: undefined;
+			if (refusal) {
+				requestAppointment({
+					accountId: refusal.accountId,
+					role: refusal.role,
+					reason: refusal.reason,
+					action: { kind: "delete", count: request.matched },
+					// The replay is a new run, and it claims nothing: the claim the
+					// original was started under belongs to a screen whose release has
+					// already fired or never will for this run, so re-claiming would
+					// leave the replay's ending held back by nobody and never said.
+					onAppointed: async () => {
+						const replayed = await startRef.current({
+							...request,
+							claimEnding: undefined,
+						});
+						if (replayed.kind === "refused") {
+							pushError({
+								title: bulkActionFailureTitle(request.action.kind, 0),
+								detail: replayed.reason,
+							});
+						}
+					},
+				});
+			} else if (outcome.error) {
+				pushError(
+					buildMutationErrorBanner(
+						bulkActionFailureTitle(request.action.kind, outcome.done),
+						bulkActionFailureDetail(request.action.kind),
+						outcome.error,
+					),
+				);
+			}
+			// 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.
+			if (!reportedInPlace) {
+				request.reportEnding?.(request.action.kind, request.matched, outcome);
+			}
+			if (outcome.done > 0) invalidateAfterRun(request);
+			return { kind: "ran", outcome };
+		},
+		[invalidateAfterRun, pushError, requestAppointment],
+	);
+	startRef.current = start;
+
+	const stop = useCallback((mailboxId: string) => {
+		if (liveRequestRef.current?.mailboxId !== mailboxId) return;
+		controllerRef.current?.abort();
+	}, []);
+
+	// A run belongs to the session that started it. Both auth shells gate the
+	// whole app on the session, so signing out or switching accounts takes this
+	// provider down with the router — and a run left paging past that would go on
+	// deleting mail for an account nobody is signed in to.
+	useEffect(() => {
+		const claims = claimsRef.current;
+		return () => {
+			controllerRef.current?.abort();
+			controllerRef.current = undefined;
+			liveRunRef.current = undefined;
+			liveRequestRef.current = undefined;
+			claims.clear();
+		};
+	}, []);
+
+	const value = useMemo(() => ({ run, start, stop }), [run, start, stop]);
+
+	return (
+		<BulkRunContext.Provider value={value}>{children}</BulkRunContext.Provider>
+	);
+};
+
+export const useBulkRun = (): BulkRunContextValue => {
+	const context = useContext(BulkRunContext);
+	if (!context) {
+		throw new Error("useBulkRun must be used within a BulkRunProvider");
+	}
+	return context;
+};

package/src/components/mail/MessageList.tsx

@@ -24,7 +24,6 @@ import { formatErrorMessage } from "@/components/ui/ErrorState";
 import { useJunkMailbox } from "@/hooks/useArchiveMailbox";
 import { useDeleteOutcome } from "@/hooks/useDeleteOutcome";
 import {
-	type EscalatedAction,
 	type EscalationSearchQuery,
 	useEscalatedActions,
 } from "@/hooks/useEscalatedActions";
@@ -355,21 +354,12 @@ export const MessageList = ({
 	// are loaded. `orderedIds` below feeds `allLoadedSelected`; declared after
 	// this hook so its callback deps stay simple — see the
 	// `orderedIds`/`handleRowSelect` block.
-	const escalationEnabled = isSearching && !!searchPredicate;
-	const predicateKey = `${mailboxId}|${JSON.stringify(searchPredicate ?? {})}`;
-	const escalation = useEscalatedActions({
-		mailboxId,
-		accountId,
-		enabled: escalationEnabled,
-		predicateKey,
-		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.
+	// How a run ended, for the user who is no longer looking at any screen that
+	// could show it. Closing the wizard mid-run is a movement the screen invites,
+	// and leaving the mailbox on top of that is one nothing prevents — the run
+	// keeps going past both, so this states the ending, whether the run covered
+	// everything or stopped short of it. The run's owner calls it only once no
+	// screen is left reporting in place, so an ending is never said twice.
 	const reportRunOutcome = useCallback(
 		(kind: BulkActionKind, matched: number, outcome: BulkRunOutcome) => {
 			const banner = runEndingBanner(kind, matched, outcome, deleteOutcome);
@@ -380,6 +370,18 @@ export const MessageList = ({
 		[pushError, deleteOutcome],
 	);
 
+	const escalationEnabled = isSearching && !!searchPredicate;
+	const predicateKey = `${mailboxId}|${JSON.stringify(searchPredicate ?? {})}`;
+	const escalation = useEscalatedActions({
+		mailboxId,
+		mailboxLabel: listTitle,
+		accountId,
+		enabled: escalationEnabled,
+		predicateKey,
+		searchQuery: searchPredicate ?? {},
+		reportEnding: reportRunOutcome,
+	});
+
 	// 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
@@ -690,7 +692,8 @@ export const MessageList = ({
 					scope: describeSearchScope(searchPredicate ?? {}),
 					total: escalation.phase.total,
 					searchQuery: searchPredicate ?? {},
-					run: (action: EscalatedAction) => escalation.runAction(action),
+					run: (action, claimEnding) =>
+						escalation.runAction(action, undefined, claimEnding),
 					stop: escalation.stop,
 				}
 			: undefined;
@@ -1086,10 +1089,16 @@ export const MessageList = ({
 	// The escalation-derived surface state — viewport-independent, fed to both
 	// the mobile sheet and the desktop toolbar so the two never diverge (#212).
 	const selectionIsBusy = isDeleting || isMoving || escalation.isRunning;
+	// A run outlives the selection it came from, and leaving the mailbox and
+	// coming back leaves no selection at all — so while one is in flight the run's
+	// own count is what the bar is about, or the bar would be an empty header over
+	// mail that is still being deleted (#112).
 	const selectionCount =
 		escalation.phase.kind === "escalated"
 			? escalation.phase.total
-			: selectedCount;
+			: escalation.progress
+				? escalation.progress.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
@@ -1128,17 +1137,22 @@ export const MessageList = ({
 		: 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;
-	// otherwise a fresh escalation offer. The (rare) cross-account move hint is
-	// layered on behind them below.
+	// a run in flight and a count both carry Stop, and that always wins; then an
+	// escalated selection's way out; otherwise a fresh escalation offer. The
+	// (rare) cross-account move hint is layered on behind them below.
+	//
+	// Stop rides on the bar rather than only on the wizard's run screen because
+	// the run outlives both the wizard and the route: a user who comes back to
+	// the mailbox mid-run finds the progress there, and has to be able to end it
+	// from the same place (#112).
 	const escalationNotice =
-		escalation.phase.kind === "counting"
+		escalation.isRunning || escalation.phase.kind === "counting"
 			? {
 					tone: "info" as const,
 					text: "",
 					action: { label: "Stop", onClick: escalation.stop },
 				}
-			: escalation.phase.kind === "escalated" && !escalation.isRunning
+			: escalation.phase.kind === "escalated"
 				? {
 						tone: "info" as const,
 						text: "",
@@ -1343,6 +1357,7 @@ export const MessageList = ({
 				verb={wizardVerb}
 				accountId={accountId}
 				mailboxId={mailboxId}
+				mailboxLabel={listTitle}
 				selection={wizardSelection}
 				selectionRestriction={moveDisabledHint ? "spansAccounts" : undefined}
 				escalated={escalatedSelection}

package/src/components/mail/SelectionWizardHost.tsx

@@ -39,7 +39,6 @@ import {
 import { useClauseSuggestions } from "@/hooks/useClauseSuggestions";
 import { useCreateMailbox } from "@/hooks/useCreateMailbox";
 import {
-	type EscalatedAction,
 	type EscalationSearchQuery,
 	useEscalatedActions,
 } from "@/hooks/useEscalatedActions";
@@ -55,6 +54,8 @@ import type {
 	BulkActionProgress,
 	BulkActionTarget,
 	BulkRunOutcome,
+	BulkRunStart,
+	EscalatedAction,
 } from "@/lib/bulk-actions";
 import { NO_JUNK_FOLDER_REASON } from "@/lib/junk-destination";
 import { useMailContext } from "@/lib/mail-context";
@@ -122,7 +123,15 @@ export interface EscalatedSelection {
 	 * 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>;
+	run: (
+		action: EscalatedAction,
+		/**
+		 * Handed the release for the ending of the run it starts, so the wizard's
+		 * run screen states that ending in place and the list does not banner it a
+		 * second time (#112).
+		 */
+		claimEnding: (release: () => void) => void,
+	) => Promise<BulkRunStart>;
 	/** Ends that run at the next page boundary, which leaving the wizard does not. */
 	stop: () => void;
 }
@@ -134,6 +143,8 @@ export interface SelectionWizardHostProps {
 	accountId?: string;
 	/** Where the selection was made, so a run invalidates the listing it changed. */
 	mailboxId?: string;
+	/** That mailbox in the user's words, for a commit refused while it runs. */
+	mailboxLabel?: string;
 	selection: readonly WizardSelectionMessage[];
 	/**
 	 * Which scope the ticked rows span more of than the folder and rule steps can
@@ -154,10 +165,11 @@ export interface SelectionWizardHostProps {
 	/** 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.
+	 * How a run ended, once no screen reporting on it is left. Handed to the run's
+	 * owner rather than called here: the run screen invites the user to close it
+	 * and keep the run going, and leaving the mailbox on top of that takes this
+	 * component with it — so the ending is stated by something that outlives both
+	 * (#112). A run screen still up reports in place instead.
 	 */
 	onRunEnded?: (
 		kind: EscalatedAction["kind"],
@@ -298,6 +310,7 @@ function SelectionWizardSession({
 	verb,
 	accountId,
 	mailboxId,
+	mailboxLabel,
 	selection,
 	selectionRestriction,
 	escalated: escalatedSelection,
@@ -361,11 +374,6 @@ 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),
@@ -491,14 +499,36 @@ function SelectionWizardSession({
 		senders,
 	);
 
+	// While this screen is up it states the ending itself, so the run's owner
+	// holds its banner back. The claim is over the run this screen starts and no
+	// other: a commit that starts none — a filter, a back-apply job — has no
+	// ending of its own to hold, and holding one anyway swallowed the banner of
+	// whatever run was going elsewhere. Leaving — closing the wizard, or leaving
+	// the mailbox altogether — unmounts this and releases it, and the ending is
+	// bannered where the user now is (#112, #521).
+	const releaseReport = useRef<(() => void) | undefined>(undefined);
+	const claimEnding = useCallback((release: () => void) => {
+		releaseReport.current?.();
+		releaseReport.current = release;
+	}, []);
+	useEffect(
+		() => () => {
+			releaseReport.current?.();
+			releaseReport.current = undefined;
+		},
+		[],
+	);
+
 	const organizeJob = useOrganizeJob(accountId);
 	const createFilter = useCreateFilter(accountId);
 	const bulk = useEscalatedActions({
 		mailboxId: mailboxId ?? "",
+		mailboxLabel,
 		accountId,
 		enabled: false,
 		predicateKey: "selection-wizard",
 		searchQuery: {},
+		reportEnding: onRunEnded,
 	});
 	const { runAction } = bulk;
 
@@ -661,13 +691,15 @@ function SelectionWizardSession({
 				return;
 			}
 			setBulkRun({ matched: targets.length, sent: targets });
-			const outcome = await runAction(action, targets);
-			setBulkRun({ matched: targets.length, sent: targets, outcome });
-			if (walkedAway.current) {
-				onRunEnded?.(action.kind, targets.length, outcome);
-			}
+			const started = await runAction(action, targets, claimEnding);
+			setBulkRun({
+				matched: targets.length,
+				sent: targets,
+				outcome: started.kind === "ran" ? started.outcome : undefined,
+				failureReason: started.kind === "refused" ? started.reason : undefined,
+			});
 		},
-		[verb, named.moveMailboxId, junkMailboxId, runAction, onRunEnded],
+		[verb, named.moveMailboxId, junkMailboxId, runAction, claimEnding],
 	);
 
 	// The escalated predicate, run by the chunked runner the list already owns.
@@ -685,12 +717,14 @@ function SelectionWizardSession({
 			return;
 		}
 		setBulkRun({ matched: escalated.total, sent: [] });
-		const outcome = await escalated.run(action);
-		setBulkRun({ matched: escalated.total, sent: [], outcome });
-		if (walkedAway.current) {
-			onRunEnded?.(action.kind, escalated.total, outcome);
-		}
-	}, [escalated, verb, named.moveMailboxId, junkMailboxId, onRunEnded]);
+		const started = await escalated.run(action, claimEnding);
+		setBulkRun({
+			matched: escalated.total,
+			sent: [],
+			outcome: started.kind === "ran" ? started.outcome : undefined,
+			failureReason: started.kind === "refused" ? started.reason : undefined,
+		});
+	}, [escalated, verb, named.moveMailboxId, junkMailboxId, claimEnding]);
 
 	const { start: startJob } = organizeJob;
 	const { createFilterAsync } = createFilter;
@@ -909,7 +943,6 @@ function SelectionWizardSession({
 	// 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]);

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

@@ -20,11 +20,11 @@
 import assert from "node:assert/strict";
 import { afterEach, beforeEach, describe, it } from "node:test";
 import { act, createElement } from "react";
-import type { BulkActionTarget } from "../lib/bulk-actions";
+import type { BulkActionTarget, EscalatedAction } from "../lib/bulk-actions";
+import { ranOutcome } from "../test-support/bulk-run";
 import { createDomHarness, type DomHarness } from "../test-support/dom";
 import { type HttpMock, httpError, mockFetch } from "../test-support/http";
 import {
-	type EscalatedAction,
 	type UseEscalatedActionsResult,
 	useEscalatedActions,
 } from "./useEscalatedActions";
@@ -80,7 +80,7 @@ const run = async (
 	});
 	await settle();
 	if (!started) throw new Error("the run never started");
-	return started;
+	return ranOutcome(await started);
 };
 
 /** The message-id list of every bulk request that left, in order. */