@gloom-sh/terminal 0.18.5 → 0.19.1

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

@@ -7,7 +7,14 @@ const WS_SYSMENU = 0x00080000n;
 const WS_THICKFRAME = 0x00040000n;
 const WS_MINIMIZEBOX = 0x00020000n;
 const WS_MAXIMIZEBOX = 0x00010000n;
-const WINDOWS_NATIVE_CONTROL_STYLE_MASK = WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
+/**
+ * Electrobun's "hiddenInset" window is captioned and sizable, with the caption
+ * cut out of its frame: its edges and corners resize it, it maximizes to the
+ * work area and keeps its shadow, while the header draws the buttons. Windows
+ * still reads the box bits: they let a click on the taskbar button minimize
+ * the window, and Win+Up, snapping and the window menu maximize it.
+ */
+const WINDOWS_FRAME_STYLE = WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
 const SWP_NOSIZE = 0x0001;
 const SWP_NOMOVE = 0x0002;
 const SWP_NOZORDER = 0x0004;
@@ -22,7 +29,7 @@ function styleValue(value: number | bigint): bigint {
 
 function applyCustomChromeToWindow(win32: Win32, windowHandle: Pointer): boolean {
   const currentStyle = styleValue(win32.symbols.GetWindowLongPtrW(windowHandle, GWL_STYLE));
-  const nextStyle = currentStyle & ~WINDOWS_NATIVE_CONTROL_STYLE_MASK;
+  const nextStyle = currentStyle | WINDOWS_FRAME_STYLE;
   if (nextStyle !== currentStyle) {
     win32.symbols.SetWindowLongPtrW(windowHandle, GWL_STYLE, nextStyle);
   }

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

@@ -41,6 +41,22 @@ function loadWin32() {
       args: [FFIType.ptr, FFIType.ptr, FFIType.int, FFIType.int, FFIType.int, FFIType.int, FFIType.u32],
       returns: FFIType.bool,
     },
+    GetCursorPos: {
+      args: [FFIType.ptr],
+      returns: FFIType.bool,
+    },
+    GetClientRect: {
+      args: [FFIType.ptr, FFIType.ptr],
+      returns: FFIType.bool,
+    },
+    PostMessageW: {
+      args: [FFIType.ptr, FFIType.u32, FFIType.u64, FFIType.i64],
+      returns: FFIType.bool,
+    },
+    GetGUIThreadInfo: {
+      args: [FFIType.u32, FFIType.ptr],
+      returns: FFIType.bool,
+    },
   });
 }
 
@@ -56,6 +72,68 @@ function win32OrNull(): Win32 | null {
   return cachedWin32;
 }
 
