gloomberb 0.16.0 → 0.16.2

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

@@ -1,4 +1,4 @@
-import Electrobun from "electrobun/bun";
+import type Electrobun from "electrobun/bun";
 import type { UpdateStatusEntry } from "electrobun/bun";
 import type {
   ReleaseInfo,
@@ -6,7 +6,30 @@ import type {
   UpdateProgress,
 } from "../../../../updater";
 
-let desktopUpdateInProgress = false;
+type ElectrobunUpdater = typeof Electrobun.Updater;
+
+/**
+ * The part of Electrobun's updater this flow uses. Tests pass a fake, because
+ * the real module cannot be loaded or exercised outside the packaged app.
+ */
+export type ElectrobunUpdaterApi = Pick<
+  ElectrobunUpdater,
+  "checkForUpdate" | "downloadUpdate" | "applyUpdate" | "updateInfo" | "clearStatusHistory" | "onStatusChange"
+> & {
+  localInfo: Pick<ElectrobunUpdater["localInfo"], "channel" | "baseUrl">;
+};
+
+export interface ElectrobunDesktopUpdater {
+  check(currentVersion: string): Promise<UpdateCheckResult>;
+  /** Downloads and stages the update, ending in `ready`. It never relaunches the app. */
+  download(currentVersion: string, onProgress: (progress: UpdateProgress) => void): Promise<void>;
+  /**
+   * Installs the staged update, which quits the app and relaunches it. Only the
+   * user's Restart gets here. A repeat request while one is running, or after it
+   * succeeded and the app is quitting, does nothing.
+   */
+  apply(onProgress: (progress: UpdateProgress) => void): Promise<void>;
+}
 
 function desktopReleasePlatformPrefix(channel: string): string {
   const os = process.platform === "darwin" ? "macos" : process.platform === "win32" ? "win" : "linux";
@@ -14,24 +37,6 @@ function desktopReleasePlatformPrefix(channel: string): string {
   return `${channel}-${os}-${arch}`;
 }
 
-async function desktopReleaseInfo(updateInfo: {
-  version?: string;
-  hash?: string;
-}, currentVersion: string): Promise<ReleaseInfo> {
-  const [channel, baseUrl] = await Promise.all([
-    Electrobun.Updater.localInfo.channel(),
-    Electrobun.Updater.localInfo.baseUrl(),
-  ]);
-  const version = updateInfo.version || currentVersion;
-  return {
-    version,
-    tagName: `v${version}`,
-    downloadUrl: `${baseUrl.replace(/\/+$/, "")}/${desktopReleasePlatformPrefix(channel)}-update.json`,
-    publishedAt: "",
-    updateAction: { kind: "desktop" },
-  };
-}
-
 function mapDesktopUpdateStatus(entry: UpdateStatusEntry): UpdateProgress | null {
   const progress = entry.details?.progress;
   switch (entry.status) {
@@ -55,12 +60,13 @@ function mapDesktopUpdateStatus(entry: UpdateStatusEntry): UpdateProgress | null
     case "extracting-version":
     case "patch-chain-complete":
     case "decompressing":
-    case "download-complete":
     case "applying":
     case "extracting":
     case "replacing-app":
     case "launching-new-version":
       return { phase: "replacing" };
+    // `download-complete` is left out: the download flow reports `ready` itself,
+    // once `updateInfo().updateReady` confirms it.
     case "complete":
       return { phase: "done", message: "Update installed, restarting..." };
     case "error":
@@ -73,90 +79,178 @@ function mapDesktopUpdateStatus(entry: UpdateStatusEntry): UpdateProgress | null
   }
 }
 
-export async function checkElectrobunDesktopUpdate(currentVersion: string): Promise<UpdateCheckResult> {
-  try {
+export function createElectrobunDesktopUpdater(updater: ElectrobunUpdaterApi): ElectrobunDesktopUpdater {
+  let downloadInProgress = false;
+  /**
+   * The release whose download finished and waits for the user's Restart. Kept
+   * here rather than read back from Electrobun: its updater replaces the object
+   * that carries `updateReady` on every update check, so one hourly check would
+   * make a later `applyUpdate()` do nothing.
+   */
+  let readyRelease: ReleaseInfo | null = null;
+  /** An apply is under way, or finished and the app is quitting. */
+  let applyInProgress = false;
+
+  async function releaseInfo(updateInfo: { version?: string; hash?: string }, currentVersion: string): Promise<ReleaseInfo> {
     const [channel, baseUrl] = await Promise.all([
-      Electrobun.Updater.localInfo.channel(),
-      Electrobun.Updater.localInfo.baseUrl(),
+      updater.localInfo.channel(),
+      updater.localInfo.baseUrl(),
     ]);
-    if (channel === "dev" || !baseUrl) {
-      return { kind: "disabled" };
-    }
-
-    const info = await Electrobun.Updater.checkForUpdate();
-    if (info.error) {
-      return { kind: "error", error: info.error };
-    }
-    if (!info.updateAvailable) {
-      return { kind: "current" };
-    }
-
+    const version = updateInfo.version || currentVersion;
     return {
-      kind: "available",
-      release: await desktopReleaseInfo(info, currentVersion),
-    };
-  } catch (error) {
-    return {
-      kind: "error",
-      error: error instanceof Error ? error.message : "Desktop update check failed",
+      version,
+      tagName: `v${version}`,
+      downloadUrl: `${baseUrl.replace(/\/+$/, "")}/${desktopReleasePlatformPrefix(channel)}-update.json`,
+      publishedAt: "",
+      updateAction: { kind: "desktop" },
     };
   }
-}
 
-export async function runElectrobunDesktopUpdate(
-  currentVersion: string,
-  onProgress: (progress: UpdateProgress) => void,
-): Promise<void> {
-  if (desktopUpdateInProgress) {
-    onProgress({
-      phase: "error",
-      error: "A desktop update is already in progress.",
-    });
-    return;
-  }
+  async function check(currentVersion: string): Promise<UpdateCheckResult> {
+    // A downloaded update stays the answer until the user restarts into it, and
+    // asking Electrobun again would discard its ready flag.
+    if (readyRelease) return { kind: "available", release: readyRelease };
+    try {
+      const [channel, baseUrl] = await Promise.all([
+        updater.localInfo.channel(),
+        updater.localInfo.baseUrl(),
+      ]);
+      if (channel === "dev" || !baseUrl) {
+        return { kind: "disabled" };
+      }
 
-  desktopUpdateInProgress = true;
-  Electrobun.Updater.clearStatusHistory();
-  Electrobun.Updater.onStatusChange((entry) => {
-    const progress = mapDesktopUpdateStatus(entry);
-    if (progress) onProgress(progress);
-  });
-
-  try {
-    onProgress({ phase: "downloading", percent: 0 });
-    const result = await checkElectrobunDesktopUpdate(currentVersion);
-    if (result.kind === "error") {
-      onProgress({ phase: "error", error: result.error });
-      return;
+      const info = await updater.checkForUpdate();
+      if (info.error) {
+        return { kind: "error", error: info.error };
+      }
+      if (!info.updateAvailable) {
+        return { kind: "current" };
+      }
+
+      return {
+        kind: "available",
+        release: await releaseInfo(info, currentVersion),
+      };
+    } catch (error) {
+      return {
+        kind: "error",
+        error: error instanceof Error ? error.message : "Desktop update check failed",
+      };
     }
-    if (result.kind !== "available") {
+  }
+
+  async function download(
+    currentVersion: string,
+    onProgress: (progress: UpdateProgress) => void,
+  ): Promise<void> {
+    if (downloadInProgress) {
       onProgress({
-        phase: "done",
-        message: result.kind === "disabled" ? "Desktop updates are unavailable in this build" : "Already on the latest version",
+        phase: "error",
+        error: "A desktop update is already in progress.",
       });
       return;
     }
 
-    await Electrobun.Updater.downloadUpdate();
-    const updateInfo = Electrobun.Updater.updateInfo();
-    if (updateInfo?.error) {
-      onProgress({ phase: "error", error: updateInfo.error });
+    // Already downloaded, for instance after the window reloaded: say so
+    // instead of fetching again.
+    if (readyRelease) {
+      onProgress({ phase: "ready", canRestart: true });
       return;
     }
-    if (!updateInfo?.updateReady) {
-      onProgress({ phase: "error", error: "Desktop update did not finish downloading." });
+
+    downloadInProgress = true;
+    updater.clearStatusHistory();
+    updater.onStatusChange((entry) => {
+      const progress = mapDesktopUpdateStatus(entry);
+      if (progress) onProgress(progress);
+    });
+
+    try {
+      onProgress({ phase: "downloading", percent: 0 });
+      const result = await check(currentVersion);
+      if (result.kind === "error") {
+        onProgress({ phase: "error", error: result.error });
+        return;
+      }
+      if (result.kind !== "available") {
+        onProgress({
+          phase: "done",
+          message: result.kind === "disabled" ? "Desktop updates are unavailable in this build" : "Already on the latest version",
+        });
+        return;
+      }
+
+      await updater.downloadUpdate();
+      const updateInfo = updater.updateInfo();
+      if (updateInfo?.error) {
+        onProgress({ phase: "error", error: updateInfo.error });
+        return;
+      }
+      if (!updateInfo?.updateReady) {
+        onProgress({ phase: "error", error: "Desktop update did not finish downloading." });
+        return;
+      }
+
+      // Downloaded, not installed: applying relaunches the app, and that waits
+      // for the user's explicit request (`apply`).
+      readyRelease = result.release;
+      onProgress({ phase: "ready", canRestart: true });
+    } catch (error) {
+      onProgress({
+        phase: "error",
+        error: error instanceof Error ? error.message : "Desktop update failed",
+      });
+    } finally {
+      downloadInProgress = false;
+      updater.onStatusChange(null);
+    }
+  }
+
+  async function apply(onProgress: (progress: UpdateProgress) => void): Promise<void> {
+    if (applyInProgress || downloadInProgress) return;
+    if (!readyRelease || !updater.updateInfo()?.updateReady) {
+      readyRelease = null;
+      onProgress({ phase: "error", error: "The downloaded update is no longer available." });
       return;
     }
 
-    onProgress({ phase: "replacing" });
-    await Electrobun.Updater.applyUpdate();
-  } catch (error) {
-    onProgress({
-      phase: "error",
-      error: error instanceof Error ? error.message : "Desktop update failed",
+    applyInProgress = true;
+    let relaunching = false;
+    let reportedError = false;
+    const report = (progress: UpdateProgress) => {
+      if (progress.phase === "error") reportedError = true;
+      onProgress(progress);
+    };
+    updater.onStatusChange((entry) => {
+      if (entry.status === "launching-new-version" || entry.status === "complete") relaunching = true;
+      const progress = mapDesktopUpdateStatus(entry);
+      if (progress) report(progress);
     });
-  } finally {
-    desktopUpdateInProgress = false;
-    Electrobun.Updater.onStatusChange(null);
+
+    try {
+      report({ phase: "replacing" });
+      await updater.applyUpdate();
+      // Electrobun returns without a status when it cannot install, for example
+      // when a newer release replaced the one that was downloaded.
+      if (!relaunching && !reportedError) {
+        report({ phase: "error", error: "Desktop update could not be installed." });
+      }
+    } catch (error) {
+      report({
+        phase: "error",
+        error: error instanceof Error ? error.message : "Desktop update failed",
+      });
+    } finally {
+      updater.onStatusChange(null);
+    }
+
+    // Past this point the app is quitting, so the guard stays up. A failed apply
+    // drops the staged release: the retry starts from the download again.
+    if (!relaunching) {
+      readyRelease = null;
+      applyInProgress = false;
+    }
   }
+
+  return { check, download, apply };
 }

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

@@ -1,4 +1,4 @@
-import Electrobun, { ApplicationMenu } from "electrobun/bun";
+import Electrobun, { ApplicationMenu, Screen } from "electrobun/bun";
 import { debugLog } from "../../../utils/debug-log";
 import { setConfigStoreHost } from "../../../data/config/store";
 import * as nodeConfigStoreHost from "../../../data/config/store/node";
@@ -13,6 +13,14 @@ import {
 } from "./window/frame";
 import { MAIN_WINDOW_RPC_KEY } from "./window/focus";
 import { createAppWindow } from "./window/create";
+import { getWindowFrame } from "./window/events";
+import {
+  fitWindowFrameToDisplays,
+  readRememberedDesktopWindow,
+  rememberedDesktopWindowPath,
+  writeRememberedDesktopWindow,
+  type RememberedDesktopWindow,
+} from "./window/remembered-frame";
 import { reapStaleTerminalMedia } from "../../opentui/terminal-media";
 import { installProcessCrashListeners } from "../../../telemetry/crash-reports-node";
 
@@ -68,16 +76,75 @@ backend.installApplicationMenu();
 reapStaleTerminalMedia();
 
 const mainRpc = backend.createWindowRpc(MAIN_WINDOW_RPC_KEY);
-const initialMainWindowFrame = normalizeWindowFrameWithMinimum(
-  defaultMainWindowFrame(),
-  defaultMainWindowFrame(),
-  MAIN_WINDOW_MIN_SIZE,
+const rememberedWindowPath = rememberedDesktopWindowPath();
+const rememberedWindow = readRememberedDesktopWindow(rememberedWindowPath);
+const fallbackMainWindowFrame = defaultMainWindowFrame();
+const initialMainWindowFrame = fitWindowFrameToDisplays(
+  normalizeWindowFrameWithMinimum(rememberedWindow?.frame, fallbackMainWindowFrame, MAIN_WINDOW_MIN_SIZE),
+  readDisplayWorkAreas(),
 );
 
-backend.mainWindow = createAppWindow({
+let windowedFrame = initialMainWindowFrame;
+let rememberTimer: ReturnType<typeof setTimeout> | null = null;
+
+function readDisplayWorkAreas() {
+  try {
+    return Screen.getAllDisplays().map((display) => ({
+      x: display.workArea?.x ?? display.bounds.x,
+      y: display.workArea?.y ?? display.bounds.y,
+      width: display.workArea?.width ?? display.bounds.width,
+      height: display.workArea?.height ?? display.bounds.height,
+      primary: display.isPrimary,
+    }));
+  } catch {
+    return [];
+  }
+}
+
+function rememberedFromWindow(): RememberedDesktopWindow | null {
+  const window = backend.mainWindow;
+  const live = getWindowFrame(window) ?? windowedFrame;
+  let minimized = false;
+  let fullscreen = false;
+  let maximized = false;
+  try { minimized = window?.isMinimized() === true; } catch { minimized = false; }
+  if (minimized) return null;
+  try { fullscreen = window?.isFullScreen() === true; } catch { fullscreen = false; }
+  try { maximized = !fullscreen && window?.isMaximized() === true; } catch { maximized = false; }
+  if (!fullscreen && !maximized) windowedFrame = live;
+  return { frame: windowedFrame, maximized, fullscreen };
+}
+
+function flushRememberedWindow(): void {
+  if (rememberTimer) {
+    clearTimeout(rememberTimer);
+    rememberTimer = null;
+  }
+  const next = rememberedFromWindow();
+  if (next) writeRememberedDesktopWindow(rememberedWindowPath, next);
+}
+
+function scheduleRememberedWindow(): void {
+  if (rememberTimer) clearTimeout(rememberTimer);
+  rememberTimer = setTimeout(() => {
+    rememberTimer = null;
+    const next = rememberedFromWindow();
+    if (next) writeRememberedDesktopWindow(rememberedWindowPath, next);
+  }, 300);
+}
+
+const mainWindow = createAppWindow({
   title: "Gloomberb",
   frame: initialMainWindowFrame,
   rpc: mainRpc,
   minSize: MAIN_WINDOW_MIN_SIZE,
+  onFrameChange: scheduleRememberedWindow,
 });
+backend.mainWindow = mainWindow;
+if (rememberedWindow?.fullscreen) {
+  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 */ }
+}
+(mainWindow as { on?: (event: "close", listener: () => void) => void }).on?.("close", flushRememberedWindow);
 backend.detachedWindows.focusWindowForRpcKey(MAIN_WINDOW_RPC_KEY);

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

@@ -0,0 +1,122 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { getGloomberbDirs } from "../../../../data/config/home";
+import type { WindowFrame } from "./frame";
+
+/**
+ * The main window's last frame lives beside the config, not in it. Launch
+ * reads it before config is loaded, and a frame is this machine's screen,
+ * so it stays out of the synced config.
+ */
+const FILE_NAME = "desktop-window.json";
+
+export interface RememberedDesktopWindow {
+  frame: WindowFrame;
+  maximized: boolean;
+  fullscreen: boolean;
+}
+
+export interface DisplayWorkArea {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  primary?: boolean;
+}
+
+export function rememberedDesktopWindowPath(env: NodeJS.ProcessEnv = process.env): string {
+  return join(dirname(getGloomberbDirs(env).configFile), FILE_NAME);
+}
+
+export function parseRememberedDesktopWindow(raw: unknown): RememberedDesktopWindow | null {
+  if (!raw || typeof raw !== "object") return null;
+  const record = raw as Record<string, unknown>;
+  const frame = record.frame;
+  if (!frame || typeof frame !== "object") return null;
+  const { x, y, width, height } = frame as Record<string, unknown>;
+  if (![x, y, width, height].every((value) => typeof value === "number" && Number.isFinite(value))) return null;
+  if ((width as number) < 1 || (height as number) < 1) return null;
+  return {
+    frame: { x: x as number, y: y as number, width: width as number, height: height as number },
+    maximized: record.maximized === true,
+    fullscreen: record.fullscreen === true,
+  };
+}
+
+export function readRememberedDesktopWindow(path: string): RememberedDesktopWindow | null {
+  try {
+    return parseRememberedDesktopWindow(JSON.parse(readFileSync(path, "utf8")));
+  } catch {
+    return null;
+  }
+}
+
+export function writeRememberedDesktopWindow(path: string, value: RememberedDesktopWindow): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync(temporary, JSON.stringify(value));
+  renameSync(temporary, path);
+}
+
+function overlapArea(frame: WindowFrame, display: DisplayWorkArea): number {
+  const width = Math.min(frame.x + frame.width, display.x + display.width) - Math.max(frame.x, display.x);
+  const height = Math.min(frame.y + frame.height, display.y + display.height) - Math.max(frame.y, display.y);
+  return width > 0 && height > 0 ? width * height : 0;
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+/**
+ * Puts a saved frame on a connected display. A window that still intersects
+ * one stays put. One left on a display that is gone moves onto the display
+ * with the most overlap, or the primary display.
+ */
+export function fitWindowFrameToDisplays(
+  frame: WindowFrame,
+  displays: readonly DisplayWorkArea[],
+): WindowFrame {
+  const usable = displays.filter((display) => display.width >= 1 && display.height >= 1);
+  if (usable.length === 0) return frame;
+  const centerX = frame.x + frame.width / 2;
+  const centerY = frame.y + frame.height / 2;
+  const containing = usable.find((display) => (
+    centerX >= display.x && centerX < display.x + display.width
+    && centerY >= display.y && centerY < display.y + display.height
+  ));
+  let display = containing;
+  if (!display) {
+    let best = usable[0]!;
+    let bestArea = overlapArea(frame, best);
+    for (const candidate of usable.slice(1)) {
+      const area = overlapArea(frame, candidate);
+      if (area > bestArea) {
+        best = candidate;
+        bestArea = area;
+      }
+    }
+    display = bestArea > 0 ? best : usable.find((candidate) => candidate.primary) ?? usable[0]!;
+  }
+  const width = Math.min(frame.width, display.width);
+  const height = Math.min(frame.height, display.height);
+  // A window left on a display that is no longer connected comes back on the
+  // one that remains, at that display's left edge, keeping its vertical place.
+  if (overlapArea(frame, display) === 0) {
+    const minY = display.y;
+    const maxY = display.y + display.height - height;
+    return { x: display.x, y: clamp(frame.y, minY, Math.max(minY, maxY)), width, height };
+  }
+  const marginX = Math.min(48, width);
+  const marginY = Math.min(48, height);
+  const minX = display.x + marginX - width;
+  const maxX = display.x + display.width - marginX;
+  const minY = display.y;
+  const maxY = display.y + display.height - marginY;
+  return {
+    x: width === display.width ? display.x : clamp(frame.x, minX, Math.max(minX, maxX)),
+    y: height === display.height ? display.y : clamp(frame.y, minY, Math.max(minY, maxY)),
+    width,
+    height,
+  };
+}

package/src/renderers/electrobun/shared/protocol.ts

@@ -209,7 +209,10 @@ interface DesktopBackendRequestMap {
   };
   "host.showContextMenu": { request: { menu: DesktopContextMenuItem[] }; response: boolean };
   "update.check": { request: { currentVersion: string }; response: UpdateCheckResult };
+  /** Downloads and stages the update. It ends in `ready` and never relaunches the app. */
   "update.start": { request: { release: ReleaseInfo; currentVersion?: string }; response: null };
+  /** Installs the staged update and relaunches. Sent only when the user presses Restart. */
+  "update.apply": { request: null; response: null };
   "ticker.loadAll": { request: null; response: TickerRecord[] };
   "ticker.load": { request: { symbol: string }; response: TickerRecord | null };
   "ticker.save": { request: { ticker: TickerRecord }; response: null };

package/src/renderers/electrobun/view/backend-rpc.ts

@@ -14,7 +14,8 @@ import {
 } from "../shared/protocol";
 import { decodeRpcResponse, decodeRpcValue, encodeRpcValue } from "../shared/rpc-codec";
 import { subscribeCapability, type CapabilitySubscriptionOptions } from "./capability-subscription";
-import { nameRpcTimeout } from "./rpc-timeout";
+import { RpcTimeoutError } from "../../../utils/rpc-timeout-error";
+import { nameRpcTimeout, RPC_MAX_REQUEST_TIME_MS } from "./rpc-timeout";
 import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
 
 type BackendMessages = ElectrobunDesktopRpcSchema["webview"]["messages"];
@@ -43,7 +44,7 @@ function emit<K extends BackendMessageName>(name: K, message: BackendMessages[K]
 }
 
 const rpc = Electroview.defineRPC<ElectrobunDesktopRpcSchema>({
-  maxRequestTime: 120_000,
+  maxRequestTime: RPC_MAX_REQUEST_TIME_MS,
   handlers: {
     requests: {
       "remote.request": async (message: RemoteControlRequestMessage) => {
@@ -107,15 +108,20 @@ const rpc = Electroview.defineRPC<ElectrobunDesktopRpcSchema>({
 
 const electroview = new Electroview({ rpc });
 
+const BRIDGE_READY_LIMIT_MS = 5_000;
+
 async function waitForBridgeReady(): Promise<void> {
   const start = Date.now();
-  while (Date.now() - start < 5_000) {
+  while (Date.now() - start < BRIDGE_READY_LIMIT_MS) {
     if (electroview.bunSocket?.readyState === WebSocket.OPEN) {
       return;
     }
     await new Promise((resolve) => setTimeout(resolve, 25));
   }
-  throw new Error("Electrobun RPC socket did not open in time.");
+  throw new RpcTimeoutError("Electrobun RPC socket did not open in time.", {
+    elapsedMs: Date.now() - start,
+    limitMs: BRIDGE_READY_LIMIT_MS,
+  });
 }
 
 export function backendRequest<T = unknown>(

package/src/renderers/electrobun/view/cli-pane-shot-entry.tsx

@@ -436,12 +436,14 @@ function ShotPane({ payload, registry }: { payload: DesktopPaneShotPayload; regi
   const title = getPaneDisplayTitle(titleState, instance, pane, registry.panes);
   const width = payload.widthCells;
   const height = payload.heightCells;
+  // PORT keeps what its basket covers, so a capture never reads as the whole account.
   return (
-    <PaneShotFrame paneId={instance.instanceId} title={title} width={width} height={height} preserveStatus={["time-sales", "gpu", "hiring", "apps", "catalysts", "litigation", "perps"].includes(pane.id)}>
+    <PaneShotFrame paneId={instance.instanceId} title={title} width={width} height={height} preserveStatus={["time-sales", "gpu", "hiring", "apps", "catalysts", "litigation", "perps", "members", "analytics"].includes(pane.id)}>
       {(bodyFrame) => <PaneContent
         component={pane.component}
         paneId={instance.instanceId}
         paneType={instance.paneId}
+        title={title}
         focused
         width={bodyFrame.width ?? 1}
         height={bodyFrame.height ?? 1}

package/src/renderers/electrobun/view/main.tsx

@@ -26,6 +26,7 @@ import { installElectrobunWindowFullscreenTracking } from "./window-fullscreen";
 import { installDomMarketDataFrames } from "../../dom/data-frames";
 import { DomErrorBoundary, DomHostProviders } from "../../dom/dom-host-providers";
 import { DesktopFatalScreen } from "./fatal-screen";
+import { resolveRendererWindowError } from "./renderer-window-error";
 import { createWebUiHost, webRendererHost } from "./ui-host";
 import {
   initializeDesktopResearchActivity,
@@ -83,7 +84,12 @@ function renderFatalError(error: unknown, details?: string, title = "Gloomberb f
 }
 
 window.__gloomRenderFatalError = (error, details, source) => {
-  if (appMounted && source === "unhandledrejection") {
+  if (resolveRendererWindowError({
+    error,
+    details,
+    source,
+    appMounted,
+  }) === "ignore") {
     return;
   }
   renderFatalError(error, details, "Gloomberb crashed");

package/src/renderers/electrobun/view/renderer-window-error.ts

@@ -0,0 +1,18 @@
+import { isBenignWindowError } from "../../../telemetry/benign-window-error";
+
+export type RendererWindowErrorDecision = "fatal" | "ignore";
+
+export function resolveRendererWindowError(input: {
+  error: unknown;
+  details?: string;
+  source?: string;
+  appMounted: boolean;
+}): RendererWindowErrorDecision {
+  if (isBenignWindowError(input.error) || isBenignWindowError(input.details)) {
+    return "ignore";
+  }
+  if (input.appMounted && input.source === "unhandledrejection") {
+    return "ignore";
+  }
+  return "fatal";
+}