gloomberb 0.19.0 → 0.19.2

package/src/renderers/electrobun/bun/desktop/relaunch.ts

@@ -1,4 +1,7 @@
-import { dirname } from "path";
+import { rm } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname, win32 } from "path";
+import { psString, runScriptAfterExit, writePowerShellScript } from "./windows-script";
 
 /**
  * The folders the relaunch script finds `sleep` in, after whatever PATH the
@@ -29,6 +32,8 @@ export interface RelaunchContext {
   cwd: string;
   /** PATH as the app sees it. */
   pathEnv: string;
+  /** Where the app keeps its data when GLOOMBERB_HOME moves it. */
+  home?: string;
 }
 
 interface RelaunchCommand {
@@ -47,15 +52,16 @@ function currentProcess(): RelaunchContext {
     args: process.argv.slice(1),
     cwd: process.cwd(),
     pathEnv: process.env.PATH ?? "",
+    home: process.env.GLOOMBERB_HOME || undefined,
   };
 }
 
 /**
- * What opens the app again once `context.pid` has exited. The script runs in
- * `/` with the shell and `open` named by their full paths: the launcher starts
- * the app inside its bundle's `Contents/MacOS`, which a rename to the app's
- * new name takes away, and a spawn into a folder that is gone fails as if the
- * shell were missing (`ENOENT, posix_spawn 'sh'`).
+ * What opens the app again once `context.pid` has exited, on a Mac or Linux.
+ * The script runs in `/` with the shell and `open` named by their full paths:
+ * the launcher starts the app inside its bundle's `Contents/MacOS`, which a
+ * rename to the app's new name takes away, and a spawn into a folder that is
+ * gone fails as if the shell were missing (`ENOENT, posix_spawn 'sh'`).
  */
 export function desktopRelaunchCommand(context: RelaunchContext, bundle?: string): RelaunchCommand {
   const pathEnv = context.pathEnv ? `${context.pathEnv}:${SYSTEM_PATH}` : SYSTEM_PATH;
@@ -70,8 +76,6 @@ export function desktopRelaunchCommand(context: RelaunchContext, bundle?: string
     };
   }
 
-  if (context.platform === "win32") return { cmd: [context.execPath, ...context.args] };
-
   const args = context.args.map(shellQuote).join(" ");
   return {
     cmd: ["/bin/sh", "-c", `${waitForExit}; cd ${shellQuote(context.cwd)} 2>/dev/null; ${shellQuote(context.execPath)}${args ? ` ${args}` : ""}`],
@@ -80,12 +84,100 @@ export function desktopRelaunchCommand(context: RelaunchContext, bundle?: string
   };
 }
 