+const WM_SIZE = 0x0005;
+
+/**
+ * Electrobun opens a window's page at the size of the whole window and fits it
+ * to the client area on each WM_SIZE. A framed window's client area is smaller
+ * than the window, so until the window first changed size its page ran past
+ * the right and bottom edges, the Close button with it. Sends the window the
+ * WM_SIZE that fits the page. False off Windows.
+ */
+export function fitPageToClientArea(windowHandle: Pointer): boolean {
+  const win32 = win32OrNull();
+  if (!win32) return false;
+  const client = new Int32Array(4);
+  if (!win32.symbols.GetClientRect(windowHandle, ptr(client))) return false;
+  const size = (((client[3]! - client[1]!) & 0xffff) << 16) | ((client[2]! - client[0]!) & 0xffff);
+  return win32.symbols.PostMessageW(windowHandle, WM_SIZE, 0n, BigInt(size >>> 0));
+}
+
+const WM_NCLBUTTONDOWN = 0x00a1;
+const WM_CANCELMODE = 0x001f;
+const HTCAPTION = 2;
+/** GUITHREADINFO on 64-bit Windows: two DWORDs, six window handles, a RECT. */
+const GUI_THREAD_INFO_SIZE = 72;
+const GUI_THREAD_INFO_CAPTURE_OFFSET = 24;
+
+/**
+ * The window holding the mouse on `windowHandle`'s thread, if any. Chromium
+ * takes the mouse on every press, and Windows will not start a move while
+ * another window holds it.
+ */
+function mouseCaptureOnThreadOf(win32: Win32, windowHandle: Pointer): Pointer | null {
+  const thread = win32.symbols.GetWindowThreadProcessId(windowHandle, null);
+  if (!thread) return null;
+  const info = new DataView(new ArrayBuffer(GUI_THREAD_INFO_SIZE));
+  info.setUint32(0, GUI_THREAD_INFO_SIZE, true);
+  if (!win32.symbols.GetGUIThreadInfo(thread, ptr(info))) return null;
+  const capture = Number(info.getBigUint64(GUI_THREAD_INFO_CAPTURE_OFFSET, true));
+  return capture ? capture as Pointer : null;
+}
+
+/**
+ * Hands a press on the header to Windows as a press on a native title bar, from
+ * where the pointer is. Its move loop then moves the window until the button
+ * comes up: it snaps to the edges and corners of the screen and comes out of
+ * maximized, which a window moved by hand does not. Electrobun's own mover
+ * only moves. False off Windows.
+ *
+ * The page holds the mouse from the press, so it is asked to let go first, as
+ * a native title bar's window would have. Both messages go to the window's
+ * thread, which handles them in order.
+ */
+export function startSystemWindowMove(windowHandle: Pointer): boolean {
+  const win32 = win32OrNull();
+  if (!win32) return false;
+  const point = new Int32Array(2);
+  if (!win32.symbols.GetCursorPos(ptr(point))) return false;
+  const capture = mouseCaptureOnThreadOf(win32, windowHandle);
+  if (capture && capture !== windowHandle) win32.symbols.PostMessageW(capture, WM_CANCELMODE, 0n, 0n);
+  const position = ((point[1]! & 0xffff) << 16) | (point[0]! & 0xffff);
+  return win32.symbols.PostMessageW(windowHandle, WM_NCLBUTTONDOWN, BigInt(HTCAPTION), BigInt(position >>> 0));
+}
+
 export function wideString(value: string): Uint8Array {
   return Uint8Array.from(Buffer.from(`${value}\0`, "utf16le"));
 }

package/src/renderers/electrobun/bun/window/windows-quit.ts

@@ -0,0 +1,57 @@
+import { dlopen, FFIType, ptr, type Pointer } from "bun:ffi";
+import Electrobun from "electrobun/bun";
+import { wideString } from "./windows-native";
+
+const WM_QUIT = 0x0012;
+/** The class Electrobun registers for its windows. */
+const WINDOW_CLASS = "BasicWindowClass";
+/** How long a quit waits for this app's windows to be destroyed. */
+const WINDOWS_CLOSED_TIMEOUT_MS = 1_000;
+
+function loadUser32() {
+  return dlopen("user32.dll", {
+    GetWindowThreadProcessId: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    FindWindowExW: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
+    PostThreadMessageW: { args: [FFIType.u32, FFIType.u32, FFIType.u64, FFIType.i64], returns: FFIType.bool },
+  });
+}
+
+/**
+ * Electrobun ends its Windows event loop with PostQuitMessage, from the thread
+ * the app's code runs on rather than the one running the loop. The loop never
+ * ends: the app sits out a 5 s timeout with Chromium never shut down, and a
+ * Gloom opened meanwhile finds Chromium's profile still held, hands itself to
+ * the closing app and crashes. The quit message goes to the loop's own thread
+ * instead, once this app's windows are gone; with one still open, Electrobun's
+ * timeout ends the app as before. Does nothing off Windows.
+ */
+export function quitWindowsEventLoopOnItsThread(window: { ptr: Pointer | null }): void {
+  if (process.platform !== "win32" || !window.ptr) return;
+  let user32: ReturnType<typeof loadUser32>;
+  try {
+    user32 = loadUser32();
+  } catch {
+    return;
+  }
+  const loopThread = user32.symbols.GetWindowThreadProcessId(window.ptr, null);
+  if (!loopThread) return;
+  const className = wideString(WINDOW_CLASS);
+  const processId = new Uint32Array(1);
+  const ownWindowOpen = (): boolean => {
+    let handle: Pointer | null = null;
+    while ((handle = user32.symbols.FindWindowExW(null, handle, ptr(className), null))) {
+      user32.symbols.GetWindowThreadProcessId(handle, ptr(processId));
+      if (processId[0] === process.pid) return true;
+    }
+    return false;
+  };
+  Electrobun.events.on("before-quit", () => {
+    // Quitting blocks this thread until the loop has ended, so the wait is here.
+    const deadline = Date.now() + WINDOWS_CLOSED_TIMEOUT_MS;
+    while (ownWindowOpen()) {
+      if (Date.now() > deadline) return;
+      Bun.sleepSync(16);
+    }
+    user32.symbols.PostThreadMessageW(loopThread, WM_QUIT, 0n, 0n);
+  });
+}

