gloomberb 0.14.1 → 0.15.1

package/src/plugins/builtin/shared/auto-refresh.ts

@@ -1,4 +1,5 @@
 import { useEffect, useRef, useState } from "react";
+import { usePaneVisible } from "../../../state/app/activity";
 import { useAppSelector } from "../../../state/app/context";
 import { formatRelativeAge } from "../../../utils/relative-time";
 
@@ -8,44 +9,89 @@ export const AGE_TICK_MS = 30_000;
 /**
  * How old a pane's data is, as a footer-ready label that keeps ageing on its
  * own. Returns null before the first successful load so callers can leave the
- * footer empty instead of claiming a freshness they do not have.
+ * footer empty instead of claiming a freshness they do not have. The clock
+ * rests while the pane cannot be seen and catches up when it can.
  */
 export function useUpdatedAgo(lastUpdated: number | null): string | null {
+  const visible = usePaneVisible();
   const [now, setNow] = useState(() => Date.now());
 
   useEffect(() => {
-    if (!lastUpdated) return;
+    if (!lastUpdated || !visible) return;
+    setNow(Date.now());
     const timer = setInterval(() => setNow(Date.now()), AGE_TICK_MS);
     return () => clearInterval(timer);
-  }, [lastUpdated]);
+  }, [lastUpdated, visible]);
 
   return lastUpdated ? formatRelativeAge(lastUpdated, now) : null;
 }
 
+export interface AutoRefreshOptions {
+  /**
+   * Cadence for a pane whose data moves faster than research data, such as a
+   * delayed curve during its session. Omitted, or not a positive number, the
+   * pane follows the refresh interval the user configured.
+   */
+  intervalMs?: number | null;
+}
+
 /**
- * Re-pull a pane once its data is older than the global refresh interval, so
- * network panes follow the one cadence the user already configured instead of
- * each hardcoding its own.
+ * When the next automatic refresh is due: one interval after the newer of the
+ * last good data and the last attempt this hook made. Counting from the last
+ * attempt is what stops a dead endpoint from turning into a retry storm.
+ */
+function nextAutoRefreshAt(
+  lastUpdated: number | null,
+  lastAttemptAt: number,
+  intervalMs: number,
+): number {
+  return Math.max(lastUpdated ?? Number.NEGATIVE_INFINITY, lastAttemptAt) + intervalMs;
+}
+
+/**
+ * Re-pull a pane once its data is one interval old, so network panes follow
+ * the one cadence the user already configured instead of each hardcoding its
+ * own. Callers that know their data moves faster pass `intervalMs`.
  *
- * The timer runs on the interval itself rather than a faster poll: a load that
- * failed is retried on the next tick, and a load that succeeded early is left
- * alone, so a dead endpoint can never turn into a retry storm.
+ * Each refresh is scheduled from `lastUpdated` rather than on a free-running
+ * timer, so data never ages to twice the interval. The clock rests while the
+ * pane cannot be seen (the app is hidden or the pane is covered) and, once it
+ * can, data that came due meanwhile refreshes at once. Pass `null` for data
+ * that has never loaded or that the pane already treats as stale: the hook
+ * then retries one interval after its last attempt. Mounting counts as an
+ * attempt, because a pane loads its data on mount.
  */
