@remit/web-client 0.0.325 → 0.0.327

package/dist/src/components/mail/SelectionWizardHost.js

@@ -0,0 +1,721 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { mailboxOperationsListMailboxesOptions } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { derivePropertyClauses, dominantSender, ruleRestrictionFor, SelectionWizard, searchConversionNotice, senderLabel, stepBlockedReason, stepIndex, stepsFor, suggestRuleName, useOverlayScope, 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 { 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 { NO_JUNK_FOLDER_REASON } from "../../lib/junk-destination";
+import { useMailContext } from "../../lib/mail-context";
+import { buildMoveOptions, folderDelimiter } from "../../lib/move-options";
+import { buildWizardDraft, 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 { 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 = { clauses: [], matchOperator: "any" };
+/**
+ * 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 = {
+    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 = [];
+/**
+ * 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, props, accounts) => ({
+    verb: "organize",
+    accountId: searchRuleAccountId(conversion, props.accountId, accounts),
+    selection: EMPTY_SELECTION,
+    selectionRestriction: undefined,
+    escalated: undefined,
+    searchConversion: conversion,
+});
+const NOT_STARTED = {
+    state: "saving",
+    matched: 0,
+    applied: 0,
+    failed: 0,
+    failures: [],
+};
+const withIds = (clauses, prefix) => 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, moveMailboxId, junkMailboxId) => {
+    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 === "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 === "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, }) {
+    // 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(fromSearch ? "properties" : "selected");
+    const mode = escalated ? "escalated" : door;
+    const [draft, setDraft] = useState(() => conversion
+        ? {
+            clauses: withIds(conversion.clauses, "search"),
+            matchOperator: conversion.matchOperator,
+        }
+        : EMPTY_DRAFT);
+    const [clauseEdit, setClauseEdit] = useState(undefined);
+    const [nudgedStep, setNudgedStep] = useState(undefined);
+    const [committedScope, setCommittedScope] = useState(undefined);
+    const [bulkRun, setBulkRun] = useState(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(() => 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(() => 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 = 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 = 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(() => 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(() => ({ ...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(undefined);
+    const claimEnding = useCallback((release) => {
+        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) => {
+        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) => {
+        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) => {
+        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) => {
+        setDraft((held) => ({
+            ...held,
+            clauses: held.clauses.filter((clause) => clause.id !== clauseId),
+        }));
+    }, []);
+    const changeClauseDraft = useCallback((next) => {
+        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) => {
+        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) => {
+        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();
+        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(() => {
+        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 !== 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 = () => {
+        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 = () => {
+        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 (_jsx(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) {
+    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 (_jsx(SelectionWizardSession, { ...props, ...(conversion ? searchEntryOverrides(conversion, props, accounts) : {}), step: step, goToStep: goToStep, goBack: goBack, closeWizard: closeWizard }));
+}