gloomberb 0.18.4 → 0.19.0

package/src/plugins/builtin/shared/earnings-report.ts

@@ -54,8 +54,8 @@ export function epsBasisShort(basis: EarningsEpsBasis | null): string {
   return basis === "gaap" ? "GAAP" : basis === "adjusted" ? "adj" : "?";
 }
 
-/** Known bases are named in row details; unknown stays in the structured data and drilldown. */
-const BASIS_TEXT: Record<EpsBasisName, string> = { GAAP: "GAAP", adjusted: "adj", unknown: "" };
+/** A reported row's detail names its basis as ERN's Basis column does, unknown included. */
+const BASIS_TEXT: Record<EpsBasisName, string> = { GAAP: "GAAP", adjusted: "adj", unknown: "unknown" };
 
 type EarningsRecord = CorporateActionsData["earnings"][number];
 

package/src/plugins/builtin/shared/job-posting.ts

@@ -34,6 +34,7 @@ export function countryName(code: string | null | undefined): string | null {
   try {
     return countryNames.of(code) ?? null;
   } catch {
+    // Intentional ignore: a region code Intl cannot name is left out of the posting's place.
     return null;
   }
 }

package/src/plugins/builtin/shared/macro-releases.ts

@@ -0,0 +1,65 @@
+/**
+ * Macro releases people look for by a name no data series carries: the
+ * purchasing managers' indexes and the GDP nowcasts. They are releases in the
+ * economic calendar (ECO, `gloom econ`), with actual, forecast and prior, that
+ * `alerts add` follows; GDPNow's history is also ECST's. `catalog` and
+ * `search` answer a query that names one with `line`, and the data catalog's
+ * empty search with `paneHint`, rather than with each other.
+ */
+interface MacroReleaseTopic {
+  /** Runs of words that name it anywhere in a query ("pmi" in "ISM manufacturing PMI"). */
+  phrases: readonly string[];
+  /** Where it is, by the commands that list it and alert on it. */
+  line: string;
+  /** The same, by the functions the command bar opens. */
+  paneHint: string;
+}
+
+const MACRO_RELEASE_TOPICS: readonly MacroReleaseTopic[] = [
+  {
+    phrases: ["pmi", "pmis", "ism", "purchasing manager", "purchasing managers", "purchasing managers index", "purchasing managers indexes", "caixin", "ratingdog"],
+    line: "PMIs (ISM, S&P Global flash and final, NBS, RatingDog, formerly Caixin) are releases in the economic calendar: gloom econ, "
+      + "or fn ECO --impact all (ECO opens on high impact only). An alert before one: gloom alerts add \"ISM Manufacturing PMI\". "
+      + "No PMI series is charted; ECST has industrial production, durables and factory orders.",
+    paneHint: "PMIs are releases in the economic calendar: ECO, Impact All. Industrial production and orders: ECST.",
+  },
+  {
+    phrases: ["nowcast", "nowcasts", "nowcasting", "gdpnow", "gdp now"],
+    line: "GDP nowcast: the Atlanta Fed's GDPNow, fn ECST gdpnow (history: gloom fred GDPNOW), the one nowcast series served. "
+      + "Each update is a release in gloom econ --country US and fn ECO US --impact all; an alert before the next: "
+      + "gloom alerts add \"Atlanta Fed GDPNow\".",
+    paneHint: "GDPNow is in ECST, Nowcasts & conditions, and each update in ECO, Impact All.",
+  },
+];
+
+/** The words of a text, lower case: "ISM-manufacturing" and "ism manufacturing" read alike. */
+function words(text: string): string[] {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+}
+
+function containsRun(query: readonly string[], run: readonly string[]): boolean {
+  for (let at = 0; at + run.length <= query.length; at += 1) {
+    if (run.every((word, index) => query[at + index] === word)) return true;
+  }
+  return false;
+}
+
+/** The macro release a query names ("flash PMI", "ISM services", "GDPNow"), else null. */
+export function macroReleaseTopic(query: string): Pick<MacroReleaseTopic, "line" | "paneHint"> | null {
+  const asked = words(query);
+  if (asked.length === 0) return null;
+  return MACRO_RELEASE_TOPICS.find((topic) => topic.phrases.some((phrase) => containsRun(asked, words(phrase)))) ?? null;
+}
+
+/**
+ * Release series a sponsor renamed, by the name's old words and its new: the
+ * S&P Global China PMI was Caixin's until RatingDog's from the August 2025
+ * survey, and IHS Markit's PMIs are S&P Global's since 2022. A name typed
+ * with the old words (`alerts add "Caixin PMI"`) reads as the series' current
+ * name, and an alert kept under the old name follows the rows under the new.
+ * Only renames of series the calendar lists.
+ */
+export const RENAMED_RELEASES: ReadonlyArray<{ former: readonly string[]; current: string; since: string }> = [
+  { former: ["Caixin"], current: "RatingDog", since: "the August 2025 survey" },
+  { former: ["IHS Markit", "Markit"], current: "S&P Global", since: "2022" },
+];

