gloomberb 0.18.2 → 0.18.4

package/src/plugins/builtin/macro-day/pane.tsx

@@ -2,6 +2,8 @@ import { useCallback, useEffect, useMemo, useRef } from "react";
 import { DataTableView, EmptyState, PaneStatusBody, QueryBar, StatGrid, statGridRows, usePaneFooter, usePaneNoticeFooter,
   usePaneTicker, type DataTableCell, type DataTableColumn, type StatItem } from "../../../components";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
+import { tableColumnWidth } from "../../../components/ui/table-layout";
+import { displayWidth } from "../../../utils/format";
 import { instrumentFromTicker } from "../../../market-data/request-types";
 import { usePaneSettingValue, usePluginPaneState } from "../../../public/react";
 import { useAsyncResource } from "../../../react/async-resource";
@@ -10,11 +12,13 @@ import { useThemeColors } from "../../../theme/theme-context";
 import type { PaneProps } from "../../../types/plugin";
 import { Box } from "../../../ui";
 import { loadMacroDayEarnings, loadMacroDayHistory, loadMacroReleases, macroDayEarningsNotice } from "./client";
-import { macroDayEventLabel, projectMacroDays, type MacroDayEvent, type MacroDayModel } from "./model";
-import { MACRO_EVENT_KINDS, MACRO_EVENT_LABELS, staleMacroReleasesNotice, type MacroEventKind } from "./releases";
+import { macroDayEventLabel, macroDayStats, matchesSurprise, projectMacroDays, type MacroDayEvent, type MacroDayModel } from "./model";
+import { MACRO_EVENT_KINDS, MACRO_EVENT_LABELS, MACRO_SURPRISE_LABELS, MACRO_SURPRISES, staleMacroReleasesNotice, type MacroEventKind,
+  type MacroSurprise } from "./releases";
 
 export const LOOKBACK_OPTIONS = [{ value: "1", label: "1Y" }, { value: "2", label: "2Y" }, { value: "3", label: "3Y" }, { value: "5", label: "5Y" }];
 const RELEASE_OPTIONS = [{ value: "all", label: "All" }, ...MACRO_EVENT_KINDS.map((kind) => ({ value: kind, label: MACRO_EVENT_LABELS[kind] }))];
