@gloom-sh/terminal 0.19.1 → 0.19.3

package/src/renderers/electrobun/bun/window/attention.ts

@@ -0,0 +1,54 @@
+import { setStallAttentionProbe, type StallAttention } from "../../../../telemetry/stall-reports";
+
+/** What this needs of a window: its id, its minimized state and its events. */
+interface AttentionWindow {
+  id: number;
+  isMinimized(): boolean;
+  on?(name: string, handler: (event: unknown) => void): void;
+}
+
+const openWindows = new Map<number, AttentionWindow>();
+let focusedWindowId: number | null = null;
+let sawFocusChange = false;
+
+/**
+ * Whether anyone was looking when the desktop app's Bun process froze. The
+ * system slows a hidden app's timers, which reads like a freeze, so a stall
+ * report from this process says whether one of the app's windows had the
+ * keyboard (the app was in front) and whether one was open and not
+ * minimized. Read only for a stall about to be reported.
+ */
+function desktopAttention(): StallAttention {
+  let visible: boolean | null = false;
+  try {
+    for (const window of openWindows.values()) {
+      if (!window.isMinimized()) {
+        visible = true;
+        break;
+      }
+    }
+  } catch {
+    visible = null;
+  }
+  return { active: sawFocusChange ? focusedWindowId !== null : null, visible };
+}
+
+/** Follows a window the app opened until it closes; the first one installs the probe. */
+export function trackWindowAttention(window: AttentionWindow): void {
+  if (openWindows.size === 0) setStallAttentionProbe(desktopAttention);
+  openWindows.set(window.id, window);
+  window.on?.("focus", () => {
+    focusedWindowId = window.id;
+    sawFocusChange = true;
+  });
+  window.on?.("blur", () => {
+    // Focus moving between two of the app's windows can report the new
+    // window's focus before the old one's blur.
+    if (focusedWindowId === window.id) focusedWindowId = null;
+    sawFocusChange = true;
+  });
+  window.on?.("close", () => {
+    openWindows.delete(window.id);
+    if (focusedWindowId === window.id) focusedWindowId = null;
+  });
+}

package/src/renderers/electrobun/bun/window/create.ts

@@ -1,4 +1,6 @@
 import { BrowserWindow } from "electrobun/bun";
