@bobfrankston/iflow 1.0.33 → 1.0.37

package/imaplib/imap-protocol.d.ts

@@ -0,0 +1,131 @@
+/**
+ * IMAP protocol parser and command builder.
+ * Pure string logic — no I/O, no Node.js dependencies.
+ * Works in browser, Node.js, or worker thread.
+ */
+/** Parsed IMAP response line */
+export interface ImapResponse {
+    /** Tag ("*" for untagged, "+" for continuation, or the command tag) */
+    tag: string;
+    /** Status (OK, NO, BAD, BYE, PREAUTH) or response type (EXISTS, RECENT, FETCH, etc.) */
+    type: string;
+    /** The full text after the tag and type */
+    text: string;
+    /** Raw line */
+    raw: string;
+}
+/** Parsed FETCH response data */
+export interface FetchData {
+    seq: number;
+    uid?: number;
+    flags?: Set<string>;
+    internalDate?: Date;
+    size?: number;
+    envelope?: EnvelopeData;
+    bodyStructure?: any;
+    headers?: string;
+    source?: string;
+}
+/** Parsed ENVELOPE data */
+export interface EnvelopeData {
+    date: Date | null;
+    subject: string;
+    from: AddressData[];
+    sender: AddressData[];
+    replyTo: AddressData[];
+    to: AddressData[];
+    cc: AddressData[];
+    bcc: AddressData[];
+    inReplyTo: string;
+    messageId: string;
+}
+export interface AddressData {
+    name: string;
+    address: string;
+}
+/** Parsed folder LIST data */
+export interface ListData {
+    flags: string[];
+    delimiter: string;
+    path: string;
+}
+/** Parsed STATUS data */
+export interface StatusData {
+    messages?: number;
+    recent?: number;
+    uidNext?: number;
+    uidValidity?: number;
+    unseen?: number;
+}
+/** Generate a unique command tag */
+export declare function nextTag(): string;
+/** Reset tag counter (for testing) */
+export declare function resetTags(): void;
+/** Build an IMAP command string (tag + command + CRLF) */
+export declare function buildCommand(tag: string, command: string): string;
+/** Build LOGIN command */
+export declare function loginCommand(tag: string, user: string, pass: string): string;
+/** Build AUTHENTICATE XOAUTH2 command */
+export declare function xoauth2Command(tag: string, user: string, token: string): string;
+/** Build LIST command */
+export declare function listCommand(tag: string, ref?: string, pattern?: string): string;
+/** Build SELECT command */
+export declare function selectCommand(tag: string, mailbox: string): string;
+/** Build EXAMINE command (read-only SELECT) */
+export declare function examineCommand(tag: string, mailbox: string): string;
+/** Build STATUS command */
+export declare function statusCommand(tag: string, mailbox: string, items?: string[]): string;
+/** Build UID FETCH command */
+export declare function fetchCommand(tag: string, range: string, items: string[]): string;
+/** Build UID SEARCH command */
+export declare function searchCommand(tag: string, criteria: string): string;
+/** Build UID STORE command (set/add/remove flags) */
+export declare function storeCommand(tag: string, uid: number, action: string, flags: string[]): string;
+/** Build UID COPY command */
+export declare function copyCommand(tag: string, uid: number, destination: string): string;
+/** Build UID MOVE command */
+export declare function moveCommand(tag: string, uid: number, destination: string): string;
+/** Build APPEND command header (body follows as literal) */
+export declare function appendCommand(tag: string, mailbox: string, flags: string[], size: number): string;
+/** Build IDLE command */
+export declare function idleCommand(tag: string): string;
+/** Build DONE command (ends IDLE) */
+export declare function doneCommand(): string;
+/** Build STARTTLS command */
+export declare function starttlsCommand(tag: string): string;
+/** Build LOGOUT command */
+export declare function logoutCommand(tag: string): string;
+/** Build CAPABILITY command */
+export declare function capabilityCommand(tag: string): string;
+/** Build NOOP command */
+export declare function noopCommand(tag: string): string;
+/** Build CREATE command */
+export declare function createCommand(tag: string, mailbox: string): string;
+/** Build DELETE command */
+export declare function deleteMailboxCommand(tag: string, mailbox: string): string;
+/** Build RENAME command */
+export declare function renameCommand(tag: string, from: string, to: string): string;
+/** Parse a single IMAP response line */
+export declare function parseResponseLine(line: string): ImapResponse;
+/** Parse a LIST response line: * LIST (\flags) "delimiter" "path" */
+export declare function parseListResponse(text: string): ListData | null;
+/** Parse STATUS response: * STATUS "mailbox" (MESSAGES n UIDNEXT n ...) */
+export declare function parseStatusResponse(text: string): StatusData | null;
+/** Parse UID SEARCH response: * SEARCH 1 2 3 4 5 */
+export declare function parseSearchResponse(text: string): number[];
+/** Parse FLAGS from a FETCH or SELECT response */
+export declare function parseFlags(flagStr: string): Set<string>;
+/** Parse ENVELOPE from FETCH — simplified parser for the common fields */
+export declare function parseEnvelope(envStr: string): EnvelopeData;
+/** Build SEARCH criteria string from common search parameters */
+export declare function buildSearchCriteria(criteria: {
+    since?: Date;
+    before?: Date;
+    from?: string;
+    to?: string;
+    subject?: string;
+    body?: string;
+    uid?: string;
+    all?: boolean;
+}): string;
+//# sourceMappingURL=imap-protocol.d.ts.map

