@remit/mailbox-service 0.0.91 → 0.0.93

package/src/message-move-copy.test.ts

@@ -69,6 +69,11 @@ const buildWorld = () => {
 				category: "primary",
 				classificationState: "Examined",
 				hasListUnsubscribe: false,
+				// Settled, which is what a delete's predicate asks for: a row every
+				// repository read carries a status, and leaving it off made the
+				// fixture answer for a state no row is ever in.
+				status: "active",
+				syncStatus: "synced",
 			},
 		],
 	]);
@@ -130,6 +135,19 @@ const buildWorld = () => {
 			if (m) Object.assign(m, patch);
 			return m;
 		},
+		transitionPlacement: async (
+			id: string,
+			expected: Record<string, unknown>,
+			patch: Record<string, unknown>,
+		) => {
+			const m = messages.get(id) as Record<string, unknown> | undefined;
+			if (!m) return undefined;
+			for (const [field, want] of Object.entries(expected)) {
+				if (want !== undefined && m[field] !== want) return undefined;
+			}
+			Object.assign(m, patch);
+			return m;
+		},
 	} as unknown as IMessageRepository;
 
 	const threadMessageService = {
@@ -457,7 +475,7 @@ describe("MessageMoveService.copyMessage — deterministic per-folder identity (
 	});
 
 	it("copy then delete of the copy removes the copy row and leaves the original", async () => {
-		const { service, threadRows } = buildWorld();
+		const { service, threadRows, messages } = buildWorld();
 
 		await service.copyMessages(
 			ACCOUNT_CONFIG,
@@ -467,6 +485,15 @@ describe("MessageMoveService.copyMessage — deterministic per-folder identity (
 		);
 		const copyId = deriveCopyMessageId(SOURCE_ID, DEST_MAILBOX);
 
+		// A fresh copy row is `moving` until the server hands back its COPYUID, and
+		// a delete against it would name uid 0. Settle it the way `updateUid`
+		// does, which is also the only state in which a user can see it to delete.
+		Object.assign(messages.get(copyId) ?? {}, {
+			uid: 77,
+			status: "active",
+			syncStatus: "synced",
+		});
+
 		await service.deleteMessages(ACCOUNT_CONFIG, [copyId], ACCOUNT, {
 			permanent: true,
 		});

package/src/message-move-empty-trash.test.ts

@@ -79,9 +79,12 @@ const buildWorld = (
 	trashContents: TrashMessage[] = [
 		{ messageId: "junk-1", syncStatus: "synced" },
 	],
+	/** Message ids whose placement another lane changed after the read. */
+	transitionsLost: string[] = [],
 ) => {
 	const emptied: string[] = [];
 	const markedDeleting: string[] = [];
+	const markPredicates = new Map<string, unknown>();
 	const events: EnqueuedEvent[] = [];
 	const messagesByMailbox = new Map<string, TrashMessage[]>([
 		[DELETED_FOLDER, [{ messageId: "keepsake-1", syncStatus: "synced" }]],
@@ -96,6 +99,12 @@ const buildWorld = (
 		update: async (messageId: string) => {
 			markedDeleting.push(messageId);
 		},
+		transitionPlacement: async (messageId: string, expected: unknown) => {
+			markPredicates.set(messageId, expected);
+			if (transitionsLost.includes(messageId)) return undefined;
+			markedDeleting.push(messageId);
+			return { messageId };
+		},
 	} as unknown as IMessageRepository;
 
 	const threadMessageService = {
@@ -135,7 +144,7 @@ const buildWorld = (
 		events.push(event);
 	};
 
-	return { service, emptied, markedDeleting, events };
+	return { service, emptied, markedDeleting, markPredicates, events };
 };
 
 describe("MessageMoveService.emptyTrash", () => {
@@ -245,6 +254,44 @@ describe("MessageMoveService.emptyTrash", () => {
 		assert.equal(deletedCount, 1);
 	});
 
+	it("predicates each mark on the row it just read, and drops the ones it loses", async () => {
+		// The rows are held by nothing between the listing and the mark, and
+		// PLACEMENT_MOVE_PUSH rides a standard queue this account's FIFO group
+		// does not order (imap-mutations R3). A row that moved under the sweep
+		// must not be marked `deleting` for an expunge that would bind a uid it
+		// no longer has.
+		const { service, markedDeleting, markPredicates } = buildWorld(
+			appointedTrash,
+			[
+				{
+					messageId: "settled-1",
+					syncStatus: "synced",
+					status: "active",
+					mailboxId: REAL_TRASH,
+					uid: 10,
+				},
+				{
+					messageId: "raced-1",
+					syncStatus: "synced",
+					status: "active",
+					mailboxId: REAL_TRASH,
+					uid: 11,
+				},
+			],
+			["raced-1"],
+		);
+
+		const { deletedCount } = await service.emptyTrash(ACCOUNT_CONFIG, ACCOUNT);
+
+		assert.deepEqual(markedDeleting, ["settled-1"]);
+		assert.equal(deletedCount, 1, "a row that lost is not counted either");
+		assert.deepEqual(markPredicates.get("settled-1"), {
+			status: "active",
+			mailboxId: REAL_TRASH,
+			uid: 10,
+		});
+	});
+
 	it("reports the same count when pressed twice before the worker runs", async () => {
 		// The rows it marked are still in that folder, so N stays true and the
 		// re-mark is idempotent. Reporting 0 the second time while still

package/src/message-move-same-mailbox.test.ts

@@ -52,8 +52,11 @@ const buildWorld = () => {
 			Array.isArray(ids) ? [message] : 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-move-unsettled-placement.test.ts

@@ -28,6 +28,7 @@ const ARCHIVE = "mbx-archive";
 const MOVING_ID = "msg-moving";
 const SETTLED_ID = "msg-settled";
 const STRANDED_ID = "msg-stranded";
+const DELETING_ID = "msg-deleting";
 const COPY_ID = "msg-copy";
 
 const INBOX_UID = 42;
@@ -58,11 +59,36 @@ const movingRow = () => ({
 	originalUid: INBOX_UID,
 });
 
-/** The same row after the mover gave up without confirming. */
+/**
+ * A row a mutation 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: "move",
+	originalMailboxId: INBOX,
+});
+
+/**
+ * The same shape a delete leaves: Trash is already written, the uid is still
+ * INBOX's, and `deleting` is what says so. R3 calls this in flight exactly as
+ * `moving` is — reading only `moving` let a move enqueued behind a delete bind
+ * this pair and be dropped when the delete settled.
+ */
+const deletingRow = () => ({
+	messageId: DELETING_ID,
+	mailboxId: ARCHIVE,
+	uid: INBOX_UID,
+	status: "deleting",
+	syncStatus: "pending",
+	originalMailboxId: INBOX,
+	originalUid: INBOX_UID,
 });
 
 /** An ordinary settled row. */
@@ -118,7 +144,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);
 		},
@@ -318,22 +348,31 @@ describe("the move gate refuses only a uid that names somebody else (#665)", ()
 		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 what every handler's
-		// give-up path leaves behind, and only `updateUid` clears it. The pair is
-		// still a lie, so the move is still refused — under a reason whose remedy
-		// is a resync, and without a wait that could never succeed.
-		const { service, events } = buildWorld([strandedRow()]);
+	it("waits out a delete in flight rather than binding its borrowed uid", async () => {
+		const { service, events, patches } = buildWorld([deletingRow()]);
 
-		const startedAt = Date.now();
 		await assert.rejects(
-			() => service.moveMessage(ACCOUNT_CONFIG, STRANDED_ID, INBOX, ACCOUNT),
-			(error: unknown) =>
-				error instanceof MessagePlacementUnsettledError &&
-				error.publicApiError?.details?.reason === "unverified",
+			() => service.moveMessage(ACCOUNT_CONFIG, DELETING_ID, INBOX, ACCOUNT),
+			(error: unknown) => error instanceof MessagePlacementUnsettledError,
 		);
 
-		assert.deepEqual(events, []);
-		assert.ok(Date.now() - startedAt < 100, "refused without waiting");
+		assert.deepEqual(events, [], "nothing was enqueued");
+		assert.deepEqual(patches, [], "and no local write was made");
+	});
+
+	it("acts on a row a move 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 folder and uid name the same message and
+		// the user's next move is an ordinary one. Refusing it — which is what a
+		// give-up left `moving` used to earn — made the message unmovable for
+		// good, with nothing routine to repair it.
+		const { service, events } = buildWorld([strandedRow()]);
+
+		const startedAt = Date.now();
+		await service.moveMessage(ACCOUNT_CONFIG, STRANDED_ID, ARCHIVE, ACCOUNT);
+
+		assert.equal(events.length, 1);
+		assert.equal(events[0].type, "MESSAGE_MOVE");
+		assert.ok(Date.now() - startedAt < 100, "and never entered the wait");
 	});
 });

package/src/message-move.ts

@@ -29,17 +29,28 @@ import { deriveCopyMessageId } from "@remit/data-ports/id";
 import { MUTATION_EVENT_SCHEMA_VERSION } from "@remit/data-ports/mutation-events";
 import {
 	CanonicalMailboxRole,
+	MessageMutation,
 	MessageStatus,
 	MessageSyncStatus,
 } from "@remit/domain-enums";
 import { createQueueProducer } from "@remit/sqs-client/producer";
 import {
-	bindsForeignUid,
-	type PlacementBinding,
+	carriesForeignUid,
 	placementBindingOf,
 	waitForPlacementToSettle,
 } from "./placement-settled.js";
 
+/**
+ * What a delete batch did not claim. A row whose placement changed between the
+ * read that decided this delete and the mark that recorded it belongs to
+ * whoever changed it (docs/architecture/imap-mutations.md R3), so this delete
+ * leaves it alone — and says which, because the client removed it optimistically
+ * and a row that reappears unexplained is a failure the user cannot act on.
+ */
+export interface DeleteMessagesOutcome {
+	refusedMessageIds: string[];
+}
+
 /**
  * Event types for message move/delete operations.
  * These match the worker event types in remit-imap-worker/events.ts.
@@ -288,9 +299,8 @@ export class MessageMoveService {
 		messageId: string,
 		accountId: string,
 		options: DeleteOptions = { toTrash: true },
-	): Promise<void> => {
-		await this.deleteMessages(accountConfigId, [messageId], accountId, options);
-	};
+	): Promise<DeleteMessagesOutcome> =>
+		this.deleteMessages(accountConfigId, [messageId], accountId, options);
 
 	/**
 	 * Delete multiple messages using batch operations.
@@ -305,12 +315,12 @@ export class MessageMoveService {
 		messageIds: string[],
 		accountId: string,
 		options: DeleteOptions = { toTrash: true },
-	): Promise<void> => {
-		if (messageIds.length === 0) return;
+	): Promise<DeleteMessagesOutcome> => {
+		if (messageIds.length === 0) return { refusedMessageIds: [] };
 
 		// Batch get all messages
 		const rows = await this.messageService.get(messageIds);
-		if (rows.length === 0) return;
+		if (rows.length === 0) return { refusedMessageIds: [] };
 
 		// Ahead of the Trash gates below, which compare `mailboxId` against the
 		// Trash folder: an in-flight move makes that comparison answer for a
@@ -381,20 +391,36 @@ export class MessageMoveService {
 		}
 
 		// Group messages by operation type
-		const moveToTrashMessages: Array<{
+		type DeleteEntry = {
 			messageId: string;
 			message: { mailboxId: string; uid: number };
 			sourceMailbox: { mailboxId: string; fullPath: string };
-		}> = [];
-		const permanentDeleteMessages: Array<{
-			messageId: string;
-			message: { mailboxId: string; uid: number };
-			sourceMailbox: { mailboxId: string; fullPath: string };
-		}> = [];
+		};
+		const moveToTrashMessages: DeleteEntry[] = [];
+		const permanentDeleteMessages: DeleteEntry[] = [];
+
+		// Rows whose placement changed between the read above and the mark below,
+		// so this delete never claimed them. Reported rather than skipped in
+		// silence: the client removed them optimistically, and a row that
+		// reappears with nothing said is the dead-button failure again (#1229).
+		const refused: string[] = [];
 
 		for (const message of messages) {
 			const sourceMailbox = mailboxMap.get(message.mailboxId);
-			if (!sourceMailbox) continue;
+			if (!sourceMailbox) {
+				// The folder lookup is scoped to one account, so a selection that
+				// spans accounts — the daily brief lists every account's mail —
+				// leaves this row's mailbox unresolved. Nothing about it was
+				// written and no event was enqueued, so it is a refusal like any
+				// other; dropping it silently answered "deleted" over a message
+				// still sitting where it was.
+				refused.push(message.messageId);
+				this.log.info(
+					{ accountId, messageId: message.messageId },
+					"Refused delete: this message's folder does not belong to this account",
+				);
+				continue;
+			}
 
 			const isInTrash =
 				trashMailbox !== null && message.mailboxId === trashMailbox.mailboxId;
@@ -428,14 +454,41 @@ export class MessageMoveService {
 					accountConfigId,
 				);
 			for (const { messageId, message, sourceMailbox } of moveToTrashMessages) {
-				// Update local state optimistically
-				await this.messageService.updateForMove(messageId, {
-					mailboxId: trashMailbox.mailboxId,
-					status: MessageStatus.moving,
-					syncStatus: MessageSyncStatus.pending,
-					originalMailboxId: sourceMailbox.mailboxId,
-					originalUid: message.uid,
-				});
+				// The optimistic write is a transition off the row this call read
+				// (imap-mutations R3). Several folder lookups stand between the read
+				// and here, and PLACEMENT_MOVE_PUSH runs on a queue this account's
+				// FIFO group does not order, so the row can settle onto a different
+				// folder and uid in between. Writing anyway would stamp `moving` and
+				// the OLD uid over the new placement, and the event enqueued below
+				// would name a uid the source no longer holds — a delete aimed at
+				// whatever message has since taken that number.
+				const marked = await this.messageService.transitionPlacement(
+					messageId,
+					{
+						// `active`, not whatever the row was read as: a row already
+						// `moving` or `deleting` is mid-mutation, and marking it again
+						// would enqueue a second event against the same uid.
+						status: MessageStatus.active,
+						mailboxId: message.mailboxId,
+						uid: message.uid,
+					},
+					{
+						mailboxId: trashMailbox.mailboxId,
+						status: MessageStatus.moving,
+						syncStatus: MessageSyncStatus.pending,
+						abandonedMutation: MessageMutation.none,
+						originalMailboxId: sourceMailbox.mailboxId,
+						originalUid: message.uid,
+					},
+				);
+				if (!marked) {
+					refused.push(messageId);
+					this.log.info(
+						{ accountId, messageId },
+						"Refused delete: this message's placement changed after it was read",
+					);
+					continue;
+				}
 
 				// Update ThreadMessage
 				await this.updateThreadMessageForMove(
@@ -481,11 +534,36 @@ export class MessageMoveService {
 			message,
 			sourceMailbox,
 		} of permanentDeleteMessages) {
-			// Update local state optimistically
-			await this.messageService.update(messageId, {
-				status: MessageStatus.deleting,
-				syncStatus: MessageSyncStatus.pending,
-			});
+			// A transition off the row this call read, like the trash path above
+			// (imap-mutations R3). The expunge below is aimed at a specific uid in
+			// a specific folder, so a row that has moved since the read must not be
+			// marked for it: a restore out of Trash settling in between would be
+			// overwritten with `deleting`, and the event would carry the uid Trash
+			// no longer holds.
+			const marked = await this.messageService.transitionPlacement(
+				messageId,
+				{
+					// `active` for the same reason as the trash path above: a second
+					// press on a row already `deleting` would enqueue a duplicate
+					// expunge rather than refusing.
+					status: MessageStatus.active,
+					mailboxId: message.mailboxId,
+					uid: message.uid,
+				},
+				{
+					status: MessageStatus.deleting,
+					syncStatus: MessageSyncStatus.pending,
+					abandonedMutation: MessageMutation.none,
+				},
+			);
+			if (!marked) {
+				refused.push(messageId);
+				this.log.info(
+					{ accountId, messageId },
+					"Refused permanent delete: this message's placement changed after it was read",
+				);
+				continue;
+			}
 
 			// Delete ThreadMessage rows up-front (one row per mailbox copy).
 			// The IMAP worker also deletes them once the IMAP DELETE succeeds —
@@ -517,6 +595,8 @@ export class MessageMoveService {
 
 		// Batch send events to SQS
 		await this.enqueueEventsBatch(events);
+
+		return { refusedMessageIds: refused };
 	};
 
 	/**
@@ -591,14 +671,41 @@ export class MessageMoveService {
 			trashMailbox && message.mailboxId === trashMailbox.mailboxId,
 		);
 
-		// Update local state optimistically
-		await this.messageService.updateForMove(messageId, {
-			mailboxId: destinationMailboxId,
-			status: MessageStatus.moving,
-			syncStatus: MessageSyncStatus.pending,
-			originalMailboxId: sourceMailbox.mailboxId,
-			originalUid: message.uid,
-		});
+		// The optimistic write is a transition off the row this call read
+		// (imap-mutations R3). Three mailbox lookups stand between the read and
+		// here, and PLACEMENT_MOVE_PUSH runs on a queue this account's FIFO group
+		// does not order, so the row can settle onto a different folder and uid in
+		// between. A blind write would stamp `moving` and the OLD uid over that
+		// placement, leaving a pair `carriesForeignUid` calls consistent, and the
+		// event below would send the worker after whatever now holds the old uid.
+		const moved = await this.messageService.transitionPlacement(
+			messageId,
+			{
+				status: MessageStatus.active,
+				mailboxId: message.mailboxId,
+				uid: message.uid,
+			},
+			{
+				mailboxId: destinationMailboxId,
+				status: MessageStatus.moving,
+				syncStatus: MessageSyncStatus.pending,
+				abandonedMutation: MessageMutation.none,
+				originalMailboxId: sourceMailbox.mailboxId,
+				originalUid: message.uid,
+			},
+		);
+		if (!moved) {
+			this.log.error(
+				{ accountId, messageId, destinationMailboxId },
+				"Refused: this message's placement changed while the move was being prepared",
+			);
+			throw new MessagePlacementUnsettledError(
+				`Message ${messageId} was not moved: something else changed where it is while this move was being prepared`,
+				accountId,
+				messageId,
+				"in_flight",
+			);
+		}
 
 		// Update ThreadMessage
 		await this.updateThreadMessageForMove(
@@ -928,18 +1035,45 @@ export class MessageMoveService {
 		// says so: its own MESSAGE_MOVE then reads the row as settled and returns
 		// without moving anything, and the worker's expunge binds that borrowed
 		// uid against whatever Trash really holds at it. Left as it stands, that
-		// move runs ahead of this expunge in the account's FIFO group and settles
-		// the row, so the message is in Trash by the time the sweep reaches it and
-		// goes with the rest of this same press — only the count below is one
-		// short of what the sweep ends up removing.
-		const messages = rows.filter((message) => !bindsForeignUid(message));
-
-		// Mark all as deleting locally
-		for (const message of messages) {
-			await this.messageService.update(message.messageId, {
-				status: MessageStatus.deleting,
-				syncStatus: MessageSyncStatus.pending,
-			});
+		// move settles the row on its own, so the message is in Trash by the time
+		// the sweep reaches it and goes with the rest of this same press — only
+		// the count below is one short of what the sweep ends up removing.
+		//
+		// `carriesForeignUid`, the same predicate the sweep applies (#1217).
+		// The binding form reads `status` too, and `status` is exactly what this
+		// mark is about to overwrite, so the two halves of one gate would have
+		// disagreed the moment the mark landed.
+		const candidates = rows.filter((message) => !carriesForeignUid(message));
+
+		// Each mark is a transition off the row as it was just read
+		// (imap-mutations R3), not a blind write onto a snapshot. The rows are
+		// held by nothing between the listing and here, and PLACEMENT_MOVE_PUSH
+		// runs on a standard queue that this account's FIFO group does not order,
+		// so a row can move out from under the sweep. A lost predicate means
+		// another lane won: the row is left alone and not counted, rather than
+		// marked `deleting` for an expunge that would bind somebody else's uid.
+		const messages: MessageItem[] = [];
+		for (const message of candidates) {
+			const marked = await this.messageService.transitionPlacement(
+				message.messageId,
+				{
+					status: message.status,
+					mailboxId: message.mailboxId,
+					uid: message.uid,
+				},
+				{
+					status: MessageStatus.deleting,
+					syncStatus: MessageSyncStatus.pending,
+				},
+			);
+			if (!marked) {
+				this.log.info(
+					{ accountId, messageId: message.messageId },
+					"Empty Trash skipped a message whose placement changed while the folder was being read",
+				);
+				continue;
+			}
+			messages.push(marked);
 			await this.updateThreadMessageDeleted(
 				accountConfigId,
 				message.messageId,
@@ -952,6 +1086,7 @@ export class MessageMoveService {
 				accountId,
 				trashMailboxId: trashMailbox.mailboxId,
 				count: messages.length,
+				skipped: rows.length - messages.length,
 			},
 			"Marked all trash messages for deletion (local)",
 		);
@@ -976,17 +1111,16 @@ export class MessageMoveService {
 	private refusePlacement = (
 		message: MessageItem,
 		accountId: string,
-		binding: Exclude<PlacementBinding, "consistent">,
 	): never => {
 		this.log.error(
-			{ accountId, messageId: message.messageId, binding },
+			{ accountId, messageId: message.messageId },
 			"Refused: this message's folder and uid do not name the same message",
 		);
 		throw new MessagePlacementUnsettledError(
 			`Message ${message.messageId} was not acted on: its folder and uid do not name the same message`,
 			accountId,
 			message.messageId,
-			binding === "abandoned" ? "unverified" : "in_flight",
+			"in_flight",
 		);
 	};
 
@@ -994,13 +1128,7 @@ export class MessageMoveService {
 		message: MessageItem,
 		accountId: string,
 	): Promise<MessageItem> => {
-		const binding = placementBindingOf(message);
-		if (binding === "consistent") return message;
-
-		// An abandoned move is never coming back, so the ceiling would be spent
-		// only to reach the same answer.
-		if (binding === "abandoned")
-			return this.refusePlacement(message, accountId, binding);
+		if (placementBindingOf(message) === "consistent") return message;
 
 		const settled = await waitForPlacementToSettle(
 			this.messageService,
@@ -1010,9 +1138,8 @@ export class MessageMoveService {
 				pollMs: this.moveSettlePollMs,
 			},
 		);
-		const settledBinding = placementBindingOf(settled);
-		if (settledBinding === "consistent") return settled;
-		return this.refusePlacement(settled, accountId, settledBinding);
+		if (placementBindingOf(settled) === "consistent") return settled;
+		return this.refusePlacement(settled, accountId);
 	};
 
 	/**

package/src/message-sync-repoint.test.ts

@@ -336,13 +336,33 @@ describe("repointsOnSighting", () => {
 		);
 	});
 
-	it("refuses a row whose move failed and has not been re-tried", () => {
+	/**
+	 * The row `abandonDelete` hands back: reader refused the delete, put the
+	 * message back where the server still has it, and nothing else is coming
+	 * for the row. Reader shares its mailboxes, so the user moving that same
+	 * message in another client is ordinary — and before R3 the sighting was
+	 * refused on `syncStatus` alone and the row never followed the move.
+	 */
+	it("accepts a row whose delete was abandoned, so a move made elsewhere still lands", () => {
+		assert.equal(
+			repointsOnSighting(
+				JUNK,
+				storedIn(INBOX, {
+					status: MessageStatus.active,
+					syncStatus: MessageSyncStatus.abandoned,
+				}),
+			),
+			true,
+		);
+	});
+
+	it("accepts a row left `failed` by a transient attempt that has since settled", () => {
 		assert.equal(
 			repointsOnSighting(
 				JUNK,
 				storedIn(INBOX, { syncStatus: MessageSyncStatus.failed }),
 			),
-			false,
+			true,
 		);
 	});