@remit/mailbox-service 0.0.91 → 0.0.93

package/src/mailbox-rename-intent.test.ts

@@ -0,0 +1,143 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { IMailboxRepository, MailboxItem } from "@remit/data-ports";
+import { MailboxSyncStatus } from "@remit/domain-enums";
+import { MailboxQueueService } from "./mailbox-queue.js";
+
+const row = (mailboxId: string, fullPath: string): MailboxItem =>
+	({
+		mailboxId,
+		accountId: "acc-1",
+		fullPath,
+		hierarchyDelimiter: "/",
+		syncStatus: MailboxSyncStatus.synced,
+	}) as MailboxItem;
+
+/**
+ * A repository that resolves the subtree and applies `rowSet` the way the real
+ * one does, so the paths the intent records are the paths under test.
+ */
+const store = (rows: MailboxItem[]) => {
+	const byId = new Map(rows.map((r) => [r.mailboxId, { ...r }]));
+
+	const repo: Pick<IMailboxRepository, "get" | "transitionSubtree"> = {
+		get: (async (_accountId: string, mailboxId: string) => {
+			const found = byId.get(mailboxId as string);
+			if (!found) {
+				throw Object.assign(new Error(`Mailbox not found: ${mailboxId}`), {
+					name: "NotFoundError",
+				});
+			}
+			return found;
+		}) as IMailboxRepository["get"],
+		transitionSubtree: async (_accountId, mailboxId, intent) => {
+			const root = byId.get(mailboxId);
+			if (!root) return null;
+			const prefix = `${root.fullPath}${root.hierarchyDelimiter}`;
+			const subtree = [
+				root,
+				...[...byId.values()].filter(
+					(r) => r !== root && r.fullPath.startsWith(prefix),
+				),
+			];
+			const written: MailboxItem[] = [];
+			for (const candidate of subtree) {
+				if (!intent.from.includes(candidate.syncStatus)) return null;
+				const next = {
+					...candidate,
+					...intent.rowSet(candidate),
+					syncStatus: intent.to,
+				} as MailboxItem;
+				byId.set(candidate.mailboxId, next);
+				written.push(next);
+			}
+			// The port promises no ordering beyond "the named folder first", so
+			// hand the caller the least convenient order it is allowed to return.
+			return written.reverse();
+		},
+	};
+
+	return {
+		repo: repo as IMailboxRepository,
+		pathOf: (id: string) => byId.get(id)?.fullPath,
+	};
+};
+
+const queueOver = (repo: IMailboxRepository) => {
+	const sent: string[] = [];
+	const service = new MailboxQueueService({
+		mailboxService: repo,
+		sqsQueueUrl: "http://localhost:4566/000000000000/mailbox",
+	});
+	(
+		service as unknown as {
+			sqs: {
+				send: (command: { input: { MessageBody: string } }) => Promise<void>;
+			};
+		}
+	).sqs = {
+		send: async (command) => {
+			sent.push(command.input.MessageBody);
+		},
+	};
+	return { service, sent };
+};
+
+describe("MailboxQueueService.renameMailbox — the recorded intent", () => {
+	it("records the path the RENAME will carry, `$` patterns and all", async () => {
+		// `String.prototype.replace` expands `$&`, "$`", `$'` and `$$` in the
+		// replacement, so a folder renamed to a name containing one of them was
+		// stored under a different path from the one the event carries to the
+		// server. The row and the server then disagree, and the next sweep finds
+		// no row for the real path and inserts a second one.
+		const { repo, pathOf } = store([
+			row("mbx-parent", "Work"),
+			row("mbx-child", "Work/2026"),
+		]);
+		const { service, sent } = queueOver(repo);
+
+		const renamed = await service.renameMailbox(
+			"mbx-parent",
+			"Q1$&Q2",
+			"acc-1",
+		);
+
+		assert.equal(renamed.fullPath, "Q1$&Q2");
+		assert.equal(pathOf("mbx-parent"), "Q1$&Q2");
+		assert.equal(pathOf("mbx-child"), "Q1$&Q2/2026");
+		assert.equal(
+			(JSON.parse(sent[0]) as { newPath: string }).newPath,
+			"Q1$&Q2",
+			"the event and the row name the same folder",
+		);
+	});
+
+	it("moves only what is under the renamed branch", async () => {
+		const { repo, pathOf } = store([
+			row("mbx-parent", "Work"),
+			row("mbx-lookalike", "Workshop"),
+		]);
+		const { service } = queueOver(repo);
+
+		await service.renameMailbox("mbx-parent", "Projects", "acc-1");
+
+		assert.equal(pathOf("mbx-parent"), "Projects");
+		assert.equal(pathOf("mbx-lookalike"), "Workshop");
+	});
+
+	it("returns the folder that was asked for, not whichever row came back first", async () => {
+		const { repo } = store([
+			row("mbx-parent", "Work"),
+			row("mbx-child", "Work/2026"),
+		]);
+		const { service } = queueOver(repo);
+
+		const renamed = await service.renameMailbox(
+			"mbx-parent",
+			"Projects",
+			"acc-1",
+		);
+
+		assert.equal(renamed.mailboxId, "mbx-parent");
+	});
+});

package/src/mailbox-rename-subtree.test.ts

@@ -21,7 +21,10 @@ const row = (
 const store = (rows: MailboxItem[], vanishAfterSweep: string[] = []) => {
 	const byId = new Map(rows.map((r) => [r.mailboxId, { ...r }]));
 
-	const repo: Pick<IMailboxRepository, "update" | "findByPathPrefix"> = {
+	const repo: Pick<
+		IMailboxRepository,
+		"update" | "transition" | "findByPathPrefix"
+	> = {
 		update: async (_accountId, mailboxId, patch) => {
 			const existing = byId.get(mailboxId);
 			if (!existing) {
@@ -33,6 +36,24 @@ const store = (rows: MailboxItem[], vanishAfterSweep: string[] = []) => {
 			byId.set(mailboxId, next);
 			return next;
 		},
+		transition: async (_accountId, mailboxId, intent) => {
+			const existing = byId.get(mailboxId);
+			if (!existing) return null;
+			if (!intent.from.includes(existing.syncStatus)) return null;
+			if (
+				intent.wherePendingPath !== undefined &&
+				(intent.wherePendingPath ?? undefined) !== existing.pendingPath
+			) {
+				return null;
+			}
+			const next = {
+				...existing,
+				...intent.set,
+				syncStatus: intent.to,
+			} as MailboxItem;
+			byId.set(mailboxId, next);
+			return next;
+		},
 		findByPathPrefix: async (_accountId, pathPrefix, delimiter = "/") => {
 			const prefix = `${pathPrefix}${delimiter}`;
 			const found = [...byId.values()].filter((r) =>

package/src/mailbox-sync.test.ts

@@ -216,19 +216,23 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 		shared: [],
 	};
 
-	// The server lists only INBOX: neither user folder is on it yet.
-	const serverConnection = (): IImapConnection =>
+	// The server lists only INBOX unless a test says otherwise: neither user
+	// folder is on it yet.
+	const serverConnection = (
+		folders: Array<{ fullPath: string; attributes?: string[] }> = [
+			{ fullPath: "INBOX" },
+		],
+	): IImapConnection =>
 		({
 			getNamespaces: async () => namespaces,
-			listMailboxes: async () => [
-				{
-					fullPath: "INBOX",
-					name: "INBOX",
+			listMailboxes: async () =>
+				folders.map((folder) => ({
+					fullPath: folder.fullPath,
+					name: folder.fullPath.split("/").pop() ?? folder.fullPath,
 					delimiter: "/",
-					attributes: [],
+					attributes: folder.attributes ?? [],
 					parentPath: null,
-				},
-			],
+				})),
 			getMailboxStatus: async () => ({
 				messages: 0,
 				recent: 0,
@@ -238,6 +242,12 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 				highestModseq: "0",
 				deletedCount: 0,
 			}),
+			openBox: async () => ({
+				uidvalidity: 1,
+				uidnext: 1,
+				messages: { total: 0 },
+			}),
+			closeBox: async () => undefined,
 		}) as unknown as IImapConnection;
 
 	const buildServices = (
@@ -245,9 +255,11 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 			mailboxId: string;
 			fullPath: string;
 			syncStatus?: string;
+			pendingPath?: string;
 		}>,
 	) => {
 		const deleted: string[] = [];
+		const created: Array<Record<string, unknown>> = [];
 		const mailboxService = {
 			listByAccount: async () => ({
 				items: existing.map((m) => ({
@@ -261,6 +273,7 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 					highestModseq: "0",
 					specialUse: undefined,
 					syncStatus: m.syncStatus,
+					pendingPath: m.pendingPath,
 				})),
 				continuationToken: undefined,
 			}),
@@ -268,7 +281,10 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 			delete: async (_accountId: string, mailboxId: string) => {
 				deleted.push(mailboxId);
 			},
-			create: async () => ({}),
+			create: async (input: Record<string, unknown>) => {
+				created.push(input);
+				return { ...input, mailboxId: `new-${created.length}` };
+			},
 		} as unknown as IMailboxRepository;
 
 		const specialUseService = {
@@ -277,23 +293,126 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 			createMany: async () => undefined,
 		} as unknown as IMailboxSpecialUseRepository;
 
-		return { mailboxService, specialUseService, deleted };
+		return { mailboxService, specialUseService, deleted, created };
 	};
 
-	it("keeps a pending folder the server has not listed yet", async () => {
-		// The folder was just created locally; MAILBOX_CREATE has not reached the
-		// server, so the LIST omits it. Deleting the row here races the create and
-		// wedges the account's mailbox-sync FIFO group for a full visibility window.
-		const { mailboxService, specialUseService, deleted } = buildServices([
-			{
-				mailboxId: "inbox",
-				fullPath: "INBOX",
-				syncStatus: MailboxSyncStatus.synced,
-			},
+	for (const syncStatus of [
+		MailboxSyncStatus.pending,
+		MailboxSyncStatus.deleting,
+	]) {
+		it(`keeps a \`${syncStatus}\` folder the server has not listed`, async () => {
+			// `pending`: the folder was just created locally and MAILBOX_CREATE has
+			// not reached the server, so the LIST omits it — deleting the row races
+			// the create and wedges the account's FIFO group for a visibility
+			// window (#290).
+			//
+			// `deleting`: the delete has landed on the server and the worker has not
+			// written back. Hard-deleting the row removes it under the client
+			// holding its id — the "Mailbox not found" of #333 — and removes it
+			// without the folder's mail, which the worker owns (D8).
+			const { mailboxService, specialUseService, deleted } = buildServices([
+				{
+					mailboxId: "inbox",
+					fullPath: "INBOX",
+					syncStatus: MailboxSyncStatus.synced,
+				},
+				{
+					mailboxId: "in-flight",
+					fullPath: "New Folder",
+					syncStatus,
+				},
+			]);
+			const service = new MailboxSyncService(
+				mailboxService,
+				specialUseService,
+				silentLogger,
+			);
+
+			const result = await service.syncMailboxes(
+				{ accountId: "acc-1" },
+				serverConnection(),
+			);
+
+			assert.deepEqual(deleted, []);
+			assert.equal(result.deleted, 0);
+		});
+
+		it(`keeps a \`${syncStatus}\` folder the server lists as \\Noselect`, async () => {
+			// A folder mid-create can transiently LIST as `\Noselect`, and the
+			// non-selectable branch deleted the row before looking at its state.
+			const { mailboxService, specialUseService, deleted } = buildServices([
+				{
+					mailboxId: "in-flight",
+					fullPath: "New Folder",
+					syncStatus,
+				},
+			]);
+			const service = new MailboxSyncService(
+				mailboxService,
+				specialUseService,
+				silentLogger,
+			);
+
+			await service.syncMailboxes(
+				{ accountId: "acc-1" },
+				serverConnection([
+					{ fullPath: "INBOX" },
+					{ fullPath: "New Folder", attributes: ["\\Noselect"] },
+				]),
+			);
+
+			assert.deepEqual(deleted, []);
+		});
+	}
+
+	it("does not insert a second row for a path a recorded rename claims", async () => {
+		// D14. `fullPath` stays the path the server held when the intent was
+		// recorded, so once the server executes RENAME the LIST returns a path no
+		// row is keyed to. Without the pendingPath index the insert branch makes a
+		// second row under a fresh mailboxId and initial-syncs the folder's mail
+		// into it, leaving the original as a permanent phantom.
+		const { mailboxService, specialUseService, deleted, created } =
+			buildServices([
+				{
+					mailboxId: "inbox",
+					fullPath: "INBOX",
+					syncStatus: MailboxSyncStatus.synced,
+				},
+				{
+					mailboxId: "renaming",
+					fullPath: "Archive/2025",
+					syncStatus: MailboxSyncStatus.pending,
+					pendingPath: "Records/2025",
+				},
+			]);
+		const service = new MailboxSyncService(
+			mailboxService,
+			specialUseService,
+			silentLogger,
+		);
+
+		const result = await service.syncMailboxes(
+			{ accountId: "acc-1" },
+			serverConnection([{ fullPath: "INBOX" }, { fullPath: "Records/2025" }]),
+		);
+
+		assert.deepEqual(created, []);
+		assert.equal(result.created, 0);
+		assert.deepEqual(deleted, []);
+	});
+
+	it("lets a failed rename's target be discovered as a folder of its own", async () => {
+		// A failed rename keeps its target so the UI can name what it was aiming
+		// at (T6), and nothing clears it until the user retries or dismisses. If
+		// the guard honoured that claim, one stuck folder would block the sweep
+		// from ever seeing a real folder another client later created at that
+		// path — permanently, and silently.
+		const { mailboxService, specialUseService, created } = buildServices([
 			{
-				mailboxId: "pending-folder",
-				fullPath: "New Folder",
-				syncStatus: MailboxSyncStatus.pending,
+				mailboxId: "stuck",
+				fullPath: "Archive/2025",
+				syncStatus: MailboxSyncStatus.failed,
+				pendingPath: "Records/2025",
 			},
 		]);
 		const service = new MailboxSyncService(
@@ -302,13 +421,36 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 			silentLogger,
 		);
 
-		const result = await service.syncMailboxes(
+		await service.syncMailboxes(
 			{ accountId: "acc-1" },
-			serverConnection(),
+			serverConnection([
+				{ fullPath: "INBOX" },
+				{ fullPath: "Archive/2025" },
+				{ fullPath: "Records/2025" },
+			]),
 		);
 
-		assert.deepEqual(deleted, []);
-		assert.equal(result.deleted, 0);
+		assert.deepEqual(
+			created.map((input) => input.fullPath),
+			["INBOX", "Records/2025"],
+		);
+	});
+
+	it("writes syncStatus synced on the row it discovers", async () => {
+		const { mailboxService, specialUseService, created } = buildServices([]);
+		const service = new MailboxSyncService(
+			mailboxService,
+			specialUseService,
+			silentLogger,
+		);
+
+		await service.syncMailboxes(
+			{ accountId: "acc-1" },
+			serverConnection([{ fullPath: "INBOX" }]),
+		);
+
+		assert.equal(created.length, 1);
+		assert.equal(created[0].syncStatus, MailboxSyncStatus.synced);
 	});
 
 	it("still deletes a synced folder that has left the server", async () => {

package/src/mailbox-sync.ts

@@ -25,7 +25,10 @@ import {
 import pMap from "p-map";
 import { isNoSelect, parseImapAttributes } from "./attribute-mapper.js";
 import { isCursorRebuildNeeded } from "./mailbox-cursor.js";
-import { isMailboxNotOnServer } from "./mailbox-presence.js";
+import {
+	isFolderMutationInFlight,
+	isMailboxMutationInFlight,
+} from "./mailbox-presence.js";
 import type {
 	FlatMailboxInfo,
 	IImapConnection,
@@ -149,6 +152,28 @@ export class MailboxSyncService {
 		const existingByPath = new Map(
 			existingMailboxes.map((m) => [m.fullPath, m]),
 		);
+		// The paths a rename is on its way to (D14). Under D2 `fullPath` stays the
+		// path the server held when the intent was recorded, so between the server
+		// executing RENAME and the settle, LIST returns a path no row is keyed to
+		// — and the insert branch below has no state guard at all. Without this it
+		// inserts a second row under a fresh mailboxId and initial-syncs the
+		// folder's mail into it, leaving the original as a permanent phantom still
+		// holding that folder's messages, filters and role appointments. No unique
+		// index on (accountId, fullPath) exists to catch it; #386 adds one.
+		//
+		// `pending` only. A failed rename keeps its target so the UI can name what
+		// it was aiming at (T6), and nothing clears it until the user retries or
+		// dismisses — so honouring a `failed` row's claim would let one stuck
+		// folder block the sweep from ever discovering a real folder another
+		// client later creates at that path.
+		const claimedByPendingRename = new Set(
+			existingMailboxes.flatMap((m) =>
+				m.syncStatus === MailboxSyncStatus.pending &&
+				m.pendingPath !== undefined
+					? [m.pendingPath]
+					: [],
+			),
+		);
 
 		// Get namespaces and mailboxes from IMAP
 		const namespaces = await connection.getNamespaces();
@@ -177,7 +202,15 @@ export class MailboxSyncService {
 					seenPaths.add(mailboxInfo.fullPath);
 					// If this mailbox exists in DB, delete it
 					const existing = existingByPath.get(mailboxInfo.fullPath);
-					if (existing) {
+					// A folder mid-create can transiently LIST as `\Noselect`, and
+					// deleting the row then races the create exactly as #290
+					// documented. The state check goes before the delete, through the
+					// same predicate the rest of the sweep asks.
+					if (existing && !isFolderMutationInFlight(existing)) {
+						// The duplicate-special-use branch below clears the special-use
+						// entries too; this one skipped them, orphaning a row per
+						// deleted mailbox.
+						await this.specialUseService.deleteByMailboxId(existing.mailboxId);
 						await this.mailboxService.delete(
 							account.accountId,
 							existing.mailboxId,
@@ -199,7 +232,7 @@ export class MailboxSyncService {
 				if (this.isDuplicateSpecialUse(mailboxInfo, claimedSpecialUse)) {
 					seenPaths.add(mailboxInfo.fullPath);
 					const existing = existingByPath.get(mailboxInfo.fullPath);
-					if (existing) {
+					if (existing && !isFolderMutationInFlight(existing)) {
 						await this.specialUseService.deleteByMailboxId(existing.mailboxId);
 						await this.mailboxService.delete(
 							account.accountId,
@@ -226,10 +259,7 @@ export class MailboxSyncService {
 					// that establishes or removes it writes its own identity back, and
 					// reading its status meanwhile is work whose only possible outcome is
 					// a failure that fails this whole account's fan-out with it.
-					if (
-						existing.syncStatus === MailboxSyncStatus.pending ||
-						existing.syncStatus === MailboxSyncStatus.deleting
-					) {
+					if (isFolderMutationInFlight(existing)) {
 						return;
 					}
 					// The folder set can change under this sweep. A delete that lands
@@ -247,7 +277,7 @@ export class MailboxSyncService {
 					).catch(async (error: unknown) => {
 						// The read only classifies the failure in hand; one that cannot
 						// answer must not replace it.
-						const gone = await isMailboxNotOnServer(
+						const gone = await isMailboxMutationInFlight(
 							this.mailboxService,
 							account.accountId,
 							existing.mailboxId,
@@ -258,7 +288,7 @@ export class MailboxSyncService {
 					if (updated) {
 						result.updated++;
 					}
-				} else {
+				} else if (!claimedByPendingRename.has(mailboxInfo.fullPath)) {
 					await this.createMailbox(
 						account.accountId,
 						mailboxInfo,
@@ -274,15 +304,20 @@ export class MailboxSyncService {
 		// Handle deleted mailboxes (exist in DB but not on server)
 		for (const existing of existingMailboxes) {
 			if (seenPaths.has(existing.fullPath)) continue;
-			// A `pending` row is a folder the user just created (or renamed) whose
-			// MAILBOX_CREATE/RENAME has not yet reached the server, so its absence
-			// from the LIST is expected, not a server-side deletion. Deleting it
-			// races the create: the row vanishes, then MAILBOX_CREATE fails with
-			// NotFoundError trying to mark it synced, and — sharing this account's
-			// mailboxes FIFO group — that un-acked failure stalls every later
-			// mailbox sync for the queue's whole visibility window (#290). Leave
-			// pending rows to the create/rename flow that owns them.
-			if (existing.syncStatus === MailboxSyncStatus.pending) continue;
+			// A row with a mutation in flight is a folder whose absence from the
+			// LIST is expected, not a server-side deletion. Deleting it races the
+			// worker: the row vanishes, then MAILBOX_CREATE fails with NotFoundError
+			// trying to mark it synced, and — sharing this account's mailboxes FIFO
+			// group — that un-acked failure stalls every later mailbox sync for the
+			// queue's whole visibility window (#290).
+			//
+			// `deleting` is here for a second reason. That window is exactly when a
+			// delete has landed on the server and the worker has not written back,
+			// so hard-deleting the row removes it under the client holding its id —
+			// the "Mailbox not found: <old id>" of #333 — and removes it without the
+			// folder's mail, which is the worker's job (D8). Leave both to the flow
+			// that owns them.
+			if (isFolderMutationInFlight(existing)) continue;
 			await this.mailboxService.delete(account.accountId, existing.mailboxId);
 			this.log.info(
 				{
@@ -456,6 +491,10 @@ export class MailboxSyncService {
 			highWaterMarkUid: 0,
 			lastMessageSyncAt: 0,
 			specialUse: parsed.specialUse.length > 0 ? parsed.specialUse : undefined,
+			// A folder the server just told us about is confirmed. The column
+			// defaults to this, so the row is right either way; the field is total
+			// now (D1) and the insert says what it means.
+			syncStatus: MailboxSyncStatus.synced,
 			// parentMailboxId would need to be resolved from parentPath
 		};
 

package/src/message-delete-junk-reconcile.test.ts

@@ -30,8 +30,11 @@ const buildWorld = (trashExists: boolean) => {
 		get: async () => [message],
 		update: async (_id: string, patch: Record<string, unknown>) =>
 			Object.assign(message, patch),
-		updateForMove: async (_id: string, patch: Record<string, unknown>) =>
-			Object.assign(message, patch),
+		transitionPlacement: async (
+			_id: string,
+			_expected: Record<string, unknown>,
+			patch: Record<string, unknown>,
+		) => Object.assign(message, patch),
 	} as unknown as IMessageRepository;
 
 	const threadMessageService = {

package/src/message-delete-no-trash.test.ts

@@ -52,7 +52,11 @@ const buildWorld = (
 			patches.push(patch);
 			return Object.assign(message, patch);
 		},
-		updateForMove: async (_id: string, patch: Record<string, unknown>) => {
+		transitionPlacement: async (
+			_id: string,
+			_expected: Record<string, unknown>,
+			patch: Record<string, unknown>,
+		) => {
 			patches.push(patch);
 			return Object.assign(message, patch);
 		},

package/src/message-delete-unsettled-placement.test.ts

@@ -68,11 +68,20 @@ const movingRow = () => ({
 	originalUid: INBOX_UID,
 });
 
-/** The same row after the trash-move handler gave up without confirming. */
+/**
+ * A row a delete gave up on. R3 defines the give-up as a hand-back: the row
+ * goes back on the placement the mail server confirmed, and only then carries
+ * `abandoned`. The pair is honest, so nothing downstream refuses it — the
+ * failure is a statement the reading pane makes, never a gate.
+ */
 const strandedRow = () => ({
-	...movingRow(),
 	messageId: STRANDED_ID,
-	syncStatus: "failed",
+	mailboxId: INBOX,
+	uid: INBOX_UID,
+	status: "active",
+	syncStatus: "abandoned",
+	abandonedMutation: "delete",
+	originalMailboxId: INBOX,
 });
 
 /** An ordinary settled row. */
@@ -127,7 +136,11 @@ const buildWorld = (seed: Array<Record<string, unknown>>) => {
 			patches.push({ messageId: id, patch });
 			return Object.assign(rows.get(id) ?? {}, patch);
 		},
-		updateForMove: async (id: string, patch: Record<string, unknown>) => {
+		transitionPlacement: async (
+			id: string,
+			_expected: Record<string, unknown>,
+			patch: Record<string, unknown>,
+		) => {
 			patches.push({ messageId: id, patch });
 			return Object.assign(rows.get(id) ?? {}, patch);
 		},
@@ -329,23 +342,18 @@ describe("the gate refuses only a uid that names somebody else (#845.3)", () =>
 		assert.ok(Date.now() - startedAt < 100, "and never entered the wait");
 	});
 
-	it("refuses a row stranded by a move that gave up, without spending the ceiling", async () => {
-		// `syncStatus: failed` with `status: moving` is the shape every handler's
-		// give-up path leaves behind, and only `updateUid` clears it. The pair is
-		// still a lie, so the delete is still refused — but under a reason whose
-		// remedy is a resync, and without a wait that could never succeed.
+	it("acts on a row a delete gave up on, rather than refusing it", async () => {
+		// A give-up hands the row back to the placement the server confirmed
+		// before it stops (R3), so the "Delete again" the reading pane offers is
+		// an ordinary delete. Refusing it — which is what a give-up left `moving`
+		// used to earn — made that button a dead end.
 		const { service, events } = buildWorld([strandedRow()]);
 
 		const startedAt = Date.now();
-		await assert.rejects(
-			() => service.deleteMessages(ACCOUNT_CONFIG, [STRANDED_ID], ACCOUNT),
-			(error: unknown) =>
-				error instanceof MessagePlacementUnsettledError &&
-				error.publicApiError?.details?.reason === "unverified",
-		);
+		await service.deleteMessages(ACCOUNT_CONFIG, [STRANDED_ID], ACCOUNT);
 
-		assert.deepEqual(events, []);
-		assert.ok(Date.now() - startedAt < 100, "refused without waiting");
+		assert.equal(events.length, 1);
+		assert.ok(Date.now() - startedAt < 100, "and never entered the wait");
 	});
 });