@remit/mailbox-service 0.0.114 → 0.0.115

package/dist/connection-factory.d.ts

@@ -3,52 +3,26 @@
  *
  * Uses ImapFlow for all IMAP connections.
  */
-import type { IImapConnection, ImapConnectionConfig, MailCredentials } from "./types.js";
+import type { IImapConnection, ImapConnectionConfig, ImapTransport, MailCredentials } from "./types.js";
 /**
  * Create an IMAP connection
  */
 export declare const createConnection: (config: ImapConnectionConfig) => IImapConnection;
-/**
- * Create an IMAP connection from account data using password credentials.
- */
-export declare const createConnectionFromAccount: (account: {
-    imapHost: string;
-    imapPort: number;
-    imapTls: boolean;
-    username: string;
-}, password: string) => IImapConnection;
 /**
  * Create an IMAP connection from account data using a MailCredentials union.
- * Use this instead of createConnectionFromAccount for OAuth accounts.
  */
 export declare const createConnectionWithCredentials: (account: {
     imapHost: string;
     imapPort: number;
     imapTls: boolean;
     username: string;
-}, credentials: MailCredentials) => IImapConnection;
-/**
- * Managed connection factory that caches and reuses a single connection.
- *
- * The factory handles connection lifecycle - callers should not disconnect.
- * Call close() on the factory to disconnect when done.
- */
-export interface ManagedConnectionFactory {
-    /** Get the cached connection (creates on first call) */
-    getConnection(): IImapConnection;
-    /** Disconnect and cleanup */
-    close(): Promise<void>;
+}, credentials: MailCredentials, transport: ImapTransport) => IImapConnection;
+export interface ConnectionScope {
+    getConnection: () => Promise<IImapConnection>;
+    disconnect: () => Promise<void>;
 }
 /**
- * Create a managed connection factory that caches a single connection.
- *
- * @example
- * ```typescript
- * const factory = createManagedConnectionFactory(config);
- * const conn = factory.getConnection();
- * await conn.connect();
- * // ... reuse conn via factory.getConnection() ...
- * await factory.close(); // Disconnect when done
- * ```
+ * A lazily-connected, cached connection shared across the operations of one
+ * unit of work. Call disconnect() when done.
  */
-export declare const createManagedConnectionFactory: (config: ImapConnectionConfig) => ManagedConnectionFactory;
+export declare const connectionScope: (config: ImapConnectionConfig) => ConnectionScope;

package/dist/connection-factory.js

@@ -3,52 +3,46 @@
  *
  * Uses ImapFlow for all IMAP connections.
  */
-import { createImapFlowConnectionFromAccount, createImapFlowConnectionWithCredentials, ImapFlowConnection, } from "./imapflow-connection.js";
+import { ImapFlowConnection } from "./imapflow-connection.js";
 /**
  * Create an IMAP connection
  */
 export const createConnection = (config) => {
     return new ImapFlowConnection(config);
 };
-/**
- * Create an IMAP connection from account data using password credentials.
- */
-export const createConnectionFromAccount = (account, password) => {
-    return createImapFlowConnectionFromAccount(account, password);
-};
 /**
  * Create an IMAP connection from account data using a MailCredentials union.
- * Use this instead of createConnectionFromAccount for OAuth accounts.
  */
-export const createConnectionWithCredentials = (account, credentials) => {
-    return createImapFlowConnectionWithCredentials(account, credentials);
-};
+export const createConnectionWithCredentials = (account, credentials, transport) => new ImapFlowConnection({
+    host: account.imapHost,
+    port: account.imapPort,
+    tls: account.imapTls,
+    transport,
+    user: account.username,
+    credentials,
+});
 /**
- * Create a managed connection factory that caches a single connection.
- *
- * @example
- * ```typescript
- * const factory = createManagedConnectionFactory(config);
- * const conn = factory.getConnection();
- * await conn.connect();
- * // ... reuse conn via factory.getConnection() ...
- * await factory.close(); // Disconnect when done
- * ```
+ * A lazily-connected, cached connection shared across the operations of one
+ * unit of work. Call disconnect() when done.
  */
