@remit/web-client 0.0.214 → 0.0.216

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

@@ -0,0 +1,156 @@
+/**
+ * A select-all delete refused for its folder role is answered by the
+ * appointment prompt, not by a banner (#876).
+ *
+ * The escalated path had no branch for the coded 409, so the refusal arrived as
+ * the API's own sentence — "Appoint one under Settings › Folder roles" — under a
+ * "Couldn't delete these messages" banner. That asks a user who has just
+ * selected three thousand messages to go to another screen and rebuild the
+ * selection, which is the outcome the prompt exists to remove; the single-row
+ * path has answered it in place since #887.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { act, createElement } from "react";
+import { RoleAppointmentPromptProvider } from "@/components/mail/RoleAppointmentPromptProvider";
+import { ErrorBannerProvider } from "@/components/ui/ErrorBannerProvider";
+import { createDomHarness, type DomHarness } from "../test-support/dom";
+import { type HttpMock, mockFetch } from "../test-support/http";
+import {
+	type UseEscalatedActionsResult,
+	useEscalatedActions,
+} from "./useEscalatedActions";
+
+const INBOX = "mbx-inbox";
+const ACCOUNT = "acc-1";
+const TRASH = "mbx-trash";
+
+let harness: DomHarness | undefined;
+let http: HttpMock | undefined;
+let hook: UseEscalatedActionsResult | undefined;
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http?.restore();
+	http = undefined;
+	hook = undefined;
+});
+
+const CONFIG = {
+	accounts: [
+		{
+			accountId: ACCOUNT,
+			email: "you@example.com",
+			folderAppointments: [
+				{ role: "Trash", mailboxId: TRASH, source: "Proposed" },
+			],
+		},
+	],
+};
+
+/** Fresh every call — a `Response` body can only be read once. */
+const refusal = (): Response =>
+	new Response(
+		JSON.stringify({
+			status: 409,
+			message: "Nobody has confirmed which folder is this account's Trash",
+			code: "folder_role_unresolved",
+			details: { reason: "unconfirmed", role: "Trash", accountId: ACCOUNT },
+		}),
+		{ status: 409, headers: { "content-type": "application/json" } },
+	);
+
+const Probe = () => {
+	hook = useEscalatedActions({
+		mailboxId: INBOX,
+		accountId: ACCOUNT,
+		enabled: true,
+		predicateKey: "npm",
+		searchQuery: { query: "npm" },
+	});
+	return null;
+};
+
+const settle = async (): Promise<void> => {
+	if (!harness) throw new Error("nothing mounted");
+	for (let round = 0; round < 40; round += 1) {
+		await harness.flush();
+		await harness.wait(0);
+	}
+};
+
+const mount = async (respond: (path: string) => unknown): Promise<void> => {
+	http = mockFetch((call) => respond(call.path));
+	harness = createDomHarness();
+	await harness.renderAsync(
+		createElement(
+			QueryClientProvider,
+			{ client: harness.queryClient as never },
+			createElement(
+				ErrorBannerProvider,
+				null,
+				createElement(
+					RoleAppointmentPromptProvider,
+					null,
+					createElement(Probe),
+				),
+			),
+		),
+	);
+	await settle();
+};
+
+const runDelete = async (): Promise<void> => {
+	await act(async () => {
+		await hook?.runAction({ kind: "delete" }, [
+			{ id: "msg-1", accountId: ACCOUNT },
+		]);
+	});
+	await settle();
+};
+
+describe("a bulk delete refused for its folder role", () => {
+	it("opens the appointment prompt instead of bannering the API's sentence", async () => {
+		await mount((path) => {
+			if (path.endsWith("/config")) return CONFIG;
+			if (path.endsWith("/messages/delete")) return refusal();
+			return {};
+		});
+
+		await runDelete();
+
+		const text = harness?.text() ?? "";
+		assert.match(text, /Confirm this account's Trash folder/);
+		assert.doesNotMatch(text, /Couldn't delete these messages/);
+		assert.doesNotMatch(
+			text,
+			/Settings › Folder roles/,
+			"the raw API sentence is what the prompt replaces",
+		);
+	});
+
+	it("keeps today's banner for a 409 that is somebody else's", async () => {
+		await mount((path) => {
+			if (path.endsWith("/config")) return CONFIG;
+			if (path.endsWith("/messages/delete"))
+				return new Response(
+					JSON.stringify({
+						status: 409,
+						message: "boom",
+						code: "mailbox_not_settled",
+					}),
+					{ status: 409, headers: { "content-type": "application/json" } },
+				);
+			return {};
+		});
+
+		await runDelete();
+
+		const text = harness?.text() ?? "";
+		assert.match(text, /Couldn't delete these messages/);
+		assert.doesNotMatch(text, /Confirm this account's Trash folder/);
+	});
+});

package/src/hooks/useDeleteOutcome.ts

@@ -11,9 +11,9 @@
  * from several mailboxes and several accounts at once.
  *
  * The decision itself is `deleteOutcomeFor`, kept pure in `lib/format`; this is
- * only the read that feeds it. The two facts beside it are what the copy needs
- * to name a folder: whether the Trash it resolved is a name match nobody
- * confirmed (D4a), and the folder a stale appointment lost.
+ * only the read that feeds it. The two facts beside it are the folders the
+ * refusal has to name: the one a stale appointment lost, and the one reader
+ * guessed and is asking the user to confirm.
  */
 import { useMemo } from "react";
 import {
@@ -25,10 +25,14 @@ import { useTrashByAccount } from "./useArchiveMailbox";
 
 export interface DeleteOutcomeResult {
 	outcome: DeleteOutcome;
-	/** The Trash these rows resolve to was matched by name, never confirmed. */
-	trashIsUnconfirmed: boolean;
 	/** The folder the user appointed, when it is gone from the mail server. */
 	staleFolderLabel?: string;
+	/**
+	 * `unconfirmed`: the folder reader matched by name, which the rows are
+	 * already inside. The prompt opens with it chosen, so confirming the guess is
+	 * one tap.
+	 */
+	guessedMailboxId?: string;
 }
 
 /** The outcome of deleting `targets`. */
@@ -48,18 +52,19 @@ export const useDeleteOutcome = (
 			target.accountId ? trashByAccount.get(target.accountId) : undefined;
 		return {
 			outcome,
-			// Only the rows the delete would actually expunge — a row filed
-			// somewhere else says nothing about the folder it is moving into.
-			trashIsUnconfirmed: targets.some((target) => {
-				const trash = trashFor(target);
-				return (
-					trash?.source === "Proposed" && trash.mailboxId === target.mailboxId
-				);
-			}),
 			// The account `deleteOutcomeFor` refused on, found the way it found it.
 			staleFolderLabel: targets
 				.map(trashFor)
 				.find((trash) => trash?.source === "Stale")?.staleFolderPath,
+			// The folder that produced `unconfirmed`: a row's own mailbox, which is
+			// also its account's guessed Trash. Only that row says which folder is
+			// being asked about — a row filed elsewhere is moving, not expunging.
+			guessedMailboxId:
+				outcome === "unconfirmed"
+					? targets.find(
+							(target) => trashFor(target)?.mailboxId === target.mailboxId,
+						)?.mailboxId
+					: undefined,
 		};
 	}, [targets, trashByAccount, hasAppointments, isError]);
 };

package/src/hooks/useEscalatedActions.ts

@@ -8,8 +8,10 @@ import {
 import type { ThreadOperationsSearchThreadsData } from "@remit/api-http-client/types.gen.ts";
 import { useQueryClient } from "@tanstack/react-query";
 import { useCallback, useEffect, useRef, useState } from "react";
+import { useRoleAppointmentPrompt } from "@/components/mail/RoleAppointmentPromptProvider";
 import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
 import { buildMutationErrorBanner } from "@/components/ui/error-banners";
+import { isFolderRoleRefusal } from "@/components/ui/folder-role-refusal";
 import {
 	bulkActionFailureDetail,
 	bulkActionFailureTitle,
@@ -152,6 +154,14 @@ export const useEscalatedActions = ({
 	const runningRef = useRef(false);
 	const queryClient = useQueryClient();
 	const { pushError } = useErrorBanners();
+	const { requestAppointment } = useRoleAppointmentPrompt();
+	// The run replays itself once a folder is appointed, so it needs a handle on
+	// itself that does not make `runAction` its own dependency.
+	const runRef = useRef<UseEscalatedActionsResult["runAction"]>(async () => ({
+		done: 0,
+		failedIds: [],
+		cancelled: false,
+	}));
 
 	// A different search (or leaving search/desktop) makes any in-flight
 	// escalation meaningless — it would otherwise keep counting or offering to
@@ -298,6 +308,10 @@ export const useEscalatedActions = ({
 			cancelRef.current = false;
 			runningRef.current = true;
 			setRunningAction(action);
+			// Read before the run clears the phase below, so a refusal can say how
+			// many messages the appointment's replay is about.
+			const matched =
+				targets?.length ?? (phase.kind === "escalated" ? phase.total : 0);
 			// `honestProgress` widens `total` if `done` overtakes it (#109) — the
 			// predicate can match more by the time the run pages it than the count
 			// saw, and the bar must never show more done than out of.
@@ -337,7 +351,25 @@ export const useEscalatedActions = ({
 			setProgress(undefined);
 			setPhase({ kind: "idle" });
 
-			if (outcome.error) {
+			// A provenance refusal is answered by the appointment prompt here exactly
+			// as it is on the single-row path (#887, #876). Left to the banner it
+			// arrives as the API's own sentence — "Appoint one under Settings ›
+			// Folder roles" — which asks the user to reassemble a select-all they
+			// have already made.
+			const refusal = outcome.error
+				? isFolderRoleRefusal(outcome.error)
+				: undefined;
+			if (refusal) {
+				requestAppointment({
+					accountId: refusal.accountId,
+					role: refusal.role,
+					reason: refusal.reason,
+					action: { kind: "delete", count: matched },
+					onAppointed: async () => {
+						await runRef.current(action, targets);
+					},
+				});
+			} else if (outcome.error) {
 				pushError(
 					buildMutationErrorBanner(
 						bulkActionFailureTitle(action.kind, outcome.done),
@@ -351,8 +383,16 @@ export const useEscalatedActions = ({
 			}
 			return outcome;
 		},
-		[applyBatchFor, fetchPagesOf, phase, pushError, invalidateAfterRun],
+		[
+			applyBatchFor,
+			fetchPagesOf,
+			phase,
+			pushError,
+			invalidateAfterRun,
+			requestAppointment,
+		],
 	);
+	runRef.current = runAction;
 
 	return {
 		phase,

package/src/hooks/useTriageLayer.ts

@@ -13,6 +13,13 @@
  * It is two hooks because a pane's verbs are aimed at the focused row: the
  * context comes first, the pane builds its handlers from it, and the keyboard
  * registration comes last.
+ *
+ * While a thread is open, `ConversationView` binds its own window listener for
+ * the messages inside it, and both used to act on one press (#723). The split
+ * is the one `shortcut-tree` already declares: the cursor keys belong to
+ * whichever surface has a list on screen, and answering a thread belongs to
+ * the open thread — so `hasOpenThread` hands r, a and f over, and the list
+ * keeps j/k, Home/End and Enter for as long as it is mounted.
  */
 import { type TriageHandlers, useTriageKeyboard } from "@remit/ui";
 import { type RefObject, useCallback, useRef, useState } from "react";
@@ -83,6 +90,16 @@ interface UseTriageLayerOptions {
 	onClose: () => void;
 	/** The pane's own verbs — reply, star, delete and the rest. */
 	handlers: TriageHandlers;
+	/**
+	 * A thread is open, so `ConversationView` is mounted and answers for it.
+	 * This layer drops the three verbs aimed at a whole message — `reply`,
+	 * `replyAll` and `forward` — while that is true, so one press opens one
+	 * reply (#723) and `a` can never answer a different message than `r` just
+	 * did. The cursor keys are not in here: a mounted list keeps those at every
+	 * width, and it is the conversation that stands down from them wherever the
+	 * list is on screen beside it (`ConversationView.listOnScreen`).
+	 */
+	hasOpenThread?: boolean;
 }
 
 export interface TriageLayer {
@@ -99,6 +116,7 @@ export const useTriageLayer = ({
 	enabled = true,
 	onClose,
 	handlers,
+	hasOpenThread = false,
 }: UseTriageLayerOptions): TriageLayer => {
 	const { listCommandsRef, hasList, blocksKeyboard } = context;
 
@@ -107,6 +125,12 @@ export const useTriageLayer = ({
 		if (selectedMessageId) onClose();
 	}, [listCommandsRef, selectedMessageId, onClose]);
 
+	// Dropped rather than kept and guarded: an unregistered action is never
+	// preventDefault-ed (see useTriageKeyboard), so the keystroke falls through
+	// to ConversationView's own listener instead of two handlers racing on one
+	// keypress.
+	const { reply, replyAll, forward, ...restHandlers } = handlers;
+
 	useTriageKeyboard({
 		// A modal owns the keyboard outright. Suspending the layer is what keeps a
 		// second Delete press from reaching a delete while the confirmation for the
@@ -131,7 +155,8 @@ export const useTriageLayer = ({
 					}
 				: {}),
 			back: goBack,
-			...handlers,
+			...restHandlers,
+			...(hasOpenThread ? {} : { reply, replyAll, forward }),
 		},
 	});
 

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

@@ -1,6 +1,6 @@
 import type { ErrorBannerSeverity } from "@/components/ui/error-banners";
 import type { BulkRunOutcome } from "@/lib/bulk-actions";
-import { type DeleteOutcome, formatNumber } from "@/lib/format";
+import { type DeleteOutcome, deleteExpunges, formatNumber } from "@/lib/format";
 
 /** A run ending, as the list banners it. */
 export interface RunEndingBanner {
@@ -38,7 +38,7 @@ const pastTense: Record<BulkActionKind, string> = {
  * it does for one that finished — the half that ran is still erased.
  */
 const pastTenseFor = (kind: BulkActionKind, outcome: DeleteOutcome): string =>
-	kind === "delete" && outcome === "permanent"
+	kind === "delete" && deleteExpunges(outcome)
 		? "permanently deleted"
 		: pastTense[kind];
 

package/src/lib/format.test.ts

@@ -1,5 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import { trashSourceMeetsAssurance } from "@remit/data-ports/folder-role";
+import { FolderAppointmentSource } from "@remit/domain-enums";
 import type { DeleteTarget, TrashResolution } from "./format.js";
 import {
 	deleteConfirmationCopy,
@@ -338,33 +340,55 @@ describe("deleteOutcomeFor", () => {
 				targets: [target("mbx-inbox", "acct-1")],
 			}),
 			"trash",
-			"only Empty Trash demands a confirmed appointment (D4)",
+			"filing mail into a name guess is reversible; only an expunge needs more",
 		);
 	});
 
-	test("never answers `unconfirmed`, whatever the rows say", () => {
-		const sources: TrashResolution["source"][] = [
-			"Appointed",
-			"Flagged",
-			"Reserved",
-			"Proposed",
-			"Stale",
-			"None",
-		];
-		for (const source of sources) {
-			for (const mailboxId of ["mbx-trash", "mbx-inbox", undefined]) {
-				assert.notStrictEqual(
-					deleteOutcomeFor({
-						...settled,
-						trashByAccount: new Map<string, TrashResolution>([
-							["acct-1", { mailboxId, source }],
-						]),
-						targets: [target("mbx-inbox", "acct-1")],
-					}),
-					"unconfirmed",
-					"the targets of a delete say nothing about a whole folder",
-				);
-			}
+	test("a row already inside a Trash resolved only by name refuses as unconfirmed (#876)", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				...settled,
+				trashByAccount: new Map<string, TrashResolution>([
+					["acct-1", { mailboxId: "mbx-trash", source: "Proposed" }],
+				]),
+				targets: [target("mbx-trash", "acct-1")],
+			}),
+			"unconfirmed",
+			"deleting a row already in the name-guessed folder expunges it — the same act Empty Trash refuses on this evidence",
+		);
+	});
+
+	test("one row expunging inside an unconfirmed Trash outranks a plain expunge", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				...settled,
+				trashByAccount: new Map<string, TrashResolution>([
+					["acct-1", { mailboxId: "mbx-trash", source: "Proposed" }],
+				]),
+				targets: [target("mbx-inbox", "acct-1"), target("mbx-trash", "acct-1")],
+			}),
+			"unconfirmed",
+		);
+	});
+
+	test("words an expunge from the same evidence the service gates it on", () => {
+		// Derived from the shared gate rather than listed here: a hand-written
+		// list is how the dialog came to offer a confirm the server 409s on.
+		// `Stale` is excluded because it refuses under its own outcome first.
+		for (const source of Object.values(FolderAppointmentSource)) {
+			if (source === FolderAppointmentSource.Stale) continue;
+			const outcome = deleteOutcomeFor({
+				...settled,
+				trashByAccount: new Map<string, TrashResolution>([
+					["acct-1", { mailboxId: "mbx-trash", source }],
+				]),
+				targets: [target("mbx-trash", "acct-1")],
+			});
+			assert.strictEqual(
+				outcome === "unconfirmed",
+				!trashSourceMeetsAssurance(source, "confirmed"),
+				`${source} must ask for what the service demands before an expunge`,
+			);
 		}
 	});
 });
@@ -438,24 +462,9 @@ describe("deleteConfirmationCopy — the refusal", () => {
 		});
 	});
 
-	test("names the folder before an expunge inside a Trash nobody confirmed", () => {
-		const copy = deleteConfirmationCopy(2, "permanent", {
-			trashFolderLabel: "Deleted Messages",
-			trashIsUnconfirmed: true,
-		});
-		assert.strictEqual(copy.title, "Permanently delete 2 messages?");
-		assert.strictEqual(
-			copy.description,
-			"They are in Deleted Messages, which reader treats as this account's Trash because of its name — nobody confirmed it. They are erased from the mail server and cannot be restored.",
-		);
-		assert.strictEqual(copy.confirmLabel, "Delete permanently");
-	});
-
 	test("drops the name clause when the caller holds no folder name", () => {
-		const copy = deleteConfirmationCopy(2, "permanent", {
-			trashIsUnconfirmed: true,
-		});
-		assert.match(copy.description, /because of its name — nobody confirmed it/);
+		const copy = deleteConfirmationCopy(3, "unconfirmed");
+		assert.match(copy.description, /matched by name — nobody confirmed it/);
 		assert.ok(!copy.description.includes("undefined"));
 	});
 });

package/src/lib/format.ts

@@ -1,3 +1,8 @@
+import {
+	type FolderAppointmentSourceValue,
+	trashSourceMeetsAssurance,
+} from "@remit/data-ports/folder-role";
+
 /**
  * Get the user's preferred locale from browser settings.
  * Falls back to 'en-US' if unavailable.
@@ -178,8 +183,6 @@ export interface DeleteConfirmationContext {
 	trashFolderLabel?: string;
 	/** The folder the user appointed, now gone from the mail server. */
 	staleFolderLabel?: string;
-	/** That folder is a name match nobody ever confirmed. */
-	trashIsUnconfirmed?: boolean;
 }
 
 /**
@@ -207,10 +210,11 @@ export interface DeleteConfirmationContext {
  * single `noTrash` member cannot — this function only ever sees the member.
  *
  * `unconfirmed` is a folder reader matched by name that nobody ever confirmed.
- * Only Empty Trash refuses on it (D4); `deleteOutcomeFor` never produces it,
- * because the targets an ordinary delete is about say nothing about a whole
- * folder. The Empty Trash surface derives it from the server's own 409, and the
- * branch lives here so both surfaces word it identically.
+ * Empty Trash refuses on it for the whole folder (D4); `deleteOutcomeFor`
+ * produces it too, for the narrower case of a row that is already inside that
+ * folder — deleting it expunges on the same name guess, and the guess is never
+ * enough to destroy mail (#876). Both surfaces derive it from the server's own
+ * 409, and the branch lives here so they word it identically.
  */
 export type DeleteOutcome =
 	| "trash"
@@ -222,13 +226,7 @@ export type DeleteOutcome =
 	| "unavailable";
 
 /** Where an account's Trash answer came from (`FolderAppointmentSource`). */
-export type TrashSource =
-	| "Appointed"
-	| "Flagged"
-	| "Reserved"
-	| "Proposed"
-	| "Stale"
-	| "None";
+export type TrashSource = FolderAppointmentSourceValue;
 
 /** One account's Trash, as `/config` resolved it. */
 export interface TrashResolution {
@@ -268,8 +266,10 @@ export interface DeleteOutcomeInput {
  * One row bound for an expunge makes the whole delete unrecoverable, so a mixed
  * set is permanent: the wording may overstate what is destroyed, never what is
  * kept. One row on an account with no Trash refuses the whole call, so that
- * outranks both. Pure, so every branch — the failure ones above all — is
- * testable without a DOM.
+ * outranks both. An expunge on a Trash nobody confirmed outranks a plain
+ * expunge in turn — the server refuses it (#876), so the dialog asks for the
+ * same confirmation up front rather than offering a confirm that 409s. Pure,
+ * so every branch — the failure ones above all — is testable without a DOM.
  */
 export const deleteOutcomeFor = ({
 	targets,
@@ -282,17 +282,33 @@ export const deleteOutcomeFor = ({
 	if (targets.length === 0) return "unknown";
 
 	let expunges = false;
+	let expungesUnconfirmed = false;
 	for (const target of targets) {
 		if (target.accountId === undefined) return "unknown";
 		const trash = trashByAccount.get(target.accountId);
 		if (trash === undefined) return "unknown";
 		if (trash.source === "Stale") return "staleTrash";
 		if (trash.mailboxId === undefined) return "noTrash";
-		if (trash.mailboxId === target.mailboxId) expunges = true;
+		if (trash.mailboxId === target.mailboxId) {
+			expunges = true;
+			if (!trashSourceMeetsAssurance(trash.source, "confirmed"))
+				expungesUnconfirmed = true;
+		}
 	}
+	if (expungesUnconfirmed) return "unconfirmed";
 	return expunges ? "permanent" : "trash";
 };
 
+/**
+ * The delete erases mail rather than filing it. Both outcomes a row already
+ * inside Trash produces say so — `unconfirmed` is only ever reached that way
+ * (#876) — and anything that reports what a delete did reads this rather than
+ * testing for `permanent`, which is how a run of expunged mail came to be
+ * announced as "moved to Trash".
+ */
+export const deleteExpunges = (outcome: DeleteOutcome): boolean =>
+	outcome === "permanent" || outcome === "unconfirmed";
+
 /**
  * The confirmation for a delete, worded for what the delete actually does.
  * Deleting mail that already sits in Trash expunges it on the server and
@@ -315,7 +331,7 @@ export const deleteConfirmationCopy = (
 ): DeleteConfirmationCopy => {
 	const quantity = count === 1 ? "1" : formatNumber(count);
 	const noun = count === 1 ? "message" : "messages";
-	const { trashFolderLabel, staleFolderLabel, trashIsUnconfirmed } = context;
+	const { trashFolderLabel, staleFolderLabel } = context;
 
 	if (outcome === "noTrash") {
 		return {
@@ -335,11 +351,18 @@ export const deleteConfirmationCopy = (
 		};
 	}
 	if (outcome === "unconfirmed") {
+		const folderClause = trashFolderLabel
+			? `reader files this account's deleted mail in ${trashFolderLabel} because of its name — nobody confirmed it.`
+			: "reader files this account's deleted mail in a folder it matched by name — nobody confirmed it.";
+		// count === 0: Empty Trash, acting on everything the folder holds. A
+		// positive count: a delete whose rows already sit in that folder, so
+		// this expunges them specifically, not the folder's whole contents.
 		return {
 			title: "Confirm this account's Trash folder",
-			description: trashFolderLabel
-				? `reader files this account's deleted mail in ${trashFolderLabel} because of its name — nobody confirmed it. Emptying a folder erases everything in it from the mail server, and that cannot be restored. Nothing has been emptied.`
-				: "reader files this account's deleted mail in a folder it matched by name — nobody confirmed it. Emptying a folder erases everything in it from the mail server, and that cannot be restored. Nothing has been emptied.",
+			description:
+				count > 0
+					? `${folderClause} Deleting ${quantity} ${noun} there erases them from the mail server, and that cannot be restored. Nothing has been deleted.`
+					: `${folderClause} Emptying a folder erases everything in it from the mail server, and that cannot be restored. Nothing has been emptied.`,
 			confirmLabel: "Confirm the folder",
 		};
 	}
@@ -359,18 +382,6 @@ export const deleteConfirmationCopy = (
 		};
 	}
 	if (outcome === "permanent") {
-		// D4a: the expunge still goes through on a Trash nobody confirmed — the
-		// user asked for these specific rows — but they are told which folder
-		// reader treats as Trash, and that nobody chose it, before it happens.
-		if (trashIsUnconfirmed) {
-			return {
-				title: `Permanently delete ${quantity} ${noun}?`,
-				description: trashFolderLabel
-					? `They are in ${trashFolderLabel}, which reader treats as this account's Trash because of its name — nobody confirmed it. They are erased from the mail server and cannot be restored.`
-					: "They are in a folder reader treats as this account's Trash because of its name — nobody confirmed it. They are erased from the mail server and cannot be restored.",
-				confirmLabel: "Delete permanently",
-			};
-		}
 		return {
 			title: `Permanently delete ${quantity} ${noun}?`,
 			description: