gloomberb 0.9.0 → 0.9.2

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,16 @@ import {
   type WindowResizeEvent,
 } from "./window-events";
 import type { DesktopStateBroadcaster, DesktopStateRpc } from "./state-broadcaster";
+import { applyWindowsCustomChrome } from "./windows-custom-chrome";
+import { applyWindowsWindowIcon } from "./windows-icons";
+import {
+  desktopTitleBarStyle,
+  desktopWindowRenderer,
+  desktopWindowStyleMask,
+} 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 +56,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 +69,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 +177,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 +188,23 @@ 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",
+      renderer: desktopWindowRenderer(),
       rpc: rpc as never,
-      titleBarStyle: "hiddenInset",
+      styleMask: desktopWindowStyleMask(),
+      titleBarStyle: desktopTitleBarStyle(),
       navigationRules: JSON.stringify(["views://*"]),
       sandbox: false,
     });
+    applyWindowsWindowIcon(title);
+    applyWindowsCustomChrome(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 +263,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/initialization.ts

@@ -91,6 +91,7 @@ function buildInitializationPayload(
     desktopThemePreview: options.desktopThemePreview,
     pluginState: loadDesktopPluginState(services.pluginRegistry),
     capabilityManifests: services.pluginRegistry.capabilities.manifests({ rendererOnly: true }),
+    desktopPlatform: process.platform,
     windowKind: windowTarget.kind,
     paneId: windowTarget.paneId,
   };

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,73 @@
+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 (
+    typeof x !== "number"
+    || typeof y !== "number"
+    || typeof width !== "number"
+    || typeof height !== "number"
+    || !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 ?? null);
+    return;
+  }
+  maximizedWindowRestoreFrames.set(window, readWindowFrame(window));
+  window.maximize?.();
+}

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

@@ -0,0 +1,31 @@
+type DesktopTitleBarStyle = "default" | "hidden" | "hiddenInset";
+type DesktopWindowRenderer = "native" | "cef";
+type DesktopWindowStyleMask = {
+  Borderless?: boolean;
+  Closable?: boolean;
+  Miniaturizable?: boolean;
+  Titled?: boolean;
+  FullSizeContentView?: boolean;
+};
+
+export function desktopTitleBarStyle(): DesktopTitleBarStyle {
+  if (process.platform === "darwin") return "hiddenInset";
+  if (process.platform === "win32") return "hidden";
+  return "hidden";
+}
+
+export function desktopWindowRenderer(): DesktopWindowRenderer {
+  if (process.platform === "win32") return "cef";
+  return "native";
+}
+
+export function desktopWindowStyleMask(): DesktopWindowStyleMask {
+  if (process.platform !== "win32") return {};
+  return {
+    Borderless: true,
+    Closable: false,
+    Miniaturizable: false,
+    Titled: false,
+    FullSizeContentView: true,
+  };
+}

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

@@ -0,0 +1,58 @@
+import type { Pointer } from "bun:ffi";
+import {
+  findCurrentProcessWindow,
+  WINDOWS_HANDLE_MAX_ATTEMPTS,
+  WINDOWS_HANDLE_RETRY_DELAY_MS,
+  win32OrNull,
+} from "./windows-native";
+
+const GWL_STYLE = -16;
+const WS_CAPTION = 0x00c00000n;
+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;
+const SWP_NOSIZE = 0x0001;
+const SWP_NOMOVE = 0x0002;
+const SWP_NOZORDER = 0x0004;
+const SWP_NOACTIVATE = 0x0010;
+const SWP_FRAMECHANGED = 0x0020;
+const CUSTOM_CHROME_SET_WINDOW_POS_FLAGS = SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED;
+
+type Win32 = NonNullable<ReturnType<typeof win32OrNull>>;
+
+function styleValue(value: number | bigint): bigint {
+  if (typeof value === "bigint") return value;
+  return BigInt(value >>> 0);
+}
+
+function applyCustomChromeToWindow(win32: Win32, windowHandle: Pointer): boolean {
+  const currentStyle = styleValue(win32.symbols.GetWindowLongPtrW(windowHandle, GWL_STYLE));
+  const nextStyle = currentStyle & ~WINDOWS_NATIVE_CONTROL_STYLE_MASK;
+  if (nextStyle !== currentStyle) {
+    win32.symbols.SetWindowLongPtrW(windowHandle, GWL_STYLE, nextStyle);
+  }
+
+  return win32.symbols.SetWindowPos(
+    windowHandle,
+    null,
+    0,
+    0,
+    0,
+    0,
+    CUSTOM_CHROME_SET_WINDOW_POS_FLAGS,
+  );
+}
+
+export function applyWindowsCustomChrome(title: string, attempt = 1): void {
+  const win32 = win32OrNull();
+  if (!win32) return;
+
+  const windowHandle = findCurrentProcessWindow(win32, title);
+  if (windowHandle && applyCustomChromeToWindow(win32, windowHandle)) return;
+
+  if (attempt < WINDOWS_HANDLE_MAX_ATTEMPTS) {
+    setTimeout(() => applyWindowsCustomChrome(title, attempt + 1), WINDOWS_HANDLE_RETRY_DELAY_MS);
+  }
+}

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