-export const createManagedConnectionFactory = (config) => {
+export const connectionScope = (config) => {
     let connection = null;
-    return {
-        getConnection: () => {
-            if (!connection) {
-                connection = new ImapFlowConnection(config);
-            }
-            return connection;
-        },
-        close: async () => {
-            if (connection) {
-                await connection.disconnect();
-                connection = null;
-            }
-        },
+    let connectPromise = null;
+    const getConnection = async () => {
+        if (connectPromise) {
+            return connectPromise;
+        }
+        const conn = createConnection(config);
+        connection = conn;
+        connectPromise = conn.connect().then(() => conn);
+        return connectPromise;
+    };
+    const disconnect = async () => {
+        if (connection) {
+            await connection.disconnect();
+            connection = null;
+            connectPromise = null;
+        }
     };
+    return { getConnection, disconnect };
 };

package/dist/imapflow-connection.d.ts

@@ -62,6 +62,7 @@ export declare class ImapFlowConnection {
     private _state;
     private config;
     private currentMailbox;
+    private currentMailboxReadOnly;
     constructor(config: ImapConnectionConfig);
     /**
      * Current connection state
@@ -357,21 +358,3 @@ export declare class ImapFlowConnection {
      */
     private ensureConnected;
 }
-/**
- * Create an ImapFlow connection from account data using password credentials.
- */
-export declare const createImapFlowConnectionFromAccount: (account: {
-    imapHost: string;
-    imapPort: number;
-    imapTls: boolean;
-    username: string;
-}, password: string) => ImapFlowConnection;
-/**
- * Create an ImapFlow connection using a credentials union (password or OAuth access token).
- */
-export declare const createImapFlowConnectionWithCredentials: (account: {
-    imapHost: string;
-    imapPort: number;
-    imapTls: boolean;
-    username: string;
-}, credentials: import("./types.js").MailCredentials) => ImapFlowConnection;

package/dist/imapflow-connection.js

@@ -149,6 +149,7 @@ export class ImapFlowConnection {
     _state = "disconnected";
     config;
     currentMailbox = null;
+    currentMailboxReadOnly = true;
     constructor(config) {
         this.config = config;
     }
@@ -223,6 +224,7 @@ export class ImapFlowConnection {
             host: this.config.host,
             port: this.config.port,
             secure: this.config.tls,
+            transport: this.config.transport,
             servername: this.config.tlsOptions?.servername,
             auth,
             tls: tlsOptions,
@@ -356,8 +358,12 @@ export class ImapFlowConnection {
         // Idempotency guard: re-selecting the currently-open mailbox is a no-op
         // SELECT on the wire. `mailbox` exposes the live, already-selected box, so
         // we can return its status without paying for another round-trip — this is
-        // what lets a batch issue one SELECT and many fetches on the same box.
-        if (this.currentMailbox === mailboxPath && this.client?.mailbox) {
+        // what lets a batch issue one SELECT and many fetches on the same box. A
+        // read-only open does not cover a read-write request: a pooled connection
+        // a sync left EXAMINEd must SELECT before a STORE, MOVE or EXPUNGE.
+        if (this.currentMailbox === mailboxPath &&
+            this.client?.mailbox &&
+            (readOnly || !this.currentMailboxReadOnly)) {
             return this.toBoxStatus(this.client.mailbox, readOnly);
         }
         const mailbox = await this.client?.mailboxOpen(mailboxPath, {
@@ -367,6 +373,7 @@ export class ImapFlowConnection {
             throw new Error(`Failed to open mailbox: ${mailboxPath}`);
         }
         this.currentMailbox = mailboxPath;
+        this.currentMailboxReadOnly = readOnly;
         return this.toBoxStatus(mailbox, readOnly);
     };
     /**
@@ -995,6 +1002,9 @@ export class ImapFlowConnection {
             uidValidity: true,
             highestModseq: true,
         });
+        if (status === false) {
+            throw new Error(`IMAP STATUS returned no result for ${mailboxPath}`);
+        }
         const deletedCount = await this.countDeleted(mailboxPath);
         return {
             messages: status.messages ?? 0,
@@ -1052,30 +1062,6 @@ export class ImapFlowConnection {
         }
     };
 }
-/**
- * Create an ImapFlow connection from account data using password credentials.
- */
-export const createImapFlowConnectionFromAccount = (account, password) => {
-    return new ImapFlowConnection({
-        host: account.imapHost,
-        port: account.imapPort,
-        tls: account.imapTls,
-        user: account.username,
-        credentials: { kind: "password", password },
-    });
-};
-/**
- * Create an ImapFlow connection using a credentials union (password or OAuth access token).
- */
-export const createImapFlowConnectionWithCredentials = (account, credentials) => {
-    return new ImapFlowConnection({
-        host: account.imapHost,
-        port: account.imapPort,
-        tls: account.imapTls,
-        user: account.username,
-        credentials,
-    });
-};
 /**
  * Build the imapflow auth object from mail credentials.
  *

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { type BodySyncQueueConfig, type BodySyncQueueLogger, BodySyncQueueServic
 export { isMessageBodySyncBroken, type ResolveExhaustedBodySyncDeps, type ResolveExhaustedBodySyncInput, type ResolveExhaustedBodySyncResult, resolveExhaustedBodySyncFailures, } from "./body-sync-terminal.js";
 export { backfillClassifications, type ClassificationBackfillCheckpoint, type ClassificationBackfillCheckpointStore, type ClassificationBackfillDeps, type ClassificationBackfillLogger, type ClassificationBackfillOptions, type ClassificationBackfillProgress, type ClassificationBackfillResult, type ClassificationBackfillTotals, } from "./classification-backfill.js";
 export { classifyParsedMessage, extractPrimaryFromEmail, } from "./classify-message.js";
-export { createConnection, createConnectionFromAccount, createConnectionWithCredentials, createManagedConnectionFactory, type ManagedConnectionFactory, } from "./connection-factory.js";
+export { type ConnectionScope, connectionScope, createConnection, createConnectionWithCredentials, } from "./connection-factory.js";
 export { type ImapTestConfig, type SmtpTestConfig, type TestResult, testImapConnection, testSmtpConnection, } from "./connection-test.js";
 export { type CreatedFilter, createFilter, type FilterPage, type FilterPatch, listFilters, type NewFilter, resolveFilterUpdate, updateFilter, } from "./filter-operations.js";
 export { extractListId, normalizeListId } from "./filters/list-id.js";
@@ -27,7 +27,7 @@ export { classifyPlacement, type FolderPlacement, type PlacementAction, type Pla
 export { classifyDisplayNameCorrespondence, extractOffDomainLinkDomains, extractSenderMismatch, type SenderMismatchContext, type SenderMismatchSignals, } from "./heuristics/senderMismatch.js";
 export { SOCIAL_DOMAINS } from "./heuristics/socialDomains.js";
 export { TRANSACTIONAL_DOMAINS } from "./heuristics/transactionalDomains.js";
-export { createImapFlowConnectionFromAccount, createImapFlowConnectionWithCredentials, ImapFlowConnection, } from "./imapflow-connection.js";
+export { ImapFlowConnection } from "./imapflow-connection.js";
 export { backfillListIds, type ListIdBackfillCheckpoint, type ListIdBackfillCheckpointStore, type ListIdBackfillDeps, type ListIdBackfillLogger, type ListIdBackfillOptions, type ListIdBackfillProgress, type ListIdBackfillResult, type ListIdBackfillTotals, } from "./list-id-backfill.js";
 export { guardConnectionCursor, guardMailboxCursor, isCursorRebuildNeeded, type MailboxCursorCheck, type MailboxCursorGuardDeps, MailboxCursorPausedError, } from "./mailbox-cursor.js";
 export { type CursorRebuildMatch, type CursorRebuildMatchResult, type CursorRebuildRow, type CursorRebuildSnapshot, matchCursorRebuild, } from "./mailbox-cursor-rebuild.js";
@@ -59,5 +59,5 @@ export { extractSearchText, extractSnippetFromEmail, generateSnippet, normalizeS
 export { MoveNotSettledError, NoJunkMailboxError, type SpamReportConfig, type SpamReportLogger, type SpamReportParams, SpamReportService, } from "./spam-report.js";
 export { type ServerUids, type SyncWarningContext, type SyncWarningRound, SyncWarningService, } from "./sync-warning.js";
 export { buildThreadMessageMoveRevert, buildThreadMessageTrashUpdate, buildThreadMessageUndelete, type ThreadMessageRowState, } from "./thread-message-rows.js";
-export type { FlatMailboxInfo, IImapConnection, ImapBoxStatus, ImapConnectionConfig, ImapConnectionState, ImapNamespace, ImapNamespaces, MailboxSyncResult, MailConnectionErrorKind, MailCredentials, } from "./types.js";
+export type { FlatMailboxInfo, IImapConnection, ImapBoxStatus, ImapConnectionConfig, ImapConnectionState, ImapNamespace, ImapNamespaces, ImapTransport, MailboxSyncResult, MailConnectionErrorKind, MailCredentials, } from "./types.js";
 export { MailConnectionError } from "./types.js";

package/dist/index.js

@@ -12,7 +12,7 @@ export { isMessageBodySyncBroken, resolveExhaustedBodySyncFailures, } from "./bo
 export { backfillClassifications, } from "./classification-backfill.js";
 export { classifyParsedMessage, extractPrimaryFromEmail, } from "./classify-message.js";
 // Connection factory
-export { createConnection, createConnectionFromAccount, createConnectionWithCredentials, createManagedConnectionFactory, } from "./connection-factory.js";
+export { connectionScope, createConnection, createConnectionWithCredentials, } from "./connection-factory.js";
 // Connection testing
 export { testImapConnection, testSmtpConnection, } from "./connection-test.js";
 export { createFilter, listFilters, resolveFilterUpdate, updateFilter, } from "./filter-operations.js";
@@ -30,7 +30,7 @@ export { classifyDisplayNameCorrespondence, extractOffDomainLinkDomains, extract
 export { SOCIAL_DOMAINS } from "./heuristics/socialDomains.js";
 export { TRANSACTIONAL_DOMAINS } from "./heuristics/transactionalDomains.js";
 // IMAP connection (ImapFlow-based)
-export { createImapFlowConnectionFromAccount, createImapFlowConnectionWithCredentials, ImapFlowConnection, } from "./imapflow-connection.js";
+export { ImapFlowConnection } from "./imapflow-connection.js";
 export { backfillListIds, } from "./list-id-backfill.js";
 export { guardConnectionCursor, guardMailboxCursor, isCursorRebuildNeeded, MailboxCursorPausedError, } from "./mailbox-cursor.js";
 export { matchCursorRebuild, } from "./mailbox-cursor-rebuild.js";

package/dist/message-sync.d.ts

@@ -1,9 +1,8 @@
 import type { IAddressRepository, IEnvelopeRepository, IMailboxRepository, IMailboxSpecialUseRepository, IMessageFlagPushRepository, IMessageFlagRepository, IMessageRepository, IThreadMessageRepository } from "@remit/data-ports";
 import type { JunkRoleMailboxes } from "@remit/data-ports/folder-role";
-import type { ManagedConnectionFactory } from "./connection-factory.js";
 import type { QuarantineService } from "./quarantine.js";
 import type { SyncWarningService } from "./sync-warning.js";
-import type { ImapAddress } from "./types.js";
+import type { IImapConnection, ImapAddress } from "./types.js";
 /**
  * A From address is only usable when it looks like a real mailbox: both parts
  * present, neither is a known "could not parse" sentinel, and the host carries
@@ -63,7 +62,7 @@ export declare const parseHeaderDate: (raw: string | undefined, fallbackMs: numb
     usedFallback: boolean;
 };
 /**
- * @deprecated Use ManagedConnectionFactory instead
+ * @deprecated Pass the IImapConnection to MessageSyncService instead
  */
 export type ImapConnectionFactory = () => {
     connect(): Promise<void>;
@@ -101,7 +100,7 @@ export interface SyncMessagesResult {
  */
 export declare const selectUidsToSync: (allUids: number[], lastSyncUid: number, highWaterMarkUid: number) => number[];
 export declare class MessageSyncService {
-    private connectionFactory;
+    private connection;
     private mailboxService;
     /**
      * The account’s folder-role map. Required, not optional: which folder
@@ -135,7 +134,7 @@ export declare class MessageSyncService {
      */
     private quarantineService?;
     private log;
-    constructor(connectionFactory: ManagedConnectionFactory, mailboxService: IMailboxRepository, 
+    constructor(connection: IImapConnection, mailboxService: IMailboxRepository, 
     /**
      * The account’s folder-role map. Required, not optional: which folder
      * holds the Junk role decides whether a sighting withholds its sender

package/dist/message-sync.js

@@ -147,7 +147,7 @@ const messageIdForSighting = (accountId, mailboxId, msg) => deriveMessageIdFromS
     fromHost: msg.envelope.from?.[0]?.host,
 });
 export class MessageSyncService {
-    connectionFactory;
+    connection;
     mailboxService;
     mailboxSpecialUseService;
     messageService;
@@ -159,7 +159,7 @@ export class MessageSyncService {
     messageFlagService;
     quarantineService;
     log;
-    constructor(connectionFactory, mailboxService, 
+    constructor(connection, mailboxService, 
     /**
      * The account’s folder-role map. Required, not optional: which folder
      * holds the Junk role decides whether a sighting withholds its sender
@@ -186,7 +186,7 @@ export class MessageSyncService {
      * not re-fetched on every round.
      */
     quarantineService) {
-        this.connectionFactory = connectionFactory;
+        this.connection = connection;
         this.mailboxService = mailboxService;
         this.mailboxSpecialUseService = mailboxSpecialUseService;
         this.messageService = messageService;
@@ -227,7 +227,7 @@ export class MessageSyncService {
         }
         const lastSyncUid = mailbox.lastSyncUid || 0;
         const highWaterMarkUid = mailbox.highWaterMarkUid || 0;
-        const connection = this.connectionFactory.getConnection();
+        const connection = this.connection;
         const box = await connection.openBox(mailboxPath);
         const status = await connection.getMailboxStatus(mailboxPath);
         // Detection: the served UIDVALIDITY may have changed since it was last
@@ -453,7 +453,7 @@ export class MessageSyncService {
         await this.mailboxService.update(accountId, mailboxId, {
             cursorState: MailboxCursorState.rebuilding,
         });
-        const connection = this.connectionFactory.getConnection();
+        const connection = this.connection;
         const box = await connection.openBox(mailboxPath);
         // Read before the pass, never after: a message arriving while the
         // rebuild runs is absent from the snapshot below, and a HIGHESTMODSEQ
@@ -652,7 +652,7 @@ export class MessageSyncService {
         const { mailbox, accountId, accountConfigId, cursor, box, status, batchSize, } = params;
         const mailboxId = mailbox.mailboxId;
         const mailboxPath = mailbox.fullPath;
-        const connection = this.connectionFactory.getConnection();
+        const connection = this.connection;
         // Ask from the last COMPLETE mod-sequence, so a group left part-applied
         // by an earlier round is served again in full; its applied members are
         // then dropped by position, without a lookup.
@@ -963,7 +963,7 @@ export class MessageSyncService {
      * Assumes mailbox is already open from fetchUidsToSync.
      */
     async fetchMessageBatch(uids) {
-        const connection = this.connectionFactory.getConnection();
+        const connection = this.connection;
         return await connection.fetchMessages(uids);
     }
     /**
@@ -1004,7 +1004,7 @@ export class MessageSyncService {
      */
     async probeDepartures(mailbox, accountId, applicable) {
         return confirmDepartures({
-            connection: this.connectionFactory.getConnection(),
+            connection: this.connection,
             mailboxService: this.mailboxService,
             messageService: this.messageService,
             log: this.log,

package/dist/node-transport.d.ts

@@ -0,0 +1,2 @@
+import type { ImapTransport } from "imapflow";
+export declare const nodeTransport: () => ImapTransport;

package/dist/node-transport.js

@@ -0,0 +1,8 @@
+import { connect as netConnect } from "node:net";
+import { connect as tlsConnect } from "node:tls";
+export const nodeTransport = () => ({
+    connect: ({ host, port, servername, tls, secure }, onConnect) => secure
+        ? tlsConnect({ host, port, servername, ...tls }, onConnect)
+        : netConnect({ host, port }, onConnect),
+    upgrade: (socket, { host, port, servername, tls }, onSecure) => tlsConnect({ socket, host, port, servername, ...tls }, onSecure),
+});

package/dist/test-helpers/fake-imap.d.ts

@@ -91,8 +91,10 @@ export declare class FakeImapConnection implements IImapConnection {
     readonly state: ImapConnectionState;
     readonly isConnected = true;
     private selected;
+    private selectedReadOnly;
     constructor(server: FakeImapServer);
     private open;
+    private writable;
     private uidList;
     connect: () => Promise<void>;
     disconnect: () => Promise<void>;

package/dist/test-helpers/fake-imap.js

@@ -216,6 +216,7 @@ export class FakeImapConnection {
     state = "authenticated";
     isConnected = true;
     selected = null;
+    selectedReadOnly = true;
     constructor(server) {
         this.server = server;
     }
@@ -224,6 +225,13 @@ export class FakeImapConnection {
             throw new Error("No mailbox selected");
         return this.server.folder(this.selected);
     }
+    writable() {
+        const folder = this.open();
+        if (this.selectedReadOnly) {
+            throw imapError("READ-ONLY", `Mailbox is read-only: ${this.selected}`);
+        }
+        return folder;
+    }
     uidList = (uids) => uids.join(",");
     connect = async () => { };
     disconnect = async () => { };
@@ -248,10 +256,11 @@ export class FakeImapConnection {
             };
         });
     };
-    openBox = async (path, readOnly = false) => {
+    openBox = async (path, readOnly = true) => {
         this.server.run(readOnly ? "EXAMINE" : "SELECT", path);
         const folder = this.server.folder(path);
         this.selected = path;
+        this.selectedReadOnly = readOnly;
         return {
             name: path,
             readOnly,
@@ -389,7 +398,7 @@ export class FakeImapConnection {
     }
     touch = (detail, uids, change) => {
         this.server.run("STORE", `${this.selected} ${this.uidList(uids)} ${detail}`);
-        const folder = this.open();
+        const folder = this.writable();
         const modseq = this.server.bumpModseq();
         for (const uid of uids) {
             const stored = folder.messages.get(uid);
@@ -446,7 +455,7 @@ export class FakeImapConnection {
         if (this.server.ignoreNext.delete(verb)) {
             return { destination, uidValidity: target.uidValidity, uidMap };
         }
-        const source = this.open();
+        const source = verb === "MOVE" ? this.writable() : this.open();
         for (const uid of uids) {
             const stored = source.messages.get(uid);
             if (!stored)
@@ -468,7 +477,7 @@ export class FakeImapConnection {
     copyMessages = async (uids, destination) => this.transfer("COPY", uids, destination);
     deleteMessages = async (uids) => {
         this.server.run("EXPUNGE", `${this.selected} ${this.uidList(uids)}`);
-        const folder = this.open();
+        const folder = this.writable();
         let deleted = 0;
         for (const uid of uids) {
             if (folder.messages.delete(uid))

package/dist/test-helpers/test-store.js

@@ -146,7 +146,7 @@ export const silentLog = {
 };
 export const syncFolder = async (store, account, mailbox, imap) => {
     const connection = imap.connection();
-    const service = new MessageSyncService({ getConnection: () => connection, close: async () => { } }, store.mailbox, store.mailboxSpecialUse, store.message, store.envelope, store.address, store.threadMessage, new SyncWarningService(store.syncWarning), silentLog, store.flagPush, store.messageFlag);
+    const service = new MessageSyncService(connection, store.mailbox, store.mailboxSpecialUse, store.message, store.envelope, store.address, store.threadMessage, new SyncWarningService(store.syncWarning), silentLog, store.flagPush, store.messageFlag);
     const synced = [];
     for (;;) {
         const result = await service.syncMessages(mailbox.mailboxId, account.accountId, account.accountConfigId);

package/dist/types.d.ts

@@ -2,6 +2,8 @@
  * Types for the remit-mailbox-service
  */
 import type { Readable } from "node:stream";
+import type { ImapTransport } from "imapflow";
+export type { ImapTransport };
 /**
  * Discriminated union of mail authentication credentials.
  *
@@ -40,6 +42,7 @@ export interface ImapConnectionConfig {
     user: string;
     credentials: MailCredentials;
     tls: boolean;
+    transport: ImapTransport;
     tlsOptions?: {
         rejectUnauthorized?: boolean;
         servername?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remit/mailbox-service",
-	"version": "0.0.114",
+	"version": "0.0.115",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -21,6 +21,10 @@
 			"types": "./dist/imapflow-connection.d.ts",
 			"default": "./dist/imapflow-connection.js"
 		},
+		"./node-transport": {
+			"types": "./dist/node-transport.d.ts",
+			"default": "./dist/node-transport.js"
+		},
 		"./account-credentials": {
 			"types": "./dist/account-credentials.d.ts",
 			"default": "./dist/account-credentials.js"
@@ -55,7 +59,7 @@
 		"better-sqlite3": "^12.11.1"
 	},
 	"dependencies": {
-		"imapflow": "^1.3.3",
+		"imapflow": "^2.9.1",
 		"mailparser": "3.12.2",
 		"nodemailer": "^10.0.6",
 		"p-map": "^7.0.4",