gloomberb 0.16.1 → 0.16.2

package/src/renderers/dom/build-assets.ts

@@ -1,5 +1,6 @@
 import { readFile, writeFile } from "fs/promises";
-import { join, relative } from "path";
+import { dirname, join, relative, resolve } from "path";
+import type { BunPlugin } from "bun";
 import { TITLEBAR_OVERLAY_HEIGHT_PX } from "../../components/layout/titlebar-overlay";
 
 /** Imports whose path ends with the first entry resolve to the second, relative to the view directory. */
@@ -27,6 +28,13 @@ interface ViewBundleOptions {
 }
 
 const ELECTROBUN_VIEW_DIR = join(process.cwd(), "src", "renderers", "electrobun", "view");
+
+/**
+ * Where the world map finds its land data, relative to the map's
+ * `basemap.ts`. Only view bundles define it, so the terminal binary, which
+ * never draws that map, leaves the data out.
+ */
+export const WORLD_MAP_DATA_SPECIFIER = "./natural-earth/index.chunk.js";
 const DOM_RENDERER_DIR = join(process.cwd(), "src", "renderers", "dom");
 
 export function electrobunViewPath(...parts: string[]): string {
@@ -50,6 +58,7 @@ export async function buildViewBundle({
   failureMessage,
   missingEntryMessage,
 }: ViewBundleOptions): Promise<{ script: string; stylesheet: string | null }> {
+  const chunks = new Map<string, string>();
   const result = await Bun.build({
     entrypoints: [entrypoint],
     outdir,
@@ -58,8 +67,15 @@ export async function buildViewBundle({
     splitting: false,
     sourcemap,
     minify: true,
-    define: { "process.env.NODE_ENV": "\"production\"", ...define },
-    plugins: aliasRules.length > 0 ? [electrobunViewAliasPlugin(aliasRules)] : [],
+    define: {
+      "process.env.NODE_ENV": "\"production\"",
+      __GLOOM_WORLD_MAP_DATA__: JSON.stringify(WORLD_MAP_DATA_SPECIFIER),
+      ...define,
+    },
+    plugins: [
+      lazyChunkPlugin(outdir, outdir, chunks),
+      ...(aliasRules.length > 0 ? [electrobunViewAliasPlugin(aliasRules)] : []),
+    ],
   });
 
   if (!result.success) {
@@ -69,6 +85,7 @@ export async function buildViewBundle({
 
   const script = result.outputs.find((output) => output.kind === "entry-point" && output.path.endsWith(".js"));
   if (!script) throw new Error(missingEntryMessage);
+  await buildLazyChunks(outdir, chunks, failureMessage);
 
   const stylesheet = result.outputs.find((output) => output.path.endsWith(".css"))?.path ?? null;
   if (stylesheet) await writeFile(stylesheet, withTitlebarOverlayHeight(await readFile(stylesheet, "utf8")));
@@ -122,6 +139,67 @@ ${bootstrapScript}
 `;
 }
 
+/**
+ * The view bundle is one file (no splitting), so a module reached through
+ * `import()` would land in it. A module named `*.chunk.ts` and imported as
+ * `import("./path/name.chunk.js")` instead ships as its own file at that path
+ * next to the importing bundle, fetched the first time it is asked for: large
+ * data only some panes draw, such as the world map's coastlines. The terminal
+ * and the tests run the source, where the same `import()` loads the module.
+ */
+function lazyChunkPlugin(rootOutdir: string, emitDir: string, chunks: Map<string, string>): BunPlugin {
+  return {
+    name: "lazy-chunks",
+    setup(build) {
+      build.onResolve({ filter: /\.chunk(\.js|\.ts)?$/ }, (args) => {
+        if (args.kind.startsWith("entry-point") || /[\\/]node_modules[\\/]/.test(args.importer)) return undefined;
+        if (args.kind !== "dynamic-import") {
+          throw new Error(`${args.path} is a lazy chunk; load it with import() (from ${args.importer})`);
+        }
+        if (!args.path.startsWith("./") || !args.path.endsWith(".chunk.js")) {
+          throw new Error(`Lazy chunk ${args.path} must be imported as "./<path>.chunk.js" (from ${args.importer})`);
+        }
+        const source = resolve(dirname(args.importer), args.path.replace(/\.js$/, ".ts"));
+        const output = resolve(emitDir, args.path);
+        if (relative(rootOutdir, output).startsWith("..")) throw new Error(`Lazy chunk ${args.path} would land outside ${rootOutdir}`);
+        const existing = chunks.get(output);
+        if (existing && existing !== source) throw new Error(`Two lazy chunks emit ${output}: ${existing} and ${source}`);
+        chunks.set(output, source);
+        return { path: args.path, external: true };
+      });
+    },
+  };
+}
+
+/** Builds each lazy chunk on its own, and the chunks those load in turn. */
+async function buildLazyChunks(rootOutdir: string, chunks: Map<string, string>, failureMessage: string): Promise<void> {
+  const built = new Set<string>();
+  let pending = [...chunks.entries()];
+  while (pending.length) {
+    const nested = new Map<string, string>();
+    for (const [output, source] of pending) {
+      if (built.has(output)) continue;
+      built.add(output);
+      const result = await Bun.build({
+        entrypoints: [source],
+        outdir: dirname(output),
+        naming: relative(dirname(output), output),
+        target: "browser",
+        format: "esm",
+        splitting: false,
+        sourcemap: "none",
+        minify: true,
+        plugins: [lazyChunkPlugin(rootOutdir, dirname(output), nested)],
+      });
+      if (!result.success) {
+        const details = result.logs.map((log) => log.message).filter(Boolean).join("\n");
+        throw new Error(`${failureMessage}: lazy chunk ${source}\n${details}`);
+      }
+    }
+    pending = [...nested.entries()];
+  }
+}
+
 function electrobunViewAliasPlugin(aliasRules: AliasRule[]) {
   return {
     name: "electrobun-view-aliases",

package/src/renderers/dom/data-table/row.tsx

@@ -353,6 +353,8 @@ function WebDataTableRowInner<
           <div
             key={column.id}
             data-gloom-role="data-table-cell"
+            // The instant behind a shortened time ("Wed 11:27"), so a rendered-view report can print it whole.
+            data-gloom-cell-instant={cell.value instanceof Date && Number.isFinite(cell.value.getTime()) ? cell.value.toISOString() : undefined}
             style={{
               minWidth: 0,
               position: freezeFirstColumn && columnIndex === 0 ? "sticky" : undefined,

package/src/renderers/dom/desktop/controls.tsx

@@ -345,8 +345,10 @@ export function WebTextField({
           focusedBackgroundColor={plain ? "transparent" : resolvedBackgroundColor}
           cursorColor={colors.textBright}
           style={{
-            paddingLeft: plain ? 0 : comfortable ? 8 : 10,
-            paddingRight: plain ? 0 : comfortable ? 8 : 10,
+            // A framed field keeps its text one cell off the frame; a plain one
+            // sits flush in the row or band that holds it.
+            paddingLeft: plain ? 0 : "var(--cell-w)",
+            paddingRight: plain ? 0 : "var(--cell-w)",
             borderRadius: plain ? 0 : CONTROL_RADIUS,
             // The field is taller than a cell, so the input takes the inner
             // height and centers its text on the box's own line.
@@ -581,8 +583,10 @@ export function WebDialogFrame({
       </Box>
       {children}
       {footer && (
+        // Sized by its line, not one cell: a cell-high box with this padding
+        // left the key line hanging out of its bottom.
         <Box
-          height={1}
+          flexShrink={0}
           style={{
             borderTop: `1px solid ${panelBorder(colors)}`,
             paddingTop: 8,

package/src/renderers/dom/desktop/list-view.tsx

@@ -5,6 +5,7 @@ import { TextAttributes } from "../../../ui";
 import type { ListRowState, ListViewItem, ListViewProps } from "../../../components/ui/list-view";
 import { blendHex, hoverBg, type ThemeColors } from "../../../theme/colors";
 import { useThemeColors } from "../../../theme/theme-context";
+import { WEB_CELL_HEIGHT } from "../../../theme/font-scale";
 import { isInsideDialogSurface } from "../host/focus-scope";
 import { isEditableKeyboardTarget } from "../key-event";
 import {
@@ -58,6 +59,10 @@ function DefaultDesktopRow({
   );
 }
 
+const FRAMED_LIST_PADDING_PX = 4;
+/** What a framed list adds above and below its rows: padding and a 1px border on each side. */
+const FRAMED_LIST_CHROME_PX = 2 * (FRAMED_LIST_PADDING_PX + 1);
+
 function listRowStyle(selected: boolean, disabled: boolean, colors: ThemeColors): CSSProperties {
   return {
     borderRadius: CONTROL_RADIUS,
@@ -109,6 +114,16 @@ export function WebListView({
   const tabStopIndex = selectedIndex >= 0 && items[selectedIndex] && !items[selectedIndex].disabled
     ? selectedIndex : items.findIndex((item) => !item.disabled);
   const effectiveSurface = surface ?? (scrollable ? "framed" : "plain");
+  // `height` counts terminal rows. A list that is not meant to scroll takes
+  // only the rows it has, up to that many; one with more rows than that
+  // scrolls inside the height instead of drawing over whatever follows it.
+  const rowsHeight = items.length === 0 ? 1 : items.length * rowHeight + (items.length - 1) * rowGap;
+  const overflowsHeight = !scrollable && height != null && rowsHeight > height;
+  const scrolls = scrollable || overflowsHeight;
+  // The frame's padding and border sit outside the rows it was asked to hold.
+  const scrollHeight = overflowsHeight
+    ? `${height * WEB_CELL_HEIGHT + (effectiveSurface === "plain" ? 0 : FRAMED_LIST_CHROME_PX)}px`
+    : height;
   const frameStyle = effectiveSurface === "plain"
     ? {
       border: "none",
@@ -119,12 +134,12 @@ export function WebListView({
     : {
       border: `1px solid ${panelBorder(colors)}`,
       borderRadius: CONTROL_RADIUS,
-      padding: 4,
+      padding: FRAMED_LIST_PADDING_PX,
       backgroundColor: subtlePanelFill(colors),
     };
 
   useEffect(() => {
-    if (!scrollable || !autoScrollToIndex || activeScrollIndex < 0) return;
+    if (!scrolls || !autoScrollToIndex || activeScrollIndex < 0) return;
     const scrollBox = scrollRef.current;
     if (!scrollBox) return;
     const safeIndex = Math.min(activeScrollIndex, items.length - 1);
@@ -136,16 +151,16 @@ export function WebListView({
     } else if (rowBottom > scrollBox.scrollTop + viewportHeight) {
       scrollBox.scrollTo(rowBottom - viewportHeight);
     }
-  }, [activeScrollIndex, autoScrollToIndex, items.length, rowHeight, rowStride, scrollable]);
+  }, [activeScrollIndex, autoScrollToIndex, items.length, rowHeight, rowStride, scrolls]);
 
   useEffect(() => {
-    if (!scrollable) return;
+    if (!scrolls) return;
     const scrollBox = scrollRef.current;
     if (!scrollBox) return;
     if (scrollBox.verticalScrollBar) {
       scrollBox.verticalScrollBar.visible = items.length * rowStride - rowGap > (scrollBox.viewport?.height ?? 0);
     }
-  }, [items.length, height, flexGrow, rowGap, rowStride, scrollable]);
+  }, [items.length, height, flexGrow, rowGap, rowStride, scrolls]);
 
   // The dialog or pane around the list moves its cursor (j/k, Home/End). A row
   // Tab or a press left focused follows it, or Space and Enter would act on the
@@ -156,8 +171,8 @@ export function WebListView({
     const active = document.activeElement;
     if (!list || !active || !list.contains(active) || isEditableKeyboardTarget(active)) return;
     const row = list.querySelectorAll<HTMLElement>('[role="option"]')[selectedIndex];
-    if (row && !row.contains(active)) row.focus({ preventScroll: scrollable });
-  }, [listDomId, scrollable, selectedIndex]);
+    if (row && !row.contains(active)) row.focus({ preventScroll: scrolls });
+  }, [listDomId, scrolls, selectedIndex]);
 
   const rows = items.length === 0
     ? (
@@ -233,11 +248,21 @@ export function WebListView({
     });
 
   return (
-    <Box id={listDomId} flexDirection="column" height={height} flexGrow={flexGrow} gap={1} role="listbox" aria-label={remoteLabel}>
-      {scrollable ? (
+    <Box
+      id={listDomId}
+      flexDirection="column"
+      height={scrollable ? height : undefined}
+      // A list sized by its container gives up height to it, and scrolls.
+      minHeight={scrollable && height == null ? 0 : undefined}
+      flexGrow={flexGrow}
+      gap={1}
+      role="listbox"
+      aria-label={remoteLabel}
+    >
+      {scrolls ? (
         <ScrollBox
           ref={scrollRef}
-          height={height}
+          height={scrollHeight}
           flexGrow={flexGrow}
           scrollY
           focusable={false}

package/src/renderers/dom/desktop/popover.tsx

@@ -2,12 +2,16 @@
 
 import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { createPortal } from "react-dom";
-import type { HostPopoverProps } from "../../../ui";
+import type { BoxRenderable, HostPopoverProps } from "../../../ui";
 import { blendHex } from "../../../theme/colors";
+import { WEB_CELL_HEIGHT, WEB_CELL_WIDTH } from "../../../theme/font-scale";
 import { useThemeColors } from "../../../theme/theme-context";
 
 const VIEWPORT_MARGIN = 10;
+/** How far a popover kept inside its pane stays off the pane's edge. */
+const PANE_MARGIN = 4;
 const POPOVER_GAP = 6;
+const PANE_SELECTOR = '[data-gloom-role="pane-window"], [data-gloom-role="detached-pane-window"]';
 /** `.gloom-popover` in styles.css: above dialogs and toasts. */
 const POPOVER_Z_INDEX = 10_001;
 
@@ -21,6 +25,51 @@ function cssSize(value: number | string | undefined): number | string | undefine
   return typeof value === "number" ? `${value}px` : value;
 }
 
+interface Edges {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+}
+
+/**
+ * Where an anchor element is now, in viewport pixels. Null once it is gone
+ * from the page (a removed message), so the popover falls back to its trigger.
+ */
+function anchorEdges(anchor: BoxRenderable): Edges | null {
+  const rect = anchor.getBoundingClientRect?.();
+  if (rect) {
+    if (rect.width === 0 && rect.height === 0) return null;
+    return { left: rect.x, top: rect.y, right: rect.x + rect.width, bottom: rect.y + rect.height };
+  }
+  const bounds = anchor.absoluteBounds;
+  if (!bounds) return null;
+  return {
+    left: bounds.x * WEB_CELL_WIDTH,
+    top: bounds.y * WEB_CELL_HEIGHT,
+    right: (bounds.x + bounds.width) * WEB_CELL_WIDTH,
+    bottom: (bounds.y + bounds.height) * WEB_CELL_HEIGHT,
+  };
+}
+
+/** The area a popover must stay in: the window, and for `pane` the pane that holds its trigger too. */
+function placementEdges(wrapper: Element | null, boundary: HostPopoverProps["boundary"]): Edges {
+  const viewport = {
+    left: VIEWPORT_MARGIN,
+    top: VIEWPORT_MARGIN,
+    right: window.innerWidth - VIEWPORT_MARGIN,
+    bottom: window.innerHeight - VIEWPORT_MARGIN,
+  };
+  const pane = boundary === "pane" ? wrapper?.closest(PANE_SELECTOR)?.getBoundingClientRect() : null;
+  if (!pane) return viewport;
+  return {
+    left: Math.max(viewport.left, pane.left + PANE_MARGIN),
+    top: Math.max(viewport.top, pane.top + PANE_MARGIN),
+    right: Math.min(viewport.right, pane.right - PANE_MARGIN),
+    bottom: Math.min(viewport.bottom, pane.bottom - PANE_MARGIN),
+  };
+}
+
 /**
  * The popover is portalled to <body>, so its z-index only competes in the root
  * stacking context. A trigger inside a surface stacked above the popover layer
@@ -45,6 +94,10 @@ export function WebPopover({
   trigger,
   children,
   anchorPoint,
+  anchor,
+  boundary = "viewport",
+  onPointerEnter,
+  onPointerLeave,
   placement = "bottom-start",
   minWidth = 280,
   maxWidth = "min(420px, calc(100vw - 20px))",
@@ -59,18 +112,19 @@ export function WebPopover({
   const [zIndex, setZIndex] = useState<number | undefined>(undefined);
 
   const updatePosition = useCallback(() => {
-    const anchor = anchorRef.current;
+    const wrapper = anchorRef.current;
     const popover = popoverRef.current;
-    if (!anchor || !popover) return;
+    if (!wrapper || !popover) return;
 
     const popoverRect = popover.getBoundingClientRect();
-    const triggerRect = anchor.getBoundingClientRect();
+    const triggerRect = wrapper.getBoundingClientRect();
+    const elementEdges = anchor ? anchorEdges(anchor) : null;
     // Keyboard-driven popovers can intentionally omit a visible trigger. In
     // that case the anchor wrapper still inherits a line-height, so its DOM
     // rect is not truly empty even though there is nothing useful to anchor to.
     // Center these unanchored menus; explicit pointer/footer coordinates still
     // take precedence below.
-    if (!anchorPoint && (trigger == null || (triggerRect.width === 0 && triggerRect.height === 0))) {
+    if (!elementEdges && !anchorPoint && (trigger == null || (triggerRect.width === 0 && triggerRect.height === 0))) {
       setPosition({
         left: Math.max(
           VIEWPORT_MARGIN,
@@ -90,28 +144,26 @@ export function WebPopover({
       });
       return;
     }
-    const anchorRect = anchorPoint
+    const anchorRect = elementEdges ?? (anchorPoint
       ? {
         left: anchorPoint.x,
         right: anchorPoint.x,
         top: anchorPoint.y,
         bottom: anchorPoint.y,
       }
-      : triggerRect;
+      : triggerRect);
+    const edges = placementEdges(wrapper, boundary);
     const preferredLeft = placement === "bottom-end"
       ? anchorRect.right - popoverRect.width
       : anchorRect.left;
-    const left = Math.max(
-      VIEWPORT_MARGIN,
-      Math.min(preferredLeft, window.innerWidth - popoverRect.width - VIEWPORT_MARGIN),
-    );
+    const left = Math.max(edges.left, Math.min(preferredLeft, edges.right - popoverRect.width));
     const below = anchorRect.bottom + POPOVER_GAP;
     const above = anchorRect.top - popoverRect.height - POPOVER_GAP;
-    const top = below + popoverRect.height <= window.innerHeight - VIEWPORT_MARGIN
+    const top = below + popoverRect.height <= edges.bottom
       ? below
-      : Math.max(VIEWPORT_MARGIN, above);
+      : Math.max(edges.top, above);
     setPosition({ left, top, visible: true });
-  }, [anchorPoint, placement, trigger]);
+  }, [anchor, anchorPoint, boundary, placement, trigger]);
 
   useLayoutEffect(() => {
     if (!open) {
@@ -123,10 +175,15 @@ export function WebPopover({
     const frame = window.requestAnimationFrame(updatePosition);
     window.addEventListener("resize", updatePosition);
     document.addEventListener("scroll", updatePosition, true);
+    // New content (a hover card swapped to another name) can change the size
+    // the placement was worked out for.
+    const resizeObserver = typeof ResizeObserver === "function" ? new ResizeObserver(updatePosition) : null;
+    if (popoverRef.current) resizeObserver?.observe(popoverRef.current);
     return () => {
       window.cancelAnimationFrame(frame);
       window.removeEventListener("resize", updatePosition);
       document.removeEventListener("scroll", updatePosition, true);
+      resizeObserver?.disconnect();
     };
   }, [open, updatePosition]);
 
@@ -181,6 +238,8 @@ export function WebPopover({
           tabIndex={-1}
           onMouseDown={(event) => event.stopPropagation()}
           onClick={(event) => event.stopPropagation()}
+          onMouseEnter={onPointerEnter}
+          onMouseLeave={onPointerLeave}
           style={{
             left: position.left,
             top: position.top,

package/src/renderers/dom/host/input.tsx

@@ -27,9 +27,21 @@ function textInputStyle(props: Record<string, unknown>, multiline: boolean): CSS
   const backgroundColor = focused && typeof props.focusedBackgroundColor === "string"
     ? props.focusedBackgroundColor
     : props.backgroundColor;
+  const base = commonStyle(props);
+  const overrides = props.style as CSSProperties | undefined;
 
   return {
-    ...commonStyle(props),
+    ...base,
+    // Flush unless the caller insets the text. Longhands, never the `padding`
+    // shorthand: React writes style keys in order, and a shorthand here landed
+    // after a caller's `paddingLeft` and wiped it, so every bordered field's
+    // text sat on its border.
+    ...(overrides?.padding === undefined ? {
+      paddingTop: base.paddingTop ?? 0,
+      paddingRight: base.paddingRight ?? 0,
+      paddingBottom: base.paddingBottom ?? 0,
+      paddingLeft: base.paddingLeft ?? 0,
+    } : {}),
     display: "block",
     resize: "none",
     border: "none",
@@ -40,10 +52,9 @@ function textInputStyle(props: Record<string, unknown>, multiline: boolean): CSS
     overflow: multiline ? "auto" : "hidden",
     width: cellWidth(props.width) ?? "100%",
     height: cellHeight(props.height) ?? (multiline ? "100%" : "var(--cell-h)"),
-    padding: 0,
     margin: 0,
     caretColor: typeof props.cursorColor === "string" ? props.cursorColor : "auto",
-    ...(props.style as CSSProperties | undefined),
+    ...overrides,
   };
 }
 

package/src/renderers/dom/styles.css

@@ -140,10 +140,12 @@ button, [data-gloom-interactive="true"] { cursor: pointer; }
   -webkit-user-select: none;
   user-select: none;
 }
-[data-gloom-role="pane-grip"],
-[data-gloom-role="pane-header-chrome"] {
+[data-gloom-role="pane-header"][data-drag-surface="pane"] {
   cursor: grab;
 }
+[data-gloom-role="pane-header-tabs"] {
+  cursor: default;
+}
 [data-gloom-role="pane-header"] [data-gloom-role="tab-button"],
 [data-gloom-role="pane-header"] button,
 [data-gloom-role="pane-header"] [data-gloom-interactive="true"] {
@@ -157,11 +159,8 @@ button, [data-gloom-interactive="true"] { cursor: pointer; }
 [data-gloom-role="pane-restore"] {
   cursor: pointer;
 }
-body.gloom-dragging [data-gloom-role="pane-grip"],
-body.gloom-dragging [data-gloom-role="pane-header-chrome"] {
-  cursor: grabbing;
-}
-body.gloom-dragging {
+body.gloom-dragging,
+body.gloom-dragging [data-gloom-role="pane-header"] {
   cursor: grabbing;
 }
 [data-gloom-role="pane-title"] {

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

@@ -443,6 +443,7 @@ function ShotPane({ payload, registry }: { payload: DesktopPaneShotPayload; regi
         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/rpc-timeout.ts

@@ -1,6 +1,10 @@
 import { getCloudApiBaseUrl } from "../../../api-client/request";
+import { RpcTimeoutError } from "../../../utils/rpc-timeout-error";
 import type { DesktopBackendRequestMethod } from "../shared/protocol";
 
+/** How long the view waits for the Bun process to answer one request. */
+export const RPC_MAX_REQUEST_TIME_MS = 120_000;
+
 /** What Electrobun's request timer rejects with: no method, request id or caller. */
 const ELECTROBUN_REQUEST_TIMEOUT_MESSAGE = "RPC request timed out.";
 
@@ -16,7 +20,9 @@ const ELECTROBUN_REQUEST_TIMEOUT_MESSAGE = "RPC request timed out.";
  * from the user's config (a broker gateway, a feed, a plugin endpoint) and is
  * only called external. Never the payload, rest of the path, query or headers.
  * Elapsed time is rounded to 10 s because crash reports are deduplicated per
- * session on the message.
+ * session on the message. The error keeps its message and `Error` type, and
+ * carries the elapsed time so a timer that fired long after its limit (the
+ * machine slept) can be told from a request that really stalled.
  */
 export async function nameRpcTimeout<T>(
   method: DesktopBackendRequestMethod,
@@ -28,8 +34,13 @@ export async function nameRpcTimeout<T>(
     return await request();
   } catch (error) {
     if (!(error instanceof Error) || error.message !== ELECTROBUN_REQUEST_TIMEOUT_MESSAGE) throw error;
-    const seconds = Math.round((performance.now() - startedAt) / 10_000) * 10;
-    throw new Error(`RPC request timed out: ${describeRequest(method, payload)} after ~${seconds}s`, { cause: error });
+    const elapsedMs = performance.now() - startedAt;
+    const seconds = Math.round(elapsedMs / 10_000) * 10;
+    throw new RpcTimeoutError(`RPC request timed out: ${describeRequest(method, payload)} after ~${seconds}s`, {
+      elapsedMs,
+      limitMs: RPC_MAX_REQUEST_TIME_MS,
+      cause: error,
+    });
   }
 }
 

package/src/renderers/opentui/host.tsx

@@ -108,6 +108,11 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
     enableMouseMovement: true,
   });
   const root = createRoot(renderer);
+  // Every mounted ScrollBox listens for `selection` and many components for
+  // `resize`, so the counts grow with the panes on screen (14 and 18 with one
+  // DES open at 80x24) and fall back when they close. Node's default warning
+  // at 11 is not a leak here, and it prints over the panes.
+  renderer.setMaxListeners(0);
   installResolutionEventBridge(renderer);
   // Streamed quotes apply and notify on one clock of up to 10 Hz: every
   // visible row stays live while a burst of ticks costs one terminal redraw,

package/src/sources/gloomberb-cloud/index.ts

@@ -40,6 +40,8 @@ import { resolveCurrencyUnit } from "../../utils/currency-units";
 import { canonicalExchange, canonicalTickerKey, parsePublicTickerKey } from "../../utils/exchanges";
 import { normalizePriceHistory, priceHistoryIntervalMs, reachesLatestSettledSession } from "../../utils/price-history";
 import { createProviderMiss } from "../provider-errors";
+import { assertSecRegistrantMatches } from "../sec-registrant";
+import { nonUsSecListingVenue } from "../../utils/sec";
 import { publicListingTarget } from "../listing-target";
 import { canonicalHistoryInterval, HistoryRetentionError, parseHistoryRecoveryCandidate, parseHistoryRetention, type HistoryRetention } from "../history-retention";
 import { getRouterEntityKey } from "../provider-router/cache";
@@ -195,7 +197,7 @@ function mapCloudPriceHistory(
       `Cloud chart data is unavailable for ${ticker}`,
     ).map((point) => mapPricePoint(point, divisor, exchange)),
   );
-  if (stale && !reachesLatestSettledSession(points, Date.now(), { exchange, intervalMs: priceHistoryIntervalMs(interval) })) {
+  if (stale && !reachesLatestSettledSession(points, Date.now(), { symbol: ticker, exchange, intervalMs: priceHistoryIntervalMs(interval) })) {
     throw createProviderMiss(`Cloud chart data is stale for ${ticker}`);
   }
   if (
@@ -486,11 +488,30 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     );
   }
 
-  async getSecFilings(ticker: string, count = 15): Promise<SecFilingItem[]> {
-    return withCloudFallback(async () => {
-      const response = await apiClient.getCloudSecFilings({ ticker, limit: count, offset: 0 });
+  async getSecFilings(ticker: string, count = 15, exchange?: string, context?: MarketDataRequestContext): Promise<SecFilingItem[]> {
+    const venue = nonUsSecListingVenue(ticker, exchange);
+    const name = venue ? context?.listingName?.trim() || await this.listingName(ticker, venue) || undefined : undefined;
+    const filings = await withCloudFallback(async () => {
+      const response = await apiClient.getCloudSecFilings({ ticker, exchange, name, limit: count, offset: 0 });
       return response.filings.map(mapCloudSecFiling);
     }, `Cloud SEC filings are unavailable for ${ticker}`);
+    if (!venue || filings.length === 0) return filings;
+    const symbol = parsePublicTickerKey(ticker).symbol;
+    // Without the listing's company the filings cannot be told apart from another company's.
+    if (!name) throw createProviderMiss(`SEC filings for ${symbol} could not be matched to its ${venue} listing`);
+    assertSecRegistrantMatches(filings, { symbol, exchange: venue, name });
+    return filings;
+  }
+
+  /** The company a listing belongs to, from its own quote; null when the quote prices another venue. */
+  private async listingName(ticker: string, venue: string): Promise<string | null> {
+    try {
+      const quote = await this.getQuote(ticker, venue);
+      const quoteVenue = canonicalExchange(quote.listingExchangeName || quote.exchangeName);
+      return quoteVenue === venue ? quote.name?.trim() || null : null;
+    } catch {
+      return null;
+    }
   }
 
   async getSecFilingDocuments(filing: SecFilingItem): Promise<SecFilingDocument[]> {