@bobfrankston/rmfmail 1.2.219 → 1.2.221

package/bin/mailx.js

@@ -2166,6 +2166,16 @@ RFC 5322 with CRLF line endings. Bodies are quoted-printable encoded (readable i
     // main-window shutdown log line to prove/refute the "closing a popout
     // closes the main window" coupling (Bob 2026-07-06, unreproduced).
     let lastPopoutClose = null;
+    /** Hidden window that keeps the "popout" WebView2 profile's browser
+     *  process warm — see the prewarm block below showService. Deliberately
+     *  NOT in popoutWindows: it is infrastructure, not a user window, and must
+     *  not show up in the shutdown popout census. */
+    let prewarmHandle = null;
+    /** How long after boot to warm the popout profile. Late enough that it
+     *  isn't racing the MAIN window's own WebView creation for the same CPU,
+     *  early enough to beat a user reaching for ^N (the 2026-08-05 case was at
+     *  boot + 18s). */
+    const PREWARM_DELAY_MS = 6000;
     const popoutKey = (a, f, u) => `${a}|${f ?? ""}|${u}`;
     try {
         const { startPopoutServer } = await import("./popout-server.js");
@@ -2571,6 +2581,54 @@ RFC 5322 with CRLF line endings. Bodies are quoted-printable encoded (readable i
             return { ok: true };
         });
     }
+    // Pre-warm the "popout" WebView2 profile.
+    //
+    // Every secondary window (compose, message popout, extra main window) runs
+    // on profile "popout" — deliberately NOT the main window's profile, so a
+    // crash there can't black out the main window (S67). The cost is that the
+    // FIRST popout of a session pays for cold-starting an entire WebView2
+    // browser process for that profile, and if the daemon is busy with initial
+    // sync at the time, that cold start is not cheap: ^N 18 seconds after boot
+    // on 2026-08-05 sat on a blank window for 59.4 SECONDS, all of it inside
+    // WebViewBuilder::build() before a line of compose JS could run (the page
+    // itself then rendered in 397ms). Nothing the page can do about it — there
+    // is no WebView yet to draw a spinner into.
+    //
+    // So pay it up front, off the user's critical path: one hidden window on
+    // that profile, opened a few seconds after boot (late enough not to
+    // compete with the main window's own WebView creation), held open for the
+    // life of the daemon so the browser process stays warm. Hidden windows
+    // still create their WebView, which is the whole point.
+    if (popoutInfo) {
+        const pi3 = popoutInfo;
+        setTimeout(() => {
+            const t0 = Date.now();
+            try {
+                const h = showMessageBoxEx({
+                    title: "rmfmail (prewarm)",
+                    url: `http://127.0.0.1:${pi3.port}/app/${pi3.token}/client/prewarm.html`,
+                    size: { width: 200, height: 100 },
+                    hidden: true,
+                    focusOnCreate: false,
+                    aumid: "com.frankston.rmfmail",
+                    profile: "popout",
+                });
+                prewarmHandle = h;
+                if (typeof h.pid === "number")
+                    addChildPid(h.pid);
+                console.log(`  [prewarm] popout WebView2 profile warming (pid=${h.pid ?? "?"})`);
+                void h.result.catch(() => { }).finally(() => {
+                    if (typeof h.pid === "number")
+                        removeChildPid(h.pid);
+                    console.log(`  [prewarm] popout profile window closed after ${Date.now() - t0}ms`);
+                });
+            }
+            catch (e) {
+                // Never fatal — a cold first popout is slow, not broken.
+                console.log(`  [prewarm] skipped: ${e?.message || e}`);
+            }
+        }, PREWARM_DELAY_MS);
+    }
     _tick("calling showService (WebView opens here)");
     const handle = showService({
         title: `rmfmail v${rootPkgVersion}`,
@@ -2656,6 +2714,12 @@ RFC 5322 with CRLF line endings. Bodies are quoted-printable encoded (readable i
             handle.close();
         }
         catch { /* already gone */ }
+        // Hidden and therefore invisible to the user if orphaned — close it on
+        // every exit path, not just gracefulShutdown.
+        try {
+            prewarmHandle?.close?.();
+        }
+        catch { /* already gone */ }
     };
     process.once("exit", __cleanupInstance);
     process.once("SIGINT", () => { __cleanupInstance(); process.exit(0); });
@@ -2841,10 +2905,22 @@ RFC 5322 with CRLF line endings. Bodies are quoted-printable encoded (readable i
     // and emits this when Word writes; compose.ts listens and reloads Quill.
     imapManager.on("wordEditUpdated", (payload) => {
         handle.send({ _event: "wordEditUpdated", type: "wordEditUpdated", ...payload });
-        // Bring compose back to the front after a Word save — the service's
-        // old mailx-host focusMainWindow call was a silent no-op (the helper
-        // never existed); this native msger command is the real mechanism.
-        handle.send({ _msgerWindow: "focus" });
+        // Deliberately NO { _msgerWindow: "focus" } here. The autosave sidecar
+        // saves every ~2s while the user types, and each save lands in this
+        // handler — so this line pulled the foreground off Word mid-sentence,
+        // every couple of seconds, for the whole editing session (Bob
+        // 2026-08-06: "keeps flipping back to rmfmail on any change"). The
+        // focus now happens once, on wordEditClosed, below.
+    });
+    // Word (or the document) closed — the external edit is over. THIS is the
+    // moment to bring rmfmail forward, replacing the old per-save focus grab.
+    imapManager.on("wordEditClosed", (payload) => {
+        handle.send({ _event: "wordEditClosed", type: "wordEditClosed", ...payload });
+        // Only raise the MAIN window when the compose lives IN it. A popout
+        // compose is a separate window with no service channel, so focusing
+        // main would just cover it up.
+        if (!payload.fromPopout)
+            handle.send({ _msgerWindow: "focus" });
     });
     // Cloud-write/read failures from mailx-settings → push to UI as a banner so
     // silent fall-back-to-local can no longer swallow Drive errors.
@@ -3289,6 +3365,13 @@ RFC 5322 with CRLF line endings. Bodies are quoted-printable encoded (readable i
             return;
         shuttingDown = true;
         console.log(`${reason} — shutting down`);
+        // The prewarm window is hidden, so an orphaned one is invisible AND
+        // unkillable by the user — close it explicitly rather than relying on
+        // child-process cascade.
+        try {
+            prewarmHandle?.close?.();
+        }
+        catch { /* already gone */ }
         imapManager.stopPeriodicSync();
         imapManager.stopOutboxWorker();
         // 3s hard timeout — don't hang on broken IMAP connections
@@ -3345,7 +3428,12 @@ RFC 5322 with CRLF line endings. Bodies are quoted-printable encoded (readable i
     const popoutDelta = lastPopoutClose
         ? `; last popout closed ${Date.now() - lastPopoutClose.at}ms ago (${lastPopoutClose.key})`
         : "; no popout closed this session";
-    await gracefulShutdown(`Window closed (main service child; ${popoutWindows.size} popout window(s) still tracked${popoutDelta})`);
+    // Name the still-tracked popouts, not just the count. "2 popout window(s)
+    // still tracked" (2026-08-05) was unactionable: two legitimately-open
+    // compose windows and two entries whose close handler never fired look
+    // identical from a bare count.
+    const popoutKeys = popoutWindows.size > 0 ? ` [${[...popoutWindows.keys()].join(", ")}]` : "";
+    await gracefulShutdown(`Window closed (main service child; ${popoutWindows.size} popout window(s) still tracked${popoutKeys}${popoutDelta})`);
 }
 main().catch(console.error);
 //# sourceMappingURL=mailx.js.map