@remit/mailbox-service 0.0.10 → 0.0.12

package/src/heuristics/classifyRealMail.test.ts

@@ -0,0 +1,242 @@
+/**
+ * Classification against realistic mail, drawn from the senders reported in
+ * issue #45 ("only personal and marketing seem to work").
+ *
+ * The rule table is easy to satisfy with synthetic one-header fixtures and
+ * still wrong on real mail, because real bulk senders set several signals at
+ * once. Every case here carries the full header set the sender actually emits,
+ * so the test fails when rule ORDER regresses even though each individual rule
+ * still works.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { MessageCategory } from "@remit/domain-enums";
+import { simpleParser } from "mailparser";
+import { classifyByHeaders } from "./classifyByHeaders.js";
+
+const classify = async (lines: string[]) =>
+	classifyByHeaders(await simpleParser(Buffer.from(lines.join("\r\n"))));
+
+describe("classifyByHeaders on realistic mail", () => {
+	describe("platform notifications", () => {
+		it("classifies an npm publish notification as automated", async () => {
+			const category = await classify([
+				"From: npm <notifications@npmjs.com>",
+				"To: me@example.com",
+				"Subject: A new version of left-pad was published",
+				"DKIM-Signature: v=1; a=rsa-sha256; d=npmjs.com; s=s1; h=from:to",
+				"Content-Type: text/plain",
+				"",
+				"published",
+			]);
+			assert.equal(category, MessageCategory.automated);
+		});
+
+		it("classifies an npm mail relayed through SES as automated", async () => {
+			const category = await classify([
+				"Return-Path: <bounces@amazonses.com>",
+				"From: npm <support@npmjs.com>",
+				"To: me@example.com",
+				"Subject: A new device signed in to your npm account",
+				"Feedback-ID: 1.eu-west-1.abc:AmazonSES",
+				"DKIM-Signature: v=1; a=rsa-sha256; d=amazonses.com; s=x; h=from:to",
+				"Content-Type: text/html",
+				"",
+				"<p>signed in</p>",
+			]);
+			assert.equal(category, MessageCategory.automated);
+		});
+
+		it("classifies a no-reply notification with no bulk headers as automated", async () => {
+			// The reported npm case: one-to-one machine mail, aligned DKIM, and no
+			// List-* or Precedence header at all. It used to reach the `personal`
+			// fallback and sit among real correspondence.
+			const category = await classify([
+				"From: CircleCI <no-reply@circleci.com>",
+				"To: me@example.com",
+				"Subject: Your build failed",
+				"DKIM-Signature: v=1; a=rsa-sha256; d=circleci.com; s=s1; h=from:to",
+				"Content-Type: text/plain",
+				"",
+				"build failed",
+			]);
+			assert.equal(category, MessageCategory.automated);
+		});
+
+		it("classifies X-Auto-Response-Suppress mail as automated", async () => {
+			const category = await classify([
+				"From: Helpdesk <ticketing@corp.example>",
+				"To: me@example.com",
+				"Subject: Ticket 4711 updated",
+				"X-Auto-Response-Suppress: All",
+				"Content-Type: text/plain",
+				"",
+				"updated",
+			]);
+			assert.equal(category, MessageCategory.automated);
+		});
+	});
+
+	describe("allow-listed sender domains outrank bulk headers", () => {
+		it("classifies a GitHub pull-request notification as transactional", async () => {
+			// GitHub sets List-ID, List-Unsubscribe AND Precedence: list. Before the
+			// reorder, Precedence matched first and every GitHub mail — security
+			// alerts and receipts included — landed in `automated`, contradicting
+			// the reason GitHub is on the transactional allow-list at all.
+			const category = await classify([
+				"From: contributor <notifications@github.com>",
+				"To: me@example.com",
+				"Subject: Re: [org/repo] Fix the thing (PR #45)",
+				"List-ID: org/repo <repo.org.github.com>",
+				"List-Unsubscribe: <https://github.com/unsub>",
+				"Precedence: list",
+				"DKIM-Signature: v=1; a=rsa-sha256; d=github.com; s=pf2014; h=from:to",
+				"Content-Type: text/plain",
+				"",
+				"comment",
+			]);
+			assert.equal(category, MessageCategory.transactional);
+		});
+
+		it("classifies a GitHub security alert as transactional", async () => {
+			const category = await classify([
+				"From: GitHub <noreply@github.com>",
+				"To: me@example.com",
+				"Subject: [org/repo] Dependabot alert",
+				"Precedence: bulk",
+				"Content-Type: text/plain",
+				"",
+				"alert",
+			]);
+			assert.equal(category, MessageCategory.transactional);
+		});
+
+		it("classifies a LinkedIn notification as social", async () => {
+			// The reported LinkedIn case. List-Unsubscribe matched before the social
+			// allow-list, so LinkedIn mail was filed as generic `marketing` and the
+			// Social bucket stayed empty.
+			const category = await classify([
+				"Return-Path: <s-hbhcfzp@bounce.linkedin.com>",
+				"From: LinkedIn <messages-noreply@linkedin.com>",
+				"To: me@example.com",
+				"Subject: You have a new invitation",
+				"List-Unsubscribe: <https://www.linkedin.com/e/unsub>",
+				"DKIM-Signature: v=1; a=rsa-sha256; d=linkedin.com; s=proddkim; h=from:to",
+				"Content-Type: text/html",
+				"",
+				"<p>invitation</p>",
+			]);
+			assert.equal(category, MessageCategory.social);
+		});
+
+		it("classifies a LinkedIn job alert from a subdomain as social", async () => {
+			const category = await classify([
+				"From: LinkedIn Job Alerts <jobalerts-noreply@e.linkedin.com>",
+				"To: me@example.com",
+				"Subject: 20 new jobs for you",
+				"Precedence: bulk",
+				"List-Unsubscribe: <https://www.linkedin.com/e/unsub>",
+				"Content-Type: text/html",
+				"",
+				"<p>jobs</p>",
+			]);
+			assert.equal(category, MessageCategory.social);
+		});
+	});
+
+	describe("bulk mail keeps its intent bucket", () => {
+		it("classifies a marketing blast that also sets Precedence: bulk as marketing", async () => {
+			// Nearly every marketing platform sets Precedence: bulk. Matching it
+			// first swallowed the whole Marketing bucket into `automated`.
+			const category = await classify([
+				"From: Shop <deals@shop.example>",
+				"To: me@example.com",
+				"Subject: 50% off everything",
+				"Precedence: bulk",
+				"List-Unsubscribe: <https://shop.example/unsub>",
+				"List-Unsubscribe-Post: List-Unsubscribe=One-Click",
+				"Content-Type: text/html",
+				"",
+				"<p>sale</p>",
+			]);
+			assert.equal(category, MessageCategory.marketing);
+		});
+
+		it("classifies a newsletter that also sets Precedence: list as newsletter", async () => {
+			const category = await classify([
+				"From: Some Writer <writer@substack.example>",
+				"To: me@example.com",
+				"Subject: This week's issue",
+				"Precedence: list",
+				"List-ID: <someletter.substack.example>",
+				"List-Unsubscribe: <https://substack.example/unsub>",
+				"Content-Type: text/html",
+				"",
+				"<p>news</p>",
+			]);
+			assert.equal(category, MessageCategory.newsletter);
+		});
+
+		it("classifies a mailing-list post as newsletter, not automated", async () => {
+			const category = await classify([
+				"From: Contributor <dev@lists.example>",
+				"To: dev@lists.example",
+				"Subject: [PATCH v2] fix the parser",
+				"Precedence: list",
+				"List-ID: <dev.lists.example>",
+				"List-Unsubscribe: <mailto:dev-unsubscribe@lists.example>",
+				"Content-Type: text/plain",
+				"",
+				"patch",
+			]);
+			assert.equal(category, MessageCategory.newsletter);
+		});
+	});
+
+	describe("personal mail stays personal", () => {
+		it("classifies a person writing from Gmail as personal", async () => {
+			const category = await classify([
+				"From: Alice <alice@gmail.com>",
+				"To: me@example.com",
+				"Subject: lunch?",
+				"DKIM-Signature: v=1; a=rsa-sha256; d=gmail.com; s=20230601; h=from:to",
+				"Content-Type: text/plain",
+				"",
+				"lunch tomorrow?",
+			]);
+			assert.equal(category, MessageCategory.personal);
+		});
+
+		it("does not treat a human support mailbox as a machine sender", async () => {
+			// `support@` is answered by people. Adding it to the machine local-parts
+			// would quietly bury real correspondence in `automated`.
+			const category = await classify([
+				"From: Acme Support <support@acme.example>",
+				"To: me@example.com",
+				"Subject: Re: your question",
+				"Content-Type: text/plain",
+				"",
+				"answering your question",
+			]);
+			assert.equal(category, MessageCategory.personal);
+		});
+
+		it("classifies a calendar invite from a colleague as transactional", async () => {
+			const category = await classify([
+				"From: Bob <bob@corp.example>",
+				"To: me@example.com",
+				"Subject: Invitation: standup",
+				'Content-Type: multipart/mixed; boundary="b1"',
+				"",
+				"--b1",
+				"Content-Type: text/calendar; method=REQUEST",
+				"",
+				"BEGIN:VCALENDAR",
+				"END:VCALENDAR",
+				"--b1--",
+			]);
+			assert.equal(category, MessageCategory.transactional);
+		});
+	});
+});

package/src/heuristics/machineSenders.test.ts

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { hasMachineHeader, isMachineLocalPart } from "./machineSenders.js";
+
+describe("isMachineLocalPart", () => {
+	it("matches the no-reply spellings", () => {
+		for (const localPart of [
+			"noreply",
+			"no-reply",
+			"no_reply",
+			"NoReply",
+			"donotreply",
+			"do-not-reply",
+		]) {
+			assert.equal(isMachineLocalPart(localPart), true, localPart);
+		}
+	});
+
+	it("matches no-reply prefixes used by platforms", () => {
+		for (const localPart of [
+			"noreply-github",
+			"no-reply+abc123",
+			"messages-noreply",
+		]) {
+			assert.equal(isMachineLocalPart(localPart), true, localPart);
+		}
+	});
+
+	it("matches notification and bounce mailboxes", () => {
+		for (const localPart of [
+			"notifications",
+			"notify",
+			"alerts",
+			"bounces",
+			"mailer-daemon",
+			"postmaster",
+		]) {
+			assert.equal(isMachineLocalPart(localPart), true, localPart);
+		}
+	});
+
+	it("does not match mailboxes a person answers", () => {
+		// A wrong entry here silently buries real correspondence in `automated`,
+		// which is the failure mode this whole change exists to remove.
+		for (const localPart of [
+			"support",
+			"info",
+			"contact",
+			"hello",
+			"sales",
+			"alice",
+			"team",
+		]) {
+			assert.equal(isMachineLocalPart(localPart), false, localPart);
+		}
+	});
+
+	it("does not read a machine name across two words of a person's name", () => {
+		// `bruno.reply` strips to "brunoreply", which contains "noreply" spanning
+		// the boundary between the two words. Matching on whole words is what
+		// keeps Bruno out of `automated`.
+		for (const localPart of [
+			"bruno.reply",
+			"bruno-reply",
+			"bruno_reply",
+			"juno.replies",
+			"toni.fyi",
+			"bruno.reply+newsletter",
+		]) {
+			assert.equal(isMachineLocalPart(localPart), false, localPart);
+		}
+	});
+
+	it("still matches the qualified machine forms", () => {
+		for (const localPart of [
+			"noreply-github",
+			"messages-noreply",
+			"jobalerts-noreply",
+			"mailer.daemon",
+			"do-not-reply",
+			"team.notifications",
+		]) {
+			assert.equal(isMachineLocalPart(localPart), true, localPart);
+		}
+	});
+});
+
+describe("hasMachineHeader", () => {
+	it("matches Feedback-ID regardless of case", () => {
+		assert.equal(hasMachineHeader(["from", "Feedback-ID"]), true);
+		assert.equal(hasMachineHeader(["feedback-id"]), true);
+	});
+
+	it("matches X-Auto-Response-Suppress", () => {
+		assert.equal(hasMachineHeader(["x-auto-response-suppress"]), true);
+	});
+
+	it("does not match ordinary headers", () => {
+		assert.equal(hasMachineHeader(["from", "to", "subject", "date"]), false);
+	});
+});

package/src/heuristics/machineSenders.ts

@@ -0,0 +1,90 @@
+/**
+ * Signals that a message was sent by a machine that does not read replies.
+ *
+ * Distinct from the bulk signals (`Precedence`, `List-Unsubscribe`): a platform
+ * notification — an npm publish or 2FA mail, a CI result, a password reset —
+ * carries none of those. It is a one-to-one message with an aligned DKIM
+ * signature, so before issue #45 it reached the `personal` fallback and sat
+ * alongside actual human correspondence.
+ */
+
+/**
+ * From local-parts that mean "this mailbox is not read by a person". Matched
+ * case-insensitively against whole separator-delimited words, so `no-reply`,
+ * `no_reply` and `noreply` are one entry.
+ *
+ * Deliberately excludes ambiguous, human-reachable local-parts (`support`,
+ * `info`, `contact`, `hello`, `sales`): a person does answer those, and a
+ * wrong entry here silently buries real mail in `automated`.
+ */
+const MACHINE_LOCAL_PARTS = new Set([
+	"noreply",
+	"donotreply",
+	"notification",
+	"notifications",
+	"notify",
+	"automailer",
+	"automated",
+	"autoreply",
+	"mailerdaemon",
+	"postmaster",
+	"bounce",
+	"bounces",
+	"alert",
+	"alerts",
+]);
+
+/**
+ * Machine mailbox names that senders spell across separators. Joined into one
+ * word before the local-part is split, so `no-reply` and `mailer.daemon` reduce
+ * to a single token that {@link MACHINE_LOCAL_PARTS} can match.
+ */
+const SPELLED_OUT_MACHINE_NAMES: ReadonlyArray<[RegExp, string]> = [
+	[/do-not-reply/g, "donotreply"],
+	[/donot-reply/g, "donotreply"],
+	[/no-reply/g, "noreply"],
+	[/mailer-daemon/g, "mailerdaemon"],
+	[/auto-reply/g, "autoreply"],
+	[/auto-mailer/g, "automailer"],
+];
+
+/**
+ * Headers only bulk/notification infrastructure sets. `Feedback-ID` is the
+ * per-campaign identifier SES, Google and other ESPs attach to programmatic
+ * sends; `X-Auto-Response-Suppress` tells the receiving client not to send
+ * vacation replies back, which only a machine sender asks for.
+ */
+const MACHINE_HEADERS = ["feedback-id", "x-auto-response-suppress"];
+
+/**
+ * Split a local-part into its separator-delimited words, with the spelled-out
+ * machine names joined back up first. The `+tag` suffix is dropped: it labels a
+ * subaddress, never the mailbox.
+ */
+const toWords = (localPart: string): string[] => {
+	let canonical = localPart.toLowerCase().split("+")[0].replace(/[._]/g, "-");
+	for (const [pattern, replacement] of SPELLED_OUT_MACHINE_NAMES) {
+		canonical = canonical.replace(pattern, replacement);
+	}
+	return canonical.split("-").filter(Boolean);
+};
+
+/**
+ * True when any whole word of the From local-part is a known machine mailbox.
+ *
+ * Word-boundary, not substring: platforms qualify the mailbox on either side
+ * (`noreply-github`, `messages-noreply`, `jobalerts-noreply`), so a bare prefix
+ * test misses half of them — but a substring test reads `bruno.reply` as
+ * "bru|noreply" and files a real person as `automated`. Splitting on the
+ * separators the sender wrote catches the qualified forms without inventing a
+ * match that spans two words.
+ */
+export const isMachineLocalPart = (localPart: string): boolean =>
+	toWords(localPart).some((word) => MACHINE_LOCAL_PARTS.has(word));
+
+export const hasMachineHeader = (headerKeys: readonly string[]): boolean => {
+	for (const key of headerKeys) {
+		if (MACHINE_HEADERS.includes(key.toLowerCase())) return true;
+	}
+	return false;
+};