package/src/plugins/builtin/shared/members-menu.tsx

@@ -1,3 +1,4 @@
+import { logFailure } from "../../../utils/log-failure";
 import { ChoiceDialog, TextPromptDialog, usePaneMenuItems } from "../../../components";
 import { createFormCollectionActions } from "../../../components/form-modal/deps";
 import { t, tf } from "../../../i18n";
@@ -195,7 +196,7 @@ export function useMembersMenu(registrationId: string, list: MemberList | null)
         const choice = choices.find((item) => item.id === templateId && !item.disabled);
         // CORR and RIPL resolve `arg` like the command bar; RRG and SIW read `symbols`.
         if (choice) createPaneFromTemplate(choice.id, { symbols: choice.symbols, arg: formatTickerListInput(choice.symbols) });
-      }).catch(() => {});
+      }).catch(logFailure("shared.members-menu", "Open members in a function failed"));
     };
     const saveAsWatchlist = async (requested: string) => {
       // The writes hold the app for about a second with a hundred names; let the dialog close on screen first.
@@ -253,7 +254,7 @@ export function useMembersMenu(registrationId: string, list: MemberList | null)
           saveAsWatchlist(name).catch((error: unknown) => {
             notify({ type: "error", body: error instanceof Error ? error.message : t("The watchlist was not saved.") });
           });
-        }).catch(() => {});
+        }).catch(logFailure("shared.members-menu", "Open save members as watchlist prompt failed"));
       } },
     ];
   }, [createPaneFromTemplate, dialog, disabledPlugins, dispatch, getState, list, notify]);

package/src/plugins/builtin/shared/pro-lock-note.ts

@@ -1,3 +1,4 @@
+import { createTtlCache, type TtlCache } from "../../../data/ttl-cache";
 import type { HeadlessPaneContext } from "../../../types/headless";
 import type { PaneLock } from "../../../types/plugin";
 import { settleWithin, signalWithTimeout } from "../../../utils/async-deadline";
@@ -35,8 +36,7 @@ const ANSWER_TTL_MS = 5 * 60_000;
  */
 const ROUTE_CHECK_WAIT_MS = 3_000;
 
-interface KeptAnswer { at: number; answer: Promise<boolean> }
-const answers = new WeakMap<FreeRoute, Map<string, KeptAnswer>>();
+const answers = new WeakMap<FreeRoute, TtlCache<boolean>>();
 
 /**
  * Whether the route has data for the symbol, null when its check failed or was
@@ -45,20 +45,20 @@ const answers = new WeakMap<FreeRoute, Map<string, KeptAnswer>>();
  * rather than hiding the route for minutes over one slow read.
  */
 async function routeAnswers(route: FreeRoute, check: NonNullable<FreeRoute["answers"]>, symbol: string, context: HeadlessPaneContext, deadline: number): Promise<boolean | null> {
-  const bySymbol = answers.get(route) ?? new Map<string, KeptAnswer>();
+  const bySymbol = answers.get(route) ?? createTtlCache<boolean>({ ttlMs: ANSWER_TTL_MS });
   answers.set(route, bySymbol);
   const key = symbol.trim().toUpperCase();
-  let kept = bySymbol.get(key);
-  if (!kept || Date.now() - kept.at >= ANSWER_TTL_MS) {
+  const kept = bySymbol.load(key, () => {
     // The check's own reads stop at the deadline where they take a signal.
     const signal = signalWithTimeout(context.signal, Math.max(0, deadline - Date.now()));
-    const entry: KeptAnswer = { at: Date.now(), answer: check(symbol, { ...context, signal }) };
-    entry.answer.catch(logFailure("plugins.pro-lock-note", "Check a free route's data failed"));
-    bySymbol.set(key, entry);
-    kept = entry;
-  }
-  const answer = await settleWithin(kept.answer, Math.max(0, deadline - Date.now()));
-  if (answer === null && bySymbol.get(key) === kept) bySymbol.delete(key);
+    return check(symbol, { ...context, signal }).catch((error: unknown) => {
+      logFailure("plugins.pro-lock-note", "Check a free route's data failed")(error);
+      throw error;
+    });
+  });
+  const answer = await settleWithin(kept, Math.max(0, deadline - Date.now()));
+  // Only this check is dropped: a newer one for the symbol stays.
+  if (answer === null) bySymbol.delete(key, kept);
   return answer;
 }
 

