@bobfrankston/mailx 1.0.256 → 1.0.264

package/packages/mailx-store-web/gmail-api-web.js

@@ -1,302 +1,11 @@
 /**
- * Web-compatible Gmail API provider.
- * Identical to packages/mailx-imap/providers/gmail-api.ts but uses
- * atob() instead of Buffer.from() for base64 decoding (no Node.js deps).
+ * Back-compat re-export. The Gmail provider is now a single implementation
+ * in @bobfrankston/mailx-sync, used by both desktop (mailx-imap) and
+ * Android (this package). Bug fixes (e.g. 403-quota retry, bounded
+ * concurrency) land in one place and apply to both platforms.
  *
- * This file is a standalone copy — not imported from mailx-imap — because
- * mailx-imap depends on Node.js modules (node:events, node:fs, mailparser, etc.)
- * that aren't available in a WebView.
+ * `GmailApiWebProvider` is kept as an alias for back-compat with existing
+ * Android wiring; it's the same class as `GmailApiProvider`.
  */
-const API = "https://gmail.googleapis.com/gmail/v1/users/me";
-/** Convert Gmail hex ID to integer UID (lower 48 bits) */
-function idToUid(id) {
-    const hex = id.length > 12 ? id.slice(-12) : id;
-    return parseInt(hex, 16);
-}
-/** Map Gmail label to IMAP-style specialUse */
-function labelSpecialUse(label) {
-    switch (label.id) {
-        case "INBOX": return "inbox";
-        case "SENT": return "sent";
-        case "DRAFT": return "drafts";
-        case "TRASH": return "trash";
-        case "SPAM": return "junk";
-        default: return "";
-    }
-}
-function getHeader(headers, name) {
-    return headers.find(h => h.name.toLowerCase() === name.toLowerCase())?.value || "";
-}
-function parseAddress(raw) {
-    const match = raw.match(/^"?([^"<]*?)"?\s*<([^>]+)>/);
-    if (match)
-        return { name: match[1].trim(), address: match[2].trim() };
-    return { address: raw.trim() };
-}
-function parseAddressList(raw) {
-    if (!raw)
-        return [];
-    return raw.split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/).map(s => parseAddress(s.trim())).filter(a => a.address);
-}
-export class GmailApiWebProvider {
-    tokenProvider;
-    constructor(tokenProvider) {
-        this.tokenProvider = tokenProvider;
-    }
-    async apiFetch(path, options = {}) {
-        const token = await this.tokenProvider();
-        for (let attempt = 0; attempt < 3; attempt++) {
-            const res = await globalThis.fetch(`${API}${path}`, {
-                ...options,
-                headers: {
-                    "Authorization": `Bearer ${token}`,
-                    "Content-Type": "application/json",
-                    ...options.headers,
-                },
-            });
-            if (res.status === 429) {
-                const delay = (attempt + 1) * 2000;
-                console.log(`[gmail] Rate limited, waiting ${delay / 1000}s...`);
-                await new Promise(r => setTimeout(r, delay));
-                continue;
-            }
-            if (!res.ok) {
-                const err = await res.text().catch(() => "");
-                throw new Error(`Gmail API ${res.status}: ${err.substring(0, 200)}`);
-            }
-            return res.json();
-        }
-        throw new Error("Gmail API: rate limited after 3 retries");
-    }
-    async listFolders() {
-        const data = await this.apiFetch("/labels");
-        const labels = data.labels || [];
-        const folders = [];
-        for (const label of labels) {
-            if (["UNREAD", "STARRED", "IMPORTANT", "CATEGORY_PERSONAL",
-                "CATEGORY_SOCIAL", "CATEGORY_PROMOTIONS", "CATEGORY_UPDATES",
-                "CATEGORY_FORUMS", "CHAT"].includes(label.id))
-                continue;
-            const specialUse = labelSpecialUse(label);
-            const path = label.name || label.id;
-            const name = path.includes("/") ? path.split("/").pop() : path;
-            // System labels like INBOX, SENT, TRASH are selectable — don't mark \Noselect
-            // Only container labels (categories) should be noselect
-            const noSelect = label.type === "system" && !specialUse && !label.messagesTotal;
-            folders.push({
-                path, name, delimiter: "/", specialUse,
-                flags: noSelect ? ["\\Noselect"] : [],
-            });
-        }
-        return folders;
-    }
-    async listMessageIds(query, maxResults = 500) {
-        const ids = [];
-        let pageToken = "";
-        while (true) {
-            const params = new URLSearchParams({ q: query, maxResults: String(Math.min(maxResults - ids.length, 500)) });
-            if (pageToken)
-                params.set("pageToken", pageToken);
-            const data = await this.apiFetch(`/messages?${params}`);
-            for (const msg of data.messages || []) {
-                ids.push(msg.id);
-            }
-            if (!data.nextPageToken || ids.length >= maxResults)
-                break;
-            pageToken = data.nextPageToken;
-        }
-        return ids;
-    }
-    async batchFetch(ids, options = {}, onChunk) {
-        const all = [];
-        const chunkSize = options.source ? 10 : 50;
-        const format = options.source ? "raw" : "metadata";
-        for (let i = 0; i < ids.length; i += chunkSize) {
-            const chunk = ids.slice(i, i + chunkSize);
-            const messages = [];
-            for (const id of chunk) {
-                const params = new URLSearchParams({ format });
-                if (format === "metadata") {
-                    for (const h of ["From", "To", "Cc", "Subject", "Message-ID", "Date"]) {
-                        params.append("metadataHeaders", h);
-                    }
-                }
-                messages.push(await this.apiFetch(`/messages/${id}?${params}`));
-            }
-            const parsed = messages.map(msg => this.parseMessage(msg, options));
-            all.push(...parsed);
-            if (onChunk)
-                onChunk(parsed);
-        }
-        return all;
-    }
-    parseMessage(msg, options = {}) {
-        const labels = msg.labelIds || [];
-        const headers = msg.payload?.headers || [];
-        let source = "";
-        if (options.source && msg.raw) {
-            // URL-safe base64 → standard base64 → UTF-8 string
-            // atob() returns a binary string (1 byte per char). Must decode bytes as UTF-8
-            // to handle multi-byte characters correctly (e.g. smart quotes).
-            const base64 = msg.raw.replace(/-/g, "+").replace(/_/g, "/");
-            const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
-            const binary = atob(padded);
-            const bytes = Uint8Array.from(binary, c => c.charCodeAt(0));
-            source = new TextDecoder("utf-8").decode(bytes);
-        }
-        const fromRaw = getHeader(headers, "From");
-        const toRaw = getHeader(headers, "To");
-        const ccRaw = getHeader(headers, "Cc");
-        const dateRaw = getHeader(headers, "Date") || "";
-        const subject = getHeader(headers, "Subject") || msg.snippet || "";
-        const messageId = getHeader(headers, "Message-ID") || "";
-        return {
-            uid: idToUid(msg.id),
-            messageId,
-            providerId: msg.id,
-            date: dateRaw ? new Date(dateRaw) : (msg.internalDate ? new Date(Number(msg.internalDate)) : null),
-            subject,
-            from: parseAddressList(fromRaw),
-            to: parseAddressList(toRaw),
-            cc: parseAddressList(ccRaw),
-            seen: !labels.includes("UNREAD"),
-            flagged: labels.includes("STARRED"),
-            answered: false,
-            draft: labels.includes("DRAFT"),
-            size: msg.sizeEstimate || 0,
-            source,
-        };
-    }
-    async fetchSince(folder, sinceUid, options = {}) {
-        const query = `in:${this.folderToLabel(folder)}`;
-        const ids = await this.listMessageIds(query, 200);
-        const messages = await this.batchFetch(ids, options);
-        return messages.filter(m => m.uid > sinceUid);
-    }
-    async fetchByDate(folder, since, before, options = {}, onChunk) {
-        const afterDate = this.formatDate(since);
-        const beforeDate = this.formatDate(before);
-        const query = `in:${this.folderToLabel(folder)} after:${afterDate} before:${beforeDate}`;
-        const ids = await this.listMessageIds(query);
-        return this.batchFetch(ids, options, onChunk);
-    }
-    async fetchByUids(folder, uids, options = {}) {
-        const query = `in:${this.folderToLabel(folder)}`;
-        const ids = await this.listMessageIds(query);
-        const uidSet = new Set(uids);
-        const matchingIds = ids.filter(id => uidSet.has(idToUid(id)));
-        return this.batchFetch(matchingIds, options);
-    }
-    /** Fetch a message directly by Gmail provider ID — fast path, no listing needed */
-    async fetchById(providerId, options = {}) {
-        const format = options.source ? "raw" : "metadata";
-        const params = new URLSearchParams({ format });
-        if (format === "metadata") {
-            for (const h of ["From", "To", "Cc", "Subject", "Message-ID", "Date"]) {
-                params.append("metadataHeaders", h);
-            }
-        }
-        try {
-            const msg = await this.apiFetch(`/messages/${providerId}?${params}`);
-            return this.parseMessage(msg, options);
-        }
-        catch (e) {
-            console.warn(`[gmail] fetchById ${providerId} failed: ${e.message}`);
-            return null;
-        }
-    }
-    async fetchOne(folder, uid, options = {}) {
-        const query = `in:${this.folderToLabel(folder)}`;
-        const ids = await this.listMessageIds(query, 1000);
-        const id = ids.find(id => idToUid(id) === uid);
-        if (!id)
-            return null;
-        const format = options.source ? "raw" : "metadata";
-        const params = new URLSearchParams({ format });
-        if (format === "metadata") {
-            for (const h of ["From", "To", "Cc", "Subject", "Message-ID", "Date"]) {
-                params.append("metadataHeaders", h);
-            }
-        }
-        const msg = await this.apiFetch(`/messages/${id}?${params}`);
-        return this.parseMessage(msg, options);
-    }
-    async getUids(folder) {
-        const query = `in:${this.folderToLabel(folder)}`;
-        const ids = await this.listMessageIds(query, 10000);
-        return ids.map(idToUid);
-    }
-    async close() { }
-    /** Bulk-fetch raw bodies for many UIDs in one Gmail label. Lists the label
-     *  once, builds UID→ID map, streams bodies via `onBody` with bounded
-     *  concurrency. Mirrors GmailApiProvider.fetchBodiesBatch on desktop. */
-    async fetchBodiesBatch(folder, uids, onBody) {
-        if (uids.length === 0)
-            return;
-        const query = `in:${this.folderToLabel(folder)}`;
-        const ids = await this.listMessageIds(query, 10000);
-        const uidToId = new Map();
-        for (const id of ids)
-            uidToId.set(idToUid(id), id);
-        const wanted = [];
-        for (const uid of uids) {
-            const id = uidToId.get(uid);
-            if (id)
-                wanted.push({ uid, id });
-        }
-        if (wanted.length === 0)
-            return;
-        const CONCURRENCY = 10;
-        let cursor = 0;
-        const worker = async () => {
-            while (cursor < wanted.length) {
-                const idx = cursor++;
-                const { uid, id } = wanted[idx];
-                try {
-                    const msg = await this.apiFetch(`/messages/${id}?format=raw`);
-                    if (!msg?.raw)
-                        continue;
-                    const base64 = msg.raw.replace(/-/g, "+").replace(/_/g, "/");
-                    const source = new TextDecoder().decode(Uint8Array.from(atob(base64), c => c.charCodeAt(0)));
-                    onBody(uid, source);
-                }
-                catch (e) {
-                    console.error(`[gmail batch] UID ${uid}: ${e.message}`);
-                }
-            }
-        };
-        await Promise.all(Array.from({ length: Math.min(CONCURRENCY, wanted.length) }, () => worker()));
-    }
-    /** Send an RFC 2822 message via Gmail API users.messages.send. The server
-     *  handles SMTP — we just hand it the raw bytes base64url-encoded. Auto-files
-     *  a copy into the Sent label, so caller does NOT need to APPEND to Sent. */
-    async sendRaw(rawRfc822) {
-        const b64 = btoa(unescape(encodeURIComponent(rawRfc822)))
-            .replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-        const data = await this.apiFetch("/messages/send", {
-            method: "POST",
-            body: JSON.stringify({ raw: b64 }),
-        });
-        return { id: data.id, threadId: data.threadId };
-    }
-    folderToLabel(path) {
-        const lower = path.toLowerCase();
-        if (lower === "inbox")
-            return "inbox";
-        if (lower === "sent" || lower === "[gmail]/sent mail")
-            return "sent";
-        if (lower === "drafts" || lower === "[gmail]/drafts")
-            return "drafts";
-        if (lower === "trash" || lower === "[gmail]/trash")
-            return "trash";
-        if (lower === "spam" || lower === "[gmail]/spam" || lower === "junk email")
-            return "spam";
-        if (lower === "archive" || lower === "[gmail]/all mail")
-            return "all";
-        return `"${path}"`;
-    }
-    formatDate(d) {
-        return `${d.getFullYear()}/${String(d.getMonth() + 1).padStart(2, "0")}/${String(d.getDate()).padStart(2, "0")}`;
-    }
-}
+export { GmailApiProvider as GmailApiWebProvider } from "@bobfrankston/mailx-sync";
 //# sourceMappingURL=gmail-api-web.js.map