package/src/imapflow-connection.test.ts

@@ -181,3 +181,88 @@ describe("ImapFlowConnection.getMailboxStatus — deletedCount (#1042)", () => {
 		assert.strictEqual(BigInt(status.highestModseq), modseq);
 	});
 });
+
+describe("ImapFlowConnection CONDSTORE (reader#20)", () => {
+	const buildCondstoreConnection = (options: {
+		enabled: Set<string>;
+		noModseq?: boolean;
+		fetched?: Array<Record<string, unknown>>;
+		record?: Array<{ range: string; options: Record<string, unknown> }>;
+	}): ImapFlowConnection => {
+		const connection = buildConnectionWithClient({
+			enabled: options.enabled,
+			mailbox: { ...fakeMailbox("INBOX", 1), noModseq: options.noModseq },
+			mailboxOpen: async (path: string) => fakeMailbox(path, 1),
+			fetch: (
+				range: string,
+				_query: Record<string, unknown>,
+				fetchOptions: Record<string, unknown>,
+			) => {
+				options.record?.push({ range, options: fetchOptions });
+				return (async function* () {
+					for (const row of options.fetched ?? []) yield row;
+				})();
+			},
+		});
+		Object.assign(connection as unknown as Record<string, unknown>, {
+			currentMailbox: "INBOX",
+		});
+		return connection;
+	};
+
+	it("reports CONDSTORE only when the session enabled it and the mailbox keeps mod-sequences", () => {
+		assert.strictEqual(
+			buildCondstoreConnection({
+				enabled: new Set(["CONDSTORE"]),
+			}).supportsCondstore(),
+			true,
+		);
+		assert.strictEqual(
+			buildCondstoreConnection({ enabled: new Set() }).supportsCondstore(),
+			false,
+		);
+		assert.strictEqual(
+			buildCondstoreConnection({
+				enabled: new Set(["CONDSTORE"]),
+				noModseq: true,
+			}).supportsCondstore(),
+			false,
+		);
+	});
+
+	it("refuses CHANGEDSINCE without CONDSTORE rather than fetching the whole mailbox", async () => {
+		const connection = buildCondstoreConnection({ enabled: new Set() });
+
+		await assert.rejects(
+			() => connection.fetchMessagesChangedSince(500n),
+			/CONDSTORE/,
+		);
+	});
+
+	it("passes the mod-sequence through as a BigInt over the whole UID space", async () => {
+		const record: Array<{ range: string; options: Record<string, unknown> }> =
+			[];
+		const connection = buildCondstoreConnection({
+			enabled: new Set(["CONDSTORE"]),
+			record,
+			fetched: [
+				{
+					uid: 7,
+					seq: 7,
+					flags: new Set(["\\Seen"]),
+					internalDate: new Date(0),
+					size: 10,
+					modseq: 18446744073709551615n,
+				},
+			],
+		});
+
+		const messages = await connection.fetchMessagesChangedSince(500n);
+
+		assert.deepStrictEqual(record, [
+			{ range: "1:*", options: { uid: true, changedSince: 500n } },
+		]);
+		assert.strictEqual(messages[0].modseq, "18446744073709551615");
+		assert.deepStrictEqual(messages[0].flags, ["\\Seen"]);
+	});
+});

