@remit/web-client 0.0.239 → 0.0.241

package/src/components/settings/QuarantinePanel.tsx

@@ -6,7 +6,10 @@
  * visible: the list, the reassurance that there is nothing in it, and the
  * failure to read it at all. None of them is an empty panel.
  */
-import { meOperationsListQuarantineOptions } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import {
+	configOperationsGetConfigOptions,
+	meOperationsListQuarantineOptions,
+} from "@remit/api-http-client/@tanstack/react-query.gen.ts";
 import type { RemitImapQuarantineResponse } from "@remit/api-http-client/types.gen.ts";
 import {
 	Button,
@@ -20,9 +23,10 @@ import { useQuery } from "@tanstack/react-query";
 import { Bug } from "lucide-react";
 import { useMemo, useState } from "react";
 import { formatErrorMessage } from "@/components/ui/ErrorState";
-import { useAccountDelimiters } from "@/hooks/useAccountDelimiters";
+import { useResultFolderIndex } from "@/hooks/useResultFolderIndex";
 import { buildBugReportContext, buildGitHubIssueUrl } from "@/lib/bug-report";
 import { toQuarantineEntry } from "@/lib/quarantine-entries";
+import type { ResultFolderIndex } from "@/lib/result-folder";
 
 /** Stable identity, so an empty list does not rebuild the memos below. */
 const EMPTY_WIRE_ENTRIES: readonly RemitImapQuarantineResponse[] = [];
@@ -126,30 +130,49 @@ export function QuarantinePanelView({
 	);
 }
 
+/**
+ * A row names the folder it came from by the leaf of its path, which cannot be
+ * cut until that account's own delimiter has arrived. A mailbox the account no
+ * longer lists never gets one, and keeps its whole path — `folderLeaf` on an
+ * empty delimiter is the path itself.
+ */
+function delimiterForMailbox(
+	folders: ResultFolderIndex,
+	mailboxId: string,
+): string {
+	return folders.get(mailboxId)?.hierarchyDelimiter ?? "";
+}
+
+/**
+ * The folder names come from the account's mailbox lists, which are a second
+ * read — started alongside the quarantine list, never behind it. Until both have
+ * landed the pane says it is still reading, because a path cut on a delimiter
+ * that has not arrived is a wrong folder name rather than a late one, and a
+ * failure on either read is reported rather than papered over with a guess.
+ */
 export function QuarantinePanel() {
-	const { data, isPending, error } = useQuery(
-		meOperationsListQuarantineOptions(),
-	);
+	const quarantine = useQuery(meOperationsListQuarantineOptions());
+	const config = useQuery(configOperationsGetConfigOptions());
+	const accounts = useMemo(() => config.data?.accounts ?? [], [config.data]);
+	const folders = useResultFolderIndex(accounts);
 
-	const wireEntries = data?.entries ?? EMPTY_WIRE_ENTRIES;
-	const accountIds = useMemo(
-		() => [...new Set(wireEntries.map((entry) => entry.accountId))],
-		[wireEntries],
-	);
-	const delimiters = useAccountDelimiters(accountIds);
+	const wireEntries = quarantine.data?.entries ?? EMPTY_WIRE_ENTRIES;
 	const entries = useMemo(
 		() =>
 			wireEntries.map((entry) =>
-				toQuarantineEntry(entry, delimiters.get(entry.accountId) ?? "/"),
+				toQuarantineEntry(
+					entry,
+					delimiterForMailbox(folders.index, entry.mailboxId),
+				),
 			),
-		[wireEntries, delimiters],
+		[wireEntries, folders.index],
 	);
 
 	return (
 		<QuarantinePanelView
 			entries={entries}
-			isPending={isPending}
-			error={error}
+			isPending={quarantine.isPending || config.isPending || folders.isPending}
+			error={quarantine.error ?? config.error ?? folders.error}
 		/>
 	);
 }

package/src/components/ui/folder-role-refusal.test.ts

@@ -1,19 +1,26 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
+import { wrapHttpFailure } from "@/lib/api";
 import {
 	isFolderRoleRefusal,
 	isMailboxNotSettledRefusal,
 } from "./folder-role-refusal.js";
 
-const refusal = {
+const wireBody = {
 	code: "folder_role_unresolved",
 	message: "No folder is appointed as Trash",
 	details: { role: "Trash", reason: "none", accountId: "acct-1" },
 };
 
+// Every call site takes the error interceptor, so what reaches these readers is
+// always the `ApiError` `wrapHttpFailure` builds — never the flat wire body it
+// carries at `.body` (#1004).
+const refused = (body: Record<string, unknown> = wireBody) =>
+	wrapHttpFailure(body, 409);
+
 describe("isFolderRoleRefusal", () => {
 	it("carries the account and the reason the prompt needs", () => {
-		assert.deepEqual(isFolderRoleRefusal(refusal), {
+		assert.deepEqual(isFolderRoleRefusal(refused()), {
 			reason: "none",
 			role: "Trash",
 			accountId: "acct-1",
@@ -23,10 +30,9 @@ describe("isFolderRoleRefusal", () => {
 	it("reads every reason the API declares", () => {
 		for (const reason of ["none", "stale", "unconfirmed"]) {
 			assert.equal(
-				isFolderRoleRefusal({
-					...refusal,
-					details: { ...refusal.details, reason },
-				})?.reason,
+				isFolderRoleRefusal(
+					refused({ ...wireBody, details: { ...wireBody.details, reason } }),
+				)?.reason,
 				reason,
 			);
 		}
@@ -34,14 +40,18 @@ describe("isFolderRoleRefusal", () => {
 
 	it("does not open the prompt for a 409 without the code", () => {
 		assert.equal(
-			isFolderRoleRefusal({
-				message: "No folder is appointed as Trash",
-				details: refusal.details,
-			}),
+			isFolderRoleRefusal(
+				refused({
+					message: "No folder is appointed as Trash",
+					details: wireBody.details,
+				}),
+			),
 			undefined,
 		);
 		assert.equal(
-			isFolderRoleRefusal({ ...refusal, code: "mailbox_not_settled" }),
+			isFolderRoleRefusal(
+				refused({ ...wireBody, code: "mailbox_not_settled" }),
+			),
 			undefined,
 		);
 	});
@@ -51,22 +61,32 @@ describe("isFolderRoleRefusal", () => {
 			isFolderRoleRefusal(new Error("folder_role_unresolved: Trash")),
 			undefined,
 		);
+		assert.equal(
+			isFolderRoleRefusal(
+				wrapHttpFailure({ message: "folder_role_unresolved" }, 409),
+			),
+			undefined,
+		);
 	});
 
 	it("refuses a body missing anything the prompt has to have", () => {
-		assert.equal(isFolderRoleRefusal({ ...refusal, details: {} }), undefined);
 		assert.equal(
-			isFolderRoleRefusal({
-				...refusal,
-				details: { role: "Trash", reason: "sideways", accountId: "acct-1" },
-			}),
+			isFolderRoleRefusal(refused({ ...wireBody, details: {} })),
+			undefined,
+		);
+		assert.equal(
+			isFolderRoleRefusal(
+				refused({
+					...wireBody,
+					details: { role: "Trash", reason: "sideways", accountId: "acct-1" },
+				}),
+			),
 			undefined,
 		);
 		assert.equal(
-			isFolderRoleRefusal({
-				...refusal,
-				details: { role: "Trash", reason: "none" },
-			}),
+			isFolderRoleRefusal(
+				refused({ ...wireBody, details: { role: "Trash", reason: "none" } }),
+			),
 			undefined,
 		);
 	});
@@ -75,20 +95,30 @@ describe("isFolderRoleRefusal", () => {
 		for (const value of [undefined, null, "boom", 409, []]) {
 			assert.equal(isFolderRoleRefusal(value), undefined);
 		}
+		assert.equal(
+			isFolderRoleRefusal(wrapHttpFailure(undefined, 500)),
+			undefined,
+		);
+	});
+
+	it("still reads a bare wire body", () => {
+		assert.equal(isFolderRoleRefusal(wireBody)?.accountId, "acct-1");
 	});
 });
 
 describe("isMailboxNotSettledRefusal", () => {
 	it("matches only the appointment write's own refusal", () => {
 		assert.equal(
-			isMailboxNotSettledRefusal({
-				code: "mailbox_not_settled",
-				message: "Mailbox is still being created",
-				details: { mailboxId: "mbx-1", syncStatus: "pending" },
-			}),
+			isMailboxNotSettledRefusal(
+				refused({
+					code: "mailbox_not_settled",
+					message: "Mailbox is still being created",
+					details: { mailboxId: "mbx-1", syncStatus: "pending" },
+				}),
+			),
 			true,
 		);
-		assert.equal(isMailboxNotSettledRefusal(refusal), false);
+		assert.equal(isMailboxNotSettledRefusal(refused()), false);
 		assert.equal(isMailboxNotSettledRefusal(new Error("pending")), false);
 	});
 });

package/src/components/ui/folder-role-refusal.ts

@@ -5,11 +5,9 @@
  * appointment prompt over an unrelated conflict. A 409 without one of these
  * codes is somebody else's error and keeps today's banner.
  */
-import type {
-	ApiError,
-	RemitImapCanonicalMailboxRole,
-} from "@remit/api-http-client/types.gen.ts";
+import type { RemitImapCanonicalMailboxRole } from "@remit/api-http-client/types.gen.ts";
 import { CanonicalMailboxRole } from "@remit/domain-enums";
+import { type CodedApiErrorBody, codedApiErrorBody } from "@/lib/api";
 
 /** Why the role is unresolved, as the API's `details.reason` spells it. */
 export type FolderRoleRefusalReason = "none" | "stale" | "unconfirmed";
@@ -29,18 +27,8 @@ const REASONS: ReadonlySet<string> = new Set<FolderRoleRefusalReason>([
 
 const ROLES: ReadonlySet<string> = new Set(Object.values(CanonicalMailboxRole));
 
-/**
- * The wire body as `handleError` emits it — flat, so `code` and `details` sit
- * at the top level. Everything is re-checked at runtime: this is a network
- * boundary, and the type only says what the contract promises.
- */
-const bodyOf = (error: unknown): Partial<ApiError> | undefined =>
-	typeof error === "object" && error !== null
-		? (error as Partial<ApiError>)
-		: undefined;
-
 const stringAt = (
-	details: ApiError["details"],
+	details: CodedApiErrorBody["details"],
 	key: string,
 ): string | undefined => {
 	const value = details?.[key];
@@ -55,10 +43,10 @@ const stringAt = (
 export const isFolderRoleRefusal = (
 	error: unknown,
 ): FolderRoleRefusal | undefined => {
-	const body = bodyOf(error);
+	const body = codedApiErrorBody(error);
 	if (body?.code !== "folder_role_unresolved") return undefined;
 	const { details } = body;
-	if (typeof details !== "object" || details === null) return undefined;
+	if (!details) return undefined;
 	const reason = stringAt(details, "reason");
 	const role = stringAt(details, "role");
 	const accountId = stringAt(details, "accountId");
@@ -78,4 +66,4 @@ export const isFolderRoleRefusal = (
  * one, retrying does not.
  */
 export const isMailboxNotSettledRefusal = (error: unknown): boolean =>
-	bodyOf(error)?.code === "mailbox_not_settled";
+	codedApiErrorBody(error)?.code === "mailbox_not_settled";

package/src/components/ui/placement-refusal.test.ts

@@ -1,15 +1,23 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
+import { wrapHttpFailure } from "@/lib/api";
 import {
 	isPlacementRefusal,
 	placementRefusalBanner,
 } from "./placement-refusal.js";
 
-const refusal = (reason: string) => ({
-	message: "Message 4f1 was not acted on: its folder and uid do not name...",
-	code: "message_placement_unsettled",
-	details: { accountId: "acc-1", messageId: "msg-1", reason },
-});
+// The reader is handed what the error interceptor produces, not the flat wire
+// body it carries at `.body` (#1004).
+const refusal = (reason: string) =>
+	wrapHttpFailure(
+		{
+			message:
+				"Message 4f1 was not acted on: its folder and uid do not name...",
+			code: "message_placement_unsettled",
+			details: { accountId: "acc-1", messageId: "msg-1", reason },
+		},
+		409,
+	);
 
 describe("isPlacementRefusal", () => {
 	it("reads the reason and the message off the coded body", () => {
@@ -23,7 +31,7 @@ describe("isPlacementRefusal", () => {
 		assert.equal(isPlacementRefusal(undefined), undefined);
 		assert.equal(isPlacementRefusal(new Error("network")), undefined);
 		assert.equal(
-			isPlacementRefusal({ ...refusal("in_flight"), code: "other" }),
+			isPlacementRefusal(wrapHttpFailure({ code: "other" }, 409)),
 			undefined,
 		);
 		assert.equal(isPlacementRefusal(refusal("something_else")), undefined);

package/src/components/ui/placement-refusal.ts

@@ -4,8 +4,8 @@
  * server's sentence names a uuid and no remedy, and a message-string match
  * would start firing on an unrelated conflict the moment the copy changes.
  */
-import type { ApiError } from "@remit/api-http-client/types.gen.ts";
 import type { PushErrorInput } from "@/components/ui/error-banners";
+import { type CodedApiErrorBody, codedApiErrorBody } from "@/lib/api";
 
 /**
  * `in_flight` clears on its own once the mail server confirms the move;
@@ -25,7 +25,7 @@ const REASONS: ReadonlySet<string> = new Set<PlacementRefusalReason>([
 ]);
 
 const stringAt = (
-	details: ApiError["details"],
+	details: CodedApiErrorBody["details"],
 	key: string,
 ): string | undefined => {
 	const value = details?.[key];
@@ -35,11 +35,10 @@ const stringAt = (
 export const isPlacementRefusal = (
 	error: unknown,
 ): PlacementRefusal | undefined => {
-	if (typeof error !== "object" || error === null) return undefined;
-	const body = error as Partial<ApiError>;
-	if (body.code !== "message_placement_unsettled") return undefined;
+	const body = codedApiErrorBody(error);
+	if (body?.code !== "message_placement_unsettled") return undefined;
 	const { details } = body;
-	if (typeof details !== "object" || details === null) return undefined;
+	if (!details) return undefined;
 	const reason = stringAt(details, "reason");
 	const messageId = stringAt(details, "messageId");
 	if (!reason || !REASONS.has(reason) || !messageId) return undefined;

package/src/hooks/refusal-escalation.render.test.ts

@@ -0,0 +1,187 @@
+/**
+ * A coded 409 must reach the surface that answers it and nothing else (#1004).
+ *
+ * Both delete paths raise through `useMutation`, and the app wires the global
+ * fail-fast sink on the `MutationCache` (`shell/index.tsx`), where a 409 with
+ * no `meta` escalates to the full-screen fatal overlay. The prompt then opens
+ * underneath a red page nobody can see past — the refusal is handled and still
+ * never reaches the user. Every other test mounts on the harness's plain
+ * `QueryClient`, which has no such sink, so none of them can see this.
+ *
+ * Mounted here on the client the app actually builds, with the error
+ * interceptor registered.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import {
+	MutationCache,
+	QueryCache,
+	QueryClient,
+	QueryClientProvider,
+} from "@tanstack/react-query";
+import { act, createElement } from "react";
+import { RoleAppointmentPromptProvider } from "@/components/mail/RoleAppointmentPromptProvider";
+import { ErrorBannerProvider } from "@/components/ui/ErrorBannerProvider";
+import { __resetFatalError, getCurrentFatalError } from "@/lib/fatal-error";
+import {
+	handleMutationCacheError,
+	handleQueryCacheError,
+} from "@/lib/query-error-handler";
+import { createDomHarness, type DomHarness } from "../test-support/dom";
+import { type HttpMock, mockFetch } from "../test-support/http";
+import { useDeleteMessages } from "./useDeleteMessages";
+import { type EmptyTrashState, useEmptyTrash } from "./useEmptyTrash";
+import "@/lib/client";
+
+const ACCOUNT = "acc-1";
+const INBOX = "mbx-inbox";
+const TRASH = "mbx-trash";
+
+let harness: DomHarness | undefined;
+let http: HttpMock | undefined;
+let deleteMessages: ((messageIds: string[]) => void) | undefined;
+let trash: EmptyTrashState | undefined;
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http?.restore();
+	http = undefined;
+	deleteMessages = undefined;
+	trash = undefined;
+	__resetFatalError();
+});
+
+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 broken = (): Response =>
+	new Response(JSON.stringify({ message: "boom" }), {
+		status: 500,
+		headers: { "content-type": "application/json" },
+	});
+
+const Probe = () => {
+	deleteMessages = useDeleteMessages({
+		mailboxId: INBOX,
+		accountId: ACCOUNT,
+	}).deleteMessages;
+	trash = useEmptyTrash({ accountId: ACCOUNT, mailboxId: TRASH });
+	return null;
+};
+
+/** The client `shell/index.tsx` builds: the real global escalation sink. */
+const appQueryClient = (): QueryClient =>
+	new QueryClient({
+		queryCache: new QueryCache({ onError: handleQueryCacheError }),
+		mutationCache: new MutationCache({ onError: handleMutationCacheError }),
+		defaultOptions: {
+			queries: { retry: false },
+			mutations: { retry: false },
+		},
+	});
+
+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({ queryClient: appQueryClient() });
+	await harness.renderAsync(
+		createElement(
+			QueryClientProvider,
+			{ client: harness.queryClient as never },
+			createElement(
+				ErrorBannerProvider,
+				null,
+				createElement(
+					RoleAppointmentPromptProvider,
+					null,
+					createElement(Probe),
+				),
+			),
+		),
+	);
+	await settle();
+};
+
+const responder =
+	(endpoint: string, answer: () => Response) =>
+	(path: string): unknown => {
+		if (path.endsWith("/config")) return CONFIG;
+		if (path.endsWith(endpoint)) return answer();
+		return {};
+	};
+
+describe("a delete refused for its folder role", () => {
+	it("opens the appointment prompt without taking the screen", async () => {
+		await mount(responder("/messages/delete", refusal));
+
+		await act(async () => {
+			deleteMessages?.(["msg-1"]);
+		});
+		await settle();
+
+		assert.match(harness?.text() ?? "", /Confirm this account's Trash folder/);
+		assert.equal(
+			getCurrentFatalError(),
+			null,
+			"a refusal the prompt answers is not a fatal error",
+		);
+	});
+
+	it("still escalates a 500 on the same delete", async () => {
+		await mount(responder("/messages/delete", broken));
+
+		await act(async () => {
+			deleteMessages?.(["msg-1"]);
+		});
+		await settle();
+
+		assert.ok(
+			getCurrentFatalError(),
+			"the 409 opt-out must not cover anything else",
+		);
+	});
+});
+
+describe("an empty Trash refused for its folder role", () => {
+	it("states the refusal in the pane without taking the screen", async () => {
+		await mount(responder("/trash/empty", refusal));
+
+		await act(async () => {
+			trash?.emptyTrash();
+		});
+		await settle();
+
+		assert.equal(trash?.refusal?.reason, "unconfirmed");
+		assert.equal(getCurrentFatalError(), null);
+	});
+});

package/src/hooks/use-system-update.test.ts

@@ -558,6 +558,110 @@ describe("useSystemUpdate — actions", () => {
 		}
 	});
 
+	test("checking from the success row reaches the pane, not a dead button (#1015)", async () => {
+		// An undismissed run outcome wins over any check in flight, so a press
+		// made while the success banner holds the pane would leave the screen
+		// exactly as it was. The row's control retires the outcome first.
+		const succeeded = {
+			currentVersion: "0.9.4",
+			check: { status: "ok", updateAvailable: false },
+			run: run({ outcome: "succeeded" }),
+		};
+		const { dom } = mountApi(() => succeeded, createElement(SelfUpdatePanel));
+		await settle(dom);
+		assert.match(dom.html(), /Updated to Remit 0\.9\.4/);
+
+		dom.click(dom.byText("button", "Check for updates"));
+		await waitFor(
+			dom,
+			() => /Looking for a newer version/.test(dom.html()),
+			"the pressed check to reach the pane",
+		);
+		assert.doesNotMatch(dom.html(), /Updated to Remit/);
+	});
+
+	test("a check pressed from the success row fails in the open, not behind the banner (#1015)", async () => {
+		const succeeded = {
+			currentVersion: "0.9.4",
+			check: { status: "ok", updateAvailable: false },
+			run: run({ outcome: "succeeded" }),
+		};
+		const { dom } = mountApi(() => succeeded, createElement(SelfUpdatePanel));
+		await settle(dom);
+
+		const control = dom.byText("button", "Check for updates");
+		const realNow = Date.now;
+		try {
+			await act(async () => {
+				// Dispatched inside this `act` rather than through `dom.click`, so
+				// the press is stamped off the real clock and the wait it arms is
+				// measured against one already past the budget.
+				control.dispatchEvent(
+					new MouseEvent("click", { bubbles: true, cancelable: true }),
+				);
+				Date.now = () => realNow() + CHECK_ANSWER_BUDGET_MS + 1_000;
+				await dom.flush();
+			});
+			await dom.wait(5);
+			await dom.flush();
+
+			assert.match(dom.html(), /The updater did not answer/);
+			assert.doesNotMatch(dom.html(), /Updated to Remit/);
+		} finally {
+			Date.now = realNow;
+		}
+	});
+
+	test("dismissing an outcome does not uncover the check verdict it hid", async () => {
+		// The failure belongs to a press made before the run, on a pane the user
+		// has not been able to see since. Serving it as the current verdict claims
+		// a check failed that may well have succeeded.
+		let response: unknown = available;
+		const { dom, api } = mountApi(
+			() => response,
+			createElement(SelfUpdatePanel),
+		);
+		await settle(dom);
+
+		const realNow = Date.now;
+		try {
+			await act(async () => {
+				api().onCheck();
+				Date.now = () => realNow() + CHECK_ANSWER_BUDGET_MS + 1_000;
+				await dom.flush();
+			});
+			await dom.wait(5);
+			await dom.flush();
+			assert.match(dom.html(), /The updater did not answer/);
+		} finally {
+			Date.now = realNow;
+		}
+
+		response = {
+			currentVersion: "0.9.4",
+			check: { status: "ok", updateAvailable: false },
+			run: run({ outcome: "succeeded" }),
+		};
+		await retryConnection(dom, api);
+		await waitFor(
+			dom,
+			() => /Updated to Remit 0\.9\.4/.test(dom.html()),
+			"the finished run to reach the pane",
+		);
+
+		await act(async () => {
+			api().onDismissResult();
+			await dom.flush();
+		});
+		await waitFor(
+			dom,
+			() => !/Updated to Remit/.test(dom.html()),
+			"the outcome to be retired",
+		);
+		assert.doesNotMatch(dom.html(), /The updater did not answer/);
+		assert.match(dom.html(), /0\.9\.4 is the latest version/);
+	});
+
 	test("a refused refresh is shown, never swallowed back into the old verdict (#599)", async () => {
 		let refused = false;
 		const { dom, api } = mountApi(

package/src/hooks/use-system-update.ts

@@ -249,6 +249,12 @@ export function useSystemUpdate(): SelfUpdateApi {
 		if (shownRunIdRef.current !== null)
 			setDismissedRunId(shownRunIdRef.current);
 		setHeld(null);
+		// Retiring the outcome uncovers the check verdict beneath it. A failure
+		// recorded while the outcome held the pane describes a press the user can
+		// no longer see, and an update run of its own supersedes anything an
+		// earlier check concluded — either way it must not resurface here.
+		setCheckPress(null);
+		setCheckFailure(null);
 	}, []);
 
 	return {

package/src/hooks/useDeleteMessages.ts

@@ -16,6 +16,7 @@ import {
 } from "@/components/ui/placement-refusal";
 import { resolveMailboxesForMessages } from "@/hooks/useMarkAsRead";
 import { runChunkedMutation } from "@/lib/bulk-actions";
+import { softErrorStatuses } from "@/lib/error-classifier";
 import {
 	cancelThreadListQueries,
 	invalidateThreadListQueries,
@@ -92,6 +93,10 @@ export const useDeleteMessages = ({
 
 	const { mutateAsync, isPending } = useMutation({
 		...messageBulkOperationsDeleteMessagesMutation(),
+		// A coded 409 is answered here — the prompt, or a banner — so it must not
+		// also take the whole screen. Only 409: a 401, 403 or 5xx on a delete is
+		// still the fatal page's (#1059).
+		meta: softErrorStatuses(409),
 		onMutate: async (variables): Promise<ThreadMutationContext> => {
 			const messageIds = new Set(variables.body.messageIds ?? []);