package/src/plugins/builtin/shared/report-freshness.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../../../utils/log-failure";
 import type { HeadlessPaneFreshness } from "../../../types/headless";
 import type { Quote, QuoteIndexSession } from "../../../types/financials";
 import { isQuoteBeforeLatestSession, isQuoteStaleForCurrentSession } from "../../../market-data/quotes/freshness";
@@ -129,8 +130,8 @@ export async function cloudRealtimeAccess(): Promise<boolean | null> {
   if (!apiClient.isSignedIn()) return false;
   try {
     return hasProAccess(apiClient.getCurrentUser() ?? await apiClient.getSession());
-  } catch {
-    return null;
+  } catch (error) {
+    return logFailure("shared.report-freshness", "Read Cloud plan for report freshness failed", null)(error);
   }
 }
 

package/src/plugins/builtin/shared/scanner-capture.ts

@@ -7,6 +7,9 @@ import type { apiClient, ScannerFeedEvent, ScannerKind } from "../../../api-clie
 
 export const HILO_PANE_ID = "scanner-hilo";
 export const FLOW_PANE_ID = "scanner-flow";
+/** SCAN, the user's own live scan; it polls Gloom Cloud rather than reading a shared feed. */
+export const LIVE_SCAN_PANE_ID = "scanner-live";
+export const LIVE_SCAN_TEMPLATE_ID = "scanner-live-pane";
 /** The panes that read a scanner feed, by the scanner each one reads. */
 export const SCANNER_PANE_KINDS: Readonly<Record<string, ScannerKind>> = { [HILO_PANE_ID]: "hilo", [FLOW_PANE_ID]: "flow" };
 

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

@@ -1,3 +1,4 @@
+import { logFailure } from "../../../utils/log-failure";
 import { useCallback } from "react";
 import { ChoiceDialog } from "../../../components/ui/choice-dialog";
 import { t } from "../../../i18n";
@@ -29,6 +30,6 @@ export function useOpenTickerChoice(): (symbols: readonly string[]) => void {
       ),
     }).then((symbol) => {
       if (symbol) openTicker(symbol);
-    }).catch(() => {});
+    }).catch(logFailure("shared.ticker-choice", "Open ticker choice failed"));
   }, [dialog, openTicker]);
 }

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

@@ -0,0 +1,77 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { isNoSourceAnswer } from "../../../sources/provider-errors";
+import type { DataProvider } from "../../../types/data-provider";
+import { shortCompanyName } from "../../../tickers/company-name";
+import { classifyInstrumentKind } from "../../../tickers/search/ranking";
+
+/**
+ * A search typed as a ticker (`TRIAL VKTX`, `FDA AZN`): one to five letters,
+ * with a share class. Registries know companies by name, so a symbol no record
+ * mentions is looked up as its company.
+ */
+export function looksLikeTicker(term: string): boolean {
+  return /^[A-Za-z]{1,5}(?:[.-][A-Za-z])?$/.test(term.trim());
+}
+
+/**
+ * The company a ticker is, by the name a registry files its records under:
+ * VKTX is "Viking Therapeutics", AZN "AstraZeneca". Read from the listing's
+ * quote, which names it; a fund or a contract is no company. Null when no
+ * share trades under it. A quote that could not be read (unreachable, busy,
+ * timed out) rejects: it says nothing about the company.
+ */
+export async function tickerCompanyName(dataProvider: Pick<DataProvider, "getQuote"> | null, ticker: string): Promise<string | null> {
+  const symbol = ticker.trim().toUpperCase();
+  if (!dataProvider || !symbol) return null;
+  const quote = await dataProvider.getQuote(symbol).catch((error: unknown) => {
+    if (isNoSourceAnswer(error)) return null;
+    throw error;
+  });
+  const name = quote?.name?.trim();
+  const kind = classifyInstrumentKind(quote?.instrumentType);
+  return name && kind !== "fund" && kind !== "derivative" ? shortCompanyName(name) : null;
+}
+
+export interface TickerCompanySearch {
+  /** The company is being looked up: the pane shows it loading. */
+  resolving: boolean;
+  /** The lookup failed, for the pane's unavailable state; null otherwise. */
+  error: string | null;
+  /** Looks again after a failure: the pane's refresh calls it. */
+  retry: () => void;
+}
+
+/**
+ * A search for a ticker that found nothing is searched again as its company's
+ * name: `onCompany` runs with it, once per `key` (the term as the pane compares
+ * it). `eligible` is true once the search has finished empty and the term reads
+ * as a ticker. A lookup that failed is no answer: it reports `error` until
+ * `retry`, or until the term changes and comes back.
+ */
+export function useTickerCompanySearch(
+  dataProvider: Pick<DataProvider, "getQuote"> | null,
+  term: string,
+  { eligible, key, onCompany }: { eligible: boolean; key: string; onCompany: (name: string) => void },
+): TickerCompanySearch {
+  const [looked, setLooked] = useState<ReadonlySet<string>>(() => new Set());
+  const [failed, setFailed] = useState<string | null>(null);
+  // A failure belongs to its term: another search clears it, so coming back looks again.
+  if (failed !== null && failed !== key) setFailed(null);
+  const onCompanyRef = useRef(onCompany);
+  onCompanyRef.current = onCompany;
+  const resolving = eligible && !looked.has(key) && failed !== key;
+  useEffect(() => {
+    if (!resolving) return;
+    let live = true;
+    tickerCompanyName(dataProvider, term).then((name) => {
+      if (!live) return;
+      setLooked((current) => new Set([...current, key]));
+      if (name) onCompanyRef.current(name);
+    }, () => {
+      if (live) setFailed(key);
+    });
+    return () => { live = false; };
+  }, [dataProvider, key, resolving, term]);
+  const retry = useCallback(() => setFailed(null), []);
+  return { resolving, error: eligible && failed === key ? `Couldn't look up ${term}'s company.` : null, retry };
+}