+import { measurePerf } from "../../../../utils/perf-marks";
+import { trackWindowAttention } from "./attention";
 import {
   applyNativeWindowFrame,
   applyWindowMoveEvent,
@@ -83,7 +85,8 @@ interface AppWindowOptions {
  * its cached frame current as it moves, and holds it to `minSize` on resize.
  */
 export function createAppWindow({ title, frame, rpc, minSize, onFrameChange, preload }: AppWindowOptions): BrowserWindow {
-  const window = new BrowserWindow({
+  // Opening a window waits on the native layer, the webview's creation included.
+  const window = measurePerf("native.window.create", () => new BrowserWindow({
     title,
     frame,
     url: APP_VIEW_URL,
@@ -94,7 +97,7 @@ export function createAppWindow({ title, frame, rpc, minSize, onFrameChange, pre
     titleBarStyle: desktopTitleBarStyle(),
     navigationRules: JSON.stringify(["views://*"]),
     sandbox: false,
-  });
+  }));
   applyWindowsWindowIcon(title);
   applyWindowsCustomChrome(title);
   if (process.platform === "win32") {
@@ -105,6 +108,7 @@ export function createAppWindow({ title, frame, rpc, minSize, onFrameChange, pre
     });
   }
   updateWindowFrameCache(window, frame, minSize);
+  trackWindowAttention(window);
   const readsNativeFrame = process.platform === "win32";
   (window as any).on?.("move", (event: WindowMoveEvent) => {
     if (readsNativeFrame) {

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

@@ -0,0 +1,48 @@
+import { BrowserView, BrowserWindow } from "electrobun/bun";
+import { measurePerf } from "../../../../utils/perf-marks";
+
+/**
+ * Electrobun's window and webview calls that go to the native layer. On
+ * Windows each one is answered on the thread that runs the windows, and this
+ * process waits for it: while that thread is busy, so is this one.
+ */
+const WINDOW_CALLS = [
+  "activate", "close", "show", "showInactive", "hide", "minimize", "unminimize", "maximize", "unmaximize",
+  "isMinimized", "isMaximized", "isFullScreen", "setFullScreen", "isAlwaysOnTop", "setAlwaysOnTop",
+  "setTitle", "setPosition", "setSize", "setFrame", "getFrame",
+];
+const VIEW_CALLS = [
+  "executeJavascript", "loadURL", "loadHTML", "setNavigationRules", "openDevTools", "closeDevTools", "toggleDevTools",
+  "setPageZoom",
+];
+
+let measured = false;
+
+/** `getFrame` as a stall report keeps it: `get-frame`. */
+function sectionPart(name: string): string {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+
+function measureCalls(prototype: object, prefix: string, names: readonly string[]): void {
+  const methods = prototype as Record<string, unknown>;
+  for (const name of names) {
+    const original = methods[name];
+    if (typeof original !== "function") continue;
+    const section = `${prefix}.${sectionPart(name)}`;
+    methods[name] = function measuredNativeCall(this: unknown, ...args: unknown[]) {
+      return measurePerf(section, () => original.apply(this, args));
+    };
+  }
+}
+
+/**
+ * Names each native window and webview call (`native.window.get-frame`,
+ * `native.view.execute-javascript`), so a stall inside or right after one
+ * says so instead of naming whatever was measured last. Once per process.
+ */
+export function measureNativeWindowCalls(): void {
+  if (measured) return;
+  measured = true;
+  measureCalls(BrowserWindow.prototype, "native.window", WINDOW_CALLS);
+  measureCalls(BrowserView.prototype, "native.view", VIEW_CALLS);
+}

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

@@ -16,8 +16,12 @@ import { JsonTickerRepository } from "../../../data/json-ticker-repository";
 import type { DesktopPaneShotPayload } from "../../../cli/desktop-pane-shot";
 import {
   SHOT_API_PROXY_PREFIX,
+  SHOT_API_SOCKET_PATH,
   SHOT_HTTP_BRIDGE_PATH,
   SHOT_MARKET_BRIDGE_PATH,
+  shotRouteUrl,
+  type ShotApiSocketCall,
+  type ShotApiSocketReply,
 } from "../../../cli/desktop-pane-shot-routes";
 import { instrumentFromTicker } from "../../../market-data/request-types";
 import type { RendererHost } from "../../../ui/host";
@@ -95,6 +99,12 @@ const TRACKED_RESPONSE_METHODS = new Set<PropertyKey>([
   "text",
 ]);
 
+/**
+ * The page's own address, read once before anything can change it: the
+ * server answers only inside the secret folder the page opened at.
+ */
+const SHOT_PAGE_URL = window.location.href;
+
 let pendingShotWork = 0;
 let didInstallShotFetchTracker = false;
 const rendererHost: RendererHost = {
@@ -142,22 +152,90 @@ function installShotFetchTracker(): void {
   )) as typeof fetch;
 }
 
+/** Sends a read over the socket; null once the socket has closed. */
+type ShotApiSocketSend = (call: Omit<ShotApiSocketCall, "id">, signal: AbortSignal | null | undefined) => Promise<Response> | null;
+
+/**
+ * Cloud API reads over one socket to the Bun server, answered as each lands.
+ * A page's fetches share six connections to its origin, so a board's seventy
+ * contract histories and terms waited on each other for seconds. Null when
+ * the socket does not open; the page's fetch carries the reads then, and
+ * once the socket closes.
+ */
+function openShotApiSocket(): Promise<ShotApiSocketSend | null> {
+  return new Promise((resolve) => {
+    const pending = new Map<number, (reply: ShotApiSocketReply | null) => void>();
+    let nextId = 1;
+    let open = false;
+    const url = shotRouteUrl(SHOT_API_SOCKET_PATH, SHOT_PAGE_URL);
+    url.protocol = "ws:";
+    const socket = new WebSocket(url);
+    socket.addEventListener("message", (event) => {
+      let reply: ShotApiSocketReply;
+      try {
+        reply = JSON.parse(String(event.data)) as ShotApiSocketReply;
+      } catch {
+        // Intentional ignore: every reply the server sends is JSON; anything else answers no call.
+        return;
+      }
+      pending.get(reply.id)?.(reply);
+      pending.delete(reply.id);
+    });
+    socket.addEventListener("close", () => {
+      open = false;
+      for (const settle of pending.values()) settle(null);
+      pending.clear();
+      resolve(null);
+    });
+    socket.addEventListener("open", () => {
+      open = true;
+      resolve((call, signal) => !open ? null : new Promise<Response>((answer, fail) => {
+        const aborted = () => fail(signal?.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+        if (signal?.aborted) return aborted();
+        const id = nextId++;
+        const onAbort = () => {
+          pending.delete(id);
+          aborted();
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        pending.set(id, (reply) => {
+          signal?.removeEventListener("abort", onAbort);
+          // A socket that closed mid-read is a request that never got an answer, as a dropped connection is to fetch.
+          if (!reply) return fail(new TypeError("Failed to fetch"));
+          if ("error" in reply) return fail(new TypeError(reply.error));
+          const bytes = Uint8Array.from(atob(reply.body), (char) => char.charCodeAt(0));
+          const empty = bytes.length === 0 || reply.status === 204 || reply.status === 304;
+          answer(new Response(empty ? null : bytes, { status: reply.status, statusText: reply.statusText, headers: reply.headers }));
+        });
+        socket.send(JSON.stringify({ id, ...call } satisfies ShotApiSocketCall));
+      }));
+    }, { once: true });
+  });
+}
+
 function installShotCloudApiTransport(): void {
   apiClient.setCookieSessionMode(true);
+  let socket: Promise<ShotApiSocketSend | null> | null = null;
   setCloudApiFetchTransport((url, init = {}) => {
     const upstream = new URL(url);
-    const proxyUrl = new URL(`${SHOT_API_PROXY_PREFIX}${upstream.pathname}`, window.location.origin);
+    const proxyUrl = shotRouteUrl(`${SHOT_API_PROXY_PREFIX}${upstream.pathname}`, SHOT_PAGE_URL);
     proxyUrl.search = upstream.search;
     const headers = new Headers(init.headers);
     // Bun owns the real session cookie. The browser only talks to the local
     // same-origin proxy and never receives or serializes the credential.
     headers.delete("Cookie");
     headers.delete("Origin");
-    return window.fetch(proxyUrl, {
+    const viaFetch = () => window.fetch(proxyUrl, {
       ...init,
       headers,
       credentials: "same-origin",
     });
+    if ((init.method ?? "GET").toUpperCase() !== "GET" || init.body != null) return viaFetch();
+    return trackShotWork((async () => {
+      socket ??= openShotApiSocket();
+      const send = await socket;
+      return await send?.({ path: `${upstream.pathname}${upstream.search}`, headers: [...headers] }, init.signal) ?? await viaFetch();
+    })());
   });
 }
 
@@ -168,7 +246,7 @@ function installShotCloudApiTransport(): void {
  */
 function installShotHttpFetchTransport(): void {
   setHttpFetchTransport(async (url, init) => {
-    const response = await window.fetch(SHOT_HTTP_BRIDGE_PATH, {
+    const response = await window.fetch(shotRouteUrl(SHOT_HTTP_BRIDGE_PATH, SHOT_PAGE_URL), {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(await toRequestEnvelope(url, init)),
@@ -190,7 +268,7 @@ async function restoreShotCloudSession(): Promise<void> {
  * of the corporate action history come from providers the router merges in.
  */
 async function requestShotMarketData<T>(operation: string, args: unknown[], signal?: AbortSignal): Promise<T> {
-  const response = await window.fetch(SHOT_MARKET_BRIDGE_PATH, {
+  const response = await window.fetch(shotRouteUrl(SHOT_MARKET_BRIDGE_PATH, SHOT_PAGE_URL), {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ operation, args }),

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

@@ -14,7 +14,9 @@ declare global {
      * Set by a capture that carries a status line: shows the first of the
      * variants (longest first) that fits the footer, cut in the middle when
      * none does, and resolves to the text shown. `dates` says what the line
-     * dates, so the pane's own text that says the same goes.
+     * dates, so the pane's own text that says the same goes. With no variants
+     * the pane has nothing to date: the footer row is given back to the body
+     * and the text shown is empty.
      */
     __GLOOM_CLI_SHOT_FIT_STATUS__?: (variants: string[], options?: { dates?: ShotLineDates }) => Promise<string>;
   }
@@ -90,22 +92,28 @@ function footerOverflows(): boolean {
 }
 
 interface ShotStatusLineState {
-  text: string;
+  /** Null once the capture has no line to show: the footer row is gone. */
+  text: string | null;
   dates: ShotLineDates;
   /** No variant fit beside the pane's own `as of`, so it gave way. */
   crowded: boolean;
 }
 
 function useShotStatusLine(enabled: boolean, hasAsOf: () => boolean): ShotStatusLineState {
-  const [text, setText] = useState(PENDING_STATUS);
+  const [text, setText] = useState<string | null>(PENDING_STATUS);
   const [dates, setDates] = useState<ShotLineDates>(null);
   const [crowded, setCrowded] = useState(false);
   useEffect(() => {
     if (!enabled) return;
     // What the line says goes before it is fitted, so the line gets its room.
-    window.__GLOOM_CLI_SHOT_FIT_STATUS__ = (variants, options) => {
+    window.__GLOOM_CLI_SHOT_FIT_STATUS__ = async (variants, options) => {
       setDates(options?.dates ?? null);
       setCrowded(false);
+      if (variants.length === 0) {
+        setText(null);
+        await nextFrames(2);
+        return "";
+      }
       const show = async (next: string) => {
         setText(next);
         await nextFrames(2);
@@ -148,7 +156,7 @@ export function PaneShotFrame({ paneId, title, width, height, preserveStatus = f
   const { text: statusText, dates, crowded } = useShotStatusLine(statusLine, hasAsOf);
   const datesData = statusLine && dates === "data";
   return <PaneFooterProvider>{(registeredFooter) => {
-    const status: PaneFooterSegment[] = statusLine ? [{ id: "shot-status", parts: [{ text: statusText, tone: "label" }] }] : [];
+    const status: PaneFooterSegment[] = statusLine && statusText !== null ? [{ id: "shot-status", parts: [{ text: statusText, tone: "label" }] }] : [];
     const info = registeredFooter.info.filter((segment) => (preserveStatus || segment.icon === "warning" || segment.capture)
       && !(datesPaneData(segment) && (datesData || crowded))
       && !(segment.quoteStatus && statusLine && dates !== null));

package/src/renderers/electrobun/view/desktop/window/snapshot.ts

@@ -36,6 +36,9 @@ export function detachedSnapshotKey(snapshot: DesktopSharedStateSnapshot, paneId
     pluginConfig: snapshot.config.pluginConfig,
     disabledPlugins: snapshot.config.disabledPlugins,
     chartPreferences: snapshot.config.chartPreferences,
+    // A popped-out window collects Attention Counts on its own, so turning
+    // them off in the main window has to reach it.
+    telemetry: snapshot.config.telemetry ?? null,
     instances: paneStateIds.map((id) => findPaneInstance(snapshot.config.layout, id) ?? null),
     paneState: Object.fromEntries(paneStateIds.map((id) => [id, snapshot.paneState[id] ?? {}])),
   });

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

@@ -53,7 +53,7 @@ import { crashReportsEnabled, installCrashReporter, reportCrash } from "../../..
 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 { installAttentionCounter } from "../../../telemetry/attention-counts";
 import { installUsageCounter, usageCountsEnabled } from "../../../telemetry/usage-counts";
 import { installWindowUsageFlush } from "../../../telemetry/usage-counts-dom";
 import { cloudSyncController } from "../../../sync/controller";
@@ -160,7 +160,12 @@ async function boot() {
     getInstallId: () => init.telemetry.installId,
     officialPluginIds: loadOfficialPluginIds,
   });
-  installAttentionCounter(() => !init.telemetry.optedOut && !browserDoNotTrack() && attentionCountsEnabled(currentTelemetryConfig(init.config)));
+  installAttentionCounter({
+    allowed: () => !init.telemetry.optedOut && !browserDoNotTrack(),
+    launchConfig: () => init.config,
+    // A popped-out window does not sync: the main window does, and sends it the settings it pulled.
+    ...(init.windowKind === "detached" ? { accountSettingsPulled: () => true } : {}),
+  });
   // Desktop has no Debug Log: this window's freezes go to the Bun process, which keeps the stall log.
   setStallSink(forwardAttendedStalls(sendElectrobunStall).sink);
   installElectrobunCapabilityStreamClient();

package/src/renderers/electrobun/view/remote/asset-data-client.ts

@@ -31,6 +31,7 @@ type PayloadBuilder = (...args: unknown[]) => Record<string, unknown>;
 const assetDataPayloads: Record<string, PayloadBuilder> = {
   canProvide: (ticker, exchange, context) => ({ ticker, exchange, context }),
   primaryMarketSourceName: () => ({}),
+  batchesReads: (method) => ({ method }),
   getCachedFinancialsForTargets: (targets, options) => ({ targets, options }),
   // An abort signal does not cross the bridge; the board stops waiting instead.
   getQuotesBatch: (targets, options) => {

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

@@ -25,9 +25,16 @@ export const webRendererHost: RendererHost = {
       void backendRequest("host.exit").catch(() => window.close());
     });
   },
-  startWindowDrag() {
-    // Windows moves the window itself, as it does from a native title bar.
+  startWindowDrag(press) {
+    // Windows moves the window itself, as it does from a native title bar, and
+    // a double-click there maximizes or restores it.
     if (detectPlatform() === "win32") {
+      if (press?.detail === 2) {
+        void backendRequest("host.windowControl", { action: "toggle-maximize" }).catch((error: unknown) => {
+          console.error("[desktop] could not maximize the window", error instanceof Error ? error.message : String(error));
+        });
+        return;
+      }
       void backendRequest("host.startWindowDrag").catch((error: unknown) => {
         console.error("[desktop] could not start moving the window", error instanceof Error ? error.message : String(error));
       });

package/src/renderers/opentui/browser-open.ts

@@ -6,6 +6,8 @@
  * nothing opened and can show the link instead.
  */
 
+import { systemOpenCommand } from "../../utils/external-url";
+
 type Env = Readonly<Record<string, string | undefined>>;
 
 function present(value: string | undefined): boolean {
@@ -35,27 +37,31 @@ export function browserOpenCommands(url: string, env: Env, platform: NodeJS.Plat
   const forwarded = present(env.BROWSER) ? envBrowserCommand(env.BROWSER!, url) : null;
 
   if (platform === "darwin") {
-    if (!remote) return [["open", url]];
+    const opener = systemOpenCommand(url, platform);
+    if (!remote) return opener ? [opener] : [];
     return forwarded ? [forwarded] : [];
   }
   if (platform === "win32") {
-    if (!remote) return [["cmd", "/c", "start", "", url]];
+    const opener = systemOpenCommand(url, platform);
+    if (!remote) return opener ? [opener] : [];
     return forwarded ? [forwarded] : [];
   }
 
   // Linux and the other unixes. WSL has no Linux browser, but Windows can
   // open the link: `wslview` when wslu is installed, else Windows' own handler.
   if (present(env.WSL_DISTRO_NAME) || present(env.WSL_INTEROP)) {
+    const windowsOpener = systemOpenCommand(url, "win32");
     return [
       ...(forwarded ? [forwarded] : []),
       ["wslview", url],
-      ["rundll32.exe", "url.dll,FileProtocolHandler", url],
+      ...(windowsOpener ? [windowsOpener] : []),
     ];
   }
   const display = present(env.DISPLAY) || present(env.WAYLAND_DISPLAY);
   // xdg-open reads $BROWSER itself, so a forwarding helper still applies.
   if (remote && !display && !forwarded) return [];
-  return [["xdg-open", url]];
+  const opener = systemOpenCommand(url, platform);
+  return opener ? [opener] : [];
 }
 
 /** How long an opener may run before it counts as having opened the browser. */

package/src/renderers/opentui/image/surface.tsx

@@ -25,7 +25,7 @@ function resolveInsets(props: Record<string, unknown>): CellInsets {
 }
 
 export const OpenTuiImageSurface = forwardRef<unknown, ImageSurfaceProps>(function OpenTuiImageSurface(
-  { children, src, alt: _alt, objectFit = "contain", ...props },
+  { children, src, alt: _alt, objectFit = "contain", fallbackWhileLoading: _fallbackWhileLoading, imageBackground: _imageBackground, ...props },
   forwardedRef,
 ) {
   const renderer = useNativeRenderer();

package/src/renderers/opentui/start.tsx

@@ -1,6 +1,7 @@
 import { hostname } from "os";
 import { getGloomberbDirs } from "../../data/config/home";
-import { existsSync, mkdirSync } from "fs";
+import { existsSync } from "fs";
+import { makePrivateDirSync } from "../../utils/private-files";
 import { App } from "../../app";
 import { getDataDir, initDataDir, loadConfig, setConfigStoreHost } from "../../data/config/store";
 import { applyLanguageFromConfig } from "../../i18n";
@@ -28,7 +29,7 @@ import { startRemoteControlServer, type RemoteControlServer } from "../../remote
 import { createAppServices } from "../../core/app-services";
 import { flushPendingPersistence } from "../../state/persist-scheduler";
 import { loadOfficialPluginIds } from "../../plugins/marketplace/feed";
-import { flushCrashReports, installCrashReporter } from "../../telemetry/crash-reports";
+import { flushCrashReports, installCrashReporter, telemetryOptedOut } from "../../telemetry/crash-reports";
 import {
   CRASH_REPORT_EXIT_FLUSH_MS,
   createNodeCrashReporterHost,
@@ -38,13 +39,14 @@ import {
 } from "../../telemetry/crash-reports-node";
 import { currentTelemetryConfig } from "../../telemetry/live-config";
 import { installUpdateFailureReporter } from "../../telemetry/update-failures";
+import { createStallClocks } from "../../telemetry/stall-clocks";
 import { installStallReporter, recordStall } from "../../telemetry/stall-reports";
 import { createNodeStallReporterHost } from "../../telemetry/stall-reports-node";
-import { setStallSink } from "../../utils/main-thread-stall";
+import { setStallClocks, 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";
-import { attentionCountsEnabled, installAttentionCounter } from "../../telemetry/attention-counts";
+import { installAttentionCounter } from "../../telemetry/attention-counts";
 import { starPromptEnvironmentAllows } from "../../app/star-prompt/model";
 import { allowStarPrompt } from "../../app/star-prompt/runtime";
 
@@ -114,7 +116,7 @@ export async function startOpenTuiApp({ externalPlugins, cliLaunchRequest }: Sta
     const dataDir = await getDataDir() ?? getGloomberbDirs().data;
 
     if (!existsSync(dataDir)) {
-      mkdirSync(dataDir, { recursive: true });
+      makePrivateDirSync(dataDir);
     }
 
     const config = await measurePerfAsync("startup.opentui.init-data-dir", () => initDataDir(dataDir));
@@ -129,6 +131,7 @@ export async function startOpenTuiApp({ externalPlugins, cliLaunchRequest }: Sta
     }));
     installStallReporter(createNodeStallReporterHost({ getDataDir: () => config.dataDir }));
     setStallSink((event) => recordStall("terminal", event));
+    setStallClocks(createStallClocks());
     installUsageCounter({
       surface: "terminal",
       os: describeNodeOs(),
@@ -136,7 +139,10 @@ export async function startOpenTuiApp({ externalPlugins, cliLaunchRequest }: Sta
       getInstallId: () => readOrCreateInstallId(config.dataDir),
       officialPluginIds: loadOfficialPluginIds,
     });
-    const stopAttention = installAttentionCounter(() => attentionCountsEnabled(currentTelemetryConfig(config), process.env));
+    const stopAttention = installAttentionCounter({
+      allowed: () => !telemetryOptedOut(process.env),
+      launchConfig: () => config,
+    });
     allowStarPrompt(starPromptEnvironmentAllows({
       env: process.env,
       stdinIsTTY: process.stdin.isTTY,

package/src/renderers/opentui/toast-host.tsx

@@ -2,7 +2,7 @@
 import { useTerminalDimensions } from "@opentui/react";
 import { useSyncExternalStore } from "react";
 import { colors } from "../../theme/colors";
-import { createToastStore, type ToastHost, type ToastTone } from "../../ui/toast";
+import { createToastStore, useToastsShown, type ToastHost, type ToastTone } from "../../ui/toast";
 import { useActionShortcut } from "../../ui";
 import { displayWidth } from "../../utils/format";
 
@@ -26,6 +26,7 @@ function toneIcon(tone: ToastTone): string {
 function ToastViewport({ position = "bottom-right" }: { position?: string }) {
   const dimensions = useTerminalDimensions();
   const shownToasts = useSyncExternalStore(toastStore.subscribe, toastStore.getSnapshot, toastStore.getSnapshot);
+  useToastsShown(shownToasts);
   const actionShortcut = useActionShortcut("notification-action");
   const maxWidth = Math.max(1, Math.min(60, dimensions.width - 4));
   const placement = position.startsWith("top") ? { top: 1 } : { bottom: 1 };

package/src/series/registry.ts

@@ -23,6 +23,24 @@ export function seriesExpression(definition: SeriesDefinition): string {
   return definition.expression ?? loadedSeriesExpression(definition);
 }
 
+/**
+ * The one catalog series a bare word is an alias of (`hashrate` is
+ * `bitcoin:hashrate`), for a chart typed with the word where a ticker goes.
+ * Only the words a series lists as its `aliases`, never any other id or
+ * name, and none that two series claim.
+ */
+export function seriesNamedBy(definitions: Iterable<SeriesDefinition>, word: string): SeriesDefinition | undefined {
+  const wanted = word.trim().toLowerCase();
+  if (!wanted) return undefined;
+  let found: SeriesDefinition | undefined;
+  for (const definition of definitions) {
+    if (definition.input || !definition.aliases?.includes(wanted)) continue;
+    if (found && found.id !== definition.id) return undefined;
+    found = definition;
+  }
+  return found;
+}
+
 /**
  * The capability series id a loaded series charts under: its name, one of its
  * lines after a tilde, and for a series with an input, the symbol after a

package/src/series/resolve.ts

@@ -195,7 +195,7 @@ export async function resolveLoadedSeries(
 ): Promise<ResolvedSeries> {
   const ticker = request.ticker?.trim().toUpperCase() || undefined;
   const line = definition.lines?.length ? request.line ?? definition.lines[0] : undefined;
-  const { points, edge, warning, attribution } = loadResult(await loadSeries(definition, {
+  const { points, edge, warning, savedAt, attribution } = loadResult(await loadSeries(definition, {
     ...seriesLoadWindow(request.viewport, now),
     ...(ticker ? { ticker } : {}),
     ...viewportBars(request.viewport, ticker),
@@ -221,6 +221,7 @@ export async function resolveLoadedSeries(
     panelId: "main",
     interpolation: style === "step" ? "step-after" : "none",
     ...(warning ? { warning } : {}),
+    ...(savedAt != null && Number.isFinite(savedAt) ? { savedAt } : {}),
     ...(attribution ? { attribution: { ...attribution } } : {}),
     points: normalizeSeriesPoints(points, edge),
   };

package/src/series/standalone.ts

@@ -4,7 +4,7 @@ import type { CapabilityInvoker } from "../capabilities/types";
 import type { GloomPlugin } from "../types/plugin";
 import { resolveRegisteredSeries } from "./capability";
 import { readSeriesFolder } from "./files";
-import { SeriesRegistry, seriesExpression } from "./registry";
+import { SeriesRegistry, seriesExpression, seriesNamedBy } from "./registry";
 import type { SeriesDefinition } from "./types";
 
 /**
@@ -75,3 +75,12 @@ export function standaloneSeriesCatalog(
     return byExpression.get(expression);
   };
 }
+
+/** The catalog series a bare word is an alias of (`hashrate`), where no plugin runtime runs; see `seriesNamedBy`. */
+export function standaloneSeriesNamed(
+  plugins: readonly GloomPlugin[],
+  disabledPlugins: readonly string[] = [],
+): (word: string) => SeriesDefinition | undefined {
+  const definitions = () => plugins.filter((plugin) => !disabledPlugins.includes(plugin.id)).flatMap((plugin) => plugin.series ?? []);
+  return (word) => seriesNamedBy(definitions(), word);
+}

package/src/series/types.ts

@@ -92,6 +92,11 @@ export interface SeriesLoadResult {
   points: readonly SeriesPoint[];
   /** A note the chart shows above the plot, such as "cached data is stale". */
   warning?: string;
+  /**
+   * When the copy the points came from was saved (ms), when its refresh failed
+   * and that copy answered: the chart's footer says "saved copy from …".
+   */
+  savedAt?: number;
   /** What a report of this series cites in place of Gloom Cloud. */
   attribution?: SeriesAttribution;
 }
@@ -123,6 +128,13 @@ interface SeriesDefinitionBase {
   group?: string;
   /** Extra words the catalog search matches, such as a ticker the series is often read against. */
   tags?: readonly string[];
+  /**
+   * Words `fn G` charts the series by where a ticker goes (`hashrate`), each
+   * in lower case: only when no listing answers to the word, the quote source
+   * says it is not a ticker, and no other series has the word. A series with
+   * an `input` takes none.
+   */
+  aliases?: readonly string[];
   /** One sentence for the catalog search and for `gloomberb` automation. */
   description?: string;
   /**

package/src/series/validate.ts

@@ -23,11 +23,13 @@ const RATE_UNITS = ["%", "bp", "x", "ratio", "index", "score", "points"] as cons
 const QUANTITY_UNITS = [
   "number", "count", "units", "shares", "contracts", "days", "people", "jobs", "posts", "views", "hours",
   "barrels", "barrels/day", "cubic feet", "MW", "MWh", "TWh", "GWh/day", "tons", "ounces",
+  // A hash rate: exahashes per second.
+  "EH/s",
   // The instrument's own currency, for a field that applies to any ticker.
   "currency", "currency/share",
 ] as const;
-/** What a price is quoted per: `USD/barrel`, `USD/GPU-hour`. */
-const PER_UNITS = ["share", "barrel", "gallon", "MMBtu", "MWh", "ounce", "ton", "tCO2", "hour", "GPU-hour"] as const;
+/** What a price is quoted per: `USD/barrel`, `USD/GPU-hour`, a miner's `USD/PH/s/day`. */
+const PER_UNITS = ["share", "barrel", "gallon", "MMBtu", "MWh", "ounce", "ton", "tCO2", "hour", "GPU-hour", "PH/s/day"] as const;
 const SCALES = ["thousand", "million", "billion", "trillion"] as const;
 
 const RATE_SET: ReadonlySet<string> = new Set(RATE_UNITS);
@@ -141,6 +143,13 @@ export function validateSeriesDefinition(definition: SeriesDefinition, context:
     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);
   }
+  if (definition.aliases !== undefined) {
+    if (!Array.isArray(definition.aliases) || definition.aliases.length > 4) fail(id, "aliases must be a list of at most 4 words.");
+    if (definition.input !== undefined) fail(id, "a series with an input takes no aliases: the word would stand for a ticker.");
+    for (const alias of definition.aliases) {
+      if (typeof alias !== "string" || !/^[a-z][a-z-]{3,31}$/.test(alias)) fail(id, `alias "${String(alias)}" must be one lower-case word of 4 to 32 letters.`);
+    }
+  }
   if (definition.url !== undefined && (typeof definition.url !== "string" || !/^https?:\/\/\S+$/.test(definition.url))) {
     fail(id, "url must be an http or https address.");
   }