-export function useAutoRefresh(lastUpdated: number | null, refresh: () => void): void {
+export function useAutoRefresh(
+  lastUpdated: number | null,
+  refresh: () => void,
+  options: AutoRefreshOptions = {},
+): void {
   const intervalMinutes = useAppSelector((state) => state.config.refreshIntervalMinutes);
+  const visible = usePaneVisible();
   const refreshRef = useRef(refresh);
-  const lastUpdatedRef = useRef(lastUpdated);
   refreshRef.current = refresh;
-  lastUpdatedRef.current = lastUpdated;
+  const lastAttemptRef = useRef(Date.now());
+  const intervalMs = options.intervalMs != null && options.intervalMs > 0
+    ? options.intervalMs
+    : intervalMinutes > 0 ? intervalMinutes * 60_000 : 0;
 
   useEffect(() => {
-    if (!(intervalMinutes > 0)) return;
-    const intervalMs = intervalMinutes * 60_000;
-    const timer = setInterval(() => {
-      const previous = lastUpdatedRef.current;
-      if (previous && Date.now() - previous < intervalMs) return;
-      refreshRef.current();
-    }, intervalMs);
-    return () => clearInterval(timer);
-  }, [intervalMinutes]);
+    if (!(intervalMs > 0) || !visible) return;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    const schedule = () => {
+      const delay = nextAutoRefreshAt(lastUpdated, lastAttemptRef.current, intervalMs) - Date.now();
+      timer = setTimeout(() => {
+        timer = null;
+        lastAttemptRef.current = Date.now();
+        refreshRef.current();
+        // A successful load moves `lastUpdated` and reschedules through the
+        // effect; a failed one waits a full interval from this attempt.
+        schedule();
+      }, Math.max(0, delay));
+    };
+    schedule();
+    return () => {
+      if (timer) clearTimeout(timer);
+    };
+  }, [intervalMs, lastUpdated, visible]);
 }

package/src/plugins/builtin/shared/cloud-upgrade.ts

@@ -3,9 +3,8 @@ import { apiClient } from "../../../api-client";
 import { recordResearchActivity, researchUpgradeUrl } from "../../../api-client/research-activity";
 import { getCurrentPluginTarget } from "../../current-target";
 import type { PaneFooterSegment, PaneHint } from "../../../components";
-import { tf } from "../../../i18n";
+import { t, tf } from "../../../i18n";
 import { useAppLanguage } from "../../../i18n/react";
-import { useShortcut } from "../../../react/input";
 import { useRendererHost } from "../../../ui";
 import type { RendererHost } from "../../../ui";
 import { getSharedRegistry } from "../../registry";
@@ -97,11 +96,21 @@ export function useCloudPlanAction(): () => void {
   }, []);
 }
 