@@ -0,0 +1,70 @@
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { ptr, type Pointer } from "bun:ffi";
+import {
+  findCurrentProcessWindow,
+  WINDOWS_HANDLE_MAX_ATTEMPTS,
+  WINDOWS_HANDLE_RETRY_DELAY_MS,
+  wideString,
+  win32OrNull,
+} from "./windows-native";
+
+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;
+type Win32 = NonNullable<ReturnType<typeof win32OrNull>>;
+let smallIconHandle: Pointer | null = null;
+let bigIconHandle: Pointer | null = null;
+
+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 < WINDOWS_HANDLE_MAX_ATTEMPTS) {
+    setTimeout(() => applyWindowsWindowIcon(title, attempt + 1), WINDOWS_HANDLE_RETRY_DELAY_MS);
+  }
+}

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

@@ -0,0 +1,75 @@
+import { dlopen, FFIType, ptr, type Pointer } from "bun:ffi";
+
+export const WINDOWS_HANDLE_MAX_ATTEMPTS = 20;
+export const WINDOWS_HANDLE_RETRY_DELAY_MS = 100;
+
+type Win32 = ReturnType<typeof loadWin32>;
+
+let cachedWin32: Win32 | null | undefined;
+
+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,
+    },
+    GetWindowLongPtrW: {
+      args: [FFIType.ptr, FFIType.int],
+      returns: FFIType.i64,
+    },
+    SetWindowLongPtrW: {
+      args: [FFIType.ptr, FFIType.int, FFIType.i64],
+      returns: FFIType.i64,
+    },
+    SetWindowPos: {
+      args: [FFIType.ptr, FFIType.ptr, FFIType.int, FFIType.int, FFIType.int, FFIType.int, FFIType.u32],
+      returns: FFIType.bool,
+    },
+  });
+}
+
+export function win32OrNull(): Win32 | null {
+  if (process.platform !== "win32") return null;
+  if (cachedWin32 !== undefined) return cachedWin32;
+
+  try {
+    cachedWin32 = loadWin32();
+  } catch {
+    cachedWin32 = null;
+  }
+  return cachedWin32;
+}
+
+export function wideString(value: string): Uint8Array {
+  return Uint8Array.from(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;
+}
+
+export 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;
+}

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,14 @@ import { handleDesktopHostRequest } from "./desktop/host-requests";
 import { handleDesktopWorkspaceRequest } from "./desktop/workspace/requests";
 import { handleDesktopBackendRequest } from "./desktop/backend-requests";
 import { initializeDesktopBackend } from "./desktop/initialization";
+import { applyWindowsCustomChrome } from "./desktop/windows-custom-chrome";
+import { applyWindowsWindowIcon } from "./desktop/windows-icons";
+import {
+  desktopTitleBarStyle,
+  desktopWindowRenderer,
+  desktopWindowStyleMask,
+} from "./desktop/window-style";
+import { applyDesktopWindowControl, type DesktopWindowControlAction } from "./desktop/window-controls";
 
 type DesktopRpc = ReturnType<typeof BrowserView.defineRPC<ElectrobunDesktopRpcSchema>>;
 
@@ -273,6 +281,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 +363,7 @@ async function handleBackendRequest(
       restartDesktopApp,
       rpc,
       teardownServices,
+      controlWindowForRpcKey,
       trackContextMenuRequest: (requestId, targetRpc) => {
         contextMenuRequestRpcs.clear();
         contextMenuRequestRpcs.set(requestId, targetRpc);
@@ -383,7 +404,7 @@ async function handleBackendRequest(
 }
 
 function installApplicationMenu() {
-  ApplicationMenu.setApplicationMenu(buildApplicationMenu());
+  ApplicationMenu.setApplicationMenu(buildDesktopApplicationMenu());
 }
 
 function createWindowRpc(key: string): DesktopRpc {
@@ -432,18 +453,26 @@ 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",
+  renderer: desktopWindowRenderer(),
   rpc: mainRpc,
-  titleBarStyle: "hiddenInset",
+  styleMask: desktopWindowStyleMask(),
+  titleBarStyle: desktopTitleBarStyle(),
   navigationRules: JSON.stringify(["views://*"]),
   sandbox: false,
 });
-updateWindowFrameCache(mainWindow, DEFAULT_WINDOW_FRAME, MAIN_WINDOW_MIN_SIZE);
+applyWindowsWindowIcon("Gloomberb");
+applyWindowsCustomChrome("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,