gloomberb 0.8.2 → 0.9.1

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

@@ -12,6 +12,7 @@ import {
 import {
   detachedRpcKey,
   focusWindowForRpcKey,
+  paneIdFromDetachedRpcKey,
 } from "../window/focus";
 import {
   applyWindowMoveEvent,
@@ -22,6 +23,11 @@ import {
   type WindowResizeEvent,
 } from "./window-events";
 import type { DesktopStateBroadcaster, DesktopStateRpc } from "./state-broadcaster";
+import { applyWindowsWindowIcon } from "./windows-icons";
+import { desktopTitleBarStyle } from "./window-style";
+
+const INITIAL_DOCK_SUPPRESSION_MS = 800;
+const WINDOW_CONTROL_DOCK_SUPPRESSION_MS = 5_000;
 
 interface DesktopDetachedWindowManagerOptions<Rpc extends DesktopStateRpc> {
   createRpc: (key: string) => Rpc;
@@ -45,6 +51,8 @@ export class DesktopDetachedWindowManager<Rpc extends DesktopStateRpc> {
   private readonly dockTimers = new Map<string, ReturnType<typeof setTimeout>>();
   private readonly closingPanes = new Set<string>();
   private readonly pendingMoveFlush = new Set<string>();
+  private readonly suppressDockUntil = new Map<string, number>();
+  private readonly windowControlDockSuppressed = new Set<string>();
 
   constructor(private readonly options: DesktopDetachedWindowManagerOptions<Rpc>) {}
 
@@ -56,6 +64,19 @@ export class DesktopDetachedWindowManager<Rpc extends DesktopStateRpc> {
     return focusWindowForRpcKey(rpcKey, this.options.getMainWindow(), this.windows);
   }
 
+  getWindowForRpcKey(rpcKey: string | undefined): BrowserWindow | null {
+    const paneId = paneIdFromDetachedRpcKey(rpcKey);
+    return paneId ? this.windows.get(paneId) ?? null : null;
+  }
+
+  suppressAutoDockForRpcKey(rpcKey: string | undefined): void {
+    const paneId = paneIdFromDetachedRpcKey(rpcKey);
+    if (!paneId || !this.windows.has(paneId)) return;
+    this.windowControlDockSuppressed.add(paneId);
+    this.suppressDockUntil.set(paneId, Date.now() + WINDOW_CONTROL_DOCK_SUPPRESSION_MS);
+    this.options.stateBroadcaster.clearDockPreview(paneId);
+  }
+
   resolveFrame(instanceId: string): WindowFrame {
     const detachedEntry = this.options.getConfig().layout.detached.find((entry) => entry.instanceId === instanceId);
     if (detachedEntry) {
@@ -151,6 +172,8 @@ export class DesktopDetachedWindowManager<Rpc extends DesktopStateRpc> {
     this.clearTimer(this.frameTimers, instanceId);
     this.clearTimer(this.dockTimers, instanceId);
     this.pendingMoveFlush.delete(instanceId);
+    this.suppressDockUntil.delete(instanceId);
+    this.windowControlDockSuppressed.delete(instanceId);
     this.options.unregisterWindowRpc(detachedRpcKey(instanceId));
   }
 
@@ -160,18 +183,21 @@ export class DesktopDetachedWindowManager<Rpc extends DesktopStateRpc> {
   ): BrowserWindow {
     const rpc = this.options.createRpc(detachedRpcKey(instanceId));
     const initialFrame = normalizeWindowFrameWithMinimum(frame, DEFAULT_WINDOW_FRAME, DETACHED_WINDOW_MIN_SIZE);
+    const title = this.resolveTitle(instanceId);
     const window = new BrowserWindow({
-      title: this.resolveTitle(instanceId),
+      title,
       frame: initialFrame,
       url: "views://mainview/index.html",
       renderer: "native",
       rpc: rpc as never,
-      titleBarStyle: "hiddenInset",
+      titleBarStyle: desktopTitleBarStyle(),
       navigationRules: JSON.stringify(["views://*"]),
       sandbox: false,
     });
+    applyWindowsWindowIcon(title);
     updateWindowFrameCache(window, initialFrame, DETACHED_WINDOW_MIN_SIZE);
     this.windows.set(instanceId, window);
+    this.suppressDockUntil.set(instanceId, Date.now() + INITIAL_DOCK_SUPPRESSION_MS);
 
     (window as any).on?.("close", () => {
       const shouldIgnore = this.closingPanes.delete(instanceId);
@@ -230,6 +256,21 @@ export class DesktopDetachedWindowManager<Rpc extends DesktopStateRpc> {
     }, 120));
 
     this.clearTimer(this.dockTimers, instanceId);
+    if (this.windowControlDockSuppressed.has(instanceId)) {
+      this.options.stateBroadcaster.clearDockPreview(instanceId);
+      if (!edge) {
+        this.windowControlDockSuppressed.delete(instanceId);
+      }
+      return;
+    }
+
+    const suppressDockUntil = this.suppressDockUntil.get(instanceId) ?? 0;
+    if (Date.now() < suppressDockUntil) {
+      this.options.stateBroadcaster.clearDockPreview(instanceId);
+      return;
+    }
+    this.suppressDockUntil.delete(instanceId);
+
     if (!edge) {
       this.options.stateBroadcaster.clearDockPreview(instanceId);
       return;

package/src/renderers/electrobun/bun/desktop/host-requests.ts

@@ -3,10 +3,13 @@ import { ContextMenu, Utils, type BrowserWindow } from "electrobun/bun";
 import { buildSoundCommand } from "../../../../notifications/app-notifier";
 import type { DesktopRestartMessage } from "../../shared/protocol";
 import { getContextMenuRequestId, normalizeContextMenuItems } from "../context-menu/normalize";
+import { MAIN_WINDOW_RPC_KEY } from "../window/focus";
+import type { DesktopWindowControlAction } from "./window-controls";
 
 interface DesktopHostRequestOptions<TRpc> {
   clearMainWindow: () => void;
   closeAllDetachedWindows: () => void;
+  controlWindowForRpcKey: (windowKey: string | undefined, action: DesktopWindowControlAction) => boolean;
   focusWindowForRpcKey: (windowKey: string) => void;
   getMainWindow: () => BrowserWindow | null;
   getRpcWindowKey: (rpc: TRpc) => string | undefined;
@@ -37,9 +40,17 @@ function playNotificationSound(sound: string | undefined): void {
   }
 }
 
+function normalizeWindowControlAction(action: unknown): DesktopWindowControlAction {
+  if (action === "minimize" || action === "toggle-maximize" || action === "close") {
+    return action;
+  }
+  throw new Error("host.windowControl requires a valid action.");
+}
+
 export function handleDesktopHostRequest<TRpc>({
   clearMainWindow,
   closeAllDetachedWindows,
+  controlWindowForRpcKey,
   focusWindowForRpcKey,
   getMainWindow,
   getRpcWindowKey,
@@ -69,6 +80,26 @@ export function handleDesktopHostRequest<TRpc>({
       Utils.quit();
       return null;
     }
+    case "host.windowControl": {
+      const action = normalizeWindowControlAction(payload.action);
+      const windowKey = getRpcWindowKey(rpc);
+      if (action === "close" && windowKey === MAIN_WINDOW_RPC_KEY) {
+        closeAllDetachedWindows();
+        teardownServices();
+        const mainWindow = getMainWindow();
+        if (mainWindow) {
+          mainWindow.close();
+          clearMainWindow();
+          return null;
+        }
+        Utils.quit();
+        return null;
+      }
+      if (!controlWindowForRpcKey(windowKey, action)) {
+        throw new Error("No desktop window is registered for this request.");
+      }
+      return null;
+    }
     case "host.openExternal":
       if (typeof payload.url !== "string") {
         throw new Error("host.openExternal requires a URL.");

package/src/renderers/electrobun/bun/desktop/http-fetch.test.ts

@@ -0,0 +1,42 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { handleHttpFetch } from "./http-fetch";
+
+let server: ReturnType<typeof Bun.serve> | null = null;
+
+afterEach(() => {
+  server?.stop(true);
+  server = null;
+});
+
+describe("handleHttpFetch", () => {
+  test("preserves manual redirects and Set-Cookie headers", async () => {
+    server = Bun.serve({
+      port: 0,
+      fetch(request) {
+        const url = new URL(request.url);
+        if (url.pathname === "/login") {
+          return new Response(null, {
+            status: 302,
+            headers: {
+              location: "/reader",
+              "set-cookie": "substack.sid=sid123; Path=/; HttpOnly",
+            },
+          });
+        }
+        if (url.pathname === "/reader") {
+          return new Response("reader");
+        }
+        return new Response("not found", { status: 404 });
+      },
+    });
+
+    const response = await handleHttpFetch({
+      url: new URL("/login", server.url).toString(),
+      init: { redirect: "manual" },
+    });
+
+    expect(response.status).toBe(302);
+    expect(response.headers.location).toBe("/reader");
+    expect(response.setCookie).toEqual(["substack.sid=sid123; Path=/; HttpOnly"]);
+  });
+});

package/src/renderers/electrobun/bun/desktop/http-fetch.ts

@@ -26,6 +26,10 @@ export async function handleHttpFetch(payload: Record<string, unknown>) {
     typeof init.method === "string" && init.method.trim().length > 0
       ? init.method.trim().toUpperCase()
       : "GET";
+  const redirect =
+    init.redirect === "manual" || init.redirect === "error" || init.redirect === "follow"
+      ? init.redirect
+      : undefined;
   const body =
     typeof init.body === "string" && method !== "GET" && method !== "HEAD"
       ? init.body
@@ -35,6 +39,7 @@ export async function handleHttpFetch(payload: Record<string, unknown>) {
     method,
     headers: normalizeHttpFetchHeaders(init.headers),
     body,
+    redirect,
   });
   const responseHeaders: Record<string, string> = {};
   response.headers.forEach((value, key) => {

package/src/renderers/electrobun/bun/desktop/window-controls.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test";
+import { applyDesktopWindowControl } from "./window-controls";
+
+type WindowCall =
+  | { type: "close" }
+  | { type: "minimize" }
+  | { type: "maximize" }
+  | { type: "unmaximize" }
+  | { type: "setFrame"; frame: { x: number; y: number; width: number; height: number } };
+
+function createWindow() {
+  const calls: WindowCall[] = [];
+  const frame = { x: 120, y: 80, width: 640, height: 420 };
+  return {
+    calls,
+    window: {
+      frame,
+      close: () => calls.push({ type: "close" }),
+      minimize: () => calls.push({ type: "minimize" }),
+      maximize: () => calls.push({ type: "maximize" }),
+      unmaximize: () => calls.push({ type: "unmaximize" }),
+      getFrame: () => frame,
+      setFrame: (x: number, y: number, width: number, height: number) => calls.push({
+        type: "setFrame",
+        frame: { x, y, width, height },
+      }),
+    },
+  };
+}
+
+describe("applyDesktopWindowControl", () => {
+  test("minimizes and closes windows", () => {
+    const target = createWindow();
+
+    applyDesktopWindowControl(target.window, "minimize");
+    applyDesktopWindowControl(target.window, "close");
+
+    expect(target.calls).toEqual([{ type: "minimize" }, { type: "close" }]);
+  });
+
+  test("toggles maximize from the custom control state", () => {
+    const target = createWindow();
+
+    applyDesktopWindowControl(target.window, "toggle-maximize");
+    applyDesktopWindowControl(target.window, "toggle-maximize");
+
+    expect(target.calls).toEqual([
+      { type: "maximize" },
+      { type: "unmaximize" },
+      { type: "setFrame", frame: { x: 120, y: 80, width: 640, height: 420 } },
+    ]);
+  });
+});

package/src/renderers/electrobun/bun/desktop/window-controls.ts

@@ -0,0 +1,64 @@
+export type DesktopWindowControlAction = "minimize" | "toggle-maximize" | "close";
+
+interface DesktopWindowFrame {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface ControllableDesktopWindow {
+  frame?: Partial<DesktopWindowFrame> | null;
+  close?: () => void;
+  minimize?: () => void;
+  maximize?: () => void;
+  unmaximize?: () => void;
+  getFrame?: () => Partial<DesktopWindowFrame> | null;
+  setFrame?: (x: number, y: number, width: number, height: number) => void;
+}
+
+const maximizedWindowRestoreFrames = new WeakMap<ControllableDesktopWindow, DesktopWindowFrame | null>();
+
+function normalizeFrame(frame: Partial<DesktopWindowFrame> | null | undefined): DesktopWindowFrame | null {
+  if (!frame) return null;
+  const { x, y, width, height } = frame;
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(width) || !Number.isFinite(height)) {
+    return null;
+  }
+  return { x, y, width, height };
+}
+
+function readWindowFrame(window: ControllableDesktopWindow): DesktopWindowFrame | null {
+  return normalizeFrame(window.getFrame?.() ?? window.frame);
+}
+
+function restoreWindowFrame(window: ControllableDesktopWindow, frame: DesktopWindowFrame | null): void {
+  if (!frame) return;
+  window.setFrame?.(frame.x, frame.y, frame.width, frame.height);
+}
+
+export function applyDesktopWindowControl(
+  window: ControllableDesktopWindow,
+  action: DesktopWindowControlAction,
+): void {
+  if (action === "close") {
+    maximizedWindowRestoreFrames.delete(window);
+    window.close?.();
+    return;
+  }
+
+  if (action === "minimize") {
+    window.minimize?.();
+    return;
+  }
+
+  const restoreFrame = maximizedWindowRestoreFrames.get(window);
+  if (maximizedWindowRestoreFrames.has(window)) {
+    maximizedWindowRestoreFrames.delete(window);
+    window.unmaximize?.();
+    restoreWindowFrame(window, restoreFrame);
+    return;
+  }
+  maximizedWindowRestoreFrames.set(window, readWindowFrame(window));
+  window.maximize?.();
+}

package/src/renderers/electrobun/bun/desktop/window-style.ts

@@ -0,0 +1,5 @@
+type DesktopTitleBarStyle = "default" | "hidden" | "hiddenInset";
+
+export function desktopTitleBarStyle(): DesktopTitleBarStyle {
+  return process.platform === "darwin" ? "hiddenInset" : "hidden";
+}

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

@@ -0,0 +1,123 @@
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { dlopen, FFIType, ptr, type Pointer } from "bun:ffi";
+
+const WM_SETICON = 0x0080;
+const ICON_SMALL = 0;
+const ICON_BIG = 1;
+const IMAGE_ICON = 1;
+const LR_LOADFROMFILE = 0x0010;
+const LR_DEFAULTSIZE = 0x0040;
+const GCLP_HICON = -14;
+const GCLP_HICONSM = -34;
+const MAX_ATTEMPTS = 20;
+const RETRY_DELAY_MS = 100;
+
+type Win32 = ReturnType<typeof loadWin32>;
+
+let cachedWin32: Win32 | null | undefined;
+let smallIconHandle: Pointer | null = null;
+let bigIconHandle: Pointer | null = null;
+
+function loadWin32() {
+  return dlopen("user32.dll", {
+    FindWindowW: {
+      args: [FFIType.ptr, FFIType.ptr],
+      returns: FFIType.ptr,
+    },
+    GetWindowThreadProcessId: {
+      args: [FFIType.ptr, FFIType.ptr],
+      returns: FFIType.u32,
+    },
+    LoadImageW: {
+      args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.int, FFIType.int, FFIType.u32],
+      returns: FFIType.ptr,
+    },
+    SendMessageW: {
+      args: [FFIType.ptr, FFIType.u32, FFIType.u64, FFIType.ptr],
+      returns: FFIType.ptr,
+    },
+    SetClassLongPtrW: {
+      args: [FFIType.ptr, FFIType.int, FFIType.ptr],
+      returns: FFIType.ptr,
+    },
+  });
+}
+
+function win32OrNull(): Win32 | null {
+  if (process.platform !== "win32") return null;
+  if (cachedWin32 !== undefined) return cachedWin32;
+
+  try {
+    cachedWin32 = loadWin32();
+  } catch {
+    cachedWin32 = null;
+  }
+  return cachedWin32;
+}
+
+function wideString(value: string): Buffer {
+  return Buffer.from(`${value}\0`, "utf16le");
+}
+
+function readWindowProcessId(win32: Win32, windowHandle: Pointer): number {
+  const processIdBuffer = new Uint32Array(1);
+  win32.symbols.GetWindowThreadProcessId(windowHandle, ptr(processIdBuffer));
+  return processIdBuffer[0] ?? 0;
+}
+
+function findCurrentProcessWindow(win32: Win32, title: string): Pointer | null {
+  const titleBuffer = wideString(title);
+  const windowHandle = win32.symbols.FindWindowW(null, ptr(titleBuffer));
+  if (!windowHandle) return null;
+  if (readWindowProcessId(win32, windowHandle) !== process.pid) return null;
+  return windowHandle;
+}
+
+function loadIconHandle(win32: Win32, iconPath: string, size: number): Pointer | null {
+  const iconPathBuffer = wideString(iconPath);
+  const iconHandle = win32.symbols.LoadImageW(
+    null,
+    ptr(iconPathBuffer),
+    IMAGE_ICON,
+    size,
+    size,
+    LR_LOADFROMFILE | LR_DEFAULTSIZE,
+  );
+
+  return iconHandle || null;
+}
+
+function ensureIconHandles(win32: Win32): boolean {
+  if (smallIconHandle && bigIconHandle) return true;
+
+  const iconPath = resolve("../Resources/app.ico");
+  if (!existsSync(iconPath)) return false;
+
+  smallIconHandle = smallIconHandle ?? loadIconHandle(win32, iconPath, 16);
+  bigIconHandle = bigIconHandle ?? loadIconHandle(win32, iconPath, 32);
+
+  return Boolean(smallIconHandle && bigIconHandle);
+}
+
+function setWindowIcon(win32: Win32, windowHandle: Pointer): boolean {
+  if (!ensureIconHandles(win32) || !smallIconHandle || !bigIconHandle) return false;
+
+  win32.symbols.SendMessageW(windowHandle, WM_SETICON, ICON_SMALL, smallIconHandle);
+  win32.symbols.SendMessageW(windowHandle, WM_SETICON, ICON_BIG, bigIconHandle);
+  win32.symbols.SetClassLongPtrW(windowHandle, GCLP_HICONSM, smallIconHandle);
+  win32.symbols.SetClassLongPtrW(windowHandle, GCLP_HICON, bigIconHandle);
+  return true;
+}
+
+export function applyWindowsWindowIcon(title: string, attempt = 1): void {
+  const win32 = win32OrNull();
+  if (!win32) return;
+
+  const windowHandle = findCurrentProcessWindow(win32, title);
+  if (windowHandle && setWindowIcon(win32, windowHandle)) return;
+
+  if (attempt < MAX_ATTEMPTS) {
+    setTimeout(() => applyWindowsWindowIcon(title, attempt + 1), RETRY_DELAY_MS);
+  }
+}

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

@@ -16,7 +16,7 @@ import { ELECTROBUN_CONTEXT_MENU_ACTION, type DesktopRestartMessage, type Electr
 import { decodeRpcValue, encodeRpcValue } from "../view/rpc-codec";
 import { contextMenuSelectionMessage } from "./context-menu/click";
 import type { DesktopWorkspace } from "./desktop/workspace";
-import { buildApplicationMenu } from "./application-menu";
+import { buildDesktopApplicationMenu } from "./application-menu";
 import { applicationMenuCommand } from "./application-menu/click";
 import { registerElectrobunCoreCapabilities } from "./core-capabilities";
 import { setNativeIbkrGatewayModuleLoader } from "../../../plugins/ibkr/gateway/service";
@@ -25,8 +25,8 @@ import {
 } from "./desktop/update";
 import { DesktopCapabilityBridge } from "./desktop/capability-bridge";
 import {
-  DEFAULT_WINDOW_FRAME,
   MAIN_WINDOW_MIN_SIZE,
+  defaultMainWindowFrame,
   normalizeWindowFrameWithMinimum,
 } from "./window/frame";
 import { MAIN_WINDOW_RPC_KEY } from "./window/focus";
@@ -47,6 +47,9 @@ import { handleDesktopHostRequest } from "./desktop/host-requests";
 import { handleDesktopWorkspaceRequest } from "./desktop/workspace/requests";
 import { handleDesktopBackendRequest } from "./desktop/backend-requests";
 import { initializeDesktopBackend } from "./desktop/initialization";
+import { applyWindowsWindowIcon } from "./desktop/windows-icons";
+import { desktopTitleBarStyle } from "./desktop/window-style";
+import { applyDesktopWindowControl, type DesktopWindowControlAction } from "./desktop/window-controls";
 
 type DesktopRpc = ReturnType<typeof BrowserView.defineRPC<ElectrobunDesktopRpcSchema>>;
 
@@ -273,6 +276,18 @@ function closeAllDetachedWindows(): void {
   detachedWindowManager.closeAll();
 }
 
+function controlWindowForRpcKey(windowKey: string | undefined, action: DesktopWindowControlAction): boolean {
+  const targetWindow = windowKey === MAIN_WINDOW_RPC_KEY
+    ? mainWindow
+    : detachedWindowManager.getWindowForRpcKey(windowKey);
+  if (!targetWindow) return false;
+  if (action !== "close") {
+    detachedWindowManager.suppressAutoDockForRpcKey(windowKey);
+  }
+  applyDesktopWindowControl(targetWindow, action);
+  return true;
+}
+
 async function initialize(
   rpc: DesktopRpc,
   payload: Record<string, unknown>,
@@ -343,6 +358,7 @@ async function handleBackendRequest(
       restartDesktopApp,
       rpc,
       teardownServices,
+      controlWindowForRpcKey,
       trackContextMenuRequest: (requestId, targetRpc) => {
         contextMenuRequestRpcs.clear();
         contextMenuRequestRpcs.set(requestId, targetRpc);
@@ -383,7 +399,7 @@ async function handleBackendRequest(
 }
 
 function installApplicationMenu() {
-  ApplicationMenu.setApplicationMenu(buildApplicationMenu());
+  ApplicationMenu.setApplicationMenu(buildDesktopApplicationMenu());
 }
 
 function createWindowRpc(key: string): DesktopRpc {
@@ -432,18 +448,24 @@ ApplicationMenu.on("application-menu-clicked", (event: unknown) => {
 installApplicationMenu();
 
 const mainRpc = createWindowRpc(MAIN_WINDOW_RPC_KEY);
+const initialMainWindowFrame = normalizeWindowFrameWithMinimum(
+  defaultMainWindowFrame(),
+  defaultMainWindowFrame(),
+  MAIN_WINDOW_MIN_SIZE,
+);
 
 mainWindow = new BrowserWindow({
   title: "Gloomberb",
-  frame: normalizeWindowFrameWithMinimum(DEFAULT_WINDOW_FRAME, DEFAULT_WINDOW_FRAME, MAIN_WINDOW_MIN_SIZE),
+  frame: initialMainWindowFrame,
   url: "views://mainview/index.html",
   renderer: "native",
   rpc: mainRpc,
-  titleBarStyle: "hiddenInset",
+  titleBarStyle: desktopTitleBarStyle(),
   navigationRules: JSON.stringify(["views://*"]),
   sandbox: false,
 });
-updateWindowFrameCache(mainWindow, DEFAULT_WINDOW_FRAME, MAIN_WINDOW_MIN_SIZE);
+applyWindowsWindowIcon("Gloomberb");
+updateWindowFrameCache(mainWindow, initialMainWindowFrame, MAIN_WINDOW_MIN_SIZE);
 detachedWindowManager.focusWindowForRpcKey(MAIN_WINDOW_RPC_KEY);
 (mainWindow as any).on?.("move", (event: WindowMoveEvent) => {
   applyWindowMoveEvent(mainWindow, event);

package/src/renderers/electrobun/bun/window/frame.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, test } from "bun:test";
 import {
   DEFAULT_WINDOW_FRAME,
+  DEFAULT_WINDOWS_WINDOW_FRAME,
   MAIN_WINDOW_MIN_SIZE,
   constrainWindowFrame,
+  defaultMainWindowFrame,
   normalizeWindowFrameWithMinimum,
 } from "./frame";
 
@@ -37,4 +39,9 @@ describe("electrobun window frames", () => {
   test("uses the default frame when no frame data is available", () => {
     expect(normalizeWindowFrameWithMinimum(null)).toEqual(DEFAULT_WINDOW_FRAME);
   });
+
+  test("uses a compact default main window frame on Windows", () => {
+    expect(defaultMainWindowFrame("win32")).toEqual(DEFAULT_WINDOWS_WINDOW_FRAME);
+    expect(defaultMainWindowFrame("darwin")).toEqual(DEFAULT_WINDOW_FRAME);
+  });
 });

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

@@ -11,11 +11,16 @@ export interface WindowMinimumSize {
 }
 
 export const DEFAULT_WINDOW_FRAME: WindowFrame = { x: 64, y: 48, width: 1440, height: 920 };
+export const DEFAULT_WINDOWS_WINDOW_FRAME: WindowFrame = { x: 32, y: 32, width: 960, height: 680 };
 // Emergency fallback until Electrobun exposes stable native minimum-size handling:
 // https://github.com/blackboardsh/electrobun/issues/188
 export const MAIN_WINDOW_MIN_SIZE: WindowMinimumSize = { width: 640, height: 400 };
 export const DETACHED_WINDOW_MIN_SIZE: WindowMinimumSize = { width: 360, height: 240 };
 
+export function defaultMainWindowFrame(platform = process.platform): WindowFrame {
+  return platform === "win32" ? DEFAULT_WINDOWS_WINDOW_FRAME : DEFAULT_WINDOW_FRAME;
+}
+
 export function normalizeWindowFrame(
   frame: Partial<WindowFrame> | null | undefined,
   fallback: WindowFrame = DEFAULT_WINDOW_FRAME,

package/src/renderers/electrobun/view/build-assets.ts

@@ -108,10 +108,11 @@ ${bootstrapScript}
 }
 
 function resolveAlias(args: { path: string; importer?: string }, aliasRules: AliasRule[]) {
+  const importer = args.importer?.replaceAll("\\", "/");
   for (const rule of aliasRules) {
     const target = rule.length === 2
       ? args.path.endsWith(rule[0]) && rule[1]
-      : args.path === rule[0] && args.importer?.endsWith(rule[1]) && rule[2];
+      : args.path === rule[0] && importer?.endsWith(rule[1]) && rule[2];
     if (target) return { path: electrobunViewPath(target) };
   }
 }