package/packages/mailx-store-web/imap-web-provider.d.ts

@@ -17,7 +17,7 @@ export declare class ImapWebProvider implements MailProvider {
     private transportFactory;
     private specialFolders;
     private folderListCache;
-    constructor(config: ImapClientConfig);
+    constructor(config: ImapClientConfig, transportFactory?: () => any);
     /** Create a fresh client (after broken pipe / connection error) */
     private reconnect;
     /** Run an operation with one retry on connection error */

package/packages/mailx-store-web/imap-web-provider.js

@@ -71,9 +71,9 @@ export class ImapWebProvider {
     transportFactory;
     specialFolders = {};
     folderListCache = null;
-    constructor(config) {
+    constructor(config, transportFactory) {
         this.config = config;
-        this.transportFactory = () => new BridgeTransport();
+        this.transportFactory = transportFactory || (() => new BridgeTransport());
         this.client = new CompatImapClient(config, this.transportFactory);
     }
     /** Create a fresh client (after broken pipe / connection error) */

package/packages/mailx-store-web/main-thread-host.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Main thread Worker host — thin shim that keeps UI responsive.
+ *
+ * Responsibilities:
+ *   1. Create Worker and proxy mailxapi calls to it
+ *   2. Proxy TCP calls from Worker to msgapi.tcp (C# native bridge)
+ *   3. Proxy native bridge calls (OAuth, device info)
+ *   4. Forward events from Worker to UI event handlers
+ *   5. Set up visibilitychange/periodic sync triggers
+ *
+ * The UI code (api-client.ts) calls window.mailxapi.* exactly as before —
+ * this host just routes those calls to the Worker instead of running them inline.
+ */
+export declare function createWorkerHost(): Promise<void>;
+//# sourceMappingURL=main-thread-host.d.ts.map

package/packages/mailx-store-web/main-thread-host.js

@@ -0,0 +1,288 @@
+/**
+ * Main thread Worker host — thin shim that keeps UI responsive.
+ *
+ * Responsibilities:
+ *   1. Create Worker and proxy mailxapi calls to it
+ *   2. Proxy TCP calls from Worker to msgapi.tcp (C# native bridge)
+ *   3. Proxy native bridge calls (OAuth, device info)
+ *   4. Forward events from Worker to UI event handlers
+ *   5. Set up visibilitychange/periodic sync triggers
+ *
+ * The UI code (api-client.ts) calls window.mailxapi.* exactly as before —
+ * this host just routes those calls to the Worker instead of running them inline.
+ */
+const eventHandlers = [];
+let worker;
+let rpcCounter = 0;
+const pendingRpc = new Map();
+// ── Worker communication ──
+function sendRpc(action, params = {}) {
+    const id = ++rpcCounter;
+    return new Promise((resolve, reject) => {
+        pendingRpc.set(id, { resolve, reject });
+        worker.postMessage({ type: "rpc", id, action, params });
+        // 5-minute timeout for long operations like syncAll
+        setTimeout(() => {
+            if (pendingRpc.has(id)) {
+                pendingRpc.delete(id);
+                reject(new Error(`RPC ${action} timeout`));
+            }
+        }, 300000);
+    });
+}
+// ── TCP proxy: relay Worker TCP requests to msgapi.tcp ──
+function handleTcpRequest(msg) {
+    const msgapi = window.msgapi;
+    if (!msgapi?.tcp) {
+        worker.postMessage({ type: "tcp-response", reqId: msg.reqId, error: "TCP bridge not available" });
+        return;
+    }
+    switch (msg.op) {
+        case "connect": {
+            msgapi.tcp.connect(msg.host, msg.port, msg.tls)
+                .then((streamId) => {
+                const sid = Number(streamId);
+                // Register event forwarding for this stream
+                msgapi.tcp.onData(sid, (data) => {
+                    worker.postMessage({ type: "tcp-data", streamId: sid, data });
+                });
+                msgapi.tcp.onClose(sid, (hadError) => {
+                    worker.postMessage({ type: "tcp-close", streamId: sid, hadError });
+                });
+                msgapi.tcp.onError(sid, (message) => {
+                    worker.postMessage({ type: "tcp-error", streamId: sid, message });
+                });
+                worker.postMessage({ type: "tcp-response", reqId: msg.reqId, result: String(sid) });
+            })
+                .catch((e) => {
+                worker.postMessage({ type: "tcp-response", reqId: msg.reqId, error: e.message });
+            });
+            break;
+        }
+        case "write": {
+            const data = msg.data;
+            // btoa for the bridge (C# expects base64)
+            msgapi.tcp.write(msg.streamId, data)
+                .then(() => {
+                worker.postMessage({ type: "tcp-response", reqId: msg.reqId, result: "ok" });
+            })
+                .catch((e) => {
+                worker.postMessage({ type: "tcp-response", reqId: msg.reqId, error: e.message });
+            });
+            break;
+        }
+        case "upgradeTLS": {
+            msgapi.tcp.upgradeTLS(msg.streamId, msg.servername)
+                .then(() => {
+                worker.postMessage({ type: "tcp-response", reqId: msg.reqId, result: "ok" });
+            })
+                .catch((e) => {
+                worker.postMessage({ type: "tcp-response", reqId: msg.reqId, error: e.message });
+            });
+            break;
+        }
+        case "close": {
+            try {
+                msgapi.tcp.close(msg.streamId);
+            }
+            catch { /* ignore */ }
+            break;
+        }
+    }
+}
+// ── Native bridge proxy: relay Worker native requests ──
+function handleNativeRequest(msg) {
+    const bridge = window._nativeBridge;
+    switch (msg.op) {
+        case "refreshToken": {
+            const email = msg.args?.[0];
+            if (bridge?.app?.startOAuth) {
+                // Use the existing OAuth flow
+                // For now, use the cached token or refresh
+                bridge.app.refreshToken?.(email)
+                    .then((token) => {
+                    worker.postMessage({ type: "native-response", reqId: msg.reqId, result: token });
+                })
+                    .catch((e) => {
+                    worker.postMessage({ type: "native-response", reqId: msg.reqId, error: e.message });
+                });
+            }
+            else {
+                worker.postMessage({ type: "native-response", reqId: msg.reqId, error: "No OAuth bridge" });
+            }
+            break;
+        }
+        case "vlog": {
+            // Verbose logging via logit
+            const text = msg.args?.[0] || "";
+            fetch(`https://rmf39.aaz.lt/logit/${encodeURIComponent("V/" + text)}?log=mailx-android`).catch(() => { });
+            break;
+        }
+        case "getAndroidId": {
+            bridge?.app?.getAndroidId?.()
+                .then((id) => {
+                worker.postMessage({ type: "native-response", reqId: msg.reqId, result: id });
+            })
+                .catch((e) => {
+                worker.postMessage({ type: "native-response", reqId: msg.reqId, error: e.message });
+            });
+            break;
+        }
+        case "getDeviceAccounts": {
+            bridge?.app?.getDeviceAccounts?.()
+                .then((accounts) => {
+                worker.postMessage({ type: "native-response", reqId: msg.reqId, result: accounts });
+            })
+                .catch((e) => {
+                worker.postMessage({ type: "native-response", reqId: msg.reqId, error: e.message });
+            });
+            break;
+        }
+        case "localStorageGet": {
+            const key = msg.args?.[0];
+            worker.postMessage({ type: "native-response", reqId: msg.reqId, result: localStorage.getItem(key) });
+            break;
+        }
+        case "localStorageSet": {
+            const [key, value] = msg.args || [];
+            localStorage.setItem(key, value);
+            worker.postMessage({ type: "native-response", reqId: msg.reqId, result: "ok" });
+            break;
+        }
+        default: {
+            worker.postMessage({ type: "native-response", reqId: msg.reqId, error: `Unknown native op: ${msg.op}` });
+        }
+    }
+}
+// ── Event handling ──
+function handleWorkerEvent(event) {
+    for (const handler of eventHandlers) {
+        try {
+            handler(event);
+        }
+        catch { /* ignore */ }
+    }
+    // Also dispatch to the global mailxapi event callback
+    const cb = window._mailxapiEvent;
+    if (cb)
+        try {
+            cb(event);
+        }
+        catch { /* ignore */ }
+}
+// ── Worker message router ──
+function onWorkerMessage(e) {
+    const msg = e.data;
+    if (msg.type === "rpc-response") {
+        const pending = pendingRpc.get(msg.id);
+        if (pending) {
+            pendingRpc.delete(msg.id);
+            if (msg.error)
+                pending.reject(new Error(msg.error));
+            else
+                pending.resolve(msg.result);
+        }
+        return;
+    }
+    if (msg.type === "event") {
+        handleWorkerEvent(msg.event);
+        return;
+    }
+    if (msg.type === "tcp") {
+        handleTcpRequest(msg);
+        return;
+    }
+    if (msg.type === "native") {
+        handleNativeRequest(msg);
+        return;
+    }
+    if (msg.type === "init-complete") {
+        console.log("[host] Worker initialization complete");
+        return;
+    }
+    if (msg.type === "init-error") {
+        console.error(`[host] Worker init failed: ${msg.error}`);
+        return;
+    }
+}
+// ── Install mailxapi bridge (same interface as before, routes to Worker) ──
+function installBridge() {
+    window.mailxapi = {
+        isApp: true,
+        platform: "android",
+        // All service methods proxy to the Worker
+        getAccounts: () => sendRpc("getAccounts"),
+        getFolders: (accountId) => sendRpc("getFolders", { accountId }),
+        getMessages: (accountId, folderId, page, pageSize) => sendRpc("getMessages", { accountId, folderId, page, pageSize }),
+        getUnifiedInbox: (page, pageSize) => sendRpc("getUnifiedInbox", { page, pageSize }),
+        getMessage: (accountId, uid, allowRemote, folderId) => sendRpc("getMessage", { accountId, uid, allowRemote, folderId }),
+        getAttachment: (accountId, uid, index, folderId) => sendRpc("getAttachment", { accountId, uid, index, folderId }),
+        updateFlags: (accountId, uid, flags) => sendRpc("updateFlags", { accountId, uid, flags }),
+        deleteMessage: (accountId, uid) => sendRpc("deleteMessage", { accountId, uid }),
+        deleteMessages: (accountId, uids) => sendRpc("deleteMessages", { accountId, uids }),
+        undeleteMessage: (accountId, uid, folderId) => sendRpc("undeleteMessage", { accountId, uid, folderId }),
+        moveMessage: (accountId, uid, targetFolderId, targetAccountId) => sendRpc("moveMessage", { accountId, uid, targetFolderId, targetAccountId }),
+        moveMessages: (accountId, uids, targetFolderId) => sendRpc("moveMessages", { accountId, uids, targetFolderId }),
+        markFolderRead: (folderId) => sendRpc("markFolderRead", { folderId }),
+        sendMessage: async (msg) => { await sendRpc("sendMessage", msg); return { ok: true }; },
+        saveDraft: (p) => sendRpc("saveDraft", p),
+        deleteDraft: (accountId, draftUid) => sendRpc("deleteDraft", { accountId, draftUid }),
+        syncAll: () => sendRpc("syncAll"),
+        syncAccount: (accountId) => sendRpc("syncAccount", { accountId }),
+        triggerSync: () => sendRpc("syncAll"),
+        getSyncPending: () => sendRpc("getSyncPending"),
+        reauthenticate: (accountId) => sendRpc("reauthenticate", { accountId }),
+        searchMessages: (query, page, pageSize) => sendRpc("searchMessages", { query, page, pageSize }),
+        searchContacts: (query) => sendRpc("searchContacts", { query }),
+        getSettings: () => sendRpc("getSettings"),
+        saveSettings: (data) => sendRpc("saveSettingsData", data),
+        allowRemoteContent: (type, value) => sendRpc("allowRemoteContent", { type, value }),
+        getVersion: () => sendRpc("getVersion"),
+        getAutocompleteSettings: () => sendRpc("getAutocompleteSettings"),
+        saveAutocompleteSettings: (data) => sendRpc("saveAutocompleteSettings", data),
+        emptyFolder: (accountId, folderId) => sendRpc("emptyFolder", { accountId, folderId }),
+        resetAll: () => sendRpc("resetStore"),
+        // Event registration
+        onEvent: (handler) => { eventHandlers.push(handler); },
+    };
+}
+// ── Public entry point ──
+export async function createWorkerHost() {
+    console.log("[host] Creating service worker...");
+    // Wait for native bridge
+    await new Promise((resolve) => {
+        const check = () => {
+            if (window._nativeBridge) {
+                resolve();
+                return;
+            }
+            setTimeout(check, 50);
+        };
+        window.addEventListener("nativebridgeready", () => resolve(), { once: true });
+        check();
+    });
+    // Alias for TCP bridge
+    if (window._nativeBridge && !window.msgapi) {
+        window.msgapi = window._nativeBridge;
+    }
+    // Create Worker
+    // Note: Worker URL must point to the bundled worker entry.
+    // For now, use the same-origin asset path.
+    // Use bundled worker (esbuild inlines all dependencies — no import map needed)
+    worker = new Worker("../packages/mailx-store-web/worker-bundle.js");
+    worker.onmessage = onWorkerMessage;
+    worker.onerror = (e) => console.error("[host] Worker error:", e.message);
+    // Install the mailxapi bridge
+    installBridge();
+    // Tell Worker to initialize
+    worker.postMessage({ type: "init", config: {} });
+    // Sync on resume
+    document.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "visible") {
+            console.log("[sync] resume poll");
+            sendRpc("syncAll").catch(() => { });
+        }
+    });
+    console.log("[host] Worker host ready");
+}
+//# sourceMappingURL=main-thread-host.js.map

package/packages/mailx-store-web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store-web",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -13,6 +13,7 @@
     "@bobfrankston/iflow-direct": "file:../../../MailApps/iflow-direct",
     "@bobfrankston/tcp-transport": "file:../../../MailApps/tcp-transport",
     "@bobfrankston/smtp-direct": "file:../../../MailApps/smtp-direct",
+    "@bobfrankston/mailx-sync": "file:../../../MailApps/mailx-sync",
     "sql.js": "^1.14.1"
   },
   "repository": {