package/src/renderers/electrobun/shared/app-name.ts

@@ -15,3 +15,16 @@ export const LEGACY_DESKTOP_APP_NAME = "Gloomberb";
  * to it.
  */
 export const DESKTOP_APP_IDENTIFIER = "com.vincelwt.gloomberb";
+
+/**
+ * The identifiers a build of this app carries: the one above, and the one a
+ * later release moves to. Until every install has moved, either one can be
+ * on disk (an app bundle, an install the script or Homebrew replaces), so
+ * anything that asks whether a copy is this app accepts both.
+ */
+export const DESKTOP_APP_IDENTIFIERS: readonly string[] = [DESKTOP_APP_IDENTIFIER, "sh.gloom.desktop"];
+
+/** Whether `identifier` is one a build of this app carries. */
+export function isDesktopAppIdentifier(identifier: string | null | undefined): boolean {
+  return !!identifier && DESKTOP_APP_IDENTIFIERS.includes(identifier);
+}

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

@@ -10,6 +10,7 @@ import type { CapabilityManifest } from "../../../capabilities";
 import type { PluginOperationResult, PluginPin } from "../../../plugins/marketplace/store";
 import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
 import type { HttpProxyRequestEnvelope, HttpProxyResponseEnvelope } from "../../../utils/http-proxy-response";
+import type { StallEvent } from "../../../utils/main-thread-stall";
 import type { BootFrame } from "../../dom/boot-frame-page";
 
 export const ELECTROBUN_CONTEXT_MENU_ACTION = "gloom.context-menu.select";
@@ -32,8 +33,13 @@ export interface ElectrobunBackendInit {
   pluginSeedNotice?: { body: string; type: "error" | "info" };
   /** What the view needs to send crash reports and usage counts the same way the Bun process would. */
   telemetry: ElectrobunTelemetryInit;
+  /** The copy on disk of the ids the view keeps in its own storage (view/view-ids.ts). */
+  viewIds: DesktopViewIds;
 }
 