+const SURPRISE_OPTIONS = [{ value: "all", label: "All" }, ...MACRO_SURPRISES.map((surprise) => ({ value: surprise, label: MACRO_SURPRISE_LABELS[surprise] }))];
 
 function pct(value: number | null | undefined, signed = true): string {
   if (value == null) return "--";
@@ -29,21 +33,45 @@ const MOVE: DataTableColumn[] = [
   { id: "move", label: "Move", width: 9, align: "right" },
   { id: "multiple", label: "vs Normal", width: 10, align: "right" },
 ];
+/** What each release came out with, under the labels the economic calendar gives them. */
+const FIGURES = [["actual", "Actual"], ["forecast", "Forecast"], ["prior", "Prior"]] as const;
+
+/** The figure columns, shown once any listed day has figures, each as wide as its header and its widest value. */
+function figureColumns(rows: readonly MacroDayEvent[]): DataTableColumn[] {
+  if (!rows.some((event) => event.figures)) return [];
+  return FIGURES.map(([id, label]) => ({ id, label, align: "right", width: tableColumnWidth({ label,
+    width: Math.max(6, ...rows.map((event) => displayWidth(event.figures?.[id] ?? ""))) }) }));
+}
 
 /**
  * With every release listed, the release's name, widened to take the earnings marker where a row has one. With one
  * selected, a column only for the marker: every row would repeat the name.
  */
-function columnsFor(release: string, rows: readonly MacroDayEvent[]): DataTableColumn[] {
+export function columnsFor(release: string, rows: readonly MacroDayEvent[]): DataTableColumn[] {
   const marked = rows.some((event) => event.earnings);
-  if (release === "all") return [DATE, { id: "release", label: "Release", width: marked ? 15 : 8, align: "left" }, ...MOVE];
-  return marked ? [DATE, { id: "release", label: "Note", width: EARNINGS_MARK.length, align: "left" }, ...MOVE] : [DATE, ...MOVE];
+  const values = [...figureColumns(rows), ...MOVE];
+  if (release === "all") return [DATE, { id: "release", label: "Release", width: marked ? 15 : 8, align: "left" }, ...values];
+  return marked ? [DATE, { id: "release", label: "Note", width: EARNINGS_MARK.length, align: "left" }, ...values] : [DATE, ...values];
+}
+
+const tone = (value: number | null) => value == null ? undefined : value >= 0 ? "positive" as const : "negative" as const;
+
+/** The figures over the days a surprise filter keeps: the same four as one release's. */
+function surpriseFigures(model: MacroDayModel, rows: readonly MacroDayEvent[]): StatItem[] {
+  const stats = macroDayStats(rows, model.normal.meanAbs);
+  return [
+    { id: "abs", label: "Avg |move|", value: pct(stats.meanAbs, false), detail: stats.count ? `${times(stats.multiple)} normal` : undefined },
+    { id: "mean", label: "Avg move", value: pct(stats.mean), tone: tone(stats.mean) },
+    { id: "up", label: "Up", value: stats.hitRate == null ? "--" : `${Math.round(stats.hitRate * 100)}%`,
+      detail: stats.count ? `${Math.round(stats.hitRate! * stats.count)} of ${stats.count}` : undefined },
+    { id: "normal", label: "Normal day", value: pct(model.normal.meanAbs, false), detail: "avg |move|" },
+  ];
 }
 
 function figures(model: MacroDayModel, release: string): StatItem[] {
   const normal: StatItem = { id: "normal", label: "Normal day", value: pct(model.normal.meanAbs, false), detail: "avg |move|" };
   if (release === "all") {
-    return [...MACRO_EVENT_KINDS.map((kind): StatItem => {
+    return [...model.kinds.map((kind): StatItem => {
       const stats = model.byKind[kind];
       return { id: kind, label: `${MACRO_EVENT_LABELS[kind]} day`, value: pct(stats.meanAbs, false),
         detail: stats.count ? `${times(stats.multiple)} normal` : undefined };
@@ -51,7 +79,6 @@ function figures(model: MacroDayModel, release: string): StatItem[] {
       detail: `${times(model.earnings.multiple)} normal` }] : []), normal];
   }
   const stats = model.byKind[release as MacroEventKind];
-  const tone = (value: number | null) => value == null ? undefined : value >= 0 ? "positive" as const : "negative" as const;
   return [
     { id: "abs", label: "Avg |move|", value: pct(stats.meanAbs, false), detail: stats.count ? `${times(stats.multiple)} normal` : undefined },
     { id: "mean", label: "Avg move", value: pct(stats.mean), tone: tone(stats.mean) },
@@ -66,6 +93,7 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
   const { symbol, ticker, error: identityError } = usePaneTicker();
   const [lookback, setLookback] = usePaneSettingValue("lookbackYears", "5");
   const [release, setRelease] = usePluginPaneState("release", "all");
+  const [surprise, setSurprise] = usePluginPaneState<MacroSurprise | "all">("surprise", "all");
   const [selectedRow, setSelectedRow] = usePluginPaneState<string | null>("selectedRow", null);
   const instrument = instrumentFromTicker(ticker, symbol);
   const instrumentKey = JSON.stringify(instrument);
@@ -88,8 +116,10 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
   [history.data, lookback, symbol]);
   const releasesNotice = history.data ? staleMacroReleasesNotice(history.data.releases) : null;
   const earningsNotice = history.data ? macroDayEarningsNotice(history.data.earnings) : null;
-  const rows = useMemo(() => model ? model.events.filter((event) => release === "all" || event.kind === release) : [], [model, release]);
-  const stats = useMemo(() => model?.events.length ? figures(model, release) : [], [model, release]);
+  const rows = useMemo(() => model ? model.events.filter((event) => (release === "all" || event.kind === release)
+    && matchesSurprise(event, surprise)) : [], [model, release, surprise]);
+  const stats = useMemo(() => !model?.events.length ? [] : surprise === "all" ? figures(model, release) : surpriseFigures(model, rows),
+    [model, release, surprise, rows]);
   const columns = useMemo(() => columnsFor(release, rows), [release, rows]);
 
   usePaneNoticeFooter({ registrationId: "macro-day-notices", focused,
@@ -103,6 +133,11 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
   const renderCell = useCallback((event: MacroDayEvent, column: DataTableColumn): DataTableCell => {
     if (column.id === "date") return { text: event.session === event.date ? event.date : `${event.date} → ${event.session.slice(5)}`, value: event.date };
     if (column.id === "release") return { text: release === "all" ? macroDayEventLabel(event) : event.earnings ? EARNINGS_MARK : "" };
+    // The print colored against the consensus, as the economic calendar colors it.
+    if (column.id === "actual") return { text: event.figures?.actual ?? "", color: event.figures?.surprise === "hot" ? colors.positive
+      : event.figures?.surprise === "cool" ? colors.negative : undefined };
+    if (column.id === "forecast") return { text: event.figures?.forecast ?? "" };
+    if (column.id === "prior") return { text: event.figures?.prior ?? "" };
     if (column.id === "move") return { text: pct(event.move), value: event.move * 100,
       color: event.move > 0 ? colors.positive : event.move < 0 ? colors.negative : undefined };
     return { text: times(event.multiple), value: event.multiple };
@@ -114,6 +149,7 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
   return <Box width={width} height={height} flexDirection="column" overflow="hidden">
     <QueryBar width={width} filters={[
       { id: "release", label: "Release", value: release, options: RELEASE_OPTIONS, onChange: setRelease, inline: true },
+      { id: "surprise", label: "Surprise", value: surprise, options: SURPRISE_OPTIONS, onChange: (value) => setSurprise(value as MacroSurprise | "all") },
       { id: "lookback", label: "Lookback", value: String(lookback), options: LOOKBACK_OPTIONS, onChange: setLookback },
     ]} />
     {!symbol ? <EmptyState title="Select a ticker." /> : <PaneStatusBody subject="macro-day moves" loading={history.loading && !model}
@@ -121,7 +157,7 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
       {model ? <>
         <StatGrid items={stats} width={width} />
         <DataTableView<MacroDayEvent> focused={focused} columns={columns} items={rows} rootWidth={width} rootHeight={contentHeight}
-          getItemKey={key} emptyStateTitle="No release days." sortColumnId={null} sortDirection="desc" selectedTextOverridesCellColor
+          getItemKey={key} emptyStateTitle={surprise === "all" ? "No release days." : `No ${MACRO_SURPRISE_LABELS[surprise].toLowerCase()} prints.`} sortColumnId={null} sortDirection="desc" selectedTextOverridesCellColor
           selection={{ kind: "id", selectedId: selectedRow, getId: key, onChange: (id) => setSelectedRow(id) }}
           getExportMetadata={() => [["symbol", model.symbol], ["from", model.start ?? ""], ["to", model.asOf ?? ""],
             ["units", "percent, close to close on the release day"]]}

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

@@ -1,27 +1,47 @@
-// Published US release days, not a rule engine: the dates each release came
+// Published release days, not a rule engine: the dates each release came
 // out, read from the publishers' own archives. A release cancelled or moved (the
 // 2025 shutdown) is as published, and a scheduled date is not a release day
-// until it is out. Dates are New York calendar days.
+// until it is out. Dates are New York calendar days. Brazil's IPCA days come
+// from Gloom Cloud only; the list the app ships with has the US releases.
 import { zonedDateKey } from "../../../utils/zoned-date-time";
 import { MACRO_RELEASE_TABLE } from "./release-table";
 
-export type MacroEventKind = "cpi" | "jobs" | "fomc";
+/** The US releases the bundled list carries, and the ones HIVG reads around. */
+export type UsMacroEventKind = "cpi" | "jobs" | "fomc";
+export type MacroEventKind = UsMacroEventKind | "ipca";
 
-export const MACRO_EVENT_KINDS: readonly MacroEventKind[] = ["cpi", "jobs", "fomc"];
+export const US_MACRO_EVENT_KINDS: readonly UsMacroEventKind[] = ["cpi", "jobs", "fomc"];
+export const MACRO_EVENT_KINDS: readonly MacroEventKind[] = [...US_MACRO_EVENT_KINDS, "ipca"];
 
-export const MACRO_EVENT_LABELS: Record<MacroEventKind, string> = { cpi: "CPI", jobs: "Jobs", fomc: "FOMC" };
+export const MACRO_EVENT_LABELS: Record<MacroEventKind, string> = { cpi: "CPI", jobs: "Jobs", fomc: "FOMC", ipca: "IPCA" };
 
-/** BLS news release archives for CPI and the Employment Situation, and the Federal Reserve's meeting calendar. */
+/** BLS news release archives for CPI and the Employment Situation, the Federal Reserve's meeting calendar, IBGE's calendar. */
 export const MACRO_RELEASE_SOURCES: Record<MacroEventKind, string> = {
   cpi: "https://www.bls.gov/bls/news-release/cpi.htm",
   jobs: "https://www.bls.gov/bls/news-release/empsit.htm",
   fomc: "https://www.federalreserve.gov/monetarypolicy/fomccalendars.htm",
+  ipca: "https://www.ibge.gov.br/calendario-indicadores-novoportal.html",
 };
 
 /** A list more than this many days behind today says so: a release day may be missing from its end. */
 export const MACRO_RELEASES_STALE_DAYS = 14;
 
-export interface MacroRelease { kind: MacroEventKind; date: string }
+/** Above the consensus (hot), below it (cool), at it (in-line). */
+export type MacroSurprise = "hot" | "cool" | "in-line";
+export const MACRO_SURPRISES: readonly MacroSurprise[] = ["hot", "cool", "in-line"];
+export const MACRO_SURPRISE_LABELS: Record<MacroSurprise, string> = { hot: "Hot", cool: "Cool", "in-line": "In line" };
+
+/** What a release day came out with: the headline, its print, the consensus before it and the figure before that. */
+export interface MacroReleaseFigures {
+  /** The headline the figures are for: "Inflation Rate YoY", "IPCA m/m". */
+  event: string;
+  actual: string | null;
+  forecast: string | null;
+  prior: string | null;
+  surprise: MacroSurprise | null;
+}
+
+export interface MacroRelease { kind: MacroEventKind; date: string; figures?: MacroReleaseFigures }
 
 export interface MacroReleaseList {
   /** Oldest first. */
@@ -37,29 +57,51 @@ const byDate = (left: MacroRelease, right: MacroRelease) => left.date.localeComp
 
 /** The list the app ships with: the floor whenever the server's list is missing or older. */
 export function bundledMacroReleases(): MacroReleaseList {
-  const releases = MACRO_EVENT_KINDS.flatMap((kind) => Object.entries(MACRO_RELEASE_TABLE.days[kind]).flatMap(([year, days]) =>
+  const releases = US_MACRO_EVENT_KINDS.flatMap((kind) => Object.entries(MACRO_RELEASE_TABLE.days[kind]).flatMap(([year, days]) =>
     days.map((day) => ({ kind, date: `${year}-${day}` }))));
   return { releases: releases.sort(byDate), coveredThrough: MACRO_RELEASE_TABLE.coveredThrough };
 }
 
+const text = (value: unknown) => typeof value === "string" && value.trim() ? value.trim() : null;
+
+/** A day's figures as served, or undefined when they break the contract. */
+function servedFigures(value: unknown): MacroReleaseFigures | undefined {
+  const figures = value as Partial<Record<keyof MacroReleaseFigures, unknown>> | null;
+  const event = text(figures?.event);
+  if (!event) return undefined;
+  const surprise = MACRO_SURPRISES.find((candidate) => candidate === figures?.surprise) ?? null;
+  return { event, actual: text(figures?.actual), forecast: text(figures?.forecast), prior: text(figures?.prior), surprise };
+}
+
 /**
  * The served list extends the floor past its end; the floor keeps its own
- * days up to there. A served list that breaks the contract, or ends no later
- * than the floor, adds nothing.
+ * days up to there. IPCA, which the floor does not carry, is the served list's
+ * through its end, and left out when the server lists none. Every day takes
+ * the figures the server has for it. A served list that breaks the contract,
+ * or ends no later than the floor, adds nothing.
  */
 export function mergeMacroReleases(floor: MacroReleaseList, served: unknown): MacroReleaseList {
-  const payload = served as { coveredThrough?: unknown; releases?: Partial<Record<MacroEventKind, unknown>> } | null;
+  const payload = served as { coveredThrough?: unknown; releases?: Partial<Record<MacroEventKind, unknown>>;
+    figures?: Partial<Record<MacroEventKind, Record<string, unknown>>> } | null;
   const coveredThrough = payload?.coveredThrough;
   if (!isDate(coveredThrough) || coveredThrough <= floor.coveredThrough) return floor;
   const later: MacroRelease[] = [];
-  for (const kind of MACRO_EVENT_KINDS) {
+  for (const kind of US_MACRO_EVENT_KINDS) {
     const dates = payload?.releases?.[kind];
     if (!Array.isArray(dates) || !dates.every(isDate)) return floor;
     for (const date of new Set(dates)) {
       if (date > floor.coveredThrough && date <= coveredThrough) later.push({ kind, date });
     }
   }
-  return { releases: [...floor.releases, ...later].sort(byDate), coveredThrough };
+  const ipca = payload?.releases?.ipca;
+  if (Array.isArray(ipca) && ipca.every(isDate)) {
+    for (const date of new Set(ipca)) if (date <= coveredThrough) later.push({ kind: "ipca", date });
+  }
+  const figuresOf = (release: MacroRelease): MacroRelease => {
+    const figures = servedFigures(payload?.figures?.[release.kind]?.[release.date]);
+    return figures ? { ...release, figures } : release;
+  };
+  return { releases: [...floor.releases, ...later].map(figuresOf).sort(byDate), coveredThrough };
 }
 
 /** Whole days from the list's last covered day to today in New York. */

package/src/plugins/builtin/market-heatmap/data.ts

@@ -31,7 +31,14 @@ export interface MarketHeatmapBoard extends MarketHeatmapResult {
 const DEFAULT_COUNT = 80;
 /** The most names one board asks for; a server that serves fewer answers with its own maximum. */
 const MAX_MARKET_HEATMAP_COUNT = 500;
-const CACHE_TTL_MS = 60_000;
+/**
+ * How often a board is worth checking again: a real-time board's live read
+ * is renewed every 15 seconds on the server, a delayed board's snapshot is
+ * cached there for a minute.
+ */
+export function heatmapCheckIntervalMs(board: Pick<MarketHeatmapResult, "access"> | null | undefined): number {
+  return board?.access === "realtime" ? 15_000 : 60_000;
+}
 const activeFetches = new Map<string, Promise<MarketHeatmapBoard>>();
 const memoryCache = new Map<string, { expiresAt: number; result: MarketHeatmapBoard }>();
 
@@ -90,7 +97,7 @@ export async function fetchMarketHeatmap(
   const fetchPromise = loadMarketHeatmap(universe, count, sources)
     .then((result) => {
       if (useCache) {
-        memoryCache.set(cacheKey, { result, expiresAt: Date.now() + CACHE_TTL_MS });
+        memoryCache.set(cacheKey, { result, expiresAt: Date.now() + heatmapCheckIntervalMs(result) });
       }
       return result;
     })

package/src/plugins/builtin/market-heatmap/evidence.ts

@@ -1,5 +1,5 @@
 /**
- * What `gloomberb shot HM` certifies: the tab the heat map drew, what its tiles
+ * What `gloom shot HM` certifies: the tab the heat map drew, what its tiles
  * are sized by, how many tiles and sectors are plotted, and whether its
  * snapshot had loaded. The heat map has
  * no table rows or labeled values, so this is how a capture counts as data.

package/src/plugins/builtin/market-heatmap/headless.ts

@@ -40,15 +40,16 @@ function noMoveNotice(symbols: readonly string[], names: number): string {
 }
 
 /**
- * When the board's figures are from, and whose sessions they follow: outside
+ * When the board's figures are from, and whose sessions they follow: when its
+ * prices printed, from a server that says (`pricesAsOf`). Otherwise, outside
  * the regular session the tiles are the completed session's, so the board is
  * as of that session's close (its date, from a server that does not send the
- * close), not when the snapshot was put together; while it trades, the
- * snapshot time.
+ * close); while it trades, the snapshot time, which is later than its prices.
  */
-function boardObservation(board: Pick<MarketHeatmapBoard, "fetchedAt" | "regularSessionDate" | "regularSessionClosedAt">) {
+function boardObservation(board: Pick<MarketHeatmapBoard, "fetchedAt" | "regularSessionDate" | "regularSessionClosedAt" | "pricesAsOf">) {
   const closedAt = board.regularSessionDate ? board.regularSessionClosedAt : null;
-  const asOf = typeof closedAt === "number" && closedAt > 0 ? new Date(closedAt).toISOString()
+  const pricedAt = typeof board.pricesAsOf === "number" && board.pricesAsOf > 0 ? board.pricesAsOf : closedAt;
+  const asOf = typeof pricedAt === "number" && pricedAt > 0 ? new Date(pricedAt).toISOString()
     : board.regularSessionDate || new Date(board.fetchedAt).toISOString();
   return { asOf, sessionExchange: "NYSE" };
 }
@@ -101,7 +102,7 @@ export const marketHeatmapHeadless: HeadlessPaneDefinition<"rows"> = {
     aliases: ["HM", "heatmap"],
     dataRequirements: ["Gloom Cloud market heatmap snapshot"],
     limitations: [
-      "The snapshot the pane starts from, refreshed about once a minute; the pane's live-streamed colors are not in the report.",
+      "The snapshot the pane starts from: real-time with Pro, fifteen minutes behind otherwise; the pane's live-streamed colors are not in the report.",
       "Sizes, shares and the weighted move use market cap (net assets for ETFs), not the pane's tile area, which follows its Size by setting (the day's move by default).",
     ],
   },
@@ -129,6 +130,8 @@ export const marketHeatmapHeadless: HeadlessPaneDefinition<"rows"> = {
       columns: columns(universe, groupBy, flat),
       rows: groups.map((summary) => projectRow(summary, groupBy, flat)),
       complete: !result.stale && covered,
+      // A Pro account's board is priced from a live read.
+      freshness: { status: result.access === "realtime" ? "live" : "delayed", tradingDayMarket: "US" },
       unavailableSymbols: covered ? [] : noMove,
       metadata: {
         universe,

package/src/plugins/builtin/market-heatmap/index.tsx

@@ -48,6 +48,7 @@ import {
   MARKET_HEATMAP_REQUEST_COUNT,
   MARKET_HEATMAP_UNIVERSES,
   fetchMarketHeatmap,
+  heatmapCheckIntervalMs,
   resetMarketHeatmapCache,
   type MarketHeatmapBoard,
   type MarketHeatmapUniverseId,
@@ -102,7 +103,6 @@ import {
 
 const NO_ASSETS: HeatmapBoardAsset[] = [];
 const NO_TARGETS: QuoteSubscriptionTarget[] = [];
-const SNAPSHOT_REFRESH_MS = 60_000;
 const LAYOUT_THROTTLE_MS = 5_000;
 /** A size change below this share of a tile's area is not worth moving it. */
 const LAYOUT_TOLERANCE = 0.005;
@@ -631,8 +631,8 @@ function MarketHeatmapPane({ focused, width, height }: PaneProps) {
   // Ages the last check that succeeded, not the snapshot, which the server can
   // hand back unchanged long after it was put together.
   const checked = useUpdatedAgo(shownBoard?.checkedAt ?? null);
-  // The snapshot carries sizes and every name the stream does not; the server caches it for a minute.
-  useAutoRefresh(board?.checkedAt ?? null, autoRefresh, { intervalMs: SNAPSHOT_REFRESH_MS });
+  // The snapshot carries sizes and every name the stream does not: a minute on the server, a quarter of one real-time.
+  useAutoRefresh(board?.checkedAt ?? null, autoRefresh, { intervalMs: heatmapCheckIntervalMs(board) });
 
   usePaneStatusFooter({ registrationId: "market-heatmap-retained", stale: hasBoard && stale && !portfolioTab });
   usePaneNoticeFooter({

package/src/plugins/builtin/market-heatmap/model.ts

@@ -85,16 +85,18 @@ const isTimestamp = (value: number | null | undefined): value is number =>
  * the largest names it holds, the completed regular session it shows outside
  * that session, the time its figures are as of, in New York time, dated when
  * that day is not the session's (or, while the session trades, today's), and
- * when this client last checked, which is a separate figure. A board of a
- * completed session is as of that session's close (`regularSessionClosedAt`);
- * otherwise, or from a server that does not say, the time is when the server
- * put the snapshot together. A footer narrower than `maxWidth` loses the check
+ * when this client last checked, which is a separate figure. A board is as of
+ * when its prices printed (`pricesAsOf`), a board of a completed session from
+ * a server that gives only its close as of that close
+ * (`regularSessionClosedAt`); otherwise the time is when the server put the
+ * snapshot together, at least fifteen minutes after its prices, and says so.
+ * A footer narrower than `maxWidth` loses the check
  * first, then that time, then the session; after a failed refresh (`failed`)
  * the age of the last good check outlasts the time. Null when not even the
  * count fits.
  */
 export function heatmapBoardCaption(
-  board: { topCount: number; fetchedAt: number; regularSessionDate?: string | null; regularSessionClosedAt?: number | null },
+  board: { topCount: number; fetchedAt: number; regularSessionDate?: string | null; regularSessionClosedAt?: number | null; pricesAsOf?: number | null },
   { now, checked = null, failed = false, maxWidth = Number.POSITIVE_INFINITY }:
     { now: number; checked?: string | null; failed?: boolean; maxWidth?: number },
 ): string | null {
@@ -103,12 +105,13 @@ export function heatmapBoardCaption(
   const parts: Array<{ text: string; rank: number }> = [{ text: `top ${board.topCount}`, rank: 0 }];
   if (sessionDate) parts.push({ text: `${dayLabel(sessionDate)} session`, rank: 1 });
   const closedAt = sessionDate && isTimestamp(board.regularSessionClosedAt) ? board.regularSessionClosedAt : null;
-  const time = closedAt ?? (isTimestamp(board.fetchedAt) ? board.fetchedAt : null);
+  const pricedAt = isTimestamp(board.pricesAsOf) ? board.pricesAsOf : closedAt;
+  const time = pricedAt ?? (isTimestamp(board.fetchedAt) ? board.fetchedAt : null);
   if (time != null) {
     const { hour, minute } = zonedDateTimeParts(time, NEW_YORK);
     const clock = `${twoDigits(hour)}:${twoDigits(minute)} ET`;
     const day = zonedDateKey(time, NEW_YORK);
-    const text = `${closedAt != null ? "as of" : "snapshot"} ${day === (sessionDate ?? zonedDateKey(now, NEW_YORK)) ? clock : `${dayLabel(day)} ${clock}`}`;
+    const text = `${pricedAt != null ? "as of" : "snapshot"} ${day === (sessionDate ?? zonedDateKey(now, NEW_YORK)) ? clock : `${dayLabel(day)} ${clock}`}`;
     parts.push({ text, rank: failed ? 3 : 2 });
   }
   if (checked) parts.push({ text: `checked ${checked}`, rank: failed ? 2 : 3 });

package/src/plugins/builtin/market-movers/client.ts

@@ -5,6 +5,7 @@ import type {
   CloudSessionMoversSide,
 } from "../../../api-client/market-movers";
 import type { DataProvider } from "../../../types/data-provider";
+import { logFailure } from "../../../utils/log-failure";
 import {
   CATEGORY_MAP,
   moverRegularSession,
@@ -17,7 +18,8 @@ import {
 } from "./model";
 import {
   fetchPreferredMarketMovers,
-  fetchTrending,
+  fetchTrendingResult,
+  type CachedResult,
   type MarketMoversResult,
   type PreferredMoversOptions,
   type TrendingSymbol,
@@ -29,6 +31,8 @@ export interface MarketMoverTabResult extends MarketMoversResult {
   quotes: MoverQuote[];
   /** What the list is ranked by; absent for trending, which keeps its source's order. */
   rankedBy?: MoverRanking;
+  /** Requested trending names whose quotes did not load. */
+  unavailableSymbols?: string[];
 }
 
 /** Rows a list shows. */
@@ -45,42 +49,52 @@ export interface MarketMoverTabDependencies {
     count: number,
     options?: PreferredMoversOptions,
   ): Promise<MarketMoversResult>;
-  fetchTrending(count: number, options?: { forceRefresh?: boolean }): Promise<TrendingSymbol[]>;
+  fetchTrending(count: number, options?: { forceRefresh?: boolean }): Promise<CachedResult<TrendingSymbol[]>>;
 }
 
 const defaultDependencies: MarketMoverTabDependencies = {
   fetchPreferred: (category, count, options) => fetchPreferredMarketMovers(category, count, options),
-  fetchTrending: (count, options) => fetchTrending(count, undefined, options),
+  fetchTrending: (count, options) => fetchTrendingResult(count, undefined, options),
 };
 
 async function hydrateTrending(
   trending: readonly TrendingSymbol[],
   provider: DataProvider | null,
-): Promise<MoverQuote[]> {
-  const symbols = trending.slice(0, 25).map(({ symbol }) => symbol);
+): Promise<Pick<MarketMoverTabResult, "quotes" | "unavailableSymbols">> {
+  const symbols = trending.slice(0, LIST_ROWS).map(({ symbol }) => symbol);
   const bySymbol = new Map<string, MoverQuote>();
-  if (!provider) return [];
-  if (provider.getQuotesBatch) {
-    const results = await provider.getQuotesBatch(
-      symbols.map((symbol) => ({ symbol, exchange: "" })),
-    ).catch(() => []);
-    for (const result of results) {
-      if (result.quote) bySymbol.set(result.target.symbol, screenerQuoteFromQuote(result.target.symbol, result.quote));
+  if (symbols.length === 0) return { quotes: [] };
+  if (provider?.getQuotesBatch) {
+    try {
+      const results = await provider.getQuotesBatch(symbols.map((symbol) => ({ symbol, exchange: "" })));
+      for (const result of results) {
+        if (result.quote) bySymbol.set(result.target.symbol, screenerQuoteFromQuote(result.target.symbol, result.quote));
+      }
+    } catch (error) {
+      logFailure("market-movers", "Trending quote batch failed")(error);
     }
-  } else {
+  } else if (provider) {
     await Promise.all(symbols.map(async (symbol) => {
       try {
         const quote = await provider.getQuote(symbol, "");
         bySymbol.set(symbol, screenerQuoteFromQuote(symbol, quote));
-      } catch {
-        // Missing quotes are omitted from a ranked list.
+      } catch (error) {
+        logFailure("market-movers", "Trending quote failed")(error);
       }
     }));
   }
-  return symbols.flatMap((symbol) => {
-    const quote = bySymbol.get(symbol);
-    return quote ? [quote] : [];
-  });
+  const unavailableSymbols = [...new Set(symbols.filter((symbol) => !bySymbol.has(symbol)))];
+  return {
+    quotes: symbols.flatMap((symbol) => {
+      const quote = bySymbol.get(symbol);
+      return quote ? [quote] : [];
+    }),
+    ...(unavailableSymbols.length ? { unavailableSymbols } : {}),
+  };
+}
+
+export function marketMoverQuoteError(result: Pick<MarketMoverTabResult, "unavailableSymbols">): string | null {
+  return result.unavailableSymbols?.length ? `Quotes unavailable: ${result.unavailableSymbols.join(", ")}.` : null;
 }
 
 export async function loadMarketMoverTab(
@@ -92,11 +106,12 @@ export async function loadMarketMoverTab(
   const { basis, ...fetchOptions } = options ?? {};
   if (tab === "trending") {
     const trending = await dependencies.fetchTrending(LIST_ROWS, fetchOptions);
+    const hydrated = await hydrateTrending(trending.data, provider);
     return {
       tab,
-      quotes: await hydrateTrending(trending, provider),
+      ...hydrated,
       source: "gloom",
-      stale: false,
+      stale: trending.stale || !!hydrated.unavailableSymbols?.length,
     };
   }
   const category = CATEGORY_MAP[tab];

package/src/plugins/builtin/market-movers/headless.ts

@@ -9,7 +9,7 @@ import type {
   CloudSessionMoversPayload,
   CloudSessionMoversSide,
 } from "../../../api-client/market-movers";
-import { loadMarketMoverTab, loadSessionMovers, type MarketMoverTabResult } from "./client";
+import { loadMarketMoverTab, loadSessionMovers, marketMoverQuoteError, type MarketMoverTabResult } from "./client";
 import { createRows, fiftyTwoWeekPositionPercent, formatMoverPrice, MOVER_RANKING_LABELS, moverExtendedSessions, moverReferencePrice, type MarketMoverRow, type ScreenerTabId, type TabId } from "./model";
 import { EXTENDED_SESSION_LABELS, type ExtendedSession } from "../../../market-data/market/status";
 import type { HeadlessPaneColumn } from "../../../types/headless";
@@ -98,7 +98,7 @@ export function createMarketMoversHeadless(
 ): HeadlessPaneDefinition<"rows"> {
   return {
     shape: "rows",
-    // A screener snapshot, not a real-time feed; rows keep the time of their own last price.
+    // The delayed lists unless the list says it is real-time; rows keep the time of their own last price.
     freshness: { status: "delayed" },
     argument: { kind: "none" },
     options: [{
@@ -145,6 +145,8 @@ export function createMarketMoversHeadless(
             events: item.catalysts.map((catalyst) => CATALYST_LABEL[catalyst] ?? catalyst).join(" "),
           })),
           metadata: { list: tab, side, session: payload.session, phase: payload.phase, asOf: payload.asOf, stale: payload.stale === true },
+          // A Pro account's list is the live board; the free one says it is delayed.
+          ...(payload.access === "delayed" ? {} : { freshness: { status: "live" as const } }),
         };
       }
       const result = await dependencies.load(args, tab, ctx.marketData);
@@ -165,15 +167,19 @@ export function createMarketMoversHeadless(
       }));
       // Beside an extended column, say which move the order follows.
       const rankedBy = result.rankedBy ?? null;
+      const quoteError = marketMoverQuoteError(result);
       return {
         ...(extendedSessions.length > 0
           ? { columns: [...COLUMNS.slice(0, 5), ...extendedSessions.map(extendedColumn), ...COLUMNS.slice(5)] }
           : {}),
         rows,
+        ...(quoteError ? { complete: false, unavailableSymbols: result.unavailableSymbols, errors: [quoteError] } : {}),
         ...(rankedBy && rankedBy !== "volume" && extendedSessions.length > 0
           ? { notes: [`Ranked by ${MOVER_RANKING_LABELS[rankedBy]}.`] }
           : {}),
         metadata: { list: tab, source: result.source, stale: result.stale, rankedBy },
+        // A Pro account's Gainers, Losers and Most Active are the real-time lists.
+        ...(result.source === "cloud" ? { freshness: { status: "live" as const } } : {}),
       };
     },
   };

package/src/plugins/builtin/market-movers/index.tsx

@@ -1,4 +1,4 @@
-import { Box } from "../../../ui";
+import { Box, useUiCapabilities } from "../../../ui";
 import { nextHeaderSort } from "../../../utils/sort-values";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { DataTableView, EmptyState, usePaneFooter, usePaneTabs, type DataTableKeyEvent } from "../../../components";
@@ -37,7 +37,7 @@ import {
   type ScreenerTabId,
   type TabId,
 } from "./model";
-import { loadMarketMoverTab } from "./client";
+import { loadMarketMoverTab, marketMoverQuoteError } from "./client";
 import { summaryFooterSegments } from "./footer";
 import { isSessionTab, resolveActiveTab, usSessionAt, type UsSession } from "./session";
 import { SessionMoversBody } from "./session-body";
@@ -161,7 +161,7 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
   const [selectedSymbol, setSelectedSymbol] = useState<string | null>(null);
   const [sortPreference, setSortPreference] = useState<MarketMoverSortPreference>(DEFAULT_SORT_PREFERENCE);
   const [moversStale, setMoversStale] = useState(false);
-  const [lastLoadedAt, setLastLoadedAt] = useState<number | null>(null);
+  const [lastSuccess, setLastSuccess] = useState<{ tab: ScreenerTabId; at: number } | null>(null);
 
   const fetchGenRef = useRef(0);
 
@@ -226,12 +226,16 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
       });
       if (fetchGenRef.current !== gen) return;
 
-      setQuotes(result.quotes);
-      setLoadedTab(tab);
+      const quoteError = marketMoverQuoteError(result);
+      // A partial list shows only its current rows; a total failure keeps this list's prior rows.
+      if (!quoteError || result.quotes.length > 0) {
+        setQuotes(result.quotes);
+        setLoadedTab(tab);
+        if (!options?.background) setSelectedSymbol(null);
+      }
       setMoversStale(result.stale);
-      if (!options?.background) setSelectedSymbol(null);
-      setLoadError(null);
-      setLastLoadedAt(Date.now());
+      setLoadError(quoteError);
+      if (!quoteError && !result.stale) setLastSuccess({ tab, at: Date.now() });
     } catch {
       if (fetchGenRef.current !== gen) return;
       setMoversStale(true);
@@ -250,7 +254,7 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
   const backgroundRefresh = useCallback(() => {
     void loadTab(activeTab, { background: true });
   }, [activeTab, loadTab]);
-  useAutoRefresh(lastLoadedAt, backgroundRefresh);
+  useAutoRefresh(lastSuccess?.tab === activeTab ? lastSuccess.at : null, backgroundRefresh);
 
   const openSymbol = useCallback((row: MarketMoverRow) => {
     pinTicker(moverKey(row), { floating: true, paneType: TICKER_RESEARCH_PANE_ID, instrument: null });
@@ -262,6 +266,8 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
     }));
   }, []);
 
+  const logos = useUiCapabilities().nativePaneChrome === true;
+  const renderCell = useCallback((row: MarketMoverRow, column: MarketMoverColumn) => renderMarketMoverCell(row, column, logos), [logos]);
   const handleTableKeyDown = useCallback((event: DataTableKeyEvent) => (
     handleRefreshKey(event, () => loadTab(activeTab, { forceRefresh: true }), { stopPropagation: true })
   ), [activeTab, loadTab]);
@@ -301,7 +307,7 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
       onHeaderClick={handleHeaderClick}
       getItemKey={moverKey}
       onActivate={openSymbol}
-      renderCell={renderMarketMoverCell}
+      renderCell={renderCell}
       selectedTextOverridesCellColor
       emptyStateTitle={loading ? "Loading movers..." : loadError ?? "No movers returned."}
       emptyContent={loadError ? (