package/src/plugins/builtin/shared/use-quote-board.ts

@@ -1,5 +1,8 @@
+import { logFailure } from "../../../utils/log-failure";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { DataTableCell, DataTableVisibleRange, PaneFooterSegment } from "../../../components";
+import { savedCopyFooterSegment } from "../../../components/layout/pane/footer/model";
+import { oldestSavedCopyAt } from "../../../data/saved-copies";
 import { useQuoteEntries } from "../../../market-data/hooks";
 import { getRegularSessionDisplay, quoteDotMarketState, quoteHeadlineTime, quoteSessionColor, quoteSessionLabel } from "../../../market-data/market/status";
 import type { InstrumentRef } from "../../../market-data/request-types";
@@ -339,7 +342,7 @@ export function useQuoteBoard(symbols: string[], options: QuoteBoardOptions = {}
         if (fetchGenRef.current !== gen) return;
         setSnapshots((prev) => paintCachedQuotes(prev, cached));
       })
-      .catch(() => {});
+      .catch(logFailure("shared.use-quote-board", "Paint cached board quotes failed"));
   }, [dataProvider]);
 
   /** The cache-first full load: the listed symbols' cached quotes at once, then from the network. */
@@ -499,6 +502,8 @@ export interface QuoteBoardStatus {
   /** Symbols with no quote to show at all. */
   unavailable: number;
   latestTs: number;
+  /** When the oldest quote shown from a saved copy, after its refresh failed, was saved; null when none is. */
+  savedAt: number | null;
 }
 
 export function quoteBoardStatus(quotes: BoardQuoteMap): QuoteBoardStatus {
@@ -512,7 +517,7 @@ export function quoteBoardStatus(quotes: BoardQuoteMap): QuoteBoardStatus {
     else if (!state.quote && !state.loading) unavailable += 1;
     latestTs = Math.max(latestTs, state.quote?.lastUpdated ?? 0);
   }
-  return { loading, stale, unavailable, latestTs };
+  return { loading, stale, unavailable, latestTs, savedAt: oldestSavedCopyAt(Array.from(quotes.values(), (state) => state.quote)) };
 }
 
 /** Board footer status: everything here changes as loads succeed or fail. */
@@ -525,7 +530,9 @@ export function quoteBoardFooterInfo(status: QuoteBoardStatus): PaneFooterSegmen
   if (status.unavailable > 0) {
     info.push({ id: "error", parts: [{ text: `${status.unavailable} unavailable`, tone: "warning" }] });
   }