package/imaplib/imap-protocol.js

@@ -0,0 +1,370 @@
+/**
+ * IMAP protocol parser and command builder.
+ * Pure string logic — no I/O, no Node.js dependencies.
+ * Works in browser, Node.js, or worker thread.
+ */
+// ── Command Builder ──
+let tagCounter = 0;
+/** Generate a unique command tag */
+export function nextTag() {
+    return `A${++tagCounter}`;
+}
+/** Reset tag counter (for testing) */
+export function resetTags() {
+    tagCounter = 0;
+}
+/** Build an IMAP command string (tag + command + CRLF) */
+export function buildCommand(tag, command) {
+    return `${tag} ${command}\r\n`;
+}
+/** Build LOGIN command */
+export function loginCommand(tag, user, pass) {
+    // Quote user and password to handle special characters
+    return buildCommand(tag, `LOGIN ${quoteString(user)} ${quoteString(pass)}`);
+}
+/** Build AUTHENTICATE XOAUTH2 command */
+export function xoauth2Command(tag, user, token) {
+    const authStr = `user=${user}\x01auth=Bearer ${token}\x01\x01`;
+    const b64 = btoa(authStr);
+    return buildCommand(tag, `AUTHENTICATE XOAUTH2 ${b64}`);
+}
+/** Build LIST command */
+export function listCommand(tag, ref = '""', pattern = '"*"') {
+    return buildCommand(tag, `LIST ${ref} ${pattern}`);
+}
+/** Build SELECT command */
+export function selectCommand(tag, mailbox) {
+    return buildCommand(tag, `SELECT ${quoteMailbox(mailbox)}`);
+}
+/** Build EXAMINE command (read-only SELECT) */
+export function examineCommand(tag, mailbox) {
+    return buildCommand(tag, `EXAMINE ${quoteMailbox(mailbox)}`);
+}
+/** Build STATUS command */
+export function statusCommand(tag, mailbox, items = ["MESSAGES", "UIDNEXT"]) {
+    return buildCommand(tag, `STATUS ${quoteMailbox(mailbox)} (${items.join(" ")})`);
+}
+/** Build UID FETCH command */
+export function fetchCommand(tag, range, items) {
+    return buildCommand(tag, `UID FETCH ${range} (${items.join(" ")})`);
+}
+/** Build UID SEARCH command */
+export function searchCommand(tag, criteria) {
+    return buildCommand(tag, `UID SEARCH ${criteria}`);
+}
+/** Build UID STORE command (set/add/remove flags) */
+export function storeCommand(tag, uid, action, flags) {
+    return buildCommand(tag, `UID STORE ${uid} ${action} (${flags.join(" ")})`);
+}
+/** Build UID COPY command */
+export function copyCommand(tag, uid, destination) {
+    return buildCommand(tag, `UID COPY ${uid} ${quoteMailbox(destination)}`);
+}
+/** Build UID MOVE command */
+export function moveCommand(tag, uid, destination) {
+    return buildCommand(tag, `UID MOVE ${uid} ${quoteMailbox(destination)}`);
+}
+/** Build APPEND command header (body follows as literal) */
+export function appendCommand(tag, mailbox, flags, size) {
+    const flagStr = flags.length > 0 ? ` (${flags.join(" ")})` : "";
+    return buildCommand(tag, `APPEND ${quoteMailbox(mailbox)}${flagStr} {${size}}`);
+}
+/** Build IDLE command */
+export function idleCommand(tag) {
+    return buildCommand(tag, "IDLE");
+}
+/** Build DONE command (ends IDLE) */
+export function doneCommand() {
+    return "DONE\r\n";
+}
+/** Build STARTTLS command */
+export function starttlsCommand(tag) {
+    return buildCommand(tag, "STARTTLS");
+}
+/** Build LOGOUT command */
+export function logoutCommand(tag) {
+    return buildCommand(tag, "LOGOUT");
+}
+/** Build CAPABILITY command */
+export function capabilityCommand(tag) {
+    return buildCommand(tag, "CAPABILITY");
+}
+/** Build NOOP command */
+export function noopCommand(tag) {
+    return buildCommand(tag, "NOOP");
+}
+/** Build CREATE command */
+export function createCommand(tag, mailbox) {
+    return buildCommand(tag, `CREATE ${quoteMailbox(mailbox)}`);
+}
+/** Build DELETE command */
+export function deleteMailboxCommand(tag, mailbox) {
+    return buildCommand(tag, `DELETE ${quoteMailbox(mailbox)}`);
+}
+/** Build RENAME command */
+export function renameCommand(tag, from, to) {
+    return buildCommand(tag, `RENAME ${quoteMailbox(from)} ${quoteMailbox(to)}`);
+}
+// ── Response Parser ──
+/** Parse a single IMAP response line */
+export function parseResponseLine(line) {
+    const trimmed = line.replace(/\r?\n$/, "");
+    // Continuation response
+    if (trimmed.startsWith("+ ") || trimmed === "+") {
+        return { tag: "+", type: "CONTINUE", text: trimmed.substring(2), raw: trimmed };
+    }
+    // Untagged response
+    if (trimmed.startsWith("* ")) {
+        const rest = trimmed.substring(2);
+        // Check for numeric response (e.g., "* 5 EXISTS")
+        const numMatch = rest.match(/^(\d+)\s+(\S+)(.*)$/);
+        if (numMatch) {
+            return { tag: "*", type: numMatch[2].toUpperCase(), text: rest, raw: trimmed };
+        }
+        // Status/capability/list response
+        const spaceIdx = rest.indexOf(" ");
+        if (spaceIdx > 0) {
+            return { tag: "*", type: rest.substring(0, spaceIdx).toUpperCase(), text: rest.substring(spaceIdx + 1), raw: trimmed };
+        }
+        return { tag: "*", type: rest.toUpperCase(), text: "", raw: trimmed };
+    }
+    // Tagged response (e.g., "A1 OK Login completed")
+    const spaceIdx = trimmed.indexOf(" ");
+    if (spaceIdx > 0) {
+        const tag = trimmed.substring(0, spaceIdx);
+        const rest = trimmed.substring(spaceIdx + 1);
+        const spaceIdx2 = rest.indexOf(" ");
+        if (spaceIdx2 > 0) {
+            return { tag, type: rest.substring(0, spaceIdx2).toUpperCase(), text: rest.substring(spaceIdx2 + 1), raw: trimmed };
+        }
+        return { tag, type: rest.toUpperCase(), text: "", raw: trimmed };
+    }
+    return { tag: "", type: "UNKNOWN", text: trimmed, raw: trimmed };
+}
+/** Parse a LIST response line: * LIST (\flags) "delimiter" "path" */
+export function parseListResponse(text) {
+    // Match: LIST (flags) "delimiter" "path" or LIST (flags) "delimiter" path
+    const match = text.match(/^LIST\s+\(([^)]*)\)\s+"([^"]*)"\s+(?:"([^"]+)"|(\S+))$/i);
+    if (!match)
+        return null;
+    const flags = match[1] ? match[1].split(/\s+/).filter(Boolean) : [];
+    const delimiter = match[2] || ".";
+    const path = match[3] || match[4] || "";
+    return { flags, delimiter, path };
+}
+/** Parse STATUS response: * STATUS "mailbox" (MESSAGES n UIDNEXT n ...) */
+export function parseStatusResponse(text) {
+    const match = text.match(/\(([^)]+)\)/);
+    if (!match)
+        return null;
+    const pairs = match[1].split(/\s+/);
+    const data = {};
+    for (let i = 0; i < pairs.length - 1; i += 2) {
+        const key = pairs[i].toUpperCase();
+        const val = parseInt(pairs[i + 1]);
+        if (key === "MESSAGES")
+            data.messages = val;
+        else if (key === "RECENT")
+            data.recent = val;
+        else if (key === "UIDNEXT")
+            data.uidNext = val;
+        else if (key === "UIDVALIDITY")
+            data.uidValidity = val;
+        else if (key === "UNSEEN")
+            data.unseen = val;
+    }
+    return data;
+}
+/** Parse UID SEARCH response: * SEARCH 1 2 3 4 5 */
+export function parseSearchResponse(text) {
+    if (!text.trim())
+        return [];
+    return text.trim().split(/\s+/).map(Number).filter(n => !isNaN(n));
+}
+/** Parse FLAGS from a FETCH or SELECT response */
+export function parseFlags(flagStr) {
+    const match = flagStr.match(/\(([^)]*)\)/);
+    if (!match)
+        return new Set();
+    return new Set(match[1].split(/\s+/).filter(Boolean));
+}
+/** Parse ENVELOPE from FETCH — simplified parser for the common fields */
+export function parseEnvelope(envStr) {
+    // ENVELOPE is a parenthesized list — this is a simplified parser
+    // Full RFC 3501 envelope: (date subject from sender reply-to to cc bcc in-reply-to message-id)
+    const result = {
+        date: null, subject: "", from: [], sender: [], replyTo: [],
+        to: [], cc: [], bcc: [], inReplyTo: "", messageId: ""
+    };
+    try {
+        const tokens = tokenizeParenList(envStr);
+        if (tokens.length >= 10) {
+            result.date = tokens[0] !== "NIL" ? new Date(unquote(tokens[0])) : null;
+            result.subject = decodeImapString(unquote(tokens[1]));
+            result.from = parseAddressList(tokens[2]);
+            result.sender = parseAddressList(tokens[3]);
+            result.replyTo = parseAddressList(tokens[4]);
+            result.to = parseAddressList(tokens[5]);
+            result.cc = parseAddressList(tokens[6]);
+            result.bcc = parseAddressList(tokens[7]);
+            result.inReplyTo = unquote(tokens[8]);
+            result.messageId = unquote(tokens[9]);
+        }
+    }
+    catch {
+        // Parsing envelope is best-effort — incomplete data is acceptable
+    }
+    return result;
+}
+// ── IMAP String Utilities ──
+/** Quote a string for IMAP (handles special characters) */
+function quoteString(s) {
+    if (/[\x00-\x1f\x7f"\\]/.test(s)) {
+        // Use literal for problematic characters
+        return `{${Buffer.byteLength(s)}}\r\n${s}`;
+    }
+    return `"${s}"`;
+}
+/** Quote a mailbox name */
+function quoteMailbox(name) {
+    if (name === "INBOX")
+        return name;
+    if (/[\s"\\*%{]/.test(name))
+        return `"${name.replace(/["\\]/g, "\\$&")}"`;
+    return name;
+}
+/** Remove quotes from an IMAP string */
+function unquote(s) {
+    if (!s || s === "NIL")
+        return "";
+    if (s.startsWith('"') && s.endsWith('"'))
+        return s.slice(1, -1).replace(/\\(.)/g, "$1");
+    return s;
+}
+/** Decode IMAP encoded-word (=?charset?encoding?text?=) */
+function decodeImapString(s) {
+    if (!s)
+        return "";
+    return s.replace(/=\?([^?]+)\?([BQ])\?([^?]+)\?=/gi, (_match, charset, encoding, text) => {
+        try {
+            if (encoding.toUpperCase() === "B") {
+                return Buffer.from(text, "base64").toString("utf-8");
+            }
+            else {
+                // Quoted-printable
+                return text.replace(/=([0-9A-F]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16))).replace(/_/g, " ");
+            }
+        }
+        catch {
+            return text;
+        }
+    });
+}
+/** Tokenize a parenthesized IMAP list (top-level only) */
+function tokenizeParenList(s) {
+    const tokens = [];
+    let i = 0;
+    const str = s.trim();
+    // Skip outer parens
+    const start = str.startsWith("(") ? 1 : 0;
+    const end = str.endsWith(")") ? str.length - 1 : str.length;
+    i = start;
+    while (i < end) {
+        // Skip whitespace
+        while (i < end && str[i] === " ")
+            i++;
+        if (i >= end)
+            break;
+        if (str[i] === "(") {
+            // Nested paren group — find matching close
+            let depth = 1;
+            let j = i + 1;
+            while (j < end && depth > 0) {
+                if (str[j] === "(")
+                    depth++;
+                else if (str[j] === ")")
+                    depth--;
+                j++;
+            }
+            tokens.push(str.substring(i, j));
+            i = j;
+        }
+        else if (str[i] === '"') {
+            // Quoted string
+            let j = i + 1;
+            while (j < end) {
+                if (str[j] === "\\" && j + 1 < end) {
+                    j += 2;
+                    continue;
+                }
+                if (str[j] === '"') {
+                    j++;
+                    break;
+                }
+                j++;
+            }
+            tokens.push(str.substring(i, j));
+            i = j;
+        }
+        else if (str.substring(i, i + 3).toUpperCase() === "NIL") {
+            tokens.push("NIL");
+            i += 3;
+        }
+        else {
+            // Atom
+            let j = i;
+            while (j < end && str[j] !== " " && str[j] !== ")" && str[j] !== "(")
+                j++;
+            tokens.push(str.substring(i, j));
+            i = j;
+        }
+    }
+    return tokens;
+}
+/** Parse an IMAP address list: ((name NIL mailbox host) ...) */
+function parseAddressList(token) {
+    if (!token || token === "NIL")
+        return [];
+    const addrs = [];
+    // Match each (name atdomain mailbox host) group
+    const re = /\(([^)]*)\)/g;
+    let m;
+    while ((m = re.exec(token)) !== null) {
+        const parts = tokenizeParenList(m[1]);
+        if (parts.length >= 4) {
+            const name = decodeImapString(unquote(parts[0]));
+            const mailbox = unquote(parts[2]);
+            const host = unquote(parts[3]);
+            const address = mailbox && host ? `${mailbox}@${host}` : mailbox || "";
+            addrs.push({ name, address });
+        }
+    }
+    return addrs;
+}
+/** Build SEARCH criteria string from common search parameters */
+export function buildSearchCriteria(criteria) {
+    const parts = [];
+    if (criteria.all)
+        parts.push("ALL");
+    if (criteria.since)
+        parts.push(`SINCE ${formatImapDate(criteria.since)}`);
+    if (criteria.before)
+        parts.push(`BEFORE ${formatImapDate(criteria.before)}`);
+    if (criteria.from)
+        parts.push(`FROM "${criteria.from}"`);
+    if (criteria.to)
+        parts.push(`TO "${criteria.to}"`);
+    if (criteria.subject)
+        parts.push(`SUBJECT "${criteria.subject}"`);
+    if (criteria.body)
+        parts.push(`BODY "${criteria.body}"`);
+    if (criteria.uid)
+        parts.push(`UID ${criteria.uid}`);
+    return parts.length > 0 ? parts.join(" ") : "ALL";
+}
+/** Format a date for IMAP (DD-Mon-YYYY) */
+function formatImapDate(d) {
+    const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+    return `${d.getDate()}-${months[d.getMonth()]}-${d.getFullYear()}`;
+}
+//# sourceMappingURL=imap-protocol.js.map

package/imaplib/node-transport.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Node.js transport for IMAP — uses net/tls modules.
+ * This is the desktop implementation.
+ */
+import type { ImapTransport } from "./transport.js";
+export declare class NodeTransport implements ImapTransport {
+    private socket;
+    private dataHandler;
+    private closeHandler;
+    private errorHandler;
+    private _connected;
+    private rejectUnauthorized;
+    constructor(options?: {
+        rejectUnauthorized?: boolean;
+    });
+    get connected(): boolean;
+    connect(host: string, port: number, useTls: boolean, servername?: string): Promise<void>;
+    upgradeTLS(servername?: string): Promise<void>;
+    write(data: string | Uint8Array): Promise<void>;
+    onData(handler: (data: string) => void): void;
+    onClose(handler: (hadError: boolean) => void): void;
+    onError(handler: (err: Error) => void): void;
+    close(): void;
+}
+//# sourceMappingURL=node-transport.d.ts.map

package/imaplib/node-transport.js

@@ -0,0 +1,109 @@
+/**
+ * Node.js transport for IMAP — uses net/tls modules.
+ * This is the desktop implementation.
+ */
+import * as net from "node:net";
+import * as tls from "node:tls";
+export class NodeTransport {
+    socket = null;
+    dataHandler = null;
+    closeHandler = null;
+    errorHandler = null;
+    _connected = false;
+    rejectUnauthorized;
+    constructor(options) {
+        this.rejectUnauthorized = options?.rejectUnauthorized ?? true;
+    }
+    get connected() { return this._connected; }
+    async connect(host, port, useTls, servername) {
+        return new Promise((resolve, reject) => {
+            const onConnect = () => {
+                this._connected = true;
+                resolve();
+            };
+            const onError = (err) => {
+                this._connected = false;
+                reject(err);
+            };
+            if (useTls) {
+                this.socket = tls.connect({
+                    host, port,
+                    servername: servername || host,
+                    rejectUnauthorized: this.rejectUnauthorized,
+                }, onConnect);
+            }
+            else {
+                this.socket = net.connect({ host, port }, onConnect);
+            }
+            this.socket.once("error", onError);
+            this.socket.setKeepAlive(true, 5000);
+            // Wire up persistent handlers after connect
+            this.socket.on("data", (chunk) => {
+                if (this.dataHandler)
+                    this.dataHandler(chunk.toString("utf-8"));
+            });
+            this.socket.on("close", (hadError) => {
+                this._connected = false;
+                if (this.closeHandler)
+                    this.closeHandler(hadError);
+            });
+            this.socket.on("error", (err) => {
+                if (this.errorHandler)
+                    this.errorHandler(err);
+            });
+        });
+    }
+    async upgradeTLS(servername) {
+        if (!this.socket)
+            throw new Error("Not connected");
+        return new Promise((resolve, reject) => {
+            const plainSocket = this.socket;
+            const tlsSocket = tls.connect({
+                socket: plainSocket,
+                servername: servername || undefined,
+                rejectUnauthorized: this.rejectUnauthorized,
+            }, () => {
+                this.socket = tlsSocket;
+                // Re-wire data handler to new socket
+                tlsSocket.on("data", (chunk) => {
+                    if (this.dataHandler)
+                        this.dataHandler(chunk.toString("utf-8"));
+                });
+                tlsSocket.on("close", (hadError) => {
+                    this._connected = false;
+                    if (this.closeHandler)
+                        this.closeHandler(hadError);
+                });
+                tlsSocket.on("error", (err) => {
+                    if (this.errorHandler)
+                        this.errorHandler(err);
+                });
+                resolve();
+            });
+            tlsSocket.once("error", reject);
+        });
+    }
+    async write(data) {
+        if (!this.socket || this.socket.destroyed)
+            throw new Error("Not connected");
+        return new Promise((resolve, reject) => {
+            this.socket.write(data, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    onData(handler) { this.dataHandler = handler; }
+    onClose(handler) { this.closeHandler = handler; }
+    onError(handler) { this.errorHandler = handler; }
+    close() {
+        this._connected = false;
+        if (this.socket && !this.socket.destroyed) {
+            this.socket.destroy();
+        }
+        this.socket = null;
+    }
+}
+//# sourceMappingURL=node-transport.js.map

package/imaplib/transport.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Abstract transport interface for IMAP connections.
+ * Implementations: NodeTransport (desktop), BridgeTransport (Android/WebView)
+ */
+export interface ImapTransport {
+    /** Connect to host:port. If tls=true, connect with TLS directly (port 993). */
+    connect(host: string, port: number, tls: boolean, servername?: string): Promise<void>;
+    /** Upgrade an existing plaintext connection to TLS (STARTTLS). */
+    upgradeTLS(servername?: string): Promise<void>;
+    /** Write data to the connection. */
+    write(data: string | Uint8Array): Promise<void>;
+    /** Register a handler for incoming data. */
+    onData(handler: (data: string) => void): void;
+    /** Register a handler for connection close. */
+    onClose(handler: (hadError: boolean) => void): void;
+    /** Register a handler for errors. */
+    onError(handler: (err: Error) => void): void;
+    /** Close the connection. */
+    close(): void;
+    /** Whether the connection is active. */
+    readonly connected: boolean;
+}
+/** Factory function type for creating transports */
+export type TransportFactory = () => ImapTransport;
+//# sourceMappingURL=transport.d.ts.map

package/imaplib/transport.js

@@ -0,0 +1,6 @@
+/**
+ * Abstract transport interface for IMAP connections.
+ * Implementations: NodeTransport (desktop), BridgeTransport (Android/WebView)
+ */
+export {};
+//# sourceMappingURL=transport.js.map

package/index.d.ts

@@ -4,4 +4,10 @@ export type { SearchObject } from 'imapflow';
 export { FetchedMessage as FetchedMessageClass } from './imaplib/types.js';
 export { createAutoImapConfig } from './imaplib/gmail.js';
 export { isGmailUser, isGmailServer, createImapConfig, type OAuthImapConfig } from './imaplib/gmail.js';
+export { NativeImapClient } from './imaplib/imap-native.js';
+export type { NativeFetchedMessage, NativeFolder, MailboxInfo } from './imaplib/imap-native.js';
+export type { ImapTransport, TransportFactory } from './imaplib/transport.js';
+export { NodeTransport } from './imaplib/node-transport.js';
+export { CompatImapClient } from './imaplib/imap-compat.js';
+export type { SpecialFolders } from './imaplib/imap-compat.js';
 //# sourceMappingURL=index.d.ts.map