+export interface WindowsRelaunch {
+  /** The app's process, which the script waits out. */
+  pid: number;
+  /** `bin\launcher.exe` beside the runtime: what the Start menu opens. */
+  launcher: string;
+  log: string;
+  cancel: string;
+  taskName: string;
+  /** GLOOMBERB_HOME for the app it opens; a task has the user's environment, not the app's. */
+  home?: string;
+}
+
+/**
+ * The PowerShell 5.1 script that opens the Windows app again. It answers
+ * `started` in its log, waits for the app's process to be gone (Chromium's
+ * profile stays held until then, and an app opened before hands itself to the
+ * closing one and crashes), then opens the launcher. An app that stopped
+ * waiting for it writes `cancel` and stays open, so the script opens nothing.
+ */
+export function windowsRelaunchScript({ pid, launcher, log, cancel, taskName, home }: WindowsRelaunch): string {
+  return [
+    "$ErrorActionPreference = 'Stop'",
+    `$OldPid = ${pid}`,
+    `$Launcher = ${psString(launcher)}`,
+    `$Log = ${psString(log)}`,
+    `$Cancel = ${psString(cancel)}`,
+    `$TaskName = ${psString(taskName)}`,
+    `$DataHome = ${psString(home ?? "")}`,
+    String.raw`
+$LogEncoding = New-Object System.Text.UTF8Encoding $false
+function Write-Log([string]$Message) {
+  for ($Attempt = 0; $Attempt -lt 10; $Attempt += 1) {
+    try { [IO.File]::AppendAllText($Log, (Get-Date).ToString('o') + ' ' + $Message + [Environment]::NewLine, $LogEncoding); return } catch { Start-Sleep -Milliseconds 100 }
+  }
+}
+
+try {
+  if (-not (Test-Path -LiteralPath $Launcher)) { Write-Log ('declined: no ' + $Launcher); return }
+  Write-Log ('started ' + $PID)
+  $Deadline = (Get-Date).AddMinutes(5)
+  while ((Get-Process -Id $OldPid -ErrorAction SilentlyContinue) -and -not (Test-Path -LiteralPath $Cancel) -and (Get-Date) -lt $Deadline) {
+    Start-Sleep -Milliseconds 250
+  }
+  if (Test-Path -LiteralPath $Cancel) { Write-Log 'the app stopped waiting; it stays open'; return }
+  if (Get-Process -Id $OldPid -ErrorAction SilentlyContinue) { Write-Log 'the app did not quit'; return }
+  Start-Sleep -Milliseconds 500
+  if ($DataHome) { $env:GLOOMBERB_HOME = $DataHome }
+  Start-Process -FilePath $Launcher -WorkingDirectory (Split-Path -Parent $Launcher)
+  Write-Log ('opened ' + $Launcher)
+} catch {
+  Write-Log ('could not open the app: ' + $_.Exception.Message)
+} finally {
+  $ErrorActionPreference = 'Continue'
+  schtasks.exe /delete /tn $TaskName /f | Out-Null
+  Remove-Item -LiteralPath $PSCommandPath -Force -ErrorAction SilentlyContinue
+}
+`,
+  ].join("\n");
+}
+
+/**
+ * Electrobun puts the Windows app in a job that ends every process it starts
+ * when it exits, so the script runs from a scheduled task, which outlives it.
+ * Resolves once the script has started: the app may quit then.
+ */
+async function scheduleWindowsRelaunch(context: RelaunchContext): Promise<void> {
+  const name = `gloom-restart-${context.pid}`;
+  const script = win32.join(tmpdir(), `${name}.ps1`);
+  const log = win32.join(tmpdir(), `${name}.log`);
+  const cancel = win32.join(tmpdir(), `${name}.cancel`);
+  await rm(log, { force: true });
+  await rm(cancel, { force: true });
+  await writePowerShellScript(script, windowsRelaunchScript({
+    pid: context.pid,
+    launcher: win32.join(win32.dirname(context.execPath), "launcher.exe"),
+    log,
+    cancel,
+    taskName: `GloomRestart-${context.pid}`,
+    home: context.home,
+  }));
+  const answer = await runScriptAfterExit(script, log, cancel, `GloomRestart-${context.pid}`);
+  if (answer.kind !== "started") throw new Error(`the restart script did not start: ${answer.reason}`);
+}
+
 /**
  * Opens the app again once this process has exited. On a Mac, `bundle` opens
  * that bundle instead of the one this process runs from: the app's own, under
- * the name it was just given.
+ * the name it was just given. Resolves once this process may exit.
  */
