@bobfrankston/iflow-direct 0.1.1

package/imap-protocol.d.ts

@@ -0,0 +1,133 @@
+/**
+ * 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;
+    /** Literal data keyed by BODY section name (e.g. "BODY[]", "BODY[HEADER]") */
+    literals?: Map<string, 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/imap-protocol.js

@@ -0,0 +1,391 @@
+/**
+ * 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", "* 131441 FETCH (...)")
+        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: (flags) "delimiter" "path" or (flags) "delimiter" path
+    // The "LIST" prefix may or may not be present (parseResponseLine may strip it into r.type)
+    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] || "").replace(/\r?\n$/, "");
+    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 `{${new TextEncoder().encode(s).length}}\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 {
+            const cs = charset.toLowerCase().replace(/^utf8$/, "utf-8");
+            if (encoding.toUpperCase() === "B") {
+                const raw = atob(text);
+                const bytes = new Uint8Array(raw.length);
+                for (let j = 0; j < raw.length; j++)
+                    bytes[j] = raw.charCodeAt(j);
+                return new TextDecoder(cs).decode(bytes);
+            }
+            else {
+                // Quoted-printable: collect bytes then decode with charset
+                const decoded = text.replace(/_/g, " ");
+                const bytes = [];
+                let i = 0;
+                while (i < decoded.length) {
+                    if (decoded[i] === "=" && i + 2 < decoded.length) {
+                        bytes.push(parseInt(decoded.substring(i + 1, i + 3), 16));
+                        i += 3;
+                    }
+                    else {
+                        bytes.push(decoded.charCodeAt(i));
+                        i++;
+                    }
+                }
+                return new TextDecoder(cs).decode(new Uint8Array(bytes));
+            }
+        }
+        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 = [];
+    // Tokenize the outer list to get each address group as a paren-delimited token
+    // e.g. ((name NIL mailbox host)(name2 NIL mailbox2 host2)) → ["(name NIL mailbox host)", "(name2 ...)"]
+    const groups = tokenizeParenList(token);
+    for (const group of groups) {
+        if (!group.startsWith("("))
+            continue;
+        const parts = tokenizeParenList(group);
+        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/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @bobfrankston/iflow-direct — direct IMAP client, transport-agnostic.
+ *
+ * No Node.js dependencies. Works in browser via import maps.
+ * Callers provide a TransportFactory:
+ *   - Desktop: NodeTransport from @bobfrankston/iflow-node
+ *   - Browser/WebView: BridgeTransport (included here, uses msgapi.tcp)
+ */
+export type { ImapClientConfig, TokenProvider } from "./types.js";
+export type { ImapTransport, TransportFactory } from "./transport.js";
+export { BridgeTransport } from "./bridge-transport.js";
+export * as proto from "./imap-protocol.js";
+export { NativeImapClient } from "./imap-native.js";
+export type { NativeFetchedMessage, NativeFolder, MailboxInfo } from "./imap-native.js";
+export { CompatImapClient } from "./imap-compat.js";
+export type { SpecialFolders } from "./imap-compat.js";
+export { isGmailUser, isGmailServer, createGmailConfig, createAutoImapConfig, type GmailOAuthConfig, } from "./gmail.js";
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,18 @@
+/**
+ * @bobfrankston/iflow-direct — direct IMAP client, transport-agnostic.
+ *
+ * No Node.js dependencies. Works in browser via import maps.
+ * Callers provide a TransportFactory:
+ *   - Desktop: NodeTransport from @bobfrankston/iflow-node
+ *   - Browser/WebView: BridgeTransport (included here, uses msgapi.tcp)
+ */
+export { BridgeTransport } from "./bridge-transport.js";
+// Protocol (pure JS, no I/O)
+export * as proto from "./imap-protocol.js";
+// Native IMAP client (transport-agnostic)
+export { NativeImapClient } from "./imap-native.js";
+// Compatibility wrapper (old ImapClient API shape)
+export { CompatImapClient } from "./imap-compat.js";
+// Gmail OAuth support (Node-free — caller provides tokenProvider)
+export { isGmailUser, isGmailServer, createGmailConfig, createAutoImapConfig, } from "./gmail.js";
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@bobfrankston/iflow-direct",
+  "version": "0.1.1",
+  "description": "Direct IMAP client — transport-agnostic, no Node.js dependencies, browser-ready",
+  "main": "index.js",
+  "types": "index.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -watch",
+    "check": "tsc --noEmit"
+  },
+  "keywords": [
+    "imap",
+    "email",
+    "browser",
+    "transport-agnostic"
+  ],
+  "author": "Bob Frankston",
+  "license": "ISC",
+  "exports": {
+    ".": {
+      "types": "./index.ts",
+      "default": "./index.js"
+    },
+    "./bridge-transport": {
+      "types": "./bridge-transport.ts",
+      "default": "./bridge-transport.js"
+    },
+    "./types": {
+      "types": "./types.ts",
+      "default": "./types.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BobFrankston/iflow-direct.git"
+  }
+}

package/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/transport.js

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

package/types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared types for iflow-common — no imapflow dependency.
+ */
+export type TokenProvider = () => Promise<string>;
+export interface ImapClientConfig {
+    server: string;
+    port: number;
+    username: string;
+    password?: string;
+    tokenProvider?: TokenProvider;
+    verbose?: boolean;
+    rejectUnauthorized?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/types.js

@@ -0,0 +1,5 @@
+/**
+ * Shared types for iflow-common — no imapflow dependency.
+ */
+export {};
+//# sourceMappingURL=types.js.map