@remit/imap-worker 0.0.77 → 0.0.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/imap-worker",
-  "version": "0.0.77",
+  "version": "0.0.79",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/src/events.ts

@@ -1,4 +1,7 @@
-import type { MUTATION_EVENT_SCHEMA_VERSION } from "@remit/data-ports/mutation-events";
+import type {
+	MUTATION_EVENT_SCHEMA_VERSION,
+	PATHLESS_MUTATION_EVENT_SCHEMA_VERSION,
+} from "@remit/data-ports/mutation-events";
 
 export interface BaseEvent {
 	accountId: string;
@@ -88,39 +91,56 @@ export type MailboxManagementEvent =
 /**
  * Event for deleting a message (move to trash or permanent delete).
  */
-export interface MessageDeleteEvent extends BaseEvent {
+interface MessageDeleteEventFields extends BaseEvent {
 	type: "MESSAGE_DELETE";
-	schemaVersion: typeof MUTATION_EVENT_SCHEMA_VERSION;
 	messageId: string;
 	mailboxId: string;
-	mailboxPath: string;
 	uid: number;
 	operation: "move_to_trash" | "permanent_delete";
 	destinationMailboxId?: string;
+}
+
+export interface MessageDeleteEventV2 extends MessageDeleteEventFields {
+	schemaVersion: typeof MUTATION_EVENT_SCHEMA_VERSION;
+	mailboxPath: string;
 	destinationMailboxPath?: string;
 }
 
+export interface MessageDeleteEventV3 extends MessageDeleteEventFields {
+	schemaVersion: typeof PATHLESS_MUTATION_EVENT_SCHEMA_VERSION;
+}
+
+export type MessageDeleteEvent = MessageDeleteEventV2 | MessageDeleteEventV3;
+
 /**
  * Event for moving a message to another mailbox.
  */
-export interface MessageMoveEvent extends BaseEvent {
+interface MessageMoveEventFields extends BaseEvent {
 	type: "MESSAGE_MOVE";
 	messageId: string;
 	sourceMailboxId: string;
-	sourceMailboxPath: string;
 	destinationMailboxId: string;
-	destinationMailboxPath: string;
 	uid: number;
 }
 
+export interface MessageMoveEventV1 extends MessageMoveEventFields {
+	schemaVersion?: undefined;
+	sourceMailboxPath: string;
+	destinationMailboxPath: string;
+}
+
+export interface MessageMoveEventV3 extends MessageMoveEventFields {
+	schemaVersion: typeof PATHLESS_MUTATION_EVENT_SCHEMA_VERSION;
+}
+
+export type MessageMoveEvent = MessageMoveEventV1 | MessageMoveEventV3;
+
 /**
  * Event for emptying the Trash mailbox.
  */
-export interface EmptyTrashEvent extends BaseEvent {
+interface EmptyTrashEventFields extends BaseEvent {
 	type: "EMPTY_TRASH";
-	schemaVersion: typeof MUTATION_EVENT_SCHEMA_VERSION;
 	trashMailboxId: string;
-	trashMailboxPath: string;
 	/**
 	 * The Trash folder's UIDVALIDITY at the moment the user consented. The
 	 * handler compares it against what the SELECT serves: a path reused by a
@@ -130,20 +150,41 @@ export interface EmptyTrashEvent extends BaseEvent {
 	trashUidValidity: number;
 }
 
+export interface EmptyTrashEventV2 extends EmptyTrashEventFields {
+	schemaVersion: typeof MUTATION_EVENT_SCHEMA_VERSION;
+	trashMailboxPath: string;
+}
+
+export interface EmptyTrashEventV3 extends EmptyTrashEventFields {
+	schemaVersion: typeof PATHLESS_MUTATION_EVENT_SCHEMA_VERSION;
+}
+
+export type EmptyTrashEvent = EmptyTrashEventV2 | EmptyTrashEventV3;
+
 /**
  * Event for copying a message to another mailbox.
  */
-export interface MessageCopyEvent extends BaseEvent {
+interface MessageCopyEventFields extends BaseEvent {
 	type: "MESSAGE_COPY";
 	sourceMessageId: string;
 	newMessageId: string;
 	sourceMailboxId: string;
-	sourceMailboxPath: string;
 	destinationMailboxId: string;
-	destinationMailboxPath: string;
 	uid: number;
 }
 
+export interface MessageCopyEventV1 extends MessageCopyEventFields {
+	schemaVersion?: undefined;
+	sourceMailboxPath: string;
+	destinationMailboxPath: string;
+}
+
+export interface MessageCopyEventV3 extends MessageCopyEventFields {
+	schemaVersion: typeof PATHLESS_MUTATION_EVENT_SCHEMA_VERSION;
+}
+
+export type MessageCopyEvent = MessageCopyEventV1 | MessageCopyEventV3;
+
 /**
  * Event for appending a sent message to the Sent mailbox via IMAP APPEND.
  */

package/src/handlers/empty-trash.test.ts

@@ -38,7 +38,12 @@ interface Harness {
 		accountConfigId: string;
 		deletedAt?: number;
 	} | null;
-	mailbox: { mailboxId: string; uidValidity: number; cursorState?: string };
+	mailbox: {
+		mailboxId: string;
+		fullPath: string;
+		uidValidity: number;
+		cursorState?: string;
+	};
 	mailboxError?: Error;
 	trashResolution: RoleResolution<TrashMailbox>;
 	connection: Connection;
@@ -118,7 +123,12 @@ const markedMidMove = (messageId: string, uid: number): LocalMessage => ({
 const fresh = (): Harness => ({
 	calls: [],
 	account: { accountId: "acc-1", accountConfigId: "cfg-1" },
-	mailbox: { mailboxId: "trash-mbx", uidValidity: 1, cursorState: undefined },
+	mailbox: {
+		mailboxId: "trash-mbx",
+		fullPath: "Trash",
+		uidValidity: 1,
+		cursorState: undefined,
+	},
 	trashResolution: {
 		kind: "flagged",
 		mailbox: { mailboxId: "trash-mbx", fullPath: "Trash" },
@@ -406,7 +416,7 @@ describe("handleEmptyTrash", () => {
 		// The path was reused: a third-party client renamed Trash away and made a
 		// fresh one. Same path, different folder, and nobody consented to empty it.
 		h.connection.openBox = async () => ({ uidvalidity: 77 });
-		h.mailbox = { mailboxId: "trash-mbx", uidValidity: 77 };
+		h.mailbox = { mailboxId: "trash-mbx", fullPath: "Trash", uidValidity: 77 };
 
 		await handleEmptyTrash(event, noopLogger, deps());
 
@@ -422,7 +432,7 @@ describe("handleEmptyTrash", () => {
 			{ messageId: "msg-arrived", uid: 12, status: "active" },
 		];
 		h.connection.openBox = async () => ({ uidvalidity: 77 });
-		h.mailbox = { mailboxId: "trash-mbx", uidValidity: 77 };
+		h.mailbox = { mailboxId: "trash-mbx", fullPath: "Trash", uidValidity: 77 };
 
 		await handleEmptyTrash(event, noopLogger, deps());
 
@@ -450,6 +460,7 @@ describe("handleEmptyTrash", () => {
 	it("reverts the marks without connecting when the cursor is rebuilding", async () => {
 		h.mailbox = {
 			mailboxId: "trash-mbx",
+			fullPath: "Trash",
 			uidValidity: 1,
 			cursorState: "rebuilding",
 		};
@@ -663,3 +674,55 @@ describe("handleEmptyTrash and an unsettled placement", () => {
 		);
 	});
 });
+
+describe("handleEmptyTrash — the Trash path comes from its mailbox row", () => {
+	beforeEach(() => {
+		h = fresh();
+	});
+
+	const openedPaths = (): string[] => {
+		const opened: string[] = [];
+		h.connection.openBox = async (path: string) => {
+			opened.push(path);
+			return { uidvalidity: 1 };
+		};
+		return opened;
+	};
+
+	it("runs an empty enqueued with the version 2 payload that carries the folder path", async () => {
+		const opened = openedPaths();
+
+		await handleEmptyTrash(event, noopLogger, deps());
+
+		assert.deepEqual(opened, ["Trash"]);
+		assert.deepEqual(called("connection.deleteMessages")[0]?.args, [[10, 11]]);
+	});
+
+	it("runs an empty enqueued with the pathless payload", async () => {
+		const opened = openedPaths();
+		const pathless: EmptyTrashEvent = {
+			type: "EMPTY_TRASH",
+			schemaVersion: 3,
+			eventId: "evt-1",
+			timestamp: 1,
+			accountId: "acc-1",
+			trashMailboxId: "trash-mbx",
+			trashUidValidity: 1,
+		};
+
+		await handleEmptyTrash(pathless, noopLogger, deps());
+
+		assert.deepEqual(opened, ["Trash"]);
+		assert.deepEqual(called("connection.deleteMessages")[0]?.args, [[10, 11]]);
+	});
+
+	it("empties Trash under its current path when the folder was renamed after enqueue", async () => {
+		const opened = openedPaths();
+		h.mailbox = { ...h.mailbox, fullPath: "Deleted Items" };
+
+		await handleEmptyTrash(event, noopLogger, deps());
+
+		assert.deepEqual(opened, ["Deleted Items"]);
+		assert.deepEqual(called("connection.deleteMessages")[0]?.args, [[10, 11]]);
+	});
+});

package/src/handlers/empty-trash.ts

@@ -1,8 +1,7 @@
 import { getClient } from "@remit/backend/client";
 import type { MessageItem } from "@remit/data-ports";
-import { isNotFoundError } from "@remit/data-ports/errors";
 import { trashMailboxAt } from "@remit/data-ports/folder-role";
-import { isCurrentSchemaVersion } from "@remit/data-ports/mutation-events";
+import { isAcceptedSchemaVersion } from "@remit/data-ports/mutation-events";
 import { MessageStatus, MessageSyncStatus } from "@remit/domain-enums";
 import type { Logger } from "@remit/logger-lambda";
 import {
@@ -15,6 +14,7 @@ import {
 import { isAccountDeleted } from "../account-check.js";
 import { createConnectionScopeWithCredentials } from "../connection-scope.js";
 import type { EmptyTrashEvent } from "../events.js";
+import { findMailboxRow } from "../mailbox-row.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 
@@ -64,12 +64,9 @@ export const handleEmptyTrash = async (
 		secrets,
 	} = await getClient();
 
-	const { accountId, trashMailboxId, trashMailboxPath } = event;
+	const { accountId, trashMailboxId } = event;
 
-	log.info(
-		{ event: event.type, accountId, trashMailboxPath },
-		"Handling event",
-	);
+	log.info({ event: event.type, accountId, trashMailboxId }, "Handling event");
 
 	const account = await accountService.get(accountId);
 	if (!account) {
@@ -151,16 +148,13 @@ export const handleEmptyTrash = async (
 		alert: string,
 		context: Record<string, unknown> = {},
 	): Promise<void> => {
-		log.error(
-			{ alert, accountId, trashMailboxId, trashMailboxPath, ...context },
-			reason,
-		);
+		log.error({ alert, accountId, trashMailboxId, ...context }, reason);
 		await handBackMarkedRows(
 			await messageService.listAllByMailbox(trashMailboxId),
 		);
 	};
 
-	if (!isCurrentSchemaVersion(event.schemaVersion)) {
+	if (!isAcceptedSchemaVersion(event.schemaVersion)) {
 		await abandonEmptyTrash(
 			"Refused to empty trash: event was minted under an unknown contract",
 			"empty_trash_unknown_schema_version",
@@ -199,19 +193,19 @@ export const handleEmptyTrash = async (
 			// NotFoundError forever, and on the account's per-group FIFO that head
 			// message stalls the whole pipeline (issues #287, #289, #290). A deleted
 			// Trash makes the empty moot: ack with a WARN.
-			const mailbox = await mailboxService
-				.get(accountId, trashMailboxId)
-				.catch((error: unknown) => {
-					if (isNotFoundError(error)) return null;
-					throw error;
-				});
-			if (!mailbox) {
+			const trash = await findMailboxRow(
+				mailboxService,
+				accountId,
+				trashMailboxId,
+			);
+			if (trash.kind === "gone") {
 				log.warn(
 					{ accountId, mailboxId: trashMailboxId },
 					"Skipping EMPTY_TRASH: mailbox no longer exists (deleted)",
 				);
 				return;
 			}
+			const mailbox = trash.mailbox;
 
 			// A paused cursor is not a wait here: this return acks the event and
 			// nothing re-issues it, so the marks have to come back or the folder
@@ -239,7 +233,7 @@ export const handleEmptyTrash = async (
 						accountId,
 						mailbox,
 					);
-					const boxStatus = await connection.openBox(trashMailboxPath, false);
+					const boxStatus = await connection.openBox(mailbox.fullPath, false);
 
 					// The path is not the folder. A third-party client that renames
 					// Trash and creates a fresh one leaves this event pointing at a

package/src/handlers/mailbox-management.ts

@@ -133,7 +133,12 @@ const handleCreate = async (
 					.then((result) => {
 						if (result.success) {
 							log.info(
-								{ accountId, mailboxId, path },
+								{
+									accountId,
+									mailboxId,
+									path,
+									existingMailboxId: result.existing?.mailboxId,
+								},
 								"Mailbox created on IMAP",
 							);
 						} else {

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

@@ -40,6 +40,8 @@ interface Harness {
 	} | null;
 	mailbox: { mailboxId: string; uidValidity: number; cursorState?: string };
 	mailboxError?: Error;
+	folderPaths: Record<string, string>;
+	goneMailboxIds: string[];
 	copyRow: CopyRow | null;
 	destinationHolds: number[];
 	connection: Connection;
@@ -89,6 +91,8 @@ const fresh = (): Harness => ({
 	calls: [],
 	account: { accountId: "acc-1", accountConfigId: "cfg-1" },
 	mailbox: { mailboxId: "src-mbx", uidValidity: 1, cursorState: undefined },
+	folderPaths: { "src-mbx": "INBOX", "dst-mbx": "Archive" },
+	goneMailboxIds: [],
 	copyRow: unsettledCopyRow(),
 	destinationHolds: [],
 	connection: buildConnection(),
@@ -136,9 +140,14 @@ const deps = (): MessageCopyDeps =>
 				update: record("threadMessage.update"),
 			},
 			mailbox: {
-				get: async () => {
+				get: async (_accountId: string, mailboxId: string) => {
 					if (h.mailboxError) throw h.mailboxError;
-					return h.mailbox;
+					if (h.goneMailboxIds.includes(mailboxId)) throw notFoundError();
+					const row =
+						mailboxId === h.mailbox.mailboxId
+							? h.mailbox
+							: { mailboxId, uidValidity: 1, cursorState: "normal" };
+					return { ...row, fullPath: h.folderPaths[mailboxId] };
 				},
 				update: record("mailbox.update"),
 			},
@@ -589,4 +598,57 @@ describe("handleMessageCopy", () => {
 		assert.equal(called("message.delete")[0]?.args[0], "new-msg");
 		assert.equal(called("threadMessage.deleteMany").length, 1);
 	});
+
+	it("runs a copy enqueued with the unversioned payload that carries folder paths", async () => {
+		await handleMessageCopy(event, noopLogger, 1, deps());
+
+		assert.deepEqual(called("copyMessages")[0]?.args, [[10], "Archive"]);
+		assert.deepEqual(called("message.updateUid")[0]?.args, [
+			"new-msg",
+			20,
+			"dst-mbx",
+		]);
+	});
+
+	it("runs a copy enqueued with the pathless payload", async () => {
+		const pathless: MessageCopyEvent = {
+			type: "MESSAGE_COPY",
+			schemaVersion: 3,
+			eventId: "evt-1",
+			timestamp: 1,
+			accountId: "acc-1",
+			sourceMessageId: "src-msg",
+			newMessageId: "new-msg",
+			sourceMailboxId: "src-mbx",
+			destinationMailboxId: "dst-mbx",
+			uid: 10,
+		};
+
+		await handleMessageCopy(pathless, noopLogger, 1, deps());
+
+		assert.deepEqual(called("openBox")[0]?.args, ["INBOX", true]);
+		assert.deepEqual(called("copyMessages")[0]?.args, [[10], "Archive"]);
+	});
+
+	it("copies between the paths the rows hold when both folders were renamed after enqueue", async () => {
+		h.folderPaths = { "src-mbx": "Old/INBOX", "dst-mbx": "Records/Archive" };
+
+		await handleMessageCopy(event, noopLogger, 1, deps());
+
+		assert.deepEqual(called("openBox")[0]?.args, ["Old/INBOX", true]);
+		assert.deepEqual(called("copyMessages")[0]?.args, [
+			[10],
+			"Records/Archive",
+		]);
+	});
+
+	it("reconciles the copy row away without connecting when the destination mailbox was deleted", async () => {
+		h.goneMailboxIds = ["dst-mbx"];
+
+		await handleMessageCopy(event, noopLogger, 1, deps());
+
+		assert.equal(h.getConnectionCount, 0);
+		assert.equal(called("copyMessages").length, 0);
+		assert.deepEqual(called("message.delete")[0]?.args, ["new-msg"]);
+	});
 });

package/src/handlers/message-copy.ts

@@ -1,5 +1,4 @@
 import { getClient } from "@remit/backend/client";
-import { isNotFoundError } from "@remit/data-ports/errors";
 import {
 	MessageMutation,
 	MessageStatus,
@@ -18,6 +17,7 @@ import { isAccountDeleted } from "../account-check.js";
 import { createConnectionScopeWithCredentials } from "../connection-scope.js";
 import { emitEvent } from "../emit.js";
 import type { MessageCopyEvent } from "../events.js";
+import { findMailboxRow } from "../mailbox-row.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 import {
@@ -108,8 +108,6 @@ export const handleMessageCopy = async (
 		sourceMessageId,
 		newMessageId,
 		sourceMailboxId,
-		sourceMailboxPath,
-		destinationMailboxPath,
 		destinationMailboxId,
 		uid,
 	} = event;
@@ -120,8 +118,8 @@ export const handleMessageCopy = async (
 			accountId,
 			sourceMessageId,
 			newMessageId,
-			from: sourceMailboxPath,
-			to: destinationMailboxPath,
+			from: sourceMailboxId,
+			to: destinationMailboxId,
 		},
 		"Handling event",
 	);
@@ -173,19 +171,46 @@ export const handleMessageCopy = async (
 			// NotFoundError forever, and on the account's per-group FIFO that head
 			// message stalls the whole pipeline (issues #287, #289, #290). A deleted
 			// source mailbox makes the copy moot: ack with a WARN.
-			const mailbox = await mailboxService
-				.get(accountId, sourceMailboxId)
-				.catch((error: unknown) => {
-					if (isNotFoundError(error)) return null;
-					throw error;
-				});
-			if (!mailbox) {
+			const source = await findMailboxRow(
+				mailboxService,
+				accountId,
+				sourceMailboxId,
+			);
+			if (source.kind === "gone") {
 				log.warn(
 					{ accountId, sourceMessageId, mailboxId: sourceMailboxId },
 					"Skipping MESSAGE_COPY: source mailbox no longer exists (deleted)",
 				);
 				return;
 			}
+			const mailbox = source.mailbox;
+			const sourceMailboxPath = mailbox.fullPath;
+
+			const destination = await findMailboxRow(
+				mailboxService,
+				accountId,
+				destinationMailboxId,
+			);
+			if (destination.kind === "gone") {
+				const { threadMessagesDeleted } = await reconcileStaleMessage(
+					{ messageService, threadMessageService },
+					account.accountConfigId,
+					newMessageId,
+				);
+				log.warn(
+					{
+						metric: "message_copy_destination_gone",
+						accountId,
+						sourceMessageId,
+						newMessageId,
+						mailboxId: destinationMailboxId,
+						threadMessagesDeleted,
+					},
+					"Skipping MESSAGE_COPY: destination mailbox no longer exists (deleted); optimistic copy row reconciled away",
+				);
+				return;
+			}
+			const destinationMailboxPath = destination.mailbox.fullPath;
 
 			// The copy row carries the source's Message-ID header, so the
 			// destination can be asked where this copy is. Always on the UNGUARDED

package/src/handlers/message-delete.test.ts

@@ -291,6 +291,8 @@ interface Harness {
 	} | null;
 	mailbox: { mailboxId: string; uidValidity: number; cursorState?: string };
 	mailboxError?: Error;
+	folderPaths: Record<string, string>;
+	goneMailboxIds: string[];
 	connection: Connection;
 	threadMessageUpdateError?: Error;
 	messageRow: { messageIdHeader?: string; status?: string } | undefined;
@@ -398,6 +400,8 @@ const fresh = (): Harness => ({
 	calls: [],
 	account: { accountId: "acc-1", accountConfigId: "cfg-1" },
 	mailbox: { mailboxId: "src-mbx", uidValidity: 1, cursorState: undefined },
+	folderPaths: { "src-mbx": "INBOX", "trash-mbx": "Trash" },
+	goneMailboxIds: [],
 	// What the API writes before it enqueues: a move to Trash records `moving`,
 	// a permanent delete records `deleting`, and the handler's guard asks one
 	// question of both — is a mutation still outstanding on this row.
@@ -457,9 +461,18 @@ const deps = (): MessageDeleteDeps =>
 				deleteMany: record("threadMessage.deleteMany"),
 			},
 			mailbox: {
-				get: async () => {
+				get: async (_accountId: string, mailboxId: string) => {
 					if (h.mailboxError) throw h.mailboxError;
-					return h.mailbox;
+					if (h.goneMailboxIds.includes(mailboxId)) {
+						throw Object.assign(new Error(`Mailbox not found: ${mailboxId}`), {
+							name: "NotFoundError",
+						});
+					}
+					const row =
+						mailboxId === h.mailbox.mailboxId
+							? h.mailbox
+							: { mailboxId, uidValidity: 1, cursorState: "normal" };
+					return { ...row, fullPath: h.folderPaths[mailboxId] };
 				},
 				update: record("mailbox.update"),
 			},
@@ -1739,3 +1752,118 @@ describe("handleMessageDelete", () => {
 		);
 	});
 });
+
+describe("handleMessageDelete — folder paths come from the mailbox rows", () => {
+	beforeEach(() => {
+		h = fresh();
+	});
+
+	const movedTo = (): string[] => {
+		const destinations: string[] = [];
+		h.connection.moveMessages = async (
+			_uids: number[],
+			destination: string,
+		) => {
+			destinations.push(destination);
+			return { uidMap: new Map([[10, 20]]) };
+		};
+		return destinations;
+	};
+
+	it("runs a delete enqueued with the version 2 payload that carries folder paths", async () => {
+		const destinations = movedTo();
+
+		await handleMessageDelete(moveEvent, noopLogger, 1, deps());
+
+		assert.deepEqual(destinations, ["Trash"]);
+		assert.deepEqual(called("message.updateUid")[0]?.args, [
+			"msg-1",
+			20,
+			"trash-mbx",
+		]);
+	});
+
+	it("runs a delete enqueued with the pathless payload", async () => {
+		const destinations = movedTo();
+		const pathless: MessageDeleteEvent = {
+			type: "MESSAGE_DELETE",
+			schemaVersion: 3,
+			eventId: "evt-1",
+			timestamp: 1,
+			accountId: "acc-1",
+			messageId: "msg-1",
+			mailboxId: "src-mbx",
+			uid: 10,
+			operation: "move_to_trash",
+			destinationMailboxId: "trash-mbx",
+		};
+
+		await handleMessageDelete(pathless, noopLogger, 1, deps());
+
+		assert.deepEqual(destinations, ["Trash"]);
+		assert.deepEqual(called("message.updateUid")[0]?.args, [
+			"msg-1",
+			20,
+			"trash-mbx",
+		]);
+	});
+
+	it("moves to Trash under its current path when the folder was renamed after enqueue", async () => {
+		const destinations = movedTo();
+		const opened: string[] = [];
+		const openBox = h.connection.openBox;
+		h.connection.openBox = async (path: string) => {
+			opened.push(path);
+			return openBox(path);
+		};
+		h.folderPaths = { "src-mbx": "Mail/INBOX", "trash-mbx": "Deleted Items" };
+
+		await handleMessageDelete(moveEvent, noopLogger, 1, deps());
+
+		assert.equal(opened[0], "Mail/INBOX");
+		assert.deepEqual(destinations, ["Deleted Items"]);
+	});
+
+	it("opens the source under its current path when it was renamed after enqueue", async () => {
+		const destinations = movedTo();
+		const opened: string[] = [];
+		const openBox = h.connection.openBox;
+		h.connection.openBox = async (path: string) => {
+			opened.push(path);
+			return openBox(path);
+		};
+		h.folderPaths = { "src-mbx": "Old/Inbox-renamed", "trash-mbx": "Trash" };
+
+		await handleMessageDelete(moveEvent, noopLogger, 1, deps());
+
+		assert.equal(opened[0], "Old/Inbox-renamed");
+		assert.deepEqual(destinations, ["Trash"]);
+	});
+
+	it("resyncs the source when a redelivered delete finds the Trash mailbox deleted", async () => {
+		h.goneMailboxIds = ["trash-mbx"];
+
+		await handleMessageDelete(moveEvent, noopLogger, 2, deps());
+
+		assert.deepEqual(called("emitEvent")[0]?.args, [
+			{ type: "SYNC_MESSAGES", accountId: "acc-1", mailboxId: "src-mbx" },
+		]);
+	});
+
+	it("hands the row back without connecting when the Trash mailbox was deleted", async () => {
+		h.goneMailboxIds = ["trash-mbx"];
+		const destinations = movedTo();
+
+		await handleMessageDelete(moveEvent, capturingLog(), 1, deps());
+
+		assert.equal(h.getConnectionCount, 0);
+		assert.deepEqual(destinations, []);
+		assert.equal(called("connection.deleteMessages").length, 0);
+		assert.equal(called("message.delete").length, 0);
+		assert.deepEqual(restoreCalls()[0]?.args, restoredToSource("abandoned"));
+		assert.equal(
+			loggedWith("alert", "message_delete_destination_gone").length,
+			1,
+		);
+	});
+});

package/src/handlers/message-delete.ts

@@ -4,8 +4,7 @@ import type {
 	IThreadMessageRepository,
 	MessageItem,
 } from "@remit/data-ports";
-import { isNotFoundError } from "@remit/data-ports/errors";
-import { isCurrentSchemaVersion } from "@remit/data-ports/mutation-events";
+import { isAcceptedSchemaVersion } from "@remit/data-ports/mutation-events";
 import {
 	MessageMutation,
 	MessageStatus,
@@ -27,6 +26,7 @@ import { isAccountDeleted } from "../account-check.js";
 import { createConnectionScopeWithCredentials } from "../connection-scope.js";
 import { emitEvent } from "../emit.js";
 import type { MessageDeleteEvent } from "../events.js";
+import { findMailboxRow } from "../mailbox-row.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 import { resolveExhaustedMessageDeleteFailure } from "./message-delete-terminal.js";
@@ -38,6 +38,11 @@ import {
 	searchMailboxForHighestMessageIdUid,
 } from "./message-move.js";
 
+interface FolderPaths {
+	source: string;
+	destination: string | undefined;
+}
+
 export const getMessageDeleteMaxAttempts = (
 	processEnv: NodeJS.ProcessEnv = process.env,
 ): number => attemptBudget("MESSAGE_DELETE_MAX_ATTEMPTS", 3, processEnv);
@@ -179,15 +184,13 @@ export const handleMessageDelete = async (
 		accountId,
 		messageId,
 		mailboxId,
-		mailboxPath,
 		uid,
 		operation,
 		destinationMailboxId,
-		destinationMailboxPath,
 	} = event;
 
 	log.info(
-		{ event: event.type, accountId, messageId, mailboxPath, operation },
+		{ event: event.type, accountId, messageId, mailboxId, operation },
 		"Handling event",
 	);
 
@@ -308,7 +311,7 @@ export const handleMessageDelete = async (
 			accountId,
 			messageId,
 			uid,
-			mailboxPath,
+			mailboxId,
 			operation,
 			receiveCount,
 			reason,
@@ -431,8 +434,10 @@ export const handleMessageDelete = async (
 	const settlePausedDelete = async (
 		getRawConnection: () => Promise<IImapConnection>,
 		commandIssued: boolean,
+		paths: FolderPaths,
 	): Promise<void> => {
 		const mayHaveIssued = commandIssued || receiveCount > 1;
+		const destinationMailboxPath = paths.destination;
 		const isProbeableTrashMove =
 			mayHaveIssued &&
 			operation === "move_to_trash" &&
@@ -443,7 +448,7 @@ export const handleMessageDelete = async (
 			? await probePausedPlacement(await getRawConnection(), {
 					messageIdHeader: (await messageService.get([messageId]))[0]
 						?.messageIdHeader,
-					sourceMailboxPath: mailboxPath,
+					sourceMailboxPath: paths.source,
 					destinationMailboxPath,
 				})
 			: { kind: "at-source" };
@@ -486,6 +491,7 @@ export const handleMessageDelete = async (
 
 	const settleExhaustedDelete = async (
 		accountConfigId: string,
+		sourceMailboxPath: string,
 		getConnection: () => Promise<IImapConnection>,
 		settlePaused: () => Promise<void>,
 	): Promise<void> => {
@@ -497,7 +503,7 @@ export const handleMessageDelete = async (
 				messageId,
 				sourceMailboxId: mailboxId,
 				uid,
-				sourceMailboxPath: mailboxPath,
+				sourceMailboxPath,
 				getConnection,
 			},
 		).catch(async (settleError: unknown) => {
@@ -542,6 +548,7 @@ export const handleMessageDelete = async (
 	const settleUnconfirmedTrashMove = async (
 		confirmation: Exclude<TrashMoveConfirmation, { outcome: "confirmed" }>,
 		accountConfigId: string,
+		sourceMailboxPath: string,
 		getConnection: () => Promise<IImapConnection>,
 		settlePaused: () => Promise<void>,
 	): Promise<void> => {
@@ -550,7 +557,7 @@ export const handleMessageDelete = async (
 			accountConfigId,
 			messageId,
 			uid,
-			mailboxPath,
+			mailboxId,
 			receiveCount,
 			confirmation: confirmation.outcome,
 		};
@@ -569,7 +576,12 @@ export const handleMessageDelete = async (
 				context,
 				"Move to trash carries no Message-ID header to probe the destination with; settling on the source's answer alone",
 			);
-			await settleExhaustedDelete(accountConfigId, getConnection, settlePaused);
+			await settleExhaustedDelete(
+				accountConfigId,
+				sourceMailboxPath,
+				getConnection,
+				settlePaused,
+			);
 			return;
 		}
 
@@ -578,7 +590,7 @@ export const handleMessageDelete = async (
 		);
 	};
 
-	if (!isCurrentSchemaVersion(event.schemaVersion)) {
+	if (!isAcceptedSchemaVersion(event.schemaVersion)) {
 		await abandonDelete(
 			"Refused to delete: event was minted under an unknown contract",
 			"message_delete_unknown_schema_version",
@@ -596,19 +608,39 @@ export const handleMessageDelete = async (
 			// NotFoundError forever, and on the account's per-group FIFO that head
 			// message stalls the whole pipeline (issues #287, #289, #290). A deleted
 			// mailbox makes the delete moot: ack with a WARN.
-			const mailbox = await mailboxService
-				.get(accountId, mailboxId)
-				.catch((error: unknown) => {
-					if (isNotFoundError(error)) return null;
-					throw error;
-				});
-			if (!mailbox) {
+			const source = await findMailboxRow(mailboxService, accountId, mailboxId);
+			if (source.kind === "gone") {
 				log.warn(
 					{ accountId, messageId, mailboxId },
 					"Skipping MESSAGE_DELETE: mailbox no longer exists (deleted)",
 				);
 				return;
 			}
+			const mailbox = source.mailbox;
+
+			const destination =
+				operation === "move_to_trash" && destinationMailboxId !== undefined
+					? await findMailboxRow(
+							mailboxService,
+							accountId,
+							destinationMailboxId,
+						)
+					: undefined;
+			if (destination?.kind === "gone") {
+				await abandonDelete(
+					"Refused to delete: the destination mailbox no longer exists (deleted)",
+					"message_delete_destination_gone",
+				);
+				await emitMailboxResync(emitEvent, { accountId, mailboxId });
+				return;
+			}
+
+			const mailboxPath = mailbox.fullPath;
+			const destinationMailboxPath = destination?.mailbox.fullPath;
+			const paths: FolderPaths = {
+				source: mailboxPath,
+				destination: destinationMailboxPath,
+			};
 
 			const scope = createConnectionScopeWithCredentials(account, credentials);
 
@@ -628,7 +660,7 @@ export const handleMessageDelete = async (
 				);
 
 			const settlePaused = (commandIssued: boolean): Promise<void> =>
-				settlePausedDelete(scope.getConnection, commandIssued);
+				settlePausedDelete(scope.getConnection, commandIssued, paths);
 
 			// Flipped the instant the MOVE or the EXPUNGE leaves, so every settle
 			// downstream of it knows the server was asked.
@@ -734,6 +766,7 @@ export const handleMessageDelete = async (
 						await settleUnconfirmedTrashMove(
 							confirmation,
 							account.accountConfigId,
+							mailboxPath,
 							getGuardedConnection,
 							() => settlePaused(true),
 						);
@@ -843,6 +876,7 @@ export const handleMessageDelete = async (
 					// failure this budget exists for.
 					await settleExhaustedDelete(
 						account.accountConfigId,
+						mailboxPath,
 						getGuardedConnection,
 						() => settlePaused(commandIssued),
 					);

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

@@ -423,7 +423,19 @@ describe("handleMessageMove — the move's own pending state gates every attempt
 				messageIdHeader: options.probeable ? "<moved@example.com>" : undefined,
 			},
 		]);
-		mock.method(client.mailbox, "get", async () => pausedSource());
+		mock.method(
+			client.mailbox,
+			"get",
+			async (_accountId: string, id: string) =>
+				id === "mm-src-zzz"
+					? { ...pausedSource(), fullPath: "INBOX" }
+					: {
+							mailboxId: id,
+							uidValidity: 1,
+							cursorState: "normal",
+							fullPath: "Archive",
+						},
+		);
 		const transitionCalls: unknown[][] = [];
 		mock.method(
 			client.message,
@@ -616,6 +628,161 @@ describe("handleMessageMove — the move's own pending state gates every attempt
 		});
 	});
 
+	const arrangeLiveMove = async (
+		folders: Record<string, string>,
+	): Promise<{
+		opened: string[];
+		movedTo: string[];
+		updateUidCalls: unknown[][];
+		transitionCalls: unknown[][];
+		connection: IImapConnection;
+	}> => {
+		const client = await getClient();
+		mock.method(client.account, "get", async () => cappedAccount());
+		mock.method(client.secrets, "decrypt", async () => "fake-password");
+		mock.method(client.message, "get", async () => [pendingRow()]);
+		mock.method(
+			client.mailbox,
+			"get",
+			async (_accountId: string, id: string) => {
+				const fullPath = folders[id];
+				if (fullPath === undefined) {
+					throw Object.assign(new Error(`Mailbox not found: ${id}`), {
+						name: "NotFoundError",
+					});
+				}
+				return {
+					mailboxId: id,
+					uidValidity: 1,
+					cursorState: "normal",
+					fullPath,
+				};
+			},
+		);
+		const updateUidCalls: unknown[][] = [];
+		mock.method(client.message, "updateUid", async (...args: unknown[]) => {
+			updateUidCalls.push(args);
+		});
+		const transitionCalls: unknown[][] = [];
+		mock.method(
+			client.message,
+			"transitionPlacement",
+			async (...args: unknown[]) => {
+				transitionCalls.push(args);
+				return { messageId: "mm-msg-zzz" };
+			},
+		);
+		const opened: string[] = [];
+		const movedTo: string[] = [];
+		const connection = {
+			openBox: async (path: string) => {
+				opened.push(path);
+				return { uidvalidity: 1 } as never;
+			},
+			moveMessages: async (_uids: number[], destination: string) => {
+				movedTo.push(destination);
+				return { uidMap: new Map([[10, 44]]) };
+			},
+		} as unknown as IImapConnection;
+		return { opened, movedTo, updateUidCalls, transitionCalls, connection };
+	};
+
+	it("runs a move enqueued with the unversioned payload that carries folder paths", async () => {
+		const { movedTo, updateUidCalls, connection } = await arrangeLiveMove({
+			"mm-src-zzz": "INBOX",
+			"mm-dst-zzz": "Archive",
+		});
+
+		await handleMessageMove(event, silentLogger, 1, moveDeps(connection));
+
+		assert.deepEqual(movedTo, ["Archive"]);
+		assert.deepEqual(updateUidCalls[0], ["mm-msg-zzz", 44, "mm-dst-zzz"]);
+	});
+
+	it("runs a move enqueued with the pathless payload", async () => {
+		const { opened, movedTo, connection } = await arrangeLiveMove({
+			"mm-src-zzz": "INBOX",
+			"mm-dst-zzz": "Archive",
+		});
+		const pathless: MessageMoveEvent = {
+			type: "MESSAGE_MOVE",
+			schemaVersion: 3,
+			accountId: acctId,
+			messageId: "mm-msg-zzz",
+			sourceMailboxId: "mm-src-zzz",
+			destinationMailboxId: "mm-dst-zzz",
+			uid: 10,
+			eventId: "mm-evt-zzz",
+			timestamp: 1700000000000,
+		};
+
+		await handleMessageMove(pathless, silentLogger, 1, moveDeps(connection));
+
+		assert.deepEqual(opened, ["INBOX"]);
+		assert.deepEqual(movedTo, ["Archive"]);
+	});
+
+	it("moves under the destination's current path when the folder was renamed after enqueue", async () => {
+		const { opened, movedTo, updateUidCalls, connection } =
+			await arrangeLiveMove({
+				"mm-src-zzz": "INBOX",
+				"mm-dst-zzz": "Records",
+			});
+
+		await handleMessageMove(event, silentLogger, 1, moveDeps(connection));
+
+		assert.deepEqual(opened, ["INBOX"]);
+		assert.deepEqual(
+			movedTo,
+			["Records"],
+			"the payload still says Archive; the row says where the folder is now",
+		);
+		assert.deepEqual(updateUidCalls[0], ["mm-msg-zzz", 44, "mm-dst-zzz"]);
+	});
+
+	it("opens the source under its current path when it was renamed after enqueue", async () => {
+		const { opened, movedTo, connection } = await arrangeLiveMove({
+			"mm-src-zzz": "Old/Inbox-renamed",
+			"mm-dst-zzz": "Archive",
+		});
+
+		await handleMessageMove(event, silentLogger, 1, moveDeps(connection));
+
+		assert.deepEqual(
+			opened,
+			["Old/Inbox-renamed"],
+			"the payload still says INBOX; the row says where the folder is now",
+		);
+		assert.deepEqual(movedTo, ["Archive"]);
+	});
+
+	it("hands the row back to its source without connecting when the destination mailbox was deleted", async () => {
+		const { transitionCalls, updateUidCalls } = await arrangeLiveMove({
+			"mm-src-zzz": "INBOX",
+		});
+
+		await handleMessageMove(event, capturingLogger(), 1, moveDeps());
+
+		assert.equal(connectCount, 0);
+		assert.equal(updateUidCalls.length, 0);
+		assert.deepEqual(transitionCalls[0]?.[2], {
+			mailboxId: "mm-src-zzz",
+			uid: 10,
+			status: "active",
+			syncStatus: "synced",
+			abandonedMutation: "none",
+		});
+		assert.equal(
+			logLines.filter(
+				(line) => line.fields.metric === "message_move_destination_gone",
+			).length,
+			1,
+		);
+		assert.deepEqual(emitted, [
+			{ type: "SYNC_MESSAGES", accountId: acctId, mailboxId: "mm-src-zzz" },
+		]);
+	});
+
 	it("acks without connecting when the message row is already gone", async () => {
 		const client = await getClient();
 		mock.method(client.account, "get", async () => cappedAccount());

package/src/handlers/message-move.ts

@@ -1,6 +1,5 @@
 import { getClient } from "@remit/backend/client";
 import type { MessageItem, ThreadMessageItem } from "@remit/data-ports";
-import { isNotFoundError } from "@remit/data-ports/errors";
 import {
 	MessageMutation,
 	MessageStatus,
@@ -20,6 +19,7 @@ import { isAccountDeleted } from "../account-check.js";
 import { createConnectionScopeWithCredentials } from "../connection-scope.js";
 import { emitEvent } from "../emit.js";
 import type { MessageMoveEvent, SyncMessagesEvent } from "../events.js";
+import { findMailboxRow } from "../mailbox-row.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 import { resolveExhaustedMessageMoveFailure } from "./message-move-terminal.js";
@@ -278,23 +278,16 @@ export const handleMessageMove = async (
 		secrets,
 	} = await getClient();
 
-	const {
-		accountId,
-		messageId,
-		sourceMailboxId,
-		sourceMailboxPath,
-		destinationMailboxPath,
-		destinationMailboxId,
-		uid,
-	} = event;
+	const { accountId, messageId, sourceMailboxId, destinationMailboxId, uid } =
+		event;
 
 	log.info(
 		{
 			event: event.type,
 			accountId,
 			messageId,
-			from: sourceMailboxPath,
-			to: destinationMailboxPath,
+			from: sourceMailboxId,
+			to: destinationMailboxId,
 		},
 		"Handling event",
 	);
@@ -349,19 +342,25 @@ export const handleMessageMove = async (
 			// NotFoundError forever, and on the account's per-group FIFO that head
 			// message stalls the whole pipeline (issues #287, #289, #290). A deleted
 			// source mailbox makes the move moot: ack with a WARN.
-			const mailbox = await mailboxService
-				.get(accountId, sourceMailboxId)
-				.catch((error: unknown) => {
-					if (isNotFoundError(error)) return null;
-					throw error;
-				});
-			if (!mailbox) {
+			const source = await findMailboxRow(
+				mailboxService,
+				accountId,
+				sourceMailboxId,
+			);
+			if (source.kind === "gone") {
 				log.warn(
 					{ accountId, messageId, mailboxId: sourceMailboxId },
 					"Skipping MESSAGE_MOVE: source mailbox no longer exists (deleted)",
 				);
 				return;
 			}
+			const mailbox = source.mailbox;
+			const sourceMailboxPath = mailbox.fullPath;
+			const destination = await findMailboxRow(
+				mailboxService,
+				accountId,
+				destinationMailboxId,
+			);
 
 			const settleMoved = async (newUid: number): Promise<void> => {
 				await messageService.updateUid(messageId, newUid, destinationMailboxId);
@@ -389,7 +388,7 @@ export const handleMessageMove = async (
 						messageId,
 						oldUid: uid,
 						newUid,
-						destination: destinationMailboxPath,
+						destination: destinationMailboxId,
 					},
 					"Message moved successfully",
 				);
@@ -413,8 +412,8 @@ export const handleMessageMove = async (
 					accountId,
 					messageId,
 					uid,
-					sourceMailboxPath,
-					destinationMailboxPath,
+					sourceMailboxId,
+					destinationMailboxId,
 					receiveCount,
 					reason,
 				};
@@ -449,6 +448,20 @@ export const handleMessageMove = async (
 				);
 			};
 
+			if (destination.kind === "gone") {
+				await handBackToSource(
+					MessageSyncStatus.synced,
+					{ metric: "message_move_destination_gone" },
+					"destination mailbox no longer exists (deleted)",
+				);
+				await emitMailboxResync(emitEvent, {
+					accountId,
+					mailboxId: sourceMailboxId,
+				});
+				return;
+			}
+			const destinationMailboxPath = destination.mailbox.fullPath;
+
 			const scope = createConnectionScopeWithCredentials(account, credentials);
 
 			// The terminal resolver opens the source itself, and its answer now

package/src/mailbox-row.ts

@@ -0,0 +1,20 @@
+import type { IMailboxRepository, MailboxItem } from "@remit/data-ports";
+import { isNotFoundError } from "@remit/data-ports/errors";
+
+export type MailboxRow =
+	| { kind: "present"; mailbox: MailboxItem }
+	| { kind: "gone"; mailboxId: string };
+
+export const findMailboxRow = (
+	mailboxService: Pick<IMailboxRepository, "get">,
+	accountId: string,
+	mailboxId: string,
+): Promise<MailboxRow> =>
+	mailboxService.get(accountId, mailboxId).then(
+		(mailbox): MailboxRow =>
+			mailbox ? { kind: "present", mailbox } : { kind: "gone", mailboxId },
+		(error: unknown): MailboxRow => {
+			if (isNotFoundError(error)) return { kind: "gone", mailboxId };
+			throw error;
+		},
+	);