package/src/imapflow-connection.ts

@@ -502,6 +502,61 @@ export class ImapFlowConnection {
 	 */
 	fetchMessages = async (uids: number[]): Promise<ImapMessage[]> => {
 		this.ensureConnected();
+
+		if (uids.length === 0) {
+			return [];
+		}
+
+		return this.runMessageFetch(uids.join(","), {});
+	};
+
+	/**
+	 * True when this session negotiated CONDSTORE (RFC 7162) and the open
+	 * mailbox keeps persistent mod-sequences.
+	 *
+	 * Both halves matter. `enabled` reflects the ENABLE exchange, not merely
+	 * the advertised capability, and a server may still answer NOMODSEQ for an
+	 * individual mailbox — in which case RFC 7162 Section 3.1.2.2 requires it
+	 * to reject CHANGEDSINCE with a BAD response.
+	 */
+	supportsCondstore = (): boolean => {
+		const { client } = this;
+		if (!client?.mailbox) return false;
+		return client.enabled.has("CONDSTORE") && !client.mailbox.noModseq;
+	};
+
+	/**
+	 * FETCH everything in the open mailbox whose MODSEQ is strictly greater
+	 * than `sinceModseq` — new arrivals and metadata changes to messages
+	 * already synced, in one pass over the whole UID space.
+	 *
+	 * The CONDSTORE guard is load-bearing rather than defensive: imapflow drops
+	 * the CHANGEDSINCE modifier when the extension is unavailable, so the same
+	 * call would degrade into a fetch of every message in the mailbox.
+	 */
+	fetchMessagesChangedSince = async (
+		sinceModseq: bigint,
+	): Promise<ImapMessage[]> => {
+		this.ensureConnected();
+
+		if (!this.supportsCondstore()) {
+			throw new Error(
+				"CHANGEDSINCE requires CONDSTORE on both the session and the open mailbox",
+			);
+		}
+
+		return this.runMessageFetch("1:*", { changedSince: sinceModseq });
+	};
+
+	/**
+	 * One UID FETCH over `range`, mapped to {@link ImapMessage}. The shared
+	 * body of {@link fetchMessages} and {@link fetchMessagesChangedSince} —
+	 * both need identical message shapes and differ only in what they select.
+	 */
+	private runMessageFetch = async (
+		range: string,
+		options: { changedSince?: bigint },
+	): Promise<ImapMessage[]> => {
 		const { client } = this;
 
 		if (!client) {
@@ -512,17 +567,10 @@ export class ImapFlowConnection {
 			throw new Error("No mailbox selected");
 		}
 
-		if (uids.length === 0) {
-			return [];
-		}
-
 		const messages: ImapMessage[] = [];
 
-		// ImapFlow fetch with native envelope support + References header
-		const uidRange = uids.join(",");
-
 		const fetchIterator = client.fetch(
-			uidRange,
+			range,
 			{
 				uid: true,
 				flags: true,
@@ -532,14 +580,12 @@ export class ImapFlowConnection {
 				size: true,
 				headers: ["references"],
 			},
-			{ uid: true },
+			{ uid: true, ...options },
 		);
 
 		// Connection may have been lost - fetch returns an async iterable
 		if (!fetchIterator) {
-			throw new Error(
-				`IMAP connection lost while fetching messages: ${uidRange}`,
-			);
+			throw new Error(`IMAP connection lost while fetching messages: ${range}`);
 		}
 
 		for await (const msg of fetchIterator) {
@@ -572,6 +618,7 @@ export class ImapFlowConnection {
 				envelope: this.convertEnvelope(msg.envelope),
 				references,
 				bodyStructure: msg.bodyStructure,
+				...(msg.modseq != null ? { modseq: msg.modseq.toString() } : {}),
 			});
 		}
 

package/src/mailbox-sync.test.ts

@@ -44,7 +44,10 @@ describe("MailboxSyncService.syncMailboxes — UIDVALIDITY cursor detection (#12
 		shared: [],
 	};
 
-	const buildConnection = (uidValidity: number): IImapConnection =>
+	const buildConnection = (
+		uidValidity: number,
+		highestModseq = "0",
+	): IImapConnection =>
 		({
 			getNamespaces: async () => namespaces,
 			listMailboxes: async () => [
@@ -62,7 +65,7 @@ describe("MailboxSyncService.syncMailboxes — UIDVALIDITY cursor detection (#12
 				unseen: 1,
 				uidNext: 100,
 				uidValidity,
-				highestModseq: "0",
+				highestModseq,
 				deletedCount: 0,
 			}),
 		}) as unknown as IImapConnection;
@@ -136,6 +139,32 @@ describe("MailboxSyncService.syncMailboxes — UIDVALIDITY cursor detection (#12
 		assert.equal(updateCalls.length, 0);
 	});
 
+	it("never writes the message-sync cursor, whatever the server reports", async () => {
+		// `highestModseq` on the mailbox row is message sync's own cursor over
+		// applied changes, not a status projection. The sweep overwriting it with
+		// the server's current value would step it over every change message sync
+		// had not yet applied.
+		const { mailboxService, specialUseService, updateCalls } = buildServices(1);
+		const service = new MailboxSyncService(mailboxService, specialUseService);
+		const connection = buildConnection(2, "99999");
+
+		await service.syncMailboxes({ accountId: "acc-1" }, connection);
+
+		for (const call of updateCalls) {
+			assert.equal("highestModseq" in call, false);
+		}
+	});
+
+	it("does not sweep-write a mailbox whose only difference is the server mod-sequence", async () => {
+		const { mailboxService, specialUseService, updateCalls } = buildServices(1);
+		const service = new MailboxSyncService(mailboxService, specialUseService);
+		const connection = buildConnection(1, "4242");
+
+		await service.syncMailboxes({ accountId: "acc-1" }, connection);
+
+		assert.equal(updateCalls.length, 0);
+	});
+
 	it("does not re-trip (no cursorState write) when the mailbox is already cursor_invalid", async () => {
 		const { mailboxService, specialUseService, updateCalls } = buildServices(
 			1,