gloomberb 0.7.4 → 0.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Bloomberg-style stock portfolio tracker for the terminal",
   "module": "src/index.tsx",
   "type": "module",

package/src/app.tsx

@@ -40,7 +40,7 @@ import {
   type PaneBinding,
   type PaneInstanceConfig,
 } from "./types/config";
-import type { CliLaunchRequest, PaneTemplateCreateOptions, PaneTemplateInstanceConfig, WizardStep } from "./types/plugin";
+import type { CliLaunchRequest, PaneTemplateCreateOptions, PaneTemplateInstanceConfig, PinTickerOptions, WizardStep } from "./types/plugin";
 import type { PaneSettingField } from "./types/plugin";
 import type { TickerRecord } from "./types/ticker";
 import type { DataProvider } from "./types/data-provider";
@@ -48,7 +48,7 @@ import type { TickerFinancials } from "./types/financials";
 import type { BrokerAccount } from "./types/trading";
 import type { DesktopDockPreviewState, DesktopSharedStateSnapshot, DesktopThemePreviewState, DesktopWindowBridge } from "./types/desktop-window";
 import type { DesktopApplicationMenuBridge } from "./types/desktop-menu";
-import { resolveTickerSearch, upsertTickerFromSearchResult } from "./utils/ticker-search";
+import { resolveTickerOpenTarget, type TickerOpenTarget } from "./utils/ticker-search";
 
 import {
   clearPersistedBrokerAccounts,
@@ -70,6 +70,7 @@ import {
   gridlockAllPanes,
   isPaneInLayout,
   removePane,
+  type LayoutBounds,
 } from "./plugins/pane-manager";
 import { notifyGridlockComplete } from "./plugins/gridlock-notification";
 import {
@@ -206,6 +207,7 @@ function AppInner({
   const isDetachedWindow = desktopWindowBridge?.kind === "detached";
   const detachedPaneId = isDetachedWindow ? desktopWindowBridge.paneId ?? null : null;
   const [desktopDockPreview, setDesktopDockPreview] = useState<DesktopDockPreviewState | null>(null);
+  const [commandBarNativeOccluder, setCommandBarNativeOccluder] = useState<LayoutBounds | null>(null);
   appActiveRef.current = appActive;
   const appNotifier = useMemo(() => createAppNotifier({
     isAppActive: () => appActiveRef.current,
@@ -1359,14 +1361,45 @@ function AppInner({
 
     focusVisiblePane(instanceId);
   };
-  pluginRegistry.pinTickerFn = (symbol, options) => {
-    if (isDetachedWindow) return;
+  const resolveOpenTickerTarget = async (rawSymbol: string): Promise<TickerOpenTarget | null> => {
+    try {
+      const target = await resolveTickerOpenTarget({
+        query: rawSymbol,
+        tickers: stateRef.current.tickers,
+        dataProvider,
+        tickerRepository,
+      });
+      if (!target) {
+        pluginRegistry.notify({ body: `Could not open ${rawSymbol}.`, type: "error" });
+      }
+      return target;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      pluginRegistry.notify({ body: `Failed to open ${rawSymbol}: ${message}`, type: "error" });
+      return null;
+    }
+  };
+  const publishTickerOpenTarget = (target: TickerOpenTarget) => {
+    const currentTicker = stateRef.current.tickers.get(target.symbol);
+    if (currentTicker !== target.ticker) {
+      dispatch({ type: "UPDATE_TICKER", ticker: target.ticker });
+    }
+    if (target.created) {
+      pluginRegistry.events.emit("ticker:added", { symbol: target.symbol, ticker: target.ticker });
+    }
+  };
+  const placePinnedTickerTarget = (target: TickerOpenTarget, options?: PinTickerOptions) => {
     const paneType = options?.paneType ?? "ticker-detail";
     const paneDef = pluginRegistry.panes.get(paneType);
     if (!paneDef) return;
+
+    publishTickerOpenTarget(target);
+    const symbol = target.symbol;
+    const currentState = stateRef.current;
+    const currentLayout = currentState.config.layout;
     const existing = options?.forceNewPane
       ? null
-      : findFixedTickerPaneForSymbol(state.config.layout, paneType, symbol);
+      : findFixedTickerPaneForSymbol(currentLayout, paneType, symbol);
     if (existing) {
       focusVisiblePane(existing.instanceId);
       return;
@@ -1379,45 +1412,38 @@ function AppInner({
     const { width, height } = pluginRegistry.getTermSizeFn();
     const shouldFloat = options?.floating ?? true;
     const nextLayout = shouldFloat
-      ? addPaneFloating(state.config.layout, instance, width, height, paneDef)
+      ? addPaneFloating(currentLayout, instance, width, height, paneDef)
       : addPaneToLayout(
-        state.config.layout,
+        currentLayout,
         instance,
         {
-          relativeTo: state.focusedPaneId && isPaneInLayout(state.config.layout, state.focusedPaneId)
-            ? state.focusedPaneId
-            : (getDockedPaneIds(state.config.layout).at(-1) ?? instance.instanceId),
+          relativeTo: currentState.focusedPaneId && isPaneInLayout(currentLayout, currentState.focusedPaneId)
+            ? currentState.focusedPaneId
+            : (getDockedPaneIds(currentLayout).at(-1) ?? instance.instanceId),
           position: "right",
         },
       );
     persistLayout(nextLayout);
     activatePane(instance.instanceId, nextLayout);
   };
+  const openPinnedTicker = async (rawSymbol: string, options?: PinTickerOptions) => {
+    const target = await resolveOpenTickerTarget(rawSymbol);
+    if (!target) return;
+    placePinnedTickerTarget(target, options);
+  };
+  pluginRegistry.pinTickerFn = (symbol, options) => {
+    if (isDetachedWindow) return;
+    void openPinnedTicker(symbol, options);
+  };
 
   pluginRegistry.navigateTickerFn = (rawSymbol, options) => {
     if (isDetachedWindow) return;
     const sourcePaneId = options?.sourcePaneId ?? stateRef.current.focusedPaneId;
     (async () => {
       try {
-        // Resolve or create the ticker in the local database
-        const resolved = await resolveTickerSearch({
-          query: rawSymbol,
-          activeTicker: null,
-          tickers: stateRef.current.tickers,
-          dataProvider,
-        });
-
-        let symbol = rawSymbol;
-        if (resolved?.kind === "local") {
-          symbol = resolved.symbol;
-        } else if (resolved?.kind === "provider" && resolved.result) {
-          const { ticker, created } = await upsertTickerFromSearchResult(tickerRepository, resolved.result);
-          symbol = ticker.metadata.ticker;
-          dispatch({ type: "UPDATE_TICKER", ticker });
-          if (created) {
-            pluginRegistry.events.emit("ticker:added", { symbol, ticker });
-          }
-        }
+        const target = await resolveOpenTickerTarget(rawSymbol);
+        if (!target) return;
+        const symbol = target.symbol;
 
         // Only actions that originate from a ticker detail replace that exact pane.
         // Everything else opens or focuses a fixed ticker detail for the symbol.
@@ -1436,6 +1462,7 @@ function AppInner({
         };
 
         if (detailPane) {
+          publishTickerOpenTarget(target);
           const nextLayout = {
             ...currentLayout,
             instances: currentLayout.instances.map((instance) => (
@@ -1451,7 +1478,7 @@ function AppInner({
           currentFocusedPaneId: stateRef.current.focusedPaneId,
           targetPaneId: null,
         })) {
-          pluginRegistry.pinTicker(symbol, { floating: false });
+          placePinnedTickerTarget(target, { floating: false });
         }
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -1618,6 +1645,7 @@ function AppInner({
           pluginRegistry={pluginRegistry}
           desktopWindowBridge={desktopWindowBridge}
           desktopDockPreview={desktopDockPreview}
+          commandBarNativeOccluder={commandBarNativeOccluder}
         />
         <StatusBar />
         {state.commandBarOpen && (
@@ -1627,6 +1655,7 @@ function AppInner({
             pluginRegistry={pluginRegistry}
             quitApp={() => rendererHost.requestExit()}
             onCheckForUpdates={() => runUpdateCheck(true)}
+            onNativeOccluderChange={setCommandBarNativeOccluder}
           />
         )}
         <ToastViewport position="bottom-right" />

package/src/components/command-bar/command-bar.tsx

@@ -73,8 +73,10 @@ import {
   movePaneRelative,
   removePane,
   swapPanes,
+  type LayoutBounds,
 } from "../../plugins/pane-manager";
 import { notifyGridlockComplete } from "../../plugins/gridlock-notification";
+import { resolveAppHeaderHeightCells } from "../layout/shell";
 import { CHART_RENDERER_PREFERENCES } from "../chart/chart-types";
 import {
   getEmptyState,
@@ -168,6 +170,7 @@ interface CommandBarProps {
   pluginRegistry: PluginRegistry;
   quitApp: () => void;
   onCheckForUpdates?: () => void | Promise<void>;
+  onNativeOccluderChange?: (rect: LayoutBounds | null) => void;
 }
 
 type WorkflowStringValues = Record<string, string>;
@@ -645,6 +648,7 @@ export function CommandBar({
   pluginRegistry,
   quitApp,
   onCheckForUpdates,
+  onNativeOccluderChange,
 }: CommandBarProps) {
   const dispatch = useAppDispatch();
   const themeColors = useThemeColors();
@@ -709,7 +713,7 @@ export function CommandBar({
   }, []);
   const { symbol: activeTickerSymbol, ticker: activeTickerData, financials: activeFinancials } = useFocusedTicker();
   const { width: termWidth, height: termHeight } = useViewport();
-  const { nativePaneChrome, cellWidthPx = 8, cellHeightPx = 18 } = useUiCapabilities();
+  const { nativePaneChrome, cellWidthPx = 8, cellHeightPx = 18, titleBarOverlay } = useUiCapabilities();
   const availableCommands = useMemo(
     () => nativePaneChrome
       ? commands.filter((command) => command.id !== "cycle-chart-renderer")
@@ -5390,6 +5394,13 @@ export function CommandBar({
     : bodyHeight + 7;
   const barLeft = Math.max(4, Math.floor((termWidth - barWidth) / 2));
   const barTop = Math.max(1, Math.floor((termHeight - barHeight) / 2));
+  const appHeaderHeight = resolveAppHeaderHeightCells({ titleBarOverlay, cellHeightPx });
+  const nativeOccluderRect = useMemo<LayoutBounds>(() => ({
+    x: barLeft,
+    y: barTop - appHeaderHeight,
+    width: barWidth,
+    height: barHeight,
+  }), [appHeaderHeight, barHeight, barLeft, barTop, barWidth]);
   const resultsInnerWidth = Math.max(12, barWidth - nativePanelPaddingColumns - contentPadding * 2);
   const trailingWidth = Math.max(8, Math.min(12, Math.floor(resultsInnerWidth * 0.18)));
   const labelWidth = Math.max(10, resultsInnerWidth - trailingWidth);
@@ -5419,6 +5430,13 @@ export function CommandBar({
     }
   }, [listBodyHeight, selectedScrollRowIndex, visibleListState?.kind, visibleListState?.query]);
 
+  useLayoutEffect(() => {
+    onNativeOccluderChange?.(nativeOccluderRect);
+    return () => {
+      onNativeOccluderChange?.(null);
+    };
+  }, [nativeOccluderRect, onNativeOccluderChange]);
+
   useEffect(() => {
     if (!nativePaneChrome || currentRoute?.kind !== "workflow") return;
     const scrollBox = workflowScrollRef.current;

package/src/components/layout/shell.test.tsx

@@ -560,6 +560,32 @@ describe("Shell", () => {
     ]);
   });
 
+  test("keeps command bar native occlusion scoped to the panel", () => {
+    const state = buildNativeWindowState(
+      ["portfolio-list:main"],
+      [],
+      null,
+      { open: false, width: 120, contentHeight: 40 },
+      [
+        {
+          id: "command-bar:panel",
+          rect: { x: 24, y: 8, width: 72, height: 14 },
+          zIndex: Number.MAX_SAFE_INTEGER,
+        },
+      ],
+    );
+
+    expect(state.occluders).toEqual([
+      {
+        id: "command-bar:panel",
+        paneId: null,
+        rect: { x: 24, y: 9, width: 72, height: 14 },
+        zIndex: Number.MAX_SAFE_INTEGER,
+      },
+    ]);
+    expect(state.occluders.some((occluder) => occluder.id === "overlay:global")).toBe(false);
+  });
+
   test("adds dock dividers as global native occluders", () => {
     const state = buildNativeWindowState(
       ["left:main", "right:main"],

package/src/components/layout/shell.tsx

@@ -76,6 +76,7 @@ interface ShellProps {
   pluginRegistry: PluginRegistry;
   desktopWindowBridge?: DesktopWindowBridge;
   desktopDockPreview?: DesktopDockPreviewState | null;
+  commandBarNativeOccluder?: LayoutBounds | null;
 }
 
 interface HoverOverlay {
@@ -192,6 +193,7 @@ const DEFAULT_HEADER_HEIGHT = 1;
 const MENU_MIN_WIDTH = 18;
 const MENU_MAX_WIDTH = 44;
 const MENU_Z_INDEX = 10_000;
+const DOCK_DIVIDER_SIZE = 1;
 const PANE_DRAG_THRESHOLD = 2;
 const PRECISE_PANE_DRAG_THRESHOLD = 0.15;
 const PANE_MANAGEMENT_ACCELERATORS = {
@@ -498,6 +500,39 @@ export function resolveNativeDockDividers(
   ));
 }
 
+function resolveDividerPreviewRect(
+  axis: "horizontal" | "vertical",
+  bounds: LayoutBounds,
+  ratio: number,
+  nativePaneChrome: boolean,
+): LayoutBounds {
+  if (axis === "horizontal") {
+    const offset = nativePaneChrome
+      ? bounds.width * ratio
+      : bounds.width > DOCK_DIVIDER_SIZE
+        ? Math.round((bounds.width - DOCK_DIVIDER_SIZE) * ratio)
+        : Math.max(0, Math.round(bounds.width * ratio) - DOCK_DIVIDER_SIZE);
+    return {
+      x: nativePaneChrome ? bounds.x + offset - (DOCK_DIVIDER_SIZE / 2) : bounds.x + offset,
+      y: bounds.y,
+      width: DOCK_DIVIDER_SIZE,
+      height: bounds.height,
+    };
+  }
+
+  const offset = nativePaneChrome
+    ? bounds.height * ratio
+    : bounds.height > DOCK_DIVIDER_SIZE
+      ? Math.round((bounds.height - DOCK_DIVIDER_SIZE) * ratio)
+      : Math.max(0, Math.round(bounds.height * ratio) - DOCK_DIVIDER_SIZE);
+  return {
+    x: bounds.x,
+    y: nativePaneChrome ? bounds.y + offset - (DOCK_DIVIDER_SIZE / 2) : bounds.y + offset,
+    width: bounds.width,
+    height: DOCK_DIVIDER_SIZE,
+  };
+}
+
 export function finalizePaneDragRelease(
   layout: LayoutConfig,
   paneId: string,
@@ -789,7 +824,12 @@ function resolveExternalDockPreview(
   }
 }
 
-export function Shell({ pluginRegistry, desktopWindowBridge, desktopDockPreview }: ShellProps) {
+export function Shell({
+  pluginRegistry,
+  desktopWindowBridge,
+  desktopDockPreview,
+  commandBarNativeOccluder = null,
+}: ShellProps) {
   useThemeColors();
   const dispatch = useAppDispatch();
   const config = useAppSelector((state) => state.config);
@@ -1047,7 +1087,9 @@ export function Shell({ pluginRegistry, desktopWindowBridge, desktopDockPreview
     event.stopPropagation();
   });
 
-  const dockGeometryOptions = useMemo(() => (nativePaneChrome ? { precise: true } : undefined), [nativePaneChrome]);
+  const dockGeometryOptions = useMemo(() => (
+    nativePaneChrome ? { precise: true } : { reserveDividerGutters: true }
+  ), [nativePaneChrome]);
   const dockLeafLayouts = useMemo(() => getDockLeafLayouts(visibleLayout, bounds, dockGeometryOptions), [bounds, dockGeometryOptions, visibleLayout]);
   const dockDividerLayouts = useMemo(() => getDockDividerLayouts(visibleLayout, bounds, dockGeometryOptions), [bounds, dockGeometryOptions, visibleLayout]);
   const snapGuides = useMemo(() => makeSnapGuides(width, contentHeight), [contentHeight, width]);
@@ -1092,8 +1134,29 @@ export function Shell({ pluginRegistry, desktopWindowBridge, desktopDockPreview
       });
     }
 
+    if (menuState) {
+      occluders.push({
+        id: `pane-menu:${menuState.paneId}`,
+        rect: {
+          x: menuState.x,
+          y: menuState.y,
+          width: menuState.width,
+          height: menuState.items.length + 2,
+        },
+        zIndex: MENU_Z_INDEX,
+      });
+    }
+
+    if (commandBarNativeOccluder) {
+      occluders.push({
+        id: "command-bar:panel",
+        rect: commandBarNativeOccluder,
+        zIndex: Number.MAX_SAFE_INTEGER,
+      });
+    }
+
     return occluders;
-  }, [activeHoverOverlay, activePaneDrag, dragFloatingRect, effectiveDockPreview]);
+  }, [activeHoverOverlay, activePaneDrag, commandBarNativeOccluder, dragFloatingRect, effectiveDockPreview, menuState]);
   const nativeDockDividers = useMemo(
     () => resolveNativeDockDividers(dockDividerLayouts, dividerPreview),
     [dividerPreview, dockDividerLayouts],
@@ -1107,12 +1170,12 @@ export function Shell({ pluginRegistry, desktopWindowBridge, desktopDockPreview
         zIndex: pane.floating?.zIndex ?? 50,
       })),
       dragFloatingRect,
-      { open: overlayOpen, width, contentHeight },
+      { open: dialogOpen, width, contentHeight },
       nativeTransientOccluders,
       nativeDockDividers,
       appHeaderHeight,
     ),
-    [appHeaderHeight, contentHeight, dockedPanes, dragFloatingRect, nativeDockDividers, nativeTransientOccluders, overlayOpen, visibleFloatingPanes, width],
+    [appHeaderHeight, contentHeight, dialogOpen, dockedPanes, dragFloatingRect, nativeDockDividers, nativeTransientOccluders, visibleFloatingPanes, width],
   );
 
   useEffect(() => {
@@ -1194,22 +1257,7 @@ export function Shell({ pluginRegistry, desktopWindowBridge, desktopDockPreview
         const total = drag.axis === "horizontal" ? drag.bounds.width : drag.bounds.height;
         const delta = drag.axis === "horizontal" ? preciseX - drag.startX : preciseShellY - drag.startY;
         const nextRatio = Math.max(0.1, Math.min(0.9, drag.startRatio + (delta / Math.max(1, total))));
-        const offset = drag.axis === "horizontal"
-          ? drag.bounds.width * nextRatio
-          : drag.bounds.height * nextRatio;
-        const nextRect = drag.axis === "horizontal"
-          ? {
-            x: nativePaneChrome ? drag.bounds.x + offset - 0.5 : drag.bounds.x + Math.round(offset) - 1,
-            y: drag.bounds.y,
-            width: 1,
-            height: drag.bounds.height,
-          }
-          : {
-            x: drag.bounds.x,
-            y: nativePaneChrome ? drag.bounds.y + offset - 0.5 : drag.bounds.y + Math.round(offset) - 1,
-            width: drag.bounds.width,
-            height: 1,
-          };
+        const nextRect = resolveDividerPreviewRect(drag.axis, drag.bounds, nextRatio, nativePaneChrome);
         updateDividerPreview({ pathKey: drag.path.join("."), rect: nextRect, ratio: nextRatio });
       } else if (drag.type === "pane-drag") {
         if (!isMeaningfulPaneDrag(drag.startX, drag.startY, preciseX, preciseShellY, dragThreshold)) {

package/src/plugins/builtin/holders/index.test.ts

@@ -1,12 +1,22 @@
-import { expect, test } from "bun:test";
+import { afterEach, expect, test } from "bun:test";
 import {
   buildTreemap,
   buildTreemapRects,
   formatHolderOwnershipPercent,
   resolveHolderOwnershipPercent,
+  tileTextColor,
 } from "./index";
+import { applyTheme, colors } from "../../../theme/colors";
+import { contrastRatio } from "../../../theme/color-utils";
+import { DEFAULT_THEME, themes } from "../../../theme/themes";
 import type { HolderRecord } from "../../../types/financials";
 
+const TILE_TEXT_MIN_CONTRAST = 4.5;
+
+afterEach(() => {
+  applyTheme(DEFAULT_THEME);
+});
+
 function holder(name: string, value: number): HolderRecord & { id: string } {
   return {
     id: name,
@@ -55,3 +65,22 @@ test("resolves holder ownership from provider percent before value over market c
   expect(resolveHolderOwnershipPercent({ value: 120 }, undefined)).toBeUndefined();
   expect(formatHolderOwnershipPercent(0.085)).toBe("8.50%");
 });
+
+test("keeps holder treemap text readable on semantic tile backgrounds", () => {
+  for (const themeId of Object.keys(themes)) {
+    applyTheme(themeId);
+    const backgrounds = {
+      positive: colors.positive,
+      negative: colors.negative,
+      neutral: colors.neutral,
+      selected: colors.selected,
+    };
+
+    for (const [name, background] of Object.entries(backgrounds)) {
+      expect(
+        contrastRatio(tileTextColor(background), background),
+        `${themeId} ${name}`,
+      ).toBeGreaterThanOrEqual(TILE_TEXT_MIN_CONTRAST);
+    }
+  }
+});

package/src/plugins/builtin/holders/index.tsx

@@ -11,7 +11,7 @@ import {
 } from "../../../components";
 import { useShortcut } from "../../../react/input";
 import { blendHex, colors, priceColor } from "../../../theme/colors";
-import { higherContrast } from "../../../theme/color-utils";
+import { blendForContrast, higherContrast } from "../../../theme/color-utils";
 import type { HolderData, HolderRecord } from "../../../types/financials";
 import type { GloomPlugin } from "../../../types/plugin";
 import { formatCompact, formatPercent, formatPercentRaw, padTo } from "../../../utils/format";
@@ -447,12 +447,16 @@ function desktopTileColor(row: HolderRow): string {
   return blendHex(colors.panel, row.changePercent > 0 ? colors.positive : colors.negative, intensity);
 }
 
-function tileTextColor(backgroundColor: string): string {
-  return higherContrast(
+const TILE_TEXT_MIN_CONTRAST = 4.5;
+
+export function tileTextColor(backgroundColor: string): string {
+  const preferred = higherContrast(
     higherContrast(colors.text, colors.textBright, backgroundColor),
     colors.selectedText,
     backgroundColor,
   );
+  const fallback = higherContrast("#000000", "#ffffff", backgroundColor);
+  return blendForContrast(preferred, backgroundColor, fallback, TILE_TEXT_MIN_CONTRAST);
 }
 
 function Tile({ tile, selected, currency, marketCap, onSelect }: {

package/src/plugins/pane-manager.test.ts

@@ -5,6 +5,8 @@ import {
   applyDrop,
   floatAtRect,
   gridlockAllPanes,
+  getDockDividerLayouts,
+  getDockLeafLayouts,
   getDockedPaneIds,
   getLeafRect,
   simulateDrop,
@@ -44,6 +46,35 @@ describe("pane-manager split-tree drops", () => {
     expect(getDockedPaneIds(next)).toContain(notesPane.instanceId);
   });
 
+  test("can reserve a gutter for dock dividers without overlapping pane rects", () => {
+    const layout = {
+      dockRoot: {
+        kind: "split" as const,
+        axis: "horizontal" as const,
+        ratio: 0.5,
+        first: { kind: "pane" as const, instanceId: "left:main" },
+        second: { kind: "pane" as const, instanceId: "right:main" },
+      },
+      instances: [
+        createPaneInstance("left", { instanceId: "left:main" }),
+        createPaneInstance("right", { instanceId: "right:main" }),
+      ],
+      floating: [],
+      detached: [],
+    };
+
+    const leaves = getDockLeafLayouts(layout, BOUNDS, { reserveDividerGutters: true });
+    const divider = getDockDividerLayouts(layout, BOUNDS, { reserveDividerGutters: true })[0];
+    const left = leaves.find((leaf) => leaf.instanceId === "left:main");
+    const right = leaves.find((leaf) => leaf.instanceId === "right:main");
+
+    expect(left).toBeDefined();
+    expect(right).toBeDefined();
+    expect(divider).toBeDefined();
+    expect(divider!.rect.x).toBe(left!.rect.x + left!.rect.width);
+    expect(right!.rect.x).toBe(divider!.rect.x + divider!.rect.width);
+  });
+
   test("splits the hovered pane on leaf drops and matches the preview", () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");
     const notesPane = createPaneInstance("chat");

package/src/plugins/pane-manager.ts

@@ -84,6 +84,7 @@ export interface DockDividerLayout {
 export interface DockGeometryOptions {
   precise?: boolean;
   dividerSize?: number;
+  reserveDividerGutters?: boolean;
 }
 
 export interface LayoutSimulation {
@@ -430,18 +431,31 @@ function collectDockGeometry(
 
   const precise = options.precise === true;
   const dividerSize = options.dividerSize ?? 1;
+  const reserveDividerGutters = options.reserveDividerGutters === true && !precise;
 
   if (node.axis === "horizontal") {
-    const [firstWidth, secondWidth] = resolveSplitSizes(bounds.width, node.ratio, MIN_PANE_WIDTH, precise);
+    const reserveDividerGutter = reserveDividerGutters && bounds.width > dividerSize;
+    const splitWidth = reserveDividerGutter ? bounds.width - dividerSize : bounds.width;
+    const [firstWidth, secondWidth] = resolveSplitSizes(splitWidth, node.ratio, MIN_PANE_WIDTH, precise);
     const firstBounds = { x: bounds.x, y: bounds.y, width: firstWidth, height: bounds.height };
-    const secondBounds = { x: bounds.x + firstWidth, y: bounds.y, width: secondWidth, height: bounds.height };
+    const dividerX = reserveDividerGutter
+      ? bounds.x + firstWidth
+      : precise
+        ? bounds.x + firstWidth - (dividerSize / 2)
+        : bounds.x + firstWidth - 1;
+    const secondBounds = {
+      x: reserveDividerGutter ? bounds.x + firstWidth + dividerSize : bounds.x + firstWidth,
+      y: bounds.y,
+      width: secondWidth,
+      height: bounds.height,
+    };
     dividers.push({
       path,
       axis: node.axis,
       bounds: { ...bounds },
       ratio: node.ratio,
       rect: {
-        x: precise ? bounds.x + firstWidth - (dividerSize / 2) : bounds.x + firstWidth - 1,
+        x: dividerX,
         y: bounds.y,
         width: dividerSize,
         height: bounds.height,
@@ -452,9 +466,21 @@ function collectDockGeometry(
     return { leaves, dividers };
   }
 
-  const [firstHeight, secondHeight] = resolveSplitSizes(bounds.height, node.ratio, MIN_DOCKED_HEIGHT, precise);
+  const reserveDividerGutter = reserveDividerGutters && bounds.height > dividerSize;
+  const splitHeight = reserveDividerGutter ? bounds.height - dividerSize : bounds.height;
+  const [firstHeight, secondHeight] = resolveSplitSizes(splitHeight, node.ratio, MIN_DOCKED_HEIGHT, precise);
   const firstBounds = { x: bounds.x, y: bounds.y, width: bounds.width, height: firstHeight };
-  const secondBounds = { x: bounds.x, y: bounds.y + firstHeight, width: bounds.width, height: secondHeight };
+  const dividerY = reserveDividerGutter
+    ? bounds.y + firstHeight
+    : precise
+      ? bounds.y + firstHeight - (dividerSize / 2)
+      : bounds.y + firstHeight - 1;
+  const secondBounds = {
+    x: bounds.x,
+    y: reserveDividerGutter ? bounds.y + firstHeight + dividerSize : bounds.y + firstHeight,
+    width: bounds.width,
+    height: secondHeight,
+  };
   dividers.push({
     path,
     axis: node.axis,
@@ -462,7 +488,7 @@ function collectDockGeometry(
     ratio: node.ratio,
     rect: {
       x: bounds.x,
-      y: precise ? bounds.y + firstHeight - (dividerSize / 2) : bounds.y + firstHeight - 1,
+      y: dividerY,
       width: bounds.width,
       height: dividerSize,
     },

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

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync } from "fs";
-import { join } from "path";
+import { dirname, join } from "path";
 import { Buffer } from "node:buffer";
 import Electrobun, { ApplicationMenu, BrowserView, BrowserWindow, Utils, ContextMenu, type UpdateStatusEntry } from "electrobun/bun";
 import {
@@ -17,7 +17,7 @@ import type { DesktopDockPreviewState, DesktopSharedStateSnapshot, DesktopThemeP
 import type { ReleaseInfo, UpdateCheckResult, UpdateProgress } from "../../../updater";
 import { buildSoundCommand } from "../../../notifications/app-notifier";
 import { isPaneDetached } from "../../../plugins/pane-manager";
-import { ELECTROBUN_CONTEXT_MENU_ACTION, type ElectrobunDesktopRpcSchema } from "../shared/protocol";
+import { ELECTROBUN_CONTEXT_MENU_ACTION, type DesktopRestartMessage, type ElectrobunDesktopRpcSchema } from "../shared/protocol";
 import { decodeRpcValue, encodeRpcValue } from "../view/rpc-codec";
 import { contextMenuSelectionMessage } from "./context-menu-click";
 import { getContextMenuRequestId, normalizeContextMenuItems } from "./context-menu-normalize";
@@ -65,6 +65,7 @@ let desktopWorkspace: DesktopWorkspace | null = null;
 let currentDockPreview: DesktopDockPreviewState = { paneId: null, edge: null };
 let currentThemePreview: DesktopThemePreviewState = { theme: null };
 let desktopUpdateInProgress = false;
+let desktopRestartInProgress = false;
 
 const detachedWindows = new Map<string, BrowserWindow>();
 const detachedFrameTimers = new Map<string, ReturnType<typeof setTimeout>>();
@@ -82,6 +83,19 @@ function summarizeError(error: unknown): string {
   return error instanceof Error ? error.stack ?? error.message : String(error);
 }
 
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+function findMacAppBundle(execPath: string): string | null {
+  let current = dirname(execPath);
+  while (current && current !== dirname(current)) {
+    if (current.endsWith(".app")) return current;
+    current = dirname(current);
+  }
+  return null;
+}
+
 function requireServices(): AppServices {
   if (!services) throw new Error("Backend services have not been initialized.");
   return services;
@@ -633,6 +647,62 @@ function teardownServices(): void {
   services = null;
 }
 
+function spawnDetached(command: string[]): void {
+  const child = Bun.spawn(command, {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"],
+  } as any);
+  child.unref();
+}
+
+function scheduleDesktopRelaunch(): void {
+  const pid = process.pid;
+  const macAppBundle = process.platform === "darwin" ? findMacAppBundle(process.execPath) : null;
+
+  if (macAppBundle) {
+    spawnDetached([
+      "sh",
+      "-c",
+      `while kill -0 ${pid} 2>/dev/null; do sleep 0.25; done; sleep 0.5; open ${shellQuote(macAppBundle)}`,
+    ]);
+    return;
+  }
+
+  if (process.platform === "win32") {
+    spawnDetached([process.execPath, ...process.argv.slice(1)]);
+    return;
+  }
+
+  const args = process.argv.slice(1).map(shellQuote).join(" ");
+  spawnDetached([
+    "sh",
+    "-c",
+    `while kill -0 ${pid} 2>/dev/null; do sleep 0.25; done; cd ${shellQuote(process.cwd())}; ${shellQuote(process.execPath)}${args ? ` ${args}` : ""}`,
+  ]);
+}
+
+function restartDesktopApp(message: DesktopRestartMessage = {}): void {
+  if (desktopRestartInProgress) return;
+  desktopRestartInProgress = true;
+  console.error("[desktop-recovery] restart requested", {
+    reason: message.reason,
+    source: message.source,
+    pid: process.pid,
+    execPath: process.execPath,
+    argv: process.argv,
+  });
+  try {
+    scheduleDesktopRelaunch();
+  } catch (error) {
+    desktopRestartInProgress = false;
+    console.error("[desktop-recovery] failed to schedule restart", summarizeError(error));
+    throw error;
+  }
+  closeAllDetachedWindows();
+  teardownServices();
+  Utils.quit();
+}
+
 function resolveDetachedWindowTitle(instanceId: string): string {
   const instance = currentConfig ? findPaneInstance(currentConfig.layout, instanceId) : null;
   if (!instance) return "Gloomberb";
@@ -1087,6 +1157,12 @@ async function handleBackendRequest(
       requireServices().persistence.pluginState.delete(payload.pluginId as string, payload.key as string);
       syncBackendCloudAuthState(payload.pluginId as string, payload.key as string, null);
       return null;
+    case "host.restart":
+      restartDesktopApp({
+        reason: typeof payload.reason === "string" ? payload.reason : undefined,
+        source: typeof payload.source === "string" ? payload.source : "backend-request",
+      });
+      return null;
     case "host.exit":
       closeAllDetachedWindows();
       teardownServices();
@@ -1153,7 +1229,11 @@ function createWindowRpc(key: string): DesktopRpc {
       requests: {
         "backend.request": async ({ method, payload }) => encodeRpcValue(await handleBackendRequest(rpc, method, payload)),
       },
-      messages: {},
+      messages: {
+        "host.restart": (message) => {
+          restartDesktopApp(message);
+        },
+      },
     },
   });
   registerWindowRpc(key, rpc);

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

@@ -53,6 +53,11 @@ export interface CapabilityEventMessage {
   event: unknown;
 }
 
+export interface DesktopRestartMessage {
+  reason?: string;
+  source?: string;
+}
+
 export interface ElectrobunDesktopRpcSchema {
   bun: {
     requests: {
@@ -61,7 +66,9 @@ export interface ElectrobunDesktopRpcSchema {
         response: unknown;
       };
     };
-    messages: {};
+    messages: {
+      "host.restart": DesktopRestartMessage;
+    };
   };
   webview: {
     requests: {};

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

@@ -5,6 +5,7 @@ import {
   type CapabilityEventMessage,
   type ContextMenuSelectMessage,
   type DesktopDockPreviewMessage,
+  type DesktopRestartMessage,
   type DesktopStateMessage,
   type DesktopThemePreviewMessage,
   type ElectrobunBackendInit,
@@ -131,6 +132,10 @@ export async function initElectrobunBackend(payload?: { kind?: "main" | "detache
   return initSnapshot;
 }
 
+export function requestElectrobunRestart(message: DesktopRestartMessage = {}): void {
+  rpc.send["host.restart"](message);
+}
+
 export function getElectrobunBackendInitSnapshot(): ElectrobunBackendInit | null {
   return initSnapshot;
 }

package/src/renderers/electrobun/view/fatal-screen.tsx

@@ -0,0 +1,118 @@
+/// <reference lib="dom" />
+/** @jsxImportSource react */
+import { Component, useMemo, useState, type ErrorInfo, type ReactNode } from "react";
+import { backendRequest, requestElectrobunRestart } from "./backend-rpc";
+
+declare global {
+  interface Window {
+    __gloomRenderFatalError?: (error: unknown, details?: string) => void;
+  }
+}
+
+interface DesktopFatalScreenProps {
+  title?: string;
+  error: unknown;
+  details?: string;
+  source: string;
+}
+
+interface ElectrobunErrorBoundaryState {
+  hasError: boolean;
+  error: unknown;
+  details?: string;
+}
+
+export function formatFatalError(error: unknown, details?: string): string {
+  const message = error instanceof Error ? error.stack ?? error.message : String(error);
+  return [message, details].filter((value): value is string => Boolean(value)).join("\n");
+}
+
+export function DesktopFatalScreen({
+  title = "Gloomberb crashed",
+  error,
+  details,
+  source,
+}: DesktopFatalScreenProps) {
+  const [status, setStatus] = useState<string | null>(null);
+  const errorText = useMemo(() => formatFatalError(error, details), [details, error]);
+
+  const reloadWindow = () => {
+    window.location.reload();
+  };
+
+  const restartApp = () => {
+    setStatus("Restart requested...");
+    try {
+      requestElectrobunRestart({
+        source,
+        reason: errorText.slice(0, 240),
+      });
+      window.setTimeout(() => {
+        setStatus("If the app stays open, quit it and open it again.");
+      }, 2500);
+    } catch (restartError) {
+      setStatus(`Restart request failed: ${formatFatalError(restartError)}`);
+    }
+  };
+
+  const copyError = async () => {
+    try {
+      if (navigator.clipboard?.writeText) {
+        await navigator.clipboard.writeText(errorText);
+      } else {
+        await backendRequest("host.copyText", { text: errorText });
+      }
+      setStatus("Error copied.");
+    } catch (copyError) {
+      setStatus(`Copy failed: ${formatFatalError(copyError)}`);
+    }
+  };
+
+  return (
+    <div className="gloom-fatal">
+      <h1>{title}</h1>
+      <div className="gloom-fatal-actions">
+        <button type="button" data-variant="primary" onClick={restartApp}>Restart app</button>
+        <button type="button" onClick={reloadWindow}>Reload window</button>
+        <button type="button" onClick={copyError}>Copy error</button>
+      </div>
+      {status && <div className="gloom-fatal-status" aria-live="polite">{status}</div>}
+      <pre>{errorText}</pre>
+    </div>
+  );
+}
+
+export class ElectrobunErrorBoundary extends Component<
+  { children: ReactNode },
+  ElectrobunErrorBoundaryState
+> {
+  override state: ElectrobunErrorBoundaryState = { hasError: false, error: null };
+
+  static getDerivedStateFromError(error: unknown): ElectrobunErrorBoundaryState {
+    return { hasError: true, error };
+  }
+
+  override componentDidCatch(error: unknown, errorInfo: ErrorInfo): void {
+    console.error("[desktop-recovery] renderer error boundary", error, errorInfo.componentStack);
+    this.setState({
+      hasError: true,
+      error,
+      details: errorInfo.componentStack ?? undefined,
+    });
+  }
+
+  override render(): ReactNode {
+    if (this.state.hasError) {
+      return (
+        <DesktopFatalScreen
+          title="Gloomberb crashed"
+          error={this.state.error}
+          details={this.state.details}
+          source="react-error-boundary"
+        />
+      );
+    }
+
+    return this.props.children;
+  }
+}

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

@@ -15,6 +15,7 @@ import {
   installElectrobunHttpFetchTransport,
 } from "./http-fetch";
 import { installElectrobunUpdateHost } from "./update-host";
+import { DesktopFatalScreen, ElectrobunErrorBoundary } from "./fatal-screen";
 import { WebInputHostProvider } from "./input-host";
 import { webNativeRenderer } from "./native-renderer";
 import { WebToastHostProvider } from "./toast-host";
@@ -27,16 +28,32 @@ const rootElement = document.getElementById("root");
 if (!rootElement) {
   throw new Error("Missing root element");
 }
+const appRootElement = rootElement;
 
-const root = createRoot(rootElement);
+const root = createRoot(appRootElement);
 const bootLog = debugLog.createLogger("electrobun-web-boot");
 
-rootElement.tabIndex = -1;
+appRootElement.tabIndex = -1;
 root.render(<div className="gloom-loading">Starting Gloomberb...</div>);
 
+function renderFatalError(error: unknown, details?: string, title = "Gloomberb failed to start"): void {
+  root.render(
+    <DesktopFatalScreen
+      title={title}
+      error={error}
+      details={details}
+      source="renderer-fatal"
+    />,
+  );
+}
+
+window.__gloomRenderFatalError = (error, details) => {
+  renderFatalError(error, details, "Gloomberb crashed");
+};
+
 function focusWebSurface(): void {
   window.focus();
-  rootElement.focus({ preventScroll: true });
+  appRootElement.focus({ preventScroll: true });
 }
 
 function requestStartupFocus(): void {
@@ -69,21 +86,23 @@ async function boot() {
   const desktopApplicationMenuBridge = createApplicationMenuBridge();
   measurePerfAsync("startup.electrobun.root-render", async () => {
     root.render(
-      <UiHostProvider ui={webUiHost} renderer={webRendererHost} nativeRenderer={webNativeRenderer}>
-        <WebInputHostProvider>
-          <WebToastHostProvider>
-            <WebDialogHostProvider>
-              <App
-                config={config}
-                desktopWindowBridge={desktopWindowBridge}
-                desktopApplicationMenuBridge={desktopApplicationMenuBridge}
-                desktopSnapshot={desktopSnapshot}
-                desktopThemePreview={init.desktopThemePreview}
-              />
-            </WebDialogHostProvider>
-          </WebToastHostProvider>
-        </WebInputHostProvider>
-      </UiHostProvider>,
+      <ElectrobunErrorBoundary>
+        <UiHostProvider ui={webUiHost} renderer={webRendererHost} nativeRenderer={webNativeRenderer}>
+          <WebInputHostProvider>
+            <WebToastHostProvider>
+              <WebDialogHostProvider>
+                <App
+                  config={config}
+                  desktopWindowBridge={desktopWindowBridge}
+                  desktopApplicationMenuBridge={desktopApplicationMenuBridge}
+                  desktopSnapshot={desktopSnapshot}
+                  desktopThemePreview={init.desktopThemePreview}
+                />
+              </WebDialogHostProvider>
+            </WebToastHostProvider>
+          </WebInputHostProvider>
+        </UiHostProvider>
+      </ElectrobunErrorBoundary>,
     );
   });
   requestStartupFocus();
@@ -96,10 +115,5 @@ async function boot() {
 }
 
 boot().catch((error) => {
-  root.render(
-    <div className="gloom-fatal">
-      <h1>Gloomberb failed to start</h1>
-      <pre>{error instanceof Error ? error.stack ?? error.message : String(error)}</pre>
-    </div>,
-  );
+  renderFatalError(error);
 });

package/src/renderers/electrobun/view/styles.css

@@ -1,5 +1,5 @@
 @keyframes gloom-spin { from { transform: rotate(0deg); } to { transform: rotate(360deg); } }
-html, body, #root { width: 100%; height: 100%; min-height: 100%; overflow: hidden; background: var(--gloom-bg); }
+html, body, #root { width: 100%; height: 100%; min-height: 100%; overflow: hidden; background: var(--gloom-bg, #272a34); }
 #root:focus { outline: none; }
 body {
   --cell-w: 8px;
@@ -8,7 +8,7 @@ body {
   font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
   font-size: 12px;
   line-height: var(--cell-h);
-  color: var(--gloom-text);
+  color: var(--gloom-text, #f2f2f2);
   cursor: default;
   user-select: none;
   color-scheme: dark;
@@ -284,8 +284,52 @@ body.gloom-dragging {
   top: 50%;
   height: 1px;
 }
-.gloom-loading, .gloom-fatal { padding: 24px; color: var(--gloom-text); }
-.gloom-fatal pre { white-space: pre-wrap; color: var(--gloom-negative); }
+.gloom-loading, .gloom-fatal {
+  padding: 24px;
+  color: var(--gloom-text, #f2f2f2);
+  background: var(--gloom-bg, #272a34);
+}
+.gloom-fatal {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+  overflow: auto;
+}
+.gloom-fatal h1 {
+  margin: 0 0 6px;
+  font-size: 28px;
+  line-height: 1.25;
+}
+.gloom-fatal-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+.gloom-fatal button {
+  border: 1px solid var(--gloom-border, #5b6070);
+  border-radius: 6px;
+  padding: 5px 10px;
+  color: var(--gloom-text, #f2f2f2);
+  background: var(--gloom-panel, #1f222b);
+}
+.gloom-fatal button:hover {
+  background: color-mix(in srgb, var(--gloom-text-bright, #fff) 10%, var(--gloom-panel, #1f222b));
+}
+.gloom-fatal button[data-variant="primary"] {
+  border-color: var(--gloom-border-focused, #8cb4ff);
+  color: var(--gloom-bg, #111318);
+  background: var(--gloom-border-focused, #8cb4ff);
+}
+.gloom-fatal-status {
+  min-height: var(--cell-h);
+  color: var(--gloom-text-dim, #a7acba);
+}
+.gloom-fatal pre {
+  margin: 0;
+  white-space: pre-wrap;
+  color: var(--gloom-negative, #ff5f5f);
+  user-select: text;
+}
 .gloom-toast-viewport {
   position: fixed;
   right: 16px;

package/src/utils/ticker-search.ts

@@ -84,6 +84,12 @@ export type ResolvedTickerSearch =
   | { kind: "local"; symbol: string; ticker: TickerRecord }
   | { kind: "provider"; symbol: string; result: InstrumentSearchResult };
 
+export interface TickerOpenTarget {
+  symbol: string;
+  ticker: TickerRecord;
+  created: boolean;
+}
+
 interface SearchQueryIntent {
   normalizedQuery: string;
   compactQuery: string;
@@ -297,6 +303,71 @@ export async function upsertTickerFromSearchResult(
   return { ticker, created };
 }
 
+export async function resolveTickerOpenTarget({
+  query,
+  tickers,
+  dataProvider,
+  tickerRepository,
+  searchContext,
+}: {
+  query: string;
+  tickers: ReadonlyMap<string, TickerRecord>;
+  dataProvider: DataProvider;
+  tickerRepository: TickerRepository;
+  searchContext?: SearchRequestContext;
+}): Promise<TickerOpenTarget | null> {
+  const symbol = normalizeTickerInput(null, query);
+  if (!symbol) return null;
+
+  let resolved: ResolvedTickerSearch | null = null;
+  try {
+    resolved = await resolveTickerSearch({
+      query: symbol,
+      activeTicker: null,
+      tickers,
+      dataProvider,
+      searchContext,
+    });
+  } catch {
+    resolved = null;
+  }
+
+  if (resolved?.kind === "local") {
+    return { symbol: resolved.symbol, ticker: resolved.ticker, created: false };
+  }
+
+  if (resolved?.kind === "provider") {
+    const { ticker, created } = await upsertTickerFromSearchResult(tickerRepository, resolved.result);
+    return { symbol: ticker.metadata.ticker, ticker, created };
+  }
+
+  try {
+    const quote = await dataProvider.getQuote(symbol, "");
+    const quoteSymbol = normalizeTickerSymbol(quote.symbol || symbol);
+    const existing = await tickerRepository.loadTicker(quoteSymbol);
+    if (existing) {
+      return { symbol: existing.metadata.ticker, ticker: existing, created: false };
+    }
+
+    const ticker = await tickerRepository.createTicker({
+      ticker: quoteSymbol,
+      exchange: quote.listingExchangeName ?? quote.exchangeName ?? "",
+      currency: quote.currency || "USD",
+      name: quote.name || quoteSymbol,
+      assetCategory: undefined,
+      portfolios: [],
+      watchlists: [],
+      positions: [],
+      custom: {},
+      tags: [],
+    });
+
+    return { symbol: ticker.metadata.ticker, ticker, created: true };
+  } catch {
+    return null;
+  }
+}
+
 export function findExactTickerSearchMatch<T extends Pick<TickerSearchRankableItem, "label"> & Partial<TickerSearchRankableItem>>(
   items: T[],
   query: string,
@@ -618,7 +689,7 @@ function analyzeSearchQuery(query: string): SearchQueryIntent {
       .map((token) => ASSET_HINT_MAP[token])
       .filter((token): token is TickerSearchInstrumentClass => token != null),
   ));
-  const assetPreference = assetHints.length === 1 ? assetHints[0] : null;
+  const assetPreference = assetHints.length === 1 ? assetHints[0]! : null;
 
   const companyTokens = tokens.filter((token) => !(token in EXCHANGE_HINT_ALIASES) && !(token in ASSET_HINT_MAP));
   const companyQuery = companyTokens.join(" ");

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.7.4";
+export const VERSION = "0.7.5";