gloomberb 0.19.2 → 0.19.3

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/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/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

@@ -128,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.");
   }

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

@@ -18,6 +18,7 @@ import type {
   EarningsEvent,
   SecFilingDocument,
   SecFilingItem,
+  BatchedReadMethod,
   MarketDataRequestContext,
   QuoteBatchOptions,
   QuoteBatchResult,
@@ -48,7 +49,7 @@ import { canonicalExchange, canonicalTickerKey, parsePublicTickerKey } from "../
 import { normalizePriceHistory, priceHistoryIntervalMs, reachesLatestSettledSession } from "../../utils/price-history";
 import { createProviderMiss, ProviderBusyError, providerMissReason, StaleHistoryError } from "../provider-errors";
 import { parseListingDelisting } from "../../market-data/quotes/delisting";
-import { isRetryableApiError } from "../../api-client/errors";
+import { isRetryableApiError, markAskedTwice, sourceDidNotAnswer, wasAskedTwice } from "../../api-client/errors";
 import { assertSecRegistrantMatches } from "../sec-registrant";
 import { nonUsSecListingVenue } from "../../utils/sec";
 import { publicListingTarget } from "../listing-target";
@@ -66,6 +67,7 @@ import {
   GLOOMBERB_CLOUD_PROVIDER_ID,
   formatCloudDateTime,
   formatCloudHistoryEnd,
+  isCloudSourceFailure,
   isEmptyCloudStatus,
   mapBatchError,
   NOT_FOUND_REASON,
@@ -86,6 +88,7 @@ import {
   boardSearchesFrom,
 } from "./perpetuals";
 import { predictionMarketListing } from "../../tickers/prediction-listing";
+import { cleanListingName } from "../../tickers/company-name";
 import { settleWithin } from "../../utils/async-deadline";
 import { cloudSearchBatch, cloudTickerChangesBatch } from "./batched-lookups";
 
@@ -127,6 +130,7 @@ function mapCloudSecFiling(item: {
   primaryDocumentUrl?: string;
   fileNumber?: string;
   fundSeries?: boolean;
+  pressReleaseUrl?: string;
 }): SecFilingItem {
   return {
     accessionNumber: item.accessionNumber,
@@ -144,9 +148,20 @@ function mapCloudSecFiling(item: {
     // Absent from an older server: no file number is not the same as an empty one.
     ...(typeof item.fileNumber === "string" ? { fileNumber: item.fileNumber } : {}),
     ...(typeof item.fundSeries === "boolean" ? { fundSeries: item.fundSeries } : {}),
+    ...(typeof item.pressReleaseUrl === "string" && /^https:\/\/www\.sec\.gov\//.test(item.pressReleaseUrl)
+      ? { pressReleaseUrl: item.pressReleaseUrl } : {}),
   };
 }
 
+/** Search rows with a venue's fixed-width name cleaned of the stray code after its spaces ("Americold Realty Trust Inc.   R"). */
+function withCleanNames<T extends { name: string }>(rows: T[]): T[] {
+  return rows.map((row) => {
+    if (typeof row.name !== "string") return row;
+    const name = cleanListingName(row.name);
+    return name === row.name ? row : { ...row, name };
+  });
+}
+
 function isCloudProviderMiss(error: unknown): boolean {
   const message = error instanceof Error ? error.message : String(error);
   return CLOUD_PROVIDER_MISS_PATTERNS.some((pattern) => pattern.test(message));
@@ -420,6 +435,8 @@ function unwrapRequiredCloudResponse<T>(response: CloudMarketResponse<T>, messag
   if (isEmptyCloudStatus(response.status)) {
     throw createProviderMiss(response.reasonCode ?? message, response.message, { notFound: response.reasonCode === NOT_FOUND_REASON });
   }
+  // The service's own source failed on a listing read asked twice (`readListing`): not an answer that the listing has nothing.
+  if (isCloudSourceFailure(response.status) && wasAskedTwice(response)) throw markAskedTwice(sourceDidNotAnswer(response.reasonCode ?? message));
   throw new Error(response.reasonCode ?? message);
 }
 
@@ -647,7 +664,7 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     const pending = searchPerpetualMarkets(query).catch(logFailure("sources.gloomberb-cloud.index", "Searching perpetual markets failed", [] as InstrumentSearchResult[]));
     // A crypto exchange's line of a coin pair, which no source quotes, is offered as the crypto venue's listing.
     const listings = await withCloudFallback(
-      async () => withExchangeLinesAsCoinListings(await apiClient.searchInstruments(query, context?.limit ?? 10)),
+      async () => withExchangeLinesAsCoinListings(withCleanNames(await apiClient.searchInstruments(query, context?.limit ?? 10))),
       "Cloud search is unavailable",
     ).catch((error: unknown) => {
       // Rate limited or overloaded: the search was not run, which is not a search that found nothing.
@@ -764,7 +781,7 @@ export class GloomberbCloudProvider implements AssetDataProvider {
   async searchBatch(queries: string[], options: { limit?: number; signal?: AbortSignal } = {}): Promise<Map<string, InstrumentSearchResult[]> | null> {
     const answers = await cloudSearchBatch(queries, options);
     if (!answers) return null;
-    for (const [query, rows] of answers) answers.set(query, withExchangeLinesAsCoinListings(rows));
+    for (const [query, rows] of answers) answers.set(query, withExchangeLinesAsCoinListings(withCleanNames(rows)));
     // Perpetual markets lead each answer, as `search` gives them, so a symbol in a list resolves as it does alone:
     // one read of the board answers every query's search of it. A query that found no listing is searched again
     // on its own, which finds them then; a board that does not answer leaves them out, as a search does.
@@ -818,7 +835,8 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     exchange = target.exchange ?? "";
     const request = toHistoryRequest(range);
     const { response, extendedHours } = await withCloudFallback(
-      () => loadCloudHistory(request.interval, (session) => apiClient.getCloudHistory(target.symbol, exchange, { ...request, ...(session ? { session } : {}) }), _context),
+      () => loadCloudHistory(request.interval, (session) => apiClient.getCloudHistory(target.symbol, exchange, { ...request, ...(session ? { session } : {}) },
+        { batch: _context?.batch }), _context),
       `Cloud chart data is unavailable for ${ticker}`,
     );
     return mapCloudPriceHistory(response, target.symbol, exchange, request.interval, subtractTimeRange(new Date(), range), undefined, extendedHours);
@@ -905,11 +923,16 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     return mapCloudPriceHistory(response, target.symbol, exchange, interval, startDate, endDate, extendedHours);
   }
 
+  /** Trailing history and dated expiries asked with others (`batch`) go out as batch requests while the service reads them so. */
+  batchesReads(method: BatchedReadMethod): boolean {
+    return apiClient.batchesReads(method === "getPriceHistory" ? "history" : "options");
+  }
+
   async getOptionsChain(ticker: string, exchange?: string, expirationDate?: number, _context?: MarketDataRequestContext): Promise<OptionsChain> {
     rejectPerpetual(ticker, exchange, "options chains");
     const target = cloudInstrumentTarget(ticker, exchange);
     return withCloudFallback(async () => {
-      const response = await apiClient.getCloudOptionsChain(target.symbol, target.exchange, expirationDate);
+      const response = await apiClient.getCloudOptionsChain(target.symbol, target.exchange, expirationDate, { batch: _context?.batch });
       const chain = unwrapRequiredCloudResponse(
         response,
         `Cloud options chains are unavailable for ${ticker}`,