@remit/web-client 0.0.325 → 0.0.327

package/src/components/mail/SelectionWizardHost.tsx

@@ -1,1078 +0,0 @@
-import { mailboxOperationsListMailboxesOptions } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import type { RemitImapAccountResponse } from "@remit/api-http-client/types.gen.ts";
-import {
-	type ClauseDraft,
-	type ClauseEditState,
-	derivePropertyClauses,
-	dominantSender,
-	type FolderTreeNode,
-	type MatchCount,
-	type MatchDoor,
-	type MatchMode,
-	type RuleClause,
-	type RunState,
-	ruleRestrictionFor,
-	type SearchConversion,
-	type SelectionRestriction,
-	SelectionWizard,
-	type StepId,
-	searchConversionNotice,
-	senderLabel,
-	stepBlockedReason,
-	stepIndex,
-	stepsFor,
-	suggestRuleName,
-	useOverlayScope,
-	type Verb,
-	type WizardDraft,
-	type WizardMessage,
-	wizardScopeFor,
-} from "@remit/ui";
-import { useQuery } from "@tanstack/react-query";
-import { useBlocker } from "@tanstack/react-router";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import {
-	useFolderAppointments,
-	useInboxMailbox,
-	useJunkMailbox,
-} from "@/hooks/useArchiveMailbox";
-import { useClauseSuggestions } from "@/hooks/useClauseSuggestions";
-import { useCreateMailbox } from "@/hooks/useCreateMailbox";
-import {
-	type EscalationSearchQuery,
-	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 { useRulePreview } from "@/hooks/useRulePreview";
-import { useSelectedSubjects } from "@/hooks/useSelectedSubjects";
-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";
-import { buildMoveOptions, folderDelimiter } from "@/lib/move-options";
-import {
-	buildWizardDraft,
-	type OrganizeMatchPredicate,
-	type OrganizeScope,
-	organizeScopeFor,
-} from "@/lib/organize/organize-model";
-import {
-	normalizeClauseValue,
-	SUPPORTED_CLAUSE_FIELDS,
-} from "@/lib/organize/rule-model";
-import { searchRuleAccountId } from "@/lib/organize/search-to-rule";
-import { useSearchConversion } from "@/lib/search-conversion";
-import type { WizardSelectionMessage } from "@/lib/wizard-selection";
-import { useWizardEntryValue, useWizardStep } from "@/routing";
-import { bulkRunReport } from "./bulk-run-state";
-import { organizeRunState } from "./organize-run-state";
-import {
-	retryIntent,
-	runIsInFlight,
-	stopRunner,
-	wizardExit,
-} from "./selection-wizard-run-controls";
-
-const EMPTY_DRAFT: WizardDraft = { clauses: [], matchOperator: "any" };
-
-interface SelectionWizardSessionProps extends SelectionWizardHostProps {
-	/** The step the URL holds. The session is mounted only while there is one. */
-	step: StepId;
-	goToStep: (step: StepId) => void;
-	goBack: () => void;
-	closeWizard: (steps: readonly StepId[], step: StepId) => void;
-	/**
-	 * The wizard was entered by converting a search rather than by ticking rows
-	 * (#477 1.8). The conversion seeds the clauses on the properties step and the
-	 * notice above them, and nothing else: every step after that is the one a
-	 * selection from the inbox walks (#477 3.4). Absent for the selection bar's
-	 * entry.
-	 */
-	searchConversion?: SearchConversion;
-}
-
-/**
- * The selection the list escalated to a predicate — every message matching the
- * query it is showing, rather than the rows on screen (#508). The wizard walks
- * it exactly as it walks a ticked selection: the same screens, the same review
- * before anything is sent. What differs is that the match has no member list,
- * so the count and the sample both come from the server that resolved it.
- */
-export interface EscalatedSelection {
-	/** What the predicate covers, in the words the list escalated it with. */
-	scope: string;
-	/** The server's count of the whole match, which the run is offered against. */
-	total: number;
-	/** The predicate itself, which the sample and the run both re-resolve. */
-	searchQuery: EscalationSearchQuery;
-	/**
-	 * 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. The run belongs to the list, so
-	 * it survives the wizard closing over it — as the run screen promises.
-	 */
-	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;
-}
-
-export interface SelectionWizardHostProps {
-	/** What the bar was pressed for. Every verb walks the same wizard. */
-	verb: Verb;
-	/** The account the ticked rows belong to, absent when they span several. */
-	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
-	 * take. The surface that resolved the selection knows which of the two it is,
-	 * and the wizard states that one (#525).
-	 */
-	selectionRestriction?: SelectionRestriction;
-	/** Present when the selection is a predicate rather than the ticked rows. */
-	escalated?: EscalatedSelection;
-	/**
-	 * How far the escalated runner has got. Read live and passed apart from
-	 * {@link EscalatedSelection}, which the wizard holds for the whole walk: the
-	 * list's escalation returns to idle when a run ends, so a progress reading
-	 * taken off the held predicate would be frozen at `undefined` for every
-	 * retry after the first and the bar would never move.
-	 */
-	escalatedProgress?: BulkActionProgress;
-	/** The wizard is done with the selection, and the list drops it. */
-	onFinished: () => void;
-	/**
-	 * 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"],
-		matched: number,
-		outcome: BulkRunOutcome,
-	) => void;
-}
-
-/**
- * A search entry with no query behind it — a link typed by hand, or one whose
- * query is gone. It opens the same properties step with nothing seeded, which
- * the step already states, rather than a wizard that renders nothing.
- */
-const NO_CONVERSION: SearchConversion = {
-	clauses: [],
-	matchOperator: "all",
-	droppedFacets: [],
-	keptTerms: false,
-};
-
-/** A search entry has nothing ticked; its match is the query's clauses (#477 3.2). */
-const EMPTY_SELECTION: readonly WizardSelectionMessage[] = [];
-
-/**
- * What a search entry overrides on the props the surface handed over. Its rule
- * belongs to the account the surface named, and to the one the query names when
- * it names one (#524) — reaching past both for the first configured account
- * writes the rule against whichever account happens to be first in the list, and
- * the mail the user was looking at is never filtered.
- */
-export const searchEntryOverrides = (
-	conversion: SearchConversion,
-	props: Pick<SelectionWizardHostProps, "accountId">,
-	accounts: readonly Pick<RemitImapAccountResponse, "accountId">[],
-): Pick<
-	SelectionWizardSessionProps,
-	| "verb"
-	| "accountId"
-	| "selection"
-	| "selectionRestriction"
-	| "escalated"
-	| "searchConversion"
-> => ({
-	verb: "organize",
-	accountId: searchRuleAccountId(conversion, props.accountId, accounts),
-	selection: EMPTY_SELECTION,
-	selectionRestriction: undefined,
-	escalated: undefined,
-	searchConversion: conversion,
-});
-
-/** How far a commit has got, whichever of the three ways it took. */
-interface RunSnapshot {
-	state: RunState;
-	matched: number;
-	applied: number;
-	failed: number;
-	failures: readonly WizardMessage[];
-	/**
-	 * Why a commit never started, when the reason is one the same commit cannot
-	 * get past. Carried to the run screen, which states it and offers no retry
-	 * (#522).
-	 */
-	failureReason?: string;
-}
-
-const NOT_STARTED: RunSnapshot = {
-	state: "saving",
-	matched: 0,
-	applied: 0,
-	failed: 0,
-	failures: [],
-};
-
-const withIds = (
-	clauses: readonly Omit<RuleClause, "id">[],
-	prefix: string,
-): RuleClause[] =>
-	clauses.map((clause, index) => ({ ...clause, id: `${prefix}-${index}` }));
-
-/**
- * The bulk call a verb makes over a concrete list of ids. Junk is a move: the
- * message-flags API has no `$Junk` field, so the Junk verb files into the
- * account's appointed Junk mailbox, and Move and Organize into the folder the
- * folder step chose.
- */
-const bulkActionFor = (
-	verb: Verb,
-	moveMailboxId: string | undefined,
-	junkMailboxId: string | undefined,
-): EscalatedAction | undefined => {
-	if (verb === "delete") return { kind: "delete" };
-	if (verb === "markRead") return { kind: "markRead" };
-	const destinationMailboxId = verb === "junk" ? junkMailboxId : moveMailboxId;
-	return destinationMailboxId
-		? { kind: "move", destinationMailboxId }
-		: undefined;
-};
-
-/**
- * Whether the properties match is applied by the server's own pass rather than over
- * the ids it matched. The back-apply job carries a move and nothing else, so
- * Move, Junk and Organize hand it the whole match; Delete and Mark read have no
- * server-side pass and act on the ids the preview matched.
- */
-const widenedRunsAsJob = (verb: Verb): boolean =>
-	verb === "move" || verb === "junk" || verb === "organize";
-
-/**
- * The commit pressed with nowhere for the mail to go. A verb that files mail
- * needs a destination, and reaching the run screen without one is a failure the
- * screen states along with the way out of it — never a control that does
- * nothing, and never a retry that re-sends the same commit to the same absence.
- */
-const noDestinationReason = (verb: Verb): string =>
-	verb === "junk"
-		? NO_JUNK_FOLDER_REASON
-		: "No destination was chosen, so there is nowhere to file these. Go back and pick a folder.";
-
-/**
- * Where the wizard meets the app (#483). The steps and their bodies belong to
- * `@remit/ui`; everything that talks to a server is here: the live count, the folder create, the bulk call, the back-apply job and the filter.
- *
- * Every commit routes through `organize-model.ts`, so the four `OrganizeScope`
- * values are reconstructed in one place from the two answers the wizard asks
- * for — what the action covers, and how long it holds.
- *
- * One walk of the wizard, and only that. Everything the walk answers — the door,
- * the draft, whether a commit has been sent — lives here rather than in the host
- * that mounts it, so closing the wizard takes all of it with the screen. Held a
- * level up, on a component the list mounts for as long as it is on screen, the
- * first commit's guard would still be up when the next selection reached Review,
- * and the second one would press a control that does nothing at all.
- */
-function SelectionWizardSession({
-	verb,
-	accountId,
-	mailboxId,
-	mailboxLabel,
-	selection,
-	selectionRestriction,
-	escalated: escalatedSelection,
-	escalatedProgress,
-	searchConversion,
-	onFinished,
-	onRunEnded,
-	step,
-	goToStep,
-	goBack,
-	closeWizard,
-}: SelectionWizardSessionProps) {
-	// The query as it read when the wizard opened. Held for the walk, so a search
-	// still settling underneath cannot rewrite the notice a user is reading while
-	// the clauses beside it stay as they were seeded.
-	const [conversion] = useState(() => searchConversion);
-	// The predicate this walk is for, held for the walk. The list's escalation
-	// returns to idle the moment a run ends, and a wizard reading it live would
-	// lose the match its run screen is reporting on — and would offer a retry over
-	// the loaded rows instead of over the predicate.
-	const [escalated] = useState(() => escalatedSelection);
-	const fromSearch = conversion !== undefined;
-	// The door the wizard is on. An escalated predicate is not one of them and is
-	// not held here: it is a property of the selection the list handed over, so
-	// the mode below is derived rather than settable. No screen can escalate a
-	// selection, and the commit path can be typed to the doors.
-	const [door, setDoor] = useState<MatchDoor>(
-		fromSearch ? "properties" : "selected",
-	);
-	const mode: MatchMode = escalated ? "escalated" : door;
-	const [draft, setDraft] = useState<WizardDraft>(() =>
-		conversion
-			? {
-					clauses: withIds(conversion.clauses, "search"),
-					matchOperator: conversion.matchOperator,
-				}
-			: EMPTY_DRAFT,
-	);
-	const [clauseEdit, setClauseEdit] = useState<ClauseEditState | undefined>(
-		undefined,
-	);
-	const [nudgedStep, setNudgedStep] = useState<StepId | undefined>(undefined);
-	const [committedScope, setCommittedScope] = useState<
-		OrganizeScope | undefined
-	>(undefined);
-	const [bulkRun, setBulkRun] = useState<
-		| {
-				matched: number;
-				/** What the run was sent, so a retry of what it missed keeps each
-				 *  id's account. Empty for an escalated run, which has no id list. */
-				sent: readonly BulkActionTarget[];
-				outcome?: BulkRunOutcome;
-				failureReason?: string;
-		  }
-		| undefined
-	>(undefined);
-	const commitSent = useRef(false);
-
-	const messageIds = useMemo(
-		() => selection.map((message) => message.id),
-		[selection],
-	);
-	// What a bulk run over the ticked rows covers, each row still naming its
-	// account so the run can batch per account.
-	const bulkTargets = useMemo<BulkActionTarget[]>(
-		() =>
-			selection.map((message) => ({
-				id: message.id,
-				accountId: message.accountId,
-			})),
-		[selection],
-	);
-	const senders = useMemo(
-		() => selection.map((message) => message.email).filter(Boolean),
-		[selection],
-	);
-	const subjects = useSelectedSubjects(messageIds);
-	const { junkMailboxId } = useJunkMailbox(accountId);
-	const { inboxMailboxId } = useInboxMailbox(accountId);
-	// A saved rule's first pass runs over the inbox. Ticked rows in any other
-	// folder take the action directly, so a rule made from Archive or from a
-	// search across folders still files the mail it was made from.
-	const outsideInbox = useMemo<BulkActionTarget[]>(
-		() =>
-			inboxMailboxId
-				? selection
-						.filter(
-							(message) =>
-								message.mailboxId !== undefined &&
-								message.mailboxId !== inboxMailboxId,
-						)
-						.map((message) => ({
-							id: message.id,
-							accountId: message.accountId,
-						}))
-				: [],
-		[selection, inboxMailboxId],
-	);
-
-	// A door the wizard resolves itself, through the preview endpoint. The
-	// escalated predicate is resolved by the list before the wizard opens, and
-	// the ticked list is its own answer, so neither is previewed.
-	const previewed = mode === "properties";
-	const predicate: OrganizeMatchPredicate = useMemo(
-		() => ({
-			matchOperator: draft.matchOperator === "all" ? "And" : "Or",
-			literalClauses: draft.clauses.map((clause) => ({
-				field: clause.field,
-				value: clause.value,
-			})),
-		}),
-		[draft.clauses, draft.matchOperator],
-	);
-	// The count and the ids both come from the server, never from paging the list
-	// in the browser (#477 5.3). The ticked list is its own count, so no request
-	// is made for it.
-	const { count: previewCount, matchedIds } = useRulePreview(
-		previewed ? accountId : undefined,
-		predicate,
-	);
-	const matchSample = useMatchSample(previewed ? matchedIds : []);
-	// The escalated match's own members, read from the search that resolved it.
-	const escalatedSample = useSearchMatchSample(
-		escalated ? mailboxId : undefined,
-		escalated?.searchQuery,
-	);
-
-	const count: MatchCount = escalated
-		? { status: "ready", count: escalated.total }
-		: previewed
-			? previewCount
-			: { status: "ready", count: selection.length };
-
-	const { data: mailboxesData } = useQuery({
-		...mailboxOperationsListMailboxesOptions({
-			path: { accountId: accountId ?? "" },
-		}),
-		enabled: !!accountId,
-		staleTime: Number.POSITIVE_INFINITY,
-	});
-	const folderAppointments = useFolderAppointments(accountId);
-	const translator = useFolderLabelTranslator();
-	const mailboxes = useMemo<FolderTreeNode[]>(
-		() =>
-			buildMoveOptions({
-				mailboxes: mailboxesData?.items ?? [],
-				folderAppointments,
-				currentMailboxId: mailboxId,
-				translator,
-			}),
-		[mailboxesData?.items, folderAppointments, mailboxId, translator],
-	);
-	const { createFolderIn } = useCreateMailbox(accountId);
-
-	const folderLabel = mailboxes.find(
-		(mailbox) => mailbox.id === draft.moveMailboxId,
-	)?.label;
-	const leadSender = dominantSender(
-		selection.map((message) => ({
-			normalizedEmail: message.email,
-			displayName: message.sender,
-		})),
-	);
-	const suggestedName = suggestRuleName({
-		match:
-			mode === "properties"
-				? draft.clauses[0]?.value.trim() || undefined
-				: undefined,
-		sender: leadSender ? senderLabel(leadSender) : undefined,
-		folder: folderLabel,
-	});
-	// The name the rule commits under: what the user typed, or the suggestion the
-	// field is showing them. The two must be the same string, or Continue blocks
-	// on a name that is on screen.
-	const named = useMemo<WizardDraft>(
-		() => ({ ...draft, name: draft.name ?? suggestedName }),
-		[draft, suggestedName],
-	);
-
-	const clauseSuggestions = useClauseSuggestions(
-		clauseEdit?.draft.field,
-		clauseEdit?.draft.value ?? "",
-		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;
-
-	const steps = stepsFor({ verb, mode, scope: draft.scope, fromSearch });
-	// The step the screens are on, which is the held one only while the answers
-	// still hold it. Reading the URL's step here and the resolved one on screen
-	// is how a footer comes to name a screen nobody is looking at.
-	const current = steps[stepIndex(steps, step)];
-
-	// A filter, a folder, and the preview that counts the properties door all
-	// belong to one account, so a selection spanning accounts reaches none of them
-	// and is told so on the step that asks (#477 5.5, #523). A selection spanning
-	// folders of one account is told about folders instead, and keeps its account:
-	// the preview behind the properties door has something to count against. The one-off
-	// scope and the ticked rows act on the messages themselves and are unaffected.
-	const wizardScope = wizardScopeFor(accountId, selectionRestriction);
-	// An escalated match is restricted on the same step for its own reason: the
-	// list resolved it before the wizard opened, and no door on the match step can
-	// give it a predicate to keep matching on (#1193).
-	const ruleRestriction = ruleRestrictionFor(mode, wizardScope);
-	const restrictionFor = (step: StepId): string | undefined => {
-		if (step === "folder") return wizardScope.destination;
-		if (step !== "rule") return undefined;
-		return named.scope === "standing" || named.scope === "until"
-			? ruleRestriction
-			: undefined;
-	};
-	const blockedReason =
-		restrictionFor(current) ?? stepBlockedReason(current, named, count);
-
-	const seedPropertyClauses = useCallback(
-		() => withIds(derivePropertyClauses(senders, subjects), "seed"),
-		[senders, subjects],
-	);
-
-	const changeMode = useCallback(
-		(next: MatchDoor) => {
-			setDoor(next);
-			setDraft((held) =>
-				next === "properties" && held.clauses.length === 0
-					? { ...held, clauses: seedPropertyClauses() }
-					: held,
-			);
-		},
-		[seedPropertyClauses],
-	);
-
-	const startAddClause = useCallback(() => {
-		setClauseEdit({ mode: "add", draft: { field: "From", value: "" } });
-	}, []);
-
-	const startEditClause = useCallback(
-		(clauseId: string) => {
-			const clause = draft.clauses.find((held) => held.id === clauseId);
-			if (!clause) return;
-			setClauseEdit({
-				mode: "edit",
-				clauseId,
-				draft: { field: clause.field, value: clause.value },
-			});
-		},
-		[draft.clauses],
-	);
-
-	const removeClause = useCallback((clauseId: string) => {
-		setDraft((held) => ({
-			...held,
-			clauses: held.clauses.filter((clause) => clause.id !== clauseId),
-		}));
-	}, []);
-
-	const changeClauseDraft = useCallback((next: ClauseDraft) => {
-		setClauseEdit((edit) => edit && { ...edit, draft: next });
-	}, []);
-
-	const submitClause = useCallback(() => {
-		setClauseEdit((edit) => {
-			if (!edit) return undefined;
-			const value = normalizeClauseValue(edit.draft.field, edit.draft.value);
-			const next = { ...edit.draft, value };
-			setDraft((held) => ({
-				...held,
-				clauses: edit.clauseId
-					? held.clauses.map((clause) =>
-							clause.id === edit.clauseId ? { ...clause, ...next } : clause,
-						)
-					: [...held.clauses, { id: crypto.randomUUID(), ...next }],
-			}));
-			return undefined;
-		});
-	}, []);
-
-	const advance = useCallback(() => {
-		if (blockedReason) {
-			setNudgedStep(current);
-			return;
-		}
-		setNudgedStep(undefined);
-		const next = steps[stepIndex(steps, current) + 1];
-		if (next) goToStep(next);
-	}, [blockedReason, current, steps, goToStep]);
-
-	const runBulk = useCallback(
-		async (targets: readonly BulkActionTarget[]) => {
-			const action = bulkActionFor(verb, named.moveMailboxId, junkMailboxId);
-			if (!action) {
-				setBulkRun({
-					matched: targets.length,
-					sent: targets,
-					failureReason: noDestinationReason(verb),
-				});
-				return;
-			}
-			setBulkRun({ matched: targets.length, sent: targets });
-			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, claimEnding],
-	);
-
-	// The escalated predicate, run by the chunked runner the list already owns.
-	// It pages the match on the server rather than acting on ids the browser
-	// loaded, so the verb reaches every message the review screen counted.
-	const runEscalated = useCallback(async () => {
-		if (!escalated) return;
-		const action = bulkActionFor(verb, named.moveMailboxId, junkMailboxId);
-		if (!action) {
-			setBulkRun({
-				matched: escalated.total,
-				sent: [],
-				failureReason: noDestinationReason(verb),
-			});
-			return;
-		}
-		setBulkRun({ matched: escalated.total, sent: [] });
-		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, watch: watchJob } = organizeJob;
-	const { createFilterAsync } = createFilter;
-
-	const sendCommit = useCallback(() => {
-		// An escalated predicate is not a rule and has no scope to reconstruct: it
-		// is the search the list is showing, applied once, by the runner that
-		// resolved it.
-		if (escalated) {
-			void runEscalated();
-			return;
-		}
-		const scope = organizeScopeFor({ mode: door, ruleScope: named.scope });
-		const organizeDraft = buildWizardDraft({
-			mode: door,
-			ruleScope: named.scope,
-			clauses: named.clauses,
-			matchOperator: named.matchOperator,
-			moveMailboxId: named.moveMailboxId,
-			until: named.until,
-		});
-		setCommittedScope(scope);
-
-		if (scope === "standing" || scope === "temporary") {
-			// Creating a filter also runs it over the inbox: the server queues that
-			// pass with the create and hands back its job id, which this screen
-			// follows. Ticked rows outside the inbox are not the job's to reach, so
-			// they take the action directly.
-			void createFilterAsync(
-				organizeDraft,
-				scope,
-				(named.name ?? "").trim(),
-			).then((created) => {
-				if (!created) return;
-				watchJob(created.organizeJobId);
-				if (outsideInbox.length > 0) void runBulk(outsideInbox);
-			});
-			return;
-		}
-		if (scope === "all-like-these" && widenedRunsAsJob(verb)) {
-			startJob(organizeDraft);
-			return;
-		}
-		// A widened match is resolved by the account's own preview, so every id it
-		// returned belongs to the account the wizard is scoped to.
-		void runBulk(
-			scope === "just-these"
-				? bulkTargets
-				: matchedIds.map((id) => ({ id, accountId })),
-		);
-	}, [
-		escalated,
-		runEscalated,
-		door,
-		named,
-		verb,
-		accountId,
-		bulkTargets,
-		matchedIds,
-		createFilterAsync,
-		watchJob,
-		outsideInbox,
-		startJob,
-		runBulk,
-	]);
-
-	// Two presses land in the same frame before either navigate settles, and both
-	// would send. The guard is a ref rather than the committed scope because that
-	// is state, and state has not been applied yet by the second press.
-	const commit = useCallback(() => {
-		if (blockedReason) {
-			setNudgedStep(current);
-			return;
-		}
-		if (commitSent.current) return;
-		commitSent.current = true;
-		goToStep("run");
-		sendCommit();
-	}, [blockedReason, current, goToStep, sendCommit]);
-
-	const jobSnapshot = useCallback(
-		(ruleSaved: boolean): RunSnapshot => {
-			const progress = organizeJob.progress;
-			const state = organizeRunState({
-				failure: organizeJob.failure,
-				isStarting: organizeJob.isStarting,
-				isRunning: organizeJob.isRunning,
-				isDone: organizeJob.isDone,
-				failedCount: progress.failedCount,
-				ruleSaved,
-			});
-			if (
-				state === "saving" ||
-				state === "commitFailed" ||
-				state === "backApplyStartFailed"
-			) {
-				return { ...NOT_STARTED, state };
-			}
-			return {
-				state,
-				matched: progress.matchedCount,
-				applied: progress.appliedCount,
-				failed:
-					state === "backApplyFailed" || state === "backApplyRestartFailed"
-						? progress.failedCount
-						: 0,
-				failures: [],
-			};
-		},
-		[organizeJob],
-	);
-
-	// Every row the wizard has seen a description of, so a run that names what it
-	// did not reach can name it rather than listing an id.
-	const rowsById = useMemo(() => {
-		const rows = new Map<string, WizardMessage>();
-		for (const message of [
-			...selection,
-			...matchSample.messages,
-			...escalatedSample.messages,
-		]) {
-			rows.set(message.id, message);
-		}
-		return rows;
-	}, [selection, matchSample.messages, escalatedSample.messages]);
-
-	const runProgress = escalated ? escalatedProgress : bulk.progress;
-
-	const bulkSnapshot = useCallback((): RunSnapshot => {
-		if (!bulkRun) return NOT_STARTED;
-		const report = bulkRunReport({
-			matched: bulkRun.matched,
-			outcome: bulkRun.outcome,
-			failureReason: bulkRun.failureReason,
-			progressDone: runProgress?.done ?? 0,
-		});
-		return {
-			state: report.state,
-			matched: report.matched,
-			applied: report.applied,
-			failed: report.failed,
-			failures: report.failedIds
-				.map((id) => rowsById.get(id))
-				.filter((message): message is WizardMessage => message !== undefined),
-			failureReason: report.failureReason,
-		};
-	}, [bulkRun, runProgress, rowsById]);
-
-	const createdFilter = createFilter.data;
-	// The direct action on ticked rows outside the inbox fell short. Its
-	// failures are reported over the job's progress: they are mail the user
-	// picked, and the job will never reach them.
-	const bulkFellShort =
-		bulkRun !== undefined &&
-		(bulkRun.failureReason !== undefined ||
-			(bulkRun.outcome?.failedIds.length ?? 0) > 0);
-
-	const runSnapshot = (): RunSnapshot => {
-		if (escalated) return bulkSnapshot();
-		if (committedScope === "standing" || committedScope === "temporary") {
-			if (createFilter.isError)
-				return { ...NOT_STARTED, state: "commitFailed" };
-			if (!createFilter.isSuccess) return NOT_STARTED;
-			if (bulkFellShort) return bulkSnapshot();
-			return jobSnapshot(true);
-		}
-		if (committedScope === "all-like-these" && widenedRunsAsJob(verb)) {
-			return jobSnapshot(false);
-		}
-		return bulkSnapshot();
-	};
-
-	const run = runSnapshot();
-
-	// Retry stays on the run screen: it re-sends the same commit rather than
-	// walking back to Review, which would push an entry the wizard does not own
-	// and leave Cancel rewinding to a step instead of out.
-	const retry = (): void => {
-		const ruleSaved =
-			committedScope === "standing" || committedScope === "temporary";
-		if (ruleSaved && bulkFellShort && bulkRun) {
-			const failed = new Set(bulkRun.outcome?.failedIds ?? []);
-			void runBulk(
-				failed.size > 0
-					? bulkRun.sent.filter((target) => failed.has(target.id))
-					: bulkRun.sent,
-			);
-			return;
-		}
-		const intent = retryIntent({
-			runState: run.state,
-			isEscalated: escalated !== undefined,
-			committedScope,
-			createFilterFailed: createFilter.isError,
-			backApplyPending: createdFilter !== undefined,
-			widenRunsAsJob: widenedRunsAsJob(verb),
-			failedIds: bulkRun?.outcome?.failedIds ?? [],
-			sent: bulkRun?.sent ?? bulkTargets,
-		});
-		switch (intent.kind) {
-			case "refreshStatus":
-				organizeJob.refreshStatus();
-				return;
-			case "rerunEscalated":
-				void runEscalated();
-				return;
-			case "resetAndResend":
-				createFilter.reset();
-				sendCommit();
-				return;
-			case "resend":
-				sendCommit();
-				return;
-			case "startBackApply":
-				if (createdFilter) organizeJob.startForFilter(createdFilter.filterId);
-				return;
-			case "waitOnJob":
-				return;
-			case "rerunBulk":
-				void runBulk(intent.targets);
-				return;
-		}
-	};
-
-	// Cancel rewinds the entries the wizard owns and leaves the selection where
-	// it was — nothing has happened to it (#477 1.6).
-	const cancel = useCallback(() => {
-		closeWizard(steps, current);
-	}, [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. 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(() => {
-		closeWizard(steps, current);
-		onFinished();
-	}, [closeWizard, steps, current, onFinished]);
-
-	const { stop: stopBulk } = bulk;
-	const stopRun = useCallback(() => {
-		stopRunner(escalated, 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
-	// commit is offered a second time; the run screen holds the outcome, which is
-	// what makes rewinding the entries under it safe (#477 1.6).
-	//
-	// The rewind `dismiss` performs is `router.history.go(-N)`, which the history
-	// classifies as `"GO"` — so it does not re-enter this blocker and recurse.
-	// `selection-wizard-history.spec.ts` walks a real browser back off the run
-	// screen, which is what pins that classification.
-	useBlocker({
-		shouldBlockFn: ({ action }) => {
-			if (action !== "BACK") return false;
-			dismiss();
-			return true;
-		},
-		enableBeforeUnload: false,
-		disabled: current !== "run",
-	});
-
-	const sampleMessages = escalated
-		? escalatedSample.messages
-		: previewed
-			? matchSample.messages
-			: selection;
-	const sample = {
-		messages: sampleMessages,
-		count,
-		label: mode === "selected" ? "Your selection" : "A sample of what matches",
-		loading: escalated
-			? escalatedSample.isPending
-			: previewed && (count.status === "loading" || matchSample.isPending),
-	};
-
-	return (
-		<SelectionWizard
-			verb={verb}
-			steps={steps}
-			step={current}
-			blockedReason={blockedReason}
-			nudged={nudgedStep === current}
-			onBack={goBack}
-			// 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={wizardExit(current, { dismiss, cancel })}
-			onContinue={advance}
-			onCommit={commit}
-			match={{
-				selectedCount: selection.length,
-				mode,
-				accountId: wizardScope.accountId,
-				onModeChange: changeMode,
-				escalatedScope: escalated?.scope,
-				sample,
-			}}
-			properties={{
-				clauses: named.clauses,
-				matchOperator: named.matchOperator,
-				onMatchOperatorChange: (matchOperator) =>
-					setDraft((held) => ({ ...held, matchOperator })),
-				clauseEdit,
-				onStartAddClause: startAddClause,
-				onStartEditClause: startEditClause,
-				onRemoveClause: removeClause,
-				onChangeDraft: changeClauseDraft,
-				onSubmitClause: submitClause,
-				onCancelClause: () => setClauseEdit(undefined),
-				clauseFields: SUPPORTED_CLAUSE_FIELDS,
-				clauseSuggestions,
-				conversionNotice: conversion
-					? searchConversionNotice(conversion)
-					: undefined,
-				sample: { ...sample, label: "What this matches" },
-			}}
-			folder={{
-				folders: mailboxes,
-				mailboxId: named.moveMailboxId,
-				delimiter: folderDelimiter(mailboxesData?.items ?? []),
-				onSelect: (moveMailboxId) =>
-					setDraft((held) => ({ ...held, moveMailboxId })),
-				onCreateFolder: accountId ? createFolderIn : undefined,
-				restriction: wizardScope.destination,
-			}}
-			rule={{
-				draft: named,
-				onScopeChange: (scope) => setDraft((held) => ({ ...held, scope })),
-				onUntilChange: (until) => setDraft((held) => ({ ...held, until })),
-				restriction: ruleRestriction,
-			}}
-			name={{
-				name: named.name ?? "",
-				onNameChange: (name) => setDraft((held) => ({ ...held, name })),
-				nudged: nudgedStep === current,
-			}}
-			review={{
-				verb,
-				mode,
-				selectedCount: selection.length,
-				clauses: named.clauses,
-				matchOperator: named.matchOperator,
-				folder: folderLabel,
-				scope: named.scope,
-				until: named.until,
-				ruleName: steps.includes("name") ? named.name : undefined,
-				escalatedScope: escalated?.scope,
-				sample,
-			}}
-			run={{
-				state: run.state,
-				verb,
-				scope: named.scope,
-				matched: run.matched,
-				applied: run.applied,
-				failedCount: run.failed,
-				failures: run.failures,
-				failureReason: run.failureReason,
-				onRetry: retry,
-				onDismiss: dismiss,
-				onCancelRun: runIsInFlight(bulkRun) ? stopRun : undefined,
-			}}
-		/>
-	);
-}
-
-/**
- * The wizard's mount point, and the only one: both entries walk this host, so
- * there is one owner of the step in the URL and of the history entries the
- * wizard pushes. The walk itself is a separate component, mounted only while a
- * step is held, so every answer it collects is gone by the time the next one
- * starts.
- *
- * The URL says which affordance opened the wizard, and that decides two things
- * and no more: which step it opens on, and whether the query seeds the clauses.
- * A search entry ticks nothing, so the selection the bar would have handed over
- * is not the one it walks; its rule belongs to the account the surface handed
- * over, and to the one the query names when it names one (#524).
- */
-export function SelectionWizardHost(props: SelectionWizardHostProps) {
-	const fromSearch = useWizardEntryValue() === "search";
-	const searchConversion = useSearchConversion();
-	const { accounts } = useMailContext();
-	const { step, goToStep, goBack, closeWizard } = useWizardStep(
-		fromSearch ? "properties" : "match",
-	);
-	// A walk in progress owns the keyboard. It answers nothing itself — Back and
-	// Close are on screen, and Escape abandoning a half-run selection is not what
-	// the reader asked for — so every triage key is contained until it closes.
-	useOverlayScope({ id: "selection-wizard", open: step !== undefined });
-	if (!step) return null;
-	const conversion = fromSearch
-		? (searchConversion ?? NO_CONVERSION)
-		: undefined;
-	return (
-		<SelectionWizardSession
-			{...props}
-			{...(conversion ? searchEntryOverrides(conversion, props, accounts) : {})}
-			step={step}
-			goToStep={goToStep}
-			goBack={goBack}
-			closeWizard={closeWizard}
-		/>
-	);
-}