+/**
+ * The key for the Pro call to action. Not `u`: that is the app's install-update
+ * key, and one press must not both update and open checkout.
+ */
+export const CLOUD_PLAN_KEY = "$";
+
 export interface CloudAccessFooterOptions {
   /** Compact delay the free tier gets on this pane's data, e.g. "15m" or "12h". */
   delayLabel: string;
   focused: boolean;
-  /** Pane-unique shortcut scope. Omit to render the CTA without a `u` binding. */
+  /**
+   * Set when the pane renders the returned `hint`: the call to action then
+   * takes the {@link CLOUD_PLAN_KEY} key, which the pane footer binds. Omit to
+   * keep the pitch inside `segment` with no key.
+   */
   shortcutScope?: string;
   /** Set false while the pane happens to show data that is not cloud-delayed. */
   degraded?: boolean;
@@ -114,7 +123,7 @@ export interface CloudAccessFooter {
   segment: PaneFooterSegment | null;
   /**
    * The call to action, for the pane to render beside its own shortcuts. Null
-   * whenever no `u` is bound, which leaves the pitch inside `segment`.
+   * without a `shortcutScope`, which leaves the pitch inside `segment`.
    */
   hint: PaneHint | null;
   openUpgrade: () => void;
@@ -129,7 +138,6 @@ export interface CloudAccessFooter {
 export function useCloudAccessFooter({
   delayLabel,
   degraded = true,
-  focused,
   segmentId = "cloud-access",
   shortcutScope,
 }: CloudAccessFooterOptions): CloudAccessFooter {
@@ -140,24 +148,15 @@ export function useCloudAccessFooter({
 
   const showTrial = access.isTrialActive;
   const showUpgrade = !showTrial && !access.hasProAccess && degraded;
-  const bindsShortcut = !!shortcutScope && showUpgrade && focused;
-
-  useShortcut(
-    (event) => {
-      const key = (event.name ?? event.key ?? "").toLowerCase();
-      if (!bindsShortcut || key !== "u") return;
-      event.stopPropagation();
-      event.preventDefault();
-      openUpgrade();
-    },
-    { scope: shortcutScope ?? "cloud-access:upgrade", enabled: bindsShortcut },
-  );
 
   const segment = useMemo<PaneFooterSegment | null>(() => {
     if (showTrial) {
+      const label = t("Manage Pro plan");
       return {
         id: segmentId,
         onPress: openPlan,
+        // The footer binds the key, and the pane menu lists the segment by its label.
+        ...(shortcutScope ? { shortcut: CLOUD_PLAN_KEY, label, title: `${label} (${CLOUD_PLAN_KEY})` } : {}),
         parts: [{
           text: tf("Pro trial · {days}d left", { days: access.trialDaysLeft }),
           tone: "positive",
@@ -169,9 +168,9 @@ export function useCloudAccessFooter({
       id: segmentId,
       onPress: openUpgrade,
       parts: [{
-        // With a `u` bound the pitch is the [u]pgrade hint, so the status says
-        // only what is true of the data. Without one there is nowhere else for
-        // it to go.
+        // With a key the pitch is the upgrade hint, so the status says only
+        // what is true of the data. Without one there is nowhere else for it
+        // to go.
         text: shortcutScope
           ? tf("{delay} delayed", { delay: delayLabel })
           : tf("{delay} delayed · try Pro live", { delay: delayLabel }),
@@ -192,9 +191,9 @@ export function useCloudAccessFooter({
 
   const hint = useMemo<PaneHint | null>(
     () => (shortcutScope && showUpgrade
-      ? { id: `${segmentId}-upgrade`, key: "u", label: "pgrade", onPress: openUpgrade }
+      ? { id: `${segmentId}-upgrade`, key: CLOUD_PLAN_KEY, label: t("upgrade"), title: t("Upgrade to Pro"), onPress: openUpgrade }
       : null),
-    [openUpgrade, segmentId, shortcutScope, showUpgrade],
+    [language, openUpgrade, segmentId, shortcutScope, showUpgrade],
   );
 
   return { access, hint, openUpgrade, segment };

package/src/plugins/builtin/shared/futures-session.ts

@@ -0,0 +1,34 @@
+const newYorkClock = new Intl.DateTimeFormat("en-US", {
+  timeZone: "America/New_York",
+  weekday: "short",
+  hour: "2-digit",
+  minute: "2-digit",
+  hourCycle: "h23",
+});
+
+/** How often a delayed futures pane refreshes while its contracts trade. */
+const FUTURES_SESSION_REFRESH_MS = 60_000;
+
+/**
+ * Whether CME Globex is trading: Sunday 18:00 to Friday 17:00 New York time,
+ * less the daily 17:00 to 18:00 break. Exchange holidays are not modelled; a
+ * holiday only costs a few quiet refreshes.
+ */
+function isCmeGlobexOpen(now = Date.now()): boolean {
+  const parts = newYorkClock.formatToParts(new Date(now));
+  const weekday = parts.find((part) => part.type === "weekday")?.value ?? "";
+  const hour = Number(parts.find((part) => part.type === "hour")?.value ?? "0");
+  if (weekday === "Sat") return false;
+  if (weekday === "Sun") return hour >= 18;
+  if (weekday === "Fri") return hour < 17;
+  return hour !== 17;
+}
+
+/**
+ * The refresh cadence for a pane of delayed futures quotes: once a minute
+ * while Globex trades, the app's research cadence (null) otherwise. Read at
+ * render, so it flips on the pane's next refresh after the open or close.
+ */
+export function futuresSessionRefreshInterval(now = Date.now()): number | null {
+  return isCmeGlobexOpen(now) ? FUTURES_SESSION_REFRESH_MS : null;
+}

package/src/plugins/builtin/shared/mine-tickers.ts

@@ -0,0 +1,19 @@
+import { useMemo } from "react";
+import { useAppSelector } from "../../../state/app/context";
+import type { TickerRecord } from "../../../types/ticker";
+
+export function collectMineTickers(tickers: Iterable<TickerRecord>): ReadonlySet<string> {
+  const symbols = new Set<string>();
+  for (const { metadata } of tickers) {
+    if (metadata.portfolios.length || metadata.watchlists.length) {
+      symbols.add(metadata.ticker.trim().toUpperCase());
+    }
+  }
+  return symbols;
+}
+
+/** Portfolio and watchlist membership from the same records the portfolio pane uses. */
+export function useMineTickers(): ReadonlySet<string> {
+  const tickers = useAppSelector((state) => state.tickers);
+  return useMemo(() => collectMineTickers(tickers.values()), [tickers]);
+}

package/src/plugins/builtin/shared/research-cloud-session.test.tsx

@@ -117,13 +117,13 @@ test.each(panes)("%s recovers from sign-in and verification while preserving pro
   state.failure = undefined;
   await emitKeypress(setup!, { name: "r" });
   for (let i = 0; i < 5; i++) await frame();
-  expect(setup!.captureCharFrame()).toContain(pane === "dividend-yield" ? "TTM Cash/Share" : pane === "analyst-research" ? "Fixture Research" : "Earnings");
+  expect(setup!.captureCharFrame()).toContain(pane === "dividend-yield" ? "TTM/share" : pane === "analyst-research" ? "Fixture Research" : "Earnings");
   expect(setup!.captureCharFrame()).not.toContain("Research provider timed out");
   // A usable non-Cloud source remains available without any signed-in account.
   state.cloudRequired = false;
   await setSession(null);
   expect(setup!.captureCharFrame()).not.toContain("Sign in to");
-  expect(setup!.captureCharFrame()).toContain(pane === "dividend-yield" ? "TTM Cash/Share" : pane === "analyst-research" ? "Fixture Research" : "Earnings");
+  expect(setup!.captureCharFrame()).toContain(pane === "dividend-yield" ? "TTM/share" : pane === "analyst-research" ? "Fixture Research" : "Earnings");
 });
 
 test("partial event data keeps usable rows and reports an auth-denied source once", async () => {

package/src/plugins/builtin/shared/research-cloud-session.ts

@@ -1,9 +1,11 @@
 import { apiClient } from "../../../api-client";
 import { usePlanAccess } from "./plan-access";
 
+export const CLOUD_SESSION_REQUIRED = "Gloom Cloud requires signup and email verification";
+
 /** Match the Cloud provider's explicit account gate, not another provider's auth failure. */
 export function isCloudSessionRequired(error: string | null | undefined): boolean {
-  return error === "Gloom Cloud requires signup and email verification";
+  return error === CLOUD_SESSION_REQUIRED;
 }
 
 /** A session change must retry an already-open research pane's denied request. */

package/src/plugins/builtin/shared/screener-live-quotes.test.ts

@@ -88,16 +88,23 @@ describe("screener live quotes", () => {
       subscriptionStartedAt: 900,
     })).toBe("live");
   });
+
+  test("reports nothing while the stream is still connecting", () => {
+    const targets = buildScreenerQuoteTargets([{ symbol: "AAPL", exchange: "NASDAQ" }], null);
+    const entries = new Map<string, QueryEntry<Quote>>();
+    expect(resolveScreenerQuoteFeedStatus(targets, entries, { now: 1_000, subscriptionStartedAt: 900 })).toBeNull();
+    expect(resolveScreenerQuoteFeedStatus(targets, entries, { now: 60_000, subscriptionStartedAt: 900 })).toBe("polling");
+  });
 });
 
-test("replacement snapshots clear unavailable fields and select only the qualified listing", () => {
+test("replacement snapshots clear unavailable fields, keep the listing currency and select only the qualified listing", () => {
   const rows = [{ symbol: "ACME", exchange: "NASDAQ", name: "US", currency: "USD", price: 10, change: 1, changePercent: 10, volume: 200, lastUpdated: 100 },
     { symbol: "ACME", exchange: "LSE", name: "UK", currency: "GBP", price: 8, change: 0, changePercent: 0, volume: 0, lastUpdated: 100 }];
   const targets = buildScreenerQuoteTargets(rows, "ACME:XLON");
   expect(targets.map(target => target.selected)).toEqual([false, true]);
-  const entries = new Map([[buildQuoteKey(rows[0]!), readyEntry({ symbol: "ACME", price: 12, currency: "USD", lastUpdated: 200 })]]);
+  const entries = new Map([[buildQuoteKey(rows[0]!), readyEntry({ symbol: "ACME", price: 12, currency: "", lastUpdated: 200 })]]);
   expect(overlayScreenerQuoteEntries(rows, entries)).toEqual([
-    expect.objectContaining({ price: 12, change: null, changePercent: null, volume: null, lastUpdated: 200 }), rows[1]!,
+    expect.objectContaining({ price: 12, change: null, changePercent: null, volume: null, currency: "USD", lastUpdated: 200 }), rows[1]!,
   ]);
   entries.set(buildQuoteKey(rows[0]!), readyEntry({ symbol: "ACME", price: 12, currency: "USD", lastUpdated: 50, change: 0, changePercent: 0, volume: 0 }));
   expect(overlayScreenerQuoteEntries(rows, entries)).toEqual(rows);

package/src/plugins/builtin/shared/screener-live-quotes.ts

@@ -3,6 +3,7 @@ import { publicTickerKey } from "../../../utils/exchanges";
 import type { Quote } from "../../../types/financials";
 import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
 import type { QueryEntry } from "../../../market-data/result-types";
+import { resolveCurrencyUnit } from "../../../utils/currency-units";
 
 const STREAM_FRESHNESS_MS = 2 * 60_000;
 const STREAM_CONNECTING_GRACE_MS = 15_000;
@@ -17,6 +18,7 @@ export interface ScreenerQuoteRow {
   currency: string;
   exchange: string;
   lastUpdated?: number;
+  previousClose?: number;
 }
 
 export interface ScreenerQuoteFreshness {
@@ -24,7 +26,7 @@ export interface ScreenerQuoteFreshness {
   subscriptionStartedAt: number;
 }
 
-export type ScreenerQuoteFeedStatus = "live" | "mixed" | "connecting" | "polling";
+export type ScreenerQuoteFeedStatus = "live" | "mixed" | "polling";
 
 export function buildScreenerQuoteTargets(
   rows: readonly Pick<ScreenerQuoteRow, "symbol" | "exchange">[],
@@ -48,6 +50,25 @@ function finite(value: number | undefined): value is number {
   return typeof value === "number" && Number.isFinite(value);
 }
 
+/** Venues quote these in either the major or the minor unit (GBP or GBp). */
+const TWO_UNIT_CURRENCIES = new Set(["GBP", "ILS", "ZAR"]);
+
+/** A quote without a currency keeps the listing's, so a streamed price never
+ * loses its symbol, unless the listing's currency has two units and the
+ * quote's could be either. */
+function overlayCurrency(row: ScreenerQuoteRow, quote: Quote): string {
+  const quoted = quote.currency?.trim();
+  if (quoted) return quoted;
+  return TWO_UNIT_CURRENCIES.has(resolveCurrencyUnit(row.currency).currency) ? "" : row.currency;
+}
+
+/**
+ * The last overlay of each source row. Every stream flush hands over a new
+ * entries map, but most rows' quotes did not move; returning the same row
+ * object for those lets memoized table rows skip the render.
+ */
+const overlayCache = new WeakMap<object, { quote: Quote; row: ScreenerQuoteRow }>();
+
 export function overlayScreenerQuoteEntries<T extends ScreenerQuoteRow>(
   rows: readonly T[],
   entries: ReadonlyMap<string, QueryEntry<Quote>>,
@@ -62,22 +83,30 @@ export function overlayScreenerQuoteEntries<T extends ScreenerQuoteRow>(
     ) {
       return row;
     }
-
-    return {
-      ...row,
-      name: quote.name?.trim() || row.name,
-      price: quote.price,
-      change: finite(quote.change) ? quote.change : null,
-      changePercent: finite(quote.changePercent)
-        ? quote.changePercent
-        : null,
-      volume: finite(quote.volume) && quote.volume >= 0 ? quote.volume : null,
-      currency: quote.currency?.trim() || "",
-      lastUpdated: quote.lastUpdated,
-    };
+    const cached = overlayCache.get(row);
+    if (cached?.quote === quote) return cached.row as T;
+    const overlaid = overlayQuote(row, quote);
+    overlayCache.set(row, { quote, row: overlaid });
+    return overlaid;
   });
 }
 
+function overlayQuote<T extends ScreenerQuoteRow>(row: T, quote: Quote): T {
+  return {
+    ...row,
+    name: quote.name?.trim() || row.name,
+    price: quote.price,
+    change: finite(quote.change) ? quote.change : null,
+    changePercent: finite(quote.changePercent)
+      ? quote.changePercent
+      : null,
+    volume: finite(quote.volume) && quote.volume >= 0 ? quote.volume : null,
+    currency: overlayCurrency(row, quote),
+    previousClose: finite(quote.previousClose) ? quote.previousClose : undefined,
+    lastUpdated: quote.lastUpdated,
+  };
+}
+
 function freshQuote(
   entry: QueryEntry<Quote> | undefined,
   freshness: ScreenerQuoteFreshness,
@@ -125,11 +154,12 @@ export function resolveScreenerQuoteFeedStatus(
 
   if (liveCount === targets.length) return "live";
   if (liveCount > 0) return "mixed";
+  // The socket connects in the background; there is nothing to report yet.
   if (
     fallbackCount === 0
     && freshness.now - freshness.subscriptionStartedAt < STREAM_CONNECTING_GRACE_MS
   ) {
-    return "connecting";
+    return null;
   }
   return "polling";
 }

package/src/plugins/builtin/shared/table-pane.ts

@@ -3,6 +3,7 @@ import { useEffect } from "react";
 // plugins, and importing the barrel back would make a cycle.
 import type { DataTableKeyEvent } from "../../../components/data-table/view";
 import type { PaneFooterSegment } from "../../../components/layout/pane/footer";
+import { isPlainKey } from "../../../utils/keyboard";
 
 export function loadingErrorFooterInfo(loading: boolean, error: string | null | undefined): PaneFooterSegment[] {
   return [
@@ -12,7 +13,8 @@ export function loadingErrorFooterInfo(loading: boolean, error: string | null |
 }
 
 export function handleRefreshKey(event: DataTableKeyEvent, reload: () => void, options: { stopPropagation?: boolean } = {}): boolean {
-  if (event.name !== "r") return false;
+  // A modified r (Shift+R refresh all, CmdOrCtrl+Shift+R resize) belongs to the app.
+  if (!isPlainKey(event, "r")) return false;
   event.preventDefault?.();
   if (options.stopPropagation) event.stopPropagation?.();
   reload();

package/src/plugins/builtin/shared/ticker-choice.tsx

@@ -0,0 +1,34 @@
+import { useCallback } from "react";
+import { ChoiceDialog } from "../../../components/ui/choice-dialog";
+import { t } from "../../../i18n";
+import { useInlineTickerOpener } from "../../../state/hooks/inline-tickers";
+import { useOptionalDialog, type PromptContext } from "../../../ui/dialog";
+
+/**
+ * The keyboard way to open a ticker badge: one symbol opens straight away,
+ * several ask which one first. Opens the same research pane a badge click does.
+ */
+export function useOpenTickerChoice(): (symbols: readonly string[]) => void {
+  const openTicker = useInlineTickerOpener();
+  const dialog = useOptionalDialog();
+  return useCallback((symbols: readonly string[]) => {
+    const unique = [...new Set(symbols.filter(Boolean))];
+    if (unique.length === 0) return;
+    if (unique.length === 1 || !dialog) {
+      openTicker(unique[0]!);
+      return;
+    }
+    void dialog.prompt<string>({
+      closeOnClickOutside: true,
+      content: (ctx: PromptContext<string>) => (
+        <ChoiceDialog
+          {...ctx}
+          title={t("Open ticker")}
+          choices={unique.map((symbol) => ({ id: symbol, label: symbol }))}
+        />
+      ),
+    }).then((symbol) => {
+      if (symbol) openTicker(symbol);
+    }).catch(() => {});
+  }, [dialog, openTicker]);
+}

package/src/plugins/builtin/shared/ticker-request.test.ts

@@ -0,0 +1,18 @@
+import { expect, test } from "bun:test";
+import { tapeRejection } from "../time-sales/client";
+import { listingIdentity } from "./ticker-request";
+
+test("a listing key splits into the bare symbol and its exchange", () => {
+  expect(listingIdentity("AMD:XNAS")).toEqual({ symbol: "AMD", exchange: "NASDAQ" });
+  expect(listingIdentity("spy:arcx", "NYSEARCA")).toEqual({ symbol: "SPY", exchange: "ARCA" });
+  expect(listingIdentity("AMD", "NASDAQ")).toEqual({ symbol: "AMD", exchange: "NASDAQ" });
+  expect(listingIdentity("BRK.B")).toEqual({ symbol: "BRK.B", exchange: "" });
+  expect(listingIdentity("  ")).toBeNull();
+  expect(listingIdentity(null)).toBeNull();
+});
+
+test("a rejected tape request shows its stated reason", () => {
+  expect(tapeRejection('{"symbol":"AMD:XNAS","status":"unavailable","gaps":["A US equity symbol is required"]}')).toBe("A US equity symbol is required");
+  expect(tapeRejection("Bad Gateway")).toBeNull();
+  expect(tapeRejection('{"gaps":[]}')).toBeNull();
+});

package/src/plugins/builtin/shared/ticker-request.test.tsx

@@ -76,9 +76,9 @@ async function mount(pane: Pane, width: number, state: { failure: Error | null;
 
 const cases: [Pane, number, string, string][] = [
   ["analyst-research", 80, "Original Research", "Recovered Research"],
-  ["earnings-estimates", 80, "12.34 USD", "15.67 USD"],
-  ["earnings-estimates", 48, "12.34 USD", "15.67 USD"],
-  ["earnings-estimates", 120, "12.34 USD", "15.67 USD"],
+  ["earnings-estimates", 80, "12.34", "15.67"],
+  ["earnings-estimates", 48, "12.34", "15.67"],
+  ["earnings-estimates", 120, "12.34", "15.67"],
   ["corporate-actions", 80, "2026-03-31", "2026-06-30"],
   ["historical-prices", 80, "2026-09-01", "2026-09-02"],
 ];

package/src/plugins/builtin/shared/ticker-request.ts

@@ -1,7 +1,8 @@
 import { useCallback } from "react";
 import { ApiRequestError } from "../../../api-client/errors";
 import { useAsyncResource } from "../../../react/async-resource";
-import { usePaneTicker } from "../../../state/app/context";
+import { usePaneTickerIdentity } from "../../../state/hooks/pane-ticker";
+import { parsePublicTickerKey } from "../../../utils/exchanges";
 import { isCloudSessionRequired } from "./research-cloud-session";
 
 function discardDeniedResearch(error: unknown): boolean {
@@ -9,8 +10,24 @@ function discardDeniedResearch(error: unknown): boolean {
     || isCloudSessionRequired(error instanceof Error ? error.message : String(error));
 }
 
+/**
+ * The bare symbol and exchange behind a ticker key. A listing chosen from
+ * search is keyed "AMD:XNAS"; Cloud research endpoints take "AMD" plus the
+ * exchange, and the key's exchange wins over saved metadata.
+ */
+export function listingIdentity(key: string | null | undefined, savedExchange = ""): { symbol: string; exchange: string } | null {
+  const value = key?.trim();
+  if (!value) return null;
+  const parsed = parsePublicTickerKey(value);
+  return { symbol: parsed.symbol.toUpperCase(), exchange: parsed.exchange ?? savedExchange };
+}
+
+/**
+ * The pane's symbol for research panes that load their own data. Identity only:
+ * it does not observe the quote, so a price tick does not re-render the pane.
+ */
 export function useBoundTicker() {
-  const { symbol, ticker } = usePaneTicker();
+  const { symbol, ticker } = usePaneTickerIdentity();
   return {
     symbol,
     ticker,

package/src/plugins/builtin/shared/ticker-surface.ts

@@ -14,6 +14,8 @@ export interface TickerSurfacePaneTemplateOptions {
   description: string;
   keywords: string[];
   shortcut: string;
+  /** Other mnemonics that open the same view without a separate command-bar row. */
+  shortcutAliases?: readonly string[];
   /** Opt in only when this template is available in the hosted browser catalog. */
   publicShare?: boolean;
   titlePrefix?: string;
@@ -93,6 +95,7 @@ export function createTickerSurfacePaneTemplate(
     keywords: templateOptions.keywords,
     shortcut: {
       prefix: templateOptions.shortcut,
+      ...(templateOptions.shortcutAliases?.length ? { aliases: templateOptions.shortcutAliases } : {}),
       argPlaceholder: "ticker",
       argKind: "ticker",
     },