@bobfrankston/mailx 1.0.411 → 1.0.415

package/bin/mailx.js

@@ -1027,20 +1027,25 @@ RFC 5322 with CRLF line endings. Bodies are quoted-printable encoded (readable i
     }
     catch { /* no saved geometry — use defaults */ }
     const rootPkgVersion = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, "..", "package.json"), "utf-8")).version;
-    // Prefer .ico over .png for the window icon: on Windows, the .ico
-    // path doubles as the PKEY_AppUserModel_RelaunchIconResource value
-    // so taskbar pins use mailx's icon instead of msgernative's embedded
-    // resource. msger auto-detects the .ico extension and wires the
-    // relaunch icon after window creation.
+    // Pass the .png as the window-decode icon: msger uses the `image` crate
+    // to decode `options.icon` for the Tao window icon, and PNG-in-ICO files
+    // round-trip unreliably through the image-0.24 ICO decoder, which leaves
+    // the taskbar entry showing the empty msgernative.exe default. PNG always
+    // decodes cleanly. The .ico path is forwarded separately as
+    // `relaunchIcon`, which msger uses for `PKEY_AppUserModel_RelaunchIconResource`
+    // (the path is consumed verbatim — no decode — so PNG-in-ICO is fine
+    // there). Falls back if either file is missing.
     const __iconIco = path.join(clientDir, "icon.ico");
     const __iconPng = path.join(clientDir, "icon.png");
-    const __iconPath = fs.existsSync(__iconIco) ? __iconIco : __iconPng;
+    const __iconPathRuntime = fs.existsSync(__iconPng) ? __iconPng : __iconIco;
+    const __iconPathPin = fs.existsSync(__iconIco) ? __iconIco : undefined;
     const handle = showService({
         title: `mailx v${rootPkgVersion}`,
         url: "index.html",
         contentDir: clientDir,
         initScript: mailxapiScript,
-        icon: __iconPath,
+        icon: __iconPathRuntime,
+        relaunchIcon: __iconPathPin,
         aumid: "com.frankston.mailx",
         size: savedGeometry
             ? { width: savedGeometry.width, height: savedGeometry.height }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.411",
+  "version": "1.0.415",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",

package/packages/mailx-imap/index.d.ts

@@ -177,6 +177,12 @@ export declare class ImapManager extends EventEmitter {
     private reconnectOps;
     /** Handle sync errors — classify and emit appropriate UI events */
     private handleSyncError;
+    /** Fetch ONLY new messages above highestUid for one account's INBOX —
+     *  the IDLE callback's hot path. Skips gap detection, backfill, and the
+     *  server reconcile (each of which fetches a full UID list — multi-second
+     *  on a large mailbox). The 5-minute STATUS poll path still runs full
+     *  `syncFolder` so deletions and gaps eventually reconcile. */
+    syncInboxNewOnly(accountId: string): Promise<void>;
     /** Sync just INBOX for each account (fast check for new mail) */
     syncInbox(): Promise<void>;
     /** Quick inbox check — per-account lightweight probe.

package/packages/mailx-imap/index.js

@@ -1540,6 +1540,46 @@ export class ImapManager extends EventEmitter {
             this.emit("accountError", accountId, errMsg, errMsg, isOAuth);
         }
     }
+    /** Fetch ONLY new messages above highestUid for one account's INBOX —
+     *  the IDLE callback's hot path. Skips gap detection, backfill, and the
+     *  server reconcile (each of which fetches a full UID list — multi-second
+     *  on a large mailbox). The 5-minute STATUS poll path still runs full
+     *  `syncFolder` so deletions and gaps eventually reconcile. */
+    async syncInboxNewOnly(accountId) {
+        if (this.isGmailAccount(accountId))
+            return; // IDLE is IMAP-only
+        const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
+        if (!inbox)
+            return;
+        try {
+            await this.withConnection(accountId, async (client) => {
+                const highestUid = this.db.getHighestUid(accountId, inbox.id);
+                if (highestUid === 0) {
+                    // First sync — fall through to full path so the date-windowed
+                    // backfill runs. `syncFolder` handles the no-highestUid case.
+                    await this.syncFolder(accountId, inbox.id, client);
+                    return;
+                }
+                const fetched = await client.fetchMessagesSinceUid(inbox.path, highestUid, { source: false });
+                const fresh = fetched.filter((m) => m.uid > highestUid);
+                if (fresh.length === 0)
+                    return;
+                const stored = await this.storeMessages(accountId, inbox.id, inbox, fresh, highestUid);
+                if (stored > 0) {
+                    this.db.recalcFolderCounts(inbox.id);
+                    const updated = this.db.getFolders(accountId).find(f => f.id === inbox.id);
+                    this.emit("folderCountsChanged", accountId, {
+                        [inbox.id]: { total: updated?.totalCount || 0, unread: updated?.unreadCount || 0 }
+                    });
+                    this.emit("folderSynced", accountId, inbox.id, Date.now());
+                    console.log(`  [idle-fast] ${accountId}: stored ${stored} new message(s)`);
+                }
+            });
+        }
+        catch (e) {
+            console.error(`  [idle-fast] ${accountId}: ${e.message}`);
+        }
+    }
     /** Sync just INBOX for each account (fast check for new mail) */
     async syncInbox() {
         if (this.inboxSyncing)
@@ -1783,8 +1823,10 @@ export class ImapManager extends EventEmitter {
                 const watchClient = this.createClient(accountId);
                 const stop = await watchClient.watchMailbox("INBOX", (newCount) => {
                     console.log(`  [idle] ${accountId}: ${newCount} new message(s)`);
-                    // Sync just INBOX for speed — full sync runs on the configured interval
-                    this.syncInbox().catch(e => console.error(`  [idle] sync error: ${e.message}`));
+                    // Fetch only the new UIDs — the heavyweight gap/reconcile
+                    // path runs on the 5-minute STATUS poll, so EXISTS lands
+                    // in the UI in roughly one round-trip.
+                    this.syncInboxNewOnly(accountId).catch(e => console.error(`  [idle] sync error: ${e.message}`));
                 });
                 this.watchers.set(accountId, async () => {
                     await stop();