+/** Ids the view keeps in its WebView storage, by storage key. */
+export type DesktopViewIds = Record<string, string>;
+
 interface ElectrobunTelemetryInit {
   /** Random per-install id from `<dataDir>/install-id`; null when the file could not be written. */
   installId: string | null;
@@ -206,6 +212,8 @@ interface DesktopBackendRequestMap {
   "host.exit": { request: null; response: null };
   "host.windowControl": { request: { action: DesktopWindowControlAction }; response: null };
   "host.windowFullscreen": { request: null; response: boolean };
+  /** Windows: moves the window with the pointer through the system's own move loop. */
+  "host.startWindowDrag": { request: null; response: null };
   "host.openExternal": { request: { url: string }; response: boolean };
   "host.copyText": { request: { text: string }; response: null };
   "host.focusWindow": { request: null; response: null };
@@ -222,6 +230,8 @@ interface DesktopBackendRequestMap {
   "host.showContextMenu": { request: { menu: DesktopContextMenuItem[] }; response: boolean };
   /** The layout the main window draws at the next launch before its script loads (dom/boot-frame.ts). Only the main window's is kept. */
   "host.saveBootFrame": { request: { frame: BootFrame }; response: null };
+  /** The ids the view keeps in its storage, for the copy on disk. Only the main window's are kept. */
+  "host.saveViewIds": { request: { ids: DesktopViewIds }; response: null };
   /** The unread count for the Dock icon badge: `""` (none), `"1"` to `"99"` or `"99+"`. Only the main window's is applied. */
   "host.setAppBadge": { request: { label: string }; response: null };
   /** `channel` absent (an older view) means stable. */
@@ -337,6 +347,8 @@ export interface ElectrobunDesktopRpcSchema {
     };
     messages: {
       "host.restart": DesktopRestartMessage;
+      /** A window froze; the Bun process keeps the stall log and its report. */
+      "runtime.stall": StallEvent;
     };
   };
   webview: {

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

@@ -17,6 +17,7 @@ import { subscribeCapability, type CapabilitySubscriptionOptions } from "./capab
 import { RpcTimeoutError } from "../../../utils/rpc-timeout-error";
 import { nameRpcTimeout, RPC_MAX_REQUEST_TIME_MS } from "./rpc-timeout";
 import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
+import type { StallEvent } from "../../../utils/main-thread-stall";
 
 type BackendMessages = ElectrobunDesktopRpcSchema["webview"]["messages"];
 type BackendMessageName = keyof BackendMessages;
@@ -153,6 +154,11 @@ export function requestElectrobunRestart(message: DesktopRestartMessage = {}): v
   rpc.send["host.restart"](message);
 }
 
+/** The Bun process keeps the stall log and sends its report. */
+export function sendElectrobunStall(event: StallEvent): void {
+  rpc.send["runtime.stall"](event);
+}
+
 export function getElectrobunBackendInitSnapshot(): ElectrobunBackendInit | null {
   return initSnapshot;
 }

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

@@ -5,12 +5,14 @@ import { App } from "../../../app";
 import { applyLanguageFromConfig } from "../../../i18n";
 import { debugLog } from "../../../utils/debug-log";
 import { capturePaneImage } from "../../../utils/dom-screenshot";
+import { setStallSink } from "../../../utils/main-thread-stall";
 import { measurePerfAsync } from "../../../utils/perf-marks";
 import {
   backendRequest,
   initElectrobunBackend,
   onBackendMessage,
   replaceElectrobunCapabilityManifests,
+  sendElectrobunStall,
   setElectrobunRemoteRequestHandler,
 } from "./backend-rpc";
 import { installElectrobunCapabilityStreamClient } from "./capability-stream-client";
@@ -49,10 +51,13 @@ import { loadOfficialPluginIds } from "../../../plugins/marketplace/feed";
 import { setPluginSeedNotice } from "../../../plugins/seed-notice";
 import { crashReportsEnabled, installCrashReporter, reportCrash } from "../../../telemetry/crash-reports";
 import { browserDoNotTrack, installWindowCrashListeners } from "../../../telemetry/crash-reports-dom";
+import { forwardAttendedStalls } from "../../../telemetry/stall-reports-dom";
 import { currentTelemetryConfig } from "../../../telemetry/live-config";
 import { attentionCountsEnabled, installAttentionCounter } from "../../../telemetry/attention-counts";
 import { installUsageCounter, usageCountsEnabled } from "../../../telemetry/usage-counts";
 import { installWindowUsageFlush } from "../../../telemetry/usage-counts-dom";
+import { cloudSyncController } from "../../../sync/controller";
+import { createViewIdMirror, restoreViewIds, viewIdStorage } from "./view-ids";
 
 // Declared here rather than sniffed: the desktop view and the hosted browser
 // app are both browser contexts but differ in what plugins may do.
@@ -156,6 +161,8 @@ async function boot() {
     officialPluginIds: loadOfficialPluginIds,
   });
   installAttentionCounter(() => !init.telemetry.optedOut && !browserDoNotTrack() && attentionCountsEnabled(currentTelemetryConfig(init.config)));
+  // Desktop has no Debug Log: this window's freezes go to the Bun process, which keeps the stall log.
+  setStallSink(forwardAttendedStalls(sendElectrobunStall).sink);
   installElectrobunCapabilityStreamClient();
   installFocusScopeRelease();
   installElectrobunWindowFullscreenTracking();
@@ -173,10 +180,26 @@ async function boot() {
   const desktopApplicationMenuBridge: DesktopApplicationMenuBridge = {
     subscribe: (listener) => onBackendMessage("application-menu.select", ({ command }) => listener(command)),
   };
+  // Before anything reads them: ids this view's storage lacks come back from
+  // the copy on disk, and the main window keeps that copy up to date. The sync
+  // id is made at the first push, and a gloom.sh link can bring a visitor id.
+  const viewStorage = viewIdStorage();
+  if (viewStorage) restoreViewIds(viewStorage, init.viewIds);
+  const mirrorViewIds = viewStorage && init.windowKind === "main"
+    ? createViewIdMirror(viewStorage, init.viewIds, (ids) => backendRequest("host.saveViewIds", { ids }))
+    : () => {};
+  mirrorViewIds();
+  cloudSyncController.subscribe(mirrorViewIds);
   initializeDesktopResearchActivity();
-  const desktopDeepLinkBridge = observeDesktopDeepLinks({
+  const observedDeepLinks = observeDesktopDeepLinks({
     subscribe: (listener) => onBackendMessage("desktop.deepLink", listener),
   });
+  const desktopDeepLinkBridge: typeof observedDeepLinks = {
+    subscribe: (listener) => observedDeepLinks.subscribe((deeplink) => {
+      listener(deeplink);
+      mirrorViewIds();
+    }),
+  };
   const webUiHost = createWebUiHost(init.desktopPlatform);
   // Compiled by the Bun process, which owns the filesystem. A failure here must
   // not stop the app from starting: the marketplace reports broken plugins, and

package/src/renderers/electrobun/view/news-source.ts

@@ -2,6 +2,7 @@ import { apiClient } from "../../../api-client";
 import { newsProvider, type NewsCapability } from "../../../capabilities";
 import { cloudNewsReadArticles, mapCloudNewsArticle, readCloudNews } from "../../../sources/gloomberb-cloud/news";
 import type { NewsArticle, NewsPage, NewsQuery } from "../../../news/types";
+import { readCompanyFrom } from "../../../types/company-from";
 
 interface BackendNews {
   id: string;
@@ -10,7 +11,8 @@ interface BackendNews {
   getNewsPage(query: NewsQuery): Promise<NewsPage>;
 }
 
-type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "getCloudNewsStory" | "searchCloudNews">;
+type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "getCloudNewsStory" | "searchCloudNews">
+  & Partial<Pick<typeof apiClient, "hasSessionCredential">>;
 
 /**
  * The view's only news source: the desktop view runs without capability
@@ -32,6 +34,8 @@ export function createDesktopNewsSource(backend: BackendNews, client: CloudNewsC
           return {
             articles: cloudNewsReadArticles(read, query.ticker),
             nextCursor: read.nextCursor ?? null,
+            access: read.access ?? null,
+            companyFrom: readCompanyFrom(read.companyFrom),
           };
         } catch {
           // The aggregate page keeps RSS failures beside any usable stories.

package/src/renderers/electrobun/view/remote/ticker-repository.ts

@@ -1,5 +1,6 @@
 import type { TickerMetadata, TickerRecord } from "../../../../types/ticker";
 import { backendRequest } from "../backend-rpc";
+import { runTickerWrite } from "../../../../data/ticker-writes";
 
 export class RemoteTickerRepository {
   async loadAllTickers(): Promise<TickerRecord[]> {
@@ -10,17 +11,23 @@ export class RemoteTickerRepository {
     return backendRequest("ticker.load", { symbol });
   }
 
-  async saveTicker(ticker: TickerRecord): Promise<void> {
-    await backendRequest("ticker.save", { ticker });
+  saveTicker(ticker: TickerRecord): Promise<void> {
+    return runTickerWrite(this, ticker.metadata.ticker, async () => {
+      await backendRequest("ticker.save", { ticker });
+    });
   }
 
-  async createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
+  createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
     const ticker: TickerRecord = { metadata };
-    await this.saveTicker(ticker);
-    return ticker;
+    return runTickerWrite(this, metadata.ticker, async () => {
+      await backendRequest("ticker.save", { ticker });
+      return ticker;
+    });
   }
 
-  async deleteTicker(symbol: string): Promise<void> {
-    await backendRequest("ticker.delete", { symbol });
+  deleteTicker(symbol: string): Promise<void> {
+    return runTickerWrite(this, symbol, async () => {
+      await backendRequest("ticker.delete", { symbol });
+    });
   }
 }

package/src/renderers/electrobun/view/ui-host.tsx

@@ -5,6 +5,7 @@ import { backendRequest } from "./backend-rpc";
 import { NATIVE_CONTEXT_MENU_SUPPORTED, showDesktopContextMenu } from "./host/native";
 import { startElectrobunWindowDrag } from "./host/window-move";
 import { createDomUiHost } from "../../dom/dom-ui-host";
+import { detectPlatform } from "../../../utils/platform";
 
 export function createWebUiHost(desktopPlatform?: string): UiHost {
   return createDomUiHost(desktopPlatform, {
@@ -25,6 +26,13 @@ export const webRendererHost: RendererHost = {
     });
   },
   startWindowDrag() {
+    // Windows moves the window itself, as it does from a native title bar.
+    if (detectPlatform() === "win32") {
+      void backendRequest("host.startWindowDrag").catch((error: unknown) => {
+        console.error("[desktop] could not start moving the window", error instanceof Error ? error.message : String(error));
+      });
+      return;
+    }
     startElectrobunWindowDrag();
   },
   async controlWindow(action) {

package/src/renderers/electrobun/view/view-ids.ts

@@ -0,0 +1,85 @@
+import { ANONYMOUS_ID_STORAGE_KEY, ATTRIBUTION_STORAGE_KEY } from "../../../api-client/research-activity";
+import { SYNC_CLIENT_ID_STORAGE_KEY } from "../../../sync/controller";
+import { logFailure } from "../../../utils/log-failure";
+import type { DesktopViewIds } from "../shared/protocol";
+
+/**
+ * What the desktop view keeps only in its WebView storage: the id Cloud sync
+ * knows this device by, and the visitor id and first touch a gloom.sh link
+ * handed over. macOS and Windows keep that storage under the app's bundle
+ * identifier, so a build under another identifier would start without them.
+ * The Bun process keeps a copy in the data folder (bun/desktop/view-ids.ts),
+ * and a view whose storage lacks one takes it back from there.
+ */
+const VIEW_ID_KEYS = [SYNC_CLIENT_ID_STORAGE_KEY, ANONYMOUS_ID_STORAGE_KEY, ATTRIBUTION_STORAGE_KEY] as const;
+
+interface ViewIdStorage {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+/** The view's WebView storage, or null where it is refused. */
+export function viewIdStorage(): ViewIdStorage | null {
+  try {
+    return globalThis.localStorage ?? null;
+  } catch {
+    // Intentional ignore: without storage there is nothing to restore or keep.
+    return null;
+  }
+}
+
+function readViewIds(storage: ViewIdStorage): DesktopViewIds {
+  const ids: DesktopViewIds = {};
+  for (const key of VIEW_ID_KEYS) {
+    const value = storage.getItem(key);
+    if (value) ids[key] = value;
+  }
+  return ids;
+}
+
+function sameIds(left: DesktopViewIds, right: DesktopViewIds): boolean {
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => left[key] === right[key]);
+}
+
+/** Puts the ids kept on disk into `storage` where it has none. One it has is never replaced. */
+export function restoreViewIds(storage: ViewIdStorage, kept: DesktopViewIds | undefined): void {
+  try {
+    for (const key of VIEW_ID_KEYS) {
+      const value = kept?.[key];
+      if (value && !storage.getItem(key)) storage.setItem(key, value);
+    }
+  } catch (error) {
+    logFailure("desktop-view-ids", "Could not restore the view's ids")(error);
+  }
+}
+
+/**
+ * A function that sends the ids in `storage` to be kept on disk when they
+ * differ from the copy there (`kept`, from `init`). It reads three keys, so it
+ * can run whenever one of them may have been written. A save that fails is
+ * tried again at the next call.
+ */
+export function createViewIdMirror(
+  storage: ViewIdStorage,
+  kept: DesktopViewIds | undefined,
+  save: (ids: DesktopViewIds) => Promise<unknown>,
+): () => void {
+  let onDisk: DesktopViewIds = { ...kept };
+  return () => {
+    let ids: DesktopViewIds;
+    try {
+      ids = readViewIds(storage);
+    } catch (error) {
+      logFailure("desktop-view-ids", "Could not read the view's ids")(error);
+      return;
+    }
+    if (sameIds(ids, onDisk)) return;
+    const previous = onDisk;
+    onDisk = ids;
+    save(ids).catch((error: unknown) => {
+      if (onDisk === ids) onDisk = previous;
+      logFailure("desktop-view-ids", "Could not send the view's ids to be kept")(error);
+    });
+  };
+}

package/src/renderers/opentui/start.tsx

@@ -38,6 +38,9 @@ import {
 } from "../../telemetry/crash-reports-node";
 import { currentTelemetryConfig } from "../../telemetry/live-config";
 import { installUpdateFailureReporter } from "../../telemetry/update-failures";
+import { installStallReporter, recordStall } from "../../telemetry/stall-reports";
+import { createNodeStallReporterHost } from "../../telemetry/stall-reports-node";
+import { setStallSink } from "../../utils/main-thread-stall";
 import { createNodeUpdateFailureHost } from "../../telemetry/update-failures-node";
 import { terminalInstallKind } from "../../updater";
 import { flushUsageCounts, installUsageCounter, usageCountsEnabled } from "../../telemetry/usage-counts";
@@ -124,6 +127,8 @@ export async function startOpenTuiApp({ externalPlugins, cliLaunchRequest }: Sta
       installKind: terminalInstallKind(),
       getDataDir: () => config.dataDir,
     }));
+    installStallReporter(createNodeStallReporterHost({ getDataDir: () => config.dataDir }));
+    setStallSink((event) => recordStall("terminal", event));
     installUsageCounter({
       surface: "terminal",
       os: describeNodeOs(),

package/src/series/registry.ts

@@ -63,6 +63,7 @@ export function seriesCatalogEntry(series: RegisteredSeries): SeriesCatalogEntry
     ...(definition.description ? { description: definition.description } : {}),
     ...(definition.publisher ? { publisher: definition.publisher } : {}),
     ...(definition.url ? { url: definition.url } : {}),
+    ...(definition.limitation ? { limitation: definition.limitation } : {}),
     ...(definition.input ? { input: definition.input } : {}),
     ...(definition.placement ? { placement: definition.placement } : {}),
     ...(definition.lines?.length ? {

package/src/series/types.ts

@@ -133,6 +133,11 @@ interface SeriesDefinitionBase {
   publisher?: string;
   /** The publisher's page for the series. */
   url?: string;
+  /**
+   * A limit on the data the publisher sets, such as a cap on how far back its
+   * history goes. One sentence: the catalog lists it beside the series.
+   */
+  limitation?: string;
   /** Ask for a ticker, an option or a crypto pair before charting. */
   input?: SeriesInput;
   /**
@@ -203,6 +208,7 @@ export interface SeriesCatalogEntry {
   description?: string;
   publisher?: string;
   url?: string;
+  limitation?: string;
   input?: SeriesInput;
   placement?: SeriesPlacement;
   /** The lines of a series that draws several, each with the expression that charts it alone. */

package/src/series/validate.ts

@@ -136,6 +136,7 @@ export function validateSeriesDefinition(definition: SeriesDefinition, context:
   checkLabel(id, "group", definition.group, 32, context);
   checkLabel(id, "description", definition.description, 300, context);
   checkLabel(id, "publisher", definition.publisher, 60, context);
+  checkLabel(id, "limitation", definition.limitation, 160, context);
   if (definition.tags !== undefined) {
     if (!Array.isArray(definition.tags) || definition.tags.length > 16) fail(id, "tags must be a list of at most 16 words.");
     for (const tag of definition.tags) checkLabel(id, "tag", tag, 40, context, false);

package/src/sources/gloomberb-cloud/fred-series.ts

@@ -42,6 +42,8 @@ export interface FredSeriesCacheEntry {
 export interface FredSeriesLoadResult extends FredSeriesCacheEntry {
   source: "cache" | "network" | "stale-fallback";
   refreshError?: string;
+  /** What the failed refresh threw, when a saved copy answered (`stale-fallback`). */
+  error?: unknown;
 }
 
 const cache = createPluginCache<FredSeriesData>({
@@ -197,6 +199,6 @@ export async function loadCachedFredSeries(
   if (!options?.force && !pending && cached && !cached.stale) return { ...cached, source: "cache" };
   const result = await cache.load(cacheKey(request), loader, pending ? { ...options, force: true } : options);
   // An early re-read is opportunistic: a failure keeps the still-fresh copy as it was.
-  if (pending && result.refreshError && cached && !cached.stale && !options?.force) return { ...cached, source: "cache" };
+  if (pending && result.source === "stale-fallback" && cached && !cached.stale && !options?.force) return { ...cached, source: "cache" };
   return withFredSourceFreshness(result);
 }