@remit/mailbox-service 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/mailbox-service",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -59,7 +59,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/remit-mail/remit.git",
+    "url": "git+https://github.com/remit-mail/reader.git",
     "directory": "packages/mailbox-service"
   }
 }

package/src/account-credentials.ts

@@ -125,4 +125,4 @@ export const encryptRefreshToken = async (
 	return JSON.stringify(serializeEncryptedPayload(payload));
 };
 
-export { RefreshTokenError, ConnectionState };
+export { ConnectionState, RefreshTokenError };

package/src/adversarial-mime.e2e.test.ts

@@ -151,161 +151,157 @@ const bodyText = (parsed: ParsedMail): string => {
 	return `${text}\n${html}`;
 };
 
-describe(
-	"Adversarial MIME corpus (Dovecot) — #402",
-	{ skip: !process.env.RUN_E2E_TESTS },
-	() => {
-		// Own mailbox instead of the shared INBOX so appending fixtures never
-		// collides with another e2e file's count/flag assertions (#508).
-		const inbox = uniqueMailboxName("E2E_adversarial");
+describe("Adversarial MIME corpus (Dovecot) — #402", {
+	skip: !process.env.RUN_E2E_TESTS,
+}, () => {
+	// Own mailbox instead of the shared INBOX so appending fixtures never
+	// collides with another e2e file's count/flag assertions (#508).
+	const inbox = uniqueMailboxName("E2E_adversarial");
 
-		before(async () => {
-			await withMailfuzzConnection(async (connection) => {
-				await connection.createMailbox(inbox);
-			});
+	before(async () => {
+		await withMailfuzzConnection(async (connection) => {
+			await connection.createMailbox(inbox);
 		});
+	});
 
-		after(async () => {
-			const connection = createMailfuzzConnection();
-			await connection.connect();
-			await connection.deleteMailbox(inbox).catch(() => {});
-			if (connection.isConnected) {
-				await connection.disconnect();
-			}
-		});
+	after(async () => {
+		const connection = createMailfuzzConnection();
+		await connection.connect();
+		await connection.deleteMailbox(inbox).catch(() => {});
+		if (connection.isConnected) {
+			await connection.disconnect();
+		}
+	});
 
-		// Sanity: every .eml on disk has an expectation entry, and every
-		// expectation entry points at an existing file. Catches a fixture being
-		// added without an assertion (or vice versa).
-		test("every fixture has an expectation entry", () => {
-			const onDisk = new Set(listEmlFixtures());
-			const expected = new Set(Object.keys(EXPECTATIONS));
-			for (const name of onDisk) {
-				assert.ok(
-					expected.has(name),
-					`Fixture ${name} has no expectation entry in EXPECTATIONS`,
-				);
-			}
-			for (const name of expected) {
+	// Sanity: every .eml on disk has an expectation entry, and every
+	// expectation entry points at an existing file. Catches a fixture being
+	// added without an assertion (or vice versa).
+	test("every fixture has an expectation entry", () => {
+		const onDisk = new Set(listEmlFixtures());
+		const expected = new Set(Object.keys(EXPECTATIONS));
+		for (const name of onDisk) {
+			assert.ok(
+				expected.has(name),
+				`Fixture ${name} has no expectation entry in EXPECTATIONS`,
+			);
+		}
+		for (const name of expected) {
+			assert.ok(
+				onDisk.has(name),
+				`Expectation ${name} has no .eml file on disk`,
+			);
+		}
+		// Pin the count: #402 calls for 8 adversarial shapes.
+		assert.equal(
+			onDisk.size,
+			8,
+			"Expected exactly 8 adversarial MIME fixtures",
+		);
+	});
+
+	for (const name of Object.keys(EXPECTATIONS).sort()) {
+		const expectation = EXPECTATIONS[name];
+		if (!expectation) continue;
+
+		test(`fixture ${name} round-trips through IMAP and parses`, async () => {
+			const raw = loadFixtureRaw(name);
+
+			await withMailfuzzConnection(async (connection) => {
+				// APPEND the fixture into this file's own mailbox. Mailfuzz uses
+				// Dovecot which returns a proper UID on APPEND (mokapi does not —
+				// see outbox-roundtrip.e2e.test.ts and the RFC 025 notes).
+				const appendResult = await connection.append(inbox, raw);
 				assert.ok(
-					onDisk.has(name),
-					`Expectation ${name} has no .eml file on disk`,
+					appendResult.uid > 0,
+					`APPEND should return a UID for ${name}`,
 				);
-			}
-			// Pin the count: #402 calls for 8 adversarial shapes.
-			assert.equal(
-				onDisk.size,
-				8,
-				"Expected exactly 8 adversarial MIME fixtures",
-			);
-		});
 
-		for (const name of Object.keys(EXPECTATIONS).sort()) {
-			const expectation = EXPECTATIONS[name];
-			if (!expectation) continue;
+				await connection.openBox(inbox, true);
 
-			test(`fixture ${name} round-trips through IMAP and parses`, async () => {
-				const raw = loadFixtureRaw(name);
+				// Fetch the message we just appended back. fetchMessageBody
+				// returns the raw RFC822 source; mailparser handles the rest
+				// (multipart walking, base64/qp decoding, charset folding).
+				const rfc822 = await connection.fetchMessageBody(appendResult.uid);
+				assert.ok(
+					rfc822.length > 0,
+					`fetchMessageBody should return bytes for ${name}`,
+				);
 
-				await withMailfuzzConnection(async (connection) => {
-					// APPEND the fixture into this file's own mailbox. Mailfuzz uses
-					// Dovecot which returns a proper UID on APPEND (mokapi does not —
-					// see outbox-roundtrip.e2e.test.ts and the RFC 025 notes).
-					const appendResult = await connection.append(inbox, raw);
+				// BODYSTRUCTURE re-fetch: exercises the IMAP mapper path at the
+				// integration boundary (the exact regression class from #394).
+				// Skipped for fixtures with synthetic shapes that don't produce
+				// meaningful BODYSTRUCTURE (see skipBodyStructure flag + #408).
+				// The guard in fetchMessages skips rows with undefined uid/internalDate
+				// so back-to-back FETCH is safe on Dovecot (see imapflow-connection.ts).
+				if (!expectation.skipBodyStructure) {
+					const refetched = await connection.fetchMessages([appendResult.uid]);
 					assert.ok(
-						appendResult.uid > 0,
-						`APPEND should return a UID for ${name}`,
+						refetched.length > 0,
+						`BODYSTRUCTURE re-fetch should return a message for ${name}`,
 					);
-
-					await connection.openBox(inbox, true);
-
-					// Fetch the message we just appended back. fetchMessageBody
-					// returns the raw RFC822 source; mailparser handles the rest
-					// (multipart walking, base64/qp decoding, charset folding).
-					const rfc822 = await connection.fetchMessageBody(appendResult.uid);
 					assert.ok(
-						rfc822.length > 0,
-						`fetchMessageBody should return bytes for ${name}`,
+						refetched[0]?.bodyStructure != null,
+						`BODYSTRUCTURE should be present for ${name}`,
 					);
+				}
 
-					// BODYSTRUCTURE re-fetch: exercises the IMAP mapper path at the
-					// integration boundary (the exact regression class from #394).
-					// Skipped for fixtures with synthetic shapes that don't produce
-					// meaningful BODYSTRUCTURE (see skipBodyStructure flag + #408).
-					// The guard in fetchMessages skips rows with undefined uid/internalDate
-					// so back-to-back FETCH is safe on Dovecot (see imapflow-connection.ts).
-					if (!expectation.skipBodyStructure) {
-						const refetched = await connection.fetchMessages([
-							appendResult.uid,
-						]);
-						assert.ok(
-							refetched.length > 0,
-							`BODYSTRUCTURE re-fetch should return a message for ${name}`,
-						);
-						assert.ok(
-							refetched[0]?.bodyStructure != null,
-							`BODYSTRUCTURE should be present for ${name}`,
-						);
-					}
+				const parsed = await simpleParser(rfc822);
 
-					const parsed = await simpleParser(rfc822);
+				// Subject round-trips (proves we fetched the right message and
+				// any encoded-word headers decoded correctly).
+				assert.ok(
+					parsed.subject,
+					`Parsed subject should be present for ${name}`,
+				);
+				assert.ok(
+					parsed.subject?.includes(expectation.subjectIncludes),
+					`Subject "${parsed.subject}" should include "${expectation.subjectIncludes}" for ${name}`,
+				);
 
-					// Subject round-trips (proves we fetched the right message and
-					// any encoded-word headers decoded correctly).
+				// Body renders — at least one of text/html is non-empty. This
+				// is the headline "body renders" assertion from #402.
+				const text = parsed.text ?? "";
+				const html = typeof parsed.html === "string" ? parsed.html : "";
+				assert.ok(
+					text.trim().length > 0 || html.trim().length > 0,
+					`Body should render (text or html non-empty) for ${name}`,
+				);
+
+				if (expectation.bodyContains) {
+					const haystack = bodyText(parsed).toLowerCase();
+					const needle = expectation.bodyContains.toLowerCase();
 					assert.ok(
-						parsed.subject,
-						`Parsed subject should be present for ${name}`,
+						haystack.includes(needle),
+						`Body should contain "${expectation.bodyContains}" for ${name}`,
+					);
+				}
+
+				// Attachments are listable — every expected attachment appears
+				// in parsed.attachments with a matching filename and non-zero
+				// content length. This is the "attachments listable" half of
+				// the #402 contract.
+				const attachments = parsed.attachments ?? [];
+				for (const expectedAtt of expectation.attachments) {
+					const found = attachments.find(
+						(a) => a.filename === expectedAtt.filename,
 					);
 					assert.ok(
-						parsed.subject?.includes(expectation.subjectIncludes),
-						`Subject "${parsed.subject}" should include "${expectation.subjectIncludes}" for ${name}`,
+						found,
+						`Attachment "${expectedAtt.filename}" should be listable for ${name}; got [${attachments.map((a) => a.filename).join(", ")}]`,
 					);
-
-					// Body renders — at least one of text/html is non-empty. This
-					// is the headline "body renders" assertion from #402.
-					const text = parsed.text ?? "";
-					const html = typeof parsed.html === "string" ? parsed.html : "";
 					assert.ok(
-						text.trim().length > 0 || html.trim().length > 0,
-						`Body should render (text or html non-empty) for ${name}`,
+						(found.size ?? 0) > 0,
+						`Attachment "${expectedAtt.filename}" should have non-zero size for ${name}`,
 					);
-
-					if (expectation.bodyContains) {
-						const haystack = bodyText(parsed).toLowerCase();
-						const needle = expectation.bodyContains.toLowerCase();
-						assert.ok(
-							haystack.includes(needle),
-							`Body should contain "${expectation.bodyContains}" for ${name}`,
-						);
-					}
-
-					// Attachments are listable — every expected attachment appears
-					// in parsed.attachments with a matching filename and non-zero
-					// content length. This is the "attachments listable" half of
-					// the #402 contract.
-					const attachments = parsed.attachments ?? [];
-					for (const expectedAtt of expectation.attachments) {
-						const found = attachments.find(
-							(a) => a.filename === expectedAtt.filename,
-						);
-						assert.ok(
-							found,
-							`Attachment "${expectedAtt.filename}" should be listable for ${name}; got [${attachments.map((a) => a.filename).join(", ")}]`,
+					if (expectedAtt.contentType) {
+						assert.equal(
+							found.contentType,
+							expectedAtt.contentType,
+							`Attachment "${expectedAtt.filename}" should have contentType "${expectedAtt.contentType}" for ${name}`,
 						);
-						assert.ok(
-							(found.size ?? 0) > 0,
-							`Attachment "${expectedAtt.filename}" should have non-zero size for ${name}`,
-						);
-						if (expectedAtt.contentType) {
-							assert.equal(
-								found.contentType,
-								expectedAtt.contentType,
-								`Attachment "${expectedAtt.filename}" should have contentType "${expectedAtt.contentType}" for ${name}`,
-							);
-						}
 					}
-				});
+				}
 			});
-		}
-	},
-);
+		});
+	}
+});

package/src/imapflow-connection.e2e.test.ts

@@ -9,304 +9,284 @@ import {
 	withMailfuzzConnection,
 } from "./test-helpers/mailfuzz-connection.js";
 
-describe(
-	"Mailbox listing (Dovecot)",
-	{
-		skip: !process.env.RUN_E2E_TESTS,
-	},
-	() => {
-		test("lists mailboxes and INBOX exists", async () => {
-			await withMailfuzzConnection(async (connection) => {
-				const mailboxes = await connection.listMailboxes();
-
-				assert.ok(mailboxes.length > 0, "Should have at least one mailbox");
-
-				const inbox = mailboxes.find((m) => m.fullPath === "INBOX");
-				assert.ok(inbox, "INBOX should exist in mailbox list");
-				assert.equal(inbox.name, "INBOX");
-			});
+describe("Mailbox listing (Dovecot)", {
+	skip: !process.env.RUN_E2E_TESTS,
+}, () => {
+	test("lists mailboxes and INBOX exists", async () => {
+		await withMailfuzzConnection(async (connection) => {
+			const mailboxes = await connection.listMailboxes();
+
+			assert.ok(mailboxes.length > 0, "Should have at least one mailbox");
+
+			const inbox = mailboxes.find((m) => m.fullPath === "INBOX");
+			assert.ok(inbox, "INBOX should exist in mailbox list");
+			assert.equal(inbox.name, "INBOX");
 		});
+	});
 
-		test("returns mailbox status with uidValidity and uidNext", async () => {
-			await withMailfuzzConnection(async (connection) => {
-				const status = await connection.getMailboxStatus("INBOX");
+	test("returns mailbox status with uidValidity and uidNext", async () => {
+		await withMailfuzzConnection(async (connection) => {
+			const status = await connection.getMailboxStatus("INBOX");
 
-				assert.ok(status.uidValidity > 0, "uidValidity should be positive");
-				assert.ok(status.uidNext > 0, "uidNext should be positive");
-				assert.ok(status.messages > 0, "INBOX should have messages");
-			});
+			assert.ok(status.uidValidity > 0, "uidValidity should be positive");
+			assert.ok(status.uidNext > 0, "uidNext should be positive");
+			assert.ok(status.messages > 0, "INBOX should have messages");
 		});
-	},
-);
-
-describe(
-	"Message fetch (Dovecot)",
-	{
-		skip: !process.env.RUN_E2E_TESTS,
-	},
-	() => {
-		test("fetches messages with ENVELOPE data", async () => {
-			await withMailfuzzConnection(async (connection) => {
-				const boxStatus = await connection.openBox("INBOX", true);
-				assert.ok(boxStatus.messages.total > 0, "INBOX should have messages");
+	});
+});
 
-				const uids = await connection.search(["ALL"]);
-				assert.ok(uids.length > 0, "Should find messages");
+describe("Message fetch (Dovecot)", {
+	skip: !process.env.RUN_E2E_TESTS,
+}, () => {
+	test("fetches messages with ENVELOPE data", async () => {
+		await withMailfuzzConnection(async (connection) => {
+			const boxStatus = await connection.openBox("INBOX", true);
+			assert.ok(boxStatus.messages.total > 0, "INBOX should have messages");
 
-				const fetchUids = uids.slice(0, 5);
-				const messages = await connection.fetchMessages(fetchUids);
+			const uids = await connection.search(["ALL"]);
+			assert.ok(uids.length > 0, "Should find messages");
 
-				assert.equal(
-					messages.length,
-					fetchUids.length,
-					"Should fetch all requested messages",
+			const fetchUids = uids.slice(0, 5);
+			const messages = await connection.fetchMessages(fetchUids);
+
+			assert.equal(
+				messages.length,
+				fetchUids.length,
+				"Should fetch all requested messages",
+			);
+
+			for (const msg of messages) {
+				assert.ok(msg.uid > 0, "Message should have a UID");
+				assert.ok(msg.envelope, "Message should have envelope data");
+				assert.ok(msg.envelope.subject, "Envelope should have a subject");
+				assert.ok(msg.envelope.messageId, "Envelope should have a messageId");
+				assert.ok(msg.envelope.date, "Envelope should have a date");
+				assert.ok(
+					msg.envelope.from.length > 0,
+					"Envelope should have from addresses",
+				);
+				assert.ok(
+					msg.envelope.to.length > 0,
+					"Envelope should have to addresses",
 				);
 
-				for (const msg of messages) {
-					assert.ok(msg.uid > 0, "Message should have a UID");
-					assert.ok(msg.envelope, "Message should have envelope data");
-					assert.ok(msg.envelope.subject, "Envelope should have a subject");
-					assert.ok(msg.envelope.messageId, "Envelope should have a messageId");
-					assert.ok(msg.envelope.date, "Envelope should have a date");
-					assert.ok(
-						msg.envelope.from.length > 0,
-						"Envelope should have from addresses",
-					);
-					assert.ok(
-						msg.envelope.to.length > 0,
-						"Envelope should have to addresses",
-					);
-
-					for (const addr of msg.envelope.from) {
-						assert.ok(addr.mailbox, "From address should have mailbox");
-						assert.ok(addr.host, "From address should have host");
-					}
+				for (const addr of msg.envelope.from) {
+					assert.ok(addr.mailbox, "From address should have mailbox");
+					assert.ok(addr.host, "From address should have host");
 				}
-			});
+			}
 		});
+	});
 
-		test("fetched message count matches status", async () => {
-			// Seed a mailbox this test owns so the SELECT-vs-SEARCH invariant holds
-			// regardless of what other e2e files do in parallel — the TOCTOU race
-			// that #501 papered over with --test-concurrency=1 is removed by
-			// isolation, not serialisation (#508).
-			const mailbox = uniqueMailboxName("E2E_count");
-			await withMailfuzzConnection(async (connection) => {
-				await seedMailbox(connection, mailbox, 3);
-				try {
-					const boxStatus = await connection.openBox(mailbox, true);
-					const uids = await connection.search(["ALL"]);
-
-					assert.equal(
-						uids.length,
-						boxStatus.messages.total,
-						"Search ALL count should match SELECT messages count",
-					);
-				} finally {
-					await connection.closeBox().catch(() => {});
-					await connection.deleteMailbox(mailbox).catch(() => {});
-				}
-			});
-		});
-	},
-);
-
-describe(
-	"Message bodies (Dovecot)",
-	{
-		skip: !process.env.RUN_E2E_TESTS,
-	},
-	() => {
-		test("fetches message body with text content", async () => {
-			await withMailfuzzConnection(async (connection) => {
-				await connection.openBox("INBOX", true);
+	test("fetched message count matches status", async () => {
+		// Seed a mailbox this test owns so the SELECT-vs-SEARCH invariant holds
+		// regardless of what other e2e files do in parallel — the TOCTOU race
+		// that #501 papered over with --test-concurrency=1 is removed by
+		// isolation, not serialisation (#508).
+		const mailbox = uniqueMailboxName("E2E_count");
+		await withMailfuzzConnection(async (connection) => {
+			await seedMailbox(connection, mailbox, 3);
+			try {
+				const boxStatus = await connection.openBox(mailbox, true);
 				const uids = await connection.search(["ALL"]);
-				assert.ok(uids.length > 0, "Should have messages to fetch body for");
-
-				const body = await connection.fetchMessageBody(uids[0]);
-				assert.ok(body.length > 0, "Body should not be empty");
 
-				const bodyText = body.toString("utf-8");
-				assert.ok(bodyText.length > 0, "Body text should not be empty");
-			});
+				assert.equal(
+					uids.length,
+					boxStatus.messages.total,
+					"Search ALL count should match SELECT messages count",
+				);
+			} finally {
+				await connection.closeBox().catch(() => {});
+				await connection.deleteMailbox(mailbox).catch(() => {});
+			}
 		});
-	},
-);
-
-describe(
-	"Flag operations (Dovecot)",
-	{
-		skip: !process.env.RUN_E2E_TESTS,
-		// These three subtests all mutate uids[0] of the same seeded mailbox, so
-		// they must run sequentially relative to each other. node:test already
-		// serialises subtests within a describe; concurrency: 1 pins that intent.
-		// Cross-file isolation (a dedicated seeded mailbox, not the shared INBOX)
-		// is what makes the whole suite safe to run in parallel — see #508.
-		concurrency: 1,
-	},
-	() => {
-		let targetUid: number;
-		const mailbox = uniqueMailboxName("E2E_flags");
-
-		before(async () => {
-			await withMailfuzzConnection(async (connection) => {
-				await seedMailbox(connection, mailbox, 3);
-			});
+	});
+});
+
+describe("Message bodies (Dovecot)", {
+	skip: !process.env.RUN_E2E_TESTS,
+}, () => {
+	test("fetches message body with text content", async () => {
+		await withMailfuzzConnection(async (connection) => {
+			await connection.openBox("INBOX", true);
+			const uids = await connection.search(["ALL"]);
+			assert.ok(uids.length > 0, "Should have messages to fetch body for");
+
+			const body = await connection.fetchMessageBody(uids[0]);
+			assert.ok(body.length > 0, "Body should not be empty");
+
+			const bodyText = body.toString("utf-8");
+			assert.ok(bodyText.length > 0, "Body text should not be empty");
 		});
+	});
+});
 
-		after(async () => {
-			const connection = createMailfuzzConnection();
-			await connection.connect();
-			await connection.deleteMailbox(mailbox).catch(() => {});
-			if (connection.isConnected) {
-				await connection.disconnect();
-			}
+describe("Flag operations (Dovecot)", {
+	skip: !process.env.RUN_E2E_TESTS,
+	// These three subtests all mutate uids[0] of the same seeded mailbox, so
+	// they must run sequentially relative to each other. node:test already
+	// serialises subtests within a describe; concurrency: 1 pins that intent.
+	// Cross-file isolation (a dedicated seeded mailbox, not the shared INBOX)
+	// is what makes the whole suite safe to run in parallel — see #508.
+	concurrency: 1,
+}, () => {
+	let targetUid: number;
+	const mailbox = uniqueMailboxName("E2E_flags");
+
+	before(async () => {
+		await withMailfuzzConnection(async (connection) => {
+			await seedMailbox(connection, mailbox, 3);
 		});
+	});
 
-		test("sets \\Seen flag and verifies it persists", async () => {
-			await withMailfuzzConnection(async (connection) => {
-				await connection.openBox(mailbox, false);
-				const uids = await connection.search(["ALL"]);
-				assert.ok(uids.length > 0, "Should have messages");
-				targetUid = uids[0];
+	after(async () => {
+		const connection = createMailfuzzConnection();
+		await connection.connect();
+		await connection.deleteMailbox(mailbox).catch(() => {});
+		if (connection.isConnected) {
+			await connection.disconnect();
+		}
+	});
 
-				await connection.removeFlags([targetUid], ["\\Seen"]);
-				await connection.addFlags([targetUid], ["\\Seen"]);
+	test("sets \\Seen flag and verifies it persists", async () => {
+		await withMailfuzzConnection(async (connection) => {
+			await connection.openBox(mailbox, false);
+			const uids = await connection.search(["ALL"]);
+			assert.ok(uids.length > 0, "Should have messages");
+			targetUid = uids[0];
 
-				const messages = await connection.fetchMessages([targetUid]);
-				assert.equal(messages.length, 1);
-				assert.ok(
-					messages[0].flags.includes("\\Seen"),
-					"Message should have \\Seen flag",
-				);
-			});
+			await connection.removeFlags([targetUid], ["\\Seen"]);
+			await connection.addFlags([targetUid], ["\\Seen"]);
+
+			const messages = await connection.fetchMessages([targetUid]);
+			assert.equal(messages.length, 1);
+			assert.ok(
+				messages[0].flags.includes("\\Seen"),
+				"Message should have \\Seen flag",
+			);
 		});
+	});
 
-		test("clears \\Seen flag and verifies it is cleared", async () => {
-			await withMailfuzzConnection(async (connection) => {
-				await connection.openBox(mailbox, false);
-				const uids = await connection.search(["ALL"]);
-				targetUid = uids[0];
+	test("clears \\Seen flag and verifies it is cleared", async () => {
+		await withMailfuzzConnection(async (connection) => {
+			await connection.openBox(mailbox, false);
+			const uids = await connection.search(["ALL"]);
+			targetUid = uids[0];
 
-				await connection.addFlags([targetUid], ["\\Seen"]);
-				await connection.removeFlags([targetUid], ["\\Seen"]);
+			await connection.addFlags([targetUid], ["\\Seen"]);
+			await connection.removeFlags([targetUid], ["\\Seen"]);
 
-				const messages = await connection.fetchMessages([targetUid]);
-				assert.equal(messages.length, 1);
-				assert.ok(
-					!messages[0].flags.includes("\\Seen"),
-					"Message should not have \\Seen flag after removal",
-				);
-			});
+			const messages = await connection.fetchMessages([targetUid]);
+			assert.equal(messages.length, 1);
+			assert.ok(
+				!messages[0].flags.includes("\\Seen"),
+				"Message should not have \\Seen flag after removal",
+			);
 		});
+	});
 
-		test("sets custom keyword flag", async () => {
-			await withMailfuzzConnection(async (connection) => {
-				await connection.openBox(mailbox, false);
-				const uids = await connection.search(["ALL"]);
-				targetUid = uids[0];
+	test("sets custom keyword flag", async () => {
+		await withMailfuzzConnection(async (connection) => {
+			await connection.openBox(mailbox, false);
+			const uids = await connection.search(["ALL"]);
+			targetUid = uids[0];
 
-				await connection.addFlags([targetUid], ["$label1"]);
+			await connection.addFlags([targetUid], ["$label1"]);
 
-				const messages = await connection.fetchMessages([targetUid]);
-				assert.equal(messages.length, 1);
-				assert.ok(
-					messages[0].flags.includes("$label1"),
-					"Message should have custom keyword $label1",
-				);
+			const messages = await connection.fetchMessages([targetUid]);
+			assert.equal(messages.length, 1);
+			assert.ok(
+				messages[0].flags.includes("$label1"),
+				"Message should have custom keyword $label1",
+			);
 
-				await connection.removeFlags([targetUid], ["$label1"]);
-			});
+			await connection.removeFlags([targetUid], ["$label1"]);
 		});
-	},
-);
-
-describe(
-	"Message operations (Dovecot)",
-	{
-		skip: !process.env.RUN_E2E_TESTS,
-	},
-	() => {
-		const testFolder = uniqueMailboxName("E2E_TestCopy");
-		// Copy/move source their messages from a mailbox this file owns rather than
-		// the shared INBOX, so nothing here appends to or mutates INBOX (#508).
-		const sourceFolder = uniqueMailboxName("E2E_TestSource");
-
-		before(async () => {
-			await withMailfuzzConnection(async (connection) => {
-				await seedMailbox(connection, sourceFolder, 3);
-			});
+	});
+});
+
+describe("Message operations (Dovecot)", {
+	skip: !process.env.RUN_E2E_TESTS,
+}, () => {
+	const testFolder = uniqueMailboxName("E2E_TestCopy");
+	// Copy/move source their messages from a mailbox this file owns rather than
+	// the shared INBOX, so nothing here appends to or mutates INBOX (#508).
+	const sourceFolder = uniqueMailboxName("E2E_TestSource");
+
+	before(async () => {
+		await withMailfuzzConnection(async (connection) => {
+			await seedMailbox(connection, sourceFolder, 3);
 		});
+	});
 
-		test("copy returns COPYUID response with uidMap entries", async () => {
-			await withMailfuzzConnection(async (connection) => {
-				await connection.createMailbox(testFolder);
+	test("copy returns COPYUID response with uidMap entries", async () => {
+		await withMailfuzzConnection(async (connection) => {
+			await connection.createMailbox(testFolder);
 
-				await connection.openBox(sourceFolder, false);
-				const uids = await connection.search(["ALL"]);
-				assert.ok(uids.length > 0, "Should have messages to copy");
+			await connection.openBox(sourceFolder, false);
+			const uids = await connection.search(["ALL"]);
+			assert.ok(uids.length > 0, "Should have messages to copy");
 
-				const result = await connection.copyMessages([uids[0]], testFolder);
+			const result = await connection.copyMessages([uids[0]], testFolder);
 
-				assert.equal(result.destination, testFolder);
-				assert.ok(
-					result.uidMap.size > 0,
-					"COPYUID response should have uidMap entries",
-				);
-				assert.ok(
-					result.uidMap.has(uids[0]),
-					"uidMap should contain the source UID",
-				);
-			});
+			assert.equal(result.destination, testFolder);
+			assert.ok(
+				result.uidMap.size > 0,
+				"COPYUID response should have uidMap entries",
+			);
+			assert.ok(
+				result.uidMap.has(uids[0]),
+				"uidMap should contain the source UID",
+			);
 		});
+	});
 
-		test("move returns COPYUID response with uidMap entries", async () => {
-			const moveFolder = uniqueMailboxName("E2E_TestMove");
-
-			await withMailfuzzConnection(async (connection) => {
-				await connection.createMailbox(moveFolder);
-
-				const appendResult = await connection.append(
-					sourceFolder,
-					[
-						"From: test@example.com",
-						"To: vmail@localhost",
-						"Subject: Move test message",
-						`Date: ${new Date().toUTCString()}`,
-						`Message-ID: <move-test-${Date.now()}@test.example.com>`,
-						"",
-						"Body for move test",
-					].join("\r\n"),
-				);
+	test("move returns COPYUID response with uidMap entries", async () => {
+		const moveFolder = uniqueMailboxName("E2E_TestMove");
 
-				await connection.openBox(sourceFolder, false);
-				const result = await connection.moveMessages(
-					[appendResult.uid],
-					moveFolder,
-				);
+		await withMailfuzzConnection(async (connection) => {
+			await connection.createMailbox(moveFolder);
+
+			const appendResult = await connection.append(
+				sourceFolder,
+				[
+					"From: test@example.com",
+					"To: vmail@localhost",
+					"Subject: Move test message",
+					`Date: ${new Date().toUTCString()}`,
+					`Message-ID: <move-test-${Date.now()}@test.example.com>`,
+					"",
+					"Body for move test",
+				].join("\r\n"),
+			);
 
-				assert.equal(result.destination, moveFolder);
-				assert.ok(
-					result.uidMap.size > 0,
-					"COPYUID response should have uidMap entries",
-				);
+			await connection.openBox(sourceFolder, false);
+			const result = await connection.moveMessages(
+				[appendResult.uid],
+				moveFolder,
+			);
 
-				await connection.closeBox();
-				await connection.deleteMailbox(moveFolder);
-			});
-		});
+			assert.equal(result.destination, moveFolder);
+			assert.ok(
+				result.uidMap.size > 0,
+				"COPYUID response should have uidMap entries",
+			);
 
-		after(async () => {
-			const connection = createMailfuzzConnection();
-			await connection.connect();
-			await connection.deleteMailbox(testFolder).catch(() => {});
-			await connection.deleteMailbox(sourceFolder).catch(() => {});
-			if (connection.isConnected) {
-				await connection.disconnect();
-			}
+			await connection.closeBox();
+			await connection.deleteMailbox(moveFolder);
 		});
-	},
-);
+	});
+
+	after(async () => {
+		const connection = createMailfuzzConnection();
+		await connection.connect();
+		await connection.deleteMailbox(testFolder).catch(() => {});
+		await connection.deleteMailbox(sourceFolder).catch(() => {});
+		if (connection.isConnected) {
+			await connection.disconnect();
+		}
+	});
+});
 
 describe("Mailbox CRUD (Dovecot)", { skip: !process.env.RUN_E2E_TESTS }, () => {
 	const crudFolder = `CrudTest_${Date.now()}`;

package/src/imapflow-connection.integ.test.ts

@@ -134,194 +134,183 @@ const getMailboxUids = async (mailbox: string): Promise<number[]> => {
 	return uids;
 };
 
-describe(
-	"ImapFlowConnection integration tests",
-	{
-		skip: !process.env.RUN_INTEG_TESTS,
-	},
-	() => {
-		describe("moveMessages", () => {
-			test("moves a message to another mailbox", async () => {
-				// Seed the test message first
-				const subject = `Move test ${Date.now()}`;
-				const uid = await seedTestMessage("INBOX", subject);
-
-				// Count messages in Work before
-				const workCountBefore = await countMessagesInMailbox("Work");
-
-				await withConnection(async (connection) => {
-					// Open INBOX
-					await connection.openBox("INBOX", false);
-
-					// Move to Work folder
-					const result = await connection.moveMessages([uid], "Work");
-
-					// mokapi doesn't return uidMap, but should return destination
-					assert.equal(
-						result.destination,
-						"Work",
-						"Destination should be Work",
-					);
-				});
-
-				// Verify message moved using fresh connections (mokapi caching workaround)
-				const inboxUids = await getMailboxUids("INBOX");
-				assert.ok(
-					!inboxUids.includes(uid),
-					"Original UID should not be in INBOX",
-				);
-
-				const workCountAfter = await countMessagesInMailbox("Work");
-				assert.ok(
-					workCountAfter > workCountBefore,
-					`Work folder should have more messages (before: ${workCountBefore}, after: ${workCountAfter})`,
-				);
+describe("ImapFlowConnection integration tests", {
+	skip: !process.env.RUN_INTEG_TESTS,
+}, () => {
+	describe("moveMessages", () => {
+		test("moves a message to another mailbox", async () => {
+			// Seed the test message first
+			const subject = `Move test ${Date.now()}`;
+			const uid = await seedTestMessage("INBOX", subject);
+
+			// Count messages in Work before
+			const workCountBefore = await countMessagesInMailbox("Work");
+
+			await withConnection(async (connection) => {
+				// Open INBOX
+				await connection.openBox("INBOX", false);
+
+				// Move to Work folder
+				const result = await connection.moveMessages([uid], "Work");
+
+				// mokapi doesn't return uidMap, but should return destination
+				assert.equal(result.destination, "Work", "Destination should be Work");
 			});
 
-			test("returns empty uidMap when no UIDs provided", async () => {
-				await withConnection(async (connection) => {
-					await connection.openBox("INBOX", false);
+			// Verify message moved using fresh connections (mokapi caching workaround)
+			const inboxUids = await getMailboxUids("INBOX");
+			assert.ok(
+				!inboxUids.includes(uid),
+				"Original UID should not be in INBOX",
+			);
+
+			const workCountAfter = await countMessagesInMailbox("Work");
+			assert.ok(
+				workCountAfter > workCountBefore,
+				`Work folder should have more messages (before: ${workCountBefore}, after: ${workCountAfter})`,
+			);
+		});
 
-					const result = await connection.moveMessages([], "Work");
+		test("returns empty uidMap when no UIDs provided", async () => {
+			await withConnection(async (connection) => {
+				await connection.openBox("INBOX", false);
 
-					assert.equal(result.destination, "Work");
-					assert.equal(result.uidMap.size, 0);
-				});
+				const result = await connection.moveMessages([], "Work");
+
+				assert.equal(result.destination, "Work");
+				assert.equal(result.uidMap.size, 0);
 			});
 		});
+	});
 
-		describe("copyMessages", () => {
-			test("copies a message to another mailbox", async () => {
-				// Seed the test message first
-				const subject = `Copy test ${Date.now()}`;
-				const uid = await seedTestMessage("INBOX", subject);
-
-				// Count messages in Archive before
-				const archiveCountBefore = await countMessagesInMailbox("Archive");
-
-				await withConnection(async (connection) => {
-					// Open INBOX
-					await connection.openBox("INBOX", false);
-
-					// Copy to Archive folder
-					const result = await connection.copyMessages([uid], "Archive");
-
-					assert.equal(
-						result.destination,
-						"Archive",
-						"Destination should be Archive",
-					);
-				});
-
-				// Verify original message is still in INBOX
-				const inboxUids = await getMailboxUids("INBOX");
-				assert.ok(
-					inboxUids.includes(uid),
-					"Original UID should still be in INBOX",
-				);
+	describe("copyMessages", () => {
+		test("copies a message to another mailbox", async () => {
+			// Seed the test message first
+			const subject = `Copy test ${Date.now()}`;
+			const uid = await seedTestMessage("INBOX", subject);
 
-				// Verify copy is in Archive (count increased)
-				const archiveCountAfter = await countMessagesInMailbox("Archive");
-				assert.ok(
-					archiveCountAfter > archiveCountBefore,
-					`Archive folder should have more messages (before: ${archiveCountBefore}, after: ${archiveCountAfter})`,
+			// Count messages in Archive before
+			const archiveCountBefore = await countMessagesInMailbox("Archive");
+
+			await withConnection(async (connection) => {
+				// Open INBOX
+				await connection.openBox("INBOX", false);
+
+				// Copy to Archive folder
+				const result = await connection.copyMessages([uid], "Archive");
+
+				assert.equal(
+					result.destination,
+					"Archive",
+					"Destination should be Archive",
 				);
+			});
 
-				// Cleanup: delete the original from INBOX
-				await withConnection(async (connection) => {
-					await connection.openBox("INBOX", false);
-					await connection.deleteMessages([uid]);
-				});
+			// Verify original message is still in INBOX
+			const inboxUids = await getMailboxUids("INBOX");
+			assert.ok(
+				inboxUids.includes(uid),
+				"Original UID should still be in INBOX",
+			);
+
+			// Verify copy is in Archive (count increased)
+			const archiveCountAfter = await countMessagesInMailbox("Archive");
+			assert.ok(
+				archiveCountAfter > archiveCountBefore,
+				`Archive folder should have more messages (before: ${archiveCountBefore}, after: ${archiveCountAfter})`,
+			);
+
+			// Cleanup: delete the original from INBOX
+			await withConnection(async (connection) => {
+				await connection.openBox("INBOX", false);
+				await connection.deleteMessages([uid]);
 			});
+		});
 
-			test("returns empty uidMap when no UIDs provided", async () => {
-				await withConnection(async (connection) => {
-					await connection.openBox("INBOX", false);
+		test("returns empty uidMap when no UIDs provided", async () => {
+			await withConnection(async (connection) => {
+				await connection.openBox("INBOX", false);
 
-					const result = await connection.copyMessages([], "Archive");
+				const result = await connection.copyMessages([], "Archive");
 
-					assert.equal(result.destination, "Archive");
-					assert.equal(result.uidMap.size, 0);
-				});
+				assert.equal(result.destination, "Archive");
+				assert.equal(result.uidMap.size, 0);
 			});
 		});
+	});
+
+	describe("deleteMessages", () => {
+		test("permanently deletes a message", async () => {
+			// Seed the test message first
+			const subject = `Delete test ${Date.now()}`;
+			const uid = await seedTestMessage("INBOX", subject);
 
-		describe("deleteMessages", () => {
-			test("permanently deletes a message", async () => {
-				// Seed the test message first
-				const subject = `Delete test ${Date.now()}`;
-				const uid = await seedTestMessage("INBOX", subject);
-
-				// Verify message exists
-				let uids = await getMailboxUids("INBOX");
-				assert.ok(uids.includes(uid), "Message should exist before delete");
-
-				await withConnection(async (connection) => {
-					// Open INBOX
-					await connection.openBox("INBOX", false);
-
-					// Delete the message
-					const deleted = await connection.deleteMessages([uid]);
-					// mokapi may return true instead of count
-					assert.ok(deleted, "Should report message deleted");
-
-					// mokapi requires mailbox close for delete to persist
-					await connection.closeBox();
-
-					// Verify within same connection
-					await connection.openBox("INBOX", true);
-					uids = await connection.search(["ALL"]);
-					assert.ok(
-						!uids.includes(uid),
-						"Message should not exist after delete",
-					);
-				});
+			// Verify message exists
+			let uids = await getMailboxUids("INBOX");
+			assert.ok(uids.includes(uid), "Message should exist before delete");
+
+			await withConnection(async (connection) => {
+				// Open INBOX
+				await connection.openBox("INBOX", false);
+
+				// Delete the message
+				const deleted = await connection.deleteMessages([uid]);
+				// mokapi may return true instead of count
+				assert.ok(deleted, "Should report message deleted");
+
+				// mokapi requires mailbox close for delete to persist
+				await connection.closeBox();
+
+				// Verify within same connection
+				await connection.openBox("INBOX", true);
+				uids = await connection.search(["ALL"]);
+				assert.ok(!uids.includes(uid), "Message should not exist after delete");
 			});
+		});
 
-			test("returns 0 when no UIDs provided", async () => {
-				await withConnection(async (connection) => {
-					await connection.openBox("INBOX", false);
+		test("returns 0 when no UIDs provided", async () => {
+			await withConnection(async (connection) => {
+				await connection.openBox("INBOX", false);
 
-					const deleted = await connection.deleteMessages([]);
-					assert.equal(deleted, 0);
-				});
+				const deleted = await connection.deleteMessages([]);
+				assert.equal(deleted, 0);
 			});
 		});
+	});
+
+	describe("move to Trash workflow", () => {
+		test("moves message to Trash folder", async () => {
+			// Seed the test message first
+			const subject = `Trash test ${Date.now()}`;
+			const uid = await seedTestMessage("INBOX", subject);
 
-		describe("move to Trash workflow", () => {
-			test("moves message to Trash folder", async () => {
-				// Seed the test message first
-				const subject = `Trash test ${Date.now()}`;
-				const uid = await seedTestMessage("INBOX", subject);
-
-				// Count messages in Trash before
-				const trashCountBefore = await countMessagesInMailbox("Trash");
-
-				await withConnection(async (connection) => {
-					// Open INBOX
-					await connection.openBox("INBOX", false);
-
-					// Move to Trash
-					const result = await connection.moveMessages([uid], "Trash");
-
-					assert.equal(
-						result.destination,
-						"Trash",
-						"Destination should be Trash",
-					);
-				});
-
-				// Verify message is no longer in INBOX
-				const inboxUids = await getMailboxUids("INBOX");
-				assert.ok(!inboxUids.includes(uid), "Message should not be in INBOX");
-
-				// Verify message is in Trash (count increased)
-				const trashCountAfter = await countMessagesInMailbox("Trash");
-				assert.ok(
-					trashCountAfter > trashCountBefore,
-					`Trash folder should have more messages (before: ${trashCountBefore}, after: ${trashCountAfter})`,
+			// Count messages in Trash before
+			const trashCountBefore = await countMessagesInMailbox("Trash");
+
+			await withConnection(async (connection) => {
+				// Open INBOX
+				await connection.openBox("INBOX", false);
+
+				// Move to Trash
+				const result = await connection.moveMessages([uid], "Trash");
+
+				assert.equal(
+					result.destination,
+					"Trash",
+					"Destination should be Trash",
 				);
 			});
+
+			// Verify message is no longer in INBOX
+			const inboxUids = await getMailboxUids("INBOX");
+			assert.ok(!inboxUids.includes(uid), "Message should not be in INBOX");
+
+			// Verify message is in Trash (count increased)
+			const trashCountAfter = await countMessagesInMailbox("Trash");
+			assert.ok(
+				trashCountAfter > trashCountBefore,
+				`Trash folder should have more messages (before: ${trashCountBefore}, after: ${trashCountAfter})`,
+			);
 		});
-	},
-);
+	});
+});

package/src/pass-through-unit-of-work.ts

@@ -1,7 +1,4 @@
-import type {
-	IUnitOfWork,
-	UnitOfWorkRepositories,
-} from "@remit/data-ports";
+import type { IUnitOfWork, UnitOfWorkRepositories } from "@remit/data-ports";
 
 /**
  * Runs the write set against fixed repositories with no surrounding