@remit/imap-worker 0.0.85 → 0.0.87

package/src/pending-sync.sqlite.test.ts

@@ -0,0 +1,167 @@
+import assert from "node:assert/strict";
+import { afterEach, before, beforeEach, describe, it } from "node:test";
+import { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
+import {
+	_resetForTest,
+	type RemitClient,
+	setClient,
+} from "@remit/backend/client";
+import { MailboxLockRepo } from "@remit/drizzle-service";
+import { createShippedSqliteDb } from "@remit/drizzle-service/test-sqlite";
+import { mockClient } from "aws-sdk-client-mock";
+import type * as Emit from "./emit.js";
+import type { SyncMessagesEvent } from "./events.js";
+import { emitMailboxResync, emitMoveResync } from "./handlers/message-move.js";
+import { emitSyncMessagesEvents } from "./handlers/sync-mailboxes.js";
+
+const ACCOUNT = "account-1366";
+const FOLDERS = [
+	{ mailboxId: "mbx-inbox", fullPath: "INBOX" },
+	{ mailboxId: "mbx-sent", fullPath: "Sent" },
+	{ mailboxId: "mbx-archive", fullPath: "Archive" },
+];
+
+const sqsMock = mockClient(SQSClient);
+
+let emitEvent: typeof Emit.emitEvent;
+let SYNC_MESSAGES_PENDING: typeof Emit.SYNC_MESSAGES_PENDING;
+let locks: MailboxLockRepo;
+let closeStore: () => void;
+
+type Queued = { mailboxId: string; eventId: string };
+
+const queued = (): Queued[] =>
+	sqsMock.commandCalls(SendMessageCommand).map((call) => {
+		const body = JSON.parse(call.args[0].input.MessageBody ?? "{}") as Queued;
+		return { mailboxId: body.mailboxId, eventId: body.eventId };
+	});
+
+const inboxSync = (): Omit<SyncMessagesEvent, "eventId" | "timestamp"> => ({
+	type: "SYNC_MESSAGES",
+	accountId: ACCOUNT,
+	mailboxId: "mbx-inbox",
+});
+
+const fanOut = (): Promise<void> =>
+	emitSyncMessagesEvents(ACCOUNT, FOLDERS, emitEvent);
+
+before(async () => {
+	const fifo = (name: string) =>
+		`https://sqs.eu-west-1.amazonaws.com/0/test-${name}.fifo`;
+	process.env.SQS_QUEUE_URL_MAILBOXES = fifo("mailboxes");
+	process.env.SQS_QUEUE_URL_MESSAGES = fifo("messages");
+	process.env.SQS_QUEUE_URL_FLAGS = fifo("flags");
+	({ emitEvent, SYNC_MESSAGES_PENDING } = await import("./emit.js"));
+});
+
+beforeEach(() => {
+	sqsMock.reset();
+	sqsMock.on(SendMessageCommand).resolves({});
+	const store = createShippedSqliteDb();
+	closeStore = store.close;
+	locks = new MailboxLockRepo(store.db);
+	setClient({ mailboxLock: locks } as unknown as RemitClient);
+});
+
+afterEach(() => {
+	_resetForTest();
+	closeStore();
+});
+
+describe("SYNC_MESSAGES under explicit refreshes (#1366)", () => {
+	it("queues one event per folder however many rounds arrive while none has started", async () => {
+		for (let round = 0; round < 25; round += 1) await fanOut();
+
+		assert.deepEqual(
+			queued()
+				.map((event) => event.mailboxId)
+				.sort(),
+			["mbx-archive", "mbx-inbox", "mbx-sent"],
+		);
+	});
+
+	it("queues a folder again once its pending sync has started", async () => {
+		await fanOut();
+		const inbox = queued().find((event) => event.mailboxId === "mbx-inbox");
+		if (!inbox) throw new Error("INBOX was not queued");
+
+		await locks.releaseLock(
+			ACCOUNT,
+			inbox.mailboxId,
+			SYNC_MESSAGES_PENDING,
+			inbox.eventId,
+		);
+		await fanOut();
+
+		assert.equal(queued().length, FOLDERS.length + 1);
+		assert.equal(queued().at(-1)?.mailboxId, "mbx-inbox");
+	});
+
+	it("keeps a folder's pending marker when a stale event starts", async () => {
+		await fanOut();
+		await locks.releaseLock(
+			ACCOUNT,
+			"mbx-inbox",
+			SYNC_MESSAGES_PENDING,
+			"an-event-from-before-the-marker",
+		);
+		await fanOut();
+
+		assert.equal(queued().length, FOLDERS.length);
+	});
+
+	it("takes the same marker for a move's resync and a delete's resync", async () => {
+		await emitMoveResync(emitEvent, {
+			accountId: ACCOUNT,
+			sourceMailboxId: "mbx-inbox",
+			destinationMailboxId: "mbx-sent",
+		});
+		await emitMailboxResync(emitEvent, {
+			accountId: ACCOUNT,
+			mailboxId: "mbx-inbox",
+		});
+		await fanOut();
+
+		assert.equal(queued().length, FOLDERS.length);
+	});
+
+	it("takes over a marker whose event was lost once it has expired", async () => {
+		await locks.tryAcquireLock(
+			"mbx-inbox",
+			"SYNC_MESSAGES_PENDING",
+			ACCOUNT,
+			"lost-event",
+			-1,
+		);
+
+		await emitEvent(inboxSync());
+
+		assert.equal(queued().length, 1);
+	});
+
+	it("releases the marker when the send fails, so the next round is not swallowed", async () => {
+		sqsMock
+			.on(SendMessageCommand)
+			.rejectsOnce(new Error("queue unreachable"))
+			.resolves({});
+
+		await assert.rejects(emitEvent(inboxSync()), /queue unreachable/);
+		await emitEvent(inboxSync());
+
+		assert.equal(queued().length, 2);
+	});
+
+	it("fails the operation when the marker store fails", async () => {
+		setClient({
+			mailboxLock: {
+				get: async () => null,
+				tryAcquireLock: async () => {
+					throw new Error("marker store down");
+				},
+			},
+		} as unknown as RemitClient);
+
+		await assert.rejects(emitEvent(inboxSync()), /marker store down/);
+		assert.equal(sqsMock.commandCalls(SendMessageCommand).length, 0);
+	});
+});

package/src/poller.ts

@@ -1,14 +1,15 @@
-import { createLogger, startMetricsServer } from "@remit/logger-lambda";
+import { createLogger } from "@remit/logger";
+import { startMetricsServer } from "@remit/logger-lambda/metrics";
+import { installNodeLogger } from "@remit/logger-lambda/node";
 import { runQueuePoller } from "@remit/sqs-client/poller";
 import { env } from "expect-env";
 import { handler } from "./index.js";
 
+installNodeLogger();
+
 /**
  * Production queue poller — the deployed form of `e2e-processor-shim.ts`.
  * Polls every imap-worker queue and invokes the production Lambda handler.
- * The search-index queue is NOT polled here: it is its own image/deployment
- * (`remit-search-index-worker`), unlike the e2e shim which piggybacks it
- * onto this same process for test convenience.
  */
 const log = createLogger();
 

package/src/processor.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 import type { ImapWorkerStopEvent } from "./events.js";
 import { processEvent } from "./processor.js";
 

package/src/processor.ts

@@ -1,4 +1,4 @@
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 import type { WorkerEvent } from "./events.js";
 import { handleAppendSentMessage } from "./handlers/append-sent-message.js";
 import { handleDeleteAccountObjects } from "./handlers/delete-account-objects.js";

package/src/scheduler/attachment-sweep.sqlite.test.ts

@@ -0,0 +1,74 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import { after, before, describe, it } from "node:test";
+import { openStore, type World } from "../test-helpers/test-world.js";
+import { buildAttachmentSweep } from "./attachment-sweep.js";
+
+let store: Awaited<ReturnType<typeof openStore>>;
+
+before(async () => {
+	store = await openStore();
+});
+
+after(() => store.close());
+
+/**
+ * A draft holding one uploaded file, and one object under the same draft that
+ * no attachment row names — what a browser leaves behind when it uploads and
+ * the reservation lapses before it is completed.
+ */
+const arrange = async (w: World) => {
+	const { outbox, attachmentId } = await w.draft(Buffer.from("q1,q2\n1,2\n"));
+	await w.client.storage.storeOutboxAttachment({
+		accountConfigId: w.account.accountConfigId,
+		accountId: w.account.accountId,
+		outboxMessageId: outbox.outboxMessageId,
+		outboxAttachmentId: `orphan-${randomUUID()}`,
+		content: Buffer.from("left behind"),
+	});
+	return { outboxMessageId: outbox.outboxMessageId, attachmentId };
+};
+
+const storedIds = async (w: World, outboxMessageId: string) =>
+	(
+		await w.client.storage.listOutboxAttachments(
+			w.account.accountConfigId,
+			w.account.accountId,
+			outboxMessageId,
+		)
+	).map((item) => item.outboxAttachmentId);
+
+describe("the outbox attachment sweep", () => {
+	it("removes the objects no attachment row names and keeps the ones that are", async () => {
+		const w = await store.world();
+		const { outboxMessageId, attachmentId } = await arrange(w);
+
+		await buildAttachmentSweep(w.client, w.log)(w.account);
+
+		assert.deepEqual(await storedIds(w, outboxMessageId), [attachmentId]);
+	});
+
+	it("runs for every account on the hosted tick, due a sync or not", async () => {
+		const first = await store.world();
+		const firstDraft = await arrange(first);
+		await first.client.account.update(first.account.accountId, {
+			lastSyncAt: Date.now(),
+		});
+		const second = await store.world();
+		const secondDraft = await arrange(second);
+
+		const { handler } = await import("./handler.js");
+		await handler(
+			{ time: new Date().toISOString() } as never,
+			{} as never,
+			() => {},
+		);
+
+		assert.deepEqual(await storedIds(first, firstDraft.outboxMessageId), [
+			firstDraft.attachmentId,
+		]);
+		assert.deepEqual(await storedIds(second, secondDraft.outboxMessageId), [
+			secondDraft.attachmentId,
+		]);
+	});
+});

package/src/scheduler/attachment-sweep.ts

@@ -1,6 +1,6 @@
 import type { RemitClient } from "@remit/backend/client";
 import type { AccountItem } from "@remit/data-ports";
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 import { sweepAbandonedOutboxAttachments } from "@remit/storage-service";
 /**
  * Collect attachment bytes the database does not know about. Both scheduler

package/src/scheduler/{calendar-subscriptions.test.ts → calendar-subscriptions.sqlite.test.ts}

@@ -1,10 +1,10 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import type { CalendarFeedFetcher } from "@remit/calendar-service";
-import { MemoryCalendarStore } from "@remit/calendar-service/memory-store";
 import type { CalendarCollectionItem } from "@remit/data-ports";
 import { CalendarSource } from "@remit/domain-enums";
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
+import { openStore } from "../test-helpers/test-world.js";
 import { refreshDueCalendarSubscriptions } from "./calendar-subscriptions.js";
 
 const INTERVAL_MS = 15 * 60 * 1000;
@@ -41,27 +41,25 @@ const logged = (): { log: Logger; lines: string[] } => {
 	return { log, lines };
 };
 
+type Client = Awaited<ReturnType<typeof openStore>>["client"];
+
 const subscription = async (
-	store: MemoryCalendarStore,
+	client: Client,
 	urlSegment: string,
 	checkedAt: number,
 ): Promise<CalendarCollectionItem> => {
-	const created = await store.transaction((repos) =>
-		repos.calendarCollection.create({
-			accountConfigId: "account-config-1",
-			urlSegment,
-			displayName: urlSegment,
-			source: CalendarSource.Subscribed,
-			subscriptionUrl: `https://calendar.example/${urlSegment}/private-feedfacecafe.ics`,
-			subscriptionEnabled: true,
-		}),
-	);
-	return store.transaction((repos) =>
-		repos.calendarCollection.update(
-			created.accountConfigId,
-			created.calendarId,
-			{ subscriptionCheckedAt: checkedAt },
-		),
+	const created = await client.calendarCollection.create({
+		accountConfigId: "account-config-1",
+		urlSegment,
+		displayName: urlSegment,
+		source: CalendarSource.Subscribed,
+		subscriptionUrl: `https://calendar.example/${urlSegment}/private-feedfacecafe.ics`,
+		subscriptionEnabled: true,
+	});
+	return client.calendarCollection.update(
+		created.accountConfigId,
+		created.calendarId,
+		{ subscriptionCheckedAt: checkedAt },
 	);
 };
 
@@ -73,29 +71,23 @@ const recording =
 	};
 
 describe("refreshDueCalendarSubscriptions", () => {
-	it("fetches the subscriptions that are due and skips the rest", async () => {
-		const store = new MemoryCalendarStore();
-		const due = await subscription(store, "due", NOW - INTERVAL_MS);
-		await subscription(store, "fresh", NOW - 60_000);
-		const paused = await subscription(store, "paused", 0);
-		await store.transaction((repos) =>
-			repos.calendarCollection.update(
-				paused.accountConfigId,
-				paused.calendarId,
-				{ subscriptionEnabled: false },
-			),
+	it("fetches the subscriptions that are due and skips the rest", async (t) => {
+		const { client, close } = await openStore();
+		t.after(close);
+		const due = await subscription(client, "due", NOW - INTERVAL_MS);
+		await subscription(client, "fresh", NOW - 60_000);
+		const paused = await subscription(client, "paused", 0);
+		await client.calendarCollection.update(
+			paused.accountConfigId,
+			paused.calendarId,
+			{ subscriptionEnabled: false },
 		);
 		const asked: string[] = [];
 
 		const tally = await refreshDueCalendarSubscriptions(
 			{
-				calendarCollection: {
-					listEnabledSubscriptions: () =>
-						store.transaction((repos) =>
-							repos.calendarCollection.listEnabledSubscriptions(),
-						),
-				},
-				calendarUnitOfWork: store,
+				calendarCollection: client.calendarCollection,
+				calendarStore: client.calendarStore,
 				log: logged().log,
 				fetcher: recording(asked, () => new Response(FEED, { status: 200 })),
 			},
@@ -105,30 +97,24 @@ describe("refreshDueCalendarSubscriptions", () => {
 
 		assert.deepEqual(asked, [due.subscriptionUrl]);
 		assert.deepEqual(tally, { refreshed: 1, failed: 0, notDue: 1 });
-		const objects = await store.transaction((repos) =>
-			repos.calendarObject.listByCalendar(due.calendarId),
-		);
+		const objects = await client.calendarObject.listByCalendar(due.calendarId);
 		assert.deepEqual(
 			objects.map((object) => object.summary),
 			["Ferry crossing"],
 		);
 	});
 
-	it("counts a feed that fails, keeps refreshing the others, and never logs an address", async () => {
-		const store = new MemoryCalendarStore();
-		const broken = await subscription(store, "broken", 0);
-		const working = await subscription(store, "working", 0);
+	it("counts a feed that fails, keeps refreshing the others, and never logs an address", async (t) => {
+		const { client, close } = await openStore();
+		t.after(close);
+		const broken = await subscription(client, "broken", 0);
+		const working = await subscription(client, "working", 0);
 		const { log, lines } = logged();
 
 		const tally = await refreshDueCalendarSubscriptions(
 			{
-				calendarCollection: {
-					listEnabledSubscriptions: () =>
-						store.transaction((repos) =>
-							repos.calendarCollection.listEnabledSubscriptions(),
-						),
-				},
-				calendarUnitOfWork: store,
+				calendarCollection: client.calendarCollection,
+				calendarStore: client.calendarStore,
 				log,
 				fetcher: recording([], (url) =>
 					url === broken.subscriptionUrl
@@ -141,13 +127,15 @@ describe("refreshDueCalendarSubscriptions", () => {
 		);
 
 		assert.deepEqual(tally, { refreshed: 1, failed: 1, notDue: 0 });
-		const stored = await store.transaction((repos) =>
-			repos.calendarCollection.get(broken.accountConfigId, broken.calendarId),
+		const stored = await client.calendarCollection.get(
+			broken.accountConfigId,
+			broken.calendarId,
 		);
 		assert.equal(stored.subscriptionError, "the feed answered HTTP 410");
 		assert.equal(stored.subscriptionCheckedAt, NOW);
-		const refreshed = await store.transaction((repos) =>
-			repos.calendarCollection.get(working.accountConfigId, working.calendarId),
+		const refreshed = await client.calendarCollection.get(
+			working.accountConfigId,
+			working.calendarId,
 		);
 		assert.equal(refreshed.subscriptionFetchedAt, NOW);
 		assert.ok(lines.some((line) => line.includes(broken.calendarId)));

package/src/scheduler/calendar-subscriptions.ts

@@ -6,9 +6,9 @@ import {
 } from "@remit/calendar-service";
 import type {
 	ICalendarCollectionRepository,
-	ICalendarUnitOfWork,
+	ICalendarStore,
 } from "@remit/data-ports";
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 import pMap from "p-map";
 
 const REFRESH_CONCURRENCY = 4;
@@ -24,7 +24,7 @@ export interface CalendarSubscriptionRefreshDeps {
 		ICalendarCollectionRepository,
 		"listEnabledSubscriptions"
 	>;
-	calendarUnitOfWork: ICalendarUnitOfWork;
+	calendarStore: ICalendarStore;
 	log: Logger;
 	fetcher?: CalendarFeedFetcher;
 }
@@ -52,7 +52,7 @@ export const refreshDueCalendarSubscriptions = async (
 		due,
 		(collection) =>
 			refreshCalendarSubscription(
-				deps.calendarUnitOfWork,
+				deps.calendarStore,
 				collection,
 				now,
 				deps.fetcher,
@@ -85,7 +85,7 @@ export const refreshDueCalendarSubscriptions = async (
 
 export const buildCalendarSubscriptionRefresh =
 	(
-		client: Pick<RemitClient, "calendarCollection" | "calendarUnitOfWork">,
+		client: Pick<RemitClient, "calendarCollection" | "calendarStore">,
 		log: Logger,
 	): ((
 		now: number,
@@ -95,7 +95,7 @@ export const buildCalendarSubscriptionRefresh =
 		refreshDueCalendarSubscriptions(
 			{
 				calendarCollection: client.calendarCollection,
-				calendarUnitOfWork: client.calendarUnitOfWork,
+				calendarStore: client.calendarStore,
 				log,
 			},
 			now,

package/src/scheduler/half-deleted-accounts.sqlite.test.ts

@@ -0,0 +1,203 @@
+import assert from "node:assert/strict";
+import { randomBytes } from "node:crypto";
+import { after, before, beforeEach, describe, it } from "node:test";
+import type { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
+import { finishHalfDeletedAccounts } from "@remit/backend/account-deletion";
+import type { RemitClient } from "@remit/backend/client";
+import { importConfig } from "@remit/config-transfer";
+import type { AccountItem } from "@remit/data-ports";
+import { AccountAuthType, ConnectionState } from "@remit/domain-enums";
+import { noopLogger } from "@remit/logger";
+import { openStore } from "../test-helpers/test-world.js";
+
+const FANOUT_URL = "http://queue:9324/000000000000/remit-account-fanout";
+
+let store: Awaited<ReturnType<typeof openStore>>;
+let client: RemitClient;
+
+before(async () => {
+	store = await openStore();
+	client = store.client;
+});
+
+after(() => store.close());
+
+const storedId = (): string => randomBytes(13).toString("hex").slice(0, 25);
+
+const configDocument = (accountId: string, email: string) => ({
+	kind: "reader.config",
+	schemaVersion: 1,
+	generator: {
+		app: "reader",
+		version: "v0.1.0",
+		exportedAt: "2026-08-27T09:15:00+02:00",
+	},
+	provenance: { accountConfigId: storedId(), instance: "reader.example.com" },
+	accountConfig: { name: "Imported" },
+	accounts: [
+		{
+			accountId,
+			email,
+			username: email,
+			authType: "password",
+			credentials: { required: "password" },
+			isActive: true,
+			imap: { host: "imap.example.com", port: 993, tls: true, startTls: false },
+			smtp: {
+				enabled: false,
+				host: "",
+				port: 587,
+				tls: false,
+				startTls: false,
+				username: "",
+			},
+			displayName: "",
+			muted: null,
+			composeLanguages: [],
+			signature: { plainText: "", html: "" },
+			folderRoles: [],
+			folderOverrides: [],
+			pinnedFolders: [],
+		},
+	],
+	labels: [],
+	filters: [],
+	addressFlags: [],
+});
+
+const seedAccount = (
+	accountConfigId: string,
+	name: string,
+	extra: { deletedAt?: number } = {},
+): Promise<AccountItem> =>
+	client.account.create({
+		accountConfigId,
+		username: `${name}@example.com`,
+		email: `${name}@example.com`,
+		authType: AccountAuthType.Password,
+		passwordHash: '{"ciphertext":"x"}',
+		imapHost: "imap.example.com",
+		imapPort: 993,
+		imapTls: true,
+		imapStartTls: false,
+		isActive: true,
+		connectionState: ConnectionState.Authenticated,
+		...extra,
+	});
+
+const importAccount = async (email: string): Promise<AccountItem> => {
+	const accountConfigId = storedId();
+	const accountId = storedId();
+	const outcome = await importConfig(
+		{
+			repositories: client,
+			appointFolderRole: async () => {},
+		},
+		{
+			accountConfigId,
+			userId: accountConfigId,
+			document: configDocument(accountId, email),
+			mode: "apply",
+			onExisting: "abort",
+		},
+	);
+	assert.equal(outcome.outcome, "report");
+	return client.account.get(accountId);
+};
+
+const recordingSqs = (sent: SendMessageCommand[], fail = false): SQSClient =>
+	({
+		send: async (command: SendMessageCommand) => {
+			if (fail) throw new Error("queue unreachable");
+			sent.push(command);
+			return {};
+		},
+	}) as unknown as SQSClient;
+
+const heal = (sqsClient: SQSClient) =>
+	finishHalfDeletedAccounts({
+		account: client.account,
+		configImport: client.configImport,
+		sqsClient,
+		accountFanoutQueueUrl: FANOUT_URL,
+		log: noopLogger,
+	});
+
+describe("finishing an account deleted before #1384 on scheduler start", () => {
+	let halfDeleted: AccountItem;
+	let live: AccountItem;
+	let deleted: AccountItem;
+	let imported: AccountItem;
+
+	beforeEach(async () => {
+		const accountConfigId = storedId();
+		live = await seedAccount(accountConfigId, `live-${storedId()}`);
+		halfDeleted = await seedAccount(accountConfigId, `gone-${storedId()}`);
+		await client.account.update(halfDeleted.accountId, { isActive: false });
+		deleted = await seedAccount(accountConfigId, `deleted-${storedId()}`, {
+			deletedAt: 1_700_000_000_000,
+		});
+		await client.account.update(deleted.accountId, { isActive: false });
+		imported = await importAccount(`imported-${storedId()}@example.com`);
+	});
+
+	const allAccounts = () =>
+		client.account.get([
+			halfDeleted.accountId,
+			live.accountId,
+			deleted.accountId,
+			imported.accountId,
+		]);
+
+	it("tombstones it and asks for the same purge a delete asks for", async () => {
+		const sent: SendMessageCommand[] = [];
+
+		await heal(recordingSqs(sent));
+
+		const purges = sent
+			.filter((command) => command.input.QueueUrl === FANOUT_URL)
+			.map((command) => JSON.parse(command.input.MessageBody ?? "{}"));
+		assert.ok(
+			purges.some(
+				(body) =>
+					body.type === "AccountDataPurge" &&
+					body.accountId === halfDeleted.accountId &&
+					body.accountConfigId === halfDeleted.accountConfigId,
+			),
+		);
+		const byId = new Map(
+			(await allAccounts()).map((account) => [account.accountId, account]),
+		);
+		assert.ok(byId.get(halfDeleted.accountId)?.deletedAt);
+		assert.equal(byId.get(live.accountId)?.deletedAt, undefined);
+		assert.equal(byId.get(imported.accountId)?.deletedAt, undefined);
+		assert.equal(byId.get(deleted.accountId)?.deletedAt, 1_700_000_000_000);
+		assert.ok(
+			!purges.some((body) =>
+				[live.accountId, imported.accountId, deleted.accountId].includes(
+					body.accountId,
+				),
+			),
+		);
+	});
+
+	it("does nothing for it on the next start", async () => {
+		await heal(recordingSqs([]));
+		const sent: SendMessageCommand[] = [];
+
+		await heal(recordingSqs(sent));
+
+		assert.ok(
+			!sent.some((command) =>
+				(command.input.MessageBody ?? "").includes(halfDeleted.accountId),
+			),
+		);
+	});
+
+	it("fails the start and leaves it to be found again when the purge cannot be asked for", async () => {
+		await assert.rejects(heal(recordingSqs([], true)), /queue unreachable/);
+
+		const after = await client.account.get(halfDeleted.accountId);
+		assert.equal(after.deletedAt, undefined);
+	});
+});