-export function scheduleDesktopRelaunch(bundle?: string, context: RelaunchContext = currentProcess()): void {
+export async function scheduleDesktopRelaunch(bundle?: string, context: RelaunchContext = currentProcess()): Promise<void> {
+  if (context.platform === "win32") {
+    await scheduleWindowsRelaunch(context);
+    return;
+  }
   const { cmd, cwd, pathEnv } = desktopRelaunchCommand(context, bundle);
   const child = Bun.spawn(cmd, {
     ...(cwd ? { cwd } : {}),

package/src/renderers/electrobun/bun/desktop/windows-script.ts

@@ -0,0 +1,92 @@
+import { readFile, writeFile } from "fs/promises";
+
+/**
+ * PowerShell scripts the Windows app leaves to finish what it cannot do while
+ * it runs: its own files are locked until it quits.
+ */
+
+/** How long a script has to answer before the app stops waiting and keeps running. */
+const SCRIPT_START_TIMEOUT_MS = 20_000;
+
+/**
+ * `value` as a single-quoted PowerShell string. PowerShell also takes the
+ * curly single quotes U+2018 to U+201B for quotes; doubling escapes each.
+ */
+export function psString(value: string): string {
+  return `'${value.replace(/['\u2018-\u201B]/g, "$&$&")}'`;
+}
+
+/** PowerShell 5.1, which every supported Windows has, running `script` hidden and without the user's profile. */
+function powershellCommand(script: string): string[] {
+  return ["powershell.exe", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-WindowStyle", "Hidden", "-File", script];
+}
+
+/**
+ * Writes `text` as a script for PowerShell 5.1: with Windows line ends, and
+ * with a byte order mark, without which it reads the file in the system code
+ * page and garbles a path with an accent in it.
+ */
+export async function writePowerShellScript(path: string, text: string): Promise<void> {
+  await writeFile(path, `\uFEFF${text.replaceAll(/\r?\n/g, "\r\n")}`, "utf8");
+}
+
+/** What a script that runs after the app quits answered before the app quit for it. */
+export type ScriptAnswer =
+  /** It waits for the app to quit. */
+  | { kind: "started" }
+  /** It cannot run now, for a while: something it needs is in use. */
+  | { kind: "busy"; reason: string }
+  /** It cannot run. */
+  | { kind: "declined"; reason: string };
+
+/**
+ * The script's answer in its log, a line `<time> started …`,
+ * `<time> busy: …` or `<time> declined: …`; null before it wrote one.
+ */
+export function scriptAnswer(log: string): ScriptAnswer | null {
+  for (const line of log.replace(/^\uFEFF/, "").split(/\r?\n/)) {
+    const match = /^\S+ (started|busy|declined)\b:? ?(.*)$/.exec(line);
+    if (!match) continue;
+    if (match[1] === "started") return { kind: "started" };
+    return { kind: match[1] === "busy" ? "busy" : "declined", reason: match[2]?.trim() ?? "" };
+  }
+  return null;
+}
+
+function schtasks(...args: string[]): void {
+  const result = Bun.spawnSync(["schtasks.exe", ...args], { stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+  if (!result.success) throw new Error(`schtasks ${args[0]}: ${result.stderr.toString().trim()}`);
+}
+
+/**
+ * Runs `script` from the scheduled task `taskName`, which outlives the app (a
+ * child of its process dies with it), and resolves to the answer it writes to
+ * `log`: only on `started` may the app quit for it. The script removes the
+ * task. When it does not answer in time, the app writes `cancel`, which keeps
+ * a script that starts late from doing anything, and this throws with the
+ * task gone, as it does when the task could not be made.
+ */
+export async function runScriptAfterExit(script: string, log: string, cancel: string, taskName: string): Promise<ScriptAnswer> {
+  const command = powershellCommand(script).map((part) => (part === script ? `"${part}"` : part)).join(" ");
+  try {
+    schtasks("/create", "/tn", taskName, "/tr", command, "/sc", "once", "/st", "00:00", "/f");
+    schtasks("/run", "/tn", taskName);
+    const deadline = Date.now() + SCRIPT_START_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      const answer = scriptAnswer(await readFile(log, "utf8").catch(() => ""));
+      if (answer) return answer;
+      await Bun.sleep(250);
+    }
+    await writeFile(cancel, "").catch(() => {});
+    throw new Error("the script did not start");
+  } catch (error) {
+    try { schtasks("/delete", "/tn", taskName, "/f"); } catch { /* Intentional ignore: never made, or the script removed it. */ }
+    throw error;
+  }
+}
+
+/** Runs `script` in the background, as a child of the app; resolves to its exit code. */
+export async function runScriptInBackground(script: string): Promise<number> {
+  const child = Bun.spawn(powershellCommand(script), { stdio: ["ignore", "ignore", "ignore"], windowsHide: true });
+  return await child.exited;
+}

package/src/renderers/electrobun/bun/index.ts

@@ -25,9 +25,11 @@ import {
   type RememberedDesktopWindow,
 } from "./window/remembered-frame";
 import { reapStaleTerminalMedia } from "../../opentui/terminal-media";
+import { quitWindowsEventLoopOnItsThread } from "./window/windows-quit";
 import { installProcessCrashListeners } from "../../../telemetry/crash-reports-node";
 import { renameLegacyMacApp } from "./desktop/app-name";
 import { scheduleDesktopRelaunch } from "./desktop/relaunch";
+import { settleInstallerFolder } from "./desktop/installer-folder";
 
 console.log = (...args) => console.error(...args);
 console.info = (...args) => console.error(...args);
@@ -45,6 +47,25 @@ setConfigStoreHost(nodeConfigStoreHost);
 // before the config, and its off switch, has been read.
 installProcessCrashListeners();
 
+// An install the Windows installer made lives in the installer's folder,
+// where its shortcuts, the gloom command and its uninstall entry lead.
+// Electrobun's updater installs an update into a folder of its own and opens
+// it from there: this build moves into the installer's folder and opens again
+// from it before any window shows.
+const installerFolderMove = await settleInstallerFolder({
+  platform: process.platform,
+  execPath: process.execPath,
+  homeDir: homedir(),
+  localAppData: process.env.LOCALAPPDATA,
+}).catch((error: unknown) => {
+  console.error("[desktop] could not move the app into the installer's folder", error instanceof Error ? error.message : String(error));
+  return null;
+});
+if (installerFolderMove?.kind === "relaunching") {
+  Utils.quit();
+  await new Promise<never>(() => {});
+}
+
 // An install from before the rename runs from Gloomberb.app, where its updater
 // put this build. It takes the new name and opens again from there before any
 // window shows. Anywhere else this returns without touching the disk.
@@ -58,7 +79,7 @@ const appRename = await renameLegacyMacApp({
   return null;
 });
 if (appRename?.kind === "renamed") {
-  scheduleDesktopRelaunch(appRename.bundle);
+  await scheduleDesktopRelaunch(appRename.bundle);
   Utils.quit();
   // The process is exiting; nothing below may open a window meanwhile.
   await new Promise<never>(() => {});
@@ -171,12 +192,15 @@ const mainWindow = createAppWindow({
   preload: desktopBootFramePreload(readDesktopBootFrame(desktopBootFramePath())),
 });
 backend.mainWindow = mainWindow;
+quitWindowsEventLoopOnItsThread(mainWindow);
 // The window is loading its view; the services it will ask for start now
 // rather than when it asks. Its `init` reports a failure, and retries.
 startDesktopBackend(backend).catch((error) => {
   console.error("[desktop] startup failed", error instanceof Error ? error.stack ?? error.message : String(error));
 });
-if (rememberedWindow?.fullscreen) {
+// Windows has no way into fullscreen here, and builds whose frameless window
+// Windows took for fullscreen saved every window as fullscreen.
+if (rememberedWindow?.fullscreen && process.platform !== "win32") {
   try { mainWindow.setFullScreen(true); } catch { /* the framed window is still the one they sized */ }
 } else if (rememberedWindow?.maximized) {
   try { mainWindow.maximize(); } catch { /* the framed window is still the one they sized */ }

package/src/renderers/electrobun/bun/window/attention.ts

@@ -0,0 +1,54 @@
+import { setStallAttentionProbe, type StallAttention } from "../../../../telemetry/stall-reports";
+
+/** What this needs of a window: its id, its minimized state and its events. */
+interface AttentionWindow {
+  id: number;
+  isMinimized(): boolean;
+  on?(name: string, handler: (event: unknown) => void): void;
+}
+
+const openWindows = new Map<number, AttentionWindow>();
+let focusedWindowId: number | null = null;
+let sawFocusChange = false;
+
+/**
+ * Whether anyone was looking when the desktop app's Bun process froze. The
+ * system slows a hidden app's timers, which reads like a freeze, so a stall
+ * report from this process says whether one of the app's windows had the
+ * keyboard (the app was in front) and whether one was open and not
+ * minimized. Read only for a stall about to be reported.
+ */
+function desktopAttention(): StallAttention {
+  let visible: boolean | null = false;
+  try {
+    for (const window of openWindows.values()) {
+      if (!window.isMinimized()) {
+        visible = true;
+        break;
+      }
+    }
+  } catch {
+    visible = null;
+  }
+  return { active: sawFocusChange ? focusedWindowId !== null : null, visible };
+}
+
+/** Follows a window the app opened until it closes; the first one installs the probe. */
+export function trackWindowAttention(window: AttentionWindow): void {
+  if (openWindows.size === 0) setStallAttentionProbe(desktopAttention);
+  openWindows.set(window.id, window);
+  window.on?.("focus", () => {
+    focusedWindowId = window.id;
+    sawFocusChange = true;
+  });
+  window.on?.("blur", () => {
+    // Focus moving between two of the app's windows can report the new
+    // window's focus before the old one's blur.
+    if (focusedWindowId === window.id) focusedWindowId = null;
+    sawFocusChange = true;
+  });
+  window.on?.("close", () => {
+    openWindows.delete(window.id);
+    if (focusedWindowId === window.id) focusedWindowId = null;
+  });
+}

package/src/renderers/electrobun/bun/window/create.ts

@@ -1,5 +1,7 @@
 import { BrowserWindow } from "electrobun/bun";
+import { trackWindowAttention } from "./attention";
 import {
+  applyNativeWindowFrame,
   applyWindowMoveEvent,
   applyWindowResizeEvent,
   updateWindowFrameCache,
@@ -9,6 +11,7 @@ import {
 import type { WindowFrame, WindowMinimumSize } from "./frame";
 import { applyWindowsCustomChrome } from "./windows-custom-chrome";
 import { applyWindowsWindowIcon } from "./windows-icons";
+import { fitPageToClientArea } from "./windows-native";
 
 type DesktopTitleBarStyle = "default" | "hidden" | "hiddenInset";
 type DesktopWindowRenderer = "native" | "cef";
@@ -20,8 +23,13 @@ type DesktopWindowStyleMask = {
   FullSizeContentView?: boolean;
 };
 
+/**
+ * No native title bar: the header is the title bar. On Windows "hidden" is a
+ * bare popup with no frame to resize by, which Windows also takes for
+ * fullscreen; "hiddenInset" keeps the sizing frame and cuts out the caption.
+ */
 function desktopTitleBarStyle(): DesktopTitleBarStyle {
-  return process.platform === "darwin" ? "hiddenInset" : "hidden";
+  return process.platform === "linux" ? "hidden" : "hiddenInset";
 }
 
 function desktopWindowRenderer(): DesktopWindowRenderer {
@@ -43,6 +51,22 @@ function desktopWindowStyleMask(): DesktopWindowStyleMask {
   };
 }
 
+const APP_VIEW_URL = "views://mainview/index.html";
+
+/**
+ * Electrobun's Windows webview takes a page load that starts while Ctrl is
+ * down for a Ctrl+click on a link: it cancels the load and asks for a new
+ * window instead. A window opened from a Ctrl chord, as Ctrl+Shift+O pops a
+ * pane out, stayed blank. Its page is loaded again, which Electrobun lets
+ * through within half a second of the one it cancelled.
+ */
+function loadAgainWhenTakenForCtrlClick(window: BrowserWindow): void {
+  (window.webview as { on: (name: string, handler: (event: unknown) => void) => void }).on("new-window-open", (event) => {
+    const detail = (event as { data?: { detail?: { url?: unknown } } }).data?.detail;
+    if (detail?.url === APP_VIEW_URL) window.webview.loadURL(APP_VIEW_URL);
+  });
+}
+
 interface AppWindowOptions {
   title: string;
   /** Already normalized to at least `minSize`. */
@@ -63,7 +87,7 @@ export function createAppWindow({ title, frame, rpc, minSize, onFrameChange, pre
   const window = new BrowserWindow({
     title,
     frame,
-    url: "views://mainview/index.html",
+    url: APP_VIEW_URL,
     ...(preload ? { preload } : {}),
     renderer: desktopWindowRenderer(),
     rpc,
@@ -74,13 +98,30 @@ export function createAppWindow({ title, frame, rpc, minSize, onFrameChange, pre
   });
   applyWindowsWindowIcon(title);
   applyWindowsCustomChrome(title);
+  if (process.platform === "win32") {
+    loadAgainWhenTakenForCtrlClick(window);
+    // The page exists once it has loaded; until then there is nothing to fit.
+    window.webview.on("dom-ready", () => {
+      fitPageToClientArea(window.ptr);
+    });
+  }
   updateWindowFrameCache(window, frame, minSize);
+  trackWindowAttention(window);
+  const readsNativeFrame = process.platform === "win32";
   (window as any).on?.("move", (event: WindowMoveEvent) => {
-    applyWindowMoveEvent(window, event);
+    if (readsNativeFrame) {
+      if (!applyNativeWindowFrame(window, minSize)) return;
+    } else {
+      applyWindowMoveEvent(window, event);
+    }
     onFrameChange?.();
   });
   (window as any).on?.("resize", (event: WindowResizeEvent) => {
-    applyWindowResizeEvent(window, event, minSize);
+    if (readsNativeFrame) {
+      if (!applyNativeWindowFrame(window, minSize)) return;
+    } else {
+      applyWindowResizeEvent(window, event, minSize);
+    }
     onFrameChange?.();
   });
   return window;

package/src/renderers/electrobun/bun/window/events.ts

@@ -47,3 +47,23 @@ export function applyWindowResizeEvent(
   }
   return nextFrame;
 }
+
+type FramedWindow = Pick<BrowserWindow, "frame" | "getFrame" | "isMinimized" | "setFrame">;
+
+/**
+ * Electrobun's Windows events do not carry the window's frame: a resize
+ * reports the client area's size at 0,0, a move the client area's corner as
+ * unsigned 16-bit values, and both come while the window is minimized. There
+ * the frame is read from the window itself, and a minimized window keeps the
+ * frame it had.
+ */
+export function applyNativeWindowFrame(window: FramedWindow, minimumSize?: WindowMinimumSize): WindowFrame | null {
+  if (window.isMinimized()) return null;
+  const read = window.getFrame();
+  if (!(read.width > 0 && read.height > 0)) return null;
+  const nextFrame = updateWindowFrameCache(window as BrowserWindow, read, minimumSize);
+  if (nextFrame && (nextFrame.width !== read.width || nextFrame.height !== read.height)) {
+    window.setFrame(nextFrame.x, nextFrame.y, nextFrame.width, nextFrame.height);
+  }
+  return nextFrame;
+}

package/src/renderers/electrobun/bun/window/windows-custom-chrome.ts

@@ -7,7 +7,14 @@ const WS_SYSMENU = 0x00080000n;
 const WS_THICKFRAME = 0x00040000n;
 const WS_MINIMIZEBOX = 0x00020000n;
 const WS_MAXIMIZEBOX = 0x00010000n;
-const WINDOWS_NATIVE_CONTROL_STYLE_MASK = WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
+/**
+ * Electrobun's "hiddenInset" window is captioned and sizable, with the caption
+ * cut out of its frame: its edges and corners resize it, it maximizes to the
+ * work area and keeps its shadow, while the header draws the buttons. Windows
+ * still reads the box bits: they let a click on the taskbar button minimize
+ * the window, and Win+Up, snapping and the window menu maximize it.
+ */
+const WINDOWS_FRAME_STYLE = WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
 const SWP_NOSIZE = 0x0001;
 const SWP_NOMOVE = 0x0002;
 const SWP_NOZORDER = 0x0004;
@@ -22,7 +29,7 @@ function styleValue(value: number | bigint): bigint {
 
 function applyCustomChromeToWindow(win32: Win32, windowHandle: Pointer): boolean {
   const currentStyle = styleValue(win32.symbols.GetWindowLongPtrW(windowHandle, GWL_STYLE));
-  const nextStyle = currentStyle & ~WINDOWS_NATIVE_CONTROL_STYLE_MASK;
+  const nextStyle = currentStyle | WINDOWS_FRAME_STYLE;
   if (nextStyle !== currentStyle) {
     win32.symbols.SetWindowLongPtrW(windowHandle, GWL_STYLE, nextStyle);
   }

package/src/renderers/electrobun/bun/window/windows-native.ts

@@ -41,6 +41,22 @@ function loadWin32() {
       args: [FFIType.ptr, FFIType.ptr, FFIType.int, FFIType.int, FFIType.int, FFIType.int, FFIType.u32],
       returns: FFIType.bool,
     },
+    GetCursorPos: {
+      args: [FFIType.ptr],
+      returns: FFIType.bool,
+    },
+    GetClientRect: {
+      args: [FFIType.ptr, FFIType.ptr],
+      returns: FFIType.bool,
+    },
+    PostMessageW: {
+      args: [FFIType.ptr, FFIType.u32, FFIType.u64, FFIType.i64],
+      returns: FFIType.bool,
+    },
+    GetGUIThreadInfo: {
+      args: [FFIType.u32, FFIType.ptr],
+      returns: FFIType.bool,
+    },
   });
 }
 
@@ -56,6 +72,68 @@ function win32OrNull(): Win32 | null {
   return cachedWin32;
 }
 
+const WM_SIZE = 0x0005;
+
+/**
+ * Electrobun opens a window's page at the size of the whole window and fits it
+ * to the client area on each WM_SIZE. A framed window's client area is smaller
+ * than the window, so until the window first changed size its page ran past
+ * the right and bottom edges, the Close button with it. Sends the window the
+ * WM_SIZE that fits the page. False off Windows.
+ */
+export function fitPageToClientArea(windowHandle: Pointer): boolean {
+  const win32 = win32OrNull();
+  if (!win32) return false;
+  const client = new Int32Array(4);
+  if (!win32.symbols.GetClientRect(windowHandle, ptr(client))) return false;
+  const size = (((client[3]! - client[1]!) & 0xffff) << 16) | ((client[2]! - client[0]!) & 0xffff);
+  return win32.symbols.PostMessageW(windowHandle, WM_SIZE, 0n, BigInt(size >>> 0));
+}
+
+const WM_NCLBUTTONDOWN = 0x00a1;
+const WM_CANCELMODE = 0x001f;
+const HTCAPTION = 2;
+/** GUITHREADINFO on 64-bit Windows: two DWORDs, six window handles, a RECT. */
+const GUI_THREAD_INFO_SIZE = 72;
+const GUI_THREAD_INFO_CAPTURE_OFFSET = 24;
+
+/**
+ * The window holding the mouse on `windowHandle`'s thread, if any. Chromium
+ * takes the mouse on every press, and Windows will not start a move while
+ * another window holds it.
+ */
+function mouseCaptureOnThreadOf(win32: Win32, windowHandle: Pointer): Pointer | null {
+  const thread = win32.symbols.GetWindowThreadProcessId(windowHandle, null);
+  if (!thread) return null;
+  const info = new DataView(new ArrayBuffer(GUI_THREAD_INFO_SIZE));
+  info.setUint32(0, GUI_THREAD_INFO_SIZE, true);
+  if (!win32.symbols.GetGUIThreadInfo(thread, ptr(info))) return null;
+  const capture = Number(info.getBigUint64(GUI_THREAD_INFO_CAPTURE_OFFSET, true));
+  return capture ? capture as Pointer : null;
+}
+
+/**
+ * Hands a press on the header to Windows as a press on a native title bar, from
+ * where the pointer is. Its move loop then moves the window until the button
+ * comes up: it snaps to the edges and corners of the screen and comes out of
+ * maximized, which a window moved by hand does not. Electrobun's own mover
+ * only moves. False off Windows.
+ *
+ * The page holds the mouse from the press, so it is asked to let go first, as
+ * a native title bar's window would have. Both messages go to the window's
+ * thread, which handles them in order.
+ */
+export function startSystemWindowMove(windowHandle: Pointer): boolean {
+  const win32 = win32OrNull();
+  if (!win32) return false;
+  const point = new Int32Array(2);
+  if (!win32.symbols.GetCursorPos(ptr(point))) return false;
+  const capture = mouseCaptureOnThreadOf(win32, windowHandle);
+  if (capture && capture !== windowHandle) win32.symbols.PostMessageW(capture, WM_CANCELMODE, 0n, 0n);
+  const position = ((point[1]! & 0xffff) << 16) | (point[0]! & 0xffff);
+  return win32.symbols.PostMessageW(windowHandle, WM_NCLBUTTONDOWN, BigInt(HTCAPTION), BigInt(position >>> 0));
+}
+
 export function wideString(value: string): Uint8Array {
   return Uint8Array.from(Buffer.from(`${value}\0`, "utf16le"));
 }

package/src/renderers/electrobun/bun/window/windows-quit.ts

@@ -0,0 +1,57 @@
+import { dlopen, FFIType, ptr, type Pointer } from "bun:ffi";
+import Electrobun from "electrobun/bun";
+import { wideString } from "./windows-native";
+
+const WM_QUIT = 0x0012;
+/** The class Electrobun registers for its windows. */
+const WINDOW_CLASS = "BasicWindowClass";
+/** How long a quit waits for this app's windows to be destroyed. */
+const WINDOWS_CLOSED_TIMEOUT_MS = 1_000;
+
+function loadUser32() {
+  return dlopen("user32.dll", {
+    GetWindowThreadProcessId: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    FindWindowExW: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
+    PostThreadMessageW: { args: [FFIType.u32, FFIType.u32, FFIType.u64, FFIType.i64], returns: FFIType.bool },
+  });
+}
+
+/**
+ * Electrobun ends its Windows event loop with PostQuitMessage, from the thread
+ * the app's code runs on rather than the one running the loop. The loop never
+ * ends: the app sits out a 5 s timeout with Chromium never shut down, and a
+ * Gloom opened meanwhile finds Chromium's profile still held, hands itself to
+ * the closing app and crashes. The quit message goes to the loop's own thread
+ * instead, once this app's windows are gone; with one still open, Electrobun's
+ * timeout ends the app as before. Does nothing off Windows.
+ */
+export function quitWindowsEventLoopOnItsThread(window: { ptr: Pointer | null }): void {
+  if (process.platform !== "win32" || !window.ptr) return;
+  let user32: ReturnType<typeof loadUser32>;
+  try {
+    user32 = loadUser32();
+  } catch {
+    return;
+  }
+  const loopThread = user32.symbols.GetWindowThreadProcessId(window.ptr, null);
+  if (!loopThread) return;
+  const className = wideString(WINDOW_CLASS);
+  const processId = new Uint32Array(1);
+  const ownWindowOpen = (): boolean => {
+    let handle: Pointer | null = null;
+    while ((handle = user32.symbols.FindWindowExW(null, handle, ptr(className), null))) {
+      user32.symbols.GetWindowThreadProcessId(handle, ptr(processId));
+      if (processId[0] === process.pid) return true;
+    }
+    return false;
+  };
+  Electrobun.events.on("before-quit", () => {
+    // Quitting blocks this thread until the loop has ended, so the wait is here.
+    const deadline = Date.now() + WINDOWS_CLOSED_TIMEOUT_MS;
+    while (ownWindowOpen()) {
+      if (Date.now() > deadline) return;
+      Bun.sleepSync(16);
+    }
+    user32.symbols.PostThreadMessageW(loopThread, WM_QUIT, 0n, 0n);
+  });
+}

package/src/renderers/electrobun/launcher/preload.ts

@@ -0,0 +1,13 @@
+// Runs first in Electrobun's launcher script (Resources/main.js) on Windows,
+// before it starts the app's worker and the browser engine. The Windows build
+// step puts it there (scripts/install-electrobun-tui-shim.ts).
+import { leaveEmulationFaultsToWindows } from "./windows-emulation";
+
+if (process.platform === "win32") {
+  try {
+    const result = leaveEmulationFaultsToWindows();
+    if (result !== "not emulated") console.log(`[launcher] x64 emulation: ${result}`);
+  } catch (error) {
+    console.error("[launcher] could not check for x64 emulation", error);
+  }
+}