-  if (status.latestTs > 0) {
+  if (status.savedAt != null) {
+    info.push(savedCopyFooterSegment("saved-copy", status.savedAt));
+  } else if (status.latestTs > 0) {
     info.push({
       id: "fresh",
       quoteStatus: true,

package/src/plugins/builtin/shared/volatility/live-session.ts

@@ -112,6 +112,21 @@ export function useOptionsSessionOpen(enabled = true): boolean {
   return state.nextChangeAt != null && Date.now() >= state.nextChangeAt ? usOptionsSession(Date.now()).open : state.open;
 }
 
+export interface LiveSessionRefresh {
+  /** The refresh cycle is running, which is what "live" means. */
+  live: boolean;
+  /**
+   * Why the last refresh failed, until one succeeds or the cycle stops. The
+   * data it would have replaced stays on screen, so the pane shows this where
+   * it shows its own failed refreshes.
+   */
+  error: string | null;
+}
+
+function isCancellation(error: unknown): boolean {
+  return !!error && typeof error === "object" && (error as { name?: unknown }).name === "AbortError";
+}
+
 /**
  * Calls `refresh` every `intervalMs` while enabled, the pane can be seen (the
  * app is visible and the pane is not covered) and the options market is open.
@@ -119,18 +134,19 @@ export function useOptionsSessionOpen(enabled = true): boolean {
  * after the caller's own load (`loadedAt`); returning after a hidden or
  * covered stretch, or reaching the open, more than an interval after the last
  * data fires straight away. A refresh still in flight is never overlapped by
- * the next. Returns whether the refresh cycle is running, which is what
- * "live" means.
+ * the next. A refresh that throws or rejects is reported as `error` until the
+ * next one succeeds; a cancelled one (an AbortError) is no failure.
  */
 export function useLiveSessionRefresh(
   refresh: () => void | Promise<unknown>,
   intervalMs: number,
   enabled: boolean,
   loadedAt?: number | null,
-): boolean {
+): LiveSessionRefresh {
   const visible = usePaneVisible();
   const open = useOptionsSessionOpen(enabled);
   const active = enabled && visible && open;
+  const [error, setError] = useState<string | null>(null);
   const refreshRef = useRef(refresh);
   refreshRef.current = refresh;
   const lastRef = useRef(Date.now());
@@ -142,21 +158,31 @@ export function useLiveSessionRefresh(
     let cancelled = false;
     // A load the caller finished itself counts as the latest refresh.
     if (loadedAtRef.current != null && loadedAtRef.current > lastRef.current) lastRef.current = loadedAtRef.current;
+    const succeeded = () => { if (!cancelled) setError(null); };
+    const failed = (failure: unknown) => {
+      if (cancelled || isCancellation(failure)) return;
+      const message = (failure instanceof Error ? failure.message : String(failure ?? "")).trim();
+      setError(message || "Live refresh failed");
+    };
     const run = () => {
       if (inFlight || cancelled) return;
       lastRef.current = Date.now();
       let pending: void | Promise<unknown>;
-      try { pending = refreshRef.current(); } catch { return; }
+      try { pending = refreshRef.current(); } catch (failure) {
+        failed(failure);
+        return;
+      }
       if (pending && typeof (pending as Promise<unknown>).then === "function") {
         inFlight = true;
-        void (pending as Promise<unknown>).catch(() => {}).finally(() => { inFlight = false; });
-      }
+        void (pending as Promise<unknown>).then(succeeded, failed).finally(() => { inFlight = false; });
+      } else succeeded();
     };
     if (Date.now() - lastRef.current >= intervalMs) run();
     const timer = setInterval(run, intervalMs);
-    return () => { cancelled = true; clearInterval(timer); };
+    // A stopped cycle's failure is old news: the pane's own loads take over.
+    return () => { cancelled = true; clearInterval(timer); setError(null); };
   }, [active, intervalMs]);
-  return active;
+  return { live: active, error: active ? error : null };
 }
 
 /**

package/src/plugins/builtin/shared/volatility/pricing.ts

@@ -1,3 +1,4 @@
+import { isSettlementStamp } from "../../../../utils/option-expiry";
 import { zonedWallClockToUtcMs } from "../../../../utils/zoned-date-time";
 
 const DAY_MS = 86_400_000;
@@ -133,6 +134,25 @@ export function valueOption(input: OptionPricingInput): OptionValuation {
   };
 }
 
+/**
+ * The chance the underlying closes above `strike` at expiry under the same
+ * Black-Scholes-Merton model: N(d2), the risk-neutral probability a call there
+ * finishes in the money. 1 or 0 when nothing is left uncertain (expiry, zero
+ * volatility), by where the discounted forward sits.
+ */
+export function probabilityAbove(input: Omit<OptionPricingInput, "side">): number {
+  const spot = Math.max(0, finite(input.spot));
+  const strike = Math.max(0, finite(input.strike));
+  const years = Math.max(0, finite(input.daysToExpiry)) / DAYS_PER_YEAR;
+  const rate = finite(input.rate);
+  const dividendYield = finite(input.dividendYield);
+  const volatility = Math.max(0, finite(input.volatility));
+  if (strike <= 0) return 1;
+  if (years <= 0 || volatility <= 0 || spot <= 0) return spot * Math.exp((rate - dividendYield) * years) > strike ? 1 : 0;
+  const d2 = (Math.log(spot / strike) + (rate - dividendYield - volatility * volatility / 2) * years) / (volatility * Math.sqrt(years));
+  return normalCdf(d2);
+}
+
 export interface ImpliedVolatilityResult {
   volatility: number | null;
   /** Why no volatility could be solved, phrased for the pane body. */
@@ -194,9 +214,14 @@ export function solveImpliedVolatility(
   return { volatility: (low + high) / 2, note: null };
 }
 
-/** Time to the option date's 16:00 ET close, preserving live 0DTE time value. */
+/**
+ * Time to the option date's 16:00 ET close, preserving live 0DTE time value.
+ * A settlement stamp is the settlement itself: Deribit's expiries settle at
+ * 08:00 UTC, the time their stamp carries (`isSettlementStamp`).
+ */
 export function daysToExpiryFrom(expirationSeconds: number, now: number): number {
   if (!Number.isFinite(expirationSeconds)) return 0;
+  if (isSettlementStamp(expirationSeconds)) return Math.max(0, (expirationSeconds * 1000 - now) / DAY_MS);
   const expirationDate = new Date(expirationSeconds * 1000);
   const close = zonedWallClockToUtcMs(
     OPTION_EXPIRY_TIME_ZONE,

package/src/plugins/builtin/shared/wall-view-lifecycle.ts

@@ -1,3 +1,5 @@
+import { logFailure } from "../../../utils/log-failure";
+
 type Arm = "control" | "teaser" | null;
 type TeaserKind = "summary" | "sample" | "none";
 const active = new Map<string, Set<object>>();
@@ -17,7 +19,7 @@ export function trackWallView({ identity, placement, exposure, currentIdentity,
   active.set(key, copies);
   let released = false;
   let reported = false;
-  const answer = exposure.catch(() => null);
+  const answer = exposure.catch(logFailure("shared.wall-view-lifecycle", "Resolve wall experiment arm failed", null));
 
   return {
     exposure: answer,

package/src/plugins/builtin/themes/headless.ts

@@ -50,8 +50,10 @@ function boardObservation(payload: ThemesPayload | ThemeMembersPayload, now = Da
     regularSessionDate: close?.date ?? null,
     regularSessionClosedAt: close?.closedAt ?? null,
   };
-  // A Pro account's board is priced from the server's live read.
-  const feed = isLiveBoard(payload) ? { status: "live" as const } : {};
+  // A Pro account's board is priced from the server's live read while a session trades; outside it the figures are
+  // the session's close and the report claims no feed, as the pane's footer names the close instead of "live".
+  // Everyone else's, and an older server's, is fifteen minutes delayed.
+  const feed = !isLiveBoard(payload) ? { status: "delayed" as const, delayMinutes: 15 } : close ? {} : { status: "live" as const };
   if (close && now - assembledAt <= SNAPSHOT_STALE_MS) {
     return {
       metadata: { asOf: close.closedAt != null ? new Date(close.closedAt).toISOString() : close.date, sessionExchange: "NYSE", ...snapshot },
@@ -77,10 +79,10 @@ function themeReportTitle(query: string | undefined, theme: Pick<ThemeSummary, "
 export const themesHeadless: HeadlessPaneDefinition<"rows"> = {
   shape: "rows",
   // The pane's stored snapshot, refreshed every 15 minutes, priced in real time for a Pro account and
-  // fifteen minutes delayed otherwise (boardObservation says which). As in the pane,
+  // fifteen minutes delayed otherwise (boardObservation says which, and declares the delay). As in the pane,
   // the payload's stale flags are historical; a snapshot over 30 minutes old is what reads stale
   // (boardObservation, which dates a board outside the regular session by its close).
-  freshness: { status: "delayed", delayMinutes: 15, ignoreStaleFlags: true },
+  freshness: { ignoreStaleFlags: true },
   argument: { kind: "free-text", optional: true, placeholder: "theme", description: "Theme name or keyword, such as nuclear; omit for all themes." },
   options: [],
   discovery: { aliases: ["THEM"], dataRequirements: ["Gloom Cloud stored equity snapshot"],

package/src/plugins/builtin/themes/model.ts

@@ -17,14 +17,16 @@ export function boardYtdBase(payload: { asOf?: unknown; regularSessionDate?: unk
 }
 
 /**
- * A period's header. YTD names its base close, as long as `room` allows:
- * `YTD vs 31 Dec close`, `YTD vs 31 Dec`, then `YTD 31 Dec`.
+ * A period's header. YTD says what it is, a return against the close it is
+ * measured from, as long as `room` allows: `YTD vs 31 Dec close`, `YTD vs 31
+ * Dec`, then `YTD`.
  */
 export function periodLabel(period: ThemePeriod, ytdBase: string | null, room = Infinity): string {
   if (period !== "returnYtdPercent" || !ytdBase) return PERIOD_LABELS[period];
-  const labels = [`YTD vs ${ytdBase} close`, `YTD vs ${ytdBase}`, `YTD ${ytdBase}`];
+  const labels = [`YTD vs ${ytdBase} close`, `YTD vs ${ytdBase}`, "YTD"];
   return labels.find((label) => label.length <= room) ?? labels.at(-1)!;
 }
+
 export interface ThemeSort { columnId: string; direction: SortDirection }
 export const DEFAULT_SORT: ThemeSort = { columnId: "changePercent", direction: "desc" };
 export function percent(value: number | null): string {
@@ -32,12 +34,17 @@ export function percent(value: number | null): string {
   const rounded = Number(value.toFixed(2));
   return `${rounded > 0 ? "+" : ""}${rounded.toFixed(2)}%`;
 }
+/** How many of a theme's names a figure is drawn from, when not all of them: `7 of 8`. Empty when every name is in it. */
+export function coverageText(metric: ThemeAggregate): string {
+  return metric.covered < metric.total ? `${metric.covered} of ${metric.total}` : "";
+}
 export function aggregateText(metric: ThemeAggregate, breadth = false): string {
   const value = breadth && metric.value !== null ? `${Math.round(metric.value)}%` : percent(metric.value);
-  return `${value}${metric.covered < metric.total ? ` ${metric.covered}/${metric.total}` : ""}`;
+  const coverage = coverageText(metric);
+  return `${value}${coverage ? ` ${coverage}` : ""}`;
 }
 export const memberPrice = (value: number | null) => value === null ? "--" : value.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
-export const coverageWidth = (metrics: readonly ThemeAggregate[]) => Math.max(0, ...metrics.map((metric) => metric.covered < metric.total ? `${metric.covered}/${metric.total}`.length + 1 : 0));
+export const coverageWidth = (metrics: readonly ThemeAggregate[]) => Math.max(0, ...metrics.map((metric) => coverageText(metric) ? coverageText(metric).length + 1 : 0));
 export function sortThemes(rows: readonly ThemeSummary[], sort: ThemeSort): ThemeSummary[] {
   const value = (row: ThemeSummary) => {
     if (sort.columnId === "name") return row.name;
@@ -73,7 +80,7 @@ export function boardClose(payload: { regularSessionDate?: unknown; regularSessi
 const WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] as const;
 const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] as const;
 /** `Fri 9 Oct close` for the US session dated 2026-10-09, named by its own day, never the reader's. */
-function closeLabel(date: string): string {
+export function closeLabel(date: string): string {
   const day = new Date(`${date}T00:00:00Z`);
   return `${WEEKDAYS[day.getUTCDay()]} ${day.getUTCDate()} ${MONTHS[day.getUTCMonth()]} close`;
 }
@@ -152,9 +159,11 @@ export function themeColumns(width: number, rows: readonly ThemeSummary[], ytdBa
   const metricWidth = (period: ThemePeriod) => Math.max(8, ...rows.map((row) => percent(row.returns[period].value).length)) + suffixWidth(period);
   // The same trailing space is reserved in every cell and its header. A note
   // occupies that space without moving the number away from its label.
-  const label = (period: ThemePeriod, room?: number) => periodLabel(period, ytdBase, room) + " ".repeat(suffixWidth(period));
+  const label = (period: ThemePeriod, room: number) => periodLabel(period, ytdBase, room) + " ".repeat(suffixWidth(period));
+  // The board always keeps room for `YTD vs 31 Dec`, so even a narrow one says what its YTD is measured against.
+  const leastRoom = ytdBase ? `YTD vs ${ytdBase}`.length : 0;
   const columns = [column("name", "Theme", 26, "left"), column("memberCount", "N", 3),
-    ...THEME_PERIODS.map((period) => column(period, label(period, 0), Math.max(metricWidth(period), label(period, 0).length + HEADER_ROOM))),
+    ...THEME_PERIODS.map((period) => column(period, label(period, leastRoom), Math.max(metricWidth(period), label(period, leastRoom).length + HEADER_ROOM))),
     column("breadth", "Breadth" + " ".repeat(coverageWidth(rows.map((row) => row.breadth))), 7 + coverageWidth(rows.map((row) => row.breadth))),
     column("best", "Best 1D", 15), column("worst", "Worst 1D", 15)];
   const fitted = fitColumns(columns, width, ["worst", "best", "return3MPercent", "returnYtdPercent", "return1MPercent", "return1WPercent", "memberCount"]);

package/src/plugins/builtin/themes/pane.tsx

@@ -5,14 +5,14 @@ import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import type { ExtendedSession } from "../../../market-data/market/status";
 import { useAsyncResource, useAutoRefresh, usePluginPaneState, usePluginTickerActions, useUpdatedAgo } from "../../../public/react";
 import { usePaneInstance } from "../../../state/app/context";
-import { priceColor } from "../../../theme/colors";
+import { shownPriceColor } from "../../../theme/colors";
 import { useThemeColors } from "../../../theme/theme-context";
 import { Box, Text } from "../../../ui";
 import { nextHeaderSort } from "../../../utils/sort-values";
 import { useMembersMenu } from "../shared/members-menu";
 import { cachedMembers, cachedThemes, loadMembers, loadThemes } from "./client";
 import {
-  aggregateText, boardYtdBase, coverageWidth, DEFAULT_SORT, extendedMove, matchTheme, memberColumns, memberExtendedSessions, memberPrice, percent,
+  aggregateText, boardYtdBase, coverageText, coverageWidth, DEFAULT_SORT, extendedMove, matchTheme, memberColumns, memberExtendedSessions, memberPrice, percent,
   isLiveBoard, LIVE_BOARD_REFRESH_MS, SNAPSHOT_STALE_MS, snapshotFooterText, sortMembers, sortThemes, themeColumns, type ThemeSort,
 } from "./model";
 
@@ -80,10 +80,10 @@ function Members({ id, width, height, focused }: { id: string; width: number; he
     if (column.id === "preMarket" || column.id === "afterHours") {
       // The extended print's move from the close in Price.
       const move = extendedMove(row, column.id === "preMarket" ? "PRE" : "POST");
-      return { text: percent(move), value: move, color: move === null ? colors.textMuted : priceColor(move, colors) };
+      return { text: percent(move), value: move, color: move === null ? colors.textMuted : shownPriceColor(move, 2, colors) };
     }
     const value = row[column.id as ThemePeriod];
-    return { text: percent(value), value, color: value === null ? colors.textMuted : priceColor(value, colors) };
+    return { text: percent(value), value, color: value === null ? colors.textMuted : shownPriceColor(value, 2, colors) };
   }, [colors]);
   return <PaneStatusBody subject="theme members" loading={!data && resource.loading} error={!data ? resource.error : null}>
     {data ? <DataTableView<ThemeMember> columns={columns} items={rows} focused={focused} rootWidth={width} rootHeight={height}
@@ -135,14 +135,14 @@ export function ThemesBoard({ width, height, focused, tabStrip, tabRows = 0 }: T
     if (column.id === "best" || column.id === "worst") {
       const member = row[column.id];
       return { text: member ? `${member.symbol} ${percent(member.changePercent)}` : "--", value: member?.changePercent ?? null,
-        color: member ? priceColor(member.changePercent, colors) : colors.textMuted };
+        color: member ? shownPriceColor(member.changePercent, 2, colors) : colors.textMuted };
     }
     const breadth = column.id === "breadth";
     const metric = breadth ? row.breadth : row.returns[column.id as ThemePeriod];
     const suffixWidth = coverageWidth((data?.themes ?? []).map((theme) => breadth ? theme.breadth : theme.returns[column.id as ThemePeriod]));
-    const color = metric.value === null || breadth ? colors.textMuted : priceColor(metric.value, colors);
+    const color = metric.value === null || breadth ? colors.textMuted : shownPriceColor(metric.value, 2, colors);
     const valueText = breadth && metric.value !== null ? `${Math.round(metric.value)}%` : percent(metric.value);
-    const suffix = metric.covered < metric.total ? `${metric.covered}/${metric.total}` : "";
+    const suffix = coverageText(metric);
     return { text: aggregateText(metric, breadth), value: metric.value,
       color, content: suffixWidth ? <Box flexDirection="row" width={column.width} justifyContent="flex-end">
         <Text fg={color}>{valueText}</Text><Text fg={colors.textMuted}>{suffix.padStart(suffixWidth)}</Text>