@remit/web-client 0.0.269 → 0.0.270

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.269",
+  "version": "0.0.270",
   "type": "module",
   "description": "Remit web client, published as composable primitives — the app shell, auth shells, and runtime config. A distributor imports what it composes and bundles it.",
   "exports": {

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

@@ -63,7 +63,7 @@ describe("reporting how a run ended", () => {
 		);
 		assert.equal(stopped?.title, "Stopped after 100");
 		assert.match(stopped?.detail ?? "", /100 of 3,000 moved to Trash\./);
-		assert.match(stopped?.detail ?? "", /Nothing was sent for the rest/);
+		assert.match(stopped?.detail ?? "", /The rest were not sent/);
 
 		const covered = runEndingBanner("delete", 100, ended(), "trash");
 		assert.match(covered?.title ?? "", /^100 moved to Trash\./);

package/src/components/mail/SelectionWizardHost.tsx

@@ -75,6 +75,7 @@ import type { OrganizeMatchPredicate } from "@/lib/organize/sender-fallback";
 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,
@@ -823,57 +824,21 @@ function SelectionWizardSession({
 
 	const bulkSnapshot = useCallback((): RunSnapshot => {
 		if (!bulkRun) return NOT_STARTED;
-		const { matched, outcome, failureReason } = bulkRun;
-		// Nothing was sent, and nothing about sending it again resolves what was
-		// missing — so the screen carries why rather than the generic ending (#522).
-		if (failureReason !== undefined) {
-			return { ...NOT_STARTED, state: "commitFailed", failureReason };
-		}
-		if (!outcome) {
-			const applied = runProgress?.done ?? 0;
-			// A predicate matches more by the time the run re-pages it than the count
-			// saw, so what it has covered can overtake what it was offered against.
-			// The bar never reads more done than out of, and neither does this.
-			return {
-				state: "backApplyRunning",
-				matched: Math.max(matched, applied),
-				applied,
-				failed: 0,
-				failures: [],
-			};
-		}
-		const stopped = outcome.cancelled || outcome.error !== undefined;
-		if (!stopped) {
-			return {
-				state: "backApplyComplete",
-				matched: Math.max(matched, outcome.done),
-				applied: outcome.done,
-				failed: 0,
-				failures: [],
-			};
-		}
-		if (outcome.done === 0) {
-			return { ...NOT_STARTED, state: "commitFailed" };
-		}
-		// The run stopped part-way. Nothing here was rejected: a returned bulk call
-		// accepts every id in it, so the only failure this layer sees is a call that
-		// threw, and everything after it was never sent. A bounded run hands back
-		// exactly those ids; a predicate run re-resolves its match on every pass and
-		// has no remainder to hand back, so what is left is the difference between
-		// the count and what the run covered.
-		const failures = outcome.failedIds
-			.map((id) => rowsById.get(id))
-			.filter((message): message is WizardMessage => message !== undefined);
-		const unreached =
-			outcome.failedIds.length > 0
-				? outcome.failedIds.length
-				: Math.max(matched - outcome.done, 1);
+		const report = bulkRunReport({
+			matched: bulkRun.matched,
+			outcome: bulkRun.outcome,
+			failureReason: bulkRun.failureReason,
+			progressDone: runProgress?.done ?? 0,
+		});
 		return {
-			state: "runStopped",
-			matched: Math.max(matched, outcome.done),
-			applied: outcome.done,
-			failed: unreached,
-			failures,
+			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]);
 

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

@@ -0,0 +1,100 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { BulkRunOutcome } from "@/lib/bulk-actions";
+import { bulkRunReport } from "./bulk-run-state";
+
+const ended = (over: Partial<BulkRunOutcome> = {}): BulkRunOutcome => ({
+	done: 0,
+	failedIds: [],
+	cancelled: false,
+	...over,
+});
+
+const report = (
+	over: Partial<Parameters<typeof bulkRunReport>[0]> = {},
+): ReturnType<typeof bulkRunReport> =>
+	bulkRunReport({
+		matched: 100,
+		outcome: undefined,
+		failureReason: undefined,
+		progressDone: 0,
+		...over,
+	});
+
+describe("what the run screen says a bulk run did", () => {
+	it("shows a run still going against what it was started with", () => {
+		assert.deepEqual(report({ progressDone: 40 }), {
+			state: "backApplyRunning",
+			matched: 100,
+			applied: 40,
+			failed: 0,
+			failedIds: [],
+		});
+	});
+
+	it("never reads more done than out of", () => {
+		const going = report({ matched: 1284, progressDone: 1340 });
+		assert.equal(going.matched, 1340);
+	});
+
+	it("ends a run that covered its match on the success screen", () => {
+		const covered = report({ outcome: ended({ done: 100 }) });
+		assert.equal(covered.state, "backApplyComplete");
+		assert.equal(covered.applied, 100);
+	});
+
+	it("carries a commit that never started, and why", () => {
+		const never = report({ failureReason: "There is no Junk folder" });
+		assert.equal(never.state, "commitFailed");
+		assert.equal(never.failureReason, "There is no Junk folder");
+		assert.equal(never.matched, 0);
+	});
+
+	it("says a run that errored before anything landed never started", () => {
+		const threw = report({ outcome: ended({ error: new Error("500") }) });
+		assert.equal(threw.state, "commitFailed");
+	});
+});
+
+/**
+ * Regression for #113. A stop used to be read only between pages, so it always
+ * landed with at least one batch already applied and `done === 0` could only
+ * mean a failure. Aborting the request in flight makes zero the ordinary
+ * outcome of stopping during the first batch — the only batch a selection of a
+ * hundred or fewer ever has — and answering that with the danger screen told
+ * the user nothing had changed while the server had most likely taken all of
+ * them.
+ */
+describe("a run the user stopped", () => {
+	it("reports a stop during the first batch as stopped, not as a failed start", () => {
+		const stopped = report({
+			matched: 100,
+			outcome: ended({ cancelled: true, failedIds: Array(100).fill("m") }),
+		});
+		assert.equal(stopped.state, "runStopped");
+		assert.notEqual(stopped.state, "commitFailed");
+		assert.equal(stopped.applied, 0);
+		assert.equal(stopped.failed, 100);
+	});
+
+	it("reports a stop that reached nothing at all as stopped too", () => {
+		// The escalated path hands back no remainder: the predicate re-resolves on
+		// every run, so there are no ids to list, only a difference to name.
+		const stopped = report({
+			matched: 3000,
+			outcome: ended({ cancelled: true }),
+		});
+		assert.equal(stopped.state, "runStopped");
+		assert.equal(stopped.failed, 3000);
+	});
+
+	it("still reports a stop that got part-way", () => {
+		const stopped = report({
+			matched: 3000,
+			outcome: ended({ done: 1200, cancelled: true }),
+		});
+		assert.equal(stopped.state, "runStopped");
+		assert.equal(stopped.applied, 1200);
+		assert.equal(stopped.failed, 1800);
+	});
+});

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

@@ -0,0 +1,99 @@
+import type { RunState } from "@remit/ui";
+import type { BulkRunOutcome } from "@/lib/bulk-actions";
+
+/** What the run screen knows about a chunked bulk run it is reporting on. */
+export interface BulkRunReading {
+	/** The count the run was started against. */
+	matched: number;
+	/** Set once the run has ended, for any reason. */
+	outcome: BulkRunOutcome | undefined;
+	/**
+	 * Why the commit never started, when the reason is one the same commit cannot
+	 * get past (#522).
+	 */
+	failureReason: string | undefined;
+	/** Ids covered so far, read off the progress bar while the run is going. */
+	progressDone: number;
+}
+
+export interface BulkRunReport {
+	state: RunState;
+	matched: number;
+	applied: number;
+	failed: number;
+	/** Ids the run leaves unconfirmed; the screen resolves them to rows. */
+	failedIds: readonly string[];
+	failureReason?: string;
+}
+
+const NOTHING_STARTED = {
+	matched: 0,
+	applied: 0,
+	failed: 0,
+	failedIds: [] as readonly string[],
+};
+
+/**
+ * What the run screen says a bulk run did.
+ *
+ * Stopping is read before counting, because a stop is not a failure however
+ * little it reached (#113). Pressing Stop during the first batch — the only
+ * batch a selection of 100 or fewer has — leaves `done` at zero while the
+ * server has most likely applied all of them, and answering that with
+ * "Couldn't start deleting / Nothing has changed" is both alarming and wrong.
+ * Only a run that errored before anything landed has nothing to report but the
+ * failure.
+ */
+export const bulkRunReport = ({
+	matched,
+	outcome,
+	failureReason,
+	progressDone,
+}: BulkRunReading): BulkRunReport => {
+	// Nothing was sent, and nothing about sending it again resolves what was
+	// missing — so the screen carries why rather than the generic ending (#522).
+	if (failureReason !== undefined) {
+		return { ...NOTHING_STARTED, state: "commitFailed", failureReason };
+	}
+	if (!outcome) {
+		// A predicate matches more by the time the run re-pages it than the count
+		// saw, so what it has covered can overtake what it was offered against.
+		// The bar never reads more done than out of, and neither does this.
+		return {
+			state: "backApplyRunning",
+			matched: Math.max(matched, progressDone),
+			applied: progressDone,
+			failed: 0,
+			failedIds: [],
+		};
+	}
+	if (!outcome.cancelled && outcome.error === undefined) {
+		return {
+			state: "backApplyComplete",
+			matched: Math.max(matched, outcome.done),
+			applied: outcome.done,
+			failed: 0,
+			failedIds: [],
+		};
+	}
+	if (!outcome.cancelled && outcome.done === 0) {
+		return { ...NOTHING_STARTED, state: "commitFailed" };
+	}
+	// The run stopped part-way. Nothing here was rejected: a returned bulk call
+	// accepts every id in it, so the only failure this layer sees is a call that
+	// threw or was aborted, and everything after it was never sent. A bounded run
+	// hands back exactly those ids; a predicate run re-resolves its match on every
+	// pass and has no remainder to hand back, so what is left is the difference
+	// between the count and what the run covered.
+	const unreached =
+		outcome.failedIds.length > 0
+			? outcome.failedIds.length
+			: Math.max(matched - outcome.done, 1);
+	return {
+		state: "runStopped",
+		matched: Math.max(matched, outcome.done),
+		applied: outcome.done,
+		failed: unreached,
+		failedIds: outcome.failedIds,
+	};
+};

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

@@ -6,9 +6,9 @@
  *
  * These mount the real hook against the real fetch seam and count the batches
  * that actually left, so what is pinned is the run's own lifetime rather than
- * the wording of whichever screen started it. Every run is parked at a page
- * boundary before the test acts on it: that is where the run reads whether it
- * has been told to stop, and so the only place the difference shows.
+ * the wording of whichever screen started it. Every run is parked on a request
+ * the server is holding before the test acts on it: that is where leaving the
+ * selection and stopping the run tell each other apart.
  */
 
 import assert from "node:assert/strict";
@@ -32,8 +32,12 @@ let server: MailServer | undefined;
 interface MailServer {
 	/** Every message id a delete call carried, in the order they were sent. */
 	deleted: () => string[];
-	/** Deletes queued at the boundary rather than answered. */
+	/** Requests queued at the boundary rather than answered. */
 	held: () => number;
+	/** Requests the client cancelled while they were held. */
+	aborted: () => number;
+	/** Hold the count request too, so a stop can be pressed during counting. */
+	holdCounts: (on: boolean) => void;
 	/** Answer everything held, and stop holding. */
 	release: () => void;
 	restore: () => void;
@@ -61,14 +65,33 @@ const searchPage = (url: URL): unknown => {
 
 /**
  * Answers the search and the bulk delete, holding every delete after the first
- * so a run can be caught mid-flight with real progress behind it.
+ * so a run can be caught mid-flight with real progress behind it. A held
+ * request honours its own abort signal, the way the platform's `fetch` does —
+ * that is the difference a stop is now supposed to make (#113).
  */
 const startMailServer = (): MailServer => {
 	const original = globalThis.fetch;
 	const deleted: string[] = [];
 	let waiting: Array<() => void> = [];
 	let holding = true;
+	let holdingCounts = false;
 	let served = 0;
+	let cancelled = 0;
+
+	const hold = (signal: AbortSignal | undefined): Promise<void> =>
+		new Promise<void>((resolve, reject) => {
+			const fail = () => {
+				cancelled += 1;
+				waiting = waiting.filter((held) => held !== resolve);
+				reject(signal?.reason);
+			};
+			if (signal?.aborted) {
+				fail();
+				return;
+			}
+			signal?.addEventListener("abort", fail, { once: true });
+			waiting.push(resolve);
+		});
 
 	globalThis.fetch = (async (input: RequestInfo | URL): Promise<Response> => {
 		const request = input instanceof Request ? input : undefined;
@@ -76,6 +99,9 @@ const startMailServer = (): MailServer => {
 		const url = new URL(request ? request.url : String(input), "http://x");
 
 		if (url.pathname.endsWith("/threads/search")) {
+			if (holdingCounts && url.searchParams.get("results") === "false") {
+				await hold(request?.signal);
+			}
 			return Response.json(searchPage(url));
 		}
 
@@ -84,7 +110,7 @@ const startMailServer = (): MailServer => {
 			: undefined;
 		served += 1;
 		if (holding && served > 1) {
-			await new Promise<void>((resolve) => waiting.push(resolve));
+			await hold(request?.signal);
 		}
 		deleted.push(...(body?.messageIds ?? []));
 		return Response.json({ successCount: 0, failureCount: 0 });
@@ -93,8 +119,13 @@ const startMailServer = (): MailServer => {
 	return {
 		deleted: () => deleted,
 		held: () => waiting.length,
+		aborted: () => cancelled,
+		holdCounts: (on) => {
+			holdingCounts = on;
+		},
 		release: () => {
 			holding = false;
+			holdingCounts = false;
 			const queued = waiting;
 			waiting = [];
 			for (const resolve of queued) resolve();
@@ -235,6 +266,56 @@ describe("an escalated run the user walks away from", () => {
 	});
 });
 
+// Regression for #113: a stop used to be read only between pages, so the delete
+// already on the wire ran to completion and its whole page — up to a hundred
+// messages — was deleted after the press.
+describe("stopping a run with a delete already on the wire", () => {
+	it("cancels that delete and sends nothing more", async () => {
+		const { hook } = mountEscalation({ query: "npm" });
+		await escalateTo(hook);
+
+		const run = press(() => hook().runAction({ kind: "delete" }));
+		await parkAtBoundary();
+		const sentBeforeStop = server?.deleted().length ?? 0;
+		press(() => hook().stop());
+		press(() => server?.release());
+		await settle();
+		const outcome = await run;
+
+		assert.equal(server?.aborted(), 1, "the delete in flight was cancelled");
+		assert.equal(
+			server?.deleted().length,
+			sentBeforeStop,
+			"no further ids reached the server",
+		);
+		assert.equal(outcome.cancelled, true);
+		assert.equal(
+			outcome.error,
+			undefined,
+			"a stop the user pressed is not a failure to report",
+		);
+		assert.equal(outcome.done, sentBeforeStop);
+	});
+
+	it("cancels a count in flight without raising an error", async () => {
+		server?.holdCounts(true);
+		const { hook } = mountEscalation({ query: "npm" });
+
+		press(() => hook().escalate());
+		await parkAtBoundary();
+		press(() => hook().stop());
+		press(() => server?.release());
+		await settle();
+
+		assert.equal(server?.aborted(), 1);
+		assert.deepEqual(hook().phase, { kind: "idle" });
+		assert.equal(
+			harness?.text().includes("Couldn't count matching messages"),
+			false,
+		);
+	});
+});
+
 describe("stopping the run, which is a different press", () => {
 	it("ends it at the next page boundary and says what it reached", async () => {
 		const { hook } = mountEscalation({ query: "npm" });

package/src/hooks/useEscalatedActions.ts

@@ -84,7 +84,9 @@ export interface UseEscalatedActionsResult {
 	 *  selection to that predicate once it answers. */
 	escalate: () => void;
 	/**
-	 * Stop whatever's running — the count or an action — at the next boundary.
+	 * Stop whatever's running — the count or an action. The request in flight is
+	 * aborted and nothing further leaves (#113); a delete the server has already
+	 * accepted still applies, so the batch on the wire is what a stop is worth.
 	 * A no-op when nothing is running. The only thing that ends a run in
 	 * flight: leaving the selection, the wizard or the search does not.
 	 */
@@ -147,7 +149,10 @@ export const useEscalatedActions = ({
 	const [progress, setProgress] = useState<BulkActionProgress | undefined>(
 		undefined,
 	);
-	const cancelRef = useRef(false);
+	// Cancellation is the signal every call the run makes is issued under, so a
+	// stop ends the request on the wire instead of waiting for it to come back
+	// (#113). Replaced, never reused, at the start of each count and each run.
+	const abortRef = useRef<AbortController | undefined>(undefined);
 	// True from the moment a run starts until its outcome is in hand. A run is
 	// mail already leaving the mailbox, so nothing that merely changes what the
 	// list is showing gets to end it — only `stop`.
@@ -170,7 +175,7 @@ export const useEscalatedActions = ({
 	// against and reports what it reached, wherever the list moved on to.
 	// biome-ignore lint/correctness/useExhaustiveDependencies: enabled/predicateKey are trigger-only — the reset itself reads neither.
 	useEffect(() => {
-		if (!runningRef.current) cancelRef.current = true;
+		if (!runningRef.current) abortRef.current?.abort();
 		setPhase({ kind: "idle" });
 	}, [enabled, predicateKey]);
 
@@ -179,10 +184,11 @@ export const useEscalatedActions = ({
 
 	const fetchPagesOf = useCallback(
 		(query: EscalationSearchQuery): FetchIdsPage =>
-			async (continuationToken) => {
+			async (continuationToken, signal) => {
 				const { data } = await threadOperationsSearchThreads({
 					path: { mailboxId },
 					query: { ...query, continuationToken, limit: PAGE_SIZE },
+					signal,
 					throwOnError: true,
 				});
 				return {
@@ -198,27 +204,32 @@ export const useEscalatedActions = ({
 	 * resolves it (#509). One count-only request: `limit` is a page size and has
 	 * no bearing on the answer, so nothing is paged to arrive at it.
 	 */
-	const fetchMatchCount = useCallback(async (): Promise<number> => {
-		const { data } = await threadOperationsSearchThreads({
-			path: { mailboxId },
-			query: { ...searchQueryRef.current, count: true, results: false },
-			throwOnError: true,
-		});
-		if (data.count === undefined) {
-			throw new Error("the search returned no count for the selection");
-		}
-		return data.count;
-	}, [mailboxId]);
+	const fetchMatchCount = useCallback(
+		async (signal: AbortSignal): Promise<number> => {
+			const { data } = await threadOperationsSearchThreads({
+				path: { mailboxId },
+				query: { ...searchQueryRef.current, count: true, results: false },
+				signal,
+				throwOnError: true,
+			});
+			if (data.count === undefined) {
+				throw new Error("the search returned no count for the selection");
+			}
+			return data.count;
+		},
+		[mailboxId],
+	);
 
 	const applyBatchFor = useCallback(
 		(action: EscalatedAction): ApplyBatch =>
-			async (ids: string[]) => {
+			async (ids: string[], signal: AbortSignal) => {
 				if (action.kind === "move") {
 					const { data } = await messageBulkOperationsMoveMessages({
 						body: {
 							messageIds: ids,
 							destinationMailboxId: action.destinationMailboxId,
 						},
+						signal,
 						throwOnError: true,
 					});
 					return data;
@@ -226,12 +237,14 @@ export const useEscalatedActions = ({
 				if (action.kind === "markRead") {
 					const { data } = await messageBulkOperationsUpdateFlags({
 						body: { messageIds: ids, isRead: true },
+						signal,
 						throwOnError: true,
 					});
 					return data;
 				}
 				const { data } = await messageBulkOperationsDeleteMessages({
 					body: { messageIds: ids },
+					signal,
 					throwOnError: true,
 				});
 				return data;
@@ -267,17 +280,24 @@ export const useEscalatedActions = ({
 	);
 
 	const escalate = useCallback(() => {
-		cancelRef.current = false;
+		const controller = new AbortController();
+		abortRef.current = controller;
 		setPhase({ kind: "counting" });
-		fetchMatchCount().then(
+		fetchMatchCount(controller.signal).then(
 			(total) => {
-				if (cancelRef.current) {
+				if (controller.signal.aborted) {
 					setPhase({ kind: "idle" });
 					return;
 				}
 				setPhase({ kind: "escalated", total });
 			},
 			(error: unknown) => {
+				// A stopped count rejects with its own abort. That is the press the
+				// user made, not a failure to report back to them.
+				if (controller.signal.aborted) {
+					setPhase({ kind: "idle" });
+					return;
+				}
 				pushError(
 					buildMutationErrorBanner(
 						"Couldn't count matching messages",
@@ -291,12 +311,12 @@ export const useEscalatedActions = ({
 	}, [fetchMatchCount, pushError]);
 
 	const stop = useCallback(() => {
-		cancelRef.current = true;
+		abortRef.current?.abort();
 	}, []);
 
 	const clear = useCallback(() => {
 		if (runningRef.current) return;
-		cancelRef.current = true;
+		abortRef.current?.abort();
 		setPhase({ kind: "idle" });
 	}, []);
 
@@ -305,7 +325,8 @@ export const useEscalatedActions = ({
 			action: EscalatedAction,
 			targets?: readonly BulkActionTarget[],
 		): Promise<BulkRunOutcome> => {
-			cancelRef.current = false;
+			const controller = new AbortController();
+			abortRef.current = controller;
 			runningRef.current = true;
 			setRunningAction(action);
 			// Read before the run clears the phase below, so a refusal can say how
@@ -334,14 +355,14 @@ export const useEscalatedActions = ({
 								targets,
 								applyBatch,
 								onProgress,
-								() => cancelRef.current,
+								controller.signal,
 							)
 						: await runPredicateAction(
 								runPages,
 								phase.kind === "escalated" ? phase.total : 0,
 								applyBatch,
 								onProgress,
-								() => cancelRef.current,
+								controller.signal,
 							);
 			} finally {
 				runningRef.current = false;

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

@@ -68,19 +68,29 @@ describe("bulkActionFailureTitle", () => {
 });
 
 describe("a run that stopped short of its match", () => {
-	test("states what it reached and that the rest is untouched", () => {
+	test("states what it reached and what became of the rest", () => {
 		assert.equal(bulkActionStoppedTitle(1200), "Stopped after 1,200");
 		assert.equal(
 			bulkActionStoppedDetail("delete", 1200, 3412),
-			"1,200 of 3,412 moved to Trash. Nothing was sent for the rest, so they are untouched.",
+			"1,200 of 3,412 moved to Trash. The rest were not sent, apart from the ones already on their way when you stopped — those may still have gone through.",
 		);
 		assert.equal(
 			bulkActionStoppedDetail("markRead", 1200, 3412),
-			"1,200 of 3,412 marked as read. Nothing was sent for the rest, so they are untouched.",
+			"1,200 of 3,412 marked as read. The rest were not sent, apart from the ones already on their way when you stopped — those may still have gone through.",
 		);
 	});
 
-	test("never reads as a rejection — nothing was sent", () => {
+	// Stopping aborts the request on the wire; it does not un-send one the server
+	// already took (#113). Promising the remainder is untouched would be a claim
+	// the client cannot make about the batch that was in flight.
+	test("stops short of promising the batch in flight never landed", () => {
+		assert.match(
+			bulkActionStoppedDetail("move", 1, 2),
+			/may still have gone through/,
+		);
+	});
+
+	test("never reads as a rejection — nothing was refused", () => {
 		assert.doesNotMatch(
 			bulkActionStoppedDetail("move", 1, 2),
 			/rejected|couldn't/i,

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

@@ -86,9 +86,11 @@ export const bulkActionCompletionText = (
 
 /**
  * Shown when a run ended before it covered what it was started against. The
- * remainder was never sent, so the mail is where it was and only the user can
+ * remainder was never sent, so that mail is where it was and only the user can
  * decide to run it again — which is why this is stated rather than left to a
- * list that quietly stops changing.
+ * list that quietly stops changing. Stopping aborts the request already on the
+ * wire rather than un-sending it (#113), so what the copy can promise about the
+ * remainder stops short of the batch that was in flight.
  */
 export const bulkActionStoppedTitle = (done: number): string =>
 	`Stopped after ${formatNumber(done)}`;
@@ -99,7 +101,7 @@ export const bulkActionStoppedDetail = (
 	total: number,
 	outcome: DeleteOutcome = "trash",
 ): string =>
-	`${formatNumber(done)} of ${formatNumber(total)} ${pastTenseFor(kind, outcome)}. Nothing was sent for the rest, so they are untouched.`;
+	`${formatNumber(done)} of ${formatNumber(total)} ${pastTenseFor(kind, outcome)}. The rest were not sent, apart from the ones already on their way when you stopped — those may still have gone through.`;
 
 /** Error-banner title for a run stopped by an infrastructure failure. */
 export const bulkActionFailureTitle = (

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

@@ -11,6 +11,24 @@ import {
 	runPredicateAction,
 } from "./bulk-actions.js";
 
+/** A run nobody stops. */
+const neverAborted = (): AbortSignal => new AbortController().signal;
+
+/**
+ * What an aborted request does: reject with the signal's own reason, whether it
+ * was already aborted when the call was made or aborted while in flight.
+ */
+const abortable = (signal: AbortSignal): Promise<never> =>
+	new Promise((_, reject) => {
+		if (signal.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		signal.addEventListener("abort", () => reject(signal.reason), {
+			once: true,
+		});
+	});
+
 const ids = (count: number, prefix = "m"): string[] =>
 	Array.from({ length: count }, (_, i) => `${prefix}${i}`);
 
@@ -112,7 +130,6 @@ describe("chunkTargets", () => {
 });
 
 describe("runChunkedAction", () => {
-	const neverCancelled = () => false;
 	const noopProgress = () => undefined;
 
 	test("zero ids does nothing and reports done=0", async () => {
@@ -124,7 +141,7 @@ describe("runChunkedAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.deepEqual(outcome, {
 			done: 0,
@@ -144,7 +161,7 @@ describe("runChunkedAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(calls.length, 2);
 		assert.equal(calls[0].length, BULK_ACTION_CHUNK_SIZE);
@@ -159,7 +176,7 @@ describe("runChunkedAction", () => {
 			input,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(outcome.done, input.length);
 		assert.deepEqual(outcome.failedIds, []);
@@ -168,16 +185,16 @@ describe("runChunkedAction", () => {
 	test("cancelling mid-run folds every unreached chunk into failedIds", async () => {
 		const input = targets(BULK_ACTION_CHUNK_SIZE * 3);
 		let calls = 0;
-		let cancelled = false;
+		const stop = new AbortController();
 		const outcome = await runChunkedAction(
 			input,
 			async (chunk) => {
 				calls++;
-				if (calls === 1) cancelled = true; // cancel after the first chunk lands
+				if (calls === 1) stop.abort(); // cancel after the first chunk lands
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			() => undefined,
-			() => cancelled,
+			stop.signal,
 		);
 		assert.equal(outcome.cancelled, true);
 		assert.equal(calls, 1);
@@ -195,7 +212,7 @@ describe("runChunkedAction", () => {
 				throw boom;
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(outcome.error, boom);
 		assert.equal(outcome.done, 0);
@@ -215,7 +232,7 @@ describe("runChunkedAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.deepEqual(calls, [["a1", "a2"], ["b1"]]);
 		assert.equal(outcome.done, 3);
@@ -231,7 +248,7 @@ describe("runChunkedAction", () => {
 			],
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			(p) => seen.push(p),
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.deepEqual(seen, [
 			{ done: 1, total: 2 },
@@ -240,7 +257,7 @@ describe("runChunkedAction", () => {
 	});
 
 	test("cancelling at an account boundary hands back the accounts never reached", async () => {
-		let cancelled = false;
+		const stop = new AbortController();
 		const outcome = await runChunkedAction(
 			[
 				{ id: "a1", accountId: "acct-a" },
@@ -248,11 +265,11 @@ describe("runChunkedAction", () => {
 				{ id: "c1", accountId: "acct-c" },
 			],
 			async (chunk) => {
-				cancelled = true;
+				stop.abort();
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			() => undefined,
-			() => cancelled,
+			stop.signal,
 		);
 		assert.equal(outcome.cancelled, true);
 		assert.equal(outcome.done, 1);
@@ -271,7 +288,7 @@ describe("runChunkedAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			() => undefined,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(outcome.error, boom);
 		assert.equal(outcome.done, 1);
@@ -291,7 +308,7 @@ describe("runChunkedAction", () => {
 				throw new Error("auth expired");
 			},
 			() => undefined,
-			neverCancelled,
+			neverAborted(),
 		);
 		// The run stops where it threw rather than trying the accounts behind it:
 		// what it hands back is exactly what is still untouched, which is what a
@@ -308,7 +325,7 @@ describe("runChunkedAction", () => {
 			input,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			(p) => progressCalls.push(p),
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.deepEqual(progressCalls, [
 			{ done: BULK_ACTION_CHUNK_SIZE, total: input.length },
@@ -318,7 +335,6 @@ describe("runChunkedAction", () => {
 });
 
 describe("runPredicateAction", () => {
-	const neverCancelled = () => false;
 	const noopProgress = () => undefined;
 
 	/** Builds a paged fixture: `pages[i]` is what the i-th call returns. */
@@ -338,7 +354,7 @@ describe("runPredicateAction", () => {
 			0,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.deepEqual(outcome, { done: 0, failedIds: [], cancelled: false });
 	});
@@ -354,7 +370,7 @@ describe("runPredicateAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(deleteCalls.length, 1);
 		assert.equal(outcome.done, BULK_ACTION_CHUNK_SIZE);
@@ -374,7 +390,7 @@ describe("runPredicateAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(deleteCalls.length, 2);
 		assert.equal(outcome.done, 150);
@@ -397,7 +413,7 @@ describe("runPredicateAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.deepEqual(deleteCalls, [
 			["a", "b"],
@@ -408,7 +424,7 @@ describe("runPredicateAction", () => {
 
 	test("cancelling mid-delete stops paging without inventing failedIds for unfetched pages", async () => {
 		let fetchCalls = 0;
-		let cancelled = false;
+		const stop = new AbortController();
 		const fetch = async (): Promise<FetchIdsPageResult> => {
 			fetchCalls++;
 			return { ids: ["a", "b"], continuationToken: "more" };
@@ -417,11 +433,11 @@ describe("runPredicateAction", () => {
 			fetch,
 			1000,
 			async (chunk) => {
-				cancelled = true; // cancel takes effect on the next loop iteration
+				stop.abort(); // cancel takes effect on the next loop iteration
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			() => undefined,
-			() => cancelled,
+			stop.signal,
 		);
 		assert.equal(outcome.cancelled, true);
 		assert.equal(fetchCalls, 1);
@@ -439,7 +455,7 @@ describe("runPredicateAction", () => {
 			100,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(outcome.error, boom);
 		assert.equal(outcome.done, 0);
@@ -455,12 +471,85 @@ describe("runPredicateAction", () => {
 				throw boom;
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(outcome.error, boom);
 	});
 });
 
+// Regression for #113: a stop used to be a flag read between pages, so the
+// search or delete already on the wire ran to completion — up to a hundred
+// messages deleted after the press. The run's signal is now the call's signal.
+describe("stopping a run that has a request in flight", () => {
+	test("a bounded run reports the aborted batch as a clean stop, never an error", async () => {
+		const stop = new AbortController();
+		const calls: string[][] = [];
+		const outcome = await runChunkedAction(
+			targets(BULK_ACTION_CHUNK_SIZE * 3),
+			async (chunk, signal) => {
+				calls.push(chunk);
+				stop.abort();
+				return abortable(signal);
+			},
+			() => undefined,
+			stop.signal,
+		);
+		assert.equal(outcome.cancelled, true);
+		assert.equal(outcome.error, undefined);
+		assert.equal(calls.length, 1, "nothing further left after the stop");
+		assert.equal(outcome.done, 0);
+		// The aborted batch may or may not have been accepted server-side, so it
+		// comes back with the chunks never attempted rather than counted as done.
+		assert.equal(outcome.failedIds.length, BULK_ACTION_CHUNK_SIZE * 3);
+	});
+
+	test("a predicate run whose delete is aborted sends nothing more and reports a clean stop", async () => {
+		const stop = new AbortController();
+		let fetches = 0;
+		let deletes = 0;
+		const outcome = await runPredicateAction(
+			async () => {
+				fetches++;
+				return { ids: ["a", "b"], continuationToken: "more" };
+			},
+			1000,
+			async (_chunk, signal) => {
+				deletes++;
+				stop.abort();
+				return abortable(signal);
+			},
+			() => undefined,
+			stop.signal,
+		);
+		assert.equal(outcome.cancelled, true);
+		assert.equal(outcome.error, undefined);
+		assert.equal(deletes, 1);
+		assert.equal(fetches, 1);
+		assert.equal(outcome.done, 0);
+	});
+
+	test("a predicate run whose search page is aborted deletes nothing", async () => {
+		const stop = new AbortController();
+		let deletes = 0;
+		const outcome = await runPredicateAction(
+			async (_token, signal) => {
+				stop.abort();
+				return abortable(signal);
+			},
+			1000,
+			async (chunk) => {
+				deletes++;
+				return { successCount: chunk.length, failureCount: 0 };
+			},
+			() => undefined,
+			stop.signal,
+		);
+		assert.equal(outcome.cancelled, true);
+		assert.equal(outcome.error, undefined);
+		assert.equal(deletes, 0);
+	});
+});
+
 describe("honestProgress", () => {
 	// Regression for #109: the count and `runPredicateAction` resolve the same
 	// predicate independently, so the delete can outrun the frozen `total` it

package/src/lib/bulk-actions.ts

@@ -15,6 +15,18 @@
  * failure (auth, the write, or the enqueue) that takes out the whole batch and
  * stops the run.
  *
+ * Cancellation is an `AbortSignal` the caller owns, handed to every call the run
+ * makes (#113). Aborting ends the request in flight rather than waiting for it,
+ * so at most the batch already on the wire is at stake instead of a whole page;
+ * the run then stops before the next request leaves. A rejection raised while
+ * the signal is aborted is that abort, so it reports `cancelled` rather than an
+ * error — the user asked for it.
+ *
+ * That classification reads `signal.aborted`, deliberately, and not the shape of
+ * the rejection (`isAbortError`): a genuine failure that raced the user's Stop
+ * should read as a stop. The user pressed it and the run is over either way, and
+ * an error banner for a run they ended themselves is the wrong answer.
+ *
  * Pure, framework-agnostic, and independently testable — no React, no fetch.
  * `useEscalatedActions.ts` supplies the real `ApplyBatch`/`FetchIdsPage`
  * implementations (the generated SDK client) and owns the React state.
@@ -22,6 +34,9 @@
 
 export const BULK_ACTION_CHUNK_SIZE = 100;
 
+/** For a run with no Stop control to wire a signal to. */
+const NEVER_ABORTED = new AbortController().signal;
+
 /**
  * Resolves a promise to a discriminated result instead of throwing, so a
  * caller can branch on infrastructure failure as a value — the app's
@@ -104,7 +119,10 @@ export interface BatchResult {
 }
 
 /** Applies the action to one batch of ids (≤100) with a single bulk call. */
-export type ApplyBatch = (ids: string[]) => Promise<BatchResult>;
+export type ApplyBatch = (
+	ids: string[],
+	signal: AbortSignal,
+) => Promise<BatchResult>;
 
 export interface BulkActionProgress {
 	/** Ids the action has been applied to so far. */
@@ -122,6 +140,9 @@ export interface BulkActionOutcome {
 	 * cancellation or a thrown error, the chunks the bounded run never attempted
 	 * (see `runChunkedAction`). Empty in the predicate case, which re-resolves on
 	 * every run rather than handing back a remainder (see `runPredicateAction`).
+	 * An aborted batch is counted here too: aborting the request does not
+	 * un-send what the server already accepted, so its ids are "may not have
+	 * landed" rather than "did not", and every action here is idempotent.
 	 * There is no per-id failure source: a returned batch call counts every id in
 	 * it as accepted (see the module header).
 	 */
@@ -150,7 +171,7 @@ export const runChunkedAction = async (
 	targets: readonly BulkActionTarget[],
 	applyBatch: ApplyBatch,
 	onProgress: (progress: BulkActionProgress) => void,
-	isCancelled: () => boolean,
+	signal: AbortSignal,
 ): Promise<BulkActionOutcome> => {
 	const chunks = chunkTargets(targets);
 	const total = targets.length;
@@ -158,14 +179,15 @@ export const runChunkedAction = async (
 	const failedIds: string[] = [];
 
 	for (let i = 0; i < chunks.length; i++) {
-		if (isCancelled()) {
+		if (signal.aborted) {
 			failedIds.push(...chunks.slice(i).flat());
 			return { done, failedIds, cancelled: true };
 		}
 		const chunk = chunks[i];
-		const attempted = await attempt(applyBatch(chunk));
+		const attempted = await attempt(applyBatch(chunk, signal));
 		if (!attempted.ok) {
 			failedIds.push(...chunks.slice(i).flat());
+			if (signal.aborted) return { done, failedIds, cancelled: true };
 			onProgress({ done, total });
 			return { done, failedIds, cancelled: false, error: attempted.error };
 		}
@@ -194,6 +216,10 @@ export const runChunkedAction = async (
  * focused row, or a selection the surface already scoped — so nothing here
  * carries an account to split by. A caller with a cross-account selection
  * belongs on `runChunkedAction`, whose targets name one (#872).
+ *
+ * These callers have no Stop control to wire a signal to — a mutation over a
+ * handful of ids has no progress surface to stop from — so the run is handed a
+ * signal that never aborts.
  */
 export const runChunkedMutation = async (
 	ids: readonly string[],
@@ -206,7 +232,7 @@ export const runChunkedMutation = async (
 			return { successCount: chunk.length, failureCount: 0 };
 		},
 		() => {},
-		() => false,
+		NEVER_ABORTED,
 	);
 };
 
@@ -218,6 +244,7 @@ export interface FetchIdsPageResult {
 /** Fetches one page of matching message ids for the active predicate. */
 export type FetchIdsPage = (
 	continuationToken: string | undefined,
+	signal: AbortSignal,
 ) => Promise<FetchIdsPageResult>;
 
 /**
@@ -230,33 +257,36 @@ export type FetchIdsPage = (
  * `failedIds` for the unreached remainder, because those ids were never
  * fetched — there is nothing to hand back. A predicate resolves fresh on
  * every run (D2), so resuming is re-invoking this same function with the same
- * predicate.
+ * predicate. Aborting also ends the page or batch on the wire, so the run gives
+ * up at most the one request rather than the whole page it was mid-way through.
  */
 export const runPredicateAction = async (
 	fetchIdsPage: FetchIdsPage,
 	total: number,
 	applyBatch: ApplyBatch,
 	onProgress: (progress: BulkActionProgress) => void,
-	isCancelled: () => boolean,
+	signal: AbortSignal,
 ): Promise<BulkActionOutcome> => {
 	let done = 0;
 	const failedIds: string[] = [];
 	let token: string | undefined;
 
 	do {
-		if (isCancelled()) {
+		if (signal.aborted) {
 			return { done, failedIds, cancelled: true };
 		}
 
-		const fetched = await attempt(fetchIdsPage(token));
+		const fetched = await attempt(fetchIdsPage(token, signal));
 		if (!fetched.ok) {
+			if (signal.aborted) return { done, failedIds, cancelled: true };
 			return { done, failedIds, cancelled: false, error: fetched.error };
 		}
 		const page = fetched.value;
 
 		if (page.ids.length > 0) {
-			const attempted = await attempt(applyBatch(page.ids));
+			const attempted = await attempt(applyBatch(page.ids, signal));
 			if (!attempted.ok) {
+				if (signal.aborted) return { done, failedIds, cancelled: true };
 				return { done, failedIds, cancelled: false, error: attempted.error };
 			}
